From a137304c0345e6e7818075a38592d4eff669856d Mon Sep 17 00:00:00 2001 From: Tristan Milnthorp Date: Wed, 9 Feb 2022 13:22:54 -0500 Subject: [PATCH 1/4] Add compressibility quantity --- Common/UnitDefinitions/Compressibility.json | 29 + .../Compressibility/Compressibility.nfproj | 42 + ...tsNet.NanoFramework.Compressibility.nuspec | 26 + .../Compressibility/packages.config | 4 + .../Quantities/Compressibility.g.cs | 161 ++++ .../Units/CompressibilityUnit.g.cs | 33 + .../GeneratedCode/UnitsNet.nanoFramework.sln | 8 + ...NumberToCompressibilityExtensionsTest.g.cs | 32 + .../NumberToCompressibilityExtensions.g.cs | 36 + .../CustomCode/CompressibilityTests.cs | 32 + .../GeneratedCode/IQuantityTests.g.cs | 4 + .../TestsBase/CompressibilityTestsBase.g.cs | 613 ++++++++++++ .../Quantities/Compressibility.g.cs | 593 ++++++++++++ .../GeneratedCode/Quantity.g.cs | 7 + .../GeneratedCode/QuantityType.g.cs | 1 + .../Units/CompressibilityUnit.g.cs | 33 + .../Quantities/Compressibility.g.cs | 903 ++++++++++++++++++ UnitsNet/GeneratedCode/Quantity.g.cs | 11 + UnitsNet/GeneratedCode/QuantityType.g.cs | 1 + .../Units/CompressibilityUnit.g.cs | 33 + 20 files changed, 2602 insertions(+) create mode 100644 Common/UnitDefinitions/Compressibility.json create mode 100644 UnitsNet.NanoFramework/GeneratedCode/Compressibility/Compressibility.nfproj create mode 100644 UnitsNet.NanoFramework/GeneratedCode/Compressibility/UnitsNet.NanoFramework.Compressibility.nuspec create mode 100644 UnitsNet.NanoFramework/GeneratedCode/Compressibility/packages.config create mode 100644 UnitsNet.NanoFramework/GeneratedCode/Quantities/Compressibility.g.cs create mode 100644 UnitsNet.NanoFramework/GeneratedCode/Units/CompressibilityUnit.g.cs create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToCompressibilityExtensionsTest.g.cs create mode 100644 UnitsNet.NumberExtensions/GeneratedCode/NumberToCompressibilityExtensions.g.cs create mode 100644 UnitsNet.Tests/CustomCode/CompressibilityTests.cs create mode 100644 UnitsNet.Tests/GeneratedCode/TestsBase/CompressibilityTestsBase.g.cs create mode 100644 UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Compressibility.g.cs create mode 100644 UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/CompressibilityUnit.g.cs create mode 100644 UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs create mode 100644 UnitsNet/GeneratedCode/Units/CompressibilityUnit.g.cs diff --git a/Common/UnitDefinitions/Compressibility.json b/Common/UnitDefinitions/Compressibility.json new file mode 100644 index 0000000000..716a25c333 --- /dev/null +++ b/Common/UnitDefinitions/Compressibility.json @@ -0,0 +1,29 @@ +{ + "Name": "Compressibility", + "BaseUnit": "InversePascal", + "XmlDoc": "Compressibility is the measure of the relative volume change of a fluid or solid in response to pressure changes.", + "BaseDimensions": { + "L": 1, + "M": -1, + "T": 2 + }, + "Units": [ + { + "SingularName": "InversePascal", + "PluralName": "InversePascals", + "BaseUnits": { + "L": "Meter", + "M": "Kilogram", + "T": "Second" + }, + "FromUnitToBaseFunc": "{x}", + "FromBaseToUnitFunc": "{x}", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "Pa⁻¹", "1/Pa" ] + } + ] + } + ] +} diff --git a/UnitsNet.NanoFramework/GeneratedCode/Compressibility/Compressibility.nfproj b/UnitsNet.NanoFramework/GeneratedCode/Compressibility/Compressibility.nfproj new file mode 100644 index 0000000000..dd14cd1436 --- /dev/null +++ b/UnitsNet.NanoFramework/GeneratedCode/Compressibility/Compressibility.nfproj @@ -0,0 +1,42 @@ + + + + $(MSBuildToolsPath)..\..\..\nanoFramework\v1.0\ + + + + Debug + AnyCPU + {11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + {daf647be-be87-88b9-ee92-dece21fe0dff} + Library + Properties + 512 + UnitsNet + UnitsNet.Compressibility + v1.0 + bin\$(Configuration)\$(AssemblyName).xml + + + + + + + + + + ..\packages\nanoFramework.CoreLibrary.1.12.0-preview.5\lib\mscorlib.dll + True + True + + + + + + + + + + + + diff --git a/UnitsNet.NanoFramework/GeneratedCode/Compressibility/UnitsNet.NanoFramework.Compressibility.nuspec b/UnitsNet.NanoFramework/GeneratedCode/Compressibility/UnitsNet.NanoFramework.Compressibility.nuspec new file mode 100644 index 0000000000..37945e0d4e --- /dev/null +++ b/UnitsNet.NanoFramework/GeneratedCode/Compressibility/UnitsNet.NanoFramework.Compressibility.nuspec @@ -0,0 +1,26 @@ + + + + UnitsNet.nanoFramework.Compressibility + 4.118.0 + Units.NET Compressibility - nanoFramework + Andreas Gullberg Larsen,nanoFramework project contributors + UnitsNet + MIT + https://github.com/angularsen/UnitsNet + false + Adds Compressibility units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead. + https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png + + + Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). + en-US + nanoframework unit units measurement si metric imperial abbreviation abbreviations convert conversion parse c# .net immutable uwp uap winrt win10 windows runtime component compressibility + + + + + + + + diff --git a/UnitsNet.NanoFramework/GeneratedCode/Compressibility/packages.config b/UnitsNet.NanoFramework/GeneratedCode/Compressibility/packages.config new file mode 100644 index 0000000000..0f8741e8f7 --- /dev/null +++ b/UnitsNet.NanoFramework/GeneratedCode/Compressibility/packages.config @@ -0,0 +1,4 @@ + + + + diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Compressibility.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Compressibility.g.cs new file mode 100644 index 0000000000..5467df2bd5 --- /dev/null +++ b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Compressibility.g.cs @@ -0,0 +1,161 @@ +//------------------------------------------------------------------------------ +// +// 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. +// +// +//------------------------------------------------------------------------------ + +// 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.Units; + +namespace UnitsNet +{ + /// + /// + /// Compressibility is the measure of the relative volume change of a fluid or solid in response to pressure changes. + /// + public struct Compressibility + { + /// + /// The numeric value this quantity was constructed with. + /// + private readonly double _value; + + /// + /// The unit this quantity was constructed with. + /// + private readonly CompressibilityUnit _unit; + + /// + /// The numeric value this quantity was constructed with. + /// + public double Value => _value; + + /// + public CompressibilityUnit Unit => _unit; + /// + /// Creates the quantity with the given numeric value and unit. + /// + /// The numeric value to construct this quantity with. + /// The unit representation to construct this quantity with. + /// If value is NaN or Infinity. + public Compressibility(double value, CompressibilityUnit unit) + { + _value = value; + _unit = unit; + } + + /// + /// The base unit of Duration, which is Second. All conversions go via this value. + /// + public static CompressibilityUnit BaseUnit { get; } = CompressibilityUnit.InversePascal; + + /// + /// Represents the largest possible value of Duration + /// + public static Compressibility MaxValue { get; } = new Compressibility(double.MaxValue, BaseUnit); + + /// + /// Represents the smallest possible value of Duration + /// + public static Compressibility MinValue { get; } = new Compressibility(double.MinValue, BaseUnit); + /// + /// Gets an instance of this quantity with a value of 0 in the base unit Second. + /// + public static Compressibility Zero { get; } = new Compressibility(0, BaseUnit); + #region Conversion Properties + + /// + /// Get Compressibility in InversePascals. + /// + public double InversePascals => As(CompressibilityUnit.InversePascal); + + #endregion + + #region Static Factory Methods + + /// + /// Get Compressibility from InversePascals. + /// + /// If value is NaN or Infinity. + public static Compressibility FromInversePascals(double inversepascals) => new Compressibility(inversepascals, CompressibilityUnit.InversePascal); + + + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// Compressibility unit value. + public static Compressibility From(double value, CompressibilityUnit fromUnit) + { + return new Compressibility(value, fromUnit); + } + + #endregion + + #region Conversion Methods + + /// + /// Convert to the unit representation . + /// + /// Value converted to the specified unit. + public double As(CompressibilityUnit unit) => GetValueAs(unit); + + /// + /// Converts this Duration to another Duration with the unit representation . + /// + /// A Duration with the specified unit. + public Compressibility ToUnit(CompressibilityUnit unit) + { + var convertedValue = GetValueAs(unit); + return new Compressibility(convertedValue, unit); + } + + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + private double GetValueInBaseUnit() + { + switch(Unit) + { + case CompressibilityUnit.InversePascal: return _value; + default: + throw new NotImplementedException($"Can not convert {Unit} to base units."); + } + } + + private double GetValueAs(CompressibilityUnit unit) + { + if (Unit == unit) + return _value; + + var baseUnitValue = GetValueInBaseUnit(); + + switch(unit) + { + case CompressibilityUnit.InversePascal: return baseUnitValue; + default: + throw new NotImplementedException($"Can not convert {Unit} to {unit}."); + } + } + + #endregion + + } +} + diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/CompressibilityUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/CompressibilityUnit.g.cs new file mode 100644 index 0000000000..77f80bab98 --- /dev/null +++ b/UnitsNet.NanoFramework/GeneratedCode/Units/CompressibilityUnit.g.cs @@ -0,0 +1,33 @@ +//------------------------------------------------------------------------------ +// +// 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. +// +// +//------------------------------------------------------------------------------ + +// 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. + +// ReSharper disable once CheckNamespace +namespace UnitsNet.Units +{ + // Disable missing XML comment warnings for the generated unit enums. + #pragma warning disable 1591 + + public enum CompressibilityUnit + { + Undefined = 0, + InversePascal, + } + + #pragma warning restore 1591 +} diff --git a/UnitsNet.NanoFramework/GeneratedCode/UnitsNet.nanoFramework.sln b/UnitsNet.NanoFramework/GeneratedCode/UnitsNet.nanoFramework.sln index 2aae3bf429..1fc7ade9ba 100644 --- a/UnitsNet.NanoFramework/GeneratedCode/UnitsNet.nanoFramework.sln +++ b/UnitsNet.NanoFramework/GeneratedCode/UnitsNet.nanoFramework.sln @@ -28,6 +28,8 @@ Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Capacitance", "Capacitance\ EndProject Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "CoefficientOfThermalExpansion", "CoefficientOfThermalExpansion\CoefficientOfThermalExpansion.nfproj", "{a9514ce6-d4e7-88ca-051e-e9e53610c519}" EndProject +Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Compressibility", "Compressibility\Compressibility.nfproj", "{daf647be-be87-88b9-ee92-dece21fe0dff}" +EndProject Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Density", "Density\Density.nfproj", "{d683a277-5892-aec2-985d-c2343725d0af}" EndProject Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "Duration", "Duration\Duration.nfproj", "{3c2ac54f-554c-518b-7c46-3b22d86d0e3b}" @@ -310,6 +312,12 @@ Global {a9514ce6-d4e7-88ca-051e-e9e53610c519}.Release|Any CPU.ActiveCfg = Release|Any CPU {a9514ce6-d4e7-88ca-051e-e9e53610c519}.Release|Any CPU.Build.0 = Release|Any CPU {a9514ce6-d4e7-88ca-051e-e9e53610c519}.Release|Any CPU.Deploy.0 = Release|Any CPU +{daf647be-be87-88b9-ee92-dece21fe0dff}.Debug|Any CPU.ActiveCfg = Debug|Any CPU +{daf647be-be87-88b9-ee92-dece21fe0dff}.Debug|Any CPU.Build.0 = Debug|Any CPU +{daf647be-be87-88b9-ee92-dece21fe0dff}.Debug|Any CPU.Deploy.0 = Debug|Any CPU +{daf647be-be87-88b9-ee92-dece21fe0dff}.Release|Any CPU.ActiveCfg = Release|Any CPU +{daf647be-be87-88b9-ee92-dece21fe0dff}.Release|Any CPU.Build.0 = Release|Any CPU +{daf647be-be87-88b9-ee92-dece21fe0dff}.Release|Any CPU.Deploy.0 = Release|Any CPU {d683a277-5892-aec2-985d-c2343725d0af}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {d683a277-5892-aec2-985d-c2343725d0af}.Debug|Any CPU.Build.0 = Debug|Any CPU {d683a277-5892-aec2-985d-c2343725d0af}.Debug|Any CPU.Deploy.0 = Debug|Any CPU diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToCompressibilityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToCompressibilityExtensionsTest.g.cs new file mode 100644 index 0000000000..39d5bb15ee --- /dev/null +++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToCompressibilityExtensionsTest.g.cs @@ -0,0 +1,32 @@ +//------------------------------------------------------------------------------ +// +// 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. +// +// +//------------------------------------------------------------------------------ + +// 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 UnitsNet.NumberExtensions.NumberToCompressibility; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToCompressibilityExtensionsTests + { + [Fact] + public void NumberToInversePascalsTest() => + Assert.Equal(Compressibility.FromInversePascals(2), 2.InversePascals()); + + } +} diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToCompressibilityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToCompressibilityExtensions.g.cs new file mode 100644 index 0000000000..fc2e3ea6e9 --- /dev/null +++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToCompressibilityExtensions.g.cs @@ -0,0 +1,36 @@ +//------------------------------------------------------------------------------ +// +// 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. +// +// +//------------------------------------------------------------------------------ + +// 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; + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToCompressibility +{ + /// + /// A number to Compressibility Extensions + /// + public static class NumberToCompressibilityExtensions + { + /// + public static Compressibility InversePascals(this T value) => + Compressibility.FromInversePascals(Convert.ToDouble(value)); + + } +} diff --git a/UnitsNet.Tests/CustomCode/CompressibilityTests.cs b/UnitsNet.Tests/CustomCode/CompressibilityTests.cs new file mode 100644 index 0000000000..bda883e3b5 --- /dev/null +++ b/UnitsNet.Tests/CustomCode/CompressibilityTests.cs @@ -0,0 +1,32 @@ +//------------------------------------------------------------------------------ +// +// 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. +// +// +//------------------------------------------------------------------------------ + +// 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.Tests.CustomCode +{ + public class CompressibilityTests : CompressibilityTestsBase + { + // Override properties in base class here + + protected override double InversePascalsInOneInversePascal => 1; + + protected override bool SupportsSIUnitSystem => true; + } +} diff --git a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs index 636742bff9..ae11acfb7b 100644 --- a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs +++ b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs @@ -47,6 +47,7 @@ void Assertion(int expectedValue, Enum expectedUnit, IQuantity quantity) 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, CompressibilityUnit.InversePascal, Quantity.From(3, CompressibilityUnit.InversePascal)); 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)); @@ -166,6 +167,7 @@ public void QuantityInfo_IsSameAsStaticInfoProperty() Assertion(BrakeSpecificFuelConsumption.Info, BrakeSpecificFuelConsumption.Zero); Assertion(Capacitance.Info, Capacitance.Zero); Assertion(CoefficientOfThermalExpansion.Info, CoefficientOfThermalExpansion.Zero); + Assertion(Compressibility.Info, Compressibility.Zero); Assertion(Density.Info, Density.Zero); Assertion(Duration.Info, Duration.Zero); Assertion(DynamicViscosity.Info, DynamicViscosity.Zero); @@ -285,6 +287,7 @@ public void Type_EqualsStaticQuantityTypeProperty() Assertion(BrakeSpecificFuelConsumption.QuantityType, BrakeSpecificFuelConsumption.Zero); Assertion(Capacitance.QuantityType, Capacitance.Zero); Assertion(CoefficientOfThermalExpansion.QuantityType, CoefficientOfThermalExpansion.Zero); + Assertion(Compressibility.QuantityType, Compressibility.Zero); Assertion(Density.QuantityType, Density.Zero); Assertion(Duration.QuantityType, Duration.Zero); Assertion(DynamicViscosity.QuantityType, DynamicViscosity.Zero); @@ -404,6 +407,7 @@ public void Dimensions_IsSameAsStaticBaseDimensions() Assertion(BrakeSpecificFuelConsumption.BaseDimensions, BrakeSpecificFuelConsumption.Zero); Assertion(Capacitance.BaseDimensions, Capacitance.Zero); Assertion(CoefficientOfThermalExpansion.BaseDimensions, CoefficientOfThermalExpansion.Zero); + Assertion(Compressibility.BaseDimensions, Compressibility.Zero); Assertion(Density.BaseDimensions, Density.Zero); Assertion(Duration.BaseDimensions, Duration.Zero); Assertion(DynamicViscosity.BaseDimensions, DynamicViscosity.Zero); diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/CompressibilityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/CompressibilityTestsBase.g.cs new file mode 100644 index 0000000000..b09d115a75 --- /dev/null +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/CompressibilityTestsBase.g.cs @@ -0,0 +1,613 @@ +//------------------------------------------------------------------------------ +// +// 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. +// +// +//------------------------------------------------------------------------------ + +// 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; +using System.Globalization; +using System.Linq; +using System.Threading; +using UnitsNet.Tests.TestsBase; +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 +{ + /// + /// Test of Compressibility. + /// +// ReSharper disable once PartialTypeWithSinglePart + public abstract partial class CompressibilityTestsBase : QuantityTestsBase + { + protected abstract double InversePascalsInOneInversePascal { get; } + +// ReSharper disable VirtualMemberNeverOverriden.Global + protected virtual double InversePascalsTolerance { get { return 1e-5; } } +// ReSharper restore VirtualMemberNeverOverriden.Global + + protected (double UnitsInBaseUnit, double Tolerence) GetConversionFactor(CompressibilityUnit unit) + { + return unit switch + { + CompressibilityUnit.InversePascal => (InversePascalsInOneInversePascal, InversePascalsTolerance), + _ => throw new NotSupportedException() + }; + } + + public static IEnumerable UnitTypes = new List + { + new object[] { CompressibilityUnit.InversePascal }, + }; + + [Fact] + public void Ctor_WithUndefinedUnit_ThrowsArgumentException() + { + Assert.Throws(() => new Compressibility((double)0.0, CompressibilityUnit.Undefined)); + } + + [Fact] + public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit() + { + var quantity = new Compressibility(); + Assert.Equal(0, quantity.Value); + Assert.Equal(CompressibilityUnit.InversePascal, quantity.Unit); + } + + + [Fact] + public void Ctor_WithInfinityValue_ThrowsArgumentException() + { + Assert.Throws(() => new Compressibility(double.PositiveInfinity, CompressibilityUnit.InversePascal)); + Assert.Throws(() => new Compressibility(double.NegativeInfinity, CompressibilityUnit.InversePascal)); + } + + [Fact] + public void Ctor_WithNaNValue_ThrowsArgumentException() + { + Assert.Throws(() => new Compressibility(double.NaN, CompressibilityUnit.InversePascal)); + } + + [Fact] + public void Ctor_NullAsUnitSystem_ThrowsArgumentNullException() + { + Assert.Throws(() => new Compressibility(value: 1, unitSystem: null)); + } + + [Fact] + public void Ctor_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported() + { + Func TestCode = () => new Compressibility(value: 1, unitSystem: UnitSystem.SI); + if (SupportsSIUnitSystem) + { + var quantity = (Compressibility) TestCode(); + Assert.Equal(1, quantity.Value); + } + else + { + Assert.Throws(TestCode); + } + } + + [Fact] + public void Compressibility_QuantityInfo_ReturnsQuantityInfoDescribingQuantity() + { + var quantity = new Compressibility(1, CompressibilityUnit.InversePascal); + + QuantityInfo quantityInfo = quantity.QuantityInfo; + + Assert.Equal(Compressibility.Zero, quantityInfo.Zero); + Assert.Equal("Compressibility", quantityInfo.Name); + Assert.Equal(QuantityType.Compressibility, quantityInfo.QuantityType); + + var units = EnumUtils.GetEnumValues().Except(new[] {CompressibilityUnit.Undefined}).ToArray(); + var unitNames = units.Select(x => x.ToString()); + + // Obsolete members + Assert.Equal(units, quantityInfo.Units); + Assert.Equal(unitNames, quantityInfo.UnitNames); + } + + [Fact] + public void InversePascalToCompressibilityUnits() + { + Compressibility inversepascal = Compressibility.FromInversePascals(1); + AssertEx.EqualTolerance(InversePascalsInOneInversePascal, inversepascal.InversePascals, InversePascalsTolerance); + } + + [Fact] + public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() + { + var quantity00 = Compressibility.From(1, CompressibilityUnit.InversePascal); + AssertEx.EqualTolerance(1, quantity00.InversePascals, InversePascalsTolerance); + Assert.Equal(CompressibilityUnit.InversePascal, quantity00.Unit); + + } + + [Fact] + public void FromInversePascals_WithInfinityValue_ThrowsArgumentException() + { + Assert.Throws(() => Compressibility.FromInversePascals(double.PositiveInfinity)); + Assert.Throws(() => Compressibility.FromInversePascals(double.NegativeInfinity)); + } + + [Fact] + public void FromInversePascals_WithNanValue_ThrowsArgumentException() + { + Assert.Throws(() => Compressibility.FromInversePascals(double.NaN)); + } + + [Fact] + public void As() + { + var inversepascal = Compressibility.FromInversePascals(1); + AssertEx.EqualTolerance(InversePascalsInOneInversePascal, inversepascal.As(CompressibilityUnit.InversePascal), InversePascalsTolerance); + } + + [Fact] + public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported() + { + var quantity = new Compressibility(value: 1, unit: Compressibility.BaseUnit); + Func AsWithSIUnitSystem = () => quantity.As(UnitSystem.SI); + + if (SupportsSIUnitSystem) + { + var value = (double) AsWithSIUnitSystem(); + Assert.Equal(1, value); + } + else + { + Assert.Throws(AsWithSIUnitSystem); + } + } + + [Theory] + [MemberData(nameof(UnitTypes))] + public void ToUnit(CompressibilityUnit unit) + { + var inBaseUnits = Compressibility.From(1.0, Compressibility.BaseUnit); + var converted = inBaseUnits.ToUnit(unit); + + var conversionFactor = GetConversionFactor(unit); + AssertEx.EqualTolerance(conversionFactor.UnitsInBaseUnit, (double)converted.Value, conversionFactor.Tolerence); + Assert.Equal(unit, converted.Unit); + } + + [Theory] + [MemberData(nameof(UnitTypes))] + public void ToUnit_WithSameUnits_AreEqual(CompressibilityUnit unit) + { + var quantity = Compressibility.From(3.0, unit); + var toUnitWithSameUnit = quantity.ToUnit(unit); + Assert.Equal(quantity, toUnitWithSameUnit); + } + + [Theory] + [MemberData(nameof(UnitTypes))] + public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(CompressibilityUnit unit) + { + // See if there is a unit available that is not the base unit. + var fromUnit = Compressibility.Units.FirstOrDefault(u => u != Compressibility.BaseUnit && u != CompressibilityUnit.Undefined); + + // If there is only one unit for the quantity, we must use the base unit. + if (fromUnit == CompressibilityUnit.Undefined) + fromUnit = Compressibility.BaseUnit; + + var quantity = Compressibility.From(3.0, fromUnit); + var converted = quantity.ToUnit(unit); + Assert.Equal(converted.Unit, unit); + } + + [Fact] + public void ConversionRoundTrip() + { + Compressibility inversepascal = Compressibility.FromInversePascals(1); + AssertEx.EqualTolerance(1, Compressibility.FromInversePascals(inversepascal.InversePascals).InversePascals, InversePascalsTolerance); + } + + [Fact] + public void ArithmeticOperators() + { + Compressibility v = Compressibility.FromInversePascals(1); + AssertEx.EqualTolerance(-1, -v.InversePascals, InversePascalsTolerance); + AssertEx.EqualTolerance(2, (Compressibility.FromInversePascals(3)-v).InversePascals, InversePascalsTolerance); + AssertEx.EqualTolerance(2, (v + v).InversePascals, InversePascalsTolerance); + AssertEx.EqualTolerance(10, (v*10).InversePascals, InversePascalsTolerance); + AssertEx.EqualTolerance(10, (10*v).InversePascals, InversePascalsTolerance); + AssertEx.EqualTolerance(2, (Compressibility.FromInversePascals(10)/5).InversePascals, InversePascalsTolerance); + AssertEx.EqualTolerance(2, Compressibility.FromInversePascals(10)/Compressibility.FromInversePascals(5), InversePascalsTolerance); + } + + [Fact] + public void ComparisonOperators() + { + Compressibility oneInversePascal = Compressibility.FromInversePascals(1); + Compressibility twoInversePascals = Compressibility.FromInversePascals(2); + + Assert.True(oneInversePascal < twoInversePascals); + Assert.True(oneInversePascal <= twoInversePascals); + Assert.True(twoInversePascals > oneInversePascal); + Assert.True(twoInversePascals >= oneInversePascal); + + Assert.False(oneInversePascal > twoInversePascals); + Assert.False(oneInversePascal >= twoInversePascals); + Assert.False(twoInversePascals < oneInversePascal); + Assert.False(twoInversePascals <= oneInversePascal); + } + + [Fact] + public void CompareToIsImplemented() + { + Compressibility inversepascal = Compressibility.FromInversePascals(1); + Assert.Equal(0, inversepascal.CompareTo(inversepascal)); + Assert.True(inversepascal.CompareTo(Compressibility.Zero) > 0); + Assert.True(Compressibility.Zero.CompareTo(inversepascal) < 0); + } + + [Fact] + public void CompareToThrowsOnTypeMismatch() + { + Compressibility inversepascal = Compressibility.FromInversePascals(1); + Assert.Throws(() => inversepascal.CompareTo(new object())); + } + + [Fact] + public void CompareToThrowsOnNull() + { + Compressibility inversepascal = Compressibility.FromInversePascals(1); + Assert.Throws(() => inversepascal.CompareTo(null)); + } + + [Fact] + public void EqualityOperators() + { + var a = Compressibility.FromInversePascals(1); + var b = Compressibility.FromInversePascals(2); + +#pragma warning disable CS8073 +// 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 +#pragma warning restore CS8073 + } + + [Fact] + public void Equals_SameType_IsImplemented() + { + var a = Compressibility.FromInversePascals(1); + var b = Compressibility.FromInversePascals(2); + + Assert.True(a.Equals(a)); + Assert.False(a.Equals(b)); + } + + [Fact] + public void Equals_QuantityAsObject_IsImplemented() + { + object a = Compressibility.FromInversePascals(1); + object b = Compressibility.FromInversePascals(2); + + Assert.True(a.Equals(a)); + Assert.False(a.Equals(b)); + Assert.False(a.Equals((object)null)); + } + + [Fact] + public void Equals_RelativeTolerance_IsImplemented() + { + var v = Compressibility.FromInversePascals(1); + Assert.True(v.Equals(Compressibility.FromInversePascals(1), InversePascalsTolerance, ComparisonType.Relative)); + Assert.False(v.Equals(Compressibility.Zero, InversePascalsTolerance, ComparisonType.Relative)); + } + + [Fact] + public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException() + { + var v = Compressibility.FromInversePascals(1); + Assert.Throws(() => v.Equals(Compressibility.FromInversePascals(1), -1, ComparisonType.Relative)); + } + + [Fact] + public void EqualsReturnsFalseOnTypeMismatch() + { + Compressibility inversepascal = Compressibility.FromInversePascals(1); + Assert.False(inversepascal.Equals(new object())); + } + + [Fact] + public void EqualsReturnsFalseOnNull() + { + Compressibility inversepascal = Compressibility.FromInversePascals(1); + Assert.False(inversepascal.Equals(null)); + } + + [Fact] + public void UnitsDoesNotContainUndefined() + { + Assert.DoesNotContain(CompressibilityUnit.Undefined, Compressibility.Units); + } + + [Fact] + public void HasAtLeastOneAbbreviationSpecified() + { + var units = Enum.GetValues(typeof(CompressibilityUnit)).Cast(); + foreach(var unit in units) + { + if (unit == CompressibilityUnit.Undefined) + continue; + + var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit); + } + } + + [Fact] + public void BaseDimensionsShouldNeverBeNull() + { + Assert.False(Compressibility.BaseDimensions is null); + } + + [Fact] + public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture() + { + var prevCulture = Thread.CurrentThread.CurrentUICulture; + Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo("en-US"); + try { + Assert.Equal("1 Pa⁻¹", new Compressibility(1, CompressibilityUnit.InversePascal).ToString()); + } + finally + { + Thread.CurrentThread.CurrentUICulture = prevCulture; + } + } + + [Fact] + public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings() + { + // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback. + var swedishCulture = CultureInfo.GetCultureInfo("sv-SE"); + + Assert.Equal("1 Pa⁻¹", new Compressibility(1, CompressibilityUnit.InversePascal).ToString(swedishCulture)); + } + + [Fact] + public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture() + { + var oldCulture = CultureInfo.CurrentUICulture; + try + { + CultureInfo.CurrentUICulture = CultureInfo.InvariantCulture; + Assert.Equal("0.1 Pa⁻¹", new Compressibility(0.123456, CompressibilityUnit.InversePascal).ToString("s1")); + Assert.Equal("0.12 Pa⁻¹", new Compressibility(0.123456, CompressibilityUnit.InversePascal).ToString("s2")); + Assert.Equal("0.123 Pa⁻¹", new Compressibility(0.123456, CompressibilityUnit.InversePascal).ToString("s3")); + Assert.Equal("0.1235 Pa⁻¹", new Compressibility(0.123456, CompressibilityUnit.InversePascal).ToString("s4")); + } + finally + { + CultureInfo.CurrentUICulture = oldCulture; + } + } + + [Fact] + public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture() + { + var culture = CultureInfo.InvariantCulture; + Assert.Equal("0.1 Pa⁻¹", new Compressibility(0.123456, CompressibilityUnit.InversePascal).ToString("s1", culture)); + Assert.Equal("0.12 Pa⁻¹", new Compressibility(0.123456, CompressibilityUnit.InversePascal).ToString("s2", culture)); + Assert.Equal("0.123 Pa⁻¹", new Compressibility(0.123456, CompressibilityUnit.InversePascal).ToString("s3", culture)); + Assert.Equal("0.1235 Pa⁻¹", new Compressibility(0.123456, CompressibilityUnit.InversePascal).ToString("s4", culture)); + } + + + [Fact] + public void ToString_NullFormat_ThrowsArgumentNullException() + { + var quantity = Compressibility.FromInversePascals(1.0); + Assert.Throws(() => quantity.ToString(null, null, null)); + } + + [Fact] + public void ToString_NullArgs_ThrowsArgumentNullException() + { + var quantity = Compressibility.FromInversePascals(1.0); + Assert.Throws(() => quantity.ToString(null, "g", null)); + } + + [Fact] + public void ToString_NullProvider_EqualsCurrentUICulture() + { + var quantity = Compressibility.FromInversePascals(1.0); + Assert.Equal(quantity.ToString(CultureInfo.CurrentUICulture, "g"), quantity.ToString(null, "g")); + } + + + [Fact] + public void Convert_ToBool_ThrowsInvalidCastException() + { + var quantity = Compressibility.FromInversePascals(1.0); + Assert.Throws(() => Convert.ToBoolean(quantity)); + } + + [Fact] + public void Convert_ToByte_EqualsValueAsSameType() + { + var quantity = Compressibility.FromInversePascals(1.0); + Assert.Equal((byte)quantity.Value, Convert.ToByte(quantity)); + } + + [Fact] + public void Convert_ToChar_ThrowsInvalidCastException() + { + var quantity = Compressibility.FromInversePascals(1.0); + Assert.Throws(() => Convert.ToChar(quantity)); + } + + [Fact] + public void Convert_ToDateTime_ThrowsInvalidCastException() + { + var quantity = Compressibility.FromInversePascals(1.0); + Assert.Throws(() => Convert.ToDateTime(quantity)); + } + + [Fact] + public void Convert_ToDecimal_EqualsValueAsSameType() + { + var quantity = Compressibility.FromInversePascals(1.0); + Assert.Equal((decimal)quantity.Value, Convert.ToDecimal(quantity)); + } + + [Fact] + public void Convert_ToDouble_EqualsValueAsSameType() + { + var quantity = Compressibility.FromInversePascals(1.0); + Assert.Equal((double)quantity.Value, Convert.ToDouble(quantity)); + } + + [Fact] + public void Convert_ToInt16_EqualsValueAsSameType() + { + var quantity = Compressibility.FromInversePascals(1.0); + Assert.Equal((short)quantity.Value, Convert.ToInt16(quantity)); + } + + [Fact] + public void Convert_ToInt32_EqualsValueAsSameType() + { + var quantity = Compressibility.FromInversePascals(1.0); + Assert.Equal((int)quantity.Value, Convert.ToInt32(quantity)); + } + + [Fact] + public void Convert_ToInt64_EqualsValueAsSameType() + { + var quantity = Compressibility.FromInversePascals(1.0); + Assert.Equal((long)quantity.Value, Convert.ToInt64(quantity)); + } + + [Fact] + public void Convert_ToSByte_EqualsValueAsSameType() + { + var quantity = Compressibility.FromInversePascals(1.0); + Assert.Equal((sbyte)quantity.Value, Convert.ToSByte(quantity)); + } + + [Fact] + public void Convert_ToSingle_EqualsValueAsSameType() + { + var quantity = Compressibility.FromInversePascals(1.0); + Assert.Equal((float)quantity.Value, Convert.ToSingle(quantity)); + } + + [Fact] + public void Convert_ToString_EqualsToString() + { + var quantity = Compressibility.FromInversePascals(1.0); + Assert.Equal(quantity.ToString(), Convert.ToString(quantity)); + } + + [Fact] + public void Convert_ToUInt16_EqualsValueAsSameType() + { + var quantity = Compressibility.FromInversePascals(1.0); + Assert.Equal((ushort)quantity.Value, Convert.ToUInt16(quantity)); + } + + [Fact] + public void Convert_ToUInt32_EqualsValueAsSameType() + { + var quantity = Compressibility.FromInversePascals(1.0); + Assert.Equal((uint)quantity.Value, Convert.ToUInt32(quantity)); + } + + [Fact] + public void Convert_ToUInt64_EqualsValueAsSameType() + { + var quantity = Compressibility.FromInversePascals(1.0); + Assert.Equal((ulong)quantity.Value, Convert.ToUInt64(quantity)); + } + + [Fact] + public void Convert_ChangeType_SelfType_EqualsSelf() + { + var quantity = Compressibility.FromInversePascals(1.0); + Assert.Equal(quantity, Convert.ChangeType(quantity, typeof(Compressibility))); + } + + [Fact] + public void Convert_ChangeType_UnitType_EqualsUnit() + { + var quantity = Compressibility.FromInversePascals(1.0); + Assert.Equal(quantity.Unit, Convert.ChangeType(quantity, typeof(CompressibilityUnit))); + } + + [Fact] + public void Convert_ChangeType_QuantityType_EqualsQuantityType() + { + var quantity = Compressibility.FromInversePascals(1.0); + Assert.Equal(QuantityType.Compressibility, Convert.ChangeType(quantity, typeof(QuantityType))); + } + + [Fact] + public void Convert_ChangeType_QuantityInfo_EqualsQuantityInfo() + { + var quantity = Compressibility.FromInversePascals(1.0); + Assert.Equal(Compressibility.Info, Convert.ChangeType(quantity, typeof(QuantityInfo))); + } + + [Fact] + public void Convert_ChangeType_BaseDimensions_EqualsBaseDimensions() + { + var quantity = Compressibility.FromInversePascals(1.0); + Assert.Equal(Compressibility.BaseDimensions, Convert.ChangeType(quantity, typeof(BaseDimensions))); + } + + [Fact] + public void Convert_ChangeType_InvalidType_ThrowsInvalidCastException() + { + var quantity = Compressibility.FromInversePascals(1.0); + Assert.Throws(() => Convert.ChangeType(quantity, typeof(QuantityFormatter))); + } + + [Fact] + public void GetHashCode_Equals() + { + var quantity = Compressibility.FromInversePascals(1.0); + Assert.Equal(new {Compressibility.Info.Name, quantity.Value, quantity.Unit}.GetHashCode(), quantity.GetHashCode()); + } + + [Theory] + [InlineData(1.0)] + [InlineData(-1.0)] + public void NegationOperator_ReturnsQuantity_WithNegatedValue(double value) + { + var quantity = Compressibility.FromInversePascals(value); + Assert.Equal(Compressibility.FromInversePascals(-value), -quantity); + } + } +} diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Compressibility.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Compressibility.g.cs new file mode 100644 index 0000000000..48a8ab07be --- /dev/null +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Compressibility.g.cs @@ -0,0 +1,593 @@ +//------------------------------------------------------------------------------ +// +// 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. +// +// +//------------------------------------------------------------------------------ + +// 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.Globalization; +using System.Linq; +using JetBrains.Annotations; +using UnitsNet.Units; +using UnitsNet.InternalHelpers; + +// ReSharper disable once CheckNamespace + +namespace UnitsNet +{ + /// + /// Compressibility is the measure of the relative volume change of a fluid or solid in response to pressure changes. + /// + // Windows Runtime Component has constraints on public types: https://msdn.microsoft.com/en-us/library/br230301.aspx#Declaring types in Windows Runtime Components + // Public structures can't have any members other than public fields, and those fields must be value types or strings. + // Public classes must be sealed (NotInheritable in Visual Basic). If your programming model requires polymorphism, you can create a public interface and implement that interface on the classes that must be polymorphic. + public sealed partial class Compressibility : IQuantity + { + /// + /// The numeric value this quantity was constructed with. + /// + private readonly double _value; + + /// + /// The unit this quantity was constructed with. + /// + private readonly CompressibilityUnit? _unit; + + static Compressibility() + { + BaseDimensions = new BaseDimensions(1, -1, 2, 0, 0, 0, 0); + BaseUnit = CompressibilityUnit.InversePascal; + MaxValue = new Compressibility(double.MaxValue, BaseUnit); + MinValue = new Compressibility(double.MinValue, BaseUnit); + QuantityType = QuantityType.Compressibility; + Units = Enum.GetValues(typeof(CompressibilityUnit)).Cast().Except(new CompressibilityUnit[]{ CompressibilityUnit.Undefined }).ToArray(); + Zero = new Compressibility(0, BaseUnit); + Info = new QuantityInfo(QuantityType.Compressibility, Units.Cast().ToArray(), BaseUnit, Zero, BaseDimensions); + } + + /// + /// Creates the quantity with a value of 0 in the base unit InversePascal. + /// + /// + /// Windows Runtime Component requires a default constructor. + /// + public Compressibility() + { + _value = 0; + _unit = BaseUnit; + } + + /// + /// Creates the quantity with the given numeric value and unit. + /// + /// The numeric value to construct this quantity with. + /// The unit representation to construct this quantity with. + /// Value parameter cannot be named 'value' due to constraint when targeting Windows Runtime Component. + /// If value is NaN or Infinity. + private Compressibility(double value, CompressibilityUnit unit) + { + if (unit == CompressibilityUnit.Undefined) + throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit)); + + _value = Guard.EnsureValidNumber(value, nameof(value)); + _unit = unit; + } + + #region Static Properties + + /// + /// Information about the quantity type, such as unit values and names. + /// + internal static QuantityInfo Info { get; } + + /// + /// The of this quantity. + /// + public static BaseDimensions BaseDimensions { get; } + + /// + /// The base unit of Compressibility, which is InversePascal. All conversions go via this value. + /// + public static CompressibilityUnit BaseUnit { get; } + + /// + /// Represents the largest possible value of Compressibility + /// + public static Compressibility MaxValue { get; } + + /// + /// Represents the smallest possible value of Compressibility + /// + public static Compressibility MinValue { get; } + + /// + /// The of this quantity. + /// + [Obsolete("QuantityType will be removed in the future. Use the Info property instead.")] + public static QuantityType QuantityType { get; } + + /// + /// All units of measurement for the Compressibility quantity. + /// + public static CompressibilityUnit[] Units { get; } + + /// + /// Gets an instance of this quantity with a value of 0 in the base unit InversePascal. + /// + public static Compressibility Zero { get; } + + #endregion + + #region Properties + + /// + /// The numeric value this quantity was constructed with. + /// + public double Value => Convert.ToDouble(_value); + + /// + object IQuantity.Unit => Unit; + + /// + /// The unit this quantity was constructed with -or- if default ctor was used. + /// + public CompressibilityUnit Unit => _unit.GetValueOrDefault(BaseUnit); + + internal QuantityInfo QuantityInfo => Info; + + /// + /// The of this quantity. + /// + [Obsolete("QuantityType will be removed in the future. Use the Info property instead.")] + public QuantityType Type => Compressibility.QuantityType; + + /// + /// The of this quantity. + /// + public BaseDimensions Dimensions => Compressibility.BaseDimensions; + + #endregion + + #region Conversion Properties + + /// + /// Get Compressibility in InversePascals. + /// + public double InversePascals => As(CompressibilityUnit.InversePascal); + + #endregion + + #region Static Methods + + internal static void MapGeneratedLocalizations(UnitAbbreviationsCache unitAbbreviationsCache) + { + unitAbbreviationsCache.PerformAbbreviationMapping(CompressibilityUnit.InversePascal, new CultureInfo("en-US"), false, true, new string[]{"Pa⁻¹", "1/Pa"}); + } + + /// + /// Get unit abbreviation string. + /// + /// Unit to get abbreviation for. + /// Unit abbreviation string. + public static string GetAbbreviation(CompressibilityUnit unit) + { + return GetAbbreviation(unit, null); + } + + /// + /// Get unit abbreviation string. + /// + /// Unit to get abbreviation for. + /// Unit abbreviation string. + /// Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to if null. + public static string GetAbbreviation(CompressibilityUnit unit, [CanBeNull] string cultureName) + { + IFormatProvider provider = GetFormatProviderFromCultureName(cultureName); + return UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit, provider); + } + + #endregion + + #region Static Factory Methods + + /// + /// Get Compressibility from InversePascals. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Compressibility FromInversePascals(double inversepascals) + { + double value = (double) inversepascals; + return new Compressibility(value, CompressibilityUnit.InversePascal); + } + + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// Compressibility unit value. + // Fix name conflict with parameter "value" + [return: System.Runtime.InteropServices.WindowsRuntime.ReturnValueName("returnValue")] + public static Compressibility From(double value, CompressibilityUnit fromUnit) + { + return new Compressibility((double)value, fromUnit); + } + + #endregion + + #region Static Parse Methods + + /// + /// Parse a string with one or two quantities of the format "<quantity> <unit>". + /// + /// String to parse. Typically in the form: {number} {unit} + /// + /// Length.Parse("5.5 m", new CultureInfo("en-US")); + /// + /// The value of 'str' cannot be null. + /// + /// Expected string to have one or two pairs of quantity and unit in the format + /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" + /// + /// + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . + /// + /// + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. + /// + public static Compressibility Parse(string str) + { + return Parse(str, null); + } + + /// + /// Parse a string with one or two quantities of the format "<quantity> <unit>". + /// + /// String to parse. Typically in the form: {number} {unit} + /// + /// Length.Parse("5.5 m", new CultureInfo("en-US")); + /// + /// The value of 'str' cannot be null. + /// + /// Expected string to have one or two pairs of quantity and unit in the format + /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" + /// + /// + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . + /// + /// + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. + /// + /// Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to if null. + public static Compressibility Parse(string str, [CanBeNull] string cultureName) + { + IFormatProvider provider = GetFormatProviderFromCultureName(cultureName); + return QuantityParser.Default.Parse( + str, + provider, + From); + } + + /// + /// Try to parse a string with one or two quantities of the format "<quantity> <unit>". + /// + /// String to parse. Typically in the form: {number} {unit} + /// Resulting unit quantity if successful. + /// + /// Length.Parse("5.5 m", new CultureInfo("en-US")); + /// + public static bool TryParse([CanBeNull] string str, out Compressibility result) + { + return TryParse(str, null, out result); + } + + /// + /// Try to parse a string with one or two quantities of the format "<quantity> <unit>". + /// + /// String to parse. Typically in the form: {number} {unit} + /// Resulting unit quantity if successful. + /// True if successful, otherwise false. + /// + /// Length.Parse("5.5 m", new CultureInfo("en-US")); + /// + /// Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to if null. + public static bool TryParse([CanBeNull] string str, [CanBeNull] string cultureName, out Compressibility result) + { + IFormatProvider provider = GetFormatProviderFromCultureName(cultureName); + return QuantityParser.Default.TryParse( + str, + provider, + From, + out result); + } + + /// + /// Parse a unit string. + /// + /// String to parse. Typically in the form: {number} {unit} + /// + /// Length.ParseUnit("m", new CultureInfo("en-US")); + /// + /// The value of 'str' cannot be null. + /// Error parsing string. + public static CompressibilityUnit ParseUnit(string str) + { + return ParseUnit(str, null); + } + + /// + /// Parse a unit string. + /// + /// String to parse. Typically in the form: {number} {unit} + /// + /// Length.ParseUnit("m", new CultureInfo("en-US")); + /// + /// The value of 'str' cannot be null. + /// Error parsing string. + /// Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to if null. + public static CompressibilityUnit ParseUnit(string str, [CanBeNull] string cultureName) + { + IFormatProvider provider = GetFormatProviderFromCultureName(cultureName); + return UnitParser.Default.Parse(str, provider); + } + + public static bool TryParseUnit(string str, out CompressibilityUnit unit) + { + return TryParseUnit(str, null, out unit); + } + + /// + /// Parse a unit string. + /// + /// String to parse. Typically in the form: {number} {unit} + /// The parsed unit if successful. + /// True if successful, otherwise false. + /// + /// Length.TryParseUnit("m", new CultureInfo("en-US")); + /// + /// Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to if null. + public static bool TryParseUnit(string str, [CanBeNull] string cultureName, out CompressibilityUnit unit) + { + IFormatProvider provider = GetFormatProviderFromCultureName(cultureName); + return UnitParser.Default.TryParse(str, provider, out unit); + } + + #endregion + + #region Equality / IComparable + + public int CompareTo(object obj) + { + if (obj is null) throw new ArgumentNullException(nameof(obj)); + if (!(obj is Compressibility objCompressibility)) throw new ArgumentException("Expected type Compressibility.", nameof(obj)); + + return CompareTo(objCompressibility); + } + + // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods + internal int CompareTo(Compressibility other) + { + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + } + + [Windows.Foundation.Metadata.DefaultOverload] + public override bool Equals(object obj) + { + if (obj is null || !(obj is Compressibility objCompressibility)) + return false; + + return Equals(objCompressibility); + } + + public bool Equals(Compressibility other) + { + return _value.Equals(other.AsBaseNumericType(this.Unit)); + } + + /// + /// + /// Compare equality to another Compressibility within the given absolute or relative tolerance. + /// + /// + /// Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and + /// as a percentage of this quantity's value. will be converted into + /// this quantity's unit for comparison. A relative tolerance of 0.01 means the absolute difference must be within +/- 1% of + /// this quantity's value to be considered equal. + /// + /// In this example, the two quantities will be equal if the value of b is within +/- 1% of a (0.02m or 2cm). + /// + /// var a = Length.FromMeters(2.0); + /// var b = Length.FromInches(50.0); + /// a.Equals(b, 0.01, ComparisonType.Relative); + /// + /// + /// + /// + /// Absolute tolerance is defined as the maximum allowable absolute difference between this quantity's value and + /// as a fixed number in this quantity's unit. will be converted into + /// this quantity's unit for comparison. + /// + /// In this example, the two quantities will be equal if the value of b is within 0.01 of a (0.01m or 1cm). + /// + /// var a = Length.FromMeters(2.0); + /// var b = Length.FromInches(50.0); + /// a.Equals(b, 0.01, ComparisonType.Absolute); + /// + /// + /// + /// + /// Note that it is advised against specifying zero difference, due to the nature + /// of floating point operations and using System.Double internally. + /// + /// + /// The other quantity to compare to. + /// The absolute or relative tolerance value. Must be greater than or equal to 0. + /// The comparison type: either relative or absolute. + /// True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance. + public bool Equals(Compressibility other, double 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); + + return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType); + } + + /// + /// Returns the hash code for this instance. + /// + /// A hash code for the current Compressibility. + public override int GetHashCode() + { + return new { Info.Name, Value, Unit }.GetHashCode(); + } + + #endregion + + #region Conversion Methods + + double IQuantity.As(object unit) => As((CompressibilityUnit)unit); + + /// + /// Convert to the unit representation . + /// + /// Value converted to the specified unit. + public double As(CompressibilityUnit unit) + { + if (Unit == unit) + return Convert.ToDouble(Value); + + var converted = AsBaseNumericType(unit); + return Convert.ToDouble(converted); + } + + /// + /// Converts this Compressibility to another Compressibility with the unit representation . + /// + /// A Compressibility with the specified unit. + public Compressibility ToUnit(CompressibilityUnit unit) + { + var convertedValue = AsBaseNumericType(unit); + return new Compressibility(convertedValue, unit); + } + + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + private double AsBaseUnit() + { + switch(Unit) + { + case CompressibilityUnit.InversePascal: return _value; + default: + throw new NotImplementedException($"Can not convert {Unit} to base units."); + } + } + + private double AsBaseNumericType(CompressibilityUnit unit) + { + if (Unit == unit) + return _value; + + var baseUnitValue = AsBaseUnit(); + + switch(unit) + { + case CompressibilityUnit.InversePascal: return baseUnitValue; + default: + throw new NotImplementedException($"Can not convert {Unit} to {unit}."); + } + } + + #endregion + + #region ToString Methods + + /// + /// Get default string representation of value and unit. + /// + /// String representation. + public override string ToString() + { + return ToString(null); + } + + /// + /// Get string representation of value and unit. Using two significant digits after radix. + /// + /// String representation. + /// Name of culture (ex: "en-US") to use for localization and number formatting. Defaults to if null. + public string ToString([CanBeNull] string cultureName) + { + var provider = cultureName; + return ToString(provider, 2); + } + + /// + /// Get string representation of value and unit. + /// + /// The number of significant digits after the radix point. + /// String representation. + /// Name of culture (ex: "en-US") to use for localization and number formatting. Defaults to if null. + public string ToString(string cultureName, int significantDigitsAfterRadix) + { + var provider = cultureName; + var value = Convert.ToDouble(Value); + var format = UnitFormatter.GetFormat(value, significantDigitsAfterRadix); + return ToString(provider, format); + } + + /// + /// Get string representation of value and unit. + /// + /// String format to use. Default: "{0:0.##} {1} for value and unit abbreviation respectively." + /// Arguments for string format. Value and unit are implicitly included as arguments 0 and 1. + /// String representation. + /// Name of culture (ex: "en-US") to use for localization and number formatting. Defaults to if null. + public string ToString([CanBeNull] string cultureName, [NotNull] string format, [NotNull] params object[] args) + { + var provider = GetFormatProviderFromCultureName(cultureName); + if (format == null) throw new ArgumentNullException(nameof(format)); + if (args == null) throw new ArgumentNullException(nameof(args)); + + provider = provider ?? GlobalConfiguration.DefaultCulture; + + var value = Convert.ToDouble(Value); + var formatArgs = UnitFormatter.GetFormatArgs(Unit, value, provider, args); + return string.Format(provider, format, formatArgs); + } + + #endregion + + private static IFormatProvider GetFormatProviderFromCultureName([CanBeNull] string cultureName) + { + return cultureName != null ? new CultureInfo(cultureName) : (IFormatProvider)null; + } + } +} diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantity.g.cs index c4bd62c635..7f8c95d0fb 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantity.g.cs @@ -80,6 +80,9 @@ internal static bool TryFrom(double value, Enum unit, out IQuantity quantity) case CoefficientOfThermalExpansionUnit coefficientOfThermalExpansionUnit: quantity = CoefficientOfThermalExpansion.From(value, coefficientOfThermalExpansionUnit); return true; + case CompressibilityUnit compressibilityUnit: + quantity = Compressibility.From(value, compressibilityUnit); + return true; case DensityUnit densityUnit: quantity = Density.From(value, densityUnit); return true; @@ -466,6 +469,9 @@ internal static bool TryParse([CanBeNull] IFormatProvider formatProvider, Type q if (quantityType == typeof(CoefficientOfThermalExpansion)) return parser.TryParse(quantityString, formatProvider, CoefficientOfThermalExpansion.From, out quantity); + if (quantityType == typeof(Compressibility)) + return parser.TryParse(quantityString, formatProvider, Compressibility.From, out quantity); + if (quantityType == typeof(Density)) return parser.TryParse(quantityString, formatProvider, Density.From, out quantity); @@ -782,6 +788,7 @@ internal static IEnumerable GetQuantityTypes() yield return typeof(BrakeSpecificFuelConsumption); yield return typeof(Capacitance); yield return typeof(CoefficientOfThermalExpansion); + yield return typeof(Compressibility); yield return typeof(Density); yield return typeof(Duration); yield return typeof(DynamicViscosity); diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/QuantityType.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/QuantityType.g.cs index 0da8ff7922..c99f5e619c 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/QuantityType.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/QuantityType.g.cs @@ -46,6 +46,7 @@ public enum QuantityType BrakeSpecificFuelConsumption, Capacitance, CoefficientOfThermalExpansion, + Compressibility, Density, Duration, DynamicViscosity, diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/CompressibilityUnit.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/CompressibilityUnit.g.cs new file mode 100644 index 0000000000..77f80bab98 --- /dev/null +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/CompressibilityUnit.g.cs @@ -0,0 +1,33 @@ +//------------------------------------------------------------------------------ +// +// 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. +// +// +//------------------------------------------------------------------------------ + +// 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. + +// ReSharper disable once CheckNamespace +namespace UnitsNet.Units +{ + // Disable missing XML comment warnings for the generated unit enums. + #pragma warning disable 1591 + + public enum CompressibilityUnit + { + Undefined = 0, + InversePascal, + } + + #pragma warning restore 1591 +} diff --git a/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs b/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs new file mode 100644 index 0000000000..7fd27df0bc --- /dev/null +++ b/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs @@ -0,0 +1,903 @@ +//------------------------------------------------------------------------------ +// +// 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. +// +// +//------------------------------------------------------------------------------ + +// 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.Globalization; +using System.Linq; +using System.Runtime.Serialization; +using JetBrains.Annotations; +using UnitsNet.InternalHelpers; +using UnitsNet.Units; + +#nullable enable + +// ReSharper disable once CheckNamespace + +namespace UnitsNet +{ + /// + /// + /// Compressibility is the measure of the relative volume change of a fluid or solid in response to pressure changes. + /// + [DataContract] + public partial struct Compressibility : IQuantity, IEquatable, IComparable, IComparable, IConvertible, IFormattable + { + /// + /// The numeric value this quantity was constructed with. + /// + [DataMember(Name = "Value", Order = 0)] + private readonly double _value; + + /// + /// The unit this quantity was constructed with. + /// + [DataMember(Name = "Unit", Order = 1)] + private readonly CompressibilityUnit? _unit; + + static Compressibility() + { + BaseDimensions = new BaseDimensions(1, -1, 2, 0, 0, 0, 0); + BaseUnit = CompressibilityUnit.InversePascal; + MaxValue = new Compressibility(double.MaxValue, BaseUnit); + MinValue = new Compressibility(double.MinValue, BaseUnit); + QuantityType = QuantityType.Compressibility; + Units = Enum.GetValues(typeof(CompressibilityUnit)).Cast().Except(new CompressibilityUnit[]{ CompressibilityUnit.Undefined }).ToArray(); + Zero = new Compressibility(0, BaseUnit); + Info = new QuantityInfo("Compressibility", + new UnitInfo[] + { + new UnitInfo(CompressibilityUnit.InversePascal, "InversePascals", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second)), + }, + BaseUnit, Zero, BaseDimensions, QuantityType.Compressibility); + + DefaultConversionFunctions = new UnitConverter(); + + RegisterDefaultConversions(DefaultConversionFunctions); + } + + /// + /// Creates the quantity with the given numeric value and unit. + /// + /// The numeric value to construct this quantity with. + /// The unit representation to construct this quantity with. + /// If value is NaN or Infinity. + public Compressibility(double value, CompressibilityUnit unit) + { + if (unit == CompressibilityUnit.Undefined) + throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit)); + + _value = Guard.EnsureValidNumber(value, nameof(value)); + _unit = unit; + } + + /// + /// Creates an instance of the quantity with the given numeric value in units compatible with the given . + /// If multiple compatible units were found, the first match is used. + /// + /// The numeric value to construct this quantity with. + /// The unit system to create the quantity with. + /// The given is null. + /// No unit was found for the given . + public Compressibility(double 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)); + _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem)); + } + + #region Static Properties + + /// + /// The containing the default generated conversion functions for instances. + /// + public static UnitConverter DefaultConversionFunctions { get; } + + /// + public static QuantityInfo Info { get; } + + /// + /// The of this quantity. + /// + public static BaseDimensions BaseDimensions { get; } + + /// + /// The base unit of Compressibility, which is InversePascal. All conversions go via this value. + /// + public static CompressibilityUnit BaseUnit { get; } + + /// + /// Represents the largest possible value of Compressibility + /// + [Obsolete("MaxValue and MinValue will be removed. Choose your own value or use nullability for unbounded lower/upper range checks. See discussion in https://github.com/angularsen/UnitsNet/issues/848.")] + public static Compressibility MaxValue { get; } + + /// + /// Represents the smallest possible value of Compressibility + /// + [Obsolete("MaxValue and MinValue will be removed. Choose your own value or use nullability for unbounded lower/upper range checks. See discussion in https://github.com/angularsen/UnitsNet/issues/848.")] + public static Compressibility MinValue { get; } + + /// + /// The of this quantity. + /// + [Obsolete("QuantityType will be removed in the future. Use the Info property instead.")] + public static QuantityType QuantityType { get; } + + /// + /// All units of measurement for the Compressibility quantity. + /// + public static CompressibilityUnit[] Units { get; } + + /// + /// Gets an instance of this quantity with a value of 0 in the base unit InversePascal. + /// + public static Compressibility Zero { get; } + + #endregion + + #region Properties + + /// + /// The numeric value this quantity was constructed with. + /// + public double Value => _value; + + Enum IQuantity.Unit => Unit; + + /// + public CompressibilityUnit Unit => _unit.GetValueOrDefault(BaseUnit); + + /// + public QuantityInfo QuantityInfo => Info; + + /// + QuantityInfo IQuantity.QuantityInfo => Info; + + /// + /// The of this quantity. + /// + [Obsolete("QuantityType will be removed in the future. Use the Info property instead.")] + public QuantityType Type => QuantityType.Compressibility; + + /// + /// The of this quantity. + /// + public BaseDimensions Dimensions => Compressibility.BaseDimensions; + + #endregion + + #region Conversion Properties + + /// + /// Get Compressibility in InversePascals. + /// + public double InversePascals => As(CompressibilityUnit.InversePascal); + + #endregion + + #region Static Methods + + /// + /// Registers the default conversion functions in the given instance. + /// + /// The to register the default conversion functions in. + internal static void RegisterDefaultConversions(UnitConverter unitConverter) + { + // Register in unit converter: BaseUnit -> CompressibilityUnit + // Register in unit converter: BaseUnit <-> BaseUnit + unitConverter.SetConversionFunction(CompressibilityUnit.InversePascal, CompressibilityUnit.InversePascal, quantity => quantity); + + // Register in unit converter: CompressibilityUnit -> BaseUnit + } + + internal static void MapGeneratedLocalizations(UnitAbbreviationsCache unitAbbreviationsCache) + { + unitAbbreviationsCache.PerformAbbreviationMapping(CompressibilityUnit.InversePascal, new CultureInfo("en-US"), false, true, new string[]{"Pa⁻¹", "1/Pa"}); + } + + /// + /// Get unit abbreviation string. + /// + /// Unit to get abbreviation for. + /// Unit abbreviation string. + public static string GetAbbreviation(CompressibilityUnit unit) + { + return GetAbbreviation(unit, null); + } + + /// + /// Get unit abbreviation string. + /// + /// Unit to get abbreviation for. + /// Unit abbreviation string. + /// Format to use for localization. Defaults to if null. + public static string GetAbbreviation(CompressibilityUnit unit, IFormatProvider? provider) + { + return UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit, provider); + } + + #endregion + + #region Static Factory Methods + + /// + /// Get Compressibility from InversePascals. + /// + /// If value is NaN or Infinity. + public static Compressibility FromInversePascals(QuantityValue inversepascals) + { + double value = (double) inversepascals; + return new Compressibility(value, CompressibilityUnit.InversePascal); + } + + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// Compressibility unit value. + public static Compressibility From(QuantityValue value, CompressibilityUnit fromUnit) + { + return new Compressibility((double)value, fromUnit); + } + + #endregion + + #region Static Parse Methods + + /// + /// Parse a string with one or two quantities of the format "<quantity> <unit>". + /// + /// String to parse. Typically in the form: {number} {unit} + /// + /// Length.Parse("5.5 m", new CultureInfo("en-US")); + /// + /// The value of 'str' cannot be null. + /// + /// Expected string to have one or two pairs of quantity and unit in the format + /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" + /// + /// + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . + /// + /// + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. + /// + public static Compressibility Parse(string str) + { + return Parse(str, null); + } + + /// + /// Parse a string with one or two quantities of the format "<quantity> <unit>". + /// + /// String to parse. Typically in the form: {number} {unit} + /// + /// Length.Parse("5.5 m", new CultureInfo("en-US")); + /// + /// The value of 'str' cannot be null. + /// + /// Expected string to have one or two pairs of quantity and unit in the format + /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" + /// + /// + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . + /// + /// + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. + /// + /// Format to use when parsing number and unit. Defaults to if null. + public static Compressibility Parse(string str, IFormatProvider? provider) + { + return QuantityParser.Default.Parse( + str, + provider, + From); + } + + /// + /// Try to parse a string with one or two quantities of the format "<quantity> <unit>". + /// + /// String to parse. Typically in the form: {number} {unit} + /// Resulting unit quantity if successful. + /// + /// Length.Parse("5.5 m", new CultureInfo("en-US")); + /// + public static bool TryParse(string? str, out Compressibility result) + { + return TryParse(str, null, out result); + } + + /// + /// Try to parse a string with one or two quantities of the format "<quantity> <unit>". + /// + /// String to parse. Typically in the form: {number} {unit} + /// Resulting unit quantity if successful. + /// True if successful, otherwise false. + /// + /// Length.Parse("5.5 m", new CultureInfo("en-US")); + /// + /// Format to use when parsing number and unit. Defaults to if null. + public static bool TryParse(string? str, IFormatProvider? provider, out Compressibility result) + { + return QuantityParser.Default.TryParse( + str, + provider, + From, + out result); + } + + /// + /// Parse a unit string. + /// + /// String to parse. Typically in the form: {number} {unit} + /// + /// Length.ParseUnit("m", new CultureInfo("en-US")); + /// + /// The value of 'str' cannot be null. + /// Error parsing string. + public static CompressibilityUnit ParseUnit(string str) + { + return ParseUnit(str, null); + } + + /// + /// Parse a unit string. + /// + /// String to parse. Typically in the form: {number} {unit} + /// Format to use when parsing number and unit. Defaults to if null. + /// + /// Length.ParseUnit("m", new CultureInfo("en-US")); + /// + /// The value of 'str' cannot be null. + /// Error parsing string. + public static CompressibilityUnit ParseUnit(string str, IFormatProvider? provider) + { + return UnitParser.Default.Parse(str, provider); + } + + /// + public static bool TryParseUnit(string str, out CompressibilityUnit unit) + { + return TryParseUnit(str, null, out unit); + } + + /// + /// Parse a unit string. + /// + /// String to parse. Typically in the form: {number} {unit} + /// The parsed unit if successful. + /// True if successful, otherwise false. + /// + /// Length.TryParseUnit("m", new CultureInfo("en-US")); + /// + /// Format to use when parsing number and unit. Defaults to if null. + public static bool TryParseUnit(string str, IFormatProvider? provider, out CompressibilityUnit unit) + { + return UnitParser.Default.TryParse(str, provider, out unit); + } + + #endregion + + #region Arithmetic Operators + + /// Negate the value. + public static Compressibility operator -(Compressibility right) + { + return new Compressibility(-right.Value, right.Unit); + } + + /// Get from adding two . + public static Compressibility operator +(Compressibility left, Compressibility right) + { + return new Compressibility(left.Value + right.GetValueAs(left.Unit), left.Unit); + } + + /// Get from subtracting two . + public static Compressibility operator -(Compressibility left, Compressibility right) + { + return new Compressibility(left.Value - right.GetValueAs(left.Unit), left.Unit); + } + + /// Get from multiplying value and . + public static Compressibility operator *(double left, Compressibility right) + { + return new Compressibility(left * right.Value, right.Unit); + } + + /// Get from multiplying value and . + public static Compressibility operator *(Compressibility left, double right) + { + return new Compressibility(left.Value * right, left.Unit); + } + + /// Get from dividing by value. + public static Compressibility operator /(Compressibility left, double right) + { + return new Compressibility(left.Value / right, left.Unit); + } + + /// Get ratio value from dividing by . + public static double operator /(Compressibility left, Compressibility right) + { + return left.InversePascals / right.InversePascals; + } + + #endregion + + #region Equality / IComparable + + /// Returns true if less or equal to. + public static bool operator <=(Compressibility left, Compressibility right) + { + return left.Value <= right.GetValueAs(left.Unit); + } + + /// Returns true if greater than or equal to. + public static bool operator >=(Compressibility left, Compressibility right) + { + return left.Value >= right.GetValueAs(left.Unit); + } + + /// Returns true if less than. + public static bool operator <(Compressibility left, Compressibility right) + { + return left.Value < right.GetValueAs(left.Unit); + } + + /// Returns true if greater than. + public static bool operator >(Compressibility left, Compressibility right) + { + return left.Value > right.GetValueAs(left.Unit); + } + + /// Returns true if exactly equal. + /// Consider using for safely comparing floating point values. + public static bool operator ==(Compressibility left, Compressibility right) + { + return left.Equals(right); + } + + /// Returns true if not exactly equal. + /// Consider using for safely comparing floating point values. + public static bool operator !=(Compressibility left, Compressibility right) + { + return !(left == right); + } + + /// + public int CompareTo(object obj) + { + if (obj is null) throw new ArgumentNullException(nameof(obj)); + if (!(obj is Compressibility objCompressibility)) throw new ArgumentException("Expected type Compressibility.", nameof(obj)); + + return CompareTo(objCompressibility); + } + + /// + public int CompareTo(Compressibility other) + { + return _value.CompareTo(other.GetValueAs(this.Unit)); + } + + /// + /// Consider using for safely comparing floating point values. + public override bool Equals(object obj) + { + if (obj is null || !(obj is Compressibility objCompressibility)) + return false; + + return Equals(objCompressibility); + } + + /// + /// Consider using for safely comparing floating point values. + public bool Equals(Compressibility other) + { + return _value.Equals(other.GetValueAs(this.Unit)); + } + + /// + /// + /// Compare equality to another Compressibility within the given absolute or relative tolerance. + /// + /// + /// Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and + /// as a percentage of this quantity's value. will be converted into + /// this quantity's unit for comparison. A relative tolerance of 0.01 means the absolute difference must be within +/- 1% of + /// this quantity's value to be considered equal. + /// + /// In this example, the two quantities will be equal if the value of b is within +/- 1% of a (0.02m or 2cm). + /// + /// var a = Length.FromMeters(2.0); + /// var b = Length.FromInches(50.0); + /// a.Equals(b, 0.01, ComparisonType.Relative); + /// + /// + /// + /// + /// Absolute tolerance is defined as the maximum allowable absolute difference between this quantity's value and + /// as a fixed number in this quantity's unit. will be converted into + /// this quantity's unit for comparison. + /// + /// In this example, the two quantities will be equal if the value of b is within 0.01 of a (0.01m or 1cm). + /// + /// var a = Length.FromMeters(2.0); + /// var b = Length.FromInches(50.0); + /// a.Equals(b, 0.01, ComparisonType.Absolute); + /// + /// + /// + /// + /// Note that it is advised against specifying zero difference, due to the nature + /// of floating point operations and using System.Double internally. + /// + /// + /// The other quantity to compare to. + /// The absolute or relative tolerance value. Must be greater than or equal to 0. + /// The comparison type: either relative or absolute. + /// True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance. + public bool Equals(Compressibility other, double 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); + + return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType); + } + + /// + /// Returns the hash code for this instance. + /// + /// A hash code for the current Compressibility. + public override int GetHashCode() + { + return new { Info.Name, Value, Unit }.GetHashCode(); + } + + #endregion + + #region Conversion Methods + + /// + /// Convert to the unit representation . + /// + /// Value converted to the specified unit. + public double As(CompressibilityUnit unit) + { + if (Unit == unit) + return Convert.ToDouble(Value); + + var converted = GetValueAs(unit); + return Convert.ToDouble(converted); + } + + /// + public double As(UnitSystem unitSystem) + { + if (unitSystem is null) + throw new ArgumentNullException(nameof(unitSystem)); + + var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits); + + var firstUnitInfo = unitInfos.FirstOrDefault(); + if (firstUnitInfo == null) + throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem)); + + return As(firstUnitInfo.Value); + } + + /// + double IQuantity.As(Enum unit) + { + if (!(unit is CompressibilityUnit unitAsCompressibilityUnit)) + throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(CompressibilityUnit)} is supported.", nameof(unit)); + + return As(unitAsCompressibilityUnit); + } + + /// + /// Converts this Compressibility to another Compressibility with the unit representation . + /// + /// The unit to convert to. + /// A Compressibility with the specified unit. + public Compressibility ToUnit(CompressibilityUnit unit) + { + return ToUnit(unit, DefaultConversionFunctions); + } + + /// + /// Converts this Compressibility to another Compressibility using the given with the unit representation . + /// + /// The unit to convert to. + /// The to use for the conversion. + /// A Compressibility with the specified unit. + public Compressibility ToUnit(CompressibilityUnit unit, UnitConverter unitConverter) + { + if (Unit == unit) + { + // Already in requested units. + return this; + } + else if (unitConverter.TryGetConversionFunction((typeof(Compressibility), Unit, typeof(Compressibility), unit), out var conversionFunction)) + { + // Direct conversion to requested unit found. Return the converted quantity. + var converted = conversionFunction(this); + return (Compressibility)converted; + } + else if (Unit != BaseUnit) + { + // Direct conversion to requested unit NOT found. Convert to BaseUnit, and then from BaseUnit to requested unit. + var inBaseUnits = ToUnit(BaseUnit); + return inBaseUnits.ToUnit(unit); + } + else + { + throw new NotImplementedException($"Can not convert {Unit} to {unit}."); + } + } + + /// + IQuantity IQuantity.ToUnit(Enum unit) + { + if (!(unit is CompressibilityUnit unitAsCompressibilityUnit)) + throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(CompressibilityUnit)} is supported.", nameof(unit)); + + return ToUnit(unitAsCompressibilityUnit, DefaultConversionFunctions); + } + + /// + IQuantity IQuantity.ToUnit(Enum unit, UnitConverter unitConverter) + { + if (!(unit is CompressibilityUnit unitAsCompressibilityUnit)) + throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(CompressibilityUnit)} is supported.", nameof(unit)); + + return ToUnit(unitAsCompressibilityUnit, unitConverter); + } + + /// + public Compressibility ToUnit(UnitSystem unitSystem) + { + if (unitSystem is null) + throw new ArgumentNullException(nameof(unitSystem)); + + var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits); + + var firstUnitInfo = unitInfos.FirstOrDefault(); + if (firstUnitInfo == null) + throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem)); + + return ToUnit(firstUnitInfo.Value); + } + + /// + IQuantity IQuantity.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem); + + /// + IQuantity IQuantity.ToUnit(CompressibilityUnit unit) => ToUnit(unit); + + /// + IQuantity IQuantity.ToUnit(CompressibilityUnit unit, UnitConverter unitConverter) => ToUnit(unit, unitConverter); + + /// + IQuantity IQuantity.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem); + + private double GetValueAs(CompressibilityUnit unit) + { + var converted = ToUnit(unit); + return (double)converted.Value; + } + + #endregion + + #region ToString Methods + + /// + /// Gets the default string representation of value and unit. + /// + /// String representation. + public override string ToString() + { + return ToString("g"); + } + + /// + /// Gets the default string representation of value and unit using the given format provider. + /// + /// String representation. + /// Format to use for localization and number formatting. Defaults to if null. + public string ToString(IFormatProvider? provider) + { + return ToString("g", provider); + } + + /// + /// Get string representation of value and unit. + /// + /// The number of significant digits after the radix point. + /// String representation. + /// Format to use for localization and number formatting. Defaults to if null. + [Obsolete(@"This method is deprecated and will be removed at a future release. Please use ToString(""s2"") or ToString(""s2"", provider) where 2 is an example of the number passed to significantDigitsAfterRadix.")] + public string ToString(IFormatProvider? provider, int significantDigitsAfterRadix) + { + var value = Convert.ToDouble(Value); + var format = UnitFormatter.GetFormat(value, significantDigitsAfterRadix); + return ToString(provider, format); + } + + /// + /// Get string representation of value and unit. + /// + /// String format to use. Default: "{0:0.##} {1} for value and unit abbreviation respectively." + /// Arguments for string format. Value and unit are implicitly included as arguments 0 and 1. + /// String representation. + /// Format to use for localization and number formatting. Defaults to if null. + [Obsolete("This method is deprecated and will be removed at a future release. Please use string.Format().")] + public string ToString(IFormatProvider? provider, [NotNull] string format, [NotNull] params object[] args) + { + if (format == null) throw new ArgumentNullException(nameof(format)); + if (args == null) throw new ArgumentNullException(nameof(args)); + + provider = provider ?? CultureInfo.CurrentUICulture; + + var value = Convert.ToDouble(Value); + var formatArgs = UnitFormatter.GetFormatArgs(Unit, value, provider, args); + return string.Format(provider, format, formatArgs); + } + + /// + /// + /// Gets the string representation of this instance in the specified format string using . + /// + /// The format string. + /// The string representation. + public string ToString(string format) + { + return ToString(format, CultureInfo.CurrentUICulture); + } + + /// + /// + /// Gets the string representation of this instance in the specified format string using the specified format provider, or if null. + /// + /// The format string. + /// Format to use for localization and number formatting. Defaults to if null. + /// The string representation. + public string ToString(string format, IFormatProvider? provider) + { + return QuantityFormatter.Format(this, format, provider); + } + + #endregion + + #region IConvertible Methods + + TypeCode IConvertible.GetTypeCode() + { + return TypeCode.Object; + } + + bool IConvertible.ToBoolean(IFormatProvider provider) + { + throw new InvalidCastException($"Converting {typeof(Compressibility)} to bool is not supported."); + } + + byte IConvertible.ToByte(IFormatProvider provider) + { + return Convert.ToByte(_value); + } + + char IConvertible.ToChar(IFormatProvider provider) + { + throw new InvalidCastException($"Converting {typeof(Compressibility)} to char is not supported."); + } + + DateTime IConvertible.ToDateTime(IFormatProvider provider) + { + throw new InvalidCastException($"Converting {typeof(Compressibility)} to DateTime is not supported."); + } + + decimal IConvertible.ToDecimal(IFormatProvider provider) + { + return Convert.ToDecimal(_value); + } + + double IConvertible.ToDouble(IFormatProvider provider) + { + return Convert.ToDouble(_value); + } + + short IConvertible.ToInt16(IFormatProvider provider) + { + return Convert.ToInt16(_value); + } + + int IConvertible.ToInt32(IFormatProvider provider) + { + return Convert.ToInt32(_value); + } + + long IConvertible.ToInt64(IFormatProvider provider) + { + return Convert.ToInt64(_value); + } + + sbyte IConvertible.ToSByte(IFormatProvider provider) + { + return Convert.ToSByte(_value); + } + + float IConvertible.ToSingle(IFormatProvider provider) + { + return Convert.ToSingle(_value); + } + + string IConvertible.ToString(IFormatProvider provider) + { + return ToString("g", provider); + } + + object IConvertible.ToType(Type conversionType, IFormatProvider provider) + { + if (conversionType == typeof(Compressibility)) + return this; + else if (conversionType == typeof(CompressibilityUnit)) + return Unit; + else if (conversionType == typeof(QuantityType)) + return Compressibility.QuantityType; + else if (conversionType == typeof(QuantityInfo)) + return Compressibility.Info; + else if (conversionType == typeof(BaseDimensions)) + return Compressibility.BaseDimensions; + else + throw new InvalidCastException($"Converting {typeof(Compressibility)} to {conversionType} is not supported."); + } + + ushort IConvertible.ToUInt16(IFormatProvider provider) + { + return Convert.ToUInt16(_value); + } + + uint IConvertible.ToUInt32(IFormatProvider provider) + { + return Convert.ToUInt32(_value); + } + + ulong IConvertible.ToUInt64(IFormatProvider provider) + { + return Convert.ToUInt64(_value); + } + + #endregion + } +} diff --git a/UnitsNet/GeneratedCode/Quantity.g.cs b/UnitsNet/GeneratedCode/Quantity.g.cs index 237b644386..3f55a4522f 100644 --- a/UnitsNet/GeneratedCode/Quantity.g.cs +++ b/UnitsNet/GeneratedCode/Quantity.g.cs @@ -51,6 +51,7 @@ public static partial class Quantity { "BrakeSpecificFuelConsumption", BrakeSpecificFuelConsumption.Info }, { "Capacitance", Capacitance.Info }, { "CoefficientOfThermalExpansion", CoefficientOfThermalExpansion.Info }, + { "Compressibility", Compressibility.Info }, { "Density", Density.Info }, { "Duration", Duration.Info }, { "DynamicViscosity", DynamicViscosity.Info }, @@ -189,6 +190,8 @@ public static IQuantity FromQuantityType(QuantityType quantityType, QuantityValu return Capacitance.From(value, Capacitance.BaseUnit); case QuantityType.CoefficientOfThermalExpansion: return CoefficientOfThermalExpansion.From(value, CoefficientOfThermalExpansion.BaseUnit); + case QuantityType.Compressibility: + return Compressibility.From(value, Compressibility.BaseUnit); case QuantityType.Density: return Density.From(value, Density.BaseUnit); case QuantityType.Duration: @@ -428,6 +431,8 @@ public static IQuantity FromQuantityInfo(QuantityInfo quantityInfo, QuantityValu return Capacitance.From(value, Capacitance.BaseUnit); case "CoefficientOfThermalExpansion": return CoefficientOfThermalExpansion.From(value, CoefficientOfThermalExpansion.BaseUnit); + case "Compressibility": + return Compressibility.From(value, Compressibility.BaseUnit); case "Density": return Density.From(value, Density.BaseUnit); case "Duration": @@ -681,6 +686,9 @@ public static bool TryFrom(QuantityValue value, Enum unit, out IQuantity? quanti case CoefficientOfThermalExpansionUnit coefficientOfThermalExpansionUnit: quantity = CoefficientOfThermalExpansion.From(value, coefficientOfThermalExpansionUnit); return true; + case CompressibilityUnit compressibilityUnit: + quantity = Compressibility.From(value, compressibilityUnit); + return true; case DensityUnit densityUnit: quantity = Density.From(value, densityUnit); return true; @@ -1031,6 +1039,8 @@ public static bool TryParse(IFormatProvider? formatProvider, Type quantityType, return parser.TryParse(quantityString, formatProvider, Capacitance.From, out quantity); case Type _ when quantityType == typeof(CoefficientOfThermalExpansion): return parser.TryParse(quantityString, formatProvider, CoefficientOfThermalExpansion.From, out quantity); + case Type _ when quantityType == typeof(Compressibility): + return parser.TryParse(quantityString, formatProvider, Compressibility.From, out quantity); case Type _ when quantityType == typeof(Density): return parser.TryParse(quantityString, formatProvider, Density.From, out quantity); case Type _ when quantityType == typeof(Duration): @@ -1249,6 +1259,7 @@ internal static IEnumerable GetQuantityTypes() yield return typeof(BrakeSpecificFuelConsumption); yield return typeof(Capacitance); yield return typeof(CoefficientOfThermalExpansion); + yield return typeof(Compressibility); yield return typeof(Density); yield return typeof(Duration); yield return typeof(DynamicViscosity); diff --git a/UnitsNet/GeneratedCode/QuantityType.g.cs b/UnitsNet/GeneratedCode/QuantityType.g.cs index 522fe664ca..d804d3eb3e 100644 --- a/UnitsNet/GeneratedCode/QuantityType.g.cs +++ b/UnitsNet/GeneratedCode/QuantityType.g.cs @@ -48,6 +48,7 @@ public enum QuantityType BrakeSpecificFuelConsumption, Capacitance, CoefficientOfThermalExpansion, + Compressibility, Density, Duration, DynamicViscosity, diff --git a/UnitsNet/GeneratedCode/Units/CompressibilityUnit.g.cs b/UnitsNet/GeneratedCode/Units/CompressibilityUnit.g.cs new file mode 100644 index 0000000000..77f80bab98 --- /dev/null +++ b/UnitsNet/GeneratedCode/Units/CompressibilityUnit.g.cs @@ -0,0 +1,33 @@ +//------------------------------------------------------------------------------ +// +// 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. +// +// +//------------------------------------------------------------------------------ + +// 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. + +// ReSharper disable once CheckNamespace +namespace UnitsNet.Units +{ + // Disable missing XML comment warnings for the generated unit enums. + #pragma warning disable 1591 + + public enum CompressibilityUnit + { + Undefined = 0, + InversePascal, + } + + #pragma warning restore 1591 +} From 825a520ab996ad13042805201a56105f1febe3c5 Mon Sep 17 00:00:00 2001 From: Tristan Milnthorp Date: Mon, 14 Feb 2022 11:06:31 -0500 Subject: [PATCH 2/4] Add missing units --- .../UnitsNetGen/QuantityGenerator.cs | 3 +- .../UnitsNetWrcGen/QuantityGenerator.cs | 3 +- Common/UnitDefinitions/Compressibility.json | 72 +++++++++++ .../Quantities/Compressibility.g.cs | 78 ++++++++++++ .../Units/CompressibilityUnit.g.cs | 6 + ...NumberToCompressibilityExtensionsTest.g.cs | 24 ++++ .../NumberToCompressibilityExtensions.g.cs | 24 ++++ .../CustomCode/CompressibilityTests.cs | 6 + .../GeneratedCode/IQuantityTests.g.cs | 2 +- .../TestsBase/CompressibilityTestsBase.g.cs | 84 ++++++++++++- .../Quantities/Acceleration.g.cs | 14 +++ .../Quantities/AmountOfSubstance.g.cs | 15 +++ .../Quantities/AmplitudeRatio.g.cs | 4 + .../GeneratedCode/Quantities/Angle.g.cs | 16 +++ .../Quantities/ApparentEnergy.g.cs | 3 + .../Quantities/ApparentPower.g.cs | 4 + .../GeneratedCode/Quantities/Area.g.cs | 14 +++ .../GeneratedCode/Quantities/AreaDensity.g.cs | 1 + .../Quantities/AreaMomentOfInertia.g.cs | 6 + .../GeneratedCode/Quantities/BitRate.g.cs | 26 ++++ .../BrakeSpecificFuelConsumption.g.cs | 3 + .../GeneratedCode/Quantities/Capacitance.g.cs | 7 ++ .../CoefficientOfThermalExpansion.g.cs | 3 + .../Quantities/Compressibility.g.cs | 115 ++++++++++++++++++ .../GeneratedCode/Quantities/Density.g.cs | 51 ++++++++ .../GeneratedCode/Quantities/Duration.g.cs | 11 ++ .../Quantities/DynamicViscosity.g.cs | 10 ++ .../Quantities/ElectricAdmittance.g.cs | 4 + .../Quantities/ElectricCharge.g.cs | 5 + .../Quantities/ElectricChargeDensity.g.cs | 1 + .../Quantities/ElectricConductance.g.cs | 3 + .../Quantities/ElectricConductivity.g.cs | 3 + .../Quantities/ElectricCurrent.g.cs | 8 ++ .../Quantities/ElectricCurrentDensity.g.cs | 3 + .../Quantities/ElectricCurrentGradient.g.cs | 4 + .../Quantities/ElectricField.g.cs | 1 + .../Quantities/ElectricInductance.g.cs | 4 + .../Quantities/ElectricPotential.g.cs | 5 + .../Quantities/ElectricPotentialAc.g.cs | 5 + .../ElectricPotentialChangeRate.g.cs | 20 +++ .../Quantities/ElectricPotentialDc.g.cs | 5 + .../Quantities/ElectricResistance.g.cs | 6 + .../Quantities/ElectricResistivity.g.cs | 14 +++ .../ElectricSurfaceChargeDensity.g.cs | 3 + .../GeneratedCode/Quantities/Energy.g.cs | 36 ++++++ .../GeneratedCode/Quantities/Entropy.g.cs | 7 ++ .../GeneratedCode/Quantities/Force.g.cs | 15 +++ .../Quantities/ForceChangeRate.g.cs | 15 +++ .../Quantities/ForcePerLength.g.cs | 38 ++++++ .../GeneratedCode/Quantities/Frequency.g.cs | 11 ++ .../Quantities/FuelEfficiency.g.cs | 4 + .../GeneratedCode/Quantities/HeatFlux.g.cs | 18 +++ .../Quantities/HeatTransferCoefficient.g.cs | 3 + .../GeneratedCode/Quantities/Illuminance.g.cs | 4 + .../GeneratedCode/Quantities/Information.g.cs | 26 ++++ .../GeneratedCode/Quantities/Irradiance.g.cs | 14 +++ .../GeneratedCode/Quantities/Irradiation.g.cs | 7 ++ .../Quantities/KinematicViscosity.g.cs | 9 ++ .../GeneratedCode/Quantities/LapseRate.g.cs | 1 + .../GeneratedCode/Quantities/Length.g.cs | 35 ++++++ .../GeneratedCode/Quantities/Level.g.cs | 2 + .../Quantities/LinearDensity.g.cs | 14 +++ .../Quantities/LinearPowerDensity.g.cs | 25 ++++ .../GeneratedCode/Quantities/Luminosity.g.cs | 14 +++ .../Quantities/LuminousFlux.g.cs | 1 + .../Quantities/LuminousIntensity.g.cs | 1 + .../Quantities/MagneticField.g.cs | 6 + .../Quantities/MagneticFlux.g.cs | 1 + .../Quantities/Magnetization.g.cs | 1 + .../GeneratedCode/Quantities/Mass.g.cs | 25 ++++ .../Quantities/MassConcentration.g.cs | 49 ++++++++ .../GeneratedCode/Quantities/MassFlow.g.cs | 33 +++++ .../GeneratedCode/Quantities/MassFlux.g.cs | 12 ++ .../Quantities/MassFraction.g.cs | 24 ++++ .../Quantities/MassMomentOfInertia.g.cs | 28 +++++ .../GeneratedCode/Quantities/MolarEnergy.g.cs | 3 + .../Quantities/MolarEntropy.g.cs | 3 + .../GeneratedCode/Quantities/MolarMass.g.cs | 12 ++ .../GeneratedCode/Quantities/Molarity.g.cs | 8 ++ .../Quantities/Permeability.g.cs | 1 + .../Quantities/Permittivity.g.cs | 1 + .../GeneratedCode/Quantities/Power.g.cs | 25 ++++ .../Quantities/PowerDensity.g.cs | 44 +++++++ .../GeneratedCode/Quantities/PowerRatio.g.cs | 2 + .../GeneratedCode/Quantities/Pressure.g.cs | 45 +++++++ .../Quantities/PressureChangeRate.g.cs | 14 +++ .../GeneratedCode/Quantities/Ratio.g.cs | 6 + .../Quantities/RatioChangeRate.g.cs | 2 + .../Quantities/ReactiveEnergy.g.cs | 3 + .../Quantities/ReactivePower.g.cs | 4 + .../Quantities/ReciprocalArea.g.cs | 11 ++ .../Quantities/ReciprocalLength.g.cs | 10 ++ .../Quantities/RelativeHumidity.g.cs | 1 + .../Quantities/RotationalAcceleration.g.cs | 4 + .../Quantities/RotationalSpeed.g.cs | 13 ++ .../Quantities/RotationalStiffness.g.cs | 33 +++++ .../RotationalStiffnessPerLength.g.cs | 5 + .../GeneratedCode/Quantities/Scalar.g.cs | 1 + .../GeneratedCode/Quantities/SolidAngle.g.cs | 1 + .../Quantities/SpecificEnergy.g.cs | 25 ++++ .../Quantities/SpecificEntropy.g.cs | 9 ++ .../Quantities/SpecificFuelConsumption.g.cs | 4 + .../Quantities/SpecificVolume.g.cs | 3 + .../Quantities/SpecificWeight.g.cs | 17 +++ .../GeneratedCode/Quantities/Speed.g.cs | 32 +++++ .../Quantities/StandardVolumeFlow.g.cs | 9 ++ .../GeneratedCode/Quantities/Temperature.g.cs | 10 ++ .../Quantities/TemperatureChangeRate.g.cs | 10 ++ .../Quantities/TemperatureDelta.g.cs | 9 ++ .../Quantities/TemperatureGradient.g.cs | 4 + .../Quantities/ThermalConductivity.g.cs | 2 + .../Quantities/ThermalResistance.g.cs | 6 + .../GeneratedCode/Quantities/Torque.g.cs | 25 ++++ .../Quantities/TorquePerLength.g.cs | 21 ++++ .../GeneratedCode/Quantities/Turbidity.g.cs | 1 + .../GeneratedCode/Quantities/VitaminA.g.cs | 1 + .../GeneratedCode/Quantities/Volume.g.cs | 52 ++++++++ .../Quantities/VolumeConcentration.g.cs | 20 +++ .../GeneratedCode/Quantities/VolumeFlow.g.cs | 62 ++++++++++ .../Quantities/VolumeFlowPerArea.g.cs | 2 + .../Quantities/VolumePerLength.g.cs | 7 ++ .../Quantities/VolumetricHeatCapacity.g.cs | 9 ++ .../Quantities/WarpingMomentOfInertia.g.cs | 6 + .../Units/CompressibilityUnit.g.cs | 6 + .../Quantities/Acceleration.g.cs | 14 +++ .../Quantities/AmountOfSubstance.g.cs | 15 +++ .../Quantities/AmplitudeRatio.g.cs | 4 + UnitsNet/GeneratedCode/Quantities/Angle.g.cs | 16 +++ .../Quantities/ApparentEnergy.g.cs | 3 + .../Quantities/ApparentPower.g.cs | 4 + UnitsNet/GeneratedCode/Quantities/Area.g.cs | 14 +++ .../GeneratedCode/Quantities/AreaDensity.g.cs | 1 + .../Quantities/AreaMomentOfInertia.g.cs | 6 + .../GeneratedCode/Quantities/BitRate.g.cs | 26 ++++ .../BrakeSpecificFuelConsumption.g.cs | 3 + .../GeneratedCode/Quantities/Capacitance.g.cs | 7 ++ .../CoefficientOfThermalExpansion.g.cs | 3 + .../Quantities/Compressibility.g.cs | 115 ++++++++++++++++++ .../GeneratedCode/Quantities/Density.g.cs | 51 ++++++++ .../GeneratedCode/Quantities/Duration.g.cs | 11 ++ .../Quantities/DynamicViscosity.g.cs | 10 ++ .../Quantities/ElectricAdmittance.g.cs | 4 + .../Quantities/ElectricCharge.g.cs | 5 + .../Quantities/ElectricChargeDensity.g.cs | 1 + .../Quantities/ElectricConductance.g.cs | 3 + .../Quantities/ElectricConductivity.g.cs | 3 + .../Quantities/ElectricCurrent.g.cs | 8 ++ .../Quantities/ElectricCurrentDensity.g.cs | 3 + .../Quantities/ElectricCurrentGradient.g.cs | 4 + .../Quantities/ElectricField.g.cs | 1 + .../Quantities/ElectricInductance.g.cs | 4 + .../Quantities/ElectricPotential.g.cs | 5 + .../Quantities/ElectricPotentialAc.g.cs | 5 + .../ElectricPotentialChangeRate.g.cs | 20 +++ .../Quantities/ElectricPotentialDc.g.cs | 5 + .../Quantities/ElectricResistance.g.cs | 6 + .../Quantities/ElectricResistivity.g.cs | 14 +++ .../ElectricSurfaceChargeDensity.g.cs | 3 + UnitsNet/GeneratedCode/Quantities/Energy.g.cs | 36 ++++++ .../GeneratedCode/Quantities/Entropy.g.cs | 7 ++ UnitsNet/GeneratedCode/Quantities/Force.g.cs | 15 +++ .../Quantities/ForceChangeRate.g.cs | 15 +++ .../Quantities/ForcePerLength.g.cs | 38 ++++++ .../GeneratedCode/Quantities/Frequency.g.cs | 11 ++ .../Quantities/FuelEfficiency.g.cs | 4 + .../GeneratedCode/Quantities/HeatFlux.g.cs | 18 +++ .../Quantities/HeatTransferCoefficient.g.cs | 3 + .../GeneratedCode/Quantities/Illuminance.g.cs | 4 + .../GeneratedCode/Quantities/Information.g.cs | 26 ++++ .../GeneratedCode/Quantities/Irradiance.g.cs | 14 +++ .../GeneratedCode/Quantities/Irradiation.g.cs | 7 ++ .../Quantities/KinematicViscosity.g.cs | 9 ++ .../GeneratedCode/Quantities/LapseRate.g.cs | 1 + UnitsNet/GeneratedCode/Quantities/Length.g.cs | 35 ++++++ UnitsNet/GeneratedCode/Quantities/Level.g.cs | 2 + .../Quantities/LinearDensity.g.cs | 14 +++ .../Quantities/LinearPowerDensity.g.cs | 25 ++++ .../GeneratedCode/Quantities/Luminosity.g.cs | 14 +++ .../Quantities/LuminousFlux.g.cs | 1 + .../Quantities/LuminousIntensity.g.cs | 1 + .../Quantities/MagneticField.g.cs | 6 + .../Quantities/MagneticFlux.g.cs | 1 + .../Quantities/Magnetization.g.cs | 1 + UnitsNet/GeneratedCode/Quantities/Mass.g.cs | 25 ++++ .../Quantities/MassConcentration.g.cs | 49 ++++++++ .../GeneratedCode/Quantities/MassFlow.g.cs | 33 +++++ .../GeneratedCode/Quantities/MassFlux.g.cs | 12 ++ .../Quantities/MassFraction.g.cs | 24 ++++ .../Quantities/MassMomentOfInertia.g.cs | 28 +++++ .../GeneratedCode/Quantities/MolarEnergy.g.cs | 3 + .../Quantities/MolarEntropy.g.cs | 3 + .../GeneratedCode/Quantities/MolarMass.g.cs | 12 ++ .../GeneratedCode/Quantities/Molarity.g.cs | 8 ++ .../Quantities/Permeability.g.cs | 1 + .../Quantities/Permittivity.g.cs | 1 + UnitsNet/GeneratedCode/Quantities/Power.g.cs | 25 ++++ .../Quantities/PowerDensity.g.cs | 44 +++++++ .../GeneratedCode/Quantities/PowerRatio.g.cs | 2 + .../GeneratedCode/Quantities/Pressure.g.cs | 45 +++++++ .../Quantities/PressureChangeRate.g.cs | 14 +++ UnitsNet/GeneratedCode/Quantities/Ratio.g.cs | 6 + .../Quantities/RatioChangeRate.g.cs | 2 + .../Quantities/ReactiveEnergy.g.cs | 3 + .../Quantities/ReactivePower.g.cs | 4 + .../Quantities/ReciprocalArea.g.cs | 11 ++ .../Quantities/ReciprocalLength.g.cs | 10 ++ .../Quantities/RelativeHumidity.g.cs | 1 + .../Quantities/RotationalAcceleration.g.cs | 4 + .../Quantities/RotationalSpeed.g.cs | 13 ++ .../Quantities/RotationalStiffness.g.cs | 33 +++++ .../RotationalStiffnessPerLength.g.cs | 5 + UnitsNet/GeneratedCode/Quantities/Scalar.g.cs | 1 + .../GeneratedCode/Quantities/SolidAngle.g.cs | 1 + .../Quantities/SpecificEnergy.g.cs | 25 ++++ .../Quantities/SpecificEntropy.g.cs | 9 ++ .../Quantities/SpecificFuelConsumption.g.cs | 4 + .../Quantities/SpecificVolume.g.cs | 3 + .../Quantities/SpecificWeight.g.cs | 17 +++ UnitsNet/GeneratedCode/Quantities/Speed.g.cs | 32 +++++ .../Quantities/StandardVolumeFlow.g.cs | 9 ++ .../GeneratedCode/Quantities/Temperature.g.cs | 10 ++ .../Quantities/TemperatureChangeRate.g.cs | 10 ++ .../Quantities/TemperatureDelta.g.cs | 9 ++ .../Quantities/TemperatureGradient.g.cs | 4 + .../Quantities/ThermalConductivity.g.cs | 2 + .../Quantities/ThermalResistance.g.cs | 6 + UnitsNet/GeneratedCode/Quantities/Torque.g.cs | 25 ++++ .../Quantities/TorquePerLength.g.cs | 21 ++++ .../GeneratedCode/Quantities/Turbidity.g.cs | 1 + .../GeneratedCode/Quantities/VitaminA.g.cs | 1 + UnitsNet/GeneratedCode/Quantities/Volume.g.cs | 52 ++++++++ .../Quantities/VolumeConcentration.g.cs | 20 +++ .../GeneratedCode/Quantities/VolumeFlow.g.cs | 62 ++++++++++ .../Quantities/VolumeFlowPerArea.g.cs | 2 + .../Quantities/VolumePerLength.g.cs | 7 ++ .../Quantities/VolumetricHeatCapacity.g.cs | 9 ++ .../Quantities/WarpingMomentOfInertia.g.cs | 6 + .../Units/CompressibilityUnit.g.cs | 6 + 238 files changed, 3256 insertions(+), 6 deletions(-) diff --git a/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs b/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs index 05ae7695af..b888bc08df 100644 --- a/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs +++ b/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs @@ -463,7 +463,8 @@ private void GenerateStaticFactoryMethods() {{ {_valueType} value = ({_valueType}) {valueParamName}; return new {_quantity.Name}(value, {_unitEnumName}.{unit.SingularName}); - }}"); + }} +"); } Writer.WL(); diff --git a/CodeGen/Generators/UnitsNetWrcGen/QuantityGenerator.cs b/CodeGen/Generators/UnitsNetWrcGen/QuantityGenerator.cs index d26c092c89..a8aed45f18 100644 --- a/CodeGen/Generators/UnitsNetWrcGen/QuantityGenerator.cs +++ b/CodeGen/Generators/UnitsNetWrcGen/QuantityGenerator.cs @@ -352,7 +352,8 @@ private void GenerateStaticFactoryMethods() {{ {_valueType} value = ({_valueType}) {valueParamName}; return new {_quantity.Name}(value, {_unitEnumName}.{unit.SingularName}); - }}"); + }} +"); } Writer.WL(); diff --git a/Common/UnitDefinitions/Compressibility.json b/Common/UnitDefinitions/Compressibility.json index 716a25c333..3b73871b64 100644 --- a/Common/UnitDefinitions/Compressibility.json +++ b/Common/UnitDefinitions/Compressibility.json @@ -24,6 +24,78 @@ "Abbreviations": [ "Pa⁻¹", "1/Pa" ] } ] + }, + { + "SingularName": "InverseKilopascal", + "PluralName": "InverseKilopascals", + "FromUnitToBaseFunc": "{x} * 1e3", + "FromBaseToUnitFunc": "{x} / 1e3", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "kPa⁻¹", "1/kPa" ] + } + ] + }, + { + "SingularName": "InverseMegapascal", + "PluralName": "InverseMegapascals", + "FromUnitToBaseFunc": "{x} * 1e6", + "FromBaseToUnitFunc": "{x} / 1e6", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "kPa⁻¹", "1/kPa" ] + } + ] + }, + { + "SingularName": "InverseAtmosphere", + "PluralName": "InverseAtmospheres", + "FromUnitToBaseFunc": "{x} * 101325", + "FromBaseToUnitFunc": "{x} / 101325", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "atm⁻¹", "1/atm" ] + } + ] + }, + { + "SingularName": "InverseMillibar", + "PluralName": "InverseMillibars", + "FromUnitToBaseFunc": "{x} * 100", + "FromBaseToUnitFunc": "{x} / 100", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "mbar⁻¹", "1/mbar" ] + } + ] + }, + { + "SingularName": "InverseBar", + "PluralName": "InverseBars", + "FromUnitToBaseFunc": "{x} * 1e5", + "FromBaseToUnitFunc": "{x} / 1e5", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "bar⁻¹", "1/bar" ] + } + ] + }, + { + "SingularName": "InversePoundForcePerSquareInch", + "PluralName": "InversePoundForcePerSquareInchs", + "FromUnitToBaseFunc": "{x} * 6.894757293168361e3", + "FromBaseToUnitFunc": "{x} / 6.894757293168361e3", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "psi⁻¹", "1/psi" ] + } + ] } ] } diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Compressibility.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Compressibility.g.cs index 4bd7cf2316..df6ae5ee36 100644 --- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Compressibility.g.cs +++ b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Compressibility.g.cs @@ -77,21 +77,87 @@ public Compressibility(double value, CompressibilityUnit unit) public static Compressibility Zero { get; } = new Compressibility(0, BaseUnit); #region Conversion Properties + /// + /// Gets a value of this quantity converted into + /// + public double InverseAtmospheres => As(CompressibilityUnit.InverseAtmosphere); + + /// + /// Gets a value of this quantity converted into + /// + public double InverseBars => As(CompressibilityUnit.InverseBar); + + /// + /// Gets a value of this quantity converted into + /// + public double InverseKilopascals => As(CompressibilityUnit.InverseKilopascal); + + /// + /// Gets a value of this quantity converted into + /// + public double InverseMegapascals => As(CompressibilityUnit.InverseMegapascal); + + /// + /// Gets a value of this quantity converted into + /// + public double InverseMillibars => As(CompressibilityUnit.InverseMillibar); + /// /// Gets a value of this quantity converted into /// public double InversePascals => As(CompressibilityUnit.InversePascal); + /// + /// Gets a value of this quantity converted into + /// + public double InversePoundForcePerSquareInchs => As(CompressibilityUnit.InversePoundForcePerSquareInch); + #endregion #region Static Factory Methods + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static Compressibility FromInverseAtmospheres(double inverseatmospheres) => new Compressibility(inverseatmospheres, CompressibilityUnit.InverseAtmosphere); + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static Compressibility FromInverseBars(double inversebars) => new Compressibility(inversebars, CompressibilityUnit.InverseBar); + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static Compressibility FromInverseKilopascals(double inversekilopascals) => new Compressibility(inversekilopascals, CompressibilityUnit.InverseKilopascal); + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static Compressibility FromInverseMegapascals(double inversemegapascals) => new Compressibility(inversemegapascals, CompressibilityUnit.InverseMegapascal); + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static Compressibility FromInverseMillibars(double inversemillibars) => new Compressibility(inversemillibars, CompressibilityUnit.InverseMillibar); + /// /// Creates a from . /// /// If value is NaN or Infinity. public static Compressibility FromInversePascals(double inversepascals) => new Compressibility(inversepascals, CompressibilityUnit.InversePascal); + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static Compressibility FromInversePoundForcePerSquareInchs(double inversepoundforcepersquareinchs) => new Compressibility(inversepoundforcepersquareinchs, CompressibilityUnit.InversePoundForcePerSquareInch); + /// /// Dynamically convert from value and unit enum to . @@ -133,7 +199,13 @@ private double GetValueInBaseUnit() { return Unit switch { + CompressibilityUnit.InverseAtmosphere => _value * 101325, + CompressibilityUnit.InverseBar => _value * 1e5, + CompressibilityUnit.InverseKilopascal => _value * 1e3, + CompressibilityUnit.InverseMegapascal => _value * 1e6, + CompressibilityUnit.InverseMillibar => _value * 100, CompressibilityUnit.InversePascal => _value, + CompressibilityUnit.InversePoundForcePerSquareInch => _value * 6.894757293168361e3, _ => throw new NotImplementedException($"Can not convert {Unit} to base units.") }; } @@ -147,7 +219,13 @@ private double GetValueAs(CompressibilityUnit unit) return unit switch { + CompressibilityUnit.InverseAtmosphere => baseUnitValue / 101325, + CompressibilityUnit.InverseBar => baseUnitValue / 1e5, + CompressibilityUnit.InverseKilopascal => baseUnitValue / 1e3, + CompressibilityUnit.InverseMegapascal => baseUnitValue / 1e6, + CompressibilityUnit.InverseMillibar => baseUnitValue / 100, CompressibilityUnit.InversePascal => baseUnitValue, + CompressibilityUnit.InversePoundForcePerSquareInch => baseUnitValue / 6.894757293168361e3, _ => throw new NotImplementedException($"Can not convert {Unit} to {unit}.") }; } diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/CompressibilityUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/CompressibilityUnit.g.cs index 77f80bab98..5b3e4f4514 100644 --- a/UnitsNet.NanoFramework/GeneratedCode/Units/CompressibilityUnit.g.cs +++ b/UnitsNet.NanoFramework/GeneratedCode/Units/CompressibilityUnit.g.cs @@ -26,7 +26,13 @@ namespace UnitsNet.Units public enum CompressibilityUnit { Undefined = 0, + InverseAtmosphere, + InverseBar, + InverseKilopascal, + InverseMegapascal, + InverseMillibar, InversePascal, + InversePoundForcePerSquareInch, } #pragma warning restore 1591 diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToCompressibilityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToCompressibilityExtensionsTest.g.cs index 39d5bb15ee..a138122f2e 100644 --- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToCompressibilityExtensionsTest.g.cs +++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToCompressibilityExtensionsTest.g.cs @@ -24,9 +24,33 @@ namespace UnitsNet.Tests { public class NumberToCompressibilityExtensionsTests { + [Fact] + public void NumberToInverseAtmospheresTest() => + Assert.Equal(Compressibility.FromInverseAtmospheres(2), 2.InverseAtmospheres()); + + [Fact] + public void NumberToInverseBarsTest() => + Assert.Equal(Compressibility.FromInverseBars(2), 2.InverseBars()); + + [Fact] + public void NumberToInverseKilopascalsTest() => + Assert.Equal(Compressibility.FromInverseKilopascals(2), 2.InverseKilopascals()); + + [Fact] + public void NumberToInverseMegapascalsTest() => + Assert.Equal(Compressibility.FromInverseMegapascals(2), 2.InverseMegapascals()); + + [Fact] + public void NumberToInverseMillibarsTest() => + Assert.Equal(Compressibility.FromInverseMillibars(2), 2.InverseMillibars()); + [Fact] public void NumberToInversePascalsTest() => Assert.Equal(Compressibility.FromInversePascals(2), 2.InversePascals()); + [Fact] + public void NumberToInversePoundForcePerSquareInchsTest() => + Assert.Equal(Compressibility.FromInversePoundForcePerSquareInchs(2), 2.InversePoundForcePerSquareInchs()); + } } diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToCompressibilityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToCompressibilityExtensions.g.cs index fc2e3ea6e9..815908538e 100644 --- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToCompressibilityExtensions.g.cs +++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToCompressibilityExtensions.g.cs @@ -28,9 +28,33 @@ namespace UnitsNet.NumberExtensions.NumberToCompressibility /// public static class NumberToCompressibilityExtensions { + /// + public static Compressibility InverseAtmospheres(this T value) => + Compressibility.FromInverseAtmospheres(Convert.ToDouble(value)); + + /// + public static Compressibility InverseBars(this T value) => + Compressibility.FromInverseBars(Convert.ToDouble(value)); + + /// + public static Compressibility InverseKilopascals(this T value) => + Compressibility.FromInverseKilopascals(Convert.ToDouble(value)); + + /// + public static Compressibility InverseMegapascals(this T value) => + Compressibility.FromInverseMegapascals(Convert.ToDouble(value)); + + /// + public static Compressibility InverseMillibars(this T value) => + Compressibility.FromInverseMillibars(Convert.ToDouble(value)); + /// public static Compressibility InversePascals(this T value) => Compressibility.FromInversePascals(Convert.ToDouble(value)); + /// + public static Compressibility InversePoundForcePerSquareInchs(this T value) => + Compressibility.FromInversePoundForcePerSquareInchs(Convert.ToDouble(value)); + } } diff --git a/UnitsNet.Tests/CustomCode/CompressibilityTests.cs b/UnitsNet.Tests/CustomCode/CompressibilityTests.cs index bda883e3b5..9f7793f4a3 100644 --- a/UnitsNet.Tests/CustomCode/CompressibilityTests.cs +++ b/UnitsNet.Tests/CustomCode/CompressibilityTests.cs @@ -26,6 +26,12 @@ public class CompressibilityTests : CompressibilityTestsBase // Override properties in base class here protected override double InversePascalsInOneInversePascal => 1; + protected override double InverseMillibarsInOneInversePascal => 1e-2; + protected override double InverseKilopascalsInOneInversePascal => 1e-3; + protected override double InverseMegapascalsInOneInversePascal => 1e-6; + protected override double InverseBarsInOneInversePascal => 1e-5; + protected override double InversePoundForcePerSquareInchsInOneInversePascal => 1.450377377302092151542e-4; + protected override double InverseAtmospheresInOneInversePascal => 9.86923266716013e-6; protected override bool SupportsSIUnitSystem => true; } diff --git a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs index ae11acfb7b..61311e9e3b 100644 --- a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs +++ b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs @@ -47,7 +47,7 @@ void Assertion(int expectedValue, Enum expectedUnit, IQuantity quantity) 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, CompressibilityUnit.InversePascal, Quantity.From(3, CompressibilityUnit.InversePascal)); + Assertion(3, CompressibilityUnit.InversePoundForcePerSquareInch, Quantity.From(3, CompressibilityUnit.InversePoundForcePerSquareInch)); 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)); diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/CompressibilityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/CompressibilityTestsBase.g.cs index b09d115a75..9e09af0b19 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/CompressibilityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/CompressibilityTestsBase.g.cs @@ -38,24 +38,48 @@ namespace UnitsNet.Tests // ReSharper disable once PartialTypeWithSinglePart public abstract partial class CompressibilityTestsBase : QuantityTestsBase { + protected abstract double InverseAtmospheresInOneInversePascal { get; } + protected abstract double InverseBarsInOneInversePascal { get; } + protected abstract double InverseKilopascalsInOneInversePascal { get; } + protected abstract double InverseMegapascalsInOneInversePascal { get; } + protected abstract double InverseMillibarsInOneInversePascal { get; } protected abstract double InversePascalsInOneInversePascal { get; } + protected abstract double InversePoundForcePerSquareInchsInOneInversePascal { get; } // ReSharper disable VirtualMemberNeverOverriden.Global + protected virtual double InverseAtmospheresTolerance { get { return 1e-5; } } + protected virtual double InverseBarsTolerance { get { return 1e-5; } } + protected virtual double InverseKilopascalsTolerance { get { return 1e-5; } } + protected virtual double InverseMegapascalsTolerance { get { return 1e-5; } } + protected virtual double InverseMillibarsTolerance { get { return 1e-5; } } protected virtual double InversePascalsTolerance { get { return 1e-5; } } + protected virtual double InversePoundForcePerSquareInchsTolerance { get { return 1e-5; } } // ReSharper restore VirtualMemberNeverOverriden.Global protected (double UnitsInBaseUnit, double Tolerence) GetConversionFactor(CompressibilityUnit unit) { return unit switch { + CompressibilityUnit.InverseAtmosphere => (InverseAtmospheresInOneInversePascal, InverseAtmospheresTolerance), + CompressibilityUnit.InverseBar => (InverseBarsInOneInversePascal, InverseBarsTolerance), + CompressibilityUnit.InverseKilopascal => (InverseKilopascalsInOneInversePascal, InverseKilopascalsTolerance), + CompressibilityUnit.InverseMegapascal => (InverseMegapascalsInOneInversePascal, InverseMegapascalsTolerance), + CompressibilityUnit.InverseMillibar => (InverseMillibarsInOneInversePascal, InverseMillibarsTolerance), CompressibilityUnit.InversePascal => (InversePascalsInOneInversePascal, InversePascalsTolerance), + CompressibilityUnit.InversePoundForcePerSquareInch => (InversePoundForcePerSquareInchsInOneInversePascal, InversePoundForcePerSquareInchsTolerance), _ => throw new NotSupportedException() }; } public static IEnumerable UnitTypes = new List { + new object[] { CompressibilityUnit.InverseAtmosphere }, + new object[] { CompressibilityUnit.InverseBar }, + new object[] { CompressibilityUnit.InverseKilopascal }, + new object[] { CompressibilityUnit.InverseMegapascal }, + new object[] { CompressibilityUnit.InverseMillibar }, new object[] { CompressibilityUnit.InversePascal }, + new object[] { CompressibilityUnit.InversePoundForcePerSquareInch }, }; [Fact] @@ -130,15 +154,45 @@ public void Compressibility_QuantityInfo_ReturnsQuantityInfoDescribingQuantity() public void InversePascalToCompressibilityUnits() { Compressibility inversepascal = Compressibility.FromInversePascals(1); + AssertEx.EqualTolerance(InverseAtmospheresInOneInversePascal, inversepascal.InverseAtmospheres, InverseAtmospheresTolerance); + AssertEx.EqualTolerance(InverseBarsInOneInversePascal, inversepascal.InverseBars, InverseBarsTolerance); + AssertEx.EqualTolerance(InverseKilopascalsInOneInversePascal, inversepascal.InverseKilopascals, InverseKilopascalsTolerance); + AssertEx.EqualTolerance(InverseMegapascalsInOneInversePascal, inversepascal.InverseMegapascals, InverseMegapascalsTolerance); + AssertEx.EqualTolerance(InverseMillibarsInOneInversePascal, inversepascal.InverseMillibars, InverseMillibarsTolerance); AssertEx.EqualTolerance(InversePascalsInOneInversePascal, inversepascal.InversePascals, InversePascalsTolerance); + AssertEx.EqualTolerance(InversePoundForcePerSquareInchsInOneInversePascal, inversepascal.InversePoundForcePerSquareInchs, InversePoundForcePerSquareInchsTolerance); } [Fact] public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() { - var quantity00 = Compressibility.From(1, CompressibilityUnit.InversePascal); - AssertEx.EqualTolerance(1, quantity00.InversePascals, InversePascalsTolerance); - Assert.Equal(CompressibilityUnit.InversePascal, quantity00.Unit); + var quantity00 = Compressibility.From(1, CompressibilityUnit.InverseAtmosphere); + AssertEx.EqualTolerance(1, quantity00.InverseAtmospheres, InverseAtmospheresTolerance); + Assert.Equal(CompressibilityUnit.InverseAtmosphere, quantity00.Unit); + + var quantity01 = Compressibility.From(1, CompressibilityUnit.InverseBar); + AssertEx.EqualTolerance(1, quantity01.InverseBars, InverseBarsTolerance); + Assert.Equal(CompressibilityUnit.InverseBar, quantity01.Unit); + + var quantity02 = Compressibility.From(1, CompressibilityUnit.InverseKilopascal); + AssertEx.EqualTolerance(1, quantity02.InverseKilopascals, InverseKilopascalsTolerance); + Assert.Equal(CompressibilityUnit.InverseKilopascal, quantity02.Unit); + + var quantity03 = Compressibility.From(1, CompressibilityUnit.InverseMegapascal); + AssertEx.EqualTolerance(1, quantity03.InverseMegapascals, InverseMegapascalsTolerance); + Assert.Equal(CompressibilityUnit.InverseMegapascal, quantity03.Unit); + + var quantity04 = Compressibility.From(1, CompressibilityUnit.InverseMillibar); + AssertEx.EqualTolerance(1, quantity04.InverseMillibars, InverseMillibarsTolerance); + Assert.Equal(CompressibilityUnit.InverseMillibar, quantity04.Unit); + + var quantity05 = Compressibility.From(1, CompressibilityUnit.InversePascal); + AssertEx.EqualTolerance(1, quantity05.InversePascals, InversePascalsTolerance); + Assert.Equal(CompressibilityUnit.InversePascal, quantity05.Unit); + + var quantity06 = Compressibility.From(1, CompressibilityUnit.InversePoundForcePerSquareInch); + AssertEx.EqualTolerance(1, quantity06.InversePoundForcePerSquareInchs, InversePoundForcePerSquareInchsTolerance); + Assert.Equal(CompressibilityUnit.InversePoundForcePerSquareInch, quantity06.Unit); } @@ -159,7 +213,13 @@ public void FromInversePascals_WithNanValue_ThrowsArgumentException() public void As() { var inversepascal = Compressibility.FromInversePascals(1); + AssertEx.EqualTolerance(InverseAtmospheresInOneInversePascal, inversepascal.As(CompressibilityUnit.InverseAtmosphere), InverseAtmospheresTolerance); + AssertEx.EqualTolerance(InverseBarsInOneInversePascal, inversepascal.As(CompressibilityUnit.InverseBar), InverseBarsTolerance); + AssertEx.EqualTolerance(InverseKilopascalsInOneInversePascal, inversepascal.As(CompressibilityUnit.InverseKilopascal), InverseKilopascalsTolerance); + AssertEx.EqualTolerance(InverseMegapascalsInOneInversePascal, inversepascal.As(CompressibilityUnit.InverseMegapascal), InverseMegapascalsTolerance); + AssertEx.EqualTolerance(InverseMillibarsInOneInversePascal, inversepascal.As(CompressibilityUnit.InverseMillibar), InverseMillibarsTolerance); AssertEx.EqualTolerance(InversePascalsInOneInversePascal, inversepascal.As(CompressibilityUnit.InversePascal), InversePascalsTolerance); + AssertEx.EqualTolerance(InversePoundForcePerSquareInchsInOneInversePascal, inversepascal.As(CompressibilityUnit.InversePoundForcePerSquareInch), InversePoundForcePerSquareInchsTolerance); } [Fact] @@ -220,7 +280,13 @@ public void ToUnit_FromNonBaseUnit_ReturnsQuantityWithGivenUnit(CompressibilityU public void ConversionRoundTrip() { Compressibility inversepascal = Compressibility.FromInversePascals(1); + AssertEx.EqualTolerance(1, Compressibility.FromInverseAtmospheres(inversepascal.InverseAtmospheres).InversePascals, InverseAtmospheresTolerance); + AssertEx.EqualTolerance(1, Compressibility.FromInverseBars(inversepascal.InverseBars).InversePascals, InverseBarsTolerance); + AssertEx.EqualTolerance(1, Compressibility.FromInverseKilopascals(inversepascal.InverseKilopascals).InversePascals, InverseKilopascalsTolerance); + AssertEx.EqualTolerance(1, Compressibility.FromInverseMegapascals(inversepascal.InverseMegapascals).InversePascals, InverseMegapascalsTolerance); + AssertEx.EqualTolerance(1, Compressibility.FromInverseMillibars(inversepascal.InverseMillibars).InversePascals, InverseMillibarsTolerance); AssertEx.EqualTolerance(1, Compressibility.FromInversePascals(inversepascal.InversePascals).InversePascals, InversePascalsTolerance); + AssertEx.EqualTolerance(1, Compressibility.FromInversePoundForcePerSquareInchs(inversepascal.InversePoundForcePerSquareInchs).InversePascals, InversePoundForcePerSquareInchsTolerance); } [Fact] @@ -379,7 +445,13 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture() var prevCulture = Thread.CurrentThread.CurrentUICulture; Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo("en-US"); try { + Assert.Equal("1 atm⁻¹", new Compressibility(1, CompressibilityUnit.InverseAtmosphere).ToString()); + Assert.Equal("1 bar⁻¹", new Compressibility(1, CompressibilityUnit.InverseBar).ToString()); + Assert.Equal("1 kPa⁻¹", new Compressibility(1, CompressibilityUnit.InverseKilopascal).ToString()); + Assert.Equal("1 kPa⁻¹", new Compressibility(1, CompressibilityUnit.InverseMegapascal).ToString()); + Assert.Equal("1 mbar⁻¹", new Compressibility(1, CompressibilityUnit.InverseMillibar).ToString()); Assert.Equal("1 Pa⁻¹", new Compressibility(1, CompressibilityUnit.InversePascal).ToString()); + Assert.Equal("1 psi⁻¹", new Compressibility(1, CompressibilityUnit.InversePoundForcePerSquareInch).ToString()); } finally { @@ -393,7 +465,13 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback. var swedishCulture = CultureInfo.GetCultureInfo("sv-SE"); + Assert.Equal("1 atm⁻¹", new Compressibility(1, CompressibilityUnit.InverseAtmosphere).ToString(swedishCulture)); + Assert.Equal("1 bar⁻¹", new Compressibility(1, CompressibilityUnit.InverseBar).ToString(swedishCulture)); + Assert.Equal("1 kPa⁻¹", new Compressibility(1, CompressibilityUnit.InverseKilopascal).ToString(swedishCulture)); + Assert.Equal("1 kPa⁻¹", new Compressibility(1, CompressibilityUnit.InverseMegapascal).ToString(swedishCulture)); + Assert.Equal("1 mbar⁻¹", new Compressibility(1, CompressibilityUnit.InverseMillibar).ToString(swedishCulture)); Assert.Equal("1 Pa⁻¹", new Compressibility(1, CompressibilityUnit.InversePascal).ToString(swedishCulture)); + Assert.Equal("1 psi⁻¹", new Compressibility(1, CompressibilityUnit.InversePoundForcePerSquareInch).ToString(swedishCulture)); } [Fact] diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Acceleration.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Acceleration.g.cs index ef11f84099..2ad97093ae 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Acceleration.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Acceleration.g.cs @@ -305,6 +305,7 @@ public static Acceleration FromCentimetersPerSecondSquared(double centimetersper double value = (double) centimeterspersecondsquared; return new Acceleration(value, AccelerationUnit.CentimeterPerSecondSquared); } + /// /// Creates a from . /// @@ -315,6 +316,7 @@ public static Acceleration FromDecimetersPerSecondSquared(double decimetersperse double value = (double) decimeterspersecondsquared; return new Acceleration(value, AccelerationUnit.DecimeterPerSecondSquared); } + /// /// Creates a from . /// @@ -325,6 +327,7 @@ public static Acceleration FromFeetPerSecondSquared(double feetpersecondsquared) double value = (double) feetpersecondsquared; return new Acceleration(value, AccelerationUnit.FootPerSecondSquared); } + /// /// Creates a from . /// @@ -335,6 +338,7 @@ public static Acceleration FromInchesPerSecondSquared(double inchespersecondsqua double value = (double) inchespersecondsquared; return new Acceleration(value, AccelerationUnit.InchPerSecondSquared); } + /// /// Creates a from . /// @@ -345,6 +349,7 @@ public static Acceleration FromKilometersPerSecondSquared(double kilometersperse double value = (double) kilometerspersecondsquared; return new Acceleration(value, AccelerationUnit.KilometerPerSecondSquared); } + /// /// Creates a from . /// @@ -355,6 +360,7 @@ public static Acceleration FromKnotsPerHour(double knotsperhour) double value = (double) knotsperhour; return new Acceleration(value, AccelerationUnit.KnotPerHour); } + /// /// Creates a from . /// @@ -365,6 +371,7 @@ public static Acceleration FromKnotsPerMinute(double knotsperminute) double value = (double) knotsperminute; return new Acceleration(value, AccelerationUnit.KnotPerMinute); } + /// /// Creates a from . /// @@ -375,6 +382,7 @@ public static Acceleration FromKnotsPerSecond(double knotspersecond) double value = (double) knotspersecond; return new Acceleration(value, AccelerationUnit.KnotPerSecond); } + /// /// Creates a from . /// @@ -385,6 +393,7 @@ public static Acceleration FromMetersPerSecondSquared(double meterspersecondsqua double value = (double) meterspersecondsquared; return new Acceleration(value, AccelerationUnit.MeterPerSecondSquared); } + /// /// Creates a from . /// @@ -395,6 +404,7 @@ public static Acceleration FromMicrometersPerSecondSquared(double micrometersper double value = (double) micrometerspersecondsquared; return new Acceleration(value, AccelerationUnit.MicrometerPerSecondSquared); } + /// /// Creates a from . /// @@ -405,6 +415,7 @@ public static Acceleration FromMillimetersPerSecondSquared(double millimetersper double value = (double) millimeterspersecondsquared; return new Acceleration(value, AccelerationUnit.MillimeterPerSecondSquared); } + /// /// Creates a from . /// @@ -415,6 +426,7 @@ public static Acceleration FromMillistandardGravity(double millistandardgravity) double value = (double) millistandardgravity; return new Acceleration(value, AccelerationUnit.MillistandardGravity); } + /// /// Creates a from . /// @@ -425,6 +437,7 @@ public static Acceleration FromNanometersPerSecondSquared(double nanometersperse double value = (double) nanometerspersecondsquared; return new Acceleration(value, AccelerationUnit.NanometerPerSecondSquared); } + /// /// Creates a from . /// @@ -436,6 +449,7 @@ public static Acceleration FromStandardGravity(double standardgravity) return new Acceleration(value, AccelerationUnit.StandardGravity); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmountOfSubstance.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmountOfSubstance.g.cs index aa34666ead..4043a7de90 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmountOfSubstance.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmountOfSubstance.g.cs @@ -297,6 +297,7 @@ public static AmountOfSubstance FromCentimoles(double centimoles) double value = (double) centimoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Centimole); } + /// /// Creates a from . /// @@ -307,6 +308,7 @@ public static AmountOfSubstance FromCentipoundMoles(double centipoundmoles) double value = (double) centipoundmoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.CentipoundMole); } + /// /// Creates a from . /// @@ -317,6 +319,7 @@ public static AmountOfSubstance FromDecimoles(double decimoles) double value = (double) decimoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Decimole); } + /// /// Creates a from . /// @@ -327,6 +330,7 @@ public static AmountOfSubstance FromDecipoundMoles(double decipoundmoles) double value = (double) decipoundmoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.DecipoundMole); } + /// /// Creates a from . /// @@ -337,6 +341,7 @@ public static AmountOfSubstance FromKilomoles(double kilomoles) double value = (double) kilomoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Kilomole); } + /// /// Creates a from . /// @@ -347,6 +352,7 @@ public static AmountOfSubstance FromKilopoundMoles(double kilopoundmoles) double value = (double) kilopoundmoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.KilopoundMole); } + /// /// Creates a from . /// @@ -357,6 +363,7 @@ public static AmountOfSubstance FromMegamoles(double megamoles) double value = (double) megamoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Megamole); } + /// /// Creates a from . /// @@ -367,6 +374,7 @@ public static AmountOfSubstance FromMicromoles(double micromoles) double value = (double) micromoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Micromole); } + /// /// Creates a from . /// @@ -377,6 +385,7 @@ public static AmountOfSubstance FromMicropoundMoles(double micropoundmoles) double value = (double) micropoundmoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.MicropoundMole); } + /// /// Creates a from . /// @@ -387,6 +396,7 @@ public static AmountOfSubstance FromMillimoles(double millimoles) double value = (double) millimoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Millimole); } + /// /// Creates a from . /// @@ -397,6 +407,7 @@ public static AmountOfSubstance FromMillipoundMoles(double millipoundmoles) double value = (double) millipoundmoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.MillipoundMole); } + /// /// Creates a from . /// @@ -407,6 +418,7 @@ public static AmountOfSubstance FromMoles(double moles) double value = (double) moles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Mole); } + /// /// Creates a from . /// @@ -417,6 +429,7 @@ public static AmountOfSubstance FromNanomoles(double nanomoles) double value = (double) nanomoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Nanomole); } + /// /// Creates a from . /// @@ -427,6 +440,7 @@ public static AmountOfSubstance FromNanopoundMoles(double nanopoundmoles) double value = (double) nanopoundmoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.NanopoundMole); } + /// /// Creates a from . /// @@ -438,6 +452,7 @@ public static AmountOfSubstance FromPoundMoles(double poundmoles) return new AmountOfSubstance(value, AmountOfSubstanceUnit.PoundMole); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmplitudeRatio.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmplitudeRatio.g.cs index b179cdab68..4bcebc2079 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmplitudeRatio.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmplitudeRatio.g.cs @@ -231,6 +231,7 @@ public static AmplitudeRatio FromDecibelMicrovolts(double decibelmicrovolts) double value = (double) decibelmicrovolts; return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelMicrovolt); } + /// /// Creates a from . /// @@ -241,6 +242,7 @@ public static AmplitudeRatio FromDecibelMillivolts(double decibelmillivolts) double value = (double) decibelmillivolts; return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelMillivolt); } + /// /// Creates a from . /// @@ -251,6 +253,7 @@ public static AmplitudeRatio FromDecibelsUnloaded(double decibelsunloaded) double value = (double) decibelsunloaded; return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelUnloaded); } + /// /// Creates a from . /// @@ -262,6 +265,7 @@ public static AmplitudeRatio FromDecibelVolts(double decibelvolts) return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelVolt); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Angle.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Angle.g.cs index 50efbd498c..ddaf3deade 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Angle.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Angle.g.cs @@ -315,6 +315,7 @@ public static Angle FromArcminutes(double arcminutes) double value = (double) arcminutes; return new Angle(value, AngleUnit.Arcminute); } + /// /// Creates a from . /// @@ -325,6 +326,7 @@ public static Angle FromArcseconds(double arcseconds) double value = (double) arcseconds; return new Angle(value, AngleUnit.Arcsecond); } + /// /// Creates a from . /// @@ -335,6 +337,7 @@ public static Angle FromCentiradians(double centiradians) double value = (double) centiradians; return new Angle(value, AngleUnit.Centiradian); } + /// /// Creates a from . /// @@ -345,6 +348,7 @@ public static Angle FromDeciradians(double deciradians) double value = (double) deciradians; return new Angle(value, AngleUnit.Deciradian); } + /// /// Creates a from . /// @@ -355,6 +359,7 @@ public static Angle FromDegrees(double degrees) double value = (double) degrees; return new Angle(value, AngleUnit.Degree); } + /// /// Creates a from . /// @@ -365,6 +370,7 @@ public static Angle FromGradians(double gradians) double value = (double) gradians; return new Angle(value, AngleUnit.Gradian); } + /// /// Creates a from . /// @@ -375,6 +381,7 @@ public static Angle FromMicrodegrees(double microdegrees) double value = (double) microdegrees; return new Angle(value, AngleUnit.Microdegree); } + /// /// Creates a from . /// @@ -385,6 +392,7 @@ public static Angle FromMicroradians(double microradians) double value = (double) microradians; return new Angle(value, AngleUnit.Microradian); } + /// /// Creates a from . /// @@ -395,6 +403,7 @@ public static Angle FromMillidegrees(double millidegrees) double value = (double) millidegrees; return new Angle(value, AngleUnit.Millidegree); } + /// /// Creates a from . /// @@ -405,6 +414,7 @@ public static Angle FromMilliradians(double milliradians) double value = (double) milliradians; return new Angle(value, AngleUnit.Milliradian); } + /// /// Creates a from . /// @@ -415,6 +425,7 @@ public static Angle FromNanodegrees(double nanodegrees) double value = (double) nanodegrees; return new Angle(value, AngleUnit.Nanodegree); } + /// /// Creates a from . /// @@ -425,6 +436,7 @@ public static Angle FromNanoradians(double nanoradians) double value = (double) nanoradians; return new Angle(value, AngleUnit.Nanoradian); } + /// /// Creates a from . /// @@ -435,6 +447,7 @@ public static Angle FromNatoMils(double natomils) double value = (double) natomils; return new Angle(value, AngleUnit.NatoMil); } + /// /// Creates a from . /// @@ -445,6 +458,7 @@ public static Angle FromRadians(double radians) double value = (double) radians; return new Angle(value, AngleUnit.Radian); } + /// /// Creates a from . /// @@ -455,6 +469,7 @@ public static Angle FromRevolutions(double revolutions) double value = (double) revolutions; return new Angle(value, AngleUnit.Revolution); } + /// /// Creates a from . /// @@ -466,6 +481,7 @@ public static Angle FromTilt(double tilt) return new Angle(value, AngleUnit.Tilt); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentEnergy.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentEnergy.g.cs index e0935aacf3..17c607c5ad 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentEnergy.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentEnergy.g.cs @@ -225,6 +225,7 @@ public static ApparentEnergy FromKilovoltampereHours(double kilovoltamperehours) double value = (double) kilovoltamperehours; return new ApparentEnergy(value, ApparentEnergyUnit.KilovoltampereHour); } + /// /// Creates a from . /// @@ -235,6 +236,7 @@ public static ApparentEnergy FromMegavoltampereHours(double megavoltamperehours) double value = (double) megavoltamperehours; return new ApparentEnergy(value, ApparentEnergyUnit.MegavoltampereHour); } + /// /// Creates a from . /// @@ -246,6 +248,7 @@ public static ApparentEnergy FromVoltampereHours(double voltamperehours) return new ApparentEnergy(value, ApparentEnergyUnit.VoltampereHour); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentPower.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentPower.g.cs index 807a33365f..08976c8ac3 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentPower.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentPower.g.cs @@ -231,6 +231,7 @@ public static ApparentPower FromGigavoltamperes(double gigavoltamperes) double value = (double) gigavoltamperes; return new ApparentPower(value, ApparentPowerUnit.Gigavoltampere); } + /// /// Creates a from . /// @@ -241,6 +242,7 @@ public static ApparentPower FromKilovoltamperes(double kilovoltamperes) double value = (double) kilovoltamperes; return new ApparentPower(value, ApparentPowerUnit.Kilovoltampere); } + /// /// Creates a from . /// @@ -251,6 +253,7 @@ public static ApparentPower FromMegavoltamperes(double megavoltamperes) double value = (double) megavoltamperes; return new ApparentPower(value, ApparentPowerUnit.Megavoltampere); } + /// /// Creates a from . /// @@ -262,6 +265,7 @@ public static ApparentPower FromVoltamperes(double voltamperes) return new ApparentPower(value, ApparentPowerUnit.Voltampere); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Area.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Area.g.cs index 1fe6b5a24c..a4201f9e6b 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Area.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Area.g.cs @@ -318,6 +318,7 @@ public static Area FromAcres(double acres) double value = (double) acres; return new Area(value, AreaUnit.Acre); } + /// /// Creates a from . /// @@ -328,6 +329,7 @@ public static Area FromHectares(double hectares) double value = (double) hectares; return new Area(value, AreaUnit.Hectare); } + /// /// Creates a from . /// @@ -338,6 +340,7 @@ public static Area FromSquareCentimeters(double squarecentimeters) double value = (double) squarecentimeters; return new Area(value, AreaUnit.SquareCentimeter); } + /// /// Creates a from . /// @@ -348,6 +351,7 @@ public static Area FromSquareDecimeters(double squaredecimeters) double value = (double) squaredecimeters; return new Area(value, AreaUnit.SquareDecimeter); } + /// /// Creates a from . /// @@ -358,6 +362,7 @@ public static Area FromSquareFeet(double squarefeet) double value = (double) squarefeet; return new Area(value, AreaUnit.SquareFoot); } + /// /// Creates a from . /// @@ -368,6 +373,7 @@ public static Area FromSquareInches(double squareinches) double value = (double) squareinches; return new Area(value, AreaUnit.SquareInch); } + /// /// Creates a from . /// @@ -378,6 +384,7 @@ public static Area FromSquareKilometers(double squarekilometers) double value = (double) squarekilometers; return new Area(value, AreaUnit.SquareKilometer); } + /// /// Creates a from . /// @@ -388,6 +395,7 @@ public static Area FromSquareMeters(double squaremeters) double value = (double) squaremeters; return new Area(value, AreaUnit.SquareMeter); } + /// /// Creates a from . /// @@ -398,6 +406,7 @@ public static Area FromSquareMicrometers(double squaremicrometers) double value = (double) squaremicrometers; return new Area(value, AreaUnit.SquareMicrometer); } + /// /// Creates a from . /// @@ -408,6 +417,7 @@ public static Area FromSquareMiles(double squaremiles) double value = (double) squaremiles; return new Area(value, AreaUnit.SquareMile); } + /// /// Creates a from . /// @@ -418,6 +428,7 @@ public static Area FromSquareMillimeters(double squaremillimeters) double value = (double) squaremillimeters; return new Area(value, AreaUnit.SquareMillimeter); } + /// /// Creates a from . /// @@ -428,6 +439,7 @@ public static Area FromSquareNauticalMiles(double squarenauticalmiles) double value = (double) squarenauticalmiles; return new Area(value, AreaUnit.SquareNauticalMile); } + /// /// Creates a from . /// @@ -438,6 +450,7 @@ public static Area FromSquareYards(double squareyards) double value = (double) squareyards; return new Area(value, AreaUnit.SquareYard); } + /// /// Creates a from . /// @@ -449,6 +462,7 @@ public static Area FromUsSurveySquareFeet(double ussurveysquarefeet) return new Area(value, AreaUnit.UsSurveySquareFoot); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaDensity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaDensity.g.cs index 9ef759f4a8..726ed56fbb 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaDensity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaDensity.g.cs @@ -214,6 +214,7 @@ public static AreaDensity FromKilogramsPerSquareMeter(double kilogramspersquarem return new AreaDensity(value, AreaDensityUnit.KilogramPerSquareMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs index 29b0403dba..b3d801a662 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs @@ -243,6 +243,7 @@ public static AreaMomentOfInertia FromCentimetersToTheFourth(double centimeterst double value = (double) centimeterstothefourth; return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.CentimeterToTheFourth); } + /// /// Creates a from . /// @@ -253,6 +254,7 @@ public static AreaMomentOfInertia FromDecimetersToTheFourth(double decimeterstot double value = (double) decimeterstothefourth; return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.DecimeterToTheFourth); } + /// /// Creates a from . /// @@ -263,6 +265,7 @@ public static AreaMomentOfInertia FromFeetToTheFourth(double feettothefourth) double value = (double) feettothefourth; return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.FootToTheFourth); } + /// /// Creates a from . /// @@ -273,6 +276,7 @@ public static AreaMomentOfInertia FromInchesToTheFourth(double inchestothefourth double value = (double) inchestothefourth; return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.InchToTheFourth); } + /// /// Creates a from . /// @@ -283,6 +287,7 @@ public static AreaMomentOfInertia FromMetersToTheFourth(double meterstothefourth double value = (double) meterstothefourth; return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.MeterToTheFourth); } + /// /// Creates a from . /// @@ -294,6 +299,7 @@ public static AreaMomentOfInertia FromMillimetersToTheFourth(double millimeterst return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.MillimeterToTheFourth); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BitRate.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BitRate.g.cs index b48f781528..638432b733 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BitRate.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BitRate.g.cs @@ -366,6 +366,7 @@ public static BitRate FromBitsPerSecond(double bitspersecond) decimal value = (decimal) bitspersecond; return new BitRate(value, BitRateUnit.BitPerSecond); } + /// /// Creates a from . /// @@ -376,6 +377,7 @@ public static BitRate FromBytesPerSecond(double bytespersecond) decimal value = (decimal) bytespersecond; return new BitRate(value, BitRateUnit.BytePerSecond); } + /// /// Creates a from . /// @@ -386,6 +388,7 @@ public static BitRate FromExabitsPerSecond(double exabitspersecond) decimal value = (decimal) exabitspersecond; return new BitRate(value, BitRateUnit.ExabitPerSecond); } + /// /// Creates a from . /// @@ -396,6 +399,7 @@ public static BitRate FromExabytesPerSecond(double exabytespersecond) decimal value = (decimal) exabytespersecond; return new BitRate(value, BitRateUnit.ExabytePerSecond); } + /// /// Creates a from . /// @@ -406,6 +410,7 @@ public static BitRate FromExbibitsPerSecond(double exbibitspersecond) decimal value = (decimal) exbibitspersecond; return new BitRate(value, BitRateUnit.ExbibitPerSecond); } + /// /// Creates a from . /// @@ -416,6 +421,7 @@ public static BitRate FromExbibytesPerSecond(double exbibytespersecond) decimal value = (decimal) exbibytespersecond; return new BitRate(value, BitRateUnit.ExbibytePerSecond); } + /// /// Creates a from . /// @@ -426,6 +432,7 @@ public static BitRate FromGibibitsPerSecond(double gibibitspersecond) decimal value = (decimal) gibibitspersecond; return new BitRate(value, BitRateUnit.GibibitPerSecond); } + /// /// Creates a from . /// @@ -436,6 +443,7 @@ public static BitRate FromGibibytesPerSecond(double gibibytespersecond) decimal value = (decimal) gibibytespersecond; return new BitRate(value, BitRateUnit.GibibytePerSecond); } + /// /// Creates a from . /// @@ -446,6 +454,7 @@ public static BitRate FromGigabitsPerSecond(double gigabitspersecond) decimal value = (decimal) gigabitspersecond; return new BitRate(value, BitRateUnit.GigabitPerSecond); } + /// /// Creates a from . /// @@ -456,6 +465,7 @@ public static BitRate FromGigabytesPerSecond(double gigabytespersecond) decimal value = (decimal) gigabytespersecond; return new BitRate(value, BitRateUnit.GigabytePerSecond); } + /// /// Creates a from . /// @@ -466,6 +476,7 @@ public static BitRate FromKibibitsPerSecond(double kibibitspersecond) decimal value = (decimal) kibibitspersecond; return new BitRate(value, BitRateUnit.KibibitPerSecond); } + /// /// Creates a from . /// @@ -476,6 +487,7 @@ public static BitRate FromKibibytesPerSecond(double kibibytespersecond) decimal value = (decimal) kibibytespersecond; return new BitRate(value, BitRateUnit.KibibytePerSecond); } + /// /// Creates a from . /// @@ -486,6 +498,7 @@ public static BitRate FromKilobitsPerSecond(double kilobitspersecond) decimal value = (decimal) kilobitspersecond; return new BitRate(value, BitRateUnit.KilobitPerSecond); } + /// /// Creates a from . /// @@ -496,6 +509,7 @@ public static BitRate FromKilobytesPerSecond(double kilobytespersecond) decimal value = (decimal) kilobytespersecond; return new BitRate(value, BitRateUnit.KilobytePerSecond); } + /// /// Creates a from . /// @@ -506,6 +520,7 @@ public static BitRate FromMebibitsPerSecond(double mebibitspersecond) decimal value = (decimal) mebibitspersecond; return new BitRate(value, BitRateUnit.MebibitPerSecond); } + /// /// Creates a from . /// @@ -516,6 +531,7 @@ public static BitRate FromMebibytesPerSecond(double mebibytespersecond) decimal value = (decimal) mebibytespersecond; return new BitRate(value, BitRateUnit.MebibytePerSecond); } + /// /// Creates a from . /// @@ -526,6 +542,7 @@ public static BitRate FromMegabitsPerSecond(double megabitspersecond) decimal value = (decimal) megabitspersecond; return new BitRate(value, BitRateUnit.MegabitPerSecond); } + /// /// Creates a from . /// @@ -536,6 +553,7 @@ public static BitRate FromMegabytesPerSecond(double megabytespersecond) decimal value = (decimal) megabytespersecond; return new BitRate(value, BitRateUnit.MegabytePerSecond); } + /// /// Creates a from . /// @@ -546,6 +564,7 @@ public static BitRate FromPebibitsPerSecond(double pebibitspersecond) decimal value = (decimal) pebibitspersecond; return new BitRate(value, BitRateUnit.PebibitPerSecond); } + /// /// Creates a from . /// @@ -556,6 +575,7 @@ public static BitRate FromPebibytesPerSecond(double pebibytespersecond) decimal value = (decimal) pebibytespersecond; return new BitRate(value, BitRateUnit.PebibytePerSecond); } + /// /// Creates a from . /// @@ -566,6 +586,7 @@ public static BitRate FromPetabitsPerSecond(double petabitspersecond) decimal value = (decimal) petabitspersecond; return new BitRate(value, BitRateUnit.PetabitPerSecond); } + /// /// Creates a from . /// @@ -576,6 +597,7 @@ public static BitRate FromPetabytesPerSecond(double petabytespersecond) decimal value = (decimal) petabytespersecond; return new BitRate(value, BitRateUnit.PetabytePerSecond); } + /// /// Creates a from . /// @@ -586,6 +608,7 @@ public static BitRate FromTebibitsPerSecond(double tebibitspersecond) decimal value = (decimal) tebibitspersecond; return new BitRate(value, BitRateUnit.TebibitPerSecond); } + /// /// Creates a from . /// @@ -596,6 +619,7 @@ public static BitRate FromTebibytesPerSecond(double tebibytespersecond) decimal value = (decimal) tebibytespersecond; return new BitRate(value, BitRateUnit.TebibytePerSecond); } + /// /// Creates a from . /// @@ -606,6 +630,7 @@ public static BitRate FromTerabitsPerSecond(double terabitspersecond) decimal value = (decimal) terabitspersecond; return new BitRate(value, BitRateUnit.TerabitPerSecond); } + /// /// Creates a from . /// @@ -617,6 +642,7 @@ public static BitRate FromTerabytesPerSecond(double terabytespersecond) return new BitRate(value, BitRateUnit.TerabytePerSecond); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs index 179e6fb1ee..206fca1b13 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs @@ -225,6 +225,7 @@ public static BrakeSpecificFuelConsumption FromGramsPerKiloWattHour(double grams double value = (double) gramsperkilowatthour; return new BrakeSpecificFuelConsumption(value, BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour); } + /// /// Creates a from . /// @@ -235,6 +236,7 @@ public static BrakeSpecificFuelConsumption FromKilogramsPerJoule(double kilogram double value = (double) kilogramsperjoule; return new BrakeSpecificFuelConsumption(value, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule); } + /// /// Creates a from . /// @@ -246,6 +248,7 @@ public static BrakeSpecificFuelConsumption FromPoundsPerMechanicalHorsepowerHour return new BrakeSpecificFuelConsumption(value, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Capacitance.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Capacitance.g.cs index 9c4bf6e762..faaf239857 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Capacitance.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Capacitance.g.cs @@ -252,6 +252,7 @@ public static Capacitance FromFarads(double farads) double value = (double) farads; return new Capacitance(value, CapacitanceUnit.Farad); } + /// /// Creates a from . /// @@ -262,6 +263,7 @@ public static Capacitance FromKilofarads(double kilofarads) double value = (double) kilofarads; return new Capacitance(value, CapacitanceUnit.Kilofarad); } + /// /// Creates a from . /// @@ -272,6 +274,7 @@ public static Capacitance FromMegafarads(double megafarads) double value = (double) megafarads; return new Capacitance(value, CapacitanceUnit.Megafarad); } + /// /// Creates a from . /// @@ -282,6 +285,7 @@ public static Capacitance FromMicrofarads(double microfarads) double value = (double) microfarads; return new Capacitance(value, CapacitanceUnit.Microfarad); } + /// /// Creates a from . /// @@ -292,6 +296,7 @@ public static Capacitance FromMillifarads(double millifarads) double value = (double) millifarads; return new Capacitance(value, CapacitanceUnit.Millifarad); } + /// /// Creates a from . /// @@ -302,6 +307,7 @@ public static Capacitance FromNanofarads(double nanofarads) double value = (double) nanofarads; return new Capacitance(value, CapacitanceUnit.Nanofarad); } + /// /// Creates a from . /// @@ -313,6 +319,7 @@ public static Capacitance FromPicofarads(double picofarads) return new Capacitance(value, CapacitanceUnit.Picofarad); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs index 2139989730..e690ee7ef8 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs @@ -225,6 +225,7 @@ public static CoefficientOfThermalExpansion FromInverseDegreeCelsius(double inve double value = (double) inversedegreecelsius; return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.InverseDegreeCelsius); } + /// /// Creates a from . /// @@ -235,6 +236,7 @@ public static CoefficientOfThermalExpansion FromInverseDegreeFahrenheit(double i double value = (double) inversedegreefahrenheit; return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit); } + /// /// Creates a from . /// @@ -246,6 +248,7 @@ public static CoefficientOfThermalExpansion FromInverseKelvin(double inversekelv return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.InverseKelvin); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Compressibility.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Compressibility.g.cs index 450da5905b..5cbc828ddf 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Compressibility.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Compressibility.g.cs @@ -163,18 +163,54 @@ private Compressibility(double value, CompressibilityUnit unit) #region Conversion Properties + /// + /// Gets a value of this quantity converted into + /// + public double InverseAtmospheres => As(CompressibilityUnit.InverseAtmosphere); + + /// + /// Gets a value of this quantity converted into + /// + public double InverseBars => As(CompressibilityUnit.InverseBar); + + /// + /// Gets a value of this quantity converted into + /// + public double InverseKilopascals => As(CompressibilityUnit.InverseKilopascal); + + /// + /// Gets a value of this quantity converted into + /// + public double InverseMegapascals => As(CompressibilityUnit.InverseMegapascal); + + /// + /// Gets a value of this quantity converted into + /// + public double InverseMillibars => As(CompressibilityUnit.InverseMillibar); + /// /// Gets a value of this quantity converted into /// public double InversePascals => As(CompressibilityUnit.InversePascal); + /// + /// Gets a value of this quantity converted into + /// + public double InversePoundForcePerSquareInchs => As(CompressibilityUnit.InversePoundForcePerSquareInch); + #endregion #region Static Methods internal static void MapGeneratedLocalizations(UnitAbbreviationsCache unitAbbreviationsCache) { + unitAbbreviationsCache.PerformAbbreviationMapping(CompressibilityUnit.InverseAtmosphere, new CultureInfo("en-US"), false, true, new string[]{"atm⁻¹", "1/atm"}); + unitAbbreviationsCache.PerformAbbreviationMapping(CompressibilityUnit.InverseBar, new CultureInfo("en-US"), false, true, new string[]{"bar⁻¹", "1/bar"}); + unitAbbreviationsCache.PerformAbbreviationMapping(CompressibilityUnit.InverseKilopascal, new CultureInfo("en-US"), false, true, new string[]{"kPa⁻¹", "1/kPa"}); + unitAbbreviationsCache.PerformAbbreviationMapping(CompressibilityUnit.InverseMegapascal, new CultureInfo("en-US"), false, true, new string[]{"kPa⁻¹", "1/kPa"}); + unitAbbreviationsCache.PerformAbbreviationMapping(CompressibilityUnit.InverseMillibar, new CultureInfo("en-US"), false, true, new string[]{"mbar⁻¹", "1/mbar"}); unitAbbreviationsCache.PerformAbbreviationMapping(CompressibilityUnit.InversePascal, new CultureInfo("en-US"), false, true, new string[]{"Pa⁻¹", "1/Pa"}); + unitAbbreviationsCache.PerformAbbreviationMapping(CompressibilityUnit.InversePoundForcePerSquareInch, new CultureInfo("en-US"), false, true, new string[]{"psi⁻¹", "1/psi"}); } /// @@ -203,6 +239,61 @@ public static string GetAbbreviation(CompressibilityUnit unit, [CanBeNull] strin #region Static Factory Methods + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Compressibility FromInverseAtmospheres(double inverseatmospheres) + { + double value = (double) inverseatmospheres; + return new Compressibility(value, CompressibilityUnit.InverseAtmosphere); + } + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Compressibility FromInverseBars(double inversebars) + { + double value = (double) inversebars; + return new Compressibility(value, CompressibilityUnit.InverseBar); + } + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Compressibility FromInverseKilopascals(double inversekilopascals) + { + double value = (double) inversekilopascals; + return new Compressibility(value, CompressibilityUnit.InverseKilopascal); + } + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Compressibility FromInverseMegapascals(double inversemegapascals) + { + double value = (double) inversemegapascals; + return new Compressibility(value, CompressibilityUnit.InverseMegapascal); + } + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Compressibility FromInverseMillibars(double inversemillibars) + { + double value = (double) inversemillibars; + return new Compressibility(value, CompressibilityUnit.InverseMillibar); + } + /// /// Creates a from . /// @@ -214,6 +305,18 @@ public static Compressibility FromInversePascals(double inversepascals) return new Compressibility(value, CompressibilityUnit.InversePascal); } + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static Compressibility FromInversePoundForcePerSquareInchs(double inversepoundforcepersquareinchs) + { + double value = (double) inversepoundforcepersquareinchs; + return new Compressibility(value, CompressibilityUnit.InversePoundForcePerSquareInch); + } + + /// /// Dynamically convert from value and unit enum to . /// @@ -504,7 +607,13 @@ private double AsBaseUnit() { switch(Unit) { + case CompressibilityUnit.InverseAtmosphere: return _value * 101325; + case CompressibilityUnit.InverseBar: return _value * 1e5; + case CompressibilityUnit.InverseKilopascal: return _value * 1e3; + case CompressibilityUnit.InverseMegapascal: return _value * 1e6; + case CompressibilityUnit.InverseMillibar: return _value * 100; case CompressibilityUnit.InversePascal: return _value; + case CompressibilityUnit.InversePoundForcePerSquareInch: return _value * 6.894757293168361e3; default: throw new NotImplementedException($"Can not convert {Unit} to base units."); } @@ -519,7 +628,13 @@ private double AsBaseNumericType(CompressibilityUnit unit) switch(unit) { + case CompressibilityUnit.InverseAtmosphere: return baseUnitValue / 101325; + case CompressibilityUnit.InverseBar: return baseUnitValue / 1e5; + case CompressibilityUnit.InverseKilopascal: return baseUnitValue / 1e3; + case CompressibilityUnit.InverseMegapascal: return baseUnitValue / 1e6; + case CompressibilityUnit.InverseMillibar: return baseUnitValue / 100; case CompressibilityUnit.InversePascal: return baseUnitValue; + case CompressibilityUnit.InversePoundForcePerSquareInch: return baseUnitValue / 6.894757293168361e3; default: throw new NotImplementedException($"Can not convert {Unit} to {unit}."); } diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Density.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Density.g.cs index 8ae408511e..ee9b52dc48 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Density.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Density.g.cs @@ -520,6 +520,7 @@ public static Density FromCentigramsPerDeciLiter(double centigramsperdeciliter) double value = (double) centigramsperdeciliter; return new Density(value, DensityUnit.CentigramPerDeciliter); } + /// /// Creates a from . /// @@ -530,6 +531,7 @@ public static Density FromCentigramsPerLiter(double centigramsperliter) double value = (double) centigramsperliter; return new Density(value, DensityUnit.CentigramPerLiter); } + /// /// Creates a from . /// @@ -540,6 +542,7 @@ public static Density FromCentigramsPerMilliliter(double centigramspermilliliter double value = (double) centigramspermilliliter; return new Density(value, DensityUnit.CentigramPerMilliliter); } + /// /// Creates a from . /// @@ -550,6 +553,7 @@ public static Density FromDecigramsPerDeciLiter(double decigramsperdeciliter) double value = (double) decigramsperdeciliter; return new Density(value, DensityUnit.DecigramPerDeciliter); } + /// /// Creates a from . /// @@ -560,6 +564,7 @@ public static Density FromDecigramsPerLiter(double decigramsperliter) double value = (double) decigramsperliter; return new Density(value, DensityUnit.DecigramPerLiter); } + /// /// Creates a from . /// @@ -570,6 +575,7 @@ public static Density FromDecigramsPerMilliliter(double decigramspermilliliter) double value = (double) decigramspermilliliter; return new Density(value, DensityUnit.DecigramPerMilliliter); } + /// /// Creates a from . /// @@ -580,6 +586,7 @@ public static Density FromGramsPerCubicCentimeter(double gramspercubiccentimeter double value = (double) gramspercubiccentimeter; return new Density(value, DensityUnit.GramPerCubicCentimeter); } + /// /// Creates a from . /// @@ -590,6 +597,7 @@ public static Density FromGramsPerCubicFoot(double gramspercubicfoot) double value = (double) gramspercubicfoot; return new Density(value, DensityUnit.GramPerCubicFoot); } + /// /// Creates a from . /// @@ -600,6 +608,7 @@ public static Density FromGramsPerCubicInch(double gramspercubicinch) double value = (double) gramspercubicinch; return new Density(value, DensityUnit.GramPerCubicInch); } + /// /// Creates a from . /// @@ -610,6 +619,7 @@ public static Density FromGramsPerCubicMeter(double gramspercubicmeter) double value = (double) gramspercubicmeter; return new Density(value, DensityUnit.GramPerCubicMeter); } + /// /// Creates a from . /// @@ -620,6 +630,7 @@ public static Density FromGramsPerCubicMillimeter(double gramspercubicmillimeter double value = (double) gramspercubicmillimeter; return new Density(value, DensityUnit.GramPerCubicMillimeter); } + /// /// Creates a from . /// @@ -630,6 +641,7 @@ public static Density FromGramsPerDeciLiter(double gramsperdeciliter) double value = (double) gramsperdeciliter; return new Density(value, DensityUnit.GramPerDeciliter); } + /// /// Creates a from . /// @@ -640,6 +652,7 @@ public static Density FromGramsPerLiter(double gramsperliter) double value = (double) gramsperliter; return new Density(value, DensityUnit.GramPerLiter); } + /// /// Creates a from . /// @@ -650,6 +663,7 @@ public static Density FromGramsPerMilliliter(double gramspermilliliter) double value = (double) gramspermilliliter; return new Density(value, DensityUnit.GramPerMilliliter); } + /// /// Creates a from . /// @@ -660,6 +674,7 @@ public static Density FromKilogramsPerCubicCentimeter(double kilogramspercubicce double value = (double) kilogramspercubiccentimeter; return new Density(value, DensityUnit.KilogramPerCubicCentimeter); } + /// /// Creates a from . /// @@ -670,6 +685,7 @@ public static Density FromKilogramsPerCubicMeter(double kilogramspercubicmeter) double value = (double) kilogramspercubicmeter; return new Density(value, DensityUnit.KilogramPerCubicMeter); } + /// /// Creates a from . /// @@ -680,6 +696,7 @@ public static Density FromKilogramsPerCubicMillimeter(double kilogramspercubicmi double value = (double) kilogramspercubicmillimeter; return new Density(value, DensityUnit.KilogramPerCubicMillimeter); } + /// /// Creates a from . /// @@ -690,6 +707,7 @@ public static Density FromKilogramsPerLiter(double kilogramsperliter) double value = (double) kilogramsperliter; return new Density(value, DensityUnit.KilogramPerLiter); } + /// /// Creates a from . /// @@ -700,6 +718,7 @@ public static Density FromKilopoundsPerCubicFoot(double kilopoundspercubicfoot) double value = (double) kilopoundspercubicfoot; return new Density(value, DensityUnit.KilopoundPerCubicFoot); } + /// /// Creates a from . /// @@ -710,6 +729,7 @@ public static Density FromKilopoundsPerCubicInch(double kilopoundspercubicinch) double value = (double) kilopoundspercubicinch; return new Density(value, DensityUnit.KilopoundPerCubicInch); } + /// /// Creates a from . /// @@ -720,6 +740,7 @@ public static Density FromMicrogramsPerCubicMeter(double microgramspercubicmeter double value = (double) microgramspercubicmeter; return new Density(value, DensityUnit.MicrogramPerCubicMeter); } + /// /// Creates a from . /// @@ -730,6 +751,7 @@ public static Density FromMicrogramsPerDeciLiter(double microgramsperdeciliter) double value = (double) microgramsperdeciliter; return new Density(value, DensityUnit.MicrogramPerDeciliter); } + /// /// Creates a from . /// @@ -740,6 +762,7 @@ public static Density FromMicrogramsPerLiter(double microgramsperliter) double value = (double) microgramsperliter; return new Density(value, DensityUnit.MicrogramPerLiter); } + /// /// Creates a from . /// @@ -750,6 +773,7 @@ public static Density FromMicrogramsPerMilliliter(double microgramspermilliliter double value = (double) microgramspermilliliter; return new Density(value, DensityUnit.MicrogramPerMilliliter); } + /// /// Creates a from . /// @@ -760,6 +784,7 @@ public static Density FromMilligramsPerCubicMeter(double milligramspercubicmeter double value = (double) milligramspercubicmeter; return new Density(value, DensityUnit.MilligramPerCubicMeter); } + /// /// Creates a from . /// @@ -770,6 +795,7 @@ public static Density FromMilligramsPerDeciLiter(double milligramsperdeciliter) double value = (double) milligramsperdeciliter; return new Density(value, DensityUnit.MilligramPerDeciliter); } + /// /// Creates a from . /// @@ -780,6 +806,7 @@ public static Density FromMilligramsPerLiter(double milligramsperliter) double value = (double) milligramsperliter; return new Density(value, DensityUnit.MilligramPerLiter); } + /// /// Creates a from . /// @@ -790,6 +817,7 @@ public static Density FromMilligramsPerMilliliter(double milligramspermilliliter double value = (double) milligramspermilliliter; return new Density(value, DensityUnit.MilligramPerMilliliter); } + /// /// Creates a from . /// @@ -800,6 +828,7 @@ public static Density FromNanogramsPerDeciLiter(double nanogramsperdeciliter) double value = (double) nanogramsperdeciliter; return new Density(value, DensityUnit.NanogramPerDeciliter); } + /// /// Creates a from . /// @@ -810,6 +839,7 @@ public static Density FromNanogramsPerLiter(double nanogramsperliter) double value = (double) nanogramsperliter; return new Density(value, DensityUnit.NanogramPerLiter); } + /// /// Creates a from . /// @@ -820,6 +850,7 @@ public static Density FromNanogramsPerMilliliter(double nanogramspermilliliter) double value = (double) nanogramspermilliliter; return new Density(value, DensityUnit.NanogramPerMilliliter); } + /// /// Creates a from . /// @@ -830,6 +861,7 @@ public static Density FromPicogramsPerDeciLiter(double picogramsperdeciliter) double value = (double) picogramsperdeciliter; return new Density(value, DensityUnit.PicogramPerDeciliter); } + /// /// Creates a from . /// @@ -840,6 +872,7 @@ public static Density FromPicogramsPerLiter(double picogramsperliter) double value = (double) picogramsperliter; return new Density(value, DensityUnit.PicogramPerLiter); } + /// /// Creates a from . /// @@ -850,6 +883,7 @@ public static Density FromPicogramsPerMilliliter(double picogramspermilliliter) double value = (double) picogramspermilliliter; return new Density(value, DensityUnit.PicogramPerMilliliter); } + /// /// Creates a from . /// @@ -860,6 +894,7 @@ public static Density FromPoundsPerCubicCentimeter(double poundspercubiccentimet double value = (double) poundspercubiccentimeter; return new Density(value, DensityUnit.PoundPerCubicCentimeter); } + /// /// Creates a from . /// @@ -870,6 +905,7 @@ public static Density FromPoundsPerCubicFoot(double poundspercubicfoot) double value = (double) poundspercubicfoot; return new Density(value, DensityUnit.PoundPerCubicFoot); } + /// /// Creates a from . /// @@ -880,6 +916,7 @@ public static Density FromPoundsPerCubicInch(double poundspercubicinch) double value = (double) poundspercubicinch; return new Density(value, DensityUnit.PoundPerCubicInch); } + /// /// Creates a from . /// @@ -890,6 +927,7 @@ public static Density FromPoundsPerCubicMeter(double poundspercubicmeter) double value = (double) poundspercubicmeter; return new Density(value, DensityUnit.PoundPerCubicMeter); } + /// /// Creates a from . /// @@ -900,6 +938,7 @@ public static Density FromPoundsPerCubicMillimeter(double poundspercubicmillimet double value = (double) poundspercubicmillimeter; return new Density(value, DensityUnit.PoundPerCubicMillimeter); } + /// /// Creates a from . /// @@ -910,6 +949,7 @@ public static Density FromPoundsPerImperialGallon(double poundsperimperialgallon double value = (double) poundsperimperialgallon; return new Density(value, DensityUnit.PoundPerImperialGallon); } + /// /// Creates a from . /// @@ -920,6 +960,7 @@ public static Density FromPoundsPerUSGallon(double poundsperusgallon) double value = (double) poundsperusgallon; return new Density(value, DensityUnit.PoundPerUSGallon); } + /// /// Creates a from . /// @@ -930,6 +971,7 @@ public static Density FromSlugsPerCubicCentimeter(double slugspercubiccentimeter double value = (double) slugspercubiccentimeter; return new Density(value, DensityUnit.SlugPerCubicCentimeter); } + /// /// Creates a from . /// @@ -940,6 +982,7 @@ public static Density FromSlugsPerCubicFoot(double slugspercubicfoot) double value = (double) slugspercubicfoot; return new Density(value, DensityUnit.SlugPerCubicFoot); } + /// /// Creates a from . /// @@ -950,6 +993,7 @@ public static Density FromSlugsPerCubicInch(double slugspercubicinch) double value = (double) slugspercubicinch; return new Density(value, DensityUnit.SlugPerCubicInch); } + /// /// Creates a from . /// @@ -960,6 +1004,7 @@ public static Density FromSlugsPerCubicMeter(double slugspercubicmeter) double value = (double) slugspercubicmeter; return new Density(value, DensityUnit.SlugPerCubicMeter); } + /// /// Creates a from . /// @@ -970,6 +1015,7 @@ public static Density FromSlugsPerCubicMillimeter(double slugspercubicmillimeter double value = (double) slugspercubicmillimeter; return new Density(value, DensityUnit.SlugPerCubicMillimeter); } + /// /// Creates a from . /// @@ -980,6 +1026,7 @@ public static Density FromTonnesPerCubicCentimeter(double tonnespercubiccentimet double value = (double) tonnespercubiccentimeter; return new Density(value, DensityUnit.TonnePerCubicCentimeter); } + /// /// Creates a from . /// @@ -990,6 +1037,7 @@ public static Density FromTonnesPerCubicFoot(double tonnespercubicfoot) double value = (double) tonnespercubicfoot; return new Density(value, DensityUnit.TonnePerCubicFoot); } + /// /// Creates a from . /// @@ -1000,6 +1048,7 @@ public static Density FromTonnesPerCubicInch(double tonnespercubicinch) double value = (double) tonnespercubicinch; return new Density(value, DensityUnit.TonnePerCubicInch); } + /// /// Creates a from . /// @@ -1010,6 +1059,7 @@ public static Density FromTonnesPerCubicMeter(double tonnespercubicmeter) double value = (double) tonnespercubicmeter; return new Density(value, DensityUnit.TonnePerCubicMeter); } + /// /// Creates a from . /// @@ -1021,6 +1071,7 @@ public static Density FromTonnesPerCubicMillimeter(double tonnespercubicmillimet return new Density(value, DensityUnit.TonnePerCubicMillimeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Duration.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Duration.g.cs index c23a7b1a38..820f70d6d9 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Duration.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Duration.g.cs @@ -283,6 +283,7 @@ public static Duration FromDays(double days) double value = (double) days; return new Duration(value, DurationUnit.Day); } + /// /// Creates a from . /// @@ -293,6 +294,7 @@ public static Duration FromHours(double hours) double value = (double) hours; return new Duration(value, DurationUnit.Hour); } + /// /// Creates a from . /// @@ -303,6 +305,7 @@ public static Duration FromJulianYears(double julianyears) double value = (double) julianyears; return new Duration(value, DurationUnit.JulianYear); } + /// /// Creates a from . /// @@ -313,6 +316,7 @@ public static Duration FromMicroseconds(double microseconds) double value = (double) microseconds; return new Duration(value, DurationUnit.Microsecond); } + /// /// Creates a from . /// @@ -323,6 +327,7 @@ public static Duration FromMilliseconds(double milliseconds) double value = (double) milliseconds; return new Duration(value, DurationUnit.Millisecond); } + /// /// Creates a from . /// @@ -333,6 +338,7 @@ public static Duration FromMinutes(double minutes) double value = (double) minutes; return new Duration(value, DurationUnit.Minute); } + /// /// Creates a from . /// @@ -343,6 +349,7 @@ public static Duration FromMonths30(double months30) double value = (double) months30; return new Duration(value, DurationUnit.Month30); } + /// /// Creates a from . /// @@ -353,6 +360,7 @@ public static Duration FromNanoseconds(double nanoseconds) double value = (double) nanoseconds; return new Duration(value, DurationUnit.Nanosecond); } + /// /// Creates a from . /// @@ -363,6 +371,7 @@ public static Duration FromSeconds(double seconds) double value = (double) seconds; return new Duration(value, DurationUnit.Second); } + /// /// Creates a from . /// @@ -373,6 +382,7 @@ public static Duration FromWeeks(double weeks) double value = (double) weeks; return new Duration(value, DurationUnit.Week); } + /// /// Creates a from . /// @@ -384,6 +394,7 @@ public static Duration FromYears365(double years365) return new Duration(value, DurationUnit.Year365); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/DynamicViscosity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/DynamicViscosity.g.cs index fb43601ea7..1f5a7ecfe7 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/DynamicViscosity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/DynamicViscosity.g.cs @@ -270,6 +270,7 @@ public static DynamicViscosity FromCentipoise(double centipoise) double value = (double) centipoise; return new DynamicViscosity(value, DynamicViscosityUnit.Centipoise); } + /// /// Creates a from . /// @@ -280,6 +281,7 @@ public static DynamicViscosity FromMicropascalSeconds(double micropascalseconds) double value = (double) micropascalseconds; return new DynamicViscosity(value, DynamicViscosityUnit.MicropascalSecond); } + /// /// Creates a from . /// @@ -290,6 +292,7 @@ public static DynamicViscosity FromMillipascalSeconds(double millipascalseconds) double value = (double) millipascalseconds; return new DynamicViscosity(value, DynamicViscosityUnit.MillipascalSecond); } + /// /// Creates a from . /// @@ -300,6 +303,7 @@ public static DynamicViscosity FromNewtonSecondsPerMeterSquared(double newtonsec double value = (double) newtonsecondspermetersquared; return new DynamicViscosity(value, DynamicViscosityUnit.NewtonSecondPerMeterSquared); } + /// /// Creates a from . /// @@ -310,6 +314,7 @@ public static DynamicViscosity FromPascalSeconds(double pascalseconds) double value = (double) pascalseconds; return new DynamicViscosity(value, DynamicViscosityUnit.PascalSecond); } + /// /// Creates a from . /// @@ -320,6 +325,7 @@ public static DynamicViscosity FromPoise(double poise) double value = (double) poise; return new DynamicViscosity(value, DynamicViscosityUnit.Poise); } + /// /// Creates a from . /// @@ -330,6 +336,7 @@ public static DynamicViscosity FromPoundsForceSecondPerSquareFoot(double poundsf double value = (double) poundsforcesecondpersquarefoot; return new DynamicViscosity(value, DynamicViscosityUnit.PoundForceSecondPerSquareFoot); } + /// /// Creates a from . /// @@ -340,6 +347,7 @@ public static DynamicViscosity FromPoundsForceSecondPerSquareInch(double poundsf double value = (double) poundsforcesecondpersquareinch; return new DynamicViscosity(value, DynamicViscosityUnit.PoundForceSecondPerSquareInch); } + /// /// Creates a from . /// @@ -350,6 +358,7 @@ public static DynamicViscosity FromPoundsPerFootSecond(double poundsperfootsecon double value = (double) poundsperfootsecond; return new DynamicViscosity(value, DynamicViscosityUnit.PoundPerFootSecond); } + /// /// Creates a from . /// @@ -361,6 +370,7 @@ public static DynamicViscosity FromReyns(double reyns) return new DynamicViscosity(value, DynamicViscosityUnit.Reyn); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricAdmittance.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricAdmittance.g.cs index 68a8f88624..edbf25ae11 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricAdmittance.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricAdmittance.g.cs @@ -231,6 +231,7 @@ public static ElectricAdmittance FromMicrosiemens(double microsiemens) double value = (double) microsiemens; return new ElectricAdmittance(value, ElectricAdmittanceUnit.Microsiemens); } + /// /// Creates a from . /// @@ -241,6 +242,7 @@ public static ElectricAdmittance FromMillisiemens(double millisiemens) double value = (double) millisiemens; return new ElectricAdmittance(value, ElectricAdmittanceUnit.Millisiemens); } + /// /// Creates a from . /// @@ -251,6 +253,7 @@ public static ElectricAdmittance FromNanosiemens(double nanosiemens) double value = (double) nanosiemens; return new ElectricAdmittance(value, ElectricAdmittanceUnit.Nanosiemens); } + /// /// Creates a from . /// @@ -262,6 +265,7 @@ public static ElectricAdmittance FromSiemens(double siemens) return new ElectricAdmittance(value, ElectricAdmittanceUnit.Siemens); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCharge.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCharge.g.cs index fc9f82ea58..742e8f23a4 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCharge.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCharge.g.cs @@ -240,6 +240,7 @@ public static ElectricCharge FromAmpereHours(double amperehours) double value = (double) amperehours; return new ElectricCharge(value, ElectricChargeUnit.AmpereHour); } + /// /// Creates a from . /// @@ -250,6 +251,7 @@ public static ElectricCharge FromCoulombs(double coulombs) double value = (double) coulombs; return new ElectricCharge(value, ElectricChargeUnit.Coulomb); } + /// /// Creates a from . /// @@ -260,6 +262,7 @@ public static ElectricCharge FromKiloampereHours(double kiloamperehours) double value = (double) kiloamperehours; return new ElectricCharge(value, ElectricChargeUnit.KiloampereHour); } + /// /// Creates a from . /// @@ -270,6 +273,7 @@ public static ElectricCharge FromMegaampereHours(double megaamperehours) double value = (double) megaamperehours; return new ElectricCharge(value, ElectricChargeUnit.MegaampereHour); } + /// /// Creates a from . /// @@ -281,6 +285,7 @@ public static ElectricCharge FromMilliampereHours(double milliamperehours) return new ElectricCharge(value, ElectricChargeUnit.MilliampereHour); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricChargeDensity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricChargeDensity.g.cs index 8b4670fdd3..04b9293e53 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricChargeDensity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricChargeDensity.g.cs @@ -217,6 +217,7 @@ public static ElectricChargeDensity FromCoulombsPerCubicMeter(double coulombsper return new ElectricChargeDensity(value, ElectricChargeDensityUnit.CoulombPerCubicMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductance.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductance.g.cs index 3183a2dfbc..4695073a1f 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductance.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductance.g.cs @@ -228,6 +228,7 @@ public static ElectricConductance FromMicrosiemens(double microsiemens) double value = (double) microsiemens; return new ElectricConductance(value, ElectricConductanceUnit.Microsiemens); } + /// /// Creates a from . /// @@ -238,6 +239,7 @@ public static ElectricConductance FromMillisiemens(double millisiemens) double value = (double) millisiemens; return new ElectricConductance(value, ElectricConductanceUnit.Millisiemens); } + /// /// Creates a from . /// @@ -249,6 +251,7 @@ public static ElectricConductance FromSiemens(double siemens) return new ElectricConductance(value, ElectricConductanceUnit.Siemens); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductivity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductivity.g.cs index 1acc1f154f..9fbe04a9eb 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductivity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductivity.g.cs @@ -228,6 +228,7 @@ public static ElectricConductivity FromSiemensPerFoot(double siemensperfoot) double value = (double) siemensperfoot; return new ElectricConductivity(value, ElectricConductivityUnit.SiemensPerFoot); } + /// /// Creates a from . /// @@ -238,6 +239,7 @@ public static ElectricConductivity FromSiemensPerInch(double siemensperinch) double value = (double) siemensperinch; return new ElectricConductivity(value, ElectricConductivityUnit.SiemensPerInch); } + /// /// Creates a from . /// @@ -249,6 +251,7 @@ public static ElectricConductivity FromSiemensPerMeter(double siemenspermeter) return new ElectricConductivity(value, ElectricConductivityUnit.SiemensPerMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrent.g.cs index 8e45e39943..03a6add850 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrent.g.cs @@ -255,6 +255,7 @@ public static ElectricCurrent FromAmperes(double amperes) double value = (double) amperes; return new ElectricCurrent(value, ElectricCurrentUnit.Ampere); } + /// /// Creates a from . /// @@ -265,6 +266,7 @@ public static ElectricCurrent FromCentiamperes(double centiamperes) double value = (double) centiamperes; return new ElectricCurrent(value, ElectricCurrentUnit.Centiampere); } + /// /// Creates a from . /// @@ -275,6 +277,7 @@ public static ElectricCurrent FromKiloamperes(double kiloamperes) double value = (double) kiloamperes; return new ElectricCurrent(value, ElectricCurrentUnit.Kiloampere); } + /// /// Creates a from . /// @@ -285,6 +288,7 @@ public static ElectricCurrent FromMegaamperes(double megaamperes) double value = (double) megaamperes; return new ElectricCurrent(value, ElectricCurrentUnit.Megaampere); } + /// /// Creates a from . /// @@ -295,6 +299,7 @@ public static ElectricCurrent FromMicroamperes(double microamperes) double value = (double) microamperes; return new ElectricCurrent(value, ElectricCurrentUnit.Microampere); } + /// /// Creates a from . /// @@ -305,6 +310,7 @@ public static ElectricCurrent FromMilliamperes(double milliamperes) double value = (double) milliamperes; return new ElectricCurrent(value, ElectricCurrentUnit.Milliampere); } + /// /// Creates a from . /// @@ -315,6 +321,7 @@ public static ElectricCurrent FromNanoamperes(double nanoamperes) double value = (double) nanoamperes; return new ElectricCurrent(value, ElectricCurrentUnit.Nanoampere); } + /// /// Creates a from . /// @@ -326,6 +333,7 @@ public static ElectricCurrent FromPicoamperes(double picoamperes) return new ElectricCurrent(value, ElectricCurrentUnit.Picoampere); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs index 45cbe10f5c..27273642a4 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs @@ -228,6 +228,7 @@ public static ElectricCurrentDensity FromAmperesPerSquareFoot(double amperespers double value = (double) amperespersquarefoot; return new ElectricCurrentDensity(value, ElectricCurrentDensityUnit.AmperePerSquareFoot); } + /// /// Creates a from . /// @@ -238,6 +239,7 @@ public static ElectricCurrentDensity FromAmperesPerSquareInch(double amperespers double value = (double) amperespersquareinch; return new ElectricCurrentDensity(value, ElectricCurrentDensityUnit.AmperePerSquareInch); } + /// /// Creates a from . /// @@ -249,6 +251,7 @@ public static ElectricCurrentDensity FromAmperesPerSquareMeter(double amperesper return new ElectricCurrentDensity(value, ElectricCurrentDensityUnit.AmperePerSquareMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs index b3994c9871..c23dff3488 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs @@ -231,6 +231,7 @@ public static ElectricCurrentGradient FromAmperesPerMicrosecond(double amperespe double value = (double) amperespermicrosecond; return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerMicrosecond); } + /// /// Creates a from . /// @@ -241,6 +242,7 @@ public static ElectricCurrentGradient FromAmperesPerMillisecond(double amperespe double value = (double) amperespermillisecond; return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerMillisecond); } + /// /// Creates a from . /// @@ -251,6 +253,7 @@ public static ElectricCurrentGradient FromAmperesPerNanosecond(double amperesper double value = (double) amperespernanosecond; return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerNanosecond); } + /// /// Creates a from . /// @@ -262,6 +265,7 @@ public static ElectricCurrentGradient FromAmperesPerSecond(double amperesperseco return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerSecond); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricField.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricField.g.cs index dea86a3a4d..80bd9a3bb9 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricField.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricField.g.cs @@ -217,6 +217,7 @@ public static ElectricField FromVoltsPerMeter(double voltspermeter) return new ElectricField(value, ElectricFieldUnit.VoltPerMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricInductance.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricInductance.g.cs index 17e9ab80ba..268cc0598c 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricInductance.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricInductance.g.cs @@ -234,6 +234,7 @@ public static ElectricInductance FromHenries(double henries) double value = (double) henries; return new ElectricInductance(value, ElectricInductanceUnit.Henry); } + /// /// Creates a from . /// @@ -244,6 +245,7 @@ public static ElectricInductance FromMicrohenries(double microhenries) double value = (double) microhenries; return new ElectricInductance(value, ElectricInductanceUnit.Microhenry); } + /// /// Creates a from . /// @@ -254,6 +256,7 @@ public static ElectricInductance FromMillihenries(double millihenries) double value = (double) millihenries; return new ElectricInductance(value, ElectricInductanceUnit.Millihenry); } + /// /// Creates a from . /// @@ -265,6 +268,7 @@ public static ElectricInductance FromNanohenries(double nanohenries) return new ElectricInductance(value, ElectricInductanceUnit.Nanohenry); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotential.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotential.g.cs index d861a6dd04..41104879ef 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotential.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotential.g.cs @@ -242,6 +242,7 @@ public static ElectricPotential FromKilovolts(double kilovolts) double value = (double) kilovolts; return new ElectricPotential(value, ElectricPotentialUnit.Kilovolt); } + /// /// Creates a from . /// @@ -252,6 +253,7 @@ public static ElectricPotential FromMegavolts(double megavolts) double value = (double) megavolts; return new ElectricPotential(value, ElectricPotentialUnit.Megavolt); } + /// /// Creates a from . /// @@ -262,6 +264,7 @@ public static ElectricPotential FromMicrovolts(double microvolts) double value = (double) microvolts; return new ElectricPotential(value, ElectricPotentialUnit.Microvolt); } + /// /// Creates a from . /// @@ -272,6 +275,7 @@ public static ElectricPotential FromMillivolts(double millivolts) double value = (double) millivolts; return new ElectricPotential(value, ElectricPotentialUnit.Millivolt); } + /// /// Creates a from . /// @@ -283,6 +287,7 @@ public static ElectricPotential FromVolts(double volts) return new ElectricPotential(value, ElectricPotentialUnit.Volt); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialAc.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialAc.g.cs index e27bb22c6d..4c110e1ccf 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialAc.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialAc.g.cs @@ -237,6 +237,7 @@ public static ElectricPotentialAc FromKilovoltsAc(double kilovoltsac) double value = (double) kilovoltsac; return new ElectricPotentialAc(value, ElectricPotentialAcUnit.KilovoltAc); } + /// /// Creates a from . /// @@ -247,6 +248,7 @@ public static ElectricPotentialAc FromMegavoltsAc(double megavoltsac) double value = (double) megavoltsac; return new ElectricPotentialAc(value, ElectricPotentialAcUnit.MegavoltAc); } + /// /// Creates a from . /// @@ -257,6 +259,7 @@ public static ElectricPotentialAc FromMicrovoltsAc(double microvoltsac) double value = (double) microvoltsac; return new ElectricPotentialAc(value, ElectricPotentialAcUnit.MicrovoltAc); } + /// /// Creates a from . /// @@ -267,6 +270,7 @@ public static ElectricPotentialAc FromMillivoltsAc(double millivoltsac) double value = (double) millivoltsac; return new ElectricPotentialAc(value, ElectricPotentialAcUnit.MillivoltAc); } + /// /// Creates a from . /// @@ -278,6 +282,7 @@ public static ElectricPotentialAc FromVoltsAc(double voltsac) return new ElectricPotentialAc(value, ElectricPotentialAcUnit.VoltAc); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs index 8007d38ce2..0af5c5e8c2 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs @@ -327,6 +327,7 @@ public static ElectricPotentialChangeRate FromKilovoltsPerHours(double kilovolts double value = (double) kilovoltsperhours; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerHour); } + /// /// Creates a from . /// @@ -337,6 +338,7 @@ public static ElectricPotentialChangeRate FromKilovoltsPerMicroseconds(double ki double value = (double) kilovoltspermicroseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond); } + /// /// Creates a from . /// @@ -347,6 +349,7 @@ public static ElectricPotentialChangeRate FromKilovoltsPerMinutes(double kilovol double value = (double) kilovoltsperminutes; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerMinute); } + /// /// Creates a from . /// @@ -357,6 +360,7 @@ public static ElectricPotentialChangeRate FromKilovoltsPerSeconds(double kilovol double value = (double) kilovoltsperseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerSecond); } + /// /// Creates a from . /// @@ -367,6 +371,7 @@ public static ElectricPotentialChangeRate FromMegavoltsPerHours(double megavolts double value = (double) megavoltsperhours; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerHour); } + /// /// Creates a from . /// @@ -377,6 +382,7 @@ public static ElectricPotentialChangeRate FromMegavoltsPerMicroseconds(double me double value = (double) megavoltspermicroseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond); } + /// /// Creates a from . /// @@ -387,6 +393,7 @@ public static ElectricPotentialChangeRate FromMegavoltsPerMinutes(double megavol double value = (double) megavoltsperminutes; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerMinute); } + /// /// Creates a from . /// @@ -397,6 +404,7 @@ public static ElectricPotentialChangeRate FromMegavoltsPerSeconds(double megavol double value = (double) megavoltsperseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerSecond); } + /// /// Creates a from . /// @@ -407,6 +415,7 @@ public static ElectricPotentialChangeRate FromMicrovoltsPerHours(double microvol double value = (double) microvoltsperhours; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerHour); } + /// /// Creates a from . /// @@ -417,6 +426,7 @@ public static ElectricPotentialChangeRate FromMicrovoltsPerMicroseconds(double m double value = (double) microvoltspermicroseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond); } + /// /// Creates a from . /// @@ -427,6 +437,7 @@ public static ElectricPotentialChangeRate FromMicrovoltsPerMinutes(double microv double value = (double) microvoltsperminutes; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerMinute); } + /// /// Creates a from . /// @@ -437,6 +448,7 @@ public static ElectricPotentialChangeRate FromMicrovoltsPerSeconds(double microv double value = (double) microvoltsperseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerSecond); } + /// /// Creates a from . /// @@ -447,6 +459,7 @@ public static ElectricPotentialChangeRate FromMillivoltsPerHours(double millivol double value = (double) millivoltsperhours; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerHour); } + /// /// Creates a from . /// @@ -457,6 +470,7 @@ public static ElectricPotentialChangeRate FromMillivoltsPerMicroseconds(double m double value = (double) millivoltspermicroseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond); } + /// /// Creates a from . /// @@ -467,6 +481,7 @@ public static ElectricPotentialChangeRate FromMillivoltsPerMinutes(double milliv double value = (double) millivoltsperminutes; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerMinute); } + /// /// Creates a from . /// @@ -477,6 +492,7 @@ public static ElectricPotentialChangeRate FromMillivoltsPerSeconds(double milliv double value = (double) millivoltsperseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerSecond); } + /// /// Creates a from . /// @@ -487,6 +503,7 @@ public static ElectricPotentialChangeRate FromVoltsPerHours(double voltsperhours double value = (double) voltsperhours; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerHour); } + /// /// Creates a from . /// @@ -497,6 +514,7 @@ public static ElectricPotentialChangeRate FromVoltsPerMicroseconds(double voltsp double value = (double) voltspermicroseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerMicrosecond); } + /// /// Creates a from . /// @@ -507,6 +525,7 @@ public static ElectricPotentialChangeRate FromVoltsPerMinutes(double voltspermin double value = (double) voltsperminutes; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerMinute); } + /// /// Creates a from . /// @@ -518,6 +537,7 @@ public static ElectricPotentialChangeRate FromVoltsPerSeconds(double voltspersec return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerSecond); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialDc.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialDc.g.cs index 573a2f3746..f49a0f461f 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialDc.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialDc.g.cs @@ -237,6 +237,7 @@ public static ElectricPotentialDc FromKilovoltsDc(double kilovoltsdc) double value = (double) kilovoltsdc; return new ElectricPotentialDc(value, ElectricPotentialDcUnit.KilovoltDc); } + /// /// Creates a from . /// @@ -247,6 +248,7 @@ public static ElectricPotentialDc FromMegavoltsDc(double megavoltsdc) double value = (double) megavoltsdc; return new ElectricPotentialDc(value, ElectricPotentialDcUnit.MegavoltDc); } + /// /// Creates a from . /// @@ -257,6 +259,7 @@ public static ElectricPotentialDc FromMicrovoltsDc(double microvoltsdc) double value = (double) microvoltsdc; return new ElectricPotentialDc(value, ElectricPotentialDcUnit.MicrovoltDc); } + /// /// Creates a from . /// @@ -267,6 +270,7 @@ public static ElectricPotentialDc FromMillivoltsDc(double millivoltsdc) double value = (double) millivoltsdc; return new ElectricPotentialDc(value, ElectricPotentialDcUnit.MillivoltDc); } + /// /// Creates a from . /// @@ -278,6 +282,7 @@ public static ElectricPotentialDc FromVoltsDc(double voltsdc) return new ElectricPotentialDc(value, ElectricPotentialDcUnit.VoltDc); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistance.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistance.g.cs index 1d1c5da49e..c34ced318f 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistance.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistance.g.cs @@ -243,6 +243,7 @@ public static ElectricResistance FromGigaohms(double gigaohms) double value = (double) gigaohms; return new ElectricResistance(value, ElectricResistanceUnit.Gigaohm); } + /// /// Creates a from . /// @@ -253,6 +254,7 @@ public static ElectricResistance FromKiloohms(double kiloohms) double value = (double) kiloohms; return new ElectricResistance(value, ElectricResistanceUnit.Kiloohm); } + /// /// Creates a from . /// @@ -263,6 +265,7 @@ public static ElectricResistance FromMegaohms(double megaohms) double value = (double) megaohms; return new ElectricResistance(value, ElectricResistanceUnit.Megaohm); } + /// /// Creates a from . /// @@ -273,6 +276,7 @@ public static ElectricResistance FromMicroohms(double microohms) double value = (double) microohms; return new ElectricResistance(value, ElectricResistanceUnit.Microohm); } + /// /// Creates a from . /// @@ -283,6 +287,7 @@ public static ElectricResistance FromMilliohms(double milliohms) double value = (double) milliohms; return new ElectricResistance(value, ElectricResistanceUnit.Milliohm); } + /// /// Creates a from . /// @@ -294,6 +299,7 @@ public static ElectricResistance FromOhms(double ohms) return new ElectricResistance(value, ElectricResistanceUnit.Ohm); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistivity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistivity.g.cs index 6d5a219cd2..2c37dae554 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistivity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistivity.g.cs @@ -294,6 +294,7 @@ public static ElectricResistivity FromKiloohmsCentimeter(double kiloohmscentimet double value = (double) kiloohmscentimeter; return new ElectricResistivity(value, ElectricResistivityUnit.KiloohmCentimeter); } + /// /// Creates a from . /// @@ -304,6 +305,7 @@ public static ElectricResistivity FromKiloohmMeters(double kiloohmmeters) double value = (double) kiloohmmeters; return new ElectricResistivity(value, ElectricResistivityUnit.KiloohmMeter); } + /// /// Creates a from . /// @@ -314,6 +316,7 @@ public static ElectricResistivity FromMegaohmsCentimeter(double megaohmscentimet double value = (double) megaohmscentimeter; return new ElectricResistivity(value, ElectricResistivityUnit.MegaohmCentimeter); } + /// /// Creates a from . /// @@ -324,6 +327,7 @@ public static ElectricResistivity FromMegaohmMeters(double megaohmmeters) double value = (double) megaohmmeters; return new ElectricResistivity(value, ElectricResistivityUnit.MegaohmMeter); } + /// /// Creates a from . /// @@ -334,6 +338,7 @@ public static ElectricResistivity FromMicroohmsCentimeter(double microohmscentim double value = (double) microohmscentimeter; return new ElectricResistivity(value, ElectricResistivityUnit.MicroohmCentimeter); } + /// /// Creates a from . /// @@ -344,6 +349,7 @@ public static ElectricResistivity FromMicroohmMeters(double microohmmeters) double value = (double) microohmmeters; return new ElectricResistivity(value, ElectricResistivityUnit.MicroohmMeter); } + /// /// Creates a from . /// @@ -354,6 +360,7 @@ public static ElectricResistivity FromMilliohmsCentimeter(double milliohmscentim double value = (double) milliohmscentimeter; return new ElectricResistivity(value, ElectricResistivityUnit.MilliohmCentimeter); } + /// /// Creates a from . /// @@ -364,6 +371,7 @@ public static ElectricResistivity FromMilliohmMeters(double milliohmmeters) double value = (double) milliohmmeters; return new ElectricResistivity(value, ElectricResistivityUnit.MilliohmMeter); } + /// /// Creates a from . /// @@ -374,6 +382,7 @@ public static ElectricResistivity FromNanoohmsCentimeter(double nanoohmscentimet double value = (double) nanoohmscentimeter; return new ElectricResistivity(value, ElectricResistivityUnit.NanoohmCentimeter); } + /// /// Creates a from . /// @@ -384,6 +393,7 @@ public static ElectricResistivity FromNanoohmMeters(double nanoohmmeters) double value = (double) nanoohmmeters; return new ElectricResistivity(value, ElectricResistivityUnit.NanoohmMeter); } + /// /// Creates a from . /// @@ -394,6 +404,7 @@ public static ElectricResistivity FromOhmsCentimeter(double ohmscentimeter) double value = (double) ohmscentimeter; return new ElectricResistivity(value, ElectricResistivityUnit.OhmCentimeter); } + /// /// Creates a from . /// @@ -404,6 +415,7 @@ public static ElectricResistivity FromOhmMeters(double ohmmeters) double value = (double) ohmmeters; return new ElectricResistivity(value, ElectricResistivityUnit.OhmMeter); } + /// /// Creates a from . /// @@ -414,6 +426,7 @@ public static ElectricResistivity FromPicoohmsCentimeter(double picoohmscentimet double value = (double) picoohmscentimeter; return new ElectricResistivity(value, ElectricResistivityUnit.PicoohmCentimeter); } + /// /// Creates a from . /// @@ -425,6 +438,7 @@ public static ElectricResistivity FromPicoohmMeters(double picoohmmeters) return new ElectricResistivity(value, ElectricResistivityUnit.PicoohmMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs index 11ce87b751..b029011347 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs @@ -228,6 +228,7 @@ public static ElectricSurfaceChargeDensity FromCoulombsPerSquareCentimeter(doubl double value = (double) coulombspersquarecentimeter; return new ElectricSurfaceChargeDensity(value, ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter); } + /// /// Creates a from . /// @@ -238,6 +239,7 @@ public static ElectricSurfaceChargeDensity FromCoulombsPerSquareInch(double coul double value = (double) coulombspersquareinch; return new ElectricSurfaceChargeDensity(value, ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch); } + /// /// Creates a from . /// @@ -249,6 +251,7 @@ public static ElectricSurfaceChargeDensity FromCoulombsPerSquareMeter(double cou return new ElectricSurfaceChargeDensity(value, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Energy.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Energy.g.cs index 9d0541830e..9d3878d86b 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Energy.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Energy.g.cs @@ -444,6 +444,7 @@ public static Energy FromBritishThermalUnits(double britishthermalunits) double value = (double) britishthermalunits; return new Energy(value, EnergyUnit.BritishThermalUnit); } + /// /// Creates a from . /// @@ -454,6 +455,7 @@ public static Energy FromCalories(double calories) double value = (double) calories; return new Energy(value, EnergyUnit.Calorie); } + /// /// Creates a from . /// @@ -464,6 +466,7 @@ public static Energy FromDecathermsEc(double decathermsec) double value = (double) decathermsec; return new Energy(value, EnergyUnit.DecathermEc); } + /// /// Creates a from . /// @@ -474,6 +477,7 @@ public static Energy FromDecathermsImperial(double decathermsimperial) double value = (double) decathermsimperial; return new Energy(value, EnergyUnit.DecathermImperial); } + /// /// Creates a from . /// @@ -484,6 +488,7 @@ public static Energy FromDecathermsUs(double decathermsus) double value = (double) decathermsus; return new Energy(value, EnergyUnit.DecathermUs); } + /// /// Creates a from . /// @@ -494,6 +499,7 @@ public static Energy FromElectronVolts(double electronvolts) double value = (double) electronvolts; return new Energy(value, EnergyUnit.ElectronVolt); } + /// /// Creates a from . /// @@ -504,6 +510,7 @@ public static Energy FromErgs(double ergs) double value = (double) ergs; return new Energy(value, EnergyUnit.Erg); } + /// /// Creates a from . /// @@ -514,6 +521,7 @@ public static Energy FromFootPounds(double footpounds) double value = (double) footpounds; return new Energy(value, EnergyUnit.FootPound); } + /// /// Creates a from . /// @@ -524,6 +532,7 @@ public static Energy FromGigabritishThermalUnits(double gigabritishthermalunits) double value = (double) gigabritishthermalunits; return new Energy(value, EnergyUnit.GigabritishThermalUnit); } + /// /// Creates a from . /// @@ -534,6 +543,7 @@ public static Energy FromGigaelectronVolts(double gigaelectronvolts) double value = (double) gigaelectronvolts; return new Energy(value, EnergyUnit.GigaelectronVolt); } + /// /// Creates a from . /// @@ -544,6 +554,7 @@ public static Energy FromGigajoules(double gigajoules) double value = (double) gigajoules; return new Energy(value, EnergyUnit.Gigajoule); } + /// /// Creates a from . /// @@ -554,6 +565,7 @@ public static Energy FromGigawattDays(double gigawattdays) double value = (double) gigawattdays; return new Energy(value, EnergyUnit.GigawattDay); } + /// /// Creates a from . /// @@ -564,6 +576,7 @@ public static Energy FromGigawattHours(double gigawatthours) double value = (double) gigawatthours; return new Energy(value, EnergyUnit.GigawattHour); } + /// /// Creates a from . /// @@ -574,6 +587,7 @@ public static Energy FromHorsepowerHours(double horsepowerhours) double value = (double) horsepowerhours; return new Energy(value, EnergyUnit.HorsepowerHour); } + /// /// Creates a from . /// @@ -584,6 +598,7 @@ public static Energy FromJoules(double joules) double value = (double) joules; return new Energy(value, EnergyUnit.Joule); } + /// /// Creates a from . /// @@ -594,6 +609,7 @@ public static Energy FromKilobritishThermalUnits(double kilobritishthermalunits) double value = (double) kilobritishthermalunits; return new Energy(value, EnergyUnit.KilobritishThermalUnit); } + /// /// Creates a from . /// @@ -604,6 +620,7 @@ public static Energy FromKilocalories(double kilocalories) double value = (double) kilocalories; return new Energy(value, EnergyUnit.Kilocalorie); } + /// /// Creates a from . /// @@ -614,6 +631,7 @@ public static Energy FromKiloelectronVolts(double kiloelectronvolts) double value = (double) kiloelectronvolts; return new Energy(value, EnergyUnit.KiloelectronVolt); } + /// /// Creates a from . /// @@ -624,6 +642,7 @@ public static Energy FromKilojoules(double kilojoules) double value = (double) kilojoules; return new Energy(value, EnergyUnit.Kilojoule); } + /// /// Creates a from . /// @@ -634,6 +653,7 @@ public static Energy FromKilowattDays(double kilowattdays) double value = (double) kilowattdays; return new Energy(value, EnergyUnit.KilowattDay); } + /// /// Creates a from . /// @@ -644,6 +664,7 @@ public static Energy FromKilowattHours(double kilowatthours) double value = (double) kilowatthours; return new Energy(value, EnergyUnit.KilowattHour); } + /// /// Creates a from . /// @@ -654,6 +675,7 @@ public static Energy FromMegabritishThermalUnits(double megabritishthermalunits) double value = (double) megabritishthermalunits; return new Energy(value, EnergyUnit.MegabritishThermalUnit); } + /// /// Creates a from . /// @@ -664,6 +686,7 @@ public static Energy FromMegacalories(double megacalories) double value = (double) megacalories; return new Energy(value, EnergyUnit.Megacalorie); } + /// /// Creates a from . /// @@ -674,6 +697,7 @@ public static Energy FromMegaelectronVolts(double megaelectronvolts) double value = (double) megaelectronvolts; return new Energy(value, EnergyUnit.MegaelectronVolt); } + /// /// Creates a from . /// @@ -684,6 +708,7 @@ public static Energy FromMegajoules(double megajoules) double value = (double) megajoules; return new Energy(value, EnergyUnit.Megajoule); } + /// /// Creates a from . /// @@ -694,6 +719,7 @@ public static Energy FromMegawattDays(double megawattdays) double value = (double) megawattdays; return new Energy(value, EnergyUnit.MegawattDay); } + /// /// Creates a from . /// @@ -704,6 +730,7 @@ public static Energy FromMegawattHours(double megawatthours) double value = (double) megawatthours; return new Energy(value, EnergyUnit.MegawattHour); } + /// /// Creates a from . /// @@ -714,6 +741,7 @@ public static Energy FromMillijoules(double millijoules) double value = (double) millijoules; return new Energy(value, EnergyUnit.Millijoule); } + /// /// Creates a from . /// @@ -724,6 +752,7 @@ public static Energy FromTeraelectronVolts(double teraelectronvolts) double value = (double) teraelectronvolts; return new Energy(value, EnergyUnit.TeraelectronVolt); } + /// /// Creates a from . /// @@ -734,6 +763,7 @@ public static Energy FromTerawattDays(double terawattdays) double value = (double) terawattdays; return new Energy(value, EnergyUnit.TerawattDay); } + /// /// Creates a from . /// @@ -744,6 +774,7 @@ public static Energy FromTerawattHours(double terawatthours) double value = (double) terawatthours; return new Energy(value, EnergyUnit.TerawattHour); } + /// /// Creates a from . /// @@ -754,6 +785,7 @@ public static Energy FromThermsEc(double thermsec) double value = (double) thermsec; return new Energy(value, EnergyUnit.ThermEc); } + /// /// Creates a from . /// @@ -764,6 +796,7 @@ public static Energy FromThermsImperial(double thermsimperial) double value = (double) thermsimperial; return new Energy(value, EnergyUnit.ThermImperial); } + /// /// Creates a from . /// @@ -774,6 +807,7 @@ public static Energy FromThermsUs(double thermsus) double value = (double) thermsus; return new Energy(value, EnergyUnit.ThermUs); } + /// /// Creates a from . /// @@ -784,6 +818,7 @@ public static Energy FromWattDays(double wattdays) double value = (double) wattdays; return new Energy(value, EnergyUnit.WattDay); } + /// /// Creates a from . /// @@ -795,6 +830,7 @@ public static Energy FromWattHours(double watthours) return new Energy(value, EnergyUnit.WattHour); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Entropy.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Entropy.g.cs index f8adc5ab09..5c7ac840c9 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Entropy.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Entropy.g.cs @@ -249,6 +249,7 @@ public static Entropy FromCaloriesPerKelvin(double caloriesperkelvin) double value = (double) caloriesperkelvin; return new Entropy(value, EntropyUnit.CaloriePerKelvin); } + /// /// Creates a from . /// @@ -259,6 +260,7 @@ public static Entropy FromJoulesPerDegreeCelsius(double joulesperdegreecelsius) double value = (double) joulesperdegreecelsius; return new Entropy(value, EntropyUnit.JoulePerDegreeCelsius); } + /// /// Creates a from . /// @@ -269,6 +271,7 @@ public static Entropy FromJoulesPerKelvin(double joulesperkelvin) double value = (double) joulesperkelvin; return new Entropy(value, EntropyUnit.JoulePerKelvin); } + /// /// Creates a from . /// @@ -279,6 +282,7 @@ public static Entropy FromKilocaloriesPerKelvin(double kilocaloriesperkelvin) double value = (double) kilocaloriesperkelvin; return new Entropy(value, EntropyUnit.KilocaloriePerKelvin); } + /// /// Creates a from . /// @@ -289,6 +293,7 @@ public static Entropy FromKilojoulesPerDegreeCelsius(double kilojoulesperdegreec double value = (double) kilojoulesperdegreecelsius; return new Entropy(value, EntropyUnit.KilojoulePerDegreeCelsius); } + /// /// Creates a from . /// @@ -299,6 +304,7 @@ public static Entropy FromKilojoulesPerKelvin(double kilojoulesperkelvin) double value = (double) kilojoulesperkelvin; return new Entropy(value, EntropyUnit.KilojoulePerKelvin); } + /// /// Creates a from . /// @@ -310,6 +316,7 @@ public static Entropy FromMegajoulesPerKelvin(double megajoulesperkelvin) return new Entropy(value, EntropyUnit.MegajoulePerKelvin); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.g.cs index 5d6c2c5dc3..13f5ded53c 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.g.cs @@ -310,6 +310,7 @@ public static Force FromDecanewtons(double decanewtons) double value = (double) decanewtons; return new Force(value, ForceUnit.Decanewton); } + /// /// Creates a from . /// @@ -320,6 +321,7 @@ public static Force FromDyne(double dyne) double value = (double) dyne; return new Force(value, ForceUnit.Dyn); } + /// /// Creates a from . /// @@ -330,6 +332,7 @@ public static Force FromKilogramsForce(double kilogramsforce) double value = (double) kilogramsforce; return new Force(value, ForceUnit.KilogramForce); } + /// /// Creates a from . /// @@ -340,6 +343,7 @@ public static Force FromKilonewtons(double kilonewtons) double value = (double) kilonewtons; return new Force(value, ForceUnit.Kilonewton); } + /// /// Creates a from . /// @@ -350,6 +354,7 @@ public static Force FromKiloPonds(double kiloponds) double value = (double) kiloponds; return new Force(value, ForceUnit.KiloPond); } + /// /// Creates a from . /// @@ -360,6 +365,7 @@ public static Force FromKilopoundsForce(double kilopoundsforce) double value = (double) kilopoundsforce; return new Force(value, ForceUnit.KilopoundForce); } + /// /// Creates a from . /// @@ -370,6 +376,7 @@ public static Force FromMeganewtons(double meganewtons) double value = (double) meganewtons; return new Force(value, ForceUnit.Meganewton); } + /// /// Creates a from . /// @@ -380,6 +387,7 @@ public static Force FromMicronewtons(double micronewtons) double value = (double) micronewtons; return new Force(value, ForceUnit.Micronewton); } + /// /// Creates a from . /// @@ -390,6 +398,7 @@ public static Force FromMillinewtons(double millinewtons) double value = (double) millinewtons; return new Force(value, ForceUnit.Millinewton); } + /// /// Creates a from . /// @@ -400,6 +409,7 @@ public static Force FromNewtons(double newtons) double value = (double) newtons; return new Force(value, ForceUnit.Newton); } + /// /// Creates a from . /// @@ -410,6 +420,7 @@ public static Force FromOunceForce(double ounceforce) double value = (double) ounceforce; return new Force(value, ForceUnit.OunceForce); } + /// /// Creates a from . /// @@ -420,6 +431,7 @@ public static Force FromPoundals(double poundals) double value = (double) poundals; return new Force(value, ForceUnit.Poundal); } + /// /// Creates a from . /// @@ -430,6 +442,7 @@ public static Force FromPoundsForce(double poundsforce) double value = (double) poundsforce; return new Force(value, ForceUnit.PoundForce); } + /// /// Creates a from . /// @@ -440,6 +453,7 @@ public static Force FromShortTonsForce(double shorttonsforce) double value = (double) shorttonsforce; return new Force(value, ForceUnit.ShortTonForce); } + /// /// Creates a from . /// @@ -451,6 +465,7 @@ public static Force FromTonnesForce(double tonnesforce) return new Force(value, ForceUnit.TonneForce); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForceChangeRate.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForceChangeRate.g.cs index 4b4c45fe48..3f5ed0cfb5 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForceChangeRate.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForceChangeRate.g.cs @@ -297,6 +297,7 @@ public static ForceChangeRate FromCentinewtonsPerSecond(double centinewtonsperse double value = (double) centinewtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.CentinewtonPerSecond); } + /// /// Creates a from . /// @@ -307,6 +308,7 @@ public static ForceChangeRate FromDecanewtonsPerMinute(double decanewtonsperminu double value = (double) decanewtonsperminute; return new ForceChangeRate(value, ForceChangeRateUnit.DecanewtonPerMinute); } + /// /// Creates a from . /// @@ -317,6 +319,7 @@ public static ForceChangeRate FromDecanewtonsPerSecond(double decanewtonsperseco double value = (double) decanewtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.DecanewtonPerSecond); } + /// /// Creates a from . /// @@ -327,6 +330,7 @@ public static ForceChangeRate FromDecinewtonsPerSecond(double decinewtonsperseco double value = (double) decinewtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.DecinewtonPerSecond); } + /// /// Creates a from . /// @@ -337,6 +341,7 @@ public static ForceChangeRate FromKilonewtonsPerMinute(double kilonewtonsperminu double value = (double) kilonewtonsperminute; return new ForceChangeRate(value, ForceChangeRateUnit.KilonewtonPerMinute); } + /// /// Creates a from . /// @@ -347,6 +352,7 @@ public static ForceChangeRate FromKilonewtonsPerSecond(double kilonewtonsperseco double value = (double) kilonewtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.KilonewtonPerSecond); } + /// /// Creates a from . /// @@ -357,6 +363,7 @@ public static ForceChangeRate FromKilopoundsForcePerMinute(double kilopoundsforc double value = (double) kilopoundsforceperminute; return new ForceChangeRate(value, ForceChangeRateUnit.KilopoundForcePerMinute); } + /// /// Creates a from . /// @@ -367,6 +374,7 @@ public static ForceChangeRate FromKilopoundsForcePerSecond(double kilopoundsforc double value = (double) kilopoundsforcepersecond; return new ForceChangeRate(value, ForceChangeRateUnit.KilopoundForcePerSecond); } + /// /// Creates a from . /// @@ -377,6 +385,7 @@ public static ForceChangeRate FromMicronewtonsPerSecond(double micronewtonsperse double value = (double) micronewtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.MicronewtonPerSecond); } + /// /// Creates a from . /// @@ -387,6 +396,7 @@ public static ForceChangeRate FromMillinewtonsPerSecond(double millinewtonsperse double value = (double) millinewtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.MillinewtonPerSecond); } + /// /// Creates a from . /// @@ -397,6 +407,7 @@ public static ForceChangeRate FromNanonewtonsPerSecond(double nanonewtonsperseco double value = (double) nanonewtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.NanonewtonPerSecond); } + /// /// Creates a from . /// @@ -407,6 +418,7 @@ public static ForceChangeRate FromNewtonsPerMinute(double newtonsperminute) double value = (double) newtonsperminute; return new ForceChangeRate(value, ForceChangeRateUnit.NewtonPerMinute); } + /// /// Creates a from . /// @@ -417,6 +429,7 @@ public static ForceChangeRate FromNewtonsPerSecond(double newtonspersecond) double value = (double) newtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.NewtonPerSecond); } + /// /// Creates a from . /// @@ -427,6 +440,7 @@ public static ForceChangeRate FromPoundsForcePerMinute(double poundsforceperminu double value = (double) poundsforceperminute; return new ForceChangeRate(value, ForceChangeRateUnit.PoundForcePerMinute); } + /// /// Creates a from . /// @@ -438,6 +452,7 @@ public static ForceChangeRate FromPoundsForcePerSecond(double poundsforceperseco return new ForceChangeRate(value, ForceChangeRateUnit.PoundForcePerSecond); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForcePerLength.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForcePerLength.g.cs index a97dd9edfd..591d553c5c 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForcePerLength.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForcePerLength.g.cs @@ -441,6 +441,7 @@ public static ForcePerLength FromCentinewtonsPerCentimeter(double centinewtonspe double value = (double) centinewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.CentinewtonPerCentimeter); } + /// /// Creates a from . /// @@ -451,6 +452,7 @@ public static ForcePerLength FromCentinewtonsPerMeter(double centinewtonspermete double value = (double) centinewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.CentinewtonPerMeter); } + /// /// Creates a from . /// @@ -461,6 +463,7 @@ public static ForcePerLength FromCentinewtonsPerMillimeter(double centinewtonspe double value = (double) centinewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.CentinewtonPerMillimeter); } + /// /// Creates a from . /// @@ -471,6 +474,7 @@ public static ForcePerLength FromDecanewtonsPerCentimeter(double decanewtonsperc double value = (double) decanewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.DecanewtonPerCentimeter); } + /// /// Creates a from . /// @@ -481,6 +485,7 @@ public static ForcePerLength FromDecanewtonsPerMeter(double decanewtonspermeter) double value = (double) decanewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.DecanewtonPerMeter); } + /// /// Creates a from . /// @@ -491,6 +496,7 @@ public static ForcePerLength FromDecanewtonsPerMillimeter(double decanewtonsperm double value = (double) decanewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.DecanewtonPerMillimeter); } + /// /// Creates a from . /// @@ -501,6 +507,7 @@ public static ForcePerLength FromDecinewtonsPerCentimeter(double decinewtonsperc double value = (double) decinewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.DecinewtonPerCentimeter); } + /// /// Creates a from . /// @@ -511,6 +518,7 @@ public static ForcePerLength FromDecinewtonsPerMeter(double decinewtonspermeter) double value = (double) decinewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.DecinewtonPerMeter); } + /// /// Creates a from . /// @@ -521,6 +529,7 @@ public static ForcePerLength FromDecinewtonsPerMillimeter(double decinewtonsperm double value = (double) decinewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.DecinewtonPerMillimeter); } + /// /// Creates a from . /// @@ -531,6 +540,7 @@ public static ForcePerLength FromKilogramsForcePerCentimeter(double kilogramsfor double value = (double) kilogramsforcepercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.KilogramForcePerCentimeter); } + /// /// Creates a from . /// @@ -541,6 +551,7 @@ public static ForcePerLength FromKilogramsForcePerMeter(double kilogramsforceper double value = (double) kilogramsforcepermeter; return new ForcePerLength(value, ForcePerLengthUnit.KilogramForcePerMeter); } + /// /// Creates a from . /// @@ -551,6 +562,7 @@ public static ForcePerLength FromKilogramsForcePerMillimeter(double kilogramsfor double value = (double) kilogramsforcepermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.KilogramForcePerMillimeter); } + /// /// Creates a from . /// @@ -561,6 +573,7 @@ public static ForcePerLength FromKilonewtonsPerCentimeter(double kilonewtonsperc double value = (double) kilonewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.KilonewtonPerCentimeter); } + /// /// Creates a from . /// @@ -571,6 +584,7 @@ public static ForcePerLength FromKilonewtonsPerMeter(double kilonewtonspermeter) double value = (double) kilonewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.KilonewtonPerMeter); } + /// /// Creates a from . /// @@ -581,6 +595,7 @@ public static ForcePerLength FromKilonewtonsPerMillimeter(double kilonewtonsperm double value = (double) kilonewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.KilonewtonPerMillimeter); } + /// /// Creates a from . /// @@ -591,6 +606,7 @@ public static ForcePerLength FromKilopoundsForcePerFoot(double kilopoundsforcepe double value = (double) kilopoundsforceperfoot; return new ForcePerLength(value, ForcePerLengthUnit.KilopoundForcePerFoot); } + /// /// Creates a from . /// @@ -601,6 +617,7 @@ public static ForcePerLength FromKilopoundsForcePerInch(double kilopoundsforcepe double value = (double) kilopoundsforceperinch; return new ForcePerLength(value, ForcePerLengthUnit.KilopoundForcePerInch); } + /// /// Creates a from . /// @@ -611,6 +628,7 @@ public static ForcePerLength FromMeganewtonsPerCentimeter(double meganewtonsperc double value = (double) meganewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.MeganewtonPerCentimeter); } + /// /// Creates a from . /// @@ -621,6 +639,7 @@ public static ForcePerLength FromMeganewtonsPerMeter(double meganewtonspermeter) double value = (double) meganewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.MeganewtonPerMeter); } + /// /// Creates a from . /// @@ -631,6 +650,7 @@ public static ForcePerLength FromMeganewtonsPerMillimeter(double meganewtonsperm double value = (double) meganewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.MeganewtonPerMillimeter); } + /// /// Creates a from . /// @@ -641,6 +661,7 @@ public static ForcePerLength FromMicronewtonsPerCentimeter(double micronewtonspe double value = (double) micronewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.MicronewtonPerCentimeter); } + /// /// Creates a from . /// @@ -651,6 +672,7 @@ public static ForcePerLength FromMicronewtonsPerMeter(double micronewtonspermete double value = (double) micronewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.MicronewtonPerMeter); } + /// /// Creates a from . /// @@ -661,6 +683,7 @@ public static ForcePerLength FromMicronewtonsPerMillimeter(double micronewtonspe double value = (double) micronewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.MicronewtonPerMillimeter); } + /// /// Creates a from . /// @@ -671,6 +694,7 @@ public static ForcePerLength FromMillinewtonsPerCentimeter(double millinewtonspe double value = (double) millinewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.MillinewtonPerCentimeter); } + /// /// Creates a from . /// @@ -681,6 +705,7 @@ public static ForcePerLength FromMillinewtonsPerMeter(double millinewtonspermete double value = (double) millinewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.MillinewtonPerMeter); } + /// /// Creates a from . /// @@ -691,6 +716,7 @@ public static ForcePerLength FromMillinewtonsPerMillimeter(double millinewtonspe double value = (double) millinewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.MillinewtonPerMillimeter); } + /// /// Creates a from . /// @@ -701,6 +727,7 @@ public static ForcePerLength FromNanonewtonsPerCentimeter(double nanonewtonsperc double value = (double) nanonewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.NanonewtonPerCentimeter); } + /// /// Creates a from . /// @@ -711,6 +738,7 @@ public static ForcePerLength FromNanonewtonsPerMeter(double nanonewtonspermeter) double value = (double) nanonewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.NanonewtonPerMeter); } + /// /// Creates a from . /// @@ -721,6 +749,7 @@ public static ForcePerLength FromNanonewtonsPerMillimeter(double nanonewtonsperm double value = (double) nanonewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.NanonewtonPerMillimeter); } + /// /// Creates a from . /// @@ -731,6 +760,7 @@ public static ForcePerLength FromNewtonsPerCentimeter(double newtonspercentimete double value = (double) newtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.NewtonPerCentimeter); } + /// /// Creates a from . /// @@ -741,6 +771,7 @@ public static ForcePerLength FromNewtonsPerMeter(double newtonspermeter) double value = (double) newtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.NewtonPerMeter); } + /// /// Creates a from . /// @@ -751,6 +782,7 @@ public static ForcePerLength FromNewtonsPerMillimeter(double newtonspermillimete double value = (double) newtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.NewtonPerMillimeter); } + /// /// Creates a from . /// @@ -761,6 +793,7 @@ public static ForcePerLength FromPoundsForcePerFoot(double poundsforceperfoot) double value = (double) poundsforceperfoot; return new ForcePerLength(value, ForcePerLengthUnit.PoundForcePerFoot); } + /// /// Creates a from . /// @@ -771,6 +804,7 @@ public static ForcePerLength FromPoundsForcePerInch(double poundsforceperinch) double value = (double) poundsforceperinch; return new ForcePerLength(value, ForcePerLengthUnit.PoundForcePerInch); } + /// /// Creates a from . /// @@ -781,6 +815,7 @@ public static ForcePerLength FromPoundsForcePerYard(double poundsforceperyard) double value = (double) poundsforceperyard; return new ForcePerLength(value, ForcePerLengthUnit.PoundForcePerYard); } + /// /// Creates a from . /// @@ -791,6 +826,7 @@ public static ForcePerLength FromTonnesForcePerCentimeter(double tonnesforceperc double value = (double) tonnesforcepercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.TonneForcePerCentimeter); } + /// /// Creates a from . /// @@ -801,6 +837,7 @@ public static ForcePerLength FromTonnesForcePerMeter(double tonnesforcepermeter) double value = (double) tonnesforcepermeter; return new ForcePerLength(value, ForcePerLengthUnit.TonneForcePerMeter); } + /// /// Creates a from . /// @@ -812,6 +849,7 @@ public static ForcePerLength FromTonnesForcePerMillimeter(double tonnesforceperm return new ForcePerLength(value, ForcePerLengthUnit.TonneForcePerMillimeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Frequency.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Frequency.g.cs index 31906df301..53ec583e85 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Frequency.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Frequency.g.cs @@ -280,6 +280,7 @@ public static Frequency FromBeatsPerMinute(double beatsperminute) double value = (double) beatsperminute; return new Frequency(value, FrequencyUnit.BeatPerMinute); } + /// /// Creates a from . /// @@ -290,6 +291,7 @@ public static Frequency FromBUnits(double bunits) double value = (double) bunits; return new Frequency(value, FrequencyUnit.BUnit); } + /// /// Creates a from . /// @@ -300,6 +302,7 @@ public static Frequency FromCyclesPerHour(double cyclesperhour) double value = (double) cyclesperhour; return new Frequency(value, FrequencyUnit.CyclePerHour); } + /// /// Creates a from . /// @@ -310,6 +313,7 @@ public static Frequency FromCyclesPerMinute(double cyclesperminute) double value = (double) cyclesperminute; return new Frequency(value, FrequencyUnit.CyclePerMinute); } + /// /// Creates a from . /// @@ -320,6 +324,7 @@ public static Frequency FromGigahertz(double gigahertz) double value = (double) gigahertz; return new Frequency(value, FrequencyUnit.Gigahertz); } + /// /// Creates a from . /// @@ -330,6 +335,7 @@ public static Frequency FromHertz(double hertz) double value = (double) hertz; return new Frequency(value, FrequencyUnit.Hertz); } + /// /// Creates a from . /// @@ -340,6 +346,7 @@ public static Frequency FromKilohertz(double kilohertz) double value = (double) kilohertz; return new Frequency(value, FrequencyUnit.Kilohertz); } + /// /// Creates a from . /// @@ -350,6 +357,7 @@ public static Frequency FromMegahertz(double megahertz) double value = (double) megahertz; return new Frequency(value, FrequencyUnit.Megahertz); } + /// /// Creates a from . /// @@ -360,6 +368,7 @@ public static Frequency FromPerSecond(double persecond) double value = (double) persecond; return new Frequency(value, FrequencyUnit.PerSecond); } + /// /// Creates a from . /// @@ -370,6 +379,7 @@ public static Frequency FromRadiansPerSecond(double radianspersecond) double value = (double) radianspersecond; return new Frequency(value, FrequencyUnit.RadianPerSecond); } + /// /// Creates a from . /// @@ -381,6 +391,7 @@ public static Frequency FromTerahertz(double terahertz) return new Frequency(value, FrequencyUnit.Terahertz); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/FuelEfficiency.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/FuelEfficiency.g.cs index 64992c86a5..7537293951 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/FuelEfficiency.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/FuelEfficiency.g.cs @@ -234,6 +234,7 @@ public static FuelEfficiency FromKilometersPerLiters(double kilometersperliters) double value = (double) kilometersperliters; return new FuelEfficiency(value, FuelEfficiencyUnit.KilometerPerLiter); } + /// /// Creates a from . /// @@ -244,6 +245,7 @@ public static FuelEfficiency FromLitersPer100Kilometers(double litersper100kilom double value = (double) litersper100kilometers; return new FuelEfficiency(value, FuelEfficiencyUnit.LiterPer100Kilometers); } + /// /// Creates a from . /// @@ -254,6 +256,7 @@ public static FuelEfficiency FromMilesPerUkGallon(double milesperukgallon) double value = (double) milesperukgallon; return new FuelEfficiency(value, FuelEfficiencyUnit.MilePerUkGallon); } + /// /// Creates a from . /// @@ -265,6 +268,7 @@ public static FuelEfficiency FromMilesPerUsGallon(double milesperusgallon) return new FuelEfficiency(value, FuelEfficiencyUnit.MilePerUsGallon); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatFlux.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatFlux.g.cs index f1948d723e..eb1b9a8a30 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatFlux.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatFlux.g.cs @@ -315,6 +315,7 @@ public static HeatFlux FromBtusPerHourSquareFoot(double btusperhoursquarefoot) double value = (double) btusperhoursquarefoot; return new HeatFlux(value, HeatFluxUnit.BtuPerHourSquareFoot); } + /// /// Creates a from . /// @@ -325,6 +326,7 @@ public static HeatFlux FromBtusPerMinuteSquareFoot(double btusperminutesquarefoo double value = (double) btusperminutesquarefoot; return new HeatFlux(value, HeatFluxUnit.BtuPerMinuteSquareFoot); } + /// /// Creates a from . /// @@ -335,6 +337,7 @@ public static HeatFlux FromBtusPerSecondSquareFoot(double btuspersecondsquarefoo double value = (double) btuspersecondsquarefoot; return new HeatFlux(value, HeatFluxUnit.BtuPerSecondSquareFoot); } + /// /// Creates a from . /// @@ -345,6 +348,7 @@ public static HeatFlux FromBtusPerSecondSquareInch(double btuspersecondsquareinc double value = (double) btuspersecondsquareinch; return new HeatFlux(value, HeatFluxUnit.BtuPerSecondSquareInch); } + /// /// Creates a from . /// @@ -355,6 +359,7 @@ public static HeatFlux FromCaloriesPerSecondSquareCentimeter(double caloriespers double value = (double) caloriespersecondsquarecentimeter; return new HeatFlux(value, HeatFluxUnit.CaloriePerSecondSquareCentimeter); } + /// /// Creates a from . /// @@ -365,6 +370,7 @@ public static HeatFlux FromCentiwattsPerSquareMeter(double centiwattspersquareme double value = (double) centiwattspersquaremeter; return new HeatFlux(value, HeatFluxUnit.CentiwattPerSquareMeter); } + /// /// Creates a from . /// @@ -375,6 +381,7 @@ public static HeatFlux FromDeciwattsPerSquareMeter(double deciwattspersquaremete double value = (double) deciwattspersquaremeter; return new HeatFlux(value, HeatFluxUnit.DeciwattPerSquareMeter); } + /// /// Creates a from . /// @@ -385,6 +392,7 @@ public static HeatFlux FromKilocaloriesPerHourSquareMeter(double kilocaloriesper double value = (double) kilocaloriesperhoursquaremeter; return new HeatFlux(value, HeatFluxUnit.KilocaloriePerHourSquareMeter); } + /// /// Creates a from . /// @@ -395,6 +403,7 @@ public static HeatFlux FromKilocaloriesPerSecondSquareCentimeter(double kilocalo double value = (double) kilocaloriespersecondsquarecentimeter; return new HeatFlux(value, HeatFluxUnit.KilocaloriePerSecondSquareCentimeter); } + /// /// Creates a from . /// @@ -405,6 +414,7 @@ public static HeatFlux FromKilowattsPerSquareMeter(double kilowattspersquaremete double value = (double) kilowattspersquaremeter; return new HeatFlux(value, HeatFluxUnit.KilowattPerSquareMeter); } + /// /// Creates a from . /// @@ -415,6 +425,7 @@ public static HeatFlux FromMicrowattsPerSquareMeter(double microwattspersquareme double value = (double) microwattspersquaremeter; return new HeatFlux(value, HeatFluxUnit.MicrowattPerSquareMeter); } + /// /// Creates a from . /// @@ -425,6 +436,7 @@ public static HeatFlux FromMilliwattsPerSquareMeter(double milliwattspersquareme double value = (double) milliwattspersquaremeter; return new HeatFlux(value, HeatFluxUnit.MilliwattPerSquareMeter); } + /// /// Creates a from . /// @@ -435,6 +447,7 @@ public static HeatFlux FromNanowattsPerSquareMeter(double nanowattspersquaremete double value = (double) nanowattspersquaremeter; return new HeatFlux(value, HeatFluxUnit.NanowattPerSquareMeter); } + /// /// Creates a from . /// @@ -445,6 +458,7 @@ public static HeatFlux FromPoundsForcePerFootSecond(double poundsforceperfootsec double value = (double) poundsforceperfootsecond; return new HeatFlux(value, HeatFluxUnit.PoundForcePerFootSecond); } + /// /// Creates a from . /// @@ -455,6 +469,7 @@ public static HeatFlux FromPoundsPerSecondCubed(double poundspersecondcubed) double value = (double) poundspersecondcubed; return new HeatFlux(value, HeatFluxUnit.PoundPerSecondCubed); } + /// /// Creates a from . /// @@ -465,6 +480,7 @@ public static HeatFlux FromWattsPerSquareFoot(double wattspersquarefoot) double value = (double) wattspersquarefoot; return new HeatFlux(value, HeatFluxUnit.WattPerSquareFoot); } + /// /// Creates a from . /// @@ -475,6 +491,7 @@ public static HeatFlux FromWattsPerSquareInch(double wattspersquareinch) double value = (double) wattspersquareinch; return new HeatFlux(value, HeatFluxUnit.WattPerSquareInch); } + /// /// Creates a from . /// @@ -486,6 +503,7 @@ public static HeatFlux FromWattsPerSquareMeter(double wattspersquaremeter) return new HeatFlux(value, HeatFluxUnit.WattPerSquareMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs index b4c9a69677..2e68312bff 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs @@ -225,6 +225,7 @@ public static HeatTransferCoefficient FromBtusPerSquareFootDegreeFahrenheit(doub double value = (double) btuspersquarefootdegreefahrenheit; return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit); } + /// /// Creates a from . /// @@ -235,6 +236,7 @@ public static HeatTransferCoefficient FromWattsPerSquareMeterCelsius(double watt double value = (double) wattspersquaremetercelsius; return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.WattPerSquareMeterCelsius); } + /// /// Creates a from . /// @@ -246,6 +248,7 @@ public static HeatTransferCoefficient FromWattsPerSquareMeterKelvin(double watts return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Illuminance.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Illuminance.g.cs index 3b6a03b2ba..23a74a1a99 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Illuminance.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Illuminance.g.cs @@ -234,6 +234,7 @@ public static Illuminance FromKilolux(double kilolux) double value = (double) kilolux; return new Illuminance(value, IlluminanceUnit.Kilolux); } + /// /// Creates a from . /// @@ -244,6 +245,7 @@ public static Illuminance FromLux(double lux) double value = (double) lux; return new Illuminance(value, IlluminanceUnit.Lux); } + /// /// Creates a from . /// @@ -254,6 +256,7 @@ public static Illuminance FromMegalux(double megalux) double value = (double) megalux; return new Illuminance(value, IlluminanceUnit.Megalux); } + /// /// Creates a from . /// @@ -265,6 +268,7 @@ public static Illuminance FromMillilux(double millilux) return new Illuminance(value, IlluminanceUnit.Millilux); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Information.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Information.g.cs index 0929028d6b..60f903ba5b 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Information.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Information.g.cs @@ -363,6 +363,7 @@ public static Information FromBits(double bits) decimal value = (decimal) bits; return new Information(value, InformationUnit.Bit); } + /// /// Creates a from . /// @@ -373,6 +374,7 @@ public static Information FromBytes(double bytes) decimal value = (decimal) bytes; return new Information(value, InformationUnit.Byte); } + /// /// Creates a from . /// @@ -383,6 +385,7 @@ public static Information FromExabits(double exabits) decimal value = (decimal) exabits; return new Information(value, InformationUnit.Exabit); } + /// /// Creates a from . /// @@ -393,6 +396,7 @@ public static Information FromExabytes(double exabytes) decimal value = (decimal) exabytes; return new Information(value, InformationUnit.Exabyte); } + /// /// Creates a from . /// @@ -403,6 +407,7 @@ public static Information FromExbibits(double exbibits) decimal value = (decimal) exbibits; return new Information(value, InformationUnit.Exbibit); } + /// /// Creates a from . /// @@ -413,6 +418,7 @@ public static Information FromExbibytes(double exbibytes) decimal value = (decimal) exbibytes; return new Information(value, InformationUnit.Exbibyte); } + /// /// Creates a from . /// @@ -423,6 +429,7 @@ public static Information FromGibibits(double gibibits) decimal value = (decimal) gibibits; return new Information(value, InformationUnit.Gibibit); } + /// /// Creates a from . /// @@ -433,6 +440,7 @@ public static Information FromGibibytes(double gibibytes) decimal value = (decimal) gibibytes; return new Information(value, InformationUnit.Gibibyte); } + /// /// Creates a from . /// @@ -443,6 +451,7 @@ public static Information FromGigabits(double gigabits) decimal value = (decimal) gigabits; return new Information(value, InformationUnit.Gigabit); } + /// /// Creates a from . /// @@ -453,6 +462,7 @@ public static Information FromGigabytes(double gigabytes) decimal value = (decimal) gigabytes; return new Information(value, InformationUnit.Gigabyte); } + /// /// Creates a from . /// @@ -463,6 +473,7 @@ public static Information FromKibibits(double kibibits) decimal value = (decimal) kibibits; return new Information(value, InformationUnit.Kibibit); } + /// /// Creates a from . /// @@ -473,6 +484,7 @@ public static Information FromKibibytes(double kibibytes) decimal value = (decimal) kibibytes; return new Information(value, InformationUnit.Kibibyte); } + /// /// Creates a from . /// @@ -483,6 +495,7 @@ public static Information FromKilobits(double kilobits) decimal value = (decimal) kilobits; return new Information(value, InformationUnit.Kilobit); } + /// /// Creates a from . /// @@ -493,6 +506,7 @@ public static Information FromKilobytes(double kilobytes) decimal value = (decimal) kilobytes; return new Information(value, InformationUnit.Kilobyte); } + /// /// Creates a from . /// @@ -503,6 +517,7 @@ public static Information FromMebibits(double mebibits) decimal value = (decimal) mebibits; return new Information(value, InformationUnit.Mebibit); } + /// /// Creates a from . /// @@ -513,6 +528,7 @@ public static Information FromMebibytes(double mebibytes) decimal value = (decimal) mebibytes; return new Information(value, InformationUnit.Mebibyte); } + /// /// Creates a from . /// @@ -523,6 +539,7 @@ public static Information FromMegabits(double megabits) decimal value = (decimal) megabits; return new Information(value, InformationUnit.Megabit); } + /// /// Creates a from . /// @@ -533,6 +550,7 @@ public static Information FromMegabytes(double megabytes) decimal value = (decimal) megabytes; return new Information(value, InformationUnit.Megabyte); } + /// /// Creates a from . /// @@ -543,6 +561,7 @@ public static Information FromPebibits(double pebibits) decimal value = (decimal) pebibits; return new Information(value, InformationUnit.Pebibit); } + /// /// Creates a from . /// @@ -553,6 +572,7 @@ public static Information FromPebibytes(double pebibytes) decimal value = (decimal) pebibytes; return new Information(value, InformationUnit.Pebibyte); } + /// /// Creates a from . /// @@ -563,6 +583,7 @@ public static Information FromPetabits(double petabits) decimal value = (decimal) petabits; return new Information(value, InformationUnit.Petabit); } + /// /// Creates a from . /// @@ -573,6 +594,7 @@ public static Information FromPetabytes(double petabytes) decimal value = (decimal) petabytes; return new Information(value, InformationUnit.Petabyte); } + /// /// Creates a from . /// @@ -583,6 +605,7 @@ public static Information FromTebibits(double tebibits) decimal value = (decimal) tebibits; return new Information(value, InformationUnit.Tebibit); } + /// /// Creates a from . /// @@ -593,6 +616,7 @@ public static Information FromTebibytes(double tebibytes) decimal value = (decimal) tebibytes; return new Information(value, InformationUnit.Tebibyte); } + /// /// Creates a from . /// @@ -603,6 +627,7 @@ public static Information FromTerabits(double terabits) decimal value = (decimal) terabits; return new Information(value, InformationUnit.Terabit); } + /// /// Creates a from . /// @@ -614,6 +639,7 @@ public static Information FromTerabytes(double terabytes) return new Information(value, InformationUnit.Terabyte); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiance.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiance.g.cs index d2055e107e..d91f16c81c 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiance.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiance.g.cs @@ -291,6 +291,7 @@ public static Irradiance FromKilowattsPerSquareCentimeter(double kilowattspersqu double value = (double) kilowattspersquarecentimeter; return new Irradiance(value, IrradianceUnit.KilowattPerSquareCentimeter); } + /// /// Creates a from . /// @@ -301,6 +302,7 @@ public static Irradiance FromKilowattsPerSquareMeter(double kilowattspersquareme double value = (double) kilowattspersquaremeter; return new Irradiance(value, IrradianceUnit.KilowattPerSquareMeter); } + /// /// Creates a from . /// @@ -311,6 +313,7 @@ public static Irradiance FromMegawattsPerSquareCentimeter(double megawattspersqu double value = (double) megawattspersquarecentimeter; return new Irradiance(value, IrradianceUnit.MegawattPerSquareCentimeter); } + /// /// Creates a from . /// @@ -321,6 +324,7 @@ public static Irradiance FromMegawattsPerSquareMeter(double megawattspersquareme double value = (double) megawattspersquaremeter; return new Irradiance(value, IrradianceUnit.MegawattPerSquareMeter); } + /// /// Creates a from . /// @@ -331,6 +335,7 @@ public static Irradiance FromMicrowattsPerSquareCentimeter(double microwattspers double value = (double) microwattspersquarecentimeter; return new Irradiance(value, IrradianceUnit.MicrowattPerSquareCentimeter); } + /// /// Creates a from . /// @@ -341,6 +346,7 @@ public static Irradiance FromMicrowattsPerSquareMeter(double microwattspersquare double value = (double) microwattspersquaremeter; return new Irradiance(value, IrradianceUnit.MicrowattPerSquareMeter); } + /// /// Creates a from . /// @@ -351,6 +357,7 @@ public static Irradiance FromMilliwattsPerSquareCentimeter(double milliwattspers double value = (double) milliwattspersquarecentimeter; return new Irradiance(value, IrradianceUnit.MilliwattPerSquareCentimeter); } + /// /// Creates a from . /// @@ -361,6 +368,7 @@ public static Irradiance FromMilliwattsPerSquareMeter(double milliwattspersquare double value = (double) milliwattspersquaremeter; return new Irradiance(value, IrradianceUnit.MilliwattPerSquareMeter); } + /// /// Creates a from . /// @@ -371,6 +379,7 @@ public static Irradiance FromNanowattsPerSquareCentimeter(double nanowattspersqu double value = (double) nanowattspersquarecentimeter; return new Irradiance(value, IrradianceUnit.NanowattPerSquareCentimeter); } + /// /// Creates a from . /// @@ -381,6 +390,7 @@ public static Irradiance FromNanowattsPerSquareMeter(double nanowattspersquareme double value = (double) nanowattspersquaremeter; return new Irradiance(value, IrradianceUnit.NanowattPerSquareMeter); } + /// /// Creates a from . /// @@ -391,6 +401,7 @@ public static Irradiance FromPicowattsPerSquareCentimeter(double picowattspersqu double value = (double) picowattspersquarecentimeter; return new Irradiance(value, IrradianceUnit.PicowattPerSquareCentimeter); } + /// /// Creates a from . /// @@ -401,6 +412,7 @@ public static Irradiance FromPicowattsPerSquareMeter(double picowattspersquareme double value = (double) picowattspersquaremeter; return new Irradiance(value, IrradianceUnit.PicowattPerSquareMeter); } + /// /// Creates a from . /// @@ -411,6 +423,7 @@ public static Irradiance FromWattsPerSquareCentimeter(double wattspersquarecenti double value = (double) wattspersquarecentimeter; return new Irradiance(value, IrradianceUnit.WattPerSquareCentimeter); } + /// /// Creates a from . /// @@ -422,6 +435,7 @@ public static Irradiance FromWattsPerSquareMeter(double wattspersquaremeter) return new Irradiance(value, IrradianceUnit.WattPerSquareMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiation.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiation.g.cs index b61ad8eac3..6ec69e6fcd 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiation.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiation.g.cs @@ -252,6 +252,7 @@ public static Irradiation FromJoulesPerSquareCentimeter(double joulespersquarece double value = (double) joulespersquarecentimeter; return new Irradiation(value, IrradiationUnit.JoulePerSquareCentimeter); } + /// /// Creates a from . /// @@ -262,6 +263,7 @@ public static Irradiation FromJoulesPerSquareMeter(double joulespersquaremeter) double value = (double) joulespersquaremeter; return new Irradiation(value, IrradiationUnit.JoulePerSquareMeter); } + /// /// Creates a from . /// @@ -272,6 +274,7 @@ public static Irradiation FromJoulesPerSquareMillimeter(double joulespersquaremi double value = (double) joulespersquaremillimeter; return new Irradiation(value, IrradiationUnit.JoulePerSquareMillimeter); } + /// /// Creates a from . /// @@ -282,6 +285,7 @@ public static Irradiation FromKilojoulesPerSquareMeter(double kilojoulespersquar double value = (double) kilojoulespersquaremeter; return new Irradiation(value, IrradiationUnit.KilojoulePerSquareMeter); } + /// /// Creates a from . /// @@ -292,6 +296,7 @@ public static Irradiation FromKilowattHoursPerSquareMeter(double kilowatthourspe double value = (double) kilowatthourspersquaremeter; return new Irradiation(value, IrradiationUnit.KilowattHourPerSquareMeter); } + /// /// Creates a from . /// @@ -302,6 +307,7 @@ public static Irradiation FromMillijoulesPerSquareCentimeter(double millijoulesp double value = (double) millijoulespersquarecentimeter; return new Irradiation(value, IrradiationUnit.MillijoulePerSquareCentimeter); } + /// /// Creates a from . /// @@ -313,6 +319,7 @@ public static Irradiation FromWattHoursPerSquareMeter(double watthourspersquarem return new Irradiation(value, IrradiationUnit.WattHourPerSquareMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/KinematicViscosity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/KinematicViscosity.g.cs index 1dd129e5f4..2f5941b684 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/KinematicViscosity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/KinematicViscosity.g.cs @@ -272,6 +272,7 @@ public static KinematicViscosity FromCentistokes(double centistokes) double value = (double) centistokes; return new KinematicViscosity(value, KinematicViscosityUnit.Centistokes); } + /// /// Creates a from . /// @@ -282,6 +283,7 @@ public static KinematicViscosity FromDecistokes(double decistokes) double value = (double) decistokes; return new KinematicViscosity(value, KinematicViscosityUnit.Decistokes); } + /// /// Creates a from . /// @@ -292,6 +294,7 @@ public static KinematicViscosity FromKilostokes(double kilostokes) double value = (double) kilostokes; return new KinematicViscosity(value, KinematicViscosityUnit.Kilostokes); } + /// /// Creates a from . /// @@ -302,6 +305,7 @@ public static KinematicViscosity FromMicrostokes(double microstokes) double value = (double) microstokes; return new KinematicViscosity(value, KinematicViscosityUnit.Microstokes); } + /// /// Creates a from . /// @@ -312,6 +316,7 @@ public static KinematicViscosity FromMillistokes(double millistokes) double value = (double) millistokes; return new KinematicViscosity(value, KinematicViscosityUnit.Millistokes); } + /// /// Creates a from . /// @@ -322,6 +327,7 @@ public static KinematicViscosity FromNanostokes(double nanostokes) double value = (double) nanostokes; return new KinematicViscosity(value, KinematicViscosityUnit.Nanostokes); } + /// /// Creates a from . /// @@ -332,6 +338,7 @@ public static KinematicViscosity FromSquareFeetPerSecond(double squarefeetpersec double value = (double) squarefeetpersecond; return new KinematicViscosity(value, KinematicViscosityUnit.SquareFootPerSecond); } + /// /// Creates a from . /// @@ -342,6 +349,7 @@ public static KinematicViscosity FromSquareMetersPerSecond(double squaremeterspe double value = (double) squaremeterspersecond; return new KinematicViscosity(value, KinematicViscosityUnit.SquareMeterPerSecond); } + /// /// Creates a from . /// @@ -353,6 +361,7 @@ public static KinematicViscosity FromStokes(double stokes) return new KinematicViscosity(value, KinematicViscosityUnit.Stokes); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LapseRate.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LapseRate.g.cs index 02bfedefc6..af1af1d179 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LapseRate.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LapseRate.g.cs @@ -215,6 +215,7 @@ public static LapseRate FromDegreesCelciusPerKilometer(double degreescelciusperk return new LapseRate(value, LapseRateUnit.DegreeCelsiusPerKilometer); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Length.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Length.g.cs index 3bf49d6d0a..43760aafa5 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Length.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Length.g.cs @@ -449,6 +449,7 @@ public static Length FromAngstroms(double angstroms) double value = (double) angstroms; return new Length(value, LengthUnit.Angstrom); } + /// /// Creates a from . /// @@ -459,6 +460,7 @@ public static Length FromAstronomicalUnits(double astronomicalunits) double value = (double) astronomicalunits; return new Length(value, LengthUnit.AstronomicalUnit); } + /// /// Creates a from . /// @@ -469,6 +471,7 @@ public static Length FromCentimeters(double centimeters) double value = (double) centimeters; return new Length(value, LengthUnit.Centimeter); } + /// /// Creates a from . /// @@ -479,6 +482,7 @@ public static Length FromChains(double chains) double value = (double) chains; return new Length(value, LengthUnit.Chain); } + /// /// Creates a from . /// @@ -489,6 +493,7 @@ public static Length FromDecameters(double decameters) double value = (double) decameters; return new Length(value, LengthUnit.Decameter); } + /// /// Creates a from . /// @@ -499,6 +504,7 @@ public static Length FromDecimeters(double decimeters) double value = (double) decimeters; return new Length(value, LengthUnit.Decimeter); } + /// /// Creates a from . /// @@ -509,6 +515,7 @@ public static Length FromDtpPicas(double dtppicas) double value = (double) dtppicas; return new Length(value, LengthUnit.DtpPica); } + /// /// Creates a from . /// @@ -519,6 +526,7 @@ public static Length FromDtpPoints(double dtppoints) double value = (double) dtppoints; return new Length(value, LengthUnit.DtpPoint); } + /// /// Creates a from . /// @@ -529,6 +537,7 @@ public static Length FromFathoms(double fathoms) double value = (double) fathoms; return new Length(value, LengthUnit.Fathom); } + /// /// Creates a from . /// @@ -539,6 +548,7 @@ public static Length FromFeet(double feet) double value = (double) feet; return new Length(value, LengthUnit.Foot); } + /// /// Creates a from . /// @@ -549,6 +559,7 @@ public static Length FromHands(double hands) double value = (double) hands; return new Length(value, LengthUnit.Hand); } + /// /// Creates a from . /// @@ -559,6 +570,7 @@ public static Length FromHectometers(double hectometers) double value = (double) hectometers; return new Length(value, LengthUnit.Hectometer); } + /// /// Creates a from . /// @@ -569,6 +581,7 @@ public static Length FromInches(double inches) double value = (double) inches; return new Length(value, LengthUnit.Inch); } + /// /// Creates a from . /// @@ -579,6 +592,7 @@ public static Length FromKilolightYears(double kilolightyears) double value = (double) kilolightyears; return new Length(value, LengthUnit.KilolightYear); } + /// /// Creates a from . /// @@ -589,6 +603,7 @@ public static Length FromKilometers(double kilometers) double value = (double) kilometers; return new Length(value, LengthUnit.Kilometer); } + /// /// Creates a from . /// @@ -599,6 +614,7 @@ public static Length FromKiloparsecs(double kiloparsecs) double value = (double) kiloparsecs; return new Length(value, LengthUnit.Kiloparsec); } + /// /// Creates a from . /// @@ -609,6 +625,7 @@ public static Length FromLightYears(double lightyears) double value = (double) lightyears; return new Length(value, LengthUnit.LightYear); } + /// /// Creates a from . /// @@ -619,6 +636,7 @@ public static Length FromMegalightYears(double megalightyears) double value = (double) megalightyears; return new Length(value, LengthUnit.MegalightYear); } + /// /// Creates a from . /// @@ -629,6 +647,7 @@ public static Length FromMegaparsecs(double megaparsecs) double value = (double) megaparsecs; return new Length(value, LengthUnit.Megaparsec); } + /// /// Creates a from . /// @@ -639,6 +658,7 @@ public static Length FromMeters(double meters) double value = (double) meters; return new Length(value, LengthUnit.Meter); } + /// /// Creates a from . /// @@ -649,6 +669,7 @@ public static Length FromMicroinches(double microinches) double value = (double) microinches; return new Length(value, LengthUnit.Microinch); } + /// /// Creates a from . /// @@ -659,6 +680,7 @@ public static Length FromMicrometers(double micrometers) double value = (double) micrometers; return new Length(value, LengthUnit.Micrometer); } + /// /// Creates a from . /// @@ -669,6 +691,7 @@ public static Length FromMils(double mils) double value = (double) mils; return new Length(value, LengthUnit.Mil); } + /// /// Creates a from . /// @@ -679,6 +702,7 @@ public static Length FromMiles(double miles) double value = (double) miles; return new Length(value, LengthUnit.Mile); } + /// /// Creates a from . /// @@ -689,6 +713,7 @@ public static Length FromMillimeters(double millimeters) double value = (double) millimeters; return new Length(value, LengthUnit.Millimeter); } + /// /// Creates a from . /// @@ -699,6 +724,7 @@ public static Length FromNanometers(double nanometers) double value = (double) nanometers; return new Length(value, LengthUnit.Nanometer); } + /// /// Creates a from . /// @@ -709,6 +735,7 @@ public static Length FromNauticalMiles(double nauticalmiles) double value = (double) nauticalmiles; return new Length(value, LengthUnit.NauticalMile); } + /// /// Creates a from . /// @@ -719,6 +746,7 @@ public static Length FromParsecs(double parsecs) double value = (double) parsecs; return new Length(value, LengthUnit.Parsec); } + /// /// Creates a from . /// @@ -729,6 +757,7 @@ public static Length FromPrinterPicas(double printerpicas) double value = (double) printerpicas; return new Length(value, LengthUnit.PrinterPica); } + /// /// Creates a from . /// @@ -739,6 +768,7 @@ public static Length FromPrinterPoints(double printerpoints) double value = (double) printerpoints; return new Length(value, LengthUnit.PrinterPoint); } + /// /// Creates a from . /// @@ -749,6 +779,7 @@ public static Length FromShackles(double shackles) double value = (double) shackles; return new Length(value, LengthUnit.Shackle); } + /// /// Creates a from . /// @@ -759,6 +790,7 @@ public static Length FromSolarRadiuses(double solarradiuses) double value = (double) solarradiuses; return new Length(value, LengthUnit.SolarRadius); } + /// /// Creates a from . /// @@ -769,6 +801,7 @@ public static Length FromTwips(double twips) double value = (double) twips; return new Length(value, LengthUnit.Twip); } + /// /// Creates a from . /// @@ -779,6 +812,7 @@ public static Length FromUsSurveyFeet(double ussurveyfeet) double value = (double) ussurveyfeet; return new Length(value, LengthUnit.UsSurveyFoot); } + /// /// Creates a from . /// @@ -790,6 +824,7 @@ public static Length FromYards(double yards) return new Length(value, LengthUnit.Yard); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Level.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Level.g.cs index 23b4a6cd4c..f40dba5692 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Level.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Level.g.cs @@ -219,6 +219,7 @@ public static Level FromDecibels(double decibels) double value = (double) decibels; return new Level(value, LevelUnit.Decibel); } + /// /// Creates a from . /// @@ -230,6 +231,7 @@ public static Level FromNepers(double nepers) return new Level(value, LevelUnit.Neper); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearDensity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearDensity.g.cs index 45c3d2edf8..5131dc933a 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearDensity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearDensity.g.cs @@ -294,6 +294,7 @@ public static LinearDensity FromGramsPerCentimeter(double gramspercentimeter) double value = (double) gramspercentimeter; return new LinearDensity(value, LinearDensityUnit.GramPerCentimeter); } + /// /// Creates a from . /// @@ -304,6 +305,7 @@ public static LinearDensity FromGramsPerMeter(double gramspermeter) double value = (double) gramspermeter; return new LinearDensity(value, LinearDensityUnit.GramPerMeter); } + /// /// Creates a from . /// @@ -314,6 +316,7 @@ public static LinearDensity FromGramsPerMillimeter(double gramspermillimeter) double value = (double) gramspermillimeter; return new LinearDensity(value, LinearDensityUnit.GramPerMillimeter); } + /// /// Creates a from . /// @@ -324,6 +327,7 @@ public static LinearDensity FromKilogramsPerCentimeter(double kilogramspercentim double value = (double) kilogramspercentimeter; return new LinearDensity(value, LinearDensityUnit.KilogramPerCentimeter); } + /// /// Creates a from . /// @@ -334,6 +338,7 @@ public static LinearDensity FromKilogramsPerMeter(double kilogramspermeter) double value = (double) kilogramspermeter; return new LinearDensity(value, LinearDensityUnit.KilogramPerMeter); } + /// /// Creates a from . /// @@ -344,6 +349,7 @@ public static LinearDensity FromKilogramsPerMillimeter(double kilogramspermillim double value = (double) kilogramspermillimeter; return new LinearDensity(value, LinearDensityUnit.KilogramPerMillimeter); } + /// /// Creates a from . /// @@ -354,6 +360,7 @@ public static LinearDensity FromMicrogramsPerCentimeter(double microgramspercent double value = (double) microgramspercentimeter; return new LinearDensity(value, LinearDensityUnit.MicrogramPerCentimeter); } + /// /// Creates a from . /// @@ -364,6 +371,7 @@ public static LinearDensity FromMicrogramsPerMeter(double microgramspermeter) double value = (double) microgramspermeter; return new LinearDensity(value, LinearDensityUnit.MicrogramPerMeter); } + /// /// Creates a from . /// @@ -374,6 +382,7 @@ public static LinearDensity FromMicrogramsPerMillimeter(double microgramspermill double value = (double) microgramspermillimeter; return new LinearDensity(value, LinearDensityUnit.MicrogramPerMillimeter); } + /// /// Creates a from . /// @@ -384,6 +393,7 @@ public static LinearDensity FromMilligramsPerCentimeter(double milligramspercent double value = (double) milligramspercentimeter; return new LinearDensity(value, LinearDensityUnit.MilligramPerCentimeter); } + /// /// Creates a from . /// @@ -394,6 +404,7 @@ public static LinearDensity FromMilligramsPerMeter(double milligramspermeter) double value = (double) milligramspermeter; return new LinearDensity(value, LinearDensityUnit.MilligramPerMeter); } + /// /// Creates a from . /// @@ -404,6 +415,7 @@ public static LinearDensity FromMilligramsPerMillimeter(double milligramspermill double value = (double) milligramspermillimeter; return new LinearDensity(value, LinearDensityUnit.MilligramPerMillimeter); } + /// /// Creates a from . /// @@ -414,6 +426,7 @@ public static LinearDensity FromPoundsPerFoot(double poundsperfoot) double value = (double) poundsperfoot; return new LinearDensity(value, LinearDensityUnit.PoundPerFoot); } + /// /// Creates a from . /// @@ -425,6 +438,7 @@ public static LinearDensity FromPoundsPerInch(double poundsperinch) return new LinearDensity(value, LinearDensityUnit.PoundPerInch); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearPowerDensity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearPowerDensity.g.cs index 4c4c7f49c8..a8119fd122 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearPowerDensity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearPowerDensity.g.cs @@ -360,6 +360,7 @@ public static LinearPowerDensity FromGigawattsPerCentimeter(double gigawattsperc double value = (double) gigawattspercentimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerCentimeter); } + /// /// Creates a from . /// @@ -370,6 +371,7 @@ public static LinearPowerDensity FromGigawattsPerFoot(double gigawattsperfoot) double value = (double) gigawattsperfoot; return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerFoot); } + /// /// Creates a from . /// @@ -380,6 +382,7 @@ public static LinearPowerDensity FromGigawattsPerInch(double gigawattsperinch) double value = (double) gigawattsperinch; return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerInch); } + /// /// Creates a from . /// @@ -390,6 +393,7 @@ public static LinearPowerDensity FromGigawattsPerMeter(double gigawattspermeter) double value = (double) gigawattspermeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerMeter); } + /// /// Creates a from . /// @@ -400,6 +404,7 @@ public static LinearPowerDensity FromGigawattsPerMillimeter(double gigawattsperm double value = (double) gigawattspermillimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerMillimeter); } + /// /// Creates a from . /// @@ -410,6 +415,7 @@ public static LinearPowerDensity FromKilowattsPerCentimeter(double kilowattsperc double value = (double) kilowattspercentimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerCentimeter); } + /// /// Creates a from . /// @@ -420,6 +426,7 @@ public static LinearPowerDensity FromKilowattsPerFoot(double kilowattsperfoot) double value = (double) kilowattsperfoot; return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerFoot); } + /// /// Creates a from . /// @@ -430,6 +437,7 @@ public static LinearPowerDensity FromKilowattsPerInch(double kilowattsperinch) double value = (double) kilowattsperinch; return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerInch); } + /// /// Creates a from . /// @@ -440,6 +448,7 @@ public static LinearPowerDensity FromKilowattsPerMeter(double kilowattspermeter) double value = (double) kilowattspermeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerMeter); } + /// /// Creates a from . /// @@ -450,6 +459,7 @@ public static LinearPowerDensity FromKilowattsPerMillimeter(double kilowattsperm double value = (double) kilowattspermillimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerMillimeter); } + /// /// Creates a from . /// @@ -460,6 +470,7 @@ public static LinearPowerDensity FromMegawattsPerCentimeter(double megawattsperc double value = (double) megawattspercentimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerCentimeter); } + /// /// Creates a from . /// @@ -470,6 +481,7 @@ public static LinearPowerDensity FromMegawattsPerFoot(double megawattsperfoot) double value = (double) megawattsperfoot; return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerFoot); } + /// /// Creates a from . /// @@ -480,6 +492,7 @@ public static LinearPowerDensity FromMegawattsPerInch(double megawattsperinch) double value = (double) megawattsperinch; return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerInch); } + /// /// Creates a from . /// @@ -490,6 +503,7 @@ public static LinearPowerDensity FromMegawattsPerMeter(double megawattspermeter) double value = (double) megawattspermeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerMeter); } + /// /// Creates a from . /// @@ -500,6 +514,7 @@ public static LinearPowerDensity FromMegawattsPerMillimeter(double megawattsperm double value = (double) megawattspermillimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerMillimeter); } + /// /// Creates a from . /// @@ -510,6 +525,7 @@ public static LinearPowerDensity FromMilliwattsPerCentimeter(double milliwattspe double value = (double) milliwattspercentimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerCentimeter); } + /// /// Creates a from . /// @@ -520,6 +536,7 @@ public static LinearPowerDensity FromMilliwattsPerFoot(double milliwattsperfoot) double value = (double) milliwattsperfoot; return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerFoot); } + /// /// Creates a from . /// @@ -530,6 +547,7 @@ public static LinearPowerDensity FromMilliwattsPerInch(double milliwattsperinch) double value = (double) milliwattsperinch; return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerInch); } + /// /// Creates a from . /// @@ -540,6 +558,7 @@ public static LinearPowerDensity FromMilliwattsPerMeter(double milliwattspermete double value = (double) milliwattspermeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerMeter); } + /// /// Creates a from . /// @@ -550,6 +569,7 @@ public static LinearPowerDensity FromMilliwattsPerMillimeter(double milliwattspe double value = (double) milliwattspermillimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerMillimeter); } + /// /// Creates a from . /// @@ -560,6 +580,7 @@ public static LinearPowerDensity FromWattsPerCentimeter(double wattspercentimete double value = (double) wattspercentimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerCentimeter); } + /// /// Creates a from . /// @@ -570,6 +591,7 @@ public static LinearPowerDensity FromWattsPerFoot(double wattsperfoot) double value = (double) wattsperfoot; return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerFoot); } + /// /// Creates a from . /// @@ -580,6 +602,7 @@ public static LinearPowerDensity FromWattsPerInch(double wattsperinch) double value = (double) wattsperinch; return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerInch); } + /// /// Creates a from . /// @@ -590,6 +613,7 @@ public static LinearPowerDensity FromWattsPerMeter(double wattspermeter) double value = (double) wattspermeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerMeter); } + /// /// Creates a from . /// @@ -601,6 +625,7 @@ public static LinearPowerDensity FromWattsPerMillimeter(double wattspermillimete return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerMillimeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Luminosity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Luminosity.g.cs index 1a7c85e340..04381f4e39 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Luminosity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Luminosity.g.cs @@ -294,6 +294,7 @@ public static Luminosity FromDecawatts(double decawatts) double value = (double) decawatts; return new Luminosity(value, LuminosityUnit.Decawatt); } + /// /// Creates a from . /// @@ -304,6 +305,7 @@ public static Luminosity FromDeciwatts(double deciwatts) double value = (double) deciwatts; return new Luminosity(value, LuminosityUnit.Deciwatt); } + /// /// Creates a from . /// @@ -314,6 +316,7 @@ public static Luminosity FromFemtowatts(double femtowatts) double value = (double) femtowatts; return new Luminosity(value, LuminosityUnit.Femtowatt); } + /// /// Creates a from . /// @@ -324,6 +327,7 @@ public static Luminosity FromGigawatts(double gigawatts) double value = (double) gigawatts; return new Luminosity(value, LuminosityUnit.Gigawatt); } + /// /// Creates a from . /// @@ -334,6 +338,7 @@ public static Luminosity FromKilowatts(double kilowatts) double value = (double) kilowatts; return new Luminosity(value, LuminosityUnit.Kilowatt); } + /// /// Creates a from . /// @@ -344,6 +349,7 @@ public static Luminosity FromMegawatts(double megawatts) double value = (double) megawatts; return new Luminosity(value, LuminosityUnit.Megawatt); } + /// /// Creates a from . /// @@ -354,6 +360,7 @@ public static Luminosity FromMicrowatts(double microwatts) double value = (double) microwatts; return new Luminosity(value, LuminosityUnit.Microwatt); } + /// /// Creates a from . /// @@ -364,6 +371,7 @@ public static Luminosity FromMilliwatts(double milliwatts) double value = (double) milliwatts; return new Luminosity(value, LuminosityUnit.Milliwatt); } + /// /// Creates a from . /// @@ -374,6 +382,7 @@ public static Luminosity FromNanowatts(double nanowatts) double value = (double) nanowatts; return new Luminosity(value, LuminosityUnit.Nanowatt); } + /// /// Creates a from . /// @@ -384,6 +393,7 @@ public static Luminosity FromPetawatts(double petawatts) double value = (double) petawatts; return new Luminosity(value, LuminosityUnit.Petawatt); } + /// /// Creates a from . /// @@ -394,6 +404,7 @@ public static Luminosity FromPicowatts(double picowatts) double value = (double) picowatts; return new Luminosity(value, LuminosityUnit.Picowatt); } + /// /// Creates a from . /// @@ -404,6 +415,7 @@ public static Luminosity FromSolarLuminosities(double solarluminosities) double value = (double) solarluminosities; return new Luminosity(value, LuminosityUnit.SolarLuminosity); } + /// /// Creates a from . /// @@ -414,6 +426,7 @@ public static Luminosity FromTerawatts(double terawatts) double value = (double) terawatts; return new Luminosity(value, LuminosityUnit.Terawatt); } + /// /// Creates a from . /// @@ -425,6 +438,7 @@ public static Luminosity FromWatts(double watts) return new Luminosity(value, LuminosityUnit.Watt); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousFlux.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousFlux.g.cs index ff1866abb2..f4b42d67a2 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousFlux.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousFlux.g.cs @@ -217,6 +217,7 @@ public static LuminousFlux FromLumens(double lumens) return new LuminousFlux(value, LuminousFluxUnit.Lumen); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousIntensity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousIntensity.g.cs index dec2aa0a17..d26d8099af 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousIntensity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousIntensity.g.cs @@ -217,6 +217,7 @@ public static LuminousIntensity FromCandela(double candela) return new LuminousIntensity(value, LuminousIntensityUnit.Candela); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticField.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticField.g.cs index 600dc4e610..247dfae7be 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticField.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticField.g.cs @@ -246,6 +246,7 @@ public static MagneticField FromGausses(double gausses) double value = (double) gausses; return new MagneticField(value, MagneticFieldUnit.Gauss); } + /// /// Creates a from . /// @@ -256,6 +257,7 @@ public static MagneticField FromMicroteslas(double microteslas) double value = (double) microteslas; return new MagneticField(value, MagneticFieldUnit.Microtesla); } + /// /// Creates a from . /// @@ -266,6 +268,7 @@ public static MagneticField FromMilligausses(double milligausses) double value = (double) milligausses; return new MagneticField(value, MagneticFieldUnit.Milligauss); } + /// /// Creates a from . /// @@ -276,6 +279,7 @@ public static MagneticField FromMilliteslas(double milliteslas) double value = (double) milliteslas; return new MagneticField(value, MagneticFieldUnit.Millitesla); } + /// /// Creates a from . /// @@ -286,6 +290,7 @@ public static MagneticField FromNanoteslas(double nanoteslas) double value = (double) nanoteslas; return new MagneticField(value, MagneticFieldUnit.Nanotesla); } + /// /// Creates a from . /// @@ -297,6 +302,7 @@ public static MagneticField FromTeslas(double teslas) return new MagneticField(value, MagneticFieldUnit.Tesla); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticFlux.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticFlux.g.cs index 863834d7e5..913093c139 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticFlux.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticFlux.g.cs @@ -217,6 +217,7 @@ public static MagneticFlux FromWebers(double webers) return new MagneticFlux(value, MagneticFluxUnit.Weber); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Magnetization.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Magnetization.g.cs index f8bdd62dab..b6dd54e58c 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Magnetization.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Magnetization.g.cs @@ -217,6 +217,7 @@ public static Magnetization FromAmperesPerMeter(double amperespermeter) return new Magnetization(value, MagnetizationUnit.AmperePerMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Mass.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Mass.g.cs index d01926a1b5..8c05e6db99 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Mass.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Mass.g.cs @@ -392,6 +392,7 @@ public static Mass FromCentigrams(double centigrams) double value = (double) centigrams; return new Mass(value, MassUnit.Centigram); } + /// /// Creates a from . /// @@ -402,6 +403,7 @@ public static Mass FromDecagrams(double decagrams) double value = (double) decagrams; return new Mass(value, MassUnit.Decagram); } + /// /// Creates a from . /// @@ -412,6 +414,7 @@ public static Mass FromDecigrams(double decigrams) double value = (double) decigrams; return new Mass(value, MassUnit.Decigram); } + /// /// Creates a from . /// @@ -422,6 +425,7 @@ public static Mass FromEarthMasses(double earthmasses) double value = (double) earthmasses; return new Mass(value, MassUnit.EarthMass); } + /// /// Creates a from . /// @@ -432,6 +436,7 @@ public static Mass FromGrains(double grains) double value = (double) grains; return new Mass(value, MassUnit.Grain); } + /// /// Creates a from . /// @@ -442,6 +447,7 @@ public static Mass FromGrams(double grams) double value = (double) grams; return new Mass(value, MassUnit.Gram); } + /// /// Creates a from . /// @@ -452,6 +458,7 @@ public static Mass FromHectograms(double hectograms) double value = (double) hectograms; return new Mass(value, MassUnit.Hectogram); } + /// /// Creates a from . /// @@ -462,6 +469,7 @@ public static Mass FromKilograms(double kilograms) double value = (double) kilograms; return new Mass(value, MassUnit.Kilogram); } + /// /// Creates a from . /// @@ -472,6 +480,7 @@ public static Mass FromKilopounds(double kilopounds) double value = (double) kilopounds; return new Mass(value, MassUnit.Kilopound); } + /// /// Creates a from . /// @@ -482,6 +491,7 @@ public static Mass FromKilotonnes(double kilotonnes) double value = (double) kilotonnes; return new Mass(value, MassUnit.Kilotonne); } + /// /// Creates a from . /// @@ -492,6 +502,7 @@ public static Mass FromLongHundredweight(double longhundredweight) double value = (double) longhundredweight; return new Mass(value, MassUnit.LongHundredweight); } + /// /// Creates a from . /// @@ -502,6 +513,7 @@ public static Mass FromLongTons(double longtons) double value = (double) longtons; return new Mass(value, MassUnit.LongTon); } + /// /// Creates a from . /// @@ -512,6 +524,7 @@ public static Mass FromMegapounds(double megapounds) double value = (double) megapounds; return new Mass(value, MassUnit.Megapound); } + /// /// Creates a from . /// @@ -522,6 +535,7 @@ public static Mass FromMegatonnes(double megatonnes) double value = (double) megatonnes; return new Mass(value, MassUnit.Megatonne); } + /// /// Creates a from . /// @@ -532,6 +546,7 @@ public static Mass FromMicrograms(double micrograms) double value = (double) micrograms; return new Mass(value, MassUnit.Microgram); } + /// /// Creates a from . /// @@ -542,6 +557,7 @@ public static Mass FromMilligrams(double milligrams) double value = (double) milligrams; return new Mass(value, MassUnit.Milligram); } + /// /// Creates a from . /// @@ -552,6 +568,7 @@ public static Mass FromNanograms(double nanograms) double value = (double) nanograms; return new Mass(value, MassUnit.Nanogram); } + /// /// Creates a from . /// @@ -562,6 +579,7 @@ public static Mass FromOunces(double ounces) double value = (double) ounces; return new Mass(value, MassUnit.Ounce); } + /// /// Creates a from . /// @@ -572,6 +590,7 @@ public static Mass FromPounds(double pounds) double value = (double) pounds; return new Mass(value, MassUnit.Pound); } + /// /// Creates a from . /// @@ -582,6 +601,7 @@ public static Mass FromShortHundredweight(double shorthundredweight) double value = (double) shorthundredweight; return new Mass(value, MassUnit.ShortHundredweight); } + /// /// Creates a from . /// @@ -592,6 +612,7 @@ public static Mass FromShortTons(double shorttons) double value = (double) shorttons; return new Mass(value, MassUnit.ShortTon); } + /// /// Creates a from . /// @@ -602,6 +623,7 @@ public static Mass FromSlugs(double slugs) double value = (double) slugs; return new Mass(value, MassUnit.Slug); } + /// /// Creates a from . /// @@ -612,6 +634,7 @@ public static Mass FromSolarMasses(double solarmasses) double value = (double) solarmasses; return new Mass(value, MassUnit.SolarMass); } + /// /// Creates a from . /// @@ -622,6 +645,7 @@ public static Mass FromStone(double stone) double value = (double) stone; return new Mass(value, MassUnit.Stone); } + /// /// Creates a from . /// @@ -633,6 +657,7 @@ public static Mass FromTonnes(double tonnes) return new Mass(value, MassUnit.Tonne); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassConcentration.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassConcentration.g.cs index 4d637de881..6debb2eb8b 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassConcentration.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassConcentration.g.cs @@ -508,6 +508,7 @@ public static MassConcentration FromCentigramsPerDeciliter(double centigramsperd double value = (double) centigramsperdeciliter; return new MassConcentration(value, MassConcentrationUnit.CentigramPerDeciliter); } + /// /// Creates a from . /// @@ -518,6 +519,7 @@ public static MassConcentration FromCentigramsPerLiter(double centigramsperliter double value = (double) centigramsperliter; return new MassConcentration(value, MassConcentrationUnit.CentigramPerLiter); } + /// /// Creates a from . /// @@ -528,6 +530,7 @@ public static MassConcentration FromCentigramsPerMicroliter(double centigramsper double value = (double) centigramspermicroliter; return new MassConcentration(value, MassConcentrationUnit.CentigramPerMicroliter); } + /// /// Creates a from . /// @@ -538,6 +541,7 @@ public static MassConcentration FromCentigramsPerMilliliter(double centigramsper double value = (double) centigramspermilliliter; return new MassConcentration(value, MassConcentrationUnit.CentigramPerMilliliter); } + /// /// Creates a from . /// @@ -548,6 +552,7 @@ public static MassConcentration FromDecigramsPerDeciliter(double decigramsperdec double value = (double) decigramsperdeciliter; return new MassConcentration(value, MassConcentrationUnit.DecigramPerDeciliter); } + /// /// Creates a from . /// @@ -558,6 +563,7 @@ public static MassConcentration FromDecigramsPerLiter(double decigramsperliter) double value = (double) decigramsperliter; return new MassConcentration(value, MassConcentrationUnit.DecigramPerLiter); } + /// /// Creates a from . /// @@ -568,6 +574,7 @@ public static MassConcentration FromDecigramsPerMicroliter(double decigramspermi double value = (double) decigramspermicroliter; return new MassConcentration(value, MassConcentrationUnit.DecigramPerMicroliter); } + /// /// Creates a from . /// @@ -578,6 +585,7 @@ public static MassConcentration FromDecigramsPerMilliliter(double decigramspermi double value = (double) decigramspermilliliter; return new MassConcentration(value, MassConcentrationUnit.DecigramPerMilliliter); } + /// /// Creates a from . /// @@ -588,6 +596,7 @@ public static MassConcentration FromGramsPerCubicCentimeter(double gramspercubic double value = (double) gramspercubiccentimeter; return new MassConcentration(value, MassConcentrationUnit.GramPerCubicCentimeter); } + /// /// Creates a from . /// @@ -598,6 +607,7 @@ public static MassConcentration FromGramsPerCubicMeter(double gramspercubicmeter double value = (double) gramspercubicmeter; return new MassConcentration(value, MassConcentrationUnit.GramPerCubicMeter); } + /// /// Creates a from . /// @@ -608,6 +618,7 @@ public static MassConcentration FromGramsPerCubicMillimeter(double gramspercubic double value = (double) gramspercubicmillimeter; return new MassConcentration(value, MassConcentrationUnit.GramPerCubicMillimeter); } + /// /// Creates a from . /// @@ -618,6 +629,7 @@ public static MassConcentration FromGramsPerDeciliter(double gramsperdeciliter) double value = (double) gramsperdeciliter; return new MassConcentration(value, MassConcentrationUnit.GramPerDeciliter); } + /// /// Creates a from . /// @@ -628,6 +640,7 @@ public static MassConcentration FromGramsPerLiter(double gramsperliter) double value = (double) gramsperliter; return new MassConcentration(value, MassConcentrationUnit.GramPerLiter); } + /// /// Creates a from . /// @@ -638,6 +651,7 @@ public static MassConcentration FromGramsPerMicroliter(double gramspermicroliter double value = (double) gramspermicroliter; return new MassConcentration(value, MassConcentrationUnit.GramPerMicroliter); } + /// /// Creates a from . /// @@ -648,6 +662,7 @@ public static MassConcentration FromGramsPerMilliliter(double gramspermilliliter double value = (double) gramspermilliliter; return new MassConcentration(value, MassConcentrationUnit.GramPerMilliliter); } + /// /// Creates a from . /// @@ -658,6 +673,7 @@ public static MassConcentration FromKilogramsPerCubicCentimeter(double kilograms double value = (double) kilogramspercubiccentimeter; return new MassConcentration(value, MassConcentrationUnit.KilogramPerCubicCentimeter); } + /// /// Creates a from . /// @@ -668,6 +684,7 @@ public static MassConcentration FromKilogramsPerCubicMeter(double kilogramspercu double value = (double) kilogramspercubicmeter; return new MassConcentration(value, MassConcentrationUnit.KilogramPerCubicMeter); } + /// /// Creates a from . /// @@ -678,6 +695,7 @@ public static MassConcentration FromKilogramsPerCubicMillimeter(double kilograms double value = (double) kilogramspercubicmillimeter; return new MassConcentration(value, MassConcentrationUnit.KilogramPerCubicMillimeter); } + /// /// Creates a from . /// @@ -688,6 +706,7 @@ public static MassConcentration FromKilogramsPerLiter(double kilogramsperliter) double value = (double) kilogramsperliter; return new MassConcentration(value, MassConcentrationUnit.KilogramPerLiter); } + /// /// Creates a from . /// @@ -698,6 +717,7 @@ public static MassConcentration FromKilopoundsPerCubicFoot(double kilopoundsperc double value = (double) kilopoundspercubicfoot; return new MassConcentration(value, MassConcentrationUnit.KilopoundPerCubicFoot); } + /// /// Creates a from . /// @@ -708,6 +728,7 @@ public static MassConcentration FromKilopoundsPerCubicInch(double kilopoundsperc double value = (double) kilopoundspercubicinch; return new MassConcentration(value, MassConcentrationUnit.KilopoundPerCubicInch); } + /// /// Creates a from . /// @@ -718,6 +739,7 @@ public static MassConcentration FromMicrogramsPerCubicMeter(double microgramsper double value = (double) microgramspercubicmeter; return new MassConcentration(value, MassConcentrationUnit.MicrogramPerCubicMeter); } + /// /// Creates a from . /// @@ -728,6 +750,7 @@ public static MassConcentration FromMicrogramsPerDeciliter(double microgramsperd double value = (double) microgramsperdeciliter; return new MassConcentration(value, MassConcentrationUnit.MicrogramPerDeciliter); } + /// /// Creates a from . /// @@ -738,6 +761,7 @@ public static MassConcentration FromMicrogramsPerLiter(double microgramsperliter double value = (double) microgramsperliter; return new MassConcentration(value, MassConcentrationUnit.MicrogramPerLiter); } + /// /// Creates a from . /// @@ -748,6 +772,7 @@ public static MassConcentration FromMicrogramsPerMicroliter(double microgramsper double value = (double) microgramspermicroliter; return new MassConcentration(value, MassConcentrationUnit.MicrogramPerMicroliter); } + /// /// Creates a from . /// @@ -758,6 +783,7 @@ public static MassConcentration FromMicrogramsPerMilliliter(double microgramsper double value = (double) microgramspermilliliter; return new MassConcentration(value, MassConcentrationUnit.MicrogramPerMilliliter); } + /// /// Creates a from . /// @@ -768,6 +794,7 @@ public static MassConcentration FromMilligramsPerCubicMeter(double milligramsper double value = (double) milligramspercubicmeter; return new MassConcentration(value, MassConcentrationUnit.MilligramPerCubicMeter); } + /// /// Creates a from . /// @@ -778,6 +805,7 @@ public static MassConcentration FromMilligramsPerDeciliter(double milligramsperd double value = (double) milligramsperdeciliter; return new MassConcentration(value, MassConcentrationUnit.MilligramPerDeciliter); } + /// /// Creates a from . /// @@ -788,6 +816,7 @@ public static MassConcentration FromMilligramsPerLiter(double milligramsperliter double value = (double) milligramsperliter; return new MassConcentration(value, MassConcentrationUnit.MilligramPerLiter); } + /// /// Creates a from . /// @@ -798,6 +827,7 @@ public static MassConcentration FromMilligramsPerMicroliter(double milligramsper double value = (double) milligramspermicroliter; return new MassConcentration(value, MassConcentrationUnit.MilligramPerMicroliter); } + /// /// Creates a from . /// @@ -808,6 +838,7 @@ public static MassConcentration FromMilligramsPerMilliliter(double milligramsper double value = (double) milligramspermilliliter; return new MassConcentration(value, MassConcentrationUnit.MilligramPerMilliliter); } + /// /// Creates a from . /// @@ -818,6 +849,7 @@ public static MassConcentration FromNanogramsPerDeciliter(double nanogramsperdec double value = (double) nanogramsperdeciliter; return new MassConcentration(value, MassConcentrationUnit.NanogramPerDeciliter); } + /// /// Creates a from . /// @@ -828,6 +860,7 @@ public static MassConcentration FromNanogramsPerLiter(double nanogramsperliter) double value = (double) nanogramsperliter; return new MassConcentration(value, MassConcentrationUnit.NanogramPerLiter); } + /// /// Creates a from . /// @@ -838,6 +871,7 @@ public static MassConcentration FromNanogramsPerMicroliter(double nanogramspermi double value = (double) nanogramspermicroliter; return new MassConcentration(value, MassConcentrationUnit.NanogramPerMicroliter); } + /// /// Creates a from . /// @@ -848,6 +882,7 @@ public static MassConcentration FromNanogramsPerMilliliter(double nanogramspermi double value = (double) nanogramspermilliliter; return new MassConcentration(value, MassConcentrationUnit.NanogramPerMilliliter); } + /// /// Creates a from . /// @@ -858,6 +893,7 @@ public static MassConcentration FromOuncesPerImperialGallon(double ouncesperimpe double value = (double) ouncesperimperialgallon; return new MassConcentration(value, MassConcentrationUnit.OuncePerImperialGallon); } + /// /// Creates a from . /// @@ -868,6 +904,7 @@ public static MassConcentration FromOuncesPerUSGallon(double ouncesperusgallon) double value = (double) ouncesperusgallon; return new MassConcentration(value, MassConcentrationUnit.OuncePerUSGallon); } + /// /// Creates a from . /// @@ -878,6 +915,7 @@ public static MassConcentration FromPicogramsPerDeciliter(double picogramsperdec double value = (double) picogramsperdeciliter; return new MassConcentration(value, MassConcentrationUnit.PicogramPerDeciliter); } + /// /// Creates a from . /// @@ -888,6 +926,7 @@ public static MassConcentration FromPicogramsPerLiter(double picogramsperliter) double value = (double) picogramsperliter; return new MassConcentration(value, MassConcentrationUnit.PicogramPerLiter); } + /// /// Creates a from . /// @@ -898,6 +937,7 @@ public static MassConcentration FromPicogramsPerMicroliter(double picogramspermi double value = (double) picogramspermicroliter; return new MassConcentration(value, MassConcentrationUnit.PicogramPerMicroliter); } + /// /// Creates a from . /// @@ -908,6 +948,7 @@ public static MassConcentration FromPicogramsPerMilliliter(double picogramspermi double value = (double) picogramspermilliliter; return new MassConcentration(value, MassConcentrationUnit.PicogramPerMilliliter); } + /// /// Creates a from . /// @@ -918,6 +959,7 @@ public static MassConcentration FromPoundsPerCubicFoot(double poundspercubicfoot double value = (double) poundspercubicfoot; return new MassConcentration(value, MassConcentrationUnit.PoundPerCubicFoot); } + /// /// Creates a from . /// @@ -928,6 +970,7 @@ public static MassConcentration FromPoundsPerCubicInch(double poundspercubicinch double value = (double) poundspercubicinch; return new MassConcentration(value, MassConcentrationUnit.PoundPerCubicInch); } + /// /// Creates a from . /// @@ -938,6 +981,7 @@ public static MassConcentration FromPoundsPerImperialGallon(double poundsperimpe double value = (double) poundsperimperialgallon; return new MassConcentration(value, MassConcentrationUnit.PoundPerImperialGallon); } + /// /// Creates a from . /// @@ -948,6 +992,7 @@ public static MassConcentration FromPoundsPerUSGallon(double poundsperusgallon) double value = (double) poundsperusgallon; return new MassConcentration(value, MassConcentrationUnit.PoundPerUSGallon); } + /// /// Creates a from . /// @@ -958,6 +1003,7 @@ public static MassConcentration FromSlugsPerCubicFoot(double slugspercubicfoot) double value = (double) slugspercubicfoot; return new MassConcentration(value, MassConcentrationUnit.SlugPerCubicFoot); } + /// /// Creates a from . /// @@ -968,6 +1014,7 @@ public static MassConcentration FromTonnesPerCubicCentimeter(double tonnespercub double value = (double) tonnespercubiccentimeter; return new MassConcentration(value, MassConcentrationUnit.TonnePerCubicCentimeter); } + /// /// Creates a from . /// @@ -978,6 +1025,7 @@ public static MassConcentration FromTonnesPerCubicMeter(double tonnespercubicmet double value = (double) tonnespercubicmeter; return new MassConcentration(value, MassConcentrationUnit.TonnePerCubicMeter); } + /// /// Creates a from . /// @@ -989,6 +1037,7 @@ public static MassConcentration FromTonnesPerCubicMillimeter(double tonnespercub return new MassConcentration(value, MassConcentrationUnit.TonnePerCubicMillimeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlow.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlow.g.cs index f28f33b950..eadbcad602 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlow.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlow.g.cs @@ -407,6 +407,7 @@ public static MassFlow FromCentigramsPerDay(double centigramsperday) double value = (double) centigramsperday; return new MassFlow(value, MassFlowUnit.CentigramPerDay); } + /// /// Creates a from . /// @@ -417,6 +418,7 @@ public static MassFlow FromCentigramsPerSecond(double centigramspersecond) double value = (double) centigramspersecond; return new MassFlow(value, MassFlowUnit.CentigramPerSecond); } + /// /// Creates a from . /// @@ -427,6 +429,7 @@ public static MassFlow FromDecagramsPerDay(double decagramsperday) double value = (double) decagramsperday; return new MassFlow(value, MassFlowUnit.DecagramPerDay); } + /// /// Creates a from . /// @@ -437,6 +440,7 @@ public static MassFlow FromDecagramsPerSecond(double decagramspersecond) double value = (double) decagramspersecond; return new MassFlow(value, MassFlowUnit.DecagramPerSecond); } + /// /// Creates a from . /// @@ -447,6 +451,7 @@ public static MassFlow FromDecigramsPerDay(double decigramsperday) double value = (double) decigramsperday; return new MassFlow(value, MassFlowUnit.DecigramPerDay); } + /// /// Creates a from . /// @@ -457,6 +462,7 @@ public static MassFlow FromDecigramsPerSecond(double decigramspersecond) double value = (double) decigramspersecond; return new MassFlow(value, MassFlowUnit.DecigramPerSecond); } + /// /// Creates a from . /// @@ -467,6 +473,7 @@ public static MassFlow FromGramsPerDay(double gramsperday) double value = (double) gramsperday; return new MassFlow(value, MassFlowUnit.GramPerDay); } + /// /// Creates a from . /// @@ -477,6 +484,7 @@ public static MassFlow FromGramsPerHour(double gramsperhour) double value = (double) gramsperhour; return new MassFlow(value, MassFlowUnit.GramPerHour); } + /// /// Creates a from . /// @@ -487,6 +495,7 @@ public static MassFlow FromGramsPerSecond(double gramspersecond) double value = (double) gramspersecond; return new MassFlow(value, MassFlowUnit.GramPerSecond); } + /// /// Creates a from . /// @@ -497,6 +506,7 @@ public static MassFlow FromHectogramsPerDay(double hectogramsperday) double value = (double) hectogramsperday; return new MassFlow(value, MassFlowUnit.HectogramPerDay); } + /// /// Creates a from . /// @@ -507,6 +517,7 @@ public static MassFlow FromHectogramsPerSecond(double hectogramspersecond) double value = (double) hectogramspersecond; return new MassFlow(value, MassFlowUnit.HectogramPerSecond); } + /// /// Creates a from . /// @@ -517,6 +528,7 @@ public static MassFlow FromKilogramsPerDay(double kilogramsperday) double value = (double) kilogramsperday; return new MassFlow(value, MassFlowUnit.KilogramPerDay); } + /// /// Creates a from . /// @@ -527,6 +539,7 @@ public static MassFlow FromKilogramsPerHour(double kilogramsperhour) double value = (double) kilogramsperhour; return new MassFlow(value, MassFlowUnit.KilogramPerHour); } + /// /// Creates a from . /// @@ -537,6 +550,7 @@ public static MassFlow FromKilogramsPerMinute(double kilogramsperminute) double value = (double) kilogramsperminute; return new MassFlow(value, MassFlowUnit.KilogramPerMinute); } + /// /// Creates a from . /// @@ -547,6 +561,7 @@ public static MassFlow FromKilogramsPerSecond(double kilogramspersecond) double value = (double) kilogramspersecond; return new MassFlow(value, MassFlowUnit.KilogramPerSecond); } + /// /// Creates a from . /// @@ -557,6 +572,7 @@ public static MassFlow FromMegagramsPerDay(double megagramsperday) double value = (double) megagramsperday; return new MassFlow(value, MassFlowUnit.MegagramPerDay); } + /// /// Creates a from . /// @@ -567,6 +583,7 @@ public static MassFlow FromMegapoundsPerDay(double megapoundsperday) double value = (double) megapoundsperday; return new MassFlow(value, MassFlowUnit.MegapoundPerDay); } + /// /// Creates a from . /// @@ -577,6 +594,7 @@ public static MassFlow FromMegapoundsPerHour(double megapoundsperhour) double value = (double) megapoundsperhour; return new MassFlow(value, MassFlowUnit.MegapoundPerHour); } + /// /// Creates a from . /// @@ -587,6 +605,7 @@ public static MassFlow FromMegapoundsPerMinute(double megapoundsperminute) double value = (double) megapoundsperminute; return new MassFlow(value, MassFlowUnit.MegapoundPerMinute); } + /// /// Creates a from . /// @@ -597,6 +616,7 @@ public static MassFlow FromMegapoundsPerSecond(double megapoundspersecond) double value = (double) megapoundspersecond; return new MassFlow(value, MassFlowUnit.MegapoundPerSecond); } + /// /// Creates a from . /// @@ -607,6 +627,7 @@ public static MassFlow FromMicrogramsPerDay(double microgramsperday) double value = (double) microgramsperday; return new MassFlow(value, MassFlowUnit.MicrogramPerDay); } + /// /// Creates a from . /// @@ -617,6 +638,7 @@ public static MassFlow FromMicrogramsPerSecond(double microgramspersecond) double value = (double) microgramspersecond; return new MassFlow(value, MassFlowUnit.MicrogramPerSecond); } + /// /// Creates a from . /// @@ -627,6 +649,7 @@ public static MassFlow FromMilligramsPerDay(double milligramsperday) double value = (double) milligramsperday; return new MassFlow(value, MassFlowUnit.MilligramPerDay); } + /// /// Creates a from . /// @@ -637,6 +660,7 @@ public static MassFlow FromMilligramsPerSecond(double milligramspersecond) double value = (double) milligramspersecond; return new MassFlow(value, MassFlowUnit.MilligramPerSecond); } + /// /// Creates a from . /// @@ -647,6 +671,7 @@ public static MassFlow FromNanogramsPerDay(double nanogramsperday) double value = (double) nanogramsperday; return new MassFlow(value, MassFlowUnit.NanogramPerDay); } + /// /// Creates a from . /// @@ -657,6 +682,7 @@ public static MassFlow FromNanogramsPerSecond(double nanogramspersecond) double value = (double) nanogramspersecond; return new MassFlow(value, MassFlowUnit.NanogramPerSecond); } + /// /// Creates a from . /// @@ -667,6 +693,7 @@ public static MassFlow FromPoundsPerDay(double poundsperday) double value = (double) poundsperday; return new MassFlow(value, MassFlowUnit.PoundPerDay); } + /// /// Creates a from . /// @@ -677,6 +704,7 @@ public static MassFlow FromPoundsPerHour(double poundsperhour) double value = (double) poundsperhour; return new MassFlow(value, MassFlowUnit.PoundPerHour); } + /// /// Creates a from . /// @@ -687,6 +715,7 @@ public static MassFlow FromPoundsPerMinute(double poundsperminute) double value = (double) poundsperminute; return new MassFlow(value, MassFlowUnit.PoundPerMinute); } + /// /// Creates a from . /// @@ -697,6 +726,7 @@ public static MassFlow FromPoundsPerSecond(double poundspersecond) double value = (double) poundspersecond; return new MassFlow(value, MassFlowUnit.PoundPerSecond); } + /// /// Creates a from . /// @@ -707,6 +737,7 @@ public static MassFlow FromShortTonsPerHour(double shorttonsperhour) double value = (double) shorttonsperhour; return new MassFlow(value, MassFlowUnit.ShortTonPerHour); } + /// /// Creates a from . /// @@ -717,6 +748,7 @@ public static MassFlow FromTonnesPerDay(double tonnesperday) double value = (double) tonnesperday; return new MassFlow(value, MassFlowUnit.TonnePerDay); } + /// /// Creates a from . /// @@ -728,6 +760,7 @@ public static MassFlow FromTonnesPerHour(double tonnesperhour) return new MassFlow(value, MassFlowUnit.TonnePerHour); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlux.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlux.g.cs index c645fc1182..d8beaaf0d3 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlux.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlux.g.cs @@ -279,6 +279,7 @@ public static MassFlux FromGramsPerHourPerSquareCentimeter(double gramsperhourpe double value = (double) gramsperhourpersquarecentimeter; return new MassFlux(value, MassFluxUnit.GramPerHourPerSquareCentimeter); } + /// /// Creates a from . /// @@ -289,6 +290,7 @@ public static MassFlux FromGramsPerHourPerSquareMeter(double gramsperhourpersqua double value = (double) gramsperhourpersquaremeter; return new MassFlux(value, MassFluxUnit.GramPerHourPerSquareMeter); } + /// /// Creates a from . /// @@ -299,6 +301,7 @@ public static MassFlux FromGramsPerHourPerSquareMillimeter(double gramsperhourpe double value = (double) gramsperhourpersquaremillimeter; return new MassFlux(value, MassFluxUnit.GramPerHourPerSquareMillimeter); } + /// /// Creates a from . /// @@ -309,6 +312,7 @@ public static MassFlux FromGramsPerSecondPerSquareCentimeter(double gramsperseco double value = (double) gramspersecondpersquarecentimeter; return new MassFlux(value, MassFluxUnit.GramPerSecondPerSquareCentimeter); } + /// /// Creates a from . /// @@ -319,6 +323,7 @@ public static MassFlux FromGramsPerSecondPerSquareMeter(double gramspersecondper double value = (double) gramspersecondpersquaremeter; return new MassFlux(value, MassFluxUnit.GramPerSecondPerSquareMeter); } + /// /// Creates a from . /// @@ -329,6 +334,7 @@ public static MassFlux FromGramsPerSecondPerSquareMillimeter(double gramsperseco double value = (double) gramspersecondpersquaremillimeter; return new MassFlux(value, MassFluxUnit.GramPerSecondPerSquareMillimeter); } + /// /// Creates a from . /// @@ -339,6 +345,7 @@ public static MassFlux FromKilogramsPerHourPerSquareCentimeter(double kilogramsp double value = (double) kilogramsperhourpersquarecentimeter; return new MassFlux(value, MassFluxUnit.KilogramPerHourPerSquareCentimeter); } + /// /// Creates a from . /// @@ -349,6 +356,7 @@ public static MassFlux FromKilogramsPerHourPerSquareMeter(double kilogramsperhou double value = (double) kilogramsperhourpersquaremeter; return new MassFlux(value, MassFluxUnit.KilogramPerHourPerSquareMeter); } + /// /// Creates a from . /// @@ -359,6 +367,7 @@ public static MassFlux FromKilogramsPerHourPerSquareMillimeter(double kilogramsp double value = (double) kilogramsperhourpersquaremillimeter; return new MassFlux(value, MassFluxUnit.KilogramPerHourPerSquareMillimeter); } + /// /// Creates a from . /// @@ -369,6 +378,7 @@ public static MassFlux FromKilogramsPerSecondPerSquareCentimeter(double kilogram double value = (double) kilogramspersecondpersquarecentimeter; return new MassFlux(value, MassFluxUnit.KilogramPerSecondPerSquareCentimeter); } + /// /// Creates a from . /// @@ -379,6 +389,7 @@ public static MassFlux FromKilogramsPerSecondPerSquareMeter(double kilogramspers double value = (double) kilogramspersecondpersquaremeter; return new MassFlux(value, MassFluxUnit.KilogramPerSecondPerSquareMeter); } + /// /// Creates a from . /// @@ -390,6 +401,7 @@ public static MassFlux FromKilogramsPerSecondPerSquareMillimeter(double kilogram return new MassFlux(value, MassFluxUnit.KilogramPerSecondPerSquareMillimeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFraction.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFraction.g.cs index 2f60af0b3a..fb71faec90 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFraction.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFraction.g.cs @@ -354,6 +354,7 @@ public static MassFraction FromCentigramsPerGram(double centigramspergram) double value = (double) centigramspergram; return new MassFraction(value, MassFractionUnit.CentigramPerGram); } + /// /// Creates a from . /// @@ -364,6 +365,7 @@ public static MassFraction FromCentigramsPerKilogram(double centigramsperkilogra double value = (double) centigramsperkilogram; return new MassFraction(value, MassFractionUnit.CentigramPerKilogram); } + /// /// Creates a from . /// @@ -374,6 +376,7 @@ public static MassFraction FromDecagramsPerGram(double decagramspergram) double value = (double) decagramspergram; return new MassFraction(value, MassFractionUnit.DecagramPerGram); } + /// /// Creates a from . /// @@ -384,6 +387,7 @@ public static MassFraction FromDecagramsPerKilogram(double decagramsperkilogram) double value = (double) decagramsperkilogram; return new MassFraction(value, MassFractionUnit.DecagramPerKilogram); } + /// /// Creates a from . /// @@ -394,6 +398,7 @@ public static MassFraction FromDecigramsPerGram(double decigramspergram) double value = (double) decigramspergram; return new MassFraction(value, MassFractionUnit.DecigramPerGram); } + /// /// Creates a from . /// @@ -404,6 +409,7 @@ public static MassFraction FromDecigramsPerKilogram(double decigramsperkilogram) double value = (double) decigramsperkilogram; return new MassFraction(value, MassFractionUnit.DecigramPerKilogram); } + /// /// Creates a from . /// @@ -414,6 +420,7 @@ public static MassFraction FromDecimalFractions(double decimalfractions) double value = (double) decimalfractions; return new MassFraction(value, MassFractionUnit.DecimalFraction); } + /// /// Creates a from . /// @@ -424,6 +431,7 @@ public static MassFraction FromGramsPerGram(double gramspergram) double value = (double) gramspergram; return new MassFraction(value, MassFractionUnit.GramPerGram); } + /// /// Creates a from . /// @@ -434,6 +442,7 @@ public static MassFraction FromGramsPerKilogram(double gramsperkilogram) double value = (double) gramsperkilogram; return new MassFraction(value, MassFractionUnit.GramPerKilogram); } + /// /// Creates a from . /// @@ -444,6 +453,7 @@ public static MassFraction FromHectogramsPerGram(double hectogramspergram) double value = (double) hectogramspergram; return new MassFraction(value, MassFractionUnit.HectogramPerGram); } + /// /// Creates a from . /// @@ -454,6 +464,7 @@ public static MassFraction FromHectogramsPerKilogram(double hectogramsperkilogra double value = (double) hectogramsperkilogram; return new MassFraction(value, MassFractionUnit.HectogramPerKilogram); } + /// /// Creates a from . /// @@ -464,6 +475,7 @@ public static MassFraction FromKilogramsPerGram(double kilogramspergram) double value = (double) kilogramspergram; return new MassFraction(value, MassFractionUnit.KilogramPerGram); } + /// /// Creates a from . /// @@ -474,6 +486,7 @@ public static MassFraction FromKilogramsPerKilogram(double kilogramsperkilogram) double value = (double) kilogramsperkilogram; return new MassFraction(value, MassFractionUnit.KilogramPerKilogram); } + /// /// Creates a from . /// @@ -484,6 +497,7 @@ public static MassFraction FromMicrogramsPerGram(double microgramspergram) double value = (double) microgramspergram; return new MassFraction(value, MassFractionUnit.MicrogramPerGram); } + /// /// Creates a from . /// @@ -494,6 +508,7 @@ public static MassFraction FromMicrogramsPerKilogram(double microgramsperkilogra double value = (double) microgramsperkilogram; return new MassFraction(value, MassFractionUnit.MicrogramPerKilogram); } + /// /// Creates a from . /// @@ -504,6 +519,7 @@ public static MassFraction FromMilligramsPerGram(double milligramspergram) double value = (double) milligramspergram; return new MassFraction(value, MassFractionUnit.MilligramPerGram); } + /// /// Creates a from . /// @@ -514,6 +530,7 @@ public static MassFraction FromMilligramsPerKilogram(double milligramsperkilogra double value = (double) milligramsperkilogram; return new MassFraction(value, MassFractionUnit.MilligramPerKilogram); } + /// /// Creates a from . /// @@ -524,6 +541,7 @@ public static MassFraction FromNanogramsPerGram(double nanogramspergram) double value = (double) nanogramspergram; return new MassFraction(value, MassFractionUnit.NanogramPerGram); } + /// /// Creates a from . /// @@ -534,6 +552,7 @@ public static MassFraction FromNanogramsPerKilogram(double nanogramsperkilogram) double value = (double) nanogramsperkilogram; return new MassFraction(value, MassFractionUnit.NanogramPerKilogram); } + /// /// Creates a from . /// @@ -544,6 +563,7 @@ public static MassFraction FromPartsPerBillion(double partsperbillion) double value = (double) partsperbillion; return new MassFraction(value, MassFractionUnit.PartPerBillion); } + /// /// Creates a from . /// @@ -554,6 +574,7 @@ public static MassFraction FromPartsPerMillion(double partspermillion) double value = (double) partspermillion; return new MassFraction(value, MassFractionUnit.PartPerMillion); } + /// /// Creates a from . /// @@ -564,6 +585,7 @@ public static MassFraction FromPartsPerThousand(double partsperthousand) double value = (double) partsperthousand; return new MassFraction(value, MassFractionUnit.PartPerThousand); } + /// /// Creates a from . /// @@ -574,6 +596,7 @@ public static MassFraction FromPartsPerTrillion(double partspertrillion) double value = (double) partspertrillion; return new MassFraction(value, MassFractionUnit.PartPerTrillion); } + /// /// Creates a from . /// @@ -585,6 +608,7 @@ public static MassFraction FromPercent(double percent) return new MassFraction(value, MassFractionUnit.Percent); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassMomentOfInertia.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassMomentOfInertia.g.cs index 74bcfc0225..dd05a4ec89 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassMomentOfInertia.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassMomentOfInertia.g.cs @@ -375,6 +375,7 @@ public static MassMomentOfInertia FromGramSquareCentimeters(double gramsquarecen double value = (double) gramsquarecentimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareCentimeter); } + /// /// Creates a from . /// @@ -385,6 +386,7 @@ public static MassMomentOfInertia FromGramSquareDecimeters(double gramsquaredeci double value = (double) gramsquaredecimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareDecimeter); } + /// /// Creates a from . /// @@ -395,6 +397,7 @@ public static MassMomentOfInertia FromGramSquareMeters(double gramsquaremeters) double value = (double) gramsquaremeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareMeter); } + /// /// Creates a from . /// @@ -405,6 +408,7 @@ public static MassMomentOfInertia FromGramSquareMillimeters(double gramsquaremil double value = (double) gramsquaremillimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareMillimeter); } + /// /// Creates a from . /// @@ -415,6 +419,7 @@ public static MassMomentOfInertia FromKilogramSquareCentimeters(double kilograms double value = (double) kilogramsquarecentimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareCentimeter); } + /// /// Creates a from . /// @@ -425,6 +430,7 @@ public static MassMomentOfInertia FromKilogramSquareDecimeters(double kilogramsq double value = (double) kilogramsquaredecimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareDecimeter); } + /// /// Creates a from . /// @@ -435,6 +441,7 @@ public static MassMomentOfInertia FromKilogramSquareMeters(double kilogramsquare double value = (double) kilogramsquaremeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareMeter); } + /// /// Creates a from . /// @@ -445,6 +452,7 @@ public static MassMomentOfInertia FromKilogramSquareMillimeters(double kilograms double value = (double) kilogramsquaremillimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareMillimeter); } + /// /// Creates a from . /// @@ -455,6 +463,7 @@ public static MassMomentOfInertia FromKilotonneSquareCentimeters(double kilotonn double value = (double) kilotonnesquarecentimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareCentimeter); } + /// /// Creates a from . /// @@ -465,6 +474,7 @@ public static MassMomentOfInertia FromKilotonneSquareDecimeters(double kilotonne double value = (double) kilotonnesquaredecimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareDecimeter); } + /// /// Creates a from . /// @@ -475,6 +485,7 @@ public static MassMomentOfInertia FromKilotonneSquareMeters(double kilotonnesqua double value = (double) kilotonnesquaremeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareMeter); } + /// /// Creates a from . /// @@ -485,6 +496,7 @@ public static MassMomentOfInertia FromKilotonneSquareMilimeters(double kilotonne double value = (double) kilotonnesquaremilimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareMilimeter); } + /// /// Creates a from . /// @@ -495,6 +507,7 @@ public static MassMomentOfInertia FromMegatonneSquareCentimeters(double megatonn double value = (double) megatonnesquarecentimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareCentimeter); } + /// /// Creates a from . /// @@ -505,6 +518,7 @@ public static MassMomentOfInertia FromMegatonneSquareDecimeters(double megatonne double value = (double) megatonnesquaredecimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareDecimeter); } + /// /// Creates a from . /// @@ -515,6 +529,7 @@ public static MassMomentOfInertia FromMegatonneSquareMeters(double megatonnesqua double value = (double) megatonnesquaremeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareMeter); } + /// /// Creates a from . /// @@ -525,6 +540,7 @@ public static MassMomentOfInertia FromMegatonneSquareMilimeters(double megatonne double value = (double) megatonnesquaremilimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareMilimeter); } + /// /// Creates a from . /// @@ -535,6 +551,7 @@ public static MassMomentOfInertia FromMilligramSquareCentimeters(double milligra double value = (double) milligramsquarecentimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareCentimeter); } + /// /// Creates a from . /// @@ -545,6 +562,7 @@ public static MassMomentOfInertia FromMilligramSquareDecimeters(double milligram double value = (double) milligramsquaredecimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareDecimeter); } + /// /// Creates a from . /// @@ -555,6 +573,7 @@ public static MassMomentOfInertia FromMilligramSquareMeters(double milligramsqua double value = (double) milligramsquaremeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareMeter); } + /// /// Creates a from . /// @@ -565,6 +584,7 @@ public static MassMomentOfInertia FromMilligramSquareMillimeters(double milligra double value = (double) milligramsquaremillimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareMillimeter); } + /// /// Creates a from . /// @@ -575,6 +595,7 @@ public static MassMomentOfInertia FromPoundSquareFeet(double poundsquarefeet) double value = (double) poundsquarefeet; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.PoundSquareFoot); } + /// /// Creates a from . /// @@ -585,6 +606,7 @@ public static MassMomentOfInertia FromPoundSquareInches(double poundsquareinches double value = (double) poundsquareinches; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.PoundSquareInch); } + /// /// Creates a from . /// @@ -595,6 +617,7 @@ public static MassMomentOfInertia FromSlugSquareFeet(double slugsquarefeet) double value = (double) slugsquarefeet; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.SlugSquareFoot); } + /// /// Creates a from . /// @@ -605,6 +628,7 @@ public static MassMomentOfInertia FromSlugSquareInches(double slugsquareinches) double value = (double) slugsquareinches; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.SlugSquareInch); } + /// /// Creates a from . /// @@ -615,6 +639,7 @@ public static MassMomentOfInertia FromTonneSquareCentimeters(double tonnesquarec double value = (double) tonnesquarecentimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareCentimeter); } + /// /// Creates a from . /// @@ -625,6 +650,7 @@ public static MassMomentOfInertia FromTonneSquareDecimeters(double tonnesquarede double value = (double) tonnesquaredecimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareDecimeter); } + /// /// Creates a from . /// @@ -635,6 +661,7 @@ public static MassMomentOfInertia FromTonneSquareMeters(double tonnesquaremeters double value = (double) tonnesquaremeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareMeter); } + /// /// Creates a from . /// @@ -646,6 +673,7 @@ public static MassMomentOfInertia FromTonneSquareMilimeters(double tonnesquaremi return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareMilimeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEnergy.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEnergy.g.cs index d2e4502b0f..116324a145 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEnergy.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEnergy.g.cs @@ -225,6 +225,7 @@ public static MolarEnergy FromJoulesPerMole(double joulespermole) double value = (double) joulespermole; return new MolarEnergy(value, MolarEnergyUnit.JoulePerMole); } + /// /// Creates a from . /// @@ -235,6 +236,7 @@ public static MolarEnergy FromKilojoulesPerMole(double kilojoulespermole) double value = (double) kilojoulespermole; return new MolarEnergy(value, MolarEnergyUnit.KilojoulePerMole); } + /// /// Creates a from . /// @@ -246,6 +248,7 @@ public static MolarEnergy FromMegajoulesPerMole(double megajoulespermole) return new MolarEnergy(value, MolarEnergyUnit.MegajoulePerMole); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEntropy.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEntropy.g.cs index 5e60a71653..47ff01ae00 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEntropy.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEntropy.g.cs @@ -225,6 +225,7 @@ public static MolarEntropy FromJoulesPerMoleKelvin(double joulespermolekelvin) double value = (double) joulespermolekelvin; return new MolarEntropy(value, MolarEntropyUnit.JoulePerMoleKelvin); } + /// /// Creates a from . /// @@ -235,6 +236,7 @@ public static MolarEntropy FromKilojoulesPerMoleKelvin(double kilojoulespermolek double value = (double) kilojoulespermolekelvin; return new MolarEntropy(value, MolarEntropyUnit.KilojoulePerMoleKelvin); } + /// /// Creates a from . /// @@ -246,6 +248,7 @@ public static MolarEntropy FromMegajoulesPerMoleKelvin(double megajoulespermolek return new MolarEntropy(value, MolarEntropyUnit.MegajoulePerMoleKelvin); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarMass.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarMass.g.cs index 61dbf93742..0d37e1bec2 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarMass.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarMass.g.cs @@ -291,6 +291,7 @@ public static MolarMass FromCentigramsPerMole(double centigramspermole) double value = (double) centigramspermole; return new MolarMass(value, MolarMassUnit.CentigramPerMole); } + /// /// Creates a from . /// @@ -301,6 +302,7 @@ public static MolarMass FromDecagramsPerMole(double decagramspermole) double value = (double) decagramspermole; return new MolarMass(value, MolarMassUnit.DecagramPerMole); } + /// /// Creates a from . /// @@ -311,6 +313,7 @@ public static MolarMass FromDecigramsPerMole(double decigramspermole) double value = (double) decigramspermole; return new MolarMass(value, MolarMassUnit.DecigramPerMole); } + /// /// Creates a from . /// @@ -321,6 +324,7 @@ public static MolarMass FromGramsPerMole(double gramspermole) double value = (double) gramspermole; return new MolarMass(value, MolarMassUnit.GramPerMole); } + /// /// Creates a from . /// @@ -331,6 +335,7 @@ public static MolarMass FromHectogramsPerMole(double hectogramspermole) double value = (double) hectogramspermole; return new MolarMass(value, MolarMassUnit.HectogramPerMole); } + /// /// Creates a from . /// @@ -341,6 +346,7 @@ public static MolarMass FromKilogramsPerMole(double kilogramspermole) double value = (double) kilogramspermole; return new MolarMass(value, MolarMassUnit.KilogramPerMole); } + /// /// Creates a from . /// @@ -351,6 +357,7 @@ public static MolarMass FromKilopoundsPerMole(double kilopoundspermole) double value = (double) kilopoundspermole; return new MolarMass(value, MolarMassUnit.KilopoundPerMole); } + /// /// Creates a from . /// @@ -361,6 +368,7 @@ public static MolarMass FromMegapoundsPerMole(double megapoundspermole) double value = (double) megapoundspermole; return new MolarMass(value, MolarMassUnit.MegapoundPerMole); } + /// /// Creates a from . /// @@ -371,6 +379,7 @@ public static MolarMass FromMicrogramsPerMole(double microgramspermole) double value = (double) microgramspermole; return new MolarMass(value, MolarMassUnit.MicrogramPerMole); } + /// /// Creates a from . /// @@ -381,6 +390,7 @@ public static MolarMass FromMilligramsPerMole(double milligramspermole) double value = (double) milligramspermole; return new MolarMass(value, MolarMassUnit.MilligramPerMole); } + /// /// Creates a from . /// @@ -391,6 +401,7 @@ public static MolarMass FromNanogramsPerMole(double nanogramspermole) double value = (double) nanogramspermole; return new MolarMass(value, MolarMassUnit.NanogramPerMole); } + /// /// Creates a from . /// @@ -402,6 +413,7 @@ public static MolarMass FromPoundsPerMole(double poundspermole) return new MolarMass(value, MolarMassUnit.PoundPerMole); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Molarity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Molarity.g.cs index 6668649bdb..017de90a3b 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Molarity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Molarity.g.cs @@ -266,6 +266,7 @@ public static Molarity FromCentimolesPerLiter(double centimolesperliter) double value = (double) centimolesperliter; return new Molarity(value, MolarityUnit.CentimolePerLiter); } + /// /// Creates a from . /// @@ -276,6 +277,7 @@ public static Molarity FromDecimolesPerLiter(double decimolesperliter) double value = (double) decimolesperliter; return new Molarity(value, MolarityUnit.DecimolePerLiter); } + /// /// Creates a from . /// @@ -286,6 +288,7 @@ public static Molarity FromMicromolesPerLiter(double micromolesperliter) double value = (double) micromolesperliter; return new Molarity(value, MolarityUnit.MicromolePerLiter); } + /// /// Creates a from . /// @@ -296,6 +299,7 @@ public static Molarity FromMillimolesPerLiter(double millimolesperliter) double value = (double) millimolesperliter; return new Molarity(value, MolarityUnit.MillimolePerLiter); } + /// /// Creates a from . /// @@ -306,6 +310,7 @@ public static Molarity FromMolesPerCubicMeter(double molespercubicmeter) double value = (double) molespercubicmeter; return new Molarity(value, MolarityUnit.MolePerCubicMeter); } + /// /// Creates a from . /// @@ -316,6 +321,7 @@ public static Molarity FromMolesPerLiter(double molesperliter) double value = (double) molesperliter; return new Molarity(value, MolarityUnit.MolePerLiter); } + /// /// Creates a from . /// @@ -326,6 +332,7 @@ public static Molarity FromNanomolesPerLiter(double nanomolesperliter) double value = (double) nanomolesperliter; return new Molarity(value, MolarityUnit.NanomolePerLiter); } + /// /// Creates a from . /// @@ -337,6 +344,7 @@ public static Molarity FromPicomolesPerLiter(double picomolesperliter) return new Molarity(value, MolarityUnit.PicomolePerLiter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permeability.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permeability.g.cs index 534a6d21c2..fe8e116fb7 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permeability.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permeability.g.cs @@ -217,6 +217,7 @@ public static Permeability FromHenriesPerMeter(double henriespermeter) return new Permeability(value, PermeabilityUnit.HenryPerMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permittivity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permittivity.g.cs index 78a9b9efb8..664f3e9f7a 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permittivity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permittivity.g.cs @@ -217,6 +217,7 @@ public static Permittivity FromFaradsPerMeter(double faradspermeter) return new Permittivity(value, PermittivityUnit.FaradPerMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Power.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Power.g.cs index 988319028f..234727e48d 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Power.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Power.g.cs @@ -357,6 +357,7 @@ public static Power FromBoilerHorsepower(double boilerhorsepower) decimal value = (decimal) boilerhorsepower; return new Power(value, PowerUnit.BoilerHorsepower); } + /// /// Creates a from . /// @@ -367,6 +368,7 @@ public static Power FromBritishThermalUnitsPerHour(double britishthermalunitsper decimal value = (decimal) britishthermalunitsperhour; return new Power(value, PowerUnit.BritishThermalUnitPerHour); } + /// /// Creates a from . /// @@ -377,6 +379,7 @@ public static Power FromDecawatts(double decawatts) decimal value = (decimal) decawatts; return new Power(value, PowerUnit.Decawatt); } + /// /// Creates a from . /// @@ -387,6 +390,7 @@ public static Power FromDeciwatts(double deciwatts) decimal value = (decimal) deciwatts; return new Power(value, PowerUnit.Deciwatt); } + /// /// Creates a from . /// @@ -397,6 +401,7 @@ public static Power FromElectricalHorsepower(double electricalhorsepower) decimal value = (decimal) electricalhorsepower; return new Power(value, PowerUnit.ElectricalHorsepower); } + /// /// Creates a from . /// @@ -407,6 +412,7 @@ public static Power FromFemtowatts(double femtowatts) decimal value = (decimal) femtowatts; return new Power(value, PowerUnit.Femtowatt); } + /// /// Creates a from . /// @@ -417,6 +423,7 @@ public static Power FromGigajoulesPerHour(double gigajoulesperhour) decimal value = (decimal) gigajoulesperhour; return new Power(value, PowerUnit.GigajoulePerHour); } + /// /// Creates a from . /// @@ -427,6 +434,7 @@ public static Power FromGigawatts(double gigawatts) decimal value = (decimal) gigawatts; return new Power(value, PowerUnit.Gigawatt); } + /// /// Creates a from . /// @@ -437,6 +445,7 @@ public static Power FromHydraulicHorsepower(double hydraulichorsepower) decimal value = (decimal) hydraulichorsepower; return new Power(value, PowerUnit.HydraulicHorsepower); } + /// /// Creates a from . /// @@ -447,6 +456,7 @@ public static Power FromJoulesPerHour(double joulesperhour) decimal value = (decimal) joulesperhour; return new Power(value, PowerUnit.JoulePerHour); } + /// /// Creates a from . /// @@ -457,6 +467,7 @@ public static Power FromKilobritishThermalUnitsPerHour(double kilobritishthermal decimal value = (decimal) kilobritishthermalunitsperhour; return new Power(value, PowerUnit.KilobritishThermalUnitPerHour); } + /// /// Creates a from . /// @@ -467,6 +478,7 @@ public static Power FromKilojoulesPerHour(double kilojoulesperhour) decimal value = (decimal) kilojoulesperhour; return new Power(value, PowerUnit.KilojoulePerHour); } + /// /// Creates a from . /// @@ -477,6 +489,7 @@ public static Power FromKilowatts(double kilowatts) decimal value = (decimal) kilowatts; return new Power(value, PowerUnit.Kilowatt); } + /// /// Creates a from . /// @@ -487,6 +500,7 @@ public static Power FromMechanicalHorsepower(double mechanicalhorsepower) decimal value = (decimal) mechanicalhorsepower; return new Power(value, PowerUnit.MechanicalHorsepower); } + /// /// Creates a from . /// @@ -497,6 +511,7 @@ public static Power FromMegajoulesPerHour(double megajoulesperhour) decimal value = (decimal) megajoulesperhour; return new Power(value, PowerUnit.MegajoulePerHour); } + /// /// Creates a from . /// @@ -507,6 +522,7 @@ public static Power FromMegawatts(double megawatts) decimal value = (decimal) megawatts; return new Power(value, PowerUnit.Megawatt); } + /// /// Creates a from . /// @@ -517,6 +533,7 @@ public static Power FromMetricHorsepower(double metrichorsepower) decimal value = (decimal) metrichorsepower; return new Power(value, PowerUnit.MetricHorsepower); } + /// /// Creates a from . /// @@ -527,6 +544,7 @@ public static Power FromMicrowatts(double microwatts) decimal value = (decimal) microwatts; return new Power(value, PowerUnit.Microwatt); } + /// /// Creates a from . /// @@ -537,6 +555,7 @@ public static Power FromMillijoulesPerHour(double millijoulesperhour) decimal value = (decimal) millijoulesperhour; return new Power(value, PowerUnit.MillijoulePerHour); } + /// /// Creates a from . /// @@ -547,6 +566,7 @@ public static Power FromMilliwatts(double milliwatts) decimal value = (decimal) milliwatts; return new Power(value, PowerUnit.Milliwatt); } + /// /// Creates a from . /// @@ -557,6 +577,7 @@ public static Power FromNanowatts(double nanowatts) decimal value = (decimal) nanowatts; return new Power(value, PowerUnit.Nanowatt); } + /// /// Creates a from . /// @@ -567,6 +588,7 @@ public static Power FromPetawatts(double petawatts) decimal value = (decimal) petawatts; return new Power(value, PowerUnit.Petawatt); } + /// /// Creates a from . /// @@ -577,6 +599,7 @@ public static Power FromPicowatts(double picowatts) decimal value = (decimal) picowatts; return new Power(value, PowerUnit.Picowatt); } + /// /// Creates a from . /// @@ -587,6 +610,7 @@ public static Power FromTerawatts(double terawatts) decimal value = (decimal) terawatts; return new Power(value, PowerUnit.Terawatt); } + /// /// Creates a from . /// @@ -598,6 +622,7 @@ public static Power FromWatts(double watts) return new Power(value, PowerUnit.Watt); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerDensity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerDensity.g.cs index 08cecdb668..648746e15a 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerDensity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerDensity.g.cs @@ -471,6 +471,7 @@ public static PowerDensity FromDecawattsPerCubicFoot(double decawattspercubicfoo double value = (double) decawattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.DecawattPerCubicFoot); } + /// /// Creates a from . /// @@ -481,6 +482,7 @@ public static PowerDensity FromDecawattsPerCubicInch(double decawattspercubicinc double value = (double) decawattspercubicinch; return new PowerDensity(value, PowerDensityUnit.DecawattPerCubicInch); } + /// /// Creates a from . /// @@ -491,6 +493,7 @@ public static PowerDensity FromDecawattsPerCubicMeter(double decawattspercubicme double value = (double) decawattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.DecawattPerCubicMeter); } + /// /// Creates a from . /// @@ -501,6 +504,7 @@ public static PowerDensity FromDecawattsPerLiter(double decawattsperliter) double value = (double) decawattsperliter; return new PowerDensity(value, PowerDensityUnit.DecawattPerLiter); } + /// /// Creates a from . /// @@ -511,6 +515,7 @@ public static PowerDensity FromDeciwattsPerCubicFoot(double deciwattspercubicfoo double value = (double) deciwattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.DeciwattPerCubicFoot); } + /// /// Creates a from . /// @@ -521,6 +526,7 @@ public static PowerDensity FromDeciwattsPerCubicInch(double deciwattspercubicinc double value = (double) deciwattspercubicinch; return new PowerDensity(value, PowerDensityUnit.DeciwattPerCubicInch); } + /// /// Creates a from . /// @@ -531,6 +537,7 @@ public static PowerDensity FromDeciwattsPerCubicMeter(double deciwattspercubicme double value = (double) deciwattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.DeciwattPerCubicMeter); } + /// /// Creates a from . /// @@ -541,6 +548,7 @@ public static PowerDensity FromDeciwattsPerLiter(double deciwattsperliter) double value = (double) deciwattsperliter; return new PowerDensity(value, PowerDensityUnit.DeciwattPerLiter); } + /// /// Creates a from . /// @@ -551,6 +559,7 @@ public static PowerDensity FromGigawattsPerCubicFoot(double gigawattspercubicfoo double value = (double) gigawattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.GigawattPerCubicFoot); } + /// /// Creates a from . /// @@ -561,6 +570,7 @@ public static PowerDensity FromGigawattsPerCubicInch(double gigawattspercubicinc double value = (double) gigawattspercubicinch; return new PowerDensity(value, PowerDensityUnit.GigawattPerCubicInch); } + /// /// Creates a from . /// @@ -571,6 +581,7 @@ public static PowerDensity FromGigawattsPerCubicMeter(double gigawattspercubicme double value = (double) gigawattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.GigawattPerCubicMeter); } + /// /// Creates a from . /// @@ -581,6 +592,7 @@ public static PowerDensity FromGigawattsPerLiter(double gigawattsperliter) double value = (double) gigawattsperliter; return new PowerDensity(value, PowerDensityUnit.GigawattPerLiter); } + /// /// Creates a from . /// @@ -591,6 +603,7 @@ public static PowerDensity FromKilowattsPerCubicFoot(double kilowattspercubicfoo double value = (double) kilowattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.KilowattPerCubicFoot); } + /// /// Creates a from . /// @@ -601,6 +614,7 @@ public static PowerDensity FromKilowattsPerCubicInch(double kilowattspercubicinc double value = (double) kilowattspercubicinch; return new PowerDensity(value, PowerDensityUnit.KilowattPerCubicInch); } + /// /// Creates a from . /// @@ -611,6 +625,7 @@ public static PowerDensity FromKilowattsPerCubicMeter(double kilowattspercubicme double value = (double) kilowattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.KilowattPerCubicMeter); } + /// /// Creates a from . /// @@ -621,6 +636,7 @@ public static PowerDensity FromKilowattsPerLiter(double kilowattsperliter) double value = (double) kilowattsperliter; return new PowerDensity(value, PowerDensityUnit.KilowattPerLiter); } + /// /// Creates a from . /// @@ -631,6 +647,7 @@ public static PowerDensity FromMegawattsPerCubicFoot(double megawattspercubicfoo double value = (double) megawattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.MegawattPerCubicFoot); } + /// /// Creates a from . /// @@ -641,6 +658,7 @@ public static PowerDensity FromMegawattsPerCubicInch(double megawattspercubicinc double value = (double) megawattspercubicinch; return new PowerDensity(value, PowerDensityUnit.MegawattPerCubicInch); } + /// /// Creates a from . /// @@ -651,6 +669,7 @@ public static PowerDensity FromMegawattsPerCubicMeter(double megawattspercubicme double value = (double) megawattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.MegawattPerCubicMeter); } + /// /// Creates a from . /// @@ -661,6 +680,7 @@ public static PowerDensity FromMegawattsPerLiter(double megawattsperliter) double value = (double) megawattsperliter; return new PowerDensity(value, PowerDensityUnit.MegawattPerLiter); } + /// /// Creates a from . /// @@ -671,6 +691,7 @@ public static PowerDensity FromMicrowattsPerCubicFoot(double microwattspercubicf double value = (double) microwattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.MicrowattPerCubicFoot); } + /// /// Creates a from . /// @@ -681,6 +702,7 @@ public static PowerDensity FromMicrowattsPerCubicInch(double microwattspercubici double value = (double) microwattspercubicinch; return new PowerDensity(value, PowerDensityUnit.MicrowattPerCubicInch); } + /// /// Creates a from . /// @@ -691,6 +713,7 @@ public static PowerDensity FromMicrowattsPerCubicMeter(double microwattspercubic double value = (double) microwattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.MicrowattPerCubicMeter); } + /// /// Creates a from . /// @@ -701,6 +724,7 @@ public static PowerDensity FromMicrowattsPerLiter(double microwattsperliter) double value = (double) microwattsperliter; return new PowerDensity(value, PowerDensityUnit.MicrowattPerLiter); } + /// /// Creates a from . /// @@ -711,6 +735,7 @@ public static PowerDensity FromMilliwattsPerCubicFoot(double milliwattspercubicf double value = (double) milliwattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.MilliwattPerCubicFoot); } + /// /// Creates a from . /// @@ -721,6 +746,7 @@ public static PowerDensity FromMilliwattsPerCubicInch(double milliwattspercubici double value = (double) milliwattspercubicinch; return new PowerDensity(value, PowerDensityUnit.MilliwattPerCubicInch); } + /// /// Creates a from . /// @@ -731,6 +757,7 @@ public static PowerDensity FromMilliwattsPerCubicMeter(double milliwattspercubic double value = (double) milliwattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.MilliwattPerCubicMeter); } + /// /// Creates a from . /// @@ -741,6 +768,7 @@ public static PowerDensity FromMilliwattsPerLiter(double milliwattsperliter) double value = (double) milliwattsperliter; return new PowerDensity(value, PowerDensityUnit.MilliwattPerLiter); } + /// /// Creates a from . /// @@ -751,6 +779,7 @@ public static PowerDensity FromNanowattsPerCubicFoot(double nanowattspercubicfoo double value = (double) nanowattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.NanowattPerCubicFoot); } + /// /// Creates a from . /// @@ -761,6 +790,7 @@ public static PowerDensity FromNanowattsPerCubicInch(double nanowattspercubicinc double value = (double) nanowattspercubicinch; return new PowerDensity(value, PowerDensityUnit.NanowattPerCubicInch); } + /// /// Creates a from . /// @@ -771,6 +801,7 @@ public static PowerDensity FromNanowattsPerCubicMeter(double nanowattspercubicme double value = (double) nanowattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.NanowattPerCubicMeter); } + /// /// Creates a from . /// @@ -781,6 +812,7 @@ public static PowerDensity FromNanowattsPerLiter(double nanowattsperliter) double value = (double) nanowattsperliter; return new PowerDensity(value, PowerDensityUnit.NanowattPerLiter); } + /// /// Creates a from . /// @@ -791,6 +823,7 @@ public static PowerDensity FromPicowattsPerCubicFoot(double picowattspercubicfoo double value = (double) picowattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.PicowattPerCubicFoot); } + /// /// Creates a from . /// @@ -801,6 +834,7 @@ public static PowerDensity FromPicowattsPerCubicInch(double picowattspercubicinc double value = (double) picowattspercubicinch; return new PowerDensity(value, PowerDensityUnit.PicowattPerCubicInch); } + /// /// Creates a from . /// @@ -811,6 +845,7 @@ public static PowerDensity FromPicowattsPerCubicMeter(double picowattspercubicme double value = (double) picowattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.PicowattPerCubicMeter); } + /// /// Creates a from . /// @@ -821,6 +856,7 @@ public static PowerDensity FromPicowattsPerLiter(double picowattsperliter) double value = (double) picowattsperliter; return new PowerDensity(value, PowerDensityUnit.PicowattPerLiter); } + /// /// Creates a from . /// @@ -831,6 +867,7 @@ public static PowerDensity FromTerawattsPerCubicFoot(double terawattspercubicfoo double value = (double) terawattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.TerawattPerCubicFoot); } + /// /// Creates a from . /// @@ -841,6 +878,7 @@ public static PowerDensity FromTerawattsPerCubicInch(double terawattspercubicinc double value = (double) terawattspercubicinch; return new PowerDensity(value, PowerDensityUnit.TerawattPerCubicInch); } + /// /// Creates a from . /// @@ -851,6 +889,7 @@ public static PowerDensity FromTerawattsPerCubicMeter(double terawattspercubicme double value = (double) terawattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.TerawattPerCubicMeter); } + /// /// Creates a from . /// @@ -861,6 +900,7 @@ public static PowerDensity FromTerawattsPerLiter(double terawattsperliter) double value = (double) terawattsperliter; return new PowerDensity(value, PowerDensityUnit.TerawattPerLiter); } + /// /// Creates a from . /// @@ -871,6 +911,7 @@ public static PowerDensity FromWattsPerCubicFoot(double wattspercubicfoot) double value = (double) wattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.WattPerCubicFoot); } + /// /// Creates a from . /// @@ -881,6 +922,7 @@ public static PowerDensity FromWattsPerCubicInch(double wattspercubicinch) double value = (double) wattspercubicinch; return new PowerDensity(value, PowerDensityUnit.WattPerCubicInch); } + /// /// Creates a from . /// @@ -891,6 +933,7 @@ public static PowerDensity FromWattsPerCubicMeter(double wattspercubicmeter) double value = (double) wattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.WattPerCubicMeter); } + /// /// Creates a from . /// @@ -902,6 +945,7 @@ public static PowerDensity FromWattsPerLiter(double wattsperliter) return new PowerDensity(value, PowerDensityUnit.WattPerLiter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerRatio.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerRatio.g.cs index 07a9ae8f8b..1100cfe26e 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerRatio.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerRatio.g.cs @@ -219,6 +219,7 @@ public static PowerRatio FromDecibelMilliwatts(double decibelmilliwatts) double value = (double) decibelmilliwatts; return new PowerRatio(value, PowerRatioUnit.DecibelMilliwatt); } + /// /// Creates a from . /// @@ -230,6 +231,7 @@ public static PowerRatio FromDecibelWatts(double decibelwatts) return new PowerRatio(value, PowerRatioUnit.DecibelWatt); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Pressure.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Pressure.g.cs index 9681deed0d..37436b45f7 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Pressure.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Pressure.g.cs @@ -508,6 +508,7 @@ public static Pressure FromAtmospheres(double atmospheres) double value = (double) atmospheres; return new Pressure(value, PressureUnit.Atmosphere); } + /// /// Creates a from . /// @@ -518,6 +519,7 @@ public static Pressure FromBars(double bars) double value = (double) bars; return new Pressure(value, PressureUnit.Bar); } + /// /// Creates a from . /// @@ -528,6 +530,7 @@ public static Pressure FromCentibars(double centibars) double value = (double) centibars; return new Pressure(value, PressureUnit.Centibar); } + /// /// Creates a from . /// @@ -538,6 +541,7 @@ public static Pressure FromDecapascals(double decapascals) double value = (double) decapascals; return new Pressure(value, PressureUnit.Decapascal); } + /// /// Creates a from . /// @@ -548,6 +552,7 @@ public static Pressure FromDecibars(double decibars) double value = (double) decibars; return new Pressure(value, PressureUnit.Decibar); } + /// /// Creates a from . /// @@ -558,6 +563,7 @@ public static Pressure FromDynesPerSquareCentimeter(double dynespersquarecentime double value = (double) dynespersquarecentimeter; return new Pressure(value, PressureUnit.DynePerSquareCentimeter); } + /// /// Creates a from . /// @@ -568,6 +574,7 @@ public static Pressure FromFeetOfElevation(double feetofelevation) double value = (double) feetofelevation; return new Pressure(value, PressureUnit.FootOfElevation); } + /// /// Creates a from . /// @@ -578,6 +585,7 @@ public static Pressure FromFeetOfHead(double feetofhead) double value = (double) feetofhead; return new Pressure(value, PressureUnit.FootOfHead); } + /// /// Creates a from . /// @@ -588,6 +596,7 @@ public static Pressure FromGigapascals(double gigapascals) double value = (double) gigapascals; return new Pressure(value, PressureUnit.Gigapascal); } + /// /// Creates a from . /// @@ -598,6 +607,7 @@ public static Pressure FromHectopascals(double hectopascals) double value = (double) hectopascals; return new Pressure(value, PressureUnit.Hectopascal); } + /// /// Creates a from . /// @@ -608,6 +618,7 @@ public static Pressure FromInchesOfMercury(double inchesofmercury) double value = (double) inchesofmercury; return new Pressure(value, PressureUnit.InchOfMercury); } + /// /// Creates a from . /// @@ -618,6 +629,7 @@ public static Pressure FromInchesOfWaterColumn(double inchesofwatercolumn) double value = (double) inchesofwatercolumn; return new Pressure(value, PressureUnit.InchOfWaterColumn); } + /// /// Creates a from . /// @@ -628,6 +640,7 @@ public static Pressure FromKilobars(double kilobars) double value = (double) kilobars; return new Pressure(value, PressureUnit.Kilobar); } + /// /// Creates a from . /// @@ -638,6 +651,7 @@ public static Pressure FromKilogramsForcePerSquareCentimeter(double kilogramsfor double value = (double) kilogramsforcepersquarecentimeter; return new Pressure(value, PressureUnit.KilogramForcePerSquareCentimeter); } + /// /// Creates a from . /// @@ -648,6 +662,7 @@ public static Pressure FromKilogramsForcePerSquareMeter(double kilogramsforceper double value = (double) kilogramsforcepersquaremeter; return new Pressure(value, PressureUnit.KilogramForcePerSquareMeter); } + /// /// Creates a from . /// @@ -658,6 +673,7 @@ public static Pressure FromKilogramsForcePerSquareMillimeter(double kilogramsfor double value = (double) kilogramsforcepersquaremillimeter; return new Pressure(value, PressureUnit.KilogramForcePerSquareMillimeter); } + /// /// Creates a from . /// @@ -668,6 +684,7 @@ public static Pressure FromKilonewtonsPerSquareCentimeter(double kilonewtonspers double value = (double) kilonewtonspersquarecentimeter; return new Pressure(value, PressureUnit.KilonewtonPerSquareCentimeter); } + /// /// Creates a from . /// @@ -678,6 +695,7 @@ public static Pressure FromKilonewtonsPerSquareMeter(double kilonewtonspersquare double value = (double) kilonewtonspersquaremeter; return new Pressure(value, PressureUnit.KilonewtonPerSquareMeter); } + /// /// Creates a from . /// @@ -688,6 +706,7 @@ public static Pressure FromKilonewtonsPerSquareMillimeter(double kilonewtonspers double value = (double) kilonewtonspersquaremillimeter; return new Pressure(value, PressureUnit.KilonewtonPerSquareMillimeter); } + /// /// Creates a from . /// @@ -698,6 +717,7 @@ public static Pressure FromKilopascals(double kilopascals) double value = (double) kilopascals; return new Pressure(value, PressureUnit.Kilopascal); } + /// /// Creates a from . /// @@ -708,6 +728,7 @@ public static Pressure FromKilopoundsForcePerSquareFoot(double kilopoundsforcepe double value = (double) kilopoundsforcepersquarefoot; return new Pressure(value, PressureUnit.KilopoundForcePerSquareFoot); } + /// /// Creates a from . /// @@ -718,6 +739,7 @@ public static Pressure FromKilopoundsForcePerSquareInch(double kilopoundsforcepe double value = (double) kilopoundsforcepersquareinch; return new Pressure(value, PressureUnit.KilopoundForcePerSquareInch); } + /// /// Creates a from . /// @@ -728,6 +750,7 @@ public static Pressure FromMegabars(double megabars) double value = (double) megabars; return new Pressure(value, PressureUnit.Megabar); } + /// /// Creates a from . /// @@ -738,6 +761,7 @@ public static Pressure FromMeganewtonsPerSquareMeter(double meganewtonspersquare double value = (double) meganewtonspersquaremeter; return new Pressure(value, PressureUnit.MeganewtonPerSquareMeter); } + /// /// Creates a from . /// @@ -748,6 +772,7 @@ public static Pressure FromMegapascals(double megapascals) double value = (double) megapascals; return new Pressure(value, PressureUnit.Megapascal); } + /// /// Creates a from . /// @@ -758,6 +783,7 @@ public static Pressure FromMetersOfElevation(double metersofelevation) double value = (double) metersofelevation; return new Pressure(value, PressureUnit.MeterOfElevation); } + /// /// Creates a from . /// @@ -768,6 +794,7 @@ public static Pressure FromMetersOfHead(double metersofhead) double value = (double) metersofhead; return new Pressure(value, PressureUnit.MeterOfHead); } + /// /// Creates a from . /// @@ -778,6 +805,7 @@ public static Pressure FromMicrobars(double microbars) double value = (double) microbars; return new Pressure(value, PressureUnit.Microbar); } + /// /// Creates a from . /// @@ -788,6 +816,7 @@ public static Pressure FromMicropascals(double micropascals) double value = (double) micropascals; return new Pressure(value, PressureUnit.Micropascal); } + /// /// Creates a from . /// @@ -798,6 +827,7 @@ public static Pressure FromMillibars(double millibars) double value = (double) millibars; return new Pressure(value, PressureUnit.Millibar); } + /// /// Creates a from . /// @@ -808,6 +838,7 @@ public static Pressure FromMillimetersOfMercury(double millimetersofmercury) double value = (double) millimetersofmercury; return new Pressure(value, PressureUnit.MillimeterOfMercury); } + /// /// Creates a from . /// @@ -818,6 +849,7 @@ public static Pressure FromMillimeterOfWaterColumn(double millimeterofwatercolum double value = (double) millimeterofwatercolumn; return new Pressure(value, PressureUnit.MillimeterOfWaterColumn); } + /// /// Creates a from . /// @@ -828,6 +860,7 @@ public static Pressure FromMillipascals(double millipascals) double value = (double) millipascals; return new Pressure(value, PressureUnit.Millipascal); } + /// /// Creates a from . /// @@ -838,6 +871,7 @@ public static Pressure FromNewtonsPerSquareCentimeter(double newtonspersquarecen double value = (double) newtonspersquarecentimeter; return new Pressure(value, PressureUnit.NewtonPerSquareCentimeter); } + /// /// Creates a from . /// @@ -848,6 +882,7 @@ public static Pressure FromNewtonsPerSquareMeter(double newtonspersquaremeter) double value = (double) newtonspersquaremeter; return new Pressure(value, PressureUnit.NewtonPerSquareMeter); } + /// /// Creates a from . /// @@ -858,6 +893,7 @@ public static Pressure FromNewtonsPerSquareMillimeter(double newtonspersquaremil double value = (double) newtonspersquaremillimeter; return new Pressure(value, PressureUnit.NewtonPerSquareMillimeter); } + /// /// Creates a from . /// @@ -868,6 +904,7 @@ public static Pressure FromPascals(double pascals) double value = (double) pascals; return new Pressure(value, PressureUnit.Pascal); } + /// /// Creates a from . /// @@ -878,6 +915,7 @@ public static Pressure FromPoundsForcePerSquareFoot(double poundsforcepersquaref double value = (double) poundsforcepersquarefoot; return new Pressure(value, PressureUnit.PoundForcePerSquareFoot); } + /// /// Creates a from . /// @@ -888,6 +926,7 @@ public static Pressure FromPoundsForcePerSquareInch(double poundsforcepersquarei double value = (double) poundsforcepersquareinch; return new Pressure(value, PressureUnit.PoundForcePerSquareInch); } + /// /// Creates a from . /// @@ -898,6 +937,7 @@ public static Pressure FromPoundsPerInchSecondSquared(double poundsperinchsecond double value = (double) poundsperinchsecondsquared; return new Pressure(value, PressureUnit.PoundPerInchSecondSquared); } + /// /// Creates a from . /// @@ -908,6 +948,7 @@ public static Pressure FromTechnicalAtmospheres(double technicalatmospheres) double value = (double) technicalatmospheres; return new Pressure(value, PressureUnit.TechnicalAtmosphere); } + /// /// Creates a from . /// @@ -918,6 +959,7 @@ public static Pressure FromTonnesForcePerSquareCentimeter(double tonnesforcepers double value = (double) tonnesforcepersquarecentimeter; return new Pressure(value, PressureUnit.TonneForcePerSquareCentimeter); } + /// /// Creates a from . /// @@ -928,6 +970,7 @@ public static Pressure FromTonnesForcePerSquareMeter(double tonnesforcepersquare double value = (double) tonnesforcepersquaremeter; return new Pressure(value, PressureUnit.TonneForcePerSquareMeter); } + /// /// Creates a from . /// @@ -938,6 +981,7 @@ public static Pressure FromTonnesForcePerSquareMillimeter(double tonnesforcepers double value = (double) tonnesforcepersquaremillimeter; return new Pressure(value, PressureUnit.TonneForcePerSquareMillimeter); } + /// /// Creates a from . /// @@ -949,6 +993,7 @@ public static Pressure FromTorrs(double torrs) return new Pressure(value, PressureUnit.Torr); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PressureChangeRate.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PressureChangeRate.g.cs index 8ca8770ee4..cd7a2a46b4 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PressureChangeRate.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PressureChangeRate.g.cs @@ -305,6 +305,7 @@ public static PressureChangeRate FromAtmospheresPerSecond(double atmospherespers double value = (double) atmospherespersecond; return new PressureChangeRate(value, PressureChangeRateUnit.AtmospherePerSecond); } + /// /// Creates a from . /// @@ -315,6 +316,7 @@ public static PressureChangeRate FromKilopascalsPerMinute(double kilopascalsperm double value = (double) kilopascalsperminute; return new PressureChangeRate(value, PressureChangeRateUnit.KilopascalPerMinute); } + /// /// Creates a from . /// @@ -325,6 +327,7 @@ public static PressureChangeRate FromKilopascalsPerSecond(double kilopascalspers double value = (double) kilopascalspersecond; return new PressureChangeRate(value, PressureChangeRateUnit.KilopascalPerSecond); } + /// /// Creates a from . /// @@ -335,6 +338,7 @@ public static PressureChangeRate FromKilopoundsForcePerSquareInchPerMinute(doubl double value = (double) kilopoundsforcepersquareinchperminute; return new PressureChangeRate(value, PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute); } + /// /// Creates a from . /// @@ -345,6 +349,7 @@ public static PressureChangeRate FromKilopoundsForcePerSquareInchPerSecond(doubl double value = (double) kilopoundsforcepersquareinchpersecond; return new PressureChangeRate(value, PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond); } + /// /// Creates a from . /// @@ -355,6 +360,7 @@ public static PressureChangeRate FromMegapascalsPerMinute(double megapascalsperm double value = (double) megapascalsperminute; return new PressureChangeRate(value, PressureChangeRateUnit.MegapascalPerMinute); } + /// /// Creates a from . /// @@ -365,6 +371,7 @@ public static PressureChangeRate FromMegapascalsPerSecond(double megapascalspers double value = (double) megapascalspersecond; return new PressureChangeRate(value, PressureChangeRateUnit.MegapascalPerSecond); } + /// /// Creates a from . /// @@ -375,6 +382,7 @@ public static PressureChangeRate FromMegapoundsForcePerSquareInchPerMinute(doubl double value = (double) megapoundsforcepersquareinchperminute; return new PressureChangeRate(value, PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute); } + /// /// Creates a from . /// @@ -385,6 +393,7 @@ public static PressureChangeRate FromMegapoundsForcePerSquareInchPerSecond(doubl double value = (double) megapoundsforcepersquareinchpersecond; return new PressureChangeRate(value, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond); } + /// /// Creates a from . /// @@ -395,6 +404,7 @@ public static PressureChangeRate FromMillimetersOfMercuryPerSecond(double millim double value = (double) millimetersofmercurypersecond; return new PressureChangeRate(value, PressureChangeRateUnit.MillimeterOfMercuryPerSecond); } + /// /// Creates a from . /// @@ -405,6 +415,7 @@ public static PressureChangeRate FromPascalsPerMinute(double pascalsperminute) double value = (double) pascalsperminute; return new PressureChangeRate(value, PressureChangeRateUnit.PascalPerMinute); } + /// /// Creates a from . /// @@ -415,6 +426,7 @@ public static PressureChangeRate FromPascalsPerSecond(double pascalspersecond) double value = (double) pascalspersecond; return new PressureChangeRate(value, PressureChangeRateUnit.PascalPerSecond); } + /// /// Creates a from . /// @@ -425,6 +437,7 @@ public static PressureChangeRate FromPoundsForcePerSquareInchPerMinute(double po double value = (double) poundsforcepersquareinchperminute; return new PressureChangeRate(value, PressureChangeRateUnit.PoundForcePerSquareInchPerMinute); } + /// /// Creates a from . /// @@ -436,6 +449,7 @@ public static PressureChangeRate FromPoundsForcePerSquareInchPerSecond(double po return new PressureChangeRate(value, PressureChangeRateUnit.PoundForcePerSquareInchPerSecond); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Ratio.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Ratio.g.cs index d20bb01e3f..12b5561177 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Ratio.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Ratio.g.cs @@ -243,6 +243,7 @@ public static Ratio FromDecimalFractions(double decimalfractions) double value = (double) decimalfractions; return new Ratio(value, RatioUnit.DecimalFraction); } + /// /// Creates a from . /// @@ -253,6 +254,7 @@ public static Ratio FromPartsPerBillion(double partsperbillion) double value = (double) partsperbillion; return new Ratio(value, RatioUnit.PartPerBillion); } + /// /// Creates a from . /// @@ -263,6 +265,7 @@ public static Ratio FromPartsPerMillion(double partspermillion) double value = (double) partspermillion; return new Ratio(value, RatioUnit.PartPerMillion); } + /// /// Creates a from . /// @@ -273,6 +276,7 @@ public static Ratio FromPartsPerThousand(double partsperthousand) double value = (double) partsperthousand; return new Ratio(value, RatioUnit.PartPerThousand); } + /// /// Creates a from . /// @@ -283,6 +287,7 @@ public static Ratio FromPartsPerTrillion(double partspertrillion) double value = (double) partspertrillion; return new Ratio(value, RatioUnit.PartPerTrillion); } + /// /// Creates a from . /// @@ -294,6 +299,7 @@ public static Ratio FromPercent(double percent) return new Ratio(value, RatioUnit.Percent); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RatioChangeRate.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RatioChangeRate.g.cs index 5c65e3f2bc..c4ddc4c301 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RatioChangeRate.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RatioChangeRate.g.cs @@ -219,6 +219,7 @@ public static RatioChangeRate FromDecimalFractionsPerSecond(double decimalfracti double value = (double) decimalfractionspersecond; return new RatioChangeRate(value, RatioChangeRateUnit.DecimalFractionPerSecond); } + /// /// Creates a from . /// @@ -230,6 +231,7 @@ public static RatioChangeRate FromPercentsPerSecond(double percentspersecond) return new RatioChangeRate(value, RatioChangeRateUnit.PercentPerSecond); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactiveEnergy.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactiveEnergy.g.cs index 5d92544122..66a864f189 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactiveEnergy.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactiveEnergy.g.cs @@ -225,6 +225,7 @@ public static ReactiveEnergy FromKilovoltampereReactiveHours(double kilovoltampe double value = (double) kilovoltamperereactivehours; return new ReactiveEnergy(value, ReactiveEnergyUnit.KilovoltampereReactiveHour); } + /// /// Creates a from . /// @@ -235,6 +236,7 @@ public static ReactiveEnergy FromMegavoltampereReactiveHours(double megavoltampe double value = (double) megavoltamperereactivehours; return new ReactiveEnergy(value, ReactiveEnergyUnit.MegavoltampereReactiveHour); } + /// /// Creates a from . /// @@ -246,6 +248,7 @@ public static ReactiveEnergy FromVoltampereReactiveHours(double voltamperereacti return new ReactiveEnergy(value, ReactiveEnergyUnit.VoltampereReactiveHour); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactivePower.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactivePower.g.cs index 99a1440808..63a2e368eb 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactivePower.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactivePower.g.cs @@ -231,6 +231,7 @@ public static ReactivePower FromGigavoltamperesReactive(double gigavoltamperesre double value = (double) gigavoltamperesreactive; return new ReactivePower(value, ReactivePowerUnit.GigavoltampereReactive); } + /// /// Creates a from . /// @@ -241,6 +242,7 @@ public static ReactivePower FromKilovoltamperesReactive(double kilovoltamperesre double value = (double) kilovoltamperesreactive; return new ReactivePower(value, ReactivePowerUnit.KilovoltampereReactive); } + /// /// Creates a from . /// @@ -251,6 +253,7 @@ public static ReactivePower FromMegavoltamperesReactive(double megavoltamperesre double value = (double) megavoltamperesreactive; return new ReactivePower(value, ReactivePowerUnit.MegavoltampereReactive); } + /// /// Creates a from . /// @@ -262,6 +265,7 @@ public static ReactivePower FromVoltamperesReactive(double voltamperesreactive) return new ReactivePower(value, ReactivePowerUnit.VoltampereReactive); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReciprocalArea.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReciprocalArea.g.cs index 7756a1c82c..432ad7a03b 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReciprocalArea.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReciprocalArea.g.cs @@ -276,6 +276,7 @@ public static ReciprocalArea FromInverseSquareCentimeters(double inversesquarece double value = (double) inversesquarecentimeters; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareCentimeter); } + /// /// Creates a from . /// @@ -286,6 +287,7 @@ public static ReciprocalArea FromInverseSquareDecimeters(double inversesquaredec double value = (double) inversesquaredecimeters; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareDecimeter); } + /// /// Creates a from . /// @@ -296,6 +298,7 @@ public static ReciprocalArea FromInverseSquareFeet(double inversesquarefeet) double value = (double) inversesquarefeet; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareFoot); } + /// /// Creates a from . /// @@ -306,6 +309,7 @@ public static ReciprocalArea FromInverseSquareInches(double inversesquareinches) double value = (double) inversesquareinches; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareInch); } + /// /// Creates a from . /// @@ -316,6 +320,7 @@ public static ReciprocalArea FromInverseSquareKilometers(double inversesquarekil double value = (double) inversesquarekilometers; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareKilometer); } + /// /// Creates a from . /// @@ -326,6 +331,7 @@ public static ReciprocalArea FromInverseSquareMeters(double inversesquaremeters) double value = (double) inversesquaremeters; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMeter); } + /// /// Creates a from . /// @@ -336,6 +342,7 @@ public static ReciprocalArea FromInverseSquareMicrometers(double inversesquaremi double value = (double) inversesquaremicrometers; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMicrometer); } + /// /// Creates a from . /// @@ -346,6 +353,7 @@ public static ReciprocalArea FromInverseSquareMiles(double inversesquaremiles) double value = (double) inversesquaremiles; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMile); } + /// /// Creates a from . /// @@ -356,6 +364,7 @@ public static ReciprocalArea FromInverseSquareMillimeters(double inversesquaremi double value = (double) inversesquaremillimeters; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMillimeter); } + /// /// Creates a from . /// @@ -366,6 +375,7 @@ public static ReciprocalArea FromInverseSquareYards(double inversesquareyards) double value = (double) inversesquareyards; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareYard); } + /// /// Creates a from . /// @@ -377,6 +387,7 @@ public static ReciprocalArea FromInverseUsSurveySquareFeet(double inverseussurve return new ReciprocalArea(value, ReciprocalAreaUnit.InverseUsSurveySquareFoot); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReciprocalLength.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReciprocalLength.g.cs index c50a973ec0..e787fc4be0 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReciprocalLength.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReciprocalLength.g.cs @@ -270,6 +270,7 @@ public static ReciprocalLength FromInverseCentimeters(double inversecentimeters) double value = (double) inversecentimeters; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseCentimeter); } + /// /// Creates a from . /// @@ -280,6 +281,7 @@ public static ReciprocalLength FromInverseFeet(double inversefeet) double value = (double) inversefeet; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseFoot); } + /// /// Creates a from . /// @@ -290,6 +292,7 @@ public static ReciprocalLength FromInverseInches(double inverseinches) double value = (double) inverseinches; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseInch); } + /// /// Creates a from . /// @@ -300,6 +303,7 @@ public static ReciprocalLength FromInverseMeters(double inversemeters) double value = (double) inversemeters; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMeter); } + /// /// Creates a from . /// @@ -310,6 +314,7 @@ public static ReciprocalLength FromInverseMicroinches(double inversemicroinches) double value = (double) inversemicroinches; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMicroinch); } + /// /// Creates a from . /// @@ -320,6 +325,7 @@ public static ReciprocalLength FromInverseMils(double inversemils) double value = (double) inversemils; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMil); } + /// /// Creates a from . /// @@ -330,6 +336,7 @@ public static ReciprocalLength FromInverseMiles(double inversemiles) double value = (double) inversemiles; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMile); } + /// /// Creates a from . /// @@ -340,6 +347,7 @@ public static ReciprocalLength FromInverseMillimeters(double inversemillimeters) double value = (double) inversemillimeters; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMillimeter); } + /// /// Creates a from . /// @@ -350,6 +358,7 @@ public static ReciprocalLength FromInverseUsSurveyFeet(double inverseussurveyfee double value = (double) inverseussurveyfeet; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseUsSurveyFoot); } + /// /// Creates a from . /// @@ -361,6 +370,7 @@ public static ReciprocalLength FromInverseYards(double inverseyards) return new ReciprocalLength(value, ReciprocalLengthUnit.InverseYard); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RelativeHumidity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RelativeHumidity.g.cs index 062e589d67..35eaa9d80b 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RelativeHumidity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RelativeHumidity.g.cs @@ -214,6 +214,7 @@ public static RelativeHumidity FromPercent(double percent) return new RelativeHumidity(value, RelativeHumidityUnit.Percent); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalAcceleration.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalAcceleration.g.cs index 9aacda5e95..c4c5febbc5 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalAcceleration.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalAcceleration.g.cs @@ -231,6 +231,7 @@ public static RotationalAcceleration FromDegreesPerSecondSquared(double degreesp double value = (double) degreespersecondsquared; return new RotationalAcceleration(value, RotationalAccelerationUnit.DegreePerSecondSquared); } + /// /// Creates a from . /// @@ -241,6 +242,7 @@ public static RotationalAcceleration FromRadiansPerSecondSquared(double radiansp double value = (double) radianspersecondsquared; return new RotationalAcceleration(value, RotationalAccelerationUnit.RadianPerSecondSquared); } + /// /// Creates a from . /// @@ -251,6 +253,7 @@ public static RotationalAcceleration FromRevolutionsPerMinutePerSecond(double re double value = (double) revolutionsperminutepersecond; return new RotationalAcceleration(value, RotationalAccelerationUnit.RevolutionPerMinutePerSecond); } + /// /// Creates a from . /// @@ -262,6 +265,7 @@ public static RotationalAcceleration FromRevolutionsPerSecondSquared(double revo return new RotationalAcceleration(value, RotationalAccelerationUnit.RevolutionPerSecondSquared); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalSpeed.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalSpeed.g.cs index 962310c532..2a6aba2804 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalSpeed.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalSpeed.g.cs @@ -297,6 +297,7 @@ public static RotationalSpeed FromCentiradiansPerSecond(double centiradiansperse double value = (double) centiradianspersecond; return new RotationalSpeed(value, RotationalSpeedUnit.CentiradianPerSecond); } + /// /// Creates a from . /// @@ -307,6 +308,7 @@ public static RotationalSpeed FromDeciradiansPerSecond(double deciradiansperseco double value = (double) deciradianspersecond; return new RotationalSpeed(value, RotationalSpeedUnit.DeciradianPerSecond); } + /// /// Creates a from . /// @@ -317,6 +319,7 @@ public static RotationalSpeed FromDegreesPerMinute(double degreesperminute) double value = (double) degreesperminute; return new RotationalSpeed(value, RotationalSpeedUnit.DegreePerMinute); } + /// /// Creates a from . /// @@ -327,6 +330,7 @@ public static RotationalSpeed FromDegreesPerSecond(double degreespersecond) double value = (double) degreespersecond; return new RotationalSpeed(value, RotationalSpeedUnit.DegreePerSecond); } + /// /// Creates a from . /// @@ -337,6 +341,7 @@ public static RotationalSpeed FromMicrodegreesPerSecond(double microdegreesperse double value = (double) microdegreespersecond; return new RotationalSpeed(value, RotationalSpeedUnit.MicrodegreePerSecond); } + /// /// Creates a from . /// @@ -347,6 +352,7 @@ public static RotationalSpeed FromMicroradiansPerSecond(double microradiansperse double value = (double) microradianspersecond; return new RotationalSpeed(value, RotationalSpeedUnit.MicroradianPerSecond); } + /// /// Creates a from . /// @@ -357,6 +363,7 @@ public static RotationalSpeed FromMillidegreesPerSecond(double millidegreesperse double value = (double) millidegreespersecond; return new RotationalSpeed(value, RotationalSpeedUnit.MillidegreePerSecond); } + /// /// Creates a from . /// @@ -367,6 +374,7 @@ public static RotationalSpeed FromMilliradiansPerSecond(double milliradiansperse double value = (double) milliradianspersecond; return new RotationalSpeed(value, RotationalSpeedUnit.MilliradianPerSecond); } + /// /// Creates a from . /// @@ -377,6 +385,7 @@ public static RotationalSpeed FromNanodegreesPerSecond(double nanodegreesperseco double value = (double) nanodegreespersecond; return new RotationalSpeed(value, RotationalSpeedUnit.NanodegreePerSecond); } + /// /// Creates a from . /// @@ -387,6 +396,7 @@ public static RotationalSpeed FromNanoradiansPerSecond(double nanoradiansperseco double value = (double) nanoradianspersecond; return new RotationalSpeed(value, RotationalSpeedUnit.NanoradianPerSecond); } + /// /// Creates a from . /// @@ -397,6 +407,7 @@ public static RotationalSpeed FromRadiansPerSecond(double radianspersecond) double value = (double) radianspersecond; return new RotationalSpeed(value, RotationalSpeedUnit.RadianPerSecond); } + /// /// Creates a from . /// @@ -407,6 +418,7 @@ public static RotationalSpeed FromRevolutionsPerMinute(double revolutionsperminu double value = (double) revolutionsperminute; return new RotationalSpeed(value, RotationalSpeedUnit.RevolutionPerMinute); } + /// /// Creates a from . /// @@ -418,6 +430,7 @@ public static RotationalSpeed FromRevolutionsPerSecond(double revolutionsperseco return new RotationalSpeed(value, RotationalSpeedUnit.RevolutionPerSecond); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.g.cs index a222be4b63..eb21e8b69e 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.g.cs @@ -405,6 +405,7 @@ public static RotationalStiffness FromCentinewtonMetersPerDegree(double centinew double value = (double) centinewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.CentinewtonMeterPerDegree); } + /// /// Creates a from . /// @@ -415,6 +416,7 @@ public static RotationalStiffness FromCentinewtonMillimetersPerDegree(double cen double value = (double) centinewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.CentinewtonMillimeterPerDegree); } + /// /// Creates a from . /// @@ -425,6 +427,7 @@ public static RotationalStiffness FromCentinewtonMillimetersPerRadian(double cen double value = (double) centinewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.CentinewtonMillimeterPerRadian); } + /// /// Creates a from . /// @@ -435,6 +438,7 @@ public static RotationalStiffness FromDecanewtonMetersPerDegree(double decanewto double value = (double) decanewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.DecanewtonMeterPerDegree); } + /// /// Creates a from . /// @@ -445,6 +449,7 @@ public static RotationalStiffness FromDecanewtonMillimetersPerDegree(double deca double value = (double) decanewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.DecanewtonMillimeterPerDegree); } + /// /// Creates a from . /// @@ -455,6 +460,7 @@ public static RotationalStiffness FromDecanewtonMillimetersPerRadian(double deca double value = (double) decanewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.DecanewtonMillimeterPerRadian); } + /// /// Creates a from . /// @@ -465,6 +471,7 @@ public static RotationalStiffness FromDecinewtonMetersPerDegree(double decinewto double value = (double) decinewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.DecinewtonMeterPerDegree); } + /// /// Creates a from . /// @@ -475,6 +482,7 @@ public static RotationalStiffness FromDecinewtonMillimetersPerDegree(double deci double value = (double) decinewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.DecinewtonMillimeterPerDegree); } + /// /// Creates a from . /// @@ -485,6 +493,7 @@ public static RotationalStiffness FromDecinewtonMillimetersPerRadian(double deci double value = (double) decinewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.DecinewtonMillimeterPerRadian); } + /// /// Creates a from . /// @@ -495,6 +504,7 @@ public static RotationalStiffness FromKilonewtonMetersPerDegree(double kilonewto double value = (double) kilonewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMeterPerDegree); } + /// /// Creates a from . /// @@ -505,6 +515,7 @@ public static RotationalStiffness FromKilonewtonMetersPerRadian(double kilonewto double value = (double) kilonewtonmetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMeterPerRadian); } + /// /// Creates a from . /// @@ -515,6 +526,7 @@ public static RotationalStiffness FromKilonewtonMillimetersPerDegree(double kilo double value = (double) kilonewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMillimeterPerDegree); } + /// /// Creates a from . /// @@ -525,6 +537,7 @@ public static RotationalStiffness FromKilonewtonMillimetersPerRadian(double kilo double value = (double) kilonewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMillimeterPerRadian); } + /// /// Creates a from . /// @@ -535,6 +548,7 @@ public static RotationalStiffness FromKilopoundForceFeetPerDegrees(double kilopo double value = (double) kilopoundforcefeetperdegrees; return new RotationalStiffness(value, RotationalStiffnessUnit.KilopoundForceFootPerDegrees); } + /// /// Creates a from . /// @@ -545,6 +559,7 @@ public static RotationalStiffness FromMeganewtonMetersPerDegree(double meganewto double value = (double) meganewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMeterPerDegree); } + /// /// Creates a from . /// @@ -555,6 +570,7 @@ public static RotationalStiffness FromMeganewtonMetersPerRadian(double meganewto double value = (double) meganewtonmetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMeterPerRadian); } + /// /// Creates a from . /// @@ -565,6 +581,7 @@ public static RotationalStiffness FromMeganewtonMillimetersPerDegree(double mega double value = (double) meganewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMillimeterPerDegree); } + /// /// Creates a from . /// @@ -575,6 +592,7 @@ public static RotationalStiffness FromMeganewtonMillimetersPerRadian(double mega double value = (double) meganewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMillimeterPerRadian); } + /// /// Creates a from . /// @@ -585,6 +603,7 @@ public static RotationalStiffness FromMicronewtonMetersPerDegree(double micronew double value = (double) micronewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.MicronewtonMeterPerDegree); } + /// /// Creates a from . /// @@ -595,6 +614,7 @@ public static RotationalStiffness FromMicronewtonMillimetersPerDegree(double mic double value = (double) micronewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.MicronewtonMillimeterPerDegree); } + /// /// Creates a from . /// @@ -605,6 +625,7 @@ public static RotationalStiffness FromMicronewtonMillimetersPerRadian(double mic double value = (double) micronewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.MicronewtonMillimeterPerRadian); } + /// /// Creates a from . /// @@ -615,6 +636,7 @@ public static RotationalStiffness FromMillinewtonMetersPerDegree(double millinew double value = (double) millinewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.MillinewtonMeterPerDegree); } + /// /// Creates a from . /// @@ -625,6 +647,7 @@ public static RotationalStiffness FromMillinewtonMillimetersPerDegree(double mil double value = (double) millinewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.MillinewtonMillimeterPerDegree); } + /// /// Creates a from . /// @@ -635,6 +658,7 @@ public static RotationalStiffness FromMillinewtonMillimetersPerRadian(double mil double value = (double) millinewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.MillinewtonMillimeterPerRadian); } + /// /// Creates a from . /// @@ -645,6 +669,7 @@ public static RotationalStiffness FromNanonewtonMetersPerDegree(double nanonewto double value = (double) nanonewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.NanonewtonMeterPerDegree); } + /// /// Creates a from . /// @@ -655,6 +680,7 @@ public static RotationalStiffness FromNanonewtonMillimetersPerDegree(double nano double value = (double) nanonewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.NanonewtonMillimeterPerDegree); } + /// /// Creates a from . /// @@ -665,6 +691,7 @@ public static RotationalStiffness FromNanonewtonMillimetersPerRadian(double nano double value = (double) nanonewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.NanonewtonMillimeterPerRadian); } + /// /// Creates a from . /// @@ -675,6 +702,7 @@ public static RotationalStiffness FromNewtonMetersPerDegree(double newtonmetersp double value = (double) newtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMeterPerDegree); } + /// /// Creates a from . /// @@ -685,6 +713,7 @@ public static RotationalStiffness FromNewtonMetersPerRadian(double newtonmetersp double value = (double) newtonmetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMeterPerRadian); } + /// /// Creates a from . /// @@ -695,6 +724,7 @@ public static RotationalStiffness FromNewtonMillimetersPerDegree(double newtonmi double value = (double) newtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMillimeterPerDegree); } + /// /// Creates a from . /// @@ -705,6 +735,7 @@ public static RotationalStiffness FromNewtonMillimetersPerRadian(double newtonmi double value = (double) newtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMillimeterPerRadian); } + /// /// Creates a from . /// @@ -715,6 +746,7 @@ public static RotationalStiffness FromPoundForceFeetPerRadian(double poundforcef double value = (double) poundforcefeetperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.PoundForceFeetPerRadian); } + /// /// Creates a from . /// @@ -726,6 +758,7 @@ public static RotationalStiffness FromPoundForceFeetPerDegrees(double poundforce return new RotationalStiffness(value, RotationalStiffnessUnit.PoundForceFootPerDegrees); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs index 02c7d4c5fe..3ddf09ab5a 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs @@ -237,6 +237,7 @@ public static RotationalStiffnessPerLength FromKilonewtonMetersPerRadianPerMeter double value = (double) kilonewtonmetersperradianpermeter; return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter); } + /// /// Creates a from . /// @@ -247,6 +248,7 @@ public static RotationalStiffnessPerLength FromKilopoundForceFeetPerDegreesPerFe double value = (double) kilopoundforcefeetperdegreesperfeet; return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot); } + /// /// Creates a from . /// @@ -257,6 +259,7 @@ public static RotationalStiffnessPerLength FromMeganewtonMetersPerRadianPerMeter double value = (double) meganewtonmetersperradianpermeter; return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter); } + /// /// Creates a from . /// @@ -267,6 +270,7 @@ public static RotationalStiffnessPerLength FromNewtonMetersPerRadianPerMeter(dou double value = (double) newtonmetersperradianpermeter; return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter); } + /// /// Creates a from . /// @@ -278,6 +282,7 @@ public static RotationalStiffnessPerLength FromPoundForceFeetPerDegreesPerFeet(d return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Scalar.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Scalar.g.cs index e777cfc9de..678e56b34d 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Scalar.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Scalar.g.cs @@ -214,6 +214,7 @@ public static Scalar FromAmount(double amount) return new Scalar(value, ScalarUnit.Amount); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SolidAngle.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SolidAngle.g.cs index f71334b801..ed91bd4398 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SolidAngle.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SolidAngle.g.cs @@ -217,6 +217,7 @@ public static SolidAngle FromSteradians(double steradians) return new SolidAngle(value, SolidAngleUnit.Steradian); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEnergy.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEnergy.g.cs index 5ae758e79d..4c58136825 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEnergy.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEnergy.g.cs @@ -360,6 +360,7 @@ public static SpecificEnergy FromBtuPerPound(double btuperpound) double value = (double) btuperpound; return new SpecificEnergy(value, SpecificEnergyUnit.BtuPerPound); } + /// /// Creates a from . /// @@ -370,6 +371,7 @@ public static SpecificEnergy FromCaloriesPerGram(double caloriespergram) double value = (double) caloriespergram; return new SpecificEnergy(value, SpecificEnergyUnit.CaloriePerGram); } + /// /// Creates a from . /// @@ -380,6 +382,7 @@ public static SpecificEnergy FromGigawattDaysPerKilogram(double gigawattdaysperk double value = (double) gigawattdaysperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.GigawattDayPerKilogram); } + /// /// Creates a from . /// @@ -390,6 +393,7 @@ public static SpecificEnergy FromGigawattDaysPerShortTon(double gigawattdayspers double value = (double) gigawattdayspershortton; return new SpecificEnergy(value, SpecificEnergyUnit.GigawattDayPerShortTon); } + /// /// Creates a from . /// @@ -400,6 +404,7 @@ public static SpecificEnergy FromGigawattDaysPerTonne(double gigawattdayspertonn double value = (double) gigawattdayspertonne; return new SpecificEnergy(value, SpecificEnergyUnit.GigawattDayPerTonne); } + /// /// Creates a from . /// @@ -410,6 +415,7 @@ public static SpecificEnergy FromGigawattHoursPerKilogram(double gigawatthourspe double value = (double) gigawatthoursperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.GigawattHourPerKilogram); } + /// /// Creates a from . /// @@ -420,6 +426,7 @@ public static SpecificEnergy FromJoulesPerKilogram(double joulesperkilogram) double value = (double) joulesperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.JoulePerKilogram); } + /// /// Creates a from . /// @@ -430,6 +437,7 @@ public static SpecificEnergy FromKilocaloriesPerGram(double kilocaloriespergram) double value = (double) kilocaloriespergram; return new SpecificEnergy(value, SpecificEnergyUnit.KilocaloriePerGram); } + /// /// Creates a from . /// @@ -440,6 +448,7 @@ public static SpecificEnergy FromKilojoulesPerKilogram(double kilojoulesperkilog double value = (double) kilojoulesperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.KilojoulePerKilogram); } + /// /// Creates a from . /// @@ -450,6 +459,7 @@ public static SpecificEnergy FromKilowattDaysPerKilogram(double kilowattdaysperk double value = (double) kilowattdaysperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.KilowattDayPerKilogram); } + /// /// Creates a from . /// @@ -460,6 +470,7 @@ public static SpecificEnergy FromKilowattDaysPerShortTon(double kilowattdayspers double value = (double) kilowattdayspershortton; return new SpecificEnergy(value, SpecificEnergyUnit.KilowattDayPerShortTon); } + /// /// Creates a from . /// @@ -470,6 +481,7 @@ public static SpecificEnergy FromKilowattDaysPerTonne(double kilowattdayspertonn double value = (double) kilowattdayspertonne; return new SpecificEnergy(value, SpecificEnergyUnit.KilowattDayPerTonne); } + /// /// Creates a from . /// @@ -480,6 +492,7 @@ public static SpecificEnergy FromKilowattHoursPerKilogram(double kilowatthourspe double value = (double) kilowatthoursperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.KilowattHourPerKilogram); } + /// /// Creates a from . /// @@ -490,6 +503,7 @@ public static SpecificEnergy FromMegajoulesPerKilogram(double megajoulesperkilog double value = (double) megajoulesperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.MegajoulePerKilogram); } + /// /// Creates a from . /// @@ -500,6 +514,7 @@ public static SpecificEnergy FromMegawattDaysPerKilogram(double megawattdaysperk double value = (double) megawattdaysperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.MegawattDayPerKilogram); } + /// /// Creates a from . /// @@ -510,6 +525,7 @@ public static SpecificEnergy FromMegawattDaysPerShortTon(double megawattdayspers double value = (double) megawattdayspershortton; return new SpecificEnergy(value, SpecificEnergyUnit.MegawattDayPerShortTon); } + /// /// Creates a from . /// @@ -520,6 +536,7 @@ public static SpecificEnergy FromMegawattDaysPerTonne(double megawattdayspertonn double value = (double) megawattdayspertonne; return new SpecificEnergy(value, SpecificEnergyUnit.MegawattDayPerTonne); } + /// /// Creates a from . /// @@ -530,6 +547,7 @@ public static SpecificEnergy FromMegawattHoursPerKilogram(double megawatthourspe double value = (double) megawatthoursperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.MegawattHourPerKilogram); } + /// /// Creates a from . /// @@ -540,6 +558,7 @@ public static SpecificEnergy FromTerawattDaysPerKilogram(double terawattdaysperk double value = (double) terawattdaysperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.TerawattDayPerKilogram); } + /// /// Creates a from . /// @@ -550,6 +569,7 @@ public static SpecificEnergy FromTerawattDaysPerShortTon(double terawattdayspers double value = (double) terawattdayspershortton; return new SpecificEnergy(value, SpecificEnergyUnit.TerawattDayPerShortTon); } + /// /// Creates a from . /// @@ -560,6 +580,7 @@ public static SpecificEnergy FromTerawattDaysPerTonne(double terawattdayspertonn double value = (double) terawattdayspertonne; return new SpecificEnergy(value, SpecificEnergyUnit.TerawattDayPerTonne); } + /// /// Creates a from . /// @@ -570,6 +591,7 @@ public static SpecificEnergy FromWattDaysPerKilogram(double wattdaysperkilogram) double value = (double) wattdaysperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.WattDayPerKilogram); } + /// /// Creates a from . /// @@ -580,6 +602,7 @@ public static SpecificEnergy FromWattDaysPerShortTon(double wattdayspershortton) double value = (double) wattdayspershortton; return new SpecificEnergy(value, SpecificEnergyUnit.WattDayPerShortTon); } + /// /// Creates a from . /// @@ -590,6 +613,7 @@ public static SpecificEnergy FromWattDaysPerTonne(double wattdayspertonne) double value = (double) wattdayspertonne; return new SpecificEnergy(value, SpecificEnergyUnit.WattDayPerTonne); } + /// /// Creates a from . /// @@ -601,6 +625,7 @@ public static SpecificEnergy FromWattHoursPerKilogram(double watthoursperkilogra return new SpecificEnergy(value, SpecificEnergyUnit.WattHourPerKilogram); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEntropy.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEntropy.g.cs index 13d7c6ba53..0b69a9d022 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEntropy.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEntropy.g.cs @@ -261,6 +261,7 @@ public static SpecificEntropy FromBtusPerPoundFahrenheit(double btusperpoundfahr double value = (double) btusperpoundfahrenheit; return new SpecificEntropy(value, SpecificEntropyUnit.BtuPerPoundFahrenheit); } + /// /// Creates a from . /// @@ -271,6 +272,7 @@ public static SpecificEntropy FromCaloriesPerGramKelvin(double caloriespergramke double value = (double) caloriespergramkelvin; return new SpecificEntropy(value, SpecificEntropyUnit.CaloriePerGramKelvin); } + /// /// Creates a from . /// @@ -281,6 +283,7 @@ public static SpecificEntropy FromJoulesPerKilogramDegreeCelsius(double joulespe double value = (double) joulesperkilogramdegreecelsius; return new SpecificEntropy(value, SpecificEntropyUnit.JoulePerKilogramDegreeCelsius); } + /// /// Creates a from . /// @@ -291,6 +294,7 @@ public static SpecificEntropy FromJoulesPerKilogramKelvin(double joulesperkilogr double value = (double) joulesperkilogramkelvin; return new SpecificEntropy(value, SpecificEntropyUnit.JoulePerKilogramKelvin); } + /// /// Creates a from . /// @@ -301,6 +305,7 @@ public static SpecificEntropy FromKilocaloriesPerGramKelvin(double kilocaloriesp double value = (double) kilocaloriespergramkelvin; return new SpecificEntropy(value, SpecificEntropyUnit.KilocaloriePerGramKelvin); } + /// /// Creates a from . /// @@ -311,6 +316,7 @@ public static SpecificEntropy FromKilojoulesPerKilogramDegreeCelsius(double kilo double value = (double) kilojoulesperkilogramdegreecelsius; return new SpecificEntropy(value, SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius); } + /// /// Creates a from . /// @@ -321,6 +327,7 @@ public static SpecificEntropy FromKilojoulesPerKilogramKelvin(double kilojoulesp double value = (double) kilojoulesperkilogramkelvin; return new SpecificEntropy(value, SpecificEntropyUnit.KilojoulePerKilogramKelvin); } + /// /// Creates a from . /// @@ -331,6 +338,7 @@ public static SpecificEntropy FromMegajoulesPerKilogramDegreeCelsius(double mega double value = (double) megajoulesperkilogramdegreecelsius; return new SpecificEntropy(value, SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius); } + /// /// Creates a from . /// @@ -342,6 +350,7 @@ public static SpecificEntropy FromMegajoulesPerKilogramKelvin(double megajoulesp return new SpecificEntropy(value, SpecificEntropyUnit.MegajoulePerKilogramKelvin); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs index 6ba8283311..0107691823 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs @@ -234,6 +234,7 @@ public static SpecificFuelConsumption FromGramsPerKiloNewtonSecond(double gramsp double value = (double) gramsperkilonewtonsecond; return new SpecificFuelConsumption(value, SpecificFuelConsumptionUnit.GramPerKiloNewtonSecond); } + /// /// Creates a from . /// @@ -244,6 +245,7 @@ public static SpecificFuelConsumption FromKilogramsPerKilogramForceHour(double k double value = (double) kilogramsperkilogramforcehour; return new SpecificFuelConsumption(value, SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour); } + /// /// Creates a from . /// @@ -254,6 +256,7 @@ public static SpecificFuelConsumption FromKilogramsPerKiloNewtonSecond(double ki double value = (double) kilogramsperkilonewtonsecond; return new SpecificFuelConsumption(value, SpecificFuelConsumptionUnit.KilogramPerKiloNewtonSecond); } + /// /// Creates a from . /// @@ -265,6 +268,7 @@ public static SpecificFuelConsumption FromPoundsMassPerPoundForceHour(double pou return new SpecificFuelConsumption(value, SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificVolume.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificVolume.g.cs index 2afac47cf9..1da96b853d 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificVolume.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificVolume.g.cs @@ -225,6 +225,7 @@ public static SpecificVolume FromCubicFeetPerPound(double cubicfeetperpound) double value = (double) cubicfeetperpound; return new SpecificVolume(value, SpecificVolumeUnit.CubicFootPerPound); } + /// /// Creates a from . /// @@ -235,6 +236,7 @@ public static SpecificVolume FromCubicMetersPerKilogram(double cubicmetersperkil double value = (double) cubicmetersperkilogram; return new SpecificVolume(value, SpecificVolumeUnit.CubicMeterPerKilogram); } + /// /// Creates a from . /// @@ -246,6 +248,7 @@ public static SpecificVolume FromMillicubicMetersPerKilogram(double millicubicme return new SpecificVolume(value, SpecificVolumeUnit.MillicubicMeterPerKilogram); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificWeight.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificWeight.g.cs index aa412824ee..57e1600911 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificWeight.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificWeight.g.cs @@ -312,6 +312,7 @@ public static SpecificWeight FromKilogramsForcePerCubicCentimeter(double kilogra double value = (double) kilogramsforcepercubiccentimeter; return new SpecificWeight(value, SpecificWeightUnit.KilogramForcePerCubicCentimeter); } + /// /// Creates a from . /// @@ -322,6 +323,7 @@ public static SpecificWeight FromKilogramsForcePerCubicMeter(double kilogramsfor double value = (double) kilogramsforcepercubicmeter; return new SpecificWeight(value, SpecificWeightUnit.KilogramForcePerCubicMeter); } + /// /// Creates a from . /// @@ -332,6 +334,7 @@ public static SpecificWeight FromKilogramsForcePerCubicMillimeter(double kilogra double value = (double) kilogramsforcepercubicmillimeter; return new SpecificWeight(value, SpecificWeightUnit.KilogramForcePerCubicMillimeter); } + /// /// Creates a from . /// @@ -342,6 +345,7 @@ public static SpecificWeight FromKilonewtonsPerCubicCentimeter(double kilonewton double value = (double) kilonewtonspercubiccentimeter; return new SpecificWeight(value, SpecificWeightUnit.KilonewtonPerCubicCentimeter); } + /// /// Creates a from . /// @@ -352,6 +356,7 @@ public static SpecificWeight FromKilonewtonsPerCubicMeter(double kilonewtonsperc double value = (double) kilonewtonspercubicmeter; return new SpecificWeight(value, SpecificWeightUnit.KilonewtonPerCubicMeter); } + /// /// Creates a from . /// @@ -362,6 +367,7 @@ public static SpecificWeight FromKilonewtonsPerCubicMillimeter(double kilonewton double value = (double) kilonewtonspercubicmillimeter; return new SpecificWeight(value, SpecificWeightUnit.KilonewtonPerCubicMillimeter); } + /// /// Creates a from . /// @@ -372,6 +378,7 @@ public static SpecificWeight FromKilopoundsForcePerCubicFoot(double kilopoundsfo double value = (double) kilopoundsforcepercubicfoot; return new SpecificWeight(value, SpecificWeightUnit.KilopoundForcePerCubicFoot); } + /// /// Creates a from . /// @@ -382,6 +389,7 @@ public static SpecificWeight FromKilopoundsForcePerCubicInch(double kilopoundsfo double value = (double) kilopoundsforcepercubicinch; return new SpecificWeight(value, SpecificWeightUnit.KilopoundForcePerCubicInch); } + /// /// Creates a from . /// @@ -392,6 +400,7 @@ public static SpecificWeight FromMeganewtonsPerCubicMeter(double meganewtonsperc double value = (double) meganewtonspercubicmeter; return new SpecificWeight(value, SpecificWeightUnit.MeganewtonPerCubicMeter); } + /// /// Creates a from . /// @@ -402,6 +411,7 @@ public static SpecificWeight FromNewtonsPerCubicCentimeter(double newtonspercubi double value = (double) newtonspercubiccentimeter; return new SpecificWeight(value, SpecificWeightUnit.NewtonPerCubicCentimeter); } + /// /// Creates a from . /// @@ -412,6 +422,7 @@ public static SpecificWeight FromNewtonsPerCubicMeter(double newtonspercubicmete double value = (double) newtonspercubicmeter; return new SpecificWeight(value, SpecificWeightUnit.NewtonPerCubicMeter); } + /// /// Creates a from . /// @@ -422,6 +433,7 @@ public static SpecificWeight FromNewtonsPerCubicMillimeter(double newtonspercubi double value = (double) newtonspercubicmillimeter; return new SpecificWeight(value, SpecificWeightUnit.NewtonPerCubicMillimeter); } + /// /// Creates a from . /// @@ -432,6 +444,7 @@ public static SpecificWeight FromPoundsForcePerCubicFoot(double poundsforcepercu double value = (double) poundsforcepercubicfoot; return new SpecificWeight(value, SpecificWeightUnit.PoundForcePerCubicFoot); } + /// /// Creates a from . /// @@ -442,6 +455,7 @@ public static SpecificWeight FromPoundsForcePerCubicInch(double poundsforcepercu double value = (double) poundsforcepercubicinch; return new SpecificWeight(value, SpecificWeightUnit.PoundForcePerCubicInch); } + /// /// Creates a from . /// @@ -452,6 +466,7 @@ public static SpecificWeight FromTonnesForcePerCubicCentimeter(double tonnesforc double value = (double) tonnesforcepercubiccentimeter; return new SpecificWeight(value, SpecificWeightUnit.TonneForcePerCubicCentimeter); } + /// /// Creates a from . /// @@ -462,6 +477,7 @@ public static SpecificWeight FromTonnesForcePerCubicMeter(double tonnesforceperc double value = (double) tonnesforcepercubicmeter; return new SpecificWeight(value, SpecificWeightUnit.TonneForcePerCubicMeter); } + /// /// Creates a from . /// @@ -473,6 +489,7 @@ public static SpecificWeight FromTonnesForcePerCubicMillimeter(double tonnesforc return new SpecificWeight(value, SpecificWeightUnit.TonneForcePerCubicMillimeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Speed.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Speed.g.cs index 95bfb27d67..538a542429 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Speed.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Speed.g.cs @@ -422,6 +422,7 @@ public static Speed FromCentimetersPerHour(double centimetersperhour) double value = (double) centimetersperhour; return new Speed(value, SpeedUnit.CentimeterPerHour); } + /// /// Creates a from . /// @@ -432,6 +433,7 @@ public static Speed FromCentimetersPerMinutes(double centimetersperminutes) double value = (double) centimetersperminutes; return new Speed(value, SpeedUnit.CentimeterPerMinute); } + /// /// Creates a from . /// @@ -442,6 +444,7 @@ public static Speed FromCentimetersPerSecond(double centimeterspersecond) double value = (double) centimeterspersecond; return new Speed(value, SpeedUnit.CentimeterPerSecond); } + /// /// Creates a from . /// @@ -452,6 +455,7 @@ public static Speed FromDecimetersPerMinutes(double decimetersperminutes) double value = (double) decimetersperminutes; return new Speed(value, SpeedUnit.DecimeterPerMinute); } + /// /// Creates a from . /// @@ -462,6 +466,7 @@ public static Speed FromDecimetersPerSecond(double decimeterspersecond) double value = (double) decimeterspersecond; return new Speed(value, SpeedUnit.DecimeterPerSecond); } + /// /// Creates a from . /// @@ -472,6 +477,7 @@ public static Speed FromFeetPerHour(double feetperhour) double value = (double) feetperhour; return new Speed(value, SpeedUnit.FootPerHour); } + /// /// Creates a from . /// @@ -482,6 +488,7 @@ public static Speed FromFeetPerMinute(double feetperminute) double value = (double) feetperminute; return new Speed(value, SpeedUnit.FootPerMinute); } + /// /// Creates a from . /// @@ -492,6 +499,7 @@ public static Speed FromFeetPerSecond(double feetpersecond) double value = (double) feetpersecond; return new Speed(value, SpeedUnit.FootPerSecond); } + /// /// Creates a from . /// @@ -502,6 +510,7 @@ public static Speed FromInchesPerHour(double inchesperhour) double value = (double) inchesperhour; return new Speed(value, SpeedUnit.InchPerHour); } + /// /// Creates a from . /// @@ -512,6 +521,7 @@ public static Speed FromInchesPerMinute(double inchesperminute) double value = (double) inchesperminute; return new Speed(value, SpeedUnit.InchPerMinute); } + /// /// Creates a from . /// @@ -522,6 +532,7 @@ public static Speed FromInchesPerSecond(double inchespersecond) double value = (double) inchespersecond; return new Speed(value, SpeedUnit.InchPerSecond); } + /// /// Creates a from . /// @@ -532,6 +543,7 @@ public static Speed FromKilometersPerHour(double kilometersperhour) double value = (double) kilometersperhour; return new Speed(value, SpeedUnit.KilometerPerHour); } + /// /// Creates a from . /// @@ -542,6 +554,7 @@ public static Speed FromKilometersPerMinutes(double kilometersperminutes) double value = (double) kilometersperminutes; return new Speed(value, SpeedUnit.KilometerPerMinute); } + /// /// Creates a from . /// @@ -552,6 +565,7 @@ public static Speed FromKilometersPerSecond(double kilometerspersecond) double value = (double) kilometerspersecond; return new Speed(value, SpeedUnit.KilometerPerSecond); } + /// /// Creates a from . /// @@ -562,6 +576,7 @@ public static Speed FromKnots(double knots) double value = (double) knots; return new Speed(value, SpeedUnit.Knot); } + /// /// Creates a from . /// @@ -572,6 +587,7 @@ public static Speed FromMetersPerHour(double metersperhour) double value = (double) metersperhour; return new Speed(value, SpeedUnit.MeterPerHour); } + /// /// Creates a from . /// @@ -582,6 +598,7 @@ public static Speed FromMetersPerMinutes(double metersperminutes) double value = (double) metersperminutes; return new Speed(value, SpeedUnit.MeterPerMinute); } + /// /// Creates a from . /// @@ -592,6 +609,7 @@ public static Speed FromMetersPerSecond(double meterspersecond) double value = (double) meterspersecond; return new Speed(value, SpeedUnit.MeterPerSecond); } + /// /// Creates a from . /// @@ -602,6 +620,7 @@ public static Speed FromMicrometersPerMinutes(double micrometersperminutes) double value = (double) micrometersperminutes; return new Speed(value, SpeedUnit.MicrometerPerMinute); } + /// /// Creates a from . /// @@ -612,6 +631,7 @@ public static Speed FromMicrometersPerSecond(double micrometerspersecond) double value = (double) micrometerspersecond; return new Speed(value, SpeedUnit.MicrometerPerSecond); } + /// /// Creates a from . /// @@ -622,6 +642,7 @@ public static Speed FromMilesPerHour(double milesperhour) double value = (double) milesperhour; return new Speed(value, SpeedUnit.MilePerHour); } + /// /// Creates a from . /// @@ -632,6 +653,7 @@ public static Speed FromMillimetersPerHour(double millimetersperhour) double value = (double) millimetersperhour; return new Speed(value, SpeedUnit.MillimeterPerHour); } + /// /// Creates a from . /// @@ -642,6 +664,7 @@ public static Speed FromMillimetersPerMinutes(double millimetersperminutes) double value = (double) millimetersperminutes; return new Speed(value, SpeedUnit.MillimeterPerMinute); } + /// /// Creates a from . /// @@ -652,6 +675,7 @@ public static Speed FromMillimetersPerSecond(double millimeterspersecond) double value = (double) millimeterspersecond; return new Speed(value, SpeedUnit.MillimeterPerSecond); } + /// /// Creates a from . /// @@ -662,6 +686,7 @@ public static Speed FromNanometersPerMinutes(double nanometersperminutes) double value = (double) nanometersperminutes; return new Speed(value, SpeedUnit.NanometerPerMinute); } + /// /// Creates a from . /// @@ -672,6 +697,7 @@ public static Speed FromNanometersPerSecond(double nanometerspersecond) double value = (double) nanometerspersecond; return new Speed(value, SpeedUnit.NanometerPerSecond); } + /// /// Creates a from . /// @@ -682,6 +708,7 @@ public static Speed FromUsSurveyFeetPerHour(double ussurveyfeetperhour) double value = (double) ussurveyfeetperhour; return new Speed(value, SpeedUnit.UsSurveyFootPerHour); } + /// /// Creates a from . /// @@ -692,6 +719,7 @@ public static Speed FromUsSurveyFeetPerMinute(double ussurveyfeetperminute) double value = (double) ussurveyfeetperminute; return new Speed(value, SpeedUnit.UsSurveyFootPerMinute); } + /// /// Creates a from . /// @@ -702,6 +730,7 @@ public static Speed FromUsSurveyFeetPerSecond(double ussurveyfeetpersecond) double value = (double) ussurveyfeetpersecond; return new Speed(value, SpeedUnit.UsSurveyFootPerSecond); } + /// /// Creates a from . /// @@ -712,6 +741,7 @@ public static Speed FromYardsPerHour(double yardsperhour) double value = (double) yardsperhour; return new Speed(value, SpeedUnit.YardPerHour); } + /// /// Creates a from . /// @@ -722,6 +752,7 @@ public static Speed FromYardsPerMinute(double yardsperminute) double value = (double) yardsperminute; return new Speed(value, SpeedUnit.YardPerMinute); } + /// /// Creates a from . /// @@ -733,6 +764,7 @@ public static Speed FromYardsPerSecond(double yardspersecond) return new Speed(value, SpeedUnit.YardPerSecond); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/StandardVolumeFlow.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/StandardVolumeFlow.g.cs index 9a8960d99e..7ede7df62c 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/StandardVolumeFlow.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/StandardVolumeFlow.g.cs @@ -261,6 +261,7 @@ public static StandardVolumeFlow FromStandardCubicCentimetersPerMinute(double st double value = (double) standardcubiccentimetersperminute; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute); } + /// /// Creates a from . /// @@ -271,6 +272,7 @@ public static StandardVolumeFlow FromStandardCubicFeetPerHour(double standardcub double value = (double) standardcubicfeetperhour; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicFootPerHour); } + /// /// Creates a from . /// @@ -281,6 +283,7 @@ public static StandardVolumeFlow FromStandardCubicFeetPerMinute(double standardc double value = (double) standardcubicfeetperminute; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicFootPerMinute); } + /// /// Creates a from . /// @@ -291,6 +294,7 @@ public static StandardVolumeFlow FromStandardCubicFeetPerSecond(double standardc double value = (double) standardcubicfeetpersecond; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicFootPerSecond); } + /// /// Creates a from . /// @@ -301,6 +305,7 @@ public static StandardVolumeFlow FromStandardCubicMetersPerDay(double standardcu double value = (double) standardcubicmetersperday; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicMeterPerDay); } + /// /// Creates a from . /// @@ -311,6 +316,7 @@ public static StandardVolumeFlow FromStandardCubicMetersPerHour(double standardc double value = (double) standardcubicmetersperhour; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicMeterPerHour); } + /// /// Creates a from . /// @@ -321,6 +327,7 @@ public static StandardVolumeFlow FromStandardCubicMetersPerMinute(double standar double value = (double) standardcubicmetersperminute; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicMeterPerMinute); } + /// /// Creates a from . /// @@ -331,6 +338,7 @@ public static StandardVolumeFlow FromStandardCubicMetersPerSecond(double standar double value = (double) standardcubicmeterspersecond; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicMeterPerSecond); } + /// /// Creates a from . /// @@ -342,6 +350,7 @@ public static StandardVolumeFlow FromStandardLitersPerMinute(double standardlite return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardLiterPerMinute); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Temperature.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Temperature.g.cs index f58a09b096..7200d43f09 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Temperature.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Temperature.g.cs @@ -267,6 +267,7 @@ public static Temperature FromDegreesCelsius(double degreescelsius) double value = (double) degreescelsius; return new Temperature(value, TemperatureUnit.DegreeCelsius); } + /// /// Creates a from . /// @@ -277,6 +278,7 @@ public static Temperature FromDegreesDelisle(double degreesdelisle) double value = (double) degreesdelisle; return new Temperature(value, TemperatureUnit.DegreeDelisle); } + /// /// Creates a from . /// @@ -287,6 +289,7 @@ public static Temperature FromDegreesFahrenheit(double degreesfahrenheit) double value = (double) degreesfahrenheit; return new Temperature(value, TemperatureUnit.DegreeFahrenheit); } + /// /// Creates a from . /// @@ -297,6 +300,7 @@ public static Temperature FromDegreesNewton(double degreesnewton) double value = (double) degreesnewton; return new Temperature(value, TemperatureUnit.DegreeNewton); } + /// /// Creates a from . /// @@ -307,6 +311,7 @@ public static Temperature FromDegreesRankine(double degreesrankine) double value = (double) degreesrankine; return new Temperature(value, TemperatureUnit.DegreeRankine); } + /// /// Creates a from . /// @@ -317,6 +322,7 @@ public static Temperature FromDegreesReaumur(double degreesreaumur) double value = (double) degreesreaumur; return new Temperature(value, TemperatureUnit.DegreeReaumur); } + /// /// Creates a from . /// @@ -327,6 +333,7 @@ public static Temperature FromDegreesRoemer(double degreesroemer) double value = (double) degreesroemer; return new Temperature(value, TemperatureUnit.DegreeRoemer); } + /// /// Creates a from . /// @@ -337,6 +344,7 @@ public static Temperature FromKelvins(double kelvins) double value = (double) kelvins; return new Temperature(value, TemperatureUnit.Kelvin); } + /// /// Creates a from . /// @@ -347,6 +355,7 @@ public static Temperature FromMillidegreesCelsius(double millidegreescelsius) double value = (double) millidegreescelsius; return new Temperature(value, TemperatureUnit.MillidegreeCelsius); } + /// /// Creates a from . /// @@ -358,6 +367,7 @@ public static Temperature FromSolarTemperatures(double solartemperatures) return new Temperature(value, TemperatureUnit.SolarTemperature); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureChangeRate.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureChangeRate.g.cs index 6a9dda55eb..115bc26a70 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureChangeRate.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureChangeRate.g.cs @@ -267,6 +267,7 @@ public static TemperatureChangeRate FromCentidegreesCelsiusPerSecond(double cent double value = (double) centidegreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond); } + /// /// Creates a from . /// @@ -277,6 +278,7 @@ public static TemperatureChangeRate FromDecadegreesCelsiusPerSecond(double decad double value = (double) decadegreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond); } + /// /// Creates a from . /// @@ -287,6 +289,7 @@ public static TemperatureChangeRate FromDecidegreesCelsiusPerSecond(double decid double value = (double) decidegreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond); } + /// /// Creates a from . /// @@ -297,6 +300,7 @@ public static TemperatureChangeRate FromDegreesCelsiusPerMinute(double degreesce double value = (double) degreescelsiusperminute; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DegreeCelsiusPerMinute); } + /// /// Creates a from . /// @@ -307,6 +311,7 @@ public static TemperatureChangeRate FromDegreesCelsiusPerSecond(double degreesce double value = (double) degreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DegreeCelsiusPerSecond); } + /// /// Creates a from . /// @@ -317,6 +322,7 @@ public static TemperatureChangeRate FromHectodegreesCelsiusPerSecond(double hect double value = (double) hectodegreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond); } + /// /// Creates a from . /// @@ -327,6 +333,7 @@ public static TemperatureChangeRate FromKilodegreesCelsiusPerSecond(double kilod double value = (double) kilodegreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond); } + /// /// Creates a from . /// @@ -337,6 +344,7 @@ public static TemperatureChangeRate FromMicrodegreesCelsiusPerSecond(double micr double value = (double) microdegreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond); } + /// /// Creates a from . /// @@ -347,6 +355,7 @@ public static TemperatureChangeRate FromMillidegreesCelsiusPerSecond(double mill double value = (double) millidegreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond); } + /// /// Creates a from . /// @@ -358,6 +367,7 @@ public static TemperatureChangeRate FromNanodegreesCelsiusPerSecond(double nanod return new TemperatureChangeRate(value, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureDelta.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureDelta.g.cs index 67eb429aea..fd46c391a0 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureDelta.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureDelta.g.cs @@ -261,6 +261,7 @@ public static TemperatureDelta FromDegreesCelsius(double degreescelsius) double value = (double) degreescelsius; return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeCelsius); } + /// /// Creates a from . /// @@ -271,6 +272,7 @@ public static TemperatureDelta FromDegreesDelisle(double degreesdelisle) double value = (double) degreesdelisle; return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeDelisle); } + /// /// Creates a from . /// @@ -281,6 +283,7 @@ public static TemperatureDelta FromDegreesFahrenheit(double degreesfahrenheit) double value = (double) degreesfahrenheit; return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeFahrenheit); } + /// /// Creates a from . /// @@ -291,6 +294,7 @@ public static TemperatureDelta FromDegreesNewton(double degreesnewton) double value = (double) degreesnewton; return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeNewton); } + /// /// Creates a from . /// @@ -301,6 +305,7 @@ public static TemperatureDelta FromDegreesRankine(double degreesrankine) double value = (double) degreesrankine; return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeRankine); } + /// /// Creates a from . /// @@ -311,6 +316,7 @@ public static TemperatureDelta FromDegreesReaumur(double degreesreaumur) double value = (double) degreesreaumur; return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeReaumur); } + /// /// Creates a from . /// @@ -321,6 +327,7 @@ public static TemperatureDelta FromDegreesRoemer(double degreesroemer) double value = (double) degreesroemer; return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeRoemer); } + /// /// Creates a from . /// @@ -331,6 +338,7 @@ public static TemperatureDelta FromKelvins(double kelvins) double value = (double) kelvins; return new TemperatureDelta(value, TemperatureDeltaUnit.Kelvin); } + /// /// Creates a from . /// @@ -342,6 +350,7 @@ public static TemperatureDelta FromMillidegreesCelsius(double millidegreescelsiu return new TemperatureDelta(value, TemperatureDeltaUnit.MillidegreeCelsius); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureGradient.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureGradient.g.cs index 6a13bad8ec..e86c810fe9 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureGradient.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureGradient.g.cs @@ -231,6 +231,7 @@ public static TemperatureGradient FromDegreesCelciusPerKilometer(double degreesc double value = (double) degreescelciusperkilometer; return new TemperatureGradient(value, TemperatureGradientUnit.DegreeCelsiusPerKilometer); } + /// /// Creates a from . /// @@ -241,6 +242,7 @@ public static TemperatureGradient FromDegreesCelciusPerMeter(double degreescelci double value = (double) degreescelciuspermeter; return new TemperatureGradient(value, TemperatureGradientUnit.DegreeCelsiusPerMeter); } + /// /// Creates a from . /// @@ -251,6 +253,7 @@ public static TemperatureGradient FromDegreesFahrenheitPerFoot(double degreesfah double value = (double) degreesfahrenheitperfoot; return new TemperatureGradient(value, TemperatureGradientUnit.DegreeFahrenheitPerFoot); } + /// /// Creates a from . /// @@ -262,6 +265,7 @@ public static TemperatureGradient FromKelvinsPerMeter(double kelvinspermeter) return new TemperatureGradient(value, TemperatureGradientUnit.KelvinPerMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalConductivity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalConductivity.g.cs index 3d79f438ae..48e063c970 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalConductivity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalConductivity.g.cs @@ -222,6 +222,7 @@ public static ThermalConductivity FromBtusPerHourFootFahrenheit(double btusperho double value = (double) btusperhourfootfahrenheit; return new ThermalConductivity(value, ThermalConductivityUnit.BtuPerHourFootFahrenheit); } + /// /// Creates a from . /// @@ -233,6 +234,7 @@ public static ThermalConductivity FromWattsPerMeterKelvin(double wattspermeterke return new ThermalConductivity(value, ThermalConductivityUnit.WattPerMeterKelvin); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalResistance.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalResistance.g.cs index ee78addddf..5de8ae9088 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalResistance.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalResistance.g.cs @@ -243,6 +243,7 @@ public static ThermalResistance FromHourSquareFeetDegreesFahrenheitPerBtu(double double value = (double) hoursquarefeetdegreesfahrenheitperbtu; return new ThermalResistance(value, ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu); } + /// /// Creates a from . /// @@ -253,6 +254,7 @@ public static ThermalResistance FromSquareCentimeterHourDegreesCelsiusPerKilocal double value = (double) squarecentimeterhourdegreescelsiusperkilocalorie; return new ThermalResistance(value, ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie); } + /// /// Creates a from . /// @@ -263,6 +265,7 @@ public static ThermalResistance FromSquareCentimeterKelvinsPerWatt(double square double value = (double) squarecentimeterkelvinsperwatt; return new ThermalResistance(value, ThermalResistanceUnit.SquareCentimeterKelvinPerWatt); } + /// /// Creates a from . /// @@ -273,6 +276,7 @@ public static ThermalResistance FromSquareMeterDegreesCelsiusPerWatt(double squa double value = (double) squaremeterdegreescelsiusperwatt; return new ThermalResistance(value, ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt); } + /// /// Creates a from . /// @@ -283,6 +287,7 @@ public static ThermalResistance FromSquareMeterKelvinsPerKilowatt(double squarem double value = (double) squaremeterkelvinsperkilowatt; return new ThermalResistance(value, ThermalResistanceUnit.SquareMeterKelvinPerKilowatt); } + /// /// Creates a from . /// @@ -294,6 +299,7 @@ public static ThermalResistance FromSquareMeterKelvinsPerWatt(double squaremeter return new ThermalResistance(value, ThermalResistanceUnit.SquareMeterKelvinPerWatt); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Torque.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Torque.g.cs index 1f25043f75..177a41b8b0 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Torque.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Torque.g.cs @@ -360,6 +360,7 @@ public static Torque FromGramForceCentimeters(double gramforcecentimeters) double value = (double) gramforcecentimeters; return new Torque(value, TorqueUnit.GramForceCentimeter); } + /// /// Creates a from . /// @@ -370,6 +371,7 @@ public static Torque FromGramForceMeters(double gramforcemeters) double value = (double) gramforcemeters; return new Torque(value, TorqueUnit.GramForceMeter); } + /// /// Creates a from . /// @@ -380,6 +382,7 @@ public static Torque FromGramForceMillimeters(double gramforcemillimeters) double value = (double) gramforcemillimeters; return new Torque(value, TorqueUnit.GramForceMillimeter); } + /// /// Creates a from . /// @@ -390,6 +393,7 @@ public static Torque FromKilogramForceCentimeters(double kilogramforcecentimeter double value = (double) kilogramforcecentimeters; return new Torque(value, TorqueUnit.KilogramForceCentimeter); } + /// /// Creates a from . /// @@ -400,6 +404,7 @@ public static Torque FromKilogramForceMeters(double kilogramforcemeters) double value = (double) kilogramforcemeters; return new Torque(value, TorqueUnit.KilogramForceMeter); } + /// /// Creates a from . /// @@ -410,6 +415,7 @@ public static Torque FromKilogramForceMillimeters(double kilogramforcemillimeter double value = (double) kilogramforcemillimeters; return new Torque(value, TorqueUnit.KilogramForceMillimeter); } + /// /// Creates a from . /// @@ -420,6 +426,7 @@ public static Torque FromKilonewtonCentimeters(double kilonewtoncentimeters) double value = (double) kilonewtoncentimeters; return new Torque(value, TorqueUnit.KilonewtonCentimeter); } + /// /// Creates a from . /// @@ -430,6 +437,7 @@ public static Torque FromKilonewtonMeters(double kilonewtonmeters) double value = (double) kilonewtonmeters; return new Torque(value, TorqueUnit.KilonewtonMeter); } + /// /// Creates a from . /// @@ -440,6 +448,7 @@ public static Torque FromKilonewtonMillimeters(double kilonewtonmillimeters) double value = (double) kilonewtonmillimeters; return new Torque(value, TorqueUnit.KilonewtonMillimeter); } + /// /// Creates a from . /// @@ -450,6 +459,7 @@ public static Torque FromKilopoundForceFeet(double kilopoundforcefeet) double value = (double) kilopoundforcefeet; return new Torque(value, TorqueUnit.KilopoundForceFoot); } + /// /// Creates a from . /// @@ -460,6 +470,7 @@ public static Torque FromKilopoundForceInches(double kilopoundforceinches) double value = (double) kilopoundforceinches; return new Torque(value, TorqueUnit.KilopoundForceInch); } + /// /// Creates a from . /// @@ -470,6 +481,7 @@ public static Torque FromMeganewtonCentimeters(double meganewtoncentimeters) double value = (double) meganewtoncentimeters; return new Torque(value, TorqueUnit.MeganewtonCentimeter); } + /// /// Creates a from . /// @@ -480,6 +492,7 @@ public static Torque FromMeganewtonMeters(double meganewtonmeters) double value = (double) meganewtonmeters; return new Torque(value, TorqueUnit.MeganewtonMeter); } + /// /// Creates a from . /// @@ -490,6 +503,7 @@ public static Torque FromMeganewtonMillimeters(double meganewtonmillimeters) double value = (double) meganewtonmillimeters; return new Torque(value, TorqueUnit.MeganewtonMillimeter); } + /// /// Creates a from . /// @@ -500,6 +514,7 @@ public static Torque FromMegapoundForceFeet(double megapoundforcefeet) double value = (double) megapoundforcefeet; return new Torque(value, TorqueUnit.MegapoundForceFoot); } + /// /// Creates a from . /// @@ -510,6 +525,7 @@ public static Torque FromMegapoundForceInches(double megapoundforceinches) double value = (double) megapoundforceinches; return new Torque(value, TorqueUnit.MegapoundForceInch); } + /// /// Creates a from . /// @@ -520,6 +536,7 @@ public static Torque FromNewtonCentimeters(double newtoncentimeters) double value = (double) newtoncentimeters; return new Torque(value, TorqueUnit.NewtonCentimeter); } + /// /// Creates a from . /// @@ -530,6 +547,7 @@ public static Torque FromNewtonMeters(double newtonmeters) double value = (double) newtonmeters; return new Torque(value, TorqueUnit.NewtonMeter); } + /// /// Creates a from . /// @@ -540,6 +558,7 @@ public static Torque FromNewtonMillimeters(double newtonmillimeters) double value = (double) newtonmillimeters; return new Torque(value, TorqueUnit.NewtonMillimeter); } + /// /// Creates a from . /// @@ -550,6 +569,7 @@ public static Torque FromPoundalFeet(double poundalfeet) double value = (double) poundalfeet; return new Torque(value, TorqueUnit.PoundalFoot); } + /// /// Creates a from . /// @@ -560,6 +580,7 @@ public static Torque FromPoundForceFeet(double poundforcefeet) double value = (double) poundforcefeet; return new Torque(value, TorqueUnit.PoundForceFoot); } + /// /// Creates a from . /// @@ -570,6 +591,7 @@ public static Torque FromPoundForceInches(double poundforceinches) double value = (double) poundforceinches; return new Torque(value, TorqueUnit.PoundForceInch); } + /// /// Creates a from . /// @@ -580,6 +602,7 @@ public static Torque FromTonneForceCentimeters(double tonneforcecentimeters) double value = (double) tonneforcecentimeters; return new Torque(value, TorqueUnit.TonneForceCentimeter); } + /// /// Creates a from . /// @@ -590,6 +613,7 @@ public static Torque FromTonneForceMeters(double tonneforcemeters) double value = (double) tonneforcemeters; return new Torque(value, TorqueUnit.TonneForceMeter); } + /// /// Creates a from . /// @@ -601,6 +625,7 @@ public static Torque FromTonneForceMillimeters(double tonneforcemillimeters) return new Torque(value, TorqueUnit.TonneForceMillimeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TorquePerLength.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TorquePerLength.g.cs index b5f514e166..f9d12545d4 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TorquePerLength.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TorquePerLength.g.cs @@ -336,6 +336,7 @@ public static TorquePerLength FromKilogramForceCentimetersPerMeter(double kilogr double value = (double) kilogramforcecentimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.KilogramForceCentimeterPerMeter); } + /// /// Creates a from . /// @@ -346,6 +347,7 @@ public static TorquePerLength FromKilogramForceMetersPerMeter(double kilogramfor double value = (double) kilogramforcemeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.KilogramForceMeterPerMeter); } + /// /// Creates a from . /// @@ -356,6 +358,7 @@ public static TorquePerLength FromKilogramForceMillimetersPerMeter(double kilogr double value = (double) kilogramforcemillimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.KilogramForceMillimeterPerMeter); } + /// /// Creates a from . /// @@ -366,6 +369,7 @@ public static TorquePerLength FromKilonewtonCentimetersPerMeter(double kilonewto double value = (double) kilonewtoncentimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.KilonewtonCentimeterPerMeter); } + /// /// Creates a from . /// @@ -376,6 +380,7 @@ public static TorquePerLength FromKilonewtonMetersPerMeter(double kilonewtonmete double value = (double) kilonewtonmeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.KilonewtonMeterPerMeter); } + /// /// Creates a from . /// @@ -386,6 +391,7 @@ public static TorquePerLength FromKilonewtonMillimetersPerMeter(double kilonewto double value = (double) kilonewtonmillimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.KilonewtonMillimeterPerMeter); } + /// /// Creates a from . /// @@ -396,6 +402,7 @@ public static TorquePerLength FromKilopoundForceFeetPerFoot(double kilopoundforc double value = (double) kilopoundforcefeetperfoot; return new TorquePerLength(value, TorquePerLengthUnit.KilopoundForceFootPerFoot); } + /// /// Creates a from . /// @@ -406,6 +413,7 @@ public static TorquePerLength FromKilopoundForceInchesPerFoot(double kilopoundfo double value = (double) kilopoundforceinchesperfoot; return new TorquePerLength(value, TorquePerLengthUnit.KilopoundForceInchPerFoot); } + /// /// Creates a from . /// @@ -416,6 +424,7 @@ public static TorquePerLength FromMeganewtonCentimetersPerMeter(double meganewto double value = (double) meganewtoncentimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.MeganewtonCentimeterPerMeter); } + /// /// Creates a from . /// @@ -426,6 +435,7 @@ public static TorquePerLength FromMeganewtonMetersPerMeter(double meganewtonmete double value = (double) meganewtonmeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.MeganewtonMeterPerMeter); } + /// /// Creates a from . /// @@ -436,6 +446,7 @@ public static TorquePerLength FromMeganewtonMillimetersPerMeter(double meganewto double value = (double) meganewtonmillimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.MeganewtonMillimeterPerMeter); } + /// /// Creates a from . /// @@ -446,6 +457,7 @@ public static TorquePerLength FromMegapoundForceFeetPerFoot(double megapoundforc double value = (double) megapoundforcefeetperfoot; return new TorquePerLength(value, TorquePerLengthUnit.MegapoundForceFootPerFoot); } + /// /// Creates a from . /// @@ -456,6 +468,7 @@ public static TorquePerLength FromMegapoundForceInchesPerFoot(double megapoundfo double value = (double) megapoundforceinchesperfoot; return new TorquePerLength(value, TorquePerLengthUnit.MegapoundForceInchPerFoot); } + /// /// Creates a from . /// @@ -466,6 +479,7 @@ public static TorquePerLength FromNewtonCentimetersPerMeter(double newtoncentime double value = (double) newtoncentimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.NewtonCentimeterPerMeter); } + /// /// Creates a from . /// @@ -476,6 +490,7 @@ public static TorquePerLength FromNewtonMetersPerMeter(double newtonmeterspermet double value = (double) newtonmeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.NewtonMeterPerMeter); } + /// /// Creates a from . /// @@ -486,6 +501,7 @@ public static TorquePerLength FromNewtonMillimetersPerMeter(double newtonmillime double value = (double) newtonmillimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.NewtonMillimeterPerMeter); } + /// /// Creates a from . /// @@ -496,6 +512,7 @@ public static TorquePerLength FromPoundForceFeetPerFoot(double poundforcefeetper double value = (double) poundforcefeetperfoot; return new TorquePerLength(value, TorquePerLengthUnit.PoundForceFootPerFoot); } + /// /// Creates a from . /// @@ -506,6 +523,7 @@ public static TorquePerLength FromPoundForceInchesPerFoot(double poundforceinche double value = (double) poundforceinchesperfoot; return new TorquePerLength(value, TorquePerLengthUnit.PoundForceInchPerFoot); } + /// /// Creates a from . /// @@ -516,6 +534,7 @@ public static TorquePerLength FromTonneForceCentimetersPerMeter(double tonneforc double value = (double) tonneforcecentimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.TonneForceCentimeterPerMeter); } + /// /// Creates a from . /// @@ -526,6 +545,7 @@ public static TorquePerLength FromTonneForceMetersPerMeter(double tonneforcemete double value = (double) tonneforcemeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.TonneForceMeterPerMeter); } + /// /// Creates a from . /// @@ -537,6 +557,7 @@ public static TorquePerLength FromTonneForceMillimetersPerMeter(double tonneforc return new TorquePerLength(value, TorquePerLengthUnit.TonneForceMillimeterPerMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Turbidity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Turbidity.g.cs index 6dffba132e..bc9e4c297c 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Turbidity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Turbidity.g.cs @@ -217,6 +217,7 @@ public static Turbidity FromNTU(double ntu) return new Turbidity(value, TurbidityUnit.NTU); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VitaminA.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VitaminA.g.cs index 167fa714db..3a4c2382d8 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VitaminA.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VitaminA.g.cs @@ -214,6 +214,7 @@ public static VitaminA FromInternationalUnits(double internationalunits) return new VitaminA(value, VitaminAUnit.InternationalUnit); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Volume.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Volume.g.cs index 2413799e2b..cdb1402136 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Volume.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Volume.g.cs @@ -566,6 +566,7 @@ public static Volume FromAcreFeet(double acrefeet) double value = (double) acrefeet; return new Volume(value, VolumeUnit.AcreFoot); } + /// /// Creates a from . /// @@ -576,6 +577,7 @@ public static Volume FromAuTablespoons(double autablespoons) double value = (double) autablespoons; return new Volume(value, VolumeUnit.AuTablespoon); } + /// /// Creates a from . /// @@ -586,6 +588,7 @@ public static Volume FromBoardFeet(double boardfeet) double value = (double) boardfeet; return new Volume(value, VolumeUnit.BoardFoot); } + /// /// Creates a from . /// @@ -596,6 +599,7 @@ public static Volume FromCentiliters(double centiliters) double value = (double) centiliters; return new Volume(value, VolumeUnit.Centiliter); } + /// /// Creates a from . /// @@ -606,6 +610,7 @@ public static Volume FromCubicCentimeters(double cubiccentimeters) double value = (double) cubiccentimeters; return new Volume(value, VolumeUnit.CubicCentimeter); } + /// /// Creates a from . /// @@ -616,6 +621,7 @@ public static Volume FromCubicDecimeters(double cubicdecimeters) double value = (double) cubicdecimeters; return new Volume(value, VolumeUnit.CubicDecimeter); } + /// /// Creates a from . /// @@ -626,6 +632,7 @@ public static Volume FromCubicFeet(double cubicfeet) double value = (double) cubicfeet; return new Volume(value, VolumeUnit.CubicFoot); } + /// /// Creates a from . /// @@ -636,6 +643,7 @@ public static Volume FromCubicHectometers(double cubichectometers) double value = (double) cubichectometers; return new Volume(value, VolumeUnit.CubicHectometer); } + /// /// Creates a from . /// @@ -646,6 +654,7 @@ public static Volume FromCubicInches(double cubicinches) double value = (double) cubicinches; return new Volume(value, VolumeUnit.CubicInch); } + /// /// Creates a from . /// @@ -656,6 +665,7 @@ public static Volume FromCubicKilometers(double cubickilometers) double value = (double) cubickilometers; return new Volume(value, VolumeUnit.CubicKilometer); } + /// /// Creates a from . /// @@ -666,6 +676,7 @@ public static Volume FromCubicMeters(double cubicmeters) double value = (double) cubicmeters; return new Volume(value, VolumeUnit.CubicMeter); } + /// /// Creates a from . /// @@ -676,6 +687,7 @@ public static Volume FromCubicMicrometers(double cubicmicrometers) double value = (double) cubicmicrometers; return new Volume(value, VolumeUnit.CubicMicrometer); } + /// /// Creates a from . /// @@ -686,6 +698,7 @@ public static Volume FromCubicMiles(double cubicmiles) double value = (double) cubicmiles; return new Volume(value, VolumeUnit.CubicMile); } + /// /// Creates a from . /// @@ -696,6 +709,7 @@ public static Volume FromCubicMillimeters(double cubicmillimeters) double value = (double) cubicmillimeters; return new Volume(value, VolumeUnit.CubicMillimeter); } + /// /// Creates a from . /// @@ -706,6 +720,7 @@ public static Volume FromCubicYards(double cubicyards) double value = (double) cubicyards; return new Volume(value, VolumeUnit.CubicYard); } + /// /// Creates a from . /// @@ -716,6 +731,7 @@ public static Volume FromDecaliters(double decaliters) double value = (double) decaliters; return new Volume(value, VolumeUnit.Decaliter); } + /// /// Creates a from . /// @@ -726,6 +742,7 @@ public static Volume FromDecausGallons(double decausgallons) double value = (double) decausgallons; return new Volume(value, VolumeUnit.DecausGallon); } + /// /// Creates a from . /// @@ -736,6 +753,7 @@ public static Volume FromDeciliters(double deciliters) double value = (double) deciliters; return new Volume(value, VolumeUnit.Deciliter); } + /// /// Creates a from . /// @@ -746,6 +764,7 @@ public static Volume FromDeciusGallons(double deciusgallons) double value = (double) deciusgallons; return new Volume(value, VolumeUnit.DeciusGallon); } + /// /// Creates a from . /// @@ -756,6 +775,7 @@ public static Volume FromHectocubicFeet(double hectocubicfeet) double value = (double) hectocubicfeet; return new Volume(value, VolumeUnit.HectocubicFoot); } + /// /// Creates a from . /// @@ -766,6 +786,7 @@ public static Volume FromHectocubicMeters(double hectocubicmeters) double value = (double) hectocubicmeters; return new Volume(value, VolumeUnit.HectocubicMeter); } + /// /// Creates a from . /// @@ -776,6 +797,7 @@ public static Volume FromHectoliters(double hectoliters) double value = (double) hectoliters; return new Volume(value, VolumeUnit.Hectoliter); } + /// /// Creates a from . /// @@ -786,6 +808,7 @@ public static Volume FromHectousGallons(double hectousgallons) double value = (double) hectousgallons; return new Volume(value, VolumeUnit.HectousGallon); } + /// /// Creates a from . /// @@ -796,6 +819,7 @@ public static Volume FromImperialBeerBarrels(double imperialbeerbarrels) double value = (double) imperialbeerbarrels; return new Volume(value, VolumeUnit.ImperialBeerBarrel); } + /// /// Creates a from . /// @@ -806,6 +830,7 @@ public static Volume FromImperialGallons(double imperialgallons) double value = (double) imperialgallons; return new Volume(value, VolumeUnit.ImperialGallon); } + /// /// Creates a from . /// @@ -816,6 +841,7 @@ public static Volume FromImperialOunces(double imperialounces) double value = (double) imperialounces; return new Volume(value, VolumeUnit.ImperialOunce); } + /// /// Creates a from . /// @@ -826,6 +852,7 @@ public static Volume FromImperialPints(double imperialpints) double value = (double) imperialpints; return new Volume(value, VolumeUnit.ImperialPint); } + /// /// Creates a from . /// @@ -836,6 +863,7 @@ public static Volume FromKilocubicFeet(double kilocubicfeet) double value = (double) kilocubicfeet; return new Volume(value, VolumeUnit.KilocubicFoot); } + /// /// Creates a from . /// @@ -846,6 +874,7 @@ public static Volume FromKilocubicMeters(double kilocubicmeters) double value = (double) kilocubicmeters; return new Volume(value, VolumeUnit.KilocubicMeter); } + /// /// Creates a from . /// @@ -856,6 +885,7 @@ public static Volume FromKiloimperialGallons(double kiloimperialgallons) double value = (double) kiloimperialgallons; return new Volume(value, VolumeUnit.KiloimperialGallon); } + /// /// Creates a from . /// @@ -866,6 +896,7 @@ public static Volume FromKiloliters(double kiloliters) double value = (double) kiloliters; return new Volume(value, VolumeUnit.Kiloliter); } + /// /// Creates a from . /// @@ -876,6 +907,7 @@ public static Volume FromKilousGallons(double kilousgallons) double value = (double) kilousgallons; return new Volume(value, VolumeUnit.KilousGallon); } + /// /// Creates a from . /// @@ -886,6 +918,7 @@ public static Volume FromLiters(double liters) double value = (double) liters; return new Volume(value, VolumeUnit.Liter); } + /// /// Creates a from . /// @@ -896,6 +929,7 @@ public static Volume FromMegacubicFeet(double megacubicfeet) double value = (double) megacubicfeet; return new Volume(value, VolumeUnit.MegacubicFoot); } + /// /// Creates a from . /// @@ -906,6 +940,7 @@ public static Volume FromMegaimperialGallons(double megaimperialgallons) double value = (double) megaimperialgallons; return new Volume(value, VolumeUnit.MegaimperialGallon); } + /// /// Creates a from . /// @@ -916,6 +951,7 @@ public static Volume FromMegaliters(double megaliters) double value = (double) megaliters; return new Volume(value, VolumeUnit.Megaliter); } + /// /// Creates a from . /// @@ -926,6 +962,7 @@ public static Volume FromMegausGallons(double megausgallons) double value = (double) megausgallons; return new Volume(value, VolumeUnit.MegausGallon); } + /// /// Creates a from . /// @@ -936,6 +973,7 @@ public static Volume FromMetricCups(double metriccups) double value = (double) metriccups; return new Volume(value, VolumeUnit.MetricCup); } + /// /// Creates a from . /// @@ -946,6 +984,7 @@ public static Volume FromMetricTeaspoons(double metricteaspoons) double value = (double) metricteaspoons; return new Volume(value, VolumeUnit.MetricTeaspoon); } + /// /// Creates a from . /// @@ -956,6 +995,7 @@ public static Volume FromMicroliters(double microliters) double value = (double) microliters; return new Volume(value, VolumeUnit.Microliter); } + /// /// Creates a from . /// @@ -966,6 +1006,7 @@ public static Volume FromMilliliters(double milliliters) double value = (double) milliliters; return new Volume(value, VolumeUnit.Milliliter); } + /// /// Creates a from . /// @@ -976,6 +1017,7 @@ public static Volume FromOilBarrels(double oilbarrels) double value = (double) oilbarrels; return new Volume(value, VolumeUnit.OilBarrel); } + /// /// Creates a from . /// @@ -986,6 +1028,7 @@ public static Volume FromUkTablespoons(double uktablespoons) double value = (double) uktablespoons; return new Volume(value, VolumeUnit.UkTablespoon); } + /// /// Creates a from . /// @@ -996,6 +1039,7 @@ public static Volume FromUsBeerBarrels(double usbeerbarrels) double value = (double) usbeerbarrels; return new Volume(value, VolumeUnit.UsBeerBarrel); } + /// /// Creates a from . /// @@ -1006,6 +1050,7 @@ public static Volume FromUsCustomaryCups(double uscustomarycups) double value = (double) uscustomarycups; return new Volume(value, VolumeUnit.UsCustomaryCup); } + /// /// Creates a from . /// @@ -1016,6 +1061,7 @@ public static Volume FromUsGallons(double usgallons) double value = (double) usgallons; return new Volume(value, VolumeUnit.UsGallon); } + /// /// Creates a from . /// @@ -1026,6 +1072,7 @@ public static Volume FromUsLegalCups(double uslegalcups) double value = (double) uslegalcups; return new Volume(value, VolumeUnit.UsLegalCup); } + /// /// Creates a from . /// @@ -1036,6 +1083,7 @@ public static Volume FromUsOunces(double usounces) double value = (double) usounces; return new Volume(value, VolumeUnit.UsOunce); } + /// /// Creates a from . /// @@ -1046,6 +1094,7 @@ public static Volume FromUsPints(double uspints) double value = (double) uspints; return new Volume(value, VolumeUnit.UsPint); } + /// /// Creates a from . /// @@ -1056,6 +1105,7 @@ public static Volume FromUsQuarts(double usquarts) double value = (double) usquarts; return new Volume(value, VolumeUnit.UsQuart); } + /// /// Creates a from . /// @@ -1066,6 +1116,7 @@ public static Volume FromUsTablespoons(double ustablespoons) double value = (double) ustablespoons; return new Volume(value, VolumeUnit.UsTablespoon); } + /// /// Creates a from . /// @@ -1077,6 +1128,7 @@ public static Volume FromUsTeaspoons(double usteaspoons) return new Volume(value, VolumeUnit.UsTeaspoon); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeConcentration.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeConcentration.g.cs index df2e356fa9..774ab97650 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeConcentration.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeConcentration.g.cs @@ -330,6 +330,7 @@ public static VolumeConcentration FromCentilitersPerLiter(double centilitersperl double value = (double) centilitersperliter; return new VolumeConcentration(value, VolumeConcentrationUnit.CentilitersPerLiter); } + /// /// Creates a from . /// @@ -340,6 +341,7 @@ public static VolumeConcentration FromCentilitersPerMililiter(double centiliters double value = (double) centiliterspermililiter; return new VolumeConcentration(value, VolumeConcentrationUnit.CentilitersPerMililiter); } + /// /// Creates a from . /// @@ -350,6 +352,7 @@ public static VolumeConcentration FromDecilitersPerLiter(double decilitersperlit double value = (double) decilitersperliter; return new VolumeConcentration(value, VolumeConcentrationUnit.DecilitersPerLiter); } + /// /// Creates a from . /// @@ -360,6 +363,7 @@ public static VolumeConcentration FromDecilitersPerMililiter(double deciliterspe double value = (double) deciliterspermililiter; return new VolumeConcentration(value, VolumeConcentrationUnit.DecilitersPerMililiter); } + /// /// Creates a from . /// @@ -370,6 +374,7 @@ public static VolumeConcentration FromDecimalFractions(double decimalfractions) double value = (double) decimalfractions; return new VolumeConcentration(value, VolumeConcentrationUnit.DecimalFraction); } + /// /// Creates a from . /// @@ -380,6 +385,7 @@ public static VolumeConcentration FromLitersPerLiter(double litersperliter) double value = (double) litersperliter; return new VolumeConcentration(value, VolumeConcentrationUnit.LitersPerLiter); } + /// /// Creates a from . /// @@ -390,6 +396,7 @@ public static VolumeConcentration FromLitersPerMililiter(double literspermililit double value = (double) literspermililiter; return new VolumeConcentration(value, VolumeConcentrationUnit.LitersPerMililiter); } + /// /// Creates a from . /// @@ -400,6 +407,7 @@ public static VolumeConcentration FromMicrolitersPerLiter(double microlitersperl double value = (double) microlitersperliter; return new VolumeConcentration(value, VolumeConcentrationUnit.MicrolitersPerLiter); } + /// /// Creates a from . /// @@ -410,6 +418,7 @@ public static VolumeConcentration FromMicrolitersPerMililiter(double microliters double value = (double) microliterspermililiter; return new VolumeConcentration(value, VolumeConcentrationUnit.MicrolitersPerMililiter); } + /// /// Creates a from . /// @@ -420,6 +429,7 @@ public static VolumeConcentration FromMillilitersPerLiter(double millilitersperl double value = (double) millilitersperliter; return new VolumeConcentration(value, VolumeConcentrationUnit.MillilitersPerLiter); } + /// /// Creates a from . /// @@ -430,6 +440,7 @@ public static VolumeConcentration FromMillilitersPerMililiter(double milliliters double value = (double) milliliterspermililiter; return new VolumeConcentration(value, VolumeConcentrationUnit.MillilitersPerMililiter); } + /// /// Creates a from . /// @@ -440,6 +451,7 @@ public static VolumeConcentration FromNanolitersPerLiter(double nanolitersperlit double value = (double) nanolitersperliter; return new VolumeConcentration(value, VolumeConcentrationUnit.NanolitersPerLiter); } + /// /// Creates a from . /// @@ -450,6 +462,7 @@ public static VolumeConcentration FromNanolitersPerMililiter(double nanoliterspe double value = (double) nanoliterspermililiter; return new VolumeConcentration(value, VolumeConcentrationUnit.NanolitersPerMililiter); } + /// /// Creates a from . /// @@ -460,6 +473,7 @@ public static VolumeConcentration FromPartsPerBillion(double partsperbillion) double value = (double) partsperbillion; return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerBillion); } + /// /// Creates a from . /// @@ -470,6 +484,7 @@ public static VolumeConcentration FromPartsPerMillion(double partspermillion) double value = (double) partspermillion; return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerMillion); } + /// /// Creates a from . /// @@ -480,6 +495,7 @@ public static VolumeConcentration FromPartsPerThousand(double partsperthousand) double value = (double) partsperthousand; return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerThousand); } + /// /// Creates a from . /// @@ -490,6 +506,7 @@ public static VolumeConcentration FromPartsPerTrillion(double partspertrillion) double value = (double) partspertrillion; return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerTrillion); } + /// /// Creates a from . /// @@ -500,6 +517,7 @@ public static VolumeConcentration FromPercent(double percent) double value = (double) percent; return new VolumeConcentration(value, VolumeConcentrationUnit.Percent); } + /// /// Creates a from . /// @@ -510,6 +528,7 @@ public static VolumeConcentration FromPicolitersPerLiter(double picolitersperlit double value = (double) picolitersperliter; return new VolumeConcentration(value, VolumeConcentrationUnit.PicolitersPerLiter); } + /// /// Creates a from . /// @@ -521,6 +540,7 @@ public static VolumeConcentration FromPicolitersPerMililiter(double picoliterspe return new VolumeConcentration(value, VolumeConcentrationUnit.PicolitersPerMililiter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlow.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlow.g.cs index b6e8930245..48d62d1026 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlow.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlow.g.cs @@ -606,6 +606,7 @@ public static VolumeFlow FromAcreFeetPerDay(double acrefeetperday) double value = (double) acrefeetperday; return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerDay); } + /// /// Creates a from . /// @@ -616,6 +617,7 @@ public static VolumeFlow FromAcreFeetPerHour(double acrefeetperhour) double value = (double) acrefeetperhour; return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerHour); } + /// /// Creates a from . /// @@ -626,6 +628,7 @@ public static VolumeFlow FromAcreFeetPerMinute(double acrefeetperminute) double value = (double) acrefeetperminute; return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerMinute); } + /// /// Creates a from . /// @@ -636,6 +639,7 @@ public static VolumeFlow FromAcreFeetPerSecond(double acrefeetpersecond) double value = (double) acrefeetpersecond; return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerSecond); } + /// /// Creates a from . /// @@ -646,6 +650,7 @@ public static VolumeFlow FromCentilitersPerDay(double centilitersperday) double value = (double) centilitersperday; return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerDay); } + /// /// Creates a from . /// @@ -656,6 +661,7 @@ public static VolumeFlow FromCentilitersPerHour(double centilitersperhour) double value = (double) centilitersperhour; return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerHour); } + /// /// Creates a from . /// @@ -666,6 +672,7 @@ public static VolumeFlow FromCentilitersPerMinute(double centilitersperminute) double value = (double) centilitersperminute; return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerMinute); } + /// /// Creates a from . /// @@ -676,6 +683,7 @@ public static VolumeFlow FromCentilitersPerSecond(double centiliterspersecond) double value = (double) centiliterspersecond; return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerSecond); } + /// /// Creates a from . /// @@ -686,6 +694,7 @@ public static VolumeFlow FromCubicCentimetersPerMinute(double cubiccentimeterspe double value = (double) cubiccentimetersperminute; return new VolumeFlow(value, VolumeFlowUnit.CubicCentimeterPerMinute); } + /// /// Creates a from . /// @@ -696,6 +705,7 @@ public static VolumeFlow FromCubicDecimetersPerMinute(double cubicdecimetersperm double value = (double) cubicdecimetersperminute; return new VolumeFlow(value, VolumeFlowUnit.CubicDecimeterPerMinute); } + /// /// Creates a from . /// @@ -706,6 +716,7 @@ public static VolumeFlow FromCubicFeetPerHour(double cubicfeetperhour) double value = (double) cubicfeetperhour; return new VolumeFlow(value, VolumeFlowUnit.CubicFootPerHour); } + /// /// Creates a from . /// @@ -716,6 +727,7 @@ public static VolumeFlow FromCubicFeetPerMinute(double cubicfeetperminute) double value = (double) cubicfeetperminute; return new VolumeFlow(value, VolumeFlowUnit.CubicFootPerMinute); } + /// /// Creates a from . /// @@ -726,6 +738,7 @@ public static VolumeFlow FromCubicFeetPerSecond(double cubicfeetpersecond) double value = (double) cubicfeetpersecond; return new VolumeFlow(value, VolumeFlowUnit.CubicFootPerSecond); } + /// /// Creates a from . /// @@ -736,6 +749,7 @@ public static VolumeFlow FromCubicMetersPerDay(double cubicmetersperday) double value = (double) cubicmetersperday; return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerDay); } + /// /// Creates a from . /// @@ -746,6 +760,7 @@ public static VolumeFlow FromCubicMetersPerHour(double cubicmetersperhour) double value = (double) cubicmetersperhour; return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerHour); } + /// /// Creates a from . /// @@ -756,6 +771,7 @@ public static VolumeFlow FromCubicMetersPerMinute(double cubicmetersperminute) double value = (double) cubicmetersperminute; return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerMinute); } + /// /// Creates a from . /// @@ -766,6 +782,7 @@ public static VolumeFlow FromCubicMetersPerSecond(double cubicmeterspersecond) double value = (double) cubicmeterspersecond; return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerSecond); } + /// /// Creates a from . /// @@ -776,6 +793,7 @@ public static VolumeFlow FromCubicMillimetersPerSecond(double cubicmillimeterspe double value = (double) cubicmillimeterspersecond; return new VolumeFlow(value, VolumeFlowUnit.CubicMillimeterPerSecond); } + /// /// Creates a from . /// @@ -786,6 +804,7 @@ public static VolumeFlow FromCubicYardsPerDay(double cubicyardsperday) double value = (double) cubicyardsperday; return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerDay); } + /// /// Creates a from . /// @@ -796,6 +815,7 @@ public static VolumeFlow FromCubicYardsPerHour(double cubicyardsperhour) double value = (double) cubicyardsperhour; return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerHour); } + /// /// Creates a from . /// @@ -806,6 +826,7 @@ public static VolumeFlow FromCubicYardsPerMinute(double cubicyardsperminute) double value = (double) cubicyardsperminute; return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerMinute); } + /// /// Creates a from . /// @@ -816,6 +837,7 @@ public static VolumeFlow FromCubicYardsPerSecond(double cubicyardspersecond) double value = (double) cubicyardspersecond; return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerSecond); } + /// /// Creates a from . /// @@ -826,6 +848,7 @@ public static VolumeFlow FromDecilitersPerDay(double decilitersperday) double value = (double) decilitersperday; return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerDay); } + /// /// Creates a from . /// @@ -836,6 +859,7 @@ public static VolumeFlow FromDecilitersPerHour(double decilitersperhour) double value = (double) decilitersperhour; return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerHour); } + /// /// Creates a from . /// @@ -846,6 +870,7 @@ public static VolumeFlow FromDecilitersPerMinute(double decilitersperminute) double value = (double) decilitersperminute; return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerMinute); } + /// /// Creates a from . /// @@ -856,6 +881,7 @@ public static VolumeFlow FromDecilitersPerSecond(double deciliterspersecond) double value = (double) deciliterspersecond; return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerSecond); } + /// /// Creates a from . /// @@ -866,6 +892,7 @@ public static VolumeFlow FromKilolitersPerDay(double kilolitersperday) double value = (double) kilolitersperday; return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerDay); } + /// /// Creates a from . /// @@ -876,6 +903,7 @@ public static VolumeFlow FromKilolitersPerHour(double kilolitersperhour) double value = (double) kilolitersperhour; return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerHour); } + /// /// Creates a from . /// @@ -886,6 +914,7 @@ public static VolumeFlow FromKilolitersPerMinute(double kilolitersperminute) double value = (double) kilolitersperminute; return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerMinute); } + /// /// Creates a from . /// @@ -896,6 +925,7 @@ public static VolumeFlow FromKilolitersPerSecond(double kiloliterspersecond) double value = (double) kiloliterspersecond; return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerSecond); } + /// /// Creates a from . /// @@ -906,6 +936,7 @@ public static VolumeFlow FromKilousGallonsPerMinute(double kilousgallonsperminut double value = (double) kilousgallonsperminute; return new VolumeFlow(value, VolumeFlowUnit.KilousGallonPerMinute); } + /// /// Creates a from . /// @@ -916,6 +947,7 @@ public static VolumeFlow FromLitersPerDay(double litersperday) double value = (double) litersperday; return new VolumeFlow(value, VolumeFlowUnit.LiterPerDay); } + /// /// Creates a from . /// @@ -926,6 +958,7 @@ public static VolumeFlow FromLitersPerHour(double litersperhour) double value = (double) litersperhour; return new VolumeFlow(value, VolumeFlowUnit.LiterPerHour); } + /// /// Creates a from . /// @@ -936,6 +969,7 @@ public static VolumeFlow FromLitersPerMinute(double litersperminute) double value = (double) litersperminute; return new VolumeFlow(value, VolumeFlowUnit.LiterPerMinute); } + /// /// Creates a from . /// @@ -946,6 +980,7 @@ public static VolumeFlow FromLitersPerSecond(double literspersecond) double value = (double) literspersecond; return new VolumeFlow(value, VolumeFlowUnit.LiterPerSecond); } + /// /// Creates a from . /// @@ -956,6 +991,7 @@ public static VolumeFlow FromMegalitersPerDay(double megalitersperday) double value = (double) megalitersperday; return new VolumeFlow(value, VolumeFlowUnit.MegaliterPerDay); } + /// /// Creates a from . /// @@ -966,6 +1002,7 @@ public static VolumeFlow FromMegaukGallonsPerSecond(double megaukgallonspersecon double value = (double) megaukgallonspersecond; return new VolumeFlow(value, VolumeFlowUnit.MegaukGallonPerSecond); } + /// /// Creates a from . /// @@ -976,6 +1013,7 @@ public static VolumeFlow FromMicrolitersPerDay(double microlitersperday) double value = (double) microlitersperday; return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerDay); } + /// /// Creates a from . /// @@ -986,6 +1024,7 @@ public static VolumeFlow FromMicrolitersPerHour(double microlitersperhour) double value = (double) microlitersperhour; return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerHour); } + /// /// Creates a from . /// @@ -996,6 +1035,7 @@ public static VolumeFlow FromMicrolitersPerMinute(double microlitersperminute) double value = (double) microlitersperminute; return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerMinute); } + /// /// Creates a from . /// @@ -1006,6 +1046,7 @@ public static VolumeFlow FromMicrolitersPerSecond(double microliterspersecond) double value = (double) microliterspersecond; return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerSecond); } + /// /// Creates a from . /// @@ -1016,6 +1057,7 @@ public static VolumeFlow FromMillilitersPerDay(double millilitersperday) double value = (double) millilitersperday; return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerDay); } + /// /// Creates a from . /// @@ -1026,6 +1068,7 @@ public static VolumeFlow FromMillilitersPerHour(double millilitersperhour) double value = (double) millilitersperhour; return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerHour); } + /// /// Creates a from . /// @@ -1036,6 +1079,7 @@ public static VolumeFlow FromMillilitersPerMinute(double millilitersperminute) double value = (double) millilitersperminute; return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerMinute); } + /// /// Creates a from . /// @@ -1046,6 +1090,7 @@ public static VolumeFlow FromMillilitersPerSecond(double milliliterspersecond) double value = (double) milliliterspersecond; return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerSecond); } + /// /// Creates a from . /// @@ -1056,6 +1101,7 @@ public static VolumeFlow FromMillionUsGallonsPerDay(double millionusgallonsperda double value = (double) millionusgallonsperday; return new VolumeFlow(value, VolumeFlowUnit.MillionUsGallonsPerDay); } + /// /// Creates a from . /// @@ -1066,6 +1112,7 @@ public static VolumeFlow FromNanolitersPerDay(double nanolitersperday) double value = (double) nanolitersperday; return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerDay); } + /// /// Creates a from . /// @@ -1076,6 +1123,7 @@ public static VolumeFlow FromNanolitersPerHour(double nanolitersperhour) double value = (double) nanolitersperhour; return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerHour); } + /// /// Creates a from . /// @@ -1086,6 +1134,7 @@ public static VolumeFlow FromNanolitersPerMinute(double nanolitersperminute) double value = (double) nanolitersperminute; return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerMinute); } + /// /// Creates a from . /// @@ -1096,6 +1145,7 @@ public static VolumeFlow FromNanolitersPerSecond(double nanoliterspersecond) double value = (double) nanoliterspersecond; return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerSecond); } + /// /// Creates a from . /// @@ -1106,6 +1156,7 @@ public static VolumeFlow FromOilBarrelsPerDay(double oilbarrelsperday) double value = (double) oilbarrelsperday; return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerDay); } + /// /// Creates a from . /// @@ -1116,6 +1167,7 @@ public static VolumeFlow FromOilBarrelsPerHour(double oilbarrelsperhour) double value = (double) oilbarrelsperhour; return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerHour); } + /// /// Creates a from . /// @@ -1126,6 +1178,7 @@ public static VolumeFlow FromOilBarrelsPerMinute(double oilbarrelsperminute) double value = (double) oilbarrelsperminute; return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerMinute); } + /// /// Creates a from . /// @@ -1136,6 +1189,7 @@ public static VolumeFlow FromOilBarrelsPerSecond(double oilbarrelspersecond) double value = (double) oilbarrelspersecond; return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerSecond); } + /// /// Creates a from . /// @@ -1146,6 +1200,7 @@ public static VolumeFlow FromUkGallonsPerDay(double ukgallonsperday) double value = (double) ukgallonsperday; return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerDay); } + /// /// Creates a from . /// @@ -1156,6 +1211,7 @@ public static VolumeFlow FromUkGallonsPerHour(double ukgallonsperhour) double value = (double) ukgallonsperhour; return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerHour); } + /// /// Creates a from . /// @@ -1166,6 +1222,7 @@ public static VolumeFlow FromUkGallonsPerMinute(double ukgallonsperminute) double value = (double) ukgallonsperminute; return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerMinute); } + /// /// Creates a from . /// @@ -1176,6 +1233,7 @@ public static VolumeFlow FromUkGallonsPerSecond(double ukgallonspersecond) double value = (double) ukgallonspersecond; return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerSecond); } + /// /// Creates a from . /// @@ -1186,6 +1244,7 @@ public static VolumeFlow FromUsGallonsPerDay(double usgallonsperday) double value = (double) usgallonsperday; return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerDay); } + /// /// Creates a from . /// @@ -1196,6 +1255,7 @@ public static VolumeFlow FromUsGallonsPerHour(double usgallonsperhour) double value = (double) usgallonsperhour; return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerHour); } + /// /// Creates a from . /// @@ -1206,6 +1266,7 @@ public static VolumeFlow FromUsGallonsPerMinute(double usgallonsperminute) double value = (double) usgallonsperminute; return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerMinute); } + /// /// Creates a from . /// @@ -1217,6 +1278,7 @@ public static VolumeFlow FromUsGallonsPerSecond(double usgallonspersecond) return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerSecond); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs index 85fe7aac9d..ae9dbeb13c 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs @@ -219,6 +219,7 @@ public static VolumeFlowPerArea FromCubicFeetPerMinutePerSquareFoot(double cubic double value = (double) cubicfeetperminutepersquarefoot; return new VolumeFlowPerArea(value, VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot); } + /// /// Creates a from . /// @@ -230,6 +231,7 @@ public static VolumeFlowPerArea FromCubicMetersPerSecondPerSquareMeter(double cu return new VolumeFlowPerArea(value, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumePerLength.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumePerLength.g.cs index 76ff0e7d2e..7762a31d00 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumePerLength.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumePerLength.g.cs @@ -249,6 +249,7 @@ public static VolumePerLength FromCubicMetersPerMeter(double cubicmeterspermeter double value = (double) cubicmeterspermeter; return new VolumePerLength(value, VolumePerLengthUnit.CubicMeterPerMeter); } + /// /// Creates a from . /// @@ -259,6 +260,7 @@ public static VolumePerLength FromCubicYardsPerFoot(double cubicyardsperfoot) double value = (double) cubicyardsperfoot; return new VolumePerLength(value, VolumePerLengthUnit.CubicYardPerFoot); } + /// /// Creates a from . /// @@ -269,6 +271,7 @@ public static VolumePerLength FromCubicYardsPerUsSurveyFoot(double cubicyardsper double value = (double) cubicyardsperussurveyfoot; return new VolumePerLength(value, VolumePerLengthUnit.CubicYardPerUsSurveyFoot); } + /// /// Creates a from . /// @@ -279,6 +282,7 @@ public static VolumePerLength FromLitersPerKilometer(double litersperkilometer) double value = (double) litersperkilometer; return new VolumePerLength(value, VolumePerLengthUnit.LiterPerKilometer); } + /// /// Creates a from . /// @@ -289,6 +293,7 @@ public static VolumePerLength FromLitersPerMeter(double literspermeter) double value = (double) literspermeter; return new VolumePerLength(value, VolumePerLengthUnit.LiterPerMeter); } + /// /// Creates a from . /// @@ -299,6 +304,7 @@ public static VolumePerLength FromLitersPerMillimeter(double literspermillimeter double value = (double) literspermillimeter; return new VolumePerLength(value, VolumePerLengthUnit.LiterPerMillimeter); } + /// /// Creates a from . /// @@ -310,6 +316,7 @@ public static VolumePerLength FromOilBarrelsPerFoot(double oilbarrelsperfoot) return new VolumePerLength(value, VolumePerLengthUnit.OilBarrelPerFoot); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs index 84b42e0e57..240640f6cf 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs @@ -264,6 +264,7 @@ public static VolumetricHeatCapacity FromBtusPerCubicFootDegreeFahrenheit(double double value = (double) btuspercubicfootdegreefahrenheit; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit); } + /// /// Creates a from . /// @@ -274,6 +275,7 @@ public static VolumetricHeatCapacity FromCaloriesPerCubicCentimeterDegreeCelsius double value = (double) caloriespercubiccentimeterdegreecelsius; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius); } + /// /// Creates a from . /// @@ -284,6 +286,7 @@ public static VolumetricHeatCapacity FromJoulesPerCubicMeterDegreeCelsius(double double value = (double) joulespercubicmeterdegreecelsius; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius); } + /// /// Creates a from . /// @@ -294,6 +297,7 @@ public static VolumetricHeatCapacity FromJoulesPerCubicMeterKelvin(double joules double value = (double) joulespercubicmeterkelvin; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin); } + /// /// Creates a from . /// @@ -304,6 +308,7 @@ public static VolumetricHeatCapacity FromKilocaloriesPerCubicCentimeterDegreeCel double value = (double) kilocaloriespercubiccentimeterdegreecelsius; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius); } + /// /// Creates a from . /// @@ -314,6 +319,7 @@ public static VolumetricHeatCapacity FromKilojoulesPerCubicMeterDegreeCelsius(do double value = (double) kilojoulespercubicmeterdegreecelsius; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius); } + /// /// Creates a from . /// @@ -324,6 +330,7 @@ public static VolumetricHeatCapacity FromKilojoulesPerCubicMeterKelvin(double ki double value = (double) kilojoulespercubicmeterkelvin; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin); } + /// /// Creates a from . /// @@ -334,6 +341,7 @@ public static VolumetricHeatCapacity FromMegajoulesPerCubicMeterDegreeCelsius(do double value = (double) megajoulespercubicmeterdegreecelsius; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius); } + /// /// Creates a from . /// @@ -345,6 +353,7 @@ public static VolumetricHeatCapacity FromMegajoulesPerCubicMeterKelvin(double me return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs index 8993c6a358..05f72acb75 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs @@ -243,6 +243,7 @@ public static WarpingMomentOfInertia FromCentimetersToTheSixth(double centimeter double value = (double) centimeterstothesixth; return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.CentimeterToTheSixth); } + /// /// Creates a from . /// @@ -253,6 +254,7 @@ public static WarpingMomentOfInertia FromDecimetersToTheSixth(double decimeterst double value = (double) decimeterstothesixth; return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.DecimeterToTheSixth); } + /// /// Creates a from . /// @@ -263,6 +265,7 @@ public static WarpingMomentOfInertia FromFeetToTheSixth(double feettothesixth) double value = (double) feettothesixth; return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.FootToTheSixth); } + /// /// Creates a from . /// @@ -273,6 +276,7 @@ public static WarpingMomentOfInertia FromInchesToTheSixth(double inchestothesixt double value = (double) inchestothesixth; return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.InchToTheSixth); } + /// /// Creates a from . /// @@ -283,6 +287,7 @@ public static WarpingMomentOfInertia FromMetersToTheSixth(double meterstothesixt double value = (double) meterstothesixth; return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.MeterToTheSixth); } + /// /// Creates a from . /// @@ -294,6 +299,7 @@ public static WarpingMomentOfInertia FromMillimetersToTheSixth(double millimeter return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.MillimeterToTheSixth); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/CompressibilityUnit.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/CompressibilityUnit.g.cs index 77f80bab98..5b3e4f4514 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/CompressibilityUnit.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/CompressibilityUnit.g.cs @@ -26,7 +26,13 @@ namespace UnitsNet.Units public enum CompressibilityUnit { Undefined = 0, + InverseAtmosphere, + InverseBar, + InverseKilopascal, + InverseMegapascal, + InverseMillibar, InversePascal, + InversePoundForcePerSquareInch, } #pragma warning restore 1591 diff --git a/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs b/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs index a7ee842c55..8793b9a15e 100644 --- a/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs @@ -380,6 +380,7 @@ public static Acceleration FromCentimetersPerSecondSquared(QuantityValue centime double value = (double) centimeterspersecondsquared; return new Acceleration(value, AccelerationUnit.CentimeterPerSecondSquared); } + /// /// Creates a from . /// @@ -389,6 +390,7 @@ public static Acceleration FromDecimetersPerSecondSquared(QuantityValue decimete double value = (double) decimeterspersecondsquared; return new Acceleration(value, AccelerationUnit.DecimeterPerSecondSquared); } + /// /// Creates a from . /// @@ -398,6 +400,7 @@ public static Acceleration FromFeetPerSecondSquared(QuantityValue feetperseconds double value = (double) feetpersecondsquared; return new Acceleration(value, AccelerationUnit.FootPerSecondSquared); } + /// /// Creates a from . /// @@ -407,6 +410,7 @@ public static Acceleration FromInchesPerSecondSquared(QuantityValue inchespersec double value = (double) inchespersecondsquared; return new Acceleration(value, AccelerationUnit.InchPerSecondSquared); } + /// /// Creates a from . /// @@ -416,6 +420,7 @@ public static Acceleration FromKilometersPerSecondSquared(QuantityValue kilomete double value = (double) kilometerspersecondsquared; return new Acceleration(value, AccelerationUnit.KilometerPerSecondSquared); } + /// /// Creates a from . /// @@ -425,6 +430,7 @@ public static Acceleration FromKnotsPerHour(QuantityValue knotsperhour) double value = (double) knotsperhour; return new Acceleration(value, AccelerationUnit.KnotPerHour); } + /// /// Creates a from . /// @@ -434,6 +440,7 @@ public static Acceleration FromKnotsPerMinute(QuantityValue knotsperminute) double value = (double) knotsperminute; return new Acceleration(value, AccelerationUnit.KnotPerMinute); } + /// /// Creates a from . /// @@ -443,6 +450,7 @@ public static Acceleration FromKnotsPerSecond(QuantityValue knotspersecond) double value = (double) knotspersecond; return new Acceleration(value, AccelerationUnit.KnotPerSecond); } + /// /// Creates a from . /// @@ -452,6 +460,7 @@ public static Acceleration FromMetersPerSecondSquared(QuantityValue meterspersec double value = (double) meterspersecondsquared; return new Acceleration(value, AccelerationUnit.MeterPerSecondSquared); } + /// /// Creates a from . /// @@ -461,6 +470,7 @@ public static Acceleration FromMicrometersPerSecondSquared(QuantityValue microme double value = (double) micrometerspersecondsquared; return new Acceleration(value, AccelerationUnit.MicrometerPerSecondSquared); } + /// /// Creates a from . /// @@ -470,6 +480,7 @@ public static Acceleration FromMillimetersPerSecondSquared(QuantityValue millime double value = (double) millimeterspersecondsquared; return new Acceleration(value, AccelerationUnit.MillimeterPerSecondSquared); } + /// /// Creates a from . /// @@ -479,6 +490,7 @@ public static Acceleration FromMillistandardGravity(QuantityValue millistandardg double value = (double) millistandardgravity; return new Acceleration(value, AccelerationUnit.MillistandardGravity); } + /// /// Creates a from . /// @@ -488,6 +500,7 @@ public static Acceleration FromNanometersPerSecondSquared(QuantityValue nanomete double value = (double) nanometerspersecondsquared; return new Acceleration(value, AccelerationUnit.NanometerPerSecondSquared); } + /// /// Creates a from . /// @@ -498,6 +511,7 @@ public static Acceleration FromStandardGravity(QuantityValue standardgravity) return new Acceleration(value, AccelerationUnit.StandardGravity); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs b/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs index 12dbe1c97a..7025dae47b 100644 --- a/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs @@ -375,6 +375,7 @@ public static AmountOfSubstance FromCentimoles(QuantityValue centimoles) double value = (double) centimoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Centimole); } + /// /// Creates a from . /// @@ -384,6 +385,7 @@ public static AmountOfSubstance FromCentipoundMoles(QuantityValue centipoundmole double value = (double) centipoundmoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.CentipoundMole); } + /// /// Creates a from . /// @@ -393,6 +395,7 @@ public static AmountOfSubstance FromDecimoles(QuantityValue decimoles) double value = (double) decimoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Decimole); } + /// /// Creates a from . /// @@ -402,6 +405,7 @@ public static AmountOfSubstance FromDecipoundMoles(QuantityValue decipoundmoles) double value = (double) decipoundmoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.DecipoundMole); } + /// /// Creates a from . /// @@ -411,6 +415,7 @@ public static AmountOfSubstance FromKilomoles(QuantityValue kilomoles) double value = (double) kilomoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Kilomole); } + /// /// Creates a from . /// @@ -420,6 +425,7 @@ public static AmountOfSubstance FromKilopoundMoles(QuantityValue kilopoundmoles) double value = (double) kilopoundmoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.KilopoundMole); } + /// /// Creates a from . /// @@ -429,6 +435,7 @@ public static AmountOfSubstance FromMegamoles(QuantityValue megamoles) double value = (double) megamoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Megamole); } + /// /// Creates a from . /// @@ -438,6 +445,7 @@ public static AmountOfSubstance FromMicromoles(QuantityValue micromoles) double value = (double) micromoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Micromole); } + /// /// Creates a from . /// @@ -447,6 +455,7 @@ public static AmountOfSubstance FromMicropoundMoles(QuantityValue micropoundmole double value = (double) micropoundmoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.MicropoundMole); } + /// /// Creates a from . /// @@ -456,6 +465,7 @@ public static AmountOfSubstance FromMillimoles(QuantityValue millimoles) double value = (double) millimoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Millimole); } + /// /// Creates a from . /// @@ -465,6 +475,7 @@ public static AmountOfSubstance FromMillipoundMoles(QuantityValue millipoundmole double value = (double) millipoundmoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.MillipoundMole); } + /// /// Creates a from . /// @@ -474,6 +485,7 @@ public static AmountOfSubstance FromMoles(QuantityValue moles) double value = (double) moles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Mole); } + /// /// Creates a from . /// @@ -483,6 +495,7 @@ public static AmountOfSubstance FromNanomoles(QuantityValue nanomoles) double value = (double) nanomoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Nanomole); } + /// /// Creates a from . /// @@ -492,6 +505,7 @@ public static AmountOfSubstance FromNanopoundMoles(QuantityValue nanopoundmoles) double value = (double) nanopoundmoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.NanopoundMole); } + /// /// Creates a from . /// @@ -502,6 +516,7 @@ public static AmountOfSubstance FromPoundMoles(QuantityValue poundmoles) return new AmountOfSubstance(value, AmountOfSubstanceUnit.PoundMole); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.g.cs b/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.g.cs index 626c69f760..999d1f0c0a 100644 --- a/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.g.cs @@ -276,6 +276,7 @@ public static AmplitudeRatio FromDecibelMicrovolts(QuantityValue decibelmicrovol double value = (double) decibelmicrovolts; return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelMicrovolt); } + /// /// Creates a from . /// @@ -285,6 +286,7 @@ public static AmplitudeRatio FromDecibelMillivolts(QuantityValue decibelmillivol double value = (double) decibelmillivolts; return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelMillivolt); } + /// /// Creates a from . /// @@ -294,6 +296,7 @@ public static AmplitudeRatio FromDecibelsUnloaded(QuantityValue decibelsunloaded double value = (double) decibelsunloaded; return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelUnloaded); } + /// /// Creates a from . /// @@ -304,6 +307,7 @@ public static AmplitudeRatio FromDecibelVolts(QuantityValue decibelvolts) return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelVolt); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Angle.g.cs b/UnitsNet/GeneratedCode/Quantities/Angle.g.cs index 9c4fb04aa6..eb7cb4a335 100644 --- a/UnitsNet/GeneratedCode/Quantities/Angle.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Angle.g.cs @@ -396,6 +396,7 @@ public static Angle FromArcminutes(QuantityValue arcminutes) double value = (double) arcminutes; return new Angle(value, AngleUnit.Arcminute); } + /// /// Creates a from . /// @@ -405,6 +406,7 @@ public static Angle FromArcseconds(QuantityValue arcseconds) double value = (double) arcseconds; return new Angle(value, AngleUnit.Arcsecond); } + /// /// Creates a from . /// @@ -414,6 +416,7 @@ public static Angle FromCentiradians(QuantityValue centiradians) double value = (double) centiradians; return new Angle(value, AngleUnit.Centiradian); } + /// /// Creates a from . /// @@ -423,6 +426,7 @@ public static Angle FromDeciradians(QuantityValue deciradians) double value = (double) deciradians; return new Angle(value, AngleUnit.Deciradian); } + /// /// Creates a from . /// @@ -432,6 +436,7 @@ public static Angle FromDegrees(QuantityValue degrees) double value = (double) degrees; return new Angle(value, AngleUnit.Degree); } + /// /// Creates a from . /// @@ -441,6 +446,7 @@ public static Angle FromGradians(QuantityValue gradians) double value = (double) gradians; return new Angle(value, AngleUnit.Gradian); } + /// /// Creates a from . /// @@ -450,6 +456,7 @@ public static Angle FromMicrodegrees(QuantityValue microdegrees) double value = (double) microdegrees; return new Angle(value, AngleUnit.Microdegree); } + /// /// Creates a from . /// @@ -459,6 +466,7 @@ public static Angle FromMicroradians(QuantityValue microradians) double value = (double) microradians; return new Angle(value, AngleUnit.Microradian); } + /// /// Creates a from . /// @@ -468,6 +476,7 @@ public static Angle FromMillidegrees(QuantityValue millidegrees) double value = (double) millidegrees; return new Angle(value, AngleUnit.Millidegree); } + /// /// Creates a from . /// @@ -477,6 +486,7 @@ public static Angle FromMilliradians(QuantityValue milliradians) double value = (double) milliradians; return new Angle(value, AngleUnit.Milliradian); } + /// /// Creates a from . /// @@ -486,6 +496,7 @@ public static Angle FromNanodegrees(QuantityValue nanodegrees) double value = (double) nanodegrees; return new Angle(value, AngleUnit.Nanodegree); } + /// /// Creates a from . /// @@ -495,6 +506,7 @@ public static Angle FromNanoradians(QuantityValue nanoradians) double value = (double) nanoradians; return new Angle(value, AngleUnit.Nanoradian); } + /// /// Creates a from . /// @@ -504,6 +516,7 @@ public static Angle FromNatoMils(QuantityValue natomils) double value = (double) natomils; return new Angle(value, AngleUnit.NatoMil); } + /// /// Creates a from . /// @@ -513,6 +526,7 @@ public static Angle FromRadians(QuantityValue radians) double value = (double) radians; return new Angle(value, AngleUnit.Radian); } + /// /// Creates a from . /// @@ -522,6 +536,7 @@ public static Angle FromRevolutions(QuantityValue revolutions) double value = (double) revolutions; return new Angle(value, AngleUnit.Revolution); } + /// /// Creates a from . /// @@ -532,6 +547,7 @@ public static Angle FromTilt(QuantityValue tilt) return new Angle(value, AngleUnit.Tilt); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.g.cs index 4c0623669f..9cc6ed3e57 100644 --- a/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.g.cs @@ -267,6 +267,7 @@ public static ApparentEnergy FromKilovoltampereHours(QuantityValue kilovoltamper double value = (double) kilovoltamperehours; return new ApparentEnergy(value, ApparentEnergyUnit.KilovoltampereHour); } + /// /// Creates a from . /// @@ -276,6 +277,7 @@ public static ApparentEnergy FromMegavoltampereHours(QuantityValue megavoltamper double value = (double) megavoltamperehours; return new ApparentEnergy(value, ApparentEnergyUnit.MegavoltampereHour); } + /// /// Creates a from . /// @@ -286,6 +288,7 @@ public static ApparentEnergy FromVoltampereHours(QuantityValue voltamperehours) return new ApparentEnergy(value, ApparentEnergyUnit.VoltampereHour); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ApparentPower.g.cs b/UnitsNet/GeneratedCode/Quantities/ApparentPower.g.cs index 3dc937dd16..9f751534ac 100644 --- a/UnitsNet/GeneratedCode/Quantities/ApparentPower.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ApparentPower.g.cs @@ -276,6 +276,7 @@ public static ApparentPower FromGigavoltamperes(QuantityValue gigavoltamperes) double value = (double) gigavoltamperes; return new ApparentPower(value, ApparentPowerUnit.Gigavoltampere); } + /// /// Creates a from . /// @@ -285,6 +286,7 @@ public static ApparentPower FromKilovoltamperes(QuantityValue kilovoltamperes) double value = (double) kilovoltamperes; return new ApparentPower(value, ApparentPowerUnit.Kilovoltampere); } + /// /// Creates a from . /// @@ -294,6 +296,7 @@ public static ApparentPower FromMegavoltamperes(QuantityValue megavoltamperes) double value = (double) megavoltamperes; return new ApparentPower(value, ApparentPowerUnit.Megavoltampere); } + /// /// Creates a from . /// @@ -304,6 +307,7 @@ public static ApparentPower FromVoltamperes(QuantityValue voltamperes) return new ApparentPower(value, ApparentPowerUnit.Voltampere); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Area.g.cs b/UnitsNet/GeneratedCode/Quantities/Area.g.cs index df0bb627b3..af9ef0c57e 100644 --- a/UnitsNet/GeneratedCode/Quantities/Area.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Area.g.cs @@ -393,6 +393,7 @@ public static Area FromAcres(QuantityValue acres) double value = (double) acres; return new Area(value, AreaUnit.Acre); } + /// /// Creates a from . /// @@ -402,6 +403,7 @@ public static Area FromHectares(QuantityValue hectares) double value = (double) hectares; return new Area(value, AreaUnit.Hectare); } + /// /// Creates a from . /// @@ -411,6 +413,7 @@ public static Area FromSquareCentimeters(QuantityValue squarecentimeters) double value = (double) squarecentimeters; return new Area(value, AreaUnit.SquareCentimeter); } + /// /// Creates a from . /// @@ -420,6 +423,7 @@ public static Area FromSquareDecimeters(QuantityValue squaredecimeters) double value = (double) squaredecimeters; return new Area(value, AreaUnit.SquareDecimeter); } + /// /// Creates a from . /// @@ -429,6 +433,7 @@ public static Area FromSquareFeet(QuantityValue squarefeet) double value = (double) squarefeet; return new Area(value, AreaUnit.SquareFoot); } + /// /// Creates a from . /// @@ -438,6 +443,7 @@ public static Area FromSquareInches(QuantityValue squareinches) double value = (double) squareinches; return new Area(value, AreaUnit.SquareInch); } + /// /// Creates a from . /// @@ -447,6 +453,7 @@ public static Area FromSquareKilometers(QuantityValue squarekilometers) double value = (double) squarekilometers; return new Area(value, AreaUnit.SquareKilometer); } + /// /// Creates a from . /// @@ -456,6 +463,7 @@ public static Area FromSquareMeters(QuantityValue squaremeters) double value = (double) squaremeters; return new Area(value, AreaUnit.SquareMeter); } + /// /// Creates a from . /// @@ -465,6 +473,7 @@ public static Area FromSquareMicrometers(QuantityValue squaremicrometers) double value = (double) squaremicrometers; return new Area(value, AreaUnit.SquareMicrometer); } + /// /// Creates a from . /// @@ -474,6 +483,7 @@ public static Area FromSquareMiles(QuantityValue squaremiles) double value = (double) squaremiles; return new Area(value, AreaUnit.SquareMile); } + /// /// Creates a from . /// @@ -483,6 +493,7 @@ public static Area FromSquareMillimeters(QuantityValue squaremillimeters) double value = (double) squaremillimeters; return new Area(value, AreaUnit.SquareMillimeter); } + /// /// Creates a from . /// @@ -492,6 +503,7 @@ public static Area FromSquareNauticalMiles(QuantityValue squarenauticalmiles) double value = (double) squarenauticalmiles; return new Area(value, AreaUnit.SquareNauticalMile); } + /// /// Creates a from . /// @@ -501,6 +513,7 @@ public static Area FromSquareYards(QuantityValue squareyards) double value = (double) squareyards; return new Area(value, AreaUnit.SquareYard); } + /// /// Creates a from . /// @@ -511,6 +524,7 @@ public static Area FromUsSurveySquareFeet(QuantityValue ussurveysquarefeet) return new Area(value, AreaUnit.UsSurveySquareFoot); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs index 1b84ba6e88..6a0ae142b7 100644 --- a/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs @@ -250,6 +250,7 @@ public static AreaDensity FromKilogramsPerSquareMeter(QuantityValue kilogramsper return new AreaDensity(value, AreaDensityUnit.KilogramPerSquareMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs b/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs index 1e3ea38167..609913636d 100644 --- a/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs @@ -294,6 +294,7 @@ public static AreaMomentOfInertia FromCentimetersToTheFourth(QuantityValue centi double value = (double) centimeterstothefourth; return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.CentimeterToTheFourth); } + /// /// Creates a from . /// @@ -303,6 +304,7 @@ public static AreaMomentOfInertia FromDecimetersToTheFourth(QuantityValue decime double value = (double) decimeterstothefourth; return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.DecimeterToTheFourth); } + /// /// Creates a from . /// @@ -312,6 +314,7 @@ public static AreaMomentOfInertia FromFeetToTheFourth(QuantityValue feettothefou double value = (double) feettothefourth; return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.FootToTheFourth); } + /// /// Creates a from . /// @@ -321,6 +324,7 @@ public static AreaMomentOfInertia FromInchesToTheFourth(QuantityValue inchestoth double value = (double) inchestothefourth; return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.InchToTheFourth); } + /// /// Creates a from . /// @@ -330,6 +334,7 @@ public static AreaMomentOfInertia FromMetersToTheFourth(QuantityValue meterstoth double value = (double) meterstothefourth; return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.MeterToTheFourth); } + /// /// Creates a from . /// @@ -340,6 +345,7 @@ public static AreaMomentOfInertia FromMillimetersToTheFourth(QuantityValue milli return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.MillimeterToTheFourth); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs b/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs index 782763d075..62509d62b6 100644 --- a/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs @@ -482,6 +482,7 @@ public static BitRate FromBitsPerSecond(QuantityValue bitspersecond) decimal value = (decimal) bitspersecond; return new BitRate(value, BitRateUnit.BitPerSecond); } + /// /// Creates a from . /// @@ -491,6 +492,7 @@ public static BitRate FromBytesPerSecond(QuantityValue bytespersecond) decimal value = (decimal) bytespersecond; return new BitRate(value, BitRateUnit.BytePerSecond); } + /// /// Creates a from . /// @@ -500,6 +502,7 @@ public static BitRate FromExabitsPerSecond(QuantityValue exabitspersecond) decimal value = (decimal) exabitspersecond; return new BitRate(value, BitRateUnit.ExabitPerSecond); } + /// /// Creates a from . /// @@ -509,6 +512,7 @@ public static BitRate FromExabytesPerSecond(QuantityValue exabytespersecond) decimal value = (decimal) exabytespersecond; return new BitRate(value, BitRateUnit.ExabytePerSecond); } + /// /// Creates a from . /// @@ -518,6 +522,7 @@ public static BitRate FromExbibitsPerSecond(QuantityValue exbibitspersecond) decimal value = (decimal) exbibitspersecond; return new BitRate(value, BitRateUnit.ExbibitPerSecond); } + /// /// Creates a from . /// @@ -527,6 +532,7 @@ public static BitRate FromExbibytesPerSecond(QuantityValue exbibytespersecond) decimal value = (decimal) exbibytespersecond; return new BitRate(value, BitRateUnit.ExbibytePerSecond); } + /// /// Creates a from . /// @@ -536,6 +542,7 @@ public static BitRate FromGibibitsPerSecond(QuantityValue gibibitspersecond) decimal value = (decimal) gibibitspersecond; return new BitRate(value, BitRateUnit.GibibitPerSecond); } + /// /// Creates a from . /// @@ -545,6 +552,7 @@ public static BitRate FromGibibytesPerSecond(QuantityValue gibibytespersecond) decimal value = (decimal) gibibytespersecond; return new BitRate(value, BitRateUnit.GibibytePerSecond); } + /// /// Creates a from . /// @@ -554,6 +562,7 @@ public static BitRate FromGigabitsPerSecond(QuantityValue gigabitspersecond) decimal value = (decimal) gigabitspersecond; return new BitRate(value, BitRateUnit.GigabitPerSecond); } + /// /// Creates a from . /// @@ -563,6 +572,7 @@ public static BitRate FromGigabytesPerSecond(QuantityValue gigabytespersecond) decimal value = (decimal) gigabytespersecond; return new BitRate(value, BitRateUnit.GigabytePerSecond); } + /// /// Creates a from . /// @@ -572,6 +582,7 @@ public static BitRate FromKibibitsPerSecond(QuantityValue kibibitspersecond) decimal value = (decimal) kibibitspersecond; return new BitRate(value, BitRateUnit.KibibitPerSecond); } + /// /// Creates a from . /// @@ -581,6 +592,7 @@ public static BitRate FromKibibytesPerSecond(QuantityValue kibibytespersecond) decimal value = (decimal) kibibytespersecond; return new BitRate(value, BitRateUnit.KibibytePerSecond); } + /// /// Creates a from . /// @@ -590,6 +602,7 @@ public static BitRate FromKilobitsPerSecond(QuantityValue kilobitspersecond) decimal value = (decimal) kilobitspersecond; return new BitRate(value, BitRateUnit.KilobitPerSecond); } + /// /// Creates a from . /// @@ -599,6 +612,7 @@ public static BitRate FromKilobytesPerSecond(QuantityValue kilobytespersecond) decimal value = (decimal) kilobytespersecond; return new BitRate(value, BitRateUnit.KilobytePerSecond); } + /// /// Creates a from . /// @@ -608,6 +622,7 @@ public static BitRate FromMebibitsPerSecond(QuantityValue mebibitspersecond) decimal value = (decimal) mebibitspersecond; return new BitRate(value, BitRateUnit.MebibitPerSecond); } + /// /// Creates a from . /// @@ -617,6 +632,7 @@ public static BitRate FromMebibytesPerSecond(QuantityValue mebibytespersecond) decimal value = (decimal) mebibytespersecond; return new BitRate(value, BitRateUnit.MebibytePerSecond); } + /// /// Creates a from . /// @@ -626,6 +642,7 @@ public static BitRate FromMegabitsPerSecond(QuantityValue megabitspersecond) decimal value = (decimal) megabitspersecond; return new BitRate(value, BitRateUnit.MegabitPerSecond); } + /// /// Creates a from . /// @@ -635,6 +652,7 @@ public static BitRate FromMegabytesPerSecond(QuantityValue megabytespersecond) decimal value = (decimal) megabytespersecond; return new BitRate(value, BitRateUnit.MegabytePerSecond); } + /// /// Creates a from . /// @@ -644,6 +662,7 @@ public static BitRate FromPebibitsPerSecond(QuantityValue pebibitspersecond) decimal value = (decimal) pebibitspersecond; return new BitRate(value, BitRateUnit.PebibitPerSecond); } + /// /// Creates a from . /// @@ -653,6 +672,7 @@ public static BitRate FromPebibytesPerSecond(QuantityValue pebibytespersecond) decimal value = (decimal) pebibytespersecond; return new BitRate(value, BitRateUnit.PebibytePerSecond); } + /// /// Creates a from . /// @@ -662,6 +682,7 @@ public static BitRate FromPetabitsPerSecond(QuantityValue petabitspersecond) decimal value = (decimal) petabitspersecond; return new BitRate(value, BitRateUnit.PetabitPerSecond); } + /// /// Creates a from . /// @@ -671,6 +692,7 @@ public static BitRate FromPetabytesPerSecond(QuantityValue petabytespersecond) decimal value = (decimal) petabytespersecond; return new BitRate(value, BitRateUnit.PetabytePerSecond); } + /// /// Creates a from . /// @@ -680,6 +702,7 @@ public static BitRate FromTebibitsPerSecond(QuantityValue tebibitspersecond) decimal value = (decimal) tebibitspersecond; return new BitRate(value, BitRateUnit.TebibitPerSecond); } + /// /// Creates a from . /// @@ -689,6 +712,7 @@ public static BitRate FromTebibytesPerSecond(QuantityValue tebibytespersecond) decimal value = (decimal) tebibytespersecond; return new BitRate(value, BitRateUnit.TebibytePerSecond); } + /// /// Creates a from . /// @@ -698,6 +722,7 @@ public static BitRate FromTerabitsPerSecond(QuantityValue terabitspersecond) decimal value = (decimal) terabitspersecond; return new BitRate(value, BitRateUnit.TerabitPerSecond); } + /// /// Creates a from . /// @@ -708,6 +733,7 @@ public static BitRate FromTerabytesPerSecond(QuantityValue terabytespersecond) return new BitRate(value, BitRateUnit.TerabytePerSecond); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs b/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs index 12594dff4c..3b000719b8 100644 --- a/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs @@ -267,6 +267,7 @@ public static BrakeSpecificFuelConsumption FromGramsPerKiloWattHour(QuantityValu double value = (double) gramsperkilowatthour; return new BrakeSpecificFuelConsumption(value, BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour); } + /// /// Creates a from . /// @@ -276,6 +277,7 @@ public static BrakeSpecificFuelConsumption FromKilogramsPerJoule(QuantityValue k double value = (double) kilogramsperjoule; return new BrakeSpecificFuelConsumption(value, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule); } + /// /// Creates a from . /// @@ -286,6 +288,7 @@ public static BrakeSpecificFuelConsumption FromPoundsPerMechanicalHorsepowerHour return new BrakeSpecificFuelConsumption(value, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Capacitance.g.cs b/UnitsNet/GeneratedCode/Quantities/Capacitance.g.cs index 8362867d16..43b5838a04 100644 --- a/UnitsNet/GeneratedCode/Quantities/Capacitance.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Capacitance.g.cs @@ -306,6 +306,7 @@ public static Capacitance FromFarads(QuantityValue farads) double value = (double) farads; return new Capacitance(value, CapacitanceUnit.Farad); } + /// /// Creates a from . /// @@ -315,6 +316,7 @@ public static Capacitance FromKilofarads(QuantityValue kilofarads) double value = (double) kilofarads; return new Capacitance(value, CapacitanceUnit.Kilofarad); } + /// /// Creates a from . /// @@ -324,6 +326,7 @@ public static Capacitance FromMegafarads(QuantityValue megafarads) double value = (double) megafarads; return new Capacitance(value, CapacitanceUnit.Megafarad); } + /// /// Creates a from . /// @@ -333,6 +336,7 @@ public static Capacitance FromMicrofarads(QuantityValue microfarads) double value = (double) microfarads; return new Capacitance(value, CapacitanceUnit.Microfarad); } + /// /// Creates a from . /// @@ -342,6 +346,7 @@ public static Capacitance FromMillifarads(QuantityValue millifarads) double value = (double) millifarads; return new Capacitance(value, CapacitanceUnit.Millifarad); } + /// /// Creates a from . /// @@ -351,6 +356,7 @@ public static Capacitance FromNanofarads(QuantityValue nanofarads) double value = (double) nanofarads; return new Capacitance(value, CapacitanceUnit.Nanofarad); } + /// /// Creates a from . /// @@ -361,6 +367,7 @@ public static Capacitance FromPicofarads(QuantityValue picofarads) return new Capacitance(value, CapacitanceUnit.Picofarad); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs b/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs index c0b951f7fb..edfc69f126 100644 --- a/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs @@ -267,6 +267,7 @@ public static CoefficientOfThermalExpansion FromInverseDegreeCelsius(QuantityVal double value = (double) inversedegreecelsius; return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.InverseDegreeCelsius); } + /// /// Creates a from . /// @@ -276,6 +277,7 @@ public static CoefficientOfThermalExpansion FromInverseDegreeFahrenheit(Quantity double value = (double) inversedegreefahrenheit; return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit); } + /// /// Creates a from . /// @@ -286,6 +288,7 @@ public static CoefficientOfThermalExpansion FromInverseKelvin(QuantityValue inve return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.InverseKelvin); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs b/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs index 7cc16d113b..015ba68598 100644 --- a/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs @@ -62,7 +62,13 @@ static Compressibility() Info = new QuantityInfo("Compressibility", new UnitInfo[] { + new UnitInfo(CompressibilityUnit.InverseAtmosphere, "InverseAtmospheres", BaseUnits.Undefined), + new UnitInfo(CompressibilityUnit.InverseBar, "InverseBars", BaseUnits.Undefined), + new UnitInfo(CompressibilityUnit.InverseKilopascal, "InverseKilopascals", BaseUnits.Undefined), + new UnitInfo(CompressibilityUnit.InverseMegapascal, "InverseMegapascals", BaseUnits.Undefined), + new UnitInfo(CompressibilityUnit.InverseMillibar, "InverseMillibars", BaseUnits.Undefined), new UnitInfo(CompressibilityUnit.InversePascal, "InversePascals", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second)), + new UnitInfo(CompressibilityUnit.InversePoundForcePerSquareInch, "InversePoundForcePerSquareInchs", BaseUnits.Undefined), }, BaseUnit, Zero, BaseDimensions, QuantityType.Compressibility); @@ -188,11 +194,41 @@ public Compressibility(double value, UnitSystem unitSystem) #region Conversion Properties + /// + /// Gets a value of this quantity converted into + /// + public double InverseAtmospheres => As(CompressibilityUnit.InverseAtmosphere); + + /// + /// Gets a value of this quantity converted into + /// + public double InverseBars => As(CompressibilityUnit.InverseBar); + + /// + /// Gets a value of this quantity converted into + /// + public double InverseKilopascals => As(CompressibilityUnit.InverseKilopascal); + + /// + /// Gets a value of this quantity converted into + /// + public double InverseMegapascals => As(CompressibilityUnit.InverseMegapascal); + + /// + /// Gets a value of this quantity converted into + /// + public double InverseMillibars => As(CompressibilityUnit.InverseMillibar); + /// /// Gets a value of this quantity converted into /// public double InversePascals => As(CompressibilityUnit.InversePascal); + /// + /// Gets a value of this quantity converted into + /// + public double InversePoundForcePerSquareInchs => As(CompressibilityUnit.InversePoundForcePerSquareInch); + #endregion #region Static Methods @@ -204,15 +240,33 @@ public Compressibility(double value, UnitSystem unitSystem) internal static void RegisterDefaultConversions(UnitConverter unitConverter) { // Register in unit converter: BaseUnit -> CompressibilityUnit + unitConverter.SetConversionFunction(CompressibilityUnit.InversePascal, CompressibilityUnit.InverseAtmosphere, quantity => new Compressibility(quantity.Value / 101325, CompressibilityUnit.InverseAtmosphere)); + unitConverter.SetConversionFunction(CompressibilityUnit.InversePascal, CompressibilityUnit.InverseBar, quantity => new Compressibility(quantity.Value / 1e5, CompressibilityUnit.InverseBar)); + unitConverter.SetConversionFunction(CompressibilityUnit.InversePascal, CompressibilityUnit.InverseKilopascal, quantity => new Compressibility(quantity.Value / 1e3, CompressibilityUnit.InverseKilopascal)); + unitConverter.SetConversionFunction(CompressibilityUnit.InversePascal, CompressibilityUnit.InverseMegapascal, quantity => new Compressibility(quantity.Value / 1e6, CompressibilityUnit.InverseMegapascal)); + unitConverter.SetConversionFunction(CompressibilityUnit.InversePascal, CompressibilityUnit.InverseMillibar, quantity => new Compressibility(quantity.Value / 100, CompressibilityUnit.InverseMillibar)); + unitConverter.SetConversionFunction(CompressibilityUnit.InversePascal, CompressibilityUnit.InversePoundForcePerSquareInch, quantity => new Compressibility(quantity.Value / 6.894757293168361e3, CompressibilityUnit.InversePoundForcePerSquareInch)); // Register in unit converter: BaseUnit <-> BaseUnit unitConverter.SetConversionFunction(CompressibilityUnit.InversePascal, CompressibilityUnit.InversePascal, quantity => quantity); // Register in unit converter: CompressibilityUnit -> BaseUnit + unitConverter.SetConversionFunction(CompressibilityUnit.InverseAtmosphere, CompressibilityUnit.InversePascal, quantity => new Compressibility(quantity.Value * 101325, CompressibilityUnit.InversePascal)); + unitConverter.SetConversionFunction(CompressibilityUnit.InverseBar, CompressibilityUnit.InversePascal, quantity => new Compressibility(quantity.Value * 1e5, CompressibilityUnit.InversePascal)); + unitConverter.SetConversionFunction(CompressibilityUnit.InverseKilopascal, CompressibilityUnit.InversePascal, quantity => new Compressibility(quantity.Value * 1e3, CompressibilityUnit.InversePascal)); + unitConverter.SetConversionFunction(CompressibilityUnit.InverseMegapascal, CompressibilityUnit.InversePascal, quantity => new Compressibility(quantity.Value * 1e6, CompressibilityUnit.InversePascal)); + unitConverter.SetConversionFunction(CompressibilityUnit.InverseMillibar, CompressibilityUnit.InversePascal, quantity => new Compressibility(quantity.Value * 100, CompressibilityUnit.InversePascal)); + unitConverter.SetConversionFunction(CompressibilityUnit.InversePoundForcePerSquareInch, CompressibilityUnit.InversePascal, quantity => new Compressibility(quantity.Value * 6.894757293168361e3, CompressibilityUnit.InversePascal)); } internal static void MapGeneratedLocalizations(UnitAbbreviationsCache unitAbbreviationsCache) { + unitAbbreviationsCache.PerformAbbreviationMapping(CompressibilityUnit.InverseAtmosphere, new CultureInfo("en-US"), false, true, new string[]{"atm⁻¹", "1/atm"}); + unitAbbreviationsCache.PerformAbbreviationMapping(CompressibilityUnit.InverseBar, new CultureInfo("en-US"), false, true, new string[]{"bar⁻¹", "1/bar"}); + unitAbbreviationsCache.PerformAbbreviationMapping(CompressibilityUnit.InverseKilopascal, new CultureInfo("en-US"), false, true, new string[]{"kPa⁻¹", "1/kPa"}); + unitAbbreviationsCache.PerformAbbreviationMapping(CompressibilityUnit.InverseMegapascal, new CultureInfo("en-US"), false, true, new string[]{"kPa⁻¹", "1/kPa"}); + unitAbbreviationsCache.PerformAbbreviationMapping(CompressibilityUnit.InverseMillibar, new CultureInfo("en-US"), false, true, new string[]{"mbar⁻¹", "1/mbar"}); unitAbbreviationsCache.PerformAbbreviationMapping(CompressibilityUnit.InversePascal, new CultureInfo("en-US"), false, true, new string[]{"Pa⁻¹", "1/Pa"}); + unitAbbreviationsCache.PerformAbbreviationMapping(CompressibilityUnit.InversePoundForcePerSquareInch, new CultureInfo("en-US"), false, true, new string[]{"psi⁻¹", "1/psi"}); } /// @@ -240,6 +294,56 @@ public static string GetAbbreviation(CompressibilityUnit unit, IFormatProvider? #region Static Factory Methods + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static Compressibility FromInverseAtmospheres(QuantityValue inverseatmospheres) + { + double value = (double) inverseatmospheres; + return new Compressibility(value, CompressibilityUnit.InverseAtmosphere); + } + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static Compressibility FromInverseBars(QuantityValue inversebars) + { + double value = (double) inversebars; + return new Compressibility(value, CompressibilityUnit.InverseBar); + } + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static Compressibility FromInverseKilopascals(QuantityValue inversekilopascals) + { + double value = (double) inversekilopascals; + return new Compressibility(value, CompressibilityUnit.InverseKilopascal); + } + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static Compressibility FromInverseMegapascals(QuantityValue inversemegapascals) + { + double value = (double) inversemegapascals; + return new Compressibility(value, CompressibilityUnit.InverseMegapascal); + } + + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static Compressibility FromInverseMillibars(QuantityValue inversemillibars) + { + double value = (double) inversemillibars; + return new Compressibility(value, CompressibilityUnit.InverseMillibar); + } + /// /// Creates a from . /// @@ -250,6 +354,17 @@ public static Compressibility FromInversePascals(QuantityValue inversepascals) return new Compressibility(value, CompressibilityUnit.InversePascal); } + /// + /// Creates a from . + /// + /// If value is NaN or Infinity. + public static Compressibility FromInversePoundForcePerSquareInchs(QuantityValue inversepoundforcepersquareinchs) + { + double value = (double) inversepoundforcepersquareinchs; + return new Compressibility(value, CompressibilityUnit.InversePoundForcePerSquareInch); + } + + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Density.g.cs b/UnitsNet/GeneratedCode/Quantities/Density.g.cs index e8e364e55e..95c6c8af5d 100644 --- a/UnitsNet/GeneratedCode/Quantities/Density.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Density.g.cs @@ -706,6 +706,7 @@ public static Density FromCentigramsPerDeciLiter(QuantityValue centigramsperdeci double value = (double) centigramsperdeciliter; return new Density(value, DensityUnit.CentigramPerDeciliter); } + /// /// Creates a from . /// @@ -715,6 +716,7 @@ public static Density FromCentigramsPerLiter(QuantityValue centigramsperliter) double value = (double) centigramsperliter; return new Density(value, DensityUnit.CentigramPerLiter); } + /// /// Creates a from . /// @@ -724,6 +726,7 @@ public static Density FromCentigramsPerMilliliter(QuantityValue centigramspermil double value = (double) centigramspermilliliter; return new Density(value, DensityUnit.CentigramPerMilliliter); } + /// /// Creates a from . /// @@ -733,6 +736,7 @@ public static Density FromDecigramsPerDeciLiter(QuantityValue decigramsperdecili double value = (double) decigramsperdeciliter; return new Density(value, DensityUnit.DecigramPerDeciliter); } + /// /// Creates a from . /// @@ -742,6 +746,7 @@ public static Density FromDecigramsPerLiter(QuantityValue decigramsperliter) double value = (double) decigramsperliter; return new Density(value, DensityUnit.DecigramPerLiter); } + /// /// Creates a from . /// @@ -751,6 +756,7 @@ public static Density FromDecigramsPerMilliliter(QuantityValue decigramspermilli double value = (double) decigramspermilliliter; return new Density(value, DensityUnit.DecigramPerMilliliter); } + /// /// Creates a from . /// @@ -760,6 +766,7 @@ public static Density FromGramsPerCubicCentimeter(QuantityValue gramspercubiccen double value = (double) gramspercubiccentimeter; return new Density(value, DensityUnit.GramPerCubicCentimeter); } + /// /// Creates a from . /// @@ -769,6 +776,7 @@ public static Density FromGramsPerCubicFoot(QuantityValue gramspercubicfoot) double value = (double) gramspercubicfoot; return new Density(value, DensityUnit.GramPerCubicFoot); } + /// /// Creates a from . /// @@ -778,6 +786,7 @@ public static Density FromGramsPerCubicInch(QuantityValue gramspercubicinch) double value = (double) gramspercubicinch; return new Density(value, DensityUnit.GramPerCubicInch); } + /// /// Creates a from . /// @@ -787,6 +796,7 @@ public static Density FromGramsPerCubicMeter(QuantityValue gramspercubicmeter) double value = (double) gramspercubicmeter; return new Density(value, DensityUnit.GramPerCubicMeter); } + /// /// Creates a from . /// @@ -796,6 +806,7 @@ public static Density FromGramsPerCubicMillimeter(QuantityValue gramspercubicmil double value = (double) gramspercubicmillimeter; return new Density(value, DensityUnit.GramPerCubicMillimeter); } + /// /// Creates a from . /// @@ -805,6 +816,7 @@ public static Density FromGramsPerDeciLiter(QuantityValue gramsperdeciliter) double value = (double) gramsperdeciliter; return new Density(value, DensityUnit.GramPerDeciliter); } + /// /// Creates a from . /// @@ -814,6 +826,7 @@ public static Density FromGramsPerLiter(QuantityValue gramsperliter) double value = (double) gramsperliter; return new Density(value, DensityUnit.GramPerLiter); } + /// /// Creates a from . /// @@ -823,6 +836,7 @@ public static Density FromGramsPerMilliliter(QuantityValue gramspermilliliter) double value = (double) gramspermilliliter; return new Density(value, DensityUnit.GramPerMilliliter); } + /// /// Creates a from . /// @@ -832,6 +846,7 @@ public static Density FromKilogramsPerCubicCentimeter(QuantityValue kilogramsper double value = (double) kilogramspercubiccentimeter; return new Density(value, DensityUnit.KilogramPerCubicCentimeter); } + /// /// Creates a from . /// @@ -841,6 +856,7 @@ public static Density FromKilogramsPerCubicMeter(QuantityValue kilogramspercubic double value = (double) kilogramspercubicmeter; return new Density(value, DensityUnit.KilogramPerCubicMeter); } + /// /// Creates a from . /// @@ -850,6 +866,7 @@ public static Density FromKilogramsPerCubicMillimeter(QuantityValue kilogramsper double value = (double) kilogramspercubicmillimeter; return new Density(value, DensityUnit.KilogramPerCubicMillimeter); } + /// /// Creates a from . /// @@ -859,6 +876,7 @@ public static Density FromKilogramsPerLiter(QuantityValue kilogramsperliter) double value = (double) kilogramsperliter; return new Density(value, DensityUnit.KilogramPerLiter); } + /// /// Creates a from . /// @@ -868,6 +886,7 @@ public static Density FromKilopoundsPerCubicFoot(QuantityValue kilopoundspercubi double value = (double) kilopoundspercubicfoot; return new Density(value, DensityUnit.KilopoundPerCubicFoot); } + /// /// Creates a from . /// @@ -877,6 +896,7 @@ public static Density FromKilopoundsPerCubicInch(QuantityValue kilopoundspercubi double value = (double) kilopoundspercubicinch; return new Density(value, DensityUnit.KilopoundPerCubicInch); } + /// /// Creates a from . /// @@ -886,6 +906,7 @@ public static Density FromMicrogramsPerCubicMeter(QuantityValue microgramspercub double value = (double) microgramspercubicmeter; return new Density(value, DensityUnit.MicrogramPerCubicMeter); } + /// /// Creates a from . /// @@ -895,6 +916,7 @@ public static Density FromMicrogramsPerDeciLiter(QuantityValue microgramsperdeci double value = (double) microgramsperdeciliter; return new Density(value, DensityUnit.MicrogramPerDeciliter); } + /// /// Creates a from . /// @@ -904,6 +926,7 @@ public static Density FromMicrogramsPerLiter(QuantityValue microgramsperliter) double value = (double) microgramsperliter; return new Density(value, DensityUnit.MicrogramPerLiter); } + /// /// Creates a from . /// @@ -913,6 +936,7 @@ public static Density FromMicrogramsPerMilliliter(QuantityValue microgramspermil double value = (double) microgramspermilliliter; return new Density(value, DensityUnit.MicrogramPerMilliliter); } + /// /// Creates a from . /// @@ -922,6 +946,7 @@ public static Density FromMilligramsPerCubicMeter(QuantityValue milligramspercub double value = (double) milligramspercubicmeter; return new Density(value, DensityUnit.MilligramPerCubicMeter); } + /// /// Creates a from . /// @@ -931,6 +956,7 @@ public static Density FromMilligramsPerDeciLiter(QuantityValue milligramsperdeci double value = (double) milligramsperdeciliter; return new Density(value, DensityUnit.MilligramPerDeciliter); } + /// /// Creates a from . /// @@ -940,6 +966,7 @@ public static Density FromMilligramsPerLiter(QuantityValue milligramsperliter) double value = (double) milligramsperliter; return new Density(value, DensityUnit.MilligramPerLiter); } + /// /// Creates a from . /// @@ -949,6 +976,7 @@ public static Density FromMilligramsPerMilliliter(QuantityValue milligramspermil double value = (double) milligramspermilliliter; return new Density(value, DensityUnit.MilligramPerMilliliter); } + /// /// Creates a from . /// @@ -958,6 +986,7 @@ public static Density FromNanogramsPerDeciLiter(QuantityValue nanogramsperdecili double value = (double) nanogramsperdeciliter; return new Density(value, DensityUnit.NanogramPerDeciliter); } + /// /// Creates a from . /// @@ -967,6 +996,7 @@ public static Density FromNanogramsPerLiter(QuantityValue nanogramsperliter) double value = (double) nanogramsperliter; return new Density(value, DensityUnit.NanogramPerLiter); } + /// /// Creates a from . /// @@ -976,6 +1006,7 @@ public static Density FromNanogramsPerMilliliter(QuantityValue nanogramspermilli double value = (double) nanogramspermilliliter; return new Density(value, DensityUnit.NanogramPerMilliliter); } + /// /// Creates a from . /// @@ -985,6 +1016,7 @@ public static Density FromPicogramsPerDeciLiter(QuantityValue picogramsperdecili double value = (double) picogramsperdeciliter; return new Density(value, DensityUnit.PicogramPerDeciliter); } + /// /// Creates a from . /// @@ -994,6 +1026,7 @@ public static Density FromPicogramsPerLiter(QuantityValue picogramsperliter) double value = (double) picogramsperliter; return new Density(value, DensityUnit.PicogramPerLiter); } + /// /// Creates a from . /// @@ -1003,6 +1036,7 @@ public static Density FromPicogramsPerMilliliter(QuantityValue picogramspermilli double value = (double) picogramspermilliliter; return new Density(value, DensityUnit.PicogramPerMilliliter); } + /// /// Creates a from . /// @@ -1012,6 +1046,7 @@ public static Density FromPoundsPerCubicCentimeter(QuantityValue poundspercubicc double value = (double) poundspercubiccentimeter; return new Density(value, DensityUnit.PoundPerCubicCentimeter); } + /// /// Creates a from . /// @@ -1021,6 +1056,7 @@ public static Density FromPoundsPerCubicFoot(QuantityValue poundspercubicfoot) double value = (double) poundspercubicfoot; return new Density(value, DensityUnit.PoundPerCubicFoot); } + /// /// Creates a from . /// @@ -1030,6 +1066,7 @@ public static Density FromPoundsPerCubicInch(QuantityValue poundspercubicinch) double value = (double) poundspercubicinch; return new Density(value, DensityUnit.PoundPerCubicInch); } + /// /// Creates a from . /// @@ -1039,6 +1076,7 @@ public static Density FromPoundsPerCubicMeter(QuantityValue poundspercubicmeter) double value = (double) poundspercubicmeter; return new Density(value, DensityUnit.PoundPerCubicMeter); } + /// /// Creates a from . /// @@ -1048,6 +1086,7 @@ public static Density FromPoundsPerCubicMillimeter(QuantityValue poundspercubicm double value = (double) poundspercubicmillimeter; return new Density(value, DensityUnit.PoundPerCubicMillimeter); } + /// /// Creates a from . /// @@ -1057,6 +1096,7 @@ public static Density FromPoundsPerImperialGallon(QuantityValue poundsperimperia double value = (double) poundsperimperialgallon; return new Density(value, DensityUnit.PoundPerImperialGallon); } + /// /// Creates a from . /// @@ -1066,6 +1106,7 @@ public static Density FromPoundsPerUSGallon(QuantityValue poundsperusgallon) double value = (double) poundsperusgallon; return new Density(value, DensityUnit.PoundPerUSGallon); } + /// /// Creates a from . /// @@ -1075,6 +1116,7 @@ public static Density FromSlugsPerCubicCentimeter(QuantityValue slugspercubiccen double value = (double) slugspercubiccentimeter; return new Density(value, DensityUnit.SlugPerCubicCentimeter); } + /// /// Creates a from . /// @@ -1084,6 +1126,7 @@ public static Density FromSlugsPerCubicFoot(QuantityValue slugspercubicfoot) double value = (double) slugspercubicfoot; return new Density(value, DensityUnit.SlugPerCubicFoot); } + /// /// Creates a from . /// @@ -1093,6 +1136,7 @@ public static Density FromSlugsPerCubicInch(QuantityValue slugspercubicinch) double value = (double) slugspercubicinch; return new Density(value, DensityUnit.SlugPerCubicInch); } + /// /// Creates a from . /// @@ -1102,6 +1146,7 @@ public static Density FromSlugsPerCubicMeter(QuantityValue slugspercubicmeter) double value = (double) slugspercubicmeter; return new Density(value, DensityUnit.SlugPerCubicMeter); } + /// /// Creates a from . /// @@ -1111,6 +1156,7 @@ public static Density FromSlugsPerCubicMillimeter(QuantityValue slugspercubicmil double value = (double) slugspercubicmillimeter; return new Density(value, DensityUnit.SlugPerCubicMillimeter); } + /// /// Creates a from . /// @@ -1120,6 +1166,7 @@ public static Density FromTonnesPerCubicCentimeter(QuantityValue tonnespercubicc double value = (double) tonnespercubiccentimeter; return new Density(value, DensityUnit.TonnePerCubicCentimeter); } + /// /// Creates a from . /// @@ -1129,6 +1176,7 @@ public static Density FromTonnesPerCubicFoot(QuantityValue tonnespercubicfoot) double value = (double) tonnespercubicfoot; return new Density(value, DensityUnit.TonnePerCubicFoot); } + /// /// Creates a from . /// @@ -1138,6 +1186,7 @@ public static Density FromTonnesPerCubicInch(QuantityValue tonnespercubicinch) double value = (double) tonnespercubicinch; return new Density(value, DensityUnit.TonnePerCubicInch); } + /// /// Creates a from . /// @@ -1147,6 +1196,7 @@ public static Density FromTonnesPerCubicMeter(QuantityValue tonnespercubicmeter) double value = (double) tonnespercubicmeter; return new Density(value, DensityUnit.TonnePerCubicMeter); } + /// /// Creates a from . /// @@ -1157,6 +1207,7 @@ public static Density FromTonnesPerCubicMillimeter(QuantityValue tonnespercubicm return new Density(value, DensityUnit.TonnePerCubicMillimeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Duration.g.cs b/UnitsNet/GeneratedCode/Quantities/Duration.g.cs index e8345e1070..af6ef0828f 100644 --- a/UnitsNet/GeneratedCode/Quantities/Duration.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Duration.g.cs @@ -349,6 +349,7 @@ public static Duration FromDays(QuantityValue days) double value = (double) days; return new Duration(value, DurationUnit.Day); } + /// /// Creates a from . /// @@ -358,6 +359,7 @@ public static Duration FromHours(QuantityValue hours) double value = (double) hours; return new Duration(value, DurationUnit.Hour); } + /// /// Creates a from . /// @@ -367,6 +369,7 @@ public static Duration FromJulianYears(QuantityValue julianyears) double value = (double) julianyears; return new Duration(value, DurationUnit.JulianYear); } + /// /// Creates a from . /// @@ -376,6 +379,7 @@ public static Duration FromMicroseconds(QuantityValue microseconds) double value = (double) microseconds; return new Duration(value, DurationUnit.Microsecond); } + /// /// Creates a from . /// @@ -385,6 +389,7 @@ public static Duration FromMilliseconds(QuantityValue milliseconds) double value = (double) milliseconds; return new Duration(value, DurationUnit.Millisecond); } + /// /// Creates a from . /// @@ -394,6 +399,7 @@ public static Duration FromMinutes(QuantityValue minutes) double value = (double) minutes; return new Duration(value, DurationUnit.Minute); } + /// /// Creates a from . /// @@ -403,6 +409,7 @@ public static Duration FromMonths30(QuantityValue months30) double value = (double) months30; return new Duration(value, DurationUnit.Month30); } + /// /// Creates a from . /// @@ -412,6 +419,7 @@ public static Duration FromNanoseconds(QuantityValue nanoseconds) double value = (double) nanoseconds; return new Duration(value, DurationUnit.Nanosecond); } + /// /// Creates a from . /// @@ -421,6 +429,7 @@ public static Duration FromSeconds(QuantityValue seconds) double value = (double) seconds; return new Duration(value, DurationUnit.Second); } + /// /// Creates a from . /// @@ -430,6 +439,7 @@ public static Duration FromWeeks(QuantityValue weeks) double value = (double) weeks; return new Duration(value, DurationUnit.Week); } + /// /// Creates a from . /// @@ -440,6 +450,7 @@ public static Duration FromYears365(QuantityValue years365) return new Duration(value, DurationUnit.Year365); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs b/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs index 7b275de867..f4c4b2ae1f 100644 --- a/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs @@ -333,6 +333,7 @@ public static DynamicViscosity FromCentipoise(QuantityValue centipoise) double value = (double) centipoise; return new DynamicViscosity(value, DynamicViscosityUnit.Centipoise); } + /// /// Creates a from . /// @@ -342,6 +343,7 @@ public static DynamicViscosity FromMicropascalSeconds(QuantityValue micropascals double value = (double) micropascalseconds; return new DynamicViscosity(value, DynamicViscosityUnit.MicropascalSecond); } + /// /// Creates a from . /// @@ -351,6 +353,7 @@ public static DynamicViscosity FromMillipascalSeconds(QuantityValue millipascals double value = (double) millipascalseconds; return new DynamicViscosity(value, DynamicViscosityUnit.MillipascalSecond); } + /// /// Creates a from . /// @@ -360,6 +363,7 @@ public static DynamicViscosity FromNewtonSecondsPerMeterSquared(QuantityValue ne double value = (double) newtonsecondspermetersquared; return new DynamicViscosity(value, DynamicViscosityUnit.NewtonSecondPerMeterSquared); } + /// /// Creates a from . /// @@ -369,6 +373,7 @@ public static DynamicViscosity FromPascalSeconds(QuantityValue pascalseconds) double value = (double) pascalseconds; return new DynamicViscosity(value, DynamicViscosityUnit.PascalSecond); } + /// /// Creates a from . /// @@ -378,6 +383,7 @@ public static DynamicViscosity FromPoise(QuantityValue poise) double value = (double) poise; return new DynamicViscosity(value, DynamicViscosityUnit.Poise); } + /// /// Creates a from . /// @@ -387,6 +393,7 @@ public static DynamicViscosity FromPoundsForceSecondPerSquareFoot(QuantityValue double value = (double) poundsforcesecondpersquarefoot; return new DynamicViscosity(value, DynamicViscosityUnit.PoundForceSecondPerSquareFoot); } + /// /// Creates a from . /// @@ -396,6 +403,7 @@ public static DynamicViscosity FromPoundsForceSecondPerSquareInch(QuantityValue double value = (double) poundsforcesecondpersquareinch; return new DynamicViscosity(value, DynamicViscosityUnit.PoundForceSecondPerSquareInch); } + /// /// Creates a from . /// @@ -405,6 +413,7 @@ public static DynamicViscosity FromPoundsPerFootSecond(QuantityValue poundsperfo double value = (double) poundsperfootsecond; return new DynamicViscosity(value, DynamicViscosityUnit.PoundPerFootSecond); } + /// /// Creates a from . /// @@ -415,6 +424,7 @@ public static DynamicViscosity FromReyns(QuantityValue reyns) return new DynamicViscosity(value, DynamicViscosityUnit.Reyn); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs index 7e9d5fc7d5..94cf72473e 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs @@ -276,6 +276,7 @@ public static ElectricAdmittance FromMicrosiemens(QuantityValue microsiemens) double value = (double) microsiemens; return new ElectricAdmittance(value, ElectricAdmittanceUnit.Microsiemens); } + /// /// Creates a from . /// @@ -285,6 +286,7 @@ public static ElectricAdmittance FromMillisiemens(QuantityValue millisiemens) double value = (double) millisiemens; return new ElectricAdmittance(value, ElectricAdmittanceUnit.Millisiemens); } + /// /// Creates a from . /// @@ -294,6 +296,7 @@ public static ElectricAdmittance FromNanosiemens(QuantityValue nanosiemens) double value = (double) nanosiemens; return new ElectricAdmittance(value, ElectricAdmittanceUnit.Nanosiemens); } + /// /// Creates a from . /// @@ -304,6 +307,7 @@ public static ElectricAdmittance FromSiemens(QuantityValue siemens) return new ElectricAdmittance(value, ElectricAdmittanceUnit.Siemens); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs index 612c10235c..03a73a9064 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs @@ -288,6 +288,7 @@ public static ElectricCharge FromAmpereHours(QuantityValue amperehours) double value = (double) amperehours; return new ElectricCharge(value, ElectricChargeUnit.AmpereHour); } + /// /// Creates a from . /// @@ -297,6 +298,7 @@ public static ElectricCharge FromCoulombs(QuantityValue coulombs) double value = (double) coulombs; return new ElectricCharge(value, ElectricChargeUnit.Coulomb); } + /// /// Creates a from . /// @@ -306,6 +308,7 @@ public static ElectricCharge FromKiloampereHours(QuantityValue kiloamperehours) double value = (double) kiloamperehours; return new ElectricCharge(value, ElectricChargeUnit.KiloampereHour); } + /// /// Creates a from . /// @@ -315,6 +318,7 @@ public static ElectricCharge FromMegaampereHours(QuantityValue megaamperehours) double value = (double) megaamperehours; return new ElectricCharge(value, ElectricChargeUnit.MegaampereHour); } + /// /// Creates a from . /// @@ -325,6 +329,7 @@ public static ElectricCharge FromMilliampereHours(QuantityValue milliamperehours return new ElectricCharge(value, ElectricChargeUnit.MilliampereHour); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs index 3297d02689..6378bf9fae 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs @@ -253,6 +253,7 @@ public static ElectricChargeDensity FromCoulombsPerCubicMeter(QuantityValue coul return new ElectricChargeDensity(value, ElectricChargeDensityUnit.CoulombPerCubicMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs index c6c05cfe13..c56fdf90a2 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs @@ -270,6 +270,7 @@ public static ElectricConductance FromMicrosiemens(QuantityValue microsiemens) double value = (double) microsiemens; return new ElectricConductance(value, ElectricConductanceUnit.Microsiemens); } + /// /// Creates a from . /// @@ -279,6 +280,7 @@ public static ElectricConductance FromMillisiemens(QuantityValue millisiemens) double value = (double) millisiemens; return new ElectricConductance(value, ElectricConductanceUnit.Millisiemens); } + /// /// Creates a from . /// @@ -289,6 +291,7 @@ public static ElectricConductance FromSiemens(QuantityValue siemens) return new ElectricConductance(value, ElectricConductanceUnit.Siemens); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs index 31a6f44390..ef6d32ab04 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs @@ -270,6 +270,7 @@ public static ElectricConductivity FromSiemensPerFoot(QuantityValue siemensperfo double value = (double) siemensperfoot; return new ElectricConductivity(value, ElectricConductivityUnit.SiemensPerFoot); } + /// /// Creates a from . /// @@ -279,6 +280,7 @@ public static ElectricConductivity FromSiemensPerInch(QuantityValue siemensperin double value = (double) siemensperinch; return new ElectricConductivity(value, ElectricConductivityUnit.SiemensPerInch); } + /// /// Creates a from . /// @@ -289,6 +291,7 @@ public static ElectricConductivity FromSiemensPerMeter(QuantityValue siemensperm return new ElectricConductivity(value, ElectricConductivityUnit.SiemensPerMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs index 83dfb4c311..c740ac7a37 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs @@ -312,6 +312,7 @@ public static ElectricCurrent FromAmperes(QuantityValue amperes) double value = (double) amperes; return new ElectricCurrent(value, ElectricCurrentUnit.Ampere); } + /// /// Creates a from . /// @@ -321,6 +322,7 @@ public static ElectricCurrent FromCentiamperes(QuantityValue centiamperes) double value = (double) centiamperes; return new ElectricCurrent(value, ElectricCurrentUnit.Centiampere); } + /// /// Creates a from . /// @@ -330,6 +332,7 @@ public static ElectricCurrent FromKiloamperes(QuantityValue kiloamperes) double value = (double) kiloamperes; return new ElectricCurrent(value, ElectricCurrentUnit.Kiloampere); } + /// /// Creates a from . /// @@ -339,6 +342,7 @@ public static ElectricCurrent FromMegaamperes(QuantityValue megaamperes) double value = (double) megaamperes; return new ElectricCurrent(value, ElectricCurrentUnit.Megaampere); } + /// /// Creates a from . /// @@ -348,6 +352,7 @@ public static ElectricCurrent FromMicroamperes(QuantityValue microamperes) double value = (double) microamperes; return new ElectricCurrent(value, ElectricCurrentUnit.Microampere); } + /// /// Creates a from . /// @@ -357,6 +362,7 @@ public static ElectricCurrent FromMilliamperes(QuantityValue milliamperes) double value = (double) milliamperes; return new ElectricCurrent(value, ElectricCurrentUnit.Milliampere); } + /// /// Creates a from . /// @@ -366,6 +372,7 @@ public static ElectricCurrent FromNanoamperes(QuantityValue nanoamperes) double value = (double) nanoamperes; return new ElectricCurrent(value, ElectricCurrentUnit.Nanoampere); } + /// /// Creates a from . /// @@ -376,6 +383,7 @@ public static ElectricCurrent FromPicoamperes(QuantityValue picoamperes) return new ElectricCurrent(value, ElectricCurrentUnit.Picoampere); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs index fd014425f3..4f7457eac6 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs @@ -270,6 +270,7 @@ public static ElectricCurrentDensity FromAmperesPerSquareFoot(QuantityValue ampe double value = (double) amperespersquarefoot; return new ElectricCurrentDensity(value, ElectricCurrentDensityUnit.AmperePerSquareFoot); } + /// /// Creates a from . /// @@ -279,6 +280,7 @@ public static ElectricCurrentDensity FromAmperesPerSquareInch(QuantityValue ampe double value = (double) amperespersquareinch; return new ElectricCurrentDensity(value, ElectricCurrentDensityUnit.AmperePerSquareInch); } + /// /// Creates a from . /// @@ -289,6 +291,7 @@ public static ElectricCurrentDensity FromAmperesPerSquareMeter(QuantityValue amp return new ElectricCurrentDensity(value, ElectricCurrentDensityUnit.AmperePerSquareMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs index 2c64fa624c..3a8706b474 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs @@ -276,6 +276,7 @@ public static ElectricCurrentGradient FromAmperesPerMicrosecond(QuantityValue am double value = (double) amperespermicrosecond; return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerMicrosecond); } + /// /// Creates a from . /// @@ -285,6 +286,7 @@ public static ElectricCurrentGradient FromAmperesPerMillisecond(QuantityValue am double value = (double) amperespermillisecond; return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerMillisecond); } + /// /// Creates a from . /// @@ -294,6 +296,7 @@ public static ElectricCurrentGradient FromAmperesPerNanosecond(QuantityValue amp double value = (double) amperespernanosecond; return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerNanosecond); } + /// /// Creates a from . /// @@ -304,6 +307,7 @@ public static ElectricCurrentGradient FromAmperesPerSecond(QuantityValue amperes return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerSecond); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs index 36df6a5276..2da601ff60 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs @@ -253,6 +253,7 @@ public static ElectricField FromVoltsPerMeter(QuantityValue voltspermeter) return new ElectricField(value, ElectricFieldUnit.VoltPerMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs index 69beef1a4f..a8d903b46c 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs @@ -279,6 +279,7 @@ public static ElectricInductance FromHenries(QuantityValue henries) double value = (double) henries; return new ElectricInductance(value, ElectricInductanceUnit.Henry); } + /// /// Creates a from . /// @@ -288,6 +289,7 @@ public static ElectricInductance FromMicrohenries(QuantityValue microhenries) double value = (double) microhenries; return new ElectricInductance(value, ElectricInductanceUnit.Microhenry); } + /// /// Creates a from . /// @@ -297,6 +299,7 @@ public static ElectricInductance FromMillihenries(QuantityValue millihenries) double value = (double) millihenries; return new ElectricInductance(value, ElectricInductanceUnit.Millihenry); } + /// /// Creates a from . /// @@ -307,6 +310,7 @@ public static ElectricInductance FromNanohenries(QuantityValue nanohenries) return new ElectricInductance(value, ElectricInductanceUnit.Nanohenry); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs index 4f9cb1a316..948f1706b9 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs @@ -290,6 +290,7 @@ public static ElectricPotential FromKilovolts(QuantityValue kilovolts) double value = (double) kilovolts; return new ElectricPotential(value, ElectricPotentialUnit.Kilovolt); } + /// /// Creates a from . /// @@ -299,6 +300,7 @@ public static ElectricPotential FromMegavolts(QuantityValue megavolts) double value = (double) megavolts; return new ElectricPotential(value, ElectricPotentialUnit.Megavolt); } + /// /// Creates a from . /// @@ -308,6 +310,7 @@ public static ElectricPotential FromMicrovolts(QuantityValue microvolts) double value = (double) microvolts; return new ElectricPotential(value, ElectricPotentialUnit.Microvolt); } + /// /// Creates a from . /// @@ -317,6 +320,7 @@ public static ElectricPotential FromMillivolts(QuantityValue millivolts) double value = (double) millivolts; return new ElectricPotential(value, ElectricPotentialUnit.Millivolt); } + /// /// Creates a from . /// @@ -327,6 +331,7 @@ public static ElectricPotential FromVolts(QuantityValue volts) return new ElectricPotential(value, ElectricPotentialUnit.Volt); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.g.cs index f956261fc2..b8a7581ca0 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.g.cs @@ -285,6 +285,7 @@ public static ElectricPotentialAc FromKilovoltsAc(QuantityValue kilovoltsac) double value = (double) kilovoltsac; return new ElectricPotentialAc(value, ElectricPotentialAcUnit.KilovoltAc); } + /// /// Creates a from . /// @@ -294,6 +295,7 @@ public static ElectricPotentialAc FromMegavoltsAc(QuantityValue megavoltsac) double value = (double) megavoltsac; return new ElectricPotentialAc(value, ElectricPotentialAcUnit.MegavoltAc); } + /// /// Creates a from . /// @@ -303,6 +305,7 @@ public static ElectricPotentialAc FromMicrovoltsAc(QuantityValue microvoltsac) double value = (double) microvoltsac; return new ElectricPotentialAc(value, ElectricPotentialAcUnit.MicrovoltAc); } + /// /// Creates a from . /// @@ -312,6 +315,7 @@ public static ElectricPotentialAc FromMillivoltsAc(QuantityValue millivoltsac) double value = (double) millivoltsac; return new ElectricPotentialAc(value, ElectricPotentialAcUnit.MillivoltAc); } + /// /// Creates a from . /// @@ -322,6 +326,7 @@ public static ElectricPotentialAc FromVoltsAc(QuantityValue voltsac) return new ElectricPotentialAc(value, ElectricPotentialAcUnit.VoltAc); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs index 6a8ac42d46..d2e5e85ebf 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs @@ -420,6 +420,7 @@ public static ElectricPotentialChangeRate FromKilovoltsPerHours(QuantityValue ki double value = (double) kilovoltsperhours; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerHour); } + /// /// Creates a from . /// @@ -429,6 +430,7 @@ public static ElectricPotentialChangeRate FromKilovoltsPerMicroseconds(QuantityV double value = (double) kilovoltspermicroseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond); } + /// /// Creates a from . /// @@ -438,6 +440,7 @@ public static ElectricPotentialChangeRate FromKilovoltsPerMinutes(QuantityValue double value = (double) kilovoltsperminutes; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerMinute); } + /// /// Creates a from . /// @@ -447,6 +450,7 @@ public static ElectricPotentialChangeRate FromKilovoltsPerSeconds(QuantityValue double value = (double) kilovoltsperseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerSecond); } + /// /// Creates a from . /// @@ -456,6 +460,7 @@ public static ElectricPotentialChangeRate FromMegavoltsPerHours(QuantityValue me double value = (double) megavoltsperhours; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerHour); } + /// /// Creates a from . /// @@ -465,6 +470,7 @@ public static ElectricPotentialChangeRate FromMegavoltsPerMicroseconds(QuantityV double value = (double) megavoltspermicroseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond); } + /// /// Creates a from . /// @@ -474,6 +480,7 @@ public static ElectricPotentialChangeRate FromMegavoltsPerMinutes(QuantityValue double value = (double) megavoltsperminutes; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerMinute); } + /// /// Creates a from . /// @@ -483,6 +490,7 @@ public static ElectricPotentialChangeRate FromMegavoltsPerSeconds(QuantityValue double value = (double) megavoltsperseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerSecond); } + /// /// Creates a from . /// @@ -492,6 +500,7 @@ public static ElectricPotentialChangeRate FromMicrovoltsPerHours(QuantityValue m double value = (double) microvoltsperhours; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerHour); } + /// /// Creates a from . /// @@ -501,6 +510,7 @@ public static ElectricPotentialChangeRate FromMicrovoltsPerMicroseconds(Quantity double value = (double) microvoltspermicroseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond); } + /// /// Creates a from . /// @@ -510,6 +520,7 @@ public static ElectricPotentialChangeRate FromMicrovoltsPerMinutes(QuantityValue double value = (double) microvoltsperminutes; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerMinute); } + /// /// Creates a from . /// @@ -519,6 +530,7 @@ public static ElectricPotentialChangeRate FromMicrovoltsPerSeconds(QuantityValue double value = (double) microvoltsperseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerSecond); } + /// /// Creates a from . /// @@ -528,6 +540,7 @@ public static ElectricPotentialChangeRate FromMillivoltsPerHours(QuantityValue m double value = (double) millivoltsperhours; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerHour); } + /// /// Creates a from . /// @@ -537,6 +550,7 @@ public static ElectricPotentialChangeRate FromMillivoltsPerMicroseconds(Quantity double value = (double) millivoltspermicroseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond); } + /// /// Creates a from . /// @@ -546,6 +560,7 @@ public static ElectricPotentialChangeRate FromMillivoltsPerMinutes(QuantityValue double value = (double) millivoltsperminutes; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerMinute); } + /// /// Creates a from . /// @@ -555,6 +570,7 @@ public static ElectricPotentialChangeRate FromMillivoltsPerSeconds(QuantityValue double value = (double) millivoltsperseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerSecond); } + /// /// Creates a from . /// @@ -564,6 +580,7 @@ public static ElectricPotentialChangeRate FromVoltsPerHours(QuantityValue voltsp double value = (double) voltsperhours; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerHour); } + /// /// Creates a from . /// @@ -573,6 +590,7 @@ public static ElectricPotentialChangeRate FromVoltsPerMicroseconds(QuantityValue double value = (double) voltspermicroseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerMicrosecond); } + /// /// Creates a from . /// @@ -582,6 +600,7 @@ public static ElectricPotentialChangeRate FromVoltsPerMinutes(QuantityValue volt double value = (double) voltsperminutes; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerMinute); } + /// /// Creates a from . /// @@ -592,6 +611,7 @@ public static ElectricPotentialChangeRate FromVoltsPerSeconds(QuantityValue volt return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerSecond); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.g.cs index 4e1b0e3b3b..09128b2ad3 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.g.cs @@ -285,6 +285,7 @@ public static ElectricPotentialDc FromKilovoltsDc(QuantityValue kilovoltsdc) double value = (double) kilovoltsdc; return new ElectricPotentialDc(value, ElectricPotentialDcUnit.KilovoltDc); } + /// /// Creates a from . /// @@ -294,6 +295,7 @@ public static ElectricPotentialDc FromMegavoltsDc(QuantityValue megavoltsdc) double value = (double) megavoltsdc; return new ElectricPotentialDc(value, ElectricPotentialDcUnit.MegavoltDc); } + /// /// Creates a from . /// @@ -303,6 +305,7 @@ public static ElectricPotentialDc FromMicrovoltsDc(QuantityValue microvoltsdc) double value = (double) microvoltsdc; return new ElectricPotentialDc(value, ElectricPotentialDcUnit.MicrovoltDc); } + /// /// Creates a from . /// @@ -312,6 +315,7 @@ public static ElectricPotentialDc FromMillivoltsDc(QuantityValue millivoltsdc) double value = (double) millivoltsdc; return new ElectricPotentialDc(value, ElectricPotentialDcUnit.MillivoltDc); } + /// /// Creates a from . /// @@ -322,6 +326,7 @@ public static ElectricPotentialDc FromVoltsDc(QuantityValue voltsdc) return new ElectricPotentialDc(value, ElectricPotentialDcUnit.VoltDc); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs index 45ac788eea..e44d9fa9d3 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs @@ -294,6 +294,7 @@ public static ElectricResistance FromGigaohms(QuantityValue gigaohms) double value = (double) gigaohms; return new ElectricResistance(value, ElectricResistanceUnit.Gigaohm); } + /// /// Creates a from . /// @@ -303,6 +304,7 @@ public static ElectricResistance FromKiloohms(QuantityValue kiloohms) double value = (double) kiloohms; return new ElectricResistance(value, ElectricResistanceUnit.Kiloohm); } + /// /// Creates a from . /// @@ -312,6 +314,7 @@ public static ElectricResistance FromMegaohms(QuantityValue megaohms) double value = (double) megaohms; return new ElectricResistance(value, ElectricResistanceUnit.Megaohm); } + /// /// Creates a from . /// @@ -321,6 +324,7 @@ public static ElectricResistance FromMicroohms(QuantityValue microohms) double value = (double) microohms; return new ElectricResistance(value, ElectricResistanceUnit.Microohm); } + /// /// Creates a from . /// @@ -330,6 +334,7 @@ public static ElectricResistance FromMilliohms(QuantityValue milliohms) double value = (double) milliohms; return new ElectricResistance(value, ElectricResistanceUnit.Milliohm); } + /// /// Creates a from . /// @@ -340,6 +345,7 @@ public static ElectricResistance FromOhms(QuantityValue ohms) return new ElectricResistance(value, ElectricResistanceUnit.Ohm); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs index a83e90cddf..8bfdffaa9d 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs @@ -369,6 +369,7 @@ public static ElectricResistivity FromKiloohmsCentimeter(QuantityValue kiloohmsc double value = (double) kiloohmscentimeter; return new ElectricResistivity(value, ElectricResistivityUnit.KiloohmCentimeter); } + /// /// Creates a from . /// @@ -378,6 +379,7 @@ public static ElectricResistivity FromKiloohmMeters(QuantityValue kiloohmmeters) double value = (double) kiloohmmeters; return new ElectricResistivity(value, ElectricResistivityUnit.KiloohmMeter); } + /// /// Creates a from . /// @@ -387,6 +389,7 @@ public static ElectricResistivity FromMegaohmsCentimeter(QuantityValue megaohmsc double value = (double) megaohmscentimeter; return new ElectricResistivity(value, ElectricResistivityUnit.MegaohmCentimeter); } + /// /// Creates a from . /// @@ -396,6 +399,7 @@ public static ElectricResistivity FromMegaohmMeters(QuantityValue megaohmmeters) double value = (double) megaohmmeters; return new ElectricResistivity(value, ElectricResistivityUnit.MegaohmMeter); } + /// /// Creates a from . /// @@ -405,6 +409,7 @@ public static ElectricResistivity FromMicroohmsCentimeter(QuantityValue microohm double value = (double) microohmscentimeter; return new ElectricResistivity(value, ElectricResistivityUnit.MicroohmCentimeter); } + /// /// Creates a from . /// @@ -414,6 +419,7 @@ public static ElectricResistivity FromMicroohmMeters(QuantityValue microohmmeter double value = (double) microohmmeters; return new ElectricResistivity(value, ElectricResistivityUnit.MicroohmMeter); } + /// /// Creates a from . /// @@ -423,6 +429,7 @@ public static ElectricResistivity FromMilliohmsCentimeter(QuantityValue milliohm double value = (double) milliohmscentimeter; return new ElectricResistivity(value, ElectricResistivityUnit.MilliohmCentimeter); } + /// /// Creates a from . /// @@ -432,6 +439,7 @@ public static ElectricResistivity FromMilliohmMeters(QuantityValue milliohmmeter double value = (double) milliohmmeters; return new ElectricResistivity(value, ElectricResistivityUnit.MilliohmMeter); } + /// /// Creates a from . /// @@ -441,6 +449,7 @@ public static ElectricResistivity FromNanoohmsCentimeter(QuantityValue nanoohmsc double value = (double) nanoohmscentimeter; return new ElectricResistivity(value, ElectricResistivityUnit.NanoohmCentimeter); } + /// /// Creates a from . /// @@ -450,6 +459,7 @@ public static ElectricResistivity FromNanoohmMeters(QuantityValue nanoohmmeters) double value = (double) nanoohmmeters; return new ElectricResistivity(value, ElectricResistivityUnit.NanoohmMeter); } + /// /// Creates a from . /// @@ -459,6 +469,7 @@ public static ElectricResistivity FromOhmsCentimeter(QuantityValue ohmscentimete double value = (double) ohmscentimeter; return new ElectricResistivity(value, ElectricResistivityUnit.OhmCentimeter); } + /// /// Creates a from . /// @@ -468,6 +479,7 @@ public static ElectricResistivity FromOhmMeters(QuantityValue ohmmeters) double value = (double) ohmmeters; return new ElectricResistivity(value, ElectricResistivityUnit.OhmMeter); } + /// /// Creates a from . /// @@ -477,6 +489,7 @@ public static ElectricResistivity FromPicoohmsCentimeter(QuantityValue picoohmsc double value = (double) picoohmscentimeter; return new ElectricResistivity(value, ElectricResistivityUnit.PicoohmCentimeter); } + /// /// Creates a from . /// @@ -487,6 +500,7 @@ public static ElectricResistivity FromPicoohmMeters(QuantityValue picoohmmeters) return new ElectricResistivity(value, ElectricResistivityUnit.PicoohmMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs index 8051b671d2..edfc905061 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs @@ -270,6 +270,7 @@ public static ElectricSurfaceChargeDensity FromCoulombsPerSquareCentimeter(Quant double value = (double) coulombspersquarecentimeter; return new ElectricSurfaceChargeDensity(value, ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter); } + /// /// Creates a from . /// @@ -279,6 +280,7 @@ public static ElectricSurfaceChargeDensity FromCoulombsPerSquareInch(QuantityVal double value = (double) coulombspersquareinch; return new ElectricSurfaceChargeDensity(value, ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch); } + /// /// Creates a from . /// @@ -289,6 +291,7 @@ public static ElectricSurfaceChargeDensity FromCoulombsPerSquareMeter(QuantityVa return new ElectricSurfaceChargeDensity(value, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Energy.g.cs b/UnitsNet/GeneratedCode/Quantities/Energy.g.cs index d88081e48c..8ff13fe246 100644 --- a/UnitsNet/GeneratedCode/Quantities/Energy.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Energy.g.cs @@ -585,6 +585,7 @@ public static Energy FromBritishThermalUnits(QuantityValue britishthermalunits) double value = (double) britishthermalunits; return new Energy(value, EnergyUnit.BritishThermalUnit); } + /// /// Creates a from . /// @@ -594,6 +595,7 @@ public static Energy FromCalories(QuantityValue calories) double value = (double) calories; return new Energy(value, EnergyUnit.Calorie); } + /// /// Creates a from . /// @@ -603,6 +605,7 @@ public static Energy FromDecathermsEc(QuantityValue decathermsec) double value = (double) decathermsec; return new Energy(value, EnergyUnit.DecathermEc); } + /// /// Creates a from . /// @@ -612,6 +615,7 @@ public static Energy FromDecathermsImperial(QuantityValue decathermsimperial) double value = (double) decathermsimperial; return new Energy(value, EnergyUnit.DecathermImperial); } + /// /// Creates a from . /// @@ -621,6 +625,7 @@ public static Energy FromDecathermsUs(QuantityValue decathermsus) double value = (double) decathermsus; return new Energy(value, EnergyUnit.DecathermUs); } + /// /// Creates a from . /// @@ -630,6 +635,7 @@ public static Energy FromElectronVolts(QuantityValue electronvolts) double value = (double) electronvolts; return new Energy(value, EnergyUnit.ElectronVolt); } + /// /// Creates a from . /// @@ -639,6 +645,7 @@ public static Energy FromErgs(QuantityValue ergs) double value = (double) ergs; return new Energy(value, EnergyUnit.Erg); } + /// /// Creates a from . /// @@ -648,6 +655,7 @@ public static Energy FromFootPounds(QuantityValue footpounds) double value = (double) footpounds; return new Energy(value, EnergyUnit.FootPound); } + /// /// Creates a from . /// @@ -657,6 +665,7 @@ public static Energy FromGigabritishThermalUnits(QuantityValue gigabritishtherma double value = (double) gigabritishthermalunits; return new Energy(value, EnergyUnit.GigabritishThermalUnit); } + /// /// Creates a from . /// @@ -666,6 +675,7 @@ public static Energy FromGigaelectronVolts(QuantityValue gigaelectronvolts) double value = (double) gigaelectronvolts; return new Energy(value, EnergyUnit.GigaelectronVolt); } + /// /// Creates a from . /// @@ -675,6 +685,7 @@ public static Energy FromGigajoules(QuantityValue gigajoules) double value = (double) gigajoules; return new Energy(value, EnergyUnit.Gigajoule); } + /// /// Creates a from . /// @@ -684,6 +695,7 @@ public static Energy FromGigawattDays(QuantityValue gigawattdays) double value = (double) gigawattdays; return new Energy(value, EnergyUnit.GigawattDay); } + /// /// Creates a from . /// @@ -693,6 +705,7 @@ public static Energy FromGigawattHours(QuantityValue gigawatthours) double value = (double) gigawatthours; return new Energy(value, EnergyUnit.GigawattHour); } + /// /// Creates a from . /// @@ -702,6 +715,7 @@ public static Energy FromHorsepowerHours(QuantityValue horsepowerhours) double value = (double) horsepowerhours; return new Energy(value, EnergyUnit.HorsepowerHour); } + /// /// Creates a from . /// @@ -711,6 +725,7 @@ public static Energy FromJoules(QuantityValue joules) double value = (double) joules; return new Energy(value, EnergyUnit.Joule); } + /// /// Creates a from . /// @@ -720,6 +735,7 @@ public static Energy FromKilobritishThermalUnits(QuantityValue kilobritishtherma double value = (double) kilobritishthermalunits; return new Energy(value, EnergyUnit.KilobritishThermalUnit); } + /// /// Creates a from . /// @@ -729,6 +745,7 @@ public static Energy FromKilocalories(QuantityValue kilocalories) double value = (double) kilocalories; return new Energy(value, EnergyUnit.Kilocalorie); } + /// /// Creates a from . /// @@ -738,6 +755,7 @@ public static Energy FromKiloelectronVolts(QuantityValue kiloelectronvolts) double value = (double) kiloelectronvolts; return new Energy(value, EnergyUnit.KiloelectronVolt); } + /// /// Creates a from . /// @@ -747,6 +765,7 @@ public static Energy FromKilojoules(QuantityValue kilojoules) double value = (double) kilojoules; return new Energy(value, EnergyUnit.Kilojoule); } + /// /// Creates a from . /// @@ -756,6 +775,7 @@ public static Energy FromKilowattDays(QuantityValue kilowattdays) double value = (double) kilowattdays; return new Energy(value, EnergyUnit.KilowattDay); } + /// /// Creates a from . /// @@ -765,6 +785,7 @@ public static Energy FromKilowattHours(QuantityValue kilowatthours) double value = (double) kilowatthours; return new Energy(value, EnergyUnit.KilowattHour); } + /// /// Creates a from . /// @@ -774,6 +795,7 @@ public static Energy FromMegabritishThermalUnits(QuantityValue megabritishtherma double value = (double) megabritishthermalunits; return new Energy(value, EnergyUnit.MegabritishThermalUnit); } + /// /// Creates a from . /// @@ -783,6 +805,7 @@ public static Energy FromMegacalories(QuantityValue megacalories) double value = (double) megacalories; return new Energy(value, EnergyUnit.Megacalorie); } + /// /// Creates a from . /// @@ -792,6 +815,7 @@ public static Energy FromMegaelectronVolts(QuantityValue megaelectronvolts) double value = (double) megaelectronvolts; return new Energy(value, EnergyUnit.MegaelectronVolt); } + /// /// Creates a from . /// @@ -801,6 +825,7 @@ public static Energy FromMegajoules(QuantityValue megajoules) double value = (double) megajoules; return new Energy(value, EnergyUnit.Megajoule); } + /// /// Creates a from . /// @@ -810,6 +835,7 @@ public static Energy FromMegawattDays(QuantityValue megawattdays) double value = (double) megawattdays; return new Energy(value, EnergyUnit.MegawattDay); } + /// /// Creates a from . /// @@ -819,6 +845,7 @@ public static Energy FromMegawattHours(QuantityValue megawatthours) double value = (double) megawatthours; return new Energy(value, EnergyUnit.MegawattHour); } + /// /// Creates a from . /// @@ -828,6 +855,7 @@ public static Energy FromMillijoules(QuantityValue millijoules) double value = (double) millijoules; return new Energy(value, EnergyUnit.Millijoule); } + /// /// Creates a from . /// @@ -837,6 +865,7 @@ public static Energy FromTeraelectronVolts(QuantityValue teraelectronvolts) double value = (double) teraelectronvolts; return new Energy(value, EnergyUnit.TeraelectronVolt); } + /// /// Creates a from . /// @@ -846,6 +875,7 @@ public static Energy FromTerawattDays(QuantityValue terawattdays) double value = (double) terawattdays; return new Energy(value, EnergyUnit.TerawattDay); } + /// /// Creates a from . /// @@ -855,6 +885,7 @@ public static Energy FromTerawattHours(QuantityValue terawatthours) double value = (double) terawatthours; return new Energy(value, EnergyUnit.TerawattHour); } + /// /// Creates a from . /// @@ -864,6 +895,7 @@ public static Energy FromThermsEc(QuantityValue thermsec) double value = (double) thermsec; return new Energy(value, EnergyUnit.ThermEc); } + /// /// Creates a from . /// @@ -873,6 +905,7 @@ public static Energy FromThermsImperial(QuantityValue thermsimperial) double value = (double) thermsimperial; return new Energy(value, EnergyUnit.ThermImperial); } + /// /// Creates a from . /// @@ -882,6 +915,7 @@ public static Energy FromThermsUs(QuantityValue thermsus) double value = (double) thermsus; return new Energy(value, EnergyUnit.ThermUs); } + /// /// Creates a from . /// @@ -891,6 +925,7 @@ public static Energy FromWattDays(QuantityValue wattdays) double value = (double) wattdays; return new Energy(value, EnergyUnit.WattDay); } + /// /// Creates a from . /// @@ -901,6 +936,7 @@ public static Energy FromWattHours(QuantityValue watthours) return new Energy(value, EnergyUnit.WattHour); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs b/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs index 034b6882c1..9f32d7ef58 100644 --- a/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs @@ -303,6 +303,7 @@ public static Entropy FromCaloriesPerKelvin(QuantityValue caloriesperkelvin) double value = (double) caloriesperkelvin; return new Entropy(value, EntropyUnit.CaloriePerKelvin); } + /// /// Creates a from . /// @@ -312,6 +313,7 @@ public static Entropy FromJoulesPerDegreeCelsius(QuantityValue joulesperdegreece double value = (double) joulesperdegreecelsius; return new Entropy(value, EntropyUnit.JoulePerDegreeCelsius); } + /// /// Creates a from . /// @@ -321,6 +323,7 @@ public static Entropy FromJoulesPerKelvin(QuantityValue joulesperkelvin) double value = (double) joulesperkelvin; return new Entropy(value, EntropyUnit.JoulePerKelvin); } + /// /// Creates a from . /// @@ -330,6 +333,7 @@ public static Entropy FromKilocaloriesPerKelvin(QuantityValue kilocaloriesperkel double value = (double) kilocaloriesperkelvin; return new Entropy(value, EntropyUnit.KilocaloriePerKelvin); } + /// /// Creates a from . /// @@ -339,6 +343,7 @@ public static Entropy FromKilojoulesPerDegreeCelsius(QuantityValue kilojoulesper double value = (double) kilojoulesperdegreecelsius; return new Entropy(value, EntropyUnit.KilojoulePerDegreeCelsius); } + /// /// Creates a from . /// @@ -348,6 +353,7 @@ public static Entropy FromKilojoulesPerKelvin(QuantityValue kilojoulesperkelvin) double value = (double) kilojoulesperkelvin; return new Entropy(value, EntropyUnit.KilojoulePerKelvin); } + /// /// Creates a from . /// @@ -358,6 +364,7 @@ public static Entropy FromMegajoulesPerKelvin(QuantityValue megajoulesperkelvin) return new Entropy(value, EntropyUnit.MegajoulePerKelvin); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Force.g.cs b/UnitsNet/GeneratedCode/Quantities/Force.g.cs index cc5e9a4a78..5b14c38642 100644 --- a/UnitsNet/GeneratedCode/Quantities/Force.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Force.g.cs @@ -388,6 +388,7 @@ public static Force FromDecanewtons(QuantityValue decanewtons) double value = (double) decanewtons; return new Force(value, ForceUnit.Decanewton); } + /// /// Creates a from . /// @@ -397,6 +398,7 @@ public static Force FromDyne(QuantityValue dyne) double value = (double) dyne; return new Force(value, ForceUnit.Dyn); } + /// /// Creates a from . /// @@ -406,6 +408,7 @@ public static Force FromKilogramsForce(QuantityValue kilogramsforce) double value = (double) kilogramsforce; return new Force(value, ForceUnit.KilogramForce); } + /// /// Creates a from . /// @@ -415,6 +418,7 @@ public static Force FromKilonewtons(QuantityValue kilonewtons) double value = (double) kilonewtons; return new Force(value, ForceUnit.Kilonewton); } + /// /// Creates a from . /// @@ -424,6 +428,7 @@ public static Force FromKiloPonds(QuantityValue kiloponds) double value = (double) kiloponds; return new Force(value, ForceUnit.KiloPond); } + /// /// Creates a from . /// @@ -433,6 +438,7 @@ public static Force FromKilopoundsForce(QuantityValue kilopoundsforce) double value = (double) kilopoundsforce; return new Force(value, ForceUnit.KilopoundForce); } + /// /// Creates a from . /// @@ -442,6 +448,7 @@ public static Force FromMeganewtons(QuantityValue meganewtons) double value = (double) meganewtons; return new Force(value, ForceUnit.Meganewton); } + /// /// Creates a from . /// @@ -451,6 +458,7 @@ public static Force FromMicronewtons(QuantityValue micronewtons) double value = (double) micronewtons; return new Force(value, ForceUnit.Micronewton); } + /// /// Creates a from . /// @@ -460,6 +468,7 @@ public static Force FromMillinewtons(QuantityValue millinewtons) double value = (double) millinewtons; return new Force(value, ForceUnit.Millinewton); } + /// /// Creates a from . /// @@ -469,6 +478,7 @@ public static Force FromNewtons(QuantityValue newtons) double value = (double) newtons; return new Force(value, ForceUnit.Newton); } + /// /// Creates a from . /// @@ -478,6 +488,7 @@ public static Force FromOunceForce(QuantityValue ounceforce) double value = (double) ounceforce; return new Force(value, ForceUnit.OunceForce); } + /// /// Creates a from . /// @@ -487,6 +498,7 @@ public static Force FromPoundals(QuantityValue poundals) double value = (double) poundals; return new Force(value, ForceUnit.Poundal); } + /// /// Creates a from . /// @@ -496,6 +508,7 @@ public static Force FromPoundsForce(QuantityValue poundsforce) double value = (double) poundsforce; return new Force(value, ForceUnit.PoundForce); } + /// /// Creates a from . /// @@ -505,6 +518,7 @@ public static Force FromShortTonsForce(QuantityValue shorttonsforce) double value = (double) shorttonsforce; return new Force(value, ForceUnit.ShortTonForce); } + /// /// Creates a from . /// @@ -515,6 +529,7 @@ public static Force FromTonnesForce(QuantityValue tonnesforce) return new Force(value, ForceUnit.TonneForce); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs index d77dbcfe17..66a8ceff97 100644 --- a/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs @@ -375,6 +375,7 @@ public static ForceChangeRate FromCentinewtonsPerSecond(QuantityValue centinewto double value = (double) centinewtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.CentinewtonPerSecond); } + /// /// Creates a from . /// @@ -384,6 +385,7 @@ public static ForceChangeRate FromDecanewtonsPerMinute(QuantityValue decanewtons double value = (double) decanewtonsperminute; return new ForceChangeRate(value, ForceChangeRateUnit.DecanewtonPerMinute); } + /// /// Creates a from . /// @@ -393,6 +395,7 @@ public static ForceChangeRate FromDecanewtonsPerSecond(QuantityValue decanewtons double value = (double) decanewtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.DecanewtonPerSecond); } + /// /// Creates a from . /// @@ -402,6 +405,7 @@ public static ForceChangeRate FromDecinewtonsPerSecond(QuantityValue decinewtons double value = (double) decinewtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.DecinewtonPerSecond); } + /// /// Creates a from . /// @@ -411,6 +415,7 @@ public static ForceChangeRate FromKilonewtonsPerMinute(QuantityValue kilonewtons double value = (double) kilonewtonsperminute; return new ForceChangeRate(value, ForceChangeRateUnit.KilonewtonPerMinute); } + /// /// Creates a from . /// @@ -420,6 +425,7 @@ public static ForceChangeRate FromKilonewtonsPerSecond(QuantityValue kilonewtons double value = (double) kilonewtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.KilonewtonPerSecond); } + /// /// Creates a from . /// @@ -429,6 +435,7 @@ public static ForceChangeRate FromKilopoundsForcePerMinute(QuantityValue kilopou double value = (double) kilopoundsforceperminute; return new ForceChangeRate(value, ForceChangeRateUnit.KilopoundForcePerMinute); } + /// /// Creates a from . /// @@ -438,6 +445,7 @@ public static ForceChangeRate FromKilopoundsForcePerSecond(QuantityValue kilopou double value = (double) kilopoundsforcepersecond; return new ForceChangeRate(value, ForceChangeRateUnit.KilopoundForcePerSecond); } + /// /// Creates a from . /// @@ -447,6 +455,7 @@ public static ForceChangeRate FromMicronewtonsPerSecond(QuantityValue micronewto double value = (double) micronewtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.MicronewtonPerSecond); } + /// /// Creates a from . /// @@ -456,6 +465,7 @@ public static ForceChangeRate FromMillinewtonsPerSecond(QuantityValue millinewto double value = (double) millinewtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.MillinewtonPerSecond); } + /// /// Creates a from . /// @@ -465,6 +475,7 @@ public static ForceChangeRate FromNanonewtonsPerSecond(QuantityValue nanonewtons double value = (double) nanonewtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.NanonewtonPerSecond); } + /// /// Creates a from . /// @@ -474,6 +485,7 @@ public static ForceChangeRate FromNewtonsPerMinute(QuantityValue newtonsperminut double value = (double) newtonsperminute; return new ForceChangeRate(value, ForceChangeRateUnit.NewtonPerMinute); } + /// /// Creates a from . /// @@ -483,6 +495,7 @@ public static ForceChangeRate FromNewtonsPerSecond(QuantityValue newtonspersecon double value = (double) newtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.NewtonPerSecond); } + /// /// Creates a from . /// @@ -492,6 +505,7 @@ public static ForceChangeRate FromPoundsForcePerMinute(QuantityValue poundsforce double value = (double) poundsforceperminute; return new ForceChangeRate(value, ForceChangeRateUnit.PoundForcePerMinute); } + /// /// Creates a from . /// @@ -502,6 +516,7 @@ public static ForceChangeRate FromPoundsForcePerSecond(QuantityValue poundsforce return new ForceChangeRate(value, ForceChangeRateUnit.PoundForcePerSecond); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs index 9146801f5f..ceae2942ab 100644 --- a/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs @@ -588,6 +588,7 @@ public static ForcePerLength FromCentinewtonsPerCentimeter(QuantityValue centine double value = (double) centinewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.CentinewtonPerCentimeter); } + /// /// Creates a from . /// @@ -597,6 +598,7 @@ public static ForcePerLength FromCentinewtonsPerMeter(QuantityValue centinewtons double value = (double) centinewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.CentinewtonPerMeter); } + /// /// Creates a from . /// @@ -606,6 +608,7 @@ public static ForcePerLength FromCentinewtonsPerMillimeter(QuantityValue centine double value = (double) centinewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.CentinewtonPerMillimeter); } + /// /// Creates a from . /// @@ -615,6 +618,7 @@ public static ForcePerLength FromDecanewtonsPerCentimeter(QuantityValue decanewt double value = (double) decanewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.DecanewtonPerCentimeter); } + /// /// Creates a from . /// @@ -624,6 +628,7 @@ public static ForcePerLength FromDecanewtonsPerMeter(QuantityValue decanewtonspe double value = (double) decanewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.DecanewtonPerMeter); } + /// /// Creates a from . /// @@ -633,6 +638,7 @@ public static ForcePerLength FromDecanewtonsPerMillimeter(QuantityValue decanewt double value = (double) decanewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.DecanewtonPerMillimeter); } + /// /// Creates a from . /// @@ -642,6 +648,7 @@ public static ForcePerLength FromDecinewtonsPerCentimeter(QuantityValue decinewt double value = (double) decinewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.DecinewtonPerCentimeter); } + /// /// Creates a from . /// @@ -651,6 +658,7 @@ public static ForcePerLength FromDecinewtonsPerMeter(QuantityValue decinewtonspe double value = (double) decinewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.DecinewtonPerMeter); } + /// /// Creates a from . /// @@ -660,6 +668,7 @@ public static ForcePerLength FromDecinewtonsPerMillimeter(QuantityValue decinewt double value = (double) decinewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.DecinewtonPerMillimeter); } + /// /// Creates a from . /// @@ -669,6 +678,7 @@ public static ForcePerLength FromKilogramsForcePerCentimeter(QuantityValue kilog double value = (double) kilogramsforcepercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.KilogramForcePerCentimeter); } + /// /// Creates a from . /// @@ -678,6 +688,7 @@ public static ForcePerLength FromKilogramsForcePerMeter(QuantityValue kilogramsf double value = (double) kilogramsforcepermeter; return new ForcePerLength(value, ForcePerLengthUnit.KilogramForcePerMeter); } + /// /// Creates a from . /// @@ -687,6 +698,7 @@ public static ForcePerLength FromKilogramsForcePerMillimeter(QuantityValue kilog double value = (double) kilogramsforcepermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.KilogramForcePerMillimeter); } + /// /// Creates a from . /// @@ -696,6 +708,7 @@ public static ForcePerLength FromKilonewtonsPerCentimeter(QuantityValue kilonewt double value = (double) kilonewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.KilonewtonPerCentimeter); } + /// /// Creates a from . /// @@ -705,6 +718,7 @@ public static ForcePerLength FromKilonewtonsPerMeter(QuantityValue kilonewtonspe double value = (double) kilonewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.KilonewtonPerMeter); } + /// /// Creates a from . /// @@ -714,6 +728,7 @@ public static ForcePerLength FromKilonewtonsPerMillimeter(QuantityValue kilonewt double value = (double) kilonewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.KilonewtonPerMillimeter); } + /// /// Creates a from . /// @@ -723,6 +738,7 @@ public static ForcePerLength FromKilopoundsForcePerFoot(QuantityValue kilopounds double value = (double) kilopoundsforceperfoot; return new ForcePerLength(value, ForcePerLengthUnit.KilopoundForcePerFoot); } + /// /// Creates a from . /// @@ -732,6 +748,7 @@ public static ForcePerLength FromKilopoundsForcePerInch(QuantityValue kilopounds double value = (double) kilopoundsforceperinch; return new ForcePerLength(value, ForcePerLengthUnit.KilopoundForcePerInch); } + /// /// Creates a from . /// @@ -741,6 +758,7 @@ public static ForcePerLength FromMeganewtonsPerCentimeter(QuantityValue meganewt double value = (double) meganewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.MeganewtonPerCentimeter); } + /// /// Creates a from . /// @@ -750,6 +768,7 @@ public static ForcePerLength FromMeganewtonsPerMeter(QuantityValue meganewtonspe double value = (double) meganewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.MeganewtonPerMeter); } + /// /// Creates a from . /// @@ -759,6 +778,7 @@ public static ForcePerLength FromMeganewtonsPerMillimeter(QuantityValue meganewt double value = (double) meganewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.MeganewtonPerMillimeter); } + /// /// Creates a from . /// @@ -768,6 +788,7 @@ public static ForcePerLength FromMicronewtonsPerCentimeter(QuantityValue microne double value = (double) micronewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.MicronewtonPerCentimeter); } + /// /// Creates a from . /// @@ -777,6 +798,7 @@ public static ForcePerLength FromMicronewtonsPerMeter(QuantityValue micronewtons double value = (double) micronewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.MicronewtonPerMeter); } + /// /// Creates a from . /// @@ -786,6 +808,7 @@ public static ForcePerLength FromMicronewtonsPerMillimeter(QuantityValue microne double value = (double) micronewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.MicronewtonPerMillimeter); } + /// /// Creates a from . /// @@ -795,6 +818,7 @@ public static ForcePerLength FromMillinewtonsPerCentimeter(QuantityValue milline double value = (double) millinewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.MillinewtonPerCentimeter); } + /// /// Creates a from . /// @@ -804,6 +828,7 @@ public static ForcePerLength FromMillinewtonsPerMeter(QuantityValue millinewtons double value = (double) millinewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.MillinewtonPerMeter); } + /// /// Creates a from . /// @@ -813,6 +838,7 @@ public static ForcePerLength FromMillinewtonsPerMillimeter(QuantityValue milline double value = (double) millinewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.MillinewtonPerMillimeter); } + /// /// Creates a from . /// @@ -822,6 +848,7 @@ public static ForcePerLength FromNanonewtonsPerCentimeter(QuantityValue nanonewt double value = (double) nanonewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.NanonewtonPerCentimeter); } + /// /// Creates a from . /// @@ -831,6 +858,7 @@ public static ForcePerLength FromNanonewtonsPerMeter(QuantityValue nanonewtonspe double value = (double) nanonewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.NanonewtonPerMeter); } + /// /// Creates a from . /// @@ -840,6 +868,7 @@ public static ForcePerLength FromNanonewtonsPerMillimeter(QuantityValue nanonewt double value = (double) nanonewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.NanonewtonPerMillimeter); } + /// /// Creates a from . /// @@ -849,6 +878,7 @@ public static ForcePerLength FromNewtonsPerCentimeter(QuantityValue newtonsperce double value = (double) newtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.NewtonPerCentimeter); } + /// /// Creates a from . /// @@ -858,6 +888,7 @@ public static ForcePerLength FromNewtonsPerMeter(QuantityValue newtonspermeter) double value = (double) newtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.NewtonPerMeter); } + /// /// Creates a from . /// @@ -867,6 +898,7 @@ public static ForcePerLength FromNewtonsPerMillimeter(QuantityValue newtonspermi double value = (double) newtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.NewtonPerMillimeter); } + /// /// Creates a from . /// @@ -876,6 +908,7 @@ public static ForcePerLength FromPoundsForcePerFoot(QuantityValue poundsforceper double value = (double) poundsforceperfoot; return new ForcePerLength(value, ForcePerLengthUnit.PoundForcePerFoot); } + /// /// Creates a from . /// @@ -885,6 +918,7 @@ public static ForcePerLength FromPoundsForcePerInch(QuantityValue poundsforceper double value = (double) poundsforceperinch; return new ForcePerLength(value, ForcePerLengthUnit.PoundForcePerInch); } + /// /// Creates a from . /// @@ -894,6 +928,7 @@ public static ForcePerLength FromPoundsForcePerYard(QuantityValue poundsforceper double value = (double) poundsforceperyard; return new ForcePerLength(value, ForcePerLengthUnit.PoundForcePerYard); } + /// /// Creates a from . /// @@ -903,6 +938,7 @@ public static ForcePerLength FromTonnesForcePerCentimeter(QuantityValue tonnesfo double value = (double) tonnesforcepercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.TonneForcePerCentimeter); } + /// /// Creates a from . /// @@ -912,6 +948,7 @@ public static ForcePerLength FromTonnesForcePerMeter(QuantityValue tonnesforcepe double value = (double) tonnesforcepermeter; return new ForcePerLength(value, ForcePerLengthUnit.TonneForcePerMeter); } + /// /// Creates a from . /// @@ -922,6 +959,7 @@ public static ForcePerLength FromTonnesForcePerMillimeter(QuantityValue tonnesfo return new ForcePerLength(value, ForcePerLengthUnit.TonneForcePerMillimeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs b/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs index 5bd4b610cc..6962aa000f 100644 --- a/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs @@ -346,6 +346,7 @@ public static Frequency FromBeatsPerMinute(QuantityValue beatsperminute) double value = (double) beatsperminute; return new Frequency(value, FrequencyUnit.BeatPerMinute); } + /// /// Creates a from . /// @@ -355,6 +356,7 @@ public static Frequency FromBUnits(QuantityValue bunits) double value = (double) bunits; return new Frequency(value, FrequencyUnit.BUnit); } + /// /// Creates a from . /// @@ -364,6 +366,7 @@ public static Frequency FromCyclesPerHour(QuantityValue cyclesperhour) double value = (double) cyclesperhour; return new Frequency(value, FrequencyUnit.CyclePerHour); } + /// /// Creates a from . /// @@ -373,6 +376,7 @@ public static Frequency FromCyclesPerMinute(QuantityValue cyclesperminute) double value = (double) cyclesperminute; return new Frequency(value, FrequencyUnit.CyclePerMinute); } + /// /// Creates a from . /// @@ -382,6 +386,7 @@ public static Frequency FromGigahertz(QuantityValue gigahertz) double value = (double) gigahertz; return new Frequency(value, FrequencyUnit.Gigahertz); } + /// /// Creates a from . /// @@ -391,6 +396,7 @@ public static Frequency FromHertz(QuantityValue hertz) double value = (double) hertz; return new Frequency(value, FrequencyUnit.Hertz); } + /// /// Creates a from . /// @@ -400,6 +406,7 @@ public static Frequency FromKilohertz(QuantityValue kilohertz) double value = (double) kilohertz; return new Frequency(value, FrequencyUnit.Kilohertz); } + /// /// Creates a from . /// @@ -409,6 +416,7 @@ public static Frequency FromMegahertz(QuantityValue megahertz) double value = (double) megahertz; return new Frequency(value, FrequencyUnit.Megahertz); } + /// /// Creates a from . /// @@ -418,6 +426,7 @@ public static Frequency FromPerSecond(QuantityValue persecond) double value = (double) persecond; return new Frequency(value, FrequencyUnit.PerSecond); } + /// /// Creates a from . /// @@ -427,6 +436,7 @@ public static Frequency FromRadiansPerSecond(QuantityValue radianspersecond) double value = (double) radianspersecond; return new Frequency(value, FrequencyUnit.RadianPerSecond); } + /// /// Creates a from . /// @@ -437,6 +447,7 @@ public static Frequency FromTerahertz(QuantityValue terahertz) return new Frequency(value, FrequencyUnit.Terahertz); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs b/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs index b2763f3bb1..0e8ddf3b32 100644 --- a/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs @@ -279,6 +279,7 @@ public static FuelEfficiency FromKilometersPerLiters(QuantityValue kilometersper double value = (double) kilometersperliters; return new FuelEfficiency(value, FuelEfficiencyUnit.KilometerPerLiter); } + /// /// Creates a from . /// @@ -288,6 +289,7 @@ public static FuelEfficiency FromLitersPer100Kilometers(QuantityValue litersper1 double value = (double) litersper100kilometers; return new FuelEfficiency(value, FuelEfficiencyUnit.LiterPer100Kilometers); } + /// /// Creates a from . /// @@ -297,6 +299,7 @@ public static FuelEfficiency FromMilesPerUkGallon(QuantityValue milesperukgallon double value = (double) milesperukgallon; return new FuelEfficiency(value, FuelEfficiencyUnit.MilePerUkGallon); } + /// /// Creates a from . /// @@ -307,6 +310,7 @@ public static FuelEfficiency FromMilesPerUsGallon(QuantityValue milesperusgallon return new FuelEfficiency(value, FuelEfficiencyUnit.MilePerUsGallon); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs index 0eca49dd08..282570facc 100644 --- a/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs @@ -402,6 +402,7 @@ public static HeatFlux FromBtusPerHourSquareFoot(QuantityValue btusperhoursquare double value = (double) btusperhoursquarefoot; return new HeatFlux(value, HeatFluxUnit.BtuPerHourSquareFoot); } + /// /// Creates a from . /// @@ -411,6 +412,7 @@ public static HeatFlux FromBtusPerMinuteSquareFoot(QuantityValue btusperminutesq double value = (double) btusperminutesquarefoot; return new HeatFlux(value, HeatFluxUnit.BtuPerMinuteSquareFoot); } + /// /// Creates a from . /// @@ -420,6 +422,7 @@ public static HeatFlux FromBtusPerSecondSquareFoot(QuantityValue btuspersecondsq double value = (double) btuspersecondsquarefoot; return new HeatFlux(value, HeatFluxUnit.BtuPerSecondSquareFoot); } + /// /// Creates a from . /// @@ -429,6 +432,7 @@ public static HeatFlux FromBtusPerSecondSquareInch(QuantityValue btuspersecondsq double value = (double) btuspersecondsquareinch; return new HeatFlux(value, HeatFluxUnit.BtuPerSecondSquareInch); } + /// /// Creates a from . /// @@ -438,6 +442,7 @@ public static HeatFlux FromCaloriesPerSecondSquareCentimeter(QuantityValue calor double value = (double) caloriespersecondsquarecentimeter; return new HeatFlux(value, HeatFluxUnit.CaloriePerSecondSquareCentimeter); } + /// /// Creates a from . /// @@ -447,6 +452,7 @@ public static HeatFlux FromCentiwattsPerSquareMeter(QuantityValue centiwattspers double value = (double) centiwattspersquaremeter; return new HeatFlux(value, HeatFluxUnit.CentiwattPerSquareMeter); } + /// /// Creates a from . /// @@ -456,6 +462,7 @@ public static HeatFlux FromDeciwattsPerSquareMeter(QuantityValue deciwattspersqu double value = (double) deciwattspersquaremeter; return new HeatFlux(value, HeatFluxUnit.DeciwattPerSquareMeter); } + /// /// Creates a from . /// @@ -465,6 +472,7 @@ public static HeatFlux FromKilocaloriesPerHourSquareMeter(QuantityValue kilocalo double value = (double) kilocaloriesperhoursquaremeter; return new HeatFlux(value, HeatFluxUnit.KilocaloriePerHourSquareMeter); } + /// /// Creates a from . /// @@ -474,6 +482,7 @@ public static HeatFlux FromKilocaloriesPerSecondSquareCentimeter(QuantityValue k double value = (double) kilocaloriespersecondsquarecentimeter; return new HeatFlux(value, HeatFluxUnit.KilocaloriePerSecondSquareCentimeter); } + /// /// Creates a from . /// @@ -483,6 +492,7 @@ public static HeatFlux FromKilowattsPerSquareMeter(QuantityValue kilowattspersqu double value = (double) kilowattspersquaremeter; return new HeatFlux(value, HeatFluxUnit.KilowattPerSquareMeter); } + /// /// Creates a from . /// @@ -492,6 +502,7 @@ public static HeatFlux FromMicrowattsPerSquareMeter(QuantityValue microwattspers double value = (double) microwattspersquaremeter; return new HeatFlux(value, HeatFluxUnit.MicrowattPerSquareMeter); } + /// /// Creates a from . /// @@ -501,6 +512,7 @@ public static HeatFlux FromMilliwattsPerSquareMeter(QuantityValue milliwattspers double value = (double) milliwattspersquaremeter; return new HeatFlux(value, HeatFluxUnit.MilliwattPerSquareMeter); } + /// /// Creates a from . /// @@ -510,6 +522,7 @@ public static HeatFlux FromNanowattsPerSquareMeter(QuantityValue nanowattspersqu double value = (double) nanowattspersquaremeter; return new HeatFlux(value, HeatFluxUnit.NanowattPerSquareMeter); } + /// /// Creates a from . /// @@ -519,6 +532,7 @@ public static HeatFlux FromPoundsForcePerFootSecond(QuantityValue poundsforceper double value = (double) poundsforceperfootsecond; return new HeatFlux(value, HeatFluxUnit.PoundForcePerFootSecond); } + /// /// Creates a from . /// @@ -528,6 +542,7 @@ public static HeatFlux FromPoundsPerSecondCubed(QuantityValue poundspersecondcub double value = (double) poundspersecondcubed; return new HeatFlux(value, HeatFluxUnit.PoundPerSecondCubed); } + /// /// Creates a from . /// @@ -537,6 +552,7 @@ public static HeatFlux FromWattsPerSquareFoot(QuantityValue wattspersquarefoot) double value = (double) wattspersquarefoot; return new HeatFlux(value, HeatFluxUnit.WattPerSquareFoot); } + /// /// Creates a from . /// @@ -546,6 +562,7 @@ public static HeatFlux FromWattsPerSquareInch(QuantityValue wattspersquareinch) double value = (double) wattspersquareinch; return new HeatFlux(value, HeatFluxUnit.WattPerSquareInch); } + /// /// Creates a from . /// @@ -556,6 +573,7 @@ public static HeatFlux FromWattsPerSquareMeter(QuantityValue wattspersquaremeter return new HeatFlux(value, HeatFluxUnit.WattPerSquareMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs b/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs index 5fb8d1454e..ea0b68f7fb 100644 --- a/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs @@ -267,6 +267,7 @@ public static HeatTransferCoefficient FromBtusPerSquareFootDegreeFahrenheit(Quan double value = (double) btuspersquarefootdegreefahrenheit; return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit); } + /// /// Creates a from . /// @@ -276,6 +277,7 @@ public static HeatTransferCoefficient FromWattsPerSquareMeterCelsius(QuantityVal double value = (double) wattspersquaremetercelsius; return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.WattPerSquareMeterCelsius); } + /// /// Creates a from . /// @@ -286,6 +288,7 @@ public static HeatTransferCoefficient FromWattsPerSquareMeterKelvin(QuantityValu return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs b/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs index d23c4326a8..6731b579bc 100644 --- a/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs @@ -279,6 +279,7 @@ public static Illuminance FromKilolux(QuantityValue kilolux) double value = (double) kilolux; return new Illuminance(value, IlluminanceUnit.Kilolux); } + /// /// Creates a from . /// @@ -288,6 +289,7 @@ public static Illuminance FromLux(QuantityValue lux) double value = (double) lux; return new Illuminance(value, IlluminanceUnit.Lux); } + /// /// Creates a from . /// @@ -297,6 +299,7 @@ public static Illuminance FromMegalux(QuantityValue megalux) double value = (double) megalux; return new Illuminance(value, IlluminanceUnit.Megalux); } + /// /// Creates a from . /// @@ -307,6 +310,7 @@ public static Illuminance FromMillilux(QuantityValue millilux) return new Illuminance(value, IlluminanceUnit.Millilux); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Information.g.cs b/UnitsNet/GeneratedCode/Quantities/Information.g.cs index e567615334..fbc2a8d931 100644 --- a/UnitsNet/GeneratedCode/Quantities/Information.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Information.g.cs @@ -479,6 +479,7 @@ public static Information FromBits(QuantityValue bits) decimal value = (decimal) bits; return new Information(value, InformationUnit.Bit); } + /// /// Creates a from . /// @@ -488,6 +489,7 @@ public static Information FromBytes(QuantityValue bytes) decimal value = (decimal) bytes; return new Information(value, InformationUnit.Byte); } + /// /// Creates a from . /// @@ -497,6 +499,7 @@ public static Information FromExabits(QuantityValue exabits) decimal value = (decimal) exabits; return new Information(value, InformationUnit.Exabit); } + /// /// Creates a from . /// @@ -506,6 +509,7 @@ public static Information FromExabytes(QuantityValue exabytes) decimal value = (decimal) exabytes; return new Information(value, InformationUnit.Exabyte); } + /// /// Creates a from . /// @@ -515,6 +519,7 @@ public static Information FromExbibits(QuantityValue exbibits) decimal value = (decimal) exbibits; return new Information(value, InformationUnit.Exbibit); } + /// /// Creates a from . /// @@ -524,6 +529,7 @@ public static Information FromExbibytes(QuantityValue exbibytes) decimal value = (decimal) exbibytes; return new Information(value, InformationUnit.Exbibyte); } + /// /// Creates a from . /// @@ -533,6 +539,7 @@ public static Information FromGibibits(QuantityValue gibibits) decimal value = (decimal) gibibits; return new Information(value, InformationUnit.Gibibit); } + /// /// Creates a from . /// @@ -542,6 +549,7 @@ public static Information FromGibibytes(QuantityValue gibibytes) decimal value = (decimal) gibibytes; return new Information(value, InformationUnit.Gibibyte); } + /// /// Creates a from . /// @@ -551,6 +559,7 @@ public static Information FromGigabits(QuantityValue gigabits) decimal value = (decimal) gigabits; return new Information(value, InformationUnit.Gigabit); } + /// /// Creates a from . /// @@ -560,6 +569,7 @@ public static Information FromGigabytes(QuantityValue gigabytes) decimal value = (decimal) gigabytes; return new Information(value, InformationUnit.Gigabyte); } + /// /// Creates a from . /// @@ -569,6 +579,7 @@ public static Information FromKibibits(QuantityValue kibibits) decimal value = (decimal) kibibits; return new Information(value, InformationUnit.Kibibit); } + /// /// Creates a from . /// @@ -578,6 +589,7 @@ public static Information FromKibibytes(QuantityValue kibibytes) decimal value = (decimal) kibibytes; return new Information(value, InformationUnit.Kibibyte); } + /// /// Creates a from . /// @@ -587,6 +599,7 @@ public static Information FromKilobits(QuantityValue kilobits) decimal value = (decimal) kilobits; return new Information(value, InformationUnit.Kilobit); } + /// /// Creates a from . /// @@ -596,6 +609,7 @@ public static Information FromKilobytes(QuantityValue kilobytes) decimal value = (decimal) kilobytes; return new Information(value, InformationUnit.Kilobyte); } + /// /// Creates a from . /// @@ -605,6 +619,7 @@ public static Information FromMebibits(QuantityValue mebibits) decimal value = (decimal) mebibits; return new Information(value, InformationUnit.Mebibit); } + /// /// Creates a from . /// @@ -614,6 +629,7 @@ public static Information FromMebibytes(QuantityValue mebibytes) decimal value = (decimal) mebibytes; return new Information(value, InformationUnit.Mebibyte); } + /// /// Creates a from . /// @@ -623,6 +639,7 @@ public static Information FromMegabits(QuantityValue megabits) decimal value = (decimal) megabits; return new Information(value, InformationUnit.Megabit); } + /// /// Creates a from . /// @@ -632,6 +649,7 @@ public static Information FromMegabytes(QuantityValue megabytes) decimal value = (decimal) megabytes; return new Information(value, InformationUnit.Megabyte); } + /// /// Creates a from . /// @@ -641,6 +659,7 @@ public static Information FromPebibits(QuantityValue pebibits) decimal value = (decimal) pebibits; return new Information(value, InformationUnit.Pebibit); } + /// /// Creates a from . /// @@ -650,6 +669,7 @@ public static Information FromPebibytes(QuantityValue pebibytes) decimal value = (decimal) pebibytes; return new Information(value, InformationUnit.Pebibyte); } + /// /// Creates a from . /// @@ -659,6 +679,7 @@ public static Information FromPetabits(QuantityValue petabits) decimal value = (decimal) petabits; return new Information(value, InformationUnit.Petabit); } + /// /// Creates a from . /// @@ -668,6 +689,7 @@ public static Information FromPetabytes(QuantityValue petabytes) decimal value = (decimal) petabytes; return new Information(value, InformationUnit.Petabyte); } + /// /// Creates a from . /// @@ -677,6 +699,7 @@ public static Information FromTebibits(QuantityValue tebibits) decimal value = (decimal) tebibits; return new Information(value, InformationUnit.Tebibit); } + /// /// Creates a from . /// @@ -686,6 +709,7 @@ public static Information FromTebibytes(QuantityValue tebibytes) decimal value = (decimal) tebibytes; return new Information(value, InformationUnit.Tebibyte); } + /// /// Creates a from . /// @@ -695,6 +719,7 @@ public static Information FromTerabits(QuantityValue terabits) decimal value = (decimal) terabits; return new Information(value, InformationUnit.Terabit); } + /// /// Creates a from . /// @@ -705,6 +730,7 @@ public static Information FromTerabytes(QuantityValue terabytes) return new Information(value, InformationUnit.Terabyte); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs b/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs index 2d2688a016..7ed3fd9ecf 100644 --- a/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs @@ -366,6 +366,7 @@ public static Irradiance FromKilowattsPerSquareCentimeter(QuantityValue kilowatt double value = (double) kilowattspersquarecentimeter; return new Irradiance(value, IrradianceUnit.KilowattPerSquareCentimeter); } + /// /// Creates a from . /// @@ -375,6 +376,7 @@ public static Irradiance FromKilowattsPerSquareMeter(QuantityValue kilowattspers double value = (double) kilowattspersquaremeter; return new Irradiance(value, IrradianceUnit.KilowattPerSquareMeter); } + /// /// Creates a from . /// @@ -384,6 +386,7 @@ public static Irradiance FromMegawattsPerSquareCentimeter(QuantityValue megawatt double value = (double) megawattspersquarecentimeter; return new Irradiance(value, IrradianceUnit.MegawattPerSquareCentimeter); } + /// /// Creates a from . /// @@ -393,6 +396,7 @@ public static Irradiance FromMegawattsPerSquareMeter(QuantityValue megawattspers double value = (double) megawattspersquaremeter; return new Irradiance(value, IrradianceUnit.MegawattPerSquareMeter); } + /// /// Creates a from . /// @@ -402,6 +406,7 @@ public static Irradiance FromMicrowattsPerSquareCentimeter(QuantityValue microwa double value = (double) microwattspersquarecentimeter; return new Irradiance(value, IrradianceUnit.MicrowattPerSquareCentimeter); } + /// /// Creates a from . /// @@ -411,6 +416,7 @@ public static Irradiance FromMicrowattsPerSquareMeter(QuantityValue microwattspe double value = (double) microwattspersquaremeter; return new Irradiance(value, IrradianceUnit.MicrowattPerSquareMeter); } + /// /// Creates a from . /// @@ -420,6 +426,7 @@ public static Irradiance FromMilliwattsPerSquareCentimeter(QuantityValue milliwa double value = (double) milliwattspersquarecentimeter; return new Irradiance(value, IrradianceUnit.MilliwattPerSquareCentimeter); } + /// /// Creates a from . /// @@ -429,6 +436,7 @@ public static Irradiance FromMilliwattsPerSquareMeter(QuantityValue milliwattspe double value = (double) milliwattspersquaremeter; return new Irradiance(value, IrradianceUnit.MilliwattPerSquareMeter); } + /// /// Creates a from . /// @@ -438,6 +446,7 @@ public static Irradiance FromNanowattsPerSquareCentimeter(QuantityValue nanowatt double value = (double) nanowattspersquarecentimeter; return new Irradiance(value, IrradianceUnit.NanowattPerSquareCentimeter); } + /// /// Creates a from . /// @@ -447,6 +456,7 @@ public static Irradiance FromNanowattsPerSquareMeter(QuantityValue nanowattspers double value = (double) nanowattspersquaremeter; return new Irradiance(value, IrradianceUnit.NanowattPerSquareMeter); } + /// /// Creates a from . /// @@ -456,6 +466,7 @@ public static Irradiance FromPicowattsPerSquareCentimeter(QuantityValue picowatt double value = (double) picowattspersquarecentimeter; return new Irradiance(value, IrradianceUnit.PicowattPerSquareCentimeter); } + /// /// Creates a from . /// @@ -465,6 +476,7 @@ public static Irradiance FromPicowattsPerSquareMeter(QuantityValue picowattspers double value = (double) picowattspersquaremeter; return new Irradiance(value, IrradianceUnit.PicowattPerSquareMeter); } + /// /// Creates a from . /// @@ -474,6 +486,7 @@ public static Irradiance FromWattsPerSquareCentimeter(QuantityValue wattspersqua double value = (double) wattspersquarecentimeter; return new Irradiance(value, IrradianceUnit.WattPerSquareCentimeter); } + /// /// Creates a from . /// @@ -484,6 +497,7 @@ public static Irradiance FromWattsPerSquareMeter(QuantityValue wattspersquaremet return new Irradiance(value, IrradianceUnit.WattPerSquareMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs b/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs index 1a8d5a5575..7d9fa92b8f 100644 --- a/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs @@ -306,6 +306,7 @@ public static Irradiation FromJoulesPerSquareCentimeter(QuantityValue joulespers double value = (double) joulespersquarecentimeter; return new Irradiation(value, IrradiationUnit.JoulePerSquareCentimeter); } + /// /// Creates a from . /// @@ -315,6 +316,7 @@ public static Irradiation FromJoulesPerSquareMeter(QuantityValue joulespersquare double value = (double) joulespersquaremeter; return new Irradiation(value, IrradiationUnit.JoulePerSquareMeter); } + /// /// Creates a from . /// @@ -324,6 +326,7 @@ public static Irradiation FromJoulesPerSquareMillimeter(QuantityValue joulespers double value = (double) joulespersquaremillimeter; return new Irradiation(value, IrradiationUnit.JoulePerSquareMillimeter); } + /// /// Creates a from . /// @@ -333,6 +336,7 @@ public static Irradiation FromKilojoulesPerSquareMeter(QuantityValue kilojoulesp double value = (double) kilojoulespersquaremeter; return new Irradiation(value, IrradiationUnit.KilojoulePerSquareMeter); } + /// /// Creates a from . /// @@ -342,6 +346,7 @@ public static Irradiation FromKilowattHoursPerSquareMeter(QuantityValue kilowatt double value = (double) kilowatthourspersquaremeter; return new Irradiation(value, IrradiationUnit.KilowattHourPerSquareMeter); } + /// /// Creates a from . /// @@ -351,6 +356,7 @@ public static Irradiation FromMillijoulesPerSquareCentimeter(QuantityValue milli double value = (double) millijoulespersquarecentimeter; return new Irradiation(value, IrradiationUnit.MillijoulePerSquareCentimeter); } + /// /// Creates a from . /// @@ -361,6 +367,7 @@ public static Irradiation FromWattHoursPerSquareMeter(QuantityValue watthoursper return new Irradiation(value, IrradiationUnit.WattHourPerSquareMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs b/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs index 33c1775fef..824a3b4208 100644 --- a/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs @@ -332,6 +332,7 @@ public static KinematicViscosity FromCentistokes(QuantityValue centistokes) double value = (double) centistokes; return new KinematicViscosity(value, KinematicViscosityUnit.Centistokes); } + /// /// Creates a from . /// @@ -341,6 +342,7 @@ public static KinematicViscosity FromDecistokes(QuantityValue decistokes) double value = (double) decistokes; return new KinematicViscosity(value, KinematicViscosityUnit.Decistokes); } + /// /// Creates a from . /// @@ -350,6 +352,7 @@ public static KinematicViscosity FromKilostokes(QuantityValue kilostokes) double value = (double) kilostokes; return new KinematicViscosity(value, KinematicViscosityUnit.Kilostokes); } + /// /// Creates a from . /// @@ -359,6 +362,7 @@ public static KinematicViscosity FromMicrostokes(QuantityValue microstokes) double value = (double) microstokes; return new KinematicViscosity(value, KinematicViscosityUnit.Microstokes); } + /// /// Creates a from . /// @@ -368,6 +372,7 @@ public static KinematicViscosity FromMillistokes(QuantityValue millistokes) double value = (double) millistokes; return new KinematicViscosity(value, KinematicViscosityUnit.Millistokes); } + /// /// Creates a from . /// @@ -377,6 +382,7 @@ public static KinematicViscosity FromNanostokes(QuantityValue nanostokes) double value = (double) nanostokes; return new KinematicViscosity(value, KinematicViscosityUnit.Nanostokes); } + /// /// Creates a from . /// @@ -386,6 +392,7 @@ public static KinematicViscosity FromSquareFeetPerSecond(QuantityValue squarefee double value = (double) squarefeetpersecond; return new KinematicViscosity(value, KinematicViscosityUnit.SquareFootPerSecond); } + /// /// Creates a from . /// @@ -395,6 +402,7 @@ public static KinematicViscosity FromSquareMetersPerSecond(QuantityValue squarem double value = (double) squaremeterspersecond; return new KinematicViscosity(value, KinematicViscosityUnit.SquareMeterPerSecond); } + /// /// Creates a from . /// @@ -405,6 +413,7 @@ public static KinematicViscosity FromStokes(QuantityValue stokes) return new KinematicViscosity(value, KinematicViscosityUnit.Stokes); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/LapseRate.g.cs b/UnitsNet/GeneratedCode/Quantities/LapseRate.g.cs index 477f4015a5..b3a9b7b2a6 100644 --- a/UnitsNet/GeneratedCode/Quantities/LapseRate.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/LapseRate.g.cs @@ -251,6 +251,7 @@ public static LapseRate FromDegreesCelciusPerKilometer(QuantityValue degreescelc return new LapseRate(value, LapseRateUnit.DegreeCelsiusPerKilometer); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Length.g.cs b/UnitsNet/GeneratedCode/Quantities/Length.g.cs index 5d8f63523d..70537e1f49 100644 --- a/UnitsNet/GeneratedCode/Quantities/Length.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Length.g.cs @@ -587,6 +587,7 @@ public static Length FromAngstroms(QuantityValue angstroms) double value = (double) angstroms; return new Length(value, LengthUnit.Angstrom); } + /// /// Creates a from . /// @@ -596,6 +597,7 @@ public static Length FromAstronomicalUnits(QuantityValue astronomicalunits) double value = (double) astronomicalunits; return new Length(value, LengthUnit.AstronomicalUnit); } + /// /// Creates a from . /// @@ -605,6 +607,7 @@ public static Length FromCentimeters(QuantityValue centimeters) double value = (double) centimeters; return new Length(value, LengthUnit.Centimeter); } + /// /// Creates a from . /// @@ -614,6 +617,7 @@ public static Length FromChains(QuantityValue chains) double value = (double) chains; return new Length(value, LengthUnit.Chain); } + /// /// Creates a from . /// @@ -623,6 +627,7 @@ public static Length FromDecameters(QuantityValue decameters) double value = (double) decameters; return new Length(value, LengthUnit.Decameter); } + /// /// Creates a from . /// @@ -632,6 +637,7 @@ public static Length FromDecimeters(QuantityValue decimeters) double value = (double) decimeters; return new Length(value, LengthUnit.Decimeter); } + /// /// Creates a from . /// @@ -641,6 +647,7 @@ public static Length FromDtpPicas(QuantityValue dtppicas) double value = (double) dtppicas; return new Length(value, LengthUnit.DtpPica); } + /// /// Creates a from . /// @@ -650,6 +657,7 @@ public static Length FromDtpPoints(QuantityValue dtppoints) double value = (double) dtppoints; return new Length(value, LengthUnit.DtpPoint); } + /// /// Creates a from . /// @@ -659,6 +667,7 @@ public static Length FromFathoms(QuantityValue fathoms) double value = (double) fathoms; return new Length(value, LengthUnit.Fathom); } + /// /// Creates a from . /// @@ -668,6 +677,7 @@ public static Length FromFeet(QuantityValue feet) double value = (double) feet; return new Length(value, LengthUnit.Foot); } + /// /// Creates a from . /// @@ -677,6 +687,7 @@ public static Length FromHands(QuantityValue hands) double value = (double) hands; return new Length(value, LengthUnit.Hand); } + /// /// Creates a from . /// @@ -686,6 +697,7 @@ public static Length FromHectometers(QuantityValue hectometers) double value = (double) hectometers; return new Length(value, LengthUnit.Hectometer); } + /// /// Creates a from . /// @@ -695,6 +707,7 @@ public static Length FromInches(QuantityValue inches) double value = (double) inches; return new Length(value, LengthUnit.Inch); } + /// /// Creates a from . /// @@ -704,6 +717,7 @@ public static Length FromKilolightYears(QuantityValue kilolightyears) double value = (double) kilolightyears; return new Length(value, LengthUnit.KilolightYear); } + /// /// Creates a from . /// @@ -713,6 +727,7 @@ public static Length FromKilometers(QuantityValue kilometers) double value = (double) kilometers; return new Length(value, LengthUnit.Kilometer); } + /// /// Creates a from . /// @@ -722,6 +737,7 @@ public static Length FromKiloparsecs(QuantityValue kiloparsecs) double value = (double) kiloparsecs; return new Length(value, LengthUnit.Kiloparsec); } + /// /// Creates a from . /// @@ -731,6 +747,7 @@ public static Length FromLightYears(QuantityValue lightyears) double value = (double) lightyears; return new Length(value, LengthUnit.LightYear); } + /// /// Creates a from . /// @@ -740,6 +757,7 @@ public static Length FromMegalightYears(QuantityValue megalightyears) double value = (double) megalightyears; return new Length(value, LengthUnit.MegalightYear); } + /// /// Creates a from . /// @@ -749,6 +767,7 @@ public static Length FromMegaparsecs(QuantityValue megaparsecs) double value = (double) megaparsecs; return new Length(value, LengthUnit.Megaparsec); } + /// /// Creates a from . /// @@ -758,6 +777,7 @@ public static Length FromMeters(QuantityValue meters) double value = (double) meters; return new Length(value, LengthUnit.Meter); } + /// /// Creates a from . /// @@ -767,6 +787,7 @@ public static Length FromMicroinches(QuantityValue microinches) double value = (double) microinches; return new Length(value, LengthUnit.Microinch); } + /// /// Creates a from . /// @@ -776,6 +797,7 @@ public static Length FromMicrometers(QuantityValue micrometers) double value = (double) micrometers; return new Length(value, LengthUnit.Micrometer); } + /// /// Creates a from . /// @@ -785,6 +807,7 @@ public static Length FromMils(QuantityValue mils) double value = (double) mils; return new Length(value, LengthUnit.Mil); } + /// /// Creates a from . /// @@ -794,6 +817,7 @@ public static Length FromMiles(QuantityValue miles) double value = (double) miles; return new Length(value, LengthUnit.Mile); } + /// /// Creates a from . /// @@ -803,6 +827,7 @@ public static Length FromMillimeters(QuantityValue millimeters) double value = (double) millimeters; return new Length(value, LengthUnit.Millimeter); } + /// /// Creates a from . /// @@ -812,6 +837,7 @@ public static Length FromNanometers(QuantityValue nanometers) double value = (double) nanometers; return new Length(value, LengthUnit.Nanometer); } + /// /// Creates a from . /// @@ -821,6 +847,7 @@ public static Length FromNauticalMiles(QuantityValue nauticalmiles) double value = (double) nauticalmiles; return new Length(value, LengthUnit.NauticalMile); } + /// /// Creates a from . /// @@ -830,6 +857,7 @@ public static Length FromParsecs(QuantityValue parsecs) double value = (double) parsecs; return new Length(value, LengthUnit.Parsec); } + /// /// Creates a from . /// @@ -839,6 +867,7 @@ public static Length FromPrinterPicas(QuantityValue printerpicas) double value = (double) printerpicas; return new Length(value, LengthUnit.PrinterPica); } + /// /// Creates a from . /// @@ -848,6 +877,7 @@ public static Length FromPrinterPoints(QuantityValue printerpoints) double value = (double) printerpoints; return new Length(value, LengthUnit.PrinterPoint); } + /// /// Creates a from . /// @@ -857,6 +887,7 @@ public static Length FromShackles(QuantityValue shackles) double value = (double) shackles; return new Length(value, LengthUnit.Shackle); } + /// /// Creates a from . /// @@ -866,6 +897,7 @@ public static Length FromSolarRadiuses(QuantityValue solarradiuses) double value = (double) solarradiuses; return new Length(value, LengthUnit.SolarRadius); } + /// /// Creates a from . /// @@ -875,6 +907,7 @@ public static Length FromTwips(QuantityValue twips) double value = (double) twips; return new Length(value, LengthUnit.Twip); } + /// /// Creates a from . /// @@ -884,6 +917,7 @@ public static Length FromUsSurveyFeet(QuantityValue ussurveyfeet) double value = (double) ussurveyfeet; return new Length(value, LengthUnit.UsSurveyFoot); } + /// /// Creates a from . /// @@ -894,6 +928,7 @@ public static Length FromYards(QuantityValue yards) return new Length(value, LengthUnit.Yard); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Level.g.cs b/UnitsNet/GeneratedCode/Quantities/Level.g.cs index a52491e09b..61c39b64e5 100644 --- a/UnitsNet/GeneratedCode/Quantities/Level.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Level.g.cs @@ -258,6 +258,7 @@ public static Level FromDecibels(QuantityValue decibels) double value = (double) decibels; return new Level(value, LevelUnit.Decibel); } + /// /// Creates a from . /// @@ -268,6 +269,7 @@ public static Level FromNepers(QuantityValue nepers) return new Level(value, LevelUnit.Neper); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs index 70677e6f39..2ac4abeae6 100644 --- a/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs @@ -369,6 +369,7 @@ public static LinearDensity FromGramsPerCentimeter(QuantityValue gramspercentime double value = (double) gramspercentimeter; return new LinearDensity(value, LinearDensityUnit.GramPerCentimeter); } + /// /// Creates a from . /// @@ -378,6 +379,7 @@ public static LinearDensity FromGramsPerMeter(QuantityValue gramspermeter) double value = (double) gramspermeter; return new LinearDensity(value, LinearDensityUnit.GramPerMeter); } + /// /// Creates a from . /// @@ -387,6 +389,7 @@ public static LinearDensity FromGramsPerMillimeter(QuantityValue gramspermillime double value = (double) gramspermillimeter; return new LinearDensity(value, LinearDensityUnit.GramPerMillimeter); } + /// /// Creates a from . /// @@ -396,6 +399,7 @@ public static LinearDensity FromKilogramsPerCentimeter(QuantityValue kilogramspe double value = (double) kilogramspercentimeter; return new LinearDensity(value, LinearDensityUnit.KilogramPerCentimeter); } + /// /// Creates a from . /// @@ -405,6 +409,7 @@ public static LinearDensity FromKilogramsPerMeter(QuantityValue kilogramspermete double value = (double) kilogramspermeter; return new LinearDensity(value, LinearDensityUnit.KilogramPerMeter); } + /// /// Creates a from . /// @@ -414,6 +419,7 @@ public static LinearDensity FromKilogramsPerMillimeter(QuantityValue kilogramspe double value = (double) kilogramspermillimeter; return new LinearDensity(value, LinearDensityUnit.KilogramPerMillimeter); } + /// /// Creates a from . /// @@ -423,6 +429,7 @@ public static LinearDensity FromMicrogramsPerCentimeter(QuantityValue micrograms double value = (double) microgramspercentimeter; return new LinearDensity(value, LinearDensityUnit.MicrogramPerCentimeter); } + /// /// Creates a from . /// @@ -432,6 +439,7 @@ public static LinearDensity FromMicrogramsPerMeter(QuantityValue microgramsperme double value = (double) microgramspermeter; return new LinearDensity(value, LinearDensityUnit.MicrogramPerMeter); } + /// /// Creates a from . /// @@ -441,6 +449,7 @@ public static LinearDensity FromMicrogramsPerMillimeter(QuantityValue micrograms double value = (double) microgramspermillimeter; return new LinearDensity(value, LinearDensityUnit.MicrogramPerMillimeter); } + /// /// Creates a from . /// @@ -450,6 +459,7 @@ public static LinearDensity FromMilligramsPerCentimeter(QuantityValue milligrams double value = (double) milligramspercentimeter; return new LinearDensity(value, LinearDensityUnit.MilligramPerCentimeter); } + /// /// Creates a from . /// @@ -459,6 +469,7 @@ public static LinearDensity FromMilligramsPerMeter(QuantityValue milligramsperme double value = (double) milligramspermeter; return new LinearDensity(value, LinearDensityUnit.MilligramPerMeter); } + /// /// Creates a from . /// @@ -468,6 +479,7 @@ public static LinearDensity FromMilligramsPerMillimeter(QuantityValue milligrams double value = (double) milligramspermillimeter; return new LinearDensity(value, LinearDensityUnit.MilligramPerMillimeter); } + /// /// Creates a from . /// @@ -477,6 +489,7 @@ public static LinearDensity FromPoundsPerFoot(QuantityValue poundsperfoot) double value = (double) poundsperfoot; return new LinearDensity(value, LinearDensityUnit.PoundPerFoot); } + /// /// Creates a from . /// @@ -487,6 +500,7 @@ public static LinearDensity FromPoundsPerInch(QuantityValue poundsperinch) return new LinearDensity(value, LinearDensityUnit.PoundPerInch); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs index 1f6e8dc2b7..8df4e7aa49 100644 --- a/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs @@ -468,6 +468,7 @@ public static LinearPowerDensity FromGigawattsPerCentimeter(QuantityValue gigawa double value = (double) gigawattspercentimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerCentimeter); } + /// /// Creates a from . /// @@ -477,6 +478,7 @@ public static LinearPowerDensity FromGigawattsPerFoot(QuantityValue gigawattsper double value = (double) gigawattsperfoot; return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerFoot); } + /// /// Creates a from . /// @@ -486,6 +488,7 @@ public static LinearPowerDensity FromGigawattsPerInch(QuantityValue gigawattsper double value = (double) gigawattsperinch; return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerInch); } + /// /// Creates a from . /// @@ -495,6 +498,7 @@ public static LinearPowerDensity FromGigawattsPerMeter(QuantityValue gigawattspe double value = (double) gigawattspermeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerMeter); } + /// /// Creates a from . /// @@ -504,6 +508,7 @@ public static LinearPowerDensity FromGigawattsPerMillimeter(QuantityValue gigawa double value = (double) gigawattspermillimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerMillimeter); } + /// /// Creates a from . /// @@ -513,6 +518,7 @@ public static LinearPowerDensity FromKilowattsPerCentimeter(QuantityValue kilowa double value = (double) kilowattspercentimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerCentimeter); } + /// /// Creates a from . /// @@ -522,6 +528,7 @@ public static LinearPowerDensity FromKilowattsPerFoot(QuantityValue kilowattsper double value = (double) kilowattsperfoot; return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerFoot); } + /// /// Creates a from . /// @@ -531,6 +538,7 @@ public static LinearPowerDensity FromKilowattsPerInch(QuantityValue kilowattsper double value = (double) kilowattsperinch; return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerInch); } + /// /// Creates a from . /// @@ -540,6 +548,7 @@ public static LinearPowerDensity FromKilowattsPerMeter(QuantityValue kilowattspe double value = (double) kilowattspermeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerMeter); } + /// /// Creates a from . /// @@ -549,6 +558,7 @@ public static LinearPowerDensity FromKilowattsPerMillimeter(QuantityValue kilowa double value = (double) kilowattspermillimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerMillimeter); } + /// /// Creates a from . /// @@ -558,6 +568,7 @@ public static LinearPowerDensity FromMegawattsPerCentimeter(QuantityValue megawa double value = (double) megawattspercentimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerCentimeter); } + /// /// Creates a from . /// @@ -567,6 +578,7 @@ public static LinearPowerDensity FromMegawattsPerFoot(QuantityValue megawattsper double value = (double) megawattsperfoot; return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerFoot); } + /// /// Creates a from . /// @@ -576,6 +588,7 @@ public static LinearPowerDensity FromMegawattsPerInch(QuantityValue megawattsper double value = (double) megawattsperinch; return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerInch); } + /// /// Creates a from . /// @@ -585,6 +598,7 @@ public static LinearPowerDensity FromMegawattsPerMeter(QuantityValue megawattspe double value = (double) megawattspermeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerMeter); } + /// /// Creates a from . /// @@ -594,6 +608,7 @@ public static LinearPowerDensity FromMegawattsPerMillimeter(QuantityValue megawa double value = (double) megawattspermillimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerMillimeter); } + /// /// Creates a from . /// @@ -603,6 +618,7 @@ public static LinearPowerDensity FromMilliwattsPerCentimeter(QuantityValue milli double value = (double) milliwattspercentimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerCentimeter); } + /// /// Creates a from . /// @@ -612,6 +628,7 @@ public static LinearPowerDensity FromMilliwattsPerFoot(QuantityValue milliwattsp double value = (double) milliwattsperfoot; return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerFoot); } + /// /// Creates a from . /// @@ -621,6 +638,7 @@ public static LinearPowerDensity FromMilliwattsPerInch(QuantityValue milliwattsp double value = (double) milliwattsperinch; return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerInch); } + /// /// Creates a from . /// @@ -630,6 +648,7 @@ public static LinearPowerDensity FromMilliwattsPerMeter(QuantityValue milliwatts double value = (double) milliwattspermeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerMeter); } + /// /// Creates a from . /// @@ -639,6 +658,7 @@ public static LinearPowerDensity FromMilliwattsPerMillimeter(QuantityValue milli double value = (double) milliwattspermillimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerMillimeter); } + /// /// Creates a from . /// @@ -648,6 +668,7 @@ public static LinearPowerDensity FromWattsPerCentimeter(QuantityValue wattsperce double value = (double) wattspercentimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerCentimeter); } + /// /// Creates a from . /// @@ -657,6 +678,7 @@ public static LinearPowerDensity FromWattsPerFoot(QuantityValue wattsperfoot) double value = (double) wattsperfoot; return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerFoot); } + /// /// Creates a from . /// @@ -666,6 +688,7 @@ public static LinearPowerDensity FromWattsPerInch(QuantityValue wattsperinch) double value = (double) wattsperinch; return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerInch); } + /// /// Creates a from . /// @@ -675,6 +698,7 @@ public static LinearPowerDensity FromWattsPerMeter(QuantityValue wattspermeter) double value = (double) wattspermeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerMeter); } + /// /// Creates a from . /// @@ -685,6 +709,7 @@ public static LinearPowerDensity FromWattsPerMillimeter(QuantityValue wattspermi return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerMillimeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs b/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs index 85b41fada5..f84d254c70 100644 --- a/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs @@ -369,6 +369,7 @@ public static Luminosity FromDecawatts(QuantityValue decawatts) double value = (double) decawatts; return new Luminosity(value, LuminosityUnit.Decawatt); } + /// /// Creates a from . /// @@ -378,6 +379,7 @@ public static Luminosity FromDeciwatts(QuantityValue deciwatts) double value = (double) deciwatts; return new Luminosity(value, LuminosityUnit.Deciwatt); } + /// /// Creates a from . /// @@ -387,6 +389,7 @@ public static Luminosity FromFemtowatts(QuantityValue femtowatts) double value = (double) femtowatts; return new Luminosity(value, LuminosityUnit.Femtowatt); } + /// /// Creates a from . /// @@ -396,6 +399,7 @@ public static Luminosity FromGigawatts(QuantityValue gigawatts) double value = (double) gigawatts; return new Luminosity(value, LuminosityUnit.Gigawatt); } + /// /// Creates a from . /// @@ -405,6 +409,7 @@ public static Luminosity FromKilowatts(QuantityValue kilowatts) double value = (double) kilowatts; return new Luminosity(value, LuminosityUnit.Kilowatt); } + /// /// Creates a from . /// @@ -414,6 +419,7 @@ public static Luminosity FromMegawatts(QuantityValue megawatts) double value = (double) megawatts; return new Luminosity(value, LuminosityUnit.Megawatt); } + /// /// Creates a from . /// @@ -423,6 +429,7 @@ public static Luminosity FromMicrowatts(QuantityValue microwatts) double value = (double) microwatts; return new Luminosity(value, LuminosityUnit.Microwatt); } + /// /// Creates a from . /// @@ -432,6 +439,7 @@ public static Luminosity FromMilliwatts(QuantityValue milliwatts) double value = (double) milliwatts; return new Luminosity(value, LuminosityUnit.Milliwatt); } + /// /// Creates a from . /// @@ -441,6 +449,7 @@ public static Luminosity FromNanowatts(QuantityValue nanowatts) double value = (double) nanowatts; return new Luminosity(value, LuminosityUnit.Nanowatt); } + /// /// Creates a from . /// @@ -450,6 +459,7 @@ public static Luminosity FromPetawatts(QuantityValue petawatts) double value = (double) petawatts; return new Luminosity(value, LuminosityUnit.Petawatt); } + /// /// Creates a from . /// @@ -459,6 +469,7 @@ public static Luminosity FromPicowatts(QuantityValue picowatts) double value = (double) picowatts; return new Luminosity(value, LuminosityUnit.Picowatt); } + /// /// Creates a from . /// @@ -468,6 +479,7 @@ public static Luminosity FromSolarLuminosities(QuantityValue solarluminosities) double value = (double) solarluminosities; return new Luminosity(value, LuminosityUnit.SolarLuminosity); } + /// /// Creates a from . /// @@ -477,6 +489,7 @@ public static Luminosity FromTerawatts(QuantityValue terawatts) double value = (double) terawatts; return new Luminosity(value, LuminosityUnit.Terawatt); } + /// /// Creates a from . /// @@ -487,6 +500,7 @@ public static Luminosity FromWatts(QuantityValue watts) return new Luminosity(value, LuminosityUnit.Watt); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs index 9dd2b04a86..f4a617259f 100644 --- a/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs @@ -253,6 +253,7 @@ public static LuminousFlux FromLumens(QuantityValue lumens) return new LuminousFlux(value, LuminousFluxUnit.Lumen); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs b/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs index f6d0175e1b..46dd530374 100644 --- a/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs @@ -253,6 +253,7 @@ public static LuminousIntensity FromCandela(QuantityValue candela) return new LuminousIntensity(value, LuminousIntensityUnit.Candela); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs b/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs index 8dbde9c185..cb95282466 100644 --- a/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs @@ -297,6 +297,7 @@ public static MagneticField FromGausses(QuantityValue gausses) double value = (double) gausses; return new MagneticField(value, MagneticFieldUnit.Gauss); } + /// /// Creates a from . /// @@ -306,6 +307,7 @@ public static MagneticField FromMicroteslas(QuantityValue microteslas) double value = (double) microteslas; return new MagneticField(value, MagneticFieldUnit.Microtesla); } + /// /// Creates a from . /// @@ -315,6 +317,7 @@ public static MagneticField FromMilligausses(QuantityValue milligausses) double value = (double) milligausses; return new MagneticField(value, MagneticFieldUnit.Milligauss); } + /// /// Creates a from . /// @@ -324,6 +327,7 @@ public static MagneticField FromMilliteslas(QuantityValue milliteslas) double value = (double) milliteslas; return new MagneticField(value, MagneticFieldUnit.Millitesla); } + /// /// Creates a from . /// @@ -333,6 +337,7 @@ public static MagneticField FromNanoteslas(QuantityValue nanoteslas) double value = (double) nanoteslas; return new MagneticField(value, MagneticFieldUnit.Nanotesla); } + /// /// Creates a from . /// @@ -343,6 +348,7 @@ public static MagneticField FromTeslas(QuantityValue teslas) return new MagneticField(value, MagneticFieldUnit.Tesla); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs index c7cada3007..2fb9d52286 100644 --- a/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs @@ -253,6 +253,7 @@ public static MagneticFlux FromWebers(QuantityValue webers) return new MagneticFlux(value, MagneticFluxUnit.Weber); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs b/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs index 9d337fe75a..551fdd43c9 100644 --- a/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs @@ -253,6 +253,7 @@ public static Magnetization FromAmperesPerMeter(QuantityValue amperespermeter) return new Magnetization(value, MagnetizationUnit.AmperePerMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Mass.g.cs b/UnitsNet/GeneratedCode/Quantities/Mass.g.cs index 818473581b..fb6bad4709 100644 --- a/UnitsNet/GeneratedCode/Quantities/Mass.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Mass.g.cs @@ -500,6 +500,7 @@ public static Mass FromCentigrams(QuantityValue centigrams) double value = (double) centigrams; return new Mass(value, MassUnit.Centigram); } + /// /// Creates a from . /// @@ -509,6 +510,7 @@ public static Mass FromDecagrams(QuantityValue decagrams) double value = (double) decagrams; return new Mass(value, MassUnit.Decagram); } + /// /// Creates a from . /// @@ -518,6 +520,7 @@ public static Mass FromDecigrams(QuantityValue decigrams) double value = (double) decigrams; return new Mass(value, MassUnit.Decigram); } + /// /// Creates a from . /// @@ -527,6 +530,7 @@ public static Mass FromEarthMasses(QuantityValue earthmasses) double value = (double) earthmasses; return new Mass(value, MassUnit.EarthMass); } + /// /// Creates a from . /// @@ -536,6 +540,7 @@ public static Mass FromGrains(QuantityValue grains) double value = (double) grains; return new Mass(value, MassUnit.Grain); } + /// /// Creates a from . /// @@ -545,6 +550,7 @@ public static Mass FromGrams(QuantityValue grams) double value = (double) grams; return new Mass(value, MassUnit.Gram); } + /// /// Creates a from . /// @@ -554,6 +560,7 @@ public static Mass FromHectograms(QuantityValue hectograms) double value = (double) hectograms; return new Mass(value, MassUnit.Hectogram); } + /// /// Creates a from . /// @@ -563,6 +570,7 @@ public static Mass FromKilograms(QuantityValue kilograms) double value = (double) kilograms; return new Mass(value, MassUnit.Kilogram); } + /// /// Creates a from . /// @@ -572,6 +580,7 @@ public static Mass FromKilopounds(QuantityValue kilopounds) double value = (double) kilopounds; return new Mass(value, MassUnit.Kilopound); } + /// /// Creates a from . /// @@ -581,6 +590,7 @@ public static Mass FromKilotonnes(QuantityValue kilotonnes) double value = (double) kilotonnes; return new Mass(value, MassUnit.Kilotonne); } + /// /// Creates a from . /// @@ -590,6 +600,7 @@ public static Mass FromLongHundredweight(QuantityValue longhundredweight) double value = (double) longhundredweight; return new Mass(value, MassUnit.LongHundredweight); } + /// /// Creates a from . /// @@ -599,6 +610,7 @@ public static Mass FromLongTons(QuantityValue longtons) double value = (double) longtons; return new Mass(value, MassUnit.LongTon); } + /// /// Creates a from . /// @@ -608,6 +620,7 @@ public static Mass FromMegapounds(QuantityValue megapounds) double value = (double) megapounds; return new Mass(value, MassUnit.Megapound); } + /// /// Creates a from . /// @@ -617,6 +630,7 @@ public static Mass FromMegatonnes(QuantityValue megatonnes) double value = (double) megatonnes; return new Mass(value, MassUnit.Megatonne); } + /// /// Creates a from . /// @@ -626,6 +640,7 @@ public static Mass FromMicrograms(QuantityValue micrograms) double value = (double) micrograms; return new Mass(value, MassUnit.Microgram); } + /// /// Creates a from . /// @@ -635,6 +650,7 @@ public static Mass FromMilligrams(QuantityValue milligrams) double value = (double) milligrams; return new Mass(value, MassUnit.Milligram); } + /// /// Creates a from . /// @@ -644,6 +660,7 @@ public static Mass FromNanograms(QuantityValue nanograms) double value = (double) nanograms; return new Mass(value, MassUnit.Nanogram); } + /// /// Creates a from . /// @@ -653,6 +670,7 @@ public static Mass FromOunces(QuantityValue ounces) double value = (double) ounces; return new Mass(value, MassUnit.Ounce); } + /// /// Creates a from . /// @@ -662,6 +680,7 @@ public static Mass FromPounds(QuantityValue pounds) double value = (double) pounds; return new Mass(value, MassUnit.Pound); } + /// /// Creates a from . /// @@ -671,6 +690,7 @@ public static Mass FromShortHundredweight(QuantityValue shorthundredweight) double value = (double) shorthundredweight; return new Mass(value, MassUnit.ShortHundredweight); } + /// /// Creates a from . /// @@ -680,6 +700,7 @@ public static Mass FromShortTons(QuantityValue shorttons) double value = (double) shorttons; return new Mass(value, MassUnit.ShortTon); } + /// /// Creates a from . /// @@ -689,6 +710,7 @@ public static Mass FromSlugs(QuantityValue slugs) double value = (double) slugs; return new Mass(value, MassUnit.Slug); } + /// /// Creates a from . /// @@ -698,6 +720,7 @@ public static Mass FromSolarMasses(QuantityValue solarmasses) double value = (double) solarmasses; return new Mass(value, MassUnit.SolarMass); } + /// /// Creates a from . /// @@ -707,6 +730,7 @@ public static Mass FromStone(QuantityValue stone) double value = (double) stone; return new Mass(value, MassUnit.Stone); } + /// /// Creates a from . /// @@ -717,6 +741,7 @@ public static Mass FromTonnes(QuantityValue tonnes) return new Mass(value, MassUnit.Tonne); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs b/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs index c3c77bdbe7..d4ca16225c 100644 --- a/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs @@ -688,6 +688,7 @@ public static MassConcentration FromCentigramsPerDeciliter(QuantityValue centigr double value = (double) centigramsperdeciliter; return new MassConcentration(value, MassConcentrationUnit.CentigramPerDeciliter); } + /// /// Creates a from . /// @@ -697,6 +698,7 @@ public static MassConcentration FromCentigramsPerLiter(QuantityValue centigramsp double value = (double) centigramsperliter; return new MassConcentration(value, MassConcentrationUnit.CentigramPerLiter); } + /// /// Creates a from . /// @@ -706,6 +708,7 @@ public static MassConcentration FromCentigramsPerMicroliter(QuantityValue centig double value = (double) centigramspermicroliter; return new MassConcentration(value, MassConcentrationUnit.CentigramPerMicroliter); } + /// /// Creates a from . /// @@ -715,6 +718,7 @@ public static MassConcentration FromCentigramsPerMilliliter(QuantityValue centig double value = (double) centigramspermilliliter; return new MassConcentration(value, MassConcentrationUnit.CentigramPerMilliliter); } + /// /// Creates a from . /// @@ -724,6 +728,7 @@ public static MassConcentration FromDecigramsPerDeciliter(QuantityValue decigram double value = (double) decigramsperdeciliter; return new MassConcentration(value, MassConcentrationUnit.DecigramPerDeciliter); } + /// /// Creates a from . /// @@ -733,6 +738,7 @@ public static MassConcentration FromDecigramsPerLiter(QuantityValue decigramsper double value = (double) decigramsperliter; return new MassConcentration(value, MassConcentrationUnit.DecigramPerLiter); } + /// /// Creates a from . /// @@ -742,6 +748,7 @@ public static MassConcentration FromDecigramsPerMicroliter(QuantityValue decigra double value = (double) decigramspermicroliter; return new MassConcentration(value, MassConcentrationUnit.DecigramPerMicroliter); } + /// /// Creates a from . /// @@ -751,6 +758,7 @@ public static MassConcentration FromDecigramsPerMilliliter(QuantityValue decigra double value = (double) decigramspermilliliter; return new MassConcentration(value, MassConcentrationUnit.DecigramPerMilliliter); } + /// /// Creates a from . /// @@ -760,6 +768,7 @@ public static MassConcentration FromGramsPerCubicCentimeter(QuantityValue gramsp double value = (double) gramspercubiccentimeter; return new MassConcentration(value, MassConcentrationUnit.GramPerCubicCentimeter); } + /// /// Creates a from . /// @@ -769,6 +778,7 @@ public static MassConcentration FromGramsPerCubicMeter(QuantityValue gramspercub double value = (double) gramspercubicmeter; return new MassConcentration(value, MassConcentrationUnit.GramPerCubicMeter); } + /// /// Creates a from . /// @@ -778,6 +788,7 @@ public static MassConcentration FromGramsPerCubicMillimeter(QuantityValue gramsp double value = (double) gramspercubicmillimeter; return new MassConcentration(value, MassConcentrationUnit.GramPerCubicMillimeter); } + /// /// Creates a from . /// @@ -787,6 +798,7 @@ public static MassConcentration FromGramsPerDeciliter(QuantityValue gramsperdeci double value = (double) gramsperdeciliter; return new MassConcentration(value, MassConcentrationUnit.GramPerDeciliter); } + /// /// Creates a from . /// @@ -796,6 +808,7 @@ public static MassConcentration FromGramsPerLiter(QuantityValue gramsperliter) double value = (double) gramsperliter; return new MassConcentration(value, MassConcentrationUnit.GramPerLiter); } + /// /// Creates a from . /// @@ -805,6 +818,7 @@ public static MassConcentration FromGramsPerMicroliter(QuantityValue gramspermic double value = (double) gramspermicroliter; return new MassConcentration(value, MassConcentrationUnit.GramPerMicroliter); } + /// /// Creates a from . /// @@ -814,6 +828,7 @@ public static MassConcentration FromGramsPerMilliliter(QuantityValue gramspermil double value = (double) gramspermilliliter; return new MassConcentration(value, MassConcentrationUnit.GramPerMilliliter); } + /// /// Creates a from . /// @@ -823,6 +838,7 @@ public static MassConcentration FromKilogramsPerCubicCentimeter(QuantityValue ki double value = (double) kilogramspercubiccentimeter; return new MassConcentration(value, MassConcentrationUnit.KilogramPerCubicCentimeter); } + /// /// Creates a from . /// @@ -832,6 +848,7 @@ public static MassConcentration FromKilogramsPerCubicMeter(QuantityValue kilogra double value = (double) kilogramspercubicmeter; return new MassConcentration(value, MassConcentrationUnit.KilogramPerCubicMeter); } + /// /// Creates a from . /// @@ -841,6 +858,7 @@ public static MassConcentration FromKilogramsPerCubicMillimeter(QuantityValue ki double value = (double) kilogramspercubicmillimeter; return new MassConcentration(value, MassConcentrationUnit.KilogramPerCubicMillimeter); } + /// /// Creates a from . /// @@ -850,6 +868,7 @@ public static MassConcentration FromKilogramsPerLiter(QuantityValue kilogramsper double value = (double) kilogramsperliter; return new MassConcentration(value, MassConcentrationUnit.KilogramPerLiter); } + /// /// Creates a from . /// @@ -859,6 +878,7 @@ public static MassConcentration FromKilopoundsPerCubicFoot(QuantityValue kilopou double value = (double) kilopoundspercubicfoot; return new MassConcentration(value, MassConcentrationUnit.KilopoundPerCubicFoot); } + /// /// Creates a from . /// @@ -868,6 +888,7 @@ public static MassConcentration FromKilopoundsPerCubicInch(QuantityValue kilopou double value = (double) kilopoundspercubicinch; return new MassConcentration(value, MassConcentrationUnit.KilopoundPerCubicInch); } + /// /// Creates a from . /// @@ -877,6 +898,7 @@ public static MassConcentration FromMicrogramsPerCubicMeter(QuantityValue microg double value = (double) microgramspercubicmeter; return new MassConcentration(value, MassConcentrationUnit.MicrogramPerCubicMeter); } + /// /// Creates a from . /// @@ -886,6 +908,7 @@ public static MassConcentration FromMicrogramsPerDeciliter(QuantityValue microgr double value = (double) microgramsperdeciliter; return new MassConcentration(value, MassConcentrationUnit.MicrogramPerDeciliter); } + /// /// Creates a from . /// @@ -895,6 +918,7 @@ public static MassConcentration FromMicrogramsPerLiter(QuantityValue microgramsp double value = (double) microgramsperliter; return new MassConcentration(value, MassConcentrationUnit.MicrogramPerLiter); } + /// /// Creates a from . /// @@ -904,6 +928,7 @@ public static MassConcentration FromMicrogramsPerMicroliter(QuantityValue microg double value = (double) microgramspermicroliter; return new MassConcentration(value, MassConcentrationUnit.MicrogramPerMicroliter); } + /// /// Creates a from . /// @@ -913,6 +938,7 @@ public static MassConcentration FromMicrogramsPerMilliliter(QuantityValue microg double value = (double) microgramspermilliliter; return new MassConcentration(value, MassConcentrationUnit.MicrogramPerMilliliter); } + /// /// Creates a from . /// @@ -922,6 +948,7 @@ public static MassConcentration FromMilligramsPerCubicMeter(QuantityValue millig double value = (double) milligramspercubicmeter; return new MassConcentration(value, MassConcentrationUnit.MilligramPerCubicMeter); } + /// /// Creates a from . /// @@ -931,6 +958,7 @@ public static MassConcentration FromMilligramsPerDeciliter(QuantityValue milligr double value = (double) milligramsperdeciliter; return new MassConcentration(value, MassConcentrationUnit.MilligramPerDeciliter); } + /// /// Creates a from . /// @@ -940,6 +968,7 @@ public static MassConcentration FromMilligramsPerLiter(QuantityValue milligramsp double value = (double) milligramsperliter; return new MassConcentration(value, MassConcentrationUnit.MilligramPerLiter); } + /// /// Creates a from . /// @@ -949,6 +978,7 @@ public static MassConcentration FromMilligramsPerMicroliter(QuantityValue millig double value = (double) milligramspermicroliter; return new MassConcentration(value, MassConcentrationUnit.MilligramPerMicroliter); } + /// /// Creates a from . /// @@ -958,6 +988,7 @@ public static MassConcentration FromMilligramsPerMilliliter(QuantityValue millig double value = (double) milligramspermilliliter; return new MassConcentration(value, MassConcentrationUnit.MilligramPerMilliliter); } + /// /// Creates a from . /// @@ -967,6 +998,7 @@ public static MassConcentration FromNanogramsPerDeciliter(QuantityValue nanogram double value = (double) nanogramsperdeciliter; return new MassConcentration(value, MassConcentrationUnit.NanogramPerDeciliter); } + /// /// Creates a from . /// @@ -976,6 +1008,7 @@ public static MassConcentration FromNanogramsPerLiter(QuantityValue nanogramsper double value = (double) nanogramsperliter; return new MassConcentration(value, MassConcentrationUnit.NanogramPerLiter); } + /// /// Creates a from . /// @@ -985,6 +1018,7 @@ public static MassConcentration FromNanogramsPerMicroliter(QuantityValue nanogra double value = (double) nanogramspermicroliter; return new MassConcentration(value, MassConcentrationUnit.NanogramPerMicroliter); } + /// /// Creates a from . /// @@ -994,6 +1028,7 @@ public static MassConcentration FromNanogramsPerMilliliter(QuantityValue nanogra double value = (double) nanogramspermilliliter; return new MassConcentration(value, MassConcentrationUnit.NanogramPerMilliliter); } + /// /// Creates a from . /// @@ -1003,6 +1038,7 @@ public static MassConcentration FromOuncesPerImperialGallon(QuantityValue ounces double value = (double) ouncesperimperialgallon; return new MassConcentration(value, MassConcentrationUnit.OuncePerImperialGallon); } + /// /// Creates a from . /// @@ -1012,6 +1048,7 @@ public static MassConcentration FromOuncesPerUSGallon(QuantityValue ouncesperusg double value = (double) ouncesperusgallon; return new MassConcentration(value, MassConcentrationUnit.OuncePerUSGallon); } + /// /// Creates a from . /// @@ -1021,6 +1058,7 @@ public static MassConcentration FromPicogramsPerDeciliter(QuantityValue picogram double value = (double) picogramsperdeciliter; return new MassConcentration(value, MassConcentrationUnit.PicogramPerDeciliter); } + /// /// Creates a from . /// @@ -1030,6 +1068,7 @@ public static MassConcentration FromPicogramsPerLiter(QuantityValue picogramsper double value = (double) picogramsperliter; return new MassConcentration(value, MassConcentrationUnit.PicogramPerLiter); } + /// /// Creates a from . /// @@ -1039,6 +1078,7 @@ public static MassConcentration FromPicogramsPerMicroliter(QuantityValue picogra double value = (double) picogramspermicroliter; return new MassConcentration(value, MassConcentrationUnit.PicogramPerMicroliter); } + /// /// Creates a from . /// @@ -1048,6 +1088,7 @@ public static MassConcentration FromPicogramsPerMilliliter(QuantityValue picogra double value = (double) picogramspermilliliter; return new MassConcentration(value, MassConcentrationUnit.PicogramPerMilliliter); } + /// /// Creates a from . /// @@ -1057,6 +1098,7 @@ public static MassConcentration FromPoundsPerCubicFoot(QuantityValue poundspercu double value = (double) poundspercubicfoot; return new MassConcentration(value, MassConcentrationUnit.PoundPerCubicFoot); } + /// /// Creates a from . /// @@ -1066,6 +1108,7 @@ public static MassConcentration FromPoundsPerCubicInch(QuantityValue poundspercu double value = (double) poundspercubicinch; return new MassConcentration(value, MassConcentrationUnit.PoundPerCubicInch); } + /// /// Creates a from . /// @@ -1075,6 +1118,7 @@ public static MassConcentration FromPoundsPerImperialGallon(QuantityValue pounds double value = (double) poundsperimperialgallon; return new MassConcentration(value, MassConcentrationUnit.PoundPerImperialGallon); } + /// /// Creates a from . /// @@ -1084,6 +1128,7 @@ public static MassConcentration FromPoundsPerUSGallon(QuantityValue poundsperusg double value = (double) poundsperusgallon; return new MassConcentration(value, MassConcentrationUnit.PoundPerUSGallon); } + /// /// Creates a from . /// @@ -1093,6 +1138,7 @@ public static MassConcentration FromSlugsPerCubicFoot(QuantityValue slugspercubi double value = (double) slugspercubicfoot; return new MassConcentration(value, MassConcentrationUnit.SlugPerCubicFoot); } + /// /// Creates a from . /// @@ -1102,6 +1148,7 @@ public static MassConcentration FromTonnesPerCubicCentimeter(QuantityValue tonne double value = (double) tonnespercubiccentimeter; return new MassConcentration(value, MassConcentrationUnit.TonnePerCubicCentimeter); } + /// /// Creates a from . /// @@ -1111,6 +1158,7 @@ public static MassConcentration FromTonnesPerCubicMeter(QuantityValue tonnesperc double value = (double) tonnespercubicmeter; return new MassConcentration(value, MassConcentrationUnit.TonnePerCubicMeter); } + /// /// Creates a from . /// @@ -1121,6 +1169,7 @@ public static MassConcentration FromTonnesPerCubicMillimeter(QuantityValue tonne return new MassConcentration(value, MassConcentrationUnit.TonnePerCubicMillimeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs index 4a81314bab..781bd3b8cf 100644 --- a/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs @@ -539,6 +539,7 @@ public static MassFlow FromCentigramsPerDay(QuantityValue centigramsperday) double value = (double) centigramsperday; return new MassFlow(value, MassFlowUnit.CentigramPerDay); } + /// /// Creates a from . /// @@ -548,6 +549,7 @@ public static MassFlow FromCentigramsPerSecond(QuantityValue centigramspersecond double value = (double) centigramspersecond; return new MassFlow(value, MassFlowUnit.CentigramPerSecond); } + /// /// Creates a from . /// @@ -557,6 +559,7 @@ public static MassFlow FromDecagramsPerDay(QuantityValue decagramsperday) double value = (double) decagramsperday; return new MassFlow(value, MassFlowUnit.DecagramPerDay); } + /// /// Creates a from . /// @@ -566,6 +569,7 @@ public static MassFlow FromDecagramsPerSecond(QuantityValue decagramspersecond) double value = (double) decagramspersecond; return new MassFlow(value, MassFlowUnit.DecagramPerSecond); } + /// /// Creates a from . /// @@ -575,6 +579,7 @@ public static MassFlow FromDecigramsPerDay(QuantityValue decigramsperday) double value = (double) decigramsperday; return new MassFlow(value, MassFlowUnit.DecigramPerDay); } + /// /// Creates a from . /// @@ -584,6 +589,7 @@ public static MassFlow FromDecigramsPerSecond(QuantityValue decigramspersecond) double value = (double) decigramspersecond; return new MassFlow(value, MassFlowUnit.DecigramPerSecond); } + /// /// Creates a from . /// @@ -593,6 +599,7 @@ public static MassFlow FromGramsPerDay(QuantityValue gramsperday) double value = (double) gramsperday; return new MassFlow(value, MassFlowUnit.GramPerDay); } + /// /// Creates a from . /// @@ -602,6 +609,7 @@ public static MassFlow FromGramsPerHour(QuantityValue gramsperhour) double value = (double) gramsperhour; return new MassFlow(value, MassFlowUnit.GramPerHour); } + /// /// Creates a from . /// @@ -611,6 +619,7 @@ public static MassFlow FromGramsPerSecond(QuantityValue gramspersecond) double value = (double) gramspersecond; return new MassFlow(value, MassFlowUnit.GramPerSecond); } + /// /// Creates a from . /// @@ -620,6 +629,7 @@ public static MassFlow FromHectogramsPerDay(QuantityValue hectogramsperday) double value = (double) hectogramsperday; return new MassFlow(value, MassFlowUnit.HectogramPerDay); } + /// /// Creates a from . /// @@ -629,6 +639,7 @@ public static MassFlow FromHectogramsPerSecond(QuantityValue hectogramspersecond double value = (double) hectogramspersecond; return new MassFlow(value, MassFlowUnit.HectogramPerSecond); } + /// /// Creates a from . /// @@ -638,6 +649,7 @@ public static MassFlow FromKilogramsPerDay(QuantityValue kilogramsperday) double value = (double) kilogramsperday; return new MassFlow(value, MassFlowUnit.KilogramPerDay); } + /// /// Creates a from . /// @@ -647,6 +659,7 @@ public static MassFlow FromKilogramsPerHour(QuantityValue kilogramsperhour) double value = (double) kilogramsperhour; return new MassFlow(value, MassFlowUnit.KilogramPerHour); } + /// /// Creates a from . /// @@ -656,6 +669,7 @@ public static MassFlow FromKilogramsPerMinute(QuantityValue kilogramsperminute) double value = (double) kilogramsperminute; return new MassFlow(value, MassFlowUnit.KilogramPerMinute); } + /// /// Creates a from . /// @@ -665,6 +679,7 @@ public static MassFlow FromKilogramsPerSecond(QuantityValue kilogramspersecond) double value = (double) kilogramspersecond; return new MassFlow(value, MassFlowUnit.KilogramPerSecond); } + /// /// Creates a from . /// @@ -674,6 +689,7 @@ public static MassFlow FromMegagramsPerDay(QuantityValue megagramsperday) double value = (double) megagramsperday; return new MassFlow(value, MassFlowUnit.MegagramPerDay); } + /// /// Creates a from . /// @@ -683,6 +699,7 @@ public static MassFlow FromMegapoundsPerDay(QuantityValue megapoundsperday) double value = (double) megapoundsperday; return new MassFlow(value, MassFlowUnit.MegapoundPerDay); } + /// /// Creates a from . /// @@ -692,6 +709,7 @@ public static MassFlow FromMegapoundsPerHour(QuantityValue megapoundsperhour) double value = (double) megapoundsperhour; return new MassFlow(value, MassFlowUnit.MegapoundPerHour); } + /// /// Creates a from . /// @@ -701,6 +719,7 @@ public static MassFlow FromMegapoundsPerMinute(QuantityValue megapoundsperminute double value = (double) megapoundsperminute; return new MassFlow(value, MassFlowUnit.MegapoundPerMinute); } + /// /// Creates a from . /// @@ -710,6 +729,7 @@ public static MassFlow FromMegapoundsPerSecond(QuantityValue megapoundspersecond double value = (double) megapoundspersecond; return new MassFlow(value, MassFlowUnit.MegapoundPerSecond); } + /// /// Creates a from . /// @@ -719,6 +739,7 @@ public static MassFlow FromMicrogramsPerDay(QuantityValue microgramsperday) double value = (double) microgramsperday; return new MassFlow(value, MassFlowUnit.MicrogramPerDay); } + /// /// Creates a from . /// @@ -728,6 +749,7 @@ public static MassFlow FromMicrogramsPerSecond(QuantityValue microgramspersecond double value = (double) microgramspersecond; return new MassFlow(value, MassFlowUnit.MicrogramPerSecond); } + /// /// Creates a from . /// @@ -737,6 +759,7 @@ public static MassFlow FromMilligramsPerDay(QuantityValue milligramsperday) double value = (double) milligramsperday; return new MassFlow(value, MassFlowUnit.MilligramPerDay); } + /// /// Creates a from . /// @@ -746,6 +769,7 @@ public static MassFlow FromMilligramsPerSecond(QuantityValue milligramspersecond double value = (double) milligramspersecond; return new MassFlow(value, MassFlowUnit.MilligramPerSecond); } + /// /// Creates a from . /// @@ -755,6 +779,7 @@ public static MassFlow FromNanogramsPerDay(QuantityValue nanogramsperday) double value = (double) nanogramsperday; return new MassFlow(value, MassFlowUnit.NanogramPerDay); } + /// /// Creates a from . /// @@ -764,6 +789,7 @@ public static MassFlow FromNanogramsPerSecond(QuantityValue nanogramspersecond) double value = (double) nanogramspersecond; return new MassFlow(value, MassFlowUnit.NanogramPerSecond); } + /// /// Creates a from . /// @@ -773,6 +799,7 @@ public static MassFlow FromPoundsPerDay(QuantityValue poundsperday) double value = (double) poundsperday; return new MassFlow(value, MassFlowUnit.PoundPerDay); } + /// /// Creates a from . /// @@ -782,6 +809,7 @@ public static MassFlow FromPoundsPerHour(QuantityValue poundsperhour) double value = (double) poundsperhour; return new MassFlow(value, MassFlowUnit.PoundPerHour); } + /// /// Creates a from . /// @@ -791,6 +819,7 @@ public static MassFlow FromPoundsPerMinute(QuantityValue poundsperminute) double value = (double) poundsperminute; return new MassFlow(value, MassFlowUnit.PoundPerMinute); } + /// /// Creates a from . /// @@ -800,6 +829,7 @@ public static MassFlow FromPoundsPerSecond(QuantityValue poundspersecond) double value = (double) poundspersecond; return new MassFlow(value, MassFlowUnit.PoundPerSecond); } + /// /// Creates a from . /// @@ -809,6 +839,7 @@ public static MassFlow FromShortTonsPerHour(QuantityValue shorttonsperhour) double value = (double) shorttonsperhour; return new MassFlow(value, MassFlowUnit.ShortTonPerHour); } + /// /// Creates a from . /// @@ -818,6 +849,7 @@ public static MassFlow FromTonnesPerDay(QuantityValue tonnesperday) double value = (double) tonnesperday; return new MassFlow(value, MassFlowUnit.TonnePerDay); } + /// /// Creates a from . /// @@ -828,6 +860,7 @@ public static MassFlow FromTonnesPerHour(QuantityValue tonnesperhour) return new MassFlow(value, MassFlowUnit.TonnePerHour); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs index 431a2eeed9..539bd39081 100644 --- a/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs @@ -348,6 +348,7 @@ public static MassFlux FromGramsPerHourPerSquareCentimeter(QuantityValue gramspe double value = (double) gramsperhourpersquarecentimeter; return new MassFlux(value, MassFluxUnit.GramPerHourPerSquareCentimeter); } + /// /// Creates a from . /// @@ -357,6 +358,7 @@ public static MassFlux FromGramsPerHourPerSquareMeter(QuantityValue gramsperhour double value = (double) gramsperhourpersquaremeter; return new MassFlux(value, MassFluxUnit.GramPerHourPerSquareMeter); } + /// /// Creates a from . /// @@ -366,6 +368,7 @@ public static MassFlux FromGramsPerHourPerSquareMillimeter(QuantityValue gramspe double value = (double) gramsperhourpersquaremillimeter; return new MassFlux(value, MassFluxUnit.GramPerHourPerSquareMillimeter); } + /// /// Creates a from . /// @@ -375,6 +378,7 @@ public static MassFlux FromGramsPerSecondPerSquareCentimeter(QuantityValue grams double value = (double) gramspersecondpersquarecentimeter; return new MassFlux(value, MassFluxUnit.GramPerSecondPerSquareCentimeter); } + /// /// Creates a from . /// @@ -384,6 +388,7 @@ public static MassFlux FromGramsPerSecondPerSquareMeter(QuantityValue gramsperse double value = (double) gramspersecondpersquaremeter; return new MassFlux(value, MassFluxUnit.GramPerSecondPerSquareMeter); } + /// /// Creates a from . /// @@ -393,6 +398,7 @@ public static MassFlux FromGramsPerSecondPerSquareMillimeter(QuantityValue grams double value = (double) gramspersecondpersquaremillimeter; return new MassFlux(value, MassFluxUnit.GramPerSecondPerSquareMillimeter); } + /// /// Creates a from . /// @@ -402,6 +408,7 @@ public static MassFlux FromKilogramsPerHourPerSquareCentimeter(QuantityValue kil double value = (double) kilogramsperhourpersquarecentimeter; return new MassFlux(value, MassFluxUnit.KilogramPerHourPerSquareCentimeter); } + /// /// Creates a from . /// @@ -411,6 +418,7 @@ public static MassFlux FromKilogramsPerHourPerSquareMeter(QuantityValue kilogram double value = (double) kilogramsperhourpersquaremeter; return new MassFlux(value, MassFluxUnit.KilogramPerHourPerSquareMeter); } + /// /// Creates a from . /// @@ -420,6 +428,7 @@ public static MassFlux FromKilogramsPerHourPerSquareMillimeter(QuantityValue kil double value = (double) kilogramsperhourpersquaremillimeter; return new MassFlux(value, MassFluxUnit.KilogramPerHourPerSquareMillimeter); } + /// /// Creates a from . /// @@ -429,6 +438,7 @@ public static MassFlux FromKilogramsPerSecondPerSquareCentimeter(QuantityValue k double value = (double) kilogramspersecondpersquarecentimeter; return new MassFlux(value, MassFluxUnit.KilogramPerSecondPerSquareCentimeter); } + /// /// Creates a from . /// @@ -438,6 +448,7 @@ public static MassFlux FromKilogramsPerSecondPerSquareMeter(QuantityValue kilogr double value = (double) kilogramspersecondpersquaremeter; return new MassFlux(value, MassFluxUnit.KilogramPerSecondPerSquareMeter); } + /// /// Creates a from . /// @@ -448,6 +459,7 @@ public static MassFlux FromKilogramsPerSecondPerSquareMillimeter(QuantityValue k return new MassFlux(value, MassFluxUnit.KilogramPerSecondPerSquareMillimeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/MassFraction.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFraction.g.cs index f6c7413cf7..926041cf56 100644 --- a/UnitsNet/GeneratedCode/Quantities/MassFraction.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MassFraction.g.cs @@ -459,6 +459,7 @@ public static MassFraction FromCentigramsPerGram(QuantityValue centigramspergram double value = (double) centigramspergram; return new MassFraction(value, MassFractionUnit.CentigramPerGram); } + /// /// Creates a from . /// @@ -468,6 +469,7 @@ public static MassFraction FromCentigramsPerKilogram(QuantityValue centigramsper double value = (double) centigramsperkilogram; return new MassFraction(value, MassFractionUnit.CentigramPerKilogram); } + /// /// Creates a from . /// @@ -477,6 +479,7 @@ public static MassFraction FromDecagramsPerGram(QuantityValue decagramspergram) double value = (double) decagramspergram; return new MassFraction(value, MassFractionUnit.DecagramPerGram); } + /// /// Creates a from . /// @@ -486,6 +489,7 @@ public static MassFraction FromDecagramsPerKilogram(QuantityValue decagramsperki double value = (double) decagramsperkilogram; return new MassFraction(value, MassFractionUnit.DecagramPerKilogram); } + /// /// Creates a from . /// @@ -495,6 +499,7 @@ public static MassFraction FromDecigramsPerGram(QuantityValue decigramspergram) double value = (double) decigramspergram; return new MassFraction(value, MassFractionUnit.DecigramPerGram); } + /// /// Creates a from . /// @@ -504,6 +509,7 @@ public static MassFraction FromDecigramsPerKilogram(QuantityValue decigramsperki double value = (double) decigramsperkilogram; return new MassFraction(value, MassFractionUnit.DecigramPerKilogram); } + /// /// Creates a from . /// @@ -513,6 +519,7 @@ public static MassFraction FromDecimalFractions(QuantityValue decimalfractions) double value = (double) decimalfractions; return new MassFraction(value, MassFractionUnit.DecimalFraction); } + /// /// Creates a from . /// @@ -522,6 +529,7 @@ public static MassFraction FromGramsPerGram(QuantityValue gramspergram) double value = (double) gramspergram; return new MassFraction(value, MassFractionUnit.GramPerGram); } + /// /// Creates a from . /// @@ -531,6 +539,7 @@ public static MassFraction FromGramsPerKilogram(QuantityValue gramsperkilogram) double value = (double) gramsperkilogram; return new MassFraction(value, MassFractionUnit.GramPerKilogram); } + /// /// Creates a from . /// @@ -540,6 +549,7 @@ public static MassFraction FromHectogramsPerGram(QuantityValue hectogramspergram double value = (double) hectogramspergram; return new MassFraction(value, MassFractionUnit.HectogramPerGram); } + /// /// Creates a from . /// @@ -549,6 +559,7 @@ public static MassFraction FromHectogramsPerKilogram(QuantityValue hectogramsper double value = (double) hectogramsperkilogram; return new MassFraction(value, MassFractionUnit.HectogramPerKilogram); } + /// /// Creates a from . /// @@ -558,6 +569,7 @@ public static MassFraction FromKilogramsPerGram(QuantityValue kilogramspergram) double value = (double) kilogramspergram; return new MassFraction(value, MassFractionUnit.KilogramPerGram); } + /// /// Creates a from . /// @@ -567,6 +579,7 @@ public static MassFraction FromKilogramsPerKilogram(QuantityValue kilogramsperki double value = (double) kilogramsperkilogram; return new MassFraction(value, MassFractionUnit.KilogramPerKilogram); } + /// /// Creates a from . /// @@ -576,6 +589,7 @@ public static MassFraction FromMicrogramsPerGram(QuantityValue microgramspergram double value = (double) microgramspergram; return new MassFraction(value, MassFractionUnit.MicrogramPerGram); } + /// /// Creates a from . /// @@ -585,6 +599,7 @@ public static MassFraction FromMicrogramsPerKilogram(QuantityValue microgramsper double value = (double) microgramsperkilogram; return new MassFraction(value, MassFractionUnit.MicrogramPerKilogram); } + /// /// Creates a from . /// @@ -594,6 +609,7 @@ public static MassFraction FromMilligramsPerGram(QuantityValue milligramspergram double value = (double) milligramspergram; return new MassFraction(value, MassFractionUnit.MilligramPerGram); } + /// /// Creates a from . /// @@ -603,6 +619,7 @@ public static MassFraction FromMilligramsPerKilogram(QuantityValue milligramsper double value = (double) milligramsperkilogram; return new MassFraction(value, MassFractionUnit.MilligramPerKilogram); } + /// /// Creates a from . /// @@ -612,6 +629,7 @@ public static MassFraction FromNanogramsPerGram(QuantityValue nanogramspergram) double value = (double) nanogramspergram; return new MassFraction(value, MassFractionUnit.NanogramPerGram); } + /// /// Creates a from . /// @@ -621,6 +639,7 @@ public static MassFraction FromNanogramsPerKilogram(QuantityValue nanogramsperki double value = (double) nanogramsperkilogram; return new MassFraction(value, MassFractionUnit.NanogramPerKilogram); } + /// /// Creates a from . /// @@ -630,6 +649,7 @@ public static MassFraction FromPartsPerBillion(QuantityValue partsperbillion) double value = (double) partsperbillion; return new MassFraction(value, MassFractionUnit.PartPerBillion); } + /// /// Creates a from . /// @@ -639,6 +659,7 @@ public static MassFraction FromPartsPerMillion(QuantityValue partspermillion) double value = (double) partspermillion; return new MassFraction(value, MassFractionUnit.PartPerMillion); } + /// /// Creates a from . /// @@ -648,6 +669,7 @@ public static MassFraction FromPartsPerThousand(QuantityValue partsperthousand) double value = (double) partsperthousand; return new MassFraction(value, MassFractionUnit.PartPerThousand); } + /// /// Creates a from . /// @@ -657,6 +679,7 @@ public static MassFraction FromPartsPerTrillion(QuantityValue partspertrillion) double value = (double) partspertrillion; return new MassFraction(value, MassFractionUnit.PartPerTrillion); } + /// /// Creates a from . /// @@ -667,6 +690,7 @@ public static MassFraction FromPercent(QuantityValue percent) return new MassFraction(value, MassFractionUnit.Percent); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs b/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs index a0ca3d11e5..9f1f91239d 100644 --- a/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs @@ -492,6 +492,7 @@ public static MassMomentOfInertia FromGramSquareCentimeters(QuantityValue gramsq double value = (double) gramsquarecentimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareCentimeter); } + /// /// Creates a from . /// @@ -501,6 +502,7 @@ public static MassMomentOfInertia FromGramSquareDecimeters(QuantityValue gramsqu double value = (double) gramsquaredecimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareDecimeter); } + /// /// Creates a from . /// @@ -510,6 +512,7 @@ public static MassMomentOfInertia FromGramSquareMeters(QuantityValue gramsquarem double value = (double) gramsquaremeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareMeter); } + /// /// Creates a from . /// @@ -519,6 +522,7 @@ public static MassMomentOfInertia FromGramSquareMillimeters(QuantityValue gramsq double value = (double) gramsquaremillimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareMillimeter); } + /// /// Creates a from . /// @@ -528,6 +532,7 @@ public static MassMomentOfInertia FromKilogramSquareCentimeters(QuantityValue ki double value = (double) kilogramsquarecentimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareCentimeter); } + /// /// Creates a from . /// @@ -537,6 +542,7 @@ public static MassMomentOfInertia FromKilogramSquareDecimeters(QuantityValue kil double value = (double) kilogramsquaredecimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareDecimeter); } + /// /// Creates a from . /// @@ -546,6 +552,7 @@ public static MassMomentOfInertia FromKilogramSquareMeters(QuantityValue kilogra double value = (double) kilogramsquaremeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareMeter); } + /// /// Creates a from . /// @@ -555,6 +562,7 @@ public static MassMomentOfInertia FromKilogramSquareMillimeters(QuantityValue ki double value = (double) kilogramsquaremillimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareMillimeter); } + /// /// Creates a from . /// @@ -564,6 +572,7 @@ public static MassMomentOfInertia FromKilotonneSquareCentimeters(QuantityValue k double value = (double) kilotonnesquarecentimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareCentimeter); } + /// /// Creates a from . /// @@ -573,6 +582,7 @@ public static MassMomentOfInertia FromKilotonneSquareDecimeters(QuantityValue ki double value = (double) kilotonnesquaredecimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareDecimeter); } + /// /// Creates a from . /// @@ -582,6 +592,7 @@ public static MassMomentOfInertia FromKilotonneSquareMeters(QuantityValue kiloto double value = (double) kilotonnesquaremeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareMeter); } + /// /// Creates a from . /// @@ -591,6 +602,7 @@ public static MassMomentOfInertia FromKilotonneSquareMilimeters(QuantityValue ki double value = (double) kilotonnesquaremilimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareMilimeter); } + /// /// Creates a from . /// @@ -600,6 +612,7 @@ public static MassMomentOfInertia FromMegatonneSquareCentimeters(QuantityValue m double value = (double) megatonnesquarecentimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareCentimeter); } + /// /// Creates a from . /// @@ -609,6 +622,7 @@ public static MassMomentOfInertia FromMegatonneSquareDecimeters(QuantityValue me double value = (double) megatonnesquaredecimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareDecimeter); } + /// /// Creates a from . /// @@ -618,6 +632,7 @@ public static MassMomentOfInertia FromMegatonneSquareMeters(QuantityValue megato double value = (double) megatonnesquaremeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareMeter); } + /// /// Creates a from . /// @@ -627,6 +642,7 @@ public static MassMomentOfInertia FromMegatonneSquareMilimeters(QuantityValue me double value = (double) megatonnesquaremilimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareMilimeter); } + /// /// Creates a from . /// @@ -636,6 +652,7 @@ public static MassMomentOfInertia FromMilligramSquareCentimeters(QuantityValue m double value = (double) milligramsquarecentimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareCentimeter); } + /// /// Creates a from . /// @@ -645,6 +662,7 @@ public static MassMomentOfInertia FromMilligramSquareDecimeters(QuantityValue mi double value = (double) milligramsquaredecimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareDecimeter); } + /// /// Creates a from . /// @@ -654,6 +672,7 @@ public static MassMomentOfInertia FromMilligramSquareMeters(QuantityValue millig double value = (double) milligramsquaremeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareMeter); } + /// /// Creates a from . /// @@ -663,6 +682,7 @@ public static MassMomentOfInertia FromMilligramSquareMillimeters(QuantityValue m double value = (double) milligramsquaremillimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareMillimeter); } + /// /// Creates a from . /// @@ -672,6 +692,7 @@ public static MassMomentOfInertia FromPoundSquareFeet(QuantityValue poundsquaref double value = (double) poundsquarefeet; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.PoundSquareFoot); } + /// /// Creates a from . /// @@ -681,6 +702,7 @@ public static MassMomentOfInertia FromPoundSquareInches(QuantityValue poundsquar double value = (double) poundsquareinches; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.PoundSquareInch); } + /// /// Creates a from . /// @@ -690,6 +712,7 @@ public static MassMomentOfInertia FromSlugSquareFeet(QuantityValue slugsquarefee double value = (double) slugsquarefeet; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.SlugSquareFoot); } + /// /// Creates a from . /// @@ -699,6 +722,7 @@ public static MassMomentOfInertia FromSlugSquareInches(QuantityValue slugsquarei double value = (double) slugsquareinches; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.SlugSquareInch); } + /// /// Creates a from . /// @@ -708,6 +732,7 @@ public static MassMomentOfInertia FromTonneSquareCentimeters(QuantityValue tonne double value = (double) tonnesquarecentimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareCentimeter); } + /// /// Creates a from . /// @@ -717,6 +742,7 @@ public static MassMomentOfInertia FromTonneSquareDecimeters(QuantityValue tonnes double value = (double) tonnesquaredecimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareDecimeter); } + /// /// Creates a from . /// @@ -726,6 +752,7 @@ public static MassMomentOfInertia FromTonneSquareMeters(QuantityValue tonnesquar double value = (double) tonnesquaremeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareMeter); } + /// /// Creates a from . /// @@ -736,6 +763,7 @@ public static MassMomentOfInertia FromTonneSquareMilimeters(QuantityValue tonnes return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareMilimeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs index 3d21ab527d..32113e3375 100644 --- a/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs @@ -267,6 +267,7 @@ public static MolarEnergy FromJoulesPerMole(QuantityValue joulespermole) double value = (double) joulespermole; return new MolarEnergy(value, MolarEnergyUnit.JoulePerMole); } + /// /// Creates a from . /// @@ -276,6 +277,7 @@ public static MolarEnergy FromKilojoulesPerMole(QuantityValue kilojoulespermole) double value = (double) kilojoulespermole; return new MolarEnergy(value, MolarEnergyUnit.KilojoulePerMole); } + /// /// Creates a from . /// @@ -286,6 +288,7 @@ public static MolarEnergy FromMegajoulesPerMole(QuantityValue megajoulespermole) return new MolarEnergy(value, MolarEnergyUnit.MegajoulePerMole); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs index 16b7132e3b..50d31ed1a2 100644 --- a/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs @@ -267,6 +267,7 @@ public static MolarEntropy FromJoulesPerMoleKelvin(QuantityValue joulespermoleke double value = (double) joulespermolekelvin; return new MolarEntropy(value, MolarEntropyUnit.JoulePerMoleKelvin); } + /// /// Creates a from . /// @@ -276,6 +277,7 @@ public static MolarEntropy FromKilojoulesPerMoleKelvin(QuantityValue kilojoulesp double value = (double) kilojoulespermolekelvin; return new MolarEntropy(value, MolarEntropyUnit.KilojoulePerMoleKelvin); } + /// /// Creates a from . /// @@ -286,6 +288,7 @@ public static MolarEntropy FromMegajoulesPerMoleKelvin(QuantityValue megajoulesp return new MolarEntropy(value, MolarEntropyUnit.MegajoulePerMoleKelvin); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs index 34dfcbbf47..5ada9b0156 100644 --- a/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs @@ -360,6 +360,7 @@ public static MolarMass FromCentigramsPerMole(QuantityValue centigramspermole) double value = (double) centigramspermole; return new MolarMass(value, MolarMassUnit.CentigramPerMole); } + /// /// Creates a from . /// @@ -369,6 +370,7 @@ public static MolarMass FromDecagramsPerMole(QuantityValue decagramspermole) double value = (double) decagramspermole; return new MolarMass(value, MolarMassUnit.DecagramPerMole); } + /// /// Creates a from . /// @@ -378,6 +380,7 @@ public static MolarMass FromDecigramsPerMole(QuantityValue decigramspermole) double value = (double) decigramspermole; return new MolarMass(value, MolarMassUnit.DecigramPerMole); } + /// /// Creates a from . /// @@ -387,6 +390,7 @@ public static MolarMass FromGramsPerMole(QuantityValue gramspermole) double value = (double) gramspermole; return new MolarMass(value, MolarMassUnit.GramPerMole); } + /// /// Creates a from . /// @@ -396,6 +400,7 @@ public static MolarMass FromHectogramsPerMole(QuantityValue hectogramspermole) double value = (double) hectogramspermole; return new MolarMass(value, MolarMassUnit.HectogramPerMole); } + /// /// Creates a from . /// @@ -405,6 +410,7 @@ public static MolarMass FromKilogramsPerMole(QuantityValue kilogramspermole) double value = (double) kilogramspermole; return new MolarMass(value, MolarMassUnit.KilogramPerMole); } + /// /// Creates a from . /// @@ -414,6 +420,7 @@ public static MolarMass FromKilopoundsPerMole(QuantityValue kilopoundspermole) double value = (double) kilopoundspermole; return new MolarMass(value, MolarMassUnit.KilopoundPerMole); } + /// /// Creates a from . /// @@ -423,6 +430,7 @@ public static MolarMass FromMegapoundsPerMole(QuantityValue megapoundspermole) double value = (double) megapoundspermole; return new MolarMass(value, MolarMassUnit.MegapoundPerMole); } + /// /// Creates a from . /// @@ -432,6 +440,7 @@ public static MolarMass FromMicrogramsPerMole(QuantityValue microgramspermole) double value = (double) microgramspermole; return new MolarMass(value, MolarMassUnit.MicrogramPerMole); } + /// /// Creates a from . /// @@ -441,6 +450,7 @@ public static MolarMass FromMilligramsPerMole(QuantityValue milligramspermole) double value = (double) milligramspermole; return new MolarMass(value, MolarMassUnit.MilligramPerMole); } + /// /// Creates a from . /// @@ -450,6 +460,7 @@ public static MolarMass FromNanogramsPerMole(QuantityValue nanogramspermole) double value = (double) nanogramspermole; return new MolarMass(value, MolarMassUnit.NanogramPerMole); } + /// /// Creates a from . /// @@ -460,6 +471,7 @@ public static MolarMass FromPoundsPerMole(QuantityValue poundspermole) return new MolarMass(value, MolarMassUnit.PoundPerMole); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs b/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs index 22da711e21..ef3a8b045d 100644 --- a/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs @@ -347,6 +347,7 @@ public static Molarity FromCentimolesPerLiter(QuantityValue centimolesperliter) double value = (double) centimolesperliter; return new Molarity(value, MolarityUnit.CentimolePerLiter); } + /// /// Creates a from . /// @@ -356,6 +357,7 @@ public static Molarity FromDecimolesPerLiter(QuantityValue decimolesperliter) double value = (double) decimolesperliter; return new Molarity(value, MolarityUnit.DecimolePerLiter); } + /// /// Creates a from . /// @@ -365,6 +367,7 @@ public static Molarity FromMicromolesPerLiter(QuantityValue micromolesperliter) double value = (double) micromolesperliter; return new Molarity(value, MolarityUnit.MicromolePerLiter); } + /// /// Creates a from . /// @@ -374,6 +377,7 @@ public static Molarity FromMillimolesPerLiter(QuantityValue millimolesperliter) double value = (double) millimolesperliter; return new Molarity(value, MolarityUnit.MillimolePerLiter); } + /// /// Creates a from . /// @@ -383,6 +387,7 @@ public static Molarity FromMolesPerCubicMeter(QuantityValue molespercubicmeter) double value = (double) molespercubicmeter; return new Molarity(value, MolarityUnit.MolePerCubicMeter); } + /// /// Creates a from . /// @@ -392,6 +397,7 @@ public static Molarity FromMolesPerLiter(QuantityValue molesperliter) double value = (double) molesperliter; return new Molarity(value, MolarityUnit.MolePerLiter); } + /// /// Creates a from . /// @@ -401,6 +407,7 @@ public static Molarity FromNanomolesPerLiter(QuantityValue nanomolesperliter) double value = (double) nanomolesperliter; return new Molarity(value, MolarityUnit.NanomolePerLiter); } + /// /// Creates a from . /// @@ -411,6 +418,7 @@ public static Molarity FromPicomolesPerLiter(QuantityValue picomolesperliter) return new Molarity(value, MolarityUnit.PicomolePerLiter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs b/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs index feef41146d..78b2c69b8c 100644 --- a/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs @@ -253,6 +253,7 @@ public static Permeability FromHenriesPerMeter(QuantityValue henriespermeter) return new Permeability(value, PermeabilityUnit.HenryPerMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs b/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs index 3ee516fe2e..3e03776636 100644 --- a/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs @@ -253,6 +253,7 @@ public static Permittivity FromFaradsPerMeter(QuantityValue faradspermeter) return new Permittivity(value, PermittivityUnit.FaradPerMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Power.g.cs b/UnitsNet/GeneratedCode/Quantities/Power.g.cs index eee2e56bef..09e844503f 100644 --- a/UnitsNet/GeneratedCode/Quantities/Power.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Power.g.cs @@ -470,6 +470,7 @@ public static Power FromBoilerHorsepower(QuantityValue boilerhorsepower) decimal value = (decimal) boilerhorsepower; return new Power(value, PowerUnit.BoilerHorsepower); } + /// /// Creates a from . /// @@ -479,6 +480,7 @@ public static Power FromBritishThermalUnitsPerHour(QuantityValue britishthermalu decimal value = (decimal) britishthermalunitsperhour; return new Power(value, PowerUnit.BritishThermalUnitPerHour); } + /// /// Creates a from . /// @@ -488,6 +490,7 @@ public static Power FromDecawatts(QuantityValue decawatts) decimal value = (decimal) decawatts; return new Power(value, PowerUnit.Decawatt); } + /// /// Creates a from . /// @@ -497,6 +500,7 @@ public static Power FromDeciwatts(QuantityValue deciwatts) decimal value = (decimal) deciwatts; return new Power(value, PowerUnit.Deciwatt); } + /// /// Creates a from . /// @@ -506,6 +510,7 @@ public static Power FromElectricalHorsepower(QuantityValue electricalhorsepower) decimal value = (decimal) electricalhorsepower; return new Power(value, PowerUnit.ElectricalHorsepower); } + /// /// Creates a from . /// @@ -515,6 +520,7 @@ public static Power FromFemtowatts(QuantityValue femtowatts) decimal value = (decimal) femtowatts; return new Power(value, PowerUnit.Femtowatt); } + /// /// Creates a from . /// @@ -524,6 +530,7 @@ public static Power FromGigajoulesPerHour(QuantityValue gigajoulesperhour) decimal value = (decimal) gigajoulesperhour; return new Power(value, PowerUnit.GigajoulePerHour); } + /// /// Creates a from . /// @@ -533,6 +540,7 @@ public static Power FromGigawatts(QuantityValue gigawatts) decimal value = (decimal) gigawatts; return new Power(value, PowerUnit.Gigawatt); } + /// /// Creates a from . /// @@ -542,6 +550,7 @@ public static Power FromHydraulicHorsepower(QuantityValue hydraulichorsepower) decimal value = (decimal) hydraulichorsepower; return new Power(value, PowerUnit.HydraulicHorsepower); } + /// /// Creates a from . /// @@ -551,6 +560,7 @@ public static Power FromJoulesPerHour(QuantityValue joulesperhour) decimal value = (decimal) joulesperhour; return new Power(value, PowerUnit.JoulePerHour); } + /// /// Creates a from . /// @@ -560,6 +570,7 @@ public static Power FromKilobritishThermalUnitsPerHour(QuantityValue kilobritish decimal value = (decimal) kilobritishthermalunitsperhour; return new Power(value, PowerUnit.KilobritishThermalUnitPerHour); } + /// /// Creates a from . /// @@ -569,6 +580,7 @@ public static Power FromKilojoulesPerHour(QuantityValue kilojoulesperhour) decimal value = (decimal) kilojoulesperhour; return new Power(value, PowerUnit.KilojoulePerHour); } + /// /// Creates a from . /// @@ -578,6 +590,7 @@ public static Power FromKilowatts(QuantityValue kilowatts) decimal value = (decimal) kilowatts; return new Power(value, PowerUnit.Kilowatt); } + /// /// Creates a from . /// @@ -587,6 +600,7 @@ public static Power FromMechanicalHorsepower(QuantityValue mechanicalhorsepower) decimal value = (decimal) mechanicalhorsepower; return new Power(value, PowerUnit.MechanicalHorsepower); } + /// /// Creates a from . /// @@ -596,6 +610,7 @@ public static Power FromMegajoulesPerHour(QuantityValue megajoulesperhour) decimal value = (decimal) megajoulesperhour; return new Power(value, PowerUnit.MegajoulePerHour); } + /// /// Creates a from . /// @@ -605,6 +620,7 @@ public static Power FromMegawatts(QuantityValue megawatts) decimal value = (decimal) megawatts; return new Power(value, PowerUnit.Megawatt); } + /// /// Creates a from . /// @@ -614,6 +630,7 @@ public static Power FromMetricHorsepower(QuantityValue metrichorsepower) decimal value = (decimal) metrichorsepower; return new Power(value, PowerUnit.MetricHorsepower); } + /// /// Creates a from . /// @@ -623,6 +640,7 @@ public static Power FromMicrowatts(QuantityValue microwatts) decimal value = (decimal) microwatts; return new Power(value, PowerUnit.Microwatt); } + /// /// Creates a from . /// @@ -632,6 +650,7 @@ public static Power FromMillijoulesPerHour(QuantityValue millijoulesperhour) decimal value = (decimal) millijoulesperhour; return new Power(value, PowerUnit.MillijoulePerHour); } + /// /// Creates a from . /// @@ -641,6 +660,7 @@ public static Power FromMilliwatts(QuantityValue milliwatts) decimal value = (decimal) milliwatts; return new Power(value, PowerUnit.Milliwatt); } + /// /// Creates a from . /// @@ -650,6 +670,7 @@ public static Power FromNanowatts(QuantityValue nanowatts) decimal value = (decimal) nanowatts; return new Power(value, PowerUnit.Nanowatt); } + /// /// Creates a from . /// @@ -659,6 +680,7 @@ public static Power FromPetawatts(QuantityValue petawatts) decimal value = (decimal) petawatts; return new Power(value, PowerUnit.Petawatt); } + /// /// Creates a from . /// @@ -668,6 +690,7 @@ public static Power FromPicowatts(QuantityValue picowatts) decimal value = (decimal) picowatts; return new Power(value, PowerUnit.Picowatt); } + /// /// Creates a from . /// @@ -677,6 +700,7 @@ public static Power FromTerawatts(QuantityValue terawatts) decimal value = (decimal) terawatts; return new Power(value, PowerUnit.Terawatt); } + /// /// Creates a from . /// @@ -687,6 +711,7 @@ public static Power FromWatts(QuantityValue watts) return new Power(value, PowerUnit.Watt); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs index 1f6958ea15..1bf2a0a418 100644 --- a/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs @@ -636,6 +636,7 @@ public static PowerDensity FromDecawattsPerCubicFoot(QuantityValue decawattsperc double value = (double) decawattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.DecawattPerCubicFoot); } + /// /// Creates a from . /// @@ -645,6 +646,7 @@ public static PowerDensity FromDecawattsPerCubicInch(QuantityValue decawattsperc double value = (double) decawattspercubicinch; return new PowerDensity(value, PowerDensityUnit.DecawattPerCubicInch); } + /// /// Creates a from . /// @@ -654,6 +656,7 @@ public static PowerDensity FromDecawattsPerCubicMeter(QuantityValue decawattsper double value = (double) decawattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.DecawattPerCubicMeter); } + /// /// Creates a from . /// @@ -663,6 +666,7 @@ public static PowerDensity FromDecawattsPerLiter(QuantityValue decawattsperliter double value = (double) decawattsperliter; return new PowerDensity(value, PowerDensityUnit.DecawattPerLiter); } + /// /// Creates a from . /// @@ -672,6 +676,7 @@ public static PowerDensity FromDeciwattsPerCubicFoot(QuantityValue deciwattsperc double value = (double) deciwattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.DeciwattPerCubicFoot); } + /// /// Creates a from . /// @@ -681,6 +686,7 @@ public static PowerDensity FromDeciwattsPerCubicInch(QuantityValue deciwattsperc double value = (double) deciwattspercubicinch; return new PowerDensity(value, PowerDensityUnit.DeciwattPerCubicInch); } + /// /// Creates a from . /// @@ -690,6 +696,7 @@ public static PowerDensity FromDeciwattsPerCubicMeter(QuantityValue deciwattsper double value = (double) deciwattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.DeciwattPerCubicMeter); } + /// /// Creates a from . /// @@ -699,6 +706,7 @@ public static PowerDensity FromDeciwattsPerLiter(QuantityValue deciwattsperliter double value = (double) deciwattsperliter; return new PowerDensity(value, PowerDensityUnit.DeciwattPerLiter); } + /// /// Creates a from . /// @@ -708,6 +716,7 @@ public static PowerDensity FromGigawattsPerCubicFoot(QuantityValue gigawattsperc double value = (double) gigawattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.GigawattPerCubicFoot); } + /// /// Creates a from . /// @@ -717,6 +726,7 @@ public static PowerDensity FromGigawattsPerCubicInch(QuantityValue gigawattsperc double value = (double) gigawattspercubicinch; return new PowerDensity(value, PowerDensityUnit.GigawattPerCubicInch); } + /// /// Creates a from . /// @@ -726,6 +736,7 @@ public static PowerDensity FromGigawattsPerCubicMeter(QuantityValue gigawattsper double value = (double) gigawattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.GigawattPerCubicMeter); } + /// /// Creates a from . /// @@ -735,6 +746,7 @@ public static PowerDensity FromGigawattsPerLiter(QuantityValue gigawattsperliter double value = (double) gigawattsperliter; return new PowerDensity(value, PowerDensityUnit.GigawattPerLiter); } + /// /// Creates a from . /// @@ -744,6 +756,7 @@ public static PowerDensity FromKilowattsPerCubicFoot(QuantityValue kilowattsperc double value = (double) kilowattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.KilowattPerCubicFoot); } + /// /// Creates a from . /// @@ -753,6 +766,7 @@ public static PowerDensity FromKilowattsPerCubicInch(QuantityValue kilowattsperc double value = (double) kilowattspercubicinch; return new PowerDensity(value, PowerDensityUnit.KilowattPerCubicInch); } + /// /// Creates a from . /// @@ -762,6 +776,7 @@ public static PowerDensity FromKilowattsPerCubicMeter(QuantityValue kilowattsper double value = (double) kilowattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.KilowattPerCubicMeter); } + /// /// Creates a from . /// @@ -771,6 +786,7 @@ public static PowerDensity FromKilowattsPerLiter(QuantityValue kilowattsperliter double value = (double) kilowattsperliter; return new PowerDensity(value, PowerDensityUnit.KilowattPerLiter); } + /// /// Creates a from . /// @@ -780,6 +796,7 @@ public static PowerDensity FromMegawattsPerCubicFoot(QuantityValue megawattsperc double value = (double) megawattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.MegawattPerCubicFoot); } + /// /// Creates a from . /// @@ -789,6 +806,7 @@ public static PowerDensity FromMegawattsPerCubicInch(QuantityValue megawattsperc double value = (double) megawattspercubicinch; return new PowerDensity(value, PowerDensityUnit.MegawattPerCubicInch); } + /// /// Creates a from . /// @@ -798,6 +816,7 @@ public static PowerDensity FromMegawattsPerCubicMeter(QuantityValue megawattsper double value = (double) megawattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.MegawattPerCubicMeter); } + /// /// Creates a from . /// @@ -807,6 +826,7 @@ public static PowerDensity FromMegawattsPerLiter(QuantityValue megawattsperliter double value = (double) megawattsperliter; return new PowerDensity(value, PowerDensityUnit.MegawattPerLiter); } + /// /// Creates a from . /// @@ -816,6 +836,7 @@ public static PowerDensity FromMicrowattsPerCubicFoot(QuantityValue microwattspe double value = (double) microwattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.MicrowattPerCubicFoot); } + /// /// Creates a from . /// @@ -825,6 +846,7 @@ public static PowerDensity FromMicrowattsPerCubicInch(QuantityValue microwattspe double value = (double) microwattspercubicinch; return new PowerDensity(value, PowerDensityUnit.MicrowattPerCubicInch); } + /// /// Creates a from . /// @@ -834,6 +856,7 @@ public static PowerDensity FromMicrowattsPerCubicMeter(QuantityValue microwattsp double value = (double) microwattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.MicrowattPerCubicMeter); } + /// /// Creates a from . /// @@ -843,6 +866,7 @@ public static PowerDensity FromMicrowattsPerLiter(QuantityValue microwattsperlit double value = (double) microwattsperliter; return new PowerDensity(value, PowerDensityUnit.MicrowattPerLiter); } + /// /// Creates a from . /// @@ -852,6 +876,7 @@ public static PowerDensity FromMilliwattsPerCubicFoot(QuantityValue milliwattspe double value = (double) milliwattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.MilliwattPerCubicFoot); } + /// /// Creates a from . /// @@ -861,6 +886,7 @@ public static PowerDensity FromMilliwattsPerCubicInch(QuantityValue milliwattspe double value = (double) milliwattspercubicinch; return new PowerDensity(value, PowerDensityUnit.MilliwattPerCubicInch); } + /// /// Creates a from . /// @@ -870,6 +896,7 @@ public static PowerDensity FromMilliwattsPerCubicMeter(QuantityValue milliwattsp double value = (double) milliwattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.MilliwattPerCubicMeter); } + /// /// Creates a from . /// @@ -879,6 +906,7 @@ public static PowerDensity FromMilliwattsPerLiter(QuantityValue milliwattsperlit double value = (double) milliwattsperliter; return new PowerDensity(value, PowerDensityUnit.MilliwattPerLiter); } + /// /// Creates a from . /// @@ -888,6 +916,7 @@ public static PowerDensity FromNanowattsPerCubicFoot(QuantityValue nanowattsperc double value = (double) nanowattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.NanowattPerCubicFoot); } + /// /// Creates a from . /// @@ -897,6 +926,7 @@ public static PowerDensity FromNanowattsPerCubicInch(QuantityValue nanowattsperc double value = (double) nanowattspercubicinch; return new PowerDensity(value, PowerDensityUnit.NanowattPerCubicInch); } + /// /// Creates a from . /// @@ -906,6 +936,7 @@ public static PowerDensity FromNanowattsPerCubicMeter(QuantityValue nanowattsper double value = (double) nanowattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.NanowattPerCubicMeter); } + /// /// Creates a from . /// @@ -915,6 +946,7 @@ public static PowerDensity FromNanowattsPerLiter(QuantityValue nanowattsperliter double value = (double) nanowattsperliter; return new PowerDensity(value, PowerDensityUnit.NanowattPerLiter); } + /// /// Creates a from . /// @@ -924,6 +956,7 @@ public static PowerDensity FromPicowattsPerCubicFoot(QuantityValue picowattsperc double value = (double) picowattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.PicowattPerCubicFoot); } + /// /// Creates a from . /// @@ -933,6 +966,7 @@ public static PowerDensity FromPicowattsPerCubicInch(QuantityValue picowattsperc double value = (double) picowattspercubicinch; return new PowerDensity(value, PowerDensityUnit.PicowattPerCubicInch); } + /// /// Creates a from . /// @@ -942,6 +976,7 @@ public static PowerDensity FromPicowattsPerCubicMeter(QuantityValue picowattsper double value = (double) picowattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.PicowattPerCubicMeter); } + /// /// Creates a from . /// @@ -951,6 +986,7 @@ public static PowerDensity FromPicowattsPerLiter(QuantityValue picowattsperliter double value = (double) picowattsperliter; return new PowerDensity(value, PowerDensityUnit.PicowattPerLiter); } + /// /// Creates a from . /// @@ -960,6 +996,7 @@ public static PowerDensity FromTerawattsPerCubicFoot(QuantityValue terawattsperc double value = (double) terawattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.TerawattPerCubicFoot); } + /// /// Creates a from . /// @@ -969,6 +1006,7 @@ public static PowerDensity FromTerawattsPerCubicInch(QuantityValue terawattsperc double value = (double) terawattspercubicinch; return new PowerDensity(value, PowerDensityUnit.TerawattPerCubicInch); } + /// /// Creates a from . /// @@ -978,6 +1016,7 @@ public static PowerDensity FromTerawattsPerCubicMeter(QuantityValue terawattsper double value = (double) terawattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.TerawattPerCubicMeter); } + /// /// Creates a from . /// @@ -987,6 +1026,7 @@ public static PowerDensity FromTerawattsPerLiter(QuantityValue terawattsperliter double value = (double) terawattsperliter; return new PowerDensity(value, PowerDensityUnit.TerawattPerLiter); } + /// /// Creates a from . /// @@ -996,6 +1036,7 @@ public static PowerDensity FromWattsPerCubicFoot(QuantityValue wattspercubicfoot double value = (double) wattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.WattPerCubicFoot); } + /// /// Creates a from . /// @@ -1005,6 +1046,7 @@ public static PowerDensity FromWattsPerCubicInch(QuantityValue wattspercubicinch double value = (double) wattspercubicinch; return new PowerDensity(value, PowerDensityUnit.WattPerCubicInch); } + /// /// Creates a from . /// @@ -1014,6 +1056,7 @@ public static PowerDensity FromWattsPerCubicMeter(QuantityValue wattspercubicmet double value = (double) wattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.WattPerCubicMeter); } + /// /// Creates a from . /// @@ -1024,6 +1067,7 @@ public static PowerDensity FromWattsPerLiter(QuantityValue wattsperliter) return new PowerDensity(value, PowerDensityUnit.WattPerLiter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/PowerRatio.g.cs b/UnitsNet/GeneratedCode/Quantities/PowerRatio.g.cs index 0080f91299..0977574ce8 100644 --- a/UnitsNet/GeneratedCode/Quantities/PowerRatio.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/PowerRatio.g.cs @@ -258,6 +258,7 @@ public static PowerRatio FromDecibelMilliwatts(QuantityValue decibelmilliwatts) double value = (double) decibelmilliwatts; return new PowerRatio(value, PowerRatioUnit.DecibelMilliwatt); } + /// /// Creates a from . /// @@ -268,6 +269,7 @@ public static PowerRatio FromDecibelWatts(QuantityValue decibelwatts) return new PowerRatio(value, PowerRatioUnit.DecibelWatt); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs b/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs index f1ea9b9383..41189d7294 100644 --- a/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs @@ -676,6 +676,7 @@ public static Pressure FromAtmospheres(QuantityValue atmospheres) double value = (double) atmospheres; return new Pressure(value, PressureUnit.Atmosphere); } + /// /// Creates a from . /// @@ -685,6 +686,7 @@ public static Pressure FromBars(QuantityValue bars) double value = (double) bars; return new Pressure(value, PressureUnit.Bar); } + /// /// Creates a from . /// @@ -694,6 +696,7 @@ public static Pressure FromCentibars(QuantityValue centibars) double value = (double) centibars; return new Pressure(value, PressureUnit.Centibar); } + /// /// Creates a from . /// @@ -703,6 +706,7 @@ public static Pressure FromDecapascals(QuantityValue decapascals) double value = (double) decapascals; return new Pressure(value, PressureUnit.Decapascal); } + /// /// Creates a from . /// @@ -712,6 +716,7 @@ public static Pressure FromDecibars(QuantityValue decibars) double value = (double) decibars; return new Pressure(value, PressureUnit.Decibar); } + /// /// Creates a from . /// @@ -721,6 +726,7 @@ public static Pressure FromDynesPerSquareCentimeter(QuantityValue dynespersquare double value = (double) dynespersquarecentimeter; return new Pressure(value, PressureUnit.DynePerSquareCentimeter); } + /// /// Creates a from . /// @@ -730,6 +736,7 @@ public static Pressure FromFeetOfElevation(QuantityValue feetofelevation) double value = (double) feetofelevation; return new Pressure(value, PressureUnit.FootOfElevation); } + /// /// Creates a from . /// @@ -739,6 +746,7 @@ public static Pressure FromFeetOfHead(QuantityValue feetofhead) double value = (double) feetofhead; return new Pressure(value, PressureUnit.FootOfHead); } + /// /// Creates a from . /// @@ -748,6 +756,7 @@ public static Pressure FromGigapascals(QuantityValue gigapascals) double value = (double) gigapascals; return new Pressure(value, PressureUnit.Gigapascal); } + /// /// Creates a from . /// @@ -757,6 +766,7 @@ public static Pressure FromHectopascals(QuantityValue hectopascals) double value = (double) hectopascals; return new Pressure(value, PressureUnit.Hectopascal); } + /// /// Creates a from . /// @@ -766,6 +776,7 @@ public static Pressure FromInchesOfMercury(QuantityValue inchesofmercury) double value = (double) inchesofmercury; return new Pressure(value, PressureUnit.InchOfMercury); } + /// /// Creates a from . /// @@ -775,6 +786,7 @@ public static Pressure FromInchesOfWaterColumn(QuantityValue inchesofwatercolumn double value = (double) inchesofwatercolumn; return new Pressure(value, PressureUnit.InchOfWaterColumn); } + /// /// Creates a from . /// @@ -784,6 +796,7 @@ public static Pressure FromKilobars(QuantityValue kilobars) double value = (double) kilobars; return new Pressure(value, PressureUnit.Kilobar); } + /// /// Creates a from . /// @@ -793,6 +806,7 @@ public static Pressure FromKilogramsForcePerSquareCentimeter(QuantityValue kilog double value = (double) kilogramsforcepersquarecentimeter; return new Pressure(value, PressureUnit.KilogramForcePerSquareCentimeter); } + /// /// Creates a from . /// @@ -802,6 +816,7 @@ public static Pressure FromKilogramsForcePerSquareMeter(QuantityValue kilogramsf double value = (double) kilogramsforcepersquaremeter; return new Pressure(value, PressureUnit.KilogramForcePerSquareMeter); } + /// /// Creates a from . /// @@ -811,6 +826,7 @@ public static Pressure FromKilogramsForcePerSquareMillimeter(QuantityValue kilog double value = (double) kilogramsforcepersquaremillimeter; return new Pressure(value, PressureUnit.KilogramForcePerSquareMillimeter); } + /// /// Creates a from . /// @@ -820,6 +836,7 @@ public static Pressure FromKilonewtonsPerSquareCentimeter(QuantityValue kilonewt double value = (double) kilonewtonspersquarecentimeter; return new Pressure(value, PressureUnit.KilonewtonPerSquareCentimeter); } + /// /// Creates a from . /// @@ -829,6 +846,7 @@ public static Pressure FromKilonewtonsPerSquareMeter(QuantityValue kilonewtonspe double value = (double) kilonewtonspersquaremeter; return new Pressure(value, PressureUnit.KilonewtonPerSquareMeter); } + /// /// Creates a from . /// @@ -838,6 +856,7 @@ public static Pressure FromKilonewtonsPerSquareMillimeter(QuantityValue kilonewt double value = (double) kilonewtonspersquaremillimeter; return new Pressure(value, PressureUnit.KilonewtonPerSquareMillimeter); } + /// /// Creates a from . /// @@ -847,6 +866,7 @@ public static Pressure FromKilopascals(QuantityValue kilopascals) double value = (double) kilopascals; return new Pressure(value, PressureUnit.Kilopascal); } + /// /// Creates a from . /// @@ -856,6 +876,7 @@ public static Pressure FromKilopoundsForcePerSquareFoot(QuantityValue kilopounds double value = (double) kilopoundsforcepersquarefoot; return new Pressure(value, PressureUnit.KilopoundForcePerSquareFoot); } + /// /// Creates a from . /// @@ -865,6 +886,7 @@ public static Pressure FromKilopoundsForcePerSquareInch(QuantityValue kilopounds double value = (double) kilopoundsforcepersquareinch; return new Pressure(value, PressureUnit.KilopoundForcePerSquareInch); } + /// /// Creates a from . /// @@ -874,6 +896,7 @@ public static Pressure FromMegabars(QuantityValue megabars) double value = (double) megabars; return new Pressure(value, PressureUnit.Megabar); } + /// /// Creates a from . /// @@ -883,6 +906,7 @@ public static Pressure FromMeganewtonsPerSquareMeter(QuantityValue meganewtonspe double value = (double) meganewtonspersquaremeter; return new Pressure(value, PressureUnit.MeganewtonPerSquareMeter); } + /// /// Creates a from . /// @@ -892,6 +916,7 @@ public static Pressure FromMegapascals(QuantityValue megapascals) double value = (double) megapascals; return new Pressure(value, PressureUnit.Megapascal); } + /// /// Creates a from . /// @@ -901,6 +926,7 @@ public static Pressure FromMetersOfElevation(QuantityValue metersofelevation) double value = (double) metersofelevation; return new Pressure(value, PressureUnit.MeterOfElevation); } + /// /// Creates a from . /// @@ -910,6 +936,7 @@ public static Pressure FromMetersOfHead(QuantityValue metersofhead) double value = (double) metersofhead; return new Pressure(value, PressureUnit.MeterOfHead); } + /// /// Creates a from . /// @@ -919,6 +946,7 @@ public static Pressure FromMicrobars(QuantityValue microbars) double value = (double) microbars; return new Pressure(value, PressureUnit.Microbar); } + /// /// Creates a from . /// @@ -928,6 +956,7 @@ public static Pressure FromMicropascals(QuantityValue micropascals) double value = (double) micropascals; return new Pressure(value, PressureUnit.Micropascal); } + /// /// Creates a from . /// @@ -937,6 +966,7 @@ public static Pressure FromMillibars(QuantityValue millibars) double value = (double) millibars; return new Pressure(value, PressureUnit.Millibar); } + /// /// Creates a from . /// @@ -946,6 +976,7 @@ public static Pressure FromMillimetersOfMercury(QuantityValue millimetersofmercu double value = (double) millimetersofmercury; return new Pressure(value, PressureUnit.MillimeterOfMercury); } + /// /// Creates a from . /// @@ -955,6 +986,7 @@ public static Pressure FromMillimeterOfWaterColumn(QuantityValue millimeterofwat double value = (double) millimeterofwatercolumn; return new Pressure(value, PressureUnit.MillimeterOfWaterColumn); } + /// /// Creates a from . /// @@ -964,6 +996,7 @@ public static Pressure FromMillipascals(QuantityValue millipascals) double value = (double) millipascals; return new Pressure(value, PressureUnit.Millipascal); } + /// /// Creates a from . /// @@ -973,6 +1006,7 @@ public static Pressure FromNewtonsPerSquareCentimeter(QuantityValue newtonspersq double value = (double) newtonspersquarecentimeter; return new Pressure(value, PressureUnit.NewtonPerSquareCentimeter); } + /// /// Creates a from . /// @@ -982,6 +1016,7 @@ public static Pressure FromNewtonsPerSquareMeter(QuantityValue newtonspersquarem double value = (double) newtonspersquaremeter; return new Pressure(value, PressureUnit.NewtonPerSquareMeter); } + /// /// Creates a from . /// @@ -991,6 +1026,7 @@ public static Pressure FromNewtonsPerSquareMillimeter(QuantityValue newtonspersq double value = (double) newtonspersquaremillimeter; return new Pressure(value, PressureUnit.NewtonPerSquareMillimeter); } + /// /// Creates a from . /// @@ -1000,6 +1036,7 @@ public static Pressure FromPascals(QuantityValue pascals) double value = (double) pascals; return new Pressure(value, PressureUnit.Pascal); } + /// /// Creates a from . /// @@ -1009,6 +1046,7 @@ public static Pressure FromPoundsForcePerSquareFoot(QuantityValue poundsforceper double value = (double) poundsforcepersquarefoot; return new Pressure(value, PressureUnit.PoundForcePerSquareFoot); } + /// /// Creates a from . /// @@ -1018,6 +1056,7 @@ public static Pressure FromPoundsForcePerSquareInch(QuantityValue poundsforceper double value = (double) poundsforcepersquareinch; return new Pressure(value, PressureUnit.PoundForcePerSquareInch); } + /// /// Creates a from . /// @@ -1027,6 +1066,7 @@ public static Pressure FromPoundsPerInchSecondSquared(QuantityValue poundsperinc double value = (double) poundsperinchsecondsquared; return new Pressure(value, PressureUnit.PoundPerInchSecondSquared); } + /// /// Creates a from . /// @@ -1036,6 +1076,7 @@ public static Pressure FromTechnicalAtmospheres(QuantityValue technicalatmospher double value = (double) technicalatmospheres; return new Pressure(value, PressureUnit.TechnicalAtmosphere); } + /// /// Creates a from . /// @@ -1045,6 +1086,7 @@ public static Pressure FromTonnesForcePerSquareCentimeter(QuantityValue tonnesfo double value = (double) tonnesforcepersquarecentimeter; return new Pressure(value, PressureUnit.TonneForcePerSquareCentimeter); } + /// /// Creates a from . /// @@ -1054,6 +1096,7 @@ public static Pressure FromTonnesForcePerSquareMeter(QuantityValue tonnesforcepe double value = (double) tonnesforcepersquaremeter; return new Pressure(value, PressureUnit.TonneForcePerSquareMeter); } + /// /// Creates a from . /// @@ -1063,6 +1106,7 @@ public static Pressure FromTonnesForcePerSquareMillimeter(QuantityValue tonnesfo double value = (double) tonnesforcepersquaremillimeter; return new Pressure(value, PressureUnit.TonneForcePerSquareMillimeter); } + /// /// Creates a from . /// @@ -1073,6 +1117,7 @@ public static Pressure FromTorrs(QuantityValue torrs) return new Pressure(value, PressureUnit.Torr); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs index fed0407915..77e7e09dec 100644 --- a/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs @@ -380,6 +380,7 @@ public static PressureChangeRate FromAtmospheresPerSecond(QuantityValue atmosphe double value = (double) atmospherespersecond; return new PressureChangeRate(value, PressureChangeRateUnit.AtmospherePerSecond); } + /// /// Creates a from . /// @@ -389,6 +390,7 @@ public static PressureChangeRate FromKilopascalsPerMinute(QuantityValue kilopasc double value = (double) kilopascalsperminute; return new PressureChangeRate(value, PressureChangeRateUnit.KilopascalPerMinute); } + /// /// Creates a from . /// @@ -398,6 +400,7 @@ public static PressureChangeRate FromKilopascalsPerSecond(QuantityValue kilopasc double value = (double) kilopascalspersecond; return new PressureChangeRate(value, PressureChangeRateUnit.KilopascalPerSecond); } + /// /// Creates a from . /// @@ -407,6 +410,7 @@ public static PressureChangeRate FromKilopoundsForcePerSquareInchPerMinute(Quant double value = (double) kilopoundsforcepersquareinchperminute; return new PressureChangeRate(value, PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute); } + /// /// Creates a from . /// @@ -416,6 +420,7 @@ public static PressureChangeRate FromKilopoundsForcePerSquareInchPerSecond(Quant double value = (double) kilopoundsforcepersquareinchpersecond; return new PressureChangeRate(value, PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond); } + /// /// Creates a from . /// @@ -425,6 +430,7 @@ public static PressureChangeRate FromMegapascalsPerMinute(QuantityValue megapasc double value = (double) megapascalsperminute; return new PressureChangeRate(value, PressureChangeRateUnit.MegapascalPerMinute); } + /// /// Creates a from . /// @@ -434,6 +440,7 @@ public static PressureChangeRate FromMegapascalsPerSecond(QuantityValue megapasc double value = (double) megapascalspersecond; return new PressureChangeRate(value, PressureChangeRateUnit.MegapascalPerSecond); } + /// /// Creates a from . /// @@ -443,6 +450,7 @@ public static PressureChangeRate FromMegapoundsForcePerSquareInchPerMinute(Quant double value = (double) megapoundsforcepersquareinchperminute; return new PressureChangeRate(value, PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute); } + /// /// Creates a from . /// @@ -452,6 +460,7 @@ public static PressureChangeRate FromMegapoundsForcePerSquareInchPerSecond(Quant double value = (double) megapoundsforcepersquareinchpersecond; return new PressureChangeRate(value, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond); } + /// /// Creates a from . /// @@ -461,6 +470,7 @@ public static PressureChangeRate FromMillimetersOfMercuryPerSecond(QuantityValue double value = (double) millimetersofmercurypersecond; return new PressureChangeRate(value, PressureChangeRateUnit.MillimeterOfMercuryPerSecond); } + /// /// Creates a from . /// @@ -470,6 +480,7 @@ public static PressureChangeRate FromPascalsPerMinute(QuantityValue pascalspermi double value = (double) pascalsperminute; return new PressureChangeRate(value, PressureChangeRateUnit.PascalPerMinute); } + /// /// Creates a from . /// @@ -479,6 +490,7 @@ public static PressureChangeRate FromPascalsPerSecond(QuantityValue pascalsperse double value = (double) pascalspersecond; return new PressureChangeRate(value, PressureChangeRateUnit.PascalPerSecond); } + /// /// Creates a from . /// @@ -488,6 +500,7 @@ public static PressureChangeRate FromPoundsForcePerSquareInchPerMinute(QuantityV double value = (double) poundsforcepersquareinchperminute; return new PressureChangeRate(value, PressureChangeRateUnit.PoundForcePerSquareInchPerMinute); } + /// /// Creates a from . /// @@ -498,6 +511,7 @@ public static PressureChangeRate FromPoundsForcePerSquareInchPerSecond(QuantityV return new PressureChangeRate(value, PressureChangeRateUnit.PoundForcePerSquareInchPerSecond); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs b/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs index a127d06926..d07266f2f0 100644 --- a/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs @@ -294,6 +294,7 @@ public static Ratio FromDecimalFractions(QuantityValue decimalfractions) double value = (double) decimalfractions; return new Ratio(value, RatioUnit.DecimalFraction); } + /// /// Creates a from . /// @@ -303,6 +304,7 @@ public static Ratio FromPartsPerBillion(QuantityValue partsperbillion) double value = (double) partsperbillion; return new Ratio(value, RatioUnit.PartPerBillion); } + /// /// Creates a from . /// @@ -312,6 +314,7 @@ public static Ratio FromPartsPerMillion(QuantityValue partspermillion) double value = (double) partspermillion; return new Ratio(value, RatioUnit.PartPerMillion); } + /// /// Creates a from . /// @@ -321,6 +324,7 @@ public static Ratio FromPartsPerThousand(QuantityValue partsperthousand) double value = (double) partsperthousand; return new Ratio(value, RatioUnit.PartPerThousand); } + /// /// Creates a from . /// @@ -330,6 +334,7 @@ public static Ratio FromPartsPerTrillion(QuantityValue partspertrillion) double value = (double) partspertrillion; return new Ratio(value, RatioUnit.PartPerTrillion); } + /// /// Creates a from . /// @@ -340,6 +345,7 @@ public static Ratio FromPercent(QuantityValue percent) return new Ratio(value, RatioUnit.Percent); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/RatioChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/RatioChangeRate.g.cs index e9a355f4fc..0d8731a672 100644 --- a/UnitsNet/GeneratedCode/Quantities/RatioChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/RatioChangeRate.g.cs @@ -258,6 +258,7 @@ public static RatioChangeRate FromDecimalFractionsPerSecond(QuantityValue decima double value = (double) decimalfractionspersecond; return new RatioChangeRate(value, RatioChangeRateUnit.DecimalFractionPerSecond); } + /// /// Creates a from . /// @@ -268,6 +269,7 @@ public static RatioChangeRate FromPercentsPerSecond(QuantityValue percentspersec return new RatioChangeRate(value, RatioChangeRateUnit.PercentPerSecond); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.g.cs index b6a14d7ec9..75628b109f 100644 --- a/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.g.cs @@ -267,6 +267,7 @@ public static ReactiveEnergy FromKilovoltampereReactiveHours(QuantityValue kilov double value = (double) kilovoltamperereactivehours; return new ReactiveEnergy(value, ReactiveEnergyUnit.KilovoltampereReactiveHour); } + /// /// Creates a from . /// @@ -276,6 +277,7 @@ public static ReactiveEnergy FromMegavoltampereReactiveHours(QuantityValue megav double value = (double) megavoltamperereactivehours; return new ReactiveEnergy(value, ReactiveEnergyUnit.MegavoltampereReactiveHour); } + /// /// Creates a from . /// @@ -286,6 +288,7 @@ public static ReactiveEnergy FromVoltampereReactiveHours(QuantityValue voltamper return new ReactiveEnergy(value, ReactiveEnergyUnit.VoltampereReactiveHour); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ReactivePower.g.cs b/UnitsNet/GeneratedCode/Quantities/ReactivePower.g.cs index 669439bbbd..aec83abde4 100644 --- a/UnitsNet/GeneratedCode/Quantities/ReactivePower.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ReactivePower.g.cs @@ -276,6 +276,7 @@ public static ReactivePower FromGigavoltamperesReactive(QuantityValue gigavoltam double value = (double) gigavoltamperesreactive; return new ReactivePower(value, ReactivePowerUnit.GigavoltampereReactive); } + /// /// Creates a from . /// @@ -285,6 +286,7 @@ public static ReactivePower FromKilovoltamperesReactive(QuantityValue kilovoltam double value = (double) kilovoltamperesreactive; return new ReactivePower(value, ReactivePowerUnit.KilovoltampereReactive); } + /// /// Creates a from . /// @@ -294,6 +296,7 @@ public static ReactivePower FromMegavoltamperesReactive(QuantityValue megavoltam double value = (double) megavoltamperesreactive; return new ReactivePower(value, ReactivePowerUnit.MegavoltampereReactive); } + /// /// Creates a from . /// @@ -304,6 +307,7 @@ public static ReactivePower FromVoltamperesReactive(QuantityValue voltamperesrea return new ReactivePower(value, ReactivePowerUnit.VoltampereReactive); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs b/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs index bfd4d269d1..96c50d8d40 100644 --- a/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs @@ -342,6 +342,7 @@ public static ReciprocalArea FromInverseSquareCentimeters(QuantityValue inverses double value = (double) inversesquarecentimeters; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareCentimeter); } + /// /// Creates a from . /// @@ -351,6 +352,7 @@ public static ReciprocalArea FromInverseSquareDecimeters(QuantityValue inversesq double value = (double) inversesquaredecimeters; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareDecimeter); } + /// /// Creates a from . /// @@ -360,6 +362,7 @@ public static ReciprocalArea FromInverseSquareFeet(QuantityValue inversesquarefe double value = (double) inversesquarefeet; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareFoot); } + /// /// Creates a from . /// @@ -369,6 +372,7 @@ public static ReciprocalArea FromInverseSquareInches(QuantityValue inversesquare double value = (double) inversesquareinches; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareInch); } + /// /// Creates a from . /// @@ -378,6 +382,7 @@ public static ReciprocalArea FromInverseSquareKilometers(QuantityValue inversesq double value = (double) inversesquarekilometers; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareKilometer); } + /// /// Creates a from . /// @@ -387,6 +392,7 @@ public static ReciprocalArea FromInverseSquareMeters(QuantityValue inversesquare double value = (double) inversesquaremeters; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMeter); } + /// /// Creates a from . /// @@ -396,6 +402,7 @@ public static ReciprocalArea FromInverseSquareMicrometers(QuantityValue inverses double value = (double) inversesquaremicrometers; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMicrometer); } + /// /// Creates a from . /// @@ -405,6 +412,7 @@ public static ReciprocalArea FromInverseSquareMiles(QuantityValue inversesquarem double value = (double) inversesquaremiles; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMile); } + /// /// Creates a from . /// @@ -414,6 +422,7 @@ public static ReciprocalArea FromInverseSquareMillimeters(QuantityValue inverses double value = (double) inversesquaremillimeters; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMillimeter); } + /// /// Creates a from . /// @@ -423,6 +432,7 @@ public static ReciprocalArea FromInverseSquareYards(QuantityValue inversesquarey double value = (double) inversesquareyards; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareYard); } + /// /// Creates a from . /// @@ -433,6 +443,7 @@ public static ReciprocalArea FromInverseUsSurveySquareFeet(QuantityValue inverse return new ReciprocalArea(value, ReciprocalAreaUnit.InverseUsSurveySquareFoot); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs b/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs index 337de3f6af..5d2e3105a2 100644 --- a/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs @@ -333,6 +333,7 @@ public static ReciprocalLength FromInverseCentimeters(QuantityValue inversecenti double value = (double) inversecentimeters; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseCentimeter); } + /// /// Creates a from . /// @@ -342,6 +343,7 @@ public static ReciprocalLength FromInverseFeet(QuantityValue inversefeet) double value = (double) inversefeet; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseFoot); } + /// /// Creates a from . /// @@ -351,6 +353,7 @@ public static ReciprocalLength FromInverseInches(QuantityValue inverseinches) double value = (double) inverseinches; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseInch); } + /// /// Creates a from . /// @@ -360,6 +363,7 @@ public static ReciprocalLength FromInverseMeters(QuantityValue inversemeters) double value = (double) inversemeters; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMeter); } + /// /// Creates a from . /// @@ -369,6 +373,7 @@ public static ReciprocalLength FromInverseMicroinches(QuantityValue inversemicro double value = (double) inversemicroinches; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMicroinch); } + /// /// Creates a from . /// @@ -378,6 +383,7 @@ public static ReciprocalLength FromInverseMils(QuantityValue inversemils) double value = (double) inversemils; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMil); } + /// /// Creates a from . /// @@ -387,6 +393,7 @@ public static ReciprocalLength FromInverseMiles(QuantityValue inversemiles) double value = (double) inversemiles; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMile); } + /// /// Creates a from . /// @@ -396,6 +403,7 @@ public static ReciprocalLength FromInverseMillimeters(QuantityValue inversemilli double value = (double) inversemillimeters; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMillimeter); } + /// /// Creates a from . /// @@ -405,6 +413,7 @@ public static ReciprocalLength FromInverseUsSurveyFeet(QuantityValue inverseussu double value = (double) inverseussurveyfeet; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseUsSurveyFoot); } + /// /// Creates a from . /// @@ -415,6 +424,7 @@ public static ReciprocalLength FromInverseYards(QuantityValue inverseyards) return new ReciprocalLength(value, ReciprocalLengthUnit.InverseYard); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/RelativeHumidity.g.cs b/UnitsNet/GeneratedCode/Quantities/RelativeHumidity.g.cs index 0a07148beb..f57fcabbb3 100644 --- a/UnitsNet/GeneratedCode/Quantities/RelativeHumidity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/RelativeHumidity.g.cs @@ -250,6 +250,7 @@ public static RelativeHumidity FromPercent(QuantityValue percent) return new RelativeHumidity(value, RelativeHumidityUnit.Percent); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs index f77e5b2a24..c669e7b146 100644 --- a/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs @@ -276,6 +276,7 @@ public static RotationalAcceleration FromDegreesPerSecondSquared(QuantityValue d double value = (double) degreespersecondsquared; return new RotationalAcceleration(value, RotationalAccelerationUnit.DegreePerSecondSquared); } + /// /// Creates a from . /// @@ -285,6 +286,7 @@ public static RotationalAcceleration FromRadiansPerSecondSquared(QuantityValue r double value = (double) radianspersecondsquared; return new RotationalAcceleration(value, RotationalAccelerationUnit.RadianPerSecondSquared); } + /// /// Creates a from . /// @@ -294,6 +296,7 @@ public static RotationalAcceleration FromRevolutionsPerMinutePerSecond(QuantityV double value = (double) revolutionsperminutepersecond; return new RotationalAcceleration(value, RotationalAccelerationUnit.RevolutionPerMinutePerSecond); } + /// /// Creates a from . /// @@ -304,6 +307,7 @@ public static RotationalAcceleration FromRevolutionsPerSecondSquared(QuantityVal return new RotationalAcceleration(value, RotationalAccelerationUnit.RevolutionPerSecondSquared); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs index 527a442545..8832c6a527 100644 --- a/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs @@ -369,6 +369,7 @@ public static RotationalSpeed FromCentiradiansPerSecond(QuantityValue centiradia double value = (double) centiradianspersecond; return new RotationalSpeed(value, RotationalSpeedUnit.CentiradianPerSecond); } + /// /// Creates a from . /// @@ -378,6 +379,7 @@ public static RotationalSpeed FromDeciradiansPerSecond(QuantityValue deciradians double value = (double) deciradianspersecond; return new RotationalSpeed(value, RotationalSpeedUnit.DeciradianPerSecond); } + /// /// Creates a from . /// @@ -387,6 +389,7 @@ public static RotationalSpeed FromDegreesPerMinute(QuantityValue degreesperminut double value = (double) degreesperminute; return new RotationalSpeed(value, RotationalSpeedUnit.DegreePerMinute); } + /// /// Creates a from . /// @@ -396,6 +399,7 @@ public static RotationalSpeed FromDegreesPerSecond(QuantityValue degreespersecon double value = (double) degreespersecond; return new RotationalSpeed(value, RotationalSpeedUnit.DegreePerSecond); } + /// /// Creates a from . /// @@ -405,6 +409,7 @@ public static RotationalSpeed FromMicrodegreesPerSecond(QuantityValue microdegre double value = (double) microdegreespersecond; return new RotationalSpeed(value, RotationalSpeedUnit.MicrodegreePerSecond); } + /// /// Creates a from . /// @@ -414,6 +419,7 @@ public static RotationalSpeed FromMicroradiansPerSecond(QuantityValue microradia double value = (double) microradianspersecond; return new RotationalSpeed(value, RotationalSpeedUnit.MicroradianPerSecond); } + /// /// Creates a from . /// @@ -423,6 +429,7 @@ public static RotationalSpeed FromMillidegreesPerSecond(QuantityValue millidegre double value = (double) millidegreespersecond; return new RotationalSpeed(value, RotationalSpeedUnit.MillidegreePerSecond); } + /// /// Creates a from . /// @@ -432,6 +439,7 @@ public static RotationalSpeed FromMilliradiansPerSecond(QuantityValue milliradia double value = (double) milliradianspersecond; return new RotationalSpeed(value, RotationalSpeedUnit.MilliradianPerSecond); } + /// /// Creates a from . /// @@ -441,6 +449,7 @@ public static RotationalSpeed FromNanodegreesPerSecond(QuantityValue nanodegrees double value = (double) nanodegreespersecond; return new RotationalSpeed(value, RotationalSpeedUnit.NanodegreePerSecond); } + /// /// Creates a from . /// @@ -450,6 +459,7 @@ public static RotationalSpeed FromNanoradiansPerSecond(QuantityValue nanoradians double value = (double) nanoradianspersecond; return new RotationalSpeed(value, RotationalSpeedUnit.NanoradianPerSecond); } + /// /// Creates a from . /// @@ -459,6 +469,7 @@ public static RotationalSpeed FromRadiansPerSecond(QuantityValue radianspersecon double value = (double) radianspersecond; return new RotationalSpeed(value, RotationalSpeedUnit.RadianPerSecond); } + /// /// Creates a from . /// @@ -468,6 +479,7 @@ public static RotationalSpeed FromRevolutionsPerMinute(QuantityValue revolutions double value = (double) revolutionsperminute; return new RotationalSpeed(value, RotationalSpeedUnit.RevolutionPerMinute); } + /// /// Creates a from . /// @@ -478,6 +490,7 @@ public static RotationalSpeed FromRevolutionsPerSecond(QuantityValue revolutions return new RotationalSpeed(value, RotationalSpeedUnit.RevolutionPerSecond); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs index 73bf8be2fb..19337b091d 100644 --- a/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs @@ -537,6 +537,7 @@ public static RotationalStiffness FromCentinewtonMetersPerDegree(QuantityValue c double value = (double) centinewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.CentinewtonMeterPerDegree); } + /// /// Creates a from . /// @@ -546,6 +547,7 @@ public static RotationalStiffness FromCentinewtonMillimetersPerDegree(QuantityVa double value = (double) centinewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.CentinewtonMillimeterPerDegree); } + /// /// Creates a from . /// @@ -555,6 +557,7 @@ public static RotationalStiffness FromCentinewtonMillimetersPerRadian(QuantityVa double value = (double) centinewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.CentinewtonMillimeterPerRadian); } + /// /// Creates a from . /// @@ -564,6 +567,7 @@ public static RotationalStiffness FromDecanewtonMetersPerDegree(QuantityValue de double value = (double) decanewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.DecanewtonMeterPerDegree); } + /// /// Creates a from . /// @@ -573,6 +577,7 @@ public static RotationalStiffness FromDecanewtonMillimetersPerDegree(QuantityVal double value = (double) decanewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.DecanewtonMillimeterPerDegree); } + /// /// Creates a from . /// @@ -582,6 +587,7 @@ public static RotationalStiffness FromDecanewtonMillimetersPerRadian(QuantityVal double value = (double) decanewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.DecanewtonMillimeterPerRadian); } + /// /// Creates a from . /// @@ -591,6 +597,7 @@ public static RotationalStiffness FromDecinewtonMetersPerDegree(QuantityValue de double value = (double) decinewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.DecinewtonMeterPerDegree); } + /// /// Creates a from . /// @@ -600,6 +607,7 @@ public static RotationalStiffness FromDecinewtonMillimetersPerDegree(QuantityVal double value = (double) decinewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.DecinewtonMillimeterPerDegree); } + /// /// Creates a from . /// @@ -609,6 +617,7 @@ public static RotationalStiffness FromDecinewtonMillimetersPerRadian(QuantityVal double value = (double) decinewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.DecinewtonMillimeterPerRadian); } + /// /// Creates a from . /// @@ -618,6 +627,7 @@ public static RotationalStiffness FromKilonewtonMetersPerDegree(QuantityValue ki double value = (double) kilonewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMeterPerDegree); } + /// /// Creates a from . /// @@ -627,6 +637,7 @@ public static RotationalStiffness FromKilonewtonMetersPerRadian(QuantityValue ki double value = (double) kilonewtonmetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMeterPerRadian); } + /// /// Creates a from . /// @@ -636,6 +647,7 @@ public static RotationalStiffness FromKilonewtonMillimetersPerDegree(QuantityVal double value = (double) kilonewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMillimeterPerDegree); } + /// /// Creates a from . /// @@ -645,6 +657,7 @@ public static RotationalStiffness FromKilonewtonMillimetersPerRadian(QuantityVal double value = (double) kilonewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMillimeterPerRadian); } + /// /// Creates a from . /// @@ -654,6 +667,7 @@ public static RotationalStiffness FromKilopoundForceFeetPerDegrees(QuantityValue double value = (double) kilopoundforcefeetperdegrees; return new RotationalStiffness(value, RotationalStiffnessUnit.KilopoundForceFootPerDegrees); } + /// /// Creates a from . /// @@ -663,6 +677,7 @@ public static RotationalStiffness FromMeganewtonMetersPerDegree(QuantityValue me double value = (double) meganewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMeterPerDegree); } + /// /// Creates a from . /// @@ -672,6 +687,7 @@ public static RotationalStiffness FromMeganewtonMetersPerRadian(QuantityValue me double value = (double) meganewtonmetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMeterPerRadian); } + /// /// Creates a from . /// @@ -681,6 +697,7 @@ public static RotationalStiffness FromMeganewtonMillimetersPerDegree(QuantityVal double value = (double) meganewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMillimeterPerDegree); } + /// /// Creates a from . /// @@ -690,6 +707,7 @@ public static RotationalStiffness FromMeganewtonMillimetersPerRadian(QuantityVal double value = (double) meganewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMillimeterPerRadian); } + /// /// Creates a from . /// @@ -699,6 +717,7 @@ public static RotationalStiffness FromMicronewtonMetersPerDegree(QuantityValue m double value = (double) micronewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.MicronewtonMeterPerDegree); } + /// /// Creates a from . /// @@ -708,6 +727,7 @@ public static RotationalStiffness FromMicronewtonMillimetersPerDegree(QuantityVa double value = (double) micronewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.MicronewtonMillimeterPerDegree); } + /// /// Creates a from . /// @@ -717,6 +737,7 @@ public static RotationalStiffness FromMicronewtonMillimetersPerRadian(QuantityVa double value = (double) micronewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.MicronewtonMillimeterPerRadian); } + /// /// Creates a from . /// @@ -726,6 +747,7 @@ public static RotationalStiffness FromMillinewtonMetersPerDegree(QuantityValue m double value = (double) millinewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.MillinewtonMeterPerDegree); } + /// /// Creates a from . /// @@ -735,6 +757,7 @@ public static RotationalStiffness FromMillinewtonMillimetersPerDegree(QuantityVa double value = (double) millinewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.MillinewtonMillimeterPerDegree); } + /// /// Creates a from . /// @@ -744,6 +767,7 @@ public static RotationalStiffness FromMillinewtonMillimetersPerRadian(QuantityVa double value = (double) millinewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.MillinewtonMillimeterPerRadian); } + /// /// Creates a from . /// @@ -753,6 +777,7 @@ public static RotationalStiffness FromNanonewtonMetersPerDegree(QuantityValue na double value = (double) nanonewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.NanonewtonMeterPerDegree); } + /// /// Creates a from . /// @@ -762,6 +787,7 @@ public static RotationalStiffness FromNanonewtonMillimetersPerDegree(QuantityVal double value = (double) nanonewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.NanonewtonMillimeterPerDegree); } + /// /// Creates a from . /// @@ -771,6 +797,7 @@ public static RotationalStiffness FromNanonewtonMillimetersPerRadian(QuantityVal double value = (double) nanonewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.NanonewtonMillimeterPerRadian); } + /// /// Creates a from . /// @@ -780,6 +807,7 @@ public static RotationalStiffness FromNewtonMetersPerDegree(QuantityValue newton double value = (double) newtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMeterPerDegree); } + /// /// Creates a from . /// @@ -789,6 +817,7 @@ public static RotationalStiffness FromNewtonMetersPerRadian(QuantityValue newton double value = (double) newtonmetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMeterPerRadian); } + /// /// Creates a from . /// @@ -798,6 +827,7 @@ public static RotationalStiffness FromNewtonMillimetersPerDegree(QuantityValue n double value = (double) newtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMillimeterPerDegree); } + /// /// Creates a from . /// @@ -807,6 +837,7 @@ public static RotationalStiffness FromNewtonMillimetersPerRadian(QuantityValue n double value = (double) newtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMillimeterPerRadian); } + /// /// Creates a from . /// @@ -816,6 +847,7 @@ public static RotationalStiffness FromPoundForceFeetPerRadian(QuantityValue poun double value = (double) poundforcefeetperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.PoundForceFeetPerRadian); } + /// /// Creates a from . /// @@ -826,6 +858,7 @@ public static RotationalStiffness FromPoundForceFeetPerDegrees(QuantityValue pou return new RotationalStiffness(value, RotationalStiffnessUnit.PoundForceFootPerDegrees); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs index 230bb1b067..24dfd83bb4 100644 --- a/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs @@ -285,6 +285,7 @@ public static RotationalStiffnessPerLength FromKilonewtonMetersPerRadianPerMeter double value = (double) kilonewtonmetersperradianpermeter; return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter); } + /// /// Creates a from . /// @@ -294,6 +295,7 @@ public static RotationalStiffnessPerLength FromKilopoundForceFeetPerDegreesPerFe double value = (double) kilopoundforcefeetperdegreesperfeet; return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot); } + /// /// Creates a from . /// @@ -303,6 +305,7 @@ public static RotationalStiffnessPerLength FromMeganewtonMetersPerRadianPerMeter double value = (double) meganewtonmetersperradianpermeter; return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter); } + /// /// Creates a from . /// @@ -312,6 +315,7 @@ public static RotationalStiffnessPerLength FromNewtonMetersPerRadianPerMeter(Qua double value = (double) newtonmetersperradianpermeter; return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter); } + /// /// Creates a from . /// @@ -322,6 +326,7 @@ public static RotationalStiffnessPerLength FromPoundForceFeetPerDegreesPerFeet(Q return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Scalar.g.cs b/UnitsNet/GeneratedCode/Quantities/Scalar.g.cs index 44edb659f9..db37c8508b 100644 --- a/UnitsNet/GeneratedCode/Quantities/Scalar.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Scalar.g.cs @@ -250,6 +250,7 @@ public static Scalar FromAmount(QuantityValue amount) return new Scalar(value, ScalarUnit.Amount); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/SolidAngle.g.cs b/UnitsNet/GeneratedCode/Quantities/SolidAngle.g.cs index 6d5d002521..b5f7bbdbd1 100644 --- a/UnitsNet/GeneratedCode/Quantities/SolidAngle.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/SolidAngle.g.cs @@ -253,6 +253,7 @@ public static SolidAngle FromSteradians(QuantityValue steradians) return new SolidAngle(value, SolidAngleUnit.Steradian); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs index 7d2c789231..4a0f7d1321 100644 --- a/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs @@ -468,6 +468,7 @@ public static SpecificEnergy FromBtuPerPound(QuantityValue btuperpound) double value = (double) btuperpound; return new SpecificEnergy(value, SpecificEnergyUnit.BtuPerPound); } + /// /// Creates a from . /// @@ -477,6 +478,7 @@ public static SpecificEnergy FromCaloriesPerGram(QuantityValue caloriespergram) double value = (double) caloriespergram; return new SpecificEnergy(value, SpecificEnergyUnit.CaloriePerGram); } + /// /// Creates a from . /// @@ -486,6 +488,7 @@ public static SpecificEnergy FromGigawattDaysPerKilogram(QuantityValue gigawattd double value = (double) gigawattdaysperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.GigawattDayPerKilogram); } + /// /// Creates a from . /// @@ -495,6 +498,7 @@ public static SpecificEnergy FromGigawattDaysPerShortTon(QuantityValue gigawattd double value = (double) gigawattdayspershortton; return new SpecificEnergy(value, SpecificEnergyUnit.GigawattDayPerShortTon); } + /// /// Creates a from . /// @@ -504,6 +508,7 @@ public static SpecificEnergy FromGigawattDaysPerTonne(QuantityValue gigawattdays double value = (double) gigawattdayspertonne; return new SpecificEnergy(value, SpecificEnergyUnit.GigawattDayPerTonne); } + /// /// Creates a from . /// @@ -513,6 +518,7 @@ public static SpecificEnergy FromGigawattHoursPerKilogram(QuantityValue gigawatt double value = (double) gigawatthoursperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.GigawattHourPerKilogram); } + /// /// Creates a from . /// @@ -522,6 +528,7 @@ public static SpecificEnergy FromJoulesPerKilogram(QuantityValue joulesperkilogr double value = (double) joulesperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.JoulePerKilogram); } + /// /// Creates a from . /// @@ -531,6 +538,7 @@ public static SpecificEnergy FromKilocaloriesPerGram(QuantityValue kilocaloriesp double value = (double) kilocaloriespergram; return new SpecificEnergy(value, SpecificEnergyUnit.KilocaloriePerGram); } + /// /// Creates a from . /// @@ -540,6 +548,7 @@ public static SpecificEnergy FromKilojoulesPerKilogram(QuantityValue kilojoulesp double value = (double) kilojoulesperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.KilojoulePerKilogram); } + /// /// Creates a from . /// @@ -549,6 +558,7 @@ public static SpecificEnergy FromKilowattDaysPerKilogram(QuantityValue kilowattd double value = (double) kilowattdaysperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.KilowattDayPerKilogram); } + /// /// Creates a from . /// @@ -558,6 +568,7 @@ public static SpecificEnergy FromKilowattDaysPerShortTon(QuantityValue kilowattd double value = (double) kilowattdayspershortton; return new SpecificEnergy(value, SpecificEnergyUnit.KilowattDayPerShortTon); } + /// /// Creates a from . /// @@ -567,6 +578,7 @@ public static SpecificEnergy FromKilowattDaysPerTonne(QuantityValue kilowattdays double value = (double) kilowattdayspertonne; return new SpecificEnergy(value, SpecificEnergyUnit.KilowattDayPerTonne); } + /// /// Creates a from . /// @@ -576,6 +588,7 @@ public static SpecificEnergy FromKilowattHoursPerKilogram(QuantityValue kilowatt double value = (double) kilowatthoursperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.KilowattHourPerKilogram); } + /// /// Creates a from . /// @@ -585,6 +598,7 @@ public static SpecificEnergy FromMegajoulesPerKilogram(QuantityValue megajoulesp double value = (double) megajoulesperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.MegajoulePerKilogram); } + /// /// Creates a from . /// @@ -594,6 +608,7 @@ public static SpecificEnergy FromMegawattDaysPerKilogram(QuantityValue megawattd double value = (double) megawattdaysperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.MegawattDayPerKilogram); } + /// /// Creates a from . /// @@ -603,6 +618,7 @@ public static SpecificEnergy FromMegawattDaysPerShortTon(QuantityValue megawattd double value = (double) megawattdayspershortton; return new SpecificEnergy(value, SpecificEnergyUnit.MegawattDayPerShortTon); } + /// /// Creates a from . /// @@ -612,6 +628,7 @@ public static SpecificEnergy FromMegawattDaysPerTonne(QuantityValue megawattdays double value = (double) megawattdayspertonne; return new SpecificEnergy(value, SpecificEnergyUnit.MegawattDayPerTonne); } + /// /// Creates a from . /// @@ -621,6 +638,7 @@ public static SpecificEnergy FromMegawattHoursPerKilogram(QuantityValue megawatt double value = (double) megawatthoursperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.MegawattHourPerKilogram); } + /// /// Creates a from . /// @@ -630,6 +648,7 @@ public static SpecificEnergy FromTerawattDaysPerKilogram(QuantityValue terawattd double value = (double) terawattdaysperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.TerawattDayPerKilogram); } + /// /// Creates a from . /// @@ -639,6 +658,7 @@ public static SpecificEnergy FromTerawattDaysPerShortTon(QuantityValue terawattd double value = (double) terawattdayspershortton; return new SpecificEnergy(value, SpecificEnergyUnit.TerawattDayPerShortTon); } + /// /// Creates a from . /// @@ -648,6 +668,7 @@ public static SpecificEnergy FromTerawattDaysPerTonne(QuantityValue terawattdays double value = (double) terawattdayspertonne; return new SpecificEnergy(value, SpecificEnergyUnit.TerawattDayPerTonne); } + /// /// Creates a from . /// @@ -657,6 +678,7 @@ public static SpecificEnergy FromWattDaysPerKilogram(QuantityValue wattdaysperki double value = (double) wattdaysperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.WattDayPerKilogram); } + /// /// Creates a from . /// @@ -666,6 +688,7 @@ public static SpecificEnergy FromWattDaysPerShortTon(QuantityValue wattdayspersh double value = (double) wattdayspershortton; return new SpecificEnergy(value, SpecificEnergyUnit.WattDayPerShortTon); } + /// /// Creates a from . /// @@ -675,6 +698,7 @@ public static SpecificEnergy FromWattDaysPerTonne(QuantityValue wattdayspertonne double value = (double) wattdayspertonne; return new SpecificEnergy(value, SpecificEnergyUnit.WattDayPerTonne); } + /// /// Creates a from . /// @@ -685,6 +709,7 @@ public static SpecificEnergy FromWattHoursPerKilogram(QuantityValue watthoursper return new SpecificEnergy(value, SpecificEnergyUnit.WattHourPerKilogram); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs index 883b0d3d0e..7709632644 100644 --- a/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs @@ -321,6 +321,7 @@ public static SpecificEntropy FromBtusPerPoundFahrenheit(QuantityValue btusperpo double value = (double) btusperpoundfahrenheit; return new SpecificEntropy(value, SpecificEntropyUnit.BtuPerPoundFahrenheit); } + /// /// Creates a from . /// @@ -330,6 +331,7 @@ public static SpecificEntropy FromCaloriesPerGramKelvin(QuantityValue caloriespe double value = (double) caloriespergramkelvin; return new SpecificEntropy(value, SpecificEntropyUnit.CaloriePerGramKelvin); } + /// /// Creates a from . /// @@ -339,6 +341,7 @@ public static SpecificEntropy FromJoulesPerKilogramDegreeCelsius(QuantityValue j double value = (double) joulesperkilogramdegreecelsius; return new SpecificEntropy(value, SpecificEntropyUnit.JoulePerKilogramDegreeCelsius); } + /// /// Creates a from . /// @@ -348,6 +351,7 @@ public static SpecificEntropy FromJoulesPerKilogramKelvin(QuantityValue joulespe double value = (double) joulesperkilogramkelvin; return new SpecificEntropy(value, SpecificEntropyUnit.JoulePerKilogramKelvin); } + /// /// Creates a from . /// @@ -357,6 +361,7 @@ public static SpecificEntropy FromKilocaloriesPerGramKelvin(QuantityValue kiloca double value = (double) kilocaloriespergramkelvin; return new SpecificEntropy(value, SpecificEntropyUnit.KilocaloriePerGramKelvin); } + /// /// Creates a from . /// @@ -366,6 +371,7 @@ public static SpecificEntropy FromKilojoulesPerKilogramDegreeCelsius(QuantityVal double value = (double) kilojoulesperkilogramdegreecelsius; return new SpecificEntropy(value, SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius); } + /// /// Creates a from . /// @@ -375,6 +381,7 @@ public static SpecificEntropy FromKilojoulesPerKilogramKelvin(QuantityValue kilo double value = (double) kilojoulesperkilogramkelvin; return new SpecificEntropy(value, SpecificEntropyUnit.KilojoulePerKilogramKelvin); } + /// /// Creates a from . /// @@ -384,6 +391,7 @@ public static SpecificEntropy FromMegajoulesPerKilogramDegreeCelsius(QuantityVal double value = (double) megajoulesperkilogramdegreecelsius; return new SpecificEntropy(value, SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius); } + /// /// Creates a from . /// @@ -394,6 +402,7 @@ public static SpecificEntropy FromMegajoulesPerKilogramKelvin(QuantityValue mega return new SpecificEntropy(value, SpecificEntropyUnit.MegajoulePerKilogramKelvin); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs index ea508e7b18..0daaab6688 100644 --- a/UnitsNet/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs @@ -279,6 +279,7 @@ public static SpecificFuelConsumption FromGramsPerKiloNewtonSecond(QuantityValue double value = (double) gramsperkilonewtonsecond; return new SpecificFuelConsumption(value, SpecificFuelConsumptionUnit.GramPerKiloNewtonSecond); } + /// /// Creates a from . /// @@ -288,6 +289,7 @@ public static SpecificFuelConsumption FromKilogramsPerKilogramForceHour(Quantity double value = (double) kilogramsperkilogramforcehour; return new SpecificFuelConsumption(value, SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour); } + /// /// Creates a from . /// @@ -297,6 +299,7 @@ public static SpecificFuelConsumption FromKilogramsPerKiloNewtonSecond(QuantityV double value = (double) kilogramsperkilonewtonsecond; return new SpecificFuelConsumption(value, SpecificFuelConsumptionUnit.KilogramPerKiloNewtonSecond); } + /// /// Creates a from . /// @@ -307,6 +310,7 @@ public static SpecificFuelConsumption FromPoundsMassPerPoundForceHour(QuantityVa return new SpecificFuelConsumption(value, SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs index 86c287dd0c..424aef46f2 100644 --- a/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs @@ -267,6 +267,7 @@ public static SpecificVolume FromCubicFeetPerPound(QuantityValue cubicfeetperpou double value = (double) cubicfeetperpound; return new SpecificVolume(value, SpecificVolumeUnit.CubicFootPerPound); } + /// /// Creates a from . /// @@ -276,6 +277,7 @@ public static SpecificVolume FromCubicMetersPerKilogram(QuantityValue cubicmeter double value = (double) cubicmetersperkilogram; return new SpecificVolume(value, SpecificVolumeUnit.CubicMeterPerKilogram); } + /// /// Creates a from . /// @@ -286,6 +288,7 @@ public static SpecificVolume FromMillicubicMetersPerKilogram(QuantityValue milli return new SpecificVolume(value, SpecificVolumeUnit.MillicubicMeterPerKilogram); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs index 8c54b7863b..db728b0a88 100644 --- a/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs @@ -396,6 +396,7 @@ public static SpecificWeight FromKilogramsForcePerCubicCentimeter(QuantityValue double value = (double) kilogramsforcepercubiccentimeter; return new SpecificWeight(value, SpecificWeightUnit.KilogramForcePerCubicCentimeter); } + /// /// Creates a from . /// @@ -405,6 +406,7 @@ public static SpecificWeight FromKilogramsForcePerCubicMeter(QuantityValue kilog double value = (double) kilogramsforcepercubicmeter; return new SpecificWeight(value, SpecificWeightUnit.KilogramForcePerCubicMeter); } + /// /// Creates a from . /// @@ -414,6 +416,7 @@ public static SpecificWeight FromKilogramsForcePerCubicMillimeter(QuantityValue double value = (double) kilogramsforcepercubicmillimeter; return new SpecificWeight(value, SpecificWeightUnit.KilogramForcePerCubicMillimeter); } + /// /// Creates a from . /// @@ -423,6 +426,7 @@ public static SpecificWeight FromKilonewtonsPerCubicCentimeter(QuantityValue kil double value = (double) kilonewtonspercubiccentimeter; return new SpecificWeight(value, SpecificWeightUnit.KilonewtonPerCubicCentimeter); } + /// /// Creates a from . /// @@ -432,6 +436,7 @@ public static SpecificWeight FromKilonewtonsPerCubicMeter(QuantityValue kilonewt double value = (double) kilonewtonspercubicmeter; return new SpecificWeight(value, SpecificWeightUnit.KilonewtonPerCubicMeter); } + /// /// Creates a from . /// @@ -441,6 +446,7 @@ public static SpecificWeight FromKilonewtonsPerCubicMillimeter(QuantityValue kil double value = (double) kilonewtonspercubicmillimeter; return new SpecificWeight(value, SpecificWeightUnit.KilonewtonPerCubicMillimeter); } + /// /// Creates a from . /// @@ -450,6 +456,7 @@ public static SpecificWeight FromKilopoundsForcePerCubicFoot(QuantityValue kilop double value = (double) kilopoundsforcepercubicfoot; return new SpecificWeight(value, SpecificWeightUnit.KilopoundForcePerCubicFoot); } + /// /// Creates a from . /// @@ -459,6 +466,7 @@ public static SpecificWeight FromKilopoundsForcePerCubicInch(QuantityValue kilop double value = (double) kilopoundsforcepercubicinch; return new SpecificWeight(value, SpecificWeightUnit.KilopoundForcePerCubicInch); } + /// /// Creates a from . /// @@ -468,6 +476,7 @@ public static SpecificWeight FromMeganewtonsPerCubicMeter(QuantityValue meganewt double value = (double) meganewtonspercubicmeter; return new SpecificWeight(value, SpecificWeightUnit.MeganewtonPerCubicMeter); } + /// /// Creates a from . /// @@ -477,6 +486,7 @@ public static SpecificWeight FromNewtonsPerCubicCentimeter(QuantityValue newtons double value = (double) newtonspercubiccentimeter; return new SpecificWeight(value, SpecificWeightUnit.NewtonPerCubicCentimeter); } + /// /// Creates a from . /// @@ -486,6 +496,7 @@ public static SpecificWeight FromNewtonsPerCubicMeter(QuantityValue newtonspercu double value = (double) newtonspercubicmeter; return new SpecificWeight(value, SpecificWeightUnit.NewtonPerCubicMeter); } + /// /// Creates a from . /// @@ -495,6 +506,7 @@ public static SpecificWeight FromNewtonsPerCubicMillimeter(QuantityValue newtons double value = (double) newtonspercubicmillimeter; return new SpecificWeight(value, SpecificWeightUnit.NewtonPerCubicMillimeter); } + /// /// Creates a from . /// @@ -504,6 +516,7 @@ public static SpecificWeight FromPoundsForcePerCubicFoot(QuantityValue poundsfor double value = (double) poundsforcepercubicfoot; return new SpecificWeight(value, SpecificWeightUnit.PoundForcePerCubicFoot); } + /// /// Creates a from . /// @@ -513,6 +526,7 @@ public static SpecificWeight FromPoundsForcePerCubicInch(QuantityValue poundsfor double value = (double) poundsforcepercubicinch; return new SpecificWeight(value, SpecificWeightUnit.PoundForcePerCubicInch); } + /// /// Creates a from . /// @@ -522,6 +536,7 @@ public static SpecificWeight FromTonnesForcePerCubicCentimeter(QuantityValue ton double value = (double) tonnesforcepercubiccentimeter; return new SpecificWeight(value, SpecificWeightUnit.TonneForcePerCubicCentimeter); } + /// /// Creates a from . /// @@ -531,6 +546,7 @@ public static SpecificWeight FromTonnesForcePerCubicMeter(QuantityValue tonnesfo double value = (double) tonnesforcepercubicmeter; return new SpecificWeight(value, SpecificWeightUnit.TonneForcePerCubicMeter); } + /// /// Creates a from . /// @@ -541,6 +557,7 @@ public static SpecificWeight FromTonnesForcePerCubicMillimeter(QuantityValue ton return new SpecificWeight(value, SpecificWeightUnit.TonneForcePerCubicMillimeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Speed.g.cs b/UnitsNet/GeneratedCode/Quantities/Speed.g.cs index 939fe782cf..65213b9270 100644 --- a/UnitsNet/GeneratedCode/Quantities/Speed.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Speed.g.cs @@ -551,6 +551,7 @@ public static Speed FromCentimetersPerHour(QuantityValue centimetersperhour) double value = (double) centimetersperhour; return new Speed(value, SpeedUnit.CentimeterPerHour); } + /// /// Creates a from . /// @@ -560,6 +561,7 @@ public static Speed FromCentimetersPerMinutes(QuantityValue centimetersperminute double value = (double) centimetersperminutes; return new Speed(value, SpeedUnit.CentimeterPerMinute); } + /// /// Creates a from . /// @@ -569,6 +571,7 @@ public static Speed FromCentimetersPerSecond(QuantityValue centimeterspersecond) double value = (double) centimeterspersecond; return new Speed(value, SpeedUnit.CentimeterPerSecond); } + /// /// Creates a from . /// @@ -578,6 +581,7 @@ public static Speed FromDecimetersPerMinutes(QuantityValue decimetersperminutes) double value = (double) decimetersperminutes; return new Speed(value, SpeedUnit.DecimeterPerMinute); } + /// /// Creates a from . /// @@ -587,6 +591,7 @@ public static Speed FromDecimetersPerSecond(QuantityValue decimeterspersecond) double value = (double) decimeterspersecond; return new Speed(value, SpeedUnit.DecimeterPerSecond); } + /// /// Creates a from . /// @@ -596,6 +601,7 @@ public static Speed FromFeetPerHour(QuantityValue feetperhour) double value = (double) feetperhour; return new Speed(value, SpeedUnit.FootPerHour); } + /// /// Creates a from . /// @@ -605,6 +611,7 @@ public static Speed FromFeetPerMinute(QuantityValue feetperminute) double value = (double) feetperminute; return new Speed(value, SpeedUnit.FootPerMinute); } + /// /// Creates a from . /// @@ -614,6 +621,7 @@ public static Speed FromFeetPerSecond(QuantityValue feetpersecond) double value = (double) feetpersecond; return new Speed(value, SpeedUnit.FootPerSecond); } + /// /// Creates a from . /// @@ -623,6 +631,7 @@ public static Speed FromInchesPerHour(QuantityValue inchesperhour) double value = (double) inchesperhour; return new Speed(value, SpeedUnit.InchPerHour); } + /// /// Creates a from . /// @@ -632,6 +641,7 @@ public static Speed FromInchesPerMinute(QuantityValue inchesperminute) double value = (double) inchesperminute; return new Speed(value, SpeedUnit.InchPerMinute); } + /// /// Creates a from . /// @@ -641,6 +651,7 @@ public static Speed FromInchesPerSecond(QuantityValue inchespersecond) double value = (double) inchespersecond; return new Speed(value, SpeedUnit.InchPerSecond); } + /// /// Creates a from . /// @@ -650,6 +661,7 @@ public static Speed FromKilometersPerHour(QuantityValue kilometersperhour) double value = (double) kilometersperhour; return new Speed(value, SpeedUnit.KilometerPerHour); } + /// /// Creates a from . /// @@ -659,6 +671,7 @@ public static Speed FromKilometersPerMinutes(QuantityValue kilometersperminutes) double value = (double) kilometersperminutes; return new Speed(value, SpeedUnit.KilometerPerMinute); } + /// /// Creates a from . /// @@ -668,6 +681,7 @@ public static Speed FromKilometersPerSecond(QuantityValue kilometerspersecond) double value = (double) kilometerspersecond; return new Speed(value, SpeedUnit.KilometerPerSecond); } + /// /// Creates a from . /// @@ -677,6 +691,7 @@ public static Speed FromKnots(QuantityValue knots) double value = (double) knots; return new Speed(value, SpeedUnit.Knot); } + /// /// Creates a from . /// @@ -686,6 +701,7 @@ public static Speed FromMetersPerHour(QuantityValue metersperhour) double value = (double) metersperhour; return new Speed(value, SpeedUnit.MeterPerHour); } + /// /// Creates a from . /// @@ -695,6 +711,7 @@ public static Speed FromMetersPerMinutes(QuantityValue metersperminutes) double value = (double) metersperminutes; return new Speed(value, SpeedUnit.MeterPerMinute); } + /// /// Creates a from . /// @@ -704,6 +721,7 @@ public static Speed FromMetersPerSecond(QuantityValue meterspersecond) double value = (double) meterspersecond; return new Speed(value, SpeedUnit.MeterPerSecond); } + /// /// Creates a from . /// @@ -713,6 +731,7 @@ public static Speed FromMicrometersPerMinutes(QuantityValue micrometersperminute double value = (double) micrometersperminutes; return new Speed(value, SpeedUnit.MicrometerPerMinute); } + /// /// Creates a from . /// @@ -722,6 +741,7 @@ public static Speed FromMicrometersPerSecond(QuantityValue micrometerspersecond) double value = (double) micrometerspersecond; return new Speed(value, SpeedUnit.MicrometerPerSecond); } + /// /// Creates a from . /// @@ -731,6 +751,7 @@ public static Speed FromMilesPerHour(QuantityValue milesperhour) double value = (double) milesperhour; return new Speed(value, SpeedUnit.MilePerHour); } + /// /// Creates a from . /// @@ -740,6 +761,7 @@ public static Speed FromMillimetersPerHour(QuantityValue millimetersperhour) double value = (double) millimetersperhour; return new Speed(value, SpeedUnit.MillimeterPerHour); } + /// /// Creates a from . /// @@ -749,6 +771,7 @@ public static Speed FromMillimetersPerMinutes(QuantityValue millimetersperminute double value = (double) millimetersperminutes; return new Speed(value, SpeedUnit.MillimeterPerMinute); } + /// /// Creates a from . /// @@ -758,6 +781,7 @@ public static Speed FromMillimetersPerSecond(QuantityValue millimeterspersecond) double value = (double) millimeterspersecond; return new Speed(value, SpeedUnit.MillimeterPerSecond); } + /// /// Creates a from . /// @@ -767,6 +791,7 @@ public static Speed FromNanometersPerMinutes(QuantityValue nanometersperminutes) double value = (double) nanometersperminutes; return new Speed(value, SpeedUnit.NanometerPerMinute); } + /// /// Creates a from . /// @@ -776,6 +801,7 @@ public static Speed FromNanometersPerSecond(QuantityValue nanometerspersecond) double value = (double) nanometerspersecond; return new Speed(value, SpeedUnit.NanometerPerSecond); } + /// /// Creates a from . /// @@ -785,6 +811,7 @@ public static Speed FromUsSurveyFeetPerHour(QuantityValue ussurveyfeetperhour) double value = (double) ussurveyfeetperhour; return new Speed(value, SpeedUnit.UsSurveyFootPerHour); } + /// /// Creates a from . /// @@ -794,6 +821,7 @@ public static Speed FromUsSurveyFeetPerMinute(QuantityValue ussurveyfeetperminut double value = (double) ussurveyfeetperminute; return new Speed(value, SpeedUnit.UsSurveyFootPerMinute); } + /// /// Creates a from . /// @@ -803,6 +831,7 @@ public static Speed FromUsSurveyFeetPerSecond(QuantityValue ussurveyfeetpersecon double value = (double) ussurveyfeetpersecond; return new Speed(value, SpeedUnit.UsSurveyFootPerSecond); } + /// /// Creates a from . /// @@ -812,6 +841,7 @@ public static Speed FromYardsPerHour(QuantityValue yardsperhour) double value = (double) yardsperhour; return new Speed(value, SpeedUnit.YardPerHour); } + /// /// Creates a from . /// @@ -821,6 +851,7 @@ public static Speed FromYardsPerMinute(QuantityValue yardsperminute) double value = (double) yardsperminute; return new Speed(value, SpeedUnit.YardPerMinute); } + /// /// Creates a from . /// @@ -831,6 +862,7 @@ public static Speed FromYardsPerSecond(QuantityValue yardspersecond) return new Speed(value, SpeedUnit.YardPerSecond); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/StandardVolumeFlow.g.cs b/UnitsNet/GeneratedCode/Quantities/StandardVolumeFlow.g.cs index af05c0d894..fbe6d6e30c 100644 --- a/UnitsNet/GeneratedCode/Quantities/StandardVolumeFlow.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/StandardVolumeFlow.g.cs @@ -321,6 +321,7 @@ public static StandardVolumeFlow FromStandardCubicCentimetersPerMinute(QuantityV double value = (double) standardcubiccentimetersperminute; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute); } + /// /// Creates a from . /// @@ -330,6 +331,7 @@ public static StandardVolumeFlow FromStandardCubicFeetPerHour(QuantityValue stan double value = (double) standardcubicfeetperhour; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicFootPerHour); } + /// /// Creates a from . /// @@ -339,6 +341,7 @@ public static StandardVolumeFlow FromStandardCubicFeetPerMinute(QuantityValue st double value = (double) standardcubicfeetperminute; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicFootPerMinute); } + /// /// Creates a from . /// @@ -348,6 +351,7 @@ public static StandardVolumeFlow FromStandardCubicFeetPerSecond(QuantityValue st double value = (double) standardcubicfeetpersecond; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicFootPerSecond); } + /// /// Creates a from . /// @@ -357,6 +361,7 @@ public static StandardVolumeFlow FromStandardCubicMetersPerDay(QuantityValue sta double value = (double) standardcubicmetersperday; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicMeterPerDay); } + /// /// Creates a from . /// @@ -366,6 +371,7 @@ public static StandardVolumeFlow FromStandardCubicMetersPerHour(QuantityValue st double value = (double) standardcubicmetersperhour; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicMeterPerHour); } + /// /// Creates a from . /// @@ -375,6 +381,7 @@ public static StandardVolumeFlow FromStandardCubicMetersPerMinute(QuantityValue double value = (double) standardcubicmetersperminute; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicMeterPerMinute); } + /// /// Creates a from . /// @@ -384,6 +391,7 @@ public static StandardVolumeFlow FromStandardCubicMetersPerSecond(QuantityValue double value = (double) standardcubicmeterspersecond; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicMeterPerSecond); } + /// /// Creates a from . /// @@ -394,6 +402,7 @@ public static StandardVolumeFlow FromStandardLitersPerMinute(QuantityValue stand return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardLiterPerMinute); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs b/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs index a21afff6dd..c11ca2677a 100644 --- a/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs @@ -330,6 +330,7 @@ public static Temperature FromDegreesCelsius(QuantityValue degreescelsius) double value = (double) degreescelsius; return new Temperature(value, TemperatureUnit.DegreeCelsius); } + /// /// Creates a from . /// @@ -339,6 +340,7 @@ public static Temperature FromDegreesDelisle(QuantityValue degreesdelisle) double value = (double) degreesdelisle; return new Temperature(value, TemperatureUnit.DegreeDelisle); } + /// /// Creates a from . /// @@ -348,6 +350,7 @@ public static Temperature FromDegreesFahrenheit(QuantityValue degreesfahrenheit) double value = (double) degreesfahrenheit; return new Temperature(value, TemperatureUnit.DegreeFahrenheit); } + /// /// Creates a from . /// @@ -357,6 +360,7 @@ public static Temperature FromDegreesNewton(QuantityValue degreesnewton) double value = (double) degreesnewton; return new Temperature(value, TemperatureUnit.DegreeNewton); } + /// /// Creates a from . /// @@ -366,6 +370,7 @@ public static Temperature FromDegreesRankine(QuantityValue degreesrankine) double value = (double) degreesrankine; return new Temperature(value, TemperatureUnit.DegreeRankine); } + /// /// Creates a from . /// @@ -375,6 +380,7 @@ public static Temperature FromDegreesReaumur(QuantityValue degreesreaumur) double value = (double) degreesreaumur; return new Temperature(value, TemperatureUnit.DegreeReaumur); } + /// /// Creates a from . /// @@ -384,6 +390,7 @@ public static Temperature FromDegreesRoemer(QuantityValue degreesroemer) double value = (double) degreesroemer; return new Temperature(value, TemperatureUnit.DegreeRoemer); } + /// /// Creates a from . /// @@ -393,6 +400,7 @@ public static Temperature FromKelvins(QuantityValue kelvins) double value = (double) kelvins; return new Temperature(value, TemperatureUnit.Kelvin); } + /// /// Creates a from . /// @@ -402,6 +410,7 @@ public static Temperature FromMillidegreesCelsius(QuantityValue millidegreescels double value = (double) millidegreescelsius; return new Temperature(value, TemperatureUnit.MillidegreeCelsius); } + /// /// Creates a from . /// @@ -412,6 +421,7 @@ public static Temperature FromSolarTemperatures(QuantityValue solartemperatures) return new Temperature(value, TemperatureUnit.SolarTemperature); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs index 790299baeb..d55065ef84 100644 --- a/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs @@ -330,6 +330,7 @@ public static TemperatureChangeRate FromCentidegreesCelsiusPerSecond(QuantityVal double value = (double) centidegreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond); } + /// /// Creates a from . /// @@ -339,6 +340,7 @@ public static TemperatureChangeRate FromDecadegreesCelsiusPerSecond(QuantityValu double value = (double) decadegreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond); } + /// /// Creates a from . /// @@ -348,6 +350,7 @@ public static TemperatureChangeRate FromDecidegreesCelsiusPerSecond(QuantityValu double value = (double) decidegreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond); } + /// /// Creates a from . /// @@ -357,6 +360,7 @@ public static TemperatureChangeRate FromDegreesCelsiusPerMinute(QuantityValue de double value = (double) degreescelsiusperminute; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DegreeCelsiusPerMinute); } + /// /// Creates a from . /// @@ -366,6 +370,7 @@ public static TemperatureChangeRate FromDegreesCelsiusPerSecond(QuantityValue de double value = (double) degreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DegreeCelsiusPerSecond); } + /// /// Creates a from . /// @@ -375,6 +380,7 @@ public static TemperatureChangeRate FromHectodegreesCelsiusPerSecond(QuantityVal double value = (double) hectodegreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond); } + /// /// Creates a from . /// @@ -384,6 +390,7 @@ public static TemperatureChangeRate FromKilodegreesCelsiusPerSecond(QuantityValu double value = (double) kilodegreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond); } + /// /// Creates a from . /// @@ -393,6 +400,7 @@ public static TemperatureChangeRate FromMicrodegreesCelsiusPerSecond(QuantityVal double value = (double) microdegreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond); } + /// /// Creates a from . /// @@ -402,6 +410,7 @@ public static TemperatureChangeRate FromMillidegreesCelsiusPerSecond(QuantityVal double value = (double) millidegreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond); } + /// /// Creates a from . /// @@ -412,6 +421,7 @@ public static TemperatureChangeRate FromNanodegreesCelsiusPerSecond(QuantityValu return new TemperatureChangeRate(value, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs index 850fd56478..aa64194385 100644 --- a/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs @@ -321,6 +321,7 @@ public static TemperatureDelta FromDegreesCelsius(QuantityValue degreescelsius) double value = (double) degreescelsius; return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeCelsius); } + /// /// Creates a from . /// @@ -330,6 +331,7 @@ public static TemperatureDelta FromDegreesDelisle(QuantityValue degreesdelisle) double value = (double) degreesdelisle; return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeDelisle); } + /// /// Creates a from . /// @@ -339,6 +341,7 @@ public static TemperatureDelta FromDegreesFahrenheit(QuantityValue degreesfahren double value = (double) degreesfahrenheit; return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeFahrenheit); } + /// /// Creates a from . /// @@ -348,6 +351,7 @@ public static TemperatureDelta FromDegreesNewton(QuantityValue degreesnewton) double value = (double) degreesnewton; return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeNewton); } + /// /// Creates a from . /// @@ -357,6 +361,7 @@ public static TemperatureDelta FromDegreesRankine(QuantityValue degreesrankine) double value = (double) degreesrankine; return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeRankine); } + /// /// Creates a from . /// @@ -366,6 +371,7 @@ public static TemperatureDelta FromDegreesReaumur(QuantityValue degreesreaumur) double value = (double) degreesreaumur; return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeReaumur); } + /// /// Creates a from . /// @@ -375,6 +381,7 @@ public static TemperatureDelta FromDegreesRoemer(QuantityValue degreesroemer) double value = (double) degreesroemer; return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeRoemer); } + /// /// Creates a from . /// @@ -384,6 +391,7 @@ public static TemperatureDelta FromKelvins(QuantityValue kelvins) double value = (double) kelvins; return new TemperatureDelta(value, TemperatureDeltaUnit.Kelvin); } + /// /// Creates a from . /// @@ -394,6 +402,7 @@ public static TemperatureDelta FromMillidegreesCelsius(QuantityValue millidegree return new TemperatureDelta(value, TemperatureDeltaUnit.MillidegreeCelsius); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureGradient.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureGradient.g.cs index 92b5abf18b..27a669415f 100644 --- a/UnitsNet/GeneratedCode/Quantities/TemperatureGradient.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/TemperatureGradient.g.cs @@ -276,6 +276,7 @@ public static TemperatureGradient FromDegreesCelciusPerKilometer(QuantityValue d double value = (double) degreescelciusperkilometer; return new TemperatureGradient(value, TemperatureGradientUnit.DegreeCelsiusPerKilometer); } + /// /// Creates a from . /// @@ -285,6 +286,7 @@ public static TemperatureGradient FromDegreesCelciusPerMeter(QuantityValue degre double value = (double) degreescelciuspermeter; return new TemperatureGradient(value, TemperatureGradientUnit.DegreeCelsiusPerMeter); } + /// /// Creates a from . /// @@ -294,6 +296,7 @@ public static TemperatureGradient FromDegreesFahrenheitPerFoot(QuantityValue deg double value = (double) degreesfahrenheitperfoot; return new TemperatureGradient(value, TemperatureGradientUnit.DegreeFahrenheitPerFoot); } + /// /// Creates a from . /// @@ -304,6 +307,7 @@ public static TemperatureGradient FromKelvinsPerMeter(QuantityValue kelvinsperme return new TemperatureGradient(value, TemperatureGradientUnit.KelvinPerMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs b/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs index f852ee5dd2..1d15a03af8 100644 --- a/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs @@ -261,6 +261,7 @@ public static ThermalConductivity FromBtusPerHourFootFahrenheit(QuantityValue bt double value = (double) btusperhourfootfahrenheit; return new ThermalConductivity(value, ThermalConductivityUnit.BtuPerHourFootFahrenheit); } + /// /// Creates a from . /// @@ -271,6 +272,7 @@ public static ThermalConductivity FromWattsPerMeterKelvin(QuantityValue wattsper return new ThermalConductivity(value, ThermalConductivityUnit.WattPerMeterKelvin); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ThermalResistance.g.cs b/UnitsNet/GeneratedCode/Quantities/ThermalResistance.g.cs index cff035c488..51a64ddf05 100644 --- a/UnitsNet/GeneratedCode/Quantities/ThermalResistance.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ThermalResistance.g.cs @@ -294,6 +294,7 @@ public static ThermalResistance FromHourSquareFeetDegreesFahrenheitPerBtu(Quanti double value = (double) hoursquarefeetdegreesfahrenheitperbtu; return new ThermalResistance(value, ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu); } + /// /// Creates a from . /// @@ -303,6 +304,7 @@ public static ThermalResistance FromSquareCentimeterHourDegreesCelsiusPerKilocal double value = (double) squarecentimeterhourdegreescelsiusperkilocalorie; return new ThermalResistance(value, ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie); } + /// /// Creates a from . /// @@ -312,6 +314,7 @@ public static ThermalResistance FromSquareCentimeterKelvinsPerWatt(QuantityValue double value = (double) squarecentimeterkelvinsperwatt; return new ThermalResistance(value, ThermalResistanceUnit.SquareCentimeterKelvinPerWatt); } + /// /// Creates a from . /// @@ -321,6 +324,7 @@ public static ThermalResistance FromSquareMeterDegreesCelsiusPerWatt(QuantityVal double value = (double) squaremeterdegreescelsiusperwatt; return new ThermalResistance(value, ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt); } + /// /// Creates a from . /// @@ -330,6 +334,7 @@ public static ThermalResistance FromSquareMeterKelvinsPerKilowatt(QuantityValue double value = (double) squaremeterkelvinsperkilowatt; return new ThermalResistance(value, ThermalResistanceUnit.SquareMeterKelvinPerKilowatt); } + /// /// Creates a from . /// @@ -340,6 +345,7 @@ public static ThermalResistance FromSquareMeterKelvinsPerWatt(QuantityValue squa return new ThermalResistance(value, ThermalResistanceUnit.SquareMeterKelvinPerWatt); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Torque.g.cs b/UnitsNet/GeneratedCode/Quantities/Torque.g.cs index 95d588d2e9..259523e65c 100644 --- a/UnitsNet/GeneratedCode/Quantities/Torque.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Torque.g.cs @@ -468,6 +468,7 @@ public static Torque FromGramForceCentimeters(QuantityValue gramforcecentimeters double value = (double) gramforcecentimeters; return new Torque(value, TorqueUnit.GramForceCentimeter); } + /// /// Creates a from . /// @@ -477,6 +478,7 @@ public static Torque FromGramForceMeters(QuantityValue gramforcemeters) double value = (double) gramforcemeters; return new Torque(value, TorqueUnit.GramForceMeter); } + /// /// Creates a from . /// @@ -486,6 +488,7 @@ public static Torque FromGramForceMillimeters(QuantityValue gramforcemillimeters double value = (double) gramforcemillimeters; return new Torque(value, TorqueUnit.GramForceMillimeter); } + /// /// Creates a from . /// @@ -495,6 +498,7 @@ public static Torque FromKilogramForceCentimeters(QuantityValue kilogramforcecen double value = (double) kilogramforcecentimeters; return new Torque(value, TorqueUnit.KilogramForceCentimeter); } + /// /// Creates a from . /// @@ -504,6 +508,7 @@ public static Torque FromKilogramForceMeters(QuantityValue kilogramforcemeters) double value = (double) kilogramforcemeters; return new Torque(value, TorqueUnit.KilogramForceMeter); } + /// /// Creates a from . /// @@ -513,6 +518,7 @@ public static Torque FromKilogramForceMillimeters(QuantityValue kilogramforcemil double value = (double) kilogramforcemillimeters; return new Torque(value, TorqueUnit.KilogramForceMillimeter); } + /// /// Creates a from . /// @@ -522,6 +528,7 @@ public static Torque FromKilonewtonCentimeters(QuantityValue kilonewtoncentimete double value = (double) kilonewtoncentimeters; return new Torque(value, TorqueUnit.KilonewtonCentimeter); } + /// /// Creates a from . /// @@ -531,6 +538,7 @@ public static Torque FromKilonewtonMeters(QuantityValue kilonewtonmeters) double value = (double) kilonewtonmeters; return new Torque(value, TorqueUnit.KilonewtonMeter); } + /// /// Creates a from . /// @@ -540,6 +548,7 @@ public static Torque FromKilonewtonMillimeters(QuantityValue kilonewtonmillimete double value = (double) kilonewtonmillimeters; return new Torque(value, TorqueUnit.KilonewtonMillimeter); } + /// /// Creates a from . /// @@ -549,6 +558,7 @@ public static Torque FromKilopoundForceFeet(QuantityValue kilopoundforcefeet) double value = (double) kilopoundforcefeet; return new Torque(value, TorqueUnit.KilopoundForceFoot); } + /// /// Creates a from . /// @@ -558,6 +568,7 @@ public static Torque FromKilopoundForceInches(QuantityValue kilopoundforceinches double value = (double) kilopoundforceinches; return new Torque(value, TorqueUnit.KilopoundForceInch); } + /// /// Creates a from . /// @@ -567,6 +578,7 @@ public static Torque FromMeganewtonCentimeters(QuantityValue meganewtoncentimete double value = (double) meganewtoncentimeters; return new Torque(value, TorqueUnit.MeganewtonCentimeter); } + /// /// Creates a from . /// @@ -576,6 +588,7 @@ public static Torque FromMeganewtonMeters(QuantityValue meganewtonmeters) double value = (double) meganewtonmeters; return new Torque(value, TorqueUnit.MeganewtonMeter); } + /// /// Creates a from . /// @@ -585,6 +598,7 @@ public static Torque FromMeganewtonMillimeters(QuantityValue meganewtonmillimete double value = (double) meganewtonmillimeters; return new Torque(value, TorqueUnit.MeganewtonMillimeter); } + /// /// Creates a from . /// @@ -594,6 +608,7 @@ public static Torque FromMegapoundForceFeet(QuantityValue megapoundforcefeet) double value = (double) megapoundforcefeet; return new Torque(value, TorqueUnit.MegapoundForceFoot); } + /// /// Creates a from . /// @@ -603,6 +618,7 @@ public static Torque FromMegapoundForceInches(QuantityValue megapoundforceinches double value = (double) megapoundforceinches; return new Torque(value, TorqueUnit.MegapoundForceInch); } + /// /// Creates a from . /// @@ -612,6 +628,7 @@ public static Torque FromNewtonCentimeters(QuantityValue newtoncentimeters) double value = (double) newtoncentimeters; return new Torque(value, TorqueUnit.NewtonCentimeter); } + /// /// Creates a from . /// @@ -621,6 +638,7 @@ public static Torque FromNewtonMeters(QuantityValue newtonmeters) double value = (double) newtonmeters; return new Torque(value, TorqueUnit.NewtonMeter); } + /// /// Creates a from . /// @@ -630,6 +648,7 @@ public static Torque FromNewtonMillimeters(QuantityValue newtonmillimeters) double value = (double) newtonmillimeters; return new Torque(value, TorqueUnit.NewtonMillimeter); } + /// /// Creates a from . /// @@ -639,6 +658,7 @@ public static Torque FromPoundalFeet(QuantityValue poundalfeet) double value = (double) poundalfeet; return new Torque(value, TorqueUnit.PoundalFoot); } + /// /// Creates a from . /// @@ -648,6 +668,7 @@ public static Torque FromPoundForceFeet(QuantityValue poundforcefeet) double value = (double) poundforcefeet; return new Torque(value, TorqueUnit.PoundForceFoot); } + /// /// Creates a from . /// @@ -657,6 +678,7 @@ public static Torque FromPoundForceInches(QuantityValue poundforceinches) double value = (double) poundforceinches; return new Torque(value, TorqueUnit.PoundForceInch); } + /// /// Creates a from . /// @@ -666,6 +688,7 @@ public static Torque FromTonneForceCentimeters(QuantityValue tonneforcecentimete double value = (double) tonneforcecentimeters; return new Torque(value, TorqueUnit.TonneForceCentimeter); } + /// /// Creates a from . /// @@ -675,6 +698,7 @@ public static Torque FromTonneForceMeters(QuantityValue tonneforcemeters) double value = (double) tonneforcemeters; return new Torque(value, TorqueUnit.TonneForceMeter); } + /// /// Creates a from . /// @@ -685,6 +709,7 @@ public static Torque FromTonneForceMillimeters(QuantityValue tonneforcemillimete return new Torque(value, TorqueUnit.TonneForceMillimeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/TorquePerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/TorquePerLength.g.cs index 75f4d7c067..e7849bea60 100644 --- a/UnitsNet/GeneratedCode/Quantities/TorquePerLength.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/TorquePerLength.g.cs @@ -432,6 +432,7 @@ public static TorquePerLength FromKilogramForceCentimetersPerMeter(QuantityValue double value = (double) kilogramforcecentimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.KilogramForceCentimeterPerMeter); } + /// /// Creates a from . /// @@ -441,6 +442,7 @@ public static TorquePerLength FromKilogramForceMetersPerMeter(QuantityValue kilo double value = (double) kilogramforcemeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.KilogramForceMeterPerMeter); } + /// /// Creates a from . /// @@ -450,6 +452,7 @@ public static TorquePerLength FromKilogramForceMillimetersPerMeter(QuantityValue double value = (double) kilogramforcemillimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.KilogramForceMillimeterPerMeter); } + /// /// Creates a from . /// @@ -459,6 +462,7 @@ public static TorquePerLength FromKilonewtonCentimetersPerMeter(QuantityValue ki double value = (double) kilonewtoncentimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.KilonewtonCentimeterPerMeter); } + /// /// Creates a from . /// @@ -468,6 +472,7 @@ public static TorquePerLength FromKilonewtonMetersPerMeter(QuantityValue kilonew double value = (double) kilonewtonmeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.KilonewtonMeterPerMeter); } + /// /// Creates a from . /// @@ -477,6 +482,7 @@ public static TorquePerLength FromKilonewtonMillimetersPerMeter(QuantityValue ki double value = (double) kilonewtonmillimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.KilonewtonMillimeterPerMeter); } + /// /// Creates a from . /// @@ -486,6 +492,7 @@ public static TorquePerLength FromKilopoundForceFeetPerFoot(QuantityValue kilopo double value = (double) kilopoundforcefeetperfoot; return new TorquePerLength(value, TorquePerLengthUnit.KilopoundForceFootPerFoot); } + /// /// Creates a from . /// @@ -495,6 +502,7 @@ public static TorquePerLength FromKilopoundForceInchesPerFoot(QuantityValue kilo double value = (double) kilopoundforceinchesperfoot; return new TorquePerLength(value, TorquePerLengthUnit.KilopoundForceInchPerFoot); } + /// /// Creates a from . /// @@ -504,6 +512,7 @@ public static TorquePerLength FromMeganewtonCentimetersPerMeter(QuantityValue me double value = (double) meganewtoncentimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.MeganewtonCentimeterPerMeter); } + /// /// Creates a from . /// @@ -513,6 +522,7 @@ public static TorquePerLength FromMeganewtonMetersPerMeter(QuantityValue meganew double value = (double) meganewtonmeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.MeganewtonMeterPerMeter); } + /// /// Creates a from . /// @@ -522,6 +532,7 @@ public static TorquePerLength FromMeganewtonMillimetersPerMeter(QuantityValue me double value = (double) meganewtonmillimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.MeganewtonMillimeterPerMeter); } + /// /// Creates a from . /// @@ -531,6 +542,7 @@ public static TorquePerLength FromMegapoundForceFeetPerFoot(QuantityValue megapo double value = (double) megapoundforcefeetperfoot; return new TorquePerLength(value, TorquePerLengthUnit.MegapoundForceFootPerFoot); } + /// /// Creates a from . /// @@ -540,6 +552,7 @@ public static TorquePerLength FromMegapoundForceInchesPerFoot(QuantityValue mega double value = (double) megapoundforceinchesperfoot; return new TorquePerLength(value, TorquePerLengthUnit.MegapoundForceInchPerFoot); } + /// /// Creates a from . /// @@ -549,6 +562,7 @@ public static TorquePerLength FromNewtonCentimetersPerMeter(QuantityValue newton double value = (double) newtoncentimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.NewtonCentimeterPerMeter); } + /// /// Creates a from . /// @@ -558,6 +572,7 @@ public static TorquePerLength FromNewtonMetersPerMeter(QuantityValue newtonmeter double value = (double) newtonmeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.NewtonMeterPerMeter); } + /// /// Creates a from . /// @@ -567,6 +582,7 @@ public static TorquePerLength FromNewtonMillimetersPerMeter(QuantityValue newton double value = (double) newtonmillimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.NewtonMillimeterPerMeter); } + /// /// Creates a from . /// @@ -576,6 +592,7 @@ public static TorquePerLength FromPoundForceFeetPerFoot(QuantityValue poundforce double value = (double) poundforcefeetperfoot; return new TorquePerLength(value, TorquePerLengthUnit.PoundForceFootPerFoot); } + /// /// Creates a from . /// @@ -585,6 +602,7 @@ public static TorquePerLength FromPoundForceInchesPerFoot(QuantityValue poundfor double value = (double) poundforceinchesperfoot; return new TorquePerLength(value, TorquePerLengthUnit.PoundForceInchPerFoot); } + /// /// Creates a from . /// @@ -594,6 +612,7 @@ public static TorquePerLength FromTonneForceCentimetersPerMeter(QuantityValue to double value = (double) tonneforcecentimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.TonneForceCentimeterPerMeter); } + /// /// Creates a from . /// @@ -603,6 +622,7 @@ public static TorquePerLength FromTonneForceMetersPerMeter(QuantityValue tonnefo double value = (double) tonneforcemeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.TonneForceMeterPerMeter); } + /// /// Creates a from . /// @@ -613,6 +633,7 @@ public static TorquePerLength FromTonneForceMillimetersPerMeter(QuantityValue to return new TorquePerLength(value, TorquePerLengthUnit.TonneForceMillimeterPerMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Turbidity.g.cs b/UnitsNet/GeneratedCode/Quantities/Turbidity.g.cs index 7e8392b36f..5b70431c0f 100644 --- a/UnitsNet/GeneratedCode/Quantities/Turbidity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Turbidity.g.cs @@ -253,6 +253,7 @@ public static Turbidity FromNTU(QuantityValue ntu) return new Turbidity(value, TurbidityUnit.NTU); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/VitaminA.g.cs b/UnitsNet/GeneratedCode/Quantities/VitaminA.g.cs index 6c2e5342ac..878d8d1dba 100644 --- a/UnitsNet/GeneratedCode/Quantities/VitaminA.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/VitaminA.g.cs @@ -250,6 +250,7 @@ public static VitaminA FromInternationalUnits(QuantityValue internationalunits) return new VitaminA(value, VitaminAUnit.InternationalUnit); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Volume.g.cs b/UnitsNet/GeneratedCode/Quantities/Volume.g.cs index de4589ffb2..7c638bb723 100644 --- a/UnitsNet/GeneratedCode/Quantities/Volume.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Volume.g.cs @@ -755,6 +755,7 @@ public static Volume FromAcreFeet(QuantityValue acrefeet) double value = (double) acrefeet; return new Volume(value, VolumeUnit.AcreFoot); } + /// /// Creates a from . /// @@ -764,6 +765,7 @@ public static Volume FromAuTablespoons(QuantityValue autablespoons) double value = (double) autablespoons; return new Volume(value, VolumeUnit.AuTablespoon); } + /// /// Creates a from . /// @@ -773,6 +775,7 @@ public static Volume FromBoardFeet(QuantityValue boardfeet) double value = (double) boardfeet; return new Volume(value, VolumeUnit.BoardFoot); } + /// /// Creates a from . /// @@ -782,6 +785,7 @@ public static Volume FromCentiliters(QuantityValue centiliters) double value = (double) centiliters; return new Volume(value, VolumeUnit.Centiliter); } + /// /// Creates a from . /// @@ -791,6 +795,7 @@ public static Volume FromCubicCentimeters(QuantityValue cubiccentimeters) double value = (double) cubiccentimeters; return new Volume(value, VolumeUnit.CubicCentimeter); } + /// /// Creates a from . /// @@ -800,6 +805,7 @@ public static Volume FromCubicDecimeters(QuantityValue cubicdecimeters) double value = (double) cubicdecimeters; return new Volume(value, VolumeUnit.CubicDecimeter); } + /// /// Creates a from . /// @@ -809,6 +815,7 @@ public static Volume FromCubicFeet(QuantityValue cubicfeet) double value = (double) cubicfeet; return new Volume(value, VolumeUnit.CubicFoot); } + /// /// Creates a from . /// @@ -818,6 +825,7 @@ public static Volume FromCubicHectometers(QuantityValue cubichectometers) double value = (double) cubichectometers; return new Volume(value, VolumeUnit.CubicHectometer); } + /// /// Creates a from . /// @@ -827,6 +835,7 @@ public static Volume FromCubicInches(QuantityValue cubicinches) double value = (double) cubicinches; return new Volume(value, VolumeUnit.CubicInch); } + /// /// Creates a from . /// @@ -836,6 +845,7 @@ public static Volume FromCubicKilometers(QuantityValue cubickilometers) double value = (double) cubickilometers; return new Volume(value, VolumeUnit.CubicKilometer); } + /// /// Creates a from . /// @@ -845,6 +855,7 @@ public static Volume FromCubicMeters(QuantityValue cubicmeters) double value = (double) cubicmeters; return new Volume(value, VolumeUnit.CubicMeter); } + /// /// Creates a from . /// @@ -854,6 +865,7 @@ public static Volume FromCubicMicrometers(QuantityValue cubicmicrometers) double value = (double) cubicmicrometers; return new Volume(value, VolumeUnit.CubicMicrometer); } + /// /// Creates a from . /// @@ -863,6 +875,7 @@ public static Volume FromCubicMiles(QuantityValue cubicmiles) double value = (double) cubicmiles; return new Volume(value, VolumeUnit.CubicMile); } + /// /// Creates a from . /// @@ -872,6 +885,7 @@ public static Volume FromCubicMillimeters(QuantityValue cubicmillimeters) double value = (double) cubicmillimeters; return new Volume(value, VolumeUnit.CubicMillimeter); } + /// /// Creates a from . /// @@ -881,6 +895,7 @@ public static Volume FromCubicYards(QuantityValue cubicyards) double value = (double) cubicyards; return new Volume(value, VolumeUnit.CubicYard); } + /// /// Creates a from . /// @@ -890,6 +905,7 @@ public static Volume FromDecaliters(QuantityValue decaliters) double value = (double) decaliters; return new Volume(value, VolumeUnit.Decaliter); } + /// /// Creates a from . /// @@ -899,6 +915,7 @@ public static Volume FromDecausGallons(QuantityValue decausgallons) double value = (double) decausgallons; return new Volume(value, VolumeUnit.DecausGallon); } + /// /// Creates a from . /// @@ -908,6 +925,7 @@ public static Volume FromDeciliters(QuantityValue deciliters) double value = (double) deciliters; return new Volume(value, VolumeUnit.Deciliter); } + /// /// Creates a from . /// @@ -917,6 +935,7 @@ public static Volume FromDeciusGallons(QuantityValue deciusgallons) double value = (double) deciusgallons; return new Volume(value, VolumeUnit.DeciusGallon); } + /// /// Creates a from . /// @@ -926,6 +945,7 @@ public static Volume FromHectocubicFeet(QuantityValue hectocubicfeet) double value = (double) hectocubicfeet; return new Volume(value, VolumeUnit.HectocubicFoot); } + /// /// Creates a from . /// @@ -935,6 +955,7 @@ public static Volume FromHectocubicMeters(QuantityValue hectocubicmeters) double value = (double) hectocubicmeters; return new Volume(value, VolumeUnit.HectocubicMeter); } + /// /// Creates a from . /// @@ -944,6 +965,7 @@ public static Volume FromHectoliters(QuantityValue hectoliters) double value = (double) hectoliters; return new Volume(value, VolumeUnit.Hectoliter); } + /// /// Creates a from . /// @@ -953,6 +975,7 @@ public static Volume FromHectousGallons(QuantityValue hectousgallons) double value = (double) hectousgallons; return new Volume(value, VolumeUnit.HectousGallon); } + /// /// Creates a from . /// @@ -962,6 +985,7 @@ public static Volume FromImperialBeerBarrels(QuantityValue imperialbeerbarrels) double value = (double) imperialbeerbarrels; return new Volume(value, VolumeUnit.ImperialBeerBarrel); } + /// /// Creates a from . /// @@ -971,6 +995,7 @@ public static Volume FromImperialGallons(QuantityValue imperialgallons) double value = (double) imperialgallons; return new Volume(value, VolumeUnit.ImperialGallon); } + /// /// Creates a from . /// @@ -980,6 +1005,7 @@ public static Volume FromImperialOunces(QuantityValue imperialounces) double value = (double) imperialounces; return new Volume(value, VolumeUnit.ImperialOunce); } + /// /// Creates a from . /// @@ -989,6 +1015,7 @@ public static Volume FromImperialPints(QuantityValue imperialpints) double value = (double) imperialpints; return new Volume(value, VolumeUnit.ImperialPint); } + /// /// Creates a from . /// @@ -998,6 +1025,7 @@ public static Volume FromKilocubicFeet(QuantityValue kilocubicfeet) double value = (double) kilocubicfeet; return new Volume(value, VolumeUnit.KilocubicFoot); } + /// /// Creates a from . /// @@ -1007,6 +1035,7 @@ public static Volume FromKilocubicMeters(QuantityValue kilocubicmeters) double value = (double) kilocubicmeters; return new Volume(value, VolumeUnit.KilocubicMeter); } + /// /// Creates a from . /// @@ -1016,6 +1045,7 @@ public static Volume FromKiloimperialGallons(QuantityValue kiloimperialgallons) double value = (double) kiloimperialgallons; return new Volume(value, VolumeUnit.KiloimperialGallon); } + /// /// Creates a from . /// @@ -1025,6 +1055,7 @@ public static Volume FromKiloliters(QuantityValue kiloliters) double value = (double) kiloliters; return new Volume(value, VolumeUnit.Kiloliter); } + /// /// Creates a from . /// @@ -1034,6 +1065,7 @@ public static Volume FromKilousGallons(QuantityValue kilousgallons) double value = (double) kilousgallons; return new Volume(value, VolumeUnit.KilousGallon); } + /// /// Creates a from . /// @@ -1043,6 +1075,7 @@ public static Volume FromLiters(QuantityValue liters) double value = (double) liters; return new Volume(value, VolumeUnit.Liter); } + /// /// Creates a from . /// @@ -1052,6 +1085,7 @@ public static Volume FromMegacubicFeet(QuantityValue megacubicfeet) double value = (double) megacubicfeet; return new Volume(value, VolumeUnit.MegacubicFoot); } + /// /// Creates a from . /// @@ -1061,6 +1095,7 @@ public static Volume FromMegaimperialGallons(QuantityValue megaimperialgallons) double value = (double) megaimperialgallons; return new Volume(value, VolumeUnit.MegaimperialGallon); } + /// /// Creates a from . /// @@ -1070,6 +1105,7 @@ public static Volume FromMegaliters(QuantityValue megaliters) double value = (double) megaliters; return new Volume(value, VolumeUnit.Megaliter); } + /// /// Creates a from . /// @@ -1079,6 +1115,7 @@ public static Volume FromMegausGallons(QuantityValue megausgallons) double value = (double) megausgallons; return new Volume(value, VolumeUnit.MegausGallon); } + /// /// Creates a from . /// @@ -1088,6 +1125,7 @@ public static Volume FromMetricCups(QuantityValue metriccups) double value = (double) metriccups; return new Volume(value, VolumeUnit.MetricCup); } + /// /// Creates a from . /// @@ -1097,6 +1135,7 @@ public static Volume FromMetricTeaspoons(QuantityValue metricteaspoons) double value = (double) metricteaspoons; return new Volume(value, VolumeUnit.MetricTeaspoon); } + /// /// Creates a from . /// @@ -1106,6 +1145,7 @@ public static Volume FromMicroliters(QuantityValue microliters) double value = (double) microliters; return new Volume(value, VolumeUnit.Microliter); } + /// /// Creates a from . /// @@ -1115,6 +1155,7 @@ public static Volume FromMilliliters(QuantityValue milliliters) double value = (double) milliliters; return new Volume(value, VolumeUnit.Milliliter); } + /// /// Creates a from . /// @@ -1124,6 +1165,7 @@ public static Volume FromOilBarrels(QuantityValue oilbarrels) double value = (double) oilbarrels; return new Volume(value, VolumeUnit.OilBarrel); } + /// /// Creates a from . /// @@ -1133,6 +1175,7 @@ public static Volume FromUkTablespoons(QuantityValue uktablespoons) double value = (double) uktablespoons; return new Volume(value, VolumeUnit.UkTablespoon); } + /// /// Creates a from . /// @@ -1142,6 +1185,7 @@ public static Volume FromUsBeerBarrels(QuantityValue usbeerbarrels) double value = (double) usbeerbarrels; return new Volume(value, VolumeUnit.UsBeerBarrel); } + /// /// Creates a from . /// @@ -1151,6 +1195,7 @@ public static Volume FromUsCustomaryCups(QuantityValue uscustomarycups) double value = (double) uscustomarycups; return new Volume(value, VolumeUnit.UsCustomaryCup); } + /// /// Creates a from . /// @@ -1160,6 +1205,7 @@ public static Volume FromUsGallons(QuantityValue usgallons) double value = (double) usgallons; return new Volume(value, VolumeUnit.UsGallon); } + /// /// Creates a from . /// @@ -1169,6 +1215,7 @@ public static Volume FromUsLegalCups(QuantityValue uslegalcups) double value = (double) uslegalcups; return new Volume(value, VolumeUnit.UsLegalCup); } + /// /// Creates a from . /// @@ -1178,6 +1225,7 @@ public static Volume FromUsOunces(QuantityValue usounces) double value = (double) usounces; return new Volume(value, VolumeUnit.UsOunce); } + /// /// Creates a from . /// @@ -1187,6 +1235,7 @@ public static Volume FromUsPints(QuantityValue uspints) double value = (double) uspints; return new Volume(value, VolumeUnit.UsPint); } + /// /// Creates a from . /// @@ -1196,6 +1245,7 @@ public static Volume FromUsQuarts(QuantityValue usquarts) double value = (double) usquarts; return new Volume(value, VolumeUnit.UsQuart); } + /// /// Creates a from . /// @@ -1205,6 +1255,7 @@ public static Volume FromUsTablespoons(QuantityValue ustablespoons) double value = (double) ustablespoons; return new Volume(value, VolumeUnit.UsTablespoon); } + /// /// Creates a from . /// @@ -1215,6 +1266,7 @@ public static Volume FromUsTeaspoons(QuantityValue usteaspoons) return new Volume(value, VolumeUnit.UsTeaspoon); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs index 969b3b5db0..c0d3cfc806 100644 --- a/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs @@ -423,6 +423,7 @@ public static VolumeConcentration FromCentilitersPerLiter(QuantityValue centilit double value = (double) centilitersperliter; return new VolumeConcentration(value, VolumeConcentrationUnit.CentilitersPerLiter); } + /// /// Creates a from . /// @@ -432,6 +433,7 @@ public static VolumeConcentration FromCentilitersPerMililiter(QuantityValue cent double value = (double) centiliterspermililiter; return new VolumeConcentration(value, VolumeConcentrationUnit.CentilitersPerMililiter); } + /// /// Creates a from . /// @@ -441,6 +443,7 @@ public static VolumeConcentration FromDecilitersPerLiter(QuantityValue deciliter double value = (double) decilitersperliter; return new VolumeConcentration(value, VolumeConcentrationUnit.DecilitersPerLiter); } + /// /// Creates a from . /// @@ -450,6 +453,7 @@ public static VolumeConcentration FromDecilitersPerMililiter(QuantityValue decil double value = (double) deciliterspermililiter; return new VolumeConcentration(value, VolumeConcentrationUnit.DecilitersPerMililiter); } + /// /// Creates a from . /// @@ -459,6 +463,7 @@ public static VolumeConcentration FromDecimalFractions(QuantityValue decimalfrac double value = (double) decimalfractions; return new VolumeConcentration(value, VolumeConcentrationUnit.DecimalFraction); } + /// /// Creates a from . /// @@ -468,6 +473,7 @@ public static VolumeConcentration FromLitersPerLiter(QuantityValue litersperlite double value = (double) litersperliter; return new VolumeConcentration(value, VolumeConcentrationUnit.LitersPerLiter); } + /// /// Creates a from . /// @@ -477,6 +483,7 @@ public static VolumeConcentration FromLitersPerMililiter(QuantityValue litersper double value = (double) literspermililiter; return new VolumeConcentration(value, VolumeConcentrationUnit.LitersPerMililiter); } + /// /// Creates a from . /// @@ -486,6 +493,7 @@ public static VolumeConcentration FromMicrolitersPerLiter(QuantityValue microlit double value = (double) microlitersperliter; return new VolumeConcentration(value, VolumeConcentrationUnit.MicrolitersPerLiter); } + /// /// Creates a from . /// @@ -495,6 +503,7 @@ public static VolumeConcentration FromMicrolitersPerMililiter(QuantityValue micr double value = (double) microliterspermililiter; return new VolumeConcentration(value, VolumeConcentrationUnit.MicrolitersPerMililiter); } + /// /// Creates a from . /// @@ -504,6 +513,7 @@ public static VolumeConcentration FromMillilitersPerLiter(QuantityValue millilit double value = (double) millilitersperliter; return new VolumeConcentration(value, VolumeConcentrationUnit.MillilitersPerLiter); } + /// /// Creates a from . /// @@ -513,6 +523,7 @@ public static VolumeConcentration FromMillilitersPerMililiter(QuantityValue mill double value = (double) milliliterspermililiter; return new VolumeConcentration(value, VolumeConcentrationUnit.MillilitersPerMililiter); } + /// /// Creates a from . /// @@ -522,6 +533,7 @@ public static VolumeConcentration FromNanolitersPerLiter(QuantityValue nanoliter double value = (double) nanolitersperliter; return new VolumeConcentration(value, VolumeConcentrationUnit.NanolitersPerLiter); } + /// /// Creates a from . /// @@ -531,6 +543,7 @@ public static VolumeConcentration FromNanolitersPerMililiter(QuantityValue nanol double value = (double) nanoliterspermililiter; return new VolumeConcentration(value, VolumeConcentrationUnit.NanolitersPerMililiter); } + /// /// Creates a from . /// @@ -540,6 +553,7 @@ public static VolumeConcentration FromPartsPerBillion(QuantityValue partsperbill double value = (double) partsperbillion; return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerBillion); } + /// /// Creates a from . /// @@ -549,6 +563,7 @@ public static VolumeConcentration FromPartsPerMillion(QuantityValue partspermill double value = (double) partspermillion; return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerMillion); } + /// /// Creates a from . /// @@ -558,6 +573,7 @@ public static VolumeConcentration FromPartsPerThousand(QuantityValue partspertho double value = (double) partsperthousand; return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerThousand); } + /// /// Creates a from . /// @@ -567,6 +583,7 @@ public static VolumeConcentration FromPartsPerTrillion(QuantityValue partspertri double value = (double) partspertrillion; return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerTrillion); } + /// /// Creates a from . /// @@ -576,6 +593,7 @@ public static VolumeConcentration FromPercent(QuantityValue percent) double value = (double) percent; return new VolumeConcentration(value, VolumeConcentrationUnit.Percent); } + /// /// Creates a from . /// @@ -585,6 +603,7 @@ public static VolumeConcentration FromPicolitersPerLiter(QuantityValue picoliter double value = (double) picolitersperliter; return new VolumeConcentration(value, VolumeConcentrationUnit.PicolitersPerLiter); } + /// /// Creates a from . /// @@ -595,6 +614,7 @@ public static VolumeConcentration FromPicolitersPerMililiter(QuantityValue picol return new VolumeConcentration(value, VolumeConcentrationUnit.PicolitersPerMililiter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs index fb33f436b3..d22284167e 100644 --- a/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs @@ -825,6 +825,7 @@ public static VolumeFlow FromAcreFeetPerDay(QuantityValue acrefeetperday) double value = (double) acrefeetperday; return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerDay); } + /// /// Creates a from . /// @@ -834,6 +835,7 @@ public static VolumeFlow FromAcreFeetPerHour(QuantityValue acrefeetperhour) double value = (double) acrefeetperhour; return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerHour); } + /// /// Creates a from . /// @@ -843,6 +845,7 @@ public static VolumeFlow FromAcreFeetPerMinute(QuantityValue acrefeetperminute) double value = (double) acrefeetperminute; return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerMinute); } + /// /// Creates a from . /// @@ -852,6 +855,7 @@ public static VolumeFlow FromAcreFeetPerSecond(QuantityValue acrefeetpersecond) double value = (double) acrefeetpersecond; return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerSecond); } + /// /// Creates a from . /// @@ -861,6 +865,7 @@ public static VolumeFlow FromCentilitersPerDay(QuantityValue centilitersperday) double value = (double) centilitersperday; return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerDay); } + /// /// Creates a from . /// @@ -870,6 +875,7 @@ public static VolumeFlow FromCentilitersPerHour(QuantityValue centilitersperhour double value = (double) centilitersperhour; return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerHour); } + /// /// Creates a from . /// @@ -879,6 +885,7 @@ public static VolumeFlow FromCentilitersPerMinute(QuantityValue centiliterspermi double value = (double) centilitersperminute; return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerMinute); } + /// /// Creates a from . /// @@ -888,6 +895,7 @@ public static VolumeFlow FromCentilitersPerSecond(QuantityValue centilitersperse double value = (double) centiliterspersecond; return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerSecond); } + /// /// Creates a from . /// @@ -897,6 +905,7 @@ public static VolumeFlow FromCubicCentimetersPerMinute(QuantityValue cubiccentim double value = (double) cubiccentimetersperminute; return new VolumeFlow(value, VolumeFlowUnit.CubicCentimeterPerMinute); } + /// /// Creates a from . /// @@ -906,6 +915,7 @@ public static VolumeFlow FromCubicDecimetersPerMinute(QuantityValue cubicdecimet double value = (double) cubicdecimetersperminute; return new VolumeFlow(value, VolumeFlowUnit.CubicDecimeterPerMinute); } + /// /// Creates a from . /// @@ -915,6 +925,7 @@ public static VolumeFlow FromCubicFeetPerHour(QuantityValue cubicfeetperhour) double value = (double) cubicfeetperhour; return new VolumeFlow(value, VolumeFlowUnit.CubicFootPerHour); } + /// /// Creates a from . /// @@ -924,6 +935,7 @@ public static VolumeFlow FromCubicFeetPerMinute(QuantityValue cubicfeetperminute double value = (double) cubicfeetperminute; return new VolumeFlow(value, VolumeFlowUnit.CubicFootPerMinute); } + /// /// Creates a from . /// @@ -933,6 +945,7 @@ public static VolumeFlow FromCubicFeetPerSecond(QuantityValue cubicfeetpersecond double value = (double) cubicfeetpersecond; return new VolumeFlow(value, VolumeFlowUnit.CubicFootPerSecond); } + /// /// Creates a from . /// @@ -942,6 +955,7 @@ public static VolumeFlow FromCubicMetersPerDay(QuantityValue cubicmetersperday) double value = (double) cubicmetersperday; return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerDay); } + /// /// Creates a from . /// @@ -951,6 +965,7 @@ public static VolumeFlow FromCubicMetersPerHour(QuantityValue cubicmetersperhour double value = (double) cubicmetersperhour; return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerHour); } + /// /// Creates a from . /// @@ -960,6 +975,7 @@ public static VolumeFlow FromCubicMetersPerMinute(QuantityValue cubicmeterspermi double value = (double) cubicmetersperminute; return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerMinute); } + /// /// Creates a from . /// @@ -969,6 +985,7 @@ public static VolumeFlow FromCubicMetersPerSecond(QuantityValue cubicmetersperse double value = (double) cubicmeterspersecond; return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerSecond); } + /// /// Creates a from . /// @@ -978,6 +995,7 @@ public static VolumeFlow FromCubicMillimetersPerSecond(QuantityValue cubicmillim double value = (double) cubicmillimeterspersecond; return new VolumeFlow(value, VolumeFlowUnit.CubicMillimeterPerSecond); } + /// /// Creates a from . /// @@ -987,6 +1005,7 @@ public static VolumeFlow FromCubicYardsPerDay(QuantityValue cubicyardsperday) double value = (double) cubicyardsperday; return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerDay); } + /// /// Creates a from . /// @@ -996,6 +1015,7 @@ public static VolumeFlow FromCubicYardsPerHour(QuantityValue cubicyardsperhour) double value = (double) cubicyardsperhour; return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerHour); } + /// /// Creates a from . /// @@ -1005,6 +1025,7 @@ public static VolumeFlow FromCubicYardsPerMinute(QuantityValue cubicyardsperminu double value = (double) cubicyardsperminute; return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerMinute); } + /// /// Creates a from . /// @@ -1014,6 +1035,7 @@ public static VolumeFlow FromCubicYardsPerSecond(QuantityValue cubicyardsperseco double value = (double) cubicyardspersecond; return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerSecond); } + /// /// Creates a from . /// @@ -1023,6 +1045,7 @@ public static VolumeFlow FromDecilitersPerDay(QuantityValue decilitersperday) double value = (double) decilitersperday; return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerDay); } + /// /// Creates a from . /// @@ -1032,6 +1055,7 @@ public static VolumeFlow FromDecilitersPerHour(QuantityValue decilitersperhour) double value = (double) decilitersperhour; return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerHour); } + /// /// Creates a from . /// @@ -1041,6 +1065,7 @@ public static VolumeFlow FromDecilitersPerMinute(QuantityValue decilitersperminu double value = (double) decilitersperminute; return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerMinute); } + /// /// Creates a from . /// @@ -1050,6 +1075,7 @@ public static VolumeFlow FromDecilitersPerSecond(QuantityValue decilitersperseco double value = (double) deciliterspersecond; return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerSecond); } + /// /// Creates a from . /// @@ -1059,6 +1085,7 @@ public static VolumeFlow FromKilolitersPerDay(QuantityValue kilolitersperday) double value = (double) kilolitersperday; return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerDay); } + /// /// Creates a from . /// @@ -1068,6 +1095,7 @@ public static VolumeFlow FromKilolitersPerHour(QuantityValue kilolitersperhour) double value = (double) kilolitersperhour; return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerHour); } + /// /// Creates a from . /// @@ -1077,6 +1105,7 @@ public static VolumeFlow FromKilolitersPerMinute(QuantityValue kilolitersperminu double value = (double) kilolitersperminute; return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerMinute); } + /// /// Creates a from . /// @@ -1086,6 +1115,7 @@ public static VolumeFlow FromKilolitersPerSecond(QuantityValue kilolitersperseco double value = (double) kiloliterspersecond; return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerSecond); } + /// /// Creates a from . /// @@ -1095,6 +1125,7 @@ public static VolumeFlow FromKilousGallonsPerMinute(QuantityValue kilousgallonsp double value = (double) kilousgallonsperminute; return new VolumeFlow(value, VolumeFlowUnit.KilousGallonPerMinute); } + /// /// Creates a from . /// @@ -1104,6 +1135,7 @@ public static VolumeFlow FromLitersPerDay(QuantityValue litersperday) double value = (double) litersperday; return new VolumeFlow(value, VolumeFlowUnit.LiterPerDay); } + /// /// Creates a from . /// @@ -1113,6 +1145,7 @@ public static VolumeFlow FromLitersPerHour(QuantityValue litersperhour) double value = (double) litersperhour; return new VolumeFlow(value, VolumeFlowUnit.LiterPerHour); } + /// /// Creates a from . /// @@ -1122,6 +1155,7 @@ public static VolumeFlow FromLitersPerMinute(QuantityValue litersperminute) double value = (double) litersperminute; return new VolumeFlow(value, VolumeFlowUnit.LiterPerMinute); } + /// /// Creates a from . /// @@ -1131,6 +1165,7 @@ public static VolumeFlow FromLitersPerSecond(QuantityValue literspersecond) double value = (double) literspersecond; return new VolumeFlow(value, VolumeFlowUnit.LiterPerSecond); } + /// /// Creates a from . /// @@ -1140,6 +1175,7 @@ public static VolumeFlow FromMegalitersPerDay(QuantityValue megalitersperday) double value = (double) megalitersperday; return new VolumeFlow(value, VolumeFlowUnit.MegaliterPerDay); } + /// /// Creates a from . /// @@ -1149,6 +1185,7 @@ public static VolumeFlow FromMegaukGallonsPerSecond(QuantityValue megaukgallonsp double value = (double) megaukgallonspersecond; return new VolumeFlow(value, VolumeFlowUnit.MegaukGallonPerSecond); } + /// /// Creates a from . /// @@ -1158,6 +1195,7 @@ public static VolumeFlow FromMicrolitersPerDay(QuantityValue microlitersperday) double value = (double) microlitersperday; return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerDay); } + /// /// Creates a from . /// @@ -1167,6 +1205,7 @@ public static VolumeFlow FromMicrolitersPerHour(QuantityValue microlitersperhour double value = (double) microlitersperhour; return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerHour); } + /// /// Creates a from . /// @@ -1176,6 +1215,7 @@ public static VolumeFlow FromMicrolitersPerMinute(QuantityValue microliterspermi double value = (double) microlitersperminute; return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerMinute); } + /// /// Creates a from . /// @@ -1185,6 +1225,7 @@ public static VolumeFlow FromMicrolitersPerSecond(QuantityValue microlitersperse double value = (double) microliterspersecond; return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerSecond); } + /// /// Creates a from . /// @@ -1194,6 +1235,7 @@ public static VolumeFlow FromMillilitersPerDay(QuantityValue millilitersperday) double value = (double) millilitersperday; return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerDay); } + /// /// Creates a from . /// @@ -1203,6 +1245,7 @@ public static VolumeFlow FromMillilitersPerHour(QuantityValue millilitersperhour double value = (double) millilitersperhour; return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerHour); } + /// /// Creates a from . /// @@ -1212,6 +1255,7 @@ public static VolumeFlow FromMillilitersPerMinute(QuantityValue milliliterspermi double value = (double) millilitersperminute; return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerMinute); } + /// /// Creates a from . /// @@ -1221,6 +1265,7 @@ public static VolumeFlow FromMillilitersPerSecond(QuantityValue millilitersperse double value = (double) milliliterspersecond; return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerSecond); } + /// /// Creates a from . /// @@ -1230,6 +1275,7 @@ public static VolumeFlow FromMillionUsGallonsPerDay(QuantityValue millionusgallo double value = (double) millionusgallonsperday; return new VolumeFlow(value, VolumeFlowUnit.MillionUsGallonsPerDay); } + /// /// Creates a from . /// @@ -1239,6 +1285,7 @@ public static VolumeFlow FromNanolitersPerDay(QuantityValue nanolitersperday) double value = (double) nanolitersperday; return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerDay); } + /// /// Creates a from . /// @@ -1248,6 +1295,7 @@ public static VolumeFlow FromNanolitersPerHour(QuantityValue nanolitersperhour) double value = (double) nanolitersperhour; return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerHour); } + /// /// Creates a from . /// @@ -1257,6 +1305,7 @@ public static VolumeFlow FromNanolitersPerMinute(QuantityValue nanolitersperminu double value = (double) nanolitersperminute; return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerMinute); } + /// /// Creates a from . /// @@ -1266,6 +1315,7 @@ public static VolumeFlow FromNanolitersPerSecond(QuantityValue nanolitersperseco double value = (double) nanoliterspersecond; return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerSecond); } + /// /// Creates a from . /// @@ -1275,6 +1325,7 @@ public static VolumeFlow FromOilBarrelsPerDay(QuantityValue oilbarrelsperday) double value = (double) oilbarrelsperday; return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerDay); } + /// /// Creates a from . /// @@ -1284,6 +1335,7 @@ public static VolumeFlow FromOilBarrelsPerHour(QuantityValue oilbarrelsperhour) double value = (double) oilbarrelsperhour; return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerHour); } + /// /// Creates a from . /// @@ -1293,6 +1345,7 @@ public static VolumeFlow FromOilBarrelsPerMinute(QuantityValue oilbarrelsperminu double value = (double) oilbarrelsperminute; return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerMinute); } + /// /// Creates a from . /// @@ -1302,6 +1355,7 @@ public static VolumeFlow FromOilBarrelsPerSecond(QuantityValue oilbarrelsperseco double value = (double) oilbarrelspersecond; return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerSecond); } + /// /// Creates a from . /// @@ -1311,6 +1365,7 @@ public static VolumeFlow FromUkGallonsPerDay(QuantityValue ukgallonsperday) double value = (double) ukgallonsperday; return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerDay); } + /// /// Creates a from . /// @@ -1320,6 +1375,7 @@ public static VolumeFlow FromUkGallonsPerHour(QuantityValue ukgallonsperhour) double value = (double) ukgallonsperhour; return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerHour); } + /// /// Creates a from . /// @@ -1329,6 +1385,7 @@ public static VolumeFlow FromUkGallonsPerMinute(QuantityValue ukgallonsperminute double value = (double) ukgallonsperminute; return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerMinute); } + /// /// Creates a from . /// @@ -1338,6 +1395,7 @@ public static VolumeFlow FromUkGallonsPerSecond(QuantityValue ukgallonspersecond double value = (double) ukgallonspersecond; return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerSecond); } + /// /// Creates a from . /// @@ -1347,6 +1405,7 @@ public static VolumeFlow FromUsGallonsPerDay(QuantityValue usgallonsperday) double value = (double) usgallonsperday; return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerDay); } + /// /// Creates a from . /// @@ -1356,6 +1415,7 @@ public static VolumeFlow FromUsGallonsPerHour(QuantityValue usgallonsperhour) double value = (double) usgallonsperhour; return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerHour); } + /// /// Creates a from . /// @@ -1365,6 +1425,7 @@ public static VolumeFlow FromUsGallonsPerMinute(QuantityValue usgallonsperminute double value = (double) usgallonsperminute; return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerMinute); } + /// /// Creates a from . /// @@ -1375,6 +1436,7 @@ public static VolumeFlow FromUsGallonsPerSecond(QuantityValue usgallonspersecond return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerSecond); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs index 5aafdb110d..da511f7fc8 100644 --- a/UnitsNet/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs @@ -258,6 +258,7 @@ public static VolumeFlowPerArea FromCubicFeetPerMinutePerSquareFoot(QuantityValu double value = (double) cubicfeetperminutepersquarefoot; return new VolumeFlowPerArea(value, VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot); } + /// /// Creates a from . /// @@ -268,6 +269,7 @@ public static VolumeFlowPerArea FromCubicMetersPerSecondPerSquareMeter(QuantityV return new VolumeFlowPerArea(value, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs index 44e9c1efb1..4d6dd9bbc5 100644 --- a/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs @@ -303,6 +303,7 @@ public static VolumePerLength FromCubicMetersPerMeter(QuantityValue cubicmetersp double value = (double) cubicmeterspermeter; return new VolumePerLength(value, VolumePerLengthUnit.CubicMeterPerMeter); } + /// /// Creates a from . /// @@ -312,6 +313,7 @@ public static VolumePerLength FromCubicYardsPerFoot(QuantityValue cubicyardsperf double value = (double) cubicyardsperfoot; return new VolumePerLength(value, VolumePerLengthUnit.CubicYardPerFoot); } + /// /// Creates a from . /// @@ -321,6 +323,7 @@ public static VolumePerLength FromCubicYardsPerUsSurveyFoot(QuantityValue cubicy double value = (double) cubicyardsperussurveyfoot; return new VolumePerLength(value, VolumePerLengthUnit.CubicYardPerUsSurveyFoot); } + /// /// Creates a from . /// @@ -330,6 +333,7 @@ public static VolumePerLength FromLitersPerKilometer(QuantityValue litersperkilo double value = (double) litersperkilometer; return new VolumePerLength(value, VolumePerLengthUnit.LiterPerKilometer); } + /// /// Creates a from . /// @@ -339,6 +343,7 @@ public static VolumePerLength FromLitersPerMeter(QuantityValue literspermeter) double value = (double) literspermeter; return new VolumePerLength(value, VolumePerLengthUnit.LiterPerMeter); } + /// /// Creates a from . /// @@ -348,6 +353,7 @@ public static VolumePerLength FromLitersPerMillimeter(QuantityValue literspermil double value = (double) literspermillimeter; return new VolumePerLength(value, VolumePerLengthUnit.LiterPerMillimeter); } + /// /// Creates a from . /// @@ -358,6 +364,7 @@ public static VolumePerLength FromOilBarrelsPerFoot(QuantityValue oilbarrelsperf return new VolumePerLength(value, VolumePerLengthUnit.OilBarrelPerFoot); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs index 83cf67e5fe..26d9913411 100644 --- a/UnitsNet/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs @@ -324,6 +324,7 @@ public static VolumetricHeatCapacity FromBtusPerCubicFootDegreeFahrenheit(Quanti double value = (double) btuspercubicfootdegreefahrenheit; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit); } + /// /// Creates a from . /// @@ -333,6 +334,7 @@ public static VolumetricHeatCapacity FromCaloriesPerCubicCentimeterDegreeCelsius double value = (double) caloriespercubiccentimeterdegreecelsius; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius); } + /// /// Creates a from . /// @@ -342,6 +344,7 @@ public static VolumetricHeatCapacity FromJoulesPerCubicMeterDegreeCelsius(Quanti double value = (double) joulespercubicmeterdegreecelsius; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius); } + /// /// Creates a from . /// @@ -351,6 +354,7 @@ public static VolumetricHeatCapacity FromJoulesPerCubicMeterKelvin(QuantityValue double value = (double) joulespercubicmeterkelvin; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin); } + /// /// Creates a from . /// @@ -360,6 +364,7 @@ public static VolumetricHeatCapacity FromKilocaloriesPerCubicCentimeterDegreeCel double value = (double) kilocaloriespercubiccentimeterdegreecelsius; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius); } + /// /// Creates a from . /// @@ -369,6 +374,7 @@ public static VolumetricHeatCapacity FromKilojoulesPerCubicMeterDegreeCelsius(Qu double value = (double) kilojoulespercubicmeterdegreecelsius; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius); } + /// /// Creates a from . /// @@ -378,6 +384,7 @@ public static VolumetricHeatCapacity FromKilojoulesPerCubicMeterKelvin(QuantityV double value = (double) kilojoulespercubicmeterkelvin; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin); } + /// /// Creates a from . /// @@ -387,6 +394,7 @@ public static VolumetricHeatCapacity FromMegajoulesPerCubicMeterDegreeCelsius(Qu double value = (double) megajoulespercubicmeterdegreecelsius; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius); } + /// /// Creates a from . /// @@ -397,6 +405,7 @@ public static VolumetricHeatCapacity FromMegajoulesPerCubicMeterKelvin(QuantityV return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs b/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs index b677f3e2c5..7f17cd8497 100644 --- a/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs @@ -294,6 +294,7 @@ public static WarpingMomentOfInertia FromCentimetersToTheSixth(QuantityValue cen double value = (double) centimeterstothesixth; return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.CentimeterToTheSixth); } + /// /// Creates a from . /// @@ -303,6 +304,7 @@ public static WarpingMomentOfInertia FromDecimetersToTheSixth(QuantityValue deci double value = (double) decimeterstothesixth; return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.DecimeterToTheSixth); } + /// /// Creates a from . /// @@ -312,6 +314,7 @@ public static WarpingMomentOfInertia FromFeetToTheSixth(QuantityValue feettothes double value = (double) feettothesixth; return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.FootToTheSixth); } + /// /// Creates a from . /// @@ -321,6 +324,7 @@ public static WarpingMomentOfInertia FromInchesToTheSixth(QuantityValue inchesto double value = (double) inchestothesixth; return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.InchToTheSixth); } + /// /// Creates a from . /// @@ -330,6 +334,7 @@ public static WarpingMomentOfInertia FromMetersToTheSixth(QuantityValue metersto double value = (double) meterstothesixth; return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.MeterToTheSixth); } + /// /// Creates a from . /// @@ -340,6 +345,7 @@ public static WarpingMomentOfInertia FromMillimetersToTheSixth(QuantityValue mil return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.MillimeterToTheSixth); } + /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Units/CompressibilityUnit.g.cs b/UnitsNet/GeneratedCode/Units/CompressibilityUnit.g.cs index 77f80bab98..5b3e4f4514 100644 --- a/UnitsNet/GeneratedCode/Units/CompressibilityUnit.g.cs +++ b/UnitsNet/GeneratedCode/Units/CompressibilityUnit.g.cs @@ -26,7 +26,13 @@ namespace UnitsNet.Units public enum CompressibilityUnit { Undefined = 0, + InverseAtmosphere, + InverseBar, + InverseKilopascal, + InverseMegapascal, + InverseMillibar, InversePascal, + InversePoundForcePerSquareInch, } #pragma warning restore 1591 From db5d8cf56ab9163ecb8b28a3cf5bcfd151663b16 Mon Sep 17 00:00:00 2001 From: Tristan Milnthorp Date: Mon, 14 Feb 2022 11:09:23 -0500 Subject: [PATCH 3/4] Avoid huge diff. Will fix spacing in another PR. --- .../UnitsNetGen/QuantityGenerator.cs | 3 +- .../UnitsNetWrcGen/QuantityGenerator.cs | 3 +- .../Quantities/Acceleration.g.cs | 14 ----- .../Quantities/AmountOfSubstance.g.cs | 15 ----- .../Quantities/AmplitudeRatio.g.cs | 4 -- .../GeneratedCode/Quantities/Angle.g.cs | 16 ----- .../Quantities/ApparentEnergy.g.cs | 3 - .../Quantities/ApparentPower.g.cs | 4 -- .../GeneratedCode/Quantities/Area.g.cs | 14 ----- .../GeneratedCode/Quantities/AreaDensity.g.cs | 1 - .../Quantities/AreaMomentOfInertia.g.cs | 6 -- .../GeneratedCode/Quantities/BitRate.g.cs | 26 -------- .../BrakeSpecificFuelConsumption.g.cs | 3 - .../GeneratedCode/Quantities/Capacitance.g.cs | 7 --- .../CoefficientOfThermalExpansion.g.cs | 3 - .../Quantities/Compressibility.g.cs | 7 --- .../GeneratedCode/Quantities/Density.g.cs | 51 --------------- .../GeneratedCode/Quantities/Duration.g.cs | 11 ---- .../Quantities/DynamicViscosity.g.cs | 10 --- .../Quantities/ElectricAdmittance.g.cs | 4 -- .../Quantities/ElectricCharge.g.cs | 5 -- .../Quantities/ElectricChargeDensity.g.cs | 1 - .../Quantities/ElectricConductance.g.cs | 3 - .../Quantities/ElectricConductivity.g.cs | 3 - .../Quantities/ElectricCurrent.g.cs | 8 --- .../Quantities/ElectricCurrentDensity.g.cs | 3 - .../Quantities/ElectricCurrentGradient.g.cs | 4 -- .../Quantities/ElectricField.g.cs | 1 - .../Quantities/ElectricInductance.g.cs | 4 -- .../Quantities/ElectricPotential.g.cs | 5 -- .../Quantities/ElectricPotentialAc.g.cs | 5 -- .../ElectricPotentialChangeRate.g.cs | 20 ------ .../Quantities/ElectricPotentialDc.g.cs | 5 -- .../Quantities/ElectricResistance.g.cs | 6 -- .../Quantities/ElectricResistivity.g.cs | 14 ----- .../ElectricSurfaceChargeDensity.g.cs | 3 - .../GeneratedCode/Quantities/Energy.g.cs | 36 ----------- .../GeneratedCode/Quantities/Entropy.g.cs | 7 --- .../GeneratedCode/Quantities/Force.g.cs | 15 ----- .../Quantities/ForceChangeRate.g.cs | 15 ----- .../Quantities/ForcePerLength.g.cs | 38 ------------ .../GeneratedCode/Quantities/Frequency.g.cs | 11 ---- .../Quantities/FuelEfficiency.g.cs | 4 -- .../GeneratedCode/Quantities/HeatFlux.g.cs | 18 ------ .../Quantities/HeatTransferCoefficient.g.cs | 3 - .../GeneratedCode/Quantities/Illuminance.g.cs | 4 -- .../GeneratedCode/Quantities/Information.g.cs | 26 -------- .../GeneratedCode/Quantities/Irradiance.g.cs | 14 ----- .../GeneratedCode/Quantities/Irradiation.g.cs | 7 --- .../Quantities/KinematicViscosity.g.cs | 9 --- .../GeneratedCode/Quantities/LapseRate.g.cs | 1 - .../GeneratedCode/Quantities/Length.g.cs | 35 ----------- .../GeneratedCode/Quantities/Level.g.cs | 2 - .../Quantities/LinearDensity.g.cs | 14 ----- .../Quantities/LinearPowerDensity.g.cs | 25 -------- .../GeneratedCode/Quantities/Luminosity.g.cs | 14 ----- .../Quantities/LuminousFlux.g.cs | 1 - .../Quantities/LuminousIntensity.g.cs | 1 - .../Quantities/MagneticField.g.cs | 6 -- .../Quantities/MagneticFlux.g.cs | 1 - .../Quantities/Magnetization.g.cs | 1 - .../GeneratedCode/Quantities/Mass.g.cs | 25 -------- .../Quantities/MassConcentration.g.cs | 49 --------------- .../GeneratedCode/Quantities/MassFlow.g.cs | 33 ---------- .../GeneratedCode/Quantities/MassFlux.g.cs | 12 ---- .../Quantities/MassFraction.g.cs | 24 ------- .../Quantities/MassMomentOfInertia.g.cs | 28 --------- .../GeneratedCode/Quantities/MolarEnergy.g.cs | 3 - .../Quantities/MolarEntropy.g.cs | 3 - .../GeneratedCode/Quantities/MolarMass.g.cs | 12 ---- .../GeneratedCode/Quantities/Molarity.g.cs | 8 --- .../Quantities/Permeability.g.cs | 1 - .../Quantities/Permittivity.g.cs | 1 - .../GeneratedCode/Quantities/Power.g.cs | 25 -------- .../Quantities/PowerDensity.g.cs | 44 ------------- .../GeneratedCode/Quantities/PowerRatio.g.cs | 2 - .../GeneratedCode/Quantities/Pressure.g.cs | 45 -------------- .../Quantities/PressureChangeRate.g.cs | 14 ----- .../GeneratedCode/Quantities/Ratio.g.cs | 6 -- .../Quantities/RatioChangeRate.g.cs | 2 - .../Quantities/ReactiveEnergy.g.cs | 3 - .../Quantities/ReactivePower.g.cs | 4 -- .../Quantities/ReciprocalArea.g.cs | 11 ---- .../Quantities/ReciprocalLength.g.cs | 10 --- .../Quantities/RelativeHumidity.g.cs | 1 - .../Quantities/RotationalAcceleration.g.cs | 4 -- .../Quantities/RotationalSpeed.g.cs | 13 ---- .../Quantities/RotationalStiffness.g.cs | 33 ---------- .../RotationalStiffnessPerLength.g.cs | 5 -- .../GeneratedCode/Quantities/Scalar.g.cs | 1 - .../GeneratedCode/Quantities/SolidAngle.g.cs | 1 - .../Quantities/SpecificEnergy.g.cs | 25 -------- .../Quantities/SpecificEntropy.g.cs | 9 --- .../Quantities/SpecificFuelConsumption.g.cs | 4 -- .../Quantities/SpecificVolume.g.cs | 3 - .../Quantities/SpecificWeight.g.cs | 17 ----- .../GeneratedCode/Quantities/Speed.g.cs | 32 ---------- .../Quantities/StandardVolumeFlow.g.cs | 9 --- .../GeneratedCode/Quantities/Temperature.g.cs | 10 --- .../Quantities/TemperatureChangeRate.g.cs | 10 --- .../Quantities/TemperatureDelta.g.cs | 9 --- .../Quantities/TemperatureGradient.g.cs | 4 -- .../Quantities/ThermalConductivity.g.cs | 2 - .../Quantities/ThermalResistance.g.cs | 6 -- .../GeneratedCode/Quantities/Torque.g.cs | 25 -------- .../Quantities/TorquePerLength.g.cs | 21 ------- .../GeneratedCode/Quantities/Turbidity.g.cs | 1 - .../GeneratedCode/Quantities/VitaminA.g.cs | 1 - .../GeneratedCode/Quantities/Volume.g.cs | 52 ---------------- .../Quantities/VolumeConcentration.g.cs | 20 ------ .../GeneratedCode/Quantities/VolumeFlow.g.cs | 62 ------------------- .../Quantities/VolumeFlowPerArea.g.cs | 2 - .../Quantities/VolumePerLength.g.cs | 7 --- .../Quantities/VolumetricHeatCapacity.g.cs | 9 --- .../Quantities/WarpingMomentOfInertia.g.cs | 6 -- .../Quantities/Acceleration.g.cs | 14 ----- .../Quantities/AmountOfSubstance.g.cs | 15 ----- .../Quantities/AmplitudeRatio.g.cs | 4 -- UnitsNet/GeneratedCode/Quantities/Angle.g.cs | 16 ----- .../Quantities/ApparentEnergy.g.cs | 3 - .../Quantities/ApparentPower.g.cs | 4 -- UnitsNet/GeneratedCode/Quantities/Area.g.cs | 14 ----- .../GeneratedCode/Quantities/AreaDensity.g.cs | 1 - .../Quantities/AreaMomentOfInertia.g.cs | 6 -- .../GeneratedCode/Quantities/BitRate.g.cs | 26 -------- .../BrakeSpecificFuelConsumption.g.cs | 3 - .../GeneratedCode/Quantities/Capacitance.g.cs | 7 --- .../CoefficientOfThermalExpansion.g.cs | 3 - .../Quantities/Compressibility.g.cs | 7 --- .../GeneratedCode/Quantities/Density.g.cs | 51 --------------- .../GeneratedCode/Quantities/Duration.g.cs | 11 ---- .../Quantities/DynamicViscosity.g.cs | 10 --- .../Quantities/ElectricAdmittance.g.cs | 4 -- .../Quantities/ElectricCharge.g.cs | 5 -- .../Quantities/ElectricChargeDensity.g.cs | 1 - .../Quantities/ElectricConductance.g.cs | 3 - .../Quantities/ElectricConductivity.g.cs | 3 - .../Quantities/ElectricCurrent.g.cs | 8 --- .../Quantities/ElectricCurrentDensity.g.cs | 3 - .../Quantities/ElectricCurrentGradient.g.cs | 4 -- .../Quantities/ElectricField.g.cs | 1 - .../Quantities/ElectricInductance.g.cs | 4 -- .../Quantities/ElectricPotential.g.cs | 5 -- .../Quantities/ElectricPotentialAc.g.cs | 5 -- .../ElectricPotentialChangeRate.g.cs | 20 ------ .../Quantities/ElectricPotentialDc.g.cs | 5 -- .../Quantities/ElectricResistance.g.cs | 6 -- .../Quantities/ElectricResistivity.g.cs | 14 ----- .../ElectricSurfaceChargeDensity.g.cs | 3 - UnitsNet/GeneratedCode/Quantities/Energy.g.cs | 36 ----------- .../GeneratedCode/Quantities/Entropy.g.cs | 7 --- UnitsNet/GeneratedCode/Quantities/Force.g.cs | 15 ----- .../Quantities/ForceChangeRate.g.cs | 15 ----- .../Quantities/ForcePerLength.g.cs | 38 ------------ .../GeneratedCode/Quantities/Frequency.g.cs | 11 ---- .../Quantities/FuelEfficiency.g.cs | 4 -- .../GeneratedCode/Quantities/HeatFlux.g.cs | 18 ------ .../Quantities/HeatTransferCoefficient.g.cs | 3 - .../GeneratedCode/Quantities/Illuminance.g.cs | 4 -- .../GeneratedCode/Quantities/Information.g.cs | 26 -------- .../GeneratedCode/Quantities/Irradiance.g.cs | 14 ----- .../GeneratedCode/Quantities/Irradiation.g.cs | 7 --- .../Quantities/KinematicViscosity.g.cs | 9 --- .../GeneratedCode/Quantities/LapseRate.g.cs | 1 - UnitsNet/GeneratedCode/Quantities/Length.g.cs | 35 ----------- UnitsNet/GeneratedCode/Quantities/Level.g.cs | 2 - .../Quantities/LinearDensity.g.cs | 14 ----- .../Quantities/LinearPowerDensity.g.cs | 25 -------- .../GeneratedCode/Quantities/Luminosity.g.cs | 14 ----- .../Quantities/LuminousFlux.g.cs | 1 - .../Quantities/LuminousIntensity.g.cs | 1 - .../Quantities/MagneticField.g.cs | 6 -- .../Quantities/MagneticFlux.g.cs | 1 - .../Quantities/Magnetization.g.cs | 1 - UnitsNet/GeneratedCode/Quantities/Mass.g.cs | 25 -------- .../Quantities/MassConcentration.g.cs | 49 --------------- .../GeneratedCode/Quantities/MassFlow.g.cs | 33 ---------- .../GeneratedCode/Quantities/MassFlux.g.cs | 12 ---- .../Quantities/MassFraction.g.cs | 24 ------- .../Quantities/MassMomentOfInertia.g.cs | 28 --------- .../GeneratedCode/Quantities/MolarEnergy.g.cs | 3 - .../Quantities/MolarEntropy.g.cs | 3 - .../GeneratedCode/Quantities/MolarMass.g.cs | 12 ---- .../GeneratedCode/Quantities/Molarity.g.cs | 8 --- .../Quantities/Permeability.g.cs | 1 - .../Quantities/Permittivity.g.cs | 1 - UnitsNet/GeneratedCode/Quantities/Power.g.cs | 25 -------- .../Quantities/PowerDensity.g.cs | 44 ------------- .../GeneratedCode/Quantities/PowerRatio.g.cs | 2 - .../GeneratedCode/Quantities/Pressure.g.cs | 45 -------------- .../Quantities/PressureChangeRate.g.cs | 14 ----- UnitsNet/GeneratedCode/Quantities/Ratio.g.cs | 6 -- .../Quantities/RatioChangeRate.g.cs | 2 - .../Quantities/ReactiveEnergy.g.cs | 3 - .../Quantities/ReactivePower.g.cs | 4 -- .../Quantities/ReciprocalArea.g.cs | 11 ---- .../Quantities/ReciprocalLength.g.cs | 10 --- .../Quantities/RelativeHumidity.g.cs | 1 - .../Quantities/RotationalAcceleration.g.cs | 4 -- .../Quantities/RotationalSpeed.g.cs | 13 ---- .../Quantities/RotationalStiffness.g.cs | 33 ---------- .../RotationalStiffnessPerLength.g.cs | 5 -- UnitsNet/GeneratedCode/Quantities/Scalar.g.cs | 1 - .../GeneratedCode/Quantities/SolidAngle.g.cs | 1 - .../Quantities/SpecificEnergy.g.cs | 25 -------- .../Quantities/SpecificEntropy.g.cs | 9 --- .../Quantities/SpecificFuelConsumption.g.cs | 4 -- .../Quantities/SpecificVolume.g.cs | 3 - .../Quantities/SpecificWeight.g.cs | 17 ----- UnitsNet/GeneratedCode/Quantities/Speed.g.cs | 32 ---------- .../Quantities/StandardVolumeFlow.g.cs | 9 --- .../GeneratedCode/Quantities/Temperature.g.cs | 10 --- .../Quantities/TemperatureChangeRate.g.cs | 10 --- .../Quantities/TemperatureDelta.g.cs | 9 --- .../Quantities/TemperatureGradient.g.cs | 4 -- .../Quantities/ThermalConductivity.g.cs | 2 - .../Quantities/ThermalResistance.g.cs | 6 -- UnitsNet/GeneratedCode/Quantities/Torque.g.cs | 25 -------- .../Quantities/TorquePerLength.g.cs | 21 ------- .../GeneratedCode/Quantities/Turbidity.g.cs | 1 - .../GeneratedCode/Quantities/VitaminA.g.cs | 1 - UnitsNet/GeneratedCode/Quantities/Volume.g.cs | 52 ---------------- .../Quantities/VolumeConcentration.g.cs | 20 ------ .../GeneratedCode/Quantities/VolumeFlow.g.cs | 62 ------------------- .../Quantities/VolumeFlowPerArea.g.cs | 2 - .../Quantities/VolumePerLength.g.cs | 7 --- .../Quantities/VolumetricHeatCapacity.g.cs | 9 --- .../Quantities/WarpingMomentOfInertia.g.cs | 6 -- 228 files changed, 2 insertions(+), 2736 deletions(-) diff --git a/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs b/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs index b888bc08df..05ae7695af 100644 --- a/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs +++ b/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs @@ -463,8 +463,7 @@ private void GenerateStaticFactoryMethods() {{ {_valueType} value = ({_valueType}) {valueParamName}; return new {_quantity.Name}(value, {_unitEnumName}.{unit.SingularName}); - }} -"); + }}"); } Writer.WL(); diff --git a/CodeGen/Generators/UnitsNetWrcGen/QuantityGenerator.cs b/CodeGen/Generators/UnitsNetWrcGen/QuantityGenerator.cs index a8aed45f18..d26c092c89 100644 --- a/CodeGen/Generators/UnitsNetWrcGen/QuantityGenerator.cs +++ b/CodeGen/Generators/UnitsNetWrcGen/QuantityGenerator.cs @@ -352,8 +352,7 @@ private void GenerateStaticFactoryMethods() {{ {_valueType} value = ({_valueType}) {valueParamName}; return new {_quantity.Name}(value, {_unitEnumName}.{unit.SingularName}); - }} -"); + }}"); } Writer.WL(); diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Acceleration.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Acceleration.g.cs index 2ad97093ae..ef11f84099 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Acceleration.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Acceleration.g.cs @@ -305,7 +305,6 @@ public static Acceleration FromCentimetersPerSecondSquared(double centimetersper double value = (double) centimeterspersecondsquared; return new Acceleration(value, AccelerationUnit.CentimeterPerSecondSquared); } - /// /// Creates a from . /// @@ -316,7 +315,6 @@ public static Acceleration FromDecimetersPerSecondSquared(double decimetersperse double value = (double) decimeterspersecondsquared; return new Acceleration(value, AccelerationUnit.DecimeterPerSecondSquared); } - /// /// Creates a from . /// @@ -327,7 +325,6 @@ public static Acceleration FromFeetPerSecondSquared(double feetpersecondsquared) double value = (double) feetpersecondsquared; return new Acceleration(value, AccelerationUnit.FootPerSecondSquared); } - /// /// Creates a from . /// @@ -338,7 +335,6 @@ public static Acceleration FromInchesPerSecondSquared(double inchespersecondsqua double value = (double) inchespersecondsquared; return new Acceleration(value, AccelerationUnit.InchPerSecondSquared); } - /// /// Creates a from . /// @@ -349,7 +345,6 @@ public static Acceleration FromKilometersPerSecondSquared(double kilometersperse double value = (double) kilometerspersecondsquared; return new Acceleration(value, AccelerationUnit.KilometerPerSecondSquared); } - /// /// Creates a from . /// @@ -360,7 +355,6 @@ public static Acceleration FromKnotsPerHour(double knotsperhour) double value = (double) knotsperhour; return new Acceleration(value, AccelerationUnit.KnotPerHour); } - /// /// Creates a from . /// @@ -371,7 +365,6 @@ public static Acceleration FromKnotsPerMinute(double knotsperminute) double value = (double) knotsperminute; return new Acceleration(value, AccelerationUnit.KnotPerMinute); } - /// /// Creates a from . /// @@ -382,7 +375,6 @@ public static Acceleration FromKnotsPerSecond(double knotspersecond) double value = (double) knotspersecond; return new Acceleration(value, AccelerationUnit.KnotPerSecond); } - /// /// Creates a from . /// @@ -393,7 +385,6 @@ public static Acceleration FromMetersPerSecondSquared(double meterspersecondsqua double value = (double) meterspersecondsquared; return new Acceleration(value, AccelerationUnit.MeterPerSecondSquared); } - /// /// Creates a from . /// @@ -404,7 +395,6 @@ public static Acceleration FromMicrometersPerSecondSquared(double micrometersper double value = (double) micrometerspersecondsquared; return new Acceleration(value, AccelerationUnit.MicrometerPerSecondSquared); } - /// /// Creates a from . /// @@ -415,7 +405,6 @@ public static Acceleration FromMillimetersPerSecondSquared(double millimetersper double value = (double) millimeterspersecondsquared; return new Acceleration(value, AccelerationUnit.MillimeterPerSecondSquared); } - /// /// Creates a from . /// @@ -426,7 +415,6 @@ public static Acceleration FromMillistandardGravity(double millistandardgravity) double value = (double) millistandardgravity; return new Acceleration(value, AccelerationUnit.MillistandardGravity); } - /// /// Creates a from . /// @@ -437,7 +425,6 @@ public static Acceleration FromNanometersPerSecondSquared(double nanometersperse double value = (double) nanometerspersecondsquared; return new Acceleration(value, AccelerationUnit.NanometerPerSecondSquared); } - /// /// Creates a from . /// @@ -449,7 +436,6 @@ public static Acceleration FromStandardGravity(double standardgravity) return new Acceleration(value, AccelerationUnit.StandardGravity); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmountOfSubstance.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmountOfSubstance.g.cs index 4043a7de90..aa34666ead 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmountOfSubstance.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmountOfSubstance.g.cs @@ -297,7 +297,6 @@ public static AmountOfSubstance FromCentimoles(double centimoles) double value = (double) centimoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Centimole); } - /// /// Creates a from . /// @@ -308,7 +307,6 @@ public static AmountOfSubstance FromCentipoundMoles(double centipoundmoles) double value = (double) centipoundmoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.CentipoundMole); } - /// /// Creates a from . /// @@ -319,7 +317,6 @@ public static AmountOfSubstance FromDecimoles(double decimoles) double value = (double) decimoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Decimole); } - /// /// Creates a from . /// @@ -330,7 +327,6 @@ public static AmountOfSubstance FromDecipoundMoles(double decipoundmoles) double value = (double) decipoundmoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.DecipoundMole); } - /// /// Creates a from . /// @@ -341,7 +337,6 @@ public static AmountOfSubstance FromKilomoles(double kilomoles) double value = (double) kilomoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Kilomole); } - /// /// Creates a from . /// @@ -352,7 +347,6 @@ public static AmountOfSubstance FromKilopoundMoles(double kilopoundmoles) double value = (double) kilopoundmoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.KilopoundMole); } - /// /// Creates a from . /// @@ -363,7 +357,6 @@ public static AmountOfSubstance FromMegamoles(double megamoles) double value = (double) megamoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Megamole); } - /// /// Creates a from . /// @@ -374,7 +367,6 @@ public static AmountOfSubstance FromMicromoles(double micromoles) double value = (double) micromoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Micromole); } - /// /// Creates a from . /// @@ -385,7 +377,6 @@ public static AmountOfSubstance FromMicropoundMoles(double micropoundmoles) double value = (double) micropoundmoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.MicropoundMole); } - /// /// Creates a from . /// @@ -396,7 +387,6 @@ public static AmountOfSubstance FromMillimoles(double millimoles) double value = (double) millimoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Millimole); } - /// /// Creates a from . /// @@ -407,7 +397,6 @@ public static AmountOfSubstance FromMillipoundMoles(double millipoundmoles) double value = (double) millipoundmoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.MillipoundMole); } - /// /// Creates a from . /// @@ -418,7 +407,6 @@ public static AmountOfSubstance FromMoles(double moles) double value = (double) moles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Mole); } - /// /// Creates a from . /// @@ -429,7 +417,6 @@ public static AmountOfSubstance FromNanomoles(double nanomoles) double value = (double) nanomoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Nanomole); } - /// /// Creates a from . /// @@ -440,7 +427,6 @@ public static AmountOfSubstance FromNanopoundMoles(double nanopoundmoles) double value = (double) nanopoundmoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.NanopoundMole); } - /// /// Creates a from . /// @@ -452,7 +438,6 @@ public static AmountOfSubstance FromPoundMoles(double poundmoles) return new AmountOfSubstance(value, AmountOfSubstanceUnit.PoundMole); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmplitudeRatio.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmplitudeRatio.g.cs index 4bcebc2079..b179cdab68 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmplitudeRatio.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmplitudeRatio.g.cs @@ -231,7 +231,6 @@ public static AmplitudeRatio FromDecibelMicrovolts(double decibelmicrovolts) double value = (double) decibelmicrovolts; return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelMicrovolt); } - /// /// Creates a from . /// @@ -242,7 +241,6 @@ public static AmplitudeRatio FromDecibelMillivolts(double decibelmillivolts) double value = (double) decibelmillivolts; return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelMillivolt); } - /// /// Creates a from . /// @@ -253,7 +251,6 @@ public static AmplitudeRatio FromDecibelsUnloaded(double decibelsunloaded) double value = (double) decibelsunloaded; return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelUnloaded); } - /// /// Creates a from . /// @@ -265,7 +262,6 @@ public static AmplitudeRatio FromDecibelVolts(double decibelvolts) return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelVolt); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Angle.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Angle.g.cs index ddaf3deade..50efbd498c 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Angle.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Angle.g.cs @@ -315,7 +315,6 @@ public static Angle FromArcminutes(double arcminutes) double value = (double) arcminutes; return new Angle(value, AngleUnit.Arcminute); } - /// /// Creates a from . /// @@ -326,7 +325,6 @@ public static Angle FromArcseconds(double arcseconds) double value = (double) arcseconds; return new Angle(value, AngleUnit.Arcsecond); } - /// /// Creates a from . /// @@ -337,7 +335,6 @@ public static Angle FromCentiradians(double centiradians) double value = (double) centiradians; return new Angle(value, AngleUnit.Centiradian); } - /// /// Creates a from . /// @@ -348,7 +345,6 @@ public static Angle FromDeciradians(double deciradians) double value = (double) deciradians; return new Angle(value, AngleUnit.Deciradian); } - /// /// Creates a from . /// @@ -359,7 +355,6 @@ public static Angle FromDegrees(double degrees) double value = (double) degrees; return new Angle(value, AngleUnit.Degree); } - /// /// Creates a from . /// @@ -370,7 +365,6 @@ public static Angle FromGradians(double gradians) double value = (double) gradians; return new Angle(value, AngleUnit.Gradian); } - /// /// Creates a from . /// @@ -381,7 +375,6 @@ public static Angle FromMicrodegrees(double microdegrees) double value = (double) microdegrees; return new Angle(value, AngleUnit.Microdegree); } - /// /// Creates a from . /// @@ -392,7 +385,6 @@ public static Angle FromMicroradians(double microradians) double value = (double) microradians; return new Angle(value, AngleUnit.Microradian); } - /// /// Creates a from . /// @@ -403,7 +395,6 @@ public static Angle FromMillidegrees(double millidegrees) double value = (double) millidegrees; return new Angle(value, AngleUnit.Millidegree); } - /// /// Creates a from . /// @@ -414,7 +405,6 @@ public static Angle FromMilliradians(double milliradians) double value = (double) milliradians; return new Angle(value, AngleUnit.Milliradian); } - /// /// Creates a from . /// @@ -425,7 +415,6 @@ public static Angle FromNanodegrees(double nanodegrees) double value = (double) nanodegrees; return new Angle(value, AngleUnit.Nanodegree); } - /// /// Creates a from . /// @@ -436,7 +425,6 @@ public static Angle FromNanoradians(double nanoradians) double value = (double) nanoradians; return new Angle(value, AngleUnit.Nanoradian); } - /// /// Creates a from . /// @@ -447,7 +435,6 @@ public static Angle FromNatoMils(double natomils) double value = (double) natomils; return new Angle(value, AngleUnit.NatoMil); } - /// /// Creates a from . /// @@ -458,7 +445,6 @@ public static Angle FromRadians(double radians) double value = (double) radians; return new Angle(value, AngleUnit.Radian); } - /// /// Creates a from . /// @@ -469,7 +455,6 @@ public static Angle FromRevolutions(double revolutions) double value = (double) revolutions; return new Angle(value, AngleUnit.Revolution); } - /// /// Creates a from . /// @@ -481,7 +466,6 @@ public static Angle FromTilt(double tilt) return new Angle(value, AngleUnit.Tilt); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentEnergy.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentEnergy.g.cs index 17c607c5ad..e0935aacf3 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentEnergy.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentEnergy.g.cs @@ -225,7 +225,6 @@ public static ApparentEnergy FromKilovoltampereHours(double kilovoltamperehours) double value = (double) kilovoltamperehours; return new ApparentEnergy(value, ApparentEnergyUnit.KilovoltampereHour); } - /// /// Creates a from . /// @@ -236,7 +235,6 @@ public static ApparentEnergy FromMegavoltampereHours(double megavoltamperehours) double value = (double) megavoltamperehours; return new ApparentEnergy(value, ApparentEnergyUnit.MegavoltampereHour); } - /// /// Creates a from . /// @@ -248,7 +246,6 @@ public static ApparentEnergy FromVoltampereHours(double voltamperehours) return new ApparentEnergy(value, ApparentEnergyUnit.VoltampereHour); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentPower.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentPower.g.cs index 08976c8ac3..807a33365f 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentPower.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentPower.g.cs @@ -231,7 +231,6 @@ public static ApparentPower FromGigavoltamperes(double gigavoltamperes) double value = (double) gigavoltamperes; return new ApparentPower(value, ApparentPowerUnit.Gigavoltampere); } - /// /// Creates a from . /// @@ -242,7 +241,6 @@ public static ApparentPower FromKilovoltamperes(double kilovoltamperes) double value = (double) kilovoltamperes; return new ApparentPower(value, ApparentPowerUnit.Kilovoltampere); } - /// /// Creates a from . /// @@ -253,7 +251,6 @@ public static ApparentPower FromMegavoltamperes(double megavoltamperes) double value = (double) megavoltamperes; return new ApparentPower(value, ApparentPowerUnit.Megavoltampere); } - /// /// Creates a from . /// @@ -265,7 +262,6 @@ public static ApparentPower FromVoltamperes(double voltamperes) return new ApparentPower(value, ApparentPowerUnit.Voltampere); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Area.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Area.g.cs index a4201f9e6b..1fe6b5a24c 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Area.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Area.g.cs @@ -318,7 +318,6 @@ public static Area FromAcres(double acres) double value = (double) acres; return new Area(value, AreaUnit.Acre); } - /// /// Creates a from . /// @@ -329,7 +328,6 @@ public static Area FromHectares(double hectares) double value = (double) hectares; return new Area(value, AreaUnit.Hectare); } - /// /// Creates a from . /// @@ -340,7 +338,6 @@ public static Area FromSquareCentimeters(double squarecentimeters) double value = (double) squarecentimeters; return new Area(value, AreaUnit.SquareCentimeter); } - /// /// Creates a from . /// @@ -351,7 +348,6 @@ public static Area FromSquareDecimeters(double squaredecimeters) double value = (double) squaredecimeters; return new Area(value, AreaUnit.SquareDecimeter); } - /// /// Creates a from . /// @@ -362,7 +358,6 @@ public static Area FromSquareFeet(double squarefeet) double value = (double) squarefeet; return new Area(value, AreaUnit.SquareFoot); } - /// /// Creates a from . /// @@ -373,7 +368,6 @@ public static Area FromSquareInches(double squareinches) double value = (double) squareinches; return new Area(value, AreaUnit.SquareInch); } - /// /// Creates a from . /// @@ -384,7 +378,6 @@ public static Area FromSquareKilometers(double squarekilometers) double value = (double) squarekilometers; return new Area(value, AreaUnit.SquareKilometer); } - /// /// Creates a from . /// @@ -395,7 +388,6 @@ public static Area FromSquareMeters(double squaremeters) double value = (double) squaremeters; return new Area(value, AreaUnit.SquareMeter); } - /// /// Creates a from . /// @@ -406,7 +398,6 @@ public static Area FromSquareMicrometers(double squaremicrometers) double value = (double) squaremicrometers; return new Area(value, AreaUnit.SquareMicrometer); } - /// /// Creates a from . /// @@ -417,7 +408,6 @@ public static Area FromSquareMiles(double squaremiles) double value = (double) squaremiles; return new Area(value, AreaUnit.SquareMile); } - /// /// Creates a from . /// @@ -428,7 +418,6 @@ public static Area FromSquareMillimeters(double squaremillimeters) double value = (double) squaremillimeters; return new Area(value, AreaUnit.SquareMillimeter); } - /// /// Creates a from . /// @@ -439,7 +428,6 @@ public static Area FromSquareNauticalMiles(double squarenauticalmiles) double value = (double) squarenauticalmiles; return new Area(value, AreaUnit.SquareNauticalMile); } - /// /// Creates a from . /// @@ -450,7 +438,6 @@ public static Area FromSquareYards(double squareyards) double value = (double) squareyards; return new Area(value, AreaUnit.SquareYard); } - /// /// Creates a from . /// @@ -462,7 +449,6 @@ public static Area FromUsSurveySquareFeet(double ussurveysquarefeet) return new Area(value, AreaUnit.UsSurveySquareFoot); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaDensity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaDensity.g.cs index 726ed56fbb..9ef759f4a8 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaDensity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaDensity.g.cs @@ -214,7 +214,6 @@ public static AreaDensity FromKilogramsPerSquareMeter(double kilogramspersquarem return new AreaDensity(value, AreaDensityUnit.KilogramPerSquareMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs index b3d801a662..29b0403dba 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs @@ -243,7 +243,6 @@ public static AreaMomentOfInertia FromCentimetersToTheFourth(double centimeterst double value = (double) centimeterstothefourth; return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.CentimeterToTheFourth); } - /// /// Creates a from . /// @@ -254,7 +253,6 @@ public static AreaMomentOfInertia FromDecimetersToTheFourth(double decimeterstot double value = (double) decimeterstothefourth; return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.DecimeterToTheFourth); } - /// /// Creates a from . /// @@ -265,7 +263,6 @@ public static AreaMomentOfInertia FromFeetToTheFourth(double feettothefourth) double value = (double) feettothefourth; return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.FootToTheFourth); } - /// /// Creates a from . /// @@ -276,7 +273,6 @@ public static AreaMomentOfInertia FromInchesToTheFourth(double inchestothefourth double value = (double) inchestothefourth; return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.InchToTheFourth); } - /// /// Creates a from . /// @@ -287,7 +283,6 @@ public static AreaMomentOfInertia FromMetersToTheFourth(double meterstothefourth double value = (double) meterstothefourth; return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.MeterToTheFourth); } - /// /// Creates a from . /// @@ -299,7 +294,6 @@ public static AreaMomentOfInertia FromMillimetersToTheFourth(double millimeterst return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.MillimeterToTheFourth); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BitRate.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BitRate.g.cs index 638432b733..b48f781528 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BitRate.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BitRate.g.cs @@ -366,7 +366,6 @@ public static BitRate FromBitsPerSecond(double bitspersecond) decimal value = (decimal) bitspersecond; return new BitRate(value, BitRateUnit.BitPerSecond); } - /// /// Creates a from . /// @@ -377,7 +376,6 @@ public static BitRate FromBytesPerSecond(double bytespersecond) decimal value = (decimal) bytespersecond; return new BitRate(value, BitRateUnit.BytePerSecond); } - /// /// Creates a from . /// @@ -388,7 +386,6 @@ public static BitRate FromExabitsPerSecond(double exabitspersecond) decimal value = (decimal) exabitspersecond; return new BitRate(value, BitRateUnit.ExabitPerSecond); } - /// /// Creates a from . /// @@ -399,7 +396,6 @@ public static BitRate FromExabytesPerSecond(double exabytespersecond) decimal value = (decimal) exabytespersecond; return new BitRate(value, BitRateUnit.ExabytePerSecond); } - /// /// Creates a from . /// @@ -410,7 +406,6 @@ public static BitRate FromExbibitsPerSecond(double exbibitspersecond) decimal value = (decimal) exbibitspersecond; return new BitRate(value, BitRateUnit.ExbibitPerSecond); } - /// /// Creates a from . /// @@ -421,7 +416,6 @@ public static BitRate FromExbibytesPerSecond(double exbibytespersecond) decimal value = (decimal) exbibytespersecond; return new BitRate(value, BitRateUnit.ExbibytePerSecond); } - /// /// Creates a from . /// @@ -432,7 +426,6 @@ public static BitRate FromGibibitsPerSecond(double gibibitspersecond) decimal value = (decimal) gibibitspersecond; return new BitRate(value, BitRateUnit.GibibitPerSecond); } - /// /// Creates a from . /// @@ -443,7 +436,6 @@ public static BitRate FromGibibytesPerSecond(double gibibytespersecond) decimal value = (decimal) gibibytespersecond; return new BitRate(value, BitRateUnit.GibibytePerSecond); } - /// /// Creates a from . /// @@ -454,7 +446,6 @@ public static BitRate FromGigabitsPerSecond(double gigabitspersecond) decimal value = (decimal) gigabitspersecond; return new BitRate(value, BitRateUnit.GigabitPerSecond); } - /// /// Creates a from . /// @@ -465,7 +456,6 @@ public static BitRate FromGigabytesPerSecond(double gigabytespersecond) decimal value = (decimal) gigabytespersecond; return new BitRate(value, BitRateUnit.GigabytePerSecond); } - /// /// Creates a from . /// @@ -476,7 +466,6 @@ public static BitRate FromKibibitsPerSecond(double kibibitspersecond) decimal value = (decimal) kibibitspersecond; return new BitRate(value, BitRateUnit.KibibitPerSecond); } - /// /// Creates a from . /// @@ -487,7 +476,6 @@ public static BitRate FromKibibytesPerSecond(double kibibytespersecond) decimal value = (decimal) kibibytespersecond; return new BitRate(value, BitRateUnit.KibibytePerSecond); } - /// /// Creates a from . /// @@ -498,7 +486,6 @@ public static BitRate FromKilobitsPerSecond(double kilobitspersecond) decimal value = (decimal) kilobitspersecond; return new BitRate(value, BitRateUnit.KilobitPerSecond); } - /// /// Creates a from . /// @@ -509,7 +496,6 @@ public static BitRate FromKilobytesPerSecond(double kilobytespersecond) decimal value = (decimal) kilobytespersecond; return new BitRate(value, BitRateUnit.KilobytePerSecond); } - /// /// Creates a from . /// @@ -520,7 +506,6 @@ public static BitRate FromMebibitsPerSecond(double mebibitspersecond) decimal value = (decimal) mebibitspersecond; return new BitRate(value, BitRateUnit.MebibitPerSecond); } - /// /// Creates a from . /// @@ -531,7 +516,6 @@ public static BitRate FromMebibytesPerSecond(double mebibytespersecond) decimal value = (decimal) mebibytespersecond; return new BitRate(value, BitRateUnit.MebibytePerSecond); } - /// /// Creates a from . /// @@ -542,7 +526,6 @@ public static BitRate FromMegabitsPerSecond(double megabitspersecond) decimal value = (decimal) megabitspersecond; return new BitRate(value, BitRateUnit.MegabitPerSecond); } - /// /// Creates a from . /// @@ -553,7 +536,6 @@ public static BitRate FromMegabytesPerSecond(double megabytespersecond) decimal value = (decimal) megabytespersecond; return new BitRate(value, BitRateUnit.MegabytePerSecond); } - /// /// Creates a from . /// @@ -564,7 +546,6 @@ public static BitRate FromPebibitsPerSecond(double pebibitspersecond) decimal value = (decimal) pebibitspersecond; return new BitRate(value, BitRateUnit.PebibitPerSecond); } - /// /// Creates a from . /// @@ -575,7 +556,6 @@ public static BitRate FromPebibytesPerSecond(double pebibytespersecond) decimal value = (decimal) pebibytespersecond; return new BitRate(value, BitRateUnit.PebibytePerSecond); } - /// /// Creates a from . /// @@ -586,7 +566,6 @@ public static BitRate FromPetabitsPerSecond(double petabitspersecond) decimal value = (decimal) petabitspersecond; return new BitRate(value, BitRateUnit.PetabitPerSecond); } - /// /// Creates a from . /// @@ -597,7 +576,6 @@ public static BitRate FromPetabytesPerSecond(double petabytespersecond) decimal value = (decimal) petabytespersecond; return new BitRate(value, BitRateUnit.PetabytePerSecond); } - /// /// Creates a from . /// @@ -608,7 +586,6 @@ public static BitRate FromTebibitsPerSecond(double tebibitspersecond) decimal value = (decimal) tebibitspersecond; return new BitRate(value, BitRateUnit.TebibitPerSecond); } - /// /// Creates a from . /// @@ -619,7 +596,6 @@ public static BitRate FromTebibytesPerSecond(double tebibytespersecond) decimal value = (decimal) tebibytespersecond; return new BitRate(value, BitRateUnit.TebibytePerSecond); } - /// /// Creates a from . /// @@ -630,7 +606,6 @@ public static BitRate FromTerabitsPerSecond(double terabitspersecond) decimal value = (decimal) terabitspersecond; return new BitRate(value, BitRateUnit.TerabitPerSecond); } - /// /// Creates a from . /// @@ -642,7 +617,6 @@ public static BitRate FromTerabytesPerSecond(double terabytespersecond) return new BitRate(value, BitRateUnit.TerabytePerSecond); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs index 206fca1b13..179e6fb1ee 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs @@ -225,7 +225,6 @@ public static BrakeSpecificFuelConsumption FromGramsPerKiloWattHour(double grams double value = (double) gramsperkilowatthour; return new BrakeSpecificFuelConsumption(value, BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour); } - /// /// Creates a from . /// @@ -236,7 +235,6 @@ public static BrakeSpecificFuelConsumption FromKilogramsPerJoule(double kilogram double value = (double) kilogramsperjoule; return new BrakeSpecificFuelConsumption(value, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule); } - /// /// Creates a from . /// @@ -248,7 +246,6 @@ public static BrakeSpecificFuelConsumption FromPoundsPerMechanicalHorsepowerHour return new BrakeSpecificFuelConsumption(value, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Capacitance.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Capacitance.g.cs index faaf239857..9c4bf6e762 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Capacitance.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Capacitance.g.cs @@ -252,7 +252,6 @@ public static Capacitance FromFarads(double farads) double value = (double) farads; return new Capacitance(value, CapacitanceUnit.Farad); } - /// /// Creates a from . /// @@ -263,7 +262,6 @@ public static Capacitance FromKilofarads(double kilofarads) double value = (double) kilofarads; return new Capacitance(value, CapacitanceUnit.Kilofarad); } - /// /// Creates a from . /// @@ -274,7 +272,6 @@ public static Capacitance FromMegafarads(double megafarads) double value = (double) megafarads; return new Capacitance(value, CapacitanceUnit.Megafarad); } - /// /// Creates a from . /// @@ -285,7 +282,6 @@ public static Capacitance FromMicrofarads(double microfarads) double value = (double) microfarads; return new Capacitance(value, CapacitanceUnit.Microfarad); } - /// /// Creates a from . /// @@ -296,7 +292,6 @@ public static Capacitance FromMillifarads(double millifarads) double value = (double) millifarads; return new Capacitance(value, CapacitanceUnit.Millifarad); } - /// /// Creates a from . /// @@ -307,7 +302,6 @@ public static Capacitance FromNanofarads(double nanofarads) double value = (double) nanofarads; return new Capacitance(value, CapacitanceUnit.Nanofarad); } - /// /// Creates a from . /// @@ -319,7 +313,6 @@ public static Capacitance FromPicofarads(double picofarads) return new Capacitance(value, CapacitanceUnit.Picofarad); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs index e690ee7ef8..2139989730 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs @@ -225,7 +225,6 @@ public static CoefficientOfThermalExpansion FromInverseDegreeCelsius(double inve double value = (double) inversedegreecelsius; return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.InverseDegreeCelsius); } - /// /// Creates a from . /// @@ -236,7 +235,6 @@ public static CoefficientOfThermalExpansion FromInverseDegreeFahrenheit(double i double value = (double) inversedegreefahrenheit; return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit); } - /// /// Creates a from . /// @@ -248,7 +246,6 @@ public static CoefficientOfThermalExpansion FromInverseKelvin(double inversekelv return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.InverseKelvin); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Compressibility.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Compressibility.g.cs index 5cbc828ddf..26e9d5ee96 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Compressibility.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Compressibility.g.cs @@ -249,7 +249,6 @@ public static Compressibility FromInverseAtmospheres(double inverseatmospheres) double value = (double) inverseatmospheres; return new Compressibility(value, CompressibilityUnit.InverseAtmosphere); } - /// /// Creates a from . /// @@ -260,7 +259,6 @@ public static Compressibility FromInverseBars(double inversebars) double value = (double) inversebars; return new Compressibility(value, CompressibilityUnit.InverseBar); } - /// /// Creates a from . /// @@ -271,7 +269,6 @@ public static Compressibility FromInverseKilopascals(double inversekilopascals) double value = (double) inversekilopascals; return new Compressibility(value, CompressibilityUnit.InverseKilopascal); } - /// /// Creates a from . /// @@ -282,7 +279,6 @@ public static Compressibility FromInverseMegapascals(double inversemegapascals) double value = (double) inversemegapascals; return new Compressibility(value, CompressibilityUnit.InverseMegapascal); } - /// /// Creates a from . /// @@ -293,7 +289,6 @@ public static Compressibility FromInverseMillibars(double inversemillibars) double value = (double) inversemillibars; return new Compressibility(value, CompressibilityUnit.InverseMillibar); } - /// /// Creates a from . /// @@ -304,7 +299,6 @@ public static Compressibility FromInversePascals(double inversepascals) double value = (double) inversepascals; return new Compressibility(value, CompressibilityUnit.InversePascal); } - /// /// Creates a from . /// @@ -316,7 +310,6 @@ public static Compressibility FromInversePoundForcePerSquareInchs(double inverse return new Compressibility(value, CompressibilityUnit.InversePoundForcePerSquareInch); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Density.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Density.g.cs index ee9b52dc48..8ae408511e 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Density.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Density.g.cs @@ -520,7 +520,6 @@ public static Density FromCentigramsPerDeciLiter(double centigramsperdeciliter) double value = (double) centigramsperdeciliter; return new Density(value, DensityUnit.CentigramPerDeciliter); } - /// /// Creates a from . /// @@ -531,7 +530,6 @@ public static Density FromCentigramsPerLiter(double centigramsperliter) double value = (double) centigramsperliter; return new Density(value, DensityUnit.CentigramPerLiter); } - /// /// Creates a from . /// @@ -542,7 +540,6 @@ public static Density FromCentigramsPerMilliliter(double centigramspermilliliter double value = (double) centigramspermilliliter; return new Density(value, DensityUnit.CentigramPerMilliliter); } - /// /// Creates a from . /// @@ -553,7 +550,6 @@ public static Density FromDecigramsPerDeciLiter(double decigramsperdeciliter) double value = (double) decigramsperdeciliter; return new Density(value, DensityUnit.DecigramPerDeciliter); } - /// /// Creates a from . /// @@ -564,7 +560,6 @@ public static Density FromDecigramsPerLiter(double decigramsperliter) double value = (double) decigramsperliter; return new Density(value, DensityUnit.DecigramPerLiter); } - /// /// Creates a from . /// @@ -575,7 +570,6 @@ public static Density FromDecigramsPerMilliliter(double decigramspermilliliter) double value = (double) decigramspermilliliter; return new Density(value, DensityUnit.DecigramPerMilliliter); } - /// /// Creates a from . /// @@ -586,7 +580,6 @@ public static Density FromGramsPerCubicCentimeter(double gramspercubiccentimeter double value = (double) gramspercubiccentimeter; return new Density(value, DensityUnit.GramPerCubicCentimeter); } - /// /// Creates a from . /// @@ -597,7 +590,6 @@ public static Density FromGramsPerCubicFoot(double gramspercubicfoot) double value = (double) gramspercubicfoot; return new Density(value, DensityUnit.GramPerCubicFoot); } - /// /// Creates a from . /// @@ -608,7 +600,6 @@ public static Density FromGramsPerCubicInch(double gramspercubicinch) double value = (double) gramspercubicinch; return new Density(value, DensityUnit.GramPerCubicInch); } - /// /// Creates a from . /// @@ -619,7 +610,6 @@ public static Density FromGramsPerCubicMeter(double gramspercubicmeter) double value = (double) gramspercubicmeter; return new Density(value, DensityUnit.GramPerCubicMeter); } - /// /// Creates a from . /// @@ -630,7 +620,6 @@ public static Density FromGramsPerCubicMillimeter(double gramspercubicmillimeter double value = (double) gramspercubicmillimeter; return new Density(value, DensityUnit.GramPerCubicMillimeter); } - /// /// Creates a from . /// @@ -641,7 +630,6 @@ public static Density FromGramsPerDeciLiter(double gramsperdeciliter) double value = (double) gramsperdeciliter; return new Density(value, DensityUnit.GramPerDeciliter); } - /// /// Creates a from . /// @@ -652,7 +640,6 @@ public static Density FromGramsPerLiter(double gramsperliter) double value = (double) gramsperliter; return new Density(value, DensityUnit.GramPerLiter); } - /// /// Creates a from . /// @@ -663,7 +650,6 @@ public static Density FromGramsPerMilliliter(double gramspermilliliter) double value = (double) gramspermilliliter; return new Density(value, DensityUnit.GramPerMilliliter); } - /// /// Creates a from . /// @@ -674,7 +660,6 @@ public static Density FromKilogramsPerCubicCentimeter(double kilogramspercubicce double value = (double) kilogramspercubiccentimeter; return new Density(value, DensityUnit.KilogramPerCubicCentimeter); } - /// /// Creates a from . /// @@ -685,7 +670,6 @@ public static Density FromKilogramsPerCubicMeter(double kilogramspercubicmeter) double value = (double) kilogramspercubicmeter; return new Density(value, DensityUnit.KilogramPerCubicMeter); } - /// /// Creates a from . /// @@ -696,7 +680,6 @@ public static Density FromKilogramsPerCubicMillimeter(double kilogramspercubicmi double value = (double) kilogramspercubicmillimeter; return new Density(value, DensityUnit.KilogramPerCubicMillimeter); } - /// /// Creates a from . /// @@ -707,7 +690,6 @@ public static Density FromKilogramsPerLiter(double kilogramsperliter) double value = (double) kilogramsperliter; return new Density(value, DensityUnit.KilogramPerLiter); } - /// /// Creates a from . /// @@ -718,7 +700,6 @@ public static Density FromKilopoundsPerCubicFoot(double kilopoundspercubicfoot) double value = (double) kilopoundspercubicfoot; return new Density(value, DensityUnit.KilopoundPerCubicFoot); } - /// /// Creates a from . /// @@ -729,7 +710,6 @@ public static Density FromKilopoundsPerCubicInch(double kilopoundspercubicinch) double value = (double) kilopoundspercubicinch; return new Density(value, DensityUnit.KilopoundPerCubicInch); } - /// /// Creates a from . /// @@ -740,7 +720,6 @@ public static Density FromMicrogramsPerCubicMeter(double microgramspercubicmeter double value = (double) microgramspercubicmeter; return new Density(value, DensityUnit.MicrogramPerCubicMeter); } - /// /// Creates a from . /// @@ -751,7 +730,6 @@ public static Density FromMicrogramsPerDeciLiter(double microgramsperdeciliter) double value = (double) microgramsperdeciliter; return new Density(value, DensityUnit.MicrogramPerDeciliter); } - /// /// Creates a from . /// @@ -762,7 +740,6 @@ public static Density FromMicrogramsPerLiter(double microgramsperliter) double value = (double) microgramsperliter; return new Density(value, DensityUnit.MicrogramPerLiter); } - /// /// Creates a from . /// @@ -773,7 +750,6 @@ public static Density FromMicrogramsPerMilliliter(double microgramspermilliliter double value = (double) microgramspermilliliter; return new Density(value, DensityUnit.MicrogramPerMilliliter); } - /// /// Creates a from . /// @@ -784,7 +760,6 @@ public static Density FromMilligramsPerCubicMeter(double milligramspercubicmeter double value = (double) milligramspercubicmeter; return new Density(value, DensityUnit.MilligramPerCubicMeter); } - /// /// Creates a from . /// @@ -795,7 +770,6 @@ public static Density FromMilligramsPerDeciLiter(double milligramsperdeciliter) double value = (double) milligramsperdeciliter; return new Density(value, DensityUnit.MilligramPerDeciliter); } - /// /// Creates a from . /// @@ -806,7 +780,6 @@ public static Density FromMilligramsPerLiter(double milligramsperliter) double value = (double) milligramsperliter; return new Density(value, DensityUnit.MilligramPerLiter); } - /// /// Creates a from . /// @@ -817,7 +790,6 @@ public static Density FromMilligramsPerMilliliter(double milligramspermilliliter double value = (double) milligramspermilliliter; return new Density(value, DensityUnit.MilligramPerMilliliter); } - /// /// Creates a from . /// @@ -828,7 +800,6 @@ public static Density FromNanogramsPerDeciLiter(double nanogramsperdeciliter) double value = (double) nanogramsperdeciliter; return new Density(value, DensityUnit.NanogramPerDeciliter); } - /// /// Creates a from . /// @@ -839,7 +810,6 @@ public static Density FromNanogramsPerLiter(double nanogramsperliter) double value = (double) nanogramsperliter; return new Density(value, DensityUnit.NanogramPerLiter); } - /// /// Creates a from . /// @@ -850,7 +820,6 @@ public static Density FromNanogramsPerMilliliter(double nanogramspermilliliter) double value = (double) nanogramspermilliliter; return new Density(value, DensityUnit.NanogramPerMilliliter); } - /// /// Creates a from . /// @@ -861,7 +830,6 @@ public static Density FromPicogramsPerDeciLiter(double picogramsperdeciliter) double value = (double) picogramsperdeciliter; return new Density(value, DensityUnit.PicogramPerDeciliter); } - /// /// Creates a from . /// @@ -872,7 +840,6 @@ public static Density FromPicogramsPerLiter(double picogramsperliter) double value = (double) picogramsperliter; return new Density(value, DensityUnit.PicogramPerLiter); } - /// /// Creates a from . /// @@ -883,7 +850,6 @@ public static Density FromPicogramsPerMilliliter(double picogramspermilliliter) double value = (double) picogramspermilliliter; return new Density(value, DensityUnit.PicogramPerMilliliter); } - /// /// Creates a from . /// @@ -894,7 +860,6 @@ public static Density FromPoundsPerCubicCentimeter(double poundspercubiccentimet double value = (double) poundspercubiccentimeter; return new Density(value, DensityUnit.PoundPerCubicCentimeter); } - /// /// Creates a from . /// @@ -905,7 +870,6 @@ public static Density FromPoundsPerCubicFoot(double poundspercubicfoot) double value = (double) poundspercubicfoot; return new Density(value, DensityUnit.PoundPerCubicFoot); } - /// /// Creates a from . /// @@ -916,7 +880,6 @@ public static Density FromPoundsPerCubicInch(double poundspercubicinch) double value = (double) poundspercubicinch; return new Density(value, DensityUnit.PoundPerCubicInch); } - /// /// Creates a from . /// @@ -927,7 +890,6 @@ public static Density FromPoundsPerCubicMeter(double poundspercubicmeter) double value = (double) poundspercubicmeter; return new Density(value, DensityUnit.PoundPerCubicMeter); } - /// /// Creates a from . /// @@ -938,7 +900,6 @@ public static Density FromPoundsPerCubicMillimeter(double poundspercubicmillimet double value = (double) poundspercubicmillimeter; return new Density(value, DensityUnit.PoundPerCubicMillimeter); } - /// /// Creates a from . /// @@ -949,7 +910,6 @@ public static Density FromPoundsPerImperialGallon(double poundsperimperialgallon double value = (double) poundsperimperialgallon; return new Density(value, DensityUnit.PoundPerImperialGallon); } - /// /// Creates a from . /// @@ -960,7 +920,6 @@ public static Density FromPoundsPerUSGallon(double poundsperusgallon) double value = (double) poundsperusgallon; return new Density(value, DensityUnit.PoundPerUSGallon); } - /// /// Creates a from . /// @@ -971,7 +930,6 @@ public static Density FromSlugsPerCubicCentimeter(double slugspercubiccentimeter double value = (double) slugspercubiccentimeter; return new Density(value, DensityUnit.SlugPerCubicCentimeter); } - /// /// Creates a from . /// @@ -982,7 +940,6 @@ public static Density FromSlugsPerCubicFoot(double slugspercubicfoot) double value = (double) slugspercubicfoot; return new Density(value, DensityUnit.SlugPerCubicFoot); } - /// /// Creates a from . /// @@ -993,7 +950,6 @@ public static Density FromSlugsPerCubicInch(double slugspercubicinch) double value = (double) slugspercubicinch; return new Density(value, DensityUnit.SlugPerCubicInch); } - /// /// Creates a from . /// @@ -1004,7 +960,6 @@ public static Density FromSlugsPerCubicMeter(double slugspercubicmeter) double value = (double) slugspercubicmeter; return new Density(value, DensityUnit.SlugPerCubicMeter); } - /// /// Creates a from . /// @@ -1015,7 +970,6 @@ public static Density FromSlugsPerCubicMillimeter(double slugspercubicmillimeter double value = (double) slugspercubicmillimeter; return new Density(value, DensityUnit.SlugPerCubicMillimeter); } - /// /// Creates a from . /// @@ -1026,7 +980,6 @@ public static Density FromTonnesPerCubicCentimeter(double tonnespercubiccentimet double value = (double) tonnespercubiccentimeter; return new Density(value, DensityUnit.TonnePerCubicCentimeter); } - /// /// Creates a from . /// @@ -1037,7 +990,6 @@ public static Density FromTonnesPerCubicFoot(double tonnespercubicfoot) double value = (double) tonnespercubicfoot; return new Density(value, DensityUnit.TonnePerCubicFoot); } - /// /// Creates a from . /// @@ -1048,7 +1000,6 @@ public static Density FromTonnesPerCubicInch(double tonnespercubicinch) double value = (double) tonnespercubicinch; return new Density(value, DensityUnit.TonnePerCubicInch); } - /// /// Creates a from . /// @@ -1059,7 +1010,6 @@ public static Density FromTonnesPerCubicMeter(double tonnespercubicmeter) double value = (double) tonnespercubicmeter; return new Density(value, DensityUnit.TonnePerCubicMeter); } - /// /// Creates a from . /// @@ -1071,7 +1021,6 @@ public static Density FromTonnesPerCubicMillimeter(double tonnespercubicmillimet return new Density(value, DensityUnit.TonnePerCubicMillimeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Duration.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Duration.g.cs index 820f70d6d9..c23a7b1a38 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Duration.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Duration.g.cs @@ -283,7 +283,6 @@ public static Duration FromDays(double days) double value = (double) days; return new Duration(value, DurationUnit.Day); } - /// /// Creates a from . /// @@ -294,7 +293,6 @@ public static Duration FromHours(double hours) double value = (double) hours; return new Duration(value, DurationUnit.Hour); } - /// /// Creates a from . /// @@ -305,7 +303,6 @@ public static Duration FromJulianYears(double julianyears) double value = (double) julianyears; return new Duration(value, DurationUnit.JulianYear); } - /// /// Creates a from . /// @@ -316,7 +313,6 @@ public static Duration FromMicroseconds(double microseconds) double value = (double) microseconds; return new Duration(value, DurationUnit.Microsecond); } - /// /// Creates a from . /// @@ -327,7 +323,6 @@ public static Duration FromMilliseconds(double milliseconds) double value = (double) milliseconds; return new Duration(value, DurationUnit.Millisecond); } - /// /// Creates a from . /// @@ -338,7 +333,6 @@ public static Duration FromMinutes(double minutes) double value = (double) minutes; return new Duration(value, DurationUnit.Minute); } - /// /// Creates a from . /// @@ -349,7 +343,6 @@ public static Duration FromMonths30(double months30) double value = (double) months30; return new Duration(value, DurationUnit.Month30); } - /// /// Creates a from . /// @@ -360,7 +353,6 @@ public static Duration FromNanoseconds(double nanoseconds) double value = (double) nanoseconds; return new Duration(value, DurationUnit.Nanosecond); } - /// /// Creates a from . /// @@ -371,7 +363,6 @@ public static Duration FromSeconds(double seconds) double value = (double) seconds; return new Duration(value, DurationUnit.Second); } - /// /// Creates a from . /// @@ -382,7 +373,6 @@ public static Duration FromWeeks(double weeks) double value = (double) weeks; return new Duration(value, DurationUnit.Week); } - /// /// Creates a from . /// @@ -394,7 +384,6 @@ public static Duration FromYears365(double years365) return new Duration(value, DurationUnit.Year365); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/DynamicViscosity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/DynamicViscosity.g.cs index 1f5a7ecfe7..fb43601ea7 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/DynamicViscosity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/DynamicViscosity.g.cs @@ -270,7 +270,6 @@ public static DynamicViscosity FromCentipoise(double centipoise) double value = (double) centipoise; return new DynamicViscosity(value, DynamicViscosityUnit.Centipoise); } - /// /// Creates a from . /// @@ -281,7 +280,6 @@ public static DynamicViscosity FromMicropascalSeconds(double micropascalseconds) double value = (double) micropascalseconds; return new DynamicViscosity(value, DynamicViscosityUnit.MicropascalSecond); } - /// /// Creates a from . /// @@ -292,7 +290,6 @@ public static DynamicViscosity FromMillipascalSeconds(double millipascalseconds) double value = (double) millipascalseconds; return new DynamicViscosity(value, DynamicViscosityUnit.MillipascalSecond); } - /// /// Creates a from . /// @@ -303,7 +300,6 @@ public static DynamicViscosity FromNewtonSecondsPerMeterSquared(double newtonsec double value = (double) newtonsecondspermetersquared; return new DynamicViscosity(value, DynamicViscosityUnit.NewtonSecondPerMeterSquared); } - /// /// Creates a from . /// @@ -314,7 +310,6 @@ public static DynamicViscosity FromPascalSeconds(double pascalseconds) double value = (double) pascalseconds; return new DynamicViscosity(value, DynamicViscosityUnit.PascalSecond); } - /// /// Creates a from . /// @@ -325,7 +320,6 @@ public static DynamicViscosity FromPoise(double poise) double value = (double) poise; return new DynamicViscosity(value, DynamicViscosityUnit.Poise); } - /// /// Creates a from . /// @@ -336,7 +330,6 @@ public static DynamicViscosity FromPoundsForceSecondPerSquareFoot(double poundsf double value = (double) poundsforcesecondpersquarefoot; return new DynamicViscosity(value, DynamicViscosityUnit.PoundForceSecondPerSquareFoot); } - /// /// Creates a from . /// @@ -347,7 +340,6 @@ public static DynamicViscosity FromPoundsForceSecondPerSquareInch(double poundsf double value = (double) poundsforcesecondpersquareinch; return new DynamicViscosity(value, DynamicViscosityUnit.PoundForceSecondPerSquareInch); } - /// /// Creates a from . /// @@ -358,7 +350,6 @@ public static DynamicViscosity FromPoundsPerFootSecond(double poundsperfootsecon double value = (double) poundsperfootsecond; return new DynamicViscosity(value, DynamicViscosityUnit.PoundPerFootSecond); } - /// /// Creates a from . /// @@ -370,7 +361,6 @@ public static DynamicViscosity FromReyns(double reyns) return new DynamicViscosity(value, DynamicViscosityUnit.Reyn); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricAdmittance.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricAdmittance.g.cs index edbf25ae11..68a8f88624 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricAdmittance.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricAdmittance.g.cs @@ -231,7 +231,6 @@ public static ElectricAdmittance FromMicrosiemens(double microsiemens) double value = (double) microsiemens; return new ElectricAdmittance(value, ElectricAdmittanceUnit.Microsiemens); } - /// /// Creates a from . /// @@ -242,7 +241,6 @@ public static ElectricAdmittance FromMillisiemens(double millisiemens) double value = (double) millisiemens; return new ElectricAdmittance(value, ElectricAdmittanceUnit.Millisiemens); } - /// /// Creates a from . /// @@ -253,7 +251,6 @@ public static ElectricAdmittance FromNanosiemens(double nanosiemens) double value = (double) nanosiemens; return new ElectricAdmittance(value, ElectricAdmittanceUnit.Nanosiemens); } - /// /// Creates a from . /// @@ -265,7 +262,6 @@ public static ElectricAdmittance FromSiemens(double siemens) return new ElectricAdmittance(value, ElectricAdmittanceUnit.Siemens); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCharge.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCharge.g.cs index 742e8f23a4..fc9f82ea58 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCharge.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCharge.g.cs @@ -240,7 +240,6 @@ public static ElectricCharge FromAmpereHours(double amperehours) double value = (double) amperehours; return new ElectricCharge(value, ElectricChargeUnit.AmpereHour); } - /// /// Creates a from . /// @@ -251,7 +250,6 @@ public static ElectricCharge FromCoulombs(double coulombs) double value = (double) coulombs; return new ElectricCharge(value, ElectricChargeUnit.Coulomb); } - /// /// Creates a from . /// @@ -262,7 +260,6 @@ public static ElectricCharge FromKiloampereHours(double kiloamperehours) double value = (double) kiloamperehours; return new ElectricCharge(value, ElectricChargeUnit.KiloampereHour); } - /// /// Creates a from . /// @@ -273,7 +270,6 @@ public static ElectricCharge FromMegaampereHours(double megaamperehours) double value = (double) megaamperehours; return new ElectricCharge(value, ElectricChargeUnit.MegaampereHour); } - /// /// Creates a from . /// @@ -285,7 +281,6 @@ public static ElectricCharge FromMilliampereHours(double milliamperehours) return new ElectricCharge(value, ElectricChargeUnit.MilliampereHour); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricChargeDensity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricChargeDensity.g.cs index 04b9293e53..8b4670fdd3 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricChargeDensity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricChargeDensity.g.cs @@ -217,7 +217,6 @@ public static ElectricChargeDensity FromCoulombsPerCubicMeter(double coulombsper return new ElectricChargeDensity(value, ElectricChargeDensityUnit.CoulombPerCubicMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductance.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductance.g.cs index 4695073a1f..3183a2dfbc 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductance.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductance.g.cs @@ -228,7 +228,6 @@ public static ElectricConductance FromMicrosiemens(double microsiemens) double value = (double) microsiemens; return new ElectricConductance(value, ElectricConductanceUnit.Microsiemens); } - /// /// Creates a from . /// @@ -239,7 +238,6 @@ public static ElectricConductance FromMillisiemens(double millisiemens) double value = (double) millisiemens; return new ElectricConductance(value, ElectricConductanceUnit.Millisiemens); } - /// /// Creates a from . /// @@ -251,7 +249,6 @@ public static ElectricConductance FromSiemens(double siemens) return new ElectricConductance(value, ElectricConductanceUnit.Siemens); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductivity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductivity.g.cs index 9fbe04a9eb..1acc1f154f 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductivity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductivity.g.cs @@ -228,7 +228,6 @@ public static ElectricConductivity FromSiemensPerFoot(double siemensperfoot) double value = (double) siemensperfoot; return new ElectricConductivity(value, ElectricConductivityUnit.SiemensPerFoot); } - /// /// Creates a from . /// @@ -239,7 +238,6 @@ public static ElectricConductivity FromSiemensPerInch(double siemensperinch) double value = (double) siemensperinch; return new ElectricConductivity(value, ElectricConductivityUnit.SiemensPerInch); } - /// /// Creates a from . /// @@ -251,7 +249,6 @@ public static ElectricConductivity FromSiemensPerMeter(double siemenspermeter) return new ElectricConductivity(value, ElectricConductivityUnit.SiemensPerMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrent.g.cs index 03a6add850..8e45e39943 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrent.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrent.g.cs @@ -255,7 +255,6 @@ public static ElectricCurrent FromAmperes(double amperes) double value = (double) amperes; return new ElectricCurrent(value, ElectricCurrentUnit.Ampere); } - /// /// Creates a from . /// @@ -266,7 +265,6 @@ public static ElectricCurrent FromCentiamperes(double centiamperes) double value = (double) centiamperes; return new ElectricCurrent(value, ElectricCurrentUnit.Centiampere); } - /// /// Creates a from . /// @@ -277,7 +275,6 @@ public static ElectricCurrent FromKiloamperes(double kiloamperes) double value = (double) kiloamperes; return new ElectricCurrent(value, ElectricCurrentUnit.Kiloampere); } - /// /// Creates a from . /// @@ -288,7 +285,6 @@ public static ElectricCurrent FromMegaamperes(double megaamperes) double value = (double) megaamperes; return new ElectricCurrent(value, ElectricCurrentUnit.Megaampere); } - /// /// Creates a from . /// @@ -299,7 +295,6 @@ public static ElectricCurrent FromMicroamperes(double microamperes) double value = (double) microamperes; return new ElectricCurrent(value, ElectricCurrentUnit.Microampere); } - /// /// Creates a from . /// @@ -310,7 +305,6 @@ public static ElectricCurrent FromMilliamperes(double milliamperes) double value = (double) milliamperes; return new ElectricCurrent(value, ElectricCurrentUnit.Milliampere); } - /// /// Creates a from . /// @@ -321,7 +315,6 @@ public static ElectricCurrent FromNanoamperes(double nanoamperes) double value = (double) nanoamperes; return new ElectricCurrent(value, ElectricCurrentUnit.Nanoampere); } - /// /// Creates a from . /// @@ -333,7 +326,6 @@ public static ElectricCurrent FromPicoamperes(double picoamperes) return new ElectricCurrent(value, ElectricCurrentUnit.Picoampere); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs index 27273642a4..45cbe10f5c 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs @@ -228,7 +228,6 @@ public static ElectricCurrentDensity FromAmperesPerSquareFoot(double amperespers double value = (double) amperespersquarefoot; return new ElectricCurrentDensity(value, ElectricCurrentDensityUnit.AmperePerSquareFoot); } - /// /// Creates a from . /// @@ -239,7 +238,6 @@ public static ElectricCurrentDensity FromAmperesPerSquareInch(double amperespers double value = (double) amperespersquareinch; return new ElectricCurrentDensity(value, ElectricCurrentDensityUnit.AmperePerSquareInch); } - /// /// Creates a from . /// @@ -251,7 +249,6 @@ public static ElectricCurrentDensity FromAmperesPerSquareMeter(double amperesper return new ElectricCurrentDensity(value, ElectricCurrentDensityUnit.AmperePerSquareMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs index c23dff3488..b3994c9871 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs @@ -231,7 +231,6 @@ public static ElectricCurrentGradient FromAmperesPerMicrosecond(double amperespe double value = (double) amperespermicrosecond; return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerMicrosecond); } - /// /// Creates a from . /// @@ -242,7 +241,6 @@ public static ElectricCurrentGradient FromAmperesPerMillisecond(double amperespe double value = (double) amperespermillisecond; return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerMillisecond); } - /// /// Creates a from . /// @@ -253,7 +251,6 @@ public static ElectricCurrentGradient FromAmperesPerNanosecond(double amperesper double value = (double) amperespernanosecond; return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerNanosecond); } - /// /// Creates a from . /// @@ -265,7 +262,6 @@ public static ElectricCurrentGradient FromAmperesPerSecond(double amperesperseco return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerSecond); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricField.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricField.g.cs index 80bd9a3bb9..dea86a3a4d 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricField.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricField.g.cs @@ -217,7 +217,6 @@ public static ElectricField FromVoltsPerMeter(double voltspermeter) return new ElectricField(value, ElectricFieldUnit.VoltPerMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricInductance.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricInductance.g.cs index 268cc0598c..17e9ab80ba 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricInductance.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricInductance.g.cs @@ -234,7 +234,6 @@ public static ElectricInductance FromHenries(double henries) double value = (double) henries; return new ElectricInductance(value, ElectricInductanceUnit.Henry); } - /// /// Creates a from . /// @@ -245,7 +244,6 @@ public static ElectricInductance FromMicrohenries(double microhenries) double value = (double) microhenries; return new ElectricInductance(value, ElectricInductanceUnit.Microhenry); } - /// /// Creates a from . /// @@ -256,7 +254,6 @@ public static ElectricInductance FromMillihenries(double millihenries) double value = (double) millihenries; return new ElectricInductance(value, ElectricInductanceUnit.Millihenry); } - /// /// Creates a from . /// @@ -268,7 +265,6 @@ public static ElectricInductance FromNanohenries(double nanohenries) return new ElectricInductance(value, ElectricInductanceUnit.Nanohenry); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotential.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotential.g.cs index 41104879ef..d861a6dd04 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotential.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotential.g.cs @@ -242,7 +242,6 @@ public static ElectricPotential FromKilovolts(double kilovolts) double value = (double) kilovolts; return new ElectricPotential(value, ElectricPotentialUnit.Kilovolt); } - /// /// Creates a from . /// @@ -253,7 +252,6 @@ public static ElectricPotential FromMegavolts(double megavolts) double value = (double) megavolts; return new ElectricPotential(value, ElectricPotentialUnit.Megavolt); } - /// /// Creates a from . /// @@ -264,7 +262,6 @@ public static ElectricPotential FromMicrovolts(double microvolts) double value = (double) microvolts; return new ElectricPotential(value, ElectricPotentialUnit.Microvolt); } - /// /// Creates a from . /// @@ -275,7 +272,6 @@ public static ElectricPotential FromMillivolts(double millivolts) double value = (double) millivolts; return new ElectricPotential(value, ElectricPotentialUnit.Millivolt); } - /// /// Creates a from . /// @@ -287,7 +283,6 @@ public static ElectricPotential FromVolts(double volts) return new ElectricPotential(value, ElectricPotentialUnit.Volt); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialAc.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialAc.g.cs index 4c110e1ccf..e27bb22c6d 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialAc.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialAc.g.cs @@ -237,7 +237,6 @@ public static ElectricPotentialAc FromKilovoltsAc(double kilovoltsac) double value = (double) kilovoltsac; return new ElectricPotentialAc(value, ElectricPotentialAcUnit.KilovoltAc); } - /// /// Creates a from . /// @@ -248,7 +247,6 @@ public static ElectricPotentialAc FromMegavoltsAc(double megavoltsac) double value = (double) megavoltsac; return new ElectricPotentialAc(value, ElectricPotentialAcUnit.MegavoltAc); } - /// /// Creates a from . /// @@ -259,7 +257,6 @@ public static ElectricPotentialAc FromMicrovoltsAc(double microvoltsac) double value = (double) microvoltsac; return new ElectricPotentialAc(value, ElectricPotentialAcUnit.MicrovoltAc); } - /// /// Creates a from . /// @@ -270,7 +267,6 @@ public static ElectricPotentialAc FromMillivoltsAc(double millivoltsac) double value = (double) millivoltsac; return new ElectricPotentialAc(value, ElectricPotentialAcUnit.MillivoltAc); } - /// /// Creates a from . /// @@ -282,7 +278,6 @@ public static ElectricPotentialAc FromVoltsAc(double voltsac) return new ElectricPotentialAc(value, ElectricPotentialAcUnit.VoltAc); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs index 0af5c5e8c2..8007d38ce2 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs @@ -327,7 +327,6 @@ public static ElectricPotentialChangeRate FromKilovoltsPerHours(double kilovolts double value = (double) kilovoltsperhours; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerHour); } - /// /// Creates a from . /// @@ -338,7 +337,6 @@ public static ElectricPotentialChangeRate FromKilovoltsPerMicroseconds(double ki double value = (double) kilovoltspermicroseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond); } - /// /// Creates a from . /// @@ -349,7 +347,6 @@ public static ElectricPotentialChangeRate FromKilovoltsPerMinutes(double kilovol double value = (double) kilovoltsperminutes; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerMinute); } - /// /// Creates a from . /// @@ -360,7 +357,6 @@ public static ElectricPotentialChangeRate FromKilovoltsPerSeconds(double kilovol double value = (double) kilovoltsperseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerSecond); } - /// /// Creates a from . /// @@ -371,7 +367,6 @@ public static ElectricPotentialChangeRate FromMegavoltsPerHours(double megavolts double value = (double) megavoltsperhours; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerHour); } - /// /// Creates a from . /// @@ -382,7 +377,6 @@ public static ElectricPotentialChangeRate FromMegavoltsPerMicroseconds(double me double value = (double) megavoltspermicroseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond); } - /// /// Creates a from . /// @@ -393,7 +387,6 @@ public static ElectricPotentialChangeRate FromMegavoltsPerMinutes(double megavol double value = (double) megavoltsperminutes; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerMinute); } - /// /// Creates a from . /// @@ -404,7 +397,6 @@ public static ElectricPotentialChangeRate FromMegavoltsPerSeconds(double megavol double value = (double) megavoltsperseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerSecond); } - /// /// Creates a from . /// @@ -415,7 +407,6 @@ public static ElectricPotentialChangeRate FromMicrovoltsPerHours(double microvol double value = (double) microvoltsperhours; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerHour); } - /// /// Creates a from . /// @@ -426,7 +417,6 @@ public static ElectricPotentialChangeRate FromMicrovoltsPerMicroseconds(double m double value = (double) microvoltspermicroseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond); } - /// /// Creates a from . /// @@ -437,7 +427,6 @@ public static ElectricPotentialChangeRate FromMicrovoltsPerMinutes(double microv double value = (double) microvoltsperminutes; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerMinute); } - /// /// Creates a from . /// @@ -448,7 +437,6 @@ public static ElectricPotentialChangeRate FromMicrovoltsPerSeconds(double microv double value = (double) microvoltsperseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerSecond); } - /// /// Creates a from . /// @@ -459,7 +447,6 @@ public static ElectricPotentialChangeRate FromMillivoltsPerHours(double millivol double value = (double) millivoltsperhours; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerHour); } - /// /// Creates a from . /// @@ -470,7 +457,6 @@ public static ElectricPotentialChangeRate FromMillivoltsPerMicroseconds(double m double value = (double) millivoltspermicroseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond); } - /// /// Creates a from . /// @@ -481,7 +467,6 @@ public static ElectricPotentialChangeRate FromMillivoltsPerMinutes(double milliv double value = (double) millivoltsperminutes; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerMinute); } - /// /// Creates a from . /// @@ -492,7 +477,6 @@ public static ElectricPotentialChangeRate FromMillivoltsPerSeconds(double milliv double value = (double) millivoltsperseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerSecond); } - /// /// Creates a from . /// @@ -503,7 +487,6 @@ public static ElectricPotentialChangeRate FromVoltsPerHours(double voltsperhours double value = (double) voltsperhours; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerHour); } - /// /// Creates a from . /// @@ -514,7 +497,6 @@ public static ElectricPotentialChangeRate FromVoltsPerMicroseconds(double voltsp double value = (double) voltspermicroseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerMicrosecond); } - /// /// Creates a from . /// @@ -525,7 +507,6 @@ public static ElectricPotentialChangeRate FromVoltsPerMinutes(double voltspermin double value = (double) voltsperminutes; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerMinute); } - /// /// Creates a from . /// @@ -537,7 +518,6 @@ public static ElectricPotentialChangeRate FromVoltsPerSeconds(double voltspersec return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerSecond); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialDc.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialDc.g.cs index f49a0f461f..573a2f3746 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialDc.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialDc.g.cs @@ -237,7 +237,6 @@ public static ElectricPotentialDc FromKilovoltsDc(double kilovoltsdc) double value = (double) kilovoltsdc; return new ElectricPotentialDc(value, ElectricPotentialDcUnit.KilovoltDc); } - /// /// Creates a from . /// @@ -248,7 +247,6 @@ public static ElectricPotentialDc FromMegavoltsDc(double megavoltsdc) double value = (double) megavoltsdc; return new ElectricPotentialDc(value, ElectricPotentialDcUnit.MegavoltDc); } - /// /// Creates a from . /// @@ -259,7 +257,6 @@ public static ElectricPotentialDc FromMicrovoltsDc(double microvoltsdc) double value = (double) microvoltsdc; return new ElectricPotentialDc(value, ElectricPotentialDcUnit.MicrovoltDc); } - /// /// Creates a from . /// @@ -270,7 +267,6 @@ public static ElectricPotentialDc FromMillivoltsDc(double millivoltsdc) double value = (double) millivoltsdc; return new ElectricPotentialDc(value, ElectricPotentialDcUnit.MillivoltDc); } - /// /// Creates a from . /// @@ -282,7 +278,6 @@ public static ElectricPotentialDc FromVoltsDc(double voltsdc) return new ElectricPotentialDc(value, ElectricPotentialDcUnit.VoltDc); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistance.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistance.g.cs index c34ced318f..1d1c5da49e 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistance.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistance.g.cs @@ -243,7 +243,6 @@ public static ElectricResistance FromGigaohms(double gigaohms) double value = (double) gigaohms; return new ElectricResistance(value, ElectricResistanceUnit.Gigaohm); } - /// /// Creates a from . /// @@ -254,7 +253,6 @@ public static ElectricResistance FromKiloohms(double kiloohms) double value = (double) kiloohms; return new ElectricResistance(value, ElectricResistanceUnit.Kiloohm); } - /// /// Creates a from . /// @@ -265,7 +263,6 @@ public static ElectricResistance FromMegaohms(double megaohms) double value = (double) megaohms; return new ElectricResistance(value, ElectricResistanceUnit.Megaohm); } - /// /// Creates a from . /// @@ -276,7 +273,6 @@ public static ElectricResistance FromMicroohms(double microohms) double value = (double) microohms; return new ElectricResistance(value, ElectricResistanceUnit.Microohm); } - /// /// Creates a from . /// @@ -287,7 +283,6 @@ public static ElectricResistance FromMilliohms(double milliohms) double value = (double) milliohms; return new ElectricResistance(value, ElectricResistanceUnit.Milliohm); } - /// /// Creates a from . /// @@ -299,7 +294,6 @@ public static ElectricResistance FromOhms(double ohms) return new ElectricResistance(value, ElectricResistanceUnit.Ohm); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistivity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistivity.g.cs index 2c37dae554..6d5a219cd2 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistivity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistivity.g.cs @@ -294,7 +294,6 @@ public static ElectricResistivity FromKiloohmsCentimeter(double kiloohmscentimet double value = (double) kiloohmscentimeter; return new ElectricResistivity(value, ElectricResistivityUnit.KiloohmCentimeter); } - /// /// Creates a from . /// @@ -305,7 +304,6 @@ public static ElectricResistivity FromKiloohmMeters(double kiloohmmeters) double value = (double) kiloohmmeters; return new ElectricResistivity(value, ElectricResistivityUnit.KiloohmMeter); } - /// /// Creates a from . /// @@ -316,7 +314,6 @@ public static ElectricResistivity FromMegaohmsCentimeter(double megaohmscentimet double value = (double) megaohmscentimeter; return new ElectricResistivity(value, ElectricResistivityUnit.MegaohmCentimeter); } - /// /// Creates a from . /// @@ -327,7 +324,6 @@ public static ElectricResistivity FromMegaohmMeters(double megaohmmeters) double value = (double) megaohmmeters; return new ElectricResistivity(value, ElectricResistivityUnit.MegaohmMeter); } - /// /// Creates a from . /// @@ -338,7 +334,6 @@ public static ElectricResistivity FromMicroohmsCentimeter(double microohmscentim double value = (double) microohmscentimeter; return new ElectricResistivity(value, ElectricResistivityUnit.MicroohmCentimeter); } - /// /// Creates a from . /// @@ -349,7 +344,6 @@ public static ElectricResistivity FromMicroohmMeters(double microohmmeters) double value = (double) microohmmeters; return new ElectricResistivity(value, ElectricResistivityUnit.MicroohmMeter); } - /// /// Creates a from . /// @@ -360,7 +354,6 @@ public static ElectricResistivity FromMilliohmsCentimeter(double milliohmscentim double value = (double) milliohmscentimeter; return new ElectricResistivity(value, ElectricResistivityUnit.MilliohmCentimeter); } - /// /// Creates a from . /// @@ -371,7 +364,6 @@ public static ElectricResistivity FromMilliohmMeters(double milliohmmeters) double value = (double) milliohmmeters; return new ElectricResistivity(value, ElectricResistivityUnit.MilliohmMeter); } - /// /// Creates a from . /// @@ -382,7 +374,6 @@ public static ElectricResistivity FromNanoohmsCentimeter(double nanoohmscentimet double value = (double) nanoohmscentimeter; return new ElectricResistivity(value, ElectricResistivityUnit.NanoohmCentimeter); } - /// /// Creates a from . /// @@ -393,7 +384,6 @@ public static ElectricResistivity FromNanoohmMeters(double nanoohmmeters) double value = (double) nanoohmmeters; return new ElectricResistivity(value, ElectricResistivityUnit.NanoohmMeter); } - /// /// Creates a from . /// @@ -404,7 +394,6 @@ public static ElectricResistivity FromOhmsCentimeter(double ohmscentimeter) double value = (double) ohmscentimeter; return new ElectricResistivity(value, ElectricResistivityUnit.OhmCentimeter); } - /// /// Creates a from . /// @@ -415,7 +404,6 @@ public static ElectricResistivity FromOhmMeters(double ohmmeters) double value = (double) ohmmeters; return new ElectricResistivity(value, ElectricResistivityUnit.OhmMeter); } - /// /// Creates a from . /// @@ -426,7 +414,6 @@ public static ElectricResistivity FromPicoohmsCentimeter(double picoohmscentimet double value = (double) picoohmscentimeter; return new ElectricResistivity(value, ElectricResistivityUnit.PicoohmCentimeter); } - /// /// Creates a from . /// @@ -438,7 +425,6 @@ public static ElectricResistivity FromPicoohmMeters(double picoohmmeters) return new ElectricResistivity(value, ElectricResistivityUnit.PicoohmMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs index b029011347..11ce87b751 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs @@ -228,7 +228,6 @@ public static ElectricSurfaceChargeDensity FromCoulombsPerSquareCentimeter(doubl double value = (double) coulombspersquarecentimeter; return new ElectricSurfaceChargeDensity(value, ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter); } - /// /// Creates a from . /// @@ -239,7 +238,6 @@ public static ElectricSurfaceChargeDensity FromCoulombsPerSquareInch(double coul double value = (double) coulombspersquareinch; return new ElectricSurfaceChargeDensity(value, ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch); } - /// /// Creates a from . /// @@ -251,7 +249,6 @@ public static ElectricSurfaceChargeDensity FromCoulombsPerSquareMeter(double cou return new ElectricSurfaceChargeDensity(value, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Energy.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Energy.g.cs index 9d3878d86b..9d0541830e 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Energy.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Energy.g.cs @@ -444,7 +444,6 @@ public static Energy FromBritishThermalUnits(double britishthermalunits) double value = (double) britishthermalunits; return new Energy(value, EnergyUnit.BritishThermalUnit); } - /// /// Creates a from . /// @@ -455,7 +454,6 @@ public static Energy FromCalories(double calories) double value = (double) calories; return new Energy(value, EnergyUnit.Calorie); } - /// /// Creates a from . /// @@ -466,7 +464,6 @@ public static Energy FromDecathermsEc(double decathermsec) double value = (double) decathermsec; return new Energy(value, EnergyUnit.DecathermEc); } - /// /// Creates a from . /// @@ -477,7 +474,6 @@ public static Energy FromDecathermsImperial(double decathermsimperial) double value = (double) decathermsimperial; return new Energy(value, EnergyUnit.DecathermImperial); } - /// /// Creates a from . /// @@ -488,7 +484,6 @@ public static Energy FromDecathermsUs(double decathermsus) double value = (double) decathermsus; return new Energy(value, EnergyUnit.DecathermUs); } - /// /// Creates a from . /// @@ -499,7 +494,6 @@ public static Energy FromElectronVolts(double electronvolts) double value = (double) electronvolts; return new Energy(value, EnergyUnit.ElectronVolt); } - /// /// Creates a from . /// @@ -510,7 +504,6 @@ public static Energy FromErgs(double ergs) double value = (double) ergs; return new Energy(value, EnergyUnit.Erg); } - /// /// Creates a from . /// @@ -521,7 +514,6 @@ public static Energy FromFootPounds(double footpounds) double value = (double) footpounds; return new Energy(value, EnergyUnit.FootPound); } - /// /// Creates a from . /// @@ -532,7 +524,6 @@ public static Energy FromGigabritishThermalUnits(double gigabritishthermalunits) double value = (double) gigabritishthermalunits; return new Energy(value, EnergyUnit.GigabritishThermalUnit); } - /// /// Creates a from . /// @@ -543,7 +534,6 @@ public static Energy FromGigaelectronVolts(double gigaelectronvolts) double value = (double) gigaelectronvolts; return new Energy(value, EnergyUnit.GigaelectronVolt); } - /// /// Creates a from . /// @@ -554,7 +544,6 @@ public static Energy FromGigajoules(double gigajoules) double value = (double) gigajoules; return new Energy(value, EnergyUnit.Gigajoule); } - /// /// Creates a from . /// @@ -565,7 +554,6 @@ public static Energy FromGigawattDays(double gigawattdays) double value = (double) gigawattdays; return new Energy(value, EnergyUnit.GigawattDay); } - /// /// Creates a from . /// @@ -576,7 +564,6 @@ public static Energy FromGigawattHours(double gigawatthours) double value = (double) gigawatthours; return new Energy(value, EnergyUnit.GigawattHour); } - /// /// Creates a from . /// @@ -587,7 +574,6 @@ public static Energy FromHorsepowerHours(double horsepowerhours) double value = (double) horsepowerhours; return new Energy(value, EnergyUnit.HorsepowerHour); } - /// /// Creates a from . /// @@ -598,7 +584,6 @@ public static Energy FromJoules(double joules) double value = (double) joules; return new Energy(value, EnergyUnit.Joule); } - /// /// Creates a from . /// @@ -609,7 +594,6 @@ public static Energy FromKilobritishThermalUnits(double kilobritishthermalunits) double value = (double) kilobritishthermalunits; return new Energy(value, EnergyUnit.KilobritishThermalUnit); } - /// /// Creates a from . /// @@ -620,7 +604,6 @@ public static Energy FromKilocalories(double kilocalories) double value = (double) kilocalories; return new Energy(value, EnergyUnit.Kilocalorie); } - /// /// Creates a from . /// @@ -631,7 +614,6 @@ public static Energy FromKiloelectronVolts(double kiloelectronvolts) double value = (double) kiloelectronvolts; return new Energy(value, EnergyUnit.KiloelectronVolt); } - /// /// Creates a from . /// @@ -642,7 +624,6 @@ public static Energy FromKilojoules(double kilojoules) double value = (double) kilojoules; return new Energy(value, EnergyUnit.Kilojoule); } - /// /// Creates a from . /// @@ -653,7 +634,6 @@ public static Energy FromKilowattDays(double kilowattdays) double value = (double) kilowattdays; return new Energy(value, EnergyUnit.KilowattDay); } - /// /// Creates a from . /// @@ -664,7 +644,6 @@ public static Energy FromKilowattHours(double kilowatthours) double value = (double) kilowatthours; return new Energy(value, EnergyUnit.KilowattHour); } - /// /// Creates a from . /// @@ -675,7 +654,6 @@ public static Energy FromMegabritishThermalUnits(double megabritishthermalunits) double value = (double) megabritishthermalunits; return new Energy(value, EnergyUnit.MegabritishThermalUnit); } - /// /// Creates a from . /// @@ -686,7 +664,6 @@ public static Energy FromMegacalories(double megacalories) double value = (double) megacalories; return new Energy(value, EnergyUnit.Megacalorie); } - /// /// Creates a from . /// @@ -697,7 +674,6 @@ public static Energy FromMegaelectronVolts(double megaelectronvolts) double value = (double) megaelectronvolts; return new Energy(value, EnergyUnit.MegaelectronVolt); } - /// /// Creates a from . /// @@ -708,7 +684,6 @@ public static Energy FromMegajoules(double megajoules) double value = (double) megajoules; return new Energy(value, EnergyUnit.Megajoule); } - /// /// Creates a from . /// @@ -719,7 +694,6 @@ public static Energy FromMegawattDays(double megawattdays) double value = (double) megawattdays; return new Energy(value, EnergyUnit.MegawattDay); } - /// /// Creates a from . /// @@ -730,7 +704,6 @@ public static Energy FromMegawattHours(double megawatthours) double value = (double) megawatthours; return new Energy(value, EnergyUnit.MegawattHour); } - /// /// Creates a from . /// @@ -741,7 +714,6 @@ public static Energy FromMillijoules(double millijoules) double value = (double) millijoules; return new Energy(value, EnergyUnit.Millijoule); } - /// /// Creates a from . /// @@ -752,7 +724,6 @@ public static Energy FromTeraelectronVolts(double teraelectronvolts) double value = (double) teraelectronvolts; return new Energy(value, EnergyUnit.TeraelectronVolt); } - /// /// Creates a from . /// @@ -763,7 +734,6 @@ public static Energy FromTerawattDays(double terawattdays) double value = (double) terawattdays; return new Energy(value, EnergyUnit.TerawattDay); } - /// /// Creates a from . /// @@ -774,7 +744,6 @@ public static Energy FromTerawattHours(double terawatthours) double value = (double) terawatthours; return new Energy(value, EnergyUnit.TerawattHour); } - /// /// Creates a from . /// @@ -785,7 +754,6 @@ public static Energy FromThermsEc(double thermsec) double value = (double) thermsec; return new Energy(value, EnergyUnit.ThermEc); } - /// /// Creates a from . /// @@ -796,7 +764,6 @@ public static Energy FromThermsImperial(double thermsimperial) double value = (double) thermsimperial; return new Energy(value, EnergyUnit.ThermImperial); } - /// /// Creates a from . /// @@ -807,7 +774,6 @@ public static Energy FromThermsUs(double thermsus) double value = (double) thermsus; return new Energy(value, EnergyUnit.ThermUs); } - /// /// Creates a from . /// @@ -818,7 +784,6 @@ public static Energy FromWattDays(double wattdays) double value = (double) wattdays; return new Energy(value, EnergyUnit.WattDay); } - /// /// Creates a from . /// @@ -830,7 +795,6 @@ public static Energy FromWattHours(double watthours) return new Energy(value, EnergyUnit.WattHour); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Entropy.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Entropy.g.cs index 5c7ac840c9..f8adc5ab09 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Entropy.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Entropy.g.cs @@ -249,7 +249,6 @@ public static Entropy FromCaloriesPerKelvin(double caloriesperkelvin) double value = (double) caloriesperkelvin; return new Entropy(value, EntropyUnit.CaloriePerKelvin); } - /// /// Creates a from . /// @@ -260,7 +259,6 @@ public static Entropy FromJoulesPerDegreeCelsius(double joulesperdegreecelsius) double value = (double) joulesperdegreecelsius; return new Entropy(value, EntropyUnit.JoulePerDegreeCelsius); } - /// /// Creates a from . /// @@ -271,7 +269,6 @@ public static Entropy FromJoulesPerKelvin(double joulesperkelvin) double value = (double) joulesperkelvin; return new Entropy(value, EntropyUnit.JoulePerKelvin); } - /// /// Creates a from . /// @@ -282,7 +279,6 @@ public static Entropy FromKilocaloriesPerKelvin(double kilocaloriesperkelvin) double value = (double) kilocaloriesperkelvin; return new Entropy(value, EntropyUnit.KilocaloriePerKelvin); } - /// /// Creates a from . /// @@ -293,7 +289,6 @@ public static Entropy FromKilojoulesPerDegreeCelsius(double kilojoulesperdegreec double value = (double) kilojoulesperdegreecelsius; return new Entropy(value, EntropyUnit.KilojoulePerDegreeCelsius); } - /// /// Creates a from . /// @@ -304,7 +299,6 @@ public static Entropy FromKilojoulesPerKelvin(double kilojoulesperkelvin) double value = (double) kilojoulesperkelvin; return new Entropy(value, EntropyUnit.KilojoulePerKelvin); } - /// /// Creates a from . /// @@ -316,7 +310,6 @@ public static Entropy FromMegajoulesPerKelvin(double megajoulesperkelvin) return new Entropy(value, EntropyUnit.MegajoulePerKelvin); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.g.cs index 13f5ded53c..5d6c2c5dc3 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.g.cs @@ -310,7 +310,6 @@ public static Force FromDecanewtons(double decanewtons) double value = (double) decanewtons; return new Force(value, ForceUnit.Decanewton); } - /// /// Creates a from . /// @@ -321,7 +320,6 @@ public static Force FromDyne(double dyne) double value = (double) dyne; return new Force(value, ForceUnit.Dyn); } - /// /// Creates a from . /// @@ -332,7 +330,6 @@ public static Force FromKilogramsForce(double kilogramsforce) double value = (double) kilogramsforce; return new Force(value, ForceUnit.KilogramForce); } - /// /// Creates a from . /// @@ -343,7 +340,6 @@ public static Force FromKilonewtons(double kilonewtons) double value = (double) kilonewtons; return new Force(value, ForceUnit.Kilonewton); } - /// /// Creates a from . /// @@ -354,7 +350,6 @@ public static Force FromKiloPonds(double kiloponds) double value = (double) kiloponds; return new Force(value, ForceUnit.KiloPond); } - /// /// Creates a from . /// @@ -365,7 +360,6 @@ public static Force FromKilopoundsForce(double kilopoundsforce) double value = (double) kilopoundsforce; return new Force(value, ForceUnit.KilopoundForce); } - /// /// Creates a from . /// @@ -376,7 +370,6 @@ public static Force FromMeganewtons(double meganewtons) double value = (double) meganewtons; return new Force(value, ForceUnit.Meganewton); } - /// /// Creates a from . /// @@ -387,7 +380,6 @@ public static Force FromMicronewtons(double micronewtons) double value = (double) micronewtons; return new Force(value, ForceUnit.Micronewton); } - /// /// Creates a from . /// @@ -398,7 +390,6 @@ public static Force FromMillinewtons(double millinewtons) double value = (double) millinewtons; return new Force(value, ForceUnit.Millinewton); } - /// /// Creates a from . /// @@ -409,7 +400,6 @@ public static Force FromNewtons(double newtons) double value = (double) newtons; return new Force(value, ForceUnit.Newton); } - /// /// Creates a from . /// @@ -420,7 +410,6 @@ public static Force FromOunceForce(double ounceforce) double value = (double) ounceforce; return new Force(value, ForceUnit.OunceForce); } - /// /// Creates a from . /// @@ -431,7 +420,6 @@ public static Force FromPoundals(double poundals) double value = (double) poundals; return new Force(value, ForceUnit.Poundal); } - /// /// Creates a from . /// @@ -442,7 +430,6 @@ public static Force FromPoundsForce(double poundsforce) double value = (double) poundsforce; return new Force(value, ForceUnit.PoundForce); } - /// /// Creates a from . /// @@ -453,7 +440,6 @@ public static Force FromShortTonsForce(double shorttonsforce) double value = (double) shorttonsforce; return new Force(value, ForceUnit.ShortTonForce); } - /// /// Creates a from . /// @@ -465,7 +451,6 @@ public static Force FromTonnesForce(double tonnesforce) return new Force(value, ForceUnit.TonneForce); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForceChangeRate.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForceChangeRate.g.cs index 3f5ed0cfb5..4b4c45fe48 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForceChangeRate.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForceChangeRate.g.cs @@ -297,7 +297,6 @@ public static ForceChangeRate FromCentinewtonsPerSecond(double centinewtonsperse double value = (double) centinewtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.CentinewtonPerSecond); } - /// /// Creates a from . /// @@ -308,7 +307,6 @@ public static ForceChangeRate FromDecanewtonsPerMinute(double decanewtonsperminu double value = (double) decanewtonsperminute; return new ForceChangeRate(value, ForceChangeRateUnit.DecanewtonPerMinute); } - /// /// Creates a from . /// @@ -319,7 +317,6 @@ public static ForceChangeRate FromDecanewtonsPerSecond(double decanewtonsperseco double value = (double) decanewtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.DecanewtonPerSecond); } - /// /// Creates a from . /// @@ -330,7 +327,6 @@ public static ForceChangeRate FromDecinewtonsPerSecond(double decinewtonsperseco double value = (double) decinewtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.DecinewtonPerSecond); } - /// /// Creates a from . /// @@ -341,7 +337,6 @@ public static ForceChangeRate FromKilonewtonsPerMinute(double kilonewtonsperminu double value = (double) kilonewtonsperminute; return new ForceChangeRate(value, ForceChangeRateUnit.KilonewtonPerMinute); } - /// /// Creates a from . /// @@ -352,7 +347,6 @@ public static ForceChangeRate FromKilonewtonsPerSecond(double kilonewtonsperseco double value = (double) kilonewtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.KilonewtonPerSecond); } - /// /// Creates a from . /// @@ -363,7 +357,6 @@ public static ForceChangeRate FromKilopoundsForcePerMinute(double kilopoundsforc double value = (double) kilopoundsforceperminute; return new ForceChangeRate(value, ForceChangeRateUnit.KilopoundForcePerMinute); } - /// /// Creates a from . /// @@ -374,7 +367,6 @@ public static ForceChangeRate FromKilopoundsForcePerSecond(double kilopoundsforc double value = (double) kilopoundsforcepersecond; return new ForceChangeRate(value, ForceChangeRateUnit.KilopoundForcePerSecond); } - /// /// Creates a from . /// @@ -385,7 +377,6 @@ public static ForceChangeRate FromMicronewtonsPerSecond(double micronewtonsperse double value = (double) micronewtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.MicronewtonPerSecond); } - /// /// Creates a from . /// @@ -396,7 +387,6 @@ public static ForceChangeRate FromMillinewtonsPerSecond(double millinewtonsperse double value = (double) millinewtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.MillinewtonPerSecond); } - /// /// Creates a from . /// @@ -407,7 +397,6 @@ public static ForceChangeRate FromNanonewtonsPerSecond(double nanonewtonsperseco double value = (double) nanonewtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.NanonewtonPerSecond); } - /// /// Creates a from . /// @@ -418,7 +407,6 @@ public static ForceChangeRate FromNewtonsPerMinute(double newtonsperminute) double value = (double) newtonsperminute; return new ForceChangeRate(value, ForceChangeRateUnit.NewtonPerMinute); } - /// /// Creates a from . /// @@ -429,7 +417,6 @@ public static ForceChangeRate FromNewtonsPerSecond(double newtonspersecond) double value = (double) newtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.NewtonPerSecond); } - /// /// Creates a from . /// @@ -440,7 +427,6 @@ public static ForceChangeRate FromPoundsForcePerMinute(double poundsforceperminu double value = (double) poundsforceperminute; return new ForceChangeRate(value, ForceChangeRateUnit.PoundForcePerMinute); } - /// /// Creates a from . /// @@ -452,7 +438,6 @@ public static ForceChangeRate FromPoundsForcePerSecond(double poundsforceperseco return new ForceChangeRate(value, ForceChangeRateUnit.PoundForcePerSecond); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForcePerLength.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForcePerLength.g.cs index 591d553c5c..a97dd9edfd 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForcePerLength.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForcePerLength.g.cs @@ -441,7 +441,6 @@ public static ForcePerLength FromCentinewtonsPerCentimeter(double centinewtonspe double value = (double) centinewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.CentinewtonPerCentimeter); } - /// /// Creates a from . /// @@ -452,7 +451,6 @@ public static ForcePerLength FromCentinewtonsPerMeter(double centinewtonspermete double value = (double) centinewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.CentinewtonPerMeter); } - /// /// Creates a from . /// @@ -463,7 +461,6 @@ public static ForcePerLength FromCentinewtonsPerMillimeter(double centinewtonspe double value = (double) centinewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.CentinewtonPerMillimeter); } - /// /// Creates a from . /// @@ -474,7 +471,6 @@ public static ForcePerLength FromDecanewtonsPerCentimeter(double decanewtonsperc double value = (double) decanewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.DecanewtonPerCentimeter); } - /// /// Creates a from . /// @@ -485,7 +481,6 @@ public static ForcePerLength FromDecanewtonsPerMeter(double decanewtonspermeter) double value = (double) decanewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.DecanewtonPerMeter); } - /// /// Creates a from . /// @@ -496,7 +491,6 @@ public static ForcePerLength FromDecanewtonsPerMillimeter(double decanewtonsperm double value = (double) decanewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.DecanewtonPerMillimeter); } - /// /// Creates a from . /// @@ -507,7 +501,6 @@ public static ForcePerLength FromDecinewtonsPerCentimeter(double decinewtonsperc double value = (double) decinewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.DecinewtonPerCentimeter); } - /// /// Creates a from . /// @@ -518,7 +511,6 @@ public static ForcePerLength FromDecinewtonsPerMeter(double decinewtonspermeter) double value = (double) decinewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.DecinewtonPerMeter); } - /// /// Creates a from . /// @@ -529,7 +521,6 @@ public static ForcePerLength FromDecinewtonsPerMillimeter(double decinewtonsperm double value = (double) decinewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.DecinewtonPerMillimeter); } - /// /// Creates a from . /// @@ -540,7 +531,6 @@ public static ForcePerLength FromKilogramsForcePerCentimeter(double kilogramsfor double value = (double) kilogramsforcepercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.KilogramForcePerCentimeter); } - /// /// Creates a from . /// @@ -551,7 +541,6 @@ public static ForcePerLength FromKilogramsForcePerMeter(double kilogramsforceper double value = (double) kilogramsforcepermeter; return new ForcePerLength(value, ForcePerLengthUnit.KilogramForcePerMeter); } - /// /// Creates a from . /// @@ -562,7 +551,6 @@ public static ForcePerLength FromKilogramsForcePerMillimeter(double kilogramsfor double value = (double) kilogramsforcepermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.KilogramForcePerMillimeter); } - /// /// Creates a from . /// @@ -573,7 +561,6 @@ public static ForcePerLength FromKilonewtonsPerCentimeter(double kilonewtonsperc double value = (double) kilonewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.KilonewtonPerCentimeter); } - /// /// Creates a from . /// @@ -584,7 +571,6 @@ public static ForcePerLength FromKilonewtonsPerMeter(double kilonewtonspermeter) double value = (double) kilonewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.KilonewtonPerMeter); } - /// /// Creates a from . /// @@ -595,7 +581,6 @@ public static ForcePerLength FromKilonewtonsPerMillimeter(double kilonewtonsperm double value = (double) kilonewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.KilonewtonPerMillimeter); } - /// /// Creates a from . /// @@ -606,7 +591,6 @@ public static ForcePerLength FromKilopoundsForcePerFoot(double kilopoundsforcepe double value = (double) kilopoundsforceperfoot; return new ForcePerLength(value, ForcePerLengthUnit.KilopoundForcePerFoot); } - /// /// Creates a from . /// @@ -617,7 +601,6 @@ public static ForcePerLength FromKilopoundsForcePerInch(double kilopoundsforcepe double value = (double) kilopoundsforceperinch; return new ForcePerLength(value, ForcePerLengthUnit.KilopoundForcePerInch); } - /// /// Creates a from . /// @@ -628,7 +611,6 @@ public static ForcePerLength FromMeganewtonsPerCentimeter(double meganewtonsperc double value = (double) meganewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.MeganewtonPerCentimeter); } - /// /// Creates a from . /// @@ -639,7 +621,6 @@ public static ForcePerLength FromMeganewtonsPerMeter(double meganewtonspermeter) double value = (double) meganewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.MeganewtonPerMeter); } - /// /// Creates a from . /// @@ -650,7 +631,6 @@ public static ForcePerLength FromMeganewtonsPerMillimeter(double meganewtonsperm double value = (double) meganewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.MeganewtonPerMillimeter); } - /// /// Creates a from . /// @@ -661,7 +641,6 @@ public static ForcePerLength FromMicronewtonsPerCentimeter(double micronewtonspe double value = (double) micronewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.MicronewtonPerCentimeter); } - /// /// Creates a from . /// @@ -672,7 +651,6 @@ public static ForcePerLength FromMicronewtonsPerMeter(double micronewtonspermete double value = (double) micronewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.MicronewtonPerMeter); } - /// /// Creates a from . /// @@ -683,7 +661,6 @@ public static ForcePerLength FromMicronewtonsPerMillimeter(double micronewtonspe double value = (double) micronewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.MicronewtonPerMillimeter); } - /// /// Creates a from . /// @@ -694,7 +671,6 @@ public static ForcePerLength FromMillinewtonsPerCentimeter(double millinewtonspe double value = (double) millinewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.MillinewtonPerCentimeter); } - /// /// Creates a from . /// @@ -705,7 +681,6 @@ public static ForcePerLength FromMillinewtonsPerMeter(double millinewtonspermete double value = (double) millinewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.MillinewtonPerMeter); } - /// /// Creates a from . /// @@ -716,7 +691,6 @@ public static ForcePerLength FromMillinewtonsPerMillimeter(double millinewtonspe double value = (double) millinewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.MillinewtonPerMillimeter); } - /// /// Creates a from . /// @@ -727,7 +701,6 @@ public static ForcePerLength FromNanonewtonsPerCentimeter(double nanonewtonsperc double value = (double) nanonewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.NanonewtonPerCentimeter); } - /// /// Creates a from . /// @@ -738,7 +711,6 @@ public static ForcePerLength FromNanonewtonsPerMeter(double nanonewtonspermeter) double value = (double) nanonewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.NanonewtonPerMeter); } - /// /// Creates a from . /// @@ -749,7 +721,6 @@ public static ForcePerLength FromNanonewtonsPerMillimeter(double nanonewtonsperm double value = (double) nanonewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.NanonewtonPerMillimeter); } - /// /// Creates a from . /// @@ -760,7 +731,6 @@ public static ForcePerLength FromNewtonsPerCentimeter(double newtonspercentimete double value = (double) newtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.NewtonPerCentimeter); } - /// /// Creates a from . /// @@ -771,7 +741,6 @@ public static ForcePerLength FromNewtonsPerMeter(double newtonspermeter) double value = (double) newtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.NewtonPerMeter); } - /// /// Creates a from . /// @@ -782,7 +751,6 @@ public static ForcePerLength FromNewtonsPerMillimeter(double newtonspermillimete double value = (double) newtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.NewtonPerMillimeter); } - /// /// Creates a from . /// @@ -793,7 +761,6 @@ public static ForcePerLength FromPoundsForcePerFoot(double poundsforceperfoot) double value = (double) poundsforceperfoot; return new ForcePerLength(value, ForcePerLengthUnit.PoundForcePerFoot); } - /// /// Creates a from . /// @@ -804,7 +771,6 @@ public static ForcePerLength FromPoundsForcePerInch(double poundsforceperinch) double value = (double) poundsforceperinch; return new ForcePerLength(value, ForcePerLengthUnit.PoundForcePerInch); } - /// /// Creates a from . /// @@ -815,7 +781,6 @@ public static ForcePerLength FromPoundsForcePerYard(double poundsforceperyard) double value = (double) poundsforceperyard; return new ForcePerLength(value, ForcePerLengthUnit.PoundForcePerYard); } - /// /// Creates a from . /// @@ -826,7 +791,6 @@ public static ForcePerLength FromTonnesForcePerCentimeter(double tonnesforceperc double value = (double) tonnesforcepercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.TonneForcePerCentimeter); } - /// /// Creates a from . /// @@ -837,7 +801,6 @@ public static ForcePerLength FromTonnesForcePerMeter(double tonnesforcepermeter) double value = (double) tonnesforcepermeter; return new ForcePerLength(value, ForcePerLengthUnit.TonneForcePerMeter); } - /// /// Creates a from . /// @@ -849,7 +812,6 @@ public static ForcePerLength FromTonnesForcePerMillimeter(double tonnesforceperm return new ForcePerLength(value, ForcePerLengthUnit.TonneForcePerMillimeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Frequency.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Frequency.g.cs index 53ec583e85..31906df301 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Frequency.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Frequency.g.cs @@ -280,7 +280,6 @@ public static Frequency FromBeatsPerMinute(double beatsperminute) double value = (double) beatsperminute; return new Frequency(value, FrequencyUnit.BeatPerMinute); } - /// /// Creates a from . /// @@ -291,7 +290,6 @@ public static Frequency FromBUnits(double bunits) double value = (double) bunits; return new Frequency(value, FrequencyUnit.BUnit); } - /// /// Creates a from . /// @@ -302,7 +300,6 @@ public static Frequency FromCyclesPerHour(double cyclesperhour) double value = (double) cyclesperhour; return new Frequency(value, FrequencyUnit.CyclePerHour); } - /// /// Creates a from . /// @@ -313,7 +310,6 @@ public static Frequency FromCyclesPerMinute(double cyclesperminute) double value = (double) cyclesperminute; return new Frequency(value, FrequencyUnit.CyclePerMinute); } - /// /// Creates a from . /// @@ -324,7 +320,6 @@ public static Frequency FromGigahertz(double gigahertz) double value = (double) gigahertz; return new Frequency(value, FrequencyUnit.Gigahertz); } - /// /// Creates a from . /// @@ -335,7 +330,6 @@ public static Frequency FromHertz(double hertz) double value = (double) hertz; return new Frequency(value, FrequencyUnit.Hertz); } - /// /// Creates a from . /// @@ -346,7 +340,6 @@ public static Frequency FromKilohertz(double kilohertz) double value = (double) kilohertz; return new Frequency(value, FrequencyUnit.Kilohertz); } - /// /// Creates a from . /// @@ -357,7 +350,6 @@ public static Frequency FromMegahertz(double megahertz) double value = (double) megahertz; return new Frequency(value, FrequencyUnit.Megahertz); } - /// /// Creates a from . /// @@ -368,7 +360,6 @@ public static Frequency FromPerSecond(double persecond) double value = (double) persecond; return new Frequency(value, FrequencyUnit.PerSecond); } - /// /// Creates a from . /// @@ -379,7 +370,6 @@ public static Frequency FromRadiansPerSecond(double radianspersecond) double value = (double) radianspersecond; return new Frequency(value, FrequencyUnit.RadianPerSecond); } - /// /// Creates a from . /// @@ -391,7 +381,6 @@ public static Frequency FromTerahertz(double terahertz) return new Frequency(value, FrequencyUnit.Terahertz); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/FuelEfficiency.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/FuelEfficiency.g.cs index 7537293951..64992c86a5 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/FuelEfficiency.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/FuelEfficiency.g.cs @@ -234,7 +234,6 @@ public static FuelEfficiency FromKilometersPerLiters(double kilometersperliters) double value = (double) kilometersperliters; return new FuelEfficiency(value, FuelEfficiencyUnit.KilometerPerLiter); } - /// /// Creates a from . /// @@ -245,7 +244,6 @@ public static FuelEfficiency FromLitersPer100Kilometers(double litersper100kilom double value = (double) litersper100kilometers; return new FuelEfficiency(value, FuelEfficiencyUnit.LiterPer100Kilometers); } - /// /// Creates a from . /// @@ -256,7 +254,6 @@ public static FuelEfficiency FromMilesPerUkGallon(double milesperukgallon) double value = (double) milesperukgallon; return new FuelEfficiency(value, FuelEfficiencyUnit.MilePerUkGallon); } - /// /// Creates a from . /// @@ -268,7 +265,6 @@ public static FuelEfficiency FromMilesPerUsGallon(double milesperusgallon) return new FuelEfficiency(value, FuelEfficiencyUnit.MilePerUsGallon); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatFlux.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatFlux.g.cs index eb1b9a8a30..f1948d723e 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatFlux.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatFlux.g.cs @@ -315,7 +315,6 @@ public static HeatFlux FromBtusPerHourSquareFoot(double btusperhoursquarefoot) double value = (double) btusperhoursquarefoot; return new HeatFlux(value, HeatFluxUnit.BtuPerHourSquareFoot); } - /// /// Creates a from . /// @@ -326,7 +325,6 @@ public static HeatFlux FromBtusPerMinuteSquareFoot(double btusperminutesquarefoo double value = (double) btusperminutesquarefoot; return new HeatFlux(value, HeatFluxUnit.BtuPerMinuteSquareFoot); } - /// /// Creates a from . /// @@ -337,7 +335,6 @@ public static HeatFlux FromBtusPerSecondSquareFoot(double btuspersecondsquarefoo double value = (double) btuspersecondsquarefoot; return new HeatFlux(value, HeatFluxUnit.BtuPerSecondSquareFoot); } - /// /// Creates a from . /// @@ -348,7 +345,6 @@ public static HeatFlux FromBtusPerSecondSquareInch(double btuspersecondsquareinc double value = (double) btuspersecondsquareinch; return new HeatFlux(value, HeatFluxUnit.BtuPerSecondSquareInch); } - /// /// Creates a from . /// @@ -359,7 +355,6 @@ public static HeatFlux FromCaloriesPerSecondSquareCentimeter(double caloriespers double value = (double) caloriespersecondsquarecentimeter; return new HeatFlux(value, HeatFluxUnit.CaloriePerSecondSquareCentimeter); } - /// /// Creates a from . /// @@ -370,7 +365,6 @@ public static HeatFlux FromCentiwattsPerSquareMeter(double centiwattspersquareme double value = (double) centiwattspersquaremeter; return new HeatFlux(value, HeatFluxUnit.CentiwattPerSquareMeter); } - /// /// Creates a from . /// @@ -381,7 +375,6 @@ public static HeatFlux FromDeciwattsPerSquareMeter(double deciwattspersquaremete double value = (double) deciwattspersquaremeter; return new HeatFlux(value, HeatFluxUnit.DeciwattPerSquareMeter); } - /// /// Creates a from . /// @@ -392,7 +385,6 @@ public static HeatFlux FromKilocaloriesPerHourSquareMeter(double kilocaloriesper double value = (double) kilocaloriesperhoursquaremeter; return new HeatFlux(value, HeatFluxUnit.KilocaloriePerHourSquareMeter); } - /// /// Creates a from . /// @@ -403,7 +395,6 @@ public static HeatFlux FromKilocaloriesPerSecondSquareCentimeter(double kilocalo double value = (double) kilocaloriespersecondsquarecentimeter; return new HeatFlux(value, HeatFluxUnit.KilocaloriePerSecondSquareCentimeter); } - /// /// Creates a from . /// @@ -414,7 +405,6 @@ public static HeatFlux FromKilowattsPerSquareMeter(double kilowattspersquaremete double value = (double) kilowattspersquaremeter; return new HeatFlux(value, HeatFluxUnit.KilowattPerSquareMeter); } - /// /// Creates a from . /// @@ -425,7 +415,6 @@ public static HeatFlux FromMicrowattsPerSquareMeter(double microwattspersquareme double value = (double) microwattspersquaremeter; return new HeatFlux(value, HeatFluxUnit.MicrowattPerSquareMeter); } - /// /// Creates a from . /// @@ -436,7 +425,6 @@ public static HeatFlux FromMilliwattsPerSquareMeter(double milliwattspersquareme double value = (double) milliwattspersquaremeter; return new HeatFlux(value, HeatFluxUnit.MilliwattPerSquareMeter); } - /// /// Creates a from . /// @@ -447,7 +435,6 @@ public static HeatFlux FromNanowattsPerSquareMeter(double nanowattspersquaremete double value = (double) nanowattspersquaremeter; return new HeatFlux(value, HeatFluxUnit.NanowattPerSquareMeter); } - /// /// Creates a from . /// @@ -458,7 +445,6 @@ public static HeatFlux FromPoundsForcePerFootSecond(double poundsforceperfootsec double value = (double) poundsforceperfootsecond; return new HeatFlux(value, HeatFluxUnit.PoundForcePerFootSecond); } - /// /// Creates a from . /// @@ -469,7 +455,6 @@ public static HeatFlux FromPoundsPerSecondCubed(double poundspersecondcubed) double value = (double) poundspersecondcubed; return new HeatFlux(value, HeatFluxUnit.PoundPerSecondCubed); } - /// /// Creates a from . /// @@ -480,7 +465,6 @@ public static HeatFlux FromWattsPerSquareFoot(double wattspersquarefoot) double value = (double) wattspersquarefoot; return new HeatFlux(value, HeatFluxUnit.WattPerSquareFoot); } - /// /// Creates a from . /// @@ -491,7 +475,6 @@ public static HeatFlux FromWattsPerSquareInch(double wattspersquareinch) double value = (double) wattspersquareinch; return new HeatFlux(value, HeatFluxUnit.WattPerSquareInch); } - /// /// Creates a from . /// @@ -503,7 +486,6 @@ public static HeatFlux FromWattsPerSquareMeter(double wattspersquaremeter) return new HeatFlux(value, HeatFluxUnit.WattPerSquareMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs index 2e68312bff..b4c9a69677 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs @@ -225,7 +225,6 @@ public static HeatTransferCoefficient FromBtusPerSquareFootDegreeFahrenheit(doub double value = (double) btuspersquarefootdegreefahrenheit; return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit); } - /// /// Creates a from . /// @@ -236,7 +235,6 @@ public static HeatTransferCoefficient FromWattsPerSquareMeterCelsius(double watt double value = (double) wattspersquaremetercelsius; return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.WattPerSquareMeterCelsius); } - /// /// Creates a from . /// @@ -248,7 +246,6 @@ public static HeatTransferCoefficient FromWattsPerSquareMeterKelvin(double watts return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Illuminance.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Illuminance.g.cs index 23a74a1a99..3b6a03b2ba 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Illuminance.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Illuminance.g.cs @@ -234,7 +234,6 @@ public static Illuminance FromKilolux(double kilolux) double value = (double) kilolux; return new Illuminance(value, IlluminanceUnit.Kilolux); } - /// /// Creates a from . /// @@ -245,7 +244,6 @@ public static Illuminance FromLux(double lux) double value = (double) lux; return new Illuminance(value, IlluminanceUnit.Lux); } - /// /// Creates a from . /// @@ -256,7 +254,6 @@ public static Illuminance FromMegalux(double megalux) double value = (double) megalux; return new Illuminance(value, IlluminanceUnit.Megalux); } - /// /// Creates a from . /// @@ -268,7 +265,6 @@ public static Illuminance FromMillilux(double millilux) return new Illuminance(value, IlluminanceUnit.Millilux); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Information.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Information.g.cs index 60f903ba5b..0929028d6b 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Information.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Information.g.cs @@ -363,7 +363,6 @@ public static Information FromBits(double bits) decimal value = (decimal) bits; return new Information(value, InformationUnit.Bit); } - /// /// Creates a from . /// @@ -374,7 +373,6 @@ public static Information FromBytes(double bytes) decimal value = (decimal) bytes; return new Information(value, InformationUnit.Byte); } - /// /// Creates a from . /// @@ -385,7 +383,6 @@ public static Information FromExabits(double exabits) decimal value = (decimal) exabits; return new Information(value, InformationUnit.Exabit); } - /// /// Creates a from . /// @@ -396,7 +393,6 @@ public static Information FromExabytes(double exabytes) decimal value = (decimal) exabytes; return new Information(value, InformationUnit.Exabyte); } - /// /// Creates a from . /// @@ -407,7 +403,6 @@ public static Information FromExbibits(double exbibits) decimal value = (decimal) exbibits; return new Information(value, InformationUnit.Exbibit); } - /// /// Creates a from . /// @@ -418,7 +413,6 @@ public static Information FromExbibytes(double exbibytes) decimal value = (decimal) exbibytes; return new Information(value, InformationUnit.Exbibyte); } - /// /// Creates a from . /// @@ -429,7 +423,6 @@ public static Information FromGibibits(double gibibits) decimal value = (decimal) gibibits; return new Information(value, InformationUnit.Gibibit); } - /// /// Creates a from . /// @@ -440,7 +433,6 @@ public static Information FromGibibytes(double gibibytes) decimal value = (decimal) gibibytes; return new Information(value, InformationUnit.Gibibyte); } - /// /// Creates a from . /// @@ -451,7 +443,6 @@ public static Information FromGigabits(double gigabits) decimal value = (decimal) gigabits; return new Information(value, InformationUnit.Gigabit); } - /// /// Creates a from . /// @@ -462,7 +453,6 @@ public static Information FromGigabytes(double gigabytes) decimal value = (decimal) gigabytes; return new Information(value, InformationUnit.Gigabyte); } - /// /// Creates a from . /// @@ -473,7 +463,6 @@ public static Information FromKibibits(double kibibits) decimal value = (decimal) kibibits; return new Information(value, InformationUnit.Kibibit); } - /// /// Creates a from . /// @@ -484,7 +473,6 @@ public static Information FromKibibytes(double kibibytes) decimal value = (decimal) kibibytes; return new Information(value, InformationUnit.Kibibyte); } - /// /// Creates a from . /// @@ -495,7 +483,6 @@ public static Information FromKilobits(double kilobits) decimal value = (decimal) kilobits; return new Information(value, InformationUnit.Kilobit); } - /// /// Creates a from . /// @@ -506,7 +493,6 @@ public static Information FromKilobytes(double kilobytes) decimal value = (decimal) kilobytes; return new Information(value, InformationUnit.Kilobyte); } - /// /// Creates a from . /// @@ -517,7 +503,6 @@ public static Information FromMebibits(double mebibits) decimal value = (decimal) mebibits; return new Information(value, InformationUnit.Mebibit); } - /// /// Creates a from . /// @@ -528,7 +513,6 @@ public static Information FromMebibytes(double mebibytes) decimal value = (decimal) mebibytes; return new Information(value, InformationUnit.Mebibyte); } - /// /// Creates a from . /// @@ -539,7 +523,6 @@ public static Information FromMegabits(double megabits) decimal value = (decimal) megabits; return new Information(value, InformationUnit.Megabit); } - /// /// Creates a from . /// @@ -550,7 +533,6 @@ public static Information FromMegabytes(double megabytes) decimal value = (decimal) megabytes; return new Information(value, InformationUnit.Megabyte); } - /// /// Creates a from . /// @@ -561,7 +543,6 @@ public static Information FromPebibits(double pebibits) decimal value = (decimal) pebibits; return new Information(value, InformationUnit.Pebibit); } - /// /// Creates a from . /// @@ -572,7 +553,6 @@ public static Information FromPebibytes(double pebibytes) decimal value = (decimal) pebibytes; return new Information(value, InformationUnit.Pebibyte); } - /// /// Creates a from . /// @@ -583,7 +563,6 @@ public static Information FromPetabits(double petabits) decimal value = (decimal) petabits; return new Information(value, InformationUnit.Petabit); } - /// /// Creates a from . /// @@ -594,7 +573,6 @@ public static Information FromPetabytes(double petabytes) decimal value = (decimal) petabytes; return new Information(value, InformationUnit.Petabyte); } - /// /// Creates a from . /// @@ -605,7 +583,6 @@ public static Information FromTebibits(double tebibits) decimal value = (decimal) tebibits; return new Information(value, InformationUnit.Tebibit); } - /// /// Creates a from . /// @@ -616,7 +593,6 @@ public static Information FromTebibytes(double tebibytes) decimal value = (decimal) tebibytes; return new Information(value, InformationUnit.Tebibyte); } - /// /// Creates a from . /// @@ -627,7 +603,6 @@ public static Information FromTerabits(double terabits) decimal value = (decimal) terabits; return new Information(value, InformationUnit.Terabit); } - /// /// Creates a from . /// @@ -639,7 +614,6 @@ public static Information FromTerabytes(double terabytes) return new Information(value, InformationUnit.Terabyte); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiance.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiance.g.cs index d91f16c81c..d2055e107e 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiance.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiance.g.cs @@ -291,7 +291,6 @@ public static Irradiance FromKilowattsPerSquareCentimeter(double kilowattspersqu double value = (double) kilowattspersquarecentimeter; return new Irradiance(value, IrradianceUnit.KilowattPerSquareCentimeter); } - /// /// Creates a from . /// @@ -302,7 +301,6 @@ public static Irradiance FromKilowattsPerSquareMeter(double kilowattspersquareme double value = (double) kilowattspersquaremeter; return new Irradiance(value, IrradianceUnit.KilowattPerSquareMeter); } - /// /// Creates a from . /// @@ -313,7 +311,6 @@ public static Irradiance FromMegawattsPerSquareCentimeter(double megawattspersqu double value = (double) megawattspersquarecentimeter; return new Irradiance(value, IrradianceUnit.MegawattPerSquareCentimeter); } - /// /// Creates a from . /// @@ -324,7 +321,6 @@ public static Irradiance FromMegawattsPerSquareMeter(double megawattspersquareme double value = (double) megawattspersquaremeter; return new Irradiance(value, IrradianceUnit.MegawattPerSquareMeter); } - /// /// Creates a from . /// @@ -335,7 +331,6 @@ public static Irradiance FromMicrowattsPerSquareCentimeter(double microwattspers double value = (double) microwattspersquarecentimeter; return new Irradiance(value, IrradianceUnit.MicrowattPerSquareCentimeter); } - /// /// Creates a from . /// @@ -346,7 +341,6 @@ public static Irradiance FromMicrowattsPerSquareMeter(double microwattspersquare double value = (double) microwattspersquaremeter; return new Irradiance(value, IrradianceUnit.MicrowattPerSquareMeter); } - /// /// Creates a from . /// @@ -357,7 +351,6 @@ public static Irradiance FromMilliwattsPerSquareCentimeter(double milliwattspers double value = (double) milliwattspersquarecentimeter; return new Irradiance(value, IrradianceUnit.MilliwattPerSquareCentimeter); } - /// /// Creates a from . /// @@ -368,7 +361,6 @@ public static Irradiance FromMilliwattsPerSquareMeter(double milliwattspersquare double value = (double) milliwattspersquaremeter; return new Irradiance(value, IrradianceUnit.MilliwattPerSquareMeter); } - /// /// Creates a from . /// @@ -379,7 +371,6 @@ public static Irradiance FromNanowattsPerSquareCentimeter(double nanowattspersqu double value = (double) nanowattspersquarecentimeter; return new Irradiance(value, IrradianceUnit.NanowattPerSquareCentimeter); } - /// /// Creates a from . /// @@ -390,7 +381,6 @@ public static Irradiance FromNanowattsPerSquareMeter(double nanowattspersquareme double value = (double) nanowattspersquaremeter; return new Irradiance(value, IrradianceUnit.NanowattPerSquareMeter); } - /// /// Creates a from . /// @@ -401,7 +391,6 @@ public static Irradiance FromPicowattsPerSquareCentimeter(double picowattspersqu double value = (double) picowattspersquarecentimeter; return new Irradiance(value, IrradianceUnit.PicowattPerSquareCentimeter); } - /// /// Creates a from . /// @@ -412,7 +401,6 @@ public static Irradiance FromPicowattsPerSquareMeter(double picowattspersquareme double value = (double) picowattspersquaremeter; return new Irradiance(value, IrradianceUnit.PicowattPerSquareMeter); } - /// /// Creates a from . /// @@ -423,7 +411,6 @@ public static Irradiance FromWattsPerSquareCentimeter(double wattspersquarecenti double value = (double) wattspersquarecentimeter; return new Irradiance(value, IrradianceUnit.WattPerSquareCentimeter); } - /// /// Creates a from . /// @@ -435,7 +422,6 @@ public static Irradiance FromWattsPerSquareMeter(double wattspersquaremeter) return new Irradiance(value, IrradianceUnit.WattPerSquareMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiation.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiation.g.cs index 6ec69e6fcd..b61ad8eac3 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiation.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiation.g.cs @@ -252,7 +252,6 @@ public static Irradiation FromJoulesPerSquareCentimeter(double joulespersquarece double value = (double) joulespersquarecentimeter; return new Irradiation(value, IrradiationUnit.JoulePerSquareCentimeter); } - /// /// Creates a from . /// @@ -263,7 +262,6 @@ public static Irradiation FromJoulesPerSquareMeter(double joulespersquaremeter) double value = (double) joulespersquaremeter; return new Irradiation(value, IrradiationUnit.JoulePerSquareMeter); } - /// /// Creates a from . /// @@ -274,7 +272,6 @@ public static Irradiation FromJoulesPerSquareMillimeter(double joulespersquaremi double value = (double) joulespersquaremillimeter; return new Irradiation(value, IrradiationUnit.JoulePerSquareMillimeter); } - /// /// Creates a from . /// @@ -285,7 +282,6 @@ public static Irradiation FromKilojoulesPerSquareMeter(double kilojoulespersquar double value = (double) kilojoulespersquaremeter; return new Irradiation(value, IrradiationUnit.KilojoulePerSquareMeter); } - /// /// Creates a from . /// @@ -296,7 +292,6 @@ public static Irradiation FromKilowattHoursPerSquareMeter(double kilowatthourspe double value = (double) kilowatthourspersquaremeter; return new Irradiation(value, IrradiationUnit.KilowattHourPerSquareMeter); } - /// /// Creates a from . /// @@ -307,7 +302,6 @@ public static Irradiation FromMillijoulesPerSquareCentimeter(double millijoulesp double value = (double) millijoulespersquarecentimeter; return new Irradiation(value, IrradiationUnit.MillijoulePerSquareCentimeter); } - /// /// Creates a from . /// @@ -319,7 +313,6 @@ public static Irradiation FromWattHoursPerSquareMeter(double watthourspersquarem return new Irradiation(value, IrradiationUnit.WattHourPerSquareMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/KinematicViscosity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/KinematicViscosity.g.cs index 2f5941b684..1dd129e5f4 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/KinematicViscosity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/KinematicViscosity.g.cs @@ -272,7 +272,6 @@ public static KinematicViscosity FromCentistokes(double centistokes) double value = (double) centistokes; return new KinematicViscosity(value, KinematicViscosityUnit.Centistokes); } - /// /// Creates a from . /// @@ -283,7 +282,6 @@ public static KinematicViscosity FromDecistokes(double decistokes) double value = (double) decistokes; return new KinematicViscosity(value, KinematicViscosityUnit.Decistokes); } - /// /// Creates a from . /// @@ -294,7 +292,6 @@ public static KinematicViscosity FromKilostokes(double kilostokes) double value = (double) kilostokes; return new KinematicViscosity(value, KinematicViscosityUnit.Kilostokes); } - /// /// Creates a from . /// @@ -305,7 +302,6 @@ public static KinematicViscosity FromMicrostokes(double microstokes) double value = (double) microstokes; return new KinematicViscosity(value, KinematicViscosityUnit.Microstokes); } - /// /// Creates a from . /// @@ -316,7 +312,6 @@ public static KinematicViscosity FromMillistokes(double millistokes) double value = (double) millistokes; return new KinematicViscosity(value, KinematicViscosityUnit.Millistokes); } - /// /// Creates a from . /// @@ -327,7 +322,6 @@ public static KinematicViscosity FromNanostokes(double nanostokes) double value = (double) nanostokes; return new KinematicViscosity(value, KinematicViscosityUnit.Nanostokes); } - /// /// Creates a from . /// @@ -338,7 +332,6 @@ public static KinematicViscosity FromSquareFeetPerSecond(double squarefeetpersec double value = (double) squarefeetpersecond; return new KinematicViscosity(value, KinematicViscosityUnit.SquareFootPerSecond); } - /// /// Creates a from . /// @@ -349,7 +342,6 @@ public static KinematicViscosity FromSquareMetersPerSecond(double squaremeterspe double value = (double) squaremeterspersecond; return new KinematicViscosity(value, KinematicViscosityUnit.SquareMeterPerSecond); } - /// /// Creates a from . /// @@ -361,7 +353,6 @@ public static KinematicViscosity FromStokes(double stokes) return new KinematicViscosity(value, KinematicViscosityUnit.Stokes); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LapseRate.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LapseRate.g.cs index af1af1d179..02bfedefc6 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LapseRate.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LapseRate.g.cs @@ -215,7 +215,6 @@ public static LapseRate FromDegreesCelciusPerKilometer(double degreescelciusperk return new LapseRate(value, LapseRateUnit.DegreeCelsiusPerKilometer); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Length.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Length.g.cs index 43760aafa5..3bf49d6d0a 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Length.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Length.g.cs @@ -449,7 +449,6 @@ public static Length FromAngstroms(double angstroms) double value = (double) angstroms; return new Length(value, LengthUnit.Angstrom); } - /// /// Creates a from . /// @@ -460,7 +459,6 @@ public static Length FromAstronomicalUnits(double astronomicalunits) double value = (double) astronomicalunits; return new Length(value, LengthUnit.AstronomicalUnit); } - /// /// Creates a from . /// @@ -471,7 +469,6 @@ public static Length FromCentimeters(double centimeters) double value = (double) centimeters; return new Length(value, LengthUnit.Centimeter); } - /// /// Creates a from . /// @@ -482,7 +479,6 @@ public static Length FromChains(double chains) double value = (double) chains; return new Length(value, LengthUnit.Chain); } - /// /// Creates a from . /// @@ -493,7 +489,6 @@ public static Length FromDecameters(double decameters) double value = (double) decameters; return new Length(value, LengthUnit.Decameter); } - /// /// Creates a from . /// @@ -504,7 +499,6 @@ public static Length FromDecimeters(double decimeters) double value = (double) decimeters; return new Length(value, LengthUnit.Decimeter); } - /// /// Creates a from . /// @@ -515,7 +509,6 @@ public static Length FromDtpPicas(double dtppicas) double value = (double) dtppicas; return new Length(value, LengthUnit.DtpPica); } - /// /// Creates a from . /// @@ -526,7 +519,6 @@ public static Length FromDtpPoints(double dtppoints) double value = (double) dtppoints; return new Length(value, LengthUnit.DtpPoint); } - /// /// Creates a from . /// @@ -537,7 +529,6 @@ public static Length FromFathoms(double fathoms) double value = (double) fathoms; return new Length(value, LengthUnit.Fathom); } - /// /// Creates a from . /// @@ -548,7 +539,6 @@ public static Length FromFeet(double feet) double value = (double) feet; return new Length(value, LengthUnit.Foot); } - /// /// Creates a from . /// @@ -559,7 +549,6 @@ public static Length FromHands(double hands) double value = (double) hands; return new Length(value, LengthUnit.Hand); } - /// /// Creates a from . /// @@ -570,7 +559,6 @@ public static Length FromHectometers(double hectometers) double value = (double) hectometers; return new Length(value, LengthUnit.Hectometer); } - /// /// Creates a from . /// @@ -581,7 +569,6 @@ public static Length FromInches(double inches) double value = (double) inches; return new Length(value, LengthUnit.Inch); } - /// /// Creates a from . /// @@ -592,7 +579,6 @@ public static Length FromKilolightYears(double kilolightyears) double value = (double) kilolightyears; return new Length(value, LengthUnit.KilolightYear); } - /// /// Creates a from . /// @@ -603,7 +589,6 @@ public static Length FromKilometers(double kilometers) double value = (double) kilometers; return new Length(value, LengthUnit.Kilometer); } - /// /// Creates a from . /// @@ -614,7 +599,6 @@ public static Length FromKiloparsecs(double kiloparsecs) double value = (double) kiloparsecs; return new Length(value, LengthUnit.Kiloparsec); } - /// /// Creates a from . /// @@ -625,7 +609,6 @@ public static Length FromLightYears(double lightyears) double value = (double) lightyears; return new Length(value, LengthUnit.LightYear); } - /// /// Creates a from . /// @@ -636,7 +619,6 @@ public static Length FromMegalightYears(double megalightyears) double value = (double) megalightyears; return new Length(value, LengthUnit.MegalightYear); } - /// /// Creates a from . /// @@ -647,7 +629,6 @@ public static Length FromMegaparsecs(double megaparsecs) double value = (double) megaparsecs; return new Length(value, LengthUnit.Megaparsec); } - /// /// Creates a from . /// @@ -658,7 +639,6 @@ public static Length FromMeters(double meters) double value = (double) meters; return new Length(value, LengthUnit.Meter); } - /// /// Creates a from . /// @@ -669,7 +649,6 @@ public static Length FromMicroinches(double microinches) double value = (double) microinches; return new Length(value, LengthUnit.Microinch); } - /// /// Creates a from . /// @@ -680,7 +659,6 @@ public static Length FromMicrometers(double micrometers) double value = (double) micrometers; return new Length(value, LengthUnit.Micrometer); } - /// /// Creates a from . /// @@ -691,7 +669,6 @@ public static Length FromMils(double mils) double value = (double) mils; return new Length(value, LengthUnit.Mil); } - /// /// Creates a from . /// @@ -702,7 +679,6 @@ public static Length FromMiles(double miles) double value = (double) miles; return new Length(value, LengthUnit.Mile); } - /// /// Creates a from . /// @@ -713,7 +689,6 @@ public static Length FromMillimeters(double millimeters) double value = (double) millimeters; return new Length(value, LengthUnit.Millimeter); } - /// /// Creates a from . /// @@ -724,7 +699,6 @@ public static Length FromNanometers(double nanometers) double value = (double) nanometers; return new Length(value, LengthUnit.Nanometer); } - /// /// Creates a from . /// @@ -735,7 +709,6 @@ public static Length FromNauticalMiles(double nauticalmiles) double value = (double) nauticalmiles; return new Length(value, LengthUnit.NauticalMile); } - /// /// Creates a from . /// @@ -746,7 +719,6 @@ public static Length FromParsecs(double parsecs) double value = (double) parsecs; return new Length(value, LengthUnit.Parsec); } - /// /// Creates a from . /// @@ -757,7 +729,6 @@ public static Length FromPrinterPicas(double printerpicas) double value = (double) printerpicas; return new Length(value, LengthUnit.PrinterPica); } - /// /// Creates a from . /// @@ -768,7 +739,6 @@ public static Length FromPrinterPoints(double printerpoints) double value = (double) printerpoints; return new Length(value, LengthUnit.PrinterPoint); } - /// /// Creates a from . /// @@ -779,7 +749,6 @@ public static Length FromShackles(double shackles) double value = (double) shackles; return new Length(value, LengthUnit.Shackle); } - /// /// Creates a from . /// @@ -790,7 +759,6 @@ public static Length FromSolarRadiuses(double solarradiuses) double value = (double) solarradiuses; return new Length(value, LengthUnit.SolarRadius); } - /// /// Creates a from . /// @@ -801,7 +769,6 @@ public static Length FromTwips(double twips) double value = (double) twips; return new Length(value, LengthUnit.Twip); } - /// /// Creates a from . /// @@ -812,7 +779,6 @@ public static Length FromUsSurveyFeet(double ussurveyfeet) double value = (double) ussurveyfeet; return new Length(value, LengthUnit.UsSurveyFoot); } - /// /// Creates a from . /// @@ -824,7 +790,6 @@ public static Length FromYards(double yards) return new Length(value, LengthUnit.Yard); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Level.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Level.g.cs index f40dba5692..23b4a6cd4c 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Level.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Level.g.cs @@ -219,7 +219,6 @@ public static Level FromDecibels(double decibels) double value = (double) decibels; return new Level(value, LevelUnit.Decibel); } - /// /// Creates a from . /// @@ -231,7 +230,6 @@ public static Level FromNepers(double nepers) return new Level(value, LevelUnit.Neper); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearDensity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearDensity.g.cs index 5131dc933a..45c3d2edf8 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearDensity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearDensity.g.cs @@ -294,7 +294,6 @@ public static LinearDensity FromGramsPerCentimeter(double gramspercentimeter) double value = (double) gramspercentimeter; return new LinearDensity(value, LinearDensityUnit.GramPerCentimeter); } - /// /// Creates a from . /// @@ -305,7 +304,6 @@ public static LinearDensity FromGramsPerMeter(double gramspermeter) double value = (double) gramspermeter; return new LinearDensity(value, LinearDensityUnit.GramPerMeter); } - /// /// Creates a from . /// @@ -316,7 +314,6 @@ public static LinearDensity FromGramsPerMillimeter(double gramspermillimeter) double value = (double) gramspermillimeter; return new LinearDensity(value, LinearDensityUnit.GramPerMillimeter); } - /// /// Creates a from . /// @@ -327,7 +324,6 @@ public static LinearDensity FromKilogramsPerCentimeter(double kilogramspercentim double value = (double) kilogramspercentimeter; return new LinearDensity(value, LinearDensityUnit.KilogramPerCentimeter); } - /// /// Creates a from . /// @@ -338,7 +334,6 @@ public static LinearDensity FromKilogramsPerMeter(double kilogramspermeter) double value = (double) kilogramspermeter; return new LinearDensity(value, LinearDensityUnit.KilogramPerMeter); } - /// /// Creates a from . /// @@ -349,7 +344,6 @@ public static LinearDensity FromKilogramsPerMillimeter(double kilogramspermillim double value = (double) kilogramspermillimeter; return new LinearDensity(value, LinearDensityUnit.KilogramPerMillimeter); } - /// /// Creates a from . /// @@ -360,7 +354,6 @@ public static LinearDensity FromMicrogramsPerCentimeter(double microgramspercent double value = (double) microgramspercentimeter; return new LinearDensity(value, LinearDensityUnit.MicrogramPerCentimeter); } - /// /// Creates a from . /// @@ -371,7 +364,6 @@ public static LinearDensity FromMicrogramsPerMeter(double microgramspermeter) double value = (double) microgramspermeter; return new LinearDensity(value, LinearDensityUnit.MicrogramPerMeter); } - /// /// Creates a from . /// @@ -382,7 +374,6 @@ public static LinearDensity FromMicrogramsPerMillimeter(double microgramspermill double value = (double) microgramspermillimeter; return new LinearDensity(value, LinearDensityUnit.MicrogramPerMillimeter); } - /// /// Creates a from . /// @@ -393,7 +384,6 @@ public static LinearDensity FromMilligramsPerCentimeter(double milligramspercent double value = (double) milligramspercentimeter; return new LinearDensity(value, LinearDensityUnit.MilligramPerCentimeter); } - /// /// Creates a from . /// @@ -404,7 +394,6 @@ public static LinearDensity FromMilligramsPerMeter(double milligramspermeter) double value = (double) milligramspermeter; return new LinearDensity(value, LinearDensityUnit.MilligramPerMeter); } - /// /// Creates a from . /// @@ -415,7 +404,6 @@ public static LinearDensity FromMilligramsPerMillimeter(double milligramspermill double value = (double) milligramspermillimeter; return new LinearDensity(value, LinearDensityUnit.MilligramPerMillimeter); } - /// /// Creates a from . /// @@ -426,7 +414,6 @@ public static LinearDensity FromPoundsPerFoot(double poundsperfoot) double value = (double) poundsperfoot; return new LinearDensity(value, LinearDensityUnit.PoundPerFoot); } - /// /// Creates a from . /// @@ -438,7 +425,6 @@ public static LinearDensity FromPoundsPerInch(double poundsperinch) return new LinearDensity(value, LinearDensityUnit.PoundPerInch); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearPowerDensity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearPowerDensity.g.cs index a8119fd122..4c4c7f49c8 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearPowerDensity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearPowerDensity.g.cs @@ -360,7 +360,6 @@ public static LinearPowerDensity FromGigawattsPerCentimeter(double gigawattsperc double value = (double) gigawattspercentimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerCentimeter); } - /// /// Creates a from . /// @@ -371,7 +370,6 @@ public static LinearPowerDensity FromGigawattsPerFoot(double gigawattsperfoot) double value = (double) gigawattsperfoot; return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerFoot); } - /// /// Creates a from . /// @@ -382,7 +380,6 @@ public static LinearPowerDensity FromGigawattsPerInch(double gigawattsperinch) double value = (double) gigawattsperinch; return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerInch); } - /// /// Creates a from . /// @@ -393,7 +390,6 @@ public static LinearPowerDensity FromGigawattsPerMeter(double gigawattspermeter) double value = (double) gigawattspermeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerMeter); } - /// /// Creates a from . /// @@ -404,7 +400,6 @@ public static LinearPowerDensity FromGigawattsPerMillimeter(double gigawattsperm double value = (double) gigawattspermillimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerMillimeter); } - /// /// Creates a from . /// @@ -415,7 +410,6 @@ public static LinearPowerDensity FromKilowattsPerCentimeter(double kilowattsperc double value = (double) kilowattspercentimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerCentimeter); } - /// /// Creates a from . /// @@ -426,7 +420,6 @@ public static LinearPowerDensity FromKilowattsPerFoot(double kilowattsperfoot) double value = (double) kilowattsperfoot; return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerFoot); } - /// /// Creates a from . /// @@ -437,7 +430,6 @@ public static LinearPowerDensity FromKilowattsPerInch(double kilowattsperinch) double value = (double) kilowattsperinch; return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerInch); } - /// /// Creates a from . /// @@ -448,7 +440,6 @@ public static LinearPowerDensity FromKilowattsPerMeter(double kilowattspermeter) double value = (double) kilowattspermeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerMeter); } - /// /// Creates a from . /// @@ -459,7 +450,6 @@ public static LinearPowerDensity FromKilowattsPerMillimeter(double kilowattsperm double value = (double) kilowattspermillimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerMillimeter); } - /// /// Creates a from . /// @@ -470,7 +460,6 @@ public static LinearPowerDensity FromMegawattsPerCentimeter(double megawattsperc double value = (double) megawattspercentimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerCentimeter); } - /// /// Creates a from . /// @@ -481,7 +470,6 @@ public static LinearPowerDensity FromMegawattsPerFoot(double megawattsperfoot) double value = (double) megawattsperfoot; return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerFoot); } - /// /// Creates a from . /// @@ -492,7 +480,6 @@ public static LinearPowerDensity FromMegawattsPerInch(double megawattsperinch) double value = (double) megawattsperinch; return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerInch); } - /// /// Creates a from . /// @@ -503,7 +490,6 @@ public static LinearPowerDensity FromMegawattsPerMeter(double megawattspermeter) double value = (double) megawattspermeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerMeter); } - /// /// Creates a from . /// @@ -514,7 +500,6 @@ public static LinearPowerDensity FromMegawattsPerMillimeter(double megawattsperm double value = (double) megawattspermillimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerMillimeter); } - /// /// Creates a from . /// @@ -525,7 +510,6 @@ public static LinearPowerDensity FromMilliwattsPerCentimeter(double milliwattspe double value = (double) milliwattspercentimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerCentimeter); } - /// /// Creates a from . /// @@ -536,7 +520,6 @@ public static LinearPowerDensity FromMilliwattsPerFoot(double milliwattsperfoot) double value = (double) milliwattsperfoot; return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerFoot); } - /// /// Creates a from . /// @@ -547,7 +530,6 @@ public static LinearPowerDensity FromMilliwattsPerInch(double milliwattsperinch) double value = (double) milliwattsperinch; return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerInch); } - /// /// Creates a from . /// @@ -558,7 +540,6 @@ public static LinearPowerDensity FromMilliwattsPerMeter(double milliwattspermete double value = (double) milliwattspermeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerMeter); } - /// /// Creates a from . /// @@ -569,7 +550,6 @@ public static LinearPowerDensity FromMilliwattsPerMillimeter(double milliwattspe double value = (double) milliwattspermillimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerMillimeter); } - /// /// Creates a from . /// @@ -580,7 +560,6 @@ public static LinearPowerDensity FromWattsPerCentimeter(double wattspercentimete double value = (double) wattspercentimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerCentimeter); } - /// /// Creates a from . /// @@ -591,7 +570,6 @@ public static LinearPowerDensity FromWattsPerFoot(double wattsperfoot) double value = (double) wattsperfoot; return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerFoot); } - /// /// Creates a from . /// @@ -602,7 +580,6 @@ public static LinearPowerDensity FromWattsPerInch(double wattsperinch) double value = (double) wattsperinch; return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerInch); } - /// /// Creates a from . /// @@ -613,7 +590,6 @@ public static LinearPowerDensity FromWattsPerMeter(double wattspermeter) double value = (double) wattspermeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerMeter); } - /// /// Creates a from . /// @@ -625,7 +601,6 @@ public static LinearPowerDensity FromWattsPerMillimeter(double wattspermillimete return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerMillimeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Luminosity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Luminosity.g.cs index 04381f4e39..1a7c85e340 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Luminosity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Luminosity.g.cs @@ -294,7 +294,6 @@ public static Luminosity FromDecawatts(double decawatts) double value = (double) decawatts; return new Luminosity(value, LuminosityUnit.Decawatt); } - /// /// Creates a from . /// @@ -305,7 +304,6 @@ public static Luminosity FromDeciwatts(double deciwatts) double value = (double) deciwatts; return new Luminosity(value, LuminosityUnit.Deciwatt); } - /// /// Creates a from . /// @@ -316,7 +314,6 @@ public static Luminosity FromFemtowatts(double femtowatts) double value = (double) femtowatts; return new Luminosity(value, LuminosityUnit.Femtowatt); } - /// /// Creates a from . /// @@ -327,7 +324,6 @@ public static Luminosity FromGigawatts(double gigawatts) double value = (double) gigawatts; return new Luminosity(value, LuminosityUnit.Gigawatt); } - /// /// Creates a from . /// @@ -338,7 +334,6 @@ public static Luminosity FromKilowatts(double kilowatts) double value = (double) kilowatts; return new Luminosity(value, LuminosityUnit.Kilowatt); } - /// /// Creates a from . /// @@ -349,7 +344,6 @@ public static Luminosity FromMegawatts(double megawatts) double value = (double) megawatts; return new Luminosity(value, LuminosityUnit.Megawatt); } - /// /// Creates a from . /// @@ -360,7 +354,6 @@ public static Luminosity FromMicrowatts(double microwatts) double value = (double) microwatts; return new Luminosity(value, LuminosityUnit.Microwatt); } - /// /// Creates a from . /// @@ -371,7 +364,6 @@ public static Luminosity FromMilliwatts(double milliwatts) double value = (double) milliwatts; return new Luminosity(value, LuminosityUnit.Milliwatt); } - /// /// Creates a from . /// @@ -382,7 +374,6 @@ public static Luminosity FromNanowatts(double nanowatts) double value = (double) nanowatts; return new Luminosity(value, LuminosityUnit.Nanowatt); } - /// /// Creates a from . /// @@ -393,7 +384,6 @@ public static Luminosity FromPetawatts(double petawatts) double value = (double) petawatts; return new Luminosity(value, LuminosityUnit.Petawatt); } - /// /// Creates a from . /// @@ -404,7 +394,6 @@ public static Luminosity FromPicowatts(double picowatts) double value = (double) picowatts; return new Luminosity(value, LuminosityUnit.Picowatt); } - /// /// Creates a from . /// @@ -415,7 +404,6 @@ public static Luminosity FromSolarLuminosities(double solarluminosities) double value = (double) solarluminosities; return new Luminosity(value, LuminosityUnit.SolarLuminosity); } - /// /// Creates a from . /// @@ -426,7 +414,6 @@ public static Luminosity FromTerawatts(double terawatts) double value = (double) terawatts; return new Luminosity(value, LuminosityUnit.Terawatt); } - /// /// Creates a from . /// @@ -438,7 +425,6 @@ public static Luminosity FromWatts(double watts) return new Luminosity(value, LuminosityUnit.Watt); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousFlux.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousFlux.g.cs index f4b42d67a2..ff1866abb2 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousFlux.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousFlux.g.cs @@ -217,7 +217,6 @@ public static LuminousFlux FromLumens(double lumens) return new LuminousFlux(value, LuminousFluxUnit.Lumen); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousIntensity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousIntensity.g.cs index d26d8099af..dec2aa0a17 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousIntensity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousIntensity.g.cs @@ -217,7 +217,6 @@ public static LuminousIntensity FromCandela(double candela) return new LuminousIntensity(value, LuminousIntensityUnit.Candela); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticField.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticField.g.cs index 247dfae7be..600dc4e610 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticField.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticField.g.cs @@ -246,7 +246,6 @@ public static MagneticField FromGausses(double gausses) double value = (double) gausses; return new MagneticField(value, MagneticFieldUnit.Gauss); } - /// /// Creates a from . /// @@ -257,7 +256,6 @@ public static MagneticField FromMicroteslas(double microteslas) double value = (double) microteslas; return new MagneticField(value, MagneticFieldUnit.Microtesla); } - /// /// Creates a from . /// @@ -268,7 +266,6 @@ public static MagneticField FromMilligausses(double milligausses) double value = (double) milligausses; return new MagneticField(value, MagneticFieldUnit.Milligauss); } - /// /// Creates a from . /// @@ -279,7 +276,6 @@ public static MagneticField FromMilliteslas(double milliteslas) double value = (double) milliteslas; return new MagneticField(value, MagneticFieldUnit.Millitesla); } - /// /// Creates a from . /// @@ -290,7 +286,6 @@ public static MagneticField FromNanoteslas(double nanoteslas) double value = (double) nanoteslas; return new MagneticField(value, MagneticFieldUnit.Nanotesla); } - /// /// Creates a from . /// @@ -302,7 +297,6 @@ public static MagneticField FromTeslas(double teslas) return new MagneticField(value, MagneticFieldUnit.Tesla); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticFlux.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticFlux.g.cs index 913093c139..863834d7e5 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticFlux.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticFlux.g.cs @@ -217,7 +217,6 @@ public static MagneticFlux FromWebers(double webers) return new MagneticFlux(value, MagneticFluxUnit.Weber); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Magnetization.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Magnetization.g.cs index b6dd54e58c..f8bdd62dab 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Magnetization.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Magnetization.g.cs @@ -217,7 +217,6 @@ public static Magnetization FromAmperesPerMeter(double amperespermeter) return new Magnetization(value, MagnetizationUnit.AmperePerMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Mass.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Mass.g.cs index 8c05e6db99..d01926a1b5 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Mass.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Mass.g.cs @@ -392,7 +392,6 @@ public static Mass FromCentigrams(double centigrams) double value = (double) centigrams; return new Mass(value, MassUnit.Centigram); } - /// /// Creates a from . /// @@ -403,7 +402,6 @@ public static Mass FromDecagrams(double decagrams) double value = (double) decagrams; return new Mass(value, MassUnit.Decagram); } - /// /// Creates a from . /// @@ -414,7 +412,6 @@ public static Mass FromDecigrams(double decigrams) double value = (double) decigrams; return new Mass(value, MassUnit.Decigram); } - /// /// Creates a from . /// @@ -425,7 +422,6 @@ public static Mass FromEarthMasses(double earthmasses) double value = (double) earthmasses; return new Mass(value, MassUnit.EarthMass); } - /// /// Creates a from . /// @@ -436,7 +432,6 @@ public static Mass FromGrains(double grains) double value = (double) grains; return new Mass(value, MassUnit.Grain); } - /// /// Creates a from . /// @@ -447,7 +442,6 @@ public static Mass FromGrams(double grams) double value = (double) grams; return new Mass(value, MassUnit.Gram); } - /// /// Creates a from . /// @@ -458,7 +452,6 @@ public static Mass FromHectograms(double hectograms) double value = (double) hectograms; return new Mass(value, MassUnit.Hectogram); } - /// /// Creates a from . /// @@ -469,7 +462,6 @@ public static Mass FromKilograms(double kilograms) double value = (double) kilograms; return new Mass(value, MassUnit.Kilogram); } - /// /// Creates a from . /// @@ -480,7 +472,6 @@ public static Mass FromKilopounds(double kilopounds) double value = (double) kilopounds; return new Mass(value, MassUnit.Kilopound); } - /// /// Creates a from . /// @@ -491,7 +482,6 @@ public static Mass FromKilotonnes(double kilotonnes) double value = (double) kilotonnes; return new Mass(value, MassUnit.Kilotonne); } - /// /// Creates a from . /// @@ -502,7 +492,6 @@ public static Mass FromLongHundredweight(double longhundredweight) double value = (double) longhundredweight; return new Mass(value, MassUnit.LongHundredweight); } - /// /// Creates a from . /// @@ -513,7 +502,6 @@ public static Mass FromLongTons(double longtons) double value = (double) longtons; return new Mass(value, MassUnit.LongTon); } - /// /// Creates a from . /// @@ -524,7 +512,6 @@ public static Mass FromMegapounds(double megapounds) double value = (double) megapounds; return new Mass(value, MassUnit.Megapound); } - /// /// Creates a from . /// @@ -535,7 +522,6 @@ public static Mass FromMegatonnes(double megatonnes) double value = (double) megatonnes; return new Mass(value, MassUnit.Megatonne); } - /// /// Creates a from . /// @@ -546,7 +532,6 @@ public static Mass FromMicrograms(double micrograms) double value = (double) micrograms; return new Mass(value, MassUnit.Microgram); } - /// /// Creates a from . /// @@ -557,7 +542,6 @@ public static Mass FromMilligrams(double milligrams) double value = (double) milligrams; return new Mass(value, MassUnit.Milligram); } - /// /// Creates a from . /// @@ -568,7 +552,6 @@ public static Mass FromNanograms(double nanograms) double value = (double) nanograms; return new Mass(value, MassUnit.Nanogram); } - /// /// Creates a from . /// @@ -579,7 +562,6 @@ public static Mass FromOunces(double ounces) double value = (double) ounces; return new Mass(value, MassUnit.Ounce); } - /// /// Creates a from . /// @@ -590,7 +572,6 @@ public static Mass FromPounds(double pounds) double value = (double) pounds; return new Mass(value, MassUnit.Pound); } - /// /// Creates a from . /// @@ -601,7 +582,6 @@ public static Mass FromShortHundredweight(double shorthundredweight) double value = (double) shorthundredweight; return new Mass(value, MassUnit.ShortHundredweight); } - /// /// Creates a from . /// @@ -612,7 +592,6 @@ public static Mass FromShortTons(double shorttons) double value = (double) shorttons; return new Mass(value, MassUnit.ShortTon); } - /// /// Creates a from . /// @@ -623,7 +602,6 @@ public static Mass FromSlugs(double slugs) double value = (double) slugs; return new Mass(value, MassUnit.Slug); } - /// /// Creates a from . /// @@ -634,7 +612,6 @@ public static Mass FromSolarMasses(double solarmasses) double value = (double) solarmasses; return new Mass(value, MassUnit.SolarMass); } - /// /// Creates a from . /// @@ -645,7 +622,6 @@ public static Mass FromStone(double stone) double value = (double) stone; return new Mass(value, MassUnit.Stone); } - /// /// Creates a from . /// @@ -657,7 +633,6 @@ public static Mass FromTonnes(double tonnes) return new Mass(value, MassUnit.Tonne); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassConcentration.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassConcentration.g.cs index 6debb2eb8b..4d637de881 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassConcentration.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassConcentration.g.cs @@ -508,7 +508,6 @@ public static MassConcentration FromCentigramsPerDeciliter(double centigramsperd double value = (double) centigramsperdeciliter; return new MassConcentration(value, MassConcentrationUnit.CentigramPerDeciliter); } - /// /// Creates a from . /// @@ -519,7 +518,6 @@ public static MassConcentration FromCentigramsPerLiter(double centigramsperliter double value = (double) centigramsperliter; return new MassConcentration(value, MassConcentrationUnit.CentigramPerLiter); } - /// /// Creates a from . /// @@ -530,7 +528,6 @@ public static MassConcentration FromCentigramsPerMicroliter(double centigramsper double value = (double) centigramspermicroliter; return new MassConcentration(value, MassConcentrationUnit.CentigramPerMicroliter); } - /// /// Creates a from . /// @@ -541,7 +538,6 @@ public static MassConcentration FromCentigramsPerMilliliter(double centigramsper double value = (double) centigramspermilliliter; return new MassConcentration(value, MassConcentrationUnit.CentigramPerMilliliter); } - /// /// Creates a from . /// @@ -552,7 +548,6 @@ public static MassConcentration FromDecigramsPerDeciliter(double decigramsperdec double value = (double) decigramsperdeciliter; return new MassConcentration(value, MassConcentrationUnit.DecigramPerDeciliter); } - /// /// Creates a from . /// @@ -563,7 +558,6 @@ public static MassConcentration FromDecigramsPerLiter(double decigramsperliter) double value = (double) decigramsperliter; return new MassConcentration(value, MassConcentrationUnit.DecigramPerLiter); } - /// /// Creates a from . /// @@ -574,7 +568,6 @@ public static MassConcentration FromDecigramsPerMicroliter(double decigramspermi double value = (double) decigramspermicroliter; return new MassConcentration(value, MassConcentrationUnit.DecigramPerMicroliter); } - /// /// Creates a from . /// @@ -585,7 +578,6 @@ public static MassConcentration FromDecigramsPerMilliliter(double decigramspermi double value = (double) decigramspermilliliter; return new MassConcentration(value, MassConcentrationUnit.DecigramPerMilliliter); } - /// /// Creates a from . /// @@ -596,7 +588,6 @@ public static MassConcentration FromGramsPerCubicCentimeter(double gramspercubic double value = (double) gramspercubiccentimeter; return new MassConcentration(value, MassConcentrationUnit.GramPerCubicCentimeter); } - /// /// Creates a from . /// @@ -607,7 +598,6 @@ public static MassConcentration FromGramsPerCubicMeter(double gramspercubicmeter double value = (double) gramspercubicmeter; return new MassConcentration(value, MassConcentrationUnit.GramPerCubicMeter); } - /// /// Creates a from . /// @@ -618,7 +608,6 @@ public static MassConcentration FromGramsPerCubicMillimeter(double gramspercubic double value = (double) gramspercubicmillimeter; return new MassConcentration(value, MassConcentrationUnit.GramPerCubicMillimeter); } - /// /// Creates a from . /// @@ -629,7 +618,6 @@ public static MassConcentration FromGramsPerDeciliter(double gramsperdeciliter) double value = (double) gramsperdeciliter; return new MassConcentration(value, MassConcentrationUnit.GramPerDeciliter); } - /// /// Creates a from . /// @@ -640,7 +628,6 @@ public static MassConcentration FromGramsPerLiter(double gramsperliter) double value = (double) gramsperliter; return new MassConcentration(value, MassConcentrationUnit.GramPerLiter); } - /// /// Creates a from . /// @@ -651,7 +638,6 @@ public static MassConcentration FromGramsPerMicroliter(double gramspermicroliter double value = (double) gramspermicroliter; return new MassConcentration(value, MassConcentrationUnit.GramPerMicroliter); } - /// /// Creates a from . /// @@ -662,7 +648,6 @@ public static MassConcentration FromGramsPerMilliliter(double gramspermilliliter double value = (double) gramspermilliliter; return new MassConcentration(value, MassConcentrationUnit.GramPerMilliliter); } - /// /// Creates a from . /// @@ -673,7 +658,6 @@ public static MassConcentration FromKilogramsPerCubicCentimeter(double kilograms double value = (double) kilogramspercubiccentimeter; return new MassConcentration(value, MassConcentrationUnit.KilogramPerCubicCentimeter); } - /// /// Creates a from . /// @@ -684,7 +668,6 @@ public static MassConcentration FromKilogramsPerCubicMeter(double kilogramspercu double value = (double) kilogramspercubicmeter; return new MassConcentration(value, MassConcentrationUnit.KilogramPerCubicMeter); } - /// /// Creates a from . /// @@ -695,7 +678,6 @@ public static MassConcentration FromKilogramsPerCubicMillimeter(double kilograms double value = (double) kilogramspercubicmillimeter; return new MassConcentration(value, MassConcentrationUnit.KilogramPerCubicMillimeter); } - /// /// Creates a from . /// @@ -706,7 +688,6 @@ public static MassConcentration FromKilogramsPerLiter(double kilogramsperliter) double value = (double) kilogramsperliter; return new MassConcentration(value, MassConcentrationUnit.KilogramPerLiter); } - /// /// Creates a from . /// @@ -717,7 +698,6 @@ public static MassConcentration FromKilopoundsPerCubicFoot(double kilopoundsperc double value = (double) kilopoundspercubicfoot; return new MassConcentration(value, MassConcentrationUnit.KilopoundPerCubicFoot); } - /// /// Creates a from . /// @@ -728,7 +708,6 @@ public static MassConcentration FromKilopoundsPerCubicInch(double kilopoundsperc double value = (double) kilopoundspercubicinch; return new MassConcentration(value, MassConcentrationUnit.KilopoundPerCubicInch); } - /// /// Creates a from . /// @@ -739,7 +718,6 @@ public static MassConcentration FromMicrogramsPerCubicMeter(double microgramsper double value = (double) microgramspercubicmeter; return new MassConcentration(value, MassConcentrationUnit.MicrogramPerCubicMeter); } - /// /// Creates a from . /// @@ -750,7 +728,6 @@ public static MassConcentration FromMicrogramsPerDeciliter(double microgramsperd double value = (double) microgramsperdeciliter; return new MassConcentration(value, MassConcentrationUnit.MicrogramPerDeciliter); } - /// /// Creates a from . /// @@ -761,7 +738,6 @@ public static MassConcentration FromMicrogramsPerLiter(double microgramsperliter double value = (double) microgramsperliter; return new MassConcentration(value, MassConcentrationUnit.MicrogramPerLiter); } - /// /// Creates a from . /// @@ -772,7 +748,6 @@ public static MassConcentration FromMicrogramsPerMicroliter(double microgramsper double value = (double) microgramspermicroliter; return new MassConcentration(value, MassConcentrationUnit.MicrogramPerMicroliter); } - /// /// Creates a from . /// @@ -783,7 +758,6 @@ public static MassConcentration FromMicrogramsPerMilliliter(double microgramsper double value = (double) microgramspermilliliter; return new MassConcentration(value, MassConcentrationUnit.MicrogramPerMilliliter); } - /// /// Creates a from . /// @@ -794,7 +768,6 @@ public static MassConcentration FromMilligramsPerCubicMeter(double milligramsper double value = (double) milligramspercubicmeter; return new MassConcentration(value, MassConcentrationUnit.MilligramPerCubicMeter); } - /// /// Creates a from . /// @@ -805,7 +778,6 @@ public static MassConcentration FromMilligramsPerDeciliter(double milligramsperd double value = (double) milligramsperdeciliter; return new MassConcentration(value, MassConcentrationUnit.MilligramPerDeciliter); } - /// /// Creates a from . /// @@ -816,7 +788,6 @@ public static MassConcentration FromMilligramsPerLiter(double milligramsperliter double value = (double) milligramsperliter; return new MassConcentration(value, MassConcentrationUnit.MilligramPerLiter); } - /// /// Creates a from . /// @@ -827,7 +798,6 @@ public static MassConcentration FromMilligramsPerMicroliter(double milligramsper double value = (double) milligramspermicroliter; return new MassConcentration(value, MassConcentrationUnit.MilligramPerMicroliter); } - /// /// Creates a from . /// @@ -838,7 +808,6 @@ public static MassConcentration FromMilligramsPerMilliliter(double milligramsper double value = (double) milligramspermilliliter; return new MassConcentration(value, MassConcentrationUnit.MilligramPerMilliliter); } - /// /// Creates a from . /// @@ -849,7 +818,6 @@ public static MassConcentration FromNanogramsPerDeciliter(double nanogramsperdec double value = (double) nanogramsperdeciliter; return new MassConcentration(value, MassConcentrationUnit.NanogramPerDeciliter); } - /// /// Creates a from . /// @@ -860,7 +828,6 @@ public static MassConcentration FromNanogramsPerLiter(double nanogramsperliter) double value = (double) nanogramsperliter; return new MassConcentration(value, MassConcentrationUnit.NanogramPerLiter); } - /// /// Creates a from . /// @@ -871,7 +838,6 @@ public static MassConcentration FromNanogramsPerMicroliter(double nanogramspermi double value = (double) nanogramspermicroliter; return new MassConcentration(value, MassConcentrationUnit.NanogramPerMicroliter); } - /// /// Creates a from . /// @@ -882,7 +848,6 @@ public static MassConcentration FromNanogramsPerMilliliter(double nanogramspermi double value = (double) nanogramspermilliliter; return new MassConcentration(value, MassConcentrationUnit.NanogramPerMilliliter); } - /// /// Creates a from . /// @@ -893,7 +858,6 @@ public static MassConcentration FromOuncesPerImperialGallon(double ouncesperimpe double value = (double) ouncesperimperialgallon; return new MassConcentration(value, MassConcentrationUnit.OuncePerImperialGallon); } - /// /// Creates a from . /// @@ -904,7 +868,6 @@ public static MassConcentration FromOuncesPerUSGallon(double ouncesperusgallon) double value = (double) ouncesperusgallon; return new MassConcentration(value, MassConcentrationUnit.OuncePerUSGallon); } - /// /// Creates a from . /// @@ -915,7 +878,6 @@ public static MassConcentration FromPicogramsPerDeciliter(double picogramsperdec double value = (double) picogramsperdeciliter; return new MassConcentration(value, MassConcentrationUnit.PicogramPerDeciliter); } - /// /// Creates a from . /// @@ -926,7 +888,6 @@ public static MassConcentration FromPicogramsPerLiter(double picogramsperliter) double value = (double) picogramsperliter; return new MassConcentration(value, MassConcentrationUnit.PicogramPerLiter); } - /// /// Creates a from . /// @@ -937,7 +898,6 @@ public static MassConcentration FromPicogramsPerMicroliter(double picogramspermi double value = (double) picogramspermicroliter; return new MassConcentration(value, MassConcentrationUnit.PicogramPerMicroliter); } - /// /// Creates a from . /// @@ -948,7 +908,6 @@ public static MassConcentration FromPicogramsPerMilliliter(double picogramspermi double value = (double) picogramspermilliliter; return new MassConcentration(value, MassConcentrationUnit.PicogramPerMilliliter); } - /// /// Creates a from . /// @@ -959,7 +918,6 @@ public static MassConcentration FromPoundsPerCubicFoot(double poundspercubicfoot double value = (double) poundspercubicfoot; return new MassConcentration(value, MassConcentrationUnit.PoundPerCubicFoot); } - /// /// Creates a from . /// @@ -970,7 +928,6 @@ public static MassConcentration FromPoundsPerCubicInch(double poundspercubicinch double value = (double) poundspercubicinch; return new MassConcentration(value, MassConcentrationUnit.PoundPerCubicInch); } - /// /// Creates a from . /// @@ -981,7 +938,6 @@ public static MassConcentration FromPoundsPerImperialGallon(double poundsperimpe double value = (double) poundsperimperialgallon; return new MassConcentration(value, MassConcentrationUnit.PoundPerImperialGallon); } - /// /// Creates a from . /// @@ -992,7 +948,6 @@ public static MassConcentration FromPoundsPerUSGallon(double poundsperusgallon) double value = (double) poundsperusgallon; return new MassConcentration(value, MassConcentrationUnit.PoundPerUSGallon); } - /// /// Creates a from . /// @@ -1003,7 +958,6 @@ public static MassConcentration FromSlugsPerCubicFoot(double slugspercubicfoot) double value = (double) slugspercubicfoot; return new MassConcentration(value, MassConcentrationUnit.SlugPerCubicFoot); } - /// /// Creates a from . /// @@ -1014,7 +968,6 @@ public static MassConcentration FromTonnesPerCubicCentimeter(double tonnespercub double value = (double) tonnespercubiccentimeter; return new MassConcentration(value, MassConcentrationUnit.TonnePerCubicCentimeter); } - /// /// Creates a from . /// @@ -1025,7 +978,6 @@ public static MassConcentration FromTonnesPerCubicMeter(double tonnespercubicmet double value = (double) tonnespercubicmeter; return new MassConcentration(value, MassConcentrationUnit.TonnePerCubicMeter); } - /// /// Creates a from . /// @@ -1037,7 +989,6 @@ public static MassConcentration FromTonnesPerCubicMillimeter(double tonnespercub return new MassConcentration(value, MassConcentrationUnit.TonnePerCubicMillimeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlow.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlow.g.cs index eadbcad602..f28f33b950 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlow.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlow.g.cs @@ -407,7 +407,6 @@ public static MassFlow FromCentigramsPerDay(double centigramsperday) double value = (double) centigramsperday; return new MassFlow(value, MassFlowUnit.CentigramPerDay); } - /// /// Creates a from . /// @@ -418,7 +417,6 @@ public static MassFlow FromCentigramsPerSecond(double centigramspersecond) double value = (double) centigramspersecond; return new MassFlow(value, MassFlowUnit.CentigramPerSecond); } - /// /// Creates a from . /// @@ -429,7 +427,6 @@ public static MassFlow FromDecagramsPerDay(double decagramsperday) double value = (double) decagramsperday; return new MassFlow(value, MassFlowUnit.DecagramPerDay); } - /// /// Creates a from . /// @@ -440,7 +437,6 @@ public static MassFlow FromDecagramsPerSecond(double decagramspersecond) double value = (double) decagramspersecond; return new MassFlow(value, MassFlowUnit.DecagramPerSecond); } - /// /// Creates a from . /// @@ -451,7 +447,6 @@ public static MassFlow FromDecigramsPerDay(double decigramsperday) double value = (double) decigramsperday; return new MassFlow(value, MassFlowUnit.DecigramPerDay); } - /// /// Creates a from . /// @@ -462,7 +457,6 @@ public static MassFlow FromDecigramsPerSecond(double decigramspersecond) double value = (double) decigramspersecond; return new MassFlow(value, MassFlowUnit.DecigramPerSecond); } - /// /// Creates a from . /// @@ -473,7 +467,6 @@ public static MassFlow FromGramsPerDay(double gramsperday) double value = (double) gramsperday; return new MassFlow(value, MassFlowUnit.GramPerDay); } - /// /// Creates a from . /// @@ -484,7 +477,6 @@ public static MassFlow FromGramsPerHour(double gramsperhour) double value = (double) gramsperhour; return new MassFlow(value, MassFlowUnit.GramPerHour); } - /// /// Creates a from . /// @@ -495,7 +487,6 @@ public static MassFlow FromGramsPerSecond(double gramspersecond) double value = (double) gramspersecond; return new MassFlow(value, MassFlowUnit.GramPerSecond); } - /// /// Creates a from . /// @@ -506,7 +497,6 @@ public static MassFlow FromHectogramsPerDay(double hectogramsperday) double value = (double) hectogramsperday; return new MassFlow(value, MassFlowUnit.HectogramPerDay); } - /// /// Creates a from . /// @@ -517,7 +507,6 @@ public static MassFlow FromHectogramsPerSecond(double hectogramspersecond) double value = (double) hectogramspersecond; return new MassFlow(value, MassFlowUnit.HectogramPerSecond); } - /// /// Creates a from . /// @@ -528,7 +517,6 @@ public static MassFlow FromKilogramsPerDay(double kilogramsperday) double value = (double) kilogramsperday; return new MassFlow(value, MassFlowUnit.KilogramPerDay); } - /// /// Creates a from . /// @@ -539,7 +527,6 @@ public static MassFlow FromKilogramsPerHour(double kilogramsperhour) double value = (double) kilogramsperhour; return new MassFlow(value, MassFlowUnit.KilogramPerHour); } - /// /// Creates a from . /// @@ -550,7 +537,6 @@ public static MassFlow FromKilogramsPerMinute(double kilogramsperminute) double value = (double) kilogramsperminute; return new MassFlow(value, MassFlowUnit.KilogramPerMinute); } - /// /// Creates a from . /// @@ -561,7 +547,6 @@ public static MassFlow FromKilogramsPerSecond(double kilogramspersecond) double value = (double) kilogramspersecond; return new MassFlow(value, MassFlowUnit.KilogramPerSecond); } - /// /// Creates a from . /// @@ -572,7 +557,6 @@ public static MassFlow FromMegagramsPerDay(double megagramsperday) double value = (double) megagramsperday; return new MassFlow(value, MassFlowUnit.MegagramPerDay); } - /// /// Creates a from . /// @@ -583,7 +567,6 @@ public static MassFlow FromMegapoundsPerDay(double megapoundsperday) double value = (double) megapoundsperday; return new MassFlow(value, MassFlowUnit.MegapoundPerDay); } - /// /// Creates a from . /// @@ -594,7 +577,6 @@ public static MassFlow FromMegapoundsPerHour(double megapoundsperhour) double value = (double) megapoundsperhour; return new MassFlow(value, MassFlowUnit.MegapoundPerHour); } - /// /// Creates a from . /// @@ -605,7 +587,6 @@ public static MassFlow FromMegapoundsPerMinute(double megapoundsperminute) double value = (double) megapoundsperminute; return new MassFlow(value, MassFlowUnit.MegapoundPerMinute); } - /// /// Creates a from . /// @@ -616,7 +597,6 @@ public static MassFlow FromMegapoundsPerSecond(double megapoundspersecond) double value = (double) megapoundspersecond; return new MassFlow(value, MassFlowUnit.MegapoundPerSecond); } - /// /// Creates a from . /// @@ -627,7 +607,6 @@ public static MassFlow FromMicrogramsPerDay(double microgramsperday) double value = (double) microgramsperday; return new MassFlow(value, MassFlowUnit.MicrogramPerDay); } - /// /// Creates a from . /// @@ -638,7 +617,6 @@ public static MassFlow FromMicrogramsPerSecond(double microgramspersecond) double value = (double) microgramspersecond; return new MassFlow(value, MassFlowUnit.MicrogramPerSecond); } - /// /// Creates a from . /// @@ -649,7 +627,6 @@ public static MassFlow FromMilligramsPerDay(double milligramsperday) double value = (double) milligramsperday; return new MassFlow(value, MassFlowUnit.MilligramPerDay); } - /// /// Creates a from . /// @@ -660,7 +637,6 @@ public static MassFlow FromMilligramsPerSecond(double milligramspersecond) double value = (double) milligramspersecond; return new MassFlow(value, MassFlowUnit.MilligramPerSecond); } - /// /// Creates a from . /// @@ -671,7 +647,6 @@ public static MassFlow FromNanogramsPerDay(double nanogramsperday) double value = (double) nanogramsperday; return new MassFlow(value, MassFlowUnit.NanogramPerDay); } - /// /// Creates a from . /// @@ -682,7 +657,6 @@ public static MassFlow FromNanogramsPerSecond(double nanogramspersecond) double value = (double) nanogramspersecond; return new MassFlow(value, MassFlowUnit.NanogramPerSecond); } - /// /// Creates a from . /// @@ -693,7 +667,6 @@ public static MassFlow FromPoundsPerDay(double poundsperday) double value = (double) poundsperday; return new MassFlow(value, MassFlowUnit.PoundPerDay); } - /// /// Creates a from . /// @@ -704,7 +677,6 @@ public static MassFlow FromPoundsPerHour(double poundsperhour) double value = (double) poundsperhour; return new MassFlow(value, MassFlowUnit.PoundPerHour); } - /// /// Creates a from . /// @@ -715,7 +687,6 @@ public static MassFlow FromPoundsPerMinute(double poundsperminute) double value = (double) poundsperminute; return new MassFlow(value, MassFlowUnit.PoundPerMinute); } - /// /// Creates a from . /// @@ -726,7 +697,6 @@ public static MassFlow FromPoundsPerSecond(double poundspersecond) double value = (double) poundspersecond; return new MassFlow(value, MassFlowUnit.PoundPerSecond); } - /// /// Creates a from . /// @@ -737,7 +707,6 @@ public static MassFlow FromShortTonsPerHour(double shorttonsperhour) double value = (double) shorttonsperhour; return new MassFlow(value, MassFlowUnit.ShortTonPerHour); } - /// /// Creates a from . /// @@ -748,7 +717,6 @@ public static MassFlow FromTonnesPerDay(double tonnesperday) double value = (double) tonnesperday; return new MassFlow(value, MassFlowUnit.TonnePerDay); } - /// /// Creates a from . /// @@ -760,7 +728,6 @@ public static MassFlow FromTonnesPerHour(double tonnesperhour) return new MassFlow(value, MassFlowUnit.TonnePerHour); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlux.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlux.g.cs index d8beaaf0d3..c645fc1182 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlux.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlux.g.cs @@ -279,7 +279,6 @@ public static MassFlux FromGramsPerHourPerSquareCentimeter(double gramsperhourpe double value = (double) gramsperhourpersquarecentimeter; return new MassFlux(value, MassFluxUnit.GramPerHourPerSquareCentimeter); } - /// /// Creates a from . /// @@ -290,7 +289,6 @@ public static MassFlux FromGramsPerHourPerSquareMeter(double gramsperhourpersqua double value = (double) gramsperhourpersquaremeter; return new MassFlux(value, MassFluxUnit.GramPerHourPerSquareMeter); } - /// /// Creates a from . /// @@ -301,7 +299,6 @@ public static MassFlux FromGramsPerHourPerSquareMillimeter(double gramsperhourpe double value = (double) gramsperhourpersquaremillimeter; return new MassFlux(value, MassFluxUnit.GramPerHourPerSquareMillimeter); } - /// /// Creates a from . /// @@ -312,7 +309,6 @@ public static MassFlux FromGramsPerSecondPerSquareCentimeter(double gramsperseco double value = (double) gramspersecondpersquarecentimeter; return new MassFlux(value, MassFluxUnit.GramPerSecondPerSquareCentimeter); } - /// /// Creates a from . /// @@ -323,7 +319,6 @@ public static MassFlux FromGramsPerSecondPerSquareMeter(double gramspersecondper double value = (double) gramspersecondpersquaremeter; return new MassFlux(value, MassFluxUnit.GramPerSecondPerSquareMeter); } - /// /// Creates a from . /// @@ -334,7 +329,6 @@ public static MassFlux FromGramsPerSecondPerSquareMillimeter(double gramsperseco double value = (double) gramspersecondpersquaremillimeter; return new MassFlux(value, MassFluxUnit.GramPerSecondPerSquareMillimeter); } - /// /// Creates a from . /// @@ -345,7 +339,6 @@ public static MassFlux FromKilogramsPerHourPerSquareCentimeter(double kilogramsp double value = (double) kilogramsperhourpersquarecentimeter; return new MassFlux(value, MassFluxUnit.KilogramPerHourPerSquareCentimeter); } - /// /// Creates a from . /// @@ -356,7 +349,6 @@ public static MassFlux FromKilogramsPerHourPerSquareMeter(double kilogramsperhou double value = (double) kilogramsperhourpersquaremeter; return new MassFlux(value, MassFluxUnit.KilogramPerHourPerSquareMeter); } - /// /// Creates a from . /// @@ -367,7 +359,6 @@ public static MassFlux FromKilogramsPerHourPerSquareMillimeter(double kilogramsp double value = (double) kilogramsperhourpersquaremillimeter; return new MassFlux(value, MassFluxUnit.KilogramPerHourPerSquareMillimeter); } - /// /// Creates a from . /// @@ -378,7 +369,6 @@ public static MassFlux FromKilogramsPerSecondPerSquareCentimeter(double kilogram double value = (double) kilogramspersecondpersquarecentimeter; return new MassFlux(value, MassFluxUnit.KilogramPerSecondPerSquareCentimeter); } - /// /// Creates a from . /// @@ -389,7 +379,6 @@ public static MassFlux FromKilogramsPerSecondPerSquareMeter(double kilogramspers double value = (double) kilogramspersecondpersquaremeter; return new MassFlux(value, MassFluxUnit.KilogramPerSecondPerSquareMeter); } - /// /// Creates a from . /// @@ -401,7 +390,6 @@ public static MassFlux FromKilogramsPerSecondPerSquareMillimeter(double kilogram return new MassFlux(value, MassFluxUnit.KilogramPerSecondPerSquareMillimeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFraction.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFraction.g.cs index fb71faec90..2f60af0b3a 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFraction.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFraction.g.cs @@ -354,7 +354,6 @@ public static MassFraction FromCentigramsPerGram(double centigramspergram) double value = (double) centigramspergram; return new MassFraction(value, MassFractionUnit.CentigramPerGram); } - /// /// Creates a from . /// @@ -365,7 +364,6 @@ public static MassFraction FromCentigramsPerKilogram(double centigramsperkilogra double value = (double) centigramsperkilogram; return new MassFraction(value, MassFractionUnit.CentigramPerKilogram); } - /// /// Creates a from . /// @@ -376,7 +374,6 @@ public static MassFraction FromDecagramsPerGram(double decagramspergram) double value = (double) decagramspergram; return new MassFraction(value, MassFractionUnit.DecagramPerGram); } - /// /// Creates a from . /// @@ -387,7 +384,6 @@ public static MassFraction FromDecagramsPerKilogram(double decagramsperkilogram) double value = (double) decagramsperkilogram; return new MassFraction(value, MassFractionUnit.DecagramPerKilogram); } - /// /// Creates a from . /// @@ -398,7 +394,6 @@ public static MassFraction FromDecigramsPerGram(double decigramspergram) double value = (double) decigramspergram; return new MassFraction(value, MassFractionUnit.DecigramPerGram); } - /// /// Creates a from . /// @@ -409,7 +404,6 @@ public static MassFraction FromDecigramsPerKilogram(double decigramsperkilogram) double value = (double) decigramsperkilogram; return new MassFraction(value, MassFractionUnit.DecigramPerKilogram); } - /// /// Creates a from . /// @@ -420,7 +414,6 @@ public static MassFraction FromDecimalFractions(double decimalfractions) double value = (double) decimalfractions; return new MassFraction(value, MassFractionUnit.DecimalFraction); } - /// /// Creates a from . /// @@ -431,7 +424,6 @@ public static MassFraction FromGramsPerGram(double gramspergram) double value = (double) gramspergram; return new MassFraction(value, MassFractionUnit.GramPerGram); } - /// /// Creates a from . /// @@ -442,7 +434,6 @@ public static MassFraction FromGramsPerKilogram(double gramsperkilogram) double value = (double) gramsperkilogram; return new MassFraction(value, MassFractionUnit.GramPerKilogram); } - /// /// Creates a from . /// @@ -453,7 +444,6 @@ public static MassFraction FromHectogramsPerGram(double hectogramspergram) double value = (double) hectogramspergram; return new MassFraction(value, MassFractionUnit.HectogramPerGram); } - /// /// Creates a from . /// @@ -464,7 +454,6 @@ public static MassFraction FromHectogramsPerKilogram(double hectogramsperkilogra double value = (double) hectogramsperkilogram; return new MassFraction(value, MassFractionUnit.HectogramPerKilogram); } - /// /// Creates a from . /// @@ -475,7 +464,6 @@ public static MassFraction FromKilogramsPerGram(double kilogramspergram) double value = (double) kilogramspergram; return new MassFraction(value, MassFractionUnit.KilogramPerGram); } - /// /// Creates a from . /// @@ -486,7 +474,6 @@ public static MassFraction FromKilogramsPerKilogram(double kilogramsperkilogram) double value = (double) kilogramsperkilogram; return new MassFraction(value, MassFractionUnit.KilogramPerKilogram); } - /// /// Creates a from . /// @@ -497,7 +484,6 @@ public static MassFraction FromMicrogramsPerGram(double microgramspergram) double value = (double) microgramspergram; return new MassFraction(value, MassFractionUnit.MicrogramPerGram); } - /// /// Creates a from . /// @@ -508,7 +494,6 @@ public static MassFraction FromMicrogramsPerKilogram(double microgramsperkilogra double value = (double) microgramsperkilogram; return new MassFraction(value, MassFractionUnit.MicrogramPerKilogram); } - /// /// Creates a from . /// @@ -519,7 +504,6 @@ public static MassFraction FromMilligramsPerGram(double milligramspergram) double value = (double) milligramspergram; return new MassFraction(value, MassFractionUnit.MilligramPerGram); } - /// /// Creates a from . /// @@ -530,7 +514,6 @@ public static MassFraction FromMilligramsPerKilogram(double milligramsperkilogra double value = (double) milligramsperkilogram; return new MassFraction(value, MassFractionUnit.MilligramPerKilogram); } - /// /// Creates a from . /// @@ -541,7 +524,6 @@ public static MassFraction FromNanogramsPerGram(double nanogramspergram) double value = (double) nanogramspergram; return new MassFraction(value, MassFractionUnit.NanogramPerGram); } - /// /// Creates a from . /// @@ -552,7 +534,6 @@ public static MassFraction FromNanogramsPerKilogram(double nanogramsperkilogram) double value = (double) nanogramsperkilogram; return new MassFraction(value, MassFractionUnit.NanogramPerKilogram); } - /// /// Creates a from . /// @@ -563,7 +544,6 @@ public static MassFraction FromPartsPerBillion(double partsperbillion) double value = (double) partsperbillion; return new MassFraction(value, MassFractionUnit.PartPerBillion); } - /// /// Creates a from . /// @@ -574,7 +554,6 @@ public static MassFraction FromPartsPerMillion(double partspermillion) double value = (double) partspermillion; return new MassFraction(value, MassFractionUnit.PartPerMillion); } - /// /// Creates a from . /// @@ -585,7 +564,6 @@ public static MassFraction FromPartsPerThousand(double partsperthousand) double value = (double) partsperthousand; return new MassFraction(value, MassFractionUnit.PartPerThousand); } - /// /// Creates a from . /// @@ -596,7 +574,6 @@ public static MassFraction FromPartsPerTrillion(double partspertrillion) double value = (double) partspertrillion; return new MassFraction(value, MassFractionUnit.PartPerTrillion); } - /// /// Creates a from . /// @@ -608,7 +585,6 @@ public static MassFraction FromPercent(double percent) return new MassFraction(value, MassFractionUnit.Percent); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassMomentOfInertia.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassMomentOfInertia.g.cs index dd05a4ec89..74bcfc0225 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassMomentOfInertia.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassMomentOfInertia.g.cs @@ -375,7 +375,6 @@ public static MassMomentOfInertia FromGramSquareCentimeters(double gramsquarecen double value = (double) gramsquarecentimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareCentimeter); } - /// /// Creates a from . /// @@ -386,7 +385,6 @@ public static MassMomentOfInertia FromGramSquareDecimeters(double gramsquaredeci double value = (double) gramsquaredecimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareDecimeter); } - /// /// Creates a from . /// @@ -397,7 +395,6 @@ public static MassMomentOfInertia FromGramSquareMeters(double gramsquaremeters) double value = (double) gramsquaremeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareMeter); } - /// /// Creates a from . /// @@ -408,7 +405,6 @@ public static MassMomentOfInertia FromGramSquareMillimeters(double gramsquaremil double value = (double) gramsquaremillimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareMillimeter); } - /// /// Creates a from . /// @@ -419,7 +415,6 @@ public static MassMomentOfInertia FromKilogramSquareCentimeters(double kilograms double value = (double) kilogramsquarecentimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareCentimeter); } - /// /// Creates a from . /// @@ -430,7 +425,6 @@ public static MassMomentOfInertia FromKilogramSquareDecimeters(double kilogramsq double value = (double) kilogramsquaredecimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareDecimeter); } - /// /// Creates a from . /// @@ -441,7 +435,6 @@ public static MassMomentOfInertia FromKilogramSquareMeters(double kilogramsquare double value = (double) kilogramsquaremeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareMeter); } - /// /// Creates a from . /// @@ -452,7 +445,6 @@ public static MassMomentOfInertia FromKilogramSquareMillimeters(double kilograms double value = (double) kilogramsquaremillimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareMillimeter); } - /// /// Creates a from . /// @@ -463,7 +455,6 @@ public static MassMomentOfInertia FromKilotonneSquareCentimeters(double kilotonn double value = (double) kilotonnesquarecentimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareCentimeter); } - /// /// Creates a from . /// @@ -474,7 +465,6 @@ public static MassMomentOfInertia FromKilotonneSquareDecimeters(double kilotonne double value = (double) kilotonnesquaredecimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareDecimeter); } - /// /// Creates a from . /// @@ -485,7 +475,6 @@ public static MassMomentOfInertia FromKilotonneSquareMeters(double kilotonnesqua double value = (double) kilotonnesquaremeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareMeter); } - /// /// Creates a from . /// @@ -496,7 +485,6 @@ public static MassMomentOfInertia FromKilotonneSquareMilimeters(double kilotonne double value = (double) kilotonnesquaremilimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareMilimeter); } - /// /// Creates a from . /// @@ -507,7 +495,6 @@ public static MassMomentOfInertia FromMegatonneSquareCentimeters(double megatonn double value = (double) megatonnesquarecentimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareCentimeter); } - /// /// Creates a from . /// @@ -518,7 +505,6 @@ public static MassMomentOfInertia FromMegatonneSquareDecimeters(double megatonne double value = (double) megatonnesquaredecimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareDecimeter); } - /// /// Creates a from . /// @@ -529,7 +515,6 @@ public static MassMomentOfInertia FromMegatonneSquareMeters(double megatonnesqua double value = (double) megatonnesquaremeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareMeter); } - /// /// Creates a from . /// @@ -540,7 +525,6 @@ public static MassMomentOfInertia FromMegatonneSquareMilimeters(double megatonne double value = (double) megatonnesquaremilimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareMilimeter); } - /// /// Creates a from . /// @@ -551,7 +535,6 @@ public static MassMomentOfInertia FromMilligramSquareCentimeters(double milligra double value = (double) milligramsquarecentimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareCentimeter); } - /// /// Creates a from . /// @@ -562,7 +545,6 @@ public static MassMomentOfInertia FromMilligramSquareDecimeters(double milligram double value = (double) milligramsquaredecimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareDecimeter); } - /// /// Creates a from . /// @@ -573,7 +555,6 @@ public static MassMomentOfInertia FromMilligramSquareMeters(double milligramsqua double value = (double) milligramsquaremeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareMeter); } - /// /// Creates a from . /// @@ -584,7 +565,6 @@ public static MassMomentOfInertia FromMilligramSquareMillimeters(double milligra double value = (double) milligramsquaremillimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareMillimeter); } - /// /// Creates a from . /// @@ -595,7 +575,6 @@ public static MassMomentOfInertia FromPoundSquareFeet(double poundsquarefeet) double value = (double) poundsquarefeet; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.PoundSquareFoot); } - /// /// Creates a from . /// @@ -606,7 +585,6 @@ public static MassMomentOfInertia FromPoundSquareInches(double poundsquareinches double value = (double) poundsquareinches; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.PoundSquareInch); } - /// /// Creates a from . /// @@ -617,7 +595,6 @@ public static MassMomentOfInertia FromSlugSquareFeet(double slugsquarefeet) double value = (double) slugsquarefeet; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.SlugSquareFoot); } - /// /// Creates a from . /// @@ -628,7 +605,6 @@ public static MassMomentOfInertia FromSlugSquareInches(double slugsquareinches) double value = (double) slugsquareinches; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.SlugSquareInch); } - /// /// Creates a from . /// @@ -639,7 +615,6 @@ public static MassMomentOfInertia FromTonneSquareCentimeters(double tonnesquarec double value = (double) tonnesquarecentimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareCentimeter); } - /// /// Creates a from . /// @@ -650,7 +625,6 @@ public static MassMomentOfInertia FromTonneSquareDecimeters(double tonnesquarede double value = (double) tonnesquaredecimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareDecimeter); } - /// /// Creates a from . /// @@ -661,7 +635,6 @@ public static MassMomentOfInertia FromTonneSquareMeters(double tonnesquaremeters double value = (double) tonnesquaremeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareMeter); } - /// /// Creates a from . /// @@ -673,7 +646,6 @@ public static MassMomentOfInertia FromTonneSquareMilimeters(double tonnesquaremi return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareMilimeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEnergy.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEnergy.g.cs index 116324a145..d2e4502b0f 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEnergy.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEnergy.g.cs @@ -225,7 +225,6 @@ public static MolarEnergy FromJoulesPerMole(double joulespermole) double value = (double) joulespermole; return new MolarEnergy(value, MolarEnergyUnit.JoulePerMole); } - /// /// Creates a from . /// @@ -236,7 +235,6 @@ public static MolarEnergy FromKilojoulesPerMole(double kilojoulespermole) double value = (double) kilojoulespermole; return new MolarEnergy(value, MolarEnergyUnit.KilojoulePerMole); } - /// /// Creates a from . /// @@ -248,7 +246,6 @@ public static MolarEnergy FromMegajoulesPerMole(double megajoulespermole) return new MolarEnergy(value, MolarEnergyUnit.MegajoulePerMole); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEntropy.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEntropy.g.cs index 47ff01ae00..5e60a71653 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEntropy.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEntropy.g.cs @@ -225,7 +225,6 @@ public static MolarEntropy FromJoulesPerMoleKelvin(double joulespermolekelvin) double value = (double) joulespermolekelvin; return new MolarEntropy(value, MolarEntropyUnit.JoulePerMoleKelvin); } - /// /// Creates a from . /// @@ -236,7 +235,6 @@ public static MolarEntropy FromKilojoulesPerMoleKelvin(double kilojoulespermolek double value = (double) kilojoulespermolekelvin; return new MolarEntropy(value, MolarEntropyUnit.KilojoulePerMoleKelvin); } - /// /// Creates a from . /// @@ -248,7 +246,6 @@ public static MolarEntropy FromMegajoulesPerMoleKelvin(double megajoulespermolek return new MolarEntropy(value, MolarEntropyUnit.MegajoulePerMoleKelvin); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarMass.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarMass.g.cs index 0d37e1bec2..61dbf93742 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarMass.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarMass.g.cs @@ -291,7 +291,6 @@ public static MolarMass FromCentigramsPerMole(double centigramspermole) double value = (double) centigramspermole; return new MolarMass(value, MolarMassUnit.CentigramPerMole); } - /// /// Creates a from . /// @@ -302,7 +301,6 @@ public static MolarMass FromDecagramsPerMole(double decagramspermole) double value = (double) decagramspermole; return new MolarMass(value, MolarMassUnit.DecagramPerMole); } - /// /// Creates a from . /// @@ -313,7 +311,6 @@ public static MolarMass FromDecigramsPerMole(double decigramspermole) double value = (double) decigramspermole; return new MolarMass(value, MolarMassUnit.DecigramPerMole); } - /// /// Creates a from . /// @@ -324,7 +321,6 @@ public static MolarMass FromGramsPerMole(double gramspermole) double value = (double) gramspermole; return new MolarMass(value, MolarMassUnit.GramPerMole); } - /// /// Creates a from . /// @@ -335,7 +331,6 @@ public static MolarMass FromHectogramsPerMole(double hectogramspermole) double value = (double) hectogramspermole; return new MolarMass(value, MolarMassUnit.HectogramPerMole); } - /// /// Creates a from . /// @@ -346,7 +341,6 @@ public static MolarMass FromKilogramsPerMole(double kilogramspermole) double value = (double) kilogramspermole; return new MolarMass(value, MolarMassUnit.KilogramPerMole); } - /// /// Creates a from . /// @@ -357,7 +351,6 @@ public static MolarMass FromKilopoundsPerMole(double kilopoundspermole) double value = (double) kilopoundspermole; return new MolarMass(value, MolarMassUnit.KilopoundPerMole); } - /// /// Creates a from . /// @@ -368,7 +361,6 @@ public static MolarMass FromMegapoundsPerMole(double megapoundspermole) double value = (double) megapoundspermole; return new MolarMass(value, MolarMassUnit.MegapoundPerMole); } - /// /// Creates a from . /// @@ -379,7 +371,6 @@ public static MolarMass FromMicrogramsPerMole(double microgramspermole) double value = (double) microgramspermole; return new MolarMass(value, MolarMassUnit.MicrogramPerMole); } - /// /// Creates a from . /// @@ -390,7 +381,6 @@ public static MolarMass FromMilligramsPerMole(double milligramspermole) double value = (double) milligramspermole; return new MolarMass(value, MolarMassUnit.MilligramPerMole); } - /// /// Creates a from . /// @@ -401,7 +391,6 @@ public static MolarMass FromNanogramsPerMole(double nanogramspermole) double value = (double) nanogramspermole; return new MolarMass(value, MolarMassUnit.NanogramPerMole); } - /// /// Creates a from . /// @@ -413,7 +402,6 @@ public static MolarMass FromPoundsPerMole(double poundspermole) return new MolarMass(value, MolarMassUnit.PoundPerMole); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Molarity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Molarity.g.cs index 017de90a3b..6668649bdb 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Molarity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Molarity.g.cs @@ -266,7 +266,6 @@ public static Molarity FromCentimolesPerLiter(double centimolesperliter) double value = (double) centimolesperliter; return new Molarity(value, MolarityUnit.CentimolePerLiter); } - /// /// Creates a from . /// @@ -277,7 +276,6 @@ public static Molarity FromDecimolesPerLiter(double decimolesperliter) double value = (double) decimolesperliter; return new Molarity(value, MolarityUnit.DecimolePerLiter); } - /// /// Creates a from . /// @@ -288,7 +286,6 @@ public static Molarity FromMicromolesPerLiter(double micromolesperliter) double value = (double) micromolesperliter; return new Molarity(value, MolarityUnit.MicromolePerLiter); } - /// /// Creates a from . /// @@ -299,7 +296,6 @@ public static Molarity FromMillimolesPerLiter(double millimolesperliter) double value = (double) millimolesperliter; return new Molarity(value, MolarityUnit.MillimolePerLiter); } - /// /// Creates a from . /// @@ -310,7 +306,6 @@ public static Molarity FromMolesPerCubicMeter(double molespercubicmeter) double value = (double) molespercubicmeter; return new Molarity(value, MolarityUnit.MolePerCubicMeter); } - /// /// Creates a from . /// @@ -321,7 +316,6 @@ public static Molarity FromMolesPerLiter(double molesperliter) double value = (double) molesperliter; return new Molarity(value, MolarityUnit.MolePerLiter); } - /// /// Creates a from . /// @@ -332,7 +326,6 @@ public static Molarity FromNanomolesPerLiter(double nanomolesperliter) double value = (double) nanomolesperliter; return new Molarity(value, MolarityUnit.NanomolePerLiter); } - /// /// Creates a from . /// @@ -344,7 +337,6 @@ public static Molarity FromPicomolesPerLiter(double picomolesperliter) return new Molarity(value, MolarityUnit.PicomolePerLiter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permeability.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permeability.g.cs index fe8e116fb7..534a6d21c2 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permeability.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permeability.g.cs @@ -217,7 +217,6 @@ public static Permeability FromHenriesPerMeter(double henriespermeter) return new Permeability(value, PermeabilityUnit.HenryPerMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permittivity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permittivity.g.cs index 664f3e9f7a..78a9b9efb8 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permittivity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permittivity.g.cs @@ -217,7 +217,6 @@ public static Permittivity FromFaradsPerMeter(double faradspermeter) return new Permittivity(value, PermittivityUnit.FaradPerMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Power.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Power.g.cs index 234727e48d..988319028f 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Power.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Power.g.cs @@ -357,7 +357,6 @@ public static Power FromBoilerHorsepower(double boilerhorsepower) decimal value = (decimal) boilerhorsepower; return new Power(value, PowerUnit.BoilerHorsepower); } - /// /// Creates a from . /// @@ -368,7 +367,6 @@ public static Power FromBritishThermalUnitsPerHour(double britishthermalunitsper decimal value = (decimal) britishthermalunitsperhour; return new Power(value, PowerUnit.BritishThermalUnitPerHour); } - /// /// Creates a from . /// @@ -379,7 +377,6 @@ public static Power FromDecawatts(double decawatts) decimal value = (decimal) decawatts; return new Power(value, PowerUnit.Decawatt); } - /// /// Creates a from . /// @@ -390,7 +387,6 @@ public static Power FromDeciwatts(double deciwatts) decimal value = (decimal) deciwatts; return new Power(value, PowerUnit.Deciwatt); } - /// /// Creates a from . /// @@ -401,7 +397,6 @@ public static Power FromElectricalHorsepower(double electricalhorsepower) decimal value = (decimal) electricalhorsepower; return new Power(value, PowerUnit.ElectricalHorsepower); } - /// /// Creates a from . /// @@ -412,7 +407,6 @@ public static Power FromFemtowatts(double femtowatts) decimal value = (decimal) femtowatts; return new Power(value, PowerUnit.Femtowatt); } - /// /// Creates a from . /// @@ -423,7 +417,6 @@ public static Power FromGigajoulesPerHour(double gigajoulesperhour) decimal value = (decimal) gigajoulesperhour; return new Power(value, PowerUnit.GigajoulePerHour); } - /// /// Creates a from . /// @@ -434,7 +427,6 @@ public static Power FromGigawatts(double gigawatts) decimal value = (decimal) gigawatts; return new Power(value, PowerUnit.Gigawatt); } - /// /// Creates a from . /// @@ -445,7 +437,6 @@ public static Power FromHydraulicHorsepower(double hydraulichorsepower) decimal value = (decimal) hydraulichorsepower; return new Power(value, PowerUnit.HydraulicHorsepower); } - /// /// Creates a from . /// @@ -456,7 +447,6 @@ public static Power FromJoulesPerHour(double joulesperhour) decimal value = (decimal) joulesperhour; return new Power(value, PowerUnit.JoulePerHour); } - /// /// Creates a from . /// @@ -467,7 +457,6 @@ public static Power FromKilobritishThermalUnitsPerHour(double kilobritishthermal decimal value = (decimal) kilobritishthermalunitsperhour; return new Power(value, PowerUnit.KilobritishThermalUnitPerHour); } - /// /// Creates a from . /// @@ -478,7 +467,6 @@ public static Power FromKilojoulesPerHour(double kilojoulesperhour) decimal value = (decimal) kilojoulesperhour; return new Power(value, PowerUnit.KilojoulePerHour); } - /// /// Creates a from . /// @@ -489,7 +477,6 @@ public static Power FromKilowatts(double kilowatts) decimal value = (decimal) kilowatts; return new Power(value, PowerUnit.Kilowatt); } - /// /// Creates a from . /// @@ -500,7 +487,6 @@ public static Power FromMechanicalHorsepower(double mechanicalhorsepower) decimal value = (decimal) mechanicalhorsepower; return new Power(value, PowerUnit.MechanicalHorsepower); } - /// /// Creates a from . /// @@ -511,7 +497,6 @@ public static Power FromMegajoulesPerHour(double megajoulesperhour) decimal value = (decimal) megajoulesperhour; return new Power(value, PowerUnit.MegajoulePerHour); } - /// /// Creates a from . /// @@ -522,7 +507,6 @@ public static Power FromMegawatts(double megawatts) decimal value = (decimal) megawatts; return new Power(value, PowerUnit.Megawatt); } - /// /// Creates a from . /// @@ -533,7 +517,6 @@ public static Power FromMetricHorsepower(double metrichorsepower) decimal value = (decimal) metrichorsepower; return new Power(value, PowerUnit.MetricHorsepower); } - /// /// Creates a from . /// @@ -544,7 +527,6 @@ public static Power FromMicrowatts(double microwatts) decimal value = (decimal) microwatts; return new Power(value, PowerUnit.Microwatt); } - /// /// Creates a from . /// @@ -555,7 +537,6 @@ public static Power FromMillijoulesPerHour(double millijoulesperhour) decimal value = (decimal) millijoulesperhour; return new Power(value, PowerUnit.MillijoulePerHour); } - /// /// Creates a from . /// @@ -566,7 +547,6 @@ public static Power FromMilliwatts(double milliwatts) decimal value = (decimal) milliwatts; return new Power(value, PowerUnit.Milliwatt); } - /// /// Creates a from . /// @@ -577,7 +557,6 @@ public static Power FromNanowatts(double nanowatts) decimal value = (decimal) nanowatts; return new Power(value, PowerUnit.Nanowatt); } - /// /// Creates a from . /// @@ -588,7 +567,6 @@ public static Power FromPetawatts(double petawatts) decimal value = (decimal) petawatts; return new Power(value, PowerUnit.Petawatt); } - /// /// Creates a from . /// @@ -599,7 +577,6 @@ public static Power FromPicowatts(double picowatts) decimal value = (decimal) picowatts; return new Power(value, PowerUnit.Picowatt); } - /// /// Creates a from . /// @@ -610,7 +587,6 @@ public static Power FromTerawatts(double terawatts) decimal value = (decimal) terawatts; return new Power(value, PowerUnit.Terawatt); } - /// /// Creates a from . /// @@ -622,7 +598,6 @@ public static Power FromWatts(double watts) return new Power(value, PowerUnit.Watt); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerDensity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerDensity.g.cs index 648746e15a..08cecdb668 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerDensity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerDensity.g.cs @@ -471,7 +471,6 @@ public static PowerDensity FromDecawattsPerCubicFoot(double decawattspercubicfoo double value = (double) decawattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.DecawattPerCubicFoot); } - /// /// Creates a from . /// @@ -482,7 +481,6 @@ public static PowerDensity FromDecawattsPerCubicInch(double decawattspercubicinc double value = (double) decawattspercubicinch; return new PowerDensity(value, PowerDensityUnit.DecawattPerCubicInch); } - /// /// Creates a from . /// @@ -493,7 +491,6 @@ public static PowerDensity FromDecawattsPerCubicMeter(double decawattspercubicme double value = (double) decawattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.DecawattPerCubicMeter); } - /// /// Creates a from . /// @@ -504,7 +501,6 @@ public static PowerDensity FromDecawattsPerLiter(double decawattsperliter) double value = (double) decawattsperliter; return new PowerDensity(value, PowerDensityUnit.DecawattPerLiter); } - /// /// Creates a from . /// @@ -515,7 +511,6 @@ public static PowerDensity FromDeciwattsPerCubicFoot(double deciwattspercubicfoo double value = (double) deciwattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.DeciwattPerCubicFoot); } - /// /// Creates a from . /// @@ -526,7 +521,6 @@ public static PowerDensity FromDeciwattsPerCubicInch(double deciwattspercubicinc double value = (double) deciwattspercubicinch; return new PowerDensity(value, PowerDensityUnit.DeciwattPerCubicInch); } - /// /// Creates a from . /// @@ -537,7 +531,6 @@ public static PowerDensity FromDeciwattsPerCubicMeter(double deciwattspercubicme double value = (double) deciwattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.DeciwattPerCubicMeter); } - /// /// Creates a from . /// @@ -548,7 +541,6 @@ public static PowerDensity FromDeciwattsPerLiter(double deciwattsperliter) double value = (double) deciwattsperliter; return new PowerDensity(value, PowerDensityUnit.DeciwattPerLiter); } - /// /// Creates a from . /// @@ -559,7 +551,6 @@ public static PowerDensity FromGigawattsPerCubicFoot(double gigawattspercubicfoo double value = (double) gigawattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.GigawattPerCubicFoot); } - /// /// Creates a from . /// @@ -570,7 +561,6 @@ public static PowerDensity FromGigawattsPerCubicInch(double gigawattspercubicinc double value = (double) gigawattspercubicinch; return new PowerDensity(value, PowerDensityUnit.GigawattPerCubicInch); } - /// /// Creates a from . /// @@ -581,7 +571,6 @@ public static PowerDensity FromGigawattsPerCubicMeter(double gigawattspercubicme double value = (double) gigawattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.GigawattPerCubicMeter); } - /// /// Creates a from . /// @@ -592,7 +581,6 @@ public static PowerDensity FromGigawattsPerLiter(double gigawattsperliter) double value = (double) gigawattsperliter; return new PowerDensity(value, PowerDensityUnit.GigawattPerLiter); } - /// /// Creates a from . /// @@ -603,7 +591,6 @@ public static PowerDensity FromKilowattsPerCubicFoot(double kilowattspercubicfoo double value = (double) kilowattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.KilowattPerCubicFoot); } - /// /// Creates a from . /// @@ -614,7 +601,6 @@ public static PowerDensity FromKilowattsPerCubicInch(double kilowattspercubicinc double value = (double) kilowattspercubicinch; return new PowerDensity(value, PowerDensityUnit.KilowattPerCubicInch); } - /// /// Creates a from . /// @@ -625,7 +611,6 @@ public static PowerDensity FromKilowattsPerCubicMeter(double kilowattspercubicme double value = (double) kilowattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.KilowattPerCubicMeter); } - /// /// Creates a from . /// @@ -636,7 +621,6 @@ public static PowerDensity FromKilowattsPerLiter(double kilowattsperliter) double value = (double) kilowattsperliter; return new PowerDensity(value, PowerDensityUnit.KilowattPerLiter); } - /// /// Creates a from . /// @@ -647,7 +631,6 @@ public static PowerDensity FromMegawattsPerCubicFoot(double megawattspercubicfoo double value = (double) megawattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.MegawattPerCubicFoot); } - /// /// Creates a from . /// @@ -658,7 +641,6 @@ public static PowerDensity FromMegawattsPerCubicInch(double megawattspercubicinc double value = (double) megawattspercubicinch; return new PowerDensity(value, PowerDensityUnit.MegawattPerCubicInch); } - /// /// Creates a from . /// @@ -669,7 +651,6 @@ public static PowerDensity FromMegawattsPerCubicMeter(double megawattspercubicme double value = (double) megawattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.MegawattPerCubicMeter); } - /// /// Creates a from . /// @@ -680,7 +661,6 @@ public static PowerDensity FromMegawattsPerLiter(double megawattsperliter) double value = (double) megawattsperliter; return new PowerDensity(value, PowerDensityUnit.MegawattPerLiter); } - /// /// Creates a from . /// @@ -691,7 +671,6 @@ public static PowerDensity FromMicrowattsPerCubicFoot(double microwattspercubicf double value = (double) microwattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.MicrowattPerCubicFoot); } - /// /// Creates a from . /// @@ -702,7 +681,6 @@ public static PowerDensity FromMicrowattsPerCubicInch(double microwattspercubici double value = (double) microwattspercubicinch; return new PowerDensity(value, PowerDensityUnit.MicrowattPerCubicInch); } - /// /// Creates a from . /// @@ -713,7 +691,6 @@ public static PowerDensity FromMicrowattsPerCubicMeter(double microwattspercubic double value = (double) microwattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.MicrowattPerCubicMeter); } - /// /// Creates a from . /// @@ -724,7 +701,6 @@ public static PowerDensity FromMicrowattsPerLiter(double microwattsperliter) double value = (double) microwattsperliter; return new PowerDensity(value, PowerDensityUnit.MicrowattPerLiter); } - /// /// Creates a from . /// @@ -735,7 +711,6 @@ public static PowerDensity FromMilliwattsPerCubicFoot(double milliwattspercubicf double value = (double) milliwattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.MilliwattPerCubicFoot); } - /// /// Creates a from . /// @@ -746,7 +721,6 @@ public static PowerDensity FromMilliwattsPerCubicInch(double milliwattspercubici double value = (double) milliwattspercubicinch; return new PowerDensity(value, PowerDensityUnit.MilliwattPerCubicInch); } - /// /// Creates a from . /// @@ -757,7 +731,6 @@ public static PowerDensity FromMilliwattsPerCubicMeter(double milliwattspercubic double value = (double) milliwattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.MilliwattPerCubicMeter); } - /// /// Creates a from . /// @@ -768,7 +741,6 @@ public static PowerDensity FromMilliwattsPerLiter(double milliwattsperliter) double value = (double) milliwattsperliter; return new PowerDensity(value, PowerDensityUnit.MilliwattPerLiter); } - /// /// Creates a from . /// @@ -779,7 +751,6 @@ public static PowerDensity FromNanowattsPerCubicFoot(double nanowattspercubicfoo double value = (double) nanowattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.NanowattPerCubicFoot); } - /// /// Creates a from . /// @@ -790,7 +761,6 @@ public static PowerDensity FromNanowattsPerCubicInch(double nanowattspercubicinc double value = (double) nanowattspercubicinch; return new PowerDensity(value, PowerDensityUnit.NanowattPerCubicInch); } - /// /// Creates a from . /// @@ -801,7 +771,6 @@ public static PowerDensity FromNanowattsPerCubicMeter(double nanowattspercubicme double value = (double) nanowattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.NanowattPerCubicMeter); } - /// /// Creates a from . /// @@ -812,7 +781,6 @@ public static PowerDensity FromNanowattsPerLiter(double nanowattsperliter) double value = (double) nanowattsperliter; return new PowerDensity(value, PowerDensityUnit.NanowattPerLiter); } - /// /// Creates a from . /// @@ -823,7 +791,6 @@ public static PowerDensity FromPicowattsPerCubicFoot(double picowattspercubicfoo double value = (double) picowattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.PicowattPerCubicFoot); } - /// /// Creates a from . /// @@ -834,7 +801,6 @@ public static PowerDensity FromPicowattsPerCubicInch(double picowattspercubicinc double value = (double) picowattspercubicinch; return new PowerDensity(value, PowerDensityUnit.PicowattPerCubicInch); } - /// /// Creates a from . /// @@ -845,7 +811,6 @@ public static PowerDensity FromPicowattsPerCubicMeter(double picowattspercubicme double value = (double) picowattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.PicowattPerCubicMeter); } - /// /// Creates a from . /// @@ -856,7 +821,6 @@ public static PowerDensity FromPicowattsPerLiter(double picowattsperliter) double value = (double) picowattsperliter; return new PowerDensity(value, PowerDensityUnit.PicowattPerLiter); } - /// /// Creates a from . /// @@ -867,7 +831,6 @@ public static PowerDensity FromTerawattsPerCubicFoot(double terawattspercubicfoo double value = (double) terawattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.TerawattPerCubicFoot); } - /// /// Creates a from . /// @@ -878,7 +841,6 @@ public static PowerDensity FromTerawattsPerCubicInch(double terawattspercubicinc double value = (double) terawattspercubicinch; return new PowerDensity(value, PowerDensityUnit.TerawattPerCubicInch); } - /// /// Creates a from . /// @@ -889,7 +851,6 @@ public static PowerDensity FromTerawattsPerCubicMeter(double terawattspercubicme double value = (double) terawattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.TerawattPerCubicMeter); } - /// /// Creates a from . /// @@ -900,7 +861,6 @@ public static PowerDensity FromTerawattsPerLiter(double terawattsperliter) double value = (double) terawattsperliter; return new PowerDensity(value, PowerDensityUnit.TerawattPerLiter); } - /// /// Creates a from . /// @@ -911,7 +871,6 @@ public static PowerDensity FromWattsPerCubicFoot(double wattspercubicfoot) double value = (double) wattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.WattPerCubicFoot); } - /// /// Creates a from . /// @@ -922,7 +881,6 @@ public static PowerDensity FromWattsPerCubicInch(double wattspercubicinch) double value = (double) wattspercubicinch; return new PowerDensity(value, PowerDensityUnit.WattPerCubicInch); } - /// /// Creates a from . /// @@ -933,7 +891,6 @@ public static PowerDensity FromWattsPerCubicMeter(double wattspercubicmeter) double value = (double) wattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.WattPerCubicMeter); } - /// /// Creates a from . /// @@ -945,7 +902,6 @@ public static PowerDensity FromWattsPerLiter(double wattsperliter) return new PowerDensity(value, PowerDensityUnit.WattPerLiter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerRatio.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerRatio.g.cs index 1100cfe26e..07a9ae8f8b 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerRatio.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerRatio.g.cs @@ -219,7 +219,6 @@ public static PowerRatio FromDecibelMilliwatts(double decibelmilliwatts) double value = (double) decibelmilliwatts; return new PowerRatio(value, PowerRatioUnit.DecibelMilliwatt); } - /// /// Creates a from . /// @@ -231,7 +230,6 @@ public static PowerRatio FromDecibelWatts(double decibelwatts) return new PowerRatio(value, PowerRatioUnit.DecibelWatt); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Pressure.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Pressure.g.cs index 37436b45f7..9681deed0d 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Pressure.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Pressure.g.cs @@ -508,7 +508,6 @@ public static Pressure FromAtmospheres(double atmospheres) double value = (double) atmospheres; return new Pressure(value, PressureUnit.Atmosphere); } - /// /// Creates a from . /// @@ -519,7 +518,6 @@ public static Pressure FromBars(double bars) double value = (double) bars; return new Pressure(value, PressureUnit.Bar); } - /// /// Creates a from . /// @@ -530,7 +528,6 @@ public static Pressure FromCentibars(double centibars) double value = (double) centibars; return new Pressure(value, PressureUnit.Centibar); } - /// /// Creates a from . /// @@ -541,7 +538,6 @@ public static Pressure FromDecapascals(double decapascals) double value = (double) decapascals; return new Pressure(value, PressureUnit.Decapascal); } - /// /// Creates a from . /// @@ -552,7 +548,6 @@ public static Pressure FromDecibars(double decibars) double value = (double) decibars; return new Pressure(value, PressureUnit.Decibar); } - /// /// Creates a from . /// @@ -563,7 +558,6 @@ public static Pressure FromDynesPerSquareCentimeter(double dynespersquarecentime double value = (double) dynespersquarecentimeter; return new Pressure(value, PressureUnit.DynePerSquareCentimeter); } - /// /// Creates a from . /// @@ -574,7 +568,6 @@ public static Pressure FromFeetOfElevation(double feetofelevation) double value = (double) feetofelevation; return new Pressure(value, PressureUnit.FootOfElevation); } - /// /// Creates a from . /// @@ -585,7 +578,6 @@ public static Pressure FromFeetOfHead(double feetofhead) double value = (double) feetofhead; return new Pressure(value, PressureUnit.FootOfHead); } - /// /// Creates a from . /// @@ -596,7 +588,6 @@ public static Pressure FromGigapascals(double gigapascals) double value = (double) gigapascals; return new Pressure(value, PressureUnit.Gigapascal); } - /// /// Creates a from . /// @@ -607,7 +598,6 @@ public static Pressure FromHectopascals(double hectopascals) double value = (double) hectopascals; return new Pressure(value, PressureUnit.Hectopascal); } - /// /// Creates a from . /// @@ -618,7 +608,6 @@ public static Pressure FromInchesOfMercury(double inchesofmercury) double value = (double) inchesofmercury; return new Pressure(value, PressureUnit.InchOfMercury); } - /// /// Creates a from . /// @@ -629,7 +618,6 @@ public static Pressure FromInchesOfWaterColumn(double inchesofwatercolumn) double value = (double) inchesofwatercolumn; return new Pressure(value, PressureUnit.InchOfWaterColumn); } - /// /// Creates a from . /// @@ -640,7 +628,6 @@ public static Pressure FromKilobars(double kilobars) double value = (double) kilobars; return new Pressure(value, PressureUnit.Kilobar); } - /// /// Creates a from . /// @@ -651,7 +638,6 @@ public static Pressure FromKilogramsForcePerSquareCentimeter(double kilogramsfor double value = (double) kilogramsforcepersquarecentimeter; return new Pressure(value, PressureUnit.KilogramForcePerSquareCentimeter); } - /// /// Creates a from . /// @@ -662,7 +648,6 @@ public static Pressure FromKilogramsForcePerSquareMeter(double kilogramsforceper double value = (double) kilogramsforcepersquaremeter; return new Pressure(value, PressureUnit.KilogramForcePerSquareMeter); } - /// /// Creates a from . /// @@ -673,7 +658,6 @@ public static Pressure FromKilogramsForcePerSquareMillimeter(double kilogramsfor double value = (double) kilogramsforcepersquaremillimeter; return new Pressure(value, PressureUnit.KilogramForcePerSquareMillimeter); } - /// /// Creates a from . /// @@ -684,7 +668,6 @@ public static Pressure FromKilonewtonsPerSquareCentimeter(double kilonewtonspers double value = (double) kilonewtonspersquarecentimeter; return new Pressure(value, PressureUnit.KilonewtonPerSquareCentimeter); } - /// /// Creates a from . /// @@ -695,7 +678,6 @@ public static Pressure FromKilonewtonsPerSquareMeter(double kilonewtonspersquare double value = (double) kilonewtonspersquaremeter; return new Pressure(value, PressureUnit.KilonewtonPerSquareMeter); } - /// /// Creates a from . /// @@ -706,7 +688,6 @@ public static Pressure FromKilonewtonsPerSquareMillimeter(double kilonewtonspers double value = (double) kilonewtonspersquaremillimeter; return new Pressure(value, PressureUnit.KilonewtonPerSquareMillimeter); } - /// /// Creates a from . /// @@ -717,7 +698,6 @@ public static Pressure FromKilopascals(double kilopascals) double value = (double) kilopascals; return new Pressure(value, PressureUnit.Kilopascal); } - /// /// Creates a from . /// @@ -728,7 +708,6 @@ public static Pressure FromKilopoundsForcePerSquareFoot(double kilopoundsforcepe double value = (double) kilopoundsforcepersquarefoot; return new Pressure(value, PressureUnit.KilopoundForcePerSquareFoot); } - /// /// Creates a from . /// @@ -739,7 +718,6 @@ public static Pressure FromKilopoundsForcePerSquareInch(double kilopoundsforcepe double value = (double) kilopoundsforcepersquareinch; return new Pressure(value, PressureUnit.KilopoundForcePerSquareInch); } - /// /// Creates a from . /// @@ -750,7 +728,6 @@ public static Pressure FromMegabars(double megabars) double value = (double) megabars; return new Pressure(value, PressureUnit.Megabar); } - /// /// Creates a from . /// @@ -761,7 +738,6 @@ public static Pressure FromMeganewtonsPerSquareMeter(double meganewtonspersquare double value = (double) meganewtonspersquaremeter; return new Pressure(value, PressureUnit.MeganewtonPerSquareMeter); } - /// /// Creates a from . /// @@ -772,7 +748,6 @@ public static Pressure FromMegapascals(double megapascals) double value = (double) megapascals; return new Pressure(value, PressureUnit.Megapascal); } - /// /// Creates a from . /// @@ -783,7 +758,6 @@ public static Pressure FromMetersOfElevation(double metersofelevation) double value = (double) metersofelevation; return new Pressure(value, PressureUnit.MeterOfElevation); } - /// /// Creates a from . /// @@ -794,7 +768,6 @@ public static Pressure FromMetersOfHead(double metersofhead) double value = (double) metersofhead; return new Pressure(value, PressureUnit.MeterOfHead); } - /// /// Creates a from . /// @@ -805,7 +778,6 @@ public static Pressure FromMicrobars(double microbars) double value = (double) microbars; return new Pressure(value, PressureUnit.Microbar); } - /// /// Creates a from . /// @@ -816,7 +788,6 @@ public static Pressure FromMicropascals(double micropascals) double value = (double) micropascals; return new Pressure(value, PressureUnit.Micropascal); } - /// /// Creates a from . /// @@ -827,7 +798,6 @@ public static Pressure FromMillibars(double millibars) double value = (double) millibars; return new Pressure(value, PressureUnit.Millibar); } - /// /// Creates a from . /// @@ -838,7 +808,6 @@ public static Pressure FromMillimetersOfMercury(double millimetersofmercury) double value = (double) millimetersofmercury; return new Pressure(value, PressureUnit.MillimeterOfMercury); } - /// /// Creates a from . /// @@ -849,7 +818,6 @@ public static Pressure FromMillimeterOfWaterColumn(double millimeterofwatercolum double value = (double) millimeterofwatercolumn; return new Pressure(value, PressureUnit.MillimeterOfWaterColumn); } - /// /// Creates a from . /// @@ -860,7 +828,6 @@ public static Pressure FromMillipascals(double millipascals) double value = (double) millipascals; return new Pressure(value, PressureUnit.Millipascal); } - /// /// Creates a from . /// @@ -871,7 +838,6 @@ public static Pressure FromNewtonsPerSquareCentimeter(double newtonspersquarecen double value = (double) newtonspersquarecentimeter; return new Pressure(value, PressureUnit.NewtonPerSquareCentimeter); } - /// /// Creates a from . /// @@ -882,7 +848,6 @@ public static Pressure FromNewtonsPerSquareMeter(double newtonspersquaremeter) double value = (double) newtonspersquaremeter; return new Pressure(value, PressureUnit.NewtonPerSquareMeter); } - /// /// Creates a from . /// @@ -893,7 +858,6 @@ public static Pressure FromNewtonsPerSquareMillimeter(double newtonspersquaremil double value = (double) newtonspersquaremillimeter; return new Pressure(value, PressureUnit.NewtonPerSquareMillimeter); } - /// /// Creates a from . /// @@ -904,7 +868,6 @@ public static Pressure FromPascals(double pascals) double value = (double) pascals; return new Pressure(value, PressureUnit.Pascal); } - /// /// Creates a from . /// @@ -915,7 +878,6 @@ public static Pressure FromPoundsForcePerSquareFoot(double poundsforcepersquaref double value = (double) poundsforcepersquarefoot; return new Pressure(value, PressureUnit.PoundForcePerSquareFoot); } - /// /// Creates a from . /// @@ -926,7 +888,6 @@ public static Pressure FromPoundsForcePerSquareInch(double poundsforcepersquarei double value = (double) poundsforcepersquareinch; return new Pressure(value, PressureUnit.PoundForcePerSquareInch); } - /// /// Creates a from . /// @@ -937,7 +898,6 @@ public static Pressure FromPoundsPerInchSecondSquared(double poundsperinchsecond double value = (double) poundsperinchsecondsquared; return new Pressure(value, PressureUnit.PoundPerInchSecondSquared); } - /// /// Creates a from . /// @@ -948,7 +908,6 @@ public static Pressure FromTechnicalAtmospheres(double technicalatmospheres) double value = (double) technicalatmospheres; return new Pressure(value, PressureUnit.TechnicalAtmosphere); } - /// /// Creates a from . /// @@ -959,7 +918,6 @@ public static Pressure FromTonnesForcePerSquareCentimeter(double tonnesforcepers double value = (double) tonnesforcepersquarecentimeter; return new Pressure(value, PressureUnit.TonneForcePerSquareCentimeter); } - /// /// Creates a from . /// @@ -970,7 +928,6 @@ public static Pressure FromTonnesForcePerSquareMeter(double tonnesforcepersquare double value = (double) tonnesforcepersquaremeter; return new Pressure(value, PressureUnit.TonneForcePerSquareMeter); } - /// /// Creates a from . /// @@ -981,7 +938,6 @@ public static Pressure FromTonnesForcePerSquareMillimeter(double tonnesforcepers double value = (double) tonnesforcepersquaremillimeter; return new Pressure(value, PressureUnit.TonneForcePerSquareMillimeter); } - /// /// Creates a from . /// @@ -993,7 +949,6 @@ public static Pressure FromTorrs(double torrs) return new Pressure(value, PressureUnit.Torr); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PressureChangeRate.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PressureChangeRate.g.cs index cd7a2a46b4..8ca8770ee4 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PressureChangeRate.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PressureChangeRate.g.cs @@ -305,7 +305,6 @@ public static PressureChangeRate FromAtmospheresPerSecond(double atmospherespers double value = (double) atmospherespersecond; return new PressureChangeRate(value, PressureChangeRateUnit.AtmospherePerSecond); } - /// /// Creates a from . /// @@ -316,7 +315,6 @@ public static PressureChangeRate FromKilopascalsPerMinute(double kilopascalsperm double value = (double) kilopascalsperminute; return new PressureChangeRate(value, PressureChangeRateUnit.KilopascalPerMinute); } - /// /// Creates a from . /// @@ -327,7 +325,6 @@ public static PressureChangeRate FromKilopascalsPerSecond(double kilopascalspers double value = (double) kilopascalspersecond; return new PressureChangeRate(value, PressureChangeRateUnit.KilopascalPerSecond); } - /// /// Creates a from . /// @@ -338,7 +335,6 @@ public static PressureChangeRate FromKilopoundsForcePerSquareInchPerMinute(doubl double value = (double) kilopoundsforcepersquareinchperminute; return new PressureChangeRate(value, PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute); } - /// /// Creates a from . /// @@ -349,7 +345,6 @@ public static PressureChangeRate FromKilopoundsForcePerSquareInchPerSecond(doubl double value = (double) kilopoundsforcepersquareinchpersecond; return new PressureChangeRate(value, PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond); } - /// /// Creates a from . /// @@ -360,7 +355,6 @@ public static PressureChangeRate FromMegapascalsPerMinute(double megapascalsperm double value = (double) megapascalsperminute; return new PressureChangeRate(value, PressureChangeRateUnit.MegapascalPerMinute); } - /// /// Creates a from . /// @@ -371,7 +365,6 @@ public static PressureChangeRate FromMegapascalsPerSecond(double megapascalspers double value = (double) megapascalspersecond; return new PressureChangeRate(value, PressureChangeRateUnit.MegapascalPerSecond); } - /// /// Creates a from . /// @@ -382,7 +375,6 @@ public static PressureChangeRate FromMegapoundsForcePerSquareInchPerMinute(doubl double value = (double) megapoundsforcepersquareinchperminute; return new PressureChangeRate(value, PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute); } - /// /// Creates a from . /// @@ -393,7 +385,6 @@ public static PressureChangeRate FromMegapoundsForcePerSquareInchPerSecond(doubl double value = (double) megapoundsforcepersquareinchpersecond; return new PressureChangeRate(value, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond); } - /// /// Creates a from . /// @@ -404,7 +395,6 @@ public static PressureChangeRate FromMillimetersOfMercuryPerSecond(double millim double value = (double) millimetersofmercurypersecond; return new PressureChangeRate(value, PressureChangeRateUnit.MillimeterOfMercuryPerSecond); } - /// /// Creates a from . /// @@ -415,7 +405,6 @@ public static PressureChangeRate FromPascalsPerMinute(double pascalsperminute) double value = (double) pascalsperminute; return new PressureChangeRate(value, PressureChangeRateUnit.PascalPerMinute); } - /// /// Creates a from . /// @@ -426,7 +415,6 @@ public static PressureChangeRate FromPascalsPerSecond(double pascalspersecond) double value = (double) pascalspersecond; return new PressureChangeRate(value, PressureChangeRateUnit.PascalPerSecond); } - /// /// Creates a from . /// @@ -437,7 +425,6 @@ public static PressureChangeRate FromPoundsForcePerSquareInchPerMinute(double po double value = (double) poundsforcepersquareinchperminute; return new PressureChangeRate(value, PressureChangeRateUnit.PoundForcePerSquareInchPerMinute); } - /// /// Creates a from . /// @@ -449,7 +436,6 @@ public static PressureChangeRate FromPoundsForcePerSquareInchPerSecond(double po return new PressureChangeRate(value, PressureChangeRateUnit.PoundForcePerSquareInchPerSecond); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Ratio.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Ratio.g.cs index 12b5561177..d20bb01e3f 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Ratio.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Ratio.g.cs @@ -243,7 +243,6 @@ public static Ratio FromDecimalFractions(double decimalfractions) double value = (double) decimalfractions; return new Ratio(value, RatioUnit.DecimalFraction); } - /// /// Creates a from . /// @@ -254,7 +253,6 @@ public static Ratio FromPartsPerBillion(double partsperbillion) double value = (double) partsperbillion; return new Ratio(value, RatioUnit.PartPerBillion); } - /// /// Creates a from . /// @@ -265,7 +263,6 @@ public static Ratio FromPartsPerMillion(double partspermillion) double value = (double) partspermillion; return new Ratio(value, RatioUnit.PartPerMillion); } - /// /// Creates a from . /// @@ -276,7 +273,6 @@ public static Ratio FromPartsPerThousand(double partsperthousand) double value = (double) partsperthousand; return new Ratio(value, RatioUnit.PartPerThousand); } - /// /// Creates a from . /// @@ -287,7 +283,6 @@ public static Ratio FromPartsPerTrillion(double partspertrillion) double value = (double) partspertrillion; return new Ratio(value, RatioUnit.PartPerTrillion); } - /// /// Creates a from . /// @@ -299,7 +294,6 @@ public static Ratio FromPercent(double percent) return new Ratio(value, RatioUnit.Percent); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RatioChangeRate.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RatioChangeRate.g.cs index c4ddc4c301..5c65e3f2bc 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RatioChangeRate.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RatioChangeRate.g.cs @@ -219,7 +219,6 @@ public static RatioChangeRate FromDecimalFractionsPerSecond(double decimalfracti double value = (double) decimalfractionspersecond; return new RatioChangeRate(value, RatioChangeRateUnit.DecimalFractionPerSecond); } - /// /// Creates a from . /// @@ -231,7 +230,6 @@ public static RatioChangeRate FromPercentsPerSecond(double percentspersecond) return new RatioChangeRate(value, RatioChangeRateUnit.PercentPerSecond); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactiveEnergy.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactiveEnergy.g.cs index 66a864f189..5d92544122 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactiveEnergy.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactiveEnergy.g.cs @@ -225,7 +225,6 @@ public static ReactiveEnergy FromKilovoltampereReactiveHours(double kilovoltampe double value = (double) kilovoltamperereactivehours; return new ReactiveEnergy(value, ReactiveEnergyUnit.KilovoltampereReactiveHour); } - /// /// Creates a from . /// @@ -236,7 +235,6 @@ public static ReactiveEnergy FromMegavoltampereReactiveHours(double megavoltampe double value = (double) megavoltamperereactivehours; return new ReactiveEnergy(value, ReactiveEnergyUnit.MegavoltampereReactiveHour); } - /// /// Creates a from . /// @@ -248,7 +246,6 @@ public static ReactiveEnergy FromVoltampereReactiveHours(double voltamperereacti return new ReactiveEnergy(value, ReactiveEnergyUnit.VoltampereReactiveHour); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactivePower.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactivePower.g.cs index 63a2e368eb..99a1440808 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactivePower.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactivePower.g.cs @@ -231,7 +231,6 @@ public static ReactivePower FromGigavoltamperesReactive(double gigavoltamperesre double value = (double) gigavoltamperesreactive; return new ReactivePower(value, ReactivePowerUnit.GigavoltampereReactive); } - /// /// Creates a from . /// @@ -242,7 +241,6 @@ public static ReactivePower FromKilovoltamperesReactive(double kilovoltamperesre double value = (double) kilovoltamperesreactive; return new ReactivePower(value, ReactivePowerUnit.KilovoltampereReactive); } - /// /// Creates a from . /// @@ -253,7 +251,6 @@ public static ReactivePower FromMegavoltamperesReactive(double megavoltamperesre double value = (double) megavoltamperesreactive; return new ReactivePower(value, ReactivePowerUnit.MegavoltampereReactive); } - /// /// Creates a from . /// @@ -265,7 +262,6 @@ public static ReactivePower FromVoltamperesReactive(double voltamperesreactive) return new ReactivePower(value, ReactivePowerUnit.VoltampereReactive); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReciprocalArea.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReciprocalArea.g.cs index 432ad7a03b..7756a1c82c 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReciprocalArea.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReciprocalArea.g.cs @@ -276,7 +276,6 @@ public static ReciprocalArea FromInverseSquareCentimeters(double inversesquarece double value = (double) inversesquarecentimeters; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareCentimeter); } - /// /// Creates a from . /// @@ -287,7 +286,6 @@ public static ReciprocalArea FromInverseSquareDecimeters(double inversesquaredec double value = (double) inversesquaredecimeters; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareDecimeter); } - /// /// Creates a from . /// @@ -298,7 +296,6 @@ public static ReciprocalArea FromInverseSquareFeet(double inversesquarefeet) double value = (double) inversesquarefeet; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareFoot); } - /// /// Creates a from . /// @@ -309,7 +306,6 @@ public static ReciprocalArea FromInverseSquareInches(double inversesquareinches) double value = (double) inversesquareinches; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareInch); } - /// /// Creates a from . /// @@ -320,7 +316,6 @@ public static ReciprocalArea FromInverseSquareKilometers(double inversesquarekil double value = (double) inversesquarekilometers; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareKilometer); } - /// /// Creates a from . /// @@ -331,7 +326,6 @@ public static ReciprocalArea FromInverseSquareMeters(double inversesquaremeters) double value = (double) inversesquaremeters; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMeter); } - /// /// Creates a from . /// @@ -342,7 +336,6 @@ public static ReciprocalArea FromInverseSquareMicrometers(double inversesquaremi double value = (double) inversesquaremicrometers; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMicrometer); } - /// /// Creates a from . /// @@ -353,7 +346,6 @@ public static ReciprocalArea FromInverseSquareMiles(double inversesquaremiles) double value = (double) inversesquaremiles; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMile); } - /// /// Creates a from . /// @@ -364,7 +356,6 @@ public static ReciprocalArea FromInverseSquareMillimeters(double inversesquaremi double value = (double) inversesquaremillimeters; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMillimeter); } - /// /// Creates a from . /// @@ -375,7 +366,6 @@ public static ReciprocalArea FromInverseSquareYards(double inversesquareyards) double value = (double) inversesquareyards; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareYard); } - /// /// Creates a from . /// @@ -387,7 +377,6 @@ public static ReciprocalArea FromInverseUsSurveySquareFeet(double inverseussurve return new ReciprocalArea(value, ReciprocalAreaUnit.InverseUsSurveySquareFoot); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReciprocalLength.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReciprocalLength.g.cs index e787fc4be0..c50a973ec0 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReciprocalLength.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReciprocalLength.g.cs @@ -270,7 +270,6 @@ public static ReciprocalLength FromInverseCentimeters(double inversecentimeters) double value = (double) inversecentimeters; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseCentimeter); } - /// /// Creates a from . /// @@ -281,7 +280,6 @@ public static ReciprocalLength FromInverseFeet(double inversefeet) double value = (double) inversefeet; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseFoot); } - /// /// Creates a from . /// @@ -292,7 +290,6 @@ public static ReciprocalLength FromInverseInches(double inverseinches) double value = (double) inverseinches; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseInch); } - /// /// Creates a from . /// @@ -303,7 +300,6 @@ public static ReciprocalLength FromInverseMeters(double inversemeters) double value = (double) inversemeters; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMeter); } - /// /// Creates a from . /// @@ -314,7 +310,6 @@ public static ReciprocalLength FromInverseMicroinches(double inversemicroinches) double value = (double) inversemicroinches; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMicroinch); } - /// /// Creates a from . /// @@ -325,7 +320,6 @@ public static ReciprocalLength FromInverseMils(double inversemils) double value = (double) inversemils; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMil); } - /// /// Creates a from . /// @@ -336,7 +330,6 @@ public static ReciprocalLength FromInverseMiles(double inversemiles) double value = (double) inversemiles; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMile); } - /// /// Creates a from . /// @@ -347,7 +340,6 @@ public static ReciprocalLength FromInverseMillimeters(double inversemillimeters) double value = (double) inversemillimeters; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMillimeter); } - /// /// Creates a from . /// @@ -358,7 +350,6 @@ public static ReciprocalLength FromInverseUsSurveyFeet(double inverseussurveyfee double value = (double) inverseussurveyfeet; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseUsSurveyFoot); } - /// /// Creates a from . /// @@ -370,7 +361,6 @@ public static ReciprocalLength FromInverseYards(double inverseyards) return new ReciprocalLength(value, ReciprocalLengthUnit.InverseYard); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RelativeHumidity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RelativeHumidity.g.cs index 35eaa9d80b..062e589d67 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RelativeHumidity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RelativeHumidity.g.cs @@ -214,7 +214,6 @@ public static RelativeHumidity FromPercent(double percent) return new RelativeHumidity(value, RelativeHumidityUnit.Percent); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalAcceleration.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalAcceleration.g.cs index c4c5febbc5..9aacda5e95 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalAcceleration.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalAcceleration.g.cs @@ -231,7 +231,6 @@ public static RotationalAcceleration FromDegreesPerSecondSquared(double degreesp double value = (double) degreespersecondsquared; return new RotationalAcceleration(value, RotationalAccelerationUnit.DegreePerSecondSquared); } - /// /// Creates a from . /// @@ -242,7 +241,6 @@ public static RotationalAcceleration FromRadiansPerSecondSquared(double radiansp double value = (double) radianspersecondsquared; return new RotationalAcceleration(value, RotationalAccelerationUnit.RadianPerSecondSquared); } - /// /// Creates a from . /// @@ -253,7 +251,6 @@ public static RotationalAcceleration FromRevolutionsPerMinutePerSecond(double re double value = (double) revolutionsperminutepersecond; return new RotationalAcceleration(value, RotationalAccelerationUnit.RevolutionPerMinutePerSecond); } - /// /// Creates a from . /// @@ -265,7 +262,6 @@ public static RotationalAcceleration FromRevolutionsPerSecondSquared(double revo return new RotationalAcceleration(value, RotationalAccelerationUnit.RevolutionPerSecondSquared); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalSpeed.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalSpeed.g.cs index 2a6aba2804..962310c532 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalSpeed.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalSpeed.g.cs @@ -297,7 +297,6 @@ public static RotationalSpeed FromCentiradiansPerSecond(double centiradiansperse double value = (double) centiradianspersecond; return new RotationalSpeed(value, RotationalSpeedUnit.CentiradianPerSecond); } - /// /// Creates a from . /// @@ -308,7 +307,6 @@ public static RotationalSpeed FromDeciradiansPerSecond(double deciradiansperseco double value = (double) deciradianspersecond; return new RotationalSpeed(value, RotationalSpeedUnit.DeciradianPerSecond); } - /// /// Creates a from . /// @@ -319,7 +317,6 @@ public static RotationalSpeed FromDegreesPerMinute(double degreesperminute) double value = (double) degreesperminute; return new RotationalSpeed(value, RotationalSpeedUnit.DegreePerMinute); } - /// /// Creates a from . /// @@ -330,7 +327,6 @@ public static RotationalSpeed FromDegreesPerSecond(double degreespersecond) double value = (double) degreespersecond; return new RotationalSpeed(value, RotationalSpeedUnit.DegreePerSecond); } - /// /// Creates a from . /// @@ -341,7 +337,6 @@ public static RotationalSpeed FromMicrodegreesPerSecond(double microdegreesperse double value = (double) microdegreespersecond; return new RotationalSpeed(value, RotationalSpeedUnit.MicrodegreePerSecond); } - /// /// Creates a from . /// @@ -352,7 +347,6 @@ public static RotationalSpeed FromMicroradiansPerSecond(double microradiansperse double value = (double) microradianspersecond; return new RotationalSpeed(value, RotationalSpeedUnit.MicroradianPerSecond); } - /// /// Creates a from . /// @@ -363,7 +357,6 @@ public static RotationalSpeed FromMillidegreesPerSecond(double millidegreesperse double value = (double) millidegreespersecond; return new RotationalSpeed(value, RotationalSpeedUnit.MillidegreePerSecond); } - /// /// Creates a from . /// @@ -374,7 +367,6 @@ public static RotationalSpeed FromMilliradiansPerSecond(double milliradiansperse double value = (double) milliradianspersecond; return new RotationalSpeed(value, RotationalSpeedUnit.MilliradianPerSecond); } - /// /// Creates a from . /// @@ -385,7 +377,6 @@ public static RotationalSpeed FromNanodegreesPerSecond(double nanodegreesperseco double value = (double) nanodegreespersecond; return new RotationalSpeed(value, RotationalSpeedUnit.NanodegreePerSecond); } - /// /// Creates a from . /// @@ -396,7 +387,6 @@ public static RotationalSpeed FromNanoradiansPerSecond(double nanoradiansperseco double value = (double) nanoradianspersecond; return new RotationalSpeed(value, RotationalSpeedUnit.NanoradianPerSecond); } - /// /// Creates a from . /// @@ -407,7 +397,6 @@ public static RotationalSpeed FromRadiansPerSecond(double radianspersecond) double value = (double) radianspersecond; return new RotationalSpeed(value, RotationalSpeedUnit.RadianPerSecond); } - /// /// Creates a from . /// @@ -418,7 +407,6 @@ public static RotationalSpeed FromRevolutionsPerMinute(double revolutionsperminu double value = (double) revolutionsperminute; return new RotationalSpeed(value, RotationalSpeedUnit.RevolutionPerMinute); } - /// /// Creates a from . /// @@ -430,7 +418,6 @@ public static RotationalSpeed FromRevolutionsPerSecond(double revolutionsperseco return new RotationalSpeed(value, RotationalSpeedUnit.RevolutionPerSecond); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.g.cs index eb21e8b69e..a222be4b63 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.g.cs @@ -405,7 +405,6 @@ public static RotationalStiffness FromCentinewtonMetersPerDegree(double centinew double value = (double) centinewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.CentinewtonMeterPerDegree); } - /// /// Creates a from . /// @@ -416,7 +415,6 @@ public static RotationalStiffness FromCentinewtonMillimetersPerDegree(double cen double value = (double) centinewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.CentinewtonMillimeterPerDegree); } - /// /// Creates a from . /// @@ -427,7 +425,6 @@ public static RotationalStiffness FromCentinewtonMillimetersPerRadian(double cen double value = (double) centinewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.CentinewtonMillimeterPerRadian); } - /// /// Creates a from . /// @@ -438,7 +435,6 @@ public static RotationalStiffness FromDecanewtonMetersPerDegree(double decanewto double value = (double) decanewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.DecanewtonMeterPerDegree); } - /// /// Creates a from . /// @@ -449,7 +445,6 @@ public static RotationalStiffness FromDecanewtonMillimetersPerDegree(double deca double value = (double) decanewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.DecanewtonMillimeterPerDegree); } - /// /// Creates a from . /// @@ -460,7 +455,6 @@ public static RotationalStiffness FromDecanewtonMillimetersPerRadian(double deca double value = (double) decanewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.DecanewtonMillimeterPerRadian); } - /// /// Creates a from . /// @@ -471,7 +465,6 @@ public static RotationalStiffness FromDecinewtonMetersPerDegree(double decinewto double value = (double) decinewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.DecinewtonMeterPerDegree); } - /// /// Creates a from . /// @@ -482,7 +475,6 @@ public static RotationalStiffness FromDecinewtonMillimetersPerDegree(double deci double value = (double) decinewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.DecinewtonMillimeterPerDegree); } - /// /// Creates a from . /// @@ -493,7 +485,6 @@ public static RotationalStiffness FromDecinewtonMillimetersPerRadian(double deci double value = (double) decinewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.DecinewtonMillimeterPerRadian); } - /// /// Creates a from . /// @@ -504,7 +495,6 @@ public static RotationalStiffness FromKilonewtonMetersPerDegree(double kilonewto double value = (double) kilonewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMeterPerDegree); } - /// /// Creates a from . /// @@ -515,7 +505,6 @@ public static RotationalStiffness FromKilonewtonMetersPerRadian(double kilonewto double value = (double) kilonewtonmetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMeterPerRadian); } - /// /// Creates a from . /// @@ -526,7 +515,6 @@ public static RotationalStiffness FromKilonewtonMillimetersPerDegree(double kilo double value = (double) kilonewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMillimeterPerDegree); } - /// /// Creates a from . /// @@ -537,7 +525,6 @@ public static RotationalStiffness FromKilonewtonMillimetersPerRadian(double kilo double value = (double) kilonewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMillimeterPerRadian); } - /// /// Creates a from . /// @@ -548,7 +535,6 @@ public static RotationalStiffness FromKilopoundForceFeetPerDegrees(double kilopo double value = (double) kilopoundforcefeetperdegrees; return new RotationalStiffness(value, RotationalStiffnessUnit.KilopoundForceFootPerDegrees); } - /// /// Creates a from . /// @@ -559,7 +545,6 @@ public static RotationalStiffness FromMeganewtonMetersPerDegree(double meganewto double value = (double) meganewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMeterPerDegree); } - /// /// Creates a from . /// @@ -570,7 +555,6 @@ public static RotationalStiffness FromMeganewtonMetersPerRadian(double meganewto double value = (double) meganewtonmetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMeterPerRadian); } - /// /// Creates a from . /// @@ -581,7 +565,6 @@ public static RotationalStiffness FromMeganewtonMillimetersPerDegree(double mega double value = (double) meganewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMillimeterPerDegree); } - /// /// Creates a from . /// @@ -592,7 +575,6 @@ public static RotationalStiffness FromMeganewtonMillimetersPerRadian(double mega double value = (double) meganewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMillimeterPerRadian); } - /// /// Creates a from . /// @@ -603,7 +585,6 @@ public static RotationalStiffness FromMicronewtonMetersPerDegree(double micronew double value = (double) micronewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.MicronewtonMeterPerDegree); } - /// /// Creates a from . /// @@ -614,7 +595,6 @@ public static RotationalStiffness FromMicronewtonMillimetersPerDegree(double mic double value = (double) micronewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.MicronewtonMillimeterPerDegree); } - /// /// Creates a from . /// @@ -625,7 +605,6 @@ public static RotationalStiffness FromMicronewtonMillimetersPerRadian(double mic double value = (double) micronewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.MicronewtonMillimeterPerRadian); } - /// /// Creates a from . /// @@ -636,7 +615,6 @@ public static RotationalStiffness FromMillinewtonMetersPerDegree(double millinew double value = (double) millinewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.MillinewtonMeterPerDegree); } - /// /// Creates a from . /// @@ -647,7 +625,6 @@ public static RotationalStiffness FromMillinewtonMillimetersPerDegree(double mil double value = (double) millinewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.MillinewtonMillimeterPerDegree); } - /// /// Creates a from . /// @@ -658,7 +635,6 @@ public static RotationalStiffness FromMillinewtonMillimetersPerRadian(double mil double value = (double) millinewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.MillinewtonMillimeterPerRadian); } - /// /// Creates a from . /// @@ -669,7 +645,6 @@ public static RotationalStiffness FromNanonewtonMetersPerDegree(double nanonewto double value = (double) nanonewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.NanonewtonMeterPerDegree); } - /// /// Creates a from . /// @@ -680,7 +655,6 @@ public static RotationalStiffness FromNanonewtonMillimetersPerDegree(double nano double value = (double) nanonewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.NanonewtonMillimeterPerDegree); } - /// /// Creates a from . /// @@ -691,7 +665,6 @@ public static RotationalStiffness FromNanonewtonMillimetersPerRadian(double nano double value = (double) nanonewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.NanonewtonMillimeterPerRadian); } - /// /// Creates a from . /// @@ -702,7 +675,6 @@ public static RotationalStiffness FromNewtonMetersPerDegree(double newtonmetersp double value = (double) newtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMeterPerDegree); } - /// /// Creates a from . /// @@ -713,7 +685,6 @@ public static RotationalStiffness FromNewtonMetersPerRadian(double newtonmetersp double value = (double) newtonmetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMeterPerRadian); } - /// /// Creates a from . /// @@ -724,7 +695,6 @@ public static RotationalStiffness FromNewtonMillimetersPerDegree(double newtonmi double value = (double) newtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMillimeterPerDegree); } - /// /// Creates a from . /// @@ -735,7 +705,6 @@ public static RotationalStiffness FromNewtonMillimetersPerRadian(double newtonmi double value = (double) newtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMillimeterPerRadian); } - /// /// Creates a from . /// @@ -746,7 +715,6 @@ public static RotationalStiffness FromPoundForceFeetPerRadian(double poundforcef double value = (double) poundforcefeetperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.PoundForceFeetPerRadian); } - /// /// Creates a from . /// @@ -758,7 +726,6 @@ public static RotationalStiffness FromPoundForceFeetPerDegrees(double poundforce return new RotationalStiffness(value, RotationalStiffnessUnit.PoundForceFootPerDegrees); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs index 3ddf09ab5a..02c7d4c5fe 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs @@ -237,7 +237,6 @@ public static RotationalStiffnessPerLength FromKilonewtonMetersPerRadianPerMeter double value = (double) kilonewtonmetersperradianpermeter; return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter); } - /// /// Creates a from . /// @@ -248,7 +247,6 @@ public static RotationalStiffnessPerLength FromKilopoundForceFeetPerDegreesPerFe double value = (double) kilopoundforcefeetperdegreesperfeet; return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot); } - /// /// Creates a from . /// @@ -259,7 +257,6 @@ public static RotationalStiffnessPerLength FromMeganewtonMetersPerRadianPerMeter double value = (double) meganewtonmetersperradianpermeter; return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter); } - /// /// Creates a from . /// @@ -270,7 +267,6 @@ public static RotationalStiffnessPerLength FromNewtonMetersPerRadianPerMeter(dou double value = (double) newtonmetersperradianpermeter; return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter); } - /// /// Creates a from . /// @@ -282,7 +278,6 @@ public static RotationalStiffnessPerLength FromPoundForceFeetPerDegreesPerFeet(d return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Scalar.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Scalar.g.cs index 678e56b34d..e777cfc9de 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Scalar.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Scalar.g.cs @@ -214,7 +214,6 @@ public static Scalar FromAmount(double amount) return new Scalar(value, ScalarUnit.Amount); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SolidAngle.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SolidAngle.g.cs index ed91bd4398..f71334b801 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SolidAngle.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SolidAngle.g.cs @@ -217,7 +217,6 @@ public static SolidAngle FromSteradians(double steradians) return new SolidAngle(value, SolidAngleUnit.Steradian); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEnergy.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEnergy.g.cs index 4c58136825..5ae758e79d 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEnergy.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEnergy.g.cs @@ -360,7 +360,6 @@ public static SpecificEnergy FromBtuPerPound(double btuperpound) double value = (double) btuperpound; return new SpecificEnergy(value, SpecificEnergyUnit.BtuPerPound); } - /// /// Creates a from . /// @@ -371,7 +370,6 @@ public static SpecificEnergy FromCaloriesPerGram(double caloriespergram) double value = (double) caloriespergram; return new SpecificEnergy(value, SpecificEnergyUnit.CaloriePerGram); } - /// /// Creates a from . /// @@ -382,7 +380,6 @@ public static SpecificEnergy FromGigawattDaysPerKilogram(double gigawattdaysperk double value = (double) gigawattdaysperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.GigawattDayPerKilogram); } - /// /// Creates a from . /// @@ -393,7 +390,6 @@ public static SpecificEnergy FromGigawattDaysPerShortTon(double gigawattdayspers double value = (double) gigawattdayspershortton; return new SpecificEnergy(value, SpecificEnergyUnit.GigawattDayPerShortTon); } - /// /// Creates a from . /// @@ -404,7 +400,6 @@ public static SpecificEnergy FromGigawattDaysPerTonne(double gigawattdayspertonn double value = (double) gigawattdayspertonne; return new SpecificEnergy(value, SpecificEnergyUnit.GigawattDayPerTonne); } - /// /// Creates a from . /// @@ -415,7 +410,6 @@ public static SpecificEnergy FromGigawattHoursPerKilogram(double gigawatthourspe double value = (double) gigawatthoursperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.GigawattHourPerKilogram); } - /// /// Creates a from . /// @@ -426,7 +420,6 @@ public static SpecificEnergy FromJoulesPerKilogram(double joulesperkilogram) double value = (double) joulesperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.JoulePerKilogram); } - /// /// Creates a from . /// @@ -437,7 +430,6 @@ public static SpecificEnergy FromKilocaloriesPerGram(double kilocaloriespergram) double value = (double) kilocaloriespergram; return new SpecificEnergy(value, SpecificEnergyUnit.KilocaloriePerGram); } - /// /// Creates a from . /// @@ -448,7 +440,6 @@ public static SpecificEnergy FromKilojoulesPerKilogram(double kilojoulesperkilog double value = (double) kilojoulesperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.KilojoulePerKilogram); } - /// /// Creates a from . /// @@ -459,7 +450,6 @@ public static SpecificEnergy FromKilowattDaysPerKilogram(double kilowattdaysperk double value = (double) kilowattdaysperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.KilowattDayPerKilogram); } - /// /// Creates a from . /// @@ -470,7 +460,6 @@ public static SpecificEnergy FromKilowattDaysPerShortTon(double kilowattdayspers double value = (double) kilowattdayspershortton; return new SpecificEnergy(value, SpecificEnergyUnit.KilowattDayPerShortTon); } - /// /// Creates a from . /// @@ -481,7 +470,6 @@ public static SpecificEnergy FromKilowattDaysPerTonne(double kilowattdayspertonn double value = (double) kilowattdayspertonne; return new SpecificEnergy(value, SpecificEnergyUnit.KilowattDayPerTonne); } - /// /// Creates a from . /// @@ -492,7 +480,6 @@ public static SpecificEnergy FromKilowattHoursPerKilogram(double kilowatthourspe double value = (double) kilowatthoursperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.KilowattHourPerKilogram); } - /// /// Creates a from . /// @@ -503,7 +490,6 @@ public static SpecificEnergy FromMegajoulesPerKilogram(double megajoulesperkilog double value = (double) megajoulesperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.MegajoulePerKilogram); } - /// /// Creates a from . /// @@ -514,7 +500,6 @@ public static SpecificEnergy FromMegawattDaysPerKilogram(double megawattdaysperk double value = (double) megawattdaysperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.MegawattDayPerKilogram); } - /// /// Creates a from . /// @@ -525,7 +510,6 @@ public static SpecificEnergy FromMegawattDaysPerShortTon(double megawattdayspers double value = (double) megawattdayspershortton; return new SpecificEnergy(value, SpecificEnergyUnit.MegawattDayPerShortTon); } - /// /// Creates a from . /// @@ -536,7 +520,6 @@ public static SpecificEnergy FromMegawattDaysPerTonne(double megawattdayspertonn double value = (double) megawattdayspertonne; return new SpecificEnergy(value, SpecificEnergyUnit.MegawattDayPerTonne); } - /// /// Creates a from . /// @@ -547,7 +530,6 @@ public static SpecificEnergy FromMegawattHoursPerKilogram(double megawatthourspe double value = (double) megawatthoursperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.MegawattHourPerKilogram); } - /// /// Creates a from . /// @@ -558,7 +540,6 @@ public static SpecificEnergy FromTerawattDaysPerKilogram(double terawattdaysperk double value = (double) terawattdaysperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.TerawattDayPerKilogram); } - /// /// Creates a from . /// @@ -569,7 +550,6 @@ public static SpecificEnergy FromTerawattDaysPerShortTon(double terawattdayspers double value = (double) terawattdayspershortton; return new SpecificEnergy(value, SpecificEnergyUnit.TerawattDayPerShortTon); } - /// /// Creates a from . /// @@ -580,7 +560,6 @@ public static SpecificEnergy FromTerawattDaysPerTonne(double terawattdayspertonn double value = (double) terawattdayspertonne; return new SpecificEnergy(value, SpecificEnergyUnit.TerawattDayPerTonne); } - /// /// Creates a from . /// @@ -591,7 +570,6 @@ public static SpecificEnergy FromWattDaysPerKilogram(double wattdaysperkilogram) double value = (double) wattdaysperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.WattDayPerKilogram); } - /// /// Creates a from . /// @@ -602,7 +580,6 @@ public static SpecificEnergy FromWattDaysPerShortTon(double wattdayspershortton) double value = (double) wattdayspershortton; return new SpecificEnergy(value, SpecificEnergyUnit.WattDayPerShortTon); } - /// /// Creates a from . /// @@ -613,7 +590,6 @@ public static SpecificEnergy FromWattDaysPerTonne(double wattdayspertonne) double value = (double) wattdayspertonne; return new SpecificEnergy(value, SpecificEnergyUnit.WattDayPerTonne); } - /// /// Creates a from . /// @@ -625,7 +601,6 @@ public static SpecificEnergy FromWattHoursPerKilogram(double watthoursperkilogra return new SpecificEnergy(value, SpecificEnergyUnit.WattHourPerKilogram); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEntropy.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEntropy.g.cs index 0b69a9d022..13d7c6ba53 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEntropy.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEntropy.g.cs @@ -261,7 +261,6 @@ public static SpecificEntropy FromBtusPerPoundFahrenheit(double btusperpoundfahr double value = (double) btusperpoundfahrenheit; return new SpecificEntropy(value, SpecificEntropyUnit.BtuPerPoundFahrenheit); } - /// /// Creates a from . /// @@ -272,7 +271,6 @@ public static SpecificEntropy FromCaloriesPerGramKelvin(double caloriespergramke double value = (double) caloriespergramkelvin; return new SpecificEntropy(value, SpecificEntropyUnit.CaloriePerGramKelvin); } - /// /// Creates a from . /// @@ -283,7 +281,6 @@ public static SpecificEntropy FromJoulesPerKilogramDegreeCelsius(double joulespe double value = (double) joulesperkilogramdegreecelsius; return new SpecificEntropy(value, SpecificEntropyUnit.JoulePerKilogramDegreeCelsius); } - /// /// Creates a from . /// @@ -294,7 +291,6 @@ public static SpecificEntropy FromJoulesPerKilogramKelvin(double joulesperkilogr double value = (double) joulesperkilogramkelvin; return new SpecificEntropy(value, SpecificEntropyUnit.JoulePerKilogramKelvin); } - /// /// Creates a from . /// @@ -305,7 +301,6 @@ public static SpecificEntropy FromKilocaloriesPerGramKelvin(double kilocaloriesp double value = (double) kilocaloriespergramkelvin; return new SpecificEntropy(value, SpecificEntropyUnit.KilocaloriePerGramKelvin); } - /// /// Creates a from . /// @@ -316,7 +311,6 @@ public static SpecificEntropy FromKilojoulesPerKilogramDegreeCelsius(double kilo double value = (double) kilojoulesperkilogramdegreecelsius; return new SpecificEntropy(value, SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius); } - /// /// Creates a from . /// @@ -327,7 +321,6 @@ public static SpecificEntropy FromKilojoulesPerKilogramKelvin(double kilojoulesp double value = (double) kilojoulesperkilogramkelvin; return new SpecificEntropy(value, SpecificEntropyUnit.KilojoulePerKilogramKelvin); } - /// /// Creates a from . /// @@ -338,7 +331,6 @@ public static SpecificEntropy FromMegajoulesPerKilogramDegreeCelsius(double mega double value = (double) megajoulesperkilogramdegreecelsius; return new SpecificEntropy(value, SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius); } - /// /// Creates a from . /// @@ -350,7 +342,6 @@ public static SpecificEntropy FromMegajoulesPerKilogramKelvin(double megajoulesp return new SpecificEntropy(value, SpecificEntropyUnit.MegajoulePerKilogramKelvin); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs index 0107691823..6ba8283311 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs @@ -234,7 +234,6 @@ public static SpecificFuelConsumption FromGramsPerKiloNewtonSecond(double gramsp double value = (double) gramsperkilonewtonsecond; return new SpecificFuelConsumption(value, SpecificFuelConsumptionUnit.GramPerKiloNewtonSecond); } - /// /// Creates a from . /// @@ -245,7 +244,6 @@ public static SpecificFuelConsumption FromKilogramsPerKilogramForceHour(double k double value = (double) kilogramsperkilogramforcehour; return new SpecificFuelConsumption(value, SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour); } - /// /// Creates a from . /// @@ -256,7 +254,6 @@ public static SpecificFuelConsumption FromKilogramsPerKiloNewtonSecond(double ki double value = (double) kilogramsperkilonewtonsecond; return new SpecificFuelConsumption(value, SpecificFuelConsumptionUnit.KilogramPerKiloNewtonSecond); } - /// /// Creates a from . /// @@ -268,7 +265,6 @@ public static SpecificFuelConsumption FromPoundsMassPerPoundForceHour(double pou return new SpecificFuelConsumption(value, SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificVolume.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificVolume.g.cs index 1da96b853d..2afac47cf9 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificVolume.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificVolume.g.cs @@ -225,7 +225,6 @@ public static SpecificVolume FromCubicFeetPerPound(double cubicfeetperpound) double value = (double) cubicfeetperpound; return new SpecificVolume(value, SpecificVolumeUnit.CubicFootPerPound); } - /// /// Creates a from . /// @@ -236,7 +235,6 @@ public static SpecificVolume FromCubicMetersPerKilogram(double cubicmetersperkil double value = (double) cubicmetersperkilogram; return new SpecificVolume(value, SpecificVolumeUnit.CubicMeterPerKilogram); } - /// /// Creates a from . /// @@ -248,7 +246,6 @@ public static SpecificVolume FromMillicubicMetersPerKilogram(double millicubicme return new SpecificVolume(value, SpecificVolumeUnit.MillicubicMeterPerKilogram); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificWeight.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificWeight.g.cs index 57e1600911..aa412824ee 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificWeight.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificWeight.g.cs @@ -312,7 +312,6 @@ public static SpecificWeight FromKilogramsForcePerCubicCentimeter(double kilogra double value = (double) kilogramsforcepercubiccentimeter; return new SpecificWeight(value, SpecificWeightUnit.KilogramForcePerCubicCentimeter); } - /// /// Creates a from . /// @@ -323,7 +322,6 @@ public static SpecificWeight FromKilogramsForcePerCubicMeter(double kilogramsfor double value = (double) kilogramsforcepercubicmeter; return new SpecificWeight(value, SpecificWeightUnit.KilogramForcePerCubicMeter); } - /// /// Creates a from . /// @@ -334,7 +332,6 @@ public static SpecificWeight FromKilogramsForcePerCubicMillimeter(double kilogra double value = (double) kilogramsforcepercubicmillimeter; return new SpecificWeight(value, SpecificWeightUnit.KilogramForcePerCubicMillimeter); } - /// /// Creates a from . /// @@ -345,7 +342,6 @@ public static SpecificWeight FromKilonewtonsPerCubicCentimeter(double kilonewton double value = (double) kilonewtonspercubiccentimeter; return new SpecificWeight(value, SpecificWeightUnit.KilonewtonPerCubicCentimeter); } - /// /// Creates a from . /// @@ -356,7 +352,6 @@ public static SpecificWeight FromKilonewtonsPerCubicMeter(double kilonewtonsperc double value = (double) kilonewtonspercubicmeter; return new SpecificWeight(value, SpecificWeightUnit.KilonewtonPerCubicMeter); } - /// /// Creates a from . /// @@ -367,7 +362,6 @@ public static SpecificWeight FromKilonewtonsPerCubicMillimeter(double kilonewton double value = (double) kilonewtonspercubicmillimeter; return new SpecificWeight(value, SpecificWeightUnit.KilonewtonPerCubicMillimeter); } - /// /// Creates a from . /// @@ -378,7 +372,6 @@ public static SpecificWeight FromKilopoundsForcePerCubicFoot(double kilopoundsfo double value = (double) kilopoundsforcepercubicfoot; return new SpecificWeight(value, SpecificWeightUnit.KilopoundForcePerCubicFoot); } - /// /// Creates a from . /// @@ -389,7 +382,6 @@ public static SpecificWeight FromKilopoundsForcePerCubicInch(double kilopoundsfo double value = (double) kilopoundsforcepercubicinch; return new SpecificWeight(value, SpecificWeightUnit.KilopoundForcePerCubicInch); } - /// /// Creates a from . /// @@ -400,7 +392,6 @@ public static SpecificWeight FromMeganewtonsPerCubicMeter(double meganewtonsperc double value = (double) meganewtonspercubicmeter; return new SpecificWeight(value, SpecificWeightUnit.MeganewtonPerCubicMeter); } - /// /// Creates a from . /// @@ -411,7 +402,6 @@ public static SpecificWeight FromNewtonsPerCubicCentimeter(double newtonspercubi double value = (double) newtonspercubiccentimeter; return new SpecificWeight(value, SpecificWeightUnit.NewtonPerCubicCentimeter); } - /// /// Creates a from . /// @@ -422,7 +412,6 @@ public static SpecificWeight FromNewtonsPerCubicMeter(double newtonspercubicmete double value = (double) newtonspercubicmeter; return new SpecificWeight(value, SpecificWeightUnit.NewtonPerCubicMeter); } - /// /// Creates a from . /// @@ -433,7 +422,6 @@ public static SpecificWeight FromNewtonsPerCubicMillimeter(double newtonspercubi double value = (double) newtonspercubicmillimeter; return new SpecificWeight(value, SpecificWeightUnit.NewtonPerCubicMillimeter); } - /// /// Creates a from . /// @@ -444,7 +432,6 @@ public static SpecificWeight FromPoundsForcePerCubicFoot(double poundsforcepercu double value = (double) poundsforcepercubicfoot; return new SpecificWeight(value, SpecificWeightUnit.PoundForcePerCubicFoot); } - /// /// Creates a from . /// @@ -455,7 +442,6 @@ public static SpecificWeight FromPoundsForcePerCubicInch(double poundsforcepercu double value = (double) poundsforcepercubicinch; return new SpecificWeight(value, SpecificWeightUnit.PoundForcePerCubicInch); } - /// /// Creates a from . /// @@ -466,7 +452,6 @@ public static SpecificWeight FromTonnesForcePerCubicCentimeter(double tonnesforc double value = (double) tonnesforcepercubiccentimeter; return new SpecificWeight(value, SpecificWeightUnit.TonneForcePerCubicCentimeter); } - /// /// Creates a from . /// @@ -477,7 +462,6 @@ public static SpecificWeight FromTonnesForcePerCubicMeter(double tonnesforceperc double value = (double) tonnesforcepercubicmeter; return new SpecificWeight(value, SpecificWeightUnit.TonneForcePerCubicMeter); } - /// /// Creates a from . /// @@ -489,7 +473,6 @@ public static SpecificWeight FromTonnesForcePerCubicMillimeter(double tonnesforc return new SpecificWeight(value, SpecificWeightUnit.TonneForcePerCubicMillimeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Speed.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Speed.g.cs index 538a542429..95bfb27d67 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Speed.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Speed.g.cs @@ -422,7 +422,6 @@ public static Speed FromCentimetersPerHour(double centimetersperhour) double value = (double) centimetersperhour; return new Speed(value, SpeedUnit.CentimeterPerHour); } - /// /// Creates a from . /// @@ -433,7 +432,6 @@ public static Speed FromCentimetersPerMinutes(double centimetersperminutes) double value = (double) centimetersperminutes; return new Speed(value, SpeedUnit.CentimeterPerMinute); } - /// /// Creates a from . /// @@ -444,7 +442,6 @@ public static Speed FromCentimetersPerSecond(double centimeterspersecond) double value = (double) centimeterspersecond; return new Speed(value, SpeedUnit.CentimeterPerSecond); } - /// /// Creates a from . /// @@ -455,7 +452,6 @@ public static Speed FromDecimetersPerMinutes(double decimetersperminutes) double value = (double) decimetersperminutes; return new Speed(value, SpeedUnit.DecimeterPerMinute); } - /// /// Creates a from . /// @@ -466,7 +462,6 @@ public static Speed FromDecimetersPerSecond(double decimeterspersecond) double value = (double) decimeterspersecond; return new Speed(value, SpeedUnit.DecimeterPerSecond); } - /// /// Creates a from . /// @@ -477,7 +472,6 @@ public static Speed FromFeetPerHour(double feetperhour) double value = (double) feetperhour; return new Speed(value, SpeedUnit.FootPerHour); } - /// /// Creates a from . /// @@ -488,7 +482,6 @@ public static Speed FromFeetPerMinute(double feetperminute) double value = (double) feetperminute; return new Speed(value, SpeedUnit.FootPerMinute); } - /// /// Creates a from . /// @@ -499,7 +492,6 @@ public static Speed FromFeetPerSecond(double feetpersecond) double value = (double) feetpersecond; return new Speed(value, SpeedUnit.FootPerSecond); } - /// /// Creates a from . /// @@ -510,7 +502,6 @@ public static Speed FromInchesPerHour(double inchesperhour) double value = (double) inchesperhour; return new Speed(value, SpeedUnit.InchPerHour); } - /// /// Creates a from . /// @@ -521,7 +512,6 @@ public static Speed FromInchesPerMinute(double inchesperminute) double value = (double) inchesperminute; return new Speed(value, SpeedUnit.InchPerMinute); } - /// /// Creates a from . /// @@ -532,7 +522,6 @@ public static Speed FromInchesPerSecond(double inchespersecond) double value = (double) inchespersecond; return new Speed(value, SpeedUnit.InchPerSecond); } - /// /// Creates a from . /// @@ -543,7 +532,6 @@ public static Speed FromKilometersPerHour(double kilometersperhour) double value = (double) kilometersperhour; return new Speed(value, SpeedUnit.KilometerPerHour); } - /// /// Creates a from . /// @@ -554,7 +542,6 @@ public static Speed FromKilometersPerMinutes(double kilometersperminutes) double value = (double) kilometersperminutes; return new Speed(value, SpeedUnit.KilometerPerMinute); } - /// /// Creates a from . /// @@ -565,7 +552,6 @@ public static Speed FromKilometersPerSecond(double kilometerspersecond) double value = (double) kilometerspersecond; return new Speed(value, SpeedUnit.KilometerPerSecond); } - /// /// Creates a from . /// @@ -576,7 +562,6 @@ public static Speed FromKnots(double knots) double value = (double) knots; return new Speed(value, SpeedUnit.Knot); } - /// /// Creates a from . /// @@ -587,7 +572,6 @@ public static Speed FromMetersPerHour(double metersperhour) double value = (double) metersperhour; return new Speed(value, SpeedUnit.MeterPerHour); } - /// /// Creates a from . /// @@ -598,7 +582,6 @@ public static Speed FromMetersPerMinutes(double metersperminutes) double value = (double) metersperminutes; return new Speed(value, SpeedUnit.MeterPerMinute); } - /// /// Creates a from . /// @@ -609,7 +592,6 @@ public static Speed FromMetersPerSecond(double meterspersecond) double value = (double) meterspersecond; return new Speed(value, SpeedUnit.MeterPerSecond); } - /// /// Creates a from . /// @@ -620,7 +602,6 @@ public static Speed FromMicrometersPerMinutes(double micrometersperminutes) double value = (double) micrometersperminutes; return new Speed(value, SpeedUnit.MicrometerPerMinute); } - /// /// Creates a from . /// @@ -631,7 +612,6 @@ public static Speed FromMicrometersPerSecond(double micrometerspersecond) double value = (double) micrometerspersecond; return new Speed(value, SpeedUnit.MicrometerPerSecond); } - /// /// Creates a from . /// @@ -642,7 +622,6 @@ public static Speed FromMilesPerHour(double milesperhour) double value = (double) milesperhour; return new Speed(value, SpeedUnit.MilePerHour); } - /// /// Creates a from . /// @@ -653,7 +632,6 @@ public static Speed FromMillimetersPerHour(double millimetersperhour) double value = (double) millimetersperhour; return new Speed(value, SpeedUnit.MillimeterPerHour); } - /// /// Creates a from . /// @@ -664,7 +642,6 @@ public static Speed FromMillimetersPerMinutes(double millimetersperminutes) double value = (double) millimetersperminutes; return new Speed(value, SpeedUnit.MillimeterPerMinute); } - /// /// Creates a from . /// @@ -675,7 +652,6 @@ public static Speed FromMillimetersPerSecond(double millimeterspersecond) double value = (double) millimeterspersecond; return new Speed(value, SpeedUnit.MillimeterPerSecond); } - /// /// Creates a from . /// @@ -686,7 +662,6 @@ public static Speed FromNanometersPerMinutes(double nanometersperminutes) double value = (double) nanometersperminutes; return new Speed(value, SpeedUnit.NanometerPerMinute); } - /// /// Creates a from . /// @@ -697,7 +672,6 @@ public static Speed FromNanometersPerSecond(double nanometerspersecond) double value = (double) nanometerspersecond; return new Speed(value, SpeedUnit.NanometerPerSecond); } - /// /// Creates a from . /// @@ -708,7 +682,6 @@ public static Speed FromUsSurveyFeetPerHour(double ussurveyfeetperhour) double value = (double) ussurveyfeetperhour; return new Speed(value, SpeedUnit.UsSurveyFootPerHour); } - /// /// Creates a from . /// @@ -719,7 +692,6 @@ public static Speed FromUsSurveyFeetPerMinute(double ussurveyfeetperminute) double value = (double) ussurveyfeetperminute; return new Speed(value, SpeedUnit.UsSurveyFootPerMinute); } - /// /// Creates a from . /// @@ -730,7 +702,6 @@ public static Speed FromUsSurveyFeetPerSecond(double ussurveyfeetpersecond) double value = (double) ussurveyfeetpersecond; return new Speed(value, SpeedUnit.UsSurveyFootPerSecond); } - /// /// Creates a from . /// @@ -741,7 +712,6 @@ public static Speed FromYardsPerHour(double yardsperhour) double value = (double) yardsperhour; return new Speed(value, SpeedUnit.YardPerHour); } - /// /// Creates a from . /// @@ -752,7 +722,6 @@ public static Speed FromYardsPerMinute(double yardsperminute) double value = (double) yardsperminute; return new Speed(value, SpeedUnit.YardPerMinute); } - /// /// Creates a from . /// @@ -764,7 +733,6 @@ public static Speed FromYardsPerSecond(double yardspersecond) return new Speed(value, SpeedUnit.YardPerSecond); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/StandardVolumeFlow.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/StandardVolumeFlow.g.cs index 7ede7df62c..9a8960d99e 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/StandardVolumeFlow.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/StandardVolumeFlow.g.cs @@ -261,7 +261,6 @@ public static StandardVolumeFlow FromStandardCubicCentimetersPerMinute(double st double value = (double) standardcubiccentimetersperminute; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute); } - /// /// Creates a from . /// @@ -272,7 +271,6 @@ public static StandardVolumeFlow FromStandardCubicFeetPerHour(double standardcub double value = (double) standardcubicfeetperhour; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicFootPerHour); } - /// /// Creates a from . /// @@ -283,7 +281,6 @@ public static StandardVolumeFlow FromStandardCubicFeetPerMinute(double standardc double value = (double) standardcubicfeetperminute; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicFootPerMinute); } - /// /// Creates a from . /// @@ -294,7 +291,6 @@ public static StandardVolumeFlow FromStandardCubicFeetPerSecond(double standardc double value = (double) standardcubicfeetpersecond; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicFootPerSecond); } - /// /// Creates a from . /// @@ -305,7 +301,6 @@ public static StandardVolumeFlow FromStandardCubicMetersPerDay(double standardcu double value = (double) standardcubicmetersperday; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicMeterPerDay); } - /// /// Creates a from . /// @@ -316,7 +311,6 @@ public static StandardVolumeFlow FromStandardCubicMetersPerHour(double standardc double value = (double) standardcubicmetersperhour; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicMeterPerHour); } - /// /// Creates a from . /// @@ -327,7 +321,6 @@ public static StandardVolumeFlow FromStandardCubicMetersPerMinute(double standar double value = (double) standardcubicmetersperminute; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicMeterPerMinute); } - /// /// Creates a from . /// @@ -338,7 +331,6 @@ public static StandardVolumeFlow FromStandardCubicMetersPerSecond(double standar double value = (double) standardcubicmeterspersecond; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicMeterPerSecond); } - /// /// Creates a from . /// @@ -350,7 +342,6 @@ public static StandardVolumeFlow FromStandardLitersPerMinute(double standardlite return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardLiterPerMinute); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Temperature.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Temperature.g.cs index 7200d43f09..f58a09b096 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Temperature.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Temperature.g.cs @@ -267,7 +267,6 @@ public static Temperature FromDegreesCelsius(double degreescelsius) double value = (double) degreescelsius; return new Temperature(value, TemperatureUnit.DegreeCelsius); } - /// /// Creates a from . /// @@ -278,7 +277,6 @@ public static Temperature FromDegreesDelisle(double degreesdelisle) double value = (double) degreesdelisle; return new Temperature(value, TemperatureUnit.DegreeDelisle); } - /// /// Creates a from . /// @@ -289,7 +287,6 @@ public static Temperature FromDegreesFahrenheit(double degreesfahrenheit) double value = (double) degreesfahrenheit; return new Temperature(value, TemperatureUnit.DegreeFahrenheit); } - /// /// Creates a from . /// @@ -300,7 +297,6 @@ public static Temperature FromDegreesNewton(double degreesnewton) double value = (double) degreesnewton; return new Temperature(value, TemperatureUnit.DegreeNewton); } - /// /// Creates a from . /// @@ -311,7 +307,6 @@ public static Temperature FromDegreesRankine(double degreesrankine) double value = (double) degreesrankine; return new Temperature(value, TemperatureUnit.DegreeRankine); } - /// /// Creates a from . /// @@ -322,7 +317,6 @@ public static Temperature FromDegreesReaumur(double degreesreaumur) double value = (double) degreesreaumur; return new Temperature(value, TemperatureUnit.DegreeReaumur); } - /// /// Creates a from . /// @@ -333,7 +327,6 @@ public static Temperature FromDegreesRoemer(double degreesroemer) double value = (double) degreesroemer; return new Temperature(value, TemperatureUnit.DegreeRoemer); } - /// /// Creates a from . /// @@ -344,7 +337,6 @@ public static Temperature FromKelvins(double kelvins) double value = (double) kelvins; return new Temperature(value, TemperatureUnit.Kelvin); } - /// /// Creates a from . /// @@ -355,7 +347,6 @@ public static Temperature FromMillidegreesCelsius(double millidegreescelsius) double value = (double) millidegreescelsius; return new Temperature(value, TemperatureUnit.MillidegreeCelsius); } - /// /// Creates a from . /// @@ -367,7 +358,6 @@ public static Temperature FromSolarTemperatures(double solartemperatures) return new Temperature(value, TemperatureUnit.SolarTemperature); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureChangeRate.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureChangeRate.g.cs index 115bc26a70..6a9dda55eb 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureChangeRate.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureChangeRate.g.cs @@ -267,7 +267,6 @@ public static TemperatureChangeRate FromCentidegreesCelsiusPerSecond(double cent double value = (double) centidegreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond); } - /// /// Creates a from . /// @@ -278,7 +277,6 @@ public static TemperatureChangeRate FromDecadegreesCelsiusPerSecond(double decad double value = (double) decadegreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond); } - /// /// Creates a from . /// @@ -289,7 +287,6 @@ public static TemperatureChangeRate FromDecidegreesCelsiusPerSecond(double decid double value = (double) decidegreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond); } - /// /// Creates a from . /// @@ -300,7 +297,6 @@ public static TemperatureChangeRate FromDegreesCelsiusPerMinute(double degreesce double value = (double) degreescelsiusperminute; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DegreeCelsiusPerMinute); } - /// /// Creates a from . /// @@ -311,7 +307,6 @@ public static TemperatureChangeRate FromDegreesCelsiusPerSecond(double degreesce double value = (double) degreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DegreeCelsiusPerSecond); } - /// /// Creates a from . /// @@ -322,7 +317,6 @@ public static TemperatureChangeRate FromHectodegreesCelsiusPerSecond(double hect double value = (double) hectodegreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond); } - /// /// Creates a from . /// @@ -333,7 +327,6 @@ public static TemperatureChangeRate FromKilodegreesCelsiusPerSecond(double kilod double value = (double) kilodegreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond); } - /// /// Creates a from . /// @@ -344,7 +337,6 @@ public static TemperatureChangeRate FromMicrodegreesCelsiusPerSecond(double micr double value = (double) microdegreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond); } - /// /// Creates a from . /// @@ -355,7 +347,6 @@ public static TemperatureChangeRate FromMillidegreesCelsiusPerSecond(double mill double value = (double) millidegreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond); } - /// /// Creates a from . /// @@ -367,7 +358,6 @@ public static TemperatureChangeRate FromNanodegreesCelsiusPerSecond(double nanod return new TemperatureChangeRate(value, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureDelta.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureDelta.g.cs index fd46c391a0..67eb429aea 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureDelta.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureDelta.g.cs @@ -261,7 +261,6 @@ public static TemperatureDelta FromDegreesCelsius(double degreescelsius) double value = (double) degreescelsius; return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeCelsius); } - /// /// Creates a from . /// @@ -272,7 +271,6 @@ public static TemperatureDelta FromDegreesDelisle(double degreesdelisle) double value = (double) degreesdelisle; return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeDelisle); } - /// /// Creates a from . /// @@ -283,7 +281,6 @@ public static TemperatureDelta FromDegreesFahrenheit(double degreesfahrenheit) double value = (double) degreesfahrenheit; return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeFahrenheit); } - /// /// Creates a from . /// @@ -294,7 +291,6 @@ public static TemperatureDelta FromDegreesNewton(double degreesnewton) double value = (double) degreesnewton; return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeNewton); } - /// /// Creates a from . /// @@ -305,7 +301,6 @@ public static TemperatureDelta FromDegreesRankine(double degreesrankine) double value = (double) degreesrankine; return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeRankine); } - /// /// Creates a from . /// @@ -316,7 +311,6 @@ public static TemperatureDelta FromDegreesReaumur(double degreesreaumur) double value = (double) degreesreaumur; return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeReaumur); } - /// /// Creates a from . /// @@ -327,7 +321,6 @@ public static TemperatureDelta FromDegreesRoemer(double degreesroemer) double value = (double) degreesroemer; return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeRoemer); } - /// /// Creates a from . /// @@ -338,7 +331,6 @@ public static TemperatureDelta FromKelvins(double kelvins) double value = (double) kelvins; return new TemperatureDelta(value, TemperatureDeltaUnit.Kelvin); } - /// /// Creates a from . /// @@ -350,7 +342,6 @@ public static TemperatureDelta FromMillidegreesCelsius(double millidegreescelsiu return new TemperatureDelta(value, TemperatureDeltaUnit.MillidegreeCelsius); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureGradient.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureGradient.g.cs index e86c810fe9..6a13bad8ec 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureGradient.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureGradient.g.cs @@ -231,7 +231,6 @@ public static TemperatureGradient FromDegreesCelciusPerKilometer(double degreesc double value = (double) degreescelciusperkilometer; return new TemperatureGradient(value, TemperatureGradientUnit.DegreeCelsiusPerKilometer); } - /// /// Creates a from . /// @@ -242,7 +241,6 @@ public static TemperatureGradient FromDegreesCelciusPerMeter(double degreescelci double value = (double) degreescelciuspermeter; return new TemperatureGradient(value, TemperatureGradientUnit.DegreeCelsiusPerMeter); } - /// /// Creates a from . /// @@ -253,7 +251,6 @@ public static TemperatureGradient FromDegreesFahrenheitPerFoot(double degreesfah double value = (double) degreesfahrenheitperfoot; return new TemperatureGradient(value, TemperatureGradientUnit.DegreeFahrenheitPerFoot); } - /// /// Creates a from . /// @@ -265,7 +262,6 @@ public static TemperatureGradient FromKelvinsPerMeter(double kelvinspermeter) return new TemperatureGradient(value, TemperatureGradientUnit.KelvinPerMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalConductivity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalConductivity.g.cs index 48e063c970..3d79f438ae 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalConductivity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalConductivity.g.cs @@ -222,7 +222,6 @@ public static ThermalConductivity FromBtusPerHourFootFahrenheit(double btusperho double value = (double) btusperhourfootfahrenheit; return new ThermalConductivity(value, ThermalConductivityUnit.BtuPerHourFootFahrenheit); } - /// /// Creates a from . /// @@ -234,7 +233,6 @@ public static ThermalConductivity FromWattsPerMeterKelvin(double wattspermeterke return new ThermalConductivity(value, ThermalConductivityUnit.WattPerMeterKelvin); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalResistance.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalResistance.g.cs index 5de8ae9088..ee78addddf 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalResistance.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalResistance.g.cs @@ -243,7 +243,6 @@ public static ThermalResistance FromHourSquareFeetDegreesFahrenheitPerBtu(double double value = (double) hoursquarefeetdegreesfahrenheitperbtu; return new ThermalResistance(value, ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu); } - /// /// Creates a from . /// @@ -254,7 +253,6 @@ public static ThermalResistance FromSquareCentimeterHourDegreesCelsiusPerKilocal double value = (double) squarecentimeterhourdegreescelsiusperkilocalorie; return new ThermalResistance(value, ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie); } - /// /// Creates a from . /// @@ -265,7 +263,6 @@ public static ThermalResistance FromSquareCentimeterKelvinsPerWatt(double square double value = (double) squarecentimeterkelvinsperwatt; return new ThermalResistance(value, ThermalResistanceUnit.SquareCentimeterKelvinPerWatt); } - /// /// Creates a from . /// @@ -276,7 +273,6 @@ public static ThermalResistance FromSquareMeterDegreesCelsiusPerWatt(double squa double value = (double) squaremeterdegreescelsiusperwatt; return new ThermalResistance(value, ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt); } - /// /// Creates a from . /// @@ -287,7 +283,6 @@ public static ThermalResistance FromSquareMeterKelvinsPerKilowatt(double squarem double value = (double) squaremeterkelvinsperkilowatt; return new ThermalResistance(value, ThermalResistanceUnit.SquareMeterKelvinPerKilowatt); } - /// /// Creates a from . /// @@ -299,7 +294,6 @@ public static ThermalResistance FromSquareMeterKelvinsPerWatt(double squaremeter return new ThermalResistance(value, ThermalResistanceUnit.SquareMeterKelvinPerWatt); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Torque.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Torque.g.cs index 177a41b8b0..1f25043f75 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Torque.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Torque.g.cs @@ -360,7 +360,6 @@ public static Torque FromGramForceCentimeters(double gramforcecentimeters) double value = (double) gramforcecentimeters; return new Torque(value, TorqueUnit.GramForceCentimeter); } - /// /// Creates a from . /// @@ -371,7 +370,6 @@ public static Torque FromGramForceMeters(double gramforcemeters) double value = (double) gramforcemeters; return new Torque(value, TorqueUnit.GramForceMeter); } - /// /// Creates a from . /// @@ -382,7 +380,6 @@ public static Torque FromGramForceMillimeters(double gramforcemillimeters) double value = (double) gramforcemillimeters; return new Torque(value, TorqueUnit.GramForceMillimeter); } - /// /// Creates a from . /// @@ -393,7 +390,6 @@ public static Torque FromKilogramForceCentimeters(double kilogramforcecentimeter double value = (double) kilogramforcecentimeters; return new Torque(value, TorqueUnit.KilogramForceCentimeter); } - /// /// Creates a from . /// @@ -404,7 +400,6 @@ public static Torque FromKilogramForceMeters(double kilogramforcemeters) double value = (double) kilogramforcemeters; return new Torque(value, TorqueUnit.KilogramForceMeter); } - /// /// Creates a from . /// @@ -415,7 +410,6 @@ public static Torque FromKilogramForceMillimeters(double kilogramforcemillimeter double value = (double) kilogramforcemillimeters; return new Torque(value, TorqueUnit.KilogramForceMillimeter); } - /// /// Creates a from . /// @@ -426,7 +420,6 @@ public static Torque FromKilonewtonCentimeters(double kilonewtoncentimeters) double value = (double) kilonewtoncentimeters; return new Torque(value, TorqueUnit.KilonewtonCentimeter); } - /// /// Creates a from . /// @@ -437,7 +430,6 @@ public static Torque FromKilonewtonMeters(double kilonewtonmeters) double value = (double) kilonewtonmeters; return new Torque(value, TorqueUnit.KilonewtonMeter); } - /// /// Creates a from . /// @@ -448,7 +440,6 @@ public static Torque FromKilonewtonMillimeters(double kilonewtonmillimeters) double value = (double) kilonewtonmillimeters; return new Torque(value, TorqueUnit.KilonewtonMillimeter); } - /// /// Creates a from . /// @@ -459,7 +450,6 @@ public static Torque FromKilopoundForceFeet(double kilopoundforcefeet) double value = (double) kilopoundforcefeet; return new Torque(value, TorqueUnit.KilopoundForceFoot); } - /// /// Creates a from . /// @@ -470,7 +460,6 @@ public static Torque FromKilopoundForceInches(double kilopoundforceinches) double value = (double) kilopoundforceinches; return new Torque(value, TorqueUnit.KilopoundForceInch); } - /// /// Creates a from . /// @@ -481,7 +470,6 @@ public static Torque FromMeganewtonCentimeters(double meganewtoncentimeters) double value = (double) meganewtoncentimeters; return new Torque(value, TorqueUnit.MeganewtonCentimeter); } - /// /// Creates a from . /// @@ -492,7 +480,6 @@ public static Torque FromMeganewtonMeters(double meganewtonmeters) double value = (double) meganewtonmeters; return new Torque(value, TorqueUnit.MeganewtonMeter); } - /// /// Creates a from . /// @@ -503,7 +490,6 @@ public static Torque FromMeganewtonMillimeters(double meganewtonmillimeters) double value = (double) meganewtonmillimeters; return new Torque(value, TorqueUnit.MeganewtonMillimeter); } - /// /// Creates a from . /// @@ -514,7 +500,6 @@ public static Torque FromMegapoundForceFeet(double megapoundforcefeet) double value = (double) megapoundforcefeet; return new Torque(value, TorqueUnit.MegapoundForceFoot); } - /// /// Creates a from . /// @@ -525,7 +510,6 @@ public static Torque FromMegapoundForceInches(double megapoundforceinches) double value = (double) megapoundforceinches; return new Torque(value, TorqueUnit.MegapoundForceInch); } - /// /// Creates a from . /// @@ -536,7 +520,6 @@ public static Torque FromNewtonCentimeters(double newtoncentimeters) double value = (double) newtoncentimeters; return new Torque(value, TorqueUnit.NewtonCentimeter); } - /// /// Creates a from . /// @@ -547,7 +530,6 @@ public static Torque FromNewtonMeters(double newtonmeters) double value = (double) newtonmeters; return new Torque(value, TorqueUnit.NewtonMeter); } - /// /// Creates a from . /// @@ -558,7 +540,6 @@ public static Torque FromNewtonMillimeters(double newtonmillimeters) double value = (double) newtonmillimeters; return new Torque(value, TorqueUnit.NewtonMillimeter); } - /// /// Creates a from . /// @@ -569,7 +550,6 @@ public static Torque FromPoundalFeet(double poundalfeet) double value = (double) poundalfeet; return new Torque(value, TorqueUnit.PoundalFoot); } - /// /// Creates a from . /// @@ -580,7 +560,6 @@ public static Torque FromPoundForceFeet(double poundforcefeet) double value = (double) poundforcefeet; return new Torque(value, TorqueUnit.PoundForceFoot); } - /// /// Creates a from . /// @@ -591,7 +570,6 @@ public static Torque FromPoundForceInches(double poundforceinches) double value = (double) poundforceinches; return new Torque(value, TorqueUnit.PoundForceInch); } - /// /// Creates a from . /// @@ -602,7 +580,6 @@ public static Torque FromTonneForceCentimeters(double tonneforcecentimeters) double value = (double) tonneforcecentimeters; return new Torque(value, TorqueUnit.TonneForceCentimeter); } - /// /// Creates a from . /// @@ -613,7 +590,6 @@ public static Torque FromTonneForceMeters(double tonneforcemeters) double value = (double) tonneforcemeters; return new Torque(value, TorqueUnit.TonneForceMeter); } - /// /// Creates a from . /// @@ -625,7 +601,6 @@ public static Torque FromTonneForceMillimeters(double tonneforcemillimeters) return new Torque(value, TorqueUnit.TonneForceMillimeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TorquePerLength.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TorquePerLength.g.cs index f9d12545d4..b5f514e166 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TorquePerLength.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TorquePerLength.g.cs @@ -336,7 +336,6 @@ public static TorquePerLength FromKilogramForceCentimetersPerMeter(double kilogr double value = (double) kilogramforcecentimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.KilogramForceCentimeterPerMeter); } - /// /// Creates a from . /// @@ -347,7 +346,6 @@ public static TorquePerLength FromKilogramForceMetersPerMeter(double kilogramfor double value = (double) kilogramforcemeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.KilogramForceMeterPerMeter); } - /// /// Creates a from . /// @@ -358,7 +356,6 @@ public static TorquePerLength FromKilogramForceMillimetersPerMeter(double kilogr double value = (double) kilogramforcemillimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.KilogramForceMillimeterPerMeter); } - /// /// Creates a from . /// @@ -369,7 +366,6 @@ public static TorquePerLength FromKilonewtonCentimetersPerMeter(double kilonewto double value = (double) kilonewtoncentimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.KilonewtonCentimeterPerMeter); } - /// /// Creates a from . /// @@ -380,7 +376,6 @@ public static TorquePerLength FromKilonewtonMetersPerMeter(double kilonewtonmete double value = (double) kilonewtonmeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.KilonewtonMeterPerMeter); } - /// /// Creates a from . /// @@ -391,7 +386,6 @@ public static TorquePerLength FromKilonewtonMillimetersPerMeter(double kilonewto double value = (double) kilonewtonmillimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.KilonewtonMillimeterPerMeter); } - /// /// Creates a from . /// @@ -402,7 +396,6 @@ public static TorquePerLength FromKilopoundForceFeetPerFoot(double kilopoundforc double value = (double) kilopoundforcefeetperfoot; return new TorquePerLength(value, TorquePerLengthUnit.KilopoundForceFootPerFoot); } - /// /// Creates a from . /// @@ -413,7 +406,6 @@ public static TorquePerLength FromKilopoundForceInchesPerFoot(double kilopoundfo double value = (double) kilopoundforceinchesperfoot; return new TorquePerLength(value, TorquePerLengthUnit.KilopoundForceInchPerFoot); } - /// /// Creates a from . /// @@ -424,7 +416,6 @@ public static TorquePerLength FromMeganewtonCentimetersPerMeter(double meganewto double value = (double) meganewtoncentimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.MeganewtonCentimeterPerMeter); } - /// /// Creates a from . /// @@ -435,7 +426,6 @@ public static TorquePerLength FromMeganewtonMetersPerMeter(double meganewtonmete double value = (double) meganewtonmeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.MeganewtonMeterPerMeter); } - /// /// Creates a from . /// @@ -446,7 +436,6 @@ public static TorquePerLength FromMeganewtonMillimetersPerMeter(double meganewto double value = (double) meganewtonmillimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.MeganewtonMillimeterPerMeter); } - /// /// Creates a from . /// @@ -457,7 +446,6 @@ public static TorquePerLength FromMegapoundForceFeetPerFoot(double megapoundforc double value = (double) megapoundforcefeetperfoot; return new TorquePerLength(value, TorquePerLengthUnit.MegapoundForceFootPerFoot); } - /// /// Creates a from . /// @@ -468,7 +456,6 @@ public static TorquePerLength FromMegapoundForceInchesPerFoot(double megapoundfo double value = (double) megapoundforceinchesperfoot; return new TorquePerLength(value, TorquePerLengthUnit.MegapoundForceInchPerFoot); } - /// /// Creates a from . /// @@ -479,7 +466,6 @@ public static TorquePerLength FromNewtonCentimetersPerMeter(double newtoncentime double value = (double) newtoncentimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.NewtonCentimeterPerMeter); } - /// /// Creates a from . /// @@ -490,7 +476,6 @@ public static TorquePerLength FromNewtonMetersPerMeter(double newtonmeterspermet double value = (double) newtonmeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.NewtonMeterPerMeter); } - /// /// Creates a from . /// @@ -501,7 +486,6 @@ public static TorquePerLength FromNewtonMillimetersPerMeter(double newtonmillime double value = (double) newtonmillimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.NewtonMillimeterPerMeter); } - /// /// Creates a from . /// @@ -512,7 +496,6 @@ public static TorquePerLength FromPoundForceFeetPerFoot(double poundforcefeetper double value = (double) poundforcefeetperfoot; return new TorquePerLength(value, TorquePerLengthUnit.PoundForceFootPerFoot); } - /// /// Creates a from . /// @@ -523,7 +506,6 @@ public static TorquePerLength FromPoundForceInchesPerFoot(double poundforceinche double value = (double) poundforceinchesperfoot; return new TorquePerLength(value, TorquePerLengthUnit.PoundForceInchPerFoot); } - /// /// Creates a from . /// @@ -534,7 +516,6 @@ public static TorquePerLength FromTonneForceCentimetersPerMeter(double tonneforc double value = (double) tonneforcecentimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.TonneForceCentimeterPerMeter); } - /// /// Creates a from . /// @@ -545,7 +526,6 @@ public static TorquePerLength FromTonneForceMetersPerMeter(double tonneforcemete double value = (double) tonneforcemeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.TonneForceMeterPerMeter); } - /// /// Creates a from . /// @@ -557,7 +537,6 @@ public static TorquePerLength FromTonneForceMillimetersPerMeter(double tonneforc return new TorquePerLength(value, TorquePerLengthUnit.TonneForceMillimeterPerMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Turbidity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Turbidity.g.cs index bc9e4c297c..6dffba132e 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Turbidity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Turbidity.g.cs @@ -217,7 +217,6 @@ public static Turbidity FromNTU(double ntu) return new Turbidity(value, TurbidityUnit.NTU); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VitaminA.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VitaminA.g.cs index 3a4c2382d8..167fa714db 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VitaminA.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VitaminA.g.cs @@ -214,7 +214,6 @@ public static VitaminA FromInternationalUnits(double internationalunits) return new VitaminA(value, VitaminAUnit.InternationalUnit); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Volume.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Volume.g.cs index cdb1402136..2413799e2b 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Volume.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Volume.g.cs @@ -566,7 +566,6 @@ public static Volume FromAcreFeet(double acrefeet) double value = (double) acrefeet; return new Volume(value, VolumeUnit.AcreFoot); } - /// /// Creates a from . /// @@ -577,7 +576,6 @@ public static Volume FromAuTablespoons(double autablespoons) double value = (double) autablespoons; return new Volume(value, VolumeUnit.AuTablespoon); } - /// /// Creates a from . /// @@ -588,7 +586,6 @@ public static Volume FromBoardFeet(double boardfeet) double value = (double) boardfeet; return new Volume(value, VolumeUnit.BoardFoot); } - /// /// Creates a from . /// @@ -599,7 +596,6 @@ public static Volume FromCentiliters(double centiliters) double value = (double) centiliters; return new Volume(value, VolumeUnit.Centiliter); } - /// /// Creates a from . /// @@ -610,7 +606,6 @@ public static Volume FromCubicCentimeters(double cubiccentimeters) double value = (double) cubiccentimeters; return new Volume(value, VolumeUnit.CubicCentimeter); } - /// /// Creates a from . /// @@ -621,7 +616,6 @@ public static Volume FromCubicDecimeters(double cubicdecimeters) double value = (double) cubicdecimeters; return new Volume(value, VolumeUnit.CubicDecimeter); } - /// /// Creates a from . /// @@ -632,7 +626,6 @@ public static Volume FromCubicFeet(double cubicfeet) double value = (double) cubicfeet; return new Volume(value, VolumeUnit.CubicFoot); } - /// /// Creates a from . /// @@ -643,7 +636,6 @@ public static Volume FromCubicHectometers(double cubichectometers) double value = (double) cubichectometers; return new Volume(value, VolumeUnit.CubicHectometer); } - /// /// Creates a from . /// @@ -654,7 +646,6 @@ public static Volume FromCubicInches(double cubicinches) double value = (double) cubicinches; return new Volume(value, VolumeUnit.CubicInch); } - /// /// Creates a from . /// @@ -665,7 +656,6 @@ public static Volume FromCubicKilometers(double cubickilometers) double value = (double) cubickilometers; return new Volume(value, VolumeUnit.CubicKilometer); } - /// /// Creates a from . /// @@ -676,7 +666,6 @@ public static Volume FromCubicMeters(double cubicmeters) double value = (double) cubicmeters; return new Volume(value, VolumeUnit.CubicMeter); } - /// /// Creates a from . /// @@ -687,7 +676,6 @@ public static Volume FromCubicMicrometers(double cubicmicrometers) double value = (double) cubicmicrometers; return new Volume(value, VolumeUnit.CubicMicrometer); } - /// /// Creates a from . /// @@ -698,7 +686,6 @@ public static Volume FromCubicMiles(double cubicmiles) double value = (double) cubicmiles; return new Volume(value, VolumeUnit.CubicMile); } - /// /// Creates a from . /// @@ -709,7 +696,6 @@ public static Volume FromCubicMillimeters(double cubicmillimeters) double value = (double) cubicmillimeters; return new Volume(value, VolumeUnit.CubicMillimeter); } - /// /// Creates a from . /// @@ -720,7 +706,6 @@ public static Volume FromCubicYards(double cubicyards) double value = (double) cubicyards; return new Volume(value, VolumeUnit.CubicYard); } - /// /// Creates a from . /// @@ -731,7 +716,6 @@ public static Volume FromDecaliters(double decaliters) double value = (double) decaliters; return new Volume(value, VolumeUnit.Decaliter); } - /// /// Creates a from . /// @@ -742,7 +726,6 @@ public static Volume FromDecausGallons(double decausgallons) double value = (double) decausgallons; return new Volume(value, VolumeUnit.DecausGallon); } - /// /// Creates a from . /// @@ -753,7 +736,6 @@ public static Volume FromDeciliters(double deciliters) double value = (double) deciliters; return new Volume(value, VolumeUnit.Deciliter); } - /// /// Creates a from . /// @@ -764,7 +746,6 @@ public static Volume FromDeciusGallons(double deciusgallons) double value = (double) deciusgallons; return new Volume(value, VolumeUnit.DeciusGallon); } - /// /// Creates a from . /// @@ -775,7 +756,6 @@ public static Volume FromHectocubicFeet(double hectocubicfeet) double value = (double) hectocubicfeet; return new Volume(value, VolumeUnit.HectocubicFoot); } - /// /// Creates a from . /// @@ -786,7 +766,6 @@ public static Volume FromHectocubicMeters(double hectocubicmeters) double value = (double) hectocubicmeters; return new Volume(value, VolumeUnit.HectocubicMeter); } - /// /// Creates a from . /// @@ -797,7 +776,6 @@ public static Volume FromHectoliters(double hectoliters) double value = (double) hectoliters; return new Volume(value, VolumeUnit.Hectoliter); } - /// /// Creates a from . /// @@ -808,7 +786,6 @@ public static Volume FromHectousGallons(double hectousgallons) double value = (double) hectousgallons; return new Volume(value, VolumeUnit.HectousGallon); } - /// /// Creates a from . /// @@ -819,7 +796,6 @@ public static Volume FromImperialBeerBarrels(double imperialbeerbarrels) double value = (double) imperialbeerbarrels; return new Volume(value, VolumeUnit.ImperialBeerBarrel); } - /// /// Creates a from . /// @@ -830,7 +806,6 @@ public static Volume FromImperialGallons(double imperialgallons) double value = (double) imperialgallons; return new Volume(value, VolumeUnit.ImperialGallon); } - /// /// Creates a from . /// @@ -841,7 +816,6 @@ public static Volume FromImperialOunces(double imperialounces) double value = (double) imperialounces; return new Volume(value, VolumeUnit.ImperialOunce); } - /// /// Creates a from . /// @@ -852,7 +826,6 @@ public static Volume FromImperialPints(double imperialpints) double value = (double) imperialpints; return new Volume(value, VolumeUnit.ImperialPint); } - /// /// Creates a from . /// @@ -863,7 +836,6 @@ public static Volume FromKilocubicFeet(double kilocubicfeet) double value = (double) kilocubicfeet; return new Volume(value, VolumeUnit.KilocubicFoot); } - /// /// Creates a from . /// @@ -874,7 +846,6 @@ public static Volume FromKilocubicMeters(double kilocubicmeters) double value = (double) kilocubicmeters; return new Volume(value, VolumeUnit.KilocubicMeter); } - /// /// Creates a from . /// @@ -885,7 +856,6 @@ public static Volume FromKiloimperialGallons(double kiloimperialgallons) double value = (double) kiloimperialgallons; return new Volume(value, VolumeUnit.KiloimperialGallon); } - /// /// Creates a from . /// @@ -896,7 +866,6 @@ public static Volume FromKiloliters(double kiloliters) double value = (double) kiloliters; return new Volume(value, VolumeUnit.Kiloliter); } - /// /// Creates a from . /// @@ -907,7 +876,6 @@ public static Volume FromKilousGallons(double kilousgallons) double value = (double) kilousgallons; return new Volume(value, VolumeUnit.KilousGallon); } - /// /// Creates a from . /// @@ -918,7 +886,6 @@ public static Volume FromLiters(double liters) double value = (double) liters; return new Volume(value, VolumeUnit.Liter); } - /// /// Creates a from . /// @@ -929,7 +896,6 @@ public static Volume FromMegacubicFeet(double megacubicfeet) double value = (double) megacubicfeet; return new Volume(value, VolumeUnit.MegacubicFoot); } - /// /// Creates a from . /// @@ -940,7 +906,6 @@ public static Volume FromMegaimperialGallons(double megaimperialgallons) double value = (double) megaimperialgallons; return new Volume(value, VolumeUnit.MegaimperialGallon); } - /// /// Creates a from . /// @@ -951,7 +916,6 @@ public static Volume FromMegaliters(double megaliters) double value = (double) megaliters; return new Volume(value, VolumeUnit.Megaliter); } - /// /// Creates a from . /// @@ -962,7 +926,6 @@ public static Volume FromMegausGallons(double megausgallons) double value = (double) megausgallons; return new Volume(value, VolumeUnit.MegausGallon); } - /// /// Creates a from . /// @@ -973,7 +936,6 @@ public static Volume FromMetricCups(double metriccups) double value = (double) metriccups; return new Volume(value, VolumeUnit.MetricCup); } - /// /// Creates a from . /// @@ -984,7 +946,6 @@ public static Volume FromMetricTeaspoons(double metricteaspoons) double value = (double) metricteaspoons; return new Volume(value, VolumeUnit.MetricTeaspoon); } - /// /// Creates a from . /// @@ -995,7 +956,6 @@ public static Volume FromMicroliters(double microliters) double value = (double) microliters; return new Volume(value, VolumeUnit.Microliter); } - /// /// Creates a from . /// @@ -1006,7 +966,6 @@ public static Volume FromMilliliters(double milliliters) double value = (double) milliliters; return new Volume(value, VolumeUnit.Milliliter); } - /// /// Creates a from . /// @@ -1017,7 +976,6 @@ public static Volume FromOilBarrels(double oilbarrels) double value = (double) oilbarrels; return new Volume(value, VolumeUnit.OilBarrel); } - /// /// Creates a from . /// @@ -1028,7 +986,6 @@ public static Volume FromUkTablespoons(double uktablespoons) double value = (double) uktablespoons; return new Volume(value, VolumeUnit.UkTablespoon); } - /// /// Creates a from . /// @@ -1039,7 +996,6 @@ public static Volume FromUsBeerBarrels(double usbeerbarrels) double value = (double) usbeerbarrels; return new Volume(value, VolumeUnit.UsBeerBarrel); } - /// /// Creates a from . /// @@ -1050,7 +1006,6 @@ public static Volume FromUsCustomaryCups(double uscustomarycups) double value = (double) uscustomarycups; return new Volume(value, VolumeUnit.UsCustomaryCup); } - /// /// Creates a from . /// @@ -1061,7 +1016,6 @@ public static Volume FromUsGallons(double usgallons) double value = (double) usgallons; return new Volume(value, VolumeUnit.UsGallon); } - /// /// Creates a from . /// @@ -1072,7 +1026,6 @@ public static Volume FromUsLegalCups(double uslegalcups) double value = (double) uslegalcups; return new Volume(value, VolumeUnit.UsLegalCup); } - /// /// Creates a from . /// @@ -1083,7 +1036,6 @@ public static Volume FromUsOunces(double usounces) double value = (double) usounces; return new Volume(value, VolumeUnit.UsOunce); } - /// /// Creates a from . /// @@ -1094,7 +1046,6 @@ public static Volume FromUsPints(double uspints) double value = (double) uspints; return new Volume(value, VolumeUnit.UsPint); } - /// /// Creates a from . /// @@ -1105,7 +1056,6 @@ public static Volume FromUsQuarts(double usquarts) double value = (double) usquarts; return new Volume(value, VolumeUnit.UsQuart); } - /// /// Creates a from . /// @@ -1116,7 +1066,6 @@ public static Volume FromUsTablespoons(double ustablespoons) double value = (double) ustablespoons; return new Volume(value, VolumeUnit.UsTablespoon); } - /// /// Creates a from . /// @@ -1128,7 +1077,6 @@ public static Volume FromUsTeaspoons(double usteaspoons) return new Volume(value, VolumeUnit.UsTeaspoon); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeConcentration.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeConcentration.g.cs index 774ab97650..df2e356fa9 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeConcentration.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeConcentration.g.cs @@ -330,7 +330,6 @@ public static VolumeConcentration FromCentilitersPerLiter(double centilitersperl double value = (double) centilitersperliter; return new VolumeConcentration(value, VolumeConcentrationUnit.CentilitersPerLiter); } - /// /// Creates a from . /// @@ -341,7 +340,6 @@ public static VolumeConcentration FromCentilitersPerMililiter(double centiliters double value = (double) centiliterspermililiter; return new VolumeConcentration(value, VolumeConcentrationUnit.CentilitersPerMililiter); } - /// /// Creates a from . /// @@ -352,7 +350,6 @@ public static VolumeConcentration FromDecilitersPerLiter(double decilitersperlit double value = (double) decilitersperliter; return new VolumeConcentration(value, VolumeConcentrationUnit.DecilitersPerLiter); } - /// /// Creates a from . /// @@ -363,7 +360,6 @@ public static VolumeConcentration FromDecilitersPerMililiter(double deciliterspe double value = (double) deciliterspermililiter; return new VolumeConcentration(value, VolumeConcentrationUnit.DecilitersPerMililiter); } - /// /// Creates a from . /// @@ -374,7 +370,6 @@ public static VolumeConcentration FromDecimalFractions(double decimalfractions) double value = (double) decimalfractions; return new VolumeConcentration(value, VolumeConcentrationUnit.DecimalFraction); } - /// /// Creates a from . /// @@ -385,7 +380,6 @@ public static VolumeConcentration FromLitersPerLiter(double litersperliter) double value = (double) litersperliter; return new VolumeConcentration(value, VolumeConcentrationUnit.LitersPerLiter); } - /// /// Creates a from . /// @@ -396,7 +390,6 @@ public static VolumeConcentration FromLitersPerMililiter(double literspermililit double value = (double) literspermililiter; return new VolumeConcentration(value, VolumeConcentrationUnit.LitersPerMililiter); } - /// /// Creates a from . /// @@ -407,7 +400,6 @@ public static VolumeConcentration FromMicrolitersPerLiter(double microlitersperl double value = (double) microlitersperliter; return new VolumeConcentration(value, VolumeConcentrationUnit.MicrolitersPerLiter); } - /// /// Creates a from . /// @@ -418,7 +410,6 @@ public static VolumeConcentration FromMicrolitersPerMililiter(double microliters double value = (double) microliterspermililiter; return new VolumeConcentration(value, VolumeConcentrationUnit.MicrolitersPerMililiter); } - /// /// Creates a from . /// @@ -429,7 +420,6 @@ public static VolumeConcentration FromMillilitersPerLiter(double millilitersperl double value = (double) millilitersperliter; return new VolumeConcentration(value, VolumeConcentrationUnit.MillilitersPerLiter); } - /// /// Creates a from . /// @@ -440,7 +430,6 @@ public static VolumeConcentration FromMillilitersPerMililiter(double milliliters double value = (double) milliliterspermililiter; return new VolumeConcentration(value, VolumeConcentrationUnit.MillilitersPerMililiter); } - /// /// Creates a from . /// @@ -451,7 +440,6 @@ public static VolumeConcentration FromNanolitersPerLiter(double nanolitersperlit double value = (double) nanolitersperliter; return new VolumeConcentration(value, VolumeConcentrationUnit.NanolitersPerLiter); } - /// /// Creates a from . /// @@ -462,7 +450,6 @@ public static VolumeConcentration FromNanolitersPerMililiter(double nanoliterspe double value = (double) nanoliterspermililiter; return new VolumeConcentration(value, VolumeConcentrationUnit.NanolitersPerMililiter); } - /// /// Creates a from . /// @@ -473,7 +460,6 @@ public static VolumeConcentration FromPartsPerBillion(double partsperbillion) double value = (double) partsperbillion; return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerBillion); } - /// /// Creates a from . /// @@ -484,7 +470,6 @@ public static VolumeConcentration FromPartsPerMillion(double partspermillion) double value = (double) partspermillion; return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerMillion); } - /// /// Creates a from . /// @@ -495,7 +480,6 @@ public static VolumeConcentration FromPartsPerThousand(double partsperthousand) double value = (double) partsperthousand; return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerThousand); } - /// /// Creates a from . /// @@ -506,7 +490,6 @@ public static VolumeConcentration FromPartsPerTrillion(double partspertrillion) double value = (double) partspertrillion; return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerTrillion); } - /// /// Creates a from . /// @@ -517,7 +500,6 @@ public static VolumeConcentration FromPercent(double percent) double value = (double) percent; return new VolumeConcentration(value, VolumeConcentrationUnit.Percent); } - /// /// Creates a from . /// @@ -528,7 +510,6 @@ public static VolumeConcentration FromPicolitersPerLiter(double picolitersperlit double value = (double) picolitersperliter; return new VolumeConcentration(value, VolumeConcentrationUnit.PicolitersPerLiter); } - /// /// Creates a from . /// @@ -540,7 +521,6 @@ public static VolumeConcentration FromPicolitersPerMililiter(double picoliterspe return new VolumeConcentration(value, VolumeConcentrationUnit.PicolitersPerMililiter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlow.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlow.g.cs index 48d62d1026..b6e8930245 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlow.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlow.g.cs @@ -606,7 +606,6 @@ public static VolumeFlow FromAcreFeetPerDay(double acrefeetperday) double value = (double) acrefeetperday; return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerDay); } - /// /// Creates a from . /// @@ -617,7 +616,6 @@ public static VolumeFlow FromAcreFeetPerHour(double acrefeetperhour) double value = (double) acrefeetperhour; return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerHour); } - /// /// Creates a from . /// @@ -628,7 +626,6 @@ public static VolumeFlow FromAcreFeetPerMinute(double acrefeetperminute) double value = (double) acrefeetperminute; return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerMinute); } - /// /// Creates a from . /// @@ -639,7 +636,6 @@ public static VolumeFlow FromAcreFeetPerSecond(double acrefeetpersecond) double value = (double) acrefeetpersecond; return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerSecond); } - /// /// Creates a from . /// @@ -650,7 +646,6 @@ public static VolumeFlow FromCentilitersPerDay(double centilitersperday) double value = (double) centilitersperday; return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerDay); } - /// /// Creates a from . /// @@ -661,7 +656,6 @@ public static VolumeFlow FromCentilitersPerHour(double centilitersperhour) double value = (double) centilitersperhour; return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerHour); } - /// /// Creates a from . /// @@ -672,7 +666,6 @@ public static VolumeFlow FromCentilitersPerMinute(double centilitersperminute) double value = (double) centilitersperminute; return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerMinute); } - /// /// Creates a from . /// @@ -683,7 +676,6 @@ public static VolumeFlow FromCentilitersPerSecond(double centiliterspersecond) double value = (double) centiliterspersecond; return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerSecond); } - /// /// Creates a from . /// @@ -694,7 +686,6 @@ public static VolumeFlow FromCubicCentimetersPerMinute(double cubiccentimeterspe double value = (double) cubiccentimetersperminute; return new VolumeFlow(value, VolumeFlowUnit.CubicCentimeterPerMinute); } - /// /// Creates a from . /// @@ -705,7 +696,6 @@ public static VolumeFlow FromCubicDecimetersPerMinute(double cubicdecimetersperm double value = (double) cubicdecimetersperminute; return new VolumeFlow(value, VolumeFlowUnit.CubicDecimeterPerMinute); } - /// /// Creates a from . /// @@ -716,7 +706,6 @@ public static VolumeFlow FromCubicFeetPerHour(double cubicfeetperhour) double value = (double) cubicfeetperhour; return new VolumeFlow(value, VolumeFlowUnit.CubicFootPerHour); } - /// /// Creates a from . /// @@ -727,7 +716,6 @@ public static VolumeFlow FromCubicFeetPerMinute(double cubicfeetperminute) double value = (double) cubicfeetperminute; return new VolumeFlow(value, VolumeFlowUnit.CubicFootPerMinute); } - /// /// Creates a from . /// @@ -738,7 +726,6 @@ public static VolumeFlow FromCubicFeetPerSecond(double cubicfeetpersecond) double value = (double) cubicfeetpersecond; return new VolumeFlow(value, VolumeFlowUnit.CubicFootPerSecond); } - /// /// Creates a from . /// @@ -749,7 +736,6 @@ public static VolumeFlow FromCubicMetersPerDay(double cubicmetersperday) double value = (double) cubicmetersperday; return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerDay); } - /// /// Creates a from . /// @@ -760,7 +746,6 @@ public static VolumeFlow FromCubicMetersPerHour(double cubicmetersperhour) double value = (double) cubicmetersperhour; return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerHour); } - /// /// Creates a from . /// @@ -771,7 +756,6 @@ public static VolumeFlow FromCubicMetersPerMinute(double cubicmetersperminute) double value = (double) cubicmetersperminute; return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerMinute); } - /// /// Creates a from . /// @@ -782,7 +766,6 @@ public static VolumeFlow FromCubicMetersPerSecond(double cubicmeterspersecond) double value = (double) cubicmeterspersecond; return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerSecond); } - /// /// Creates a from . /// @@ -793,7 +776,6 @@ public static VolumeFlow FromCubicMillimetersPerSecond(double cubicmillimeterspe double value = (double) cubicmillimeterspersecond; return new VolumeFlow(value, VolumeFlowUnit.CubicMillimeterPerSecond); } - /// /// Creates a from . /// @@ -804,7 +786,6 @@ public static VolumeFlow FromCubicYardsPerDay(double cubicyardsperday) double value = (double) cubicyardsperday; return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerDay); } - /// /// Creates a from . /// @@ -815,7 +796,6 @@ public static VolumeFlow FromCubicYardsPerHour(double cubicyardsperhour) double value = (double) cubicyardsperhour; return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerHour); } - /// /// Creates a from . /// @@ -826,7 +806,6 @@ public static VolumeFlow FromCubicYardsPerMinute(double cubicyardsperminute) double value = (double) cubicyardsperminute; return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerMinute); } - /// /// Creates a from . /// @@ -837,7 +816,6 @@ public static VolumeFlow FromCubicYardsPerSecond(double cubicyardspersecond) double value = (double) cubicyardspersecond; return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerSecond); } - /// /// Creates a from . /// @@ -848,7 +826,6 @@ public static VolumeFlow FromDecilitersPerDay(double decilitersperday) double value = (double) decilitersperday; return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerDay); } - /// /// Creates a from . /// @@ -859,7 +836,6 @@ public static VolumeFlow FromDecilitersPerHour(double decilitersperhour) double value = (double) decilitersperhour; return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerHour); } - /// /// Creates a from . /// @@ -870,7 +846,6 @@ public static VolumeFlow FromDecilitersPerMinute(double decilitersperminute) double value = (double) decilitersperminute; return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerMinute); } - /// /// Creates a from . /// @@ -881,7 +856,6 @@ public static VolumeFlow FromDecilitersPerSecond(double deciliterspersecond) double value = (double) deciliterspersecond; return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerSecond); } - /// /// Creates a from . /// @@ -892,7 +866,6 @@ public static VolumeFlow FromKilolitersPerDay(double kilolitersperday) double value = (double) kilolitersperday; return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerDay); } - /// /// Creates a from . /// @@ -903,7 +876,6 @@ public static VolumeFlow FromKilolitersPerHour(double kilolitersperhour) double value = (double) kilolitersperhour; return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerHour); } - /// /// Creates a from . /// @@ -914,7 +886,6 @@ public static VolumeFlow FromKilolitersPerMinute(double kilolitersperminute) double value = (double) kilolitersperminute; return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerMinute); } - /// /// Creates a from . /// @@ -925,7 +896,6 @@ public static VolumeFlow FromKilolitersPerSecond(double kiloliterspersecond) double value = (double) kiloliterspersecond; return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerSecond); } - /// /// Creates a from . /// @@ -936,7 +906,6 @@ public static VolumeFlow FromKilousGallonsPerMinute(double kilousgallonsperminut double value = (double) kilousgallonsperminute; return new VolumeFlow(value, VolumeFlowUnit.KilousGallonPerMinute); } - /// /// Creates a from . /// @@ -947,7 +916,6 @@ public static VolumeFlow FromLitersPerDay(double litersperday) double value = (double) litersperday; return new VolumeFlow(value, VolumeFlowUnit.LiterPerDay); } - /// /// Creates a from . /// @@ -958,7 +926,6 @@ public static VolumeFlow FromLitersPerHour(double litersperhour) double value = (double) litersperhour; return new VolumeFlow(value, VolumeFlowUnit.LiterPerHour); } - /// /// Creates a from . /// @@ -969,7 +936,6 @@ public static VolumeFlow FromLitersPerMinute(double litersperminute) double value = (double) litersperminute; return new VolumeFlow(value, VolumeFlowUnit.LiterPerMinute); } - /// /// Creates a from . /// @@ -980,7 +946,6 @@ public static VolumeFlow FromLitersPerSecond(double literspersecond) double value = (double) literspersecond; return new VolumeFlow(value, VolumeFlowUnit.LiterPerSecond); } - /// /// Creates a from . /// @@ -991,7 +956,6 @@ public static VolumeFlow FromMegalitersPerDay(double megalitersperday) double value = (double) megalitersperday; return new VolumeFlow(value, VolumeFlowUnit.MegaliterPerDay); } - /// /// Creates a from . /// @@ -1002,7 +966,6 @@ public static VolumeFlow FromMegaukGallonsPerSecond(double megaukgallonspersecon double value = (double) megaukgallonspersecond; return new VolumeFlow(value, VolumeFlowUnit.MegaukGallonPerSecond); } - /// /// Creates a from . /// @@ -1013,7 +976,6 @@ public static VolumeFlow FromMicrolitersPerDay(double microlitersperday) double value = (double) microlitersperday; return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerDay); } - /// /// Creates a from . /// @@ -1024,7 +986,6 @@ public static VolumeFlow FromMicrolitersPerHour(double microlitersperhour) double value = (double) microlitersperhour; return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerHour); } - /// /// Creates a from . /// @@ -1035,7 +996,6 @@ public static VolumeFlow FromMicrolitersPerMinute(double microlitersperminute) double value = (double) microlitersperminute; return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerMinute); } - /// /// Creates a from . /// @@ -1046,7 +1006,6 @@ public static VolumeFlow FromMicrolitersPerSecond(double microliterspersecond) double value = (double) microliterspersecond; return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerSecond); } - /// /// Creates a from . /// @@ -1057,7 +1016,6 @@ public static VolumeFlow FromMillilitersPerDay(double millilitersperday) double value = (double) millilitersperday; return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerDay); } - /// /// Creates a from . /// @@ -1068,7 +1026,6 @@ public static VolumeFlow FromMillilitersPerHour(double millilitersperhour) double value = (double) millilitersperhour; return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerHour); } - /// /// Creates a from . /// @@ -1079,7 +1036,6 @@ public static VolumeFlow FromMillilitersPerMinute(double millilitersperminute) double value = (double) millilitersperminute; return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerMinute); } - /// /// Creates a from . /// @@ -1090,7 +1046,6 @@ public static VolumeFlow FromMillilitersPerSecond(double milliliterspersecond) double value = (double) milliliterspersecond; return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerSecond); } - /// /// Creates a from . /// @@ -1101,7 +1056,6 @@ public static VolumeFlow FromMillionUsGallonsPerDay(double millionusgallonsperda double value = (double) millionusgallonsperday; return new VolumeFlow(value, VolumeFlowUnit.MillionUsGallonsPerDay); } - /// /// Creates a from . /// @@ -1112,7 +1066,6 @@ public static VolumeFlow FromNanolitersPerDay(double nanolitersperday) double value = (double) nanolitersperday; return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerDay); } - /// /// Creates a from . /// @@ -1123,7 +1076,6 @@ public static VolumeFlow FromNanolitersPerHour(double nanolitersperhour) double value = (double) nanolitersperhour; return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerHour); } - /// /// Creates a from . /// @@ -1134,7 +1086,6 @@ public static VolumeFlow FromNanolitersPerMinute(double nanolitersperminute) double value = (double) nanolitersperminute; return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerMinute); } - /// /// Creates a from . /// @@ -1145,7 +1096,6 @@ public static VolumeFlow FromNanolitersPerSecond(double nanoliterspersecond) double value = (double) nanoliterspersecond; return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerSecond); } - /// /// Creates a from . /// @@ -1156,7 +1106,6 @@ public static VolumeFlow FromOilBarrelsPerDay(double oilbarrelsperday) double value = (double) oilbarrelsperday; return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerDay); } - /// /// Creates a from . /// @@ -1167,7 +1116,6 @@ public static VolumeFlow FromOilBarrelsPerHour(double oilbarrelsperhour) double value = (double) oilbarrelsperhour; return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerHour); } - /// /// Creates a from . /// @@ -1178,7 +1126,6 @@ public static VolumeFlow FromOilBarrelsPerMinute(double oilbarrelsperminute) double value = (double) oilbarrelsperminute; return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerMinute); } - /// /// Creates a from . /// @@ -1189,7 +1136,6 @@ public static VolumeFlow FromOilBarrelsPerSecond(double oilbarrelspersecond) double value = (double) oilbarrelspersecond; return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerSecond); } - /// /// Creates a from . /// @@ -1200,7 +1146,6 @@ public static VolumeFlow FromUkGallonsPerDay(double ukgallonsperday) double value = (double) ukgallonsperday; return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerDay); } - /// /// Creates a from . /// @@ -1211,7 +1156,6 @@ public static VolumeFlow FromUkGallonsPerHour(double ukgallonsperhour) double value = (double) ukgallonsperhour; return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerHour); } - /// /// Creates a from . /// @@ -1222,7 +1166,6 @@ public static VolumeFlow FromUkGallonsPerMinute(double ukgallonsperminute) double value = (double) ukgallonsperminute; return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerMinute); } - /// /// Creates a from . /// @@ -1233,7 +1176,6 @@ public static VolumeFlow FromUkGallonsPerSecond(double ukgallonspersecond) double value = (double) ukgallonspersecond; return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerSecond); } - /// /// Creates a from . /// @@ -1244,7 +1186,6 @@ public static VolumeFlow FromUsGallonsPerDay(double usgallonsperday) double value = (double) usgallonsperday; return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerDay); } - /// /// Creates a from . /// @@ -1255,7 +1196,6 @@ public static VolumeFlow FromUsGallonsPerHour(double usgallonsperhour) double value = (double) usgallonsperhour; return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerHour); } - /// /// Creates a from . /// @@ -1266,7 +1206,6 @@ public static VolumeFlow FromUsGallonsPerMinute(double usgallonsperminute) double value = (double) usgallonsperminute; return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerMinute); } - /// /// Creates a from . /// @@ -1278,7 +1217,6 @@ public static VolumeFlow FromUsGallonsPerSecond(double usgallonspersecond) return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerSecond); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs index ae9dbeb13c..85fe7aac9d 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs @@ -219,7 +219,6 @@ public static VolumeFlowPerArea FromCubicFeetPerMinutePerSquareFoot(double cubic double value = (double) cubicfeetperminutepersquarefoot; return new VolumeFlowPerArea(value, VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot); } - /// /// Creates a from . /// @@ -231,7 +230,6 @@ public static VolumeFlowPerArea FromCubicMetersPerSecondPerSquareMeter(double cu return new VolumeFlowPerArea(value, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumePerLength.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumePerLength.g.cs index 7762a31d00..76ff0e7d2e 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumePerLength.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumePerLength.g.cs @@ -249,7 +249,6 @@ public static VolumePerLength FromCubicMetersPerMeter(double cubicmeterspermeter double value = (double) cubicmeterspermeter; return new VolumePerLength(value, VolumePerLengthUnit.CubicMeterPerMeter); } - /// /// Creates a from . /// @@ -260,7 +259,6 @@ public static VolumePerLength FromCubicYardsPerFoot(double cubicyardsperfoot) double value = (double) cubicyardsperfoot; return new VolumePerLength(value, VolumePerLengthUnit.CubicYardPerFoot); } - /// /// Creates a from . /// @@ -271,7 +269,6 @@ public static VolumePerLength FromCubicYardsPerUsSurveyFoot(double cubicyardsper double value = (double) cubicyardsperussurveyfoot; return new VolumePerLength(value, VolumePerLengthUnit.CubicYardPerUsSurveyFoot); } - /// /// Creates a from . /// @@ -282,7 +279,6 @@ public static VolumePerLength FromLitersPerKilometer(double litersperkilometer) double value = (double) litersperkilometer; return new VolumePerLength(value, VolumePerLengthUnit.LiterPerKilometer); } - /// /// Creates a from . /// @@ -293,7 +289,6 @@ public static VolumePerLength FromLitersPerMeter(double literspermeter) double value = (double) literspermeter; return new VolumePerLength(value, VolumePerLengthUnit.LiterPerMeter); } - /// /// Creates a from . /// @@ -304,7 +299,6 @@ public static VolumePerLength FromLitersPerMillimeter(double literspermillimeter double value = (double) literspermillimeter; return new VolumePerLength(value, VolumePerLengthUnit.LiterPerMillimeter); } - /// /// Creates a from . /// @@ -316,7 +310,6 @@ public static VolumePerLength FromOilBarrelsPerFoot(double oilbarrelsperfoot) return new VolumePerLength(value, VolumePerLengthUnit.OilBarrelPerFoot); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs index 240640f6cf..84b42e0e57 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs @@ -264,7 +264,6 @@ public static VolumetricHeatCapacity FromBtusPerCubicFootDegreeFahrenheit(double double value = (double) btuspercubicfootdegreefahrenheit; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit); } - /// /// Creates a from . /// @@ -275,7 +274,6 @@ public static VolumetricHeatCapacity FromCaloriesPerCubicCentimeterDegreeCelsius double value = (double) caloriespercubiccentimeterdegreecelsius; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius); } - /// /// Creates a from . /// @@ -286,7 +284,6 @@ public static VolumetricHeatCapacity FromJoulesPerCubicMeterDegreeCelsius(double double value = (double) joulespercubicmeterdegreecelsius; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius); } - /// /// Creates a from . /// @@ -297,7 +294,6 @@ public static VolumetricHeatCapacity FromJoulesPerCubicMeterKelvin(double joules double value = (double) joulespercubicmeterkelvin; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin); } - /// /// Creates a from . /// @@ -308,7 +304,6 @@ public static VolumetricHeatCapacity FromKilocaloriesPerCubicCentimeterDegreeCel double value = (double) kilocaloriespercubiccentimeterdegreecelsius; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius); } - /// /// Creates a from . /// @@ -319,7 +314,6 @@ public static VolumetricHeatCapacity FromKilojoulesPerCubicMeterDegreeCelsius(do double value = (double) kilojoulespercubicmeterdegreecelsius; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius); } - /// /// Creates a from . /// @@ -330,7 +324,6 @@ public static VolumetricHeatCapacity FromKilojoulesPerCubicMeterKelvin(double ki double value = (double) kilojoulespercubicmeterkelvin; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin); } - /// /// Creates a from . /// @@ -341,7 +334,6 @@ public static VolumetricHeatCapacity FromMegajoulesPerCubicMeterDegreeCelsius(do double value = (double) megajoulespercubicmeterdegreecelsius; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius); } - /// /// Creates a from . /// @@ -353,7 +345,6 @@ public static VolumetricHeatCapacity FromMegajoulesPerCubicMeterKelvin(double me return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs index 05f72acb75..8993c6a358 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs @@ -243,7 +243,6 @@ public static WarpingMomentOfInertia FromCentimetersToTheSixth(double centimeter double value = (double) centimeterstothesixth; return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.CentimeterToTheSixth); } - /// /// Creates a from . /// @@ -254,7 +253,6 @@ public static WarpingMomentOfInertia FromDecimetersToTheSixth(double decimeterst double value = (double) decimeterstothesixth; return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.DecimeterToTheSixth); } - /// /// Creates a from . /// @@ -265,7 +263,6 @@ public static WarpingMomentOfInertia FromFeetToTheSixth(double feettothesixth) double value = (double) feettothesixth; return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.FootToTheSixth); } - /// /// Creates a from . /// @@ -276,7 +273,6 @@ public static WarpingMomentOfInertia FromInchesToTheSixth(double inchestothesixt double value = (double) inchestothesixth; return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.InchToTheSixth); } - /// /// Creates a from . /// @@ -287,7 +283,6 @@ public static WarpingMomentOfInertia FromMetersToTheSixth(double meterstothesixt double value = (double) meterstothesixth; return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.MeterToTheSixth); } - /// /// Creates a from . /// @@ -299,7 +294,6 @@ public static WarpingMomentOfInertia FromMillimetersToTheSixth(double millimeter return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.MillimeterToTheSixth); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs b/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs index 8793b9a15e..a7ee842c55 100644 --- a/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs @@ -380,7 +380,6 @@ public static Acceleration FromCentimetersPerSecondSquared(QuantityValue centime double value = (double) centimeterspersecondsquared; return new Acceleration(value, AccelerationUnit.CentimeterPerSecondSquared); } - /// /// Creates a from . /// @@ -390,7 +389,6 @@ public static Acceleration FromDecimetersPerSecondSquared(QuantityValue decimete double value = (double) decimeterspersecondsquared; return new Acceleration(value, AccelerationUnit.DecimeterPerSecondSquared); } - /// /// Creates a from . /// @@ -400,7 +398,6 @@ public static Acceleration FromFeetPerSecondSquared(QuantityValue feetperseconds double value = (double) feetpersecondsquared; return new Acceleration(value, AccelerationUnit.FootPerSecondSquared); } - /// /// Creates a from . /// @@ -410,7 +407,6 @@ public static Acceleration FromInchesPerSecondSquared(QuantityValue inchespersec double value = (double) inchespersecondsquared; return new Acceleration(value, AccelerationUnit.InchPerSecondSquared); } - /// /// Creates a from . /// @@ -420,7 +416,6 @@ public static Acceleration FromKilometersPerSecondSquared(QuantityValue kilomete double value = (double) kilometerspersecondsquared; return new Acceleration(value, AccelerationUnit.KilometerPerSecondSquared); } - /// /// Creates a from . /// @@ -430,7 +425,6 @@ public static Acceleration FromKnotsPerHour(QuantityValue knotsperhour) double value = (double) knotsperhour; return new Acceleration(value, AccelerationUnit.KnotPerHour); } - /// /// Creates a from . /// @@ -440,7 +434,6 @@ public static Acceleration FromKnotsPerMinute(QuantityValue knotsperminute) double value = (double) knotsperminute; return new Acceleration(value, AccelerationUnit.KnotPerMinute); } - /// /// Creates a from . /// @@ -450,7 +443,6 @@ public static Acceleration FromKnotsPerSecond(QuantityValue knotspersecond) double value = (double) knotspersecond; return new Acceleration(value, AccelerationUnit.KnotPerSecond); } - /// /// Creates a from . /// @@ -460,7 +452,6 @@ public static Acceleration FromMetersPerSecondSquared(QuantityValue meterspersec double value = (double) meterspersecondsquared; return new Acceleration(value, AccelerationUnit.MeterPerSecondSquared); } - /// /// Creates a from . /// @@ -470,7 +461,6 @@ public static Acceleration FromMicrometersPerSecondSquared(QuantityValue microme double value = (double) micrometerspersecondsquared; return new Acceleration(value, AccelerationUnit.MicrometerPerSecondSquared); } - /// /// Creates a from . /// @@ -480,7 +470,6 @@ public static Acceleration FromMillimetersPerSecondSquared(QuantityValue millime double value = (double) millimeterspersecondsquared; return new Acceleration(value, AccelerationUnit.MillimeterPerSecondSquared); } - /// /// Creates a from . /// @@ -490,7 +479,6 @@ public static Acceleration FromMillistandardGravity(QuantityValue millistandardg double value = (double) millistandardgravity; return new Acceleration(value, AccelerationUnit.MillistandardGravity); } - /// /// Creates a from . /// @@ -500,7 +488,6 @@ public static Acceleration FromNanometersPerSecondSquared(QuantityValue nanomete double value = (double) nanometerspersecondsquared; return new Acceleration(value, AccelerationUnit.NanometerPerSecondSquared); } - /// /// Creates a from . /// @@ -511,7 +498,6 @@ public static Acceleration FromStandardGravity(QuantityValue standardgravity) return new Acceleration(value, AccelerationUnit.StandardGravity); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs b/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs index 7025dae47b..12dbe1c97a 100644 --- a/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs @@ -375,7 +375,6 @@ public static AmountOfSubstance FromCentimoles(QuantityValue centimoles) double value = (double) centimoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Centimole); } - /// /// Creates a from . /// @@ -385,7 +384,6 @@ public static AmountOfSubstance FromCentipoundMoles(QuantityValue centipoundmole double value = (double) centipoundmoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.CentipoundMole); } - /// /// Creates a from . /// @@ -395,7 +393,6 @@ public static AmountOfSubstance FromDecimoles(QuantityValue decimoles) double value = (double) decimoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Decimole); } - /// /// Creates a from . /// @@ -405,7 +402,6 @@ public static AmountOfSubstance FromDecipoundMoles(QuantityValue decipoundmoles) double value = (double) decipoundmoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.DecipoundMole); } - /// /// Creates a from . /// @@ -415,7 +411,6 @@ public static AmountOfSubstance FromKilomoles(QuantityValue kilomoles) double value = (double) kilomoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Kilomole); } - /// /// Creates a from . /// @@ -425,7 +420,6 @@ public static AmountOfSubstance FromKilopoundMoles(QuantityValue kilopoundmoles) double value = (double) kilopoundmoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.KilopoundMole); } - /// /// Creates a from . /// @@ -435,7 +429,6 @@ public static AmountOfSubstance FromMegamoles(QuantityValue megamoles) double value = (double) megamoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Megamole); } - /// /// Creates a from . /// @@ -445,7 +438,6 @@ public static AmountOfSubstance FromMicromoles(QuantityValue micromoles) double value = (double) micromoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Micromole); } - /// /// Creates a from . /// @@ -455,7 +447,6 @@ public static AmountOfSubstance FromMicropoundMoles(QuantityValue micropoundmole double value = (double) micropoundmoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.MicropoundMole); } - /// /// Creates a from . /// @@ -465,7 +456,6 @@ public static AmountOfSubstance FromMillimoles(QuantityValue millimoles) double value = (double) millimoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Millimole); } - /// /// Creates a from . /// @@ -475,7 +465,6 @@ public static AmountOfSubstance FromMillipoundMoles(QuantityValue millipoundmole double value = (double) millipoundmoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.MillipoundMole); } - /// /// Creates a from . /// @@ -485,7 +474,6 @@ public static AmountOfSubstance FromMoles(QuantityValue moles) double value = (double) moles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Mole); } - /// /// Creates a from . /// @@ -495,7 +483,6 @@ public static AmountOfSubstance FromNanomoles(QuantityValue nanomoles) double value = (double) nanomoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.Nanomole); } - /// /// Creates a from . /// @@ -505,7 +492,6 @@ public static AmountOfSubstance FromNanopoundMoles(QuantityValue nanopoundmoles) double value = (double) nanopoundmoles; return new AmountOfSubstance(value, AmountOfSubstanceUnit.NanopoundMole); } - /// /// Creates a from . /// @@ -516,7 +502,6 @@ public static AmountOfSubstance FromPoundMoles(QuantityValue poundmoles) return new AmountOfSubstance(value, AmountOfSubstanceUnit.PoundMole); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.g.cs b/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.g.cs index 999d1f0c0a..626c69f760 100644 --- a/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.g.cs @@ -276,7 +276,6 @@ public static AmplitudeRatio FromDecibelMicrovolts(QuantityValue decibelmicrovol double value = (double) decibelmicrovolts; return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelMicrovolt); } - /// /// Creates a from . /// @@ -286,7 +285,6 @@ public static AmplitudeRatio FromDecibelMillivolts(QuantityValue decibelmillivol double value = (double) decibelmillivolts; return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelMillivolt); } - /// /// Creates a from . /// @@ -296,7 +294,6 @@ public static AmplitudeRatio FromDecibelsUnloaded(QuantityValue decibelsunloaded double value = (double) decibelsunloaded; return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelUnloaded); } - /// /// Creates a from . /// @@ -307,7 +304,6 @@ public static AmplitudeRatio FromDecibelVolts(QuantityValue decibelvolts) return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelVolt); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Angle.g.cs b/UnitsNet/GeneratedCode/Quantities/Angle.g.cs index eb7cb4a335..9c4fb04aa6 100644 --- a/UnitsNet/GeneratedCode/Quantities/Angle.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Angle.g.cs @@ -396,7 +396,6 @@ public static Angle FromArcminutes(QuantityValue arcminutes) double value = (double) arcminutes; return new Angle(value, AngleUnit.Arcminute); } - /// /// Creates a from . /// @@ -406,7 +405,6 @@ public static Angle FromArcseconds(QuantityValue arcseconds) double value = (double) arcseconds; return new Angle(value, AngleUnit.Arcsecond); } - /// /// Creates a from . /// @@ -416,7 +414,6 @@ public static Angle FromCentiradians(QuantityValue centiradians) double value = (double) centiradians; return new Angle(value, AngleUnit.Centiradian); } - /// /// Creates a from . /// @@ -426,7 +423,6 @@ public static Angle FromDeciradians(QuantityValue deciradians) double value = (double) deciradians; return new Angle(value, AngleUnit.Deciradian); } - /// /// Creates a from . /// @@ -436,7 +432,6 @@ public static Angle FromDegrees(QuantityValue degrees) double value = (double) degrees; return new Angle(value, AngleUnit.Degree); } - /// /// Creates a from . /// @@ -446,7 +441,6 @@ public static Angle FromGradians(QuantityValue gradians) double value = (double) gradians; return new Angle(value, AngleUnit.Gradian); } - /// /// Creates a from . /// @@ -456,7 +450,6 @@ public static Angle FromMicrodegrees(QuantityValue microdegrees) double value = (double) microdegrees; return new Angle(value, AngleUnit.Microdegree); } - /// /// Creates a from . /// @@ -466,7 +459,6 @@ public static Angle FromMicroradians(QuantityValue microradians) double value = (double) microradians; return new Angle(value, AngleUnit.Microradian); } - /// /// Creates a from . /// @@ -476,7 +468,6 @@ public static Angle FromMillidegrees(QuantityValue millidegrees) double value = (double) millidegrees; return new Angle(value, AngleUnit.Millidegree); } - /// /// Creates a from . /// @@ -486,7 +477,6 @@ public static Angle FromMilliradians(QuantityValue milliradians) double value = (double) milliradians; return new Angle(value, AngleUnit.Milliradian); } - /// /// Creates a from . /// @@ -496,7 +486,6 @@ public static Angle FromNanodegrees(QuantityValue nanodegrees) double value = (double) nanodegrees; return new Angle(value, AngleUnit.Nanodegree); } - /// /// Creates a from . /// @@ -506,7 +495,6 @@ public static Angle FromNanoradians(QuantityValue nanoradians) double value = (double) nanoradians; return new Angle(value, AngleUnit.Nanoradian); } - /// /// Creates a from . /// @@ -516,7 +504,6 @@ public static Angle FromNatoMils(QuantityValue natomils) double value = (double) natomils; return new Angle(value, AngleUnit.NatoMil); } - /// /// Creates a from . /// @@ -526,7 +513,6 @@ public static Angle FromRadians(QuantityValue radians) double value = (double) radians; return new Angle(value, AngleUnit.Radian); } - /// /// Creates a from . /// @@ -536,7 +522,6 @@ public static Angle FromRevolutions(QuantityValue revolutions) double value = (double) revolutions; return new Angle(value, AngleUnit.Revolution); } - /// /// Creates a from . /// @@ -547,7 +532,6 @@ public static Angle FromTilt(QuantityValue tilt) return new Angle(value, AngleUnit.Tilt); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.g.cs index 9cc6ed3e57..4c0623669f 100644 --- a/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.g.cs @@ -267,7 +267,6 @@ public static ApparentEnergy FromKilovoltampereHours(QuantityValue kilovoltamper double value = (double) kilovoltamperehours; return new ApparentEnergy(value, ApparentEnergyUnit.KilovoltampereHour); } - /// /// Creates a from . /// @@ -277,7 +276,6 @@ public static ApparentEnergy FromMegavoltampereHours(QuantityValue megavoltamper double value = (double) megavoltamperehours; return new ApparentEnergy(value, ApparentEnergyUnit.MegavoltampereHour); } - /// /// Creates a from . /// @@ -288,7 +286,6 @@ public static ApparentEnergy FromVoltampereHours(QuantityValue voltamperehours) return new ApparentEnergy(value, ApparentEnergyUnit.VoltampereHour); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ApparentPower.g.cs b/UnitsNet/GeneratedCode/Quantities/ApparentPower.g.cs index 9f751534ac..3dc937dd16 100644 --- a/UnitsNet/GeneratedCode/Quantities/ApparentPower.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ApparentPower.g.cs @@ -276,7 +276,6 @@ public static ApparentPower FromGigavoltamperes(QuantityValue gigavoltamperes) double value = (double) gigavoltamperes; return new ApparentPower(value, ApparentPowerUnit.Gigavoltampere); } - /// /// Creates a from . /// @@ -286,7 +285,6 @@ public static ApparentPower FromKilovoltamperes(QuantityValue kilovoltamperes) double value = (double) kilovoltamperes; return new ApparentPower(value, ApparentPowerUnit.Kilovoltampere); } - /// /// Creates a from . /// @@ -296,7 +294,6 @@ public static ApparentPower FromMegavoltamperes(QuantityValue megavoltamperes) double value = (double) megavoltamperes; return new ApparentPower(value, ApparentPowerUnit.Megavoltampere); } - /// /// Creates a from . /// @@ -307,7 +304,6 @@ public static ApparentPower FromVoltamperes(QuantityValue voltamperes) return new ApparentPower(value, ApparentPowerUnit.Voltampere); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Area.g.cs b/UnitsNet/GeneratedCode/Quantities/Area.g.cs index af9ef0c57e..df0bb627b3 100644 --- a/UnitsNet/GeneratedCode/Quantities/Area.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Area.g.cs @@ -393,7 +393,6 @@ public static Area FromAcres(QuantityValue acres) double value = (double) acres; return new Area(value, AreaUnit.Acre); } - /// /// Creates a from . /// @@ -403,7 +402,6 @@ public static Area FromHectares(QuantityValue hectares) double value = (double) hectares; return new Area(value, AreaUnit.Hectare); } - /// /// Creates a from . /// @@ -413,7 +411,6 @@ public static Area FromSquareCentimeters(QuantityValue squarecentimeters) double value = (double) squarecentimeters; return new Area(value, AreaUnit.SquareCentimeter); } - /// /// Creates a from . /// @@ -423,7 +420,6 @@ public static Area FromSquareDecimeters(QuantityValue squaredecimeters) double value = (double) squaredecimeters; return new Area(value, AreaUnit.SquareDecimeter); } - /// /// Creates a from . /// @@ -433,7 +429,6 @@ public static Area FromSquareFeet(QuantityValue squarefeet) double value = (double) squarefeet; return new Area(value, AreaUnit.SquareFoot); } - /// /// Creates a from . /// @@ -443,7 +438,6 @@ public static Area FromSquareInches(QuantityValue squareinches) double value = (double) squareinches; return new Area(value, AreaUnit.SquareInch); } - /// /// Creates a from . /// @@ -453,7 +447,6 @@ public static Area FromSquareKilometers(QuantityValue squarekilometers) double value = (double) squarekilometers; return new Area(value, AreaUnit.SquareKilometer); } - /// /// Creates a from . /// @@ -463,7 +456,6 @@ public static Area FromSquareMeters(QuantityValue squaremeters) double value = (double) squaremeters; return new Area(value, AreaUnit.SquareMeter); } - /// /// Creates a from . /// @@ -473,7 +465,6 @@ public static Area FromSquareMicrometers(QuantityValue squaremicrometers) double value = (double) squaremicrometers; return new Area(value, AreaUnit.SquareMicrometer); } - /// /// Creates a from . /// @@ -483,7 +474,6 @@ public static Area FromSquareMiles(QuantityValue squaremiles) double value = (double) squaremiles; return new Area(value, AreaUnit.SquareMile); } - /// /// Creates a from . /// @@ -493,7 +483,6 @@ public static Area FromSquareMillimeters(QuantityValue squaremillimeters) double value = (double) squaremillimeters; return new Area(value, AreaUnit.SquareMillimeter); } - /// /// Creates a from . /// @@ -503,7 +492,6 @@ public static Area FromSquareNauticalMiles(QuantityValue squarenauticalmiles) double value = (double) squarenauticalmiles; return new Area(value, AreaUnit.SquareNauticalMile); } - /// /// Creates a from . /// @@ -513,7 +501,6 @@ public static Area FromSquareYards(QuantityValue squareyards) double value = (double) squareyards; return new Area(value, AreaUnit.SquareYard); } - /// /// Creates a from . /// @@ -524,7 +511,6 @@ public static Area FromUsSurveySquareFeet(QuantityValue ussurveysquarefeet) return new Area(value, AreaUnit.UsSurveySquareFoot); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs index 6a0ae142b7..1b84ba6e88 100644 --- a/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs @@ -250,7 +250,6 @@ public static AreaDensity FromKilogramsPerSquareMeter(QuantityValue kilogramsper return new AreaDensity(value, AreaDensityUnit.KilogramPerSquareMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs b/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs index 609913636d..1e3ea38167 100644 --- a/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs @@ -294,7 +294,6 @@ public static AreaMomentOfInertia FromCentimetersToTheFourth(QuantityValue centi double value = (double) centimeterstothefourth; return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.CentimeterToTheFourth); } - /// /// Creates a from . /// @@ -304,7 +303,6 @@ public static AreaMomentOfInertia FromDecimetersToTheFourth(QuantityValue decime double value = (double) decimeterstothefourth; return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.DecimeterToTheFourth); } - /// /// Creates a from . /// @@ -314,7 +312,6 @@ public static AreaMomentOfInertia FromFeetToTheFourth(QuantityValue feettothefou double value = (double) feettothefourth; return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.FootToTheFourth); } - /// /// Creates a from . /// @@ -324,7 +321,6 @@ public static AreaMomentOfInertia FromInchesToTheFourth(QuantityValue inchestoth double value = (double) inchestothefourth; return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.InchToTheFourth); } - /// /// Creates a from . /// @@ -334,7 +330,6 @@ public static AreaMomentOfInertia FromMetersToTheFourth(QuantityValue meterstoth double value = (double) meterstothefourth; return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.MeterToTheFourth); } - /// /// Creates a from . /// @@ -345,7 +340,6 @@ public static AreaMomentOfInertia FromMillimetersToTheFourth(QuantityValue milli return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.MillimeterToTheFourth); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs b/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs index 62509d62b6..782763d075 100644 --- a/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs @@ -482,7 +482,6 @@ public static BitRate FromBitsPerSecond(QuantityValue bitspersecond) decimal value = (decimal) bitspersecond; return new BitRate(value, BitRateUnit.BitPerSecond); } - /// /// Creates a from . /// @@ -492,7 +491,6 @@ public static BitRate FromBytesPerSecond(QuantityValue bytespersecond) decimal value = (decimal) bytespersecond; return new BitRate(value, BitRateUnit.BytePerSecond); } - /// /// Creates a from . /// @@ -502,7 +500,6 @@ public static BitRate FromExabitsPerSecond(QuantityValue exabitspersecond) decimal value = (decimal) exabitspersecond; return new BitRate(value, BitRateUnit.ExabitPerSecond); } - /// /// Creates a from . /// @@ -512,7 +509,6 @@ public static BitRate FromExabytesPerSecond(QuantityValue exabytespersecond) decimal value = (decimal) exabytespersecond; return new BitRate(value, BitRateUnit.ExabytePerSecond); } - /// /// Creates a from . /// @@ -522,7 +518,6 @@ public static BitRate FromExbibitsPerSecond(QuantityValue exbibitspersecond) decimal value = (decimal) exbibitspersecond; return new BitRate(value, BitRateUnit.ExbibitPerSecond); } - /// /// Creates a from . /// @@ -532,7 +527,6 @@ public static BitRate FromExbibytesPerSecond(QuantityValue exbibytespersecond) decimal value = (decimal) exbibytespersecond; return new BitRate(value, BitRateUnit.ExbibytePerSecond); } - /// /// Creates a from . /// @@ -542,7 +536,6 @@ public static BitRate FromGibibitsPerSecond(QuantityValue gibibitspersecond) decimal value = (decimal) gibibitspersecond; return new BitRate(value, BitRateUnit.GibibitPerSecond); } - /// /// Creates a from . /// @@ -552,7 +545,6 @@ public static BitRate FromGibibytesPerSecond(QuantityValue gibibytespersecond) decimal value = (decimal) gibibytespersecond; return new BitRate(value, BitRateUnit.GibibytePerSecond); } - /// /// Creates a from . /// @@ -562,7 +554,6 @@ public static BitRate FromGigabitsPerSecond(QuantityValue gigabitspersecond) decimal value = (decimal) gigabitspersecond; return new BitRate(value, BitRateUnit.GigabitPerSecond); } - /// /// Creates a from . /// @@ -572,7 +563,6 @@ public static BitRate FromGigabytesPerSecond(QuantityValue gigabytespersecond) decimal value = (decimal) gigabytespersecond; return new BitRate(value, BitRateUnit.GigabytePerSecond); } - /// /// Creates a from . /// @@ -582,7 +572,6 @@ public static BitRate FromKibibitsPerSecond(QuantityValue kibibitspersecond) decimal value = (decimal) kibibitspersecond; return new BitRate(value, BitRateUnit.KibibitPerSecond); } - /// /// Creates a from . /// @@ -592,7 +581,6 @@ public static BitRate FromKibibytesPerSecond(QuantityValue kibibytespersecond) decimal value = (decimal) kibibytespersecond; return new BitRate(value, BitRateUnit.KibibytePerSecond); } - /// /// Creates a from . /// @@ -602,7 +590,6 @@ public static BitRate FromKilobitsPerSecond(QuantityValue kilobitspersecond) decimal value = (decimal) kilobitspersecond; return new BitRate(value, BitRateUnit.KilobitPerSecond); } - /// /// Creates a from . /// @@ -612,7 +599,6 @@ public static BitRate FromKilobytesPerSecond(QuantityValue kilobytespersecond) decimal value = (decimal) kilobytespersecond; return new BitRate(value, BitRateUnit.KilobytePerSecond); } - /// /// Creates a from . /// @@ -622,7 +608,6 @@ public static BitRate FromMebibitsPerSecond(QuantityValue mebibitspersecond) decimal value = (decimal) mebibitspersecond; return new BitRate(value, BitRateUnit.MebibitPerSecond); } - /// /// Creates a from . /// @@ -632,7 +617,6 @@ public static BitRate FromMebibytesPerSecond(QuantityValue mebibytespersecond) decimal value = (decimal) mebibytespersecond; return new BitRate(value, BitRateUnit.MebibytePerSecond); } - /// /// Creates a from . /// @@ -642,7 +626,6 @@ public static BitRate FromMegabitsPerSecond(QuantityValue megabitspersecond) decimal value = (decimal) megabitspersecond; return new BitRate(value, BitRateUnit.MegabitPerSecond); } - /// /// Creates a from . /// @@ -652,7 +635,6 @@ public static BitRate FromMegabytesPerSecond(QuantityValue megabytespersecond) decimal value = (decimal) megabytespersecond; return new BitRate(value, BitRateUnit.MegabytePerSecond); } - /// /// Creates a from . /// @@ -662,7 +644,6 @@ public static BitRate FromPebibitsPerSecond(QuantityValue pebibitspersecond) decimal value = (decimal) pebibitspersecond; return new BitRate(value, BitRateUnit.PebibitPerSecond); } - /// /// Creates a from . /// @@ -672,7 +653,6 @@ public static BitRate FromPebibytesPerSecond(QuantityValue pebibytespersecond) decimal value = (decimal) pebibytespersecond; return new BitRate(value, BitRateUnit.PebibytePerSecond); } - /// /// Creates a from . /// @@ -682,7 +662,6 @@ public static BitRate FromPetabitsPerSecond(QuantityValue petabitspersecond) decimal value = (decimal) petabitspersecond; return new BitRate(value, BitRateUnit.PetabitPerSecond); } - /// /// Creates a from . /// @@ -692,7 +671,6 @@ public static BitRate FromPetabytesPerSecond(QuantityValue petabytespersecond) decimal value = (decimal) petabytespersecond; return new BitRate(value, BitRateUnit.PetabytePerSecond); } - /// /// Creates a from . /// @@ -702,7 +680,6 @@ public static BitRate FromTebibitsPerSecond(QuantityValue tebibitspersecond) decimal value = (decimal) tebibitspersecond; return new BitRate(value, BitRateUnit.TebibitPerSecond); } - /// /// Creates a from . /// @@ -712,7 +689,6 @@ public static BitRate FromTebibytesPerSecond(QuantityValue tebibytespersecond) decimal value = (decimal) tebibytespersecond; return new BitRate(value, BitRateUnit.TebibytePerSecond); } - /// /// Creates a from . /// @@ -722,7 +698,6 @@ public static BitRate FromTerabitsPerSecond(QuantityValue terabitspersecond) decimal value = (decimal) terabitspersecond; return new BitRate(value, BitRateUnit.TerabitPerSecond); } - /// /// Creates a from . /// @@ -733,7 +708,6 @@ public static BitRate FromTerabytesPerSecond(QuantityValue terabytespersecond) return new BitRate(value, BitRateUnit.TerabytePerSecond); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs b/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs index 3b000719b8..12594dff4c 100644 --- a/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs @@ -267,7 +267,6 @@ public static BrakeSpecificFuelConsumption FromGramsPerKiloWattHour(QuantityValu double value = (double) gramsperkilowatthour; return new BrakeSpecificFuelConsumption(value, BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour); } - /// /// Creates a from . /// @@ -277,7 +276,6 @@ public static BrakeSpecificFuelConsumption FromKilogramsPerJoule(QuantityValue k double value = (double) kilogramsperjoule; return new BrakeSpecificFuelConsumption(value, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule); } - /// /// Creates a from . /// @@ -288,7 +286,6 @@ public static BrakeSpecificFuelConsumption FromPoundsPerMechanicalHorsepowerHour return new BrakeSpecificFuelConsumption(value, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Capacitance.g.cs b/UnitsNet/GeneratedCode/Quantities/Capacitance.g.cs index 43b5838a04..8362867d16 100644 --- a/UnitsNet/GeneratedCode/Quantities/Capacitance.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Capacitance.g.cs @@ -306,7 +306,6 @@ public static Capacitance FromFarads(QuantityValue farads) double value = (double) farads; return new Capacitance(value, CapacitanceUnit.Farad); } - /// /// Creates a from . /// @@ -316,7 +315,6 @@ public static Capacitance FromKilofarads(QuantityValue kilofarads) double value = (double) kilofarads; return new Capacitance(value, CapacitanceUnit.Kilofarad); } - /// /// Creates a from . /// @@ -326,7 +324,6 @@ public static Capacitance FromMegafarads(QuantityValue megafarads) double value = (double) megafarads; return new Capacitance(value, CapacitanceUnit.Megafarad); } - /// /// Creates a from . /// @@ -336,7 +333,6 @@ public static Capacitance FromMicrofarads(QuantityValue microfarads) double value = (double) microfarads; return new Capacitance(value, CapacitanceUnit.Microfarad); } - /// /// Creates a from . /// @@ -346,7 +342,6 @@ public static Capacitance FromMillifarads(QuantityValue millifarads) double value = (double) millifarads; return new Capacitance(value, CapacitanceUnit.Millifarad); } - /// /// Creates a from . /// @@ -356,7 +351,6 @@ public static Capacitance FromNanofarads(QuantityValue nanofarads) double value = (double) nanofarads; return new Capacitance(value, CapacitanceUnit.Nanofarad); } - /// /// Creates a from . /// @@ -367,7 +361,6 @@ public static Capacitance FromPicofarads(QuantityValue picofarads) return new Capacitance(value, CapacitanceUnit.Picofarad); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs b/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs index edfc69f126..c0b951f7fb 100644 --- a/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs @@ -267,7 +267,6 @@ public static CoefficientOfThermalExpansion FromInverseDegreeCelsius(QuantityVal double value = (double) inversedegreecelsius; return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.InverseDegreeCelsius); } - /// /// Creates a from . /// @@ -277,7 +276,6 @@ public static CoefficientOfThermalExpansion FromInverseDegreeFahrenheit(Quantity double value = (double) inversedegreefahrenheit; return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit); } - /// /// Creates a from . /// @@ -288,7 +286,6 @@ public static CoefficientOfThermalExpansion FromInverseKelvin(QuantityValue inve return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.InverseKelvin); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs b/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs index 015ba68598..938cb4afd4 100644 --- a/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs @@ -303,7 +303,6 @@ public static Compressibility FromInverseAtmospheres(QuantityValue inverseatmosp double value = (double) inverseatmospheres; return new Compressibility(value, CompressibilityUnit.InverseAtmosphere); } - /// /// Creates a from . /// @@ -313,7 +312,6 @@ public static Compressibility FromInverseBars(QuantityValue inversebars) double value = (double) inversebars; return new Compressibility(value, CompressibilityUnit.InverseBar); } - /// /// Creates a from . /// @@ -323,7 +321,6 @@ public static Compressibility FromInverseKilopascals(QuantityValue inversekilopa double value = (double) inversekilopascals; return new Compressibility(value, CompressibilityUnit.InverseKilopascal); } - /// /// Creates a from . /// @@ -333,7 +330,6 @@ public static Compressibility FromInverseMegapascals(QuantityValue inversemegapa double value = (double) inversemegapascals; return new Compressibility(value, CompressibilityUnit.InverseMegapascal); } - /// /// Creates a from . /// @@ -343,7 +339,6 @@ public static Compressibility FromInverseMillibars(QuantityValue inversemillibar double value = (double) inversemillibars; return new Compressibility(value, CompressibilityUnit.InverseMillibar); } - /// /// Creates a from . /// @@ -353,7 +348,6 @@ public static Compressibility FromInversePascals(QuantityValue inversepascals) double value = (double) inversepascals; return new Compressibility(value, CompressibilityUnit.InversePascal); } - /// /// Creates a from . /// @@ -364,7 +358,6 @@ public static Compressibility FromInversePoundForcePerSquareInchs(QuantityValue return new Compressibility(value, CompressibilityUnit.InversePoundForcePerSquareInch); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Density.g.cs b/UnitsNet/GeneratedCode/Quantities/Density.g.cs index 95c6c8af5d..e8e364e55e 100644 --- a/UnitsNet/GeneratedCode/Quantities/Density.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Density.g.cs @@ -706,7 +706,6 @@ public static Density FromCentigramsPerDeciLiter(QuantityValue centigramsperdeci double value = (double) centigramsperdeciliter; return new Density(value, DensityUnit.CentigramPerDeciliter); } - /// /// Creates a from . /// @@ -716,7 +715,6 @@ public static Density FromCentigramsPerLiter(QuantityValue centigramsperliter) double value = (double) centigramsperliter; return new Density(value, DensityUnit.CentigramPerLiter); } - /// /// Creates a from . /// @@ -726,7 +724,6 @@ public static Density FromCentigramsPerMilliliter(QuantityValue centigramspermil double value = (double) centigramspermilliliter; return new Density(value, DensityUnit.CentigramPerMilliliter); } - /// /// Creates a from . /// @@ -736,7 +733,6 @@ public static Density FromDecigramsPerDeciLiter(QuantityValue decigramsperdecili double value = (double) decigramsperdeciliter; return new Density(value, DensityUnit.DecigramPerDeciliter); } - /// /// Creates a from . /// @@ -746,7 +742,6 @@ public static Density FromDecigramsPerLiter(QuantityValue decigramsperliter) double value = (double) decigramsperliter; return new Density(value, DensityUnit.DecigramPerLiter); } - /// /// Creates a from . /// @@ -756,7 +751,6 @@ public static Density FromDecigramsPerMilliliter(QuantityValue decigramspermilli double value = (double) decigramspermilliliter; return new Density(value, DensityUnit.DecigramPerMilliliter); } - /// /// Creates a from . /// @@ -766,7 +760,6 @@ public static Density FromGramsPerCubicCentimeter(QuantityValue gramspercubiccen double value = (double) gramspercubiccentimeter; return new Density(value, DensityUnit.GramPerCubicCentimeter); } - /// /// Creates a from . /// @@ -776,7 +769,6 @@ public static Density FromGramsPerCubicFoot(QuantityValue gramspercubicfoot) double value = (double) gramspercubicfoot; return new Density(value, DensityUnit.GramPerCubicFoot); } - /// /// Creates a from . /// @@ -786,7 +778,6 @@ public static Density FromGramsPerCubicInch(QuantityValue gramspercubicinch) double value = (double) gramspercubicinch; return new Density(value, DensityUnit.GramPerCubicInch); } - /// /// Creates a from . /// @@ -796,7 +787,6 @@ public static Density FromGramsPerCubicMeter(QuantityValue gramspercubicmeter) double value = (double) gramspercubicmeter; return new Density(value, DensityUnit.GramPerCubicMeter); } - /// /// Creates a from . /// @@ -806,7 +796,6 @@ public static Density FromGramsPerCubicMillimeter(QuantityValue gramspercubicmil double value = (double) gramspercubicmillimeter; return new Density(value, DensityUnit.GramPerCubicMillimeter); } - /// /// Creates a from . /// @@ -816,7 +805,6 @@ public static Density FromGramsPerDeciLiter(QuantityValue gramsperdeciliter) double value = (double) gramsperdeciliter; return new Density(value, DensityUnit.GramPerDeciliter); } - /// /// Creates a from . /// @@ -826,7 +814,6 @@ public static Density FromGramsPerLiter(QuantityValue gramsperliter) double value = (double) gramsperliter; return new Density(value, DensityUnit.GramPerLiter); } - /// /// Creates a from . /// @@ -836,7 +823,6 @@ public static Density FromGramsPerMilliliter(QuantityValue gramspermilliliter) double value = (double) gramspermilliliter; return new Density(value, DensityUnit.GramPerMilliliter); } - /// /// Creates a from . /// @@ -846,7 +832,6 @@ public static Density FromKilogramsPerCubicCentimeter(QuantityValue kilogramsper double value = (double) kilogramspercubiccentimeter; return new Density(value, DensityUnit.KilogramPerCubicCentimeter); } - /// /// Creates a from . /// @@ -856,7 +841,6 @@ public static Density FromKilogramsPerCubicMeter(QuantityValue kilogramspercubic double value = (double) kilogramspercubicmeter; return new Density(value, DensityUnit.KilogramPerCubicMeter); } - /// /// Creates a from . /// @@ -866,7 +850,6 @@ public static Density FromKilogramsPerCubicMillimeter(QuantityValue kilogramsper double value = (double) kilogramspercubicmillimeter; return new Density(value, DensityUnit.KilogramPerCubicMillimeter); } - /// /// Creates a from . /// @@ -876,7 +859,6 @@ public static Density FromKilogramsPerLiter(QuantityValue kilogramsperliter) double value = (double) kilogramsperliter; return new Density(value, DensityUnit.KilogramPerLiter); } - /// /// Creates a from . /// @@ -886,7 +868,6 @@ public static Density FromKilopoundsPerCubicFoot(QuantityValue kilopoundspercubi double value = (double) kilopoundspercubicfoot; return new Density(value, DensityUnit.KilopoundPerCubicFoot); } - /// /// Creates a from . /// @@ -896,7 +877,6 @@ public static Density FromKilopoundsPerCubicInch(QuantityValue kilopoundspercubi double value = (double) kilopoundspercubicinch; return new Density(value, DensityUnit.KilopoundPerCubicInch); } - /// /// Creates a from . /// @@ -906,7 +886,6 @@ public static Density FromMicrogramsPerCubicMeter(QuantityValue microgramspercub double value = (double) microgramspercubicmeter; return new Density(value, DensityUnit.MicrogramPerCubicMeter); } - /// /// Creates a from . /// @@ -916,7 +895,6 @@ public static Density FromMicrogramsPerDeciLiter(QuantityValue microgramsperdeci double value = (double) microgramsperdeciliter; return new Density(value, DensityUnit.MicrogramPerDeciliter); } - /// /// Creates a from . /// @@ -926,7 +904,6 @@ public static Density FromMicrogramsPerLiter(QuantityValue microgramsperliter) double value = (double) microgramsperliter; return new Density(value, DensityUnit.MicrogramPerLiter); } - /// /// Creates a from . /// @@ -936,7 +913,6 @@ public static Density FromMicrogramsPerMilliliter(QuantityValue microgramspermil double value = (double) microgramspermilliliter; return new Density(value, DensityUnit.MicrogramPerMilliliter); } - /// /// Creates a from . /// @@ -946,7 +922,6 @@ public static Density FromMilligramsPerCubicMeter(QuantityValue milligramspercub double value = (double) milligramspercubicmeter; return new Density(value, DensityUnit.MilligramPerCubicMeter); } - /// /// Creates a from . /// @@ -956,7 +931,6 @@ public static Density FromMilligramsPerDeciLiter(QuantityValue milligramsperdeci double value = (double) milligramsperdeciliter; return new Density(value, DensityUnit.MilligramPerDeciliter); } - /// /// Creates a from . /// @@ -966,7 +940,6 @@ public static Density FromMilligramsPerLiter(QuantityValue milligramsperliter) double value = (double) milligramsperliter; return new Density(value, DensityUnit.MilligramPerLiter); } - /// /// Creates a from . /// @@ -976,7 +949,6 @@ public static Density FromMilligramsPerMilliliter(QuantityValue milligramspermil double value = (double) milligramspermilliliter; return new Density(value, DensityUnit.MilligramPerMilliliter); } - /// /// Creates a from . /// @@ -986,7 +958,6 @@ public static Density FromNanogramsPerDeciLiter(QuantityValue nanogramsperdecili double value = (double) nanogramsperdeciliter; return new Density(value, DensityUnit.NanogramPerDeciliter); } - /// /// Creates a from . /// @@ -996,7 +967,6 @@ public static Density FromNanogramsPerLiter(QuantityValue nanogramsperliter) double value = (double) nanogramsperliter; return new Density(value, DensityUnit.NanogramPerLiter); } - /// /// Creates a from . /// @@ -1006,7 +976,6 @@ public static Density FromNanogramsPerMilliliter(QuantityValue nanogramspermilli double value = (double) nanogramspermilliliter; return new Density(value, DensityUnit.NanogramPerMilliliter); } - /// /// Creates a from . /// @@ -1016,7 +985,6 @@ public static Density FromPicogramsPerDeciLiter(QuantityValue picogramsperdecili double value = (double) picogramsperdeciliter; return new Density(value, DensityUnit.PicogramPerDeciliter); } - /// /// Creates a from . /// @@ -1026,7 +994,6 @@ public static Density FromPicogramsPerLiter(QuantityValue picogramsperliter) double value = (double) picogramsperliter; return new Density(value, DensityUnit.PicogramPerLiter); } - /// /// Creates a from . /// @@ -1036,7 +1003,6 @@ public static Density FromPicogramsPerMilliliter(QuantityValue picogramspermilli double value = (double) picogramspermilliliter; return new Density(value, DensityUnit.PicogramPerMilliliter); } - /// /// Creates a from . /// @@ -1046,7 +1012,6 @@ public static Density FromPoundsPerCubicCentimeter(QuantityValue poundspercubicc double value = (double) poundspercubiccentimeter; return new Density(value, DensityUnit.PoundPerCubicCentimeter); } - /// /// Creates a from . /// @@ -1056,7 +1021,6 @@ public static Density FromPoundsPerCubicFoot(QuantityValue poundspercubicfoot) double value = (double) poundspercubicfoot; return new Density(value, DensityUnit.PoundPerCubicFoot); } - /// /// Creates a from . /// @@ -1066,7 +1030,6 @@ public static Density FromPoundsPerCubicInch(QuantityValue poundspercubicinch) double value = (double) poundspercubicinch; return new Density(value, DensityUnit.PoundPerCubicInch); } - /// /// Creates a from . /// @@ -1076,7 +1039,6 @@ public static Density FromPoundsPerCubicMeter(QuantityValue poundspercubicmeter) double value = (double) poundspercubicmeter; return new Density(value, DensityUnit.PoundPerCubicMeter); } - /// /// Creates a from . /// @@ -1086,7 +1048,6 @@ public static Density FromPoundsPerCubicMillimeter(QuantityValue poundspercubicm double value = (double) poundspercubicmillimeter; return new Density(value, DensityUnit.PoundPerCubicMillimeter); } - /// /// Creates a from . /// @@ -1096,7 +1057,6 @@ public static Density FromPoundsPerImperialGallon(QuantityValue poundsperimperia double value = (double) poundsperimperialgallon; return new Density(value, DensityUnit.PoundPerImperialGallon); } - /// /// Creates a from . /// @@ -1106,7 +1066,6 @@ public static Density FromPoundsPerUSGallon(QuantityValue poundsperusgallon) double value = (double) poundsperusgallon; return new Density(value, DensityUnit.PoundPerUSGallon); } - /// /// Creates a from . /// @@ -1116,7 +1075,6 @@ public static Density FromSlugsPerCubicCentimeter(QuantityValue slugspercubiccen double value = (double) slugspercubiccentimeter; return new Density(value, DensityUnit.SlugPerCubicCentimeter); } - /// /// Creates a from . /// @@ -1126,7 +1084,6 @@ public static Density FromSlugsPerCubicFoot(QuantityValue slugspercubicfoot) double value = (double) slugspercubicfoot; return new Density(value, DensityUnit.SlugPerCubicFoot); } - /// /// Creates a from . /// @@ -1136,7 +1093,6 @@ public static Density FromSlugsPerCubicInch(QuantityValue slugspercubicinch) double value = (double) slugspercubicinch; return new Density(value, DensityUnit.SlugPerCubicInch); } - /// /// Creates a from . /// @@ -1146,7 +1102,6 @@ public static Density FromSlugsPerCubicMeter(QuantityValue slugspercubicmeter) double value = (double) slugspercubicmeter; return new Density(value, DensityUnit.SlugPerCubicMeter); } - /// /// Creates a from . /// @@ -1156,7 +1111,6 @@ public static Density FromSlugsPerCubicMillimeter(QuantityValue slugspercubicmil double value = (double) slugspercubicmillimeter; return new Density(value, DensityUnit.SlugPerCubicMillimeter); } - /// /// Creates a from . /// @@ -1166,7 +1120,6 @@ public static Density FromTonnesPerCubicCentimeter(QuantityValue tonnespercubicc double value = (double) tonnespercubiccentimeter; return new Density(value, DensityUnit.TonnePerCubicCentimeter); } - /// /// Creates a from . /// @@ -1176,7 +1129,6 @@ public static Density FromTonnesPerCubicFoot(QuantityValue tonnespercubicfoot) double value = (double) tonnespercubicfoot; return new Density(value, DensityUnit.TonnePerCubicFoot); } - /// /// Creates a from . /// @@ -1186,7 +1138,6 @@ public static Density FromTonnesPerCubicInch(QuantityValue tonnespercubicinch) double value = (double) tonnespercubicinch; return new Density(value, DensityUnit.TonnePerCubicInch); } - /// /// Creates a from . /// @@ -1196,7 +1147,6 @@ public static Density FromTonnesPerCubicMeter(QuantityValue tonnespercubicmeter) double value = (double) tonnespercubicmeter; return new Density(value, DensityUnit.TonnePerCubicMeter); } - /// /// Creates a from . /// @@ -1207,7 +1157,6 @@ public static Density FromTonnesPerCubicMillimeter(QuantityValue tonnespercubicm return new Density(value, DensityUnit.TonnePerCubicMillimeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Duration.g.cs b/UnitsNet/GeneratedCode/Quantities/Duration.g.cs index af6ef0828f..e8345e1070 100644 --- a/UnitsNet/GeneratedCode/Quantities/Duration.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Duration.g.cs @@ -349,7 +349,6 @@ public static Duration FromDays(QuantityValue days) double value = (double) days; return new Duration(value, DurationUnit.Day); } - /// /// Creates a from . /// @@ -359,7 +358,6 @@ public static Duration FromHours(QuantityValue hours) double value = (double) hours; return new Duration(value, DurationUnit.Hour); } - /// /// Creates a from . /// @@ -369,7 +367,6 @@ public static Duration FromJulianYears(QuantityValue julianyears) double value = (double) julianyears; return new Duration(value, DurationUnit.JulianYear); } - /// /// Creates a from . /// @@ -379,7 +376,6 @@ public static Duration FromMicroseconds(QuantityValue microseconds) double value = (double) microseconds; return new Duration(value, DurationUnit.Microsecond); } - /// /// Creates a from . /// @@ -389,7 +385,6 @@ public static Duration FromMilliseconds(QuantityValue milliseconds) double value = (double) milliseconds; return new Duration(value, DurationUnit.Millisecond); } - /// /// Creates a from . /// @@ -399,7 +394,6 @@ public static Duration FromMinutes(QuantityValue minutes) double value = (double) minutes; return new Duration(value, DurationUnit.Minute); } - /// /// Creates a from . /// @@ -409,7 +403,6 @@ public static Duration FromMonths30(QuantityValue months30) double value = (double) months30; return new Duration(value, DurationUnit.Month30); } - /// /// Creates a from . /// @@ -419,7 +412,6 @@ public static Duration FromNanoseconds(QuantityValue nanoseconds) double value = (double) nanoseconds; return new Duration(value, DurationUnit.Nanosecond); } - /// /// Creates a from . /// @@ -429,7 +421,6 @@ public static Duration FromSeconds(QuantityValue seconds) double value = (double) seconds; return new Duration(value, DurationUnit.Second); } - /// /// Creates a from . /// @@ -439,7 +430,6 @@ public static Duration FromWeeks(QuantityValue weeks) double value = (double) weeks; return new Duration(value, DurationUnit.Week); } - /// /// Creates a from . /// @@ -450,7 +440,6 @@ public static Duration FromYears365(QuantityValue years365) return new Duration(value, DurationUnit.Year365); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs b/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs index f4c4b2ae1f..7b275de867 100644 --- a/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs @@ -333,7 +333,6 @@ public static DynamicViscosity FromCentipoise(QuantityValue centipoise) double value = (double) centipoise; return new DynamicViscosity(value, DynamicViscosityUnit.Centipoise); } - /// /// Creates a from . /// @@ -343,7 +342,6 @@ public static DynamicViscosity FromMicropascalSeconds(QuantityValue micropascals double value = (double) micropascalseconds; return new DynamicViscosity(value, DynamicViscosityUnit.MicropascalSecond); } - /// /// Creates a from . /// @@ -353,7 +351,6 @@ public static DynamicViscosity FromMillipascalSeconds(QuantityValue millipascals double value = (double) millipascalseconds; return new DynamicViscosity(value, DynamicViscosityUnit.MillipascalSecond); } - /// /// Creates a from . /// @@ -363,7 +360,6 @@ public static DynamicViscosity FromNewtonSecondsPerMeterSquared(QuantityValue ne double value = (double) newtonsecondspermetersquared; return new DynamicViscosity(value, DynamicViscosityUnit.NewtonSecondPerMeterSquared); } - /// /// Creates a from . /// @@ -373,7 +369,6 @@ public static DynamicViscosity FromPascalSeconds(QuantityValue pascalseconds) double value = (double) pascalseconds; return new DynamicViscosity(value, DynamicViscosityUnit.PascalSecond); } - /// /// Creates a from . /// @@ -383,7 +378,6 @@ public static DynamicViscosity FromPoise(QuantityValue poise) double value = (double) poise; return new DynamicViscosity(value, DynamicViscosityUnit.Poise); } - /// /// Creates a from . /// @@ -393,7 +387,6 @@ public static DynamicViscosity FromPoundsForceSecondPerSquareFoot(QuantityValue double value = (double) poundsforcesecondpersquarefoot; return new DynamicViscosity(value, DynamicViscosityUnit.PoundForceSecondPerSquareFoot); } - /// /// Creates a from . /// @@ -403,7 +396,6 @@ public static DynamicViscosity FromPoundsForceSecondPerSquareInch(QuantityValue double value = (double) poundsforcesecondpersquareinch; return new DynamicViscosity(value, DynamicViscosityUnit.PoundForceSecondPerSquareInch); } - /// /// Creates a from . /// @@ -413,7 +405,6 @@ public static DynamicViscosity FromPoundsPerFootSecond(QuantityValue poundsperfo double value = (double) poundsperfootsecond; return new DynamicViscosity(value, DynamicViscosityUnit.PoundPerFootSecond); } - /// /// Creates a from . /// @@ -424,7 +415,6 @@ public static DynamicViscosity FromReyns(QuantityValue reyns) return new DynamicViscosity(value, DynamicViscosityUnit.Reyn); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs index 94cf72473e..7e9d5fc7d5 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs @@ -276,7 +276,6 @@ public static ElectricAdmittance FromMicrosiemens(QuantityValue microsiemens) double value = (double) microsiemens; return new ElectricAdmittance(value, ElectricAdmittanceUnit.Microsiemens); } - /// /// Creates a from . /// @@ -286,7 +285,6 @@ public static ElectricAdmittance FromMillisiemens(QuantityValue millisiemens) double value = (double) millisiemens; return new ElectricAdmittance(value, ElectricAdmittanceUnit.Millisiemens); } - /// /// Creates a from . /// @@ -296,7 +294,6 @@ public static ElectricAdmittance FromNanosiemens(QuantityValue nanosiemens) double value = (double) nanosiemens; return new ElectricAdmittance(value, ElectricAdmittanceUnit.Nanosiemens); } - /// /// Creates a from . /// @@ -307,7 +304,6 @@ public static ElectricAdmittance FromSiemens(QuantityValue siemens) return new ElectricAdmittance(value, ElectricAdmittanceUnit.Siemens); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs index 03a73a9064..612c10235c 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs @@ -288,7 +288,6 @@ public static ElectricCharge FromAmpereHours(QuantityValue amperehours) double value = (double) amperehours; return new ElectricCharge(value, ElectricChargeUnit.AmpereHour); } - /// /// Creates a from . /// @@ -298,7 +297,6 @@ public static ElectricCharge FromCoulombs(QuantityValue coulombs) double value = (double) coulombs; return new ElectricCharge(value, ElectricChargeUnit.Coulomb); } - /// /// Creates a from . /// @@ -308,7 +306,6 @@ public static ElectricCharge FromKiloampereHours(QuantityValue kiloamperehours) double value = (double) kiloamperehours; return new ElectricCharge(value, ElectricChargeUnit.KiloampereHour); } - /// /// Creates a from . /// @@ -318,7 +315,6 @@ public static ElectricCharge FromMegaampereHours(QuantityValue megaamperehours) double value = (double) megaamperehours; return new ElectricCharge(value, ElectricChargeUnit.MegaampereHour); } - /// /// Creates a from . /// @@ -329,7 +325,6 @@ public static ElectricCharge FromMilliampereHours(QuantityValue milliamperehours return new ElectricCharge(value, ElectricChargeUnit.MilliampereHour); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs index 6378bf9fae..3297d02689 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs @@ -253,7 +253,6 @@ public static ElectricChargeDensity FromCoulombsPerCubicMeter(QuantityValue coul return new ElectricChargeDensity(value, ElectricChargeDensityUnit.CoulombPerCubicMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs index c56fdf90a2..c6c05cfe13 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs @@ -270,7 +270,6 @@ public static ElectricConductance FromMicrosiemens(QuantityValue microsiemens) double value = (double) microsiemens; return new ElectricConductance(value, ElectricConductanceUnit.Microsiemens); } - /// /// Creates a from . /// @@ -280,7 +279,6 @@ public static ElectricConductance FromMillisiemens(QuantityValue millisiemens) double value = (double) millisiemens; return new ElectricConductance(value, ElectricConductanceUnit.Millisiemens); } - /// /// Creates a from . /// @@ -291,7 +289,6 @@ public static ElectricConductance FromSiemens(QuantityValue siemens) return new ElectricConductance(value, ElectricConductanceUnit.Siemens); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs index ef6d32ab04..31a6f44390 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs @@ -270,7 +270,6 @@ public static ElectricConductivity FromSiemensPerFoot(QuantityValue siemensperfo double value = (double) siemensperfoot; return new ElectricConductivity(value, ElectricConductivityUnit.SiemensPerFoot); } - /// /// Creates a from . /// @@ -280,7 +279,6 @@ public static ElectricConductivity FromSiemensPerInch(QuantityValue siemensperin double value = (double) siemensperinch; return new ElectricConductivity(value, ElectricConductivityUnit.SiemensPerInch); } - /// /// Creates a from . /// @@ -291,7 +289,6 @@ public static ElectricConductivity FromSiemensPerMeter(QuantityValue siemensperm return new ElectricConductivity(value, ElectricConductivityUnit.SiemensPerMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs index c740ac7a37..83dfb4c311 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs @@ -312,7 +312,6 @@ public static ElectricCurrent FromAmperes(QuantityValue amperes) double value = (double) amperes; return new ElectricCurrent(value, ElectricCurrentUnit.Ampere); } - /// /// Creates a from . /// @@ -322,7 +321,6 @@ public static ElectricCurrent FromCentiamperes(QuantityValue centiamperes) double value = (double) centiamperes; return new ElectricCurrent(value, ElectricCurrentUnit.Centiampere); } - /// /// Creates a from . /// @@ -332,7 +330,6 @@ public static ElectricCurrent FromKiloamperes(QuantityValue kiloamperes) double value = (double) kiloamperes; return new ElectricCurrent(value, ElectricCurrentUnit.Kiloampere); } - /// /// Creates a from . /// @@ -342,7 +339,6 @@ public static ElectricCurrent FromMegaamperes(QuantityValue megaamperes) double value = (double) megaamperes; return new ElectricCurrent(value, ElectricCurrentUnit.Megaampere); } - /// /// Creates a from . /// @@ -352,7 +348,6 @@ public static ElectricCurrent FromMicroamperes(QuantityValue microamperes) double value = (double) microamperes; return new ElectricCurrent(value, ElectricCurrentUnit.Microampere); } - /// /// Creates a from . /// @@ -362,7 +357,6 @@ public static ElectricCurrent FromMilliamperes(QuantityValue milliamperes) double value = (double) milliamperes; return new ElectricCurrent(value, ElectricCurrentUnit.Milliampere); } - /// /// Creates a from . /// @@ -372,7 +366,6 @@ public static ElectricCurrent FromNanoamperes(QuantityValue nanoamperes) double value = (double) nanoamperes; return new ElectricCurrent(value, ElectricCurrentUnit.Nanoampere); } - /// /// Creates a from . /// @@ -383,7 +376,6 @@ public static ElectricCurrent FromPicoamperes(QuantityValue picoamperes) return new ElectricCurrent(value, ElectricCurrentUnit.Picoampere); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs index 4f7457eac6..fd014425f3 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs @@ -270,7 +270,6 @@ public static ElectricCurrentDensity FromAmperesPerSquareFoot(QuantityValue ampe double value = (double) amperespersquarefoot; return new ElectricCurrentDensity(value, ElectricCurrentDensityUnit.AmperePerSquareFoot); } - /// /// Creates a from . /// @@ -280,7 +279,6 @@ public static ElectricCurrentDensity FromAmperesPerSquareInch(QuantityValue ampe double value = (double) amperespersquareinch; return new ElectricCurrentDensity(value, ElectricCurrentDensityUnit.AmperePerSquareInch); } - /// /// Creates a from . /// @@ -291,7 +289,6 @@ public static ElectricCurrentDensity FromAmperesPerSquareMeter(QuantityValue amp return new ElectricCurrentDensity(value, ElectricCurrentDensityUnit.AmperePerSquareMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs index 3a8706b474..2c64fa624c 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs @@ -276,7 +276,6 @@ public static ElectricCurrentGradient FromAmperesPerMicrosecond(QuantityValue am double value = (double) amperespermicrosecond; return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerMicrosecond); } - /// /// Creates a from . /// @@ -286,7 +285,6 @@ public static ElectricCurrentGradient FromAmperesPerMillisecond(QuantityValue am double value = (double) amperespermillisecond; return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerMillisecond); } - /// /// Creates a from . /// @@ -296,7 +294,6 @@ public static ElectricCurrentGradient FromAmperesPerNanosecond(QuantityValue amp double value = (double) amperespernanosecond; return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerNanosecond); } - /// /// Creates a from . /// @@ -307,7 +304,6 @@ public static ElectricCurrentGradient FromAmperesPerSecond(QuantityValue amperes return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerSecond); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs index 2da601ff60..36df6a5276 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs @@ -253,7 +253,6 @@ public static ElectricField FromVoltsPerMeter(QuantityValue voltspermeter) return new ElectricField(value, ElectricFieldUnit.VoltPerMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs index a8d903b46c..69beef1a4f 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs @@ -279,7 +279,6 @@ public static ElectricInductance FromHenries(QuantityValue henries) double value = (double) henries; return new ElectricInductance(value, ElectricInductanceUnit.Henry); } - /// /// Creates a from . /// @@ -289,7 +288,6 @@ public static ElectricInductance FromMicrohenries(QuantityValue microhenries) double value = (double) microhenries; return new ElectricInductance(value, ElectricInductanceUnit.Microhenry); } - /// /// Creates a from . /// @@ -299,7 +297,6 @@ public static ElectricInductance FromMillihenries(QuantityValue millihenries) double value = (double) millihenries; return new ElectricInductance(value, ElectricInductanceUnit.Millihenry); } - /// /// Creates a from . /// @@ -310,7 +307,6 @@ public static ElectricInductance FromNanohenries(QuantityValue nanohenries) return new ElectricInductance(value, ElectricInductanceUnit.Nanohenry); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs index 948f1706b9..4f9cb1a316 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs @@ -290,7 +290,6 @@ public static ElectricPotential FromKilovolts(QuantityValue kilovolts) double value = (double) kilovolts; return new ElectricPotential(value, ElectricPotentialUnit.Kilovolt); } - /// /// Creates a from . /// @@ -300,7 +299,6 @@ public static ElectricPotential FromMegavolts(QuantityValue megavolts) double value = (double) megavolts; return new ElectricPotential(value, ElectricPotentialUnit.Megavolt); } - /// /// Creates a from . /// @@ -310,7 +308,6 @@ public static ElectricPotential FromMicrovolts(QuantityValue microvolts) double value = (double) microvolts; return new ElectricPotential(value, ElectricPotentialUnit.Microvolt); } - /// /// Creates a from . /// @@ -320,7 +317,6 @@ public static ElectricPotential FromMillivolts(QuantityValue millivolts) double value = (double) millivolts; return new ElectricPotential(value, ElectricPotentialUnit.Millivolt); } - /// /// Creates a from . /// @@ -331,7 +327,6 @@ public static ElectricPotential FromVolts(QuantityValue volts) return new ElectricPotential(value, ElectricPotentialUnit.Volt); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.g.cs index b8a7581ca0..f956261fc2 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.g.cs @@ -285,7 +285,6 @@ public static ElectricPotentialAc FromKilovoltsAc(QuantityValue kilovoltsac) double value = (double) kilovoltsac; return new ElectricPotentialAc(value, ElectricPotentialAcUnit.KilovoltAc); } - /// /// Creates a from . /// @@ -295,7 +294,6 @@ public static ElectricPotentialAc FromMegavoltsAc(QuantityValue megavoltsac) double value = (double) megavoltsac; return new ElectricPotentialAc(value, ElectricPotentialAcUnit.MegavoltAc); } - /// /// Creates a from . /// @@ -305,7 +303,6 @@ public static ElectricPotentialAc FromMicrovoltsAc(QuantityValue microvoltsac) double value = (double) microvoltsac; return new ElectricPotentialAc(value, ElectricPotentialAcUnit.MicrovoltAc); } - /// /// Creates a from . /// @@ -315,7 +312,6 @@ public static ElectricPotentialAc FromMillivoltsAc(QuantityValue millivoltsac) double value = (double) millivoltsac; return new ElectricPotentialAc(value, ElectricPotentialAcUnit.MillivoltAc); } - /// /// Creates a from . /// @@ -326,7 +322,6 @@ public static ElectricPotentialAc FromVoltsAc(QuantityValue voltsac) return new ElectricPotentialAc(value, ElectricPotentialAcUnit.VoltAc); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs index d2e5e85ebf..6a8ac42d46 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs @@ -420,7 +420,6 @@ public static ElectricPotentialChangeRate FromKilovoltsPerHours(QuantityValue ki double value = (double) kilovoltsperhours; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerHour); } - /// /// Creates a from . /// @@ -430,7 +429,6 @@ public static ElectricPotentialChangeRate FromKilovoltsPerMicroseconds(QuantityV double value = (double) kilovoltspermicroseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond); } - /// /// Creates a from . /// @@ -440,7 +438,6 @@ public static ElectricPotentialChangeRate FromKilovoltsPerMinutes(QuantityValue double value = (double) kilovoltsperminutes; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerMinute); } - /// /// Creates a from . /// @@ -450,7 +447,6 @@ public static ElectricPotentialChangeRate FromKilovoltsPerSeconds(QuantityValue double value = (double) kilovoltsperseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerSecond); } - /// /// Creates a from . /// @@ -460,7 +456,6 @@ public static ElectricPotentialChangeRate FromMegavoltsPerHours(QuantityValue me double value = (double) megavoltsperhours; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerHour); } - /// /// Creates a from . /// @@ -470,7 +465,6 @@ public static ElectricPotentialChangeRate FromMegavoltsPerMicroseconds(QuantityV double value = (double) megavoltspermicroseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond); } - /// /// Creates a from . /// @@ -480,7 +474,6 @@ public static ElectricPotentialChangeRate FromMegavoltsPerMinutes(QuantityValue double value = (double) megavoltsperminutes; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerMinute); } - /// /// Creates a from . /// @@ -490,7 +483,6 @@ public static ElectricPotentialChangeRate FromMegavoltsPerSeconds(QuantityValue double value = (double) megavoltsperseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerSecond); } - /// /// Creates a from . /// @@ -500,7 +492,6 @@ public static ElectricPotentialChangeRate FromMicrovoltsPerHours(QuantityValue m double value = (double) microvoltsperhours; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerHour); } - /// /// Creates a from . /// @@ -510,7 +501,6 @@ public static ElectricPotentialChangeRate FromMicrovoltsPerMicroseconds(Quantity double value = (double) microvoltspermicroseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond); } - /// /// Creates a from . /// @@ -520,7 +510,6 @@ public static ElectricPotentialChangeRate FromMicrovoltsPerMinutes(QuantityValue double value = (double) microvoltsperminutes; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerMinute); } - /// /// Creates a from . /// @@ -530,7 +519,6 @@ public static ElectricPotentialChangeRate FromMicrovoltsPerSeconds(QuantityValue double value = (double) microvoltsperseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerSecond); } - /// /// Creates a from . /// @@ -540,7 +528,6 @@ public static ElectricPotentialChangeRate FromMillivoltsPerHours(QuantityValue m double value = (double) millivoltsperhours; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerHour); } - /// /// Creates a from . /// @@ -550,7 +537,6 @@ public static ElectricPotentialChangeRate FromMillivoltsPerMicroseconds(Quantity double value = (double) millivoltspermicroseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond); } - /// /// Creates a from . /// @@ -560,7 +546,6 @@ public static ElectricPotentialChangeRate FromMillivoltsPerMinutes(QuantityValue double value = (double) millivoltsperminutes; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerMinute); } - /// /// Creates a from . /// @@ -570,7 +555,6 @@ public static ElectricPotentialChangeRate FromMillivoltsPerSeconds(QuantityValue double value = (double) millivoltsperseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerSecond); } - /// /// Creates a from . /// @@ -580,7 +564,6 @@ public static ElectricPotentialChangeRate FromVoltsPerHours(QuantityValue voltsp double value = (double) voltsperhours; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerHour); } - /// /// Creates a from . /// @@ -590,7 +573,6 @@ public static ElectricPotentialChangeRate FromVoltsPerMicroseconds(QuantityValue double value = (double) voltspermicroseconds; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerMicrosecond); } - /// /// Creates a from . /// @@ -600,7 +582,6 @@ public static ElectricPotentialChangeRate FromVoltsPerMinutes(QuantityValue volt double value = (double) voltsperminutes; return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerMinute); } - /// /// Creates a from . /// @@ -611,7 +592,6 @@ public static ElectricPotentialChangeRate FromVoltsPerSeconds(QuantityValue volt return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerSecond); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.g.cs index 09128b2ad3..4e1b0e3b3b 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.g.cs @@ -285,7 +285,6 @@ public static ElectricPotentialDc FromKilovoltsDc(QuantityValue kilovoltsdc) double value = (double) kilovoltsdc; return new ElectricPotentialDc(value, ElectricPotentialDcUnit.KilovoltDc); } - /// /// Creates a from . /// @@ -295,7 +294,6 @@ public static ElectricPotentialDc FromMegavoltsDc(QuantityValue megavoltsdc) double value = (double) megavoltsdc; return new ElectricPotentialDc(value, ElectricPotentialDcUnit.MegavoltDc); } - /// /// Creates a from . /// @@ -305,7 +303,6 @@ public static ElectricPotentialDc FromMicrovoltsDc(QuantityValue microvoltsdc) double value = (double) microvoltsdc; return new ElectricPotentialDc(value, ElectricPotentialDcUnit.MicrovoltDc); } - /// /// Creates a from . /// @@ -315,7 +312,6 @@ public static ElectricPotentialDc FromMillivoltsDc(QuantityValue millivoltsdc) double value = (double) millivoltsdc; return new ElectricPotentialDc(value, ElectricPotentialDcUnit.MillivoltDc); } - /// /// Creates a from . /// @@ -326,7 +322,6 @@ public static ElectricPotentialDc FromVoltsDc(QuantityValue voltsdc) return new ElectricPotentialDc(value, ElectricPotentialDcUnit.VoltDc); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs index e44d9fa9d3..45ac788eea 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs @@ -294,7 +294,6 @@ public static ElectricResistance FromGigaohms(QuantityValue gigaohms) double value = (double) gigaohms; return new ElectricResistance(value, ElectricResistanceUnit.Gigaohm); } - /// /// Creates a from . /// @@ -304,7 +303,6 @@ public static ElectricResistance FromKiloohms(QuantityValue kiloohms) double value = (double) kiloohms; return new ElectricResistance(value, ElectricResistanceUnit.Kiloohm); } - /// /// Creates a from . /// @@ -314,7 +312,6 @@ public static ElectricResistance FromMegaohms(QuantityValue megaohms) double value = (double) megaohms; return new ElectricResistance(value, ElectricResistanceUnit.Megaohm); } - /// /// Creates a from . /// @@ -324,7 +321,6 @@ public static ElectricResistance FromMicroohms(QuantityValue microohms) double value = (double) microohms; return new ElectricResistance(value, ElectricResistanceUnit.Microohm); } - /// /// Creates a from . /// @@ -334,7 +330,6 @@ public static ElectricResistance FromMilliohms(QuantityValue milliohms) double value = (double) milliohms; return new ElectricResistance(value, ElectricResistanceUnit.Milliohm); } - /// /// Creates a from . /// @@ -345,7 +340,6 @@ public static ElectricResistance FromOhms(QuantityValue ohms) return new ElectricResistance(value, ElectricResistanceUnit.Ohm); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs index 8bfdffaa9d..a83e90cddf 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs @@ -369,7 +369,6 @@ public static ElectricResistivity FromKiloohmsCentimeter(QuantityValue kiloohmsc double value = (double) kiloohmscentimeter; return new ElectricResistivity(value, ElectricResistivityUnit.KiloohmCentimeter); } - /// /// Creates a from . /// @@ -379,7 +378,6 @@ public static ElectricResistivity FromKiloohmMeters(QuantityValue kiloohmmeters) double value = (double) kiloohmmeters; return new ElectricResistivity(value, ElectricResistivityUnit.KiloohmMeter); } - /// /// Creates a from . /// @@ -389,7 +387,6 @@ public static ElectricResistivity FromMegaohmsCentimeter(QuantityValue megaohmsc double value = (double) megaohmscentimeter; return new ElectricResistivity(value, ElectricResistivityUnit.MegaohmCentimeter); } - /// /// Creates a from . /// @@ -399,7 +396,6 @@ public static ElectricResistivity FromMegaohmMeters(QuantityValue megaohmmeters) double value = (double) megaohmmeters; return new ElectricResistivity(value, ElectricResistivityUnit.MegaohmMeter); } - /// /// Creates a from . /// @@ -409,7 +405,6 @@ public static ElectricResistivity FromMicroohmsCentimeter(QuantityValue microohm double value = (double) microohmscentimeter; return new ElectricResistivity(value, ElectricResistivityUnit.MicroohmCentimeter); } - /// /// Creates a from . /// @@ -419,7 +414,6 @@ public static ElectricResistivity FromMicroohmMeters(QuantityValue microohmmeter double value = (double) microohmmeters; return new ElectricResistivity(value, ElectricResistivityUnit.MicroohmMeter); } - /// /// Creates a from . /// @@ -429,7 +423,6 @@ public static ElectricResistivity FromMilliohmsCentimeter(QuantityValue milliohm double value = (double) milliohmscentimeter; return new ElectricResistivity(value, ElectricResistivityUnit.MilliohmCentimeter); } - /// /// Creates a from . /// @@ -439,7 +432,6 @@ public static ElectricResistivity FromMilliohmMeters(QuantityValue milliohmmeter double value = (double) milliohmmeters; return new ElectricResistivity(value, ElectricResistivityUnit.MilliohmMeter); } - /// /// Creates a from . /// @@ -449,7 +441,6 @@ public static ElectricResistivity FromNanoohmsCentimeter(QuantityValue nanoohmsc double value = (double) nanoohmscentimeter; return new ElectricResistivity(value, ElectricResistivityUnit.NanoohmCentimeter); } - /// /// Creates a from . /// @@ -459,7 +450,6 @@ public static ElectricResistivity FromNanoohmMeters(QuantityValue nanoohmmeters) double value = (double) nanoohmmeters; return new ElectricResistivity(value, ElectricResistivityUnit.NanoohmMeter); } - /// /// Creates a from . /// @@ -469,7 +459,6 @@ public static ElectricResistivity FromOhmsCentimeter(QuantityValue ohmscentimete double value = (double) ohmscentimeter; return new ElectricResistivity(value, ElectricResistivityUnit.OhmCentimeter); } - /// /// Creates a from . /// @@ -479,7 +468,6 @@ public static ElectricResistivity FromOhmMeters(QuantityValue ohmmeters) double value = (double) ohmmeters; return new ElectricResistivity(value, ElectricResistivityUnit.OhmMeter); } - /// /// Creates a from . /// @@ -489,7 +477,6 @@ public static ElectricResistivity FromPicoohmsCentimeter(QuantityValue picoohmsc double value = (double) picoohmscentimeter; return new ElectricResistivity(value, ElectricResistivityUnit.PicoohmCentimeter); } - /// /// Creates a from . /// @@ -500,7 +487,6 @@ public static ElectricResistivity FromPicoohmMeters(QuantityValue picoohmmeters) return new ElectricResistivity(value, ElectricResistivityUnit.PicoohmMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs index edfc905061..8051b671d2 100644 --- a/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs @@ -270,7 +270,6 @@ public static ElectricSurfaceChargeDensity FromCoulombsPerSquareCentimeter(Quant double value = (double) coulombspersquarecentimeter; return new ElectricSurfaceChargeDensity(value, ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter); } - /// /// Creates a from . /// @@ -280,7 +279,6 @@ public static ElectricSurfaceChargeDensity FromCoulombsPerSquareInch(QuantityVal double value = (double) coulombspersquareinch; return new ElectricSurfaceChargeDensity(value, ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch); } - /// /// Creates a from . /// @@ -291,7 +289,6 @@ public static ElectricSurfaceChargeDensity FromCoulombsPerSquareMeter(QuantityVa return new ElectricSurfaceChargeDensity(value, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Energy.g.cs b/UnitsNet/GeneratedCode/Quantities/Energy.g.cs index 8ff13fe246..d88081e48c 100644 --- a/UnitsNet/GeneratedCode/Quantities/Energy.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Energy.g.cs @@ -585,7 +585,6 @@ public static Energy FromBritishThermalUnits(QuantityValue britishthermalunits) double value = (double) britishthermalunits; return new Energy(value, EnergyUnit.BritishThermalUnit); } - /// /// Creates a from . /// @@ -595,7 +594,6 @@ public static Energy FromCalories(QuantityValue calories) double value = (double) calories; return new Energy(value, EnergyUnit.Calorie); } - /// /// Creates a from . /// @@ -605,7 +603,6 @@ public static Energy FromDecathermsEc(QuantityValue decathermsec) double value = (double) decathermsec; return new Energy(value, EnergyUnit.DecathermEc); } - /// /// Creates a from . /// @@ -615,7 +612,6 @@ public static Energy FromDecathermsImperial(QuantityValue decathermsimperial) double value = (double) decathermsimperial; return new Energy(value, EnergyUnit.DecathermImperial); } - /// /// Creates a from . /// @@ -625,7 +621,6 @@ public static Energy FromDecathermsUs(QuantityValue decathermsus) double value = (double) decathermsus; return new Energy(value, EnergyUnit.DecathermUs); } - /// /// Creates a from . /// @@ -635,7 +630,6 @@ public static Energy FromElectronVolts(QuantityValue electronvolts) double value = (double) electronvolts; return new Energy(value, EnergyUnit.ElectronVolt); } - /// /// Creates a from . /// @@ -645,7 +639,6 @@ public static Energy FromErgs(QuantityValue ergs) double value = (double) ergs; return new Energy(value, EnergyUnit.Erg); } - /// /// Creates a from . /// @@ -655,7 +648,6 @@ public static Energy FromFootPounds(QuantityValue footpounds) double value = (double) footpounds; return new Energy(value, EnergyUnit.FootPound); } - /// /// Creates a from . /// @@ -665,7 +657,6 @@ public static Energy FromGigabritishThermalUnits(QuantityValue gigabritishtherma double value = (double) gigabritishthermalunits; return new Energy(value, EnergyUnit.GigabritishThermalUnit); } - /// /// Creates a from . /// @@ -675,7 +666,6 @@ public static Energy FromGigaelectronVolts(QuantityValue gigaelectronvolts) double value = (double) gigaelectronvolts; return new Energy(value, EnergyUnit.GigaelectronVolt); } - /// /// Creates a from . /// @@ -685,7 +675,6 @@ public static Energy FromGigajoules(QuantityValue gigajoules) double value = (double) gigajoules; return new Energy(value, EnergyUnit.Gigajoule); } - /// /// Creates a from . /// @@ -695,7 +684,6 @@ public static Energy FromGigawattDays(QuantityValue gigawattdays) double value = (double) gigawattdays; return new Energy(value, EnergyUnit.GigawattDay); } - /// /// Creates a from . /// @@ -705,7 +693,6 @@ public static Energy FromGigawattHours(QuantityValue gigawatthours) double value = (double) gigawatthours; return new Energy(value, EnergyUnit.GigawattHour); } - /// /// Creates a from . /// @@ -715,7 +702,6 @@ public static Energy FromHorsepowerHours(QuantityValue horsepowerhours) double value = (double) horsepowerhours; return new Energy(value, EnergyUnit.HorsepowerHour); } - /// /// Creates a from . /// @@ -725,7 +711,6 @@ public static Energy FromJoules(QuantityValue joules) double value = (double) joules; return new Energy(value, EnergyUnit.Joule); } - /// /// Creates a from . /// @@ -735,7 +720,6 @@ public static Energy FromKilobritishThermalUnits(QuantityValue kilobritishtherma double value = (double) kilobritishthermalunits; return new Energy(value, EnergyUnit.KilobritishThermalUnit); } - /// /// Creates a from . /// @@ -745,7 +729,6 @@ public static Energy FromKilocalories(QuantityValue kilocalories) double value = (double) kilocalories; return new Energy(value, EnergyUnit.Kilocalorie); } - /// /// Creates a from . /// @@ -755,7 +738,6 @@ public static Energy FromKiloelectronVolts(QuantityValue kiloelectronvolts) double value = (double) kiloelectronvolts; return new Energy(value, EnergyUnit.KiloelectronVolt); } - /// /// Creates a from . /// @@ -765,7 +747,6 @@ public static Energy FromKilojoules(QuantityValue kilojoules) double value = (double) kilojoules; return new Energy(value, EnergyUnit.Kilojoule); } - /// /// Creates a from . /// @@ -775,7 +756,6 @@ public static Energy FromKilowattDays(QuantityValue kilowattdays) double value = (double) kilowattdays; return new Energy(value, EnergyUnit.KilowattDay); } - /// /// Creates a from . /// @@ -785,7 +765,6 @@ public static Energy FromKilowattHours(QuantityValue kilowatthours) double value = (double) kilowatthours; return new Energy(value, EnergyUnit.KilowattHour); } - /// /// Creates a from . /// @@ -795,7 +774,6 @@ public static Energy FromMegabritishThermalUnits(QuantityValue megabritishtherma double value = (double) megabritishthermalunits; return new Energy(value, EnergyUnit.MegabritishThermalUnit); } - /// /// Creates a from . /// @@ -805,7 +783,6 @@ public static Energy FromMegacalories(QuantityValue megacalories) double value = (double) megacalories; return new Energy(value, EnergyUnit.Megacalorie); } - /// /// Creates a from . /// @@ -815,7 +792,6 @@ public static Energy FromMegaelectronVolts(QuantityValue megaelectronvolts) double value = (double) megaelectronvolts; return new Energy(value, EnergyUnit.MegaelectronVolt); } - /// /// Creates a from . /// @@ -825,7 +801,6 @@ public static Energy FromMegajoules(QuantityValue megajoules) double value = (double) megajoules; return new Energy(value, EnergyUnit.Megajoule); } - /// /// Creates a from . /// @@ -835,7 +810,6 @@ public static Energy FromMegawattDays(QuantityValue megawattdays) double value = (double) megawattdays; return new Energy(value, EnergyUnit.MegawattDay); } - /// /// Creates a from . /// @@ -845,7 +819,6 @@ public static Energy FromMegawattHours(QuantityValue megawatthours) double value = (double) megawatthours; return new Energy(value, EnergyUnit.MegawattHour); } - /// /// Creates a from . /// @@ -855,7 +828,6 @@ public static Energy FromMillijoules(QuantityValue millijoules) double value = (double) millijoules; return new Energy(value, EnergyUnit.Millijoule); } - /// /// Creates a from . /// @@ -865,7 +837,6 @@ public static Energy FromTeraelectronVolts(QuantityValue teraelectronvolts) double value = (double) teraelectronvolts; return new Energy(value, EnergyUnit.TeraelectronVolt); } - /// /// Creates a from . /// @@ -875,7 +846,6 @@ public static Energy FromTerawattDays(QuantityValue terawattdays) double value = (double) terawattdays; return new Energy(value, EnergyUnit.TerawattDay); } - /// /// Creates a from . /// @@ -885,7 +855,6 @@ public static Energy FromTerawattHours(QuantityValue terawatthours) double value = (double) terawatthours; return new Energy(value, EnergyUnit.TerawattHour); } - /// /// Creates a from . /// @@ -895,7 +864,6 @@ public static Energy FromThermsEc(QuantityValue thermsec) double value = (double) thermsec; return new Energy(value, EnergyUnit.ThermEc); } - /// /// Creates a from . /// @@ -905,7 +873,6 @@ public static Energy FromThermsImperial(QuantityValue thermsimperial) double value = (double) thermsimperial; return new Energy(value, EnergyUnit.ThermImperial); } - /// /// Creates a from . /// @@ -915,7 +882,6 @@ public static Energy FromThermsUs(QuantityValue thermsus) double value = (double) thermsus; return new Energy(value, EnergyUnit.ThermUs); } - /// /// Creates a from . /// @@ -925,7 +891,6 @@ public static Energy FromWattDays(QuantityValue wattdays) double value = (double) wattdays; return new Energy(value, EnergyUnit.WattDay); } - /// /// Creates a from . /// @@ -936,7 +901,6 @@ public static Energy FromWattHours(QuantityValue watthours) return new Energy(value, EnergyUnit.WattHour); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs b/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs index 9f32d7ef58..034b6882c1 100644 --- a/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs @@ -303,7 +303,6 @@ public static Entropy FromCaloriesPerKelvin(QuantityValue caloriesperkelvin) double value = (double) caloriesperkelvin; return new Entropy(value, EntropyUnit.CaloriePerKelvin); } - /// /// Creates a from . /// @@ -313,7 +312,6 @@ public static Entropy FromJoulesPerDegreeCelsius(QuantityValue joulesperdegreece double value = (double) joulesperdegreecelsius; return new Entropy(value, EntropyUnit.JoulePerDegreeCelsius); } - /// /// Creates a from . /// @@ -323,7 +321,6 @@ public static Entropy FromJoulesPerKelvin(QuantityValue joulesperkelvin) double value = (double) joulesperkelvin; return new Entropy(value, EntropyUnit.JoulePerKelvin); } - /// /// Creates a from . /// @@ -333,7 +330,6 @@ public static Entropy FromKilocaloriesPerKelvin(QuantityValue kilocaloriesperkel double value = (double) kilocaloriesperkelvin; return new Entropy(value, EntropyUnit.KilocaloriePerKelvin); } - /// /// Creates a from . /// @@ -343,7 +339,6 @@ public static Entropy FromKilojoulesPerDegreeCelsius(QuantityValue kilojoulesper double value = (double) kilojoulesperdegreecelsius; return new Entropy(value, EntropyUnit.KilojoulePerDegreeCelsius); } - /// /// Creates a from . /// @@ -353,7 +348,6 @@ public static Entropy FromKilojoulesPerKelvin(QuantityValue kilojoulesperkelvin) double value = (double) kilojoulesperkelvin; return new Entropy(value, EntropyUnit.KilojoulePerKelvin); } - /// /// Creates a from . /// @@ -364,7 +358,6 @@ public static Entropy FromMegajoulesPerKelvin(QuantityValue megajoulesperkelvin) return new Entropy(value, EntropyUnit.MegajoulePerKelvin); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Force.g.cs b/UnitsNet/GeneratedCode/Quantities/Force.g.cs index 5b14c38642..cc5e9a4a78 100644 --- a/UnitsNet/GeneratedCode/Quantities/Force.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Force.g.cs @@ -388,7 +388,6 @@ public static Force FromDecanewtons(QuantityValue decanewtons) double value = (double) decanewtons; return new Force(value, ForceUnit.Decanewton); } - /// /// Creates a from . /// @@ -398,7 +397,6 @@ public static Force FromDyne(QuantityValue dyne) double value = (double) dyne; return new Force(value, ForceUnit.Dyn); } - /// /// Creates a from . /// @@ -408,7 +406,6 @@ public static Force FromKilogramsForce(QuantityValue kilogramsforce) double value = (double) kilogramsforce; return new Force(value, ForceUnit.KilogramForce); } - /// /// Creates a from . /// @@ -418,7 +415,6 @@ public static Force FromKilonewtons(QuantityValue kilonewtons) double value = (double) kilonewtons; return new Force(value, ForceUnit.Kilonewton); } - /// /// Creates a from . /// @@ -428,7 +424,6 @@ public static Force FromKiloPonds(QuantityValue kiloponds) double value = (double) kiloponds; return new Force(value, ForceUnit.KiloPond); } - /// /// Creates a from . /// @@ -438,7 +433,6 @@ public static Force FromKilopoundsForce(QuantityValue kilopoundsforce) double value = (double) kilopoundsforce; return new Force(value, ForceUnit.KilopoundForce); } - /// /// Creates a from . /// @@ -448,7 +442,6 @@ public static Force FromMeganewtons(QuantityValue meganewtons) double value = (double) meganewtons; return new Force(value, ForceUnit.Meganewton); } - /// /// Creates a from . /// @@ -458,7 +451,6 @@ public static Force FromMicronewtons(QuantityValue micronewtons) double value = (double) micronewtons; return new Force(value, ForceUnit.Micronewton); } - /// /// Creates a from . /// @@ -468,7 +460,6 @@ public static Force FromMillinewtons(QuantityValue millinewtons) double value = (double) millinewtons; return new Force(value, ForceUnit.Millinewton); } - /// /// Creates a from . /// @@ -478,7 +469,6 @@ public static Force FromNewtons(QuantityValue newtons) double value = (double) newtons; return new Force(value, ForceUnit.Newton); } - /// /// Creates a from . /// @@ -488,7 +478,6 @@ public static Force FromOunceForce(QuantityValue ounceforce) double value = (double) ounceforce; return new Force(value, ForceUnit.OunceForce); } - /// /// Creates a from . /// @@ -498,7 +487,6 @@ public static Force FromPoundals(QuantityValue poundals) double value = (double) poundals; return new Force(value, ForceUnit.Poundal); } - /// /// Creates a from . /// @@ -508,7 +496,6 @@ public static Force FromPoundsForce(QuantityValue poundsforce) double value = (double) poundsforce; return new Force(value, ForceUnit.PoundForce); } - /// /// Creates a from . /// @@ -518,7 +505,6 @@ public static Force FromShortTonsForce(QuantityValue shorttonsforce) double value = (double) shorttonsforce; return new Force(value, ForceUnit.ShortTonForce); } - /// /// Creates a from . /// @@ -529,7 +515,6 @@ public static Force FromTonnesForce(QuantityValue tonnesforce) return new Force(value, ForceUnit.TonneForce); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs index 66a8ceff97..d77dbcfe17 100644 --- a/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs @@ -375,7 +375,6 @@ public static ForceChangeRate FromCentinewtonsPerSecond(QuantityValue centinewto double value = (double) centinewtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.CentinewtonPerSecond); } - /// /// Creates a from . /// @@ -385,7 +384,6 @@ public static ForceChangeRate FromDecanewtonsPerMinute(QuantityValue decanewtons double value = (double) decanewtonsperminute; return new ForceChangeRate(value, ForceChangeRateUnit.DecanewtonPerMinute); } - /// /// Creates a from . /// @@ -395,7 +393,6 @@ public static ForceChangeRate FromDecanewtonsPerSecond(QuantityValue decanewtons double value = (double) decanewtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.DecanewtonPerSecond); } - /// /// Creates a from . /// @@ -405,7 +402,6 @@ public static ForceChangeRate FromDecinewtonsPerSecond(QuantityValue decinewtons double value = (double) decinewtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.DecinewtonPerSecond); } - /// /// Creates a from . /// @@ -415,7 +411,6 @@ public static ForceChangeRate FromKilonewtonsPerMinute(QuantityValue kilonewtons double value = (double) kilonewtonsperminute; return new ForceChangeRate(value, ForceChangeRateUnit.KilonewtonPerMinute); } - /// /// Creates a from . /// @@ -425,7 +420,6 @@ public static ForceChangeRate FromKilonewtonsPerSecond(QuantityValue kilonewtons double value = (double) kilonewtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.KilonewtonPerSecond); } - /// /// Creates a from . /// @@ -435,7 +429,6 @@ public static ForceChangeRate FromKilopoundsForcePerMinute(QuantityValue kilopou double value = (double) kilopoundsforceperminute; return new ForceChangeRate(value, ForceChangeRateUnit.KilopoundForcePerMinute); } - /// /// Creates a from . /// @@ -445,7 +438,6 @@ public static ForceChangeRate FromKilopoundsForcePerSecond(QuantityValue kilopou double value = (double) kilopoundsforcepersecond; return new ForceChangeRate(value, ForceChangeRateUnit.KilopoundForcePerSecond); } - /// /// Creates a from . /// @@ -455,7 +447,6 @@ public static ForceChangeRate FromMicronewtonsPerSecond(QuantityValue micronewto double value = (double) micronewtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.MicronewtonPerSecond); } - /// /// Creates a from . /// @@ -465,7 +456,6 @@ public static ForceChangeRate FromMillinewtonsPerSecond(QuantityValue millinewto double value = (double) millinewtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.MillinewtonPerSecond); } - /// /// Creates a from . /// @@ -475,7 +465,6 @@ public static ForceChangeRate FromNanonewtonsPerSecond(QuantityValue nanonewtons double value = (double) nanonewtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.NanonewtonPerSecond); } - /// /// Creates a from . /// @@ -485,7 +474,6 @@ public static ForceChangeRate FromNewtonsPerMinute(QuantityValue newtonsperminut double value = (double) newtonsperminute; return new ForceChangeRate(value, ForceChangeRateUnit.NewtonPerMinute); } - /// /// Creates a from . /// @@ -495,7 +483,6 @@ public static ForceChangeRate FromNewtonsPerSecond(QuantityValue newtonspersecon double value = (double) newtonspersecond; return new ForceChangeRate(value, ForceChangeRateUnit.NewtonPerSecond); } - /// /// Creates a from . /// @@ -505,7 +492,6 @@ public static ForceChangeRate FromPoundsForcePerMinute(QuantityValue poundsforce double value = (double) poundsforceperminute; return new ForceChangeRate(value, ForceChangeRateUnit.PoundForcePerMinute); } - /// /// Creates a from . /// @@ -516,7 +502,6 @@ public static ForceChangeRate FromPoundsForcePerSecond(QuantityValue poundsforce return new ForceChangeRate(value, ForceChangeRateUnit.PoundForcePerSecond); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs index ceae2942ab..9146801f5f 100644 --- a/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs @@ -588,7 +588,6 @@ public static ForcePerLength FromCentinewtonsPerCentimeter(QuantityValue centine double value = (double) centinewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.CentinewtonPerCentimeter); } - /// /// Creates a from . /// @@ -598,7 +597,6 @@ public static ForcePerLength FromCentinewtonsPerMeter(QuantityValue centinewtons double value = (double) centinewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.CentinewtonPerMeter); } - /// /// Creates a from . /// @@ -608,7 +606,6 @@ public static ForcePerLength FromCentinewtonsPerMillimeter(QuantityValue centine double value = (double) centinewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.CentinewtonPerMillimeter); } - /// /// Creates a from . /// @@ -618,7 +615,6 @@ public static ForcePerLength FromDecanewtonsPerCentimeter(QuantityValue decanewt double value = (double) decanewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.DecanewtonPerCentimeter); } - /// /// Creates a from . /// @@ -628,7 +624,6 @@ public static ForcePerLength FromDecanewtonsPerMeter(QuantityValue decanewtonspe double value = (double) decanewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.DecanewtonPerMeter); } - /// /// Creates a from . /// @@ -638,7 +633,6 @@ public static ForcePerLength FromDecanewtonsPerMillimeter(QuantityValue decanewt double value = (double) decanewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.DecanewtonPerMillimeter); } - /// /// Creates a from . /// @@ -648,7 +642,6 @@ public static ForcePerLength FromDecinewtonsPerCentimeter(QuantityValue decinewt double value = (double) decinewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.DecinewtonPerCentimeter); } - /// /// Creates a from . /// @@ -658,7 +651,6 @@ public static ForcePerLength FromDecinewtonsPerMeter(QuantityValue decinewtonspe double value = (double) decinewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.DecinewtonPerMeter); } - /// /// Creates a from . /// @@ -668,7 +660,6 @@ public static ForcePerLength FromDecinewtonsPerMillimeter(QuantityValue decinewt double value = (double) decinewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.DecinewtonPerMillimeter); } - /// /// Creates a from . /// @@ -678,7 +669,6 @@ public static ForcePerLength FromKilogramsForcePerCentimeter(QuantityValue kilog double value = (double) kilogramsforcepercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.KilogramForcePerCentimeter); } - /// /// Creates a from . /// @@ -688,7 +678,6 @@ public static ForcePerLength FromKilogramsForcePerMeter(QuantityValue kilogramsf double value = (double) kilogramsforcepermeter; return new ForcePerLength(value, ForcePerLengthUnit.KilogramForcePerMeter); } - /// /// Creates a from . /// @@ -698,7 +687,6 @@ public static ForcePerLength FromKilogramsForcePerMillimeter(QuantityValue kilog double value = (double) kilogramsforcepermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.KilogramForcePerMillimeter); } - /// /// Creates a from . /// @@ -708,7 +696,6 @@ public static ForcePerLength FromKilonewtonsPerCentimeter(QuantityValue kilonewt double value = (double) kilonewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.KilonewtonPerCentimeter); } - /// /// Creates a from . /// @@ -718,7 +705,6 @@ public static ForcePerLength FromKilonewtonsPerMeter(QuantityValue kilonewtonspe double value = (double) kilonewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.KilonewtonPerMeter); } - /// /// Creates a from . /// @@ -728,7 +714,6 @@ public static ForcePerLength FromKilonewtonsPerMillimeter(QuantityValue kilonewt double value = (double) kilonewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.KilonewtonPerMillimeter); } - /// /// Creates a from . /// @@ -738,7 +723,6 @@ public static ForcePerLength FromKilopoundsForcePerFoot(QuantityValue kilopounds double value = (double) kilopoundsforceperfoot; return new ForcePerLength(value, ForcePerLengthUnit.KilopoundForcePerFoot); } - /// /// Creates a from . /// @@ -748,7 +732,6 @@ public static ForcePerLength FromKilopoundsForcePerInch(QuantityValue kilopounds double value = (double) kilopoundsforceperinch; return new ForcePerLength(value, ForcePerLengthUnit.KilopoundForcePerInch); } - /// /// Creates a from . /// @@ -758,7 +741,6 @@ public static ForcePerLength FromMeganewtonsPerCentimeter(QuantityValue meganewt double value = (double) meganewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.MeganewtonPerCentimeter); } - /// /// Creates a from . /// @@ -768,7 +750,6 @@ public static ForcePerLength FromMeganewtonsPerMeter(QuantityValue meganewtonspe double value = (double) meganewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.MeganewtonPerMeter); } - /// /// Creates a from . /// @@ -778,7 +759,6 @@ public static ForcePerLength FromMeganewtonsPerMillimeter(QuantityValue meganewt double value = (double) meganewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.MeganewtonPerMillimeter); } - /// /// Creates a from . /// @@ -788,7 +768,6 @@ public static ForcePerLength FromMicronewtonsPerCentimeter(QuantityValue microne double value = (double) micronewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.MicronewtonPerCentimeter); } - /// /// Creates a from . /// @@ -798,7 +777,6 @@ public static ForcePerLength FromMicronewtonsPerMeter(QuantityValue micronewtons double value = (double) micronewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.MicronewtonPerMeter); } - /// /// Creates a from . /// @@ -808,7 +786,6 @@ public static ForcePerLength FromMicronewtonsPerMillimeter(QuantityValue microne double value = (double) micronewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.MicronewtonPerMillimeter); } - /// /// Creates a from . /// @@ -818,7 +795,6 @@ public static ForcePerLength FromMillinewtonsPerCentimeter(QuantityValue milline double value = (double) millinewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.MillinewtonPerCentimeter); } - /// /// Creates a from . /// @@ -828,7 +804,6 @@ public static ForcePerLength FromMillinewtonsPerMeter(QuantityValue millinewtons double value = (double) millinewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.MillinewtonPerMeter); } - /// /// Creates a from . /// @@ -838,7 +813,6 @@ public static ForcePerLength FromMillinewtonsPerMillimeter(QuantityValue milline double value = (double) millinewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.MillinewtonPerMillimeter); } - /// /// Creates a from . /// @@ -848,7 +822,6 @@ public static ForcePerLength FromNanonewtonsPerCentimeter(QuantityValue nanonewt double value = (double) nanonewtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.NanonewtonPerCentimeter); } - /// /// Creates a from . /// @@ -858,7 +831,6 @@ public static ForcePerLength FromNanonewtonsPerMeter(QuantityValue nanonewtonspe double value = (double) nanonewtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.NanonewtonPerMeter); } - /// /// Creates a from . /// @@ -868,7 +840,6 @@ public static ForcePerLength FromNanonewtonsPerMillimeter(QuantityValue nanonewt double value = (double) nanonewtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.NanonewtonPerMillimeter); } - /// /// Creates a from . /// @@ -878,7 +849,6 @@ public static ForcePerLength FromNewtonsPerCentimeter(QuantityValue newtonsperce double value = (double) newtonspercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.NewtonPerCentimeter); } - /// /// Creates a from . /// @@ -888,7 +858,6 @@ public static ForcePerLength FromNewtonsPerMeter(QuantityValue newtonspermeter) double value = (double) newtonspermeter; return new ForcePerLength(value, ForcePerLengthUnit.NewtonPerMeter); } - /// /// Creates a from . /// @@ -898,7 +867,6 @@ public static ForcePerLength FromNewtonsPerMillimeter(QuantityValue newtonspermi double value = (double) newtonspermillimeter; return new ForcePerLength(value, ForcePerLengthUnit.NewtonPerMillimeter); } - /// /// Creates a from . /// @@ -908,7 +876,6 @@ public static ForcePerLength FromPoundsForcePerFoot(QuantityValue poundsforceper double value = (double) poundsforceperfoot; return new ForcePerLength(value, ForcePerLengthUnit.PoundForcePerFoot); } - /// /// Creates a from . /// @@ -918,7 +885,6 @@ public static ForcePerLength FromPoundsForcePerInch(QuantityValue poundsforceper double value = (double) poundsforceperinch; return new ForcePerLength(value, ForcePerLengthUnit.PoundForcePerInch); } - /// /// Creates a from . /// @@ -928,7 +894,6 @@ public static ForcePerLength FromPoundsForcePerYard(QuantityValue poundsforceper double value = (double) poundsforceperyard; return new ForcePerLength(value, ForcePerLengthUnit.PoundForcePerYard); } - /// /// Creates a from . /// @@ -938,7 +903,6 @@ public static ForcePerLength FromTonnesForcePerCentimeter(QuantityValue tonnesfo double value = (double) tonnesforcepercentimeter; return new ForcePerLength(value, ForcePerLengthUnit.TonneForcePerCentimeter); } - /// /// Creates a from . /// @@ -948,7 +912,6 @@ public static ForcePerLength FromTonnesForcePerMeter(QuantityValue tonnesforcepe double value = (double) tonnesforcepermeter; return new ForcePerLength(value, ForcePerLengthUnit.TonneForcePerMeter); } - /// /// Creates a from . /// @@ -959,7 +922,6 @@ public static ForcePerLength FromTonnesForcePerMillimeter(QuantityValue tonnesfo return new ForcePerLength(value, ForcePerLengthUnit.TonneForcePerMillimeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs b/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs index 6962aa000f..5bd4b610cc 100644 --- a/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs @@ -346,7 +346,6 @@ public static Frequency FromBeatsPerMinute(QuantityValue beatsperminute) double value = (double) beatsperminute; return new Frequency(value, FrequencyUnit.BeatPerMinute); } - /// /// Creates a from . /// @@ -356,7 +355,6 @@ public static Frequency FromBUnits(QuantityValue bunits) double value = (double) bunits; return new Frequency(value, FrequencyUnit.BUnit); } - /// /// Creates a from . /// @@ -366,7 +364,6 @@ public static Frequency FromCyclesPerHour(QuantityValue cyclesperhour) double value = (double) cyclesperhour; return new Frequency(value, FrequencyUnit.CyclePerHour); } - /// /// Creates a from . /// @@ -376,7 +373,6 @@ public static Frequency FromCyclesPerMinute(QuantityValue cyclesperminute) double value = (double) cyclesperminute; return new Frequency(value, FrequencyUnit.CyclePerMinute); } - /// /// Creates a from . /// @@ -386,7 +382,6 @@ public static Frequency FromGigahertz(QuantityValue gigahertz) double value = (double) gigahertz; return new Frequency(value, FrequencyUnit.Gigahertz); } - /// /// Creates a from . /// @@ -396,7 +391,6 @@ public static Frequency FromHertz(QuantityValue hertz) double value = (double) hertz; return new Frequency(value, FrequencyUnit.Hertz); } - /// /// Creates a from . /// @@ -406,7 +400,6 @@ public static Frequency FromKilohertz(QuantityValue kilohertz) double value = (double) kilohertz; return new Frequency(value, FrequencyUnit.Kilohertz); } - /// /// Creates a from . /// @@ -416,7 +409,6 @@ public static Frequency FromMegahertz(QuantityValue megahertz) double value = (double) megahertz; return new Frequency(value, FrequencyUnit.Megahertz); } - /// /// Creates a from . /// @@ -426,7 +418,6 @@ public static Frequency FromPerSecond(QuantityValue persecond) double value = (double) persecond; return new Frequency(value, FrequencyUnit.PerSecond); } - /// /// Creates a from . /// @@ -436,7 +427,6 @@ public static Frequency FromRadiansPerSecond(QuantityValue radianspersecond) double value = (double) radianspersecond; return new Frequency(value, FrequencyUnit.RadianPerSecond); } - /// /// Creates a from . /// @@ -447,7 +437,6 @@ public static Frequency FromTerahertz(QuantityValue terahertz) return new Frequency(value, FrequencyUnit.Terahertz); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs b/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs index 0e8ddf3b32..b2763f3bb1 100644 --- a/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs @@ -279,7 +279,6 @@ public static FuelEfficiency FromKilometersPerLiters(QuantityValue kilometersper double value = (double) kilometersperliters; return new FuelEfficiency(value, FuelEfficiencyUnit.KilometerPerLiter); } - /// /// Creates a from . /// @@ -289,7 +288,6 @@ public static FuelEfficiency FromLitersPer100Kilometers(QuantityValue litersper1 double value = (double) litersper100kilometers; return new FuelEfficiency(value, FuelEfficiencyUnit.LiterPer100Kilometers); } - /// /// Creates a from . /// @@ -299,7 +297,6 @@ public static FuelEfficiency FromMilesPerUkGallon(QuantityValue milesperukgallon double value = (double) milesperukgallon; return new FuelEfficiency(value, FuelEfficiencyUnit.MilePerUkGallon); } - /// /// Creates a from . /// @@ -310,7 +307,6 @@ public static FuelEfficiency FromMilesPerUsGallon(QuantityValue milesperusgallon return new FuelEfficiency(value, FuelEfficiencyUnit.MilePerUsGallon); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs index 282570facc..0eca49dd08 100644 --- a/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs @@ -402,7 +402,6 @@ public static HeatFlux FromBtusPerHourSquareFoot(QuantityValue btusperhoursquare double value = (double) btusperhoursquarefoot; return new HeatFlux(value, HeatFluxUnit.BtuPerHourSquareFoot); } - /// /// Creates a from . /// @@ -412,7 +411,6 @@ public static HeatFlux FromBtusPerMinuteSquareFoot(QuantityValue btusperminutesq double value = (double) btusperminutesquarefoot; return new HeatFlux(value, HeatFluxUnit.BtuPerMinuteSquareFoot); } - /// /// Creates a from . /// @@ -422,7 +420,6 @@ public static HeatFlux FromBtusPerSecondSquareFoot(QuantityValue btuspersecondsq double value = (double) btuspersecondsquarefoot; return new HeatFlux(value, HeatFluxUnit.BtuPerSecondSquareFoot); } - /// /// Creates a from . /// @@ -432,7 +429,6 @@ public static HeatFlux FromBtusPerSecondSquareInch(QuantityValue btuspersecondsq double value = (double) btuspersecondsquareinch; return new HeatFlux(value, HeatFluxUnit.BtuPerSecondSquareInch); } - /// /// Creates a from . /// @@ -442,7 +438,6 @@ public static HeatFlux FromCaloriesPerSecondSquareCentimeter(QuantityValue calor double value = (double) caloriespersecondsquarecentimeter; return new HeatFlux(value, HeatFluxUnit.CaloriePerSecondSquareCentimeter); } - /// /// Creates a from . /// @@ -452,7 +447,6 @@ public static HeatFlux FromCentiwattsPerSquareMeter(QuantityValue centiwattspers double value = (double) centiwattspersquaremeter; return new HeatFlux(value, HeatFluxUnit.CentiwattPerSquareMeter); } - /// /// Creates a from . /// @@ -462,7 +456,6 @@ public static HeatFlux FromDeciwattsPerSquareMeter(QuantityValue deciwattspersqu double value = (double) deciwattspersquaremeter; return new HeatFlux(value, HeatFluxUnit.DeciwattPerSquareMeter); } - /// /// Creates a from . /// @@ -472,7 +465,6 @@ public static HeatFlux FromKilocaloriesPerHourSquareMeter(QuantityValue kilocalo double value = (double) kilocaloriesperhoursquaremeter; return new HeatFlux(value, HeatFluxUnit.KilocaloriePerHourSquareMeter); } - /// /// Creates a from . /// @@ -482,7 +474,6 @@ public static HeatFlux FromKilocaloriesPerSecondSquareCentimeter(QuantityValue k double value = (double) kilocaloriespersecondsquarecentimeter; return new HeatFlux(value, HeatFluxUnit.KilocaloriePerSecondSquareCentimeter); } - /// /// Creates a from . /// @@ -492,7 +483,6 @@ public static HeatFlux FromKilowattsPerSquareMeter(QuantityValue kilowattspersqu double value = (double) kilowattspersquaremeter; return new HeatFlux(value, HeatFluxUnit.KilowattPerSquareMeter); } - /// /// Creates a from . /// @@ -502,7 +492,6 @@ public static HeatFlux FromMicrowattsPerSquareMeter(QuantityValue microwattspers double value = (double) microwattspersquaremeter; return new HeatFlux(value, HeatFluxUnit.MicrowattPerSquareMeter); } - /// /// Creates a from . /// @@ -512,7 +501,6 @@ public static HeatFlux FromMilliwattsPerSquareMeter(QuantityValue milliwattspers double value = (double) milliwattspersquaremeter; return new HeatFlux(value, HeatFluxUnit.MilliwattPerSquareMeter); } - /// /// Creates a from . /// @@ -522,7 +510,6 @@ public static HeatFlux FromNanowattsPerSquareMeter(QuantityValue nanowattspersqu double value = (double) nanowattspersquaremeter; return new HeatFlux(value, HeatFluxUnit.NanowattPerSquareMeter); } - /// /// Creates a from . /// @@ -532,7 +519,6 @@ public static HeatFlux FromPoundsForcePerFootSecond(QuantityValue poundsforceper double value = (double) poundsforceperfootsecond; return new HeatFlux(value, HeatFluxUnit.PoundForcePerFootSecond); } - /// /// Creates a from . /// @@ -542,7 +528,6 @@ public static HeatFlux FromPoundsPerSecondCubed(QuantityValue poundspersecondcub double value = (double) poundspersecondcubed; return new HeatFlux(value, HeatFluxUnit.PoundPerSecondCubed); } - /// /// Creates a from . /// @@ -552,7 +537,6 @@ public static HeatFlux FromWattsPerSquareFoot(QuantityValue wattspersquarefoot) double value = (double) wattspersquarefoot; return new HeatFlux(value, HeatFluxUnit.WattPerSquareFoot); } - /// /// Creates a from . /// @@ -562,7 +546,6 @@ public static HeatFlux FromWattsPerSquareInch(QuantityValue wattspersquareinch) double value = (double) wattspersquareinch; return new HeatFlux(value, HeatFluxUnit.WattPerSquareInch); } - /// /// Creates a from . /// @@ -573,7 +556,6 @@ public static HeatFlux FromWattsPerSquareMeter(QuantityValue wattspersquaremeter return new HeatFlux(value, HeatFluxUnit.WattPerSquareMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs b/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs index ea0b68f7fb..5fb8d1454e 100644 --- a/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs @@ -267,7 +267,6 @@ public static HeatTransferCoefficient FromBtusPerSquareFootDegreeFahrenheit(Quan double value = (double) btuspersquarefootdegreefahrenheit; return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit); } - /// /// Creates a from . /// @@ -277,7 +276,6 @@ public static HeatTransferCoefficient FromWattsPerSquareMeterCelsius(QuantityVal double value = (double) wattspersquaremetercelsius; return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.WattPerSquareMeterCelsius); } - /// /// Creates a from . /// @@ -288,7 +286,6 @@ public static HeatTransferCoefficient FromWattsPerSquareMeterKelvin(QuantityValu return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs b/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs index 6731b579bc..d23c4326a8 100644 --- a/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs @@ -279,7 +279,6 @@ public static Illuminance FromKilolux(QuantityValue kilolux) double value = (double) kilolux; return new Illuminance(value, IlluminanceUnit.Kilolux); } - /// /// Creates a from . /// @@ -289,7 +288,6 @@ public static Illuminance FromLux(QuantityValue lux) double value = (double) lux; return new Illuminance(value, IlluminanceUnit.Lux); } - /// /// Creates a from . /// @@ -299,7 +297,6 @@ public static Illuminance FromMegalux(QuantityValue megalux) double value = (double) megalux; return new Illuminance(value, IlluminanceUnit.Megalux); } - /// /// Creates a from . /// @@ -310,7 +307,6 @@ public static Illuminance FromMillilux(QuantityValue millilux) return new Illuminance(value, IlluminanceUnit.Millilux); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Information.g.cs b/UnitsNet/GeneratedCode/Quantities/Information.g.cs index fbc2a8d931..e567615334 100644 --- a/UnitsNet/GeneratedCode/Quantities/Information.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Information.g.cs @@ -479,7 +479,6 @@ public static Information FromBits(QuantityValue bits) decimal value = (decimal) bits; return new Information(value, InformationUnit.Bit); } - /// /// Creates a from . /// @@ -489,7 +488,6 @@ public static Information FromBytes(QuantityValue bytes) decimal value = (decimal) bytes; return new Information(value, InformationUnit.Byte); } - /// /// Creates a from . /// @@ -499,7 +497,6 @@ public static Information FromExabits(QuantityValue exabits) decimal value = (decimal) exabits; return new Information(value, InformationUnit.Exabit); } - /// /// Creates a from . /// @@ -509,7 +506,6 @@ public static Information FromExabytes(QuantityValue exabytes) decimal value = (decimal) exabytes; return new Information(value, InformationUnit.Exabyte); } - /// /// Creates a from . /// @@ -519,7 +515,6 @@ public static Information FromExbibits(QuantityValue exbibits) decimal value = (decimal) exbibits; return new Information(value, InformationUnit.Exbibit); } - /// /// Creates a from . /// @@ -529,7 +524,6 @@ public static Information FromExbibytes(QuantityValue exbibytes) decimal value = (decimal) exbibytes; return new Information(value, InformationUnit.Exbibyte); } - /// /// Creates a from . /// @@ -539,7 +533,6 @@ public static Information FromGibibits(QuantityValue gibibits) decimal value = (decimal) gibibits; return new Information(value, InformationUnit.Gibibit); } - /// /// Creates a from . /// @@ -549,7 +542,6 @@ public static Information FromGibibytes(QuantityValue gibibytes) decimal value = (decimal) gibibytes; return new Information(value, InformationUnit.Gibibyte); } - /// /// Creates a from . /// @@ -559,7 +551,6 @@ public static Information FromGigabits(QuantityValue gigabits) decimal value = (decimal) gigabits; return new Information(value, InformationUnit.Gigabit); } - /// /// Creates a from . /// @@ -569,7 +560,6 @@ public static Information FromGigabytes(QuantityValue gigabytes) decimal value = (decimal) gigabytes; return new Information(value, InformationUnit.Gigabyte); } - /// /// Creates a from . /// @@ -579,7 +569,6 @@ public static Information FromKibibits(QuantityValue kibibits) decimal value = (decimal) kibibits; return new Information(value, InformationUnit.Kibibit); } - /// /// Creates a from . /// @@ -589,7 +578,6 @@ public static Information FromKibibytes(QuantityValue kibibytes) decimal value = (decimal) kibibytes; return new Information(value, InformationUnit.Kibibyte); } - /// /// Creates a from . /// @@ -599,7 +587,6 @@ public static Information FromKilobits(QuantityValue kilobits) decimal value = (decimal) kilobits; return new Information(value, InformationUnit.Kilobit); } - /// /// Creates a from . /// @@ -609,7 +596,6 @@ public static Information FromKilobytes(QuantityValue kilobytes) decimal value = (decimal) kilobytes; return new Information(value, InformationUnit.Kilobyte); } - /// /// Creates a from . /// @@ -619,7 +605,6 @@ public static Information FromMebibits(QuantityValue mebibits) decimal value = (decimal) mebibits; return new Information(value, InformationUnit.Mebibit); } - /// /// Creates a from . /// @@ -629,7 +614,6 @@ public static Information FromMebibytes(QuantityValue mebibytes) decimal value = (decimal) mebibytes; return new Information(value, InformationUnit.Mebibyte); } - /// /// Creates a from . /// @@ -639,7 +623,6 @@ public static Information FromMegabits(QuantityValue megabits) decimal value = (decimal) megabits; return new Information(value, InformationUnit.Megabit); } - /// /// Creates a from . /// @@ -649,7 +632,6 @@ public static Information FromMegabytes(QuantityValue megabytes) decimal value = (decimal) megabytes; return new Information(value, InformationUnit.Megabyte); } - /// /// Creates a from . /// @@ -659,7 +641,6 @@ public static Information FromPebibits(QuantityValue pebibits) decimal value = (decimal) pebibits; return new Information(value, InformationUnit.Pebibit); } - /// /// Creates a from . /// @@ -669,7 +650,6 @@ public static Information FromPebibytes(QuantityValue pebibytes) decimal value = (decimal) pebibytes; return new Information(value, InformationUnit.Pebibyte); } - /// /// Creates a from . /// @@ -679,7 +659,6 @@ public static Information FromPetabits(QuantityValue petabits) decimal value = (decimal) petabits; return new Information(value, InformationUnit.Petabit); } - /// /// Creates a from . /// @@ -689,7 +668,6 @@ public static Information FromPetabytes(QuantityValue petabytes) decimal value = (decimal) petabytes; return new Information(value, InformationUnit.Petabyte); } - /// /// Creates a from . /// @@ -699,7 +677,6 @@ public static Information FromTebibits(QuantityValue tebibits) decimal value = (decimal) tebibits; return new Information(value, InformationUnit.Tebibit); } - /// /// Creates a from . /// @@ -709,7 +686,6 @@ public static Information FromTebibytes(QuantityValue tebibytes) decimal value = (decimal) tebibytes; return new Information(value, InformationUnit.Tebibyte); } - /// /// Creates a from . /// @@ -719,7 +695,6 @@ public static Information FromTerabits(QuantityValue terabits) decimal value = (decimal) terabits; return new Information(value, InformationUnit.Terabit); } - /// /// Creates a from . /// @@ -730,7 +705,6 @@ public static Information FromTerabytes(QuantityValue terabytes) return new Information(value, InformationUnit.Terabyte); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs b/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs index 7ed3fd9ecf..2d2688a016 100644 --- a/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs @@ -366,7 +366,6 @@ public static Irradiance FromKilowattsPerSquareCentimeter(QuantityValue kilowatt double value = (double) kilowattspersquarecentimeter; return new Irradiance(value, IrradianceUnit.KilowattPerSquareCentimeter); } - /// /// Creates a from . /// @@ -376,7 +375,6 @@ public static Irradiance FromKilowattsPerSquareMeter(QuantityValue kilowattspers double value = (double) kilowattspersquaremeter; return new Irradiance(value, IrradianceUnit.KilowattPerSquareMeter); } - /// /// Creates a from . /// @@ -386,7 +384,6 @@ public static Irradiance FromMegawattsPerSquareCentimeter(QuantityValue megawatt double value = (double) megawattspersquarecentimeter; return new Irradiance(value, IrradianceUnit.MegawattPerSquareCentimeter); } - /// /// Creates a from . /// @@ -396,7 +393,6 @@ public static Irradiance FromMegawattsPerSquareMeter(QuantityValue megawattspers double value = (double) megawattspersquaremeter; return new Irradiance(value, IrradianceUnit.MegawattPerSquareMeter); } - /// /// Creates a from . /// @@ -406,7 +402,6 @@ public static Irradiance FromMicrowattsPerSquareCentimeter(QuantityValue microwa double value = (double) microwattspersquarecentimeter; return new Irradiance(value, IrradianceUnit.MicrowattPerSquareCentimeter); } - /// /// Creates a from . /// @@ -416,7 +411,6 @@ public static Irradiance FromMicrowattsPerSquareMeter(QuantityValue microwattspe double value = (double) microwattspersquaremeter; return new Irradiance(value, IrradianceUnit.MicrowattPerSquareMeter); } - /// /// Creates a from . /// @@ -426,7 +420,6 @@ public static Irradiance FromMilliwattsPerSquareCentimeter(QuantityValue milliwa double value = (double) milliwattspersquarecentimeter; return new Irradiance(value, IrradianceUnit.MilliwattPerSquareCentimeter); } - /// /// Creates a from . /// @@ -436,7 +429,6 @@ public static Irradiance FromMilliwattsPerSquareMeter(QuantityValue milliwattspe double value = (double) milliwattspersquaremeter; return new Irradiance(value, IrradianceUnit.MilliwattPerSquareMeter); } - /// /// Creates a from . /// @@ -446,7 +438,6 @@ public static Irradiance FromNanowattsPerSquareCentimeter(QuantityValue nanowatt double value = (double) nanowattspersquarecentimeter; return new Irradiance(value, IrradianceUnit.NanowattPerSquareCentimeter); } - /// /// Creates a from . /// @@ -456,7 +447,6 @@ public static Irradiance FromNanowattsPerSquareMeter(QuantityValue nanowattspers double value = (double) nanowattspersquaremeter; return new Irradiance(value, IrradianceUnit.NanowattPerSquareMeter); } - /// /// Creates a from . /// @@ -466,7 +456,6 @@ public static Irradiance FromPicowattsPerSquareCentimeter(QuantityValue picowatt double value = (double) picowattspersquarecentimeter; return new Irradiance(value, IrradianceUnit.PicowattPerSquareCentimeter); } - /// /// Creates a from . /// @@ -476,7 +465,6 @@ public static Irradiance FromPicowattsPerSquareMeter(QuantityValue picowattspers double value = (double) picowattspersquaremeter; return new Irradiance(value, IrradianceUnit.PicowattPerSquareMeter); } - /// /// Creates a from . /// @@ -486,7 +474,6 @@ public static Irradiance FromWattsPerSquareCentimeter(QuantityValue wattspersqua double value = (double) wattspersquarecentimeter; return new Irradiance(value, IrradianceUnit.WattPerSquareCentimeter); } - /// /// Creates a from . /// @@ -497,7 +484,6 @@ public static Irradiance FromWattsPerSquareMeter(QuantityValue wattspersquaremet return new Irradiance(value, IrradianceUnit.WattPerSquareMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs b/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs index 7d9fa92b8f..1a8d5a5575 100644 --- a/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs @@ -306,7 +306,6 @@ public static Irradiation FromJoulesPerSquareCentimeter(QuantityValue joulespers double value = (double) joulespersquarecentimeter; return new Irradiation(value, IrradiationUnit.JoulePerSquareCentimeter); } - /// /// Creates a from . /// @@ -316,7 +315,6 @@ public static Irradiation FromJoulesPerSquareMeter(QuantityValue joulespersquare double value = (double) joulespersquaremeter; return new Irradiation(value, IrradiationUnit.JoulePerSquareMeter); } - /// /// Creates a from . /// @@ -326,7 +324,6 @@ public static Irradiation FromJoulesPerSquareMillimeter(QuantityValue joulespers double value = (double) joulespersquaremillimeter; return new Irradiation(value, IrradiationUnit.JoulePerSquareMillimeter); } - /// /// Creates a from . /// @@ -336,7 +333,6 @@ public static Irradiation FromKilojoulesPerSquareMeter(QuantityValue kilojoulesp double value = (double) kilojoulespersquaremeter; return new Irradiation(value, IrradiationUnit.KilojoulePerSquareMeter); } - /// /// Creates a from . /// @@ -346,7 +342,6 @@ public static Irradiation FromKilowattHoursPerSquareMeter(QuantityValue kilowatt double value = (double) kilowatthourspersquaremeter; return new Irradiation(value, IrradiationUnit.KilowattHourPerSquareMeter); } - /// /// Creates a from . /// @@ -356,7 +351,6 @@ public static Irradiation FromMillijoulesPerSquareCentimeter(QuantityValue milli double value = (double) millijoulespersquarecentimeter; return new Irradiation(value, IrradiationUnit.MillijoulePerSquareCentimeter); } - /// /// Creates a from . /// @@ -367,7 +361,6 @@ public static Irradiation FromWattHoursPerSquareMeter(QuantityValue watthoursper return new Irradiation(value, IrradiationUnit.WattHourPerSquareMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs b/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs index 824a3b4208..33c1775fef 100644 --- a/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs @@ -332,7 +332,6 @@ public static KinematicViscosity FromCentistokes(QuantityValue centistokes) double value = (double) centistokes; return new KinematicViscosity(value, KinematicViscosityUnit.Centistokes); } - /// /// Creates a from . /// @@ -342,7 +341,6 @@ public static KinematicViscosity FromDecistokes(QuantityValue decistokes) double value = (double) decistokes; return new KinematicViscosity(value, KinematicViscosityUnit.Decistokes); } - /// /// Creates a from . /// @@ -352,7 +350,6 @@ public static KinematicViscosity FromKilostokes(QuantityValue kilostokes) double value = (double) kilostokes; return new KinematicViscosity(value, KinematicViscosityUnit.Kilostokes); } - /// /// Creates a from . /// @@ -362,7 +359,6 @@ public static KinematicViscosity FromMicrostokes(QuantityValue microstokes) double value = (double) microstokes; return new KinematicViscosity(value, KinematicViscosityUnit.Microstokes); } - /// /// Creates a from . /// @@ -372,7 +368,6 @@ public static KinematicViscosity FromMillistokes(QuantityValue millistokes) double value = (double) millistokes; return new KinematicViscosity(value, KinematicViscosityUnit.Millistokes); } - /// /// Creates a from . /// @@ -382,7 +377,6 @@ public static KinematicViscosity FromNanostokes(QuantityValue nanostokes) double value = (double) nanostokes; return new KinematicViscosity(value, KinematicViscosityUnit.Nanostokes); } - /// /// Creates a from . /// @@ -392,7 +386,6 @@ public static KinematicViscosity FromSquareFeetPerSecond(QuantityValue squarefee double value = (double) squarefeetpersecond; return new KinematicViscosity(value, KinematicViscosityUnit.SquareFootPerSecond); } - /// /// Creates a from . /// @@ -402,7 +395,6 @@ public static KinematicViscosity FromSquareMetersPerSecond(QuantityValue squarem double value = (double) squaremeterspersecond; return new KinematicViscosity(value, KinematicViscosityUnit.SquareMeterPerSecond); } - /// /// Creates a from . /// @@ -413,7 +405,6 @@ public static KinematicViscosity FromStokes(QuantityValue stokes) return new KinematicViscosity(value, KinematicViscosityUnit.Stokes); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/LapseRate.g.cs b/UnitsNet/GeneratedCode/Quantities/LapseRate.g.cs index b3a9b7b2a6..477f4015a5 100644 --- a/UnitsNet/GeneratedCode/Quantities/LapseRate.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/LapseRate.g.cs @@ -251,7 +251,6 @@ public static LapseRate FromDegreesCelciusPerKilometer(QuantityValue degreescelc return new LapseRate(value, LapseRateUnit.DegreeCelsiusPerKilometer); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Length.g.cs b/UnitsNet/GeneratedCode/Quantities/Length.g.cs index 70537e1f49..5d8f63523d 100644 --- a/UnitsNet/GeneratedCode/Quantities/Length.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Length.g.cs @@ -587,7 +587,6 @@ public static Length FromAngstroms(QuantityValue angstroms) double value = (double) angstroms; return new Length(value, LengthUnit.Angstrom); } - /// /// Creates a from . /// @@ -597,7 +596,6 @@ public static Length FromAstronomicalUnits(QuantityValue astronomicalunits) double value = (double) astronomicalunits; return new Length(value, LengthUnit.AstronomicalUnit); } - /// /// Creates a from . /// @@ -607,7 +605,6 @@ public static Length FromCentimeters(QuantityValue centimeters) double value = (double) centimeters; return new Length(value, LengthUnit.Centimeter); } - /// /// Creates a from . /// @@ -617,7 +614,6 @@ public static Length FromChains(QuantityValue chains) double value = (double) chains; return new Length(value, LengthUnit.Chain); } - /// /// Creates a from . /// @@ -627,7 +623,6 @@ public static Length FromDecameters(QuantityValue decameters) double value = (double) decameters; return new Length(value, LengthUnit.Decameter); } - /// /// Creates a from . /// @@ -637,7 +632,6 @@ public static Length FromDecimeters(QuantityValue decimeters) double value = (double) decimeters; return new Length(value, LengthUnit.Decimeter); } - /// /// Creates a from . /// @@ -647,7 +641,6 @@ public static Length FromDtpPicas(QuantityValue dtppicas) double value = (double) dtppicas; return new Length(value, LengthUnit.DtpPica); } - /// /// Creates a from . /// @@ -657,7 +650,6 @@ public static Length FromDtpPoints(QuantityValue dtppoints) double value = (double) dtppoints; return new Length(value, LengthUnit.DtpPoint); } - /// /// Creates a from . /// @@ -667,7 +659,6 @@ public static Length FromFathoms(QuantityValue fathoms) double value = (double) fathoms; return new Length(value, LengthUnit.Fathom); } - /// /// Creates a from . /// @@ -677,7 +668,6 @@ public static Length FromFeet(QuantityValue feet) double value = (double) feet; return new Length(value, LengthUnit.Foot); } - /// /// Creates a from . /// @@ -687,7 +677,6 @@ public static Length FromHands(QuantityValue hands) double value = (double) hands; return new Length(value, LengthUnit.Hand); } - /// /// Creates a from . /// @@ -697,7 +686,6 @@ public static Length FromHectometers(QuantityValue hectometers) double value = (double) hectometers; return new Length(value, LengthUnit.Hectometer); } - /// /// Creates a from . /// @@ -707,7 +695,6 @@ public static Length FromInches(QuantityValue inches) double value = (double) inches; return new Length(value, LengthUnit.Inch); } - /// /// Creates a from . /// @@ -717,7 +704,6 @@ public static Length FromKilolightYears(QuantityValue kilolightyears) double value = (double) kilolightyears; return new Length(value, LengthUnit.KilolightYear); } - /// /// Creates a from . /// @@ -727,7 +713,6 @@ public static Length FromKilometers(QuantityValue kilometers) double value = (double) kilometers; return new Length(value, LengthUnit.Kilometer); } - /// /// Creates a from . /// @@ -737,7 +722,6 @@ public static Length FromKiloparsecs(QuantityValue kiloparsecs) double value = (double) kiloparsecs; return new Length(value, LengthUnit.Kiloparsec); } - /// /// Creates a from . /// @@ -747,7 +731,6 @@ public static Length FromLightYears(QuantityValue lightyears) double value = (double) lightyears; return new Length(value, LengthUnit.LightYear); } - /// /// Creates a from . /// @@ -757,7 +740,6 @@ public static Length FromMegalightYears(QuantityValue megalightyears) double value = (double) megalightyears; return new Length(value, LengthUnit.MegalightYear); } - /// /// Creates a from . /// @@ -767,7 +749,6 @@ public static Length FromMegaparsecs(QuantityValue megaparsecs) double value = (double) megaparsecs; return new Length(value, LengthUnit.Megaparsec); } - /// /// Creates a from . /// @@ -777,7 +758,6 @@ public static Length FromMeters(QuantityValue meters) double value = (double) meters; return new Length(value, LengthUnit.Meter); } - /// /// Creates a from . /// @@ -787,7 +767,6 @@ public static Length FromMicroinches(QuantityValue microinches) double value = (double) microinches; return new Length(value, LengthUnit.Microinch); } - /// /// Creates a from . /// @@ -797,7 +776,6 @@ public static Length FromMicrometers(QuantityValue micrometers) double value = (double) micrometers; return new Length(value, LengthUnit.Micrometer); } - /// /// Creates a from . /// @@ -807,7 +785,6 @@ public static Length FromMils(QuantityValue mils) double value = (double) mils; return new Length(value, LengthUnit.Mil); } - /// /// Creates a from . /// @@ -817,7 +794,6 @@ public static Length FromMiles(QuantityValue miles) double value = (double) miles; return new Length(value, LengthUnit.Mile); } - /// /// Creates a from . /// @@ -827,7 +803,6 @@ public static Length FromMillimeters(QuantityValue millimeters) double value = (double) millimeters; return new Length(value, LengthUnit.Millimeter); } - /// /// Creates a from . /// @@ -837,7 +812,6 @@ public static Length FromNanometers(QuantityValue nanometers) double value = (double) nanometers; return new Length(value, LengthUnit.Nanometer); } - /// /// Creates a from . /// @@ -847,7 +821,6 @@ public static Length FromNauticalMiles(QuantityValue nauticalmiles) double value = (double) nauticalmiles; return new Length(value, LengthUnit.NauticalMile); } - /// /// Creates a from . /// @@ -857,7 +830,6 @@ public static Length FromParsecs(QuantityValue parsecs) double value = (double) parsecs; return new Length(value, LengthUnit.Parsec); } - /// /// Creates a from . /// @@ -867,7 +839,6 @@ public static Length FromPrinterPicas(QuantityValue printerpicas) double value = (double) printerpicas; return new Length(value, LengthUnit.PrinterPica); } - /// /// Creates a from . /// @@ -877,7 +848,6 @@ public static Length FromPrinterPoints(QuantityValue printerpoints) double value = (double) printerpoints; return new Length(value, LengthUnit.PrinterPoint); } - /// /// Creates a from . /// @@ -887,7 +857,6 @@ public static Length FromShackles(QuantityValue shackles) double value = (double) shackles; return new Length(value, LengthUnit.Shackle); } - /// /// Creates a from . /// @@ -897,7 +866,6 @@ public static Length FromSolarRadiuses(QuantityValue solarradiuses) double value = (double) solarradiuses; return new Length(value, LengthUnit.SolarRadius); } - /// /// Creates a from . /// @@ -907,7 +875,6 @@ public static Length FromTwips(QuantityValue twips) double value = (double) twips; return new Length(value, LengthUnit.Twip); } - /// /// Creates a from . /// @@ -917,7 +884,6 @@ public static Length FromUsSurveyFeet(QuantityValue ussurveyfeet) double value = (double) ussurveyfeet; return new Length(value, LengthUnit.UsSurveyFoot); } - /// /// Creates a from . /// @@ -928,7 +894,6 @@ public static Length FromYards(QuantityValue yards) return new Length(value, LengthUnit.Yard); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Level.g.cs b/UnitsNet/GeneratedCode/Quantities/Level.g.cs index 61c39b64e5..a52491e09b 100644 --- a/UnitsNet/GeneratedCode/Quantities/Level.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Level.g.cs @@ -258,7 +258,6 @@ public static Level FromDecibels(QuantityValue decibels) double value = (double) decibels; return new Level(value, LevelUnit.Decibel); } - /// /// Creates a from . /// @@ -269,7 +268,6 @@ public static Level FromNepers(QuantityValue nepers) return new Level(value, LevelUnit.Neper); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs index 2ac4abeae6..70677e6f39 100644 --- a/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs @@ -369,7 +369,6 @@ public static LinearDensity FromGramsPerCentimeter(QuantityValue gramspercentime double value = (double) gramspercentimeter; return new LinearDensity(value, LinearDensityUnit.GramPerCentimeter); } - /// /// Creates a from . /// @@ -379,7 +378,6 @@ public static LinearDensity FromGramsPerMeter(QuantityValue gramspermeter) double value = (double) gramspermeter; return new LinearDensity(value, LinearDensityUnit.GramPerMeter); } - /// /// Creates a from . /// @@ -389,7 +387,6 @@ public static LinearDensity FromGramsPerMillimeter(QuantityValue gramspermillime double value = (double) gramspermillimeter; return new LinearDensity(value, LinearDensityUnit.GramPerMillimeter); } - /// /// Creates a from . /// @@ -399,7 +396,6 @@ public static LinearDensity FromKilogramsPerCentimeter(QuantityValue kilogramspe double value = (double) kilogramspercentimeter; return new LinearDensity(value, LinearDensityUnit.KilogramPerCentimeter); } - /// /// Creates a from . /// @@ -409,7 +405,6 @@ public static LinearDensity FromKilogramsPerMeter(QuantityValue kilogramspermete double value = (double) kilogramspermeter; return new LinearDensity(value, LinearDensityUnit.KilogramPerMeter); } - /// /// Creates a from . /// @@ -419,7 +414,6 @@ public static LinearDensity FromKilogramsPerMillimeter(QuantityValue kilogramspe double value = (double) kilogramspermillimeter; return new LinearDensity(value, LinearDensityUnit.KilogramPerMillimeter); } - /// /// Creates a from . /// @@ -429,7 +423,6 @@ public static LinearDensity FromMicrogramsPerCentimeter(QuantityValue micrograms double value = (double) microgramspercentimeter; return new LinearDensity(value, LinearDensityUnit.MicrogramPerCentimeter); } - /// /// Creates a from . /// @@ -439,7 +432,6 @@ public static LinearDensity FromMicrogramsPerMeter(QuantityValue microgramsperme double value = (double) microgramspermeter; return new LinearDensity(value, LinearDensityUnit.MicrogramPerMeter); } - /// /// Creates a from . /// @@ -449,7 +441,6 @@ public static LinearDensity FromMicrogramsPerMillimeter(QuantityValue micrograms double value = (double) microgramspermillimeter; return new LinearDensity(value, LinearDensityUnit.MicrogramPerMillimeter); } - /// /// Creates a from . /// @@ -459,7 +450,6 @@ public static LinearDensity FromMilligramsPerCentimeter(QuantityValue milligrams double value = (double) milligramspercentimeter; return new LinearDensity(value, LinearDensityUnit.MilligramPerCentimeter); } - /// /// Creates a from . /// @@ -469,7 +459,6 @@ public static LinearDensity FromMilligramsPerMeter(QuantityValue milligramsperme double value = (double) milligramspermeter; return new LinearDensity(value, LinearDensityUnit.MilligramPerMeter); } - /// /// Creates a from . /// @@ -479,7 +468,6 @@ public static LinearDensity FromMilligramsPerMillimeter(QuantityValue milligrams double value = (double) milligramspermillimeter; return new LinearDensity(value, LinearDensityUnit.MilligramPerMillimeter); } - /// /// Creates a from . /// @@ -489,7 +477,6 @@ public static LinearDensity FromPoundsPerFoot(QuantityValue poundsperfoot) double value = (double) poundsperfoot; return new LinearDensity(value, LinearDensityUnit.PoundPerFoot); } - /// /// Creates a from . /// @@ -500,7 +487,6 @@ public static LinearDensity FromPoundsPerInch(QuantityValue poundsperinch) return new LinearDensity(value, LinearDensityUnit.PoundPerInch); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs index 8df4e7aa49..1f6e8dc2b7 100644 --- a/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs @@ -468,7 +468,6 @@ public static LinearPowerDensity FromGigawattsPerCentimeter(QuantityValue gigawa double value = (double) gigawattspercentimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerCentimeter); } - /// /// Creates a from . /// @@ -478,7 +477,6 @@ public static LinearPowerDensity FromGigawattsPerFoot(QuantityValue gigawattsper double value = (double) gigawattsperfoot; return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerFoot); } - /// /// Creates a from . /// @@ -488,7 +486,6 @@ public static LinearPowerDensity FromGigawattsPerInch(QuantityValue gigawattsper double value = (double) gigawattsperinch; return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerInch); } - /// /// Creates a from . /// @@ -498,7 +495,6 @@ public static LinearPowerDensity FromGigawattsPerMeter(QuantityValue gigawattspe double value = (double) gigawattspermeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerMeter); } - /// /// Creates a from . /// @@ -508,7 +504,6 @@ public static LinearPowerDensity FromGigawattsPerMillimeter(QuantityValue gigawa double value = (double) gigawattspermillimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerMillimeter); } - /// /// Creates a from . /// @@ -518,7 +513,6 @@ public static LinearPowerDensity FromKilowattsPerCentimeter(QuantityValue kilowa double value = (double) kilowattspercentimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerCentimeter); } - /// /// Creates a from . /// @@ -528,7 +522,6 @@ public static LinearPowerDensity FromKilowattsPerFoot(QuantityValue kilowattsper double value = (double) kilowattsperfoot; return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerFoot); } - /// /// Creates a from . /// @@ -538,7 +531,6 @@ public static LinearPowerDensity FromKilowattsPerInch(QuantityValue kilowattsper double value = (double) kilowattsperinch; return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerInch); } - /// /// Creates a from . /// @@ -548,7 +540,6 @@ public static LinearPowerDensity FromKilowattsPerMeter(QuantityValue kilowattspe double value = (double) kilowattspermeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerMeter); } - /// /// Creates a from . /// @@ -558,7 +549,6 @@ public static LinearPowerDensity FromKilowattsPerMillimeter(QuantityValue kilowa double value = (double) kilowattspermillimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerMillimeter); } - /// /// Creates a from . /// @@ -568,7 +558,6 @@ public static LinearPowerDensity FromMegawattsPerCentimeter(QuantityValue megawa double value = (double) megawattspercentimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerCentimeter); } - /// /// Creates a from . /// @@ -578,7 +567,6 @@ public static LinearPowerDensity FromMegawattsPerFoot(QuantityValue megawattsper double value = (double) megawattsperfoot; return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerFoot); } - /// /// Creates a from . /// @@ -588,7 +576,6 @@ public static LinearPowerDensity FromMegawattsPerInch(QuantityValue megawattsper double value = (double) megawattsperinch; return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerInch); } - /// /// Creates a from . /// @@ -598,7 +585,6 @@ public static LinearPowerDensity FromMegawattsPerMeter(QuantityValue megawattspe double value = (double) megawattspermeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerMeter); } - /// /// Creates a from . /// @@ -608,7 +594,6 @@ public static LinearPowerDensity FromMegawattsPerMillimeter(QuantityValue megawa double value = (double) megawattspermillimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerMillimeter); } - /// /// Creates a from . /// @@ -618,7 +603,6 @@ public static LinearPowerDensity FromMilliwattsPerCentimeter(QuantityValue milli double value = (double) milliwattspercentimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerCentimeter); } - /// /// Creates a from . /// @@ -628,7 +612,6 @@ public static LinearPowerDensity FromMilliwattsPerFoot(QuantityValue milliwattsp double value = (double) milliwattsperfoot; return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerFoot); } - /// /// Creates a from . /// @@ -638,7 +621,6 @@ public static LinearPowerDensity FromMilliwattsPerInch(QuantityValue milliwattsp double value = (double) milliwattsperinch; return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerInch); } - /// /// Creates a from . /// @@ -648,7 +630,6 @@ public static LinearPowerDensity FromMilliwattsPerMeter(QuantityValue milliwatts double value = (double) milliwattspermeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerMeter); } - /// /// Creates a from . /// @@ -658,7 +639,6 @@ public static LinearPowerDensity FromMilliwattsPerMillimeter(QuantityValue milli double value = (double) milliwattspermillimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerMillimeter); } - /// /// Creates a from . /// @@ -668,7 +648,6 @@ public static LinearPowerDensity FromWattsPerCentimeter(QuantityValue wattsperce double value = (double) wattspercentimeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerCentimeter); } - /// /// Creates a from . /// @@ -678,7 +657,6 @@ public static LinearPowerDensity FromWattsPerFoot(QuantityValue wattsperfoot) double value = (double) wattsperfoot; return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerFoot); } - /// /// Creates a from . /// @@ -688,7 +666,6 @@ public static LinearPowerDensity FromWattsPerInch(QuantityValue wattsperinch) double value = (double) wattsperinch; return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerInch); } - /// /// Creates a from . /// @@ -698,7 +675,6 @@ public static LinearPowerDensity FromWattsPerMeter(QuantityValue wattspermeter) double value = (double) wattspermeter; return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerMeter); } - /// /// Creates a from . /// @@ -709,7 +685,6 @@ public static LinearPowerDensity FromWattsPerMillimeter(QuantityValue wattspermi return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerMillimeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs b/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs index f84d254c70..85b41fada5 100644 --- a/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs @@ -369,7 +369,6 @@ public static Luminosity FromDecawatts(QuantityValue decawatts) double value = (double) decawatts; return new Luminosity(value, LuminosityUnit.Decawatt); } - /// /// Creates a from . /// @@ -379,7 +378,6 @@ public static Luminosity FromDeciwatts(QuantityValue deciwatts) double value = (double) deciwatts; return new Luminosity(value, LuminosityUnit.Deciwatt); } - /// /// Creates a from . /// @@ -389,7 +387,6 @@ public static Luminosity FromFemtowatts(QuantityValue femtowatts) double value = (double) femtowatts; return new Luminosity(value, LuminosityUnit.Femtowatt); } - /// /// Creates a from . /// @@ -399,7 +396,6 @@ public static Luminosity FromGigawatts(QuantityValue gigawatts) double value = (double) gigawatts; return new Luminosity(value, LuminosityUnit.Gigawatt); } - /// /// Creates a from . /// @@ -409,7 +405,6 @@ public static Luminosity FromKilowatts(QuantityValue kilowatts) double value = (double) kilowatts; return new Luminosity(value, LuminosityUnit.Kilowatt); } - /// /// Creates a from . /// @@ -419,7 +414,6 @@ public static Luminosity FromMegawatts(QuantityValue megawatts) double value = (double) megawatts; return new Luminosity(value, LuminosityUnit.Megawatt); } - /// /// Creates a from . /// @@ -429,7 +423,6 @@ public static Luminosity FromMicrowatts(QuantityValue microwatts) double value = (double) microwatts; return new Luminosity(value, LuminosityUnit.Microwatt); } - /// /// Creates a from . /// @@ -439,7 +432,6 @@ public static Luminosity FromMilliwatts(QuantityValue milliwatts) double value = (double) milliwatts; return new Luminosity(value, LuminosityUnit.Milliwatt); } - /// /// Creates a from . /// @@ -449,7 +441,6 @@ public static Luminosity FromNanowatts(QuantityValue nanowatts) double value = (double) nanowatts; return new Luminosity(value, LuminosityUnit.Nanowatt); } - /// /// Creates a from . /// @@ -459,7 +450,6 @@ public static Luminosity FromPetawatts(QuantityValue petawatts) double value = (double) petawatts; return new Luminosity(value, LuminosityUnit.Petawatt); } - /// /// Creates a from . /// @@ -469,7 +459,6 @@ public static Luminosity FromPicowatts(QuantityValue picowatts) double value = (double) picowatts; return new Luminosity(value, LuminosityUnit.Picowatt); } - /// /// Creates a from . /// @@ -479,7 +468,6 @@ public static Luminosity FromSolarLuminosities(QuantityValue solarluminosities) double value = (double) solarluminosities; return new Luminosity(value, LuminosityUnit.SolarLuminosity); } - /// /// Creates a from . /// @@ -489,7 +477,6 @@ public static Luminosity FromTerawatts(QuantityValue terawatts) double value = (double) terawatts; return new Luminosity(value, LuminosityUnit.Terawatt); } - /// /// Creates a from . /// @@ -500,7 +487,6 @@ public static Luminosity FromWatts(QuantityValue watts) return new Luminosity(value, LuminosityUnit.Watt); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs index f4a617259f..9dd2b04a86 100644 --- a/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs @@ -253,7 +253,6 @@ public static LuminousFlux FromLumens(QuantityValue lumens) return new LuminousFlux(value, LuminousFluxUnit.Lumen); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs b/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs index 46dd530374..f6d0175e1b 100644 --- a/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs @@ -253,7 +253,6 @@ public static LuminousIntensity FromCandela(QuantityValue candela) return new LuminousIntensity(value, LuminousIntensityUnit.Candela); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs b/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs index cb95282466..8dbde9c185 100644 --- a/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs @@ -297,7 +297,6 @@ public static MagneticField FromGausses(QuantityValue gausses) double value = (double) gausses; return new MagneticField(value, MagneticFieldUnit.Gauss); } - /// /// Creates a from . /// @@ -307,7 +306,6 @@ public static MagneticField FromMicroteslas(QuantityValue microteslas) double value = (double) microteslas; return new MagneticField(value, MagneticFieldUnit.Microtesla); } - /// /// Creates a from . /// @@ -317,7 +315,6 @@ public static MagneticField FromMilligausses(QuantityValue milligausses) double value = (double) milligausses; return new MagneticField(value, MagneticFieldUnit.Milligauss); } - /// /// Creates a from . /// @@ -327,7 +324,6 @@ public static MagneticField FromMilliteslas(QuantityValue milliteslas) double value = (double) milliteslas; return new MagneticField(value, MagneticFieldUnit.Millitesla); } - /// /// Creates a from . /// @@ -337,7 +333,6 @@ public static MagneticField FromNanoteslas(QuantityValue nanoteslas) double value = (double) nanoteslas; return new MagneticField(value, MagneticFieldUnit.Nanotesla); } - /// /// Creates a from . /// @@ -348,7 +343,6 @@ public static MagneticField FromTeslas(QuantityValue teslas) return new MagneticField(value, MagneticFieldUnit.Tesla); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs index 2fb9d52286..c7cada3007 100644 --- a/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs @@ -253,7 +253,6 @@ public static MagneticFlux FromWebers(QuantityValue webers) return new MagneticFlux(value, MagneticFluxUnit.Weber); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs b/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs index 551fdd43c9..9d337fe75a 100644 --- a/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs @@ -253,7 +253,6 @@ public static Magnetization FromAmperesPerMeter(QuantityValue amperespermeter) return new Magnetization(value, MagnetizationUnit.AmperePerMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Mass.g.cs b/UnitsNet/GeneratedCode/Quantities/Mass.g.cs index fb6bad4709..818473581b 100644 --- a/UnitsNet/GeneratedCode/Quantities/Mass.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Mass.g.cs @@ -500,7 +500,6 @@ public static Mass FromCentigrams(QuantityValue centigrams) double value = (double) centigrams; return new Mass(value, MassUnit.Centigram); } - /// /// Creates a from . /// @@ -510,7 +509,6 @@ public static Mass FromDecagrams(QuantityValue decagrams) double value = (double) decagrams; return new Mass(value, MassUnit.Decagram); } - /// /// Creates a from . /// @@ -520,7 +518,6 @@ public static Mass FromDecigrams(QuantityValue decigrams) double value = (double) decigrams; return new Mass(value, MassUnit.Decigram); } - /// /// Creates a from . /// @@ -530,7 +527,6 @@ public static Mass FromEarthMasses(QuantityValue earthmasses) double value = (double) earthmasses; return new Mass(value, MassUnit.EarthMass); } - /// /// Creates a from . /// @@ -540,7 +536,6 @@ public static Mass FromGrains(QuantityValue grains) double value = (double) grains; return new Mass(value, MassUnit.Grain); } - /// /// Creates a from . /// @@ -550,7 +545,6 @@ public static Mass FromGrams(QuantityValue grams) double value = (double) grams; return new Mass(value, MassUnit.Gram); } - /// /// Creates a from . /// @@ -560,7 +554,6 @@ public static Mass FromHectograms(QuantityValue hectograms) double value = (double) hectograms; return new Mass(value, MassUnit.Hectogram); } - /// /// Creates a from . /// @@ -570,7 +563,6 @@ public static Mass FromKilograms(QuantityValue kilograms) double value = (double) kilograms; return new Mass(value, MassUnit.Kilogram); } - /// /// Creates a from . /// @@ -580,7 +572,6 @@ public static Mass FromKilopounds(QuantityValue kilopounds) double value = (double) kilopounds; return new Mass(value, MassUnit.Kilopound); } - /// /// Creates a from . /// @@ -590,7 +581,6 @@ public static Mass FromKilotonnes(QuantityValue kilotonnes) double value = (double) kilotonnes; return new Mass(value, MassUnit.Kilotonne); } - /// /// Creates a from . /// @@ -600,7 +590,6 @@ public static Mass FromLongHundredweight(QuantityValue longhundredweight) double value = (double) longhundredweight; return new Mass(value, MassUnit.LongHundredweight); } - /// /// Creates a from . /// @@ -610,7 +599,6 @@ public static Mass FromLongTons(QuantityValue longtons) double value = (double) longtons; return new Mass(value, MassUnit.LongTon); } - /// /// Creates a from . /// @@ -620,7 +608,6 @@ public static Mass FromMegapounds(QuantityValue megapounds) double value = (double) megapounds; return new Mass(value, MassUnit.Megapound); } - /// /// Creates a from . /// @@ -630,7 +617,6 @@ public static Mass FromMegatonnes(QuantityValue megatonnes) double value = (double) megatonnes; return new Mass(value, MassUnit.Megatonne); } - /// /// Creates a from . /// @@ -640,7 +626,6 @@ public static Mass FromMicrograms(QuantityValue micrograms) double value = (double) micrograms; return new Mass(value, MassUnit.Microgram); } - /// /// Creates a from . /// @@ -650,7 +635,6 @@ public static Mass FromMilligrams(QuantityValue milligrams) double value = (double) milligrams; return new Mass(value, MassUnit.Milligram); } - /// /// Creates a from . /// @@ -660,7 +644,6 @@ public static Mass FromNanograms(QuantityValue nanograms) double value = (double) nanograms; return new Mass(value, MassUnit.Nanogram); } - /// /// Creates a from . /// @@ -670,7 +653,6 @@ public static Mass FromOunces(QuantityValue ounces) double value = (double) ounces; return new Mass(value, MassUnit.Ounce); } - /// /// Creates a from . /// @@ -680,7 +662,6 @@ public static Mass FromPounds(QuantityValue pounds) double value = (double) pounds; return new Mass(value, MassUnit.Pound); } - /// /// Creates a from . /// @@ -690,7 +671,6 @@ public static Mass FromShortHundredweight(QuantityValue shorthundredweight) double value = (double) shorthundredweight; return new Mass(value, MassUnit.ShortHundredweight); } - /// /// Creates a from . /// @@ -700,7 +680,6 @@ public static Mass FromShortTons(QuantityValue shorttons) double value = (double) shorttons; return new Mass(value, MassUnit.ShortTon); } - /// /// Creates a from . /// @@ -710,7 +689,6 @@ public static Mass FromSlugs(QuantityValue slugs) double value = (double) slugs; return new Mass(value, MassUnit.Slug); } - /// /// Creates a from . /// @@ -720,7 +698,6 @@ public static Mass FromSolarMasses(QuantityValue solarmasses) double value = (double) solarmasses; return new Mass(value, MassUnit.SolarMass); } - /// /// Creates a from . /// @@ -730,7 +707,6 @@ public static Mass FromStone(QuantityValue stone) double value = (double) stone; return new Mass(value, MassUnit.Stone); } - /// /// Creates a from . /// @@ -741,7 +717,6 @@ public static Mass FromTonnes(QuantityValue tonnes) return new Mass(value, MassUnit.Tonne); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs b/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs index d4ca16225c..c3c77bdbe7 100644 --- a/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs @@ -688,7 +688,6 @@ public static MassConcentration FromCentigramsPerDeciliter(QuantityValue centigr double value = (double) centigramsperdeciliter; return new MassConcentration(value, MassConcentrationUnit.CentigramPerDeciliter); } - /// /// Creates a from . /// @@ -698,7 +697,6 @@ public static MassConcentration FromCentigramsPerLiter(QuantityValue centigramsp double value = (double) centigramsperliter; return new MassConcentration(value, MassConcentrationUnit.CentigramPerLiter); } - /// /// Creates a from . /// @@ -708,7 +706,6 @@ public static MassConcentration FromCentigramsPerMicroliter(QuantityValue centig double value = (double) centigramspermicroliter; return new MassConcentration(value, MassConcentrationUnit.CentigramPerMicroliter); } - /// /// Creates a from . /// @@ -718,7 +715,6 @@ public static MassConcentration FromCentigramsPerMilliliter(QuantityValue centig double value = (double) centigramspermilliliter; return new MassConcentration(value, MassConcentrationUnit.CentigramPerMilliliter); } - /// /// Creates a from . /// @@ -728,7 +724,6 @@ public static MassConcentration FromDecigramsPerDeciliter(QuantityValue decigram double value = (double) decigramsperdeciliter; return new MassConcentration(value, MassConcentrationUnit.DecigramPerDeciliter); } - /// /// Creates a from . /// @@ -738,7 +733,6 @@ public static MassConcentration FromDecigramsPerLiter(QuantityValue decigramsper double value = (double) decigramsperliter; return new MassConcentration(value, MassConcentrationUnit.DecigramPerLiter); } - /// /// Creates a from . /// @@ -748,7 +742,6 @@ public static MassConcentration FromDecigramsPerMicroliter(QuantityValue decigra double value = (double) decigramspermicroliter; return new MassConcentration(value, MassConcentrationUnit.DecigramPerMicroliter); } - /// /// Creates a from . /// @@ -758,7 +751,6 @@ public static MassConcentration FromDecigramsPerMilliliter(QuantityValue decigra double value = (double) decigramspermilliliter; return new MassConcentration(value, MassConcentrationUnit.DecigramPerMilliliter); } - /// /// Creates a from . /// @@ -768,7 +760,6 @@ public static MassConcentration FromGramsPerCubicCentimeter(QuantityValue gramsp double value = (double) gramspercubiccentimeter; return new MassConcentration(value, MassConcentrationUnit.GramPerCubicCentimeter); } - /// /// Creates a from . /// @@ -778,7 +769,6 @@ public static MassConcentration FromGramsPerCubicMeter(QuantityValue gramspercub double value = (double) gramspercubicmeter; return new MassConcentration(value, MassConcentrationUnit.GramPerCubicMeter); } - /// /// Creates a from . /// @@ -788,7 +778,6 @@ public static MassConcentration FromGramsPerCubicMillimeter(QuantityValue gramsp double value = (double) gramspercubicmillimeter; return new MassConcentration(value, MassConcentrationUnit.GramPerCubicMillimeter); } - /// /// Creates a from . /// @@ -798,7 +787,6 @@ public static MassConcentration FromGramsPerDeciliter(QuantityValue gramsperdeci double value = (double) gramsperdeciliter; return new MassConcentration(value, MassConcentrationUnit.GramPerDeciliter); } - /// /// Creates a from . /// @@ -808,7 +796,6 @@ public static MassConcentration FromGramsPerLiter(QuantityValue gramsperliter) double value = (double) gramsperliter; return new MassConcentration(value, MassConcentrationUnit.GramPerLiter); } - /// /// Creates a from . /// @@ -818,7 +805,6 @@ public static MassConcentration FromGramsPerMicroliter(QuantityValue gramspermic double value = (double) gramspermicroliter; return new MassConcentration(value, MassConcentrationUnit.GramPerMicroliter); } - /// /// Creates a from . /// @@ -828,7 +814,6 @@ public static MassConcentration FromGramsPerMilliliter(QuantityValue gramspermil double value = (double) gramspermilliliter; return new MassConcentration(value, MassConcentrationUnit.GramPerMilliliter); } - /// /// Creates a from . /// @@ -838,7 +823,6 @@ public static MassConcentration FromKilogramsPerCubicCentimeter(QuantityValue ki double value = (double) kilogramspercubiccentimeter; return new MassConcentration(value, MassConcentrationUnit.KilogramPerCubicCentimeter); } - /// /// Creates a from . /// @@ -848,7 +832,6 @@ public static MassConcentration FromKilogramsPerCubicMeter(QuantityValue kilogra double value = (double) kilogramspercubicmeter; return new MassConcentration(value, MassConcentrationUnit.KilogramPerCubicMeter); } - /// /// Creates a from . /// @@ -858,7 +841,6 @@ public static MassConcentration FromKilogramsPerCubicMillimeter(QuantityValue ki double value = (double) kilogramspercubicmillimeter; return new MassConcentration(value, MassConcentrationUnit.KilogramPerCubicMillimeter); } - /// /// Creates a from . /// @@ -868,7 +850,6 @@ public static MassConcentration FromKilogramsPerLiter(QuantityValue kilogramsper double value = (double) kilogramsperliter; return new MassConcentration(value, MassConcentrationUnit.KilogramPerLiter); } - /// /// Creates a from . /// @@ -878,7 +859,6 @@ public static MassConcentration FromKilopoundsPerCubicFoot(QuantityValue kilopou double value = (double) kilopoundspercubicfoot; return new MassConcentration(value, MassConcentrationUnit.KilopoundPerCubicFoot); } - /// /// Creates a from . /// @@ -888,7 +868,6 @@ public static MassConcentration FromKilopoundsPerCubicInch(QuantityValue kilopou double value = (double) kilopoundspercubicinch; return new MassConcentration(value, MassConcentrationUnit.KilopoundPerCubicInch); } - /// /// Creates a from . /// @@ -898,7 +877,6 @@ public static MassConcentration FromMicrogramsPerCubicMeter(QuantityValue microg double value = (double) microgramspercubicmeter; return new MassConcentration(value, MassConcentrationUnit.MicrogramPerCubicMeter); } - /// /// Creates a from . /// @@ -908,7 +886,6 @@ public static MassConcentration FromMicrogramsPerDeciliter(QuantityValue microgr double value = (double) microgramsperdeciliter; return new MassConcentration(value, MassConcentrationUnit.MicrogramPerDeciliter); } - /// /// Creates a from . /// @@ -918,7 +895,6 @@ public static MassConcentration FromMicrogramsPerLiter(QuantityValue microgramsp double value = (double) microgramsperliter; return new MassConcentration(value, MassConcentrationUnit.MicrogramPerLiter); } - /// /// Creates a from . /// @@ -928,7 +904,6 @@ public static MassConcentration FromMicrogramsPerMicroliter(QuantityValue microg double value = (double) microgramspermicroliter; return new MassConcentration(value, MassConcentrationUnit.MicrogramPerMicroliter); } - /// /// Creates a from . /// @@ -938,7 +913,6 @@ public static MassConcentration FromMicrogramsPerMilliliter(QuantityValue microg double value = (double) microgramspermilliliter; return new MassConcentration(value, MassConcentrationUnit.MicrogramPerMilliliter); } - /// /// Creates a from . /// @@ -948,7 +922,6 @@ public static MassConcentration FromMilligramsPerCubicMeter(QuantityValue millig double value = (double) milligramspercubicmeter; return new MassConcentration(value, MassConcentrationUnit.MilligramPerCubicMeter); } - /// /// Creates a from . /// @@ -958,7 +931,6 @@ public static MassConcentration FromMilligramsPerDeciliter(QuantityValue milligr double value = (double) milligramsperdeciliter; return new MassConcentration(value, MassConcentrationUnit.MilligramPerDeciliter); } - /// /// Creates a from . /// @@ -968,7 +940,6 @@ public static MassConcentration FromMilligramsPerLiter(QuantityValue milligramsp double value = (double) milligramsperliter; return new MassConcentration(value, MassConcentrationUnit.MilligramPerLiter); } - /// /// Creates a from . /// @@ -978,7 +949,6 @@ public static MassConcentration FromMilligramsPerMicroliter(QuantityValue millig double value = (double) milligramspermicroliter; return new MassConcentration(value, MassConcentrationUnit.MilligramPerMicroliter); } - /// /// Creates a from . /// @@ -988,7 +958,6 @@ public static MassConcentration FromMilligramsPerMilliliter(QuantityValue millig double value = (double) milligramspermilliliter; return new MassConcentration(value, MassConcentrationUnit.MilligramPerMilliliter); } - /// /// Creates a from . /// @@ -998,7 +967,6 @@ public static MassConcentration FromNanogramsPerDeciliter(QuantityValue nanogram double value = (double) nanogramsperdeciliter; return new MassConcentration(value, MassConcentrationUnit.NanogramPerDeciliter); } - /// /// Creates a from . /// @@ -1008,7 +976,6 @@ public static MassConcentration FromNanogramsPerLiter(QuantityValue nanogramsper double value = (double) nanogramsperliter; return new MassConcentration(value, MassConcentrationUnit.NanogramPerLiter); } - /// /// Creates a from . /// @@ -1018,7 +985,6 @@ public static MassConcentration FromNanogramsPerMicroliter(QuantityValue nanogra double value = (double) nanogramspermicroliter; return new MassConcentration(value, MassConcentrationUnit.NanogramPerMicroliter); } - /// /// Creates a from . /// @@ -1028,7 +994,6 @@ public static MassConcentration FromNanogramsPerMilliliter(QuantityValue nanogra double value = (double) nanogramspermilliliter; return new MassConcentration(value, MassConcentrationUnit.NanogramPerMilliliter); } - /// /// Creates a from . /// @@ -1038,7 +1003,6 @@ public static MassConcentration FromOuncesPerImperialGallon(QuantityValue ounces double value = (double) ouncesperimperialgallon; return new MassConcentration(value, MassConcentrationUnit.OuncePerImperialGallon); } - /// /// Creates a from . /// @@ -1048,7 +1012,6 @@ public static MassConcentration FromOuncesPerUSGallon(QuantityValue ouncesperusg double value = (double) ouncesperusgallon; return new MassConcentration(value, MassConcentrationUnit.OuncePerUSGallon); } - /// /// Creates a from . /// @@ -1058,7 +1021,6 @@ public static MassConcentration FromPicogramsPerDeciliter(QuantityValue picogram double value = (double) picogramsperdeciliter; return new MassConcentration(value, MassConcentrationUnit.PicogramPerDeciliter); } - /// /// Creates a from . /// @@ -1068,7 +1030,6 @@ public static MassConcentration FromPicogramsPerLiter(QuantityValue picogramsper double value = (double) picogramsperliter; return new MassConcentration(value, MassConcentrationUnit.PicogramPerLiter); } - /// /// Creates a from . /// @@ -1078,7 +1039,6 @@ public static MassConcentration FromPicogramsPerMicroliter(QuantityValue picogra double value = (double) picogramspermicroliter; return new MassConcentration(value, MassConcentrationUnit.PicogramPerMicroliter); } - /// /// Creates a from . /// @@ -1088,7 +1048,6 @@ public static MassConcentration FromPicogramsPerMilliliter(QuantityValue picogra double value = (double) picogramspermilliliter; return new MassConcentration(value, MassConcentrationUnit.PicogramPerMilliliter); } - /// /// Creates a from . /// @@ -1098,7 +1057,6 @@ public static MassConcentration FromPoundsPerCubicFoot(QuantityValue poundspercu double value = (double) poundspercubicfoot; return new MassConcentration(value, MassConcentrationUnit.PoundPerCubicFoot); } - /// /// Creates a from . /// @@ -1108,7 +1066,6 @@ public static MassConcentration FromPoundsPerCubicInch(QuantityValue poundspercu double value = (double) poundspercubicinch; return new MassConcentration(value, MassConcentrationUnit.PoundPerCubicInch); } - /// /// Creates a from . /// @@ -1118,7 +1075,6 @@ public static MassConcentration FromPoundsPerImperialGallon(QuantityValue pounds double value = (double) poundsperimperialgallon; return new MassConcentration(value, MassConcentrationUnit.PoundPerImperialGallon); } - /// /// Creates a from . /// @@ -1128,7 +1084,6 @@ public static MassConcentration FromPoundsPerUSGallon(QuantityValue poundsperusg double value = (double) poundsperusgallon; return new MassConcentration(value, MassConcentrationUnit.PoundPerUSGallon); } - /// /// Creates a from . /// @@ -1138,7 +1093,6 @@ public static MassConcentration FromSlugsPerCubicFoot(QuantityValue slugspercubi double value = (double) slugspercubicfoot; return new MassConcentration(value, MassConcentrationUnit.SlugPerCubicFoot); } - /// /// Creates a from . /// @@ -1148,7 +1102,6 @@ public static MassConcentration FromTonnesPerCubicCentimeter(QuantityValue tonne double value = (double) tonnespercubiccentimeter; return new MassConcentration(value, MassConcentrationUnit.TonnePerCubicCentimeter); } - /// /// Creates a from . /// @@ -1158,7 +1111,6 @@ public static MassConcentration FromTonnesPerCubicMeter(QuantityValue tonnesperc double value = (double) tonnespercubicmeter; return new MassConcentration(value, MassConcentrationUnit.TonnePerCubicMeter); } - /// /// Creates a from . /// @@ -1169,7 +1121,6 @@ public static MassConcentration FromTonnesPerCubicMillimeter(QuantityValue tonne return new MassConcentration(value, MassConcentrationUnit.TonnePerCubicMillimeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs index 781bd3b8cf..4a81314bab 100644 --- a/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs @@ -539,7 +539,6 @@ public static MassFlow FromCentigramsPerDay(QuantityValue centigramsperday) double value = (double) centigramsperday; return new MassFlow(value, MassFlowUnit.CentigramPerDay); } - /// /// Creates a from . /// @@ -549,7 +548,6 @@ public static MassFlow FromCentigramsPerSecond(QuantityValue centigramspersecond double value = (double) centigramspersecond; return new MassFlow(value, MassFlowUnit.CentigramPerSecond); } - /// /// Creates a from . /// @@ -559,7 +557,6 @@ public static MassFlow FromDecagramsPerDay(QuantityValue decagramsperday) double value = (double) decagramsperday; return new MassFlow(value, MassFlowUnit.DecagramPerDay); } - /// /// Creates a from . /// @@ -569,7 +566,6 @@ public static MassFlow FromDecagramsPerSecond(QuantityValue decagramspersecond) double value = (double) decagramspersecond; return new MassFlow(value, MassFlowUnit.DecagramPerSecond); } - /// /// Creates a from . /// @@ -579,7 +575,6 @@ public static MassFlow FromDecigramsPerDay(QuantityValue decigramsperday) double value = (double) decigramsperday; return new MassFlow(value, MassFlowUnit.DecigramPerDay); } - /// /// Creates a from . /// @@ -589,7 +584,6 @@ public static MassFlow FromDecigramsPerSecond(QuantityValue decigramspersecond) double value = (double) decigramspersecond; return new MassFlow(value, MassFlowUnit.DecigramPerSecond); } - /// /// Creates a from . /// @@ -599,7 +593,6 @@ public static MassFlow FromGramsPerDay(QuantityValue gramsperday) double value = (double) gramsperday; return new MassFlow(value, MassFlowUnit.GramPerDay); } - /// /// Creates a from . /// @@ -609,7 +602,6 @@ public static MassFlow FromGramsPerHour(QuantityValue gramsperhour) double value = (double) gramsperhour; return new MassFlow(value, MassFlowUnit.GramPerHour); } - /// /// Creates a from . /// @@ -619,7 +611,6 @@ public static MassFlow FromGramsPerSecond(QuantityValue gramspersecond) double value = (double) gramspersecond; return new MassFlow(value, MassFlowUnit.GramPerSecond); } - /// /// Creates a from . /// @@ -629,7 +620,6 @@ public static MassFlow FromHectogramsPerDay(QuantityValue hectogramsperday) double value = (double) hectogramsperday; return new MassFlow(value, MassFlowUnit.HectogramPerDay); } - /// /// Creates a from . /// @@ -639,7 +629,6 @@ public static MassFlow FromHectogramsPerSecond(QuantityValue hectogramspersecond double value = (double) hectogramspersecond; return new MassFlow(value, MassFlowUnit.HectogramPerSecond); } - /// /// Creates a from . /// @@ -649,7 +638,6 @@ public static MassFlow FromKilogramsPerDay(QuantityValue kilogramsperday) double value = (double) kilogramsperday; return new MassFlow(value, MassFlowUnit.KilogramPerDay); } - /// /// Creates a from . /// @@ -659,7 +647,6 @@ public static MassFlow FromKilogramsPerHour(QuantityValue kilogramsperhour) double value = (double) kilogramsperhour; return new MassFlow(value, MassFlowUnit.KilogramPerHour); } - /// /// Creates a from . /// @@ -669,7 +656,6 @@ public static MassFlow FromKilogramsPerMinute(QuantityValue kilogramsperminute) double value = (double) kilogramsperminute; return new MassFlow(value, MassFlowUnit.KilogramPerMinute); } - /// /// Creates a from . /// @@ -679,7 +665,6 @@ public static MassFlow FromKilogramsPerSecond(QuantityValue kilogramspersecond) double value = (double) kilogramspersecond; return new MassFlow(value, MassFlowUnit.KilogramPerSecond); } - /// /// Creates a from . /// @@ -689,7 +674,6 @@ public static MassFlow FromMegagramsPerDay(QuantityValue megagramsperday) double value = (double) megagramsperday; return new MassFlow(value, MassFlowUnit.MegagramPerDay); } - /// /// Creates a from . /// @@ -699,7 +683,6 @@ public static MassFlow FromMegapoundsPerDay(QuantityValue megapoundsperday) double value = (double) megapoundsperday; return new MassFlow(value, MassFlowUnit.MegapoundPerDay); } - /// /// Creates a from . /// @@ -709,7 +692,6 @@ public static MassFlow FromMegapoundsPerHour(QuantityValue megapoundsperhour) double value = (double) megapoundsperhour; return new MassFlow(value, MassFlowUnit.MegapoundPerHour); } - /// /// Creates a from . /// @@ -719,7 +701,6 @@ public static MassFlow FromMegapoundsPerMinute(QuantityValue megapoundsperminute double value = (double) megapoundsperminute; return new MassFlow(value, MassFlowUnit.MegapoundPerMinute); } - /// /// Creates a from . /// @@ -729,7 +710,6 @@ public static MassFlow FromMegapoundsPerSecond(QuantityValue megapoundspersecond double value = (double) megapoundspersecond; return new MassFlow(value, MassFlowUnit.MegapoundPerSecond); } - /// /// Creates a from . /// @@ -739,7 +719,6 @@ public static MassFlow FromMicrogramsPerDay(QuantityValue microgramsperday) double value = (double) microgramsperday; return new MassFlow(value, MassFlowUnit.MicrogramPerDay); } - /// /// Creates a from . /// @@ -749,7 +728,6 @@ public static MassFlow FromMicrogramsPerSecond(QuantityValue microgramspersecond double value = (double) microgramspersecond; return new MassFlow(value, MassFlowUnit.MicrogramPerSecond); } - /// /// Creates a from . /// @@ -759,7 +737,6 @@ public static MassFlow FromMilligramsPerDay(QuantityValue milligramsperday) double value = (double) milligramsperday; return new MassFlow(value, MassFlowUnit.MilligramPerDay); } - /// /// Creates a from . /// @@ -769,7 +746,6 @@ public static MassFlow FromMilligramsPerSecond(QuantityValue milligramspersecond double value = (double) milligramspersecond; return new MassFlow(value, MassFlowUnit.MilligramPerSecond); } - /// /// Creates a from . /// @@ -779,7 +755,6 @@ public static MassFlow FromNanogramsPerDay(QuantityValue nanogramsperday) double value = (double) nanogramsperday; return new MassFlow(value, MassFlowUnit.NanogramPerDay); } - /// /// Creates a from . /// @@ -789,7 +764,6 @@ public static MassFlow FromNanogramsPerSecond(QuantityValue nanogramspersecond) double value = (double) nanogramspersecond; return new MassFlow(value, MassFlowUnit.NanogramPerSecond); } - /// /// Creates a from . /// @@ -799,7 +773,6 @@ public static MassFlow FromPoundsPerDay(QuantityValue poundsperday) double value = (double) poundsperday; return new MassFlow(value, MassFlowUnit.PoundPerDay); } - /// /// Creates a from . /// @@ -809,7 +782,6 @@ public static MassFlow FromPoundsPerHour(QuantityValue poundsperhour) double value = (double) poundsperhour; return new MassFlow(value, MassFlowUnit.PoundPerHour); } - /// /// Creates a from . /// @@ -819,7 +791,6 @@ public static MassFlow FromPoundsPerMinute(QuantityValue poundsperminute) double value = (double) poundsperminute; return new MassFlow(value, MassFlowUnit.PoundPerMinute); } - /// /// Creates a from . /// @@ -829,7 +800,6 @@ public static MassFlow FromPoundsPerSecond(QuantityValue poundspersecond) double value = (double) poundspersecond; return new MassFlow(value, MassFlowUnit.PoundPerSecond); } - /// /// Creates a from . /// @@ -839,7 +809,6 @@ public static MassFlow FromShortTonsPerHour(QuantityValue shorttonsperhour) double value = (double) shorttonsperhour; return new MassFlow(value, MassFlowUnit.ShortTonPerHour); } - /// /// Creates a from . /// @@ -849,7 +818,6 @@ public static MassFlow FromTonnesPerDay(QuantityValue tonnesperday) double value = (double) tonnesperday; return new MassFlow(value, MassFlowUnit.TonnePerDay); } - /// /// Creates a from . /// @@ -860,7 +828,6 @@ public static MassFlow FromTonnesPerHour(QuantityValue tonnesperhour) return new MassFlow(value, MassFlowUnit.TonnePerHour); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs index 539bd39081..431a2eeed9 100644 --- a/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs @@ -348,7 +348,6 @@ public static MassFlux FromGramsPerHourPerSquareCentimeter(QuantityValue gramspe double value = (double) gramsperhourpersquarecentimeter; return new MassFlux(value, MassFluxUnit.GramPerHourPerSquareCentimeter); } - /// /// Creates a from . /// @@ -358,7 +357,6 @@ public static MassFlux FromGramsPerHourPerSquareMeter(QuantityValue gramsperhour double value = (double) gramsperhourpersquaremeter; return new MassFlux(value, MassFluxUnit.GramPerHourPerSquareMeter); } - /// /// Creates a from . /// @@ -368,7 +366,6 @@ public static MassFlux FromGramsPerHourPerSquareMillimeter(QuantityValue gramspe double value = (double) gramsperhourpersquaremillimeter; return new MassFlux(value, MassFluxUnit.GramPerHourPerSquareMillimeter); } - /// /// Creates a from . /// @@ -378,7 +375,6 @@ public static MassFlux FromGramsPerSecondPerSquareCentimeter(QuantityValue grams double value = (double) gramspersecondpersquarecentimeter; return new MassFlux(value, MassFluxUnit.GramPerSecondPerSquareCentimeter); } - /// /// Creates a from . /// @@ -388,7 +384,6 @@ public static MassFlux FromGramsPerSecondPerSquareMeter(QuantityValue gramsperse double value = (double) gramspersecondpersquaremeter; return new MassFlux(value, MassFluxUnit.GramPerSecondPerSquareMeter); } - /// /// Creates a from . /// @@ -398,7 +393,6 @@ public static MassFlux FromGramsPerSecondPerSquareMillimeter(QuantityValue grams double value = (double) gramspersecondpersquaremillimeter; return new MassFlux(value, MassFluxUnit.GramPerSecondPerSquareMillimeter); } - /// /// Creates a from . /// @@ -408,7 +402,6 @@ public static MassFlux FromKilogramsPerHourPerSquareCentimeter(QuantityValue kil double value = (double) kilogramsperhourpersquarecentimeter; return new MassFlux(value, MassFluxUnit.KilogramPerHourPerSquareCentimeter); } - /// /// Creates a from . /// @@ -418,7 +411,6 @@ public static MassFlux FromKilogramsPerHourPerSquareMeter(QuantityValue kilogram double value = (double) kilogramsperhourpersquaremeter; return new MassFlux(value, MassFluxUnit.KilogramPerHourPerSquareMeter); } - /// /// Creates a from . /// @@ -428,7 +420,6 @@ public static MassFlux FromKilogramsPerHourPerSquareMillimeter(QuantityValue kil double value = (double) kilogramsperhourpersquaremillimeter; return new MassFlux(value, MassFluxUnit.KilogramPerHourPerSquareMillimeter); } - /// /// Creates a from . /// @@ -438,7 +429,6 @@ public static MassFlux FromKilogramsPerSecondPerSquareCentimeter(QuantityValue k double value = (double) kilogramspersecondpersquarecentimeter; return new MassFlux(value, MassFluxUnit.KilogramPerSecondPerSquareCentimeter); } - /// /// Creates a from . /// @@ -448,7 +438,6 @@ public static MassFlux FromKilogramsPerSecondPerSquareMeter(QuantityValue kilogr double value = (double) kilogramspersecondpersquaremeter; return new MassFlux(value, MassFluxUnit.KilogramPerSecondPerSquareMeter); } - /// /// Creates a from . /// @@ -459,7 +448,6 @@ public static MassFlux FromKilogramsPerSecondPerSquareMillimeter(QuantityValue k return new MassFlux(value, MassFluxUnit.KilogramPerSecondPerSquareMillimeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/MassFraction.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFraction.g.cs index 926041cf56..f6c7413cf7 100644 --- a/UnitsNet/GeneratedCode/Quantities/MassFraction.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MassFraction.g.cs @@ -459,7 +459,6 @@ public static MassFraction FromCentigramsPerGram(QuantityValue centigramspergram double value = (double) centigramspergram; return new MassFraction(value, MassFractionUnit.CentigramPerGram); } - /// /// Creates a from . /// @@ -469,7 +468,6 @@ public static MassFraction FromCentigramsPerKilogram(QuantityValue centigramsper double value = (double) centigramsperkilogram; return new MassFraction(value, MassFractionUnit.CentigramPerKilogram); } - /// /// Creates a from . /// @@ -479,7 +477,6 @@ public static MassFraction FromDecagramsPerGram(QuantityValue decagramspergram) double value = (double) decagramspergram; return new MassFraction(value, MassFractionUnit.DecagramPerGram); } - /// /// Creates a from . /// @@ -489,7 +486,6 @@ public static MassFraction FromDecagramsPerKilogram(QuantityValue decagramsperki double value = (double) decagramsperkilogram; return new MassFraction(value, MassFractionUnit.DecagramPerKilogram); } - /// /// Creates a from . /// @@ -499,7 +495,6 @@ public static MassFraction FromDecigramsPerGram(QuantityValue decigramspergram) double value = (double) decigramspergram; return new MassFraction(value, MassFractionUnit.DecigramPerGram); } - /// /// Creates a from . /// @@ -509,7 +504,6 @@ public static MassFraction FromDecigramsPerKilogram(QuantityValue decigramsperki double value = (double) decigramsperkilogram; return new MassFraction(value, MassFractionUnit.DecigramPerKilogram); } - /// /// Creates a from . /// @@ -519,7 +513,6 @@ public static MassFraction FromDecimalFractions(QuantityValue decimalfractions) double value = (double) decimalfractions; return new MassFraction(value, MassFractionUnit.DecimalFraction); } - /// /// Creates a from . /// @@ -529,7 +522,6 @@ public static MassFraction FromGramsPerGram(QuantityValue gramspergram) double value = (double) gramspergram; return new MassFraction(value, MassFractionUnit.GramPerGram); } - /// /// Creates a from . /// @@ -539,7 +531,6 @@ public static MassFraction FromGramsPerKilogram(QuantityValue gramsperkilogram) double value = (double) gramsperkilogram; return new MassFraction(value, MassFractionUnit.GramPerKilogram); } - /// /// Creates a from . /// @@ -549,7 +540,6 @@ public static MassFraction FromHectogramsPerGram(QuantityValue hectogramspergram double value = (double) hectogramspergram; return new MassFraction(value, MassFractionUnit.HectogramPerGram); } - /// /// Creates a from . /// @@ -559,7 +549,6 @@ public static MassFraction FromHectogramsPerKilogram(QuantityValue hectogramsper double value = (double) hectogramsperkilogram; return new MassFraction(value, MassFractionUnit.HectogramPerKilogram); } - /// /// Creates a from . /// @@ -569,7 +558,6 @@ public static MassFraction FromKilogramsPerGram(QuantityValue kilogramspergram) double value = (double) kilogramspergram; return new MassFraction(value, MassFractionUnit.KilogramPerGram); } - /// /// Creates a from . /// @@ -579,7 +567,6 @@ public static MassFraction FromKilogramsPerKilogram(QuantityValue kilogramsperki double value = (double) kilogramsperkilogram; return new MassFraction(value, MassFractionUnit.KilogramPerKilogram); } - /// /// Creates a from . /// @@ -589,7 +576,6 @@ public static MassFraction FromMicrogramsPerGram(QuantityValue microgramspergram double value = (double) microgramspergram; return new MassFraction(value, MassFractionUnit.MicrogramPerGram); } - /// /// Creates a from . /// @@ -599,7 +585,6 @@ public static MassFraction FromMicrogramsPerKilogram(QuantityValue microgramsper double value = (double) microgramsperkilogram; return new MassFraction(value, MassFractionUnit.MicrogramPerKilogram); } - /// /// Creates a from . /// @@ -609,7 +594,6 @@ public static MassFraction FromMilligramsPerGram(QuantityValue milligramspergram double value = (double) milligramspergram; return new MassFraction(value, MassFractionUnit.MilligramPerGram); } - /// /// Creates a from . /// @@ -619,7 +603,6 @@ public static MassFraction FromMilligramsPerKilogram(QuantityValue milligramsper double value = (double) milligramsperkilogram; return new MassFraction(value, MassFractionUnit.MilligramPerKilogram); } - /// /// Creates a from . /// @@ -629,7 +612,6 @@ public static MassFraction FromNanogramsPerGram(QuantityValue nanogramspergram) double value = (double) nanogramspergram; return new MassFraction(value, MassFractionUnit.NanogramPerGram); } - /// /// Creates a from . /// @@ -639,7 +621,6 @@ public static MassFraction FromNanogramsPerKilogram(QuantityValue nanogramsperki double value = (double) nanogramsperkilogram; return new MassFraction(value, MassFractionUnit.NanogramPerKilogram); } - /// /// Creates a from . /// @@ -649,7 +630,6 @@ public static MassFraction FromPartsPerBillion(QuantityValue partsperbillion) double value = (double) partsperbillion; return new MassFraction(value, MassFractionUnit.PartPerBillion); } - /// /// Creates a from . /// @@ -659,7 +639,6 @@ public static MassFraction FromPartsPerMillion(QuantityValue partspermillion) double value = (double) partspermillion; return new MassFraction(value, MassFractionUnit.PartPerMillion); } - /// /// Creates a from . /// @@ -669,7 +648,6 @@ public static MassFraction FromPartsPerThousand(QuantityValue partsperthousand) double value = (double) partsperthousand; return new MassFraction(value, MassFractionUnit.PartPerThousand); } - /// /// Creates a from . /// @@ -679,7 +657,6 @@ public static MassFraction FromPartsPerTrillion(QuantityValue partspertrillion) double value = (double) partspertrillion; return new MassFraction(value, MassFractionUnit.PartPerTrillion); } - /// /// Creates a from . /// @@ -690,7 +667,6 @@ public static MassFraction FromPercent(QuantityValue percent) return new MassFraction(value, MassFractionUnit.Percent); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs b/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs index 9f1f91239d..a0ca3d11e5 100644 --- a/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs @@ -492,7 +492,6 @@ public static MassMomentOfInertia FromGramSquareCentimeters(QuantityValue gramsq double value = (double) gramsquarecentimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareCentimeter); } - /// /// Creates a from . /// @@ -502,7 +501,6 @@ public static MassMomentOfInertia FromGramSquareDecimeters(QuantityValue gramsqu double value = (double) gramsquaredecimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareDecimeter); } - /// /// Creates a from . /// @@ -512,7 +510,6 @@ public static MassMomentOfInertia FromGramSquareMeters(QuantityValue gramsquarem double value = (double) gramsquaremeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareMeter); } - /// /// Creates a from . /// @@ -522,7 +519,6 @@ public static MassMomentOfInertia FromGramSquareMillimeters(QuantityValue gramsq double value = (double) gramsquaremillimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareMillimeter); } - /// /// Creates a from . /// @@ -532,7 +528,6 @@ public static MassMomentOfInertia FromKilogramSquareCentimeters(QuantityValue ki double value = (double) kilogramsquarecentimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareCentimeter); } - /// /// Creates a from . /// @@ -542,7 +537,6 @@ public static MassMomentOfInertia FromKilogramSquareDecimeters(QuantityValue kil double value = (double) kilogramsquaredecimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareDecimeter); } - /// /// Creates a from . /// @@ -552,7 +546,6 @@ public static MassMomentOfInertia FromKilogramSquareMeters(QuantityValue kilogra double value = (double) kilogramsquaremeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareMeter); } - /// /// Creates a from . /// @@ -562,7 +555,6 @@ public static MassMomentOfInertia FromKilogramSquareMillimeters(QuantityValue ki double value = (double) kilogramsquaremillimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareMillimeter); } - /// /// Creates a from . /// @@ -572,7 +564,6 @@ public static MassMomentOfInertia FromKilotonneSquareCentimeters(QuantityValue k double value = (double) kilotonnesquarecentimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareCentimeter); } - /// /// Creates a from . /// @@ -582,7 +573,6 @@ public static MassMomentOfInertia FromKilotonneSquareDecimeters(QuantityValue ki double value = (double) kilotonnesquaredecimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareDecimeter); } - /// /// Creates a from . /// @@ -592,7 +582,6 @@ public static MassMomentOfInertia FromKilotonneSquareMeters(QuantityValue kiloto double value = (double) kilotonnesquaremeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareMeter); } - /// /// Creates a from . /// @@ -602,7 +591,6 @@ public static MassMomentOfInertia FromKilotonneSquareMilimeters(QuantityValue ki double value = (double) kilotonnesquaremilimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareMilimeter); } - /// /// Creates a from . /// @@ -612,7 +600,6 @@ public static MassMomentOfInertia FromMegatonneSquareCentimeters(QuantityValue m double value = (double) megatonnesquarecentimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareCentimeter); } - /// /// Creates a from . /// @@ -622,7 +609,6 @@ public static MassMomentOfInertia FromMegatonneSquareDecimeters(QuantityValue me double value = (double) megatonnesquaredecimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareDecimeter); } - /// /// Creates a from . /// @@ -632,7 +618,6 @@ public static MassMomentOfInertia FromMegatonneSquareMeters(QuantityValue megato double value = (double) megatonnesquaremeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareMeter); } - /// /// Creates a from . /// @@ -642,7 +627,6 @@ public static MassMomentOfInertia FromMegatonneSquareMilimeters(QuantityValue me double value = (double) megatonnesquaremilimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareMilimeter); } - /// /// Creates a from . /// @@ -652,7 +636,6 @@ public static MassMomentOfInertia FromMilligramSquareCentimeters(QuantityValue m double value = (double) milligramsquarecentimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareCentimeter); } - /// /// Creates a from . /// @@ -662,7 +645,6 @@ public static MassMomentOfInertia FromMilligramSquareDecimeters(QuantityValue mi double value = (double) milligramsquaredecimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareDecimeter); } - /// /// Creates a from . /// @@ -672,7 +654,6 @@ public static MassMomentOfInertia FromMilligramSquareMeters(QuantityValue millig double value = (double) milligramsquaremeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareMeter); } - /// /// Creates a from . /// @@ -682,7 +663,6 @@ public static MassMomentOfInertia FromMilligramSquareMillimeters(QuantityValue m double value = (double) milligramsquaremillimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareMillimeter); } - /// /// Creates a from . /// @@ -692,7 +672,6 @@ public static MassMomentOfInertia FromPoundSquareFeet(QuantityValue poundsquaref double value = (double) poundsquarefeet; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.PoundSquareFoot); } - /// /// Creates a from . /// @@ -702,7 +681,6 @@ public static MassMomentOfInertia FromPoundSquareInches(QuantityValue poundsquar double value = (double) poundsquareinches; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.PoundSquareInch); } - /// /// Creates a from . /// @@ -712,7 +690,6 @@ public static MassMomentOfInertia FromSlugSquareFeet(QuantityValue slugsquarefee double value = (double) slugsquarefeet; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.SlugSquareFoot); } - /// /// Creates a from . /// @@ -722,7 +699,6 @@ public static MassMomentOfInertia FromSlugSquareInches(QuantityValue slugsquarei double value = (double) slugsquareinches; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.SlugSquareInch); } - /// /// Creates a from . /// @@ -732,7 +708,6 @@ public static MassMomentOfInertia FromTonneSquareCentimeters(QuantityValue tonne double value = (double) tonnesquarecentimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareCentimeter); } - /// /// Creates a from . /// @@ -742,7 +717,6 @@ public static MassMomentOfInertia FromTonneSquareDecimeters(QuantityValue tonnes double value = (double) tonnesquaredecimeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareDecimeter); } - /// /// Creates a from . /// @@ -752,7 +726,6 @@ public static MassMomentOfInertia FromTonneSquareMeters(QuantityValue tonnesquar double value = (double) tonnesquaremeters; return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareMeter); } - /// /// Creates a from . /// @@ -763,7 +736,6 @@ public static MassMomentOfInertia FromTonneSquareMilimeters(QuantityValue tonnes return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareMilimeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs index 32113e3375..3d21ab527d 100644 --- a/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs @@ -267,7 +267,6 @@ public static MolarEnergy FromJoulesPerMole(QuantityValue joulespermole) double value = (double) joulespermole; return new MolarEnergy(value, MolarEnergyUnit.JoulePerMole); } - /// /// Creates a from . /// @@ -277,7 +276,6 @@ public static MolarEnergy FromKilojoulesPerMole(QuantityValue kilojoulespermole) double value = (double) kilojoulespermole; return new MolarEnergy(value, MolarEnergyUnit.KilojoulePerMole); } - /// /// Creates a from . /// @@ -288,7 +286,6 @@ public static MolarEnergy FromMegajoulesPerMole(QuantityValue megajoulespermole) return new MolarEnergy(value, MolarEnergyUnit.MegajoulePerMole); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs index 50d31ed1a2..16b7132e3b 100644 --- a/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs @@ -267,7 +267,6 @@ public static MolarEntropy FromJoulesPerMoleKelvin(QuantityValue joulespermoleke double value = (double) joulespermolekelvin; return new MolarEntropy(value, MolarEntropyUnit.JoulePerMoleKelvin); } - /// /// Creates a from . /// @@ -277,7 +276,6 @@ public static MolarEntropy FromKilojoulesPerMoleKelvin(QuantityValue kilojoulesp double value = (double) kilojoulespermolekelvin; return new MolarEntropy(value, MolarEntropyUnit.KilojoulePerMoleKelvin); } - /// /// Creates a from . /// @@ -288,7 +286,6 @@ public static MolarEntropy FromMegajoulesPerMoleKelvin(QuantityValue megajoulesp return new MolarEntropy(value, MolarEntropyUnit.MegajoulePerMoleKelvin); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs index 5ada9b0156..34dfcbbf47 100644 --- a/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs @@ -360,7 +360,6 @@ public static MolarMass FromCentigramsPerMole(QuantityValue centigramspermole) double value = (double) centigramspermole; return new MolarMass(value, MolarMassUnit.CentigramPerMole); } - /// /// Creates a from . /// @@ -370,7 +369,6 @@ public static MolarMass FromDecagramsPerMole(QuantityValue decagramspermole) double value = (double) decagramspermole; return new MolarMass(value, MolarMassUnit.DecagramPerMole); } - /// /// Creates a from . /// @@ -380,7 +378,6 @@ public static MolarMass FromDecigramsPerMole(QuantityValue decigramspermole) double value = (double) decigramspermole; return new MolarMass(value, MolarMassUnit.DecigramPerMole); } - /// /// Creates a from . /// @@ -390,7 +387,6 @@ public static MolarMass FromGramsPerMole(QuantityValue gramspermole) double value = (double) gramspermole; return new MolarMass(value, MolarMassUnit.GramPerMole); } - /// /// Creates a from . /// @@ -400,7 +396,6 @@ public static MolarMass FromHectogramsPerMole(QuantityValue hectogramspermole) double value = (double) hectogramspermole; return new MolarMass(value, MolarMassUnit.HectogramPerMole); } - /// /// Creates a from . /// @@ -410,7 +405,6 @@ public static MolarMass FromKilogramsPerMole(QuantityValue kilogramspermole) double value = (double) kilogramspermole; return new MolarMass(value, MolarMassUnit.KilogramPerMole); } - /// /// Creates a from . /// @@ -420,7 +414,6 @@ public static MolarMass FromKilopoundsPerMole(QuantityValue kilopoundspermole) double value = (double) kilopoundspermole; return new MolarMass(value, MolarMassUnit.KilopoundPerMole); } - /// /// Creates a from . /// @@ -430,7 +423,6 @@ public static MolarMass FromMegapoundsPerMole(QuantityValue megapoundspermole) double value = (double) megapoundspermole; return new MolarMass(value, MolarMassUnit.MegapoundPerMole); } - /// /// Creates a from . /// @@ -440,7 +432,6 @@ public static MolarMass FromMicrogramsPerMole(QuantityValue microgramspermole) double value = (double) microgramspermole; return new MolarMass(value, MolarMassUnit.MicrogramPerMole); } - /// /// Creates a from . /// @@ -450,7 +441,6 @@ public static MolarMass FromMilligramsPerMole(QuantityValue milligramspermole) double value = (double) milligramspermole; return new MolarMass(value, MolarMassUnit.MilligramPerMole); } - /// /// Creates a from . /// @@ -460,7 +450,6 @@ public static MolarMass FromNanogramsPerMole(QuantityValue nanogramspermole) double value = (double) nanogramspermole; return new MolarMass(value, MolarMassUnit.NanogramPerMole); } - /// /// Creates a from . /// @@ -471,7 +460,6 @@ public static MolarMass FromPoundsPerMole(QuantityValue poundspermole) return new MolarMass(value, MolarMassUnit.PoundPerMole); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs b/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs index ef3a8b045d..22da711e21 100644 --- a/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs @@ -347,7 +347,6 @@ public static Molarity FromCentimolesPerLiter(QuantityValue centimolesperliter) double value = (double) centimolesperliter; return new Molarity(value, MolarityUnit.CentimolePerLiter); } - /// /// Creates a from . /// @@ -357,7 +356,6 @@ public static Molarity FromDecimolesPerLiter(QuantityValue decimolesperliter) double value = (double) decimolesperliter; return new Molarity(value, MolarityUnit.DecimolePerLiter); } - /// /// Creates a from . /// @@ -367,7 +365,6 @@ public static Molarity FromMicromolesPerLiter(QuantityValue micromolesperliter) double value = (double) micromolesperliter; return new Molarity(value, MolarityUnit.MicromolePerLiter); } - /// /// Creates a from . /// @@ -377,7 +374,6 @@ public static Molarity FromMillimolesPerLiter(QuantityValue millimolesperliter) double value = (double) millimolesperliter; return new Molarity(value, MolarityUnit.MillimolePerLiter); } - /// /// Creates a from . /// @@ -387,7 +383,6 @@ public static Molarity FromMolesPerCubicMeter(QuantityValue molespercubicmeter) double value = (double) molespercubicmeter; return new Molarity(value, MolarityUnit.MolePerCubicMeter); } - /// /// Creates a from . /// @@ -397,7 +392,6 @@ public static Molarity FromMolesPerLiter(QuantityValue molesperliter) double value = (double) molesperliter; return new Molarity(value, MolarityUnit.MolePerLiter); } - /// /// Creates a from . /// @@ -407,7 +401,6 @@ public static Molarity FromNanomolesPerLiter(QuantityValue nanomolesperliter) double value = (double) nanomolesperliter; return new Molarity(value, MolarityUnit.NanomolePerLiter); } - /// /// Creates a from . /// @@ -418,7 +411,6 @@ public static Molarity FromPicomolesPerLiter(QuantityValue picomolesperliter) return new Molarity(value, MolarityUnit.PicomolePerLiter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs b/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs index 78b2c69b8c..feef41146d 100644 --- a/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs @@ -253,7 +253,6 @@ public static Permeability FromHenriesPerMeter(QuantityValue henriespermeter) return new Permeability(value, PermeabilityUnit.HenryPerMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs b/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs index 3e03776636..3ee516fe2e 100644 --- a/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs @@ -253,7 +253,6 @@ public static Permittivity FromFaradsPerMeter(QuantityValue faradspermeter) return new Permittivity(value, PermittivityUnit.FaradPerMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Power.g.cs b/UnitsNet/GeneratedCode/Quantities/Power.g.cs index 09e844503f..eee2e56bef 100644 --- a/UnitsNet/GeneratedCode/Quantities/Power.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Power.g.cs @@ -470,7 +470,6 @@ public static Power FromBoilerHorsepower(QuantityValue boilerhorsepower) decimal value = (decimal) boilerhorsepower; return new Power(value, PowerUnit.BoilerHorsepower); } - /// /// Creates a from . /// @@ -480,7 +479,6 @@ public static Power FromBritishThermalUnitsPerHour(QuantityValue britishthermalu decimal value = (decimal) britishthermalunitsperhour; return new Power(value, PowerUnit.BritishThermalUnitPerHour); } - /// /// Creates a from . /// @@ -490,7 +488,6 @@ public static Power FromDecawatts(QuantityValue decawatts) decimal value = (decimal) decawatts; return new Power(value, PowerUnit.Decawatt); } - /// /// Creates a from . /// @@ -500,7 +497,6 @@ public static Power FromDeciwatts(QuantityValue deciwatts) decimal value = (decimal) deciwatts; return new Power(value, PowerUnit.Deciwatt); } - /// /// Creates a from . /// @@ -510,7 +506,6 @@ public static Power FromElectricalHorsepower(QuantityValue electricalhorsepower) decimal value = (decimal) electricalhorsepower; return new Power(value, PowerUnit.ElectricalHorsepower); } - /// /// Creates a from . /// @@ -520,7 +515,6 @@ public static Power FromFemtowatts(QuantityValue femtowatts) decimal value = (decimal) femtowatts; return new Power(value, PowerUnit.Femtowatt); } - /// /// Creates a from . /// @@ -530,7 +524,6 @@ public static Power FromGigajoulesPerHour(QuantityValue gigajoulesperhour) decimal value = (decimal) gigajoulesperhour; return new Power(value, PowerUnit.GigajoulePerHour); } - /// /// Creates a from . /// @@ -540,7 +533,6 @@ public static Power FromGigawatts(QuantityValue gigawatts) decimal value = (decimal) gigawatts; return new Power(value, PowerUnit.Gigawatt); } - /// /// Creates a from . /// @@ -550,7 +542,6 @@ public static Power FromHydraulicHorsepower(QuantityValue hydraulichorsepower) decimal value = (decimal) hydraulichorsepower; return new Power(value, PowerUnit.HydraulicHorsepower); } - /// /// Creates a from . /// @@ -560,7 +551,6 @@ public static Power FromJoulesPerHour(QuantityValue joulesperhour) decimal value = (decimal) joulesperhour; return new Power(value, PowerUnit.JoulePerHour); } - /// /// Creates a from . /// @@ -570,7 +560,6 @@ public static Power FromKilobritishThermalUnitsPerHour(QuantityValue kilobritish decimal value = (decimal) kilobritishthermalunitsperhour; return new Power(value, PowerUnit.KilobritishThermalUnitPerHour); } - /// /// Creates a from . /// @@ -580,7 +569,6 @@ public static Power FromKilojoulesPerHour(QuantityValue kilojoulesperhour) decimal value = (decimal) kilojoulesperhour; return new Power(value, PowerUnit.KilojoulePerHour); } - /// /// Creates a from . /// @@ -590,7 +578,6 @@ public static Power FromKilowatts(QuantityValue kilowatts) decimal value = (decimal) kilowatts; return new Power(value, PowerUnit.Kilowatt); } - /// /// Creates a from . /// @@ -600,7 +587,6 @@ public static Power FromMechanicalHorsepower(QuantityValue mechanicalhorsepower) decimal value = (decimal) mechanicalhorsepower; return new Power(value, PowerUnit.MechanicalHorsepower); } - /// /// Creates a from . /// @@ -610,7 +596,6 @@ public static Power FromMegajoulesPerHour(QuantityValue megajoulesperhour) decimal value = (decimal) megajoulesperhour; return new Power(value, PowerUnit.MegajoulePerHour); } - /// /// Creates a from . /// @@ -620,7 +605,6 @@ public static Power FromMegawatts(QuantityValue megawatts) decimal value = (decimal) megawatts; return new Power(value, PowerUnit.Megawatt); } - /// /// Creates a from . /// @@ -630,7 +614,6 @@ public static Power FromMetricHorsepower(QuantityValue metrichorsepower) decimal value = (decimal) metrichorsepower; return new Power(value, PowerUnit.MetricHorsepower); } - /// /// Creates a from . /// @@ -640,7 +623,6 @@ public static Power FromMicrowatts(QuantityValue microwatts) decimal value = (decimal) microwatts; return new Power(value, PowerUnit.Microwatt); } - /// /// Creates a from . /// @@ -650,7 +632,6 @@ public static Power FromMillijoulesPerHour(QuantityValue millijoulesperhour) decimal value = (decimal) millijoulesperhour; return new Power(value, PowerUnit.MillijoulePerHour); } - /// /// Creates a from . /// @@ -660,7 +641,6 @@ public static Power FromMilliwatts(QuantityValue milliwatts) decimal value = (decimal) milliwatts; return new Power(value, PowerUnit.Milliwatt); } - /// /// Creates a from . /// @@ -670,7 +650,6 @@ public static Power FromNanowatts(QuantityValue nanowatts) decimal value = (decimal) nanowatts; return new Power(value, PowerUnit.Nanowatt); } - /// /// Creates a from . /// @@ -680,7 +659,6 @@ public static Power FromPetawatts(QuantityValue petawatts) decimal value = (decimal) petawatts; return new Power(value, PowerUnit.Petawatt); } - /// /// Creates a from . /// @@ -690,7 +668,6 @@ public static Power FromPicowatts(QuantityValue picowatts) decimal value = (decimal) picowatts; return new Power(value, PowerUnit.Picowatt); } - /// /// Creates a from . /// @@ -700,7 +677,6 @@ public static Power FromTerawatts(QuantityValue terawatts) decimal value = (decimal) terawatts; return new Power(value, PowerUnit.Terawatt); } - /// /// Creates a from . /// @@ -711,7 +687,6 @@ public static Power FromWatts(QuantityValue watts) return new Power(value, PowerUnit.Watt); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs index 1bf2a0a418..1f6958ea15 100644 --- a/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs @@ -636,7 +636,6 @@ public static PowerDensity FromDecawattsPerCubicFoot(QuantityValue decawattsperc double value = (double) decawattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.DecawattPerCubicFoot); } - /// /// Creates a from . /// @@ -646,7 +645,6 @@ public static PowerDensity FromDecawattsPerCubicInch(QuantityValue decawattsperc double value = (double) decawattspercubicinch; return new PowerDensity(value, PowerDensityUnit.DecawattPerCubicInch); } - /// /// Creates a from . /// @@ -656,7 +654,6 @@ public static PowerDensity FromDecawattsPerCubicMeter(QuantityValue decawattsper double value = (double) decawattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.DecawattPerCubicMeter); } - /// /// Creates a from . /// @@ -666,7 +663,6 @@ public static PowerDensity FromDecawattsPerLiter(QuantityValue decawattsperliter double value = (double) decawattsperliter; return new PowerDensity(value, PowerDensityUnit.DecawattPerLiter); } - /// /// Creates a from . /// @@ -676,7 +672,6 @@ public static PowerDensity FromDeciwattsPerCubicFoot(QuantityValue deciwattsperc double value = (double) deciwattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.DeciwattPerCubicFoot); } - /// /// Creates a from . /// @@ -686,7 +681,6 @@ public static PowerDensity FromDeciwattsPerCubicInch(QuantityValue deciwattsperc double value = (double) deciwattspercubicinch; return new PowerDensity(value, PowerDensityUnit.DeciwattPerCubicInch); } - /// /// Creates a from . /// @@ -696,7 +690,6 @@ public static PowerDensity FromDeciwattsPerCubicMeter(QuantityValue deciwattsper double value = (double) deciwattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.DeciwattPerCubicMeter); } - /// /// Creates a from . /// @@ -706,7 +699,6 @@ public static PowerDensity FromDeciwattsPerLiter(QuantityValue deciwattsperliter double value = (double) deciwattsperliter; return new PowerDensity(value, PowerDensityUnit.DeciwattPerLiter); } - /// /// Creates a from . /// @@ -716,7 +708,6 @@ public static PowerDensity FromGigawattsPerCubicFoot(QuantityValue gigawattsperc double value = (double) gigawattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.GigawattPerCubicFoot); } - /// /// Creates a from . /// @@ -726,7 +717,6 @@ public static PowerDensity FromGigawattsPerCubicInch(QuantityValue gigawattsperc double value = (double) gigawattspercubicinch; return new PowerDensity(value, PowerDensityUnit.GigawattPerCubicInch); } - /// /// Creates a from . /// @@ -736,7 +726,6 @@ public static PowerDensity FromGigawattsPerCubicMeter(QuantityValue gigawattsper double value = (double) gigawattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.GigawattPerCubicMeter); } - /// /// Creates a from . /// @@ -746,7 +735,6 @@ public static PowerDensity FromGigawattsPerLiter(QuantityValue gigawattsperliter double value = (double) gigawattsperliter; return new PowerDensity(value, PowerDensityUnit.GigawattPerLiter); } - /// /// Creates a from . /// @@ -756,7 +744,6 @@ public static PowerDensity FromKilowattsPerCubicFoot(QuantityValue kilowattsperc double value = (double) kilowattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.KilowattPerCubicFoot); } - /// /// Creates a from . /// @@ -766,7 +753,6 @@ public static PowerDensity FromKilowattsPerCubicInch(QuantityValue kilowattsperc double value = (double) kilowattspercubicinch; return new PowerDensity(value, PowerDensityUnit.KilowattPerCubicInch); } - /// /// Creates a from . /// @@ -776,7 +762,6 @@ public static PowerDensity FromKilowattsPerCubicMeter(QuantityValue kilowattsper double value = (double) kilowattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.KilowattPerCubicMeter); } - /// /// Creates a from . /// @@ -786,7 +771,6 @@ public static PowerDensity FromKilowattsPerLiter(QuantityValue kilowattsperliter double value = (double) kilowattsperliter; return new PowerDensity(value, PowerDensityUnit.KilowattPerLiter); } - /// /// Creates a from . /// @@ -796,7 +780,6 @@ public static PowerDensity FromMegawattsPerCubicFoot(QuantityValue megawattsperc double value = (double) megawattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.MegawattPerCubicFoot); } - /// /// Creates a from . /// @@ -806,7 +789,6 @@ public static PowerDensity FromMegawattsPerCubicInch(QuantityValue megawattsperc double value = (double) megawattspercubicinch; return new PowerDensity(value, PowerDensityUnit.MegawattPerCubicInch); } - /// /// Creates a from . /// @@ -816,7 +798,6 @@ public static PowerDensity FromMegawattsPerCubicMeter(QuantityValue megawattsper double value = (double) megawattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.MegawattPerCubicMeter); } - /// /// Creates a from . /// @@ -826,7 +807,6 @@ public static PowerDensity FromMegawattsPerLiter(QuantityValue megawattsperliter double value = (double) megawattsperliter; return new PowerDensity(value, PowerDensityUnit.MegawattPerLiter); } - /// /// Creates a from . /// @@ -836,7 +816,6 @@ public static PowerDensity FromMicrowattsPerCubicFoot(QuantityValue microwattspe double value = (double) microwattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.MicrowattPerCubicFoot); } - /// /// Creates a from . /// @@ -846,7 +825,6 @@ public static PowerDensity FromMicrowattsPerCubicInch(QuantityValue microwattspe double value = (double) microwattspercubicinch; return new PowerDensity(value, PowerDensityUnit.MicrowattPerCubicInch); } - /// /// Creates a from . /// @@ -856,7 +834,6 @@ public static PowerDensity FromMicrowattsPerCubicMeter(QuantityValue microwattsp double value = (double) microwattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.MicrowattPerCubicMeter); } - /// /// Creates a from . /// @@ -866,7 +843,6 @@ public static PowerDensity FromMicrowattsPerLiter(QuantityValue microwattsperlit double value = (double) microwattsperliter; return new PowerDensity(value, PowerDensityUnit.MicrowattPerLiter); } - /// /// Creates a from . /// @@ -876,7 +852,6 @@ public static PowerDensity FromMilliwattsPerCubicFoot(QuantityValue milliwattspe double value = (double) milliwattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.MilliwattPerCubicFoot); } - /// /// Creates a from . /// @@ -886,7 +861,6 @@ public static PowerDensity FromMilliwattsPerCubicInch(QuantityValue milliwattspe double value = (double) milliwattspercubicinch; return new PowerDensity(value, PowerDensityUnit.MilliwattPerCubicInch); } - /// /// Creates a from . /// @@ -896,7 +870,6 @@ public static PowerDensity FromMilliwattsPerCubicMeter(QuantityValue milliwattsp double value = (double) milliwattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.MilliwattPerCubicMeter); } - /// /// Creates a from . /// @@ -906,7 +879,6 @@ public static PowerDensity FromMilliwattsPerLiter(QuantityValue milliwattsperlit double value = (double) milliwattsperliter; return new PowerDensity(value, PowerDensityUnit.MilliwattPerLiter); } - /// /// Creates a from . /// @@ -916,7 +888,6 @@ public static PowerDensity FromNanowattsPerCubicFoot(QuantityValue nanowattsperc double value = (double) nanowattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.NanowattPerCubicFoot); } - /// /// Creates a from . /// @@ -926,7 +897,6 @@ public static PowerDensity FromNanowattsPerCubicInch(QuantityValue nanowattsperc double value = (double) nanowattspercubicinch; return new PowerDensity(value, PowerDensityUnit.NanowattPerCubicInch); } - /// /// Creates a from . /// @@ -936,7 +906,6 @@ public static PowerDensity FromNanowattsPerCubicMeter(QuantityValue nanowattsper double value = (double) nanowattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.NanowattPerCubicMeter); } - /// /// Creates a from . /// @@ -946,7 +915,6 @@ public static PowerDensity FromNanowattsPerLiter(QuantityValue nanowattsperliter double value = (double) nanowattsperliter; return new PowerDensity(value, PowerDensityUnit.NanowattPerLiter); } - /// /// Creates a from . /// @@ -956,7 +924,6 @@ public static PowerDensity FromPicowattsPerCubicFoot(QuantityValue picowattsperc double value = (double) picowattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.PicowattPerCubicFoot); } - /// /// Creates a from . /// @@ -966,7 +933,6 @@ public static PowerDensity FromPicowattsPerCubicInch(QuantityValue picowattsperc double value = (double) picowattspercubicinch; return new PowerDensity(value, PowerDensityUnit.PicowattPerCubicInch); } - /// /// Creates a from . /// @@ -976,7 +942,6 @@ public static PowerDensity FromPicowattsPerCubicMeter(QuantityValue picowattsper double value = (double) picowattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.PicowattPerCubicMeter); } - /// /// Creates a from . /// @@ -986,7 +951,6 @@ public static PowerDensity FromPicowattsPerLiter(QuantityValue picowattsperliter double value = (double) picowattsperliter; return new PowerDensity(value, PowerDensityUnit.PicowattPerLiter); } - /// /// Creates a from . /// @@ -996,7 +960,6 @@ public static PowerDensity FromTerawattsPerCubicFoot(QuantityValue terawattsperc double value = (double) terawattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.TerawattPerCubicFoot); } - /// /// Creates a from . /// @@ -1006,7 +969,6 @@ public static PowerDensity FromTerawattsPerCubicInch(QuantityValue terawattsperc double value = (double) terawattspercubicinch; return new PowerDensity(value, PowerDensityUnit.TerawattPerCubicInch); } - /// /// Creates a from . /// @@ -1016,7 +978,6 @@ public static PowerDensity FromTerawattsPerCubicMeter(QuantityValue terawattsper double value = (double) terawattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.TerawattPerCubicMeter); } - /// /// Creates a from . /// @@ -1026,7 +987,6 @@ public static PowerDensity FromTerawattsPerLiter(QuantityValue terawattsperliter double value = (double) terawattsperliter; return new PowerDensity(value, PowerDensityUnit.TerawattPerLiter); } - /// /// Creates a from . /// @@ -1036,7 +996,6 @@ public static PowerDensity FromWattsPerCubicFoot(QuantityValue wattspercubicfoot double value = (double) wattspercubicfoot; return new PowerDensity(value, PowerDensityUnit.WattPerCubicFoot); } - /// /// Creates a from . /// @@ -1046,7 +1005,6 @@ public static PowerDensity FromWattsPerCubicInch(QuantityValue wattspercubicinch double value = (double) wattspercubicinch; return new PowerDensity(value, PowerDensityUnit.WattPerCubicInch); } - /// /// Creates a from . /// @@ -1056,7 +1014,6 @@ public static PowerDensity FromWattsPerCubicMeter(QuantityValue wattspercubicmet double value = (double) wattspercubicmeter; return new PowerDensity(value, PowerDensityUnit.WattPerCubicMeter); } - /// /// Creates a from . /// @@ -1067,7 +1024,6 @@ public static PowerDensity FromWattsPerLiter(QuantityValue wattsperliter) return new PowerDensity(value, PowerDensityUnit.WattPerLiter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/PowerRatio.g.cs b/UnitsNet/GeneratedCode/Quantities/PowerRatio.g.cs index 0977574ce8..0080f91299 100644 --- a/UnitsNet/GeneratedCode/Quantities/PowerRatio.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/PowerRatio.g.cs @@ -258,7 +258,6 @@ public static PowerRatio FromDecibelMilliwatts(QuantityValue decibelmilliwatts) double value = (double) decibelmilliwatts; return new PowerRatio(value, PowerRatioUnit.DecibelMilliwatt); } - /// /// Creates a from . /// @@ -269,7 +268,6 @@ public static PowerRatio FromDecibelWatts(QuantityValue decibelwatts) return new PowerRatio(value, PowerRatioUnit.DecibelWatt); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs b/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs index 41189d7294..f1ea9b9383 100644 --- a/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs @@ -676,7 +676,6 @@ public static Pressure FromAtmospheres(QuantityValue atmospheres) double value = (double) atmospheres; return new Pressure(value, PressureUnit.Atmosphere); } - /// /// Creates a from . /// @@ -686,7 +685,6 @@ public static Pressure FromBars(QuantityValue bars) double value = (double) bars; return new Pressure(value, PressureUnit.Bar); } - /// /// Creates a from . /// @@ -696,7 +694,6 @@ public static Pressure FromCentibars(QuantityValue centibars) double value = (double) centibars; return new Pressure(value, PressureUnit.Centibar); } - /// /// Creates a from . /// @@ -706,7 +703,6 @@ public static Pressure FromDecapascals(QuantityValue decapascals) double value = (double) decapascals; return new Pressure(value, PressureUnit.Decapascal); } - /// /// Creates a from . /// @@ -716,7 +712,6 @@ public static Pressure FromDecibars(QuantityValue decibars) double value = (double) decibars; return new Pressure(value, PressureUnit.Decibar); } - /// /// Creates a from . /// @@ -726,7 +721,6 @@ public static Pressure FromDynesPerSquareCentimeter(QuantityValue dynespersquare double value = (double) dynespersquarecentimeter; return new Pressure(value, PressureUnit.DynePerSquareCentimeter); } - /// /// Creates a from . /// @@ -736,7 +730,6 @@ public static Pressure FromFeetOfElevation(QuantityValue feetofelevation) double value = (double) feetofelevation; return new Pressure(value, PressureUnit.FootOfElevation); } - /// /// Creates a from . /// @@ -746,7 +739,6 @@ public static Pressure FromFeetOfHead(QuantityValue feetofhead) double value = (double) feetofhead; return new Pressure(value, PressureUnit.FootOfHead); } - /// /// Creates a from . /// @@ -756,7 +748,6 @@ public static Pressure FromGigapascals(QuantityValue gigapascals) double value = (double) gigapascals; return new Pressure(value, PressureUnit.Gigapascal); } - /// /// Creates a from . /// @@ -766,7 +757,6 @@ public static Pressure FromHectopascals(QuantityValue hectopascals) double value = (double) hectopascals; return new Pressure(value, PressureUnit.Hectopascal); } - /// /// Creates a from . /// @@ -776,7 +766,6 @@ public static Pressure FromInchesOfMercury(QuantityValue inchesofmercury) double value = (double) inchesofmercury; return new Pressure(value, PressureUnit.InchOfMercury); } - /// /// Creates a from . /// @@ -786,7 +775,6 @@ public static Pressure FromInchesOfWaterColumn(QuantityValue inchesofwatercolumn double value = (double) inchesofwatercolumn; return new Pressure(value, PressureUnit.InchOfWaterColumn); } - /// /// Creates a from . /// @@ -796,7 +784,6 @@ public static Pressure FromKilobars(QuantityValue kilobars) double value = (double) kilobars; return new Pressure(value, PressureUnit.Kilobar); } - /// /// Creates a from . /// @@ -806,7 +793,6 @@ public static Pressure FromKilogramsForcePerSquareCentimeter(QuantityValue kilog double value = (double) kilogramsforcepersquarecentimeter; return new Pressure(value, PressureUnit.KilogramForcePerSquareCentimeter); } - /// /// Creates a from . /// @@ -816,7 +802,6 @@ public static Pressure FromKilogramsForcePerSquareMeter(QuantityValue kilogramsf double value = (double) kilogramsforcepersquaremeter; return new Pressure(value, PressureUnit.KilogramForcePerSquareMeter); } - /// /// Creates a from . /// @@ -826,7 +811,6 @@ public static Pressure FromKilogramsForcePerSquareMillimeter(QuantityValue kilog double value = (double) kilogramsforcepersquaremillimeter; return new Pressure(value, PressureUnit.KilogramForcePerSquareMillimeter); } - /// /// Creates a from . /// @@ -836,7 +820,6 @@ public static Pressure FromKilonewtonsPerSquareCentimeter(QuantityValue kilonewt double value = (double) kilonewtonspersquarecentimeter; return new Pressure(value, PressureUnit.KilonewtonPerSquareCentimeter); } - /// /// Creates a from . /// @@ -846,7 +829,6 @@ public static Pressure FromKilonewtonsPerSquareMeter(QuantityValue kilonewtonspe double value = (double) kilonewtonspersquaremeter; return new Pressure(value, PressureUnit.KilonewtonPerSquareMeter); } - /// /// Creates a from . /// @@ -856,7 +838,6 @@ public static Pressure FromKilonewtonsPerSquareMillimeter(QuantityValue kilonewt double value = (double) kilonewtonspersquaremillimeter; return new Pressure(value, PressureUnit.KilonewtonPerSquareMillimeter); } - /// /// Creates a from . /// @@ -866,7 +847,6 @@ public static Pressure FromKilopascals(QuantityValue kilopascals) double value = (double) kilopascals; return new Pressure(value, PressureUnit.Kilopascal); } - /// /// Creates a from . /// @@ -876,7 +856,6 @@ public static Pressure FromKilopoundsForcePerSquareFoot(QuantityValue kilopounds double value = (double) kilopoundsforcepersquarefoot; return new Pressure(value, PressureUnit.KilopoundForcePerSquareFoot); } - /// /// Creates a from . /// @@ -886,7 +865,6 @@ public static Pressure FromKilopoundsForcePerSquareInch(QuantityValue kilopounds double value = (double) kilopoundsforcepersquareinch; return new Pressure(value, PressureUnit.KilopoundForcePerSquareInch); } - /// /// Creates a from . /// @@ -896,7 +874,6 @@ public static Pressure FromMegabars(QuantityValue megabars) double value = (double) megabars; return new Pressure(value, PressureUnit.Megabar); } - /// /// Creates a from . /// @@ -906,7 +883,6 @@ public static Pressure FromMeganewtonsPerSquareMeter(QuantityValue meganewtonspe double value = (double) meganewtonspersquaremeter; return new Pressure(value, PressureUnit.MeganewtonPerSquareMeter); } - /// /// Creates a from . /// @@ -916,7 +892,6 @@ public static Pressure FromMegapascals(QuantityValue megapascals) double value = (double) megapascals; return new Pressure(value, PressureUnit.Megapascal); } - /// /// Creates a from . /// @@ -926,7 +901,6 @@ public static Pressure FromMetersOfElevation(QuantityValue metersofelevation) double value = (double) metersofelevation; return new Pressure(value, PressureUnit.MeterOfElevation); } - /// /// Creates a from . /// @@ -936,7 +910,6 @@ public static Pressure FromMetersOfHead(QuantityValue metersofhead) double value = (double) metersofhead; return new Pressure(value, PressureUnit.MeterOfHead); } - /// /// Creates a from . /// @@ -946,7 +919,6 @@ public static Pressure FromMicrobars(QuantityValue microbars) double value = (double) microbars; return new Pressure(value, PressureUnit.Microbar); } - /// /// Creates a from . /// @@ -956,7 +928,6 @@ public static Pressure FromMicropascals(QuantityValue micropascals) double value = (double) micropascals; return new Pressure(value, PressureUnit.Micropascal); } - /// /// Creates a from . /// @@ -966,7 +937,6 @@ public static Pressure FromMillibars(QuantityValue millibars) double value = (double) millibars; return new Pressure(value, PressureUnit.Millibar); } - /// /// Creates a from . /// @@ -976,7 +946,6 @@ public static Pressure FromMillimetersOfMercury(QuantityValue millimetersofmercu double value = (double) millimetersofmercury; return new Pressure(value, PressureUnit.MillimeterOfMercury); } - /// /// Creates a from . /// @@ -986,7 +955,6 @@ public static Pressure FromMillimeterOfWaterColumn(QuantityValue millimeterofwat double value = (double) millimeterofwatercolumn; return new Pressure(value, PressureUnit.MillimeterOfWaterColumn); } - /// /// Creates a from . /// @@ -996,7 +964,6 @@ public static Pressure FromMillipascals(QuantityValue millipascals) double value = (double) millipascals; return new Pressure(value, PressureUnit.Millipascal); } - /// /// Creates a from . /// @@ -1006,7 +973,6 @@ public static Pressure FromNewtonsPerSquareCentimeter(QuantityValue newtonspersq double value = (double) newtonspersquarecentimeter; return new Pressure(value, PressureUnit.NewtonPerSquareCentimeter); } - /// /// Creates a from . /// @@ -1016,7 +982,6 @@ public static Pressure FromNewtonsPerSquareMeter(QuantityValue newtonspersquarem double value = (double) newtonspersquaremeter; return new Pressure(value, PressureUnit.NewtonPerSquareMeter); } - /// /// Creates a from . /// @@ -1026,7 +991,6 @@ public static Pressure FromNewtonsPerSquareMillimeter(QuantityValue newtonspersq double value = (double) newtonspersquaremillimeter; return new Pressure(value, PressureUnit.NewtonPerSquareMillimeter); } - /// /// Creates a from . /// @@ -1036,7 +1000,6 @@ public static Pressure FromPascals(QuantityValue pascals) double value = (double) pascals; return new Pressure(value, PressureUnit.Pascal); } - /// /// Creates a from . /// @@ -1046,7 +1009,6 @@ public static Pressure FromPoundsForcePerSquareFoot(QuantityValue poundsforceper double value = (double) poundsforcepersquarefoot; return new Pressure(value, PressureUnit.PoundForcePerSquareFoot); } - /// /// Creates a from . /// @@ -1056,7 +1018,6 @@ public static Pressure FromPoundsForcePerSquareInch(QuantityValue poundsforceper double value = (double) poundsforcepersquareinch; return new Pressure(value, PressureUnit.PoundForcePerSquareInch); } - /// /// Creates a from . /// @@ -1066,7 +1027,6 @@ public static Pressure FromPoundsPerInchSecondSquared(QuantityValue poundsperinc double value = (double) poundsperinchsecondsquared; return new Pressure(value, PressureUnit.PoundPerInchSecondSquared); } - /// /// Creates a from . /// @@ -1076,7 +1036,6 @@ public static Pressure FromTechnicalAtmospheres(QuantityValue technicalatmospher double value = (double) technicalatmospheres; return new Pressure(value, PressureUnit.TechnicalAtmosphere); } - /// /// Creates a from . /// @@ -1086,7 +1045,6 @@ public static Pressure FromTonnesForcePerSquareCentimeter(QuantityValue tonnesfo double value = (double) tonnesforcepersquarecentimeter; return new Pressure(value, PressureUnit.TonneForcePerSquareCentimeter); } - /// /// Creates a from . /// @@ -1096,7 +1054,6 @@ public static Pressure FromTonnesForcePerSquareMeter(QuantityValue tonnesforcepe double value = (double) tonnesforcepersquaremeter; return new Pressure(value, PressureUnit.TonneForcePerSquareMeter); } - /// /// Creates a from . /// @@ -1106,7 +1063,6 @@ public static Pressure FromTonnesForcePerSquareMillimeter(QuantityValue tonnesfo double value = (double) tonnesforcepersquaremillimeter; return new Pressure(value, PressureUnit.TonneForcePerSquareMillimeter); } - /// /// Creates a from . /// @@ -1117,7 +1073,6 @@ public static Pressure FromTorrs(QuantityValue torrs) return new Pressure(value, PressureUnit.Torr); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs index 77e7e09dec..fed0407915 100644 --- a/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs @@ -380,7 +380,6 @@ public static PressureChangeRate FromAtmospheresPerSecond(QuantityValue atmosphe double value = (double) atmospherespersecond; return new PressureChangeRate(value, PressureChangeRateUnit.AtmospherePerSecond); } - /// /// Creates a from . /// @@ -390,7 +389,6 @@ public static PressureChangeRate FromKilopascalsPerMinute(QuantityValue kilopasc double value = (double) kilopascalsperminute; return new PressureChangeRate(value, PressureChangeRateUnit.KilopascalPerMinute); } - /// /// Creates a from . /// @@ -400,7 +398,6 @@ public static PressureChangeRate FromKilopascalsPerSecond(QuantityValue kilopasc double value = (double) kilopascalspersecond; return new PressureChangeRate(value, PressureChangeRateUnit.KilopascalPerSecond); } - /// /// Creates a from . /// @@ -410,7 +407,6 @@ public static PressureChangeRate FromKilopoundsForcePerSquareInchPerMinute(Quant double value = (double) kilopoundsforcepersquareinchperminute; return new PressureChangeRate(value, PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute); } - /// /// Creates a from . /// @@ -420,7 +416,6 @@ public static PressureChangeRate FromKilopoundsForcePerSquareInchPerSecond(Quant double value = (double) kilopoundsforcepersquareinchpersecond; return new PressureChangeRate(value, PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond); } - /// /// Creates a from . /// @@ -430,7 +425,6 @@ public static PressureChangeRate FromMegapascalsPerMinute(QuantityValue megapasc double value = (double) megapascalsperminute; return new PressureChangeRate(value, PressureChangeRateUnit.MegapascalPerMinute); } - /// /// Creates a from . /// @@ -440,7 +434,6 @@ public static PressureChangeRate FromMegapascalsPerSecond(QuantityValue megapasc double value = (double) megapascalspersecond; return new PressureChangeRate(value, PressureChangeRateUnit.MegapascalPerSecond); } - /// /// Creates a from . /// @@ -450,7 +443,6 @@ public static PressureChangeRate FromMegapoundsForcePerSquareInchPerMinute(Quant double value = (double) megapoundsforcepersquareinchperminute; return new PressureChangeRate(value, PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute); } - /// /// Creates a from . /// @@ -460,7 +452,6 @@ public static PressureChangeRate FromMegapoundsForcePerSquareInchPerSecond(Quant double value = (double) megapoundsforcepersquareinchpersecond; return new PressureChangeRate(value, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond); } - /// /// Creates a from . /// @@ -470,7 +461,6 @@ public static PressureChangeRate FromMillimetersOfMercuryPerSecond(QuantityValue double value = (double) millimetersofmercurypersecond; return new PressureChangeRate(value, PressureChangeRateUnit.MillimeterOfMercuryPerSecond); } - /// /// Creates a from . /// @@ -480,7 +470,6 @@ public static PressureChangeRate FromPascalsPerMinute(QuantityValue pascalspermi double value = (double) pascalsperminute; return new PressureChangeRate(value, PressureChangeRateUnit.PascalPerMinute); } - /// /// Creates a from . /// @@ -490,7 +479,6 @@ public static PressureChangeRate FromPascalsPerSecond(QuantityValue pascalsperse double value = (double) pascalspersecond; return new PressureChangeRate(value, PressureChangeRateUnit.PascalPerSecond); } - /// /// Creates a from . /// @@ -500,7 +488,6 @@ public static PressureChangeRate FromPoundsForcePerSquareInchPerMinute(QuantityV double value = (double) poundsforcepersquareinchperminute; return new PressureChangeRate(value, PressureChangeRateUnit.PoundForcePerSquareInchPerMinute); } - /// /// Creates a from . /// @@ -511,7 +498,6 @@ public static PressureChangeRate FromPoundsForcePerSquareInchPerSecond(QuantityV return new PressureChangeRate(value, PressureChangeRateUnit.PoundForcePerSquareInchPerSecond); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs b/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs index d07266f2f0..a127d06926 100644 --- a/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs @@ -294,7 +294,6 @@ public static Ratio FromDecimalFractions(QuantityValue decimalfractions) double value = (double) decimalfractions; return new Ratio(value, RatioUnit.DecimalFraction); } - /// /// Creates a from . /// @@ -304,7 +303,6 @@ public static Ratio FromPartsPerBillion(QuantityValue partsperbillion) double value = (double) partsperbillion; return new Ratio(value, RatioUnit.PartPerBillion); } - /// /// Creates a from . /// @@ -314,7 +312,6 @@ public static Ratio FromPartsPerMillion(QuantityValue partspermillion) double value = (double) partspermillion; return new Ratio(value, RatioUnit.PartPerMillion); } - /// /// Creates a from . /// @@ -324,7 +321,6 @@ public static Ratio FromPartsPerThousand(QuantityValue partsperthousand) double value = (double) partsperthousand; return new Ratio(value, RatioUnit.PartPerThousand); } - /// /// Creates a from . /// @@ -334,7 +330,6 @@ public static Ratio FromPartsPerTrillion(QuantityValue partspertrillion) double value = (double) partspertrillion; return new Ratio(value, RatioUnit.PartPerTrillion); } - /// /// Creates a from . /// @@ -345,7 +340,6 @@ public static Ratio FromPercent(QuantityValue percent) return new Ratio(value, RatioUnit.Percent); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/RatioChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/RatioChangeRate.g.cs index 0d8731a672..e9a355f4fc 100644 --- a/UnitsNet/GeneratedCode/Quantities/RatioChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/RatioChangeRate.g.cs @@ -258,7 +258,6 @@ public static RatioChangeRate FromDecimalFractionsPerSecond(QuantityValue decima double value = (double) decimalfractionspersecond; return new RatioChangeRate(value, RatioChangeRateUnit.DecimalFractionPerSecond); } - /// /// Creates a from . /// @@ -269,7 +268,6 @@ public static RatioChangeRate FromPercentsPerSecond(QuantityValue percentspersec return new RatioChangeRate(value, RatioChangeRateUnit.PercentPerSecond); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.g.cs index 75628b109f..b6a14d7ec9 100644 --- a/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.g.cs @@ -267,7 +267,6 @@ public static ReactiveEnergy FromKilovoltampereReactiveHours(QuantityValue kilov double value = (double) kilovoltamperereactivehours; return new ReactiveEnergy(value, ReactiveEnergyUnit.KilovoltampereReactiveHour); } - /// /// Creates a from . /// @@ -277,7 +276,6 @@ public static ReactiveEnergy FromMegavoltampereReactiveHours(QuantityValue megav double value = (double) megavoltamperereactivehours; return new ReactiveEnergy(value, ReactiveEnergyUnit.MegavoltampereReactiveHour); } - /// /// Creates a from . /// @@ -288,7 +286,6 @@ public static ReactiveEnergy FromVoltampereReactiveHours(QuantityValue voltamper return new ReactiveEnergy(value, ReactiveEnergyUnit.VoltampereReactiveHour); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ReactivePower.g.cs b/UnitsNet/GeneratedCode/Quantities/ReactivePower.g.cs index aec83abde4..669439bbbd 100644 --- a/UnitsNet/GeneratedCode/Quantities/ReactivePower.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ReactivePower.g.cs @@ -276,7 +276,6 @@ public static ReactivePower FromGigavoltamperesReactive(QuantityValue gigavoltam double value = (double) gigavoltamperesreactive; return new ReactivePower(value, ReactivePowerUnit.GigavoltampereReactive); } - /// /// Creates a from . /// @@ -286,7 +285,6 @@ public static ReactivePower FromKilovoltamperesReactive(QuantityValue kilovoltam double value = (double) kilovoltamperesreactive; return new ReactivePower(value, ReactivePowerUnit.KilovoltampereReactive); } - /// /// Creates a from . /// @@ -296,7 +294,6 @@ public static ReactivePower FromMegavoltamperesReactive(QuantityValue megavoltam double value = (double) megavoltamperesreactive; return new ReactivePower(value, ReactivePowerUnit.MegavoltampereReactive); } - /// /// Creates a from . /// @@ -307,7 +304,6 @@ public static ReactivePower FromVoltamperesReactive(QuantityValue voltamperesrea return new ReactivePower(value, ReactivePowerUnit.VoltampereReactive); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs b/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs index 96c50d8d40..bfd4d269d1 100644 --- a/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs @@ -342,7 +342,6 @@ public static ReciprocalArea FromInverseSquareCentimeters(QuantityValue inverses double value = (double) inversesquarecentimeters; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareCentimeter); } - /// /// Creates a from . /// @@ -352,7 +351,6 @@ public static ReciprocalArea FromInverseSquareDecimeters(QuantityValue inversesq double value = (double) inversesquaredecimeters; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareDecimeter); } - /// /// Creates a from . /// @@ -362,7 +360,6 @@ public static ReciprocalArea FromInverseSquareFeet(QuantityValue inversesquarefe double value = (double) inversesquarefeet; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareFoot); } - /// /// Creates a from . /// @@ -372,7 +369,6 @@ public static ReciprocalArea FromInverseSquareInches(QuantityValue inversesquare double value = (double) inversesquareinches; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareInch); } - /// /// Creates a from . /// @@ -382,7 +378,6 @@ public static ReciprocalArea FromInverseSquareKilometers(QuantityValue inversesq double value = (double) inversesquarekilometers; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareKilometer); } - /// /// Creates a from . /// @@ -392,7 +387,6 @@ public static ReciprocalArea FromInverseSquareMeters(QuantityValue inversesquare double value = (double) inversesquaremeters; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMeter); } - /// /// Creates a from . /// @@ -402,7 +396,6 @@ public static ReciprocalArea FromInverseSquareMicrometers(QuantityValue inverses double value = (double) inversesquaremicrometers; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMicrometer); } - /// /// Creates a from . /// @@ -412,7 +405,6 @@ public static ReciprocalArea FromInverseSquareMiles(QuantityValue inversesquarem double value = (double) inversesquaremiles; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMile); } - /// /// Creates a from . /// @@ -422,7 +414,6 @@ public static ReciprocalArea FromInverseSquareMillimeters(QuantityValue inverses double value = (double) inversesquaremillimeters; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMillimeter); } - /// /// Creates a from . /// @@ -432,7 +423,6 @@ public static ReciprocalArea FromInverseSquareYards(QuantityValue inversesquarey double value = (double) inversesquareyards; return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareYard); } - /// /// Creates a from . /// @@ -443,7 +433,6 @@ public static ReciprocalArea FromInverseUsSurveySquareFeet(QuantityValue inverse return new ReciprocalArea(value, ReciprocalAreaUnit.InverseUsSurveySquareFoot); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs b/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs index 5d2e3105a2..337de3f6af 100644 --- a/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs @@ -333,7 +333,6 @@ public static ReciprocalLength FromInverseCentimeters(QuantityValue inversecenti double value = (double) inversecentimeters; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseCentimeter); } - /// /// Creates a from . /// @@ -343,7 +342,6 @@ public static ReciprocalLength FromInverseFeet(QuantityValue inversefeet) double value = (double) inversefeet; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseFoot); } - /// /// Creates a from . /// @@ -353,7 +351,6 @@ public static ReciprocalLength FromInverseInches(QuantityValue inverseinches) double value = (double) inverseinches; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseInch); } - /// /// Creates a from . /// @@ -363,7 +360,6 @@ public static ReciprocalLength FromInverseMeters(QuantityValue inversemeters) double value = (double) inversemeters; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMeter); } - /// /// Creates a from . /// @@ -373,7 +369,6 @@ public static ReciprocalLength FromInverseMicroinches(QuantityValue inversemicro double value = (double) inversemicroinches; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMicroinch); } - /// /// Creates a from . /// @@ -383,7 +378,6 @@ public static ReciprocalLength FromInverseMils(QuantityValue inversemils) double value = (double) inversemils; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMil); } - /// /// Creates a from . /// @@ -393,7 +387,6 @@ public static ReciprocalLength FromInverseMiles(QuantityValue inversemiles) double value = (double) inversemiles; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMile); } - /// /// Creates a from . /// @@ -403,7 +396,6 @@ public static ReciprocalLength FromInverseMillimeters(QuantityValue inversemilli double value = (double) inversemillimeters; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMillimeter); } - /// /// Creates a from . /// @@ -413,7 +405,6 @@ public static ReciprocalLength FromInverseUsSurveyFeet(QuantityValue inverseussu double value = (double) inverseussurveyfeet; return new ReciprocalLength(value, ReciprocalLengthUnit.InverseUsSurveyFoot); } - /// /// Creates a from . /// @@ -424,7 +415,6 @@ public static ReciprocalLength FromInverseYards(QuantityValue inverseyards) return new ReciprocalLength(value, ReciprocalLengthUnit.InverseYard); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/RelativeHumidity.g.cs b/UnitsNet/GeneratedCode/Quantities/RelativeHumidity.g.cs index f57fcabbb3..0a07148beb 100644 --- a/UnitsNet/GeneratedCode/Quantities/RelativeHumidity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/RelativeHumidity.g.cs @@ -250,7 +250,6 @@ public static RelativeHumidity FromPercent(QuantityValue percent) return new RelativeHumidity(value, RelativeHumidityUnit.Percent); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs index c669e7b146..f77e5b2a24 100644 --- a/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs @@ -276,7 +276,6 @@ public static RotationalAcceleration FromDegreesPerSecondSquared(QuantityValue d double value = (double) degreespersecondsquared; return new RotationalAcceleration(value, RotationalAccelerationUnit.DegreePerSecondSquared); } - /// /// Creates a from . /// @@ -286,7 +285,6 @@ public static RotationalAcceleration FromRadiansPerSecondSquared(QuantityValue r double value = (double) radianspersecondsquared; return new RotationalAcceleration(value, RotationalAccelerationUnit.RadianPerSecondSquared); } - /// /// Creates a from . /// @@ -296,7 +294,6 @@ public static RotationalAcceleration FromRevolutionsPerMinutePerSecond(QuantityV double value = (double) revolutionsperminutepersecond; return new RotationalAcceleration(value, RotationalAccelerationUnit.RevolutionPerMinutePerSecond); } - /// /// Creates a from . /// @@ -307,7 +304,6 @@ public static RotationalAcceleration FromRevolutionsPerSecondSquared(QuantityVal return new RotationalAcceleration(value, RotationalAccelerationUnit.RevolutionPerSecondSquared); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs index 8832c6a527..527a442545 100644 --- a/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs @@ -369,7 +369,6 @@ public static RotationalSpeed FromCentiradiansPerSecond(QuantityValue centiradia double value = (double) centiradianspersecond; return new RotationalSpeed(value, RotationalSpeedUnit.CentiradianPerSecond); } - /// /// Creates a from . /// @@ -379,7 +378,6 @@ public static RotationalSpeed FromDeciradiansPerSecond(QuantityValue deciradians double value = (double) deciradianspersecond; return new RotationalSpeed(value, RotationalSpeedUnit.DeciradianPerSecond); } - /// /// Creates a from . /// @@ -389,7 +387,6 @@ public static RotationalSpeed FromDegreesPerMinute(QuantityValue degreesperminut double value = (double) degreesperminute; return new RotationalSpeed(value, RotationalSpeedUnit.DegreePerMinute); } - /// /// Creates a from . /// @@ -399,7 +396,6 @@ public static RotationalSpeed FromDegreesPerSecond(QuantityValue degreespersecon double value = (double) degreespersecond; return new RotationalSpeed(value, RotationalSpeedUnit.DegreePerSecond); } - /// /// Creates a from . /// @@ -409,7 +405,6 @@ public static RotationalSpeed FromMicrodegreesPerSecond(QuantityValue microdegre double value = (double) microdegreespersecond; return new RotationalSpeed(value, RotationalSpeedUnit.MicrodegreePerSecond); } - /// /// Creates a from . /// @@ -419,7 +414,6 @@ public static RotationalSpeed FromMicroradiansPerSecond(QuantityValue microradia double value = (double) microradianspersecond; return new RotationalSpeed(value, RotationalSpeedUnit.MicroradianPerSecond); } - /// /// Creates a from . /// @@ -429,7 +423,6 @@ public static RotationalSpeed FromMillidegreesPerSecond(QuantityValue millidegre double value = (double) millidegreespersecond; return new RotationalSpeed(value, RotationalSpeedUnit.MillidegreePerSecond); } - /// /// Creates a from . /// @@ -439,7 +432,6 @@ public static RotationalSpeed FromMilliradiansPerSecond(QuantityValue milliradia double value = (double) milliradianspersecond; return new RotationalSpeed(value, RotationalSpeedUnit.MilliradianPerSecond); } - /// /// Creates a from . /// @@ -449,7 +441,6 @@ public static RotationalSpeed FromNanodegreesPerSecond(QuantityValue nanodegrees double value = (double) nanodegreespersecond; return new RotationalSpeed(value, RotationalSpeedUnit.NanodegreePerSecond); } - /// /// Creates a from . /// @@ -459,7 +450,6 @@ public static RotationalSpeed FromNanoradiansPerSecond(QuantityValue nanoradians double value = (double) nanoradianspersecond; return new RotationalSpeed(value, RotationalSpeedUnit.NanoradianPerSecond); } - /// /// Creates a from . /// @@ -469,7 +459,6 @@ public static RotationalSpeed FromRadiansPerSecond(QuantityValue radianspersecon double value = (double) radianspersecond; return new RotationalSpeed(value, RotationalSpeedUnit.RadianPerSecond); } - /// /// Creates a from . /// @@ -479,7 +468,6 @@ public static RotationalSpeed FromRevolutionsPerMinute(QuantityValue revolutions double value = (double) revolutionsperminute; return new RotationalSpeed(value, RotationalSpeedUnit.RevolutionPerMinute); } - /// /// Creates a from . /// @@ -490,7 +478,6 @@ public static RotationalSpeed FromRevolutionsPerSecond(QuantityValue revolutions return new RotationalSpeed(value, RotationalSpeedUnit.RevolutionPerSecond); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs index 19337b091d..73bf8be2fb 100644 --- a/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs @@ -537,7 +537,6 @@ public static RotationalStiffness FromCentinewtonMetersPerDegree(QuantityValue c double value = (double) centinewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.CentinewtonMeterPerDegree); } - /// /// Creates a from . /// @@ -547,7 +546,6 @@ public static RotationalStiffness FromCentinewtonMillimetersPerDegree(QuantityVa double value = (double) centinewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.CentinewtonMillimeterPerDegree); } - /// /// Creates a from . /// @@ -557,7 +555,6 @@ public static RotationalStiffness FromCentinewtonMillimetersPerRadian(QuantityVa double value = (double) centinewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.CentinewtonMillimeterPerRadian); } - /// /// Creates a from . /// @@ -567,7 +564,6 @@ public static RotationalStiffness FromDecanewtonMetersPerDegree(QuantityValue de double value = (double) decanewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.DecanewtonMeterPerDegree); } - /// /// Creates a from . /// @@ -577,7 +573,6 @@ public static RotationalStiffness FromDecanewtonMillimetersPerDegree(QuantityVal double value = (double) decanewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.DecanewtonMillimeterPerDegree); } - /// /// Creates a from . /// @@ -587,7 +582,6 @@ public static RotationalStiffness FromDecanewtonMillimetersPerRadian(QuantityVal double value = (double) decanewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.DecanewtonMillimeterPerRadian); } - /// /// Creates a from . /// @@ -597,7 +591,6 @@ public static RotationalStiffness FromDecinewtonMetersPerDegree(QuantityValue de double value = (double) decinewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.DecinewtonMeterPerDegree); } - /// /// Creates a from . /// @@ -607,7 +600,6 @@ public static RotationalStiffness FromDecinewtonMillimetersPerDegree(QuantityVal double value = (double) decinewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.DecinewtonMillimeterPerDegree); } - /// /// Creates a from . /// @@ -617,7 +609,6 @@ public static RotationalStiffness FromDecinewtonMillimetersPerRadian(QuantityVal double value = (double) decinewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.DecinewtonMillimeterPerRadian); } - /// /// Creates a from . /// @@ -627,7 +618,6 @@ public static RotationalStiffness FromKilonewtonMetersPerDegree(QuantityValue ki double value = (double) kilonewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMeterPerDegree); } - /// /// Creates a from . /// @@ -637,7 +627,6 @@ public static RotationalStiffness FromKilonewtonMetersPerRadian(QuantityValue ki double value = (double) kilonewtonmetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMeterPerRadian); } - /// /// Creates a from . /// @@ -647,7 +636,6 @@ public static RotationalStiffness FromKilonewtonMillimetersPerDegree(QuantityVal double value = (double) kilonewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMillimeterPerDegree); } - /// /// Creates a from . /// @@ -657,7 +645,6 @@ public static RotationalStiffness FromKilonewtonMillimetersPerRadian(QuantityVal double value = (double) kilonewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMillimeterPerRadian); } - /// /// Creates a from . /// @@ -667,7 +654,6 @@ public static RotationalStiffness FromKilopoundForceFeetPerDegrees(QuantityValue double value = (double) kilopoundforcefeetperdegrees; return new RotationalStiffness(value, RotationalStiffnessUnit.KilopoundForceFootPerDegrees); } - /// /// Creates a from . /// @@ -677,7 +663,6 @@ public static RotationalStiffness FromMeganewtonMetersPerDegree(QuantityValue me double value = (double) meganewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMeterPerDegree); } - /// /// Creates a from . /// @@ -687,7 +672,6 @@ public static RotationalStiffness FromMeganewtonMetersPerRadian(QuantityValue me double value = (double) meganewtonmetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMeterPerRadian); } - /// /// Creates a from . /// @@ -697,7 +681,6 @@ public static RotationalStiffness FromMeganewtonMillimetersPerDegree(QuantityVal double value = (double) meganewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMillimeterPerDegree); } - /// /// Creates a from . /// @@ -707,7 +690,6 @@ public static RotationalStiffness FromMeganewtonMillimetersPerRadian(QuantityVal double value = (double) meganewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMillimeterPerRadian); } - /// /// Creates a from . /// @@ -717,7 +699,6 @@ public static RotationalStiffness FromMicronewtonMetersPerDegree(QuantityValue m double value = (double) micronewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.MicronewtonMeterPerDegree); } - /// /// Creates a from . /// @@ -727,7 +708,6 @@ public static RotationalStiffness FromMicronewtonMillimetersPerDegree(QuantityVa double value = (double) micronewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.MicronewtonMillimeterPerDegree); } - /// /// Creates a from . /// @@ -737,7 +717,6 @@ public static RotationalStiffness FromMicronewtonMillimetersPerRadian(QuantityVa double value = (double) micronewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.MicronewtonMillimeterPerRadian); } - /// /// Creates a from . /// @@ -747,7 +726,6 @@ public static RotationalStiffness FromMillinewtonMetersPerDegree(QuantityValue m double value = (double) millinewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.MillinewtonMeterPerDegree); } - /// /// Creates a from . /// @@ -757,7 +735,6 @@ public static RotationalStiffness FromMillinewtonMillimetersPerDegree(QuantityVa double value = (double) millinewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.MillinewtonMillimeterPerDegree); } - /// /// Creates a from . /// @@ -767,7 +744,6 @@ public static RotationalStiffness FromMillinewtonMillimetersPerRadian(QuantityVa double value = (double) millinewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.MillinewtonMillimeterPerRadian); } - /// /// Creates a from . /// @@ -777,7 +753,6 @@ public static RotationalStiffness FromNanonewtonMetersPerDegree(QuantityValue na double value = (double) nanonewtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.NanonewtonMeterPerDegree); } - /// /// Creates a from . /// @@ -787,7 +762,6 @@ public static RotationalStiffness FromNanonewtonMillimetersPerDegree(QuantityVal double value = (double) nanonewtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.NanonewtonMillimeterPerDegree); } - /// /// Creates a from . /// @@ -797,7 +771,6 @@ public static RotationalStiffness FromNanonewtonMillimetersPerRadian(QuantityVal double value = (double) nanonewtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.NanonewtonMillimeterPerRadian); } - /// /// Creates a from . /// @@ -807,7 +780,6 @@ public static RotationalStiffness FromNewtonMetersPerDegree(QuantityValue newton double value = (double) newtonmetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMeterPerDegree); } - /// /// Creates a from . /// @@ -817,7 +789,6 @@ public static RotationalStiffness FromNewtonMetersPerRadian(QuantityValue newton double value = (double) newtonmetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMeterPerRadian); } - /// /// Creates a from . /// @@ -827,7 +798,6 @@ public static RotationalStiffness FromNewtonMillimetersPerDegree(QuantityValue n double value = (double) newtonmillimetersperdegree; return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMillimeterPerDegree); } - /// /// Creates a from . /// @@ -837,7 +807,6 @@ public static RotationalStiffness FromNewtonMillimetersPerRadian(QuantityValue n double value = (double) newtonmillimetersperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMillimeterPerRadian); } - /// /// Creates a from . /// @@ -847,7 +816,6 @@ public static RotationalStiffness FromPoundForceFeetPerRadian(QuantityValue poun double value = (double) poundforcefeetperradian; return new RotationalStiffness(value, RotationalStiffnessUnit.PoundForceFeetPerRadian); } - /// /// Creates a from . /// @@ -858,7 +826,6 @@ public static RotationalStiffness FromPoundForceFeetPerDegrees(QuantityValue pou return new RotationalStiffness(value, RotationalStiffnessUnit.PoundForceFootPerDegrees); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs index 24dfd83bb4..230bb1b067 100644 --- a/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs @@ -285,7 +285,6 @@ public static RotationalStiffnessPerLength FromKilonewtonMetersPerRadianPerMeter double value = (double) kilonewtonmetersperradianpermeter; return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter); } - /// /// Creates a from . /// @@ -295,7 +294,6 @@ public static RotationalStiffnessPerLength FromKilopoundForceFeetPerDegreesPerFe double value = (double) kilopoundforcefeetperdegreesperfeet; return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot); } - /// /// Creates a from . /// @@ -305,7 +303,6 @@ public static RotationalStiffnessPerLength FromMeganewtonMetersPerRadianPerMeter double value = (double) meganewtonmetersperradianpermeter; return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter); } - /// /// Creates a from . /// @@ -315,7 +312,6 @@ public static RotationalStiffnessPerLength FromNewtonMetersPerRadianPerMeter(Qua double value = (double) newtonmetersperradianpermeter; return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter); } - /// /// Creates a from . /// @@ -326,7 +322,6 @@ public static RotationalStiffnessPerLength FromPoundForceFeetPerDegreesPerFeet(Q return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Scalar.g.cs b/UnitsNet/GeneratedCode/Quantities/Scalar.g.cs index db37c8508b..44edb659f9 100644 --- a/UnitsNet/GeneratedCode/Quantities/Scalar.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Scalar.g.cs @@ -250,7 +250,6 @@ public static Scalar FromAmount(QuantityValue amount) return new Scalar(value, ScalarUnit.Amount); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/SolidAngle.g.cs b/UnitsNet/GeneratedCode/Quantities/SolidAngle.g.cs index b5f7bbdbd1..6d5d002521 100644 --- a/UnitsNet/GeneratedCode/Quantities/SolidAngle.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/SolidAngle.g.cs @@ -253,7 +253,6 @@ public static SolidAngle FromSteradians(QuantityValue steradians) return new SolidAngle(value, SolidAngleUnit.Steradian); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs index 4a0f7d1321..7d2c789231 100644 --- a/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs @@ -468,7 +468,6 @@ public static SpecificEnergy FromBtuPerPound(QuantityValue btuperpound) double value = (double) btuperpound; return new SpecificEnergy(value, SpecificEnergyUnit.BtuPerPound); } - /// /// Creates a from . /// @@ -478,7 +477,6 @@ public static SpecificEnergy FromCaloriesPerGram(QuantityValue caloriespergram) double value = (double) caloriespergram; return new SpecificEnergy(value, SpecificEnergyUnit.CaloriePerGram); } - /// /// Creates a from . /// @@ -488,7 +486,6 @@ public static SpecificEnergy FromGigawattDaysPerKilogram(QuantityValue gigawattd double value = (double) gigawattdaysperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.GigawattDayPerKilogram); } - /// /// Creates a from . /// @@ -498,7 +495,6 @@ public static SpecificEnergy FromGigawattDaysPerShortTon(QuantityValue gigawattd double value = (double) gigawattdayspershortton; return new SpecificEnergy(value, SpecificEnergyUnit.GigawattDayPerShortTon); } - /// /// Creates a from . /// @@ -508,7 +504,6 @@ public static SpecificEnergy FromGigawattDaysPerTonne(QuantityValue gigawattdays double value = (double) gigawattdayspertonne; return new SpecificEnergy(value, SpecificEnergyUnit.GigawattDayPerTonne); } - /// /// Creates a from . /// @@ -518,7 +513,6 @@ public static SpecificEnergy FromGigawattHoursPerKilogram(QuantityValue gigawatt double value = (double) gigawatthoursperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.GigawattHourPerKilogram); } - /// /// Creates a from . /// @@ -528,7 +522,6 @@ public static SpecificEnergy FromJoulesPerKilogram(QuantityValue joulesperkilogr double value = (double) joulesperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.JoulePerKilogram); } - /// /// Creates a from . /// @@ -538,7 +531,6 @@ public static SpecificEnergy FromKilocaloriesPerGram(QuantityValue kilocaloriesp double value = (double) kilocaloriespergram; return new SpecificEnergy(value, SpecificEnergyUnit.KilocaloriePerGram); } - /// /// Creates a from . /// @@ -548,7 +540,6 @@ public static SpecificEnergy FromKilojoulesPerKilogram(QuantityValue kilojoulesp double value = (double) kilojoulesperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.KilojoulePerKilogram); } - /// /// Creates a from . /// @@ -558,7 +549,6 @@ public static SpecificEnergy FromKilowattDaysPerKilogram(QuantityValue kilowattd double value = (double) kilowattdaysperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.KilowattDayPerKilogram); } - /// /// Creates a from . /// @@ -568,7 +558,6 @@ public static SpecificEnergy FromKilowattDaysPerShortTon(QuantityValue kilowattd double value = (double) kilowattdayspershortton; return new SpecificEnergy(value, SpecificEnergyUnit.KilowattDayPerShortTon); } - /// /// Creates a from . /// @@ -578,7 +567,6 @@ public static SpecificEnergy FromKilowattDaysPerTonne(QuantityValue kilowattdays double value = (double) kilowattdayspertonne; return new SpecificEnergy(value, SpecificEnergyUnit.KilowattDayPerTonne); } - /// /// Creates a from . /// @@ -588,7 +576,6 @@ public static SpecificEnergy FromKilowattHoursPerKilogram(QuantityValue kilowatt double value = (double) kilowatthoursperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.KilowattHourPerKilogram); } - /// /// Creates a from . /// @@ -598,7 +585,6 @@ public static SpecificEnergy FromMegajoulesPerKilogram(QuantityValue megajoulesp double value = (double) megajoulesperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.MegajoulePerKilogram); } - /// /// Creates a from . /// @@ -608,7 +594,6 @@ public static SpecificEnergy FromMegawattDaysPerKilogram(QuantityValue megawattd double value = (double) megawattdaysperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.MegawattDayPerKilogram); } - /// /// Creates a from . /// @@ -618,7 +603,6 @@ public static SpecificEnergy FromMegawattDaysPerShortTon(QuantityValue megawattd double value = (double) megawattdayspershortton; return new SpecificEnergy(value, SpecificEnergyUnit.MegawattDayPerShortTon); } - /// /// Creates a from . /// @@ -628,7 +612,6 @@ public static SpecificEnergy FromMegawattDaysPerTonne(QuantityValue megawattdays double value = (double) megawattdayspertonne; return new SpecificEnergy(value, SpecificEnergyUnit.MegawattDayPerTonne); } - /// /// Creates a from . /// @@ -638,7 +621,6 @@ public static SpecificEnergy FromMegawattHoursPerKilogram(QuantityValue megawatt double value = (double) megawatthoursperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.MegawattHourPerKilogram); } - /// /// Creates a from . /// @@ -648,7 +630,6 @@ public static SpecificEnergy FromTerawattDaysPerKilogram(QuantityValue terawattd double value = (double) terawattdaysperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.TerawattDayPerKilogram); } - /// /// Creates a from . /// @@ -658,7 +639,6 @@ public static SpecificEnergy FromTerawattDaysPerShortTon(QuantityValue terawattd double value = (double) terawattdayspershortton; return new SpecificEnergy(value, SpecificEnergyUnit.TerawattDayPerShortTon); } - /// /// Creates a from . /// @@ -668,7 +648,6 @@ public static SpecificEnergy FromTerawattDaysPerTonne(QuantityValue terawattdays double value = (double) terawattdayspertonne; return new SpecificEnergy(value, SpecificEnergyUnit.TerawattDayPerTonne); } - /// /// Creates a from . /// @@ -678,7 +657,6 @@ public static SpecificEnergy FromWattDaysPerKilogram(QuantityValue wattdaysperki double value = (double) wattdaysperkilogram; return new SpecificEnergy(value, SpecificEnergyUnit.WattDayPerKilogram); } - /// /// Creates a from . /// @@ -688,7 +666,6 @@ public static SpecificEnergy FromWattDaysPerShortTon(QuantityValue wattdayspersh double value = (double) wattdayspershortton; return new SpecificEnergy(value, SpecificEnergyUnit.WattDayPerShortTon); } - /// /// Creates a from . /// @@ -698,7 +675,6 @@ public static SpecificEnergy FromWattDaysPerTonne(QuantityValue wattdayspertonne double value = (double) wattdayspertonne; return new SpecificEnergy(value, SpecificEnergyUnit.WattDayPerTonne); } - /// /// Creates a from . /// @@ -709,7 +685,6 @@ public static SpecificEnergy FromWattHoursPerKilogram(QuantityValue watthoursper return new SpecificEnergy(value, SpecificEnergyUnit.WattHourPerKilogram); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs index 7709632644..883b0d3d0e 100644 --- a/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs @@ -321,7 +321,6 @@ public static SpecificEntropy FromBtusPerPoundFahrenheit(QuantityValue btusperpo double value = (double) btusperpoundfahrenheit; return new SpecificEntropy(value, SpecificEntropyUnit.BtuPerPoundFahrenheit); } - /// /// Creates a from . /// @@ -331,7 +330,6 @@ public static SpecificEntropy FromCaloriesPerGramKelvin(QuantityValue caloriespe double value = (double) caloriespergramkelvin; return new SpecificEntropy(value, SpecificEntropyUnit.CaloriePerGramKelvin); } - /// /// Creates a from . /// @@ -341,7 +339,6 @@ public static SpecificEntropy FromJoulesPerKilogramDegreeCelsius(QuantityValue j double value = (double) joulesperkilogramdegreecelsius; return new SpecificEntropy(value, SpecificEntropyUnit.JoulePerKilogramDegreeCelsius); } - /// /// Creates a from . /// @@ -351,7 +348,6 @@ public static SpecificEntropy FromJoulesPerKilogramKelvin(QuantityValue joulespe double value = (double) joulesperkilogramkelvin; return new SpecificEntropy(value, SpecificEntropyUnit.JoulePerKilogramKelvin); } - /// /// Creates a from . /// @@ -361,7 +357,6 @@ public static SpecificEntropy FromKilocaloriesPerGramKelvin(QuantityValue kiloca double value = (double) kilocaloriespergramkelvin; return new SpecificEntropy(value, SpecificEntropyUnit.KilocaloriePerGramKelvin); } - /// /// Creates a from . /// @@ -371,7 +366,6 @@ public static SpecificEntropy FromKilojoulesPerKilogramDegreeCelsius(QuantityVal double value = (double) kilojoulesperkilogramdegreecelsius; return new SpecificEntropy(value, SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius); } - /// /// Creates a from . /// @@ -381,7 +375,6 @@ public static SpecificEntropy FromKilojoulesPerKilogramKelvin(QuantityValue kilo double value = (double) kilojoulesperkilogramkelvin; return new SpecificEntropy(value, SpecificEntropyUnit.KilojoulePerKilogramKelvin); } - /// /// Creates a from . /// @@ -391,7 +384,6 @@ public static SpecificEntropy FromMegajoulesPerKilogramDegreeCelsius(QuantityVal double value = (double) megajoulesperkilogramdegreecelsius; return new SpecificEntropy(value, SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius); } - /// /// Creates a from . /// @@ -402,7 +394,6 @@ public static SpecificEntropy FromMegajoulesPerKilogramKelvin(QuantityValue mega return new SpecificEntropy(value, SpecificEntropyUnit.MegajoulePerKilogramKelvin); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs index 0daaab6688..ea508e7b18 100644 --- a/UnitsNet/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs @@ -279,7 +279,6 @@ public static SpecificFuelConsumption FromGramsPerKiloNewtonSecond(QuantityValue double value = (double) gramsperkilonewtonsecond; return new SpecificFuelConsumption(value, SpecificFuelConsumptionUnit.GramPerKiloNewtonSecond); } - /// /// Creates a from . /// @@ -289,7 +288,6 @@ public static SpecificFuelConsumption FromKilogramsPerKilogramForceHour(Quantity double value = (double) kilogramsperkilogramforcehour; return new SpecificFuelConsumption(value, SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour); } - /// /// Creates a from . /// @@ -299,7 +297,6 @@ public static SpecificFuelConsumption FromKilogramsPerKiloNewtonSecond(QuantityV double value = (double) kilogramsperkilonewtonsecond; return new SpecificFuelConsumption(value, SpecificFuelConsumptionUnit.KilogramPerKiloNewtonSecond); } - /// /// Creates a from . /// @@ -310,7 +307,6 @@ public static SpecificFuelConsumption FromPoundsMassPerPoundForceHour(QuantityVa return new SpecificFuelConsumption(value, SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs index 424aef46f2..86c287dd0c 100644 --- a/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs @@ -267,7 +267,6 @@ public static SpecificVolume FromCubicFeetPerPound(QuantityValue cubicfeetperpou double value = (double) cubicfeetperpound; return new SpecificVolume(value, SpecificVolumeUnit.CubicFootPerPound); } - /// /// Creates a from . /// @@ -277,7 +276,6 @@ public static SpecificVolume FromCubicMetersPerKilogram(QuantityValue cubicmeter double value = (double) cubicmetersperkilogram; return new SpecificVolume(value, SpecificVolumeUnit.CubicMeterPerKilogram); } - /// /// Creates a from . /// @@ -288,7 +286,6 @@ public static SpecificVolume FromMillicubicMetersPerKilogram(QuantityValue milli return new SpecificVolume(value, SpecificVolumeUnit.MillicubicMeterPerKilogram); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs index db728b0a88..8c54b7863b 100644 --- a/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs @@ -396,7 +396,6 @@ public static SpecificWeight FromKilogramsForcePerCubicCentimeter(QuantityValue double value = (double) kilogramsforcepercubiccentimeter; return new SpecificWeight(value, SpecificWeightUnit.KilogramForcePerCubicCentimeter); } - /// /// Creates a from . /// @@ -406,7 +405,6 @@ public static SpecificWeight FromKilogramsForcePerCubicMeter(QuantityValue kilog double value = (double) kilogramsforcepercubicmeter; return new SpecificWeight(value, SpecificWeightUnit.KilogramForcePerCubicMeter); } - /// /// Creates a from . /// @@ -416,7 +414,6 @@ public static SpecificWeight FromKilogramsForcePerCubicMillimeter(QuantityValue double value = (double) kilogramsforcepercubicmillimeter; return new SpecificWeight(value, SpecificWeightUnit.KilogramForcePerCubicMillimeter); } - /// /// Creates a from . /// @@ -426,7 +423,6 @@ public static SpecificWeight FromKilonewtonsPerCubicCentimeter(QuantityValue kil double value = (double) kilonewtonspercubiccentimeter; return new SpecificWeight(value, SpecificWeightUnit.KilonewtonPerCubicCentimeter); } - /// /// Creates a from . /// @@ -436,7 +432,6 @@ public static SpecificWeight FromKilonewtonsPerCubicMeter(QuantityValue kilonewt double value = (double) kilonewtonspercubicmeter; return new SpecificWeight(value, SpecificWeightUnit.KilonewtonPerCubicMeter); } - /// /// Creates a from . /// @@ -446,7 +441,6 @@ public static SpecificWeight FromKilonewtonsPerCubicMillimeter(QuantityValue kil double value = (double) kilonewtonspercubicmillimeter; return new SpecificWeight(value, SpecificWeightUnit.KilonewtonPerCubicMillimeter); } - /// /// Creates a from . /// @@ -456,7 +450,6 @@ public static SpecificWeight FromKilopoundsForcePerCubicFoot(QuantityValue kilop double value = (double) kilopoundsforcepercubicfoot; return new SpecificWeight(value, SpecificWeightUnit.KilopoundForcePerCubicFoot); } - /// /// Creates a from . /// @@ -466,7 +459,6 @@ public static SpecificWeight FromKilopoundsForcePerCubicInch(QuantityValue kilop double value = (double) kilopoundsforcepercubicinch; return new SpecificWeight(value, SpecificWeightUnit.KilopoundForcePerCubicInch); } - /// /// Creates a from . /// @@ -476,7 +468,6 @@ public static SpecificWeight FromMeganewtonsPerCubicMeter(QuantityValue meganewt double value = (double) meganewtonspercubicmeter; return new SpecificWeight(value, SpecificWeightUnit.MeganewtonPerCubicMeter); } - /// /// Creates a from . /// @@ -486,7 +477,6 @@ public static SpecificWeight FromNewtonsPerCubicCentimeter(QuantityValue newtons double value = (double) newtonspercubiccentimeter; return new SpecificWeight(value, SpecificWeightUnit.NewtonPerCubicCentimeter); } - /// /// Creates a from . /// @@ -496,7 +486,6 @@ public static SpecificWeight FromNewtonsPerCubicMeter(QuantityValue newtonspercu double value = (double) newtonspercubicmeter; return new SpecificWeight(value, SpecificWeightUnit.NewtonPerCubicMeter); } - /// /// Creates a from . /// @@ -506,7 +495,6 @@ public static SpecificWeight FromNewtonsPerCubicMillimeter(QuantityValue newtons double value = (double) newtonspercubicmillimeter; return new SpecificWeight(value, SpecificWeightUnit.NewtonPerCubicMillimeter); } - /// /// Creates a from . /// @@ -516,7 +504,6 @@ public static SpecificWeight FromPoundsForcePerCubicFoot(QuantityValue poundsfor double value = (double) poundsforcepercubicfoot; return new SpecificWeight(value, SpecificWeightUnit.PoundForcePerCubicFoot); } - /// /// Creates a from . /// @@ -526,7 +513,6 @@ public static SpecificWeight FromPoundsForcePerCubicInch(QuantityValue poundsfor double value = (double) poundsforcepercubicinch; return new SpecificWeight(value, SpecificWeightUnit.PoundForcePerCubicInch); } - /// /// Creates a from . /// @@ -536,7 +522,6 @@ public static SpecificWeight FromTonnesForcePerCubicCentimeter(QuantityValue ton double value = (double) tonnesforcepercubiccentimeter; return new SpecificWeight(value, SpecificWeightUnit.TonneForcePerCubicCentimeter); } - /// /// Creates a from . /// @@ -546,7 +531,6 @@ public static SpecificWeight FromTonnesForcePerCubicMeter(QuantityValue tonnesfo double value = (double) tonnesforcepercubicmeter; return new SpecificWeight(value, SpecificWeightUnit.TonneForcePerCubicMeter); } - /// /// Creates a from . /// @@ -557,7 +541,6 @@ public static SpecificWeight FromTonnesForcePerCubicMillimeter(QuantityValue ton return new SpecificWeight(value, SpecificWeightUnit.TonneForcePerCubicMillimeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Speed.g.cs b/UnitsNet/GeneratedCode/Quantities/Speed.g.cs index 65213b9270..939fe782cf 100644 --- a/UnitsNet/GeneratedCode/Quantities/Speed.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Speed.g.cs @@ -551,7 +551,6 @@ public static Speed FromCentimetersPerHour(QuantityValue centimetersperhour) double value = (double) centimetersperhour; return new Speed(value, SpeedUnit.CentimeterPerHour); } - /// /// Creates a from . /// @@ -561,7 +560,6 @@ public static Speed FromCentimetersPerMinutes(QuantityValue centimetersperminute double value = (double) centimetersperminutes; return new Speed(value, SpeedUnit.CentimeterPerMinute); } - /// /// Creates a from . /// @@ -571,7 +569,6 @@ public static Speed FromCentimetersPerSecond(QuantityValue centimeterspersecond) double value = (double) centimeterspersecond; return new Speed(value, SpeedUnit.CentimeterPerSecond); } - /// /// Creates a from . /// @@ -581,7 +578,6 @@ public static Speed FromDecimetersPerMinutes(QuantityValue decimetersperminutes) double value = (double) decimetersperminutes; return new Speed(value, SpeedUnit.DecimeterPerMinute); } - /// /// Creates a from . /// @@ -591,7 +587,6 @@ public static Speed FromDecimetersPerSecond(QuantityValue decimeterspersecond) double value = (double) decimeterspersecond; return new Speed(value, SpeedUnit.DecimeterPerSecond); } - /// /// Creates a from . /// @@ -601,7 +596,6 @@ public static Speed FromFeetPerHour(QuantityValue feetperhour) double value = (double) feetperhour; return new Speed(value, SpeedUnit.FootPerHour); } - /// /// Creates a from . /// @@ -611,7 +605,6 @@ public static Speed FromFeetPerMinute(QuantityValue feetperminute) double value = (double) feetperminute; return new Speed(value, SpeedUnit.FootPerMinute); } - /// /// Creates a from . /// @@ -621,7 +614,6 @@ public static Speed FromFeetPerSecond(QuantityValue feetpersecond) double value = (double) feetpersecond; return new Speed(value, SpeedUnit.FootPerSecond); } - /// /// Creates a from . /// @@ -631,7 +623,6 @@ public static Speed FromInchesPerHour(QuantityValue inchesperhour) double value = (double) inchesperhour; return new Speed(value, SpeedUnit.InchPerHour); } - /// /// Creates a from . /// @@ -641,7 +632,6 @@ public static Speed FromInchesPerMinute(QuantityValue inchesperminute) double value = (double) inchesperminute; return new Speed(value, SpeedUnit.InchPerMinute); } - /// /// Creates a from . /// @@ -651,7 +641,6 @@ public static Speed FromInchesPerSecond(QuantityValue inchespersecond) double value = (double) inchespersecond; return new Speed(value, SpeedUnit.InchPerSecond); } - /// /// Creates a from . /// @@ -661,7 +650,6 @@ public static Speed FromKilometersPerHour(QuantityValue kilometersperhour) double value = (double) kilometersperhour; return new Speed(value, SpeedUnit.KilometerPerHour); } - /// /// Creates a from . /// @@ -671,7 +659,6 @@ public static Speed FromKilometersPerMinutes(QuantityValue kilometersperminutes) double value = (double) kilometersperminutes; return new Speed(value, SpeedUnit.KilometerPerMinute); } - /// /// Creates a from . /// @@ -681,7 +668,6 @@ public static Speed FromKilometersPerSecond(QuantityValue kilometerspersecond) double value = (double) kilometerspersecond; return new Speed(value, SpeedUnit.KilometerPerSecond); } - /// /// Creates a from . /// @@ -691,7 +677,6 @@ public static Speed FromKnots(QuantityValue knots) double value = (double) knots; return new Speed(value, SpeedUnit.Knot); } - /// /// Creates a from . /// @@ -701,7 +686,6 @@ public static Speed FromMetersPerHour(QuantityValue metersperhour) double value = (double) metersperhour; return new Speed(value, SpeedUnit.MeterPerHour); } - /// /// Creates a from . /// @@ -711,7 +695,6 @@ public static Speed FromMetersPerMinutes(QuantityValue metersperminutes) double value = (double) metersperminutes; return new Speed(value, SpeedUnit.MeterPerMinute); } - /// /// Creates a from . /// @@ -721,7 +704,6 @@ public static Speed FromMetersPerSecond(QuantityValue meterspersecond) double value = (double) meterspersecond; return new Speed(value, SpeedUnit.MeterPerSecond); } - /// /// Creates a from . /// @@ -731,7 +713,6 @@ public static Speed FromMicrometersPerMinutes(QuantityValue micrometersperminute double value = (double) micrometersperminutes; return new Speed(value, SpeedUnit.MicrometerPerMinute); } - /// /// Creates a from . /// @@ -741,7 +722,6 @@ public static Speed FromMicrometersPerSecond(QuantityValue micrometerspersecond) double value = (double) micrometerspersecond; return new Speed(value, SpeedUnit.MicrometerPerSecond); } - /// /// Creates a from . /// @@ -751,7 +731,6 @@ public static Speed FromMilesPerHour(QuantityValue milesperhour) double value = (double) milesperhour; return new Speed(value, SpeedUnit.MilePerHour); } - /// /// Creates a from . /// @@ -761,7 +740,6 @@ public static Speed FromMillimetersPerHour(QuantityValue millimetersperhour) double value = (double) millimetersperhour; return new Speed(value, SpeedUnit.MillimeterPerHour); } - /// /// Creates a from . /// @@ -771,7 +749,6 @@ public static Speed FromMillimetersPerMinutes(QuantityValue millimetersperminute double value = (double) millimetersperminutes; return new Speed(value, SpeedUnit.MillimeterPerMinute); } - /// /// Creates a from . /// @@ -781,7 +758,6 @@ public static Speed FromMillimetersPerSecond(QuantityValue millimeterspersecond) double value = (double) millimeterspersecond; return new Speed(value, SpeedUnit.MillimeterPerSecond); } - /// /// Creates a from . /// @@ -791,7 +767,6 @@ public static Speed FromNanometersPerMinutes(QuantityValue nanometersperminutes) double value = (double) nanometersperminutes; return new Speed(value, SpeedUnit.NanometerPerMinute); } - /// /// Creates a from . /// @@ -801,7 +776,6 @@ public static Speed FromNanometersPerSecond(QuantityValue nanometerspersecond) double value = (double) nanometerspersecond; return new Speed(value, SpeedUnit.NanometerPerSecond); } - /// /// Creates a from . /// @@ -811,7 +785,6 @@ public static Speed FromUsSurveyFeetPerHour(QuantityValue ussurveyfeetperhour) double value = (double) ussurveyfeetperhour; return new Speed(value, SpeedUnit.UsSurveyFootPerHour); } - /// /// Creates a from . /// @@ -821,7 +794,6 @@ public static Speed FromUsSurveyFeetPerMinute(QuantityValue ussurveyfeetperminut double value = (double) ussurveyfeetperminute; return new Speed(value, SpeedUnit.UsSurveyFootPerMinute); } - /// /// Creates a from . /// @@ -831,7 +803,6 @@ public static Speed FromUsSurveyFeetPerSecond(QuantityValue ussurveyfeetpersecon double value = (double) ussurveyfeetpersecond; return new Speed(value, SpeedUnit.UsSurveyFootPerSecond); } - /// /// Creates a from . /// @@ -841,7 +812,6 @@ public static Speed FromYardsPerHour(QuantityValue yardsperhour) double value = (double) yardsperhour; return new Speed(value, SpeedUnit.YardPerHour); } - /// /// Creates a from . /// @@ -851,7 +821,6 @@ public static Speed FromYardsPerMinute(QuantityValue yardsperminute) double value = (double) yardsperminute; return new Speed(value, SpeedUnit.YardPerMinute); } - /// /// Creates a from . /// @@ -862,7 +831,6 @@ public static Speed FromYardsPerSecond(QuantityValue yardspersecond) return new Speed(value, SpeedUnit.YardPerSecond); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/StandardVolumeFlow.g.cs b/UnitsNet/GeneratedCode/Quantities/StandardVolumeFlow.g.cs index fbe6d6e30c..af05c0d894 100644 --- a/UnitsNet/GeneratedCode/Quantities/StandardVolumeFlow.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/StandardVolumeFlow.g.cs @@ -321,7 +321,6 @@ public static StandardVolumeFlow FromStandardCubicCentimetersPerMinute(QuantityV double value = (double) standardcubiccentimetersperminute; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute); } - /// /// Creates a from . /// @@ -331,7 +330,6 @@ public static StandardVolumeFlow FromStandardCubicFeetPerHour(QuantityValue stan double value = (double) standardcubicfeetperhour; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicFootPerHour); } - /// /// Creates a from . /// @@ -341,7 +339,6 @@ public static StandardVolumeFlow FromStandardCubicFeetPerMinute(QuantityValue st double value = (double) standardcubicfeetperminute; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicFootPerMinute); } - /// /// Creates a from . /// @@ -351,7 +348,6 @@ public static StandardVolumeFlow FromStandardCubicFeetPerSecond(QuantityValue st double value = (double) standardcubicfeetpersecond; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicFootPerSecond); } - /// /// Creates a from . /// @@ -361,7 +357,6 @@ public static StandardVolumeFlow FromStandardCubicMetersPerDay(QuantityValue sta double value = (double) standardcubicmetersperday; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicMeterPerDay); } - /// /// Creates a from . /// @@ -371,7 +366,6 @@ public static StandardVolumeFlow FromStandardCubicMetersPerHour(QuantityValue st double value = (double) standardcubicmetersperhour; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicMeterPerHour); } - /// /// Creates a from . /// @@ -381,7 +375,6 @@ public static StandardVolumeFlow FromStandardCubicMetersPerMinute(QuantityValue double value = (double) standardcubicmetersperminute; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicMeterPerMinute); } - /// /// Creates a from . /// @@ -391,7 +384,6 @@ public static StandardVolumeFlow FromStandardCubicMetersPerSecond(QuantityValue double value = (double) standardcubicmeterspersecond; return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicMeterPerSecond); } - /// /// Creates a from . /// @@ -402,7 +394,6 @@ public static StandardVolumeFlow FromStandardLitersPerMinute(QuantityValue stand return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardLiterPerMinute); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs b/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs index c11ca2677a..a21afff6dd 100644 --- a/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs @@ -330,7 +330,6 @@ public static Temperature FromDegreesCelsius(QuantityValue degreescelsius) double value = (double) degreescelsius; return new Temperature(value, TemperatureUnit.DegreeCelsius); } - /// /// Creates a from . /// @@ -340,7 +339,6 @@ public static Temperature FromDegreesDelisle(QuantityValue degreesdelisle) double value = (double) degreesdelisle; return new Temperature(value, TemperatureUnit.DegreeDelisle); } - /// /// Creates a from . /// @@ -350,7 +348,6 @@ public static Temperature FromDegreesFahrenheit(QuantityValue degreesfahrenheit) double value = (double) degreesfahrenheit; return new Temperature(value, TemperatureUnit.DegreeFahrenheit); } - /// /// Creates a from . /// @@ -360,7 +357,6 @@ public static Temperature FromDegreesNewton(QuantityValue degreesnewton) double value = (double) degreesnewton; return new Temperature(value, TemperatureUnit.DegreeNewton); } - /// /// Creates a from . /// @@ -370,7 +366,6 @@ public static Temperature FromDegreesRankine(QuantityValue degreesrankine) double value = (double) degreesrankine; return new Temperature(value, TemperatureUnit.DegreeRankine); } - /// /// Creates a from . /// @@ -380,7 +375,6 @@ public static Temperature FromDegreesReaumur(QuantityValue degreesreaumur) double value = (double) degreesreaumur; return new Temperature(value, TemperatureUnit.DegreeReaumur); } - /// /// Creates a from . /// @@ -390,7 +384,6 @@ public static Temperature FromDegreesRoemer(QuantityValue degreesroemer) double value = (double) degreesroemer; return new Temperature(value, TemperatureUnit.DegreeRoemer); } - /// /// Creates a from . /// @@ -400,7 +393,6 @@ public static Temperature FromKelvins(QuantityValue kelvins) double value = (double) kelvins; return new Temperature(value, TemperatureUnit.Kelvin); } - /// /// Creates a from . /// @@ -410,7 +402,6 @@ public static Temperature FromMillidegreesCelsius(QuantityValue millidegreescels double value = (double) millidegreescelsius; return new Temperature(value, TemperatureUnit.MillidegreeCelsius); } - /// /// Creates a from . /// @@ -421,7 +412,6 @@ public static Temperature FromSolarTemperatures(QuantityValue solartemperatures) return new Temperature(value, TemperatureUnit.SolarTemperature); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs index d55065ef84..790299baeb 100644 --- a/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs @@ -330,7 +330,6 @@ public static TemperatureChangeRate FromCentidegreesCelsiusPerSecond(QuantityVal double value = (double) centidegreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond); } - /// /// Creates a from . /// @@ -340,7 +339,6 @@ public static TemperatureChangeRate FromDecadegreesCelsiusPerSecond(QuantityValu double value = (double) decadegreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond); } - /// /// Creates a from . /// @@ -350,7 +348,6 @@ public static TemperatureChangeRate FromDecidegreesCelsiusPerSecond(QuantityValu double value = (double) decidegreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond); } - /// /// Creates a from . /// @@ -360,7 +357,6 @@ public static TemperatureChangeRate FromDegreesCelsiusPerMinute(QuantityValue de double value = (double) degreescelsiusperminute; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DegreeCelsiusPerMinute); } - /// /// Creates a from . /// @@ -370,7 +366,6 @@ public static TemperatureChangeRate FromDegreesCelsiusPerSecond(QuantityValue de double value = (double) degreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DegreeCelsiusPerSecond); } - /// /// Creates a from . /// @@ -380,7 +375,6 @@ public static TemperatureChangeRate FromHectodegreesCelsiusPerSecond(QuantityVal double value = (double) hectodegreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond); } - /// /// Creates a from . /// @@ -390,7 +384,6 @@ public static TemperatureChangeRate FromKilodegreesCelsiusPerSecond(QuantityValu double value = (double) kilodegreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond); } - /// /// Creates a from . /// @@ -400,7 +393,6 @@ public static TemperatureChangeRate FromMicrodegreesCelsiusPerSecond(QuantityVal double value = (double) microdegreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond); } - /// /// Creates a from . /// @@ -410,7 +402,6 @@ public static TemperatureChangeRate FromMillidegreesCelsiusPerSecond(QuantityVal double value = (double) millidegreescelsiuspersecond; return new TemperatureChangeRate(value, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond); } - /// /// Creates a from . /// @@ -421,7 +412,6 @@ public static TemperatureChangeRate FromNanodegreesCelsiusPerSecond(QuantityValu return new TemperatureChangeRate(value, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs index aa64194385..850fd56478 100644 --- a/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs @@ -321,7 +321,6 @@ public static TemperatureDelta FromDegreesCelsius(QuantityValue degreescelsius) double value = (double) degreescelsius; return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeCelsius); } - /// /// Creates a from . /// @@ -331,7 +330,6 @@ public static TemperatureDelta FromDegreesDelisle(QuantityValue degreesdelisle) double value = (double) degreesdelisle; return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeDelisle); } - /// /// Creates a from . /// @@ -341,7 +339,6 @@ public static TemperatureDelta FromDegreesFahrenheit(QuantityValue degreesfahren double value = (double) degreesfahrenheit; return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeFahrenheit); } - /// /// Creates a from . /// @@ -351,7 +348,6 @@ public static TemperatureDelta FromDegreesNewton(QuantityValue degreesnewton) double value = (double) degreesnewton; return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeNewton); } - /// /// Creates a from . /// @@ -361,7 +357,6 @@ public static TemperatureDelta FromDegreesRankine(QuantityValue degreesrankine) double value = (double) degreesrankine; return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeRankine); } - /// /// Creates a from . /// @@ -371,7 +366,6 @@ public static TemperatureDelta FromDegreesReaumur(QuantityValue degreesreaumur) double value = (double) degreesreaumur; return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeReaumur); } - /// /// Creates a from . /// @@ -381,7 +375,6 @@ public static TemperatureDelta FromDegreesRoemer(QuantityValue degreesroemer) double value = (double) degreesroemer; return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeRoemer); } - /// /// Creates a from . /// @@ -391,7 +384,6 @@ public static TemperatureDelta FromKelvins(QuantityValue kelvins) double value = (double) kelvins; return new TemperatureDelta(value, TemperatureDeltaUnit.Kelvin); } - /// /// Creates a from . /// @@ -402,7 +394,6 @@ public static TemperatureDelta FromMillidegreesCelsius(QuantityValue millidegree return new TemperatureDelta(value, TemperatureDeltaUnit.MillidegreeCelsius); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureGradient.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureGradient.g.cs index 27a669415f..92b5abf18b 100644 --- a/UnitsNet/GeneratedCode/Quantities/TemperatureGradient.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/TemperatureGradient.g.cs @@ -276,7 +276,6 @@ public static TemperatureGradient FromDegreesCelciusPerKilometer(QuantityValue d double value = (double) degreescelciusperkilometer; return new TemperatureGradient(value, TemperatureGradientUnit.DegreeCelsiusPerKilometer); } - /// /// Creates a from . /// @@ -286,7 +285,6 @@ public static TemperatureGradient FromDegreesCelciusPerMeter(QuantityValue degre double value = (double) degreescelciuspermeter; return new TemperatureGradient(value, TemperatureGradientUnit.DegreeCelsiusPerMeter); } - /// /// Creates a from . /// @@ -296,7 +294,6 @@ public static TemperatureGradient FromDegreesFahrenheitPerFoot(QuantityValue deg double value = (double) degreesfahrenheitperfoot; return new TemperatureGradient(value, TemperatureGradientUnit.DegreeFahrenheitPerFoot); } - /// /// Creates a from . /// @@ -307,7 +304,6 @@ public static TemperatureGradient FromKelvinsPerMeter(QuantityValue kelvinsperme return new TemperatureGradient(value, TemperatureGradientUnit.KelvinPerMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs b/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs index 1d15a03af8..f852ee5dd2 100644 --- a/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs @@ -261,7 +261,6 @@ public static ThermalConductivity FromBtusPerHourFootFahrenheit(QuantityValue bt double value = (double) btusperhourfootfahrenheit; return new ThermalConductivity(value, ThermalConductivityUnit.BtuPerHourFootFahrenheit); } - /// /// Creates a from . /// @@ -272,7 +271,6 @@ public static ThermalConductivity FromWattsPerMeterKelvin(QuantityValue wattsper return new ThermalConductivity(value, ThermalConductivityUnit.WattPerMeterKelvin); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/ThermalResistance.g.cs b/UnitsNet/GeneratedCode/Quantities/ThermalResistance.g.cs index 51a64ddf05..cff035c488 100644 --- a/UnitsNet/GeneratedCode/Quantities/ThermalResistance.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/ThermalResistance.g.cs @@ -294,7 +294,6 @@ public static ThermalResistance FromHourSquareFeetDegreesFahrenheitPerBtu(Quanti double value = (double) hoursquarefeetdegreesfahrenheitperbtu; return new ThermalResistance(value, ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu); } - /// /// Creates a from . /// @@ -304,7 +303,6 @@ public static ThermalResistance FromSquareCentimeterHourDegreesCelsiusPerKilocal double value = (double) squarecentimeterhourdegreescelsiusperkilocalorie; return new ThermalResistance(value, ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie); } - /// /// Creates a from . /// @@ -314,7 +312,6 @@ public static ThermalResistance FromSquareCentimeterKelvinsPerWatt(QuantityValue double value = (double) squarecentimeterkelvinsperwatt; return new ThermalResistance(value, ThermalResistanceUnit.SquareCentimeterKelvinPerWatt); } - /// /// Creates a from . /// @@ -324,7 +321,6 @@ public static ThermalResistance FromSquareMeterDegreesCelsiusPerWatt(QuantityVal double value = (double) squaremeterdegreescelsiusperwatt; return new ThermalResistance(value, ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt); } - /// /// Creates a from . /// @@ -334,7 +330,6 @@ public static ThermalResistance FromSquareMeterKelvinsPerKilowatt(QuantityValue double value = (double) squaremeterkelvinsperkilowatt; return new ThermalResistance(value, ThermalResistanceUnit.SquareMeterKelvinPerKilowatt); } - /// /// Creates a from . /// @@ -345,7 +340,6 @@ public static ThermalResistance FromSquareMeterKelvinsPerWatt(QuantityValue squa return new ThermalResistance(value, ThermalResistanceUnit.SquareMeterKelvinPerWatt); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Torque.g.cs b/UnitsNet/GeneratedCode/Quantities/Torque.g.cs index 259523e65c..95d588d2e9 100644 --- a/UnitsNet/GeneratedCode/Quantities/Torque.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Torque.g.cs @@ -468,7 +468,6 @@ public static Torque FromGramForceCentimeters(QuantityValue gramforcecentimeters double value = (double) gramforcecentimeters; return new Torque(value, TorqueUnit.GramForceCentimeter); } - /// /// Creates a from . /// @@ -478,7 +477,6 @@ public static Torque FromGramForceMeters(QuantityValue gramforcemeters) double value = (double) gramforcemeters; return new Torque(value, TorqueUnit.GramForceMeter); } - /// /// Creates a from . /// @@ -488,7 +486,6 @@ public static Torque FromGramForceMillimeters(QuantityValue gramforcemillimeters double value = (double) gramforcemillimeters; return new Torque(value, TorqueUnit.GramForceMillimeter); } - /// /// Creates a from . /// @@ -498,7 +495,6 @@ public static Torque FromKilogramForceCentimeters(QuantityValue kilogramforcecen double value = (double) kilogramforcecentimeters; return new Torque(value, TorqueUnit.KilogramForceCentimeter); } - /// /// Creates a from . /// @@ -508,7 +504,6 @@ public static Torque FromKilogramForceMeters(QuantityValue kilogramforcemeters) double value = (double) kilogramforcemeters; return new Torque(value, TorqueUnit.KilogramForceMeter); } - /// /// Creates a from . /// @@ -518,7 +513,6 @@ public static Torque FromKilogramForceMillimeters(QuantityValue kilogramforcemil double value = (double) kilogramforcemillimeters; return new Torque(value, TorqueUnit.KilogramForceMillimeter); } - /// /// Creates a from . /// @@ -528,7 +522,6 @@ public static Torque FromKilonewtonCentimeters(QuantityValue kilonewtoncentimete double value = (double) kilonewtoncentimeters; return new Torque(value, TorqueUnit.KilonewtonCentimeter); } - /// /// Creates a from . /// @@ -538,7 +531,6 @@ public static Torque FromKilonewtonMeters(QuantityValue kilonewtonmeters) double value = (double) kilonewtonmeters; return new Torque(value, TorqueUnit.KilonewtonMeter); } - /// /// Creates a from . /// @@ -548,7 +540,6 @@ public static Torque FromKilonewtonMillimeters(QuantityValue kilonewtonmillimete double value = (double) kilonewtonmillimeters; return new Torque(value, TorqueUnit.KilonewtonMillimeter); } - /// /// Creates a from . /// @@ -558,7 +549,6 @@ public static Torque FromKilopoundForceFeet(QuantityValue kilopoundforcefeet) double value = (double) kilopoundforcefeet; return new Torque(value, TorqueUnit.KilopoundForceFoot); } - /// /// Creates a from . /// @@ -568,7 +558,6 @@ public static Torque FromKilopoundForceInches(QuantityValue kilopoundforceinches double value = (double) kilopoundforceinches; return new Torque(value, TorqueUnit.KilopoundForceInch); } - /// /// Creates a from . /// @@ -578,7 +567,6 @@ public static Torque FromMeganewtonCentimeters(QuantityValue meganewtoncentimete double value = (double) meganewtoncentimeters; return new Torque(value, TorqueUnit.MeganewtonCentimeter); } - /// /// Creates a from . /// @@ -588,7 +576,6 @@ public static Torque FromMeganewtonMeters(QuantityValue meganewtonmeters) double value = (double) meganewtonmeters; return new Torque(value, TorqueUnit.MeganewtonMeter); } - /// /// Creates a from . /// @@ -598,7 +585,6 @@ public static Torque FromMeganewtonMillimeters(QuantityValue meganewtonmillimete double value = (double) meganewtonmillimeters; return new Torque(value, TorqueUnit.MeganewtonMillimeter); } - /// /// Creates a from . /// @@ -608,7 +594,6 @@ public static Torque FromMegapoundForceFeet(QuantityValue megapoundforcefeet) double value = (double) megapoundforcefeet; return new Torque(value, TorqueUnit.MegapoundForceFoot); } - /// /// Creates a from . /// @@ -618,7 +603,6 @@ public static Torque FromMegapoundForceInches(QuantityValue megapoundforceinches double value = (double) megapoundforceinches; return new Torque(value, TorqueUnit.MegapoundForceInch); } - /// /// Creates a from . /// @@ -628,7 +612,6 @@ public static Torque FromNewtonCentimeters(QuantityValue newtoncentimeters) double value = (double) newtoncentimeters; return new Torque(value, TorqueUnit.NewtonCentimeter); } - /// /// Creates a from . /// @@ -638,7 +621,6 @@ public static Torque FromNewtonMeters(QuantityValue newtonmeters) double value = (double) newtonmeters; return new Torque(value, TorqueUnit.NewtonMeter); } - /// /// Creates a from . /// @@ -648,7 +630,6 @@ public static Torque FromNewtonMillimeters(QuantityValue newtonmillimeters) double value = (double) newtonmillimeters; return new Torque(value, TorqueUnit.NewtonMillimeter); } - /// /// Creates a from . /// @@ -658,7 +639,6 @@ public static Torque FromPoundalFeet(QuantityValue poundalfeet) double value = (double) poundalfeet; return new Torque(value, TorqueUnit.PoundalFoot); } - /// /// Creates a from . /// @@ -668,7 +648,6 @@ public static Torque FromPoundForceFeet(QuantityValue poundforcefeet) double value = (double) poundforcefeet; return new Torque(value, TorqueUnit.PoundForceFoot); } - /// /// Creates a from . /// @@ -678,7 +657,6 @@ public static Torque FromPoundForceInches(QuantityValue poundforceinches) double value = (double) poundforceinches; return new Torque(value, TorqueUnit.PoundForceInch); } - /// /// Creates a from . /// @@ -688,7 +666,6 @@ public static Torque FromTonneForceCentimeters(QuantityValue tonneforcecentimete double value = (double) tonneforcecentimeters; return new Torque(value, TorqueUnit.TonneForceCentimeter); } - /// /// Creates a from . /// @@ -698,7 +675,6 @@ public static Torque FromTonneForceMeters(QuantityValue tonneforcemeters) double value = (double) tonneforcemeters; return new Torque(value, TorqueUnit.TonneForceMeter); } - /// /// Creates a from . /// @@ -709,7 +685,6 @@ public static Torque FromTonneForceMillimeters(QuantityValue tonneforcemillimete return new Torque(value, TorqueUnit.TonneForceMillimeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/TorquePerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/TorquePerLength.g.cs index e7849bea60..75f4d7c067 100644 --- a/UnitsNet/GeneratedCode/Quantities/TorquePerLength.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/TorquePerLength.g.cs @@ -432,7 +432,6 @@ public static TorquePerLength FromKilogramForceCentimetersPerMeter(QuantityValue double value = (double) kilogramforcecentimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.KilogramForceCentimeterPerMeter); } - /// /// Creates a from . /// @@ -442,7 +441,6 @@ public static TorquePerLength FromKilogramForceMetersPerMeter(QuantityValue kilo double value = (double) kilogramforcemeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.KilogramForceMeterPerMeter); } - /// /// Creates a from . /// @@ -452,7 +450,6 @@ public static TorquePerLength FromKilogramForceMillimetersPerMeter(QuantityValue double value = (double) kilogramforcemillimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.KilogramForceMillimeterPerMeter); } - /// /// Creates a from . /// @@ -462,7 +459,6 @@ public static TorquePerLength FromKilonewtonCentimetersPerMeter(QuantityValue ki double value = (double) kilonewtoncentimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.KilonewtonCentimeterPerMeter); } - /// /// Creates a from . /// @@ -472,7 +468,6 @@ public static TorquePerLength FromKilonewtonMetersPerMeter(QuantityValue kilonew double value = (double) kilonewtonmeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.KilonewtonMeterPerMeter); } - /// /// Creates a from . /// @@ -482,7 +477,6 @@ public static TorquePerLength FromKilonewtonMillimetersPerMeter(QuantityValue ki double value = (double) kilonewtonmillimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.KilonewtonMillimeterPerMeter); } - /// /// Creates a from . /// @@ -492,7 +486,6 @@ public static TorquePerLength FromKilopoundForceFeetPerFoot(QuantityValue kilopo double value = (double) kilopoundforcefeetperfoot; return new TorquePerLength(value, TorquePerLengthUnit.KilopoundForceFootPerFoot); } - /// /// Creates a from . /// @@ -502,7 +495,6 @@ public static TorquePerLength FromKilopoundForceInchesPerFoot(QuantityValue kilo double value = (double) kilopoundforceinchesperfoot; return new TorquePerLength(value, TorquePerLengthUnit.KilopoundForceInchPerFoot); } - /// /// Creates a from . /// @@ -512,7 +504,6 @@ public static TorquePerLength FromMeganewtonCentimetersPerMeter(QuantityValue me double value = (double) meganewtoncentimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.MeganewtonCentimeterPerMeter); } - /// /// Creates a from . /// @@ -522,7 +513,6 @@ public static TorquePerLength FromMeganewtonMetersPerMeter(QuantityValue meganew double value = (double) meganewtonmeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.MeganewtonMeterPerMeter); } - /// /// Creates a from . /// @@ -532,7 +522,6 @@ public static TorquePerLength FromMeganewtonMillimetersPerMeter(QuantityValue me double value = (double) meganewtonmillimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.MeganewtonMillimeterPerMeter); } - /// /// Creates a from . /// @@ -542,7 +531,6 @@ public static TorquePerLength FromMegapoundForceFeetPerFoot(QuantityValue megapo double value = (double) megapoundforcefeetperfoot; return new TorquePerLength(value, TorquePerLengthUnit.MegapoundForceFootPerFoot); } - /// /// Creates a from . /// @@ -552,7 +540,6 @@ public static TorquePerLength FromMegapoundForceInchesPerFoot(QuantityValue mega double value = (double) megapoundforceinchesperfoot; return new TorquePerLength(value, TorquePerLengthUnit.MegapoundForceInchPerFoot); } - /// /// Creates a from . /// @@ -562,7 +549,6 @@ public static TorquePerLength FromNewtonCentimetersPerMeter(QuantityValue newton double value = (double) newtoncentimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.NewtonCentimeterPerMeter); } - /// /// Creates a from . /// @@ -572,7 +558,6 @@ public static TorquePerLength FromNewtonMetersPerMeter(QuantityValue newtonmeter double value = (double) newtonmeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.NewtonMeterPerMeter); } - /// /// Creates a from . /// @@ -582,7 +567,6 @@ public static TorquePerLength FromNewtonMillimetersPerMeter(QuantityValue newton double value = (double) newtonmillimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.NewtonMillimeterPerMeter); } - /// /// Creates a from . /// @@ -592,7 +576,6 @@ public static TorquePerLength FromPoundForceFeetPerFoot(QuantityValue poundforce double value = (double) poundforcefeetperfoot; return new TorquePerLength(value, TorquePerLengthUnit.PoundForceFootPerFoot); } - /// /// Creates a from . /// @@ -602,7 +585,6 @@ public static TorquePerLength FromPoundForceInchesPerFoot(QuantityValue poundfor double value = (double) poundforceinchesperfoot; return new TorquePerLength(value, TorquePerLengthUnit.PoundForceInchPerFoot); } - /// /// Creates a from . /// @@ -612,7 +594,6 @@ public static TorquePerLength FromTonneForceCentimetersPerMeter(QuantityValue to double value = (double) tonneforcecentimeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.TonneForceCentimeterPerMeter); } - /// /// Creates a from . /// @@ -622,7 +603,6 @@ public static TorquePerLength FromTonneForceMetersPerMeter(QuantityValue tonnefo double value = (double) tonneforcemeterspermeter; return new TorquePerLength(value, TorquePerLengthUnit.TonneForceMeterPerMeter); } - /// /// Creates a from . /// @@ -633,7 +613,6 @@ public static TorquePerLength FromTonneForceMillimetersPerMeter(QuantityValue to return new TorquePerLength(value, TorquePerLengthUnit.TonneForceMillimeterPerMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Turbidity.g.cs b/UnitsNet/GeneratedCode/Quantities/Turbidity.g.cs index 5b70431c0f..7e8392b36f 100644 --- a/UnitsNet/GeneratedCode/Quantities/Turbidity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Turbidity.g.cs @@ -253,7 +253,6 @@ public static Turbidity FromNTU(QuantityValue ntu) return new Turbidity(value, TurbidityUnit.NTU); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/VitaminA.g.cs b/UnitsNet/GeneratedCode/Quantities/VitaminA.g.cs index 878d8d1dba..6c2e5342ac 100644 --- a/UnitsNet/GeneratedCode/Quantities/VitaminA.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/VitaminA.g.cs @@ -250,7 +250,6 @@ public static VitaminA FromInternationalUnits(QuantityValue internationalunits) return new VitaminA(value, VitaminAUnit.InternationalUnit); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/Volume.g.cs b/UnitsNet/GeneratedCode/Quantities/Volume.g.cs index 7c638bb723..de4589ffb2 100644 --- a/UnitsNet/GeneratedCode/Quantities/Volume.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Volume.g.cs @@ -755,7 +755,6 @@ public static Volume FromAcreFeet(QuantityValue acrefeet) double value = (double) acrefeet; return new Volume(value, VolumeUnit.AcreFoot); } - /// /// Creates a from . /// @@ -765,7 +764,6 @@ public static Volume FromAuTablespoons(QuantityValue autablespoons) double value = (double) autablespoons; return new Volume(value, VolumeUnit.AuTablespoon); } - /// /// Creates a from . /// @@ -775,7 +773,6 @@ public static Volume FromBoardFeet(QuantityValue boardfeet) double value = (double) boardfeet; return new Volume(value, VolumeUnit.BoardFoot); } - /// /// Creates a from . /// @@ -785,7 +782,6 @@ public static Volume FromCentiliters(QuantityValue centiliters) double value = (double) centiliters; return new Volume(value, VolumeUnit.Centiliter); } - /// /// Creates a from . /// @@ -795,7 +791,6 @@ public static Volume FromCubicCentimeters(QuantityValue cubiccentimeters) double value = (double) cubiccentimeters; return new Volume(value, VolumeUnit.CubicCentimeter); } - /// /// Creates a from . /// @@ -805,7 +800,6 @@ public static Volume FromCubicDecimeters(QuantityValue cubicdecimeters) double value = (double) cubicdecimeters; return new Volume(value, VolumeUnit.CubicDecimeter); } - /// /// Creates a from . /// @@ -815,7 +809,6 @@ public static Volume FromCubicFeet(QuantityValue cubicfeet) double value = (double) cubicfeet; return new Volume(value, VolumeUnit.CubicFoot); } - /// /// Creates a from . /// @@ -825,7 +818,6 @@ public static Volume FromCubicHectometers(QuantityValue cubichectometers) double value = (double) cubichectometers; return new Volume(value, VolumeUnit.CubicHectometer); } - /// /// Creates a from . /// @@ -835,7 +827,6 @@ public static Volume FromCubicInches(QuantityValue cubicinches) double value = (double) cubicinches; return new Volume(value, VolumeUnit.CubicInch); } - /// /// Creates a from . /// @@ -845,7 +836,6 @@ public static Volume FromCubicKilometers(QuantityValue cubickilometers) double value = (double) cubickilometers; return new Volume(value, VolumeUnit.CubicKilometer); } - /// /// Creates a from . /// @@ -855,7 +845,6 @@ public static Volume FromCubicMeters(QuantityValue cubicmeters) double value = (double) cubicmeters; return new Volume(value, VolumeUnit.CubicMeter); } - /// /// Creates a from . /// @@ -865,7 +854,6 @@ public static Volume FromCubicMicrometers(QuantityValue cubicmicrometers) double value = (double) cubicmicrometers; return new Volume(value, VolumeUnit.CubicMicrometer); } - /// /// Creates a from . /// @@ -875,7 +863,6 @@ public static Volume FromCubicMiles(QuantityValue cubicmiles) double value = (double) cubicmiles; return new Volume(value, VolumeUnit.CubicMile); } - /// /// Creates a from . /// @@ -885,7 +872,6 @@ public static Volume FromCubicMillimeters(QuantityValue cubicmillimeters) double value = (double) cubicmillimeters; return new Volume(value, VolumeUnit.CubicMillimeter); } - /// /// Creates a from . /// @@ -895,7 +881,6 @@ public static Volume FromCubicYards(QuantityValue cubicyards) double value = (double) cubicyards; return new Volume(value, VolumeUnit.CubicYard); } - /// /// Creates a from . /// @@ -905,7 +890,6 @@ public static Volume FromDecaliters(QuantityValue decaliters) double value = (double) decaliters; return new Volume(value, VolumeUnit.Decaliter); } - /// /// Creates a from . /// @@ -915,7 +899,6 @@ public static Volume FromDecausGallons(QuantityValue decausgallons) double value = (double) decausgallons; return new Volume(value, VolumeUnit.DecausGallon); } - /// /// Creates a from . /// @@ -925,7 +908,6 @@ public static Volume FromDeciliters(QuantityValue deciliters) double value = (double) deciliters; return new Volume(value, VolumeUnit.Deciliter); } - /// /// Creates a from . /// @@ -935,7 +917,6 @@ public static Volume FromDeciusGallons(QuantityValue deciusgallons) double value = (double) deciusgallons; return new Volume(value, VolumeUnit.DeciusGallon); } - /// /// Creates a from . /// @@ -945,7 +926,6 @@ public static Volume FromHectocubicFeet(QuantityValue hectocubicfeet) double value = (double) hectocubicfeet; return new Volume(value, VolumeUnit.HectocubicFoot); } - /// /// Creates a from . /// @@ -955,7 +935,6 @@ public static Volume FromHectocubicMeters(QuantityValue hectocubicmeters) double value = (double) hectocubicmeters; return new Volume(value, VolumeUnit.HectocubicMeter); } - /// /// Creates a from . /// @@ -965,7 +944,6 @@ public static Volume FromHectoliters(QuantityValue hectoliters) double value = (double) hectoliters; return new Volume(value, VolumeUnit.Hectoliter); } - /// /// Creates a from . /// @@ -975,7 +953,6 @@ public static Volume FromHectousGallons(QuantityValue hectousgallons) double value = (double) hectousgallons; return new Volume(value, VolumeUnit.HectousGallon); } - /// /// Creates a from . /// @@ -985,7 +962,6 @@ public static Volume FromImperialBeerBarrels(QuantityValue imperialbeerbarrels) double value = (double) imperialbeerbarrels; return new Volume(value, VolumeUnit.ImperialBeerBarrel); } - /// /// Creates a from . /// @@ -995,7 +971,6 @@ public static Volume FromImperialGallons(QuantityValue imperialgallons) double value = (double) imperialgallons; return new Volume(value, VolumeUnit.ImperialGallon); } - /// /// Creates a from . /// @@ -1005,7 +980,6 @@ public static Volume FromImperialOunces(QuantityValue imperialounces) double value = (double) imperialounces; return new Volume(value, VolumeUnit.ImperialOunce); } - /// /// Creates a from . /// @@ -1015,7 +989,6 @@ public static Volume FromImperialPints(QuantityValue imperialpints) double value = (double) imperialpints; return new Volume(value, VolumeUnit.ImperialPint); } - /// /// Creates a from . /// @@ -1025,7 +998,6 @@ public static Volume FromKilocubicFeet(QuantityValue kilocubicfeet) double value = (double) kilocubicfeet; return new Volume(value, VolumeUnit.KilocubicFoot); } - /// /// Creates a from . /// @@ -1035,7 +1007,6 @@ public static Volume FromKilocubicMeters(QuantityValue kilocubicmeters) double value = (double) kilocubicmeters; return new Volume(value, VolumeUnit.KilocubicMeter); } - /// /// Creates a from . /// @@ -1045,7 +1016,6 @@ public static Volume FromKiloimperialGallons(QuantityValue kiloimperialgallons) double value = (double) kiloimperialgallons; return new Volume(value, VolumeUnit.KiloimperialGallon); } - /// /// Creates a from . /// @@ -1055,7 +1025,6 @@ public static Volume FromKiloliters(QuantityValue kiloliters) double value = (double) kiloliters; return new Volume(value, VolumeUnit.Kiloliter); } - /// /// Creates a from . /// @@ -1065,7 +1034,6 @@ public static Volume FromKilousGallons(QuantityValue kilousgallons) double value = (double) kilousgallons; return new Volume(value, VolumeUnit.KilousGallon); } - /// /// Creates a from . /// @@ -1075,7 +1043,6 @@ public static Volume FromLiters(QuantityValue liters) double value = (double) liters; return new Volume(value, VolumeUnit.Liter); } - /// /// Creates a from . /// @@ -1085,7 +1052,6 @@ public static Volume FromMegacubicFeet(QuantityValue megacubicfeet) double value = (double) megacubicfeet; return new Volume(value, VolumeUnit.MegacubicFoot); } - /// /// Creates a from . /// @@ -1095,7 +1061,6 @@ public static Volume FromMegaimperialGallons(QuantityValue megaimperialgallons) double value = (double) megaimperialgallons; return new Volume(value, VolumeUnit.MegaimperialGallon); } - /// /// Creates a from . /// @@ -1105,7 +1070,6 @@ public static Volume FromMegaliters(QuantityValue megaliters) double value = (double) megaliters; return new Volume(value, VolumeUnit.Megaliter); } - /// /// Creates a from . /// @@ -1115,7 +1079,6 @@ public static Volume FromMegausGallons(QuantityValue megausgallons) double value = (double) megausgallons; return new Volume(value, VolumeUnit.MegausGallon); } - /// /// Creates a from . /// @@ -1125,7 +1088,6 @@ public static Volume FromMetricCups(QuantityValue metriccups) double value = (double) metriccups; return new Volume(value, VolumeUnit.MetricCup); } - /// /// Creates a from . /// @@ -1135,7 +1097,6 @@ public static Volume FromMetricTeaspoons(QuantityValue metricteaspoons) double value = (double) metricteaspoons; return new Volume(value, VolumeUnit.MetricTeaspoon); } - /// /// Creates a from . /// @@ -1145,7 +1106,6 @@ public static Volume FromMicroliters(QuantityValue microliters) double value = (double) microliters; return new Volume(value, VolumeUnit.Microliter); } - /// /// Creates a from . /// @@ -1155,7 +1115,6 @@ public static Volume FromMilliliters(QuantityValue milliliters) double value = (double) milliliters; return new Volume(value, VolumeUnit.Milliliter); } - /// /// Creates a from . /// @@ -1165,7 +1124,6 @@ public static Volume FromOilBarrels(QuantityValue oilbarrels) double value = (double) oilbarrels; return new Volume(value, VolumeUnit.OilBarrel); } - /// /// Creates a from . /// @@ -1175,7 +1133,6 @@ public static Volume FromUkTablespoons(QuantityValue uktablespoons) double value = (double) uktablespoons; return new Volume(value, VolumeUnit.UkTablespoon); } - /// /// Creates a from . /// @@ -1185,7 +1142,6 @@ public static Volume FromUsBeerBarrels(QuantityValue usbeerbarrels) double value = (double) usbeerbarrels; return new Volume(value, VolumeUnit.UsBeerBarrel); } - /// /// Creates a from . /// @@ -1195,7 +1151,6 @@ public static Volume FromUsCustomaryCups(QuantityValue uscustomarycups) double value = (double) uscustomarycups; return new Volume(value, VolumeUnit.UsCustomaryCup); } - /// /// Creates a from . /// @@ -1205,7 +1160,6 @@ public static Volume FromUsGallons(QuantityValue usgallons) double value = (double) usgallons; return new Volume(value, VolumeUnit.UsGallon); } - /// /// Creates a from . /// @@ -1215,7 +1169,6 @@ public static Volume FromUsLegalCups(QuantityValue uslegalcups) double value = (double) uslegalcups; return new Volume(value, VolumeUnit.UsLegalCup); } - /// /// Creates a from . /// @@ -1225,7 +1178,6 @@ public static Volume FromUsOunces(QuantityValue usounces) double value = (double) usounces; return new Volume(value, VolumeUnit.UsOunce); } - /// /// Creates a from . /// @@ -1235,7 +1187,6 @@ public static Volume FromUsPints(QuantityValue uspints) double value = (double) uspints; return new Volume(value, VolumeUnit.UsPint); } - /// /// Creates a from . /// @@ -1245,7 +1196,6 @@ public static Volume FromUsQuarts(QuantityValue usquarts) double value = (double) usquarts; return new Volume(value, VolumeUnit.UsQuart); } - /// /// Creates a from . /// @@ -1255,7 +1205,6 @@ public static Volume FromUsTablespoons(QuantityValue ustablespoons) double value = (double) ustablespoons; return new Volume(value, VolumeUnit.UsTablespoon); } - /// /// Creates a from . /// @@ -1266,7 +1215,6 @@ public static Volume FromUsTeaspoons(QuantityValue usteaspoons) return new Volume(value, VolumeUnit.UsTeaspoon); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs index c0d3cfc806..969b3b5db0 100644 --- a/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs @@ -423,7 +423,6 @@ public static VolumeConcentration FromCentilitersPerLiter(QuantityValue centilit double value = (double) centilitersperliter; return new VolumeConcentration(value, VolumeConcentrationUnit.CentilitersPerLiter); } - /// /// Creates a from . /// @@ -433,7 +432,6 @@ public static VolumeConcentration FromCentilitersPerMililiter(QuantityValue cent double value = (double) centiliterspermililiter; return new VolumeConcentration(value, VolumeConcentrationUnit.CentilitersPerMililiter); } - /// /// Creates a from . /// @@ -443,7 +441,6 @@ public static VolumeConcentration FromDecilitersPerLiter(QuantityValue deciliter double value = (double) decilitersperliter; return new VolumeConcentration(value, VolumeConcentrationUnit.DecilitersPerLiter); } - /// /// Creates a from . /// @@ -453,7 +450,6 @@ public static VolumeConcentration FromDecilitersPerMililiter(QuantityValue decil double value = (double) deciliterspermililiter; return new VolumeConcentration(value, VolumeConcentrationUnit.DecilitersPerMililiter); } - /// /// Creates a from . /// @@ -463,7 +459,6 @@ public static VolumeConcentration FromDecimalFractions(QuantityValue decimalfrac double value = (double) decimalfractions; return new VolumeConcentration(value, VolumeConcentrationUnit.DecimalFraction); } - /// /// Creates a from . /// @@ -473,7 +468,6 @@ public static VolumeConcentration FromLitersPerLiter(QuantityValue litersperlite double value = (double) litersperliter; return new VolumeConcentration(value, VolumeConcentrationUnit.LitersPerLiter); } - /// /// Creates a from . /// @@ -483,7 +477,6 @@ public static VolumeConcentration FromLitersPerMililiter(QuantityValue litersper double value = (double) literspermililiter; return new VolumeConcentration(value, VolumeConcentrationUnit.LitersPerMililiter); } - /// /// Creates a from . /// @@ -493,7 +486,6 @@ public static VolumeConcentration FromMicrolitersPerLiter(QuantityValue microlit double value = (double) microlitersperliter; return new VolumeConcentration(value, VolumeConcentrationUnit.MicrolitersPerLiter); } - /// /// Creates a from . /// @@ -503,7 +495,6 @@ public static VolumeConcentration FromMicrolitersPerMililiter(QuantityValue micr double value = (double) microliterspermililiter; return new VolumeConcentration(value, VolumeConcentrationUnit.MicrolitersPerMililiter); } - /// /// Creates a from . /// @@ -513,7 +504,6 @@ public static VolumeConcentration FromMillilitersPerLiter(QuantityValue millilit double value = (double) millilitersperliter; return new VolumeConcentration(value, VolumeConcentrationUnit.MillilitersPerLiter); } - /// /// Creates a from . /// @@ -523,7 +513,6 @@ public static VolumeConcentration FromMillilitersPerMililiter(QuantityValue mill double value = (double) milliliterspermililiter; return new VolumeConcentration(value, VolumeConcentrationUnit.MillilitersPerMililiter); } - /// /// Creates a from . /// @@ -533,7 +522,6 @@ public static VolumeConcentration FromNanolitersPerLiter(QuantityValue nanoliter double value = (double) nanolitersperliter; return new VolumeConcentration(value, VolumeConcentrationUnit.NanolitersPerLiter); } - /// /// Creates a from . /// @@ -543,7 +531,6 @@ public static VolumeConcentration FromNanolitersPerMililiter(QuantityValue nanol double value = (double) nanoliterspermililiter; return new VolumeConcentration(value, VolumeConcentrationUnit.NanolitersPerMililiter); } - /// /// Creates a from . /// @@ -553,7 +540,6 @@ public static VolumeConcentration FromPartsPerBillion(QuantityValue partsperbill double value = (double) partsperbillion; return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerBillion); } - /// /// Creates a from . /// @@ -563,7 +549,6 @@ public static VolumeConcentration FromPartsPerMillion(QuantityValue partspermill double value = (double) partspermillion; return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerMillion); } - /// /// Creates a from . /// @@ -573,7 +558,6 @@ public static VolumeConcentration FromPartsPerThousand(QuantityValue partspertho double value = (double) partsperthousand; return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerThousand); } - /// /// Creates a from . /// @@ -583,7 +567,6 @@ public static VolumeConcentration FromPartsPerTrillion(QuantityValue partspertri double value = (double) partspertrillion; return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerTrillion); } - /// /// Creates a from . /// @@ -593,7 +576,6 @@ public static VolumeConcentration FromPercent(QuantityValue percent) double value = (double) percent; return new VolumeConcentration(value, VolumeConcentrationUnit.Percent); } - /// /// Creates a from . /// @@ -603,7 +585,6 @@ public static VolumeConcentration FromPicolitersPerLiter(QuantityValue picoliter double value = (double) picolitersperliter; return new VolumeConcentration(value, VolumeConcentrationUnit.PicolitersPerLiter); } - /// /// Creates a from . /// @@ -614,7 +595,6 @@ public static VolumeConcentration FromPicolitersPerMililiter(QuantityValue picol return new VolumeConcentration(value, VolumeConcentrationUnit.PicolitersPerMililiter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs index d22284167e..fb33f436b3 100644 --- a/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs @@ -825,7 +825,6 @@ public static VolumeFlow FromAcreFeetPerDay(QuantityValue acrefeetperday) double value = (double) acrefeetperday; return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerDay); } - /// /// Creates a from . /// @@ -835,7 +834,6 @@ public static VolumeFlow FromAcreFeetPerHour(QuantityValue acrefeetperhour) double value = (double) acrefeetperhour; return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerHour); } - /// /// Creates a from . /// @@ -845,7 +843,6 @@ public static VolumeFlow FromAcreFeetPerMinute(QuantityValue acrefeetperminute) double value = (double) acrefeetperminute; return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerMinute); } - /// /// Creates a from . /// @@ -855,7 +852,6 @@ public static VolumeFlow FromAcreFeetPerSecond(QuantityValue acrefeetpersecond) double value = (double) acrefeetpersecond; return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerSecond); } - /// /// Creates a from . /// @@ -865,7 +861,6 @@ public static VolumeFlow FromCentilitersPerDay(QuantityValue centilitersperday) double value = (double) centilitersperday; return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerDay); } - /// /// Creates a from . /// @@ -875,7 +870,6 @@ public static VolumeFlow FromCentilitersPerHour(QuantityValue centilitersperhour double value = (double) centilitersperhour; return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerHour); } - /// /// Creates a from . /// @@ -885,7 +879,6 @@ public static VolumeFlow FromCentilitersPerMinute(QuantityValue centiliterspermi double value = (double) centilitersperminute; return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerMinute); } - /// /// Creates a from . /// @@ -895,7 +888,6 @@ public static VolumeFlow FromCentilitersPerSecond(QuantityValue centilitersperse double value = (double) centiliterspersecond; return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerSecond); } - /// /// Creates a from . /// @@ -905,7 +897,6 @@ public static VolumeFlow FromCubicCentimetersPerMinute(QuantityValue cubiccentim double value = (double) cubiccentimetersperminute; return new VolumeFlow(value, VolumeFlowUnit.CubicCentimeterPerMinute); } - /// /// Creates a from . /// @@ -915,7 +906,6 @@ public static VolumeFlow FromCubicDecimetersPerMinute(QuantityValue cubicdecimet double value = (double) cubicdecimetersperminute; return new VolumeFlow(value, VolumeFlowUnit.CubicDecimeterPerMinute); } - /// /// Creates a from . /// @@ -925,7 +915,6 @@ public static VolumeFlow FromCubicFeetPerHour(QuantityValue cubicfeetperhour) double value = (double) cubicfeetperhour; return new VolumeFlow(value, VolumeFlowUnit.CubicFootPerHour); } - /// /// Creates a from . /// @@ -935,7 +924,6 @@ public static VolumeFlow FromCubicFeetPerMinute(QuantityValue cubicfeetperminute double value = (double) cubicfeetperminute; return new VolumeFlow(value, VolumeFlowUnit.CubicFootPerMinute); } - /// /// Creates a from . /// @@ -945,7 +933,6 @@ public static VolumeFlow FromCubicFeetPerSecond(QuantityValue cubicfeetpersecond double value = (double) cubicfeetpersecond; return new VolumeFlow(value, VolumeFlowUnit.CubicFootPerSecond); } - /// /// Creates a from . /// @@ -955,7 +942,6 @@ public static VolumeFlow FromCubicMetersPerDay(QuantityValue cubicmetersperday) double value = (double) cubicmetersperday; return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerDay); } - /// /// Creates a from . /// @@ -965,7 +951,6 @@ public static VolumeFlow FromCubicMetersPerHour(QuantityValue cubicmetersperhour double value = (double) cubicmetersperhour; return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerHour); } - /// /// Creates a from . /// @@ -975,7 +960,6 @@ public static VolumeFlow FromCubicMetersPerMinute(QuantityValue cubicmeterspermi double value = (double) cubicmetersperminute; return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerMinute); } - /// /// Creates a from . /// @@ -985,7 +969,6 @@ public static VolumeFlow FromCubicMetersPerSecond(QuantityValue cubicmetersperse double value = (double) cubicmeterspersecond; return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerSecond); } - /// /// Creates a from . /// @@ -995,7 +978,6 @@ public static VolumeFlow FromCubicMillimetersPerSecond(QuantityValue cubicmillim double value = (double) cubicmillimeterspersecond; return new VolumeFlow(value, VolumeFlowUnit.CubicMillimeterPerSecond); } - /// /// Creates a from . /// @@ -1005,7 +987,6 @@ public static VolumeFlow FromCubicYardsPerDay(QuantityValue cubicyardsperday) double value = (double) cubicyardsperday; return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerDay); } - /// /// Creates a from . /// @@ -1015,7 +996,6 @@ public static VolumeFlow FromCubicYardsPerHour(QuantityValue cubicyardsperhour) double value = (double) cubicyardsperhour; return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerHour); } - /// /// Creates a from . /// @@ -1025,7 +1005,6 @@ public static VolumeFlow FromCubicYardsPerMinute(QuantityValue cubicyardsperminu double value = (double) cubicyardsperminute; return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerMinute); } - /// /// Creates a from . /// @@ -1035,7 +1014,6 @@ public static VolumeFlow FromCubicYardsPerSecond(QuantityValue cubicyardsperseco double value = (double) cubicyardspersecond; return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerSecond); } - /// /// Creates a from . /// @@ -1045,7 +1023,6 @@ public static VolumeFlow FromDecilitersPerDay(QuantityValue decilitersperday) double value = (double) decilitersperday; return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerDay); } - /// /// Creates a from . /// @@ -1055,7 +1032,6 @@ public static VolumeFlow FromDecilitersPerHour(QuantityValue decilitersperhour) double value = (double) decilitersperhour; return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerHour); } - /// /// Creates a from . /// @@ -1065,7 +1041,6 @@ public static VolumeFlow FromDecilitersPerMinute(QuantityValue decilitersperminu double value = (double) decilitersperminute; return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerMinute); } - /// /// Creates a from . /// @@ -1075,7 +1050,6 @@ public static VolumeFlow FromDecilitersPerSecond(QuantityValue decilitersperseco double value = (double) deciliterspersecond; return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerSecond); } - /// /// Creates a from . /// @@ -1085,7 +1059,6 @@ public static VolumeFlow FromKilolitersPerDay(QuantityValue kilolitersperday) double value = (double) kilolitersperday; return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerDay); } - /// /// Creates a from . /// @@ -1095,7 +1068,6 @@ public static VolumeFlow FromKilolitersPerHour(QuantityValue kilolitersperhour) double value = (double) kilolitersperhour; return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerHour); } - /// /// Creates a from . /// @@ -1105,7 +1077,6 @@ public static VolumeFlow FromKilolitersPerMinute(QuantityValue kilolitersperminu double value = (double) kilolitersperminute; return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerMinute); } - /// /// Creates a from . /// @@ -1115,7 +1086,6 @@ public static VolumeFlow FromKilolitersPerSecond(QuantityValue kilolitersperseco double value = (double) kiloliterspersecond; return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerSecond); } - /// /// Creates a from . /// @@ -1125,7 +1095,6 @@ public static VolumeFlow FromKilousGallonsPerMinute(QuantityValue kilousgallonsp double value = (double) kilousgallonsperminute; return new VolumeFlow(value, VolumeFlowUnit.KilousGallonPerMinute); } - /// /// Creates a from . /// @@ -1135,7 +1104,6 @@ public static VolumeFlow FromLitersPerDay(QuantityValue litersperday) double value = (double) litersperday; return new VolumeFlow(value, VolumeFlowUnit.LiterPerDay); } - /// /// Creates a from . /// @@ -1145,7 +1113,6 @@ public static VolumeFlow FromLitersPerHour(QuantityValue litersperhour) double value = (double) litersperhour; return new VolumeFlow(value, VolumeFlowUnit.LiterPerHour); } - /// /// Creates a from . /// @@ -1155,7 +1122,6 @@ public static VolumeFlow FromLitersPerMinute(QuantityValue litersperminute) double value = (double) litersperminute; return new VolumeFlow(value, VolumeFlowUnit.LiterPerMinute); } - /// /// Creates a from . /// @@ -1165,7 +1131,6 @@ public static VolumeFlow FromLitersPerSecond(QuantityValue literspersecond) double value = (double) literspersecond; return new VolumeFlow(value, VolumeFlowUnit.LiterPerSecond); } - /// /// Creates a from . /// @@ -1175,7 +1140,6 @@ public static VolumeFlow FromMegalitersPerDay(QuantityValue megalitersperday) double value = (double) megalitersperday; return new VolumeFlow(value, VolumeFlowUnit.MegaliterPerDay); } - /// /// Creates a from . /// @@ -1185,7 +1149,6 @@ public static VolumeFlow FromMegaukGallonsPerSecond(QuantityValue megaukgallonsp double value = (double) megaukgallonspersecond; return new VolumeFlow(value, VolumeFlowUnit.MegaukGallonPerSecond); } - /// /// Creates a from . /// @@ -1195,7 +1158,6 @@ public static VolumeFlow FromMicrolitersPerDay(QuantityValue microlitersperday) double value = (double) microlitersperday; return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerDay); } - /// /// Creates a from . /// @@ -1205,7 +1167,6 @@ public static VolumeFlow FromMicrolitersPerHour(QuantityValue microlitersperhour double value = (double) microlitersperhour; return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerHour); } - /// /// Creates a from . /// @@ -1215,7 +1176,6 @@ public static VolumeFlow FromMicrolitersPerMinute(QuantityValue microliterspermi double value = (double) microlitersperminute; return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerMinute); } - /// /// Creates a from . /// @@ -1225,7 +1185,6 @@ public static VolumeFlow FromMicrolitersPerSecond(QuantityValue microlitersperse double value = (double) microliterspersecond; return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerSecond); } - /// /// Creates a from . /// @@ -1235,7 +1194,6 @@ public static VolumeFlow FromMillilitersPerDay(QuantityValue millilitersperday) double value = (double) millilitersperday; return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerDay); } - /// /// Creates a from . /// @@ -1245,7 +1203,6 @@ public static VolumeFlow FromMillilitersPerHour(QuantityValue millilitersperhour double value = (double) millilitersperhour; return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerHour); } - /// /// Creates a from . /// @@ -1255,7 +1212,6 @@ public static VolumeFlow FromMillilitersPerMinute(QuantityValue milliliterspermi double value = (double) millilitersperminute; return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerMinute); } - /// /// Creates a from . /// @@ -1265,7 +1221,6 @@ public static VolumeFlow FromMillilitersPerSecond(QuantityValue millilitersperse double value = (double) milliliterspersecond; return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerSecond); } - /// /// Creates a from . /// @@ -1275,7 +1230,6 @@ public static VolumeFlow FromMillionUsGallonsPerDay(QuantityValue millionusgallo double value = (double) millionusgallonsperday; return new VolumeFlow(value, VolumeFlowUnit.MillionUsGallonsPerDay); } - /// /// Creates a from . /// @@ -1285,7 +1239,6 @@ public static VolumeFlow FromNanolitersPerDay(QuantityValue nanolitersperday) double value = (double) nanolitersperday; return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerDay); } - /// /// Creates a from . /// @@ -1295,7 +1248,6 @@ public static VolumeFlow FromNanolitersPerHour(QuantityValue nanolitersperhour) double value = (double) nanolitersperhour; return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerHour); } - /// /// Creates a from . /// @@ -1305,7 +1257,6 @@ public static VolumeFlow FromNanolitersPerMinute(QuantityValue nanolitersperminu double value = (double) nanolitersperminute; return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerMinute); } - /// /// Creates a from . /// @@ -1315,7 +1266,6 @@ public static VolumeFlow FromNanolitersPerSecond(QuantityValue nanolitersperseco double value = (double) nanoliterspersecond; return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerSecond); } - /// /// Creates a from . /// @@ -1325,7 +1275,6 @@ public static VolumeFlow FromOilBarrelsPerDay(QuantityValue oilbarrelsperday) double value = (double) oilbarrelsperday; return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerDay); } - /// /// Creates a from . /// @@ -1335,7 +1284,6 @@ public static VolumeFlow FromOilBarrelsPerHour(QuantityValue oilbarrelsperhour) double value = (double) oilbarrelsperhour; return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerHour); } - /// /// Creates a from . /// @@ -1345,7 +1293,6 @@ public static VolumeFlow FromOilBarrelsPerMinute(QuantityValue oilbarrelsperminu double value = (double) oilbarrelsperminute; return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerMinute); } - /// /// Creates a from . /// @@ -1355,7 +1302,6 @@ public static VolumeFlow FromOilBarrelsPerSecond(QuantityValue oilbarrelsperseco double value = (double) oilbarrelspersecond; return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerSecond); } - /// /// Creates a from . /// @@ -1365,7 +1311,6 @@ public static VolumeFlow FromUkGallonsPerDay(QuantityValue ukgallonsperday) double value = (double) ukgallonsperday; return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerDay); } - /// /// Creates a from . /// @@ -1375,7 +1320,6 @@ public static VolumeFlow FromUkGallonsPerHour(QuantityValue ukgallonsperhour) double value = (double) ukgallonsperhour; return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerHour); } - /// /// Creates a from . /// @@ -1385,7 +1329,6 @@ public static VolumeFlow FromUkGallonsPerMinute(QuantityValue ukgallonsperminute double value = (double) ukgallonsperminute; return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerMinute); } - /// /// Creates a from . /// @@ -1395,7 +1338,6 @@ public static VolumeFlow FromUkGallonsPerSecond(QuantityValue ukgallonspersecond double value = (double) ukgallonspersecond; return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerSecond); } - /// /// Creates a from . /// @@ -1405,7 +1347,6 @@ public static VolumeFlow FromUsGallonsPerDay(QuantityValue usgallonsperday) double value = (double) usgallonsperday; return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerDay); } - /// /// Creates a from . /// @@ -1415,7 +1356,6 @@ public static VolumeFlow FromUsGallonsPerHour(QuantityValue usgallonsperhour) double value = (double) usgallonsperhour; return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerHour); } - /// /// Creates a from . /// @@ -1425,7 +1365,6 @@ public static VolumeFlow FromUsGallonsPerMinute(QuantityValue usgallonsperminute double value = (double) usgallonsperminute; return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerMinute); } - /// /// Creates a from . /// @@ -1436,7 +1375,6 @@ public static VolumeFlow FromUsGallonsPerSecond(QuantityValue usgallonspersecond return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerSecond); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs index da511f7fc8..5aafdb110d 100644 --- a/UnitsNet/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs @@ -258,7 +258,6 @@ public static VolumeFlowPerArea FromCubicFeetPerMinutePerSquareFoot(QuantityValu double value = (double) cubicfeetperminutepersquarefoot; return new VolumeFlowPerArea(value, VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot); } - /// /// Creates a from . /// @@ -269,7 +268,6 @@ public static VolumeFlowPerArea FromCubicMetersPerSecondPerSquareMeter(QuantityV return new VolumeFlowPerArea(value, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs index 4d6dd9bbc5..44e9c1efb1 100644 --- a/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs @@ -303,7 +303,6 @@ public static VolumePerLength FromCubicMetersPerMeter(QuantityValue cubicmetersp double value = (double) cubicmeterspermeter; return new VolumePerLength(value, VolumePerLengthUnit.CubicMeterPerMeter); } - /// /// Creates a from . /// @@ -313,7 +312,6 @@ public static VolumePerLength FromCubicYardsPerFoot(QuantityValue cubicyardsperf double value = (double) cubicyardsperfoot; return new VolumePerLength(value, VolumePerLengthUnit.CubicYardPerFoot); } - /// /// Creates a from . /// @@ -323,7 +321,6 @@ public static VolumePerLength FromCubicYardsPerUsSurveyFoot(QuantityValue cubicy double value = (double) cubicyardsperussurveyfoot; return new VolumePerLength(value, VolumePerLengthUnit.CubicYardPerUsSurveyFoot); } - /// /// Creates a from . /// @@ -333,7 +330,6 @@ public static VolumePerLength FromLitersPerKilometer(QuantityValue litersperkilo double value = (double) litersperkilometer; return new VolumePerLength(value, VolumePerLengthUnit.LiterPerKilometer); } - /// /// Creates a from . /// @@ -343,7 +339,6 @@ public static VolumePerLength FromLitersPerMeter(QuantityValue literspermeter) double value = (double) literspermeter; return new VolumePerLength(value, VolumePerLengthUnit.LiterPerMeter); } - /// /// Creates a from . /// @@ -353,7 +348,6 @@ public static VolumePerLength FromLitersPerMillimeter(QuantityValue literspermil double value = (double) literspermillimeter; return new VolumePerLength(value, VolumePerLengthUnit.LiterPerMillimeter); } - /// /// Creates a from . /// @@ -364,7 +358,6 @@ public static VolumePerLength FromOilBarrelsPerFoot(QuantityValue oilbarrelsperf return new VolumePerLength(value, VolumePerLengthUnit.OilBarrelPerFoot); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs index 26d9913411..83cf67e5fe 100644 --- a/UnitsNet/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs @@ -324,7 +324,6 @@ public static VolumetricHeatCapacity FromBtusPerCubicFootDegreeFahrenheit(Quanti double value = (double) btuspercubicfootdegreefahrenheit; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit); } - /// /// Creates a from . /// @@ -334,7 +333,6 @@ public static VolumetricHeatCapacity FromCaloriesPerCubicCentimeterDegreeCelsius double value = (double) caloriespercubiccentimeterdegreecelsius; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius); } - /// /// Creates a from . /// @@ -344,7 +342,6 @@ public static VolumetricHeatCapacity FromJoulesPerCubicMeterDegreeCelsius(Quanti double value = (double) joulespercubicmeterdegreecelsius; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius); } - /// /// Creates a from . /// @@ -354,7 +351,6 @@ public static VolumetricHeatCapacity FromJoulesPerCubicMeterKelvin(QuantityValue double value = (double) joulespercubicmeterkelvin; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin); } - /// /// Creates a from . /// @@ -364,7 +360,6 @@ public static VolumetricHeatCapacity FromKilocaloriesPerCubicCentimeterDegreeCel double value = (double) kilocaloriespercubiccentimeterdegreecelsius; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius); } - /// /// Creates a from . /// @@ -374,7 +369,6 @@ public static VolumetricHeatCapacity FromKilojoulesPerCubicMeterDegreeCelsius(Qu double value = (double) kilojoulespercubicmeterdegreecelsius; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius); } - /// /// Creates a from . /// @@ -384,7 +378,6 @@ public static VolumetricHeatCapacity FromKilojoulesPerCubicMeterKelvin(QuantityV double value = (double) kilojoulespercubicmeterkelvin; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin); } - /// /// Creates a from . /// @@ -394,7 +387,6 @@ public static VolumetricHeatCapacity FromMegajoulesPerCubicMeterDegreeCelsius(Qu double value = (double) megajoulespercubicmeterdegreecelsius; return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius); } - /// /// Creates a from . /// @@ -405,7 +397,6 @@ public static VolumetricHeatCapacity FromMegajoulesPerCubicMeterKelvin(QuantityV return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin); } - /// /// Dynamically convert from value and unit enum to . /// diff --git a/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs b/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs index 7f17cd8497..b677f3e2c5 100644 --- a/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs @@ -294,7 +294,6 @@ public static WarpingMomentOfInertia FromCentimetersToTheSixth(QuantityValue cen double value = (double) centimeterstothesixth; return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.CentimeterToTheSixth); } - /// /// Creates a from . /// @@ -304,7 +303,6 @@ public static WarpingMomentOfInertia FromDecimetersToTheSixth(QuantityValue deci double value = (double) decimeterstothesixth; return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.DecimeterToTheSixth); } - /// /// Creates a from . /// @@ -314,7 +312,6 @@ public static WarpingMomentOfInertia FromFeetToTheSixth(QuantityValue feettothes double value = (double) feettothesixth; return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.FootToTheSixth); } - /// /// Creates a from . /// @@ -324,7 +321,6 @@ public static WarpingMomentOfInertia FromInchesToTheSixth(QuantityValue inchesto double value = (double) inchestothesixth; return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.InchToTheSixth); } - /// /// Creates a from . /// @@ -334,7 +330,6 @@ public static WarpingMomentOfInertia FromMetersToTheSixth(QuantityValue metersto double value = (double) meterstothesixth; return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.MeterToTheSixth); } - /// /// Creates a from . /// @@ -345,7 +340,6 @@ public static WarpingMomentOfInertia FromMillimetersToTheSixth(QuantityValue mil return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.MillimeterToTheSixth); } - /// /// Dynamically convert from value and unit enum to . /// From 1fb9f263c655a4f135ab75d30b66ab2331cb2319 Mon Sep 17 00:00:00 2001 From: Tristan Milnthorp Date: Tue, 15 Feb 2022 17:28:29 -0500 Subject: [PATCH 4/4] Fix plural name --- Common/UnitDefinitions/Compressibility.json | 2 +- .../GeneratedCode/Quantities/Compressibility.g.cs | 4 ++-- .../NumberToCompressibilityExtensionsTest.g.cs | 4 ++-- .../NumberToCompressibilityExtensions.g.cs | 6 +++--- UnitsNet.Tests/CustomCode/CompressibilityTests.cs | 2 +- .../TestsBase/CompressibilityTestsBase.g.cs | 14 +++++++------- .../GeneratedCode/Quantities/Compressibility.g.cs | 6 +++--- .../GeneratedCode/Quantities/Compressibility.g.cs | 8 ++++---- 8 files changed, 23 insertions(+), 23 deletions(-) diff --git a/Common/UnitDefinitions/Compressibility.json b/Common/UnitDefinitions/Compressibility.json index 3b73871b64..7c22f0092f 100644 --- a/Common/UnitDefinitions/Compressibility.json +++ b/Common/UnitDefinitions/Compressibility.json @@ -87,7 +87,7 @@ }, { "SingularName": "InversePoundForcePerSquareInch", - "PluralName": "InversePoundForcePerSquareInchs", + "PluralName": "InversePoundsForcePerSquareInch", "FromUnitToBaseFunc": "{x} * 6.894757293168361e3", "FromBaseToUnitFunc": "{x} / 6.894757293168361e3", "Localization": [ diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Compressibility.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Compressibility.g.cs index 37333c57b1..e92522ef3f 100644 --- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/Compressibility.g.cs +++ b/UnitsNet.NanoFramework/GeneratedCode/Quantities/Compressibility.g.cs @@ -112,7 +112,7 @@ public Compressibility(double value, CompressibilityUnit unit) /// /// Gets a value of this quantity converted into /// - public double InversePoundForcePerSquareInchs => As(CompressibilityUnit.InversePoundForcePerSquareInch); + public double InversePoundsForcePerSquareInch => As(CompressibilityUnit.InversePoundForcePerSquareInch); #endregion @@ -158,7 +158,7 @@ public Compressibility(double value, CompressibilityUnit unit) /// Creates a from . /// /// If value is NaN or Infinity. - public static Compressibility FromInversePoundForcePerSquareInchs(double inversepoundforcepersquareinchs) => new Compressibility(inversepoundforcepersquareinchs, CompressibilityUnit.InversePoundForcePerSquareInch); + public static Compressibility FromInversePoundsForcePerSquareInch(double inversepoundsforcepersquareinch) => new Compressibility(inversepoundsforcepersquareinch, CompressibilityUnit.InversePoundForcePerSquareInch); /// /// Dynamically convert from value and unit enum to . diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToCompressibilityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToCompressibilityExtensionsTest.g.cs index a138122f2e..da846bbb69 100644 --- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToCompressibilityExtensionsTest.g.cs +++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToCompressibilityExtensionsTest.g.cs @@ -49,8 +49,8 @@ public void NumberToInversePascalsTest() => Assert.Equal(Compressibility.FromInversePascals(2), 2.InversePascals()); [Fact] - public void NumberToInversePoundForcePerSquareInchsTest() => - Assert.Equal(Compressibility.FromInversePoundForcePerSquareInchs(2), 2.InversePoundForcePerSquareInchs()); + public void NumberToInversePoundsForcePerSquareInchTest() => + Assert.Equal(Compressibility.FromInversePoundsForcePerSquareInch(2), 2.InversePoundsForcePerSquareInch()); } } diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToCompressibilityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToCompressibilityExtensions.g.cs index 815908538e..40f8b04061 100644 --- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToCompressibilityExtensions.g.cs +++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToCompressibilityExtensions.g.cs @@ -52,9 +52,9 @@ public static Compressibility InverseMillibars(this T value) => public static Compressibility InversePascals(this T value) => Compressibility.FromInversePascals(Convert.ToDouble(value)); - /// - public static Compressibility InversePoundForcePerSquareInchs(this T value) => - Compressibility.FromInversePoundForcePerSquareInchs(Convert.ToDouble(value)); + /// + public static Compressibility InversePoundsForcePerSquareInch(this T value) => + Compressibility.FromInversePoundsForcePerSquareInch(Convert.ToDouble(value)); } } diff --git a/UnitsNet.Tests/CustomCode/CompressibilityTests.cs b/UnitsNet.Tests/CustomCode/CompressibilityTests.cs index 9f7793f4a3..689efed670 100644 --- a/UnitsNet.Tests/CustomCode/CompressibilityTests.cs +++ b/UnitsNet.Tests/CustomCode/CompressibilityTests.cs @@ -30,7 +30,7 @@ public class CompressibilityTests : CompressibilityTestsBase protected override double InverseKilopascalsInOneInversePascal => 1e-3; protected override double InverseMegapascalsInOneInversePascal => 1e-6; protected override double InverseBarsInOneInversePascal => 1e-5; - protected override double InversePoundForcePerSquareInchsInOneInversePascal => 1.450377377302092151542e-4; + protected override double InversePoundsForcePerSquareInchInOneInversePascal => 1.450377377302092151542e-4; protected override double InverseAtmospheresInOneInversePascal => 9.86923266716013e-6; protected override bool SupportsSIUnitSystem => true; diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/CompressibilityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/CompressibilityTestsBase.g.cs index 9e09af0b19..d707793ecc 100644 --- a/UnitsNet.Tests/GeneratedCode/TestsBase/CompressibilityTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/CompressibilityTestsBase.g.cs @@ -44,7 +44,7 @@ public abstract partial class CompressibilityTestsBase : QuantityTestsBase protected abstract double InverseMegapascalsInOneInversePascal { get; } protected abstract double InverseMillibarsInOneInversePascal { get; } protected abstract double InversePascalsInOneInversePascal { get; } - protected abstract double InversePoundForcePerSquareInchsInOneInversePascal { get; } + protected abstract double InversePoundsForcePerSquareInchInOneInversePascal { get; } // ReSharper disable VirtualMemberNeverOverriden.Global protected virtual double InverseAtmospheresTolerance { get { return 1e-5; } } @@ -53,7 +53,7 @@ public abstract partial class CompressibilityTestsBase : QuantityTestsBase protected virtual double InverseMegapascalsTolerance { get { return 1e-5; } } protected virtual double InverseMillibarsTolerance { get { return 1e-5; } } protected virtual double InversePascalsTolerance { get { return 1e-5; } } - protected virtual double InversePoundForcePerSquareInchsTolerance { get { return 1e-5; } } + protected virtual double InversePoundsForcePerSquareInchTolerance { get { return 1e-5; } } // ReSharper restore VirtualMemberNeverOverriden.Global protected (double UnitsInBaseUnit, double Tolerence) GetConversionFactor(CompressibilityUnit unit) @@ -66,7 +66,7 @@ public abstract partial class CompressibilityTestsBase : QuantityTestsBase CompressibilityUnit.InverseMegapascal => (InverseMegapascalsInOneInversePascal, InverseMegapascalsTolerance), CompressibilityUnit.InverseMillibar => (InverseMillibarsInOneInversePascal, InverseMillibarsTolerance), CompressibilityUnit.InversePascal => (InversePascalsInOneInversePascal, InversePascalsTolerance), - CompressibilityUnit.InversePoundForcePerSquareInch => (InversePoundForcePerSquareInchsInOneInversePascal, InversePoundForcePerSquareInchsTolerance), + CompressibilityUnit.InversePoundForcePerSquareInch => (InversePoundsForcePerSquareInchInOneInversePascal, InversePoundsForcePerSquareInchTolerance), _ => throw new NotSupportedException() }; } @@ -160,7 +160,7 @@ public void InversePascalToCompressibilityUnits() AssertEx.EqualTolerance(InverseMegapascalsInOneInversePascal, inversepascal.InverseMegapascals, InverseMegapascalsTolerance); AssertEx.EqualTolerance(InverseMillibarsInOneInversePascal, inversepascal.InverseMillibars, InverseMillibarsTolerance); AssertEx.EqualTolerance(InversePascalsInOneInversePascal, inversepascal.InversePascals, InversePascalsTolerance); - AssertEx.EqualTolerance(InversePoundForcePerSquareInchsInOneInversePascal, inversepascal.InversePoundForcePerSquareInchs, InversePoundForcePerSquareInchsTolerance); + AssertEx.EqualTolerance(InversePoundsForcePerSquareInchInOneInversePascal, inversepascal.InversePoundsForcePerSquareInch, InversePoundsForcePerSquareInchTolerance); } [Fact] @@ -191,7 +191,7 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() Assert.Equal(CompressibilityUnit.InversePascal, quantity05.Unit); var quantity06 = Compressibility.From(1, CompressibilityUnit.InversePoundForcePerSquareInch); - AssertEx.EqualTolerance(1, quantity06.InversePoundForcePerSquareInchs, InversePoundForcePerSquareInchsTolerance); + AssertEx.EqualTolerance(1, quantity06.InversePoundsForcePerSquareInch, InversePoundsForcePerSquareInchTolerance); Assert.Equal(CompressibilityUnit.InversePoundForcePerSquareInch, quantity06.Unit); } @@ -219,7 +219,7 @@ public void As() AssertEx.EqualTolerance(InverseMegapascalsInOneInversePascal, inversepascal.As(CompressibilityUnit.InverseMegapascal), InverseMegapascalsTolerance); AssertEx.EqualTolerance(InverseMillibarsInOneInversePascal, inversepascal.As(CompressibilityUnit.InverseMillibar), InverseMillibarsTolerance); AssertEx.EqualTolerance(InversePascalsInOneInversePascal, inversepascal.As(CompressibilityUnit.InversePascal), InversePascalsTolerance); - AssertEx.EqualTolerance(InversePoundForcePerSquareInchsInOneInversePascal, inversepascal.As(CompressibilityUnit.InversePoundForcePerSquareInch), InversePoundForcePerSquareInchsTolerance); + AssertEx.EqualTolerance(InversePoundsForcePerSquareInchInOneInversePascal, inversepascal.As(CompressibilityUnit.InversePoundForcePerSquareInch), InversePoundsForcePerSquareInchTolerance); } [Fact] @@ -286,7 +286,7 @@ public void ConversionRoundTrip() AssertEx.EqualTolerance(1, Compressibility.FromInverseMegapascals(inversepascal.InverseMegapascals).InversePascals, InverseMegapascalsTolerance); AssertEx.EqualTolerance(1, Compressibility.FromInverseMillibars(inversepascal.InverseMillibars).InversePascals, InverseMillibarsTolerance); AssertEx.EqualTolerance(1, Compressibility.FromInversePascals(inversepascal.InversePascals).InversePascals, InversePascalsTolerance); - AssertEx.EqualTolerance(1, Compressibility.FromInversePoundForcePerSquareInchs(inversepascal.InversePoundForcePerSquareInchs).InversePascals, InversePoundForcePerSquareInchsTolerance); + AssertEx.EqualTolerance(1, Compressibility.FromInversePoundsForcePerSquareInch(inversepascal.InversePoundsForcePerSquareInch).InversePascals, InversePoundsForcePerSquareInchTolerance); } [Fact] diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Compressibility.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Compressibility.g.cs index bbf99b2c1a..6362bd4a39 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Compressibility.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Compressibility.g.cs @@ -196,7 +196,7 @@ private Compressibility(double value, CompressibilityUnit unit) /// /// Gets a value of this quantity converted into /// - public double InversePoundForcePerSquareInchs => As(CompressibilityUnit.InversePoundForcePerSquareInch); + public double InversePoundsForcePerSquareInch => As(CompressibilityUnit.InversePoundForcePerSquareInch); #endregion @@ -310,9 +310,9 @@ public static Compressibility FromInversePascals(double inversepascals) /// /// If value is NaN or Infinity. [Windows.Foundation.Metadata.DefaultOverload] - public static Compressibility FromInversePoundForcePerSquareInchs(double inversepoundforcepersquareinchs) + public static Compressibility FromInversePoundsForcePerSquareInch(double inversepoundsforcepersquareinch) { - double value = (double) inversepoundforcepersquareinchs; + double value = (double) inversepoundsforcepersquareinch; return new Compressibility(value, CompressibilityUnit.InversePoundForcePerSquareInch); } diff --git a/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs b/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs index 6295ad30f0..681bf11347 100644 --- a/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs @@ -68,7 +68,7 @@ static Compressibility() new UnitInfo(CompressibilityUnit.InverseMegapascal, "InverseMegapascals", BaseUnits.Undefined), new UnitInfo(CompressibilityUnit.InverseMillibar, "InverseMillibars", BaseUnits.Undefined), new UnitInfo(CompressibilityUnit.InversePascal, "InversePascals", new BaseUnits(length: LengthUnit.Meter, mass: MassUnit.Kilogram, time: DurationUnit.Second)), - new UnitInfo(CompressibilityUnit.InversePoundForcePerSquareInch, "InversePoundForcePerSquareInchs", BaseUnits.Undefined), + new UnitInfo(CompressibilityUnit.InversePoundForcePerSquareInch, "InversePoundsForcePerSquareInch", BaseUnits.Undefined), }, BaseUnit, Zero, BaseDimensions, QuantityType.Compressibility); @@ -226,7 +226,7 @@ public Compressibility(double value, UnitSystem unitSystem) /// /// Gets a value of this quantity converted into /// - public double InversePoundForcePerSquareInchs => As(CompressibilityUnit.InversePoundForcePerSquareInch); + public double InversePoundsForcePerSquareInch => As(CompressibilityUnit.InversePoundForcePerSquareInch); #endregion @@ -358,9 +358,9 @@ public static Compressibility FromInversePascals(QuantityValue inversepascals) /// Creates a from . /// /// If value is NaN or Infinity. - public static Compressibility FromInversePoundForcePerSquareInchs(QuantityValue inversepoundforcepersquareinchs) + public static Compressibility FromInversePoundsForcePerSquareInch(QuantityValue inversepoundsforcepersquareinch) { - double value = (double) inversepoundforcepersquareinchs; + double value = (double) inversepoundsforcepersquareinch; return new Compressibility(value, CompressibilityUnit.InversePoundForcePerSquareInch); }