diff --git a/Build/build-functions.psm1 b/Build/build-functions.psm1 index 8cd4235052..66bd3e1c4d 100644 --- a/Build/build-functions.psm1 +++ b/Build/build-functions.psm1 @@ -90,6 +90,7 @@ function Start-Tests { $projectPaths = @( "UnitsNet.Tests\UnitsNet.Tests.csproj", "UnitsNet.NumberExtensions.Tests\UnitsNet.NumberExtensions.Tests.csproj", + "UnitsNet.NumberExtensions.CS14.Tests\UnitsNet.NumberExtensions.CS14.Tests.csproj", "UnitsNet.Serialization.JsonNet.Tests\UnitsNet.Serialization.JsonNet.Tests.csproj" ) @@ -129,7 +130,8 @@ function Start-PackNugets { $projectPaths = @( "UnitsNet\UnitsNet.csproj", "UnitsNet.Serialization.JsonNet\UnitsNet.Serialization.JsonNet.csproj", - "UnitsNet.NumberExtensions\UnitsNet.NumberExtensions.csproj" + "UnitsNet.NumberExtensions\UnitsNet.NumberExtensions.csproj", + "UnitsNet.NumberExtensions.CS14\UnitsNet.NumberExtensions.CS14.csproj" ) write-host -foreground blue "Pack nugets (dotnet CLI)...`n---" diff --git a/CodeGen/Generators/UnitsNetGen/NumberExtensionsCS14Generator.cs b/CodeGen/Generators/UnitsNetGen/NumberExtensionsCS14Generator.cs new file mode 100644 index 0000000000..f815158c3a --- /dev/null +++ b/CodeGen/Generators/UnitsNetGen/NumberExtensionsCS14Generator.cs @@ -0,0 +1,82 @@ +using System; +using CodeGen.JsonTypes; + +namespace CodeGen.Generators.UnitsNetGen +{ + internal class NumberExtensionsCS14Generator(Quantity quantity) : GeneratorBase + { + private readonly Quantity _quantity = quantity ?? throw new ArgumentNullException(nameof(quantity)); + private readonly Unit[] _units = quantity.Units; + private readonly string _quantityName = quantity.Name; + + public string Generate() + { + Writer.WL(GeneratedFileHeader); + + Writer.WL( + $@" +using System; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberTo{_quantityName} +{{ + /// + /// A number to {_quantityName} Extensions + /// "); + + Writer.WLIfText(1, GetObsoleteAttributeOrNull(_quantity)); + Writer.WL(@$" + public static class NumberTo{_quantityName}Extensions + {{"); + + Writer.WL(@" +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + {"); + + + foreach (var unit in _units) + { + if (unit.SkipConversionGeneration) + continue; + + Writer.WL(3, $@" +/// "); + + // Include obsolete text from the quantity per extension method, to make it visible when the class is not explicitly referenced in code. + Writer.WLIfText(3, GetObsoleteAttributeOrNull(unit.ObsoleteText ?? _quantity.ObsoleteText)); + + Writer.WL(3, $@"public {_quantityName} {unit.PluralName} +#if NET7_0_OR_GREATER + => {_quantityName}.From{unit.PluralName}(double.CreateChecked(value)); +#else + => {_quantityName}.From{unit.PluralName}(value.ToDouble(null)); +#endif +"); + } + + Writer.WL(2, @"} + } +}"); + return Writer.ToString(); + } + + /// + private static string? GetObsoleteAttributeOrNull(Quantity quantity) => GetObsoleteAttributeOrNull(quantity.ObsoleteText); + + private static string? GetObsoleteAttributeOrNull(string? obsoleteText) => + string.IsNullOrWhiteSpace(obsoleteText) ? null : $"[Obsolete(\"{obsoleteText}\")]"; + } +} diff --git a/CodeGen/Generators/UnitsNetGen/NumberExtensionsCS14TestClassGenerator.cs b/CodeGen/Generators/UnitsNetGen/NumberExtensionsCS14TestClassGenerator.cs new file mode 100644 index 0000000000..d3573fcaf5 --- /dev/null +++ b/CodeGen/Generators/UnitsNetGen/NumberExtensionsCS14TestClassGenerator.cs @@ -0,0 +1,51 @@ +using System; +using CodeGen.JsonTypes; + +namespace CodeGen.Generators.UnitsNetGen +{ + internal class NumberExtensionsCS14TestClassGenerator : GeneratorBase + { + private readonly Unit[] _units; + private readonly string _quantityName; + + public NumberExtensionsCS14TestClassGenerator(Quantity quantity) + { + if (quantity is null) throw new ArgumentNullException(nameof(quantity)); + + _units = quantity.Units; + _quantityName = quantity.Name; + } + + public string Generate() + { + Writer.WL(GeneratedFileHeader); + + Writer.WL( +$@" +using UnitsNet.NumberExtensions.NumberTo{_quantityName}; +using Xunit; + +namespace UnitsNet.Tests +{{ + public class NumberTo{_quantityName}ExtensionsTests + {{"); + + foreach (var unit in _units) + { + if (unit.SkipConversionGeneration) + continue; + + Writer.WL(2, $@" +[Fact]"); + + Writer.WL(2, $@"public void NumberTo{unit.PluralName}Test() => + Assert.Equal({_quantityName}.From{unit.PluralName}(2), 2.{unit.PluralName}); +"); + } + + Writer.WL(1, @"} +}"); + return Writer.ToString(); + } + } +} diff --git a/CodeGen/Generators/UnitsNetGenerator.cs b/CodeGen/Generators/UnitsNetGenerator.cs index 907f70e4a6..7b69071029 100644 --- a/CodeGen/Generators/UnitsNetGenerator.cs +++ b/CodeGen/Generators/UnitsNetGenerator.cs @@ -39,6 +39,8 @@ public static void Generate(string rootDir, Quantity[] quantities, QuantityNameT var outputDir = $"{rootDir}/UnitsNet/GeneratedCode"; var extensionsOutputDir = $"{rootDir}/UnitsNet.NumberExtensions/GeneratedCode"; var extensionsTestOutputDir = $"{rootDir}/UnitsNet.NumberExtensions.Tests/GeneratedCode"; + var extensionsCs14OutputDir = $"{rootDir}/UnitsNet.NumberExtensions.CS14/GeneratedCode"; + var extensionsCs14TestOutputDir = $"{rootDir}/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode"; var testProjectDir = $"{rootDir}/UnitsNet.Tests"; // Ensure output directories exist @@ -46,6 +48,8 @@ public static void Generate(string rootDir, Quantity[] quantities, QuantityNameT Directory.CreateDirectory($"{outputDir}/Units"); Directory.CreateDirectory($"{extensionsOutputDir}"); Directory.CreateDirectory($"{extensionsTestOutputDir}"); + Directory.CreateDirectory($"{extensionsCs14OutputDir}"); + Directory.CreateDirectory($"{extensionsCs14TestOutputDir}"); Directory.CreateDirectory($"{testProjectDir}/GeneratedCode"); Directory.CreateDirectory($"{testProjectDir}/GeneratedCode/TestsBase"); Directory.CreateDirectory($"{testProjectDir}/GeneratedCode/QuantityTests"); @@ -58,6 +62,8 @@ public static void Generate(string rootDir, Quantity[] quantities, QuantityNameT GenerateUnitType(quantity, $"{outputDir}/Units/{quantity.Name}Unit.g.cs", unitEnumValues); GenerateNumberToExtensions(quantity, $"{extensionsOutputDir}/NumberTo{quantity.Name}Extensions.g.cs"); GenerateNumberToExtensionsTestClass(quantity, $"{extensionsTestOutputDir}/NumberTo{quantity.Name}ExtensionsTest.g.cs"); + GenerateNumberToExtensionsCS14(quantity, $"{extensionsCs14OutputDir}/NumberTo{quantity.Name}Extensions.g.cs"); + GenerateNumberToExtensionsCS14TestClass(quantity, $"{extensionsCs14TestOutputDir}/NumberTo{quantity.Name}ExtensionsTest.g.cs"); // Example: CustomCode/Quantities/LengthTests inherits GeneratedCode/TestsBase/LengthTestsBase // This way when new units are added to the quantity JSON definition, we auto-generate the new @@ -107,6 +113,18 @@ private static void GenerateNumberToExtensionsTestClass(Quantity quantity, strin File.WriteAllText(filePath, content); } + private static void GenerateNumberToExtensionsCS14(Quantity quantity, string filePath) + { + var content = new NumberExtensionsCS14Generator(quantity).Generate(); + File.WriteAllText(filePath, content); + } + + private static void GenerateNumberToExtensionsCS14TestClass(Quantity quantity, string filePath) + { + var content = new NumberExtensionsCS14TestClassGenerator(quantity).Generate(); + File.WriteAllText(filePath, content); + } + private static void GenerateUnitType(Quantity quantity, string filePath, UnitEnumNameToValue unitEnumValues) { var content = new UnitTypeGenerator(quantity, unitEnumValues).Generate(); diff --git a/README.md b/README.md index 9a6096d0c9..ac67a2a75e 100644 --- a/README.md +++ b/README.md @@ -45,11 +45,49 @@ dotnet add package UnitsNet or go to [NuGet Gallery | UnitsNet](https://www.nuget.org/packages/UnitsNet) for detailed instructions. -#### Build Targets +### Build Targets * .NET Standard 2.0 +* .NET 8.0 (LTS) +* .NET 9.0 (latest stable) +* .NET 10.0 (preview) * [.NET nanoFramework](https://www.nanoframework.net/) + +### Extension Packages + +#### UnitsNet.NumberExtensions.CS14 (C# 14 Extension Members) + +For C# 14 projects, use the new extension members syntax (no parentheses): + +```bash +dotnet add package UnitsNet.NumberExtensions.CS14 +``` + +```C# +using UnitsNet.NumberExtensions.NumberToLength; + +// C# 14 extension members syntax, without parantheses +Length distance = 5.Meters; // Instead of Length.FromMeters(5) +``` + +> **Note:** Requires 'preview' and .NET 10 SDK preview for now. + +#### UnitsNet.NumberExtensions (Classic) + +For C# 13 and lower (.NET SDK 9 or lower), use the classic extension methods: + +```bash +dotnet add package UnitsNet.NumberExtensions +``` + +```C# +using UnitsNet.NumberExtensions.NumberToLength; + +// Classic extension methods, with parentheses +Length distance = 5.Meters(); // Instead of Length.FromMeters(5) +``` + ### Static Typing ```C# diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAbsorbedDoseOfIonizingRadiationExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAbsorbedDoseOfIonizingRadiationExtensionsTest.g.cs new file mode 100644 index 0000000000..f7b16795da --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAbsorbedDoseOfIonizingRadiationExtensionsTest.g.cs @@ -0,0 +1,96 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToAbsorbedDoseOfIonizingRadiation; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToAbsorbedDoseOfIonizingRadiationExtensionsTests + { + [Fact] + public void NumberToCentigraysTest() => + Assert.Equal(AbsorbedDoseOfIonizingRadiation.FromCentigrays(2), 2.Centigrays); + + [Fact] + public void NumberToDecigraysTest() => + Assert.Equal(AbsorbedDoseOfIonizingRadiation.FromDecigrays(2), 2.Decigrays); + + [Fact] + public void NumberToFemtograysTest() => + Assert.Equal(AbsorbedDoseOfIonizingRadiation.FromFemtograys(2), 2.Femtograys); + + [Fact] + public void NumberToGigagraysTest() => + Assert.Equal(AbsorbedDoseOfIonizingRadiation.FromGigagrays(2), 2.Gigagrays); + + [Fact] + public void NumberToGraysTest() => + Assert.Equal(AbsorbedDoseOfIonizingRadiation.FromGrays(2), 2.Grays); + + [Fact] + public void NumberToKilograysTest() => + Assert.Equal(AbsorbedDoseOfIonizingRadiation.FromKilograys(2), 2.Kilograys); + + [Fact] + public void NumberToKiloradsTest() => + Assert.Equal(AbsorbedDoseOfIonizingRadiation.FromKilorads(2), 2.Kilorads); + + [Fact] + public void NumberToMegagraysTest() => + Assert.Equal(AbsorbedDoseOfIonizingRadiation.FromMegagrays(2), 2.Megagrays); + + [Fact] + public void NumberToMegaradsTest() => + Assert.Equal(AbsorbedDoseOfIonizingRadiation.FromMegarads(2), 2.Megarads); + + [Fact] + public void NumberToMicrograysTest() => + Assert.Equal(AbsorbedDoseOfIonizingRadiation.FromMicrograys(2), 2.Micrograys); + + [Fact] + public void NumberToMilligraysTest() => + Assert.Equal(AbsorbedDoseOfIonizingRadiation.FromMilligrays(2), 2.Milligrays); + + [Fact] + public void NumberToMilliradsTest() => + Assert.Equal(AbsorbedDoseOfIonizingRadiation.FromMillirads(2), 2.Millirads); + + [Fact] + public void NumberToNanograysTest() => + Assert.Equal(AbsorbedDoseOfIonizingRadiation.FromNanograys(2), 2.Nanograys); + + [Fact] + public void NumberToPetagraysTest() => + Assert.Equal(AbsorbedDoseOfIonizingRadiation.FromPetagrays(2), 2.Petagrays); + + [Fact] + public void NumberToPicograysTest() => + Assert.Equal(AbsorbedDoseOfIonizingRadiation.FromPicograys(2), 2.Picograys); + + [Fact] + public void NumberToRadsTest() => + Assert.Equal(AbsorbedDoseOfIonizingRadiation.FromRads(2), 2.Rads); + + [Fact] + public void NumberToTeragraysTest() => + Assert.Equal(AbsorbedDoseOfIonizingRadiation.FromTeragrays(2), 2.Teragrays); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAccelerationExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAccelerationExtensionsTest.g.cs new file mode 100644 index 0000000000..912d8082c1 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAccelerationExtensionsTest.g.cs @@ -0,0 +1,84 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToAcceleration; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToAccelerationExtensionsTests + { + [Fact] + public void NumberToCentimetersPerSecondSquaredTest() => + Assert.Equal(Acceleration.FromCentimetersPerSecondSquared(2), 2.CentimetersPerSecondSquared); + + [Fact] + public void NumberToDecimetersPerSecondSquaredTest() => + Assert.Equal(Acceleration.FromDecimetersPerSecondSquared(2), 2.DecimetersPerSecondSquared); + + [Fact] + public void NumberToFeetPerSecondSquaredTest() => + Assert.Equal(Acceleration.FromFeetPerSecondSquared(2), 2.FeetPerSecondSquared); + + [Fact] + public void NumberToInchesPerSecondSquaredTest() => + Assert.Equal(Acceleration.FromInchesPerSecondSquared(2), 2.InchesPerSecondSquared); + + [Fact] + public void NumberToKilometersPerSecondSquaredTest() => + Assert.Equal(Acceleration.FromKilometersPerSecondSquared(2), 2.KilometersPerSecondSquared); + + [Fact] + public void NumberToKnotsPerHourTest() => + Assert.Equal(Acceleration.FromKnotsPerHour(2), 2.KnotsPerHour); + + [Fact] + public void NumberToKnotsPerMinuteTest() => + Assert.Equal(Acceleration.FromKnotsPerMinute(2), 2.KnotsPerMinute); + + [Fact] + public void NumberToKnotsPerSecondTest() => + Assert.Equal(Acceleration.FromKnotsPerSecond(2), 2.KnotsPerSecond); + + [Fact] + public void NumberToMetersPerSecondSquaredTest() => + Assert.Equal(Acceleration.FromMetersPerSecondSquared(2), 2.MetersPerSecondSquared); + + [Fact] + public void NumberToMicrometersPerSecondSquaredTest() => + Assert.Equal(Acceleration.FromMicrometersPerSecondSquared(2), 2.MicrometersPerSecondSquared); + + [Fact] + public void NumberToMillimetersPerSecondSquaredTest() => + Assert.Equal(Acceleration.FromMillimetersPerSecondSquared(2), 2.MillimetersPerSecondSquared); + + [Fact] + public void NumberToMillistandardGravityTest() => + Assert.Equal(Acceleration.FromMillistandardGravity(2), 2.MillistandardGravity); + + [Fact] + public void NumberToNanometersPerSecondSquaredTest() => + Assert.Equal(Acceleration.FromNanometersPerSecondSquared(2), 2.NanometersPerSecondSquared); + + [Fact] + public void NumberToStandardGravityTest() => + Assert.Equal(Acceleration.FromStandardGravity(2), 2.StandardGravity); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAmountOfSubstanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAmountOfSubstanceExtensionsTest.g.cs new file mode 100644 index 0000000000..b3cb0b6c90 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAmountOfSubstanceExtensionsTest.g.cs @@ -0,0 +1,96 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToAmountOfSubstance; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToAmountOfSubstanceExtensionsTests + { + [Fact] + public void NumberToCentimolesTest() => + Assert.Equal(AmountOfSubstance.FromCentimoles(2), 2.Centimoles); + + [Fact] + public void NumberToCentipoundMolesTest() => + Assert.Equal(AmountOfSubstance.FromCentipoundMoles(2), 2.CentipoundMoles); + + [Fact] + public void NumberToDecimolesTest() => + Assert.Equal(AmountOfSubstance.FromDecimoles(2), 2.Decimoles); + + [Fact] + public void NumberToDecipoundMolesTest() => + Assert.Equal(AmountOfSubstance.FromDecipoundMoles(2), 2.DecipoundMoles); + + [Fact] + public void NumberToFemtomolesTest() => + Assert.Equal(AmountOfSubstance.FromFemtomoles(2), 2.Femtomoles); + + [Fact] + public void NumberToKilomolesTest() => + Assert.Equal(AmountOfSubstance.FromKilomoles(2), 2.Kilomoles); + + [Fact] + public void NumberToKilopoundMolesTest() => + Assert.Equal(AmountOfSubstance.FromKilopoundMoles(2), 2.KilopoundMoles); + + [Fact] + public void NumberToMegamolesTest() => + Assert.Equal(AmountOfSubstance.FromMegamoles(2), 2.Megamoles); + + [Fact] + public void NumberToMicromolesTest() => + Assert.Equal(AmountOfSubstance.FromMicromoles(2), 2.Micromoles); + + [Fact] + public void NumberToMicropoundMolesTest() => + Assert.Equal(AmountOfSubstance.FromMicropoundMoles(2), 2.MicropoundMoles); + + [Fact] + public void NumberToMillimolesTest() => + Assert.Equal(AmountOfSubstance.FromMillimoles(2), 2.Millimoles); + + [Fact] + public void NumberToMillipoundMolesTest() => + Assert.Equal(AmountOfSubstance.FromMillipoundMoles(2), 2.MillipoundMoles); + + [Fact] + public void NumberToMolesTest() => + Assert.Equal(AmountOfSubstance.FromMoles(2), 2.Moles); + + [Fact] + public void NumberToNanomolesTest() => + Assert.Equal(AmountOfSubstance.FromNanomoles(2), 2.Nanomoles); + + [Fact] + public void NumberToNanopoundMolesTest() => + Assert.Equal(AmountOfSubstance.FromNanopoundMoles(2), 2.NanopoundMoles); + + [Fact] + public void NumberToPicomolesTest() => + Assert.Equal(AmountOfSubstance.FromPicomoles(2), 2.Picomoles); + + [Fact] + public void NumberToPoundMolesTest() => + Assert.Equal(AmountOfSubstance.FromPoundMoles(2), 2.PoundMoles); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAmplitudeRatioExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAmplitudeRatioExtensionsTest.g.cs new file mode 100644 index 0000000000..5b1ad5a037 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAmplitudeRatioExtensionsTest.g.cs @@ -0,0 +1,44 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToAmplitudeRatio; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToAmplitudeRatioExtensionsTests + { + [Fact] + public void NumberToDecibelMicrovoltsTest() => + Assert.Equal(AmplitudeRatio.FromDecibelMicrovolts(2), 2.DecibelMicrovolts); + + [Fact] + public void NumberToDecibelMillivoltsTest() => + Assert.Equal(AmplitudeRatio.FromDecibelMillivolts(2), 2.DecibelMillivolts); + + [Fact] + public void NumberToDecibelsUnloadedTest() => + Assert.Equal(AmplitudeRatio.FromDecibelsUnloaded(2), 2.DecibelsUnloaded); + + [Fact] + public void NumberToDecibelVoltsTest() => + Assert.Equal(AmplitudeRatio.FromDecibelVolts(2), 2.DecibelVolts); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAngleExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAngleExtensionsTest.g.cs new file mode 100644 index 0000000000..11a35a9f15 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAngleExtensionsTest.g.cs @@ -0,0 +1,88 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToAngle; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToAngleExtensionsTests + { + [Fact] + public void NumberToArcminutesTest() => + Assert.Equal(Angle.FromArcminutes(2), 2.Arcminutes); + + [Fact] + public void NumberToArcsecondsTest() => + Assert.Equal(Angle.FromArcseconds(2), 2.Arcseconds); + + [Fact] + public void NumberToCentiradiansTest() => + Assert.Equal(Angle.FromCentiradians(2), 2.Centiradians); + + [Fact] + public void NumberToDeciradiansTest() => + Assert.Equal(Angle.FromDeciradians(2), 2.Deciradians); + + [Fact] + public void NumberToDegreesTest() => + Assert.Equal(Angle.FromDegrees(2), 2.Degrees); + + [Fact] + public void NumberToGradiansTest() => + Assert.Equal(Angle.FromGradians(2), 2.Gradians); + + [Fact] + public void NumberToMicrodegreesTest() => + Assert.Equal(Angle.FromMicrodegrees(2), 2.Microdegrees); + + [Fact] + public void NumberToMicroradiansTest() => + Assert.Equal(Angle.FromMicroradians(2), 2.Microradians); + + [Fact] + public void NumberToMillidegreesTest() => + Assert.Equal(Angle.FromMillidegrees(2), 2.Millidegrees); + + [Fact] + public void NumberToMilliradiansTest() => + Assert.Equal(Angle.FromMilliradians(2), 2.Milliradians); + + [Fact] + public void NumberToNanodegreesTest() => + Assert.Equal(Angle.FromNanodegrees(2), 2.Nanodegrees); + + [Fact] + public void NumberToNanoradiansTest() => + Assert.Equal(Angle.FromNanoradians(2), 2.Nanoradians); + + [Fact] + public void NumberToNatoMilsTest() => + Assert.Equal(Angle.FromNatoMils(2), 2.NatoMils); + + [Fact] + public void NumberToRadiansTest() => + Assert.Equal(Angle.FromRadians(2), 2.Radians); + + [Fact] + public void NumberToRevolutionsTest() => + Assert.Equal(Angle.FromRevolutions(2), 2.Revolutions); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAreaDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAreaDensityExtensionsTest.g.cs new file mode 100644 index 0000000000..5c8fb6a388 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAreaDensityExtensionsTest.g.cs @@ -0,0 +1,40 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToAreaDensity; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToAreaDensityExtensionsTests + { + [Fact] + public void NumberToGramsPerSquareMeterTest() => + Assert.Equal(AreaDensity.FromGramsPerSquareMeter(2), 2.GramsPerSquareMeter); + + [Fact] + public void NumberToKilogramsPerSquareMeterTest() => + Assert.Equal(AreaDensity.FromKilogramsPerSquareMeter(2), 2.KilogramsPerSquareMeter); + + [Fact] + public void NumberToMilligramsPerSquareMeterTest() => + Assert.Equal(AreaDensity.FromMilligramsPerSquareMeter(2), 2.MilligramsPerSquareMeter); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAreaExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAreaExtensionsTest.g.cs new file mode 100644 index 0000000000..ed650965d8 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAreaExtensionsTest.g.cs @@ -0,0 +1,84 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToArea; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToAreaExtensionsTests + { + [Fact] + public void NumberToAcresTest() => + Assert.Equal(Area.FromAcres(2), 2.Acres); + + [Fact] + public void NumberToHectaresTest() => + Assert.Equal(Area.FromHectares(2), 2.Hectares); + + [Fact] + public void NumberToSquareCentimetersTest() => + Assert.Equal(Area.FromSquareCentimeters(2), 2.SquareCentimeters); + + [Fact] + public void NumberToSquareDecimetersTest() => + Assert.Equal(Area.FromSquareDecimeters(2), 2.SquareDecimeters); + + [Fact] + public void NumberToSquareFeetTest() => + Assert.Equal(Area.FromSquareFeet(2), 2.SquareFeet); + + [Fact] + public void NumberToSquareInchesTest() => + Assert.Equal(Area.FromSquareInches(2), 2.SquareInches); + + [Fact] + public void NumberToSquareKilometersTest() => + Assert.Equal(Area.FromSquareKilometers(2), 2.SquareKilometers); + + [Fact] + public void NumberToSquareMetersTest() => + Assert.Equal(Area.FromSquareMeters(2), 2.SquareMeters); + + [Fact] + public void NumberToSquareMicrometersTest() => + Assert.Equal(Area.FromSquareMicrometers(2), 2.SquareMicrometers); + + [Fact] + public void NumberToSquareMilesTest() => + Assert.Equal(Area.FromSquareMiles(2), 2.SquareMiles); + + [Fact] + public void NumberToSquareMillimetersTest() => + Assert.Equal(Area.FromSquareMillimeters(2), 2.SquareMillimeters); + + [Fact] + public void NumberToSquareNauticalMilesTest() => + Assert.Equal(Area.FromSquareNauticalMiles(2), 2.SquareNauticalMiles); + + [Fact] + public void NumberToSquareYardsTest() => + Assert.Equal(Area.FromSquareYards(2), 2.SquareYards); + + [Fact] + public void NumberToUsSurveySquareFeetTest() => + Assert.Equal(Area.FromUsSurveySquareFeet(2), 2.UsSurveySquareFeet); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAreaMomentOfInertiaExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAreaMomentOfInertiaExtensionsTest.g.cs new file mode 100644 index 0000000000..2d3a3112e6 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToAreaMomentOfInertiaExtensionsTest.g.cs @@ -0,0 +1,52 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToAreaMomentOfInertia; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToAreaMomentOfInertiaExtensionsTests + { + [Fact] + public void NumberToCentimetersToTheFourthTest() => + Assert.Equal(AreaMomentOfInertia.FromCentimetersToTheFourth(2), 2.CentimetersToTheFourth); + + [Fact] + public void NumberToDecimetersToTheFourthTest() => + Assert.Equal(AreaMomentOfInertia.FromDecimetersToTheFourth(2), 2.DecimetersToTheFourth); + + [Fact] + public void NumberToFeetToTheFourthTest() => + Assert.Equal(AreaMomentOfInertia.FromFeetToTheFourth(2), 2.FeetToTheFourth); + + [Fact] + public void NumberToInchesToTheFourthTest() => + Assert.Equal(AreaMomentOfInertia.FromInchesToTheFourth(2), 2.InchesToTheFourth); + + [Fact] + public void NumberToMetersToTheFourthTest() => + Assert.Equal(AreaMomentOfInertia.FromMetersToTheFourth(2), 2.MetersToTheFourth); + + [Fact] + public void NumberToMillimetersToTheFourthTest() => + Assert.Equal(AreaMomentOfInertia.FromMillimetersToTheFourth(2), 2.MillimetersToTheFourth); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToBitRateExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToBitRateExtensionsTest.g.cs new file mode 100644 index 0000000000..9bd2ac71ab --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToBitRateExtensionsTest.g.cs @@ -0,0 +1,184 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToBitRate; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToBitRateExtensionsTests + { + [Fact] + public void NumberToBitsPerSecondTest() => + Assert.Equal(BitRate.FromBitsPerSecond(2), 2.BitsPerSecond); + + [Fact] + public void NumberToBytesPerSecondTest() => + Assert.Equal(BitRate.FromBytesPerSecond(2), 2.BytesPerSecond); + + [Fact] + public void NumberToExabitsPerSecondTest() => + Assert.Equal(BitRate.FromExabitsPerSecond(2), 2.ExabitsPerSecond); + + [Fact] + public void NumberToExabytesPerSecondTest() => + Assert.Equal(BitRate.FromExabytesPerSecond(2), 2.ExabytesPerSecond); + + [Fact] + public void NumberToExaoctetsPerSecondTest() => + Assert.Equal(BitRate.FromExaoctetsPerSecond(2), 2.ExaoctetsPerSecond); + + [Fact] + public void NumberToExbibitsPerSecondTest() => + Assert.Equal(BitRate.FromExbibitsPerSecond(2), 2.ExbibitsPerSecond); + + [Fact] + public void NumberToExbibytesPerSecondTest() => + Assert.Equal(BitRate.FromExbibytesPerSecond(2), 2.ExbibytesPerSecond); + + [Fact] + public void NumberToExbioctetsPerSecondTest() => + Assert.Equal(BitRate.FromExbioctetsPerSecond(2), 2.ExbioctetsPerSecond); + + [Fact] + public void NumberToGibibitsPerSecondTest() => + Assert.Equal(BitRate.FromGibibitsPerSecond(2), 2.GibibitsPerSecond); + + [Fact] + public void NumberToGibibytesPerSecondTest() => + Assert.Equal(BitRate.FromGibibytesPerSecond(2), 2.GibibytesPerSecond); + + [Fact] + public void NumberToGibioctetsPerSecondTest() => + Assert.Equal(BitRate.FromGibioctetsPerSecond(2), 2.GibioctetsPerSecond); + + [Fact] + public void NumberToGigabitsPerSecondTest() => + Assert.Equal(BitRate.FromGigabitsPerSecond(2), 2.GigabitsPerSecond); + + [Fact] + public void NumberToGigabytesPerSecondTest() => + Assert.Equal(BitRate.FromGigabytesPerSecond(2), 2.GigabytesPerSecond); + + [Fact] + public void NumberToGigaoctetsPerSecondTest() => + Assert.Equal(BitRate.FromGigaoctetsPerSecond(2), 2.GigaoctetsPerSecond); + + [Fact] + public void NumberToKibibitsPerSecondTest() => + Assert.Equal(BitRate.FromKibibitsPerSecond(2), 2.KibibitsPerSecond); + + [Fact] + public void NumberToKibibytesPerSecondTest() => + Assert.Equal(BitRate.FromKibibytesPerSecond(2), 2.KibibytesPerSecond); + + [Fact] + public void NumberToKibioctetsPerSecondTest() => + Assert.Equal(BitRate.FromKibioctetsPerSecond(2), 2.KibioctetsPerSecond); + + [Fact] + public void NumberToKilobitsPerSecondTest() => + Assert.Equal(BitRate.FromKilobitsPerSecond(2), 2.KilobitsPerSecond); + + [Fact] + public void NumberToKilobytesPerSecondTest() => + Assert.Equal(BitRate.FromKilobytesPerSecond(2), 2.KilobytesPerSecond); + + [Fact] + public void NumberToKilooctetsPerSecondTest() => + Assert.Equal(BitRate.FromKilooctetsPerSecond(2), 2.KilooctetsPerSecond); + + [Fact] + public void NumberToMebibitsPerSecondTest() => + Assert.Equal(BitRate.FromMebibitsPerSecond(2), 2.MebibitsPerSecond); + + [Fact] + public void NumberToMebibytesPerSecondTest() => + Assert.Equal(BitRate.FromMebibytesPerSecond(2), 2.MebibytesPerSecond); + + [Fact] + public void NumberToMebioctetsPerSecondTest() => + Assert.Equal(BitRate.FromMebioctetsPerSecond(2), 2.MebioctetsPerSecond); + + [Fact] + public void NumberToMegabitsPerSecondTest() => + Assert.Equal(BitRate.FromMegabitsPerSecond(2), 2.MegabitsPerSecond); + + [Fact] + public void NumberToMegabytesPerSecondTest() => + Assert.Equal(BitRate.FromMegabytesPerSecond(2), 2.MegabytesPerSecond); + + [Fact] + public void NumberToMegaoctetsPerSecondTest() => + Assert.Equal(BitRate.FromMegaoctetsPerSecond(2), 2.MegaoctetsPerSecond); + + [Fact] + public void NumberToOctetsPerSecondTest() => + Assert.Equal(BitRate.FromOctetsPerSecond(2), 2.OctetsPerSecond); + + [Fact] + public void NumberToPebibitsPerSecondTest() => + Assert.Equal(BitRate.FromPebibitsPerSecond(2), 2.PebibitsPerSecond); + + [Fact] + public void NumberToPebibytesPerSecondTest() => + Assert.Equal(BitRate.FromPebibytesPerSecond(2), 2.PebibytesPerSecond); + + [Fact] + public void NumberToPebioctetsPerSecondTest() => + Assert.Equal(BitRate.FromPebioctetsPerSecond(2), 2.PebioctetsPerSecond); + + [Fact] + public void NumberToPetabitsPerSecondTest() => + Assert.Equal(BitRate.FromPetabitsPerSecond(2), 2.PetabitsPerSecond); + + [Fact] + public void NumberToPetabytesPerSecondTest() => + Assert.Equal(BitRate.FromPetabytesPerSecond(2), 2.PetabytesPerSecond); + + [Fact] + public void NumberToPetaoctetsPerSecondTest() => + Assert.Equal(BitRate.FromPetaoctetsPerSecond(2), 2.PetaoctetsPerSecond); + + [Fact] + public void NumberToTebibitsPerSecondTest() => + Assert.Equal(BitRate.FromTebibitsPerSecond(2), 2.TebibitsPerSecond); + + [Fact] + public void NumberToTebibytesPerSecondTest() => + Assert.Equal(BitRate.FromTebibytesPerSecond(2), 2.TebibytesPerSecond); + + [Fact] + public void NumberToTebioctetsPerSecondTest() => + Assert.Equal(BitRate.FromTebioctetsPerSecond(2), 2.TebioctetsPerSecond); + + [Fact] + public void NumberToTerabitsPerSecondTest() => + Assert.Equal(BitRate.FromTerabitsPerSecond(2), 2.TerabitsPerSecond); + + [Fact] + public void NumberToTerabytesPerSecondTest() => + Assert.Equal(BitRate.FromTerabytesPerSecond(2), 2.TerabytesPerSecond); + + [Fact] + public void NumberToTeraoctetsPerSecondTest() => + Assert.Equal(BitRate.FromTeraoctetsPerSecond(2), 2.TeraoctetsPerSecond); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensionsTest.g.cs new file mode 100644 index 0000000000..aee2825a7c --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensionsTest.g.cs @@ -0,0 +1,40 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToBrakeSpecificFuelConsumption; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToBrakeSpecificFuelConsumptionExtensionsTests + { + [Fact] + public void NumberToGramsPerKiloWattHourTest() => + Assert.Equal(BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(2), 2.GramsPerKiloWattHour); + + [Fact] + public void NumberToKilogramsPerJouleTest() => + Assert.Equal(BrakeSpecificFuelConsumption.FromKilogramsPerJoule(2), 2.KilogramsPerJoule); + + [Fact] + public void NumberToPoundsPerMechanicalHorsepowerHourTest() => + Assert.Equal(BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(2), 2.PoundsPerMechanicalHorsepowerHour); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensionsTest.g.cs new file mode 100644 index 0000000000..09ffcbf3d4 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensionsTest.g.cs @@ -0,0 +1,52 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToCoefficientOfThermalExpansion; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToCoefficientOfThermalExpansionExtensionsTests + { + [Fact] + public void NumberToPerDegreeCelsiusTest() => + Assert.Equal(CoefficientOfThermalExpansion.FromPerDegreeCelsius(2), 2.PerDegreeCelsius); + + [Fact] + public void NumberToPerDegreeFahrenheitTest() => + Assert.Equal(CoefficientOfThermalExpansion.FromPerDegreeFahrenheit(2), 2.PerDegreeFahrenheit); + + [Fact] + public void NumberToPerKelvinTest() => + Assert.Equal(CoefficientOfThermalExpansion.FromPerKelvin(2), 2.PerKelvin); + + [Fact] + public void NumberToPpmPerDegreeCelsiusTest() => + Assert.Equal(CoefficientOfThermalExpansion.FromPpmPerDegreeCelsius(2), 2.PpmPerDegreeCelsius); + + [Fact] + public void NumberToPpmPerDegreeFahrenheitTest() => + Assert.Equal(CoefficientOfThermalExpansion.FromPpmPerDegreeFahrenheit(2), 2.PpmPerDegreeFahrenheit); + + [Fact] + public void NumberToPpmPerKelvinTest() => + Assert.Equal(CoefficientOfThermalExpansion.FromPpmPerKelvin(2), 2.PpmPerKelvin); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToCompressibilityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToCompressibilityExtensionsTest.g.cs new file mode 100644 index 0000000000..369c3fca30 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToCompressibilityExtensionsTest.g.cs @@ -0,0 +1,56 @@ +//------------------------------------------------------------------------------ +// +// 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 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 NumberToInversePoundsForcePerSquareInchTest() => + Assert.Equal(Compressibility.FromInversePoundsForcePerSquareInch(2), 2.InversePoundsForcePerSquareInch); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToDensityExtensionsTest.g.cs new file mode 100644 index 0000000000..5df97ecd5b --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToDensityExtensionsTest.g.cs @@ -0,0 +1,252 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToDensity; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToDensityExtensionsTests + { + [Fact] + public void NumberToCentigramsPerDeciliterTest() => + Assert.Equal(Density.FromCentigramsPerDeciliter(2), 2.CentigramsPerDeciliter); + + [Fact] + public void NumberToCentigramsPerLiterTest() => + Assert.Equal(Density.FromCentigramsPerLiter(2), 2.CentigramsPerLiter); + + [Fact] + public void NumberToCentigramsPerMilliliterTest() => + Assert.Equal(Density.FromCentigramsPerMilliliter(2), 2.CentigramsPerMilliliter); + + [Fact] + public void NumberToDecigramsPerDeciliterTest() => + Assert.Equal(Density.FromDecigramsPerDeciliter(2), 2.DecigramsPerDeciliter); + + [Fact] + public void NumberToDecigramsPerLiterTest() => + Assert.Equal(Density.FromDecigramsPerLiter(2), 2.DecigramsPerLiter); + + [Fact] + public void NumberToDecigramsPerMilliliterTest() => + Assert.Equal(Density.FromDecigramsPerMilliliter(2), 2.DecigramsPerMilliliter); + + [Fact] + public void NumberToFemtogramsPerDeciliterTest() => + Assert.Equal(Density.FromFemtogramsPerDeciliter(2), 2.FemtogramsPerDeciliter); + + [Fact] + public void NumberToFemtogramsPerLiterTest() => + Assert.Equal(Density.FromFemtogramsPerLiter(2), 2.FemtogramsPerLiter); + + [Fact] + public void NumberToFemtogramsPerMilliliterTest() => + Assert.Equal(Density.FromFemtogramsPerMilliliter(2), 2.FemtogramsPerMilliliter); + + [Fact] + public void NumberToGramsPerCubicCentimeterTest() => + Assert.Equal(Density.FromGramsPerCubicCentimeter(2), 2.GramsPerCubicCentimeter); + + [Fact] + public void NumberToGramsPerCubicFootTest() => + Assert.Equal(Density.FromGramsPerCubicFoot(2), 2.GramsPerCubicFoot); + + [Fact] + public void NumberToGramsPerCubicInchTest() => + Assert.Equal(Density.FromGramsPerCubicInch(2), 2.GramsPerCubicInch); + + [Fact] + public void NumberToGramsPerCubicMeterTest() => + Assert.Equal(Density.FromGramsPerCubicMeter(2), 2.GramsPerCubicMeter); + + [Fact] + public void NumberToGramsPerCubicMillimeterTest() => + Assert.Equal(Density.FromGramsPerCubicMillimeter(2), 2.GramsPerCubicMillimeter); + + [Fact] + public void NumberToGramsPerDeciliterTest() => + Assert.Equal(Density.FromGramsPerDeciliter(2), 2.GramsPerDeciliter); + + [Fact] + public void NumberToGramsPerLiterTest() => + Assert.Equal(Density.FromGramsPerLiter(2), 2.GramsPerLiter); + + [Fact] + public void NumberToGramsPerMilliliterTest() => + Assert.Equal(Density.FromGramsPerMilliliter(2), 2.GramsPerMilliliter); + + [Fact] + public void NumberToKilogramsPerCubicCentimeterTest() => + Assert.Equal(Density.FromKilogramsPerCubicCentimeter(2), 2.KilogramsPerCubicCentimeter); + + [Fact] + public void NumberToKilogramsPerCubicMeterTest() => + Assert.Equal(Density.FromKilogramsPerCubicMeter(2), 2.KilogramsPerCubicMeter); + + [Fact] + public void NumberToKilogramsPerCubicMillimeterTest() => + Assert.Equal(Density.FromKilogramsPerCubicMillimeter(2), 2.KilogramsPerCubicMillimeter); + + [Fact] + public void NumberToKilogramsPerLiterTest() => + Assert.Equal(Density.FromKilogramsPerLiter(2), 2.KilogramsPerLiter); + + [Fact] + public void NumberToKilopoundsPerCubicFootTest() => + Assert.Equal(Density.FromKilopoundsPerCubicFoot(2), 2.KilopoundsPerCubicFoot); + + [Fact] + public void NumberToKilopoundsPerCubicInchTest() => + Assert.Equal(Density.FromKilopoundsPerCubicInch(2), 2.KilopoundsPerCubicInch); + + [Fact] + public void NumberToKilopoundsPerCubicYardTest() => + Assert.Equal(Density.FromKilopoundsPerCubicYard(2), 2.KilopoundsPerCubicYard); + + [Fact] + public void NumberToMicrogramsPerCubicMeterTest() => + Assert.Equal(Density.FromMicrogramsPerCubicMeter(2), 2.MicrogramsPerCubicMeter); + + [Fact] + public void NumberToMicrogramsPerDeciliterTest() => + Assert.Equal(Density.FromMicrogramsPerDeciliter(2), 2.MicrogramsPerDeciliter); + + [Fact] + public void NumberToMicrogramsPerLiterTest() => + Assert.Equal(Density.FromMicrogramsPerLiter(2), 2.MicrogramsPerLiter); + + [Fact] + public void NumberToMicrogramsPerMilliliterTest() => + Assert.Equal(Density.FromMicrogramsPerMilliliter(2), 2.MicrogramsPerMilliliter); + + [Fact] + public void NumberToMilligramsPerCubicMeterTest() => + Assert.Equal(Density.FromMilligramsPerCubicMeter(2), 2.MilligramsPerCubicMeter); + + [Fact] + public void NumberToMilligramsPerDeciliterTest() => + Assert.Equal(Density.FromMilligramsPerDeciliter(2), 2.MilligramsPerDeciliter); + + [Fact] + public void NumberToMilligramsPerLiterTest() => + Assert.Equal(Density.FromMilligramsPerLiter(2), 2.MilligramsPerLiter); + + [Fact] + public void NumberToMilligramsPerMilliliterTest() => + Assert.Equal(Density.FromMilligramsPerMilliliter(2), 2.MilligramsPerMilliliter); + + [Fact] + public void NumberToNanogramsPerDeciliterTest() => + Assert.Equal(Density.FromNanogramsPerDeciliter(2), 2.NanogramsPerDeciliter); + + [Fact] + public void NumberToNanogramsPerLiterTest() => + Assert.Equal(Density.FromNanogramsPerLiter(2), 2.NanogramsPerLiter); + + [Fact] + public void NumberToNanogramsPerMilliliterTest() => + Assert.Equal(Density.FromNanogramsPerMilliliter(2), 2.NanogramsPerMilliliter); + + [Fact] + public void NumberToPicogramsPerDeciliterTest() => + Assert.Equal(Density.FromPicogramsPerDeciliter(2), 2.PicogramsPerDeciliter); + + [Fact] + public void NumberToPicogramsPerLiterTest() => + Assert.Equal(Density.FromPicogramsPerLiter(2), 2.PicogramsPerLiter); + + [Fact] + public void NumberToPicogramsPerMilliliterTest() => + Assert.Equal(Density.FromPicogramsPerMilliliter(2), 2.PicogramsPerMilliliter); + + [Fact] + public void NumberToPoundsPerCubicCentimeterTest() => + Assert.Equal(Density.FromPoundsPerCubicCentimeter(2), 2.PoundsPerCubicCentimeter); + + [Fact] + public void NumberToPoundsPerCubicFootTest() => + Assert.Equal(Density.FromPoundsPerCubicFoot(2), 2.PoundsPerCubicFoot); + + [Fact] + public void NumberToPoundsPerCubicInchTest() => + Assert.Equal(Density.FromPoundsPerCubicInch(2), 2.PoundsPerCubicInch); + + [Fact] + public void NumberToPoundsPerCubicMeterTest() => + Assert.Equal(Density.FromPoundsPerCubicMeter(2), 2.PoundsPerCubicMeter); + + [Fact] + public void NumberToPoundsPerCubicMillimeterTest() => + Assert.Equal(Density.FromPoundsPerCubicMillimeter(2), 2.PoundsPerCubicMillimeter); + + [Fact] + public void NumberToPoundsPerCubicYardTest() => + Assert.Equal(Density.FromPoundsPerCubicYard(2), 2.PoundsPerCubicYard); + + [Fact] + public void NumberToPoundsPerImperialGallonTest() => + Assert.Equal(Density.FromPoundsPerImperialGallon(2), 2.PoundsPerImperialGallon); + + [Fact] + public void NumberToPoundsPerUSGallonTest() => + Assert.Equal(Density.FromPoundsPerUSGallon(2), 2.PoundsPerUSGallon); + + [Fact] + public void NumberToSlugsPerCubicCentimeterTest() => + Assert.Equal(Density.FromSlugsPerCubicCentimeter(2), 2.SlugsPerCubicCentimeter); + + [Fact] + public void NumberToSlugsPerCubicFootTest() => + Assert.Equal(Density.FromSlugsPerCubicFoot(2), 2.SlugsPerCubicFoot); + + [Fact] + public void NumberToSlugsPerCubicInchTest() => + Assert.Equal(Density.FromSlugsPerCubicInch(2), 2.SlugsPerCubicInch); + + [Fact] + public void NumberToSlugsPerCubicMeterTest() => + Assert.Equal(Density.FromSlugsPerCubicMeter(2), 2.SlugsPerCubicMeter); + + [Fact] + public void NumberToSlugsPerCubicMillimeterTest() => + Assert.Equal(Density.FromSlugsPerCubicMillimeter(2), 2.SlugsPerCubicMillimeter); + + [Fact] + public void NumberToTonnesPerCubicCentimeterTest() => + Assert.Equal(Density.FromTonnesPerCubicCentimeter(2), 2.TonnesPerCubicCentimeter); + + [Fact] + public void NumberToTonnesPerCubicFootTest() => + Assert.Equal(Density.FromTonnesPerCubicFoot(2), 2.TonnesPerCubicFoot); + + [Fact] + public void NumberToTonnesPerCubicInchTest() => + Assert.Equal(Density.FromTonnesPerCubicInch(2), 2.TonnesPerCubicInch); + + [Fact] + public void NumberToTonnesPerCubicMeterTest() => + Assert.Equal(Density.FromTonnesPerCubicMeter(2), 2.TonnesPerCubicMeter); + + [Fact] + public void NumberToTonnesPerCubicMillimeterTest() => + Assert.Equal(Density.FromTonnesPerCubicMillimeter(2), 2.TonnesPerCubicMillimeter); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToDoseAreaProductExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToDoseAreaProductExtensionsTest.g.cs new file mode 100644 index 0000000000..c56af9a643 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToDoseAreaProductExtensionsTest.g.cs @@ -0,0 +1,128 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToDoseAreaProduct; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToDoseAreaProductExtensionsTests + { + [Fact] + public void NumberToCentigraySquareCentimetersTest() => + Assert.Equal(DoseAreaProduct.FromCentigraySquareCentimeters(2), 2.CentigraySquareCentimeters); + + [Fact] + public void NumberToCentigraySquareDecimetersTest() => + Assert.Equal(DoseAreaProduct.FromCentigraySquareDecimeters(2), 2.CentigraySquareDecimeters); + + [Fact] + public void NumberToCentigraySquareMetersTest() => + Assert.Equal(DoseAreaProduct.FromCentigraySquareMeters(2), 2.CentigraySquareMeters); + + [Fact] + public void NumberToCentigraySquareMicrometersTest() => + Assert.Equal(DoseAreaProduct.FromCentigraySquareMicrometers(2), 2.CentigraySquareMicrometers); + + [Fact] + public void NumberToCentigraySquareMillimetersTest() => + Assert.Equal(DoseAreaProduct.FromCentigraySquareMillimeters(2), 2.CentigraySquareMillimeters); + + [Fact] + public void NumberToDecigraySquareCentimetersTest() => + Assert.Equal(DoseAreaProduct.FromDecigraySquareCentimeters(2), 2.DecigraySquareCentimeters); + + [Fact] + public void NumberToDecigraySquareDecimetersTest() => + Assert.Equal(DoseAreaProduct.FromDecigraySquareDecimeters(2), 2.DecigraySquareDecimeters); + + [Fact] + public void NumberToDecigraySquareMetersTest() => + Assert.Equal(DoseAreaProduct.FromDecigraySquareMeters(2), 2.DecigraySquareMeters); + + [Fact] + public void NumberToDecigraySquareMicrometersTest() => + Assert.Equal(DoseAreaProduct.FromDecigraySquareMicrometers(2), 2.DecigraySquareMicrometers); + + [Fact] + public void NumberToDecigraySquareMillimetersTest() => + Assert.Equal(DoseAreaProduct.FromDecigraySquareMillimeters(2), 2.DecigraySquareMillimeters); + + [Fact] + public void NumberToGraySquareCentimetersTest() => + Assert.Equal(DoseAreaProduct.FromGraySquareCentimeters(2), 2.GraySquareCentimeters); + + [Fact] + public void NumberToGraySquareDecimetersTest() => + Assert.Equal(DoseAreaProduct.FromGraySquareDecimeters(2), 2.GraySquareDecimeters); + + [Fact] + public void NumberToGraySquareMetersTest() => + Assert.Equal(DoseAreaProduct.FromGraySquareMeters(2), 2.GraySquareMeters); + + [Fact] + public void NumberToGraySquareMicrometersTest() => + Assert.Equal(DoseAreaProduct.FromGraySquareMicrometers(2), 2.GraySquareMicrometers); + + [Fact] + public void NumberToGraySquareMillimetersTest() => + Assert.Equal(DoseAreaProduct.FromGraySquareMillimeters(2), 2.GraySquareMillimeters); + + [Fact] + public void NumberToMicrograySquareCentimetersTest() => + Assert.Equal(DoseAreaProduct.FromMicrograySquareCentimeters(2), 2.MicrograySquareCentimeters); + + [Fact] + public void NumberToMicrograySquareDecimetersTest() => + Assert.Equal(DoseAreaProduct.FromMicrograySquareDecimeters(2), 2.MicrograySquareDecimeters); + + [Fact] + public void NumberToMicrograySquareMetersTest() => + Assert.Equal(DoseAreaProduct.FromMicrograySquareMeters(2), 2.MicrograySquareMeters); + + [Fact] + public void NumberToMicrograySquareMicrometersTest() => + Assert.Equal(DoseAreaProduct.FromMicrograySquareMicrometers(2), 2.MicrograySquareMicrometers); + + [Fact] + public void NumberToMicrograySquareMillimetersTest() => + Assert.Equal(DoseAreaProduct.FromMicrograySquareMillimeters(2), 2.MicrograySquareMillimeters); + + [Fact] + public void NumberToMilligraySquareCentimetersTest() => + Assert.Equal(DoseAreaProduct.FromMilligraySquareCentimeters(2), 2.MilligraySquareCentimeters); + + [Fact] + public void NumberToMilligraySquareDecimetersTest() => + Assert.Equal(DoseAreaProduct.FromMilligraySquareDecimeters(2), 2.MilligraySquareDecimeters); + + [Fact] + public void NumberToMilligraySquareMetersTest() => + Assert.Equal(DoseAreaProduct.FromMilligraySquareMeters(2), 2.MilligraySquareMeters); + + [Fact] + public void NumberToMilligraySquareMicrometersTest() => + Assert.Equal(DoseAreaProduct.FromMilligraySquareMicrometers(2), 2.MilligraySquareMicrometers); + + [Fact] + public void NumberToMilligraySquareMillimetersTest() => + Assert.Equal(DoseAreaProduct.FromMilligraySquareMillimeters(2), 2.MilligraySquareMillimeters); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToDurationExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToDurationExtensionsTest.g.cs new file mode 100644 index 0000000000..4b410d19c1 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToDurationExtensionsTest.g.cs @@ -0,0 +1,80 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToDuration; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToDurationExtensionsTests + { + [Fact] + public void NumberToDaysTest() => + Assert.Equal(Duration.FromDays(2), 2.Days); + + [Fact] + public void NumberToHoursTest() => + Assert.Equal(Duration.FromHours(2), 2.Hours); + + [Fact] + public void NumberToJulianYearsTest() => + Assert.Equal(Duration.FromJulianYears(2), 2.JulianYears); + + [Fact] + public void NumberToMicrosecondsTest() => + Assert.Equal(Duration.FromMicroseconds(2), 2.Microseconds); + + [Fact] + public void NumberToMillisecondsTest() => + Assert.Equal(Duration.FromMilliseconds(2), 2.Milliseconds); + + [Fact] + public void NumberToMinutesTest() => + Assert.Equal(Duration.FromMinutes(2), 2.Minutes); + + [Fact] + public void NumberToMonths30Test() => + Assert.Equal(Duration.FromMonths30(2), 2.Months30); + + [Fact] + public void NumberToNanosecondsTest() => + Assert.Equal(Duration.FromNanoseconds(2), 2.Nanoseconds); + + [Fact] + public void NumberToPicosecondsTest() => + Assert.Equal(Duration.FromPicoseconds(2), 2.Picoseconds); + + [Fact] + public void NumberToSecondsTest() => + Assert.Equal(Duration.FromSeconds(2), 2.Seconds); + + [Fact] + public void NumberToSolsTest() => + Assert.Equal(Duration.FromSols(2), 2.Sols); + + [Fact] + public void NumberToWeeksTest() => + Assert.Equal(Duration.FromWeeks(2), 2.Weeks); + + [Fact] + public void NumberToYears365Test() => + Assert.Equal(Duration.FromYears365(2), 2.Years365); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToDynamicViscosityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToDynamicViscosityExtensionsTest.g.cs new file mode 100644 index 0000000000..7ae231e1fa --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToDynamicViscosityExtensionsTest.g.cs @@ -0,0 +1,68 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToDynamicViscosity; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToDynamicViscosityExtensionsTests + { + [Fact] + public void NumberToCentipoiseTest() => + Assert.Equal(DynamicViscosity.FromCentipoise(2), 2.Centipoise); + + [Fact] + public void NumberToMicropascalSecondsTest() => + Assert.Equal(DynamicViscosity.FromMicropascalSeconds(2), 2.MicropascalSeconds); + + [Fact] + public void NumberToMillipascalSecondsTest() => + Assert.Equal(DynamicViscosity.FromMillipascalSeconds(2), 2.MillipascalSeconds); + + [Fact] + public void NumberToNewtonSecondsPerMeterSquaredTest() => + Assert.Equal(DynamicViscosity.FromNewtonSecondsPerMeterSquared(2), 2.NewtonSecondsPerMeterSquared); + + [Fact] + public void NumberToPascalSecondsTest() => + Assert.Equal(DynamicViscosity.FromPascalSeconds(2), 2.PascalSeconds); + + [Fact] + public void NumberToPoiseTest() => + Assert.Equal(DynamicViscosity.FromPoise(2), 2.Poise); + + [Fact] + public void NumberToPoundsForceSecondPerSquareFootTest() => + Assert.Equal(DynamicViscosity.FromPoundsForceSecondPerSquareFoot(2), 2.PoundsForceSecondPerSquareFoot); + + [Fact] + public void NumberToPoundsForceSecondPerSquareInchTest() => + Assert.Equal(DynamicViscosity.FromPoundsForceSecondPerSquareInch(2), 2.PoundsForceSecondPerSquareInch); + + [Fact] + public void NumberToPoundsPerFootSecondTest() => + Assert.Equal(DynamicViscosity.FromPoundsPerFootSecond(2), 2.PoundsPerFootSecond); + + [Fact] + public void NumberToReynsTest() => + Assert.Equal(DynamicViscosity.FromReyns(2), 2.Reyns); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricAdmittanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricAdmittanceExtensionsTest.g.cs new file mode 100644 index 0000000000..8e9e1493c5 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricAdmittanceExtensionsTest.g.cs @@ -0,0 +1,92 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToElectricAdmittance; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToElectricAdmittanceExtensionsTests + { + [Fact] + public void NumberToGigamhosTest() => + Assert.Equal(ElectricAdmittance.FromGigamhos(2), 2.Gigamhos); + + [Fact] + public void NumberToGigasiemensTest() => + Assert.Equal(ElectricAdmittance.FromGigasiemens(2), 2.Gigasiemens); + + [Fact] + public void NumberToKilomhosTest() => + Assert.Equal(ElectricAdmittance.FromKilomhos(2), 2.Kilomhos); + + [Fact] + public void NumberToKilosiemensTest() => + Assert.Equal(ElectricAdmittance.FromKilosiemens(2), 2.Kilosiemens); + + [Fact] + public void NumberToMegamhosTest() => + Assert.Equal(ElectricAdmittance.FromMegamhos(2), 2.Megamhos); + + [Fact] + public void NumberToMegasiemensTest() => + Assert.Equal(ElectricAdmittance.FromMegasiemens(2), 2.Megasiemens); + + [Fact] + public void NumberToMhosTest() => + Assert.Equal(ElectricAdmittance.FromMhos(2), 2.Mhos); + + [Fact] + public void NumberToMicromhosTest() => + Assert.Equal(ElectricAdmittance.FromMicromhos(2), 2.Micromhos); + + [Fact] + public void NumberToMicrosiemensTest() => + Assert.Equal(ElectricAdmittance.FromMicrosiemens(2), 2.Microsiemens); + + [Fact] + public void NumberToMillimhosTest() => + Assert.Equal(ElectricAdmittance.FromMillimhos(2), 2.Millimhos); + + [Fact] + public void NumberToMillisiemensTest() => + Assert.Equal(ElectricAdmittance.FromMillisiemens(2), 2.Millisiemens); + + [Fact] + public void NumberToNanomhosTest() => + Assert.Equal(ElectricAdmittance.FromNanomhos(2), 2.Nanomhos); + + [Fact] + public void NumberToNanosiemensTest() => + Assert.Equal(ElectricAdmittance.FromNanosiemens(2), 2.Nanosiemens); + + [Fact] + public void NumberToSiemensTest() => + Assert.Equal(ElectricAdmittance.FromSiemens(2), 2.Siemens); + + [Fact] + public void NumberToTeramhosTest() => + Assert.Equal(ElectricAdmittance.FromTeramhos(2), 2.Teramhos); + + [Fact] + public void NumberToTerasiemensTest() => + Assert.Equal(ElectricAdmittance.FromTerasiemens(2), 2.Terasiemens); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricApparentEnergyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricApparentEnergyExtensionsTest.g.cs new file mode 100644 index 0000000000..56cd1c76e9 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricApparentEnergyExtensionsTest.g.cs @@ -0,0 +1,40 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToElectricApparentEnergy; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToElectricApparentEnergyExtensionsTests + { + [Fact] + public void NumberToKilovoltampereHoursTest() => + Assert.Equal(ElectricApparentEnergy.FromKilovoltampereHours(2), 2.KilovoltampereHours); + + [Fact] + public void NumberToMegavoltampereHoursTest() => + Assert.Equal(ElectricApparentEnergy.FromMegavoltampereHours(2), 2.MegavoltampereHours); + + [Fact] + public void NumberToVoltampereHoursTest() => + Assert.Equal(ElectricApparentEnergy.FromVoltampereHours(2), 2.VoltampereHours); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricApparentPowerExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricApparentPowerExtensionsTest.g.cs new file mode 100644 index 0000000000..46f66ec9b4 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricApparentPowerExtensionsTest.g.cs @@ -0,0 +1,52 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToElectricApparentPower; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToElectricApparentPowerExtensionsTests + { + [Fact] + public void NumberToGigavoltamperesTest() => + Assert.Equal(ElectricApparentPower.FromGigavoltamperes(2), 2.Gigavoltamperes); + + [Fact] + public void NumberToKilovoltamperesTest() => + Assert.Equal(ElectricApparentPower.FromKilovoltamperes(2), 2.Kilovoltamperes); + + [Fact] + public void NumberToMegavoltamperesTest() => + Assert.Equal(ElectricApparentPower.FromMegavoltamperes(2), 2.Megavoltamperes); + + [Fact] + public void NumberToMicrovoltamperesTest() => + Assert.Equal(ElectricApparentPower.FromMicrovoltamperes(2), 2.Microvoltamperes); + + [Fact] + public void NumberToMillivoltamperesTest() => + Assert.Equal(ElectricApparentPower.FromMillivoltamperes(2), 2.Millivoltamperes); + + [Fact] + public void NumberToVoltamperesTest() => + Assert.Equal(ElectricApparentPower.FromVoltamperes(2), 2.Voltamperes); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricCapacitanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricCapacitanceExtensionsTest.g.cs new file mode 100644 index 0000000000..42e2d6d219 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricCapacitanceExtensionsTest.g.cs @@ -0,0 +1,56 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToElectricCapacitance; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToElectricCapacitanceExtensionsTests + { + [Fact] + public void NumberToFaradsTest() => + Assert.Equal(ElectricCapacitance.FromFarads(2), 2.Farads); + + [Fact] + public void NumberToKilofaradsTest() => + Assert.Equal(ElectricCapacitance.FromKilofarads(2), 2.Kilofarads); + + [Fact] + public void NumberToMegafaradsTest() => + Assert.Equal(ElectricCapacitance.FromMegafarads(2), 2.Megafarads); + + [Fact] + public void NumberToMicrofaradsTest() => + Assert.Equal(ElectricCapacitance.FromMicrofarads(2), 2.Microfarads); + + [Fact] + public void NumberToMillifaradsTest() => + Assert.Equal(ElectricCapacitance.FromMillifarads(2), 2.Millifarads); + + [Fact] + public void NumberToNanofaradsTest() => + Assert.Equal(ElectricCapacitance.FromNanofarads(2), 2.Nanofarads); + + [Fact] + public void NumberToPicofaradsTest() => + Assert.Equal(ElectricCapacitance.FromPicofarads(2), 2.Picofarads); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricChargeDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricChargeDensityExtensionsTest.g.cs new file mode 100644 index 0000000000..7b7e85e3c9 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricChargeDensityExtensionsTest.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.NumberToElectricChargeDensity; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToElectricChargeDensityExtensionsTests + { + [Fact] + public void NumberToCoulombsPerCubicMeterTest() => + Assert.Equal(ElectricChargeDensity.FromCoulombsPerCubicMeter(2), 2.CoulombsPerCubicMeter); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricChargeExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricChargeExtensionsTest.g.cs new file mode 100644 index 0000000000..a93fc26591 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricChargeExtensionsTest.g.cs @@ -0,0 +1,72 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToElectricCharge; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToElectricChargeExtensionsTests + { + [Fact] + public void NumberToAmpereHoursTest() => + Assert.Equal(ElectricCharge.FromAmpereHours(2), 2.AmpereHours); + + [Fact] + public void NumberToCoulombsTest() => + Assert.Equal(ElectricCharge.FromCoulombs(2), 2.Coulombs); + + [Fact] + public void NumberToKiloampereHoursTest() => + Assert.Equal(ElectricCharge.FromKiloampereHours(2), 2.KiloampereHours); + + [Fact] + public void NumberToKilocoulombsTest() => + Assert.Equal(ElectricCharge.FromKilocoulombs(2), 2.Kilocoulombs); + + [Fact] + public void NumberToMegaampereHoursTest() => + Assert.Equal(ElectricCharge.FromMegaampereHours(2), 2.MegaampereHours); + + [Fact] + public void NumberToMegacoulombsTest() => + Assert.Equal(ElectricCharge.FromMegacoulombs(2), 2.Megacoulombs); + + [Fact] + public void NumberToMicrocoulombsTest() => + Assert.Equal(ElectricCharge.FromMicrocoulombs(2), 2.Microcoulombs); + + [Fact] + public void NumberToMilliampereHoursTest() => + Assert.Equal(ElectricCharge.FromMilliampereHours(2), 2.MilliampereHours); + + [Fact] + public void NumberToMillicoulombsTest() => + Assert.Equal(ElectricCharge.FromMillicoulombs(2), 2.Millicoulombs); + + [Fact] + public void NumberToNanocoulombsTest() => + Assert.Equal(ElectricCharge.FromNanocoulombs(2), 2.Nanocoulombs); + + [Fact] + public void NumberToPicocoulombsTest() => + Assert.Equal(ElectricCharge.FromPicocoulombs(2), 2.Picocoulombs); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricConductanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricConductanceExtensionsTest.g.cs new file mode 100644 index 0000000000..b687168466 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricConductanceExtensionsTest.g.cs @@ -0,0 +1,92 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToElectricConductance; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToElectricConductanceExtensionsTests + { + [Fact] + public void NumberToGigamhosTest() => + Assert.Equal(ElectricConductance.FromGigamhos(2), 2.Gigamhos); + + [Fact] + public void NumberToGigasiemensTest() => + Assert.Equal(ElectricConductance.FromGigasiemens(2), 2.Gigasiemens); + + [Fact] + public void NumberToKilomhosTest() => + Assert.Equal(ElectricConductance.FromKilomhos(2), 2.Kilomhos); + + [Fact] + public void NumberToKilosiemensTest() => + Assert.Equal(ElectricConductance.FromKilosiemens(2), 2.Kilosiemens); + + [Fact] + public void NumberToMegamhosTest() => + Assert.Equal(ElectricConductance.FromMegamhos(2), 2.Megamhos); + + [Fact] + public void NumberToMegasiemensTest() => + Assert.Equal(ElectricConductance.FromMegasiemens(2), 2.Megasiemens); + + [Fact] + public void NumberToMhosTest() => + Assert.Equal(ElectricConductance.FromMhos(2), 2.Mhos); + + [Fact] + public void NumberToMicromhosTest() => + Assert.Equal(ElectricConductance.FromMicromhos(2), 2.Micromhos); + + [Fact] + public void NumberToMicrosiemensTest() => + Assert.Equal(ElectricConductance.FromMicrosiemens(2), 2.Microsiemens); + + [Fact] + public void NumberToMillimhosTest() => + Assert.Equal(ElectricConductance.FromMillimhos(2), 2.Millimhos); + + [Fact] + public void NumberToMillisiemensTest() => + Assert.Equal(ElectricConductance.FromMillisiemens(2), 2.Millisiemens); + + [Fact] + public void NumberToNanomhosTest() => + Assert.Equal(ElectricConductance.FromNanomhos(2), 2.Nanomhos); + + [Fact] + public void NumberToNanosiemensTest() => + Assert.Equal(ElectricConductance.FromNanosiemens(2), 2.Nanosiemens); + + [Fact] + public void NumberToSiemensTest() => + Assert.Equal(ElectricConductance.FromSiemens(2), 2.Siemens); + + [Fact] + public void NumberToTeramhosTest() => + Assert.Equal(ElectricConductance.FromTeramhos(2), 2.Teramhos); + + [Fact] + public void NumberToTerasiemensTest() => + Assert.Equal(ElectricConductance.FromTerasiemens(2), 2.Terasiemens); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricConductivityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricConductivityExtensionsTest.g.cs new file mode 100644 index 0000000000..9dad8091ed --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricConductivityExtensionsTest.g.cs @@ -0,0 +1,52 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToElectricConductivity; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToElectricConductivityExtensionsTests + { + [Fact] + public void NumberToMicrosiemensPerCentimeterTest() => + Assert.Equal(ElectricConductivity.FromMicrosiemensPerCentimeter(2), 2.MicrosiemensPerCentimeter); + + [Fact] + public void NumberToMillisiemensPerCentimeterTest() => + Assert.Equal(ElectricConductivity.FromMillisiemensPerCentimeter(2), 2.MillisiemensPerCentimeter); + + [Fact] + public void NumberToSiemensPerCentimeterTest() => + Assert.Equal(ElectricConductivity.FromSiemensPerCentimeter(2), 2.SiemensPerCentimeter); + + [Fact] + public void NumberToSiemensPerFootTest() => + Assert.Equal(ElectricConductivity.FromSiemensPerFoot(2), 2.SiemensPerFoot); + + [Fact] + public void NumberToSiemensPerInchTest() => + Assert.Equal(ElectricConductivity.FromSiemensPerInch(2), 2.SiemensPerInch); + + [Fact] + public void NumberToSiemensPerMeterTest() => + Assert.Equal(ElectricConductivity.FromSiemensPerMeter(2), 2.SiemensPerMeter); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricCurrentDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricCurrentDensityExtensionsTest.g.cs new file mode 100644 index 0000000000..9bcd57a7e1 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricCurrentDensityExtensionsTest.g.cs @@ -0,0 +1,40 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToElectricCurrentDensity; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToElectricCurrentDensityExtensionsTests + { + [Fact] + public void NumberToAmperesPerSquareFootTest() => + Assert.Equal(ElectricCurrentDensity.FromAmperesPerSquareFoot(2), 2.AmperesPerSquareFoot); + + [Fact] + public void NumberToAmperesPerSquareInchTest() => + Assert.Equal(ElectricCurrentDensity.FromAmperesPerSquareInch(2), 2.AmperesPerSquareInch); + + [Fact] + public void NumberToAmperesPerSquareMeterTest() => + Assert.Equal(ElectricCurrentDensity.FromAmperesPerSquareMeter(2), 2.AmperesPerSquareMeter); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricCurrentExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricCurrentExtensionsTest.g.cs new file mode 100644 index 0000000000..827444267d --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricCurrentExtensionsTest.g.cs @@ -0,0 +1,64 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToElectricCurrent; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToElectricCurrentExtensionsTests + { + [Fact] + public void NumberToAmperesTest() => + Assert.Equal(ElectricCurrent.FromAmperes(2), 2.Amperes); + + [Fact] + public void NumberToCentiamperesTest() => + Assert.Equal(ElectricCurrent.FromCentiamperes(2), 2.Centiamperes); + + [Fact] + public void NumberToFemtoamperesTest() => + Assert.Equal(ElectricCurrent.FromFemtoamperes(2), 2.Femtoamperes); + + [Fact] + public void NumberToKiloamperesTest() => + Assert.Equal(ElectricCurrent.FromKiloamperes(2), 2.Kiloamperes); + + [Fact] + public void NumberToMegaamperesTest() => + Assert.Equal(ElectricCurrent.FromMegaamperes(2), 2.Megaamperes); + + [Fact] + public void NumberToMicroamperesTest() => + Assert.Equal(ElectricCurrent.FromMicroamperes(2), 2.Microamperes); + + [Fact] + public void NumberToMilliamperesTest() => + Assert.Equal(ElectricCurrent.FromMilliamperes(2), 2.Milliamperes); + + [Fact] + public void NumberToNanoamperesTest() => + Assert.Equal(ElectricCurrent.FromNanoamperes(2), 2.Nanoamperes); + + [Fact] + public void NumberToPicoamperesTest() => + Assert.Equal(ElectricCurrent.FromPicoamperes(2), 2.Picoamperes); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricCurrentGradientExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricCurrentGradientExtensionsTest.g.cs new file mode 100644 index 0000000000..77f4eb439a --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricCurrentGradientExtensionsTest.g.cs @@ -0,0 +1,56 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToElectricCurrentGradient; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToElectricCurrentGradientExtensionsTests + { + [Fact] + public void NumberToAmperesPerMicrosecondTest() => + Assert.Equal(ElectricCurrentGradient.FromAmperesPerMicrosecond(2), 2.AmperesPerMicrosecond); + + [Fact] + public void NumberToAmperesPerMillisecondTest() => + Assert.Equal(ElectricCurrentGradient.FromAmperesPerMillisecond(2), 2.AmperesPerMillisecond); + + [Fact] + public void NumberToAmperesPerMinuteTest() => + Assert.Equal(ElectricCurrentGradient.FromAmperesPerMinute(2), 2.AmperesPerMinute); + + [Fact] + public void NumberToAmperesPerNanosecondTest() => + Assert.Equal(ElectricCurrentGradient.FromAmperesPerNanosecond(2), 2.AmperesPerNanosecond); + + [Fact] + public void NumberToAmperesPerSecondTest() => + Assert.Equal(ElectricCurrentGradient.FromAmperesPerSecond(2), 2.AmperesPerSecond); + + [Fact] + public void NumberToMilliamperesPerMinuteTest() => + Assert.Equal(ElectricCurrentGradient.FromMilliamperesPerMinute(2), 2.MilliamperesPerMinute); + + [Fact] + public void NumberToMilliamperesPerSecondTest() => + Assert.Equal(ElectricCurrentGradient.FromMilliamperesPerSecond(2), 2.MilliamperesPerSecond); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricFieldExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricFieldExtensionsTest.g.cs new file mode 100644 index 0000000000..2a1730a38b --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricFieldExtensionsTest.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.NumberToElectricField; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToElectricFieldExtensionsTests + { + [Fact] + public void NumberToVoltsPerMeterTest() => + Assert.Equal(ElectricField.FromVoltsPerMeter(2), 2.VoltsPerMeter); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricImpedanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricImpedanceExtensionsTest.g.cs new file mode 100644 index 0000000000..af92be766f --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricImpedanceExtensionsTest.g.cs @@ -0,0 +1,60 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToElectricImpedance; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToElectricImpedanceExtensionsTests + { + [Fact] + public void NumberToGigaohmsTest() => + Assert.Equal(ElectricImpedance.FromGigaohms(2), 2.Gigaohms); + + [Fact] + public void NumberToKiloohmsTest() => + Assert.Equal(ElectricImpedance.FromKiloohms(2), 2.Kiloohms); + + [Fact] + public void NumberToMegaohmsTest() => + Assert.Equal(ElectricImpedance.FromMegaohms(2), 2.Megaohms); + + [Fact] + public void NumberToMicroohmsTest() => + Assert.Equal(ElectricImpedance.FromMicroohms(2), 2.Microohms); + + [Fact] + public void NumberToMilliohmsTest() => + Assert.Equal(ElectricImpedance.FromMilliohms(2), 2.Milliohms); + + [Fact] + public void NumberToNanoohmsTest() => + Assert.Equal(ElectricImpedance.FromNanoohms(2), 2.Nanoohms); + + [Fact] + public void NumberToOhmsTest() => + Assert.Equal(ElectricImpedance.FromOhms(2), 2.Ohms); + + [Fact] + public void NumberToTeraohmsTest() => + Assert.Equal(ElectricImpedance.FromTeraohms(2), 2.Teraohms); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricInductanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricInductanceExtensionsTest.g.cs new file mode 100644 index 0000000000..4edefffa7c --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricInductanceExtensionsTest.g.cs @@ -0,0 +1,48 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToElectricInductance; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToElectricInductanceExtensionsTests + { + [Fact] + public void NumberToHenriesTest() => + Assert.Equal(ElectricInductance.FromHenries(2), 2.Henries); + + [Fact] + public void NumberToMicrohenriesTest() => + Assert.Equal(ElectricInductance.FromMicrohenries(2), 2.Microhenries); + + [Fact] + public void NumberToMillihenriesTest() => + Assert.Equal(ElectricInductance.FromMillihenries(2), 2.Millihenries); + + [Fact] + public void NumberToNanohenriesTest() => + Assert.Equal(ElectricInductance.FromNanohenries(2), 2.Nanohenries); + + [Fact] + public void NumberToPicohenriesTest() => + Assert.Equal(ElectricInductance.FromPicohenries(2), 2.Picohenries); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricPotentialChangeRateExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricPotentialChangeRateExtensionsTest.g.cs new file mode 100644 index 0000000000..8d9264e74b --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricPotentialChangeRateExtensionsTest.g.cs @@ -0,0 +1,108 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToElectricPotentialChangeRate; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToElectricPotentialChangeRateExtensionsTests + { + [Fact] + public void NumberToKilovoltsPerHourTest() => + Assert.Equal(ElectricPotentialChangeRate.FromKilovoltsPerHour(2), 2.KilovoltsPerHour); + + [Fact] + public void NumberToKilovoltsPerMicrosecondTest() => + Assert.Equal(ElectricPotentialChangeRate.FromKilovoltsPerMicrosecond(2), 2.KilovoltsPerMicrosecond); + + [Fact] + public void NumberToKilovoltsPerMinuteTest() => + Assert.Equal(ElectricPotentialChangeRate.FromKilovoltsPerMinute(2), 2.KilovoltsPerMinute); + + [Fact] + public void NumberToKilovoltsPerSecondTest() => + Assert.Equal(ElectricPotentialChangeRate.FromKilovoltsPerSecond(2), 2.KilovoltsPerSecond); + + [Fact] + public void NumberToMegavoltsPerHourTest() => + Assert.Equal(ElectricPotentialChangeRate.FromMegavoltsPerHour(2), 2.MegavoltsPerHour); + + [Fact] + public void NumberToMegavoltsPerMicrosecondTest() => + Assert.Equal(ElectricPotentialChangeRate.FromMegavoltsPerMicrosecond(2), 2.MegavoltsPerMicrosecond); + + [Fact] + public void NumberToMegavoltsPerMinuteTest() => + Assert.Equal(ElectricPotentialChangeRate.FromMegavoltsPerMinute(2), 2.MegavoltsPerMinute); + + [Fact] + public void NumberToMegavoltsPerSecondTest() => + Assert.Equal(ElectricPotentialChangeRate.FromMegavoltsPerSecond(2), 2.MegavoltsPerSecond); + + [Fact] + public void NumberToMicrovoltsPerHourTest() => + Assert.Equal(ElectricPotentialChangeRate.FromMicrovoltsPerHour(2), 2.MicrovoltsPerHour); + + [Fact] + public void NumberToMicrovoltsPerMicrosecondTest() => + Assert.Equal(ElectricPotentialChangeRate.FromMicrovoltsPerMicrosecond(2), 2.MicrovoltsPerMicrosecond); + + [Fact] + public void NumberToMicrovoltsPerMinuteTest() => + Assert.Equal(ElectricPotentialChangeRate.FromMicrovoltsPerMinute(2), 2.MicrovoltsPerMinute); + + [Fact] + public void NumberToMicrovoltsPerSecondTest() => + Assert.Equal(ElectricPotentialChangeRate.FromMicrovoltsPerSecond(2), 2.MicrovoltsPerSecond); + + [Fact] + public void NumberToMillivoltsPerHourTest() => + Assert.Equal(ElectricPotentialChangeRate.FromMillivoltsPerHour(2), 2.MillivoltsPerHour); + + [Fact] + public void NumberToMillivoltsPerMicrosecondTest() => + Assert.Equal(ElectricPotentialChangeRate.FromMillivoltsPerMicrosecond(2), 2.MillivoltsPerMicrosecond); + + [Fact] + public void NumberToMillivoltsPerMinuteTest() => + Assert.Equal(ElectricPotentialChangeRate.FromMillivoltsPerMinute(2), 2.MillivoltsPerMinute); + + [Fact] + public void NumberToMillivoltsPerSecondTest() => + Assert.Equal(ElectricPotentialChangeRate.FromMillivoltsPerSecond(2), 2.MillivoltsPerSecond); + + [Fact] + public void NumberToVoltsPerHourTest() => + Assert.Equal(ElectricPotentialChangeRate.FromVoltsPerHour(2), 2.VoltsPerHour); + + [Fact] + public void NumberToVoltsPerMicrosecondTest() => + Assert.Equal(ElectricPotentialChangeRate.FromVoltsPerMicrosecond(2), 2.VoltsPerMicrosecond); + + [Fact] + public void NumberToVoltsPerMinuteTest() => + Assert.Equal(ElectricPotentialChangeRate.FromVoltsPerMinute(2), 2.VoltsPerMinute); + + [Fact] + public void NumberToVoltsPerSecondTest() => + Assert.Equal(ElectricPotentialChangeRate.FromVoltsPerSecond(2), 2.VoltsPerSecond); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricPotentialExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricPotentialExtensionsTest.g.cs new file mode 100644 index 0000000000..091eae1cb6 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricPotentialExtensionsTest.g.cs @@ -0,0 +1,52 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToElectricPotential; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToElectricPotentialExtensionsTests + { + [Fact] + public void NumberToKilovoltsTest() => + Assert.Equal(ElectricPotential.FromKilovolts(2), 2.Kilovolts); + + [Fact] + public void NumberToMegavoltsTest() => + Assert.Equal(ElectricPotential.FromMegavolts(2), 2.Megavolts); + + [Fact] + public void NumberToMicrovoltsTest() => + Assert.Equal(ElectricPotential.FromMicrovolts(2), 2.Microvolts); + + [Fact] + public void NumberToMillivoltsTest() => + Assert.Equal(ElectricPotential.FromMillivolts(2), 2.Millivolts); + + [Fact] + public void NumberToNanovoltsTest() => + Assert.Equal(ElectricPotential.FromNanovolts(2), 2.Nanovolts); + + [Fact] + public void NumberToVoltsTest() => + Assert.Equal(ElectricPotential.FromVolts(2), 2.Volts); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricReactanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricReactanceExtensionsTest.g.cs new file mode 100644 index 0000000000..b07854f021 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricReactanceExtensionsTest.g.cs @@ -0,0 +1,60 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToElectricReactance; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToElectricReactanceExtensionsTests + { + [Fact] + public void NumberToGigaohmsTest() => + Assert.Equal(ElectricReactance.FromGigaohms(2), 2.Gigaohms); + + [Fact] + public void NumberToKiloohmsTest() => + Assert.Equal(ElectricReactance.FromKiloohms(2), 2.Kiloohms); + + [Fact] + public void NumberToMegaohmsTest() => + Assert.Equal(ElectricReactance.FromMegaohms(2), 2.Megaohms); + + [Fact] + public void NumberToMicroohmsTest() => + Assert.Equal(ElectricReactance.FromMicroohms(2), 2.Microohms); + + [Fact] + public void NumberToMilliohmsTest() => + Assert.Equal(ElectricReactance.FromMilliohms(2), 2.Milliohms); + + [Fact] + public void NumberToNanoohmsTest() => + Assert.Equal(ElectricReactance.FromNanoohms(2), 2.Nanoohms); + + [Fact] + public void NumberToOhmsTest() => + Assert.Equal(ElectricReactance.FromOhms(2), 2.Ohms); + + [Fact] + public void NumberToTeraohmsTest() => + Assert.Equal(ElectricReactance.FromTeraohms(2), 2.Teraohms); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricReactiveEnergyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricReactiveEnergyExtensionsTest.g.cs new file mode 100644 index 0000000000..54dfceda79 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricReactiveEnergyExtensionsTest.g.cs @@ -0,0 +1,40 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToElectricReactiveEnergy; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToElectricReactiveEnergyExtensionsTests + { + [Fact] + public void NumberToKilovoltampereReactiveHoursTest() => + Assert.Equal(ElectricReactiveEnergy.FromKilovoltampereReactiveHours(2), 2.KilovoltampereReactiveHours); + + [Fact] + public void NumberToMegavoltampereReactiveHoursTest() => + Assert.Equal(ElectricReactiveEnergy.FromMegavoltampereReactiveHours(2), 2.MegavoltampereReactiveHours); + + [Fact] + public void NumberToVoltampereReactiveHoursTest() => + Assert.Equal(ElectricReactiveEnergy.FromVoltampereReactiveHours(2), 2.VoltampereReactiveHours); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricReactivePowerExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricReactivePowerExtensionsTest.g.cs new file mode 100644 index 0000000000..fa28a4d6f5 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricReactivePowerExtensionsTest.g.cs @@ -0,0 +1,44 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToElectricReactivePower; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToElectricReactivePowerExtensionsTests + { + [Fact] + public void NumberToGigavoltamperesReactiveTest() => + Assert.Equal(ElectricReactivePower.FromGigavoltamperesReactive(2), 2.GigavoltamperesReactive); + + [Fact] + public void NumberToKilovoltamperesReactiveTest() => + Assert.Equal(ElectricReactivePower.FromKilovoltamperesReactive(2), 2.KilovoltamperesReactive); + + [Fact] + public void NumberToMegavoltamperesReactiveTest() => + Assert.Equal(ElectricReactivePower.FromMegavoltamperesReactive(2), 2.MegavoltamperesReactive); + + [Fact] + public void NumberToVoltamperesReactiveTest() => + Assert.Equal(ElectricReactivePower.FromVoltamperesReactive(2), 2.VoltamperesReactive); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricResistanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricResistanceExtensionsTest.g.cs new file mode 100644 index 0000000000..5d43c7c6e6 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricResistanceExtensionsTest.g.cs @@ -0,0 +1,60 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToElectricResistance; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToElectricResistanceExtensionsTests + { + [Fact] + public void NumberToGigaohmsTest() => + Assert.Equal(ElectricResistance.FromGigaohms(2), 2.Gigaohms); + + [Fact] + public void NumberToKiloohmsTest() => + Assert.Equal(ElectricResistance.FromKiloohms(2), 2.Kiloohms); + + [Fact] + public void NumberToMegaohmsTest() => + Assert.Equal(ElectricResistance.FromMegaohms(2), 2.Megaohms); + + [Fact] + public void NumberToMicroohmsTest() => + Assert.Equal(ElectricResistance.FromMicroohms(2), 2.Microohms); + + [Fact] + public void NumberToMilliohmsTest() => + Assert.Equal(ElectricResistance.FromMilliohms(2), 2.Milliohms); + + [Fact] + public void NumberToNanoohmsTest() => + Assert.Equal(ElectricResistance.FromNanoohms(2), 2.Nanoohms); + + [Fact] + public void NumberToOhmsTest() => + Assert.Equal(ElectricResistance.FromOhms(2), 2.Ohms); + + [Fact] + public void NumberToTeraohmsTest() => + Assert.Equal(ElectricResistance.FromTeraohms(2), 2.Teraohms); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricResistivityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricResistivityExtensionsTest.g.cs new file mode 100644 index 0000000000..e9632e4563 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricResistivityExtensionsTest.g.cs @@ -0,0 +1,84 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToElectricResistivity; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToElectricResistivityExtensionsTests + { + [Fact] + public void NumberToKiloohmsCentimeterTest() => + Assert.Equal(ElectricResistivity.FromKiloohmsCentimeter(2), 2.KiloohmsCentimeter); + + [Fact] + public void NumberToKiloohmMetersTest() => + Assert.Equal(ElectricResistivity.FromKiloohmMeters(2), 2.KiloohmMeters); + + [Fact] + public void NumberToMegaohmsCentimeterTest() => + Assert.Equal(ElectricResistivity.FromMegaohmsCentimeter(2), 2.MegaohmsCentimeter); + + [Fact] + public void NumberToMegaohmMetersTest() => + Assert.Equal(ElectricResistivity.FromMegaohmMeters(2), 2.MegaohmMeters); + + [Fact] + public void NumberToMicroohmsCentimeterTest() => + Assert.Equal(ElectricResistivity.FromMicroohmsCentimeter(2), 2.MicroohmsCentimeter); + + [Fact] + public void NumberToMicroohmMetersTest() => + Assert.Equal(ElectricResistivity.FromMicroohmMeters(2), 2.MicroohmMeters); + + [Fact] + public void NumberToMilliohmsCentimeterTest() => + Assert.Equal(ElectricResistivity.FromMilliohmsCentimeter(2), 2.MilliohmsCentimeter); + + [Fact] + public void NumberToMilliohmMetersTest() => + Assert.Equal(ElectricResistivity.FromMilliohmMeters(2), 2.MilliohmMeters); + + [Fact] + public void NumberToNanoohmsCentimeterTest() => + Assert.Equal(ElectricResistivity.FromNanoohmsCentimeter(2), 2.NanoohmsCentimeter); + + [Fact] + public void NumberToNanoohmMetersTest() => + Assert.Equal(ElectricResistivity.FromNanoohmMeters(2), 2.NanoohmMeters); + + [Fact] + public void NumberToOhmsCentimeterTest() => + Assert.Equal(ElectricResistivity.FromOhmsCentimeter(2), 2.OhmsCentimeter); + + [Fact] + public void NumberToOhmMetersTest() => + Assert.Equal(ElectricResistivity.FromOhmMeters(2), 2.OhmMeters); + + [Fact] + public void NumberToPicoohmsCentimeterTest() => + Assert.Equal(ElectricResistivity.FromPicoohmsCentimeter(2), 2.PicoohmsCentimeter); + + [Fact] + public void NumberToPicoohmMetersTest() => + Assert.Equal(ElectricResistivity.FromPicoohmMeters(2), 2.PicoohmMeters); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensionsTest.g.cs new file mode 100644 index 0000000000..630ac2a705 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensionsTest.g.cs @@ -0,0 +1,40 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToElectricSurfaceChargeDensity; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToElectricSurfaceChargeDensityExtensionsTests + { + [Fact] + public void NumberToCoulombsPerSquareCentimeterTest() => + Assert.Equal(ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(2), 2.CoulombsPerSquareCentimeter); + + [Fact] + public void NumberToCoulombsPerSquareInchTest() => + Assert.Equal(ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(2), 2.CoulombsPerSquareInch); + + [Fact] + public void NumberToCoulombsPerSquareMeterTest() => + Assert.Equal(ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(2), 2.CoulombsPerSquareMeter); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricSusceptanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricSusceptanceExtensionsTest.g.cs new file mode 100644 index 0000000000..bd1b3b8fc7 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToElectricSusceptanceExtensionsTest.g.cs @@ -0,0 +1,92 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToElectricSusceptance; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToElectricSusceptanceExtensionsTests + { + [Fact] + public void NumberToGigamhosTest() => + Assert.Equal(ElectricSusceptance.FromGigamhos(2), 2.Gigamhos); + + [Fact] + public void NumberToGigasiemensTest() => + Assert.Equal(ElectricSusceptance.FromGigasiemens(2), 2.Gigasiemens); + + [Fact] + public void NumberToKilomhosTest() => + Assert.Equal(ElectricSusceptance.FromKilomhos(2), 2.Kilomhos); + + [Fact] + public void NumberToKilosiemensTest() => + Assert.Equal(ElectricSusceptance.FromKilosiemens(2), 2.Kilosiemens); + + [Fact] + public void NumberToMegamhosTest() => + Assert.Equal(ElectricSusceptance.FromMegamhos(2), 2.Megamhos); + + [Fact] + public void NumberToMegasiemensTest() => + Assert.Equal(ElectricSusceptance.FromMegasiemens(2), 2.Megasiemens); + + [Fact] + public void NumberToMhosTest() => + Assert.Equal(ElectricSusceptance.FromMhos(2), 2.Mhos); + + [Fact] + public void NumberToMicromhosTest() => + Assert.Equal(ElectricSusceptance.FromMicromhos(2), 2.Micromhos); + + [Fact] + public void NumberToMicrosiemensTest() => + Assert.Equal(ElectricSusceptance.FromMicrosiemens(2), 2.Microsiemens); + + [Fact] + public void NumberToMillimhosTest() => + Assert.Equal(ElectricSusceptance.FromMillimhos(2), 2.Millimhos); + + [Fact] + public void NumberToMillisiemensTest() => + Assert.Equal(ElectricSusceptance.FromMillisiemens(2), 2.Millisiemens); + + [Fact] + public void NumberToNanomhosTest() => + Assert.Equal(ElectricSusceptance.FromNanomhos(2), 2.Nanomhos); + + [Fact] + public void NumberToNanosiemensTest() => + Assert.Equal(ElectricSusceptance.FromNanosiemens(2), 2.Nanosiemens); + + [Fact] + public void NumberToSiemensTest() => + Assert.Equal(ElectricSusceptance.FromSiemens(2), 2.Siemens); + + [Fact] + public void NumberToTeramhosTest() => + Assert.Equal(ElectricSusceptance.FromTeramhos(2), 2.Teramhos); + + [Fact] + public void NumberToTerasiemensTest() => + Assert.Equal(ElectricSusceptance.FromTerasiemens(2), 2.Terasiemens); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToEnergyDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToEnergyDensityExtensionsTest.g.cs new file mode 100644 index 0000000000..651c86b5a7 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToEnergyDensityExtensionsTest.g.cs @@ -0,0 +1,76 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToEnergyDensity; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToEnergyDensityExtensionsTests + { + [Fact] + public void NumberToGigajoulesPerCubicMeterTest() => + Assert.Equal(EnergyDensity.FromGigajoulesPerCubicMeter(2), 2.GigajoulesPerCubicMeter); + + [Fact] + public void NumberToGigawattHoursPerCubicMeterTest() => + Assert.Equal(EnergyDensity.FromGigawattHoursPerCubicMeter(2), 2.GigawattHoursPerCubicMeter); + + [Fact] + public void NumberToJoulesPerCubicMeterTest() => + Assert.Equal(EnergyDensity.FromJoulesPerCubicMeter(2), 2.JoulesPerCubicMeter); + + [Fact] + public void NumberToKilojoulesPerCubicMeterTest() => + Assert.Equal(EnergyDensity.FromKilojoulesPerCubicMeter(2), 2.KilojoulesPerCubicMeter); + + [Fact] + public void NumberToKilowattHoursPerCubicMeterTest() => + Assert.Equal(EnergyDensity.FromKilowattHoursPerCubicMeter(2), 2.KilowattHoursPerCubicMeter); + + [Fact] + public void NumberToMegajoulesPerCubicMeterTest() => + Assert.Equal(EnergyDensity.FromMegajoulesPerCubicMeter(2), 2.MegajoulesPerCubicMeter); + + [Fact] + public void NumberToMegawattHoursPerCubicMeterTest() => + Assert.Equal(EnergyDensity.FromMegawattHoursPerCubicMeter(2), 2.MegawattHoursPerCubicMeter); + + [Fact] + public void NumberToPetajoulesPerCubicMeterTest() => + Assert.Equal(EnergyDensity.FromPetajoulesPerCubicMeter(2), 2.PetajoulesPerCubicMeter); + + [Fact] + public void NumberToPetawattHoursPerCubicMeterTest() => + Assert.Equal(EnergyDensity.FromPetawattHoursPerCubicMeter(2), 2.PetawattHoursPerCubicMeter); + + [Fact] + public void NumberToTerajoulesPerCubicMeterTest() => + Assert.Equal(EnergyDensity.FromTerajoulesPerCubicMeter(2), 2.TerajoulesPerCubicMeter); + + [Fact] + public void NumberToTerawattHoursPerCubicMeterTest() => + Assert.Equal(EnergyDensity.FromTerawattHoursPerCubicMeter(2), 2.TerawattHoursPerCubicMeter); + + [Fact] + public void NumberToWattHoursPerCubicMeterTest() => + Assert.Equal(EnergyDensity.FromWattHoursPerCubicMeter(2), 2.WattHoursPerCubicMeter); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToEnergyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToEnergyExtensionsTest.g.cs new file mode 100644 index 0000000000..5e6c9077b0 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToEnergyExtensionsTest.g.cs @@ -0,0 +1,188 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToEnergy; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToEnergyExtensionsTests + { + [Fact] + public void NumberToBritishThermalUnitsTest() => + Assert.Equal(Energy.FromBritishThermalUnits(2), 2.BritishThermalUnits); + + [Fact] + public void NumberToCaloriesTest() => + Assert.Equal(Energy.FromCalories(2), 2.Calories); + + [Fact] + public void NumberToDecathermsEcTest() => + Assert.Equal(Energy.FromDecathermsEc(2), 2.DecathermsEc); + + [Fact] + public void NumberToDecathermsImperialTest() => + Assert.Equal(Energy.FromDecathermsImperial(2), 2.DecathermsImperial); + + [Fact] + public void NumberToDecathermsUsTest() => + Assert.Equal(Energy.FromDecathermsUs(2), 2.DecathermsUs); + + [Fact] + public void NumberToElectronVoltsTest() => + Assert.Equal(Energy.FromElectronVolts(2), 2.ElectronVolts); + + [Fact] + public void NumberToErgsTest() => + Assert.Equal(Energy.FromErgs(2), 2.Ergs); + + [Fact] + public void NumberToFootPoundsTest() => + Assert.Equal(Energy.FromFootPounds(2), 2.FootPounds); + + [Fact] + public void NumberToGigabritishThermalUnitsTest() => + Assert.Equal(Energy.FromGigabritishThermalUnits(2), 2.GigabritishThermalUnits); + + [Fact] + public void NumberToGigaelectronVoltsTest() => + Assert.Equal(Energy.FromGigaelectronVolts(2), 2.GigaelectronVolts); + + [Fact] + public void NumberToGigajoulesTest() => + Assert.Equal(Energy.FromGigajoules(2), 2.Gigajoules); + + [Fact] + public void NumberToGigawattDaysTest() => + Assert.Equal(Energy.FromGigawattDays(2), 2.GigawattDays); + + [Fact] + public void NumberToGigawattHoursTest() => + Assert.Equal(Energy.FromGigawattHours(2), 2.GigawattHours); + + [Fact] + public void NumberToHorsepowerHoursTest() => + Assert.Equal(Energy.FromHorsepowerHours(2), 2.HorsepowerHours); + + [Fact] + public void NumberToJoulesTest() => + Assert.Equal(Energy.FromJoules(2), 2.Joules); + + [Fact] + public void NumberToKilobritishThermalUnitsTest() => + Assert.Equal(Energy.FromKilobritishThermalUnits(2), 2.KilobritishThermalUnits); + + [Fact] + public void NumberToKilocaloriesTest() => + Assert.Equal(Energy.FromKilocalories(2), 2.Kilocalories); + + [Fact] + public void NumberToKiloelectronVoltsTest() => + Assert.Equal(Energy.FromKiloelectronVolts(2), 2.KiloelectronVolts); + + [Fact] + public void NumberToKilojoulesTest() => + Assert.Equal(Energy.FromKilojoules(2), 2.Kilojoules); + + [Fact] + public void NumberToKilowattDaysTest() => + Assert.Equal(Energy.FromKilowattDays(2), 2.KilowattDays); + + [Fact] + public void NumberToKilowattHoursTest() => + Assert.Equal(Energy.FromKilowattHours(2), 2.KilowattHours); + + [Fact] + public void NumberToMegabritishThermalUnitsTest() => + Assert.Equal(Energy.FromMegabritishThermalUnits(2), 2.MegabritishThermalUnits); + + [Fact] + public void NumberToMegacaloriesTest() => + Assert.Equal(Energy.FromMegacalories(2), 2.Megacalories); + + [Fact] + public void NumberToMegaelectronVoltsTest() => + Assert.Equal(Energy.FromMegaelectronVolts(2), 2.MegaelectronVolts); + + [Fact] + public void NumberToMegajoulesTest() => + Assert.Equal(Energy.FromMegajoules(2), 2.Megajoules); + + [Fact] + public void NumberToMegawattDaysTest() => + Assert.Equal(Energy.FromMegawattDays(2), 2.MegawattDays); + + [Fact] + public void NumberToMegawattHoursTest() => + Assert.Equal(Energy.FromMegawattHours(2), 2.MegawattHours); + + [Fact] + public void NumberToMicrojoulesTest() => + Assert.Equal(Energy.FromMicrojoules(2), 2.Microjoules); + + [Fact] + public void NumberToMillijoulesTest() => + Assert.Equal(Energy.FromMillijoules(2), 2.Millijoules); + + [Fact] + public void NumberToNanojoulesTest() => + Assert.Equal(Energy.FromNanojoules(2), 2.Nanojoules); + + [Fact] + public void NumberToPetajoulesTest() => + Assert.Equal(Energy.FromPetajoules(2), 2.Petajoules); + + [Fact] + public void NumberToTeraelectronVoltsTest() => + Assert.Equal(Energy.FromTeraelectronVolts(2), 2.TeraelectronVolts); + + [Fact] + public void NumberToTerajoulesTest() => + Assert.Equal(Energy.FromTerajoules(2), 2.Terajoules); + + [Fact] + public void NumberToTerawattDaysTest() => + Assert.Equal(Energy.FromTerawattDays(2), 2.TerawattDays); + + [Fact] + public void NumberToTerawattHoursTest() => + Assert.Equal(Energy.FromTerawattHours(2), 2.TerawattHours); + + [Fact] + public void NumberToThermsEcTest() => + Assert.Equal(Energy.FromThermsEc(2), 2.ThermsEc); + + [Fact] + public void NumberToThermsImperialTest() => + Assert.Equal(Energy.FromThermsImperial(2), 2.ThermsImperial); + + [Fact] + public void NumberToThermsUsTest() => + Assert.Equal(Energy.FromThermsUs(2), 2.ThermsUs); + + [Fact] + public void NumberToWattDaysTest() => + Assert.Equal(Energy.FromWattDays(2), 2.WattDays); + + [Fact] + public void NumberToWattHoursTest() => + Assert.Equal(Energy.FromWattHours(2), 2.WattHours); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToEntropyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToEntropyExtensionsTest.g.cs new file mode 100644 index 0000000000..70438648ad --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToEntropyExtensionsTest.g.cs @@ -0,0 +1,56 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToEntropy; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToEntropyExtensionsTests + { + [Fact] + public void NumberToCaloriesPerKelvinTest() => + Assert.Equal(Entropy.FromCaloriesPerKelvin(2), 2.CaloriesPerKelvin); + + [Fact] + public void NumberToJoulesPerDegreeCelsiusTest() => + Assert.Equal(Entropy.FromJoulesPerDegreeCelsius(2), 2.JoulesPerDegreeCelsius); + + [Fact] + public void NumberToJoulesPerKelvinTest() => + Assert.Equal(Entropy.FromJoulesPerKelvin(2), 2.JoulesPerKelvin); + + [Fact] + public void NumberToKilocaloriesPerKelvinTest() => + Assert.Equal(Entropy.FromKilocaloriesPerKelvin(2), 2.KilocaloriesPerKelvin); + + [Fact] + public void NumberToKilojoulesPerDegreeCelsiusTest() => + Assert.Equal(Entropy.FromKilojoulesPerDegreeCelsius(2), 2.KilojoulesPerDegreeCelsius); + + [Fact] + public void NumberToKilojoulesPerKelvinTest() => + Assert.Equal(Entropy.FromKilojoulesPerKelvin(2), 2.KilojoulesPerKelvin); + + [Fact] + public void NumberToMegajoulesPerKelvinTest() => + Assert.Equal(Entropy.FromMegajoulesPerKelvin(2), 2.MegajoulesPerKelvin); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToFluidResistanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToFluidResistanceExtensionsTest.g.cs new file mode 100644 index 0000000000..b3295ab649 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToFluidResistanceExtensionsTest.g.cs @@ -0,0 +1,104 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToFluidResistance; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToFluidResistanceExtensionsTests + { + [Fact] + public void NumberToDyneSecondsPerCentimeterToTheFifthTest() => + Assert.Equal(FluidResistance.FromDyneSecondsPerCentimeterToTheFifth(2), 2.DyneSecondsPerCentimeterToTheFifth); + + [Fact] + public void NumberToMegapascalSecondsPerCubicMeterTest() => + Assert.Equal(FluidResistance.FromMegapascalSecondsPerCubicMeter(2), 2.MegapascalSecondsPerCubicMeter); + + [Fact] + public void NumberToMillimeterMercuryMinutesPerCubicCentimeterTest() => + Assert.Equal(FluidResistance.FromMillimeterMercuryMinutesPerCubicCentimeter(2), 2.MillimeterMercuryMinutesPerCubicCentimeter); + + [Fact] + public void NumberToMillimeterMercuryMinutesPerCubicMeterTest() => + Assert.Equal(FluidResistance.FromMillimeterMercuryMinutesPerCubicMeter(2), 2.MillimeterMercuryMinutesPerCubicMeter); + + [Fact] + public void NumberToMillimeterMercuryMinutesPerLiterTest() => + Assert.Equal(FluidResistance.FromMillimeterMercuryMinutesPerLiter(2), 2.MillimeterMercuryMinutesPerLiter); + + [Fact] + public void NumberToMillimeterMercuryMinutesPerMilliliterTest() => + Assert.Equal(FluidResistance.FromMillimeterMercuryMinutesPerMilliliter(2), 2.MillimeterMercuryMinutesPerMilliliter); + + [Fact] + public void NumberToMillimeterMercurySecondsPerCubicCentimeterTest() => + Assert.Equal(FluidResistance.FromMillimeterMercurySecondsPerCubicCentimeter(2), 2.MillimeterMercurySecondsPerCubicCentimeter); + + [Fact] + public void NumberToMillimeterMercurySecondsPerCubicMeterTest() => + Assert.Equal(FluidResistance.FromMillimeterMercurySecondsPerCubicMeter(2), 2.MillimeterMercurySecondsPerCubicMeter); + + [Fact] + public void NumberToMillimeterMercurySecondsPerLiterTest() => + Assert.Equal(FluidResistance.FromMillimeterMercurySecondsPerLiter(2), 2.MillimeterMercurySecondsPerLiter); + + [Fact] + public void NumberToMillimeterMercurySecondsPerMilliliterTest() => + Assert.Equal(FluidResistance.FromMillimeterMercurySecondsPerMilliliter(2), 2.MillimeterMercurySecondsPerMilliliter); + + [Fact] + public void NumberToPascalMinutesPerCubicCentimeterTest() => + Assert.Equal(FluidResistance.FromPascalMinutesPerCubicCentimeter(2), 2.PascalMinutesPerCubicCentimeter); + + [Fact] + public void NumberToPascalMinutesPerCubicMeterTest() => + Assert.Equal(FluidResistance.FromPascalMinutesPerCubicMeter(2), 2.PascalMinutesPerCubicMeter); + + [Fact] + public void NumberToPascalMinutesPerLiterTest() => + Assert.Equal(FluidResistance.FromPascalMinutesPerLiter(2), 2.PascalMinutesPerLiter); + + [Fact] + public void NumberToPascalMinutesPerMilliliterTest() => + Assert.Equal(FluidResistance.FromPascalMinutesPerMilliliter(2), 2.PascalMinutesPerMilliliter); + + [Fact] + public void NumberToPascalSecondsPerCubicCentimeterTest() => + Assert.Equal(FluidResistance.FromPascalSecondsPerCubicCentimeter(2), 2.PascalSecondsPerCubicCentimeter); + + [Fact] + public void NumberToPascalSecondsPerCubicMeterTest() => + Assert.Equal(FluidResistance.FromPascalSecondsPerCubicMeter(2), 2.PascalSecondsPerCubicMeter); + + [Fact] + public void NumberToPascalSecondsPerLiterTest() => + Assert.Equal(FluidResistance.FromPascalSecondsPerLiter(2), 2.PascalSecondsPerLiter); + + [Fact] + public void NumberToPascalSecondsPerMilliliterTest() => + Assert.Equal(FluidResistance.FromPascalSecondsPerMilliliter(2), 2.PascalSecondsPerMilliliter); + + [Fact] + public void NumberToWoodUnitsTest() => + Assert.Equal(FluidResistance.FromWoodUnits(2), 2.WoodUnits); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToForceChangeRateExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToForceChangeRateExtensionsTest.g.cs new file mode 100644 index 0000000000..0d057c89f9 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToForceChangeRateExtensionsTest.g.cs @@ -0,0 +1,88 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToForceChangeRate; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToForceChangeRateExtensionsTests + { + [Fact] + public void NumberToCentinewtonsPerSecondTest() => + Assert.Equal(ForceChangeRate.FromCentinewtonsPerSecond(2), 2.CentinewtonsPerSecond); + + [Fact] + public void NumberToDecanewtonsPerMinuteTest() => + Assert.Equal(ForceChangeRate.FromDecanewtonsPerMinute(2), 2.DecanewtonsPerMinute); + + [Fact] + public void NumberToDecanewtonsPerSecondTest() => + Assert.Equal(ForceChangeRate.FromDecanewtonsPerSecond(2), 2.DecanewtonsPerSecond); + + [Fact] + public void NumberToDecinewtonsPerSecondTest() => + Assert.Equal(ForceChangeRate.FromDecinewtonsPerSecond(2), 2.DecinewtonsPerSecond); + + [Fact] + public void NumberToKilonewtonsPerMinuteTest() => + Assert.Equal(ForceChangeRate.FromKilonewtonsPerMinute(2), 2.KilonewtonsPerMinute); + + [Fact] + public void NumberToKilonewtonsPerSecondTest() => + Assert.Equal(ForceChangeRate.FromKilonewtonsPerSecond(2), 2.KilonewtonsPerSecond); + + [Fact] + public void NumberToKilopoundsForcePerMinuteTest() => + Assert.Equal(ForceChangeRate.FromKilopoundsForcePerMinute(2), 2.KilopoundsForcePerMinute); + + [Fact] + public void NumberToKilopoundsForcePerSecondTest() => + Assert.Equal(ForceChangeRate.FromKilopoundsForcePerSecond(2), 2.KilopoundsForcePerSecond); + + [Fact] + public void NumberToMicronewtonsPerSecondTest() => + Assert.Equal(ForceChangeRate.FromMicronewtonsPerSecond(2), 2.MicronewtonsPerSecond); + + [Fact] + public void NumberToMillinewtonsPerSecondTest() => + Assert.Equal(ForceChangeRate.FromMillinewtonsPerSecond(2), 2.MillinewtonsPerSecond); + + [Fact] + public void NumberToNanonewtonsPerSecondTest() => + Assert.Equal(ForceChangeRate.FromNanonewtonsPerSecond(2), 2.NanonewtonsPerSecond); + + [Fact] + public void NumberToNewtonsPerMinuteTest() => + Assert.Equal(ForceChangeRate.FromNewtonsPerMinute(2), 2.NewtonsPerMinute); + + [Fact] + public void NumberToNewtonsPerSecondTest() => + Assert.Equal(ForceChangeRate.FromNewtonsPerSecond(2), 2.NewtonsPerSecond); + + [Fact] + public void NumberToPoundsForcePerMinuteTest() => + Assert.Equal(ForceChangeRate.FromPoundsForcePerMinute(2), 2.PoundsForcePerMinute); + + [Fact] + public void NumberToPoundsForcePerSecondTest() => + Assert.Equal(ForceChangeRate.FromPoundsForcePerSecond(2), 2.PoundsForcePerSecond); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToForceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToForceExtensionsTest.g.cs new file mode 100644 index 0000000000..7dd09f0f2b --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToForceExtensionsTest.g.cs @@ -0,0 +1,88 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToForce; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToForceExtensionsTests + { + [Fact] + public void NumberToDecanewtonsTest() => + Assert.Equal(Force.FromDecanewtons(2), 2.Decanewtons); + + [Fact] + public void NumberToDyneTest() => + Assert.Equal(Force.FromDyne(2), 2.Dyne); + + [Fact] + public void NumberToKilogramsForceTest() => + Assert.Equal(Force.FromKilogramsForce(2), 2.KilogramsForce); + + [Fact] + public void NumberToKilonewtonsTest() => + Assert.Equal(Force.FromKilonewtons(2), 2.Kilonewtons); + + [Fact] + public void NumberToKilopondsTest() => + Assert.Equal(Force.FromKiloponds(2), 2.Kiloponds); + + [Fact] + public void NumberToKilopoundsForceTest() => + Assert.Equal(Force.FromKilopoundsForce(2), 2.KilopoundsForce); + + [Fact] + public void NumberToMeganewtonsTest() => + Assert.Equal(Force.FromMeganewtons(2), 2.Meganewtons); + + [Fact] + public void NumberToMicronewtonsTest() => + Assert.Equal(Force.FromMicronewtons(2), 2.Micronewtons); + + [Fact] + public void NumberToMillinewtonsTest() => + Assert.Equal(Force.FromMillinewtons(2), 2.Millinewtons); + + [Fact] + public void NumberToNewtonsTest() => + Assert.Equal(Force.FromNewtons(2), 2.Newtons); + + [Fact] + public void NumberToOunceForceTest() => + Assert.Equal(Force.FromOunceForce(2), 2.OunceForce); + + [Fact] + public void NumberToPoundalsTest() => + Assert.Equal(Force.FromPoundals(2), 2.Poundals); + + [Fact] + public void NumberToPoundsForceTest() => + Assert.Equal(Force.FromPoundsForce(2), 2.PoundsForce); + + [Fact] + public void NumberToShortTonsForceTest() => + Assert.Equal(Force.FromShortTonsForce(2), 2.ShortTonsForce); + + [Fact] + public void NumberToTonnesForceTest() => + Assert.Equal(Force.FromTonnesForce(2), 2.TonnesForce); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToForcePerLengthExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToForcePerLengthExtensionsTest.g.cs new file mode 100644 index 0000000000..ac43816887 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToForcePerLengthExtensionsTest.g.cs @@ -0,0 +1,180 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToForcePerLength; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToForcePerLengthExtensionsTests + { + [Fact] + public void NumberToCentinewtonsPerCentimeterTest() => + Assert.Equal(ForcePerLength.FromCentinewtonsPerCentimeter(2), 2.CentinewtonsPerCentimeter); + + [Fact] + public void NumberToCentinewtonsPerMeterTest() => + Assert.Equal(ForcePerLength.FromCentinewtonsPerMeter(2), 2.CentinewtonsPerMeter); + + [Fact] + public void NumberToCentinewtonsPerMillimeterTest() => + Assert.Equal(ForcePerLength.FromCentinewtonsPerMillimeter(2), 2.CentinewtonsPerMillimeter); + + [Fact] + public void NumberToDecanewtonsPerCentimeterTest() => + Assert.Equal(ForcePerLength.FromDecanewtonsPerCentimeter(2), 2.DecanewtonsPerCentimeter); + + [Fact] + public void NumberToDecanewtonsPerMeterTest() => + Assert.Equal(ForcePerLength.FromDecanewtonsPerMeter(2), 2.DecanewtonsPerMeter); + + [Fact] + public void NumberToDecanewtonsPerMillimeterTest() => + Assert.Equal(ForcePerLength.FromDecanewtonsPerMillimeter(2), 2.DecanewtonsPerMillimeter); + + [Fact] + public void NumberToDecinewtonsPerCentimeterTest() => + Assert.Equal(ForcePerLength.FromDecinewtonsPerCentimeter(2), 2.DecinewtonsPerCentimeter); + + [Fact] + public void NumberToDecinewtonsPerMeterTest() => + Assert.Equal(ForcePerLength.FromDecinewtonsPerMeter(2), 2.DecinewtonsPerMeter); + + [Fact] + public void NumberToDecinewtonsPerMillimeterTest() => + Assert.Equal(ForcePerLength.FromDecinewtonsPerMillimeter(2), 2.DecinewtonsPerMillimeter); + + [Fact] + public void NumberToKilogramsForcePerCentimeterTest() => + Assert.Equal(ForcePerLength.FromKilogramsForcePerCentimeter(2), 2.KilogramsForcePerCentimeter); + + [Fact] + public void NumberToKilogramsForcePerMeterTest() => + Assert.Equal(ForcePerLength.FromKilogramsForcePerMeter(2), 2.KilogramsForcePerMeter); + + [Fact] + public void NumberToKilogramsForcePerMillimeterTest() => + Assert.Equal(ForcePerLength.FromKilogramsForcePerMillimeter(2), 2.KilogramsForcePerMillimeter); + + [Fact] + public void NumberToKilonewtonsPerCentimeterTest() => + Assert.Equal(ForcePerLength.FromKilonewtonsPerCentimeter(2), 2.KilonewtonsPerCentimeter); + + [Fact] + public void NumberToKilonewtonsPerMeterTest() => + Assert.Equal(ForcePerLength.FromKilonewtonsPerMeter(2), 2.KilonewtonsPerMeter); + + [Fact] + public void NumberToKilonewtonsPerMillimeterTest() => + Assert.Equal(ForcePerLength.FromKilonewtonsPerMillimeter(2), 2.KilonewtonsPerMillimeter); + + [Fact] + public void NumberToKilopoundsForcePerFootTest() => + Assert.Equal(ForcePerLength.FromKilopoundsForcePerFoot(2), 2.KilopoundsForcePerFoot); + + [Fact] + public void NumberToKilopoundsForcePerInchTest() => + Assert.Equal(ForcePerLength.FromKilopoundsForcePerInch(2), 2.KilopoundsForcePerInch); + + [Fact] + public void NumberToMeganewtonsPerCentimeterTest() => + Assert.Equal(ForcePerLength.FromMeganewtonsPerCentimeter(2), 2.MeganewtonsPerCentimeter); + + [Fact] + public void NumberToMeganewtonsPerMeterTest() => + Assert.Equal(ForcePerLength.FromMeganewtonsPerMeter(2), 2.MeganewtonsPerMeter); + + [Fact] + public void NumberToMeganewtonsPerMillimeterTest() => + Assert.Equal(ForcePerLength.FromMeganewtonsPerMillimeter(2), 2.MeganewtonsPerMillimeter); + + [Fact] + public void NumberToMicronewtonsPerCentimeterTest() => + Assert.Equal(ForcePerLength.FromMicronewtonsPerCentimeter(2), 2.MicronewtonsPerCentimeter); + + [Fact] + public void NumberToMicronewtonsPerMeterTest() => + Assert.Equal(ForcePerLength.FromMicronewtonsPerMeter(2), 2.MicronewtonsPerMeter); + + [Fact] + public void NumberToMicronewtonsPerMillimeterTest() => + Assert.Equal(ForcePerLength.FromMicronewtonsPerMillimeter(2), 2.MicronewtonsPerMillimeter); + + [Fact] + public void NumberToMillinewtonsPerCentimeterTest() => + Assert.Equal(ForcePerLength.FromMillinewtonsPerCentimeter(2), 2.MillinewtonsPerCentimeter); + + [Fact] + public void NumberToMillinewtonsPerMeterTest() => + Assert.Equal(ForcePerLength.FromMillinewtonsPerMeter(2), 2.MillinewtonsPerMeter); + + [Fact] + public void NumberToMillinewtonsPerMillimeterTest() => + Assert.Equal(ForcePerLength.FromMillinewtonsPerMillimeter(2), 2.MillinewtonsPerMillimeter); + + [Fact] + public void NumberToNanonewtonsPerCentimeterTest() => + Assert.Equal(ForcePerLength.FromNanonewtonsPerCentimeter(2), 2.NanonewtonsPerCentimeter); + + [Fact] + public void NumberToNanonewtonsPerMeterTest() => + Assert.Equal(ForcePerLength.FromNanonewtonsPerMeter(2), 2.NanonewtonsPerMeter); + + [Fact] + public void NumberToNanonewtonsPerMillimeterTest() => + Assert.Equal(ForcePerLength.FromNanonewtonsPerMillimeter(2), 2.NanonewtonsPerMillimeter); + + [Fact] + public void NumberToNewtonsPerCentimeterTest() => + Assert.Equal(ForcePerLength.FromNewtonsPerCentimeter(2), 2.NewtonsPerCentimeter); + + [Fact] + public void NumberToNewtonsPerMeterTest() => + Assert.Equal(ForcePerLength.FromNewtonsPerMeter(2), 2.NewtonsPerMeter); + + [Fact] + public void NumberToNewtonsPerMillimeterTest() => + Assert.Equal(ForcePerLength.FromNewtonsPerMillimeter(2), 2.NewtonsPerMillimeter); + + [Fact] + public void NumberToPoundsForcePerFootTest() => + Assert.Equal(ForcePerLength.FromPoundsForcePerFoot(2), 2.PoundsForcePerFoot); + + [Fact] + public void NumberToPoundsForcePerInchTest() => + Assert.Equal(ForcePerLength.FromPoundsForcePerInch(2), 2.PoundsForcePerInch); + + [Fact] + public void NumberToPoundsForcePerYardTest() => + Assert.Equal(ForcePerLength.FromPoundsForcePerYard(2), 2.PoundsForcePerYard); + + [Fact] + public void NumberToTonnesForcePerCentimeterTest() => + Assert.Equal(ForcePerLength.FromTonnesForcePerCentimeter(2), 2.TonnesForcePerCentimeter); + + [Fact] + public void NumberToTonnesForcePerMeterTest() => + Assert.Equal(ForcePerLength.FromTonnesForcePerMeter(2), 2.TonnesForcePerMeter); + + [Fact] + public void NumberToTonnesForcePerMillimeterTest() => + Assert.Equal(ForcePerLength.FromTonnesForcePerMillimeter(2), 2.TonnesForcePerMillimeter); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToFrequencyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToFrequencyExtensionsTest.g.cs new file mode 100644 index 0000000000..66368bf900 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToFrequencyExtensionsTest.g.cs @@ -0,0 +1,76 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToFrequency; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToFrequencyExtensionsTests + { + [Fact] + public void NumberToBeatsPerMinuteTest() => + Assert.Equal(Frequency.FromBeatsPerMinute(2), 2.BeatsPerMinute); + + [Fact] + public void NumberToCyclesPerHourTest() => + Assert.Equal(Frequency.FromCyclesPerHour(2), 2.CyclesPerHour); + + [Fact] + public void NumberToCyclesPerMinuteTest() => + Assert.Equal(Frequency.FromCyclesPerMinute(2), 2.CyclesPerMinute); + + [Fact] + public void NumberToGigahertzTest() => + Assert.Equal(Frequency.FromGigahertz(2), 2.Gigahertz); + + [Fact] + public void NumberToHertzTest() => + Assert.Equal(Frequency.FromHertz(2), 2.Hertz); + + [Fact] + public void NumberToKilohertzTest() => + Assert.Equal(Frequency.FromKilohertz(2), 2.Kilohertz); + + [Fact] + public void NumberToMegahertzTest() => + Assert.Equal(Frequency.FromMegahertz(2), 2.Megahertz); + + [Fact] + public void NumberToMicrohertzTest() => + Assert.Equal(Frequency.FromMicrohertz(2), 2.Microhertz); + + [Fact] + public void NumberToMillihertzTest() => + Assert.Equal(Frequency.FromMillihertz(2), 2.Millihertz); + + [Fact] + public void NumberToPerSecondTest() => + Assert.Equal(Frequency.FromPerSecond(2), 2.PerSecond); + + [Fact] + public void NumberToRadiansPerSecondTest() => + Assert.Equal(Frequency.FromRadiansPerSecond(2), 2.RadiansPerSecond); + + [Fact] + public void NumberToTerahertzTest() => + Assert.Equal(Frequency.FromTerahertz(2), 2.Terahertz); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToFuelEfficiencyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToFuelEfficiencyExtensionsTest.g.cs new file mode 100644 index 0000000000..309940fdda --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToFuelEfficiencyExtensionsTest.g.cs @@ -0,0 +1,44 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToFuelEfficiency; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToFuelEfficiencyExtensionsTests + { + [Fact] + public void NumberToKilometersPerLiterTest() => + Assert.Equal(FuelEfficiency.FromKilometersPerLiter(2), 2.KilometersPerLiter); + + [Fact] + public void NumberToLitersPer100KilometersTest() => + Assert.Equal(FuelEfficiency.FromLitersPer100Kilometers(2), 2.LitersPer100Kilometers); + + [Fact] + public void NumberToMilesPerUkGallonTest() => + Assert.Equal(FuelEfficiency.FromMilesPerUkGallon(2), 2.MilesPerUkGallon); + + [Fact] + public void NumberToMilesPerUsGallonTest() => + Assert.Equal(FuelEfficiency.FromMilesPerUsGallon(2), 2.MilesPerUsGallon); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToHeatFluxExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToHeatFluxExtensionsTest.g.cs new file mode 100644 index 0000000000..b085267732 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToHeatFluxExtensionsTest.g.cs @@ -0,0 +1,100 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToHeatFlux; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToHeatFluxExtensionsTests + { + [Fact] + public void NumberToBtusPerHourSquareFootTest() => + Assert.Equal(HeatFlux.FromBtusPerHourSquareFoot(2), 2.BtusPerHourSquareFoot); + + [Fact] + public void NumberToBtusPerMinuteSquareFootTest() => + Assert.Equal(HeatFlux.FromBtusPerMinuteSquareFoot(2), 2.BtusPerMinuteSquareFoot); + + [Fact] + public void NumberToBtusPerSecondSquareFootTest() => + Assert.Equal(HeatFlux.FromBtusPerSecondSquareFoot(2), 2.BtusPerSecondSquareFoot); + + [Fact] + public void NumberToBtusPerSecondSquareInchTest() => + Assert.Equal(HeatFlux.FromBtusPerSecondSquareInch(2), 2.BtusPerSecondSquareInch); + + [Fact] + public void NumberToCaloriesPerSecondSquareCentimeterTest() => + Assert.Equal(HeatFlux.FromCaloriesPerSecondSquareCentimeter(2), 2.CaloriesPerSecondSquareCentimeter); + + [Fact] + public void NumberToCentiwattsPerSquareMeterTest() => + Assert.Equal(HeatFlux.FromCentiwattsPerSquareMeter(2), 2.CentiwattsPerSquareMeter); + + [Fact] + public void NumberToDeciwattsPerSquareMeterTest() => + Assert.Equal(HeatFlux.FromDeciwattsPerSquareMeter(2), 2.DeciwattsPerSquareMeter); + + [Fact] + public void NumberToKilocaloriesPerHourSquareMeterTest() => + Assert.Equal(HeatFlux.FromKilocaloriesPerHourSquareMeter(2), 2.KilocaloriesPerHourSquareMeter); + + [Fact] + public void NumberToKilocaloriesPerSecondSquareCentimeterTest() => + Assert.Equal(HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(2), 2.KilocaloriesPerSecondSquareCentimeter); + + [Fact] + public void NumberToKilowattsPerSquareMeterTest() => + Assert.Equal(HeatFlux.FromKilowattsPerSquareMeter(2), 2.KilowattsPerSquareMeter); + + [Fact] + public void NumberToMicrowattsPerSquareMeterTest() => + Assert.Equal(HeatFlux.FromMicrowattsPerSquareMeter(2), 2.MicrowattsPerSquareMeter); + + [Fact] + public void NumberToMilliwattsPerSquareMeterTest() => + Assert.Equal(HeatFlux.FromMilliwattsPerSquareMeter(2), 2.MilliwattsPerSquareMeter); + + [Fact] + public void NumberToNanowattsPerSquareMeterTest() => + Assert.Equal(HeatFlux.FromNanowattsPerSquareMeter(2), 2.NanowattsPerSquareMeter); + + [Fact] + public void NumberToPoundsForcePerFootSecondTest() => + Assert.Equal(HeatFlux.FromPoundsForcePerFootSecond(2), 2.PoundsForcePerFootSecond); + + [Fact] + public void NumberToPoundsPerSecondCubedTest() => + Assert.Equal(HeatFlux.FromPoundsPerSecondCubed(2), 2.PoundsPerSecondCubed); + + [Fact] + public void NumberToWattsPerSquareFootTest() => + Assert.Equal(HeatFlux.FromWattsPerSquareFoot(2), 2.WattsPerSquareFoot); + + [Fact] + public void NumberToWattsPerSquareInchTest() => + Assert.Equal(HeatFlux.FromWattsPerSquareInch(2), 2.WattsPerSquareInch); + + [Fact] + public void NumberToWattsPerSquareMeterTest() => + Assert.Equal(HeatFlux.FromWattsPerSquareMeter(2), 2.WattsPerSquareMeter); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToHeatTransferCoefficientExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToHeatTransferCoefficientExtensionsTest.g.cs new file mode 100644 index 0000000000..37425e80bf --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToHeatTransferCoefficientExtensionsTest.g.cs @@ -0,0 +1,48 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToHeatTransferCoefficient; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToHeatTransferCoefficientExtensionsTests + { + [Fact] + public void NumberToBtusPerHourSquareFootDegreeFahrenheitTest() => + Assert.Equal(HeatTransferCoefficient.FromBtusPerHourSquareFootDegreeFahrenheit(2), 2.BtusPerHourSquareFootDegreeFahrenheit); + + [Fact] + public void NumberToCaloriesPerHourSquareMeterDegreeCelsiusTest() => + Assert.Equal(HeatTransferCoefficient.FromCaloriesPerHourSquareMeterDegreeCelsius(2), 2.CaloriesPerHourSquareMeterDegreeCelsius); + + [Fact] + public void NumberToKilocaloriesPerHourSquareMeterDegreeCelsiusTest() => + Assert.Equal(HeatTransferCoefficient.FromKilocaloriesPerHourSquareMeterDegreeCelsius(2), 2.KilocaloriesPerHourSquareMeterDegreeCelsius); + + [Fact] + public void NumberToWattsPerSquareMeterCelsiusTest() => + Assert.Equal(HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(2), 2.WattsPerSquareMeterCelsius); + + [Fact] + public void NumberToWattsPerSquareMeterKelvinTest() => + Assert.Equal(HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(2), 2.WattsPerSquareMeterKelvin); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToIlluminanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToIlluminanceExtensionsTest.g.cs new file mode 100644 index 0000000000..f8aabecec7 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToIlluminanceExtensionsTest.g.cs @@ -0,0 +1,44 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToIlluminance; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToIlluminanceExtensionsTests + { + [Fact] + public void NumberToKiloluxTest() => + Assert.Equal(Illuminance.FromKilolux(2), 2.Kilolux); + + [Fact] + public void NumberToLuxTest() => + Assert.Equal(Illuminance.FromLux(2), 2.Lux); + + [Fact] + public void NumberToMegaluxTest() => + Assert.Equal(Illuminance.FromMegalux(2), 2.Megalux); + + [Fact] + public void NumberToMilliluxTest() => + Assert.Equal(Illuminance.FromMillilux(2), 2.Millilux); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToImpulseExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToImpulseExtensionsTest.g.cs new file mode 100644 index 0000000000..2032f5c2d6 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToImpulseExtensionsTest.g.cs @@ -0,0 +1,80 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToImpulse; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToImpulseExtensionsTests + { + [Fact] + public void NumberToCentinewtonSecondsTest() => + Assert.Equal(Impulse.FromCentinewtonSeconds(2), 2.CentinewtonSeconds); + + [Fact] + public void NumberToDecanewtonSecondsTest() => + Assert.Equal(Impulse.FromDecanewtonSeconds(2), 2.DecanewtonSeconds); + + [Fact] + public void NumberToDecinewtonSecondsTest() => + Assert.Equal(Impulse.FromDecinewtonSeconds(2), 2.DecinewtonSeconds); + + [Fact] + public void NumberToKilogramMetersPerSecondTest() => + Assert.Equal(Impulse.FromKilogramMetersPerSecond(2), 2.KilogramMetersPerSecond); + + [Fact] + public void NumberToKilonewtonSecondsTest() => + Assert.Equal(Impulse.FromKilonewtonSeconds(2), 2.KilonewtonSeconds); + + [Fact] + public void NumberToMeganewtonSecondsTest() => + Assert.Equal(Impulse.FromMeganewtonSeconds(2), 2.MeganewtonSeconds); + + [Fact] + public void NumberToMicronewtonSecondsTest() => + Assert.Equal(Impulse.FromMicronewtonSeconds(2), 2.MicronewtonSeconds); + + [Fact] + public void NumberToMillinewtonSecondsTest() => + Assert.Equal(Impulse.FromMillinewtonSeconds(2), 2.MillinewtonSeconds); + + [Fact] + public void NumberToNanonewtonSecondsTest() => + Assert.Equal(Impulse.FromNanonewtonSeconds(2), 2.NanonewtonSeconds); + + [Fact] + public void NumberToNewtonSecondsTest() => + Assert.Equal(Impulse.FromNewtonSeconds(2), 2.NewtonSeconds); + + [Fact] + public void NumberToPoundFeetPerSecondTest() => + Assert.Equal(Impulse.FromPoundFeetPerSecond(2), 2.PoundFeetPerSecond); + + [Fact] + public void NumberToPoundForceSecondsTest() => + Assert.Equal(Impulse.FromPoundForceSeconds(2), 2.PoundForceSeconds); + + [Fact] + public void NumberToSlugFeetPerSecondTest() => + Assert.Equal(Impulse.FromSlugFeetPerSecond(2), 2.SlugFeetPerSecond); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToInformationExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToInformationExtensionsTest.g.cs new file mode 100644 index 0000000000..fab6d2b454 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToInformationExtensionsTest.g.cs @@ -0,0 +1,184 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToInformation; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToInformationExtensionsTests + { + [Fact] + public void NumberToBitsTest() => + Assert.Equal(Information.FromBits(2), 2.Bits); + + [Fact] + public void NumberToBytesTest() => + Assert.Equal(Information.FromBytes(2), 2.Bytes); + + [Fact] + public void NumberToExabitsTest() => + Assert.Equal(Information.FromExabits(2), 2.Exabits); + + [Fact] + public void NumberToExabytesTest() => + Assert.Equal(Information.FromExabytes(2), 2.Exabytes); + + [Fact] + public void NumberToExaoctetsTest() => + Assert.Equal(Information.FromExaoctets(2), 2.Exaoctets); + + [Fact] + public void NumberToExbibitsTest() => + Assert.Equal(Information.FromExbibits(2), 2.Exbibits); + + [Fact] + public void NumberToExbibytesTest() => + Assert.Equal(Information.FromExbibytes(2), 2.Exbibytes); + + [Fact] + public void NumberToExbioctetsTest() => + Assert.Equal(Information.FromExbioctets(2), 2.Exbioctets); + + [Fact] + public void NumberToGibibitsTest() => + Assert.Equal(Information.FromGibibits(2), 2.Gibibits); + + [Fact] + public void NumberToGibibytesTest() => + Assert.Equal(Information.FromGibibytes(2), 2.Gibibytes); + + [Fact] + public void NumberToGibioctetsTest() => + Assert.Equal(Information.FromGibioctets(2), 2.Gibioctets); + + [Fact] + public void NumberToGigabitsTest() => + Assert.Equal(Information.FromGigabits(2), 2.Gigabits); + + [Fact] + public void NumberToGigabytesTest() => + Assert.Equal(Information.FromGigabytes(2), 2.Gigabytes); + + [Fact] + public void NumberToGigaoctetsTest() => + Assert.Equal(Information.FromGigaoctets(2), 2.Gigaoctets); + + [Fact] + public void NumberToKibibitsTest() => + Assert.Equal(Information.FromKibibits(2), 2.Kibibits); + + [Fact] + public void NumberToKibibytesTest() => + Assert.Equal(Information.FromKibibytes(2), 2.Kibibytes); + + [Fact] + public void NumberToKibioctetsTest() => + Assert.Equal(Information.FromKibioctets(2), 2.Kibioctets); + + [Fact] + public void NumberToKilobitsTest() => + Assert.Equal(Information.FromKilobits(2), 2.Kilobits); + + [Fact] + public void NumberToKilobytesTest() => + Assert.Equal(Information.FromKilobytes(2), 2.Kilobytes); + + [Fact] + public void NumberToKilooctetsTest() => + Assert.Equal(Information.FromKilooctets(2), 2.Kilooctets); + + [Fact] + public void NumberToMebibitsTest() => + Assert.Equal(Information.FromMebibits(2), 2.Mebibits); + + [Fact] + public void NumberToMebibytesTest() => + Assert.Equal(Information.FromMebibytes(2), 2.Mebibytes); + + [Fact] + public void NumberToMebioctetsTest() => + Assert.Equal(Information.FromMebioctets(2), 2.Mebioctets); + + [Fact] + public void NumberToMegabitsTest() => + Assert.Equal(Information.FromMegabits(2), 2.Megabits); + + [Fact] + public void NumberToMegabytesTest() => + Assert.Equal(Information.FromMegabytes(2), 2.Megabytes); + + [Fact] + public void NumberToMegaoctetsTest() => + Assert.Equal(Information.FromMegaoctets(2), 2.Megaoctets); + + [Fact] + public void NumberToOctetsTest() => + Assert.Equal(Information.FromOctets(2), 2.Octets); + + [Fact] + public void NumberToPebibitsTest() => + Assert.Equal(Information.FromPebibits(2), 2.Pebibits); + + [Fact] + public void NumberToPebibytesTest() => + Assert.Equal(Information.FromPebibytes(2), 2.Pebibytes); + + [Fact] + public void NumberToPebioctetsTest() => + Assert.Equal(Information.FromPebioctets(2), 2.Pebioctets); + + [Fact] + public void NumberToPetabitsTest() => + Assert.Equal(Information.FromPetabits(2), 2.Petabits); + + [Fact] + public void NumberToPetabytesTest() => + Assert.Equal(Information.FromPetabytes(2), 2.Petabytes); + + [Fact] + public void NumberToPetaoctetsTest() => + Assert.Equal(Information.FromPetaoctets(2), 2.Petaoctets); + + [Fact] + public void NumberToTebibitsTest() => + Assert.Equal(Information.FromTebibits(2), 2.Tebibits); + + [Fact] + public void NumberToTebibytesTest() => + Assert.Equal(Information.FromTebibytes(2), 2.Tebibytes); + + [Fact] + public void NumberToTebioctetsTest() => + Assert.Equal(Information.FromTebioctets(2), 2.Tebioctets); + + [Fact] + public void NumberToTerabitsTest() => + Assert.Equal(Information.FromTerabits(2), 2.Terabits); + + [Fact] + public void NumberToTerabytesTest() => + Assert.Equal(Information.FromTerabytes(2), 2.Terabytes); + + [Fact] + public void NumberToTeraoctetsTest() => + Assert.Equal(Information.FromTeraoctets(2), 2.Teraoctets); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToIrradianceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToIrradianceExtensionsTest.g.cs new file mode 100644 index 0000000000..4bce344bf3 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToIrradianceExtensionsTest.g.cs @@ -0,0 +1,84 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToIrradiance; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToIrradianceExtensionsTests + { + [Fact] + public void NumberToKilowattsPerSquareCentimeterTest() => + Assert.Equal(Irradiance.FromKilowattsPerSquareCentimeter(2), 2.KilowattsPerSquareCentimeter); + + [Fact] + public void NumberToKilowattsPerSquareMeterTest() => + Assert.Equal(Irradiance.FromKilowattsPerSquareMeter(2), 2.KilowattsPerSquareMeter); + + [Fact] + public void NumberToMegawattsPerSquareCentimeterTest() => + Assert.Equal(Irradiance.FromMegawattsPerSquareCentimeter(2), 2.MegawattsPerSquareCentimeter); + + [Fact] + public void NumberToMegawattsPerSquareMeterTest() => + Assert.Equal(Irradiance.FromMegawattsPerSquareMeter(2), 2.MegawattsPerSquareMeter); + + [Fact] + public void NumberToMicrowattsPerSquareCentimeterTest() => + Assert.Equal(Irradiance.FromMicrowattsPerSquareCentimeter(2), 2.MicrowattsPerSquareCentimeter); + + [Fact] + public void NumberToMicrowattsPerSquareMeterTest() => + Assert.Equal(Irradiance.FromMicrowattsPerSquareMeter(2), 2.MicrowattsPerSquareMeter); + + [Fact] + public void NumberToMilliwattsPerSquareCentimeterTest() => + Assert.Equal(Irradiance.FromMilliwattsPerSquareCentimeter(2), 2.MilliwattsPerSquareCentimeter); + + [Fact] + public void NumberToMilliwattsPerSquareMeterTest() => + Assert.Equal(Irradiance.FromMilliwattsPerSquareMeter(2), 2.MilliwattsPerSquareMeter); + + [Fact] + public void NumberToNanowattsPerSquareCentimeterTest() => + Assert.Equal(Irradiance.FromNanowattsPerSquareCentimeter(2), 2.NanowattsPerSquareCentimeter); + + [Fact] + public void NumberToNanowattsPerSquareMeterTest() => + Assert.Equal(Irradiance.FromNanowattsPerSquareMeter(2), 2.NanowattsPerSquareMeter); + + [Fact] + public void NumberToPicowattsPerSquareCentimeterTest() => + Assert.Equal(Irradiance.FromPicowattsPerSquareCentimeter(2), 2.PicowattsPerSquareCentimeter); + + [Fact] + public void NumberToPicowattsPerSquareMeterTest() => + Assert.Equal(Irradiance.FromPicowattsPerSquareMeter(2), 2.PicowattsPerSquareMeter); + + [Fact] + public void NumberToWattsPerSquareCentimeterTest() => + Assert.Equal(Irradiance.FromWattsPerSquareCentimeter(2), 2.WattsPerSquareCentimeter); + + [Fact] + public void NumberToWattsPerSquareMeterTest() => + Assert.Equal(Irradiance.FromWattsPerSquareMeter(2), 2.WattsPerSquareMeter); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToIrradiationExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToIrradiationExtensionsTest.g.cs new file mode 100644 index 0000000000..e092c3a5a6 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToIrradiationExtensionsTest.g.cs @@ -0,0 +1,64 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToIrradiation; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToIrradiationExtensionsTests + { + [Fact] + public void NumberToBtusPerSquareFootTest() => + Assert.Equal(Irradiation.FromBtusPerSquareFoot(2), 2.BtusPerSquareFoot); + + [Fact] + public void NumberToJoulesPerSquareCentimeterTest() => + Assert.Equal(Irradiation.FromJoulesPerSquareCentimeter(2), 2.JoulesPerSquareCentimeter); + + [Fact] + public void NumberToJoulesPerSquareMeterTest() => + Assert.Equal(Irradiation.FromJoulesPerSquareMeter(2), 2.JoulesPerSquareMeter); + + [Fact] + public void NumberToJoulesPerSquareMillimeterTest() => + Assert.Equal(Irradiation.FromJoulesPerSquareMillimeter(2), 2.JoulesPerSquareMillimeter); + + [Fact] + public void NumberToKilobtusPerSquareFootTest() => + Assert.Equal(Irradiation.FromKilobtusPerSquareFoot(2), 2.KilobtusPerSquareFoot); + + [Fact] + public void NumberToKilojoulesPerSquareMeterTest() => + Assert.Equal(Irradiation.FromKilojoulesPerSquareMeter(2), 2.KilojoulesPerSquareMeter); + + [Fact] + public void NumberToKilowattHoursPerSquareMeterTest() => + Assert.Equal(Irradiation.FromKilowattHoursPerSquareMeter(2), 2.KilowattHoursPerSquareMeter); + + [Fact] + public void NumberToMillijoulesPerSquareCentimeterTest() => + Assert.Equal(Irradiation.FromMillijoulesPerSquareCentimeter(2), 2.MillijoulesPerSquareCentimeter); + + [Fact] + public void NumberToWattHoursPerSquareMeterTest() => + Assert.Equal(Irradiation.FromWattHoursPerSquareMeter(2), 2.WattHoursPerSquareMeter); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToJerkExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToJerkExtensionsTest.g.cs new file mode 100644 index 0000000000..cb55404b73 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToJerkExtensionsTest.g.cs @@ -0,0 +1,72 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToJerk; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToJerkExtensionsTests + { + [Fact] + public void NumberToCentimetersPerSecondCubedTest() => + Assert.Equal(Jerk.FromCentimetersPerSecondCubed(2), 2.CentimetersPerSecondCubed); + + [Fact] + public void NumberToDecimetersPerSecondCubedTest() => + Assert.Equal(Jerk.FromDecimetersPerSecondCubed(2), 2.DecimetersPerSecondCubed); + + [Fact] + public void NumberToFeetPerSecondCubedTest() => + Assert.Equal(Jerk.FromFeetPerSecondCubed(2), 2.FeetPerSecondCubed); + + [Fact] + public void NumberToInchesPerSecondCubedTest() => + Assert.Equal(Jerk.FromInchesPerSecondCubed(2), 2.InchesPerSecondCubed); + + [Fact] + public void NumberToKilometersPerSecondCubedTest() => + Assert.Equal(Jerk.FromKilometersPerSecondCubed(2), 2.KilometersPerSecondCubed); + + [Fact] + public void NumberToMetersPerSecondCubedTest() => + Assert.Equal(Jerk.FromMetersPerSecondCubed(2), 2.MetersPerSecondCubed); + + [Fact] + public void NumberToMicrometersPerSecondCubedTest() => + Assert.Equal(Jerk.FromMicrometersPerSecondCubed(2), 2.MicrometersPerSecondCubed); + + [Fact] + public void NumberToMillimetersPerSecondCubedTest() => + Assert.Equal(Jerk.FromMillimetersPerSecondCubed(2), 2.MillimetersPerSecondCubed); + + [Fact] + public void NumberToMillistandardGravitiesPerSecondTest() => + Assert.Equal(Jerk.FromMillistandardGravitiesPerSecond(2), 2.MillistandardGravitiesPerSecond); + + [Fact] + public void NumberToNanometersPerSecondCubedTest() => + Assert.Equal(Jerk.FromNanometersPerSecondCubed(2), 2.NanometersPerSecondCubed); + + [Fact] + public void NumberToStandardGravitiesPerSecondTest() => + Assert.Equal(Jerk.FromStandardGravitiesPerSecond(2), 2.StandardGravitiesPerSecond); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToKinematicViscosityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToKinematicViscosityExtensionsTest.g.cs new file mode 100644 index 0000000000..fdf5f250d8 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToKinematicViscosityExtensionsTest.g.cs @@ -0,0 +1,64 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToKinematicViscosity; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToKinematicViscosityExtensionsTests + { + [Fact] + public void NumberToCentistokesTest() => + Assert.Equal(KinematicViscosity.FromCentistokes(2), 2.Centistokes); + + [Fact] + public void NumberToDecistokesTest() => + Assert.Equal(KinematicViscosity.FromDecistokes(2), 2.Decistokes); + + [Fact] + public void NumberToKilostokesTest() => + Assert.Equal(KinematicViscosity.FromKilostokes(2), 2.Kilostokes); + + [Fact] + public void NumberToMicrostokesTest() => + Assert.Equal(KinematicViscosity.FromMicrostokes(2), 2.Microstokes); + + [Fact] + public void NumberToMillistokesTest() => + Assert.Equal(KinematicViscosity.FromMillistokes(2), 2.Millistokes); + + [Fact] + public void NumberToNanostokesTest() => + Assert.Equal(KinematicViscosity.FromNanostokes(2), 2.Nanostokes); + + [Fact] + public void NumberToSquareFeetPerSecondTest() => + Assert.Equal(KinematicViscosity.FromSquareFeetPerSecond(2), 2.SquareFeetPerSecond); + + [Fact] + public void NumberToSquareMetersPerSecondTest() => + Assert.Equal(KinematicViscosity.FromSquareMetersPerSecond(2), 2.SquareMetersPerSecond); + + [Fact] + public void NumberToStokesTest() => + Assert.Equal(KinematicViscosity.FromStokes(2), 2.Stokes); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToLeakRateExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToLeakRateExtensionsTest.g.cs new file mode 100644 index 0000000000..05da6f53db --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToLeakRateExtensionsTest.g.cs @@ -0,0 +1,44 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToLeakRate; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToLeakRateExtensionsTests + { + [Fact] + public void NumberToAtmCubicCentimetersPerSecondTest() => + Assert.Equal(LeakRate.FromAtmCubicCentimetersPerSecond(2), 2.AtmCubicCentimetersPerSecond); + + [Fact] + public void NumberToMillibarLitersPerSecondTest() => + Assert.Equal(LeakRate.FromMillibarLitersPerSecond(2), 2.MillibarLitersPerSecond); + + [Fact] + public void NumberToPascalCubicMetersPerSecondTest() => + Assert.Equal(LeakRate.FromPascalCubicMetersPerSecond(2), 2.PascalCubicMetersPerSecond); + + [Fact] + public void NumberToTorrLitersPerSecondTest() => + Assert.Equal(LeakRate.FromTorrLitersPerSecond(2), 2.TorrLitersPerSecond); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToLengthExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToLengthExtensionsTest.g.cs new file mode 100644 index 0000000000..5a97dae152 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToLengthExtensionsTest.g.cs @@ -0,0 +1,196 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToLength; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToLengthExtensionsTests + { + [Fact] + public void NumberToAngstromsTest() => + Assert.Equal(Length.FromAngstroms(2), 2.Angstroms); + + [Fact] + public void NumberToAstronomicalUnitsTest() => + Assert.Equal(Length.FromAstronomicalUnits(2), 2.AstronomicalUnits); + + [Fact] + public void NumberToCentimetersTest() => + Assert.Equal(Length.FromCentimeters(2), 2.Centimeters); + + [Fact] + public void NumberToChainsTest() => + Assert.Equal(Length.FromChains(2), 2.Chains); + + [Fact] + public void NumberToDataMilesTest() => + Assert.Equal(Length.FromDataMiles(2), 2.DataMiles); + + [Fact] + public void NumberToDecametersTest() => + Assert.Equal(Length.FromDecameters(2), 2.Decameters); + + [Fact] + public void NumberToDecimetersTest() => + Assert.Equal(Length.FromDecimeters(2), 2.Decimeters); + + [Fact] + public void NumberToDtpPicasTest() => + Assert.Equal(Length.FromDtpPicas(2), 2.DtpPicas); + + [Fact] + public void NumberToDtpPointsTest() => + Assert.Equal(Length.FromDtpPoints(2), 2.DtpPoints); + + [Fact] + public void NumberToFathomsTest() => + Assert.Equal(Length.FromFathoms(2), 2.Fathoms); + + [Fact] + public void NumberToFemtometersTest() => + Assert.Equal(Length.FromFemtometers(2), 2.Femtometers); + + [Fact] + public void NumberToFeetTest() => + Assert.Equal(Length.FromFeet(2), 2.Feet); + + [Fact] + public void NumberToGigametersTest() => + Assert.Equal(Length.FromGigameters(2), 2.Gigameters); + + [Fact] + public void NumberToHandsTest() => + Assert.Equal(Length.FromHands(2), 2.Hands); + + [Fact] + public void NumberToHectometersTest() => + Assert.Equal(Length.FromHectometers(2), 2.Hectometers); + + [Fact] + public void NumberToInchesTest() => + Assert.Equal(Length.FromInches(2), 2.Inches); + + [Fact] + public void NumberToKilofeetTest() => + Assert.Equal(Length.FromKilofeet(2), 2.Kilofeet); + + [Fact] + public void NumberToKilolightYearsTest() => + Assert.Equal(Length.FromKilolightYears(2), 2.KilolightYears); + + [Fact] + public void NumberToKilometersTest() => + Assert.Equal(Length.FromKilometers(2), 2.Kilometers); + + [Fact] + public void NumberToKiloparsecsTest() => + Assert.Equal(Length.FromKiloparsecs(2), 2.Kiloparsecs); + + [Fact] + public void NumberToKiloyardsTest() => + Assert.Equal(Length.FromKiloyards(2), 2.Kiloyards); + + [Fact] + public void NumberToLightYearsTest() => + Assert.Equal(Length.FromLightYears(2), 2.LightYears); + + [Fact] + public void NumberToMegalightYearsTest() => + Assert.Equal(Length.FromMegalightYears(2), 2.MegalightYears); + + [Fact] + public void NumberToMegametersTest() => + Assert.Equal(Length.FromMegameters(2), 2.Megameters); + + [Fact] + public void NumberToMegaparsecsTest() => + Assert.Equal(Length.FromMegaparsecs(2), 2.Megaparsecs); + + [Fact] + public void NumberToMetersTest() => + Assert.Equal(Length.FromMeters(2), 2.Meters); + + [Fact] + public void NumberToMicroinchesTest() => + Assert.Equal(Length.FromMicroinches(2), 2.Microinches); + + [Fact] + public void NumberToMicrometersTest() => + Assert.Equal(Length.FromMicrometers(2), 2.Micrometers); + + [Fact] + public void NumberToMilsTest() => + Assert.Equal(Length.FromMils(2), 2.Mils); + + [Fact] + public void NumberToMilesTest() => + Assert.Equal(Length.FromMiles(2), 2.Miles); + + [Fact] + public void NumberToMillimetersTest() => + Assert.Equal(Length.FromMillimeters(2), 2.Millimeters); + + [Fact] + public void NumberToNanometersTest() => + Assert.Equal(Length.FromNanometers(2), 2.Nanometers); + + [Fact] + public void NumberToNauticalMilesTest() => + Assert.Equal(Length.FromNauticalMiles(2), 2.NauticalMiles); + + [Fact] + public void NumberToParsecsTest() => + Assert.Equal(Length.FromParsecs(2), 2.Parsecs); + + [Fact] + public void NumberToPicometersTest() => + Assert.Equal(Length.FromPicometers(2), 2.Picometers); + + [Fact] + public void NumberToPrinterPicasTest() => + Assert.Equal(Length.FromPrinterPicas(2), 2.PrinterPicas); + + [Fact] + public void NumberToPrinterPointsTest() => + Assert.Equal(Length.FromPrinterPoints(2), 2.PrinterPoints); + + [Fact] + public void NumberToShacklesTest() => + Assert.Equal(Length.FromShackles(2), 2.Shackles); + + [Fact] + public void NumberToSolarRadiusesTest() => + Assert.Equal(Length.FromSolarRadiuses(2), 2.SolarRadiuses); + + [Fact] + public void NumberToTwipsTest() => + Assert.Equal(Length.FromTwips(2), 2.Twips); + + [Fact] + public void NumberToUsSurveyFeetTest() => + Assert.Equal(Length.FromUsSurveyFeet(2), 2.UsSurveyFeet); + + [Fact] + public void NumberToYardsTest() => + Assert.Equal(Length.FromYards(2), 2.Yards); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToLevelExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToLevelExtensionsTest.g.cs new file mode 100644 index 0000000000..4f5d945998 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToLevelExtensionsTest.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 UnitsNet.NumberExtensions.NumberToLevel; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToLevelExtensionsTests + { + [Fact] + public void NumberToDecibelsTest() => + Assert.Equal(Level.FromDecibels(2), 2.Decibels); + + [Fact] + public void NumberToNepersTest() => + Assert.Equal(Level.FromNepers(2), 2.Nepers); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToLinearDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToLinearDensityExtensionsTest.g.cs new file mode 100644 index 0000000000..2f7b66338e --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToLinearDensityExtensionsTest.g.cs @@ -0,0 +1,100 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToLinearDensity; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToLinearDensityExtensionsTests + { + [Fact] + public void NumberToGramsPerCentimeterTest() => + Assert.Equal(LinearDensity.FromGramsPerCentimeter(2), 2.GramsPerCentimeter); + + [Fact] + public void NumberToGramsPerFootTest() => + Assert.Equal(LinearDensity.FromGramsPerFoot(2), 2.GramsPerFoot); + + [Fact] + public void NumberToGramsPerMeterTest() => + Assert.Equal(LinearDensity.FromGramsPerMeter(2), 2.GramsPerMeter); + + [Fact] + public void NumberToGramsPerMillimeterTest() => + Assert.Equal(LinearDensity.FromGramsPerMillimeter(2), 2.GramsPerMillimeter); + + [Fact] + public void NumberToKilogramsPerCentimeterTest() => + Assert.Equal(LinearDensity.FromKilogramsPerCentimeter(2), 2.KilogramsPerCentimeter); + + [Fact] + public void NumberToKilogramsPerFootTest() => + Assert.Equal(LinearDensity.FromKilogramsPerFoot(2), 2.KilogramsPerFoot); + + [Fact] + public void NumberToKilogramsPerMeterTest() => + Assert.Equal(LinearDensity.FromKilogramsPerMeter(2), 2.KilogramsPerMeter); + + [Fact] + public void NumberToKilogramsPerMillimeterTest() => + Assert.Equal(LinearDensity.FromKilogramsPerMillimeter(2), 2.KilogramsPerMillimeter); + + [Fact] + public void NumberToMicrogramsPerCentimeterTest() => + Assert.Equal(LinearDensity.FromMicrogramsPerCentimeter(2), 2.MicrogramsPerCentimeter); + + [Fact] + public void NumberToMicrogramsPerFootTest() => + Assert.Equal(LinearDensity.FromMicrogramsPerFoot(2), 2.MicrogramsPerFoot); + + [Fact] + public void NumberToMicrogramsPerMeterTest() => + Assert.Equal(LinearDensity.FromMicrogramsPerMeter(2), 2.MicrogramsPerMeter); + + [Fact] + public void NumberToMicrogramsPerMillimeterTest() => + Assert.Equal(LinearDensity.FromMicrogramsPerMillimeter(2), 2.MicrogramsPerMillimeter); + + [Fact] + public void NumberToMilligramsPerCentimeterTest() => + Assert.Equal(LinearDensity.FromMilligramsPerCentimeter(2), 2.MilligramsPerCentimeter); + + [Fact] + public void NumberToMilligramsPerFootTest() => + Assert.Equal(LinearDensity.FromMilligramsPerFoot(2), 2.MilligramsPerFoot); + + [Fact] + public void NumberToMilligramsPerMeterTest() => + Assert.Equal(LinearDensity.FromMilligramsPerMeter(2), 2.MilligramsPerMeter); + + [Fact] + public void NumberToMilligramsPerMillimeterTest() => + Assert.Equal(LinearDensity.FromMilligramsPerMillimeter(2), 2.MilligramsPerMillimeter); + + [Fact] + public void NumberToPoundsPerFootTest() => + Assert.Equal(LinearDensity.FromPoundsPerFoot(2), 2.PoundsPerFoot); + + [Fact] + public void NumberToPoundsPerInchTest() => + Assert.Equal(LinearDensity.FromPoundsPerInch(2), 2.PoundsPerInch); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToLinearPowerDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToLinearPowerDensityExtensionsTest.g.cs new file mode 100644 index 0000000000..231e8c752a --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToLinearPowerDensityExtensionsTest.g.cs @@ -0,0 +1,128 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToLinearPowerDensity; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToLinearPowerDensityExtensionsTests + { + [Fact] + public void NumberToGigawattsPerCentimeterTest() => + Assert.Equal(LinearPowerDensity.FromGigawattsPerCentimeter(2), 2.GigawattsPerCentimeter); + + [Fact] + public void NumberToGigawattsPerFootTest() => + Assert.Equal(LinearPowerDensity.FromGigawattsPerFoot(2), 2.GigawattsPerFoot); + + [Fact] + public void NumberToGigawattsPerInchTest() => + Assert.Equal(LinearPowerDensity.FromGigawattsPerInch(2), 2.GigawattsPerInch); + + [Fact] + public void NumberToGigawattsPerMeterTest() => + Assert.Equal(LinearPowerDensity.FromGigawattsPerMeter(2), 2.GigawattsPerMeter); + + [Fact] + public void NumberToGigawattsPerMillimeterTest() => + Assert.Equal(LinearPowerDensity.FromGigawattsPerMillimeter(2), 2.GigawattsPerMillimeter); + + [Fact] + public void NumberToKilowattsPerCentimeterTest() => + Assert.Equal(LinearPowerDensity.FromKilowattsPerCentimeter(2), 2.KilowattsPerCentimeter); + + [Fact] + public void NumberToKilowattsPerFootTest() => + Assert.Equal(LinearPowerDensity.FromKilowattsPerFoot(2), 2.KilowattsPerFoot); + + [Fact] + public void NumberToKilowattsPerInchTest() => + Assert.Equal(LinearPowerDensity.FromKilowattsPerInch(2), 2.KilowattsPerInch); + + [Fact] + public void NumberToKilowattsPerMeterTest() => + Assert.Equal(LinearPowerDensity.FromKilowattsPerMeter(2), 2.KilowattsPerMeter); + + [Fact] + public void NumberToKilowattsPerMillimeterTest() => + Assert.Equal(LinearPowerDensity.FromKilowattsPerMillimeter(2), 2.KilowattsPerMillimeter); + + [Fact] + public void NumberToMegawattsPerCentimeterTest() => + Assert.Equal(LinearPowerDensity.FromMegawattsPerCentimeter(2), 2.MegawattsPerCentimeter); + + [Fact] + public void NumberToMegawattsPerFootTest() => + Assert.Equal(LinearPowerDensity.FromMegawattsPerFoot(2), 2.MegawattsPerFoot); + + [Fact] + public void NumberToMegawattsPerInchTest() => + Assert.Equal(LinearPowerDensity.FromMegawattsPerInch(2), 2.MegawattsPerInch); + + [Fact] + public void NumberToMegawattsPerMeterTest() => + Assert.Equal(LinearPowerDensity.FromMegawattsPerMeter(2), 2.MegawattsPerMeter); + + [Fact] + public void NumberToMegawattsPerMillimeterTest() => + Assert.Equal(LinearPowerDensity.FromMegawattsPerMillimeter(2), 2.MegawattsPerMillimeter); + + [Fact] + public void NumberToMilliwattsPerCentimeterTest() => + Assert.Equal(LinearPowerDensity.FromMilliwattsPerCentimeter(2), 2.MilliwattsPerCentimeter); + + [Fact] + public void NumberToMilliwattsPerFootTest() => + Assert.Equal(LinearPowerDensity.FromMilliwattsPerFoot(2), 2.MilliwattsPerFoot); + + [Fact] + public void NumberToMilliwattsPerInchTest() => + Assert.Equal(LinearPowerDensity.FromMilliwattsPerInch(2), 2.MilliwattsPerInch); + + [Fact] + public void NumberToMilliwattsPerMeterTest() => + Assert.Equal(LinearPowerDensity.FromMilliwattsPerMeter(2), 2.MilliwattsPerMeter); + + [Fact] + public void NumberToMilliwattsPerMillimeterTest() => + Assert.Equal(LinearPowerDensity.FromMilliwattsPerMillimeter(2), 2.MilliwattsPerMillimeter); + + [Fact] + public void NumberToWattsPerCentimeterTest() => + Assert.Equal(LinearPowerDensity.FromWattsPerCentimeter(2), 2.WattsPerCentimeter); + + [Fact] + public void NumberToWattsPerFootTest() => + Assert.Equal(LinearPowerDensity.FromWattsPerFoot(2), 2.WattsPerFoot); + + [Fact] + public void NumberToWattsPerInchTest() => + Assert.Equal(LinearPowerDensity.FromWattsPerInch(2), 2.WattsPerInch); + + [Fact] + public void NumberToWattsPerMeterTest() => + Assert.Equal(LinearPowerDensity.FromWattsPerMeter(2), 2.WattsPerMeter); + + [Fact] + public void NumberToWattsPerMillimeterTest() => + Assert.Equal(LinearPowerDensity.FromWattsPerMillimeter(2), 2.WattsPerMillimeter); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToLuminanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToLuminanceExtensionsTest.g.cs new file mode 100644 index 0000000000..56b5d7ebc7 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToLuminanceExtensionsTest.g.cs @@ -0,0 +1,68 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToLuminance; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToLuminanceExtensionsTests + { + [Fact] + public void NumberToCandelasPerSquareFootTest() => + Assert.Equal(Luminance.FromCandelasPerSquareFoot(2), 2.CandelasPerSquareFoot); + + [Fact] + public void NumberToCandelasPerSquareInchTest() => + Assert.Equal(Luminance.FromCandelasPerSquareInch(2), 2.CandelasPerSquareInch); + + [Fact] + public void NumberToCandelasPerSquareMeterTest() => + Assert.Equal(Luminance.FromCandelasPerSquareMeter(2), 2.CandelasPerSquareMeter); + + [Fact] + public void NumberToCenticandelasPerSquareMeterTest() => + Assert.Equal(Luminance.FromCenticandelasPerSquareMeter(2), 2.CenticandelasPerSquareMeter); + + [Fact] + public void NumberToDecicandelasPerSquareMeterTest() => + Assert.Equal(Luminance.FromDecicandelasPerSquareMeter(2), 2.DecicandelasPerSquareMeter); + + [Fact] + public void NumberToKilocandelasPerSquareMeterTest() => + Assert.Equal(Luminance.FromKilocandelasPerSquareMeter(2), 2.KilocandelasPerSquareMeter); + + [Fact] + public void NumberToMicrocandelasPerSquareMeterTest() => + Assert.Equal(Luminance.FromMicrocandelasPerSquareMeter(2), 2.MicrocandelasPerSquareMeter); + + [Fact] + public void NumberToMillicandelasPerSquareMeterTest() => + Assert.Equal(Luminance.FromMillicandelasPerSquareMeter(2), 2.MillicandelasPerSquareMeter); + + [Fact] + public void NumberToNanocandelasPerSquareMeterTest() => + Assert.Equal(Luminance.FromNanocandelasPerSquareMeter(2), 2.NanocandelasPerSquareMeter); + + [Fact] + public void NumberToNitsTest() => + Assert.Equal(Luminance.FromNits(2), 2.Nits); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToLuminosityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToLuminosityExtensionsTest.g.cs new file mode 100644 index 0000000000..c59fb87f41 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToLuminosityExtensionsTest.g.cs @@ -0,0 +1,84 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToLuminosity; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToLuminosityExtensionsTests + { + [Fact] + public void NumberToDecawattsTest() => + Assert.Equal(Luminosity.FromDecawatts(2), 2.Decawatts); + + [Fact] + public void NumberToDeciwattsTest() => + Assert.Equal(Luminosity.FromDeciwatts(2), 2.Deciwatts); + + [Fact] + public void NumberToFemtowattsTest() => + Assert.Equal(Luminosity.FromFemtowatts(2), 2.Femtowatts); + + [Fact] + public void NumberToGigawattsTest() => + Assert.Equal(Luminosity.FromGigawatts(2), 2.Gigawatts); + + [Fact] + public void NumberToKilowattsTest() => + Assert.Equal(Luminosity.FromKilowatts(2), 2.Kilowatts); + + [Fact] + public void NumberToMegawattsTest() => + Assert.Equal(Luminosity.FromMegawatts(2), 2.Megawatts); + + [Fact] + public void NumberToMicrowattsTest() => + Assert.Equal(Luminosity.FromMicrowatts(2), 2.Microwatts); + + [Fact] + public void NumberToMilliwattsTest() => + Assert.Equal(Luminosity.FromMilliwatts(2), 2.Milliwatts); + + [Fact] + public void NumberToNanowattsTest() => + Assert.Equal(Luminosity.FromNanowatts(2), 2.Nanowatts); + + [Fact] + public void NumberToPetawattsTest() => + Assert.Equal(Luminosity.FromPetawatts(2), 2.Petawatts); + + [Fact] + public void NumberToPicowattsTest() => + Assert.Equal(Luminosity.FromPicowatts(2), 2.Picowatts); + + [Fact] + public void NumberToSolarLuminositiesTest() => + Assert.Equal(Luminosity.FromSolarLuminosities(2), 2.SolarLuminosities); + + [Fact] + public void NumberToTerawattsTest() => + Assert.Equal(Luminosity.FromTerawatts(2), 2.Terawatts); + + [Fact] + public void NumberToWattsTest() => + Assert.Equal(Luminosity.FromWatts(2), 2.Watts); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToLuminousFluxExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToLuminousFluxExtensionsTest.g.cs new file mode 100644 index 0000000000..4794333bc4 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToLuminousFluxExtensionsTest.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.NumberToLuminousFlux; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToLuminousFluxExtensionsTests + { + [Fact] + public void NumberToLumensTest() => + Assert.Equal(LuminousFlux.FromLumens(2), 2.Lumens); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToLuminousIntensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToLuminousIntensityExtensionsTest.g.cs new file mode 100644 index 0000000000..9aee452faf --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToLuminousIntensityExtensionsTest.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.NumberToLuminousIntensity; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToLuminousIntensityExtensionsTests + { + [Fact] + public void NumberToCandelaTest() => + Assert.Equal(LuminousIntensity.FromCandela(2), 2.Candela); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMagneticFieldExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMagneticFieldExtensionsTest.g.cs new file mode 100644 index 0000000000..bdbe36b33d --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMagneticFieldExtensionsTest.g.cs @@ -0,0 +1,52 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToMagneticField; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToMagneticFieldExtensionsTests + { + [Fact] + public void NumberToGaussesTest() => + Assert.Equal(MagneticField.FromGausses(2), 2.Gausses); + + [Fact] + public void NumberToMicroteslasTest() => + Assert.Equal(MagneticField.FromMicroteslas(2), 2.Microteslas); + + [Fact] + public void NumberToMilligaussesTest() => + Assert.Equal(MagneticField.FromMilligausses(2), 2.Milligausses); + + [Fact] + public void NumberToMilliteslasTest() => + Assert.Equal(MagneticField.FromMilliteslas(2), 2.Milliteslas); + + [Fact] + public void NumberToNanoteslasTest() => + Assert.Equal(MagneticField.FromNanoteslas(2), 2.Nanoteslas); + + [Fact] + public void NumberToTeslasTest() => + Assert.Equal(MagneticField.FromTeslas(2), 2.Teslas); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMagneticFluxExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMagneticFluxExtensionsTest.g.cs new file mode 100644 index 0000000000..7bf579fa8d --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMagneticFluxExtensionsTest.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.NumberToMagneticFlux; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToMagneticFluxExtensionsTests + { + [Fact] + public void NumberToWebersTest() => + Assert.Equal(MagneticFlux.FromWebers(2), 2.Webers); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMagnetizationExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMagnetizationExtensionsTest.g.cs new file mode 100644 index 0000000000..4272f18c2f --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMagnetizationExtensionsTest.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.NumberToMagnetization; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToMagnetizationExtensionsTests + { + [Fact] + public void NumberToAmperesPerMeterTest() => + Assert.Equal(Magnetization.FromAmperesPerMeter(2), 2.AmperesPerMeter); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMassConcentrationExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMassConcentrationExtensionsTest.g.cs new file mode 100644 index 0000000000..76fef0c822 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMassConcentrationExtensionsTest.g.cs @@ -0,0 +1,224 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToMassConcentration; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToMassConcentrationExtensionsTests + { + [Fact] + public void NumberToCentigramsPerDeciliterTest() => + Assert.Equal(MassConcentration.FromCentigramsPerDeciliter(2), 2.CentigramsPerDeciliter); + + [Fact] + public void NumberToCentigramsPerLiterTest() => + Assert.Equal(MassConcentration.FromCentigramsPerLiter(2), 2.CentigramsPerLiter); + + [Fact] + public void NumberToCentigramsPerMicroliterTest() => + Assert.Equal(MassConcentration.FromCentigramsPerMicroliter(2), 2.CentigramsPerMicroliter); + + [Fact] + public void NumberToCentigramsPerMilliliterTest() => + Assert.Equal(MassConcentration.FromCentigramsPerMilliliter(2), 2.CentigramsPerMilliliter); + + [Fact] + public void NumberToDecigramsPerDeciliterTest() => + Assert.Equal(MassConcentration.FromDecigramsPerDeciliter(2), 2.DecigramsPerDeciliter); + + [Fact] + public void NumberToDecigramsPerLiterTest() => + Assert.Equal(MassConcentration.FromDecigramsPerLiter(2), 2.DecigramsPerLiter); + + [Fact] + public void NumberToDecigramsPerMicroliterTest() => + Assert.Equal(MassConcentration.FromDecigramsPerMicroliter(2), 2.DecigramsPerMicroliter); + + [Fact] + public void NumberToDecigramsPerMilliliterTest() => + Assert.Equal(MassConcentration.FromDecigramsPerMilliliter(2), 2.DecigramsPerMilliliter); + + [Fact] + public void NumberToGramsPerCubicCentimeterTest() => + Assert.Equal(MassConcentration.FromGramsPerCubicCentimeter(2), 2.GramsPerCubicCentimeter); + + [Fact] + public void NumberToGramsPerCubicMeterTest() => + Assert.Equal(MassConcentration.FromGramsPerCubicMeter(2), 2.GramsPerCubicMeter); + + [Fact] + public void NumberToGramsPerCubicMillimeterTest() => + Assert.Equal(MassConcentration.FromGramsPerCubicMillimeter(2), 2.GramsPerCubicMillimeter); + + [Fact] + public void NumberToGramsPerDeciliterTest() => + Assert.Equal(MassConcentration.FromGramsPerDeciliter(2), 2.GramsPerDeciliter); + + [Fact] + public void NumberToGramsPerLiterTest() => + Assert.Equal(MassConcentration.FromGramsPerLiter(2), 2.GramsPerLiter); + + [Fact] + public void NumberToGramsPerMicroliterTest() => + Assert.Equal(MassConcentration.FromGramsPerMicroliter(2), 2.GramsPerMicroliter); + + [Fact] + public void NumberToGramsPerMilliliterTest() => + Assert.Equal(MassConcentration.FromGramsPerMilliliter(2), 2.GramsPerMilliliter); + + [Fact] + public void NumberToKilogramsPerCubicCentimeterTest() => + Assert.Equal(MassConcentration.FromKilogramsPerCubicCentimeter(2), 2.KilogramsPerCubicCentimeter); + + [Fact] + public void NumberToKilogramsPerCubicMeterTest() => + Assert.Equal(MassConcentration.FromKilogramsPerCubicMeter(2), 2.KilogramsPerCubicMeter); + + [Fact] + public void NumberToKilogramsPerCubicMillimeterTest() => + Assert.Equal(MassConcentration.FromKilogramsPerCubicMillimeter(2), 2.KilogramsPerCubicMillimeter); + + [Fact] + public void NumberToKilogramsPerLiterTest() => + Assert.Equal(MassConcentration.FromKilogramsPerLiter(2), 2.KilogramsPerLiter); + + [Fact] + public void NumberToKilopoundsPerCubicFootTest() => + Assert.Equal(MassConcentration.FromKilopoundsPerCubicFoot(2), 2.KilopoundsPerCubicFoot); + + [Fact] + public void NumberToKilopoundsPerCubicInchTest() => + Assert.Equal(MassConcentration.FromKilopoundsPerCubicInch(2), 2.KilopoundsPerCubicInch); + + [Fact] + public void NumberToMicrogramsPerCubicMeterTest() => + Assert.Equal(MassConcentration.FromMicrogramsPerCubicMeter(2), 2.MicrogramsPerCubicMeter); + + [Fact] + public void NumberToMicrogramsPerDeciliterTest() => + Assert.Equal(MassConcentration.FromMicrogramsPerDeciliter(2), 2.MicrogramsPerDeciliter); + + [Fact] + public void NumberToMicrogramsPerLiterTest() => + Assert.Equal(MassConcentration.FromMicrogramsPerLiter(2), 2.MicrogramsPerLiter); + + [Fact] + public void NumberToMicrogramsPerMicroliterTest() => + Assert.Equal(MassConcentration.FromMicrogramsPerMicroliter(2), 2.MicrogramsPerMicroliter); + + [Fact] + public void NumberToMicrogramsPerMilliliterTest() => + Assert.Equal(MassConcentration.FromMicrogramsPerMilliliter(2), 2.MicrogramsPerMilliliter); + + [Fact] + public void NumberToMilligramsPerCubicMeterTest() => + Assert.Equal(MassConcentration.FromMilligramsPerCubicMeter(2), 2.MilligramsPerCubicMeter); + + [Fact] + public void NumberToMilligramsPerDeciliterTest() => + Assert.Equal(MassConcentration.FromMilligramsPerDeciliter(2), 2.MilligramsPerDeciliter); + + [Fact] + public void NumberToMilligramsPerLiterTest() => + Assert.Equal(MassConcentration.FromMilligramsPerLiter(2), 2.MilligramsPerLiter); + + [Fact] + public void NumberToMilligramsPerMicroliterTest() => + Assert.Equal(MassConcentration.FromMilligramsPerMicroliter(2), 2.MilligramsPerMicroliter); + + [Fact] + public void NumberToMilligramsPerMilliliterTest() => + Assert.Equal(MassConcentration.FromMilligramsPerMilliliter(2), 2.MilligramsPerMilliliter); + + [Fact] + public void NumberToNanogramsPerDeciliterTest() => + Assert.Equal(MassConcentration.FromNanogramsPerDeciliter(2), 2.NanogramsPerDeciliter); + + [Fact] + public void NumberToNanogramsPerLiterTest() => + Assert.Equal(MassConcentration.FromNanogramsPerLiter(2), 2.NanogramsPerLiter); + + [Fact] + public void NumberToNanogramsPerMicroliterTest() => + Assert.Equal(MassConcentration.FromNanogramsPerMicroliter(2), 2.NanogramsPerMicroliter); + + [Fact] + public void NumberToNanogramsPerMilliliterTest() => + Assert.Equal(MassConcentration.FromNanogramsPerMilliliter(2), 2.NanogramsPerMilliliter); + + [Fact] + public void NumberToOuncesPerImperialGallonTest() => + Assert.Equal(MassConcentration.FromOuncesPerImperialGallon(2), 2.OuncesPerImperialGallon); + + [Fact] + public void NumberToOuncesPerUSGallonTest() => + Assert.Equal(MassConcentration.FromOuncesPerUSGallon(2), 2.OuncesPerUSGallon); + + [Fact] + public void NumberToPicogramsPerDeciliterTest() => + Assert.Equal(MassConcentration.FromPicogramsPerDeciliter(2), 2.PicogramsPerDeciliter); + + [Fact] + public void NumberToPicogramsPerLiterTest() => + Assert.Equal(MassConcentration.FromPicogramsPerLiter(2), 2.PicogramsPerLiter); + + [Fact] + public void NumberToPicogramsPerMicroliterTest() => + Assert.Equal(MassConcentration.FromPicogramsPerMicroliter(2), 2.PicogramsPerMicroliter); + + [Fact] + public void NumberToPicogramsPerMilliliterTest() => + Assert.Equal(MassConcentration.FromPicogramsPerMilliliter(2), 2.PicogramsPerMilliliter); + + [Fact] + public void NumberToPoundsPerCubicFootTest() => + Assert.Equal(MassConcentration.FromPoundsPerCubicFoot(2), 2.PoundsPerCubicFoot); + + [Fact] + public void NumberToPoundsPerCubicInchTest() => + Assert.Equal(MassConcentration.FromPoundsPerCubicInch(2), 2.PoundsPerCubicInch); + + [Fact] + public void NumberToPoundsPerImperialGallonTest() => + Assert.Equal(MassConcentration.FromPoundsPerImperialGallon(2), 2.PoundsPerImperialGallon); + + [Fact] + public void NumberToPoundsPerUSGallonTest() => + Assert.Equal(MassConcentration.FromPoundsPerUSGallon(2), 2.PoundsPerUSGallon); + + [Fact] + public void NumberToSlugsPerCubicFootTest() => + Assert.Equal(MassConcentration.FromSlugsPerCubicFoot(2), 2.SlugsPerCubicFoot); + + [Fact] + public void NumberToTonnesPerCubicCentimeterTest() => + Assert.Equal(MassConcentration.FromTonnesPerCubicCentimeter(2), 2.TonnesPerCubicCentimeter); + + [Fact] + public void NumberToTonnesPerCubicMeterTest() => + Assert.Equal(MassConcentration.FromTonnesPerCubicMeter(2), 2.TonnesPerCubicMeter); + + [Fact] + public void NumberToTonnesPerCubicMillimeterTest() => + Assert.Equal(MassConcentration.FromTonnesPerCubicMillimeter(2), 2.TonnesPerCubicMillimeter); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMassExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMassExtensionsTest.g.cs new file mode 100644 index 0000000000..72e37c7716 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMassExtensionsTest.g.cs @@ -0,0 +1,136 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToMass; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToMassExtensionsTests + { + [Fact] + public void NumberToCentigramsTest() => + Assert.Equal(Mass.FromCentigrams(2), 2.Centigrams); + + [Fact] + public void NumberToDecagramsTest() => + Assert.Equal(Mass.FromDecagrams(2), 2.Decagrams); + + [Fact] + public void NumberToDecigramsTest() => + Assert.Equal(Mass.FromDecigrams(2), 2.Decigrams); + + [Fact] + public void NumberToEarthMassesTest() => + Assert.Equal(Mass.FromEarthMasses(2), 2.EarthMasses); + + [Fact] + public void NumberToFemtogramsTest() => + Assert.Equal(Mass.FromFemtograms(2), 2.Femtograms); + + [Fact] + public void NumberToGrainsTest() => + Assert.Equal(Mass.FromGrains(2), 2.Grains); + + [Fact] + public void NumberToGramsTest() => + Assert.Equal(Mass.FromGrams(2), 2.Grams); + + [Fact] + public void NumberToHectogramsTest() => + Assert.Equal(Mass.FromHectograms(2), 2.Hectograms); + + [Fact] + public void NumberToKilogramsTest() => + Assert.Equal(Mass.FromKilograms(2), 2.Kilograms); + + [Fact] + public void NumberToKilopoundsTest() => + Assert.Equal(Mass.FromKilopounds(2), 2.Kilopounds); + + [Fact] + public void NumberToKilotonnesTest() => + Assert.Equal(Mass.FromKilotonnes(2), 2.Kilotonnes); + + [Fact] + public void NumberToLongHundredweightTest() => + Assert.Equal(Mass.FromLongHundredweight(2), 2.LongHundredweight); + + [Fact] + public void NumberToLongTonsTest() => + Assert.Equal(Mass.FromLongTons(2), 2.LongTons); + + [Fact] + public void NumberToMegapoundsTest() => + Assert.Equal(Mass.FromMegapounds(2), 2.Megapounds); + + [Fact] + public void NumberToMegatonnesTest() => + Assert.Equal(Mass.FromMegatonnes(2), 2.Megatonnes); + + [Fact] + public void NumberToMicrogramsTest() => + Assert.Equal(Mass.FromMicrograms(2), 2.Micrograms); + + [Fact] + public void NumberToMilligramsTest() => + Assert.Equal(Mass.FromMilligrams(2), 2.Milligrams); + + [Fact] + public void NumberToNanogramsTest() => + Assert.Equal(Mass.FromNanograms(2), 2.Nanograms); + + [Fact] + public void NumberToOuncesTest() => + Assert.Equal(Mass.FromOunces(2), 2.Ounces); + + [Fact] + public void NumberToPicogramsTest() => + Assert.Equal(Mass.FromPicograms(2), 2.Picograms); + + [Fact] + public void NumberToPoundsTest() => + Assert.Equal(Mass.FromPounds(2), 2.Pounds); + + [Fact] + public void NumberToShortHundredweightTest() => + Assert.Equal(Mass.FromShortHundredweight(2), 2.ShortHundredweight); + + [Fact] + public void NumberToShortTonsTest() => + Assert.Equal(Mass.FromShortTons(2), 2.ShortTons); + + [Fact] + public void NumberToSlugsTest() => + Assert.Equal(Mass.FromSlugs(2), 2.Slugs); + + [Fact] + public void NumberToSolarMassesTest() => + Assert.Equal(Mass.FromSolarMasses(2), 2.SolarMasses); + + [Fact] + public void NumberToStoneTest() => + Assert.Equal(Mass.FromStone(2), 2.Stone); + + [Fact] + public void NumberToTonnesTest() => + Assert.Equal(Mass.FromTonnes(2), 2.Tonnes); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMassFlowExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMassFlowExtensionsTest.g.cs new file mode 100644 index 0000000000..7164e8c44c --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMassFlowExtensionsTest.g.cs @@ -0,0 +1,160 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToMassFlow; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToMassFlowExtensionsTests + { + [Fact] + public void NumberToCentigramsPerDayTest() => + Assert.Equal(MassFlow.FromCentigramsPerDay(2), 2.CentigramsPerDay); + + [Fact] + public void NumberToCentigramsPerSecondTest() => + Assert.Equal(MassFlow.FromCentigramsPerSecond(2), 2.CentigramsPerSecond); + + [Fact] + public void NumberToDecagramsPerDayTest() => + Assert.Equal(MassFlow.FromDecagramsPerDay(2), 2.DecagramsPerDay); + + [Fact] + public void NumberToDecagramsPerSecondTest() => + Assert.Equal(MassFlow.FromDecagramsPerSecond(2), 2.DecagramsPerSecond); + + [Fact] + public void NumberToDecigramsPerDayTest() => + Assert.Equal(MassFlow.FromDecigramsPerDay(2), 2.DecigramsPerDay); + + [Fact] + public void NumberToDecigramsPerSecondTest() => + Assert.Equal(MassFlow.FromDecigramsPerSecond(2), 2.DecigramsPerSecond); + + [Fact] + public void NumberToGramsPerDayTest() => + Assert.Equal(MassFlow.FromGramsPerDay(2), 2.GramsPerDay); + + [Fact] + public void NumberToGramsPerHourTest() => + Assert.Equal(MassFlow.FromGramsPerHour(2), 2.GramsPerHour); + + [Fact] + public void NumberToGramsPerSecondTest() => + Assert.Equal(MassFlow.FromGramsPerSecond(2), 2.GramsPerSecond); + + [Fact] + public void NumberToHectogramsPerDayTest() => + Assert.Equal(MassFlow.FromHectogramsPerDay(2), 2.HectogramsPerDay); + + [Fact] + public void NumberToHectogramsPerSecondTest() => + Assert.Equal(MassFlow.FromHectogramsPerSecond(2), 2.HectogramsPerSecond); + + [Fact] + public void NumberToKilogramsPerDayTest() => + Assert.Equal(MassFlow.FromKilogramsPerDay(2), 2.KilogramsPerDay); + + [Fact] + public void NumberToKilogramsPerHourTest() => + Assert.Equal(MassFlow.FromKilogramsPerHour(2), 2.KilogramsPerHour); + + [Fact] + public void NumberToKilogramsPerMinuteTest() => + Assert.Equal(MassFlow.FromKilogramsPerMinute(2), 2.KilogramsPerMinute); + + [Fact] + public void NumberToKilogramsPerSecondTest() => + Assert.Equal(MassFlow.FromKilogramsPerSecond(2), 2.KilogramsPerSecond); + + [Fact] + public void NumberToMegagramsPerDayTest() => + Assert.Equal(MassFlow.FromMegagramsPerDay(2), 2.MegagramsPerDay); + + [Fact] + public void NumberToMegapoundsPerDayTest() => + Assert.Equal(MassFlow.FromMegapoundsPerDay(2), 2.MegapoundsPerDay); + + [Fact] + public void NumberToMegapoundsPerHourTest() => + Assert.Equal(MassFlow.FromMegapoundsPerHour(2), 2.MegapoundsPerHour); + + [Fact] + public void NumberToMegapoundsPerMinuteTest() => + Assert.Equal(MassFlow.FromMegapoundsPerMinute(2), 2.MegapoundsPerMinute); + + [Fact] + public void NumberToMegapoundsPerSecondTest() => + Assert.Equal(MassFlow.FromMegapoundsPerSecond(2), 2.MegapoundsPerSecond); + + [Fact] + public void NumberToMicrogramsPerDayTest() => + Assert.Equal(MassFlow.FromMicrogramsPerDay(2), 2.MicrogramsPerDay); + + [Fact] + public void NumberToMicrogramsPerSecondTest() => + Assert.Equal(MassFlow.FromMicrogramsPerSecond(2), 2.MicrogramsPerSecond); + + [Fact] + public void NumberToMilligramsPerDayTest() => + Assert.Equal(MassFlow.FromMilligramsPerDay(2), 2.MilligramsPerDay); + + [Fact] + public void NumberToMilligramsPerSecondTest() => + Assert.Equal(MassFlow.FromMilligramsPerSecond(2), 2.MilligramsPerSecond); + + [Fact] + public void NumberToNanogramsPerDayTest() => + Assert.Equal(MassFlow.FromNanogramsPerDay(2), 2.NanogramsPerDay); + + [Fact] + public void NumberToNanogramsPerSecondTest() => + Assert.Equal(MassFlow.FromNanogramsPerSecond(2), 2.NanogramsPerSecond); + + [Fact] + public void NumberToPoundsPerDayTest() => + Assert.Equal(MassFlow.FromPoundsPerDay(2), 2.PoundsPerDay); + + [Fact] + public void NumberToPoundsPerHourTest() => + Assert.Equal(MassFlow.FromPoundsPerHour(2), 2.PoundsPerHour); + + [Fact] + public void NumberToPoundsPerMinuteTest() => + Assert.Equal(MassFlow.FromPoundsPerMinute(2), 2.PoundsPerMinute); + + [Fact] + public void NumberToPoundsPerSecondTest() => + Assert.Equal(MassFlow.FromPoundsPerSecond(2), 2.PoundsPerSecond); + + [Fact] + public void NumberToShortTonsPerHourTest() => + Assert.Equal(MassFlow.FromShortTonsPerHour(2), 2.ShortTonsPerHour); + + [Fact] + public void NumberToTonnesPerDayTest() => + Assert.Equal(MassFlow.FromTonnesPerDay(2), 2.TonnesPerDay); + + [Fact] + public void NumberToTonnesPerHourTest() => + Assert.Equal(MassFlow.FromTonnesPerHour(2), 2.TonnesPerHour); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMassFluxExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMassFluxExtensionsTest.g.cs new file mode 100644 index 0000000000..ee95382f25 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMassFluxExtensionsTest.g.cs @@ -0,0 +1,76 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToMassFlux; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToMassFluxExtensionsTests + { + [Fact] + public void NumberToGramsPerHourPerSquareCentimeterTest() => + Assert.Equal(MassFlux.FromGramsPerHourPerSquareCentimeter(2), 2.GramsPerHourPerSquareCentimeter); + + [Fact] + public void NumberToGramsPerHourPerSquareMeterTest() => + Assert.Equal(MassFlux.FromGramsPerHourPerSquareMeter(2), 2.GramsPerHourPerSquareMeter); + + [Fact] + public void NumberToGramsPerHourPerSquareMillimeterTest() => + Assert.Equal(MassFlux.FromGramsPerHourPerSquareMillimeter(2), 2.GramsPerHourPerSquareMillimeter); + + [Fact] + public void NumberToGramsPerSecondPerSquareCentimeterTest() => + Assert.Equal(MassFlux.FromGramsPerSecondPerSquareCentimeter(2), 2.GramsPerSecondPerSquareCentimeter); + + [Fact] + public void NumberToGramsPerSecondPerSquareMeterTest() => + Assert.Equal(MassFlux.FromGramsPerSecondPerSquareMeter(2), 2.GramsPerSecondPerSquareMeter); + + [Fact] + public void NumberToGramsPerSecondPerSquareMillimeterTest() => + Assert.Equal(MassFlux.FromGramsPerSecondPerSquareMillimeter(2), 2.GramsPerSecondPerSquareMillimeter); + + [Fact] + public void NumberToKilogramsPerHourPerSquareCentimeterTest() => + Assert.Equal(MassFlux.FromKilogramsPerHourPerSquareCentimeter(2), 2.KilogramsPerHourPerSquareCentimeter); + + [Fact] + public void NumberToKilogramsPerHourPerSquareMeterTest() => + Assert.Equal(MassFlux.FromKilogramsPerHourPerSquareMeter(2), 2.KilogramsPerHourPerSquareMeter); + + [Fact] + public void NumberToKilogramsPerHourPerSquareMillimeterTest() => + Assert.Equal(MassFlux.FromKilogramsPerHourPerSquareMillimeter(2), 2.KilogramsPerHourPerSquareMillimeter); + + [Fact] + public void NumberToKilogramsPerSecondPerSquareCentimeterTest() => + Assert.Equal(MassFlux.FromKilogramsPerSecondPerSquareCentimeter(2), 2.KilogramsPerSecondPerSquareCentimeter); + + [Fact] + public void NumberToKilogramsPerSecondPerSquareMeterTest() => + Assert.Equal(MassFlux.FromKilogramsPerSecondPerSquareMeter(2), 2.KilogramsPerSecondPerSquareMeter); + + [Fact] + public void NumberToKilogramsPerSecondPerSquareMillimeterTest() => + Assert.Equal(MassFlux.FromKilogramsPerSecondPerSquareMillimeter(2), 2.KilogramsPerSecondPerSquareMillimeter); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMassFractionExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMassFractionExtensionsTest.g.cs new file mode 100644 index 0000000000..f81c0cec84 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMassFractionExtensionsTest.g.cs @@ -0,0 +1,124 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToMassFraction; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToMassFractionExtensionsTests + { + [Fact] + public void NumberToCentigramsPerGramTest() => + Assert.Equal(MassFraction.FromCentigramsPerGram(2), 2.CentigramsPerGram); + + [Fact] + public void NumberToCentigramsPerKilogramTest() => + Assert.Equal(MassFraction.FromCentigramsPerKilogram(2), 2.CentigramsPerKilogram); + + [Fact] + public void NumberToDecagramsPerGramTest() => + Assert.Equal(MassFraction.FromDecagramsPerGram(2), 2.DecagramsPerGram); + + [Fact] + public void NumberToDecagramsPerKilogramTest() => + Assert.Equal(MassFraction.FromDecagramsPerKilogram(2), 2.DecagramsPerKilogram); + + [Fact] + public void NumberToDecigramsPerGramTest() => + Assert.Equal(MassFraction.FromDecigramsPerGram(2), 2.DecigramsPerGram); + + [Fact] + public void NumberToDecigramsPerKilogramTest() => + Assert.Equal(MassFraction.FromDecigramsPerKilogram(2), 2.DecigramsPerKilogram); + + [Fact] + public void NumberToDecimalFractionsTest() => + Assert.Equal(MassFraction.FromDecimalFractions(2), 2.DecimalFractions); + + [Fact] + public void NumberToGramsPerGramTest() => + Assert.Equal(MassFraction.FromGramsPerGram(2), 2.GramsPerGram); + + [Fact] + public void NumberToGramsPerKilogramTest() => + Assert.Equal(MassFraction.FromGramsPerKilogram(2), 2.GramsPerKilogram); + + [Fact] + public void NumberToHectogramsPerGramTest() => + Assert.Equal(MassFraction.FromHectogramsPerGram(2), 2.HectogramsPerGram); + + [Fact] + public void NumberToHectogramsPerKilogramTest() => + Assert.Equal(MassFraction.FromHectogramsPerKilogram(2), 2.HectogramsPerKilogram); + + [Fact] + public void NumberToKilogramsPerGramTest() => + Assert.Equal(MassFraction.FromKilogramsPerGram(2), 2.KilogramsPerGram); + + [Fact] + public void NumberToKilogramsPerKilogramTest() => + Assert.Equal(MassFraction.FromKilogramsPerKilogram(2), 2.KilogramsPerKilogram); + + [Fact] + public void NumberToMicrogramsPerGramTest() => + Assert.Equal(MassFraction.FromMicrogramsPerGram(2), 2.MicrogramsPerGram); + + [Fact] + public void NumberToMicrogramsPerKilogramTest() => + Assert.Equal(MassFraction.FromMicrogramsPerKilogram(2), 2.MicrogramsPerKilogram); + + [Fact] + public void NumberToMilligramsPerGramTest() => + Assert.Equal(MassFraction.FromMilligramsPerGram(2), 2.MilligramsPerGram); + + [Fact] + public void NumberToMilligramsPerKilogramTest() => + Assert.Equal(MassFraction.FromMilligramsPerKilogram(2), 2.MilligramsPerKilogram); + + [Fact] + public void NumberToNanogramsPerGramTest() => + Assert.Equal(MassFraction.FromNanogramsPerGram(2), 2.NanogramsPerGram); + + [Fact] + public void NumberToNanogramsPerKilogramTest() => + Assert.Equal(MassFraction.FromNanogramsPerKilogram(2), 2.NanogramsPerKilogram); + + [Fact] + public void NumberToPartsPerBillionTest() => + Assert.Equal(MassFraction.FromPartsPerBillion(2), 2.PartsPerBillion); + + [Fact] + public void NumberToPartsPerMillionTest() => + Assert.Equal(MassFraction.FromPartsPerMillion(2), 2.PartsPerMillion); + + [Fact] + public void NumberToPartsPerThousandTest() => + Assert.Equal(MassFraction.FromPartsPerThousand(2), 2.PartsPerThousand); + + [Fact] + public void NumberToPartsPerTrillionTest() => + Assert.Equal(MassFraction.FromPartsPerTrillion(2), 2.PartsPerTrillion); + + [Fact] + public void NumberToPercentTest() => + Assert.Equal(MassFraction.FromPercent(2), 2.Percent); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMassMomentOfInertiaExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMassMomentOfInertiaExtensionsTest.g.cs new file mode 100644 index 0000000000..067192d974 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMassMomentOfInertiaExtensionsTest.g.cs @@ -0,0 +1,140 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToMassMomentOfInertia; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToMassMomentOfInertiaExtensionsTests + { + [Fact] + public void NumberToGramSquareCentimetersTest() => + Assert.Equal(MassMomentOfInertia.FromGramSquareCentimeters(2), 2.GramSquareCentimeters); + + [Fact] + public void NumberToGramSquareDecimetersTest() => + Assert.Equal(MassMomentOfInertia.FromGramSquareDecimeters(2), 2.GramSquareDecimeters); + + [Fact] + public void NumberToGramSquareMetersTest() => + Assert.Equal(MassMomentOfInertia.FromGramSquareMeters(2), 2.GramSquareMeters); + + [Fact] + public void NumberToGramSquareMillimetersTest() => + Assert.Equal(MassMomentOfInertia.FromGramSquareMillimeters(2), 2.GramSquareMillimeters); + + [Fact] + public void NumberToKilogramSquareCentimetersTest() => + Assert.Equal(MassMomentOfInertia.FromKilogramSquareCentimeters(2), 2.KilogramSquareCentimeters); + + [Fact] + public void NumberToKilogramSquareDecimetersTest() => + Assert.Equal(MassMomentOfInertia.FromKilogramSquareDecimeters(2), 2.KilogramSquareDecimeters); + + [Fact] + public void NumberToKilogramSquareMetersTest() => + Assert.Equal(MassMomentOfInertia.FromKilogramSquareMeters(2), 2.KilogramSquareMeters); + + [Fact] + public void NumberToKilogramSquareMillimetersTest() => + Assert.Equal(MassMomentOfInertia.FromKilogramSquareMillimeters(2), 2.KilogramSquareMillimeters); + + [Fact] + public void NumberToKilotonneSquareCentimetersTest() => + Assert.Equal(MassMomentOfInertia.FromKilotonneSquareCentimeters(2), 2.KilotonneSquareCentimeters); + + [Fact] + public void NumberToKilotonneSquareDecimetersTest() => + Assert.Equal(MassMomentOfInertia.FromKilotonneSquareDecimeters(2), 2.KilotonneSquareDecimeters); + + [Fact] + public void NumberToKilotonneSquareMetersTest() => + Assert.Equal(MassMomentOfInertia.FromKilotonneSquareMeters(2), 2.KilotonneSquareMeters); + + [Fact] + public void NumberToKilotonneSquareMillimetersTest() => + Assert.Equal(MassMomentOfInertia.FromKilotonneSquareMillimeters(2), 2.KilotonneSquareMillimeters); + + [Fact] + public void NumberToMegatonneSquareCentimetersTest() => + Assert.Equal(MassMomentOfInertia.FromMegatonneSquareCentimeters(2), 2.MegatonneSquareCentimeters); + + [Fact] + public void NumberToMegatonneSquareDecimetersTest() => + Assert.Equal(MassMomentOfInertia.FromMegatonneSquareDecimeters(2), 2.MegatonneSquareDecimeters); + + [Fact] + public void NumberToMegatonneSquareMetersTest() => + Assert.Equal(MassMomentOfInertia.FromMegatonneSquareMeters(2), 2.MegatonneSquareMeters); + + [Fact] + public void NumberToMegatonneSquareMillimetersTest() => + Assert.Equal(MassMomentOfInertia.FromMegatonneSquareMillimeters(2), 2.MegatonneSquareMillimeters); + + [Fact] + public void NumberToMilligramSquareCentimetersTest() => + Assert.Equal(MassMomentOfInertia.FromMilligramSquareCentimeters(2), 2.MilligramSquareCentimeters); + + [Fact] + public void NumberToMilligramSquareDecimetersTest() => + Assert.Equal(MassMomentOfInertia.FromMilligramSquareDecimeters(2), 2.MilligramSquareDecimeters); + + [Fact] + public void NumberToMilligramSquareMetersTest() => + Assert.Equal(MassMomentOfInertia.FromMilligramSquareMeters(2), 2.MilligramSquareMeters); + + [Fact] + public void NumberToMilligramSquareMillimetersTest() => + Assert.Equal(MassMomentOfInertia.FromMilligramSquareMillimeters(2), 2.MilligramSquareMillimeters); + + [Fact] + public void NumberToPoundSquareFeetTest() => + Assert.Equal(MassMomentOfInertia.FromPoundSquareFeet(2), 2.PoundSquareFeet); + + [Fact] + public void NumberToPoundSquareInchesTest() => + Assert.Equal(MassMomentOfInertia.FromPoundSquareInches(2), 2.PoundSquareInches); + + [Fact] + public void NumberToSlugSquareFeetTest() => + Assert.Equal(MassMomentOfInertia.FromSlugSquareFeet(2), 2.SlugSquareFeet); + + [Fact] + public void NumberToSlugSquareInchesTest() => + Assert.Equal(MassMomentOfInertia.FromSlugSquareInches(2), 2.SlugSquareInches); + + [Fact] + public void NumberToTonneSquareCentimetersTest() => + Assert.Equal(MassMomentOfInertia.FromTonneSquareCentimeters(2), 2.TonneSquareCentimeters); + + [Fact] + public void NumberToTonneSquareDecimetersTest() => + Assert.Equal(MassMomentOfInertia.FromTonneSquareDecimeters(2), 2.TonneSquareDecimeters); + + [Fact] + public void NumberToTonneSquareMetersTest() => + Assert.Equal(MassMomentOfInertia.FromTonneSquareMeters(2), 2.TonneSquareMeters); + + [Fact] + public void NumberToTonneSquareMillimetersTest() => + Assert.Equal(MassMomentOfInertia.FromTonneSquareMillimeters(2), 2.TonneSquareMillimeters); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMolalityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMolalityExtensionsTest.g.cs new file mode 100644 index 0000000000..e071a846bb --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMolalityExtensionsTest.g.cs @@ -0,0 +1,40 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToMolality; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToMolalityExtensionsTests + { + [Fact] + public void NumberToMillimolesPerKilogramTest() => + Assert.Equal(Molality.FromMillimolesPerKilogram(2), 2.MillimolesPerKilogram); + + [Fact] + public void NumberToMolesPerGramTest() => + Assert.Equal(Molality.FromMolesPerGram(2), 2.MolesPerGram); + + [Fact] + public void NumberToMolesPerKilogramTest() => + Assert.Equal(Molality.FromMolesPerKilogram(2), 2.MolesPerKilogram); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMolarEnergyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMolarEnergyExtensionsTest.g.cs new file mode 100644 index 0000000000..1e4e3dc039 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMolarEnergyExtensionsTest.g.cs @@ -0,0 +1,40 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToMolarEnergy; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToMolarEnergyExtensionsTests + { + [Fact] + public void NumberToJoulesPerMoleTest() => + Assert.Equal(MolarEnergy.FromJoulesPerMole(2), 2.JoulesPerMole); + + [Fact] + public void NumberToKilojoulesPerMoleTest() => + Assert.Equal(MolarEnergy.FromKilojoulesPerMole(2), 2.KilojoulesPerMole); + + [Fact] + public void NumberToMegajoulesPerMoleTest() => + Assert.Equal(MolarEnergy.FromMegajoulesPerMole(2), 2.MegajoulesPerMole); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMolarEntropyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMolarEntropyExtensionsTest.g.cs new file mode 100644 index 0000000000..71e852ec88 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMolarEntropyExtensionsTest.g.cs @@ -0,0 +1,40 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToMolarEntropy; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToMolarEntropyExtensionsTests + { + [Fact] + public void NumberToJoulesPerMoleKelvinTest() => + Assert.Equal(MolarEntropy.FromJoulesPerMoleKelvin(2), 2.JoulesPerMoleKelvin); + + [Fact] + public void NumberToKilojoulesPerMoleKelvinTest() => + Assert.Equal(MolarEntropy.FromKilojoulesPerMoleKelvin(2), 2.KilojoulesPerMoleKelvin); + + [Fact] + public void NumberToMegajoulesPerMoleKelvinTest() => + Assert.Equal(MolarEntropy.FromMegajoulesPerMoleKelvin(2), 2.MegajoulesPerMoleKelvin); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMolarFlowExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMolarFlowExtensionsTest.g.cs new file mode 100644 index 0000000000..cf4e2d209e --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMolarFlowExtensionsTest.g.cs @@ -0,0 +1,64 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToMolarFlow; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToMolarFlowExtensionsTests + { + [Fact] + public void NumberToKilomolesPerHourTest() => + Assert.Equal(MolarFlow.FromKilomolesPerHour(2), 2.KilomolesPerHour); + + [Fact] + public void NumberToKilomolesPerMinuteTest() => + Assert.Equal(MolarFlow.FromKilomolesPerMinute(2), 2.KilomolesPerMinute); + + [Fact] + public void NumberToKilomolesPerSecondTest() => + Assert.Equal(MolarFlow.FromKilomolesPerSecond(2), 2.KilomolesPerSecond); + + [Fact] + public void NumberToMolesPerHourTest() => + Assert.Equal(MolarFlow.FromMolesPerHour(2), 2.MolesPerHour); + + [Fact] + public void NumberToMolesPerMinuteTest() => + Assert.Equal(MolarFlow.FromMolesPerMinute(2), 2.MolesPerMinute); + + [Fact] + public void NumberToMolesPerSecondTest() => + Assert.Equal(MolarFlow.FromMolesPerSecond(2), 2.MolesPerSecond); + + [Fact] + public void NumberToPoundMolesPerHourTest() => + Assert.Equal(MolarFlow.FromPoundMolesPerHour(2), 2.PoundMolesPerHour); + + [Fact] + public void NumberToPoundMolesPerMinuteTest() => + Assert.Equal(MolarFlow.FromPoundMolesPerMinute(2), 2.PoundMolesPerMinute); + + [Fact] + public void NumberToPoundMolesPerSecondTest() => + Assert.Equal(MolarFlow.FromPoundMolesPerSecond(2), 2.PoundMolesPerSecond); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMolarMassExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMolarMassExtensionsTest.g.cs new file mode 100644 index 0000000000..23859f41a6 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMolarMassExtensionsTest.g.cs @@ -0,0 +1,80 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToMolarMass; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToMolarMassExtensionsTests + { + [Fact] + public void NumberToCentigramsPerMoleTest() => + Assert.Equal(MolarMass.FromCentigramsPerMole(2), 2.CentigramsPerMole); + + [Fact] + public void NumberToDecagramsPerMoleTest() => + Assert.Equal(MolarMass.FromDecagramsPerMole(2), 2.DecagramsPerMole); + + [Fact] + public void NumberToDecigramsPerMoleTest() => + Assert.Equal(MolarMass.FromDecigramsPerMole(2), 2.DecigramsPerMole); + + [Fact] + public void NumberToGramsPerMoleTest() => + Assert.Equal(MolarMass.FromGramsPerMole(2), 2.GramsPerMole); + + [Fact] + public void NumberToHectogramsPerMoleTest() => + Assert.Equal(MolarMass.FromHectogramsPerMole(2), 2.HectogramsPerMole); + + [Fact] + public void NumberToKilogramsPerKilomoleTest() => + Assert.Equal(MolarMass.FromKilogramsPerKilomole(2), 2.KilogramsPerKilomole); + + [Fact] + public void NumberToKilogramsPerMoleTest() => + Assert.Equal(MolarMass.FromKilogramsPerMole(2), 2.KilogramsPerMole); + + [Fact] + public void NumberToKilopoundsPerMoleTest() => + Assert.Equal(MolarMass.FromKilopoundsPerMole(2), 2.KilopoundsPerMole); + + [Fact] + public void NumberToMegapoundsPerMoleTest() => + Assert.Equal(MolarMass.FromMegapoundsPerMole(2), 2.MegapoundsPerMole); + + [Fact] + public void NumberToMicrogramsPerMoleTest() => + Assert.Equal(MolarMass.FromMicrogramsPerMole(2), 2.MicrogramsPerMole); + + [Fact] + public void NumberToMilligramsPerMoleTest() => + Assert.Equal(MolarMass.FromMilligramsPerMole(2), 2.MilligramsPerMole); + + [Fact] + public void NumberToNanogramsPerMoleTest() => + Assert.Equal(MolarMass.FromNanogramsPerMole(2), 2.NanogramsPerMole); + + [Fact] + public void NumberToPoundsPerMoleTest() => + Assert.Equal(MolarMass.FromPoundsPerMole(2), 2.PoundsPerMole); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMolarityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMolarityExtensionsTest.g.cs new file mode 100644 index 0000000000..68877fc1a8 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToMolarityExtensionsTest.g.cs @@ -0,0 +1,72 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToMolarity; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToMolarityExtensionsTests + { + [Fact] + public void NumberToCentimolesPerLiterTest() => + Assert.Equal(Molarity.FromCentimolesPerLiter(2), 2.CentimolesPerLiter); + + [Fact] + public void NumberToDecimolesPerLiterTest() => + Assert.Equal(Molarity.FromDecimolesPerLiter(2), 2.DecimolesPerLiter); + + [Fact] + public void NumberToFemtomolesPerLiterTest() => + Assert.Equal(Molarity.FromFemtomolesPerLiter(2), 2.FemtomolesPerLiter); + + [Fact] + public void NumberToKilomolesPerCubicMeterTest() => + Assert.Equal(Molarity.FromKilomolesPerCubicMeter(2), 2.KilomolesPerCubicMeter); + + [Fact] + public void NumberToMicromolesPerLiterTest() => + Assert.Equal(Molarity.FromMicromolesPerLiter(2), 2.MicromolesPerLiter); + + [Fact] + public void NumberToMillimolesPerLiterTest() => + Assert.Equal(Molarity.FromMillimolesPerLiter(2), 2.MillimolesPerLiter); + + [Fact] + public void NumberToMolesPerCubicMeterTest() => + Assert.Equal(Molarity.FromMolesPerCubicMeter(2), 2.MolesPerCubicMeter); + + [Fact] + public void NumberToMolesPerLiterTest() => + Assert.Equal(Molarity.FromMolesPerLiter(2), 2.MolesPerLiter); + + [Fact] + public void NumberToNanomolesPerLiterTest() => + Assert.Equal(Molarity.FromNanomolesPerLiter(2), 2.NanomolesPerLiter); + + [Fact] + public void NumberToPicomolesPerLiterTest() => + Assert.Equal(Molarity.FromPicomolesPerLiter(2), 2.PicomolesPerLiter); + + [Fact] + public void NumberToPoundMolesPerCubicFootTest() => + Assert.Equal(Molarity.FromPoundMolesPerCubicFoot(2), 2.PoundMolesPerCubicFoot); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPermeabilityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPermeabilityExtensionsTest.g.cs new file mode 100644 index 0000000000..e38a5aa64a --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPermeabilityExtensionsTest.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.NumberToPermeability; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToPermeabilityExtensionsTests + { + [Fact] + public void NumberToHenriesPerMeterTest() => + Assert.Equal(Permeability.FromHenriesPerMeter(2), 2.HenriesPerMeter); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPermittivityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPermittivityExtensionsTest.g.cs new file mode 100644 index 0000000000..909a8a4b02 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPermittivityExtensionsTest.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.NumberToPermittivity; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToPermittivityExtensionsTests + { + [Fact] + public void NumberToFaradsPerMeterTest() => + Assert.Equal(Permittivity.FromFaradsPerMeter(2), 2.FaradsPerMeter); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPorousMediumPermeabilityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPorousMediumPermeabilityExtensionsTest.g.cs new file mode 100644 index 0000000000..9e9522e20e --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPorousMediumPermeabilityExtensionsTest.g.cs @@ -0,0 +1,48 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToPorousMediumPermeability; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToPorousMediumPermeabilityExtensionsTests + { + [Fact] + public void NumberToDarcysTest() => + Assert.Equal(PorousMediumPermeability.FromDarcys(2), 2.Darcys); + + [Fact] + public void NumberToMicrodarcysTest() => + Assert.Equal(PorousMediumPermeability.FromMicrodarcys(2), 2.Microdarcys); + + [Fact] + public void NumberToMillidarcysTest() => + Assert.Equal(PorousMediumPermeability.FromMillidarcys(2), 2.Millidarcys); + + [Fact] + public void NumberToSquareCentimetersTest() => + Assert.Equal(PorousMediumPermeability.FromSquareCentimeters(2), 2.SquareCentimeters); + + [Fact] + public void NumberToSquareMetersTest() => + Assert.Equal(PorousMediumPermeability.FromSquareMeters(2), 2.SquareMeters); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPowerDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPowerDensityExtensionsTest.g.cs new file mode 100644 index 0000000000..f575799760 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPowerDensityExtensionsTest.g.cs @@ -0,0 +1,204 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToPowerDensity; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToPowerDensityExtensionsTests + { + [Fact] + public void NumberToDecawattsPerCubicFootTest() => + Assert.Equal(PowerDensity.FromDecawattsPerCubicFoot(2), 2.DecawattsPerCubicFoot); + + [Fact] + public void NumberToDecawattsPerCubicInchTest() => + Assert.Equal(PowerDensity.FromDecawattsPerCubicInch(2), 2.DecawattsPerCubicInch); + + [Fact] + public void NumberToDecawattsPerCubicMeterTest() => + Assert.Equal(PowerDensity.FromDecawattsPerCubicMeter(2), 2.DecawattsPerCubicMeter); + + [Fact] + public void NumberToDecawattsPerLiterTest() => + Assert.Equal(PowerDensity.FromDecawattsPerLiter(2), 2.DecawattsPerLiter); + + [Fact] + public void NumberToDeciwattsPerCubicFootTest() => + Assert.Equal(PowerDensity.FromDeciwattsPerCubicFoot(2), 2.DeciwattsPerCubicFoot); + + [Fact] + public void NumberToDeciwattsPerCubicInchTest() => + Assert.Equal(PowerDensity.FromDeciwattsPerCubicInch(2), 2.DeciwattsPerCubicInch); + + [Fact] + public void NumberToDeciwattsPerCubicMeterTest() => + Assert.Equal(PowerDensity.FromDeciwattsPerCubicMeter(2), 2.DeciwattsPerCubicMeter); + + [Fact] + public void NumberToDeciwattsPerLiterTest() => + Assert.Equal(PowerDensity.FromDeciwattsPerLiter(2), 2.DeciwattsPerLiter); + + [Fact] + public void NumberToGigawattsPerCubicFootTest() => + Assert.Equal(PowerDensity.FromGigawattsPerCubicFoot(2), 2.GigawattsPerCubicFoot); + + [Fact] + public void NumberToGigawattsPerCubicInchTest() => + Assert.Equal(PowerDensity.FromGigawattsPerCubicInch(2), 2.GigawattsPerCubicInch); + + [Fact] + public void NumberToGigawattsPerCubicMeterTest() => + Assert.Equal(PowerDensity.FromGigawattsPerCubicMeter(2), 2.GigawattsPerCubicMeter); + + [Fact] + public void NumberToGigawattsPerLiterTest() => + Assert.Equal(PowerDensity.FromGigawattsPerLiter(2), 2.GigawattsPerLiter); + + [Fact] + public void NumberToKilowattsPerCubicFootTest() => + Assert.Equal(PowerDensity.FromKilowattsPerCubicFoot(2), 2.KilowattsPerCubicFoot); + + [Fact] + public void NumberToKilowattsPerCubicInchTest() => + Assert.Equal(PowerDensity.FromKilowattsPerCubicInch(2), 2.KilowattsPerCubicInch); + + [Fact] + public void NumberToKilowattsPerCubicMeterTest() => + Assert.Equal(PowerDensity.FromKilowattsPerCubicMeter(2), 2.KilowattsPerCubicMeter); + + [Fact] + public void NumberToKilowattsPerLiterTest() => + Assert.Equal(PowerDensity.FromKilowattsPerLiter(2), 2.KilowattsPerLiter); + + [Fact] + public void NumberToMegawattsPerCubicFootTest() => + Assert.Equal(PowerDensity.FromMegawattsPerCubicFoot(2), 2.MegawattsPerCubicFoot); + + [Fact] + public void NumberToMegawattsPerCubicInchTest() => + Assert.Equal(PowerDensity.FromMegawattsPerCubicInch(2), 2.MegawattsPerCubicInch); + + [Fact] + public void NumberToMegawattsPerCubicMeterTest() => + Assert.Equal(PowerDensity.FromMegawattsPerCubicMeter(2), 2.MegawattsPerCubicMeter); + + [Fact] + public void NumberToMegawattsPerLiterTest() => + Assert.Equal(PowerDensity.FromMegawattsPerLiter(2), 2.MegawattsPerLiter); + + [Fact] + public void NumberToMicrowattsPerCubicFootTest() => + Assert.Equal(PowerDensity.FromMicrowattsPerCubicFoot(2), 2.MicrowattsPerCubicFoot); + + [Fact] + public void NumberToMicrowattsPerCubicInchTest() => + Assert.Equal(PowerDensity.FromMicrowattsPerCubicInch(2), 2.MicrowattsPerCubicInch); + + [Fact] + public void NumberToMicrowattsPerCubicMeterTest() => + Assert.Equal(PowerDensity.FromMicrowattsPerCubicMeter(2), 2.MicrowattsPerCubicMeter); + + [Fact] + public void NumberToMicrowattsPerLiterTest() => + Assert.Equal(PowerDensity.FromMicrowattsPerLiter(2), 2.MicrowattsPerLiter); + + [Fact] + public void NumberToMilliwattsPerCubicFootTest() => + Assert.Equal(PowerDensity.FromMilliwattsPerCubicFoot(2), 2.MilliwattsPerCubicFoot); + + [Fact] + public void NumberToMilliwattsPerCubicInchTest() => + Assert.Equal(PowerDensity.FromMilliwattsPerCubicInch(2), 2.MilliwattsPerCubicInch); + + [Fact] + public void NumberToMilliwattsPerCubicMeterTest() => + Assert.Equal(PowerDensity.FromMilliwattsPerCubicMeter(2), 2.MilliwattsPerCubicMeter); + + [Fact] + public void NumberToMilliwattsPerLiterTest() => + Assert.Equal(PowerDensity.FromMilliwattsPerLiter(2), 2.MilliwattsPerLiter); + + [Fact] + public void NumberToNanowattsPerCubicFootTest() => + Assert.Equal(PowerDensity.FromNanowattsPerCubicFoot(2), 2.NanowattsPerCubicFoot); + + [Fact] + public void NumberToNanowattsPerCubicInchTest() => + Assert.Equal(PowerDensity.FromNanowattsPerCubicInch(2), 2.NanowattsPerCubicInch); + + [Fact] + public void NumberToNanowattsPerCubicMeterTest() => + Assert.Equal(PowerDensity.FromNanowattsPerCubicMeter(2), 2.NanowattsPerCubicMeter); + + [Fact] + public void NumberToNanowattsPerLiterTest() => + Assert.Equal(PowerDensity.FromNanowattsPerLiter(2), 2.NanowattsPerLiter); + + [Fact] + public void NumberToPicowattsPerCubicFootTest() => + Assert.Equal(PowerDensity.FromPicowattsPerCubicFoot(2), 2.PicowattsPerCubicFoot); + + [Fact] + public void NumberToPicowattsPerCubicInchTest() => + Assert.Equal(PowerDensity.FromPicowattsPerCubicInch(2), 2.PicowattsPerCubicInch); + + [Fact] + public void NumberToPicowattsPerCubicMeterTest() => + Assert.Equal(PowerDensity.FromPicowattsPerCubicMeter(2), 2.PicowattsPerCubicMeter); + + [Fact] + public void NumberToPicowattsPerLiterTest() => + Assert.Equal(PowerDensity.FromPicowattsPerLiter(2), 2.PicowattsPerLiter); + + [Fact] + public void NumberToTerawattsPerCubicFootTest() => + Assert.Equal(PowerDensity.FromTerawattsPerCubicFoot(2), 2.TerawattsPerCubicFoot); + + [Fact] + public void NumberToTerawattsPerCubicInchTest() => + Assert.Equal(PowerDensity.FromTerawattsPerCubicInch(2), 2.TerawattsPerCubicInch); + + [Fact] + public void NumberToTerawattsPerCubicMeterTest() => + Assert.Equal(PowerDensity.FromTerawattsPerCubicMeter(2), 2.TerawattsPerCubicMeter); + + [Fact] + public void NumberToTerawattsPerLiterTest() => + Assert.Equal(PowerDensity.FromTerawattsPerLiter(2), 2.TerawattsPerLiter); + + [Fact] + public void NumberToWattsPerCubicFootTest() => + Assert.Equal(PowerDensity.FromWattsPerCubicFoot(2), 2.WattsPerCubicFoot); + + [Fact] + public void NumberToWattsPerCubicInchTest() => + Assert.Equal(PowerDensity.FromWattsPerCubicInch(2), 2.WattsPerCubicInch); + + [Fact] + public void NumberToWattsPerCubicMeterTest() => + Assert.Equal(PowerDensity.FromWattsPerCubicMeter(2), 2.WattsPerCubicMeter); + + [Fact] + public void NumberToWattsPerLiterTest() => + Assert.Equal(PowerDensity.FromWattsPerLiter(2), 2.WattsPerLiter); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPowerExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPowerExtensionsTest.g.cs new file mode 100644 index 0000000000..5fca8f9312 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPowerExtensionsTest.g.cs @@ -0,0 +1,136 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToPower; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToPowerExtensionsTests + { + [Fact] + public void NumberToBoilerHorsepowerTest() => + Assert.Equal(Power.FromBoilerHorsepower(2), 2.BoilerHorsepower); + + [Fact] + public void NumberToBritishThermalUnitsPerHourTest() => + Assert.Equal(Power.FromBritishThermalUnitsPerHour(2), 2.BritishThermalUnitsPerHour); + + [Fact] + public void NumberToDecawattsTest() => + Assert.Equal(Power.FromDecawatts(2), 2.Decawatts); + + [Fact] + public void NumberToDeciwattsTest() => + Assert.Equal(Power.FromDeciwatts(2), 2.Deciwatts); + + [Fact] + public void NumberToElectricalHorsepowerTest() => + Assert.Equal(Power.FromElectricalHorsepower(2), 2.ElectricalHorsepower); + + [Fact] + public void NumberToFemtowattsTest() => + Assert.Equal(Power.FromFemtowatts(2), 2.Femtowatts); + + [Fact] + public void NumberToGigajoulesPerHourTest() => + Assert.Equal(Power.FromGigajoulesPerHour(2), 2.GigajoulesPerHour); + + [Fact] + public void NumberToGigawattsTest() => + Assert.Equal(Power.FromGigawatts(2), 2.Gigawatts); + + [Fact] + public void NumberToHydraulicHorsepowerTest() => + Assert.Equal(Power.FromHydraulicHorsepower(2), 2.HydraulicHorsepower); + + [Fact] + public void NumberToJoulesPerHourTest() => + Assert.Equal(Power.FromJoulesPerHour(2), 2.JoulesPerHour); + + [Fact] + public void NumberToKilobritishThermalUnitsPerHourTest() => + Assert.Equal(Power.FromKilobritishThermalUnitsPerHour(2), 2.KilobritishThermalUnitsPerHour); + + [Fact] + public void NumberToKilojoulesPerHourTest() => + Assert.Equal(Power.FromKilojoulesPerHour(2), 2.KilojoulesPerHour); + + [Fact] + public void NumberToKilowattsTest() => + Assert.Equal(Power.FromKilowatts(2), 2.Kilowatts); + + [Fact] + public void NumberToMechanicalHorsepowerTest() => + Assert.Equal(Power.FromMechanicalHorsepower(2), 2.MechanicalHorsepower); + + [Fact] + public void NumberToMegabritishThermalUnitsPerHourTest() => + Assert.Equal(Power.FromMegabritishThermalUnitsPerHour(2), 2.MegabritishThermalUnitsPerHour); + + [Fact] + public void NumberToMegajoulesPerHourTest() => + Assert.Equal(Power.FromMegajoulesPerHour(2), 2.MegajoulesPerHour); + + [Fact] + public void NumberToMegawattsTest() => + Assert.Equal(Power.FromMegawatts(2), 2.Megawatts); + + [Fact] + public void NumberToMetricHorsepowerTest() => + Assert.Equal(Power.FromMetricHorsepower(2), 2.MetricHorsepower); + + [Fact] + public void NumberToMicrowattsTest() => + Assert.Equal(Power.FromMicrowatts(2), 2.Microwatts); + + [Fact] + public void NumberToMillijoulesPerHourTest() => + Assert.Equal(Power.FromMillijoulesPerHour(2), 2.MillijoulesPerHour); + + [Fact] + public void NumberToMilliwattsTest() => + Assert.Equal(Power.FromMilliwatts(2), 2.Milliwatts); + + [Fact] + public void NumberToNanowattsTest() => + Assert.Equal(Power.FromNanowatts(2), 2.Nanowatts); + + [Fact] + public void NumberToPetawattsTest() => + Assert.Equal(Power.FromPetawatts(2), 2.Petawatts); + + [Fact] + public void NumberToPicowattsTest() => + Assert.Equal(Power.FromPicowatts(2), 2.Picowatts); + + [Fact] + public void NumberToTerawattsTest() => + Assert.Equal(Power.FromTerawatts(2), 2.Terawatts); + + [Fact] + public void NumberToTonsOfRefrigerationTest() => + Assert.Equal(Power.FromTonsOfRefrigeration(2), 2.TonsOfRefrigeration); + + [Fact] + public void NumberToWattsTest() => + Assert.Equal(Power.FromWatts(2), 2.Watts); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPowerRatioExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPowerRatioExtensionsTest.g.cs new file mode 100644 index 0000000000..ea5d57e054 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPowerRatioExtensionsTest.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 UnitsNet.NumberExtensions.NumberToPowerRatio; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToPowerRatioExtensionsTests + { + [Fact] + public void NumberToDecibelMilliwattsTest() => + Assert.Equal(PowerRatio.FromDecibelMilliwatts(2), 2.DecibelMilliwatts); + + [Fact] + public void NumberToDecibelWattsTest() => + Assert.Equal(PowerRatio.FromDecibelWatts(2), 2.DecibelWatts); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPressureChangeRateExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPressureChangeRateExtensionsTest.g.cs new file mode 100644 index 0000000000..b762cc0c61 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPressureChangeRateExtensionsTest.g.cs @@ -0,0 +1,100 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToPressureChangeRate; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToPressureChangeRateExtensionsTests + { + [Fact] + public void NumberToAtmospheresPerSecondTest() => + Assert.Equal(PressureChangeRate.FromAtmospheresPerSecond(2), 2.AtmospheresPerSecond); + + [Fact] + public void NumberToBarsPerMinuteTest() => + Assert.Equal(PressureChangeRate.FromBarsPerMinute(2), 2.BarsPerMinute); + + [Fact] + public void NumberToBarsPerSecondTest() => + Assert.Equal(PressureChangeRate.FromBarsPerSecond(2), 2.BarsPerSecond); + + [Fact] + public void NumberToKilopascalsPerMinuteTest() => + Assert.Equal(PressureChangeRate.FromKilopascalsPerMinute(2), 2.KilopascalsPerMinute); + + [Fact] + public void NumberToKilopascalsPerSecondTest() => + Assert.Equal(PressureChangeRate.FromKilopascalsPerSecond(2), 2.KilopascalsPerSecond); + + [Fact] + public void NumberToKilopoundsForcePerSquareInchPerMinuteTest() => + Assert.Equal(PressureChangeRate.FromKilopoundsForcePerSquareInchPerMinute(2), 2.KilopoundsForcePerSquareInchPerMinute); + + [Fact] + public void NumberToKilopoundsForcePerSquareInchPerSecondTest() => + Assert.Equal(PressureChangeRate.FromKilopoundsForcePerSquareInchPerSecond(2), 2.KilopoundsForcePerSquareInchPerSecond); + + [Fact] + public void NumberToMegapascalsPerMinuteTest() => + Assert.Equal(PressureChangeRate.FromMegapascalsPerMinute(2), 2.MegapascalsPerMinute); + + [Fact] + public void NumberToMegapascalsPerSecondTest() => + Assert.Equal(PressureChangeRate.FromMegapascalsPerSecond(2), 2.MegapascalsPerSecond); + + [Fact] + public void NumberToMegapoundsForcePerSquareInchPerMinuteTest() => + Assert.Equal(PressureChangeRate.FromMegapoundsForcePerSquareInchPerMinute(2), 2.MegapoundsForcePerSquareInchPerMinute); + + [Fact] + public void NumberToMegapoundsForcePerSquareInchPerSecondTest() => + Assert.Equal(PressureChangeRate.FromMegapoundsForcePerSquareInchPerSecond(2), 2.MegapoundsForcePerSquareInchPerSecond); + + [Fact] + public void NumberToMillibarsPerMinuteTest() => + Assert.Equal(PressureChangeRate.FromMillibarsPerMinute(2), 2.MillibarsPerMinute); + + [Fact] + public void NumberToMillibarsPerSecondTest() => + Assert.Equal(PressureChangeRate.FromMillibarsPerSecond(2), 2.MillibarsPerSecond); + + [Fact] + public void NumberToMillimetersOfMercuryPerSecondTest() => + Assert.Equal(PressureChangeRate.FromMillimetersOfMercuryPerSecond(2), 2.MillimetersOfMercuryPerSecond); + + [Fact] + public void NumberToPascalsPerMinuteTest() => + Assert.Equal(PressureChangeRate.FromPascalsPerMinute(2), 2.PascalsPerMinute); + + [Fact] + public void NumberToPascalsPerSecondTest() => + Assert.Equal(PressureChangeRate.FromPascalsPerSecond(2), 2.PascalsPerSecond); + + [Fact] + public void NumberToPoundsForcePerSquareInchPerMinuteTest() => + Assert.Equal(PressureChangeRate.FromPoundsForcePerSquareInchPerMinute(2), 2.PoundsForcePerSquareInchPerMinute); + + [Fact] + public void NumberToPoundsForcePerSquareInchPerSecondTest() => + Assert.Equal(PressureChangeRate.FromPoundsForcePerSquareInchPerSecond(2), 2.PoundsForcePerSquareInchPerSecond); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPressureExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPressureExtensionsTest.g.cs new file mode 100644 index 0000000000..904dc52a68 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToPressureExtensionsTest.g.cs @@ -0,0 +1,220 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToPressure; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToPressureExtensionsTests + { + [Fact] + public void NumberToAtmospheresTest() => + Assert.Equal(Pressure.FromAtmospheres(2), 2.Atmospheres); + + [Fact] + public void NumberToBarsTest() => + Assert.Equal(Pressure.FromBars(2), 2.Bars); + + [Fact] + public void NumberToCentibarsTest() => + Assert.Equal(Pressure.FromCentibars(2), 2.Centibars); + + [Fact] + public void NumberToCentimetersOfWaterColumnTest() => + Assert.Equal(Pressure.FromCentimetersOfWaterColumn(2), 2.CentimetersOfWaterColumn); + + [Fact] + public void NumberToDecapascalsTest() => + Assert.Equal(Pressure.FromDecapascals(2), 2.Decapascals); + + [Fact] + public void NumberToDecibarsTest() => + Assert.Equal(Pressure.FromDecibars(2), 2.Decibars); + + [Fact] + public void NumberToDynesPerSquareCentimeterTest() => + Assert.Equal(Pressure.FromDynesPerSquareCentimeter(2), 2.DynesPerSquareCentimeter); + + [Fact] + public void NumberToFeetOfHeadTest() => + Assert.Equal(Pressure.FromFeetOfHead(2), 2.FeetOfHead); + + [Fact] + public void NumberToGigapascalsTest() => + Assert.Equal(Pressure.FromGigapascals(2), 2.Gigapascals); + + [Fact] + public void NumberToHectopascalsTest() => + Assert.Equal(Pressure.FromHectopascals(2), 2.Hectopascals); + + [Fact] + public void NumberToInchesOfMercuryTest() => + Assert.Equal(Pressure.FromInchesOfMercury(2), 2.InchesOfMercury); + + [Fact] + public void NumberToInchesOfWaterColumnTest() => + Assert.Equal(Pressure.FromInchesOfWaterColumn(2), 2.InchesOfWaterColumn); + + [Fact] + public void NumberToKilobarsTest() => + Assert.Equal(Pressure.FromKilobars(2), 2.Kilobars); + + [Fact] + public void NumberToKilogramsForcePerSquareCentimeterTest() => + Assert.Equal(Pressure.FromKilogramsForcePerSquareCentimeter(2), 2.KilogramsForcePerSquareCentimeter); + + [Fact] + public void NumberToKilogramsForcePerSquareMeterTest() => + Assert.Equal(Pressure.FromKilogramsForcePerSquareMeter(2), 2.KilogramsForcePerSquareMeter); + + [Fact] + public void NumberToKilogramsForcePerSquareMillimeterTest() => + Assert.Equal(Pressure.FromKilogramsForcePerSquareMillimeter(2), 2.KilogramsForcePerSquareMillimeter); + + [Fact] + public void NumberToKilonewtonsPerSquareCentimeterTest() => + Assert.Equal(Pressure.FromKilonewtonsPerSquareCentimeter(2), 2.KilonewtonsPerSquareCentimeter); + + [Fact] + public void NumberToKilonewtonsPerSquareMeterTest() => + Assert.Equal(Pressure.FromKilonewtonsPerSquareMeter(2), 2.KilonewtonsPerSquareMeter); + + [Fact] + public void NumberToKilonewtonsPerSquareMillimeterTest() => + Assert.Equal(Pressure.FromKilonewtonsPerSquareMillimeter(2), 2.KilonewtonsPerSquareMillimeter); + + [Fact] + public void NumberToKilopascalsTest() => + Assert.Equal(Pressure.FromKilopascals(2), 2.Kilopascals); + + [Fact] + public void NumberToKilopoundsForcePerSquareFootTest() => + Assert.Equal(Pressure.FromKilopoundsForcePerSquareFoot(2), 2.KilopoundsForcePerSquareFoot); + + [Fact] + public void NumberToKilopoundsForcePerSquareInchTest() => + Assert.Equal(Pressure.FromKilopoundsForcePerSquareInch(2), 2.KilopoundsForcePerSquareInch); + + [Fact] + public void NumberToKilopoundsForcePerSquareMilTest() => + Assert.Equal(Pressure.FromKilopoundsForcePerSquareMil(2), 2.KilopoundsForcePerSquareMil); + + [Fact] + public void NumberToMegabarsTest() => + Assert.Equal(Pressure.FromMegabars(2), 2.Megabars); + + [Fact] + public void NumberToMeganewtonsPerSquareMeterTest() => + Assert.Equal(Pressure.FromMeganewtonsPerSquareMeter(2), 2.MeganewtonsPerSquareMeter); + + [Fact] + public void NumberToMegapascalsTest() => + Assert.Equal(Pressure.FromMegapascals(2), 2.Megapascals); + + [Fact] + public void NumberToMetersOfHeadTest() => + Assert.Equal(Pressure.FromMetersOfHead(2), 2.MetersOfHead); + + [Fact] + public void NumberToMetersOfWaterColumnTest() => + Assert.Equal(Pressure.FromMetersOfWaterColumn(2), 2.MetersOfWaterColumn); + + [Fact] + public void NumberToMicrobarsTest() => + Assert.Equal(Pressure.FromMicrobars(2), 2.Microbars); + + [Fact] + public void NumberToMicropascalsTest() => + Assert.Equal(Pressure.FromMicropascals(2), 2.Micropascals); + + [Fact] + public void NumberToMillibarsTest() => + Assert.Equal(Pressure.FromMillibars(2), 2.Millibars); + + [Fact] + public void NumberToMillimetersOfMercuryTest() => + Assert.Equal(Pressure.FromMillimetersOfMercury(2), 2.MillimetersOfMercury); + + [Fact] + public void NumberToMillimetersOfWaterColumnTest() => + Assert.Equal(Pressure.FromMillimetersOfWaterColumn(2), 2.MillimetersOfWaterColumn); + + [Fact] + public void NumberToMillipascalsTest() => + Assert.Equal(Pressure.FromMillipascals(2), 2.Millipascals); + + [Fact] + public void NumberToMillitorrsTest() => + Assert.Equal(Pressure.FromMillitorrs(2), 2.Millitorrs); + + [Fact] + public void NumberToNewtonsPerSquareCentimeterTest() => + Assert.Equal(Pressure.FromNewtonsPerSquareCentimeter(2), 2.NewtonsPerSquareCentimeter); + + [Fact] + public void NumberToNewtonsPerSquareMeterTest() => + Assert.Equal(Pressure.FromNewtonsPerSquareMeter(2), 2.NewtonsPerSquareMeter); + + [Fact] + public void NumberToNewtonsPerSquareMillimeterTest() => + Assert.Equal(Pressure.FromNewtonsPerSquareMillimeter(2), 2.NewtonsPerSquareMillimeter); + + [Fact] + public void NumberToPascalsTest() => + Assert.Equal(Pressure.FromPascals(2), 2.Pascals); + + [Fact] + public void NumberToPoundsForcePerSquareFootTest() => + Assert.Equal(Pressure.FromPoundsForcePerSquareFoot(2), 2.PoundsForcePerSquareFoot); + + [Fact] + public void NumberToPoundsForcePerSquareInchTest() => + Assert.Equal(Pressure.FromPoundsForcePerSquareInch(2), 2.PoundsForcePerSquareInch); + + [Fact] + public void NumberToPoundsForcePerSquareMilTest() => + Assert.Equal(Pressure.FromPoundsForcePerSquareMil(2), 2.PoundsForcePerSquareMil); + + [Fact] + public void NumberToPoundsPerInchSecondSquaredTest() => + Assert.Equal(Pressure.FromPoundsPerInchSecondSquared(2), 2.PoundsPerInchSecondSquared); + + [Fact] + public void NumberToTechnicalAtmospheresTest() => + Assert.Equal(Pressure.FromTechnicalAtmospheres(2), 2.TechnicalAtmospheres); + + [Fact] + public void NumberToTonnesForcePerSquareCentimeterTest() => + Assert.Equal(Pressure.FromTonnesForcePerSquareCentimeter(2), 2.TonnesForcePerSquareCentimeter); + + [Fact] + public void NumberToTonnesForcePerSquareMeterTest() => + Assert.Equal(Pressure.FromTonnesForcePerSquareMeter(2), 2.TonnesForcePerSquareMeter); + + [Fact] + public void NumberToTonnesForcePerSquareMillimeterTest() => + Assert.Equal(Pressure.FromTonnesForcePerSquareMillimeter(2), 2.TonnesForcePerSquareMillimeter); + + [Fact] + public void NumberToTorrsTest() => + Assert.Equal(Pressure.FromTorrs(2), 2.Torrs); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRadiationEquivalentDoseExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRadiationEquivalentDoseExtensionsTest.g.cs new file mode 100644 index 0000000000..52642298b3 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRadiationEquivalentDoseExtensionsTest.g.cs @@ -0,0 +1,52 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToRadiationEquivalentDose; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToRadiationEquivalentDoseExtensionsTests + { + [Fact] + public void NumberToMicrosievertsTest() => + Assert.Equal(RadiationEquivalentDose.FromMicrosieverts(2), 2.Microsieverts); + + [Fact] + public void NumberToMilliroentgensEquivalentManTest() => + Assert.Equal(RadiationEquivalentDose.FromMilliroentgensEquivalentMan(2), 2.MilliroentgensEquivalentMan); + + [Fact] + public void NumberToMillisievertsTest() => + Assert.Equal(RadiationEquivalentDose.FromMillisieverts(2), 2.Millisieverts); + + [Fact] + public void NumberToNanosievertsTest() => + Assert.Equal(RadiationEquivalentDose.FromNanosieverts(2), 2.Nanosieverts); + + [Fact] + public void NumberToRoentgensEquivalentManTest() => + Assert.Equal(RadiationEquivalentDose.FromRoentgensEquivalentMan(2), 2.RoentgensEquivalentMan); + + [Fact] + public void NumberToSievertsTest() => + Assert.Equal(RadiationEquivalentDose.FromSieverts(2), 2.Sieverts); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRadiationEquivalentDoseRateExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRadiationEquivalentDoseRateExtensionsTest.g.cs new file mode 100644 index 0000000000..428af3ac5a --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRadiationEquivalentDoseRateExtensionsTest.g.cs @@ -0,0 +1,68 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToRadiationEquivalentDoseRate; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToRadiationEquivalentDoseRateExtensionsTests + { + [Fact] + public void NumberToMicrosievertsPerHourTest() => + Assert.Equal(RadiationEquivalentDoseRate.FromMicrosievertsPerHour(2), 2.MicrosievertsPerHour); + + [Fact] + public void NumberToMicrosievertsPerSecondTest() => + Assert.Equal(RadiationEquivalentDoseRate.FromMicrosievertsPerSecond(2), 2.MicrosievertsPerSecond); + + [Fact] + public void NumberToMilliroentgensEquivalentManPerHourTest() => + Assert.Equal(RadiationEquivalentDoseRate.FromMilliroentgensEquivalentManPerHour(2), 2.MilliroentgensEquivalentManPerHour); + + [Fact] + public void NumberToMillisievertsPerHourTest() => + Assert.Equal(RadiationEquivalentDoseRate.FromMillisievertsPerHour(2), 2.MillisievertsPerHour); + + [Fact] + public void NumberToMillisievertsPerSecondTest() => + Assert.Equal(RadiationEquivalentDoseRate.FromMillisievertsPerSecond(2), 2.MillisievertsPerSecond); + + [Fact] + public void NumberToNanosievertsPerHourTest() => + Assert.Equal(RadiationEquivalentDoseRate.FromNanosievertsPerHour(2), 2.NanosievertsPerHour); + + [Fact] + public void NumberToNanosievertsPerSecondTest() => + Assert.Equal(RadiationEquivalentDoseRate.FromNanosievertsPerSecond(2), 2.NanosievertsPerSecond); + + [Fact] + public void NumberToRoentgensEquivalentManPerHourTest() => + Assert.Equal(RadiationEquivalentDoseRate.FromRoentgensEquivalentManPerHour(2), 2.RoentgensEquivalentManPerHour); + + [Fact] + public void NumberToSievertsPerHourTest() => + Assert.Equal(RadiationEquivalentDoseRate.FromSievertsPerHour(2), 2.SievertsPerHour); + + [Fact] + public void NumberToSievertsPerSecondTest() => + Assert.Equal(RadiationEquivalentDoseRate.FromSievertsPerSecond(2), 2.SievertsPerSecond); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRadiationExposureExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRadiationExposureExtensionsTest.g.cs new file mode 100644 index 0000000000..b14a9b4c4a --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRadiationExposureExtensionsTest.g.cs @@ -0,0 +1,60 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToRadiationExposure; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToRadiationExposureExtensionsTests + { + [Fact] + public void NumberToCoulombsPerKilogramTest() => + Assert.Equal(RadiationExposure.FromCoulombsPerKilogram(2), 2.CoulombsPerKilogram); + + [Fact] + public void NumberToMicrocoulombsPerKilogramTest() => + Assert.Equal(RadiationExposure.FromMicrocoulombsPerKilogram(2), 2.MicrocoulombsPerKilogram); + + [Fact] + public void NumberToMicroroentgensTest() => + Assert.Equal(RadiationExposure.FromMicroroentgens(2), 2.Microroentgens); + + [Fact] + public void NumberToMillicoulombsPerKilogramTest() => + Assert.Equal(RadiationExposure.FromMillicoulombsPerKilogram(2), 2.MillicoulombsPerKilogram); + + [Fact] + public void NumberToMilliroentgensTest() => + Assert.Equal(RadiationExposure.FromMilliroentgens(2), 2.Milliroentgens); + + [Fact] + public void NumberToNanocoulombsPerKilogramTest() => + Assert.Equal(RadiationExposure.FromNanocoulombsPerKilogram(2), 2.NanocoulombsPerKilogram); + + [Fact] + public void NumberToPicocoulombsPerKilogramTest() => + Assert.Equal(RadiationExposure.FromPicocoulombsPerKilogram(2), 2.PicocoulombsPerKilogram); + + [Fact] + public void NumberToRoentgensTest() => + Assert.Equal(RadiationExposure.FromRoentgens(2), 2.Roentgens); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRadioactivityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRadioactivityExtensionsTest.g.cs new file mode 100644 index 0000000000..c08800528c --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRadioactivityExtensionsTest.g.cs @@ -0,0 +1,144 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToRadioactivity; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToRadioactivityExtensionsTests + { + [Fact] + public void NumberToBecquerelsTest() => + Assert.Equal(Radioactivity.FromBecquerels(2), 2.Becquerels); + + [Fact] + public void NumberToCuriesTest() => + Assert.Equal(Radioactivity.FromCuries(2), 2.Curies); + + [Fact] + public void NumberToExabecquerelsTest() => + Assert.Equal(Radioactivity.FromExabecquerels(2), 2.Exabecquerels); + + [Fact] + public void NumberToGigabecquerelsTest() => + Assert.Equal(Radioactivity.FromGigabecquerels(2), 2.Gigabecquerels); + + [Fact] + public void NumberToGigacuriesTest() => + Assert.Equal(Radioactivity.FromGigacuries(2), 2.Gigacuries); + + [Fact] + public void NumberToGigarutherfordsTest() => + Assert.Equal(Radioactivity.FromGigarutherfords(2), 2.Gigarutherfords); + + [Fact] + public void NumberToKilobecquerelsTest() => + Assert.Equal(Radioactivity.FromKilobecquerels(2), 2.Kilobecquerels); + + [Fact] + public void NumberToKilocuriesTest() => + Assert.Equal(Radioactivity.FromKilocuries(2), 2.Kilocuries); + + [Fact] + public void NumberToKilorutherfordsTest() => + Assert.Equal(Radioactivity.FromKilorutherfords(2), 2.Kilorutherfords); + + [Fact] + public void NumberToMegabecquerelsTest() => + Assert.Equal(Radioactivity.FromMegabecquerels(2), 2.Megabecquerels); + + [Fact] + public void NumberToMegacuriesTest() => + Assert.Equal(Radioactivity.FromMegacuries(2), 2.Megacuries); + + [Fact] + public void NumberToMegarutherfordsTest() => + Assert.Equal(Radioactivity.FromMegarutherfords(2), 2.Megarutherfords); + + [Fact] + public void NumberToMicrobecquerelsTest() => + Assert.Equal(Radioactivity.FromMicrobecquerels(2), 2.Microbecquerels); + + [Fact] + public void NumberToMicrocuriesTest() => + Assert.Equal(Radioactivity.FromMicrocuries(2), 2.Microcuries); + + [Fact] + public void NumberToMicrorutherfordsTest() => + Assert.Equal(Radioactivity.FromMicrorutherfords(2), 2.Microrutherfords); + + [Fact] + public void NumberToMillibecquerelsTest() => + Assert.Equal(Radioactivity.FromMillibecquerels(2), 2.Millibecquerels); + + [Fact] + public void NumberToMillicuriesTest() => + Assert.Equal(Radioactivity.FromMillicuries(2), 2.Millicuries); + + [Fact] + public void NumberToMillirutherfordsTest() => + Assert.Equal(Radioactivity.FromMillirutherfords(2), 2.Millirutherfords); + + [Fact] + public void NumberToNanobecquerelsTest() => + Assert.Equal(Radioactivity.FromNanobecquerels(2), 2.Nanobecquerels); + + [Fact] + public void NumberToNanocuriesTest() => + Assert.Equal(Radioactivity.FromNanocuries(2), 2.Nanocuries); + + [Fact] + public void NumberToNanorutherfordsTest() => + Assert.Equal(Radioactivity.FromNanorutherfords(2), 2.Nanorutherfords); + + [Fact] + public void NumberToPetabecquerelsTest() => + Assert.Equal(Radioactivity.FromPetabecquerels(2), 2.Petabecquerels); + + [Fact] + public void NumberToPicobecquerelsTest() => + Assert.Equal(Radioactivity.FromPicobecquerels(2), 2.Picobecquerels); + + [Fact] + public void NumberToPicocuriesTest() => + Assert.Equal(Radioactivity.FromPicocuries(2), 2.Picocuries); + + [Fact] + public void NumberToPicorutherfordsTest() => + Assert.Equal(Radioactivity.FromPicorutherfords(2), 2.Picorutherfords); + + [Fact] + public void NumberToRutherfordsTest() => + Assert.Equal(Radioactivity.FromRutherfords(2), 2.Rutherfords); + + [Fact] + public void NumberToTerabecquerelsTest() => + Assert.Equal(Radioactivity.FromTerabecquerels(2), 2.Terabecquerels); + + [Fact] + public void NumberToTeracuriesTest() => + Assert.Equal(Radioactivity.FromTeracuries(2), 2.Teracuries); + + [Fact] + public void NumberToTerarutherfordsTest() => + Assert.Equal(Radioactivity.FromTerarutherfords(2), 2.Terarutherfords); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRatioChangeRateExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRatioChangeRateExtensionsTest.g.cs new file mode 100644 index 0000000000..78bcaa509e --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRatioChangeRateExtensionsTest.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 UnitsNet.NumberExtensions.NumberToRatioChangeRate; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToRatioChangeRateExtensionsTests + { + [Fact] + public void NumberToDecimalFractionsPerSecondTest() => + Assert.Equal(RatioChangeRate.FromDecimalFractionsPerSecond(2), 2.DecimalFractionsPerSecond); + + [Fact] + public void NumberToPercentsPerSecondTest() => + Assert.Equal(RatioChangeRate.FromPercentsPerSecond(2), 2.PercentsPerSecond); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRatioExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRatioExtensionsTest.g.cs new file mode 100644 index 0000000000..15f7e7fe4a --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRatioExtensionsTest.g.cs @@ -0,0 +1,52 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToRatio; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToRatioExtensionsTests + { + [Fact] + public void NumberToDecimalFractionsTest() => + Assert.Equal(Ratio.FromDecimalFractions(2), 2.DecimalFractions); + + [Fact] + public void NumberToPartsPerBillionTest() => + Assert.Equal(Ratio.FromPartsPerBillion(2), 2.PartsPerBillion); + + [Fact] + public void NumberToPartsPerMillionTest() => + Assert.Equal(Ratio.FromPartsPerMillion(2), 2.PartsPerMillion); + + [Fact] + public void NumberToPartsPerThousandTest() => + Assert.Equal(Ratio.FromPartsPerThousand(2), 2.PartsPerThousand); + + [Fact] + public void NumberToPartsPerTrillionTest() => + Assert.Equal(Ratio.FromPartsPerTrillion(2), 2.PartsPerTrillion); + + [Fact] + public void NumberToPercentTest() => + Assert.Equal(Ratio.FromPercent(2), 2.Percent); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToReciprocalAreaExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToReciprocalAreaExtensionsTest.g.cs new file mode 100644 index 0000000000..277f681bcc --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToReciprocalAreaExtensionsTest.g.cs @@ -0,0 +1,72 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToReciprocalArea; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToReciprocalAreaExtensionsTests + { + [Fact] + public void NumberToInverseSquareCentimetersTest() => + Assert.Equal(ReciprocalArea.FromInverseSquareCentimeters(2), 2.InverseSquareCentimeters); + + [Fact] + public void NumberToInverseSquareDecimetersTest() => + Assert.Equal(ReciprocalArea.FromInverseSquareDecimeters(2), 2.InverseSquareDecimeters); + + [Fact] + public void NumberToInverseSquareFeetTest() => + Assert.Equal(ReciprocalArea.FromInverseSquareFeet(2), 2.InverseSquareFeet); + + [Fact] + public void NumberToInverseSquareInchesTest() => + Assert.Equal(ReciprocalArea.FromInverseSquareInches(2), 2.InverseSquareInches); + + [Fact] + public void NumberToInverseSquareKilometersTest() => + Assert.Equal(ReciprocalArea.FromInverseSquareKilometers(2), 2.InverseSquareKilometers); + + [Fact] + public void NumberToInverseSquareMetersTest() => + Assert.Equal(ReciprocalArea.FromInverseSquareMeters(2), 2.InverseSquareMeters); + + [Fact] + public void NumberToInverseSquareMicrometersTest() => + Assert.Equal(ReciprocalArea.FromInverseSquareMicrometers(2), 2.InverseSquareMicrometers); + + [Fact] + public void NumberToInverseSquareMilesTest() => + Assert.Equal(ReciprocalArea.FromInverseSquareMiles(2), 2.InverseSquareMiles); + + [Fact] + public void NumberToInverseSquareMillimetersTest() => + Assert.Equal(ReciprocalArea.FromInverseSquareMillimeters(2), 2.InverseSquareMillimeters); + + [Fact] + public void NumberToInverseSquareYardsTest() => + Assert.Equal(ReciprocalArea.FromInverseSquareYards(2), 2.InverseSquareYards); + + [Fact] + public void NumberToInverseUsSurveySquareFeetTest() => + Assert.Equal(ReciprocalArea.FromInverseUsSurveySquareFeet(2), 2.InverseUsSurveySquareFeet); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToReciprocalLengthExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToReciprocalLengthExtensionsTest.g.cs new file mode 100644 index 0000000000..dc69c726a0 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToReciprocalLengthExtensionsTest.g.cs @@ -0,0 +1,68 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToReciprocalLength; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToReciprocalLengthExtensionsTests + { + [Fact] + public void NumberToInverseCentimetersTest() => + Assert.Equal(ReciprocalLength.FromInverseCentimeters(2), 2.InverseCentimeters); + + [Fact] + public void NumberToInverseFeetTest() => + Assert.Equal(ReciprocalLength.FromInverseFeet(2), 2.InverseFeet); + + [Fact] + public void NumberToInverseInchesTest() => + Assert.Equal(ReciprocalLength.FromInverseInches(2), 2.InverseInches); + + [Fact] + public void NumberToInverseMetersTest() => + Assert.Equal(ReciprocalLength.FromInverseMeters(2), 2.InverseMeters); + + [Fact] + public void NumberToInverseMicroinchesTest() => + Assert.Equal(ReciprocalLength.FromInverseMicroinches(2), 2.InverseMicroinches); + + [Fact] + public void NumberToInverseMilsTest() => + Assert.Equal(ReciprocalLength.FromInverseMils(2), 2.InverseMils); + + [Fact] + public void NumberToInverseMilesTest() => + Assert.Equal(ReciprocalLength.FromInverseMiles(2), 2.InverseMiles); + + [Fact] + public void NumberToInverseMillimetersTest() => + Assert.Equal(ReciprocalLength.FromInverseMillimeters(2), 2.InverseMillimeters); + + [Fact] + public void NumberToInverseUsSurveyFeetTest() => + Assert.Equal(ReciprocalLength.FromInverseUsSurveyFeet(2), 2.InverseUsSurveyFeet); + + [Fact] + public void NumberToInverseYardsTest() => + Assert.Equal(ReciprocalLength.FromInverseYards(2), 2.InverseYards); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRelativeHumidityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRelativeHumidityExtensionsTest.g.cs new file mode 100644 index 0000000000..496e4f9d48 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRelativeHumidityExtensionsTest.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.NumberToRelativeHumidity; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToRelativeHumidityExtensionsTests + { + [Fact] + public void NumberToPercentTest() => + Assert.Equal(RelativeHumidity.FromPercent(2), 2.Percent); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRotationalAccelerationExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRotationalAccelerationExtensionsTest.g.cs new file mode 100644 index 0000000000..e78b075189 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRotationalAccelerationExtensionsTest.g.cs @@ -0,0 +1,44 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToRotationalAcceleration; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToRotationalAccelerationExtensionsTests + { + [Fact] + public void NumberToDegreesPerSecondSquaredTest() => + Assert.Equal(RotationalAcceleration.FromDegreesPerSecondSquared(2), 2.DegreesPerSecondSquared); + + [Fact] + public void NumberToRadiansPerSecondSquaredTest() => + Assert.Equal(RotationalAcceleration.FromRadiansPerSecondSquared(2), 2.RadiansPerSecondSquared); + + [Fact] + public void NumberToRevolutionsPerMinutePerSecondTest() => + Assert.Equal(RotationalAcceleration.FromRevolutionsPerMinutePerSecond(2), 2.RevolutionsPerMinutePerSecond); + + [Fact] + public void NumberToRevolutionsPerSecondSquaredTest() => + Assert.Equal(RotationalAcceleration.FromRevolutionsPerSecondSquared(2), 2.RevolutionsPerSecondSquared); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRotationalSpeedExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRotationalSpeedExtensionsTest.g.cs new file mode 100644 index 0000000000..6db7dc413b --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRotationalSpeedExtensionsTest.g.cs @@ -0,0 +1,80 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToRotationalSpeed; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToRotationalSpeedExtensionsTests + { + [Fact] + public void NumberToCentiradiansPerSecondTest() => + Assert.Equal(RotationalSpeed.FromCentiradiansPerSecond(2), 2.CentiradiansPerSecond); + + [Fact] + public void NumberToDeciradiansPerSecondTest() => + Assert.Equal(RotationalSpeed.FromDeciradiansPerSecond(2), 2.DeciradiansPerSecond); + + [Fact] + public void NumberToDegreesPerMinuteTest() => + Assert.Equal(RotationalSpeed.FromDegreesPerMinute(2), 2.DegreesPerMinute); + + [Fact] + public void NumberToDegreesPerSecondTest() => + Assert.Equal(RotationalSpeed.FromDegreesPerSecond(2), 2.DegreesPerSecond); + + [Fact] + public void NumberToMicrodegreesPerSecondTest() => + Assert.Equal(RotationalSpeed.FromMicrodegreesPerSecond(2), 2.MicrodegreesPerSecond); + + [Fact] + public void NumberToMicroradiansPerSecondTest() => + Assert.Equal(RotationalSpeed.FromMicroradiansPerSecond(2), 2.MicroradiansPerSecond); + + [Fact] + public void NumberToMillidegreesPerSecondTest() => + Assert.Equal(RotationalSpeed.FromMillidegreesPerSecond(2), 2.MillidegreesPerSecond); + + [Fact] + public void NumberToMilliradiansPerSecondTest() => + Assert.Equal(RotationalSpeed.FromMilliradiansPerSecond(2), 2.MilliradiansPerSecond); + + [Fact] + public void NumberToNanodegreesPerSecondTest() => + Assert.Equal(RotationalSpeed.FromNanodegreesPerSecond(2), 2.NanodegreesPerSecond); + + [Fact] + public void NumberToNanoradiansPerSecondTest() => + Assert.Equal(RotationalSpeed.FromNanoradiansPerSecond(2), 2.NanoradiansPerSecond); + + [Fact] + public void NumberToRadiansPerSecondTest() => + Assert.Equal(RotationalSpeed.FromRadiansPerSecond(2), 2.RadiansPerSecond); + + [Fact] + public void NumberToRevolutionsPerMinuteTest() => + Assert.Equal(RotationalSpeed.FromRevolutionsPerMinute(2), 2.RevolutionsPerMinute); + + [Fact] + public void NumberToRevolutionsPerSecondTest() => + Assert.Equal(RotationalSpeed.FromRevolutionsPerSecond(2), 2.RevolutionsPerSecond); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRotationalStiffnessExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRotationalStiffnessExtensionsTest.g.cs new file mode 100644 index 0000000000..f080820a3a --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRotationalStiffnessExtensionsTest.g.cs @@ -0,0 +1,160 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToRotationalStiffness; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToRotationalStiffnessExtensionsTests + { + [Fact] + public void NumberToCentinewtonMetersPerDegreeTest() => + Assert.Equal(RotationalStiffness.FromCentinewtonMetersPerDegree(2), 2.CentinewtonMetersPerDegree); + + [Fact] + public void NumberToCentinewtonMillimetersPerDegreeTest() => + Assert.Equal(RotationalStiffness.FromCentinewtonMillimetersPerDegree(2), 2.CentinewtonMillimetersPerDegree); + + [Fact] + public void NumberToCentinewtonMillimetersPerRadianTest() => + Assert.Equal(RotationalStiffness.FromCentinewtonMillimetersPerRadian(2), 2.CentinewtonMillimetersPerRadian); + + [Fact] + public void NumberToDecanewtonMetersPerDegreeTest() => + Assert.Equal(RotationalStiffness.FromDecanewtonMetersPerDegree(2), 2.DecanewtonMetersPerDegree); + + [Fact] + public void NumberToDecanewtonMillimetersPerDegreeTest() => + Assert.Equal(RotationalStiffness.FromDecanewtonMillimetersPerDegree(2), 2.DecanewtonMillimetersPerDegree); + + [Fact] + public void NumberToDecanewtonMillimetersPerRadianTest() => + Assert.Equal(RotationalStiffness.FromDecanewtonMillimetersPerRadian(2), 2.DecanewtonMillimetersPerRadian); + + [Fact] + public void NumberToDecinewtonMetersPerDegreeTest() => + Assert.Equal(RotationalStiffness.FromDecinewtonMetersPerDegree(2), 2.DecinewtonMetersPerDegree); + + [Fact] + public void NumberToDecinewtonMillimetersPerDegreeTest() => + Assert.Equal(RotationalStiffness.FromDecinewtonMillimetersPerDegree(2), 2.DecinewtonMillimetersPerDegree); + + [Fact] + public void NumberToDecinewtonMillimetersPerRadianTest() => + Assert.Equal(RotationalStiffness.FromDecinewtonMillimetersPerRadian(2), 2.DecinewtonMillimetersPerRadian); + + [Fact] + public void NumberToKilonewtonMetersPerDegreeTest() => + Assert.Equal(RotationalStiffness.FromKilonewtonMetersPerDegree(2), 2.KilonewtonMetersPerDegree); + + [Fact] + public void NumberToKilonewtonMetersPerRadianTest() => + Assert.Equal(RotationalStiffness.FromKilonewtonMetersPerRadian(2), 2.KilonewtonMetersPerRadian); + + [Fact] + public void NumberToKilonewtonMillimetersPerDegreeTest() => + Assert.Equal(RotationalStiffness.FromKilonewtonMillimetersPerDegree(2), 2.KilonewtonMillimetersPerDegree); + + [Fact] + public void NumberToKilonewtonMillimetersPerRadianTest() => + Assert.Equal(RotationalStiffness.FromKilonewtonMillimetersPerRadian(2), 2.KilonewtonMillimetersPerRadian); + + [Fact] + public void NumberToKilopoundForceFeetPerDegreesTest() => + Assert.Equal(RotationalStiffness.FromKilopoundForceFeetPerDegrees(2), 2.KilopoundForceFeetPerDegrees); + + [Fact] + public void NumberToMeganewtonMetersPerDegreeTest() => + Assert.Equal(RotationalStiffness.FromMeganewtonMetersPerDegree(2), 2.MeganewtonMetersPerDegree); + + [Fact] + public void NumberToMeganewtonMetersPerRadianTest() => + Assert.Equal(RotationalStiffness.FromMeganewtonMetersPerRadian(2), 2.MeganewtonMetersPerRadian); + + [Fact] + public void NumberToMeganewtonMillimetersPerDegreeTest() => + Assert.Equal(RotationalStiffness.FromMeganewtonMillimetersPerDegree(2), 2.MeganewtonMillimetersPerDegree); + + [Fact] + public void NumberToMeganewtonMillimetersPerRadianTest() => + Assert.Equal(RotationalStiffness.FromMeganewtonMillimetersPerRadian(2), 2.MeganewtonMillimetersPerRadian); + + [Fact] + public void NumberToMicronewtonMetersPerDegreeTest() => + Assert.Equal(RotationalStiffness.FromMicronewtonMetersPerDegree(2), 2.MicronewtonMetersPerDegree); + + [Fact] + public void NumberToMicronewtonMillimetersPerDegreeTest() => + Assert.Equal(RotationalStiffness.FromMicronewtonMillimetersPerDegree(2), 2.MicronewtonMillimetersPerDegree); + + [Fact] + public void NumberToMicronewtonMillimetersPerRadianTest() => + Assert.Equal(RotationalStiffness.FromMicronewtonMillimetersPerRadian(2), 2.MicronewtonMillimetersPerRadian); + + [Fact] + public void NumberToMillinewtonMetersPerDegreeTest() => + Assert.Equal(RotationalStiffness.FromMillinewtonMetersPerDegree(2), 2.MillinewtonMetersPerDegree); + + [Fact] + public void NumberToMillinewtonMillimetersPerDegreeTest() => + Assert.Equal(RotationalStiffness.FromMillinewtonMillimetersPerDegree(2), 2.MillinewtonMillimetersPerDegree); + + [Fact] + public void NumberToMillinewtonMillimetersPerRadianTest() => + Assert.Equal(RotationalStiffness.FromMillinewtonMillimetersPerRadian(2), 2.MillinewtonMillimetersPerRadian); + + [Fact] + public void NumberToNanonewtonMetersPerDegreeTest() => + Assert.Equal(RotationalStiffness.FromNanonewtonMetersPerDegree(2), 2.NanonewtonMetersPerDegree); + + [Fact] + public void NumberToNanonewtonMillimetersPerDegreeTest() => + Assert.Equal(RotationalStiffness.FromNanonewtonMillimetersPerDegree(2), 2.NanonewtonMillimetersPerDegree); + + [Fact] + public void NumberToNanonewtonMillimetersPerRadianTest() => + Assert.Equal(RotationalStiffness.FromNanonewtonMillimetersPerRadian(2), 2.NanonewtonMillimetersPerRadian); + + [Fact] + public void NumberToNewtonMetersPerDegreeTest() => + Assert.Equal(RotationalStiffness.FromNewtonMetersPerDegree(2), 2.NewtonMetersPerDegree); + + [Fact] + public void NumberToNewtonMetersPerRadianTest() => + Assert.Equal(RotationalStiffness.FromNewtonMetersPerRadian(2), 2.NewtonMetersPerRadian); + + [Fact] + public void NumberToNewtonMillimetersPerDegreeTest() => + Assert.Equal(RotationalStiffness.FromNewtonMillimetersPerDegree(2), 2.NewtonMillimetersPerDegree); + + [Fact] + public void NumberToNewtonMillimetersPerRadianTest() => + Assert.Equal(RotationalStiffness.FromNewtonMillimetersPerRadian(2), 2.NewtonMillimetersPerRadian); + + [Fact] + public void NumberToPoundForceFeetPerRadianTest() => + Assert.Equal(RotationalStiffness.FromPoundForceFeetPerRadian(2), 2.PoundForceFeetPerRadian); + + [Fact] + public void NumberToPoundForceFeetPerDegreesTest() => + Assert.Equal(RotationalStiffness.FromPoundForceFeetPerDegrees(2), 2.PoundForceFeetPerDegrees); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensionsTest.g.cs new file mode 100644 index 0000000000..8229d27e6d --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensionsTest.g.cs @@ -0,0 +1,48 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToRotationalStiffnessPerLength; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToRotationalStiffnessPerLengthExtensionsTests + { + [Fact] + public void NumberToKilonewtonMetersPerRadianPerMeterTest() => + Assert.Equal(RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(2), 2.KilonewtonMetersPerRadianPerMeter); + + [Fact] + public void NumberToKilopoundForceFeetPerDegreesPerFeetTest() => + Assert.Equal(RotationalStiffnessPerLength.FromKilopoundForceFeetPerDegreesPerFeet(2), 2.KilopoundForceFeetPerDegreesPerFeet); + + [Fact] + public void NumberToMeganewtonMetersPerRadianPerMeterTest() => + Assert.Equal(RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(2), 2.MeganewtonMetersPerRadianPerMeter); + + [Fact] + public void NumberToNewtonMetersPerRadianPerMeterTest() => + Assert.Equal(RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(2), 2.NewtonMetersPerRadianPerMeter); + + [Fact] + public void NumberToPoundForceFeetPerDegreesPerFeetTest() => + Assert.Equal(RotationalStiffnessPerLength.FromPoundForceFeetPerDegreesPerFeet(2), 2.PoundForceFeetPerDegreesPerFeet); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToScalarExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToScalarExtensionsTest.g.cs new file mode 100644 index 0000000000..8e49100470 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToScalarExtensionsTest.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.NumberToScalar; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToScalarExtensionsTests + { + [Fact] + public void NumberToAmountTest() => + Assert.Equal(Scalar.FromAmount(2), 2.Amount); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToSolidAngleExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToSolidAngleExtensionsTest.g.cs new file mode 100644 index 0000000000..e9305e4e38 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToSolidAngleExtensionsTest.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.NumberToSolidAngle; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToSolidAngleExtensionsTests + { + [Fact] + public void NumberToSteradiansTest() => + Assert.Equal(SolidAngle.FromSteradians(2), 2.Steradians); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToSpecificEnergyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToSpecificEnergyExtensionsTest.g.cs new file mode 100644 index 0000000000..fb0f62c309 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToSpecificEnergyExtensionsTest.g.cs @@ -0,0 +1,148 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToSpecificEnergy; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToSpecificEnergyExtensionsTests + { + [Fact] + public void NumberToBtuPerPoundTest() => + Assert.Equal(SpecificEnergy.FromBtuPerPound(2), 2.BtuPerPound); + + [Fact] + public void NumberToCaloriesPerGramTest() => + Assert.Equal(SpecificEnergy.FromCaloriesPerGram(2), 2.CaloriesPerGram); + + [Fact] + public void NumberToGigawattDaysPerKilogramTest() => + Assert.Equal(SpecificEnergy.FromGigawattDaysPerKilogram(2), 2.GigawattDaysPerKilogram); + + [Fact] + public void NumberToGigawattDaysPerShortTonTest() => + Assert.Equal(SpecificEnergy.FromGigawattDaysPerShortTon(2), 2.GigawattDaysPerShortTon); + + [Fact] + public void NumberToGigawattDaysPerTonneTest() => + Assert.Equal(SpecificEnergy.FromGigawattDaysPerTonne(2), 2.GigawattDaysPerTonne); + + [Fact] + public void NumberToGigawattHoursPerKilogramTest() => + Assert.Equal(SpecificEnergy.FromGigawattHoursPerKilogram(2), 2.GigawattHoursPerKilogram); + + [Fact] + public void NumberToGigawattHoursPerPoundTest() => + Assert.Equal(SpecificEnergy.FromGigawattHoursPerPound(2), 2.GigawattHoursPerPound); + + [Fact] + public void NumberToJoulesPerKilogramTest() => + Assert.Equal(SpecificEnergy.FromJoulesPerKilogram(2), 2.JoulesPerKilogram); + + [Fact] + public void NumberToKilocaloriesPerGramTest() => + Assert.Equal(SpecificEnergy.FromKilocaloriesPerGram(2), 2.KilocaloriesPerGram); + + [Fact] + public void NumberToKilojoulesPerKilogramTest() => + Assert.Equal(SpecificEnergy.FromKilojoulesPerKilogram(2), 2.KilojoulesPerKilogram); + + [Fact] + public void NumberToKilowattDaysPerKilogramTest() => + Assert.Equal(SpecificEnergy.FromKilowattDaysPerKilogram(2), 2.KilowattDaysPerKilogram); + + [Fact] + public void NumberToKilowattDaysPerShortTonTest() => + Assert.Equal(SpecificEnergy.FromKilowattDaysPerShortTon(2), 2.KilowattDaysPerShortTon); + + [Fact] + public void NumberToKilowattDaysPerTonneTest() => + Assert.Equal(SpecificEnergy.FromKilowattDaysPerTonne(2), 2.KilowattDaysPerTonne); + + [Fact] + public void NumberToKilowattHoursPerKilogramTest() => + Assert.Equal(SpecificEnergy.FromKilowattHoursPerKilogram(2), 2.KilowattHoursPerKilogram); + + [Fact] + public void NumberToKilowattHoursPerPoundTest() => + Assert.Equal(SpecificEnergy.FromKilowattHoursPerPound(2), 2.KilowattHoursPerPound); + + [Fact] + public void NumberToMegajoulesPerKilogramTest() => + Assert.Equal(SpecificEnergy.FromMegajoulesPerKilogram(2), 2.MegajoulesPerKilogram); + + [Fact] + public void NumberToMegajoulesPerTonneTest() => + Assert.Equal(SpecificEnergy.FromMegajoulesPerTonne(2), 2.MegajoulesPerTonne); + + [Fact] + public void NumberToMegawattDaysPerKilogramTest() => + Assert.Equal(SpecificEnergy.FromMegawattDaysPerKilogram(2), 2.MegawattDaysPerKilogram); + + [Fact] + public void NumberToMegawattDaysPerShortTonTest() => + Assert.Equal(SpecificEnergy.FromMegawattDaysPerShortTon(2), 2.MegawattDaysPerShortTon); + + [Fact] + public void NumberToMegawattDaysPerTonneTest() => + Assert.Equal(SpecificEnergy.FromMegawattDaysPerTonne(2), 2.MegawattDaysPerTonne); + + [Fact] + public void NumberToMegawattHoursPerKilogramTest() => + Assert.Equal(SpecificEnergy.FromMegawattHoursPerKilogram(2), 2.MegawattHoursPerKilogram); + + [Fact] + public void NumberToMegawattHoursPerPoundTest() => + Assert.Equal(SpecificEnergy.FromMegawattHoursPerPound(2), 2.MegawattHoursPerPound); + + [Fact] + public void NumberToTerawattDaysPerKilogramTest() => + Assert.Equal(SpecificEnergy.FromTerawattDaysPerKilogram(2), 2.TerawattDaysPerKilogram); + + [Fact] + public void NumberToTerawattDaysPerShortTonTest() => + Assert.Equal(SpecificEnergy.FromTerawattDaysPerShortTon(2), 2.TerawattDaysPerShortTon); + + [Fact] + public void NumberToTerawattDaysPerTonneTest() => + Assert.Equal(SpecificEnergy.FromTerawattDaysPerTonne(2), 2.TerawattDaysPerTonne); + + [Fact] + public void NumberToWattDaysPerKilogramTest() => + Assert.Equal(SpecificEnergy.FromWattDaysPerKilogram(2), 2.WattDaysPerKilogram); + + [Fact] + public void NumberToWattDaysPerShortTonTest() => + Assert.Equal(SpecificEnergy.FromWattDaysPerShortTon(2), 2.WattDaysPerShortTon); + + [Fact] + public void NumberToWattDaysPerTonneTest() => + Assert.Equal(SpecificEnergy.FromWattDaysPerTonne(2), 2.WattDaysPerTonne); + + [Fact] + public void NumberToWattHoursPerKilogramTest() => + Assert.Equal(SpecificEnergy.FromWattHoursPerKilogram(2), 2.WattHoursPerKilogram); + + [Fact] + public void NumberToWattHoursPerPoundTest() => + Assert.Equal(SpecificEnergy.FromWattHoursPerPound(2), 2.WattHoursPerPound); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToSpecificEntropyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToSpecificEntropyExtensionsTest.g.cs new file mode 100644 index 0000000000..bf0299b01f --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToSpecificEntropyExtensionsTest.g.cs @@ -0,0 +1,64 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToSpecificEntropy; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToSpecificEntropyExtensionsTests + { + [Fact] + public void NumberToBtusPerPoundFahrenheitTest() => + Assert.Equal(SpecificEntropy.FromBtusPerPoundFahrenheit(2), 2.BtusPerPoundFahrenheit); + + [Fact] + public void NumberToCaloriesPerGramKelvinTest() => + Assert.Equal(SpecificEntropy.FromCaloriesPerGramKelvin(2), 2.CaloriesPerGramKelvin); + + [Fact] + public void NumberToJoulesPerKilogramDegreeCelsiusTest() => + Assert.Equal(SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(2), 2.JoulesPerKilogramDegreeCelsius); + + [Fact] + public void NumberToJoulesPerKilogramKelvinTest() => + Assert.Equal(SpecificEntropy.FromJoulesPerKilogramKelvin(2), 2.JoulesPerKilogramKelvin); + + [Fact] + public void NumberToKilocaloriesPerGramKelvinTest() => + Assert.Equal(SpecificEntropy.FromKilocaloriesPerGramKelvin(2), 2.KilocaloriesPerGramKelvin); + + [Fact] + public void NumberToKilojoulesPerKilogramDegreeCelsiusTest() => + Assert.Equal(SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(2), 2.KilojoulesPerKilogramDegreeCelsius); + + [Fact] + public void NumberToKilojoulesPerKilogramKelvinTest() => + Assert.Equal(SpecificEntropy.FromKilojoulesPerKilogramKelvin(2), 2.KilojoulesPerKilogramKelvin); + + [Fact] + public void NumberToMegajoulesPerKilogramDegreeCelsiusTest() => + Assert.Equal(SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(2), 2.MegajoulesPerKilogramDegreeCelsius); + + [Fact] + public void NumberToMegajoulesPerKilogramKelvinTest() => + Assert.Equal(SpecificEntropy.FromMegajoulesPerKilogramKelvin(2), 2.MegajoulesPerKilogramKelvin); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToSpecificFuelConsumptionExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToSpecificFuelConsumptionExtensionsTest.g.cs new file mode 100644 index 0000000000..5ee296a7ef --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToSpecificFuelConsumptionExtensionsTest.g.cs @@ -0,0 +1,44 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToSpecificFuelConsumption; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToSpecificFuelConsumptionExtensionsTests + { + [Fact] + public void NumberToGramsPerKilonewtonSecondTest() => + Assert.Equal(SpecificFuelConsumption.FromGramsPerKilonewtonSecond(2), 2.GramsPerKilonewtonSecond); + + [Fact] + public void NumberToKilogramsPerKilogramForceHourTest() => + Assert.Equal(SpecificFuelConsumption.FromKilogramsPerKilogramForceHour(2), 2.KilogramsPerKilogramForceHour); + + [Fact] + public void NumberToKilogramsPerKilonewtonSecondTest() => + Assert.Equal(SpecificFuelConsumption.FromKilogramsPerKilonewtonSecond(2), 2.KilogramsPerKilonewtonSecond); + + [Fact] + public void NumberToPoundsMassPerPoundForceHourTest() => + Assert.Equal(SpecificFuelConsumption.FromPoundsMassPerPoundForceHour(2), 2.PoundsMassPerPoundForceHour); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToSpecificVolumeExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToSpecificVolumeExtensionsTest.g.cs new file mode 100644 index 0000000000..d6eb58f168 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToSpecificVolumeExtensionsTest.g.cs @@ -0,0 +1,40 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToSpecificVolume; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToSpecificVolumeExtensionsTests + { + [Fact] + public void NumberToCubicFeetPerPoundTest() => + Assert.Equal(SpecificVolume.FromCubicFeetPerPound(2), 2.CubicFeetPerPound); + + [Fact] + public void NumberToCubicMetersPerKilogramTest() => + Assert.Equal(SpecificVolume.FromCubicMetersPerKilogram(2), 2.CubicMetersPerKilogram); + + [Fact] + public void NumberToMillicubicMetersPerKilogramTest() => + Assert.Equal(SpecificVolume.FromMillicubicMetersPerKilogram(2), 2.MillicubicMetersPerKilogram); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToSpecificWeightExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToSpecificWeightExtensionsTest.g.cs new file mode 100644 index 0000000000..862ceeacd7 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToSpecificWeightExtensionsTest.g.cs @@ -0,0 +1,96 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToSpecificWeight; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToSpecificWeightExtensionsTests + { + [Fact] + public void NumberToKilogramsForcePerCubicCentimeterTest() => + Assert.Equal(SpecificWeight.FromKilogramsForcePerCubicCentimeter(2), 2.KilogramsForcePerCubicCentimeter); + + [Fact] + public void NumberToKilogramsForcePerCubicMeterTest() => + Assert.Equal(SpecificWeight.FromKilogramsForcePerCubicMeter(2), 2.KilogramsForcePerCubicMeter); + + [Fact] + public void NumberToKilogramsForcePerCubicMillimeterTest() => + Assert.Equal(SpecificWeight.FromKilogramsForcePerCubicMillimeter(2), 2.KilogramsForcePerCubicMillimeter); + + [Fact] + public void NumberToKilonewtonsPerCubicCentimeterTest() => + Assert.Equal(SpecificWeight.FromKilonewtonsPerCubicCentimeter(2), 2.KilonewtonsPerCubicCentimeter); + + [Fact] + public void NumberToKilonewtonsPerCubicMeterTest() => + Assert.Equal(SpecificWeight.FromKilonewtonsPerCubicMeter(2), 2.KilonewtonsPerCubicMeter); + + [Fact] + public void NumberToKilonewtonsPerCubicMillimeterTest() => + Assert.Equal(SpecificWeight.FromKilonewtonsPerCubicMillimeter(2), 2.KilonewtonsPerCubicMillimeter); + + [Fact] + public void NumberToKilopoundsForcePerCubicFootTest() => + Assert.Equal(SpecificWeight.FromKilopoundsForcePerCubicFoot(2), 2.KilopoundsForcePerCubicFoot); + + [Fact] + public void NumberToKilopoundsForcePerCubicInchTest() => + Assert.Equal(SpecificWeight.FromKilopoundsForcePerCubicInch(2), 2.KilopoundsForcePerCubicInch); + + [Fact] + public void NumberToMeganewtonsPerCubicMeterTest() => + Assert.Equal(SpecificWeight.FromMeganewtonsPerCubicMeter(2), 2.MeganewtonsPerCubicMeter); + + [Fact] + public void NumberToNewtonsPerCubicCentimeterTest() => + Assert.Equal(SpecificWeight.FromNewtonsPerCubicCentimeter(2), 2.NewtonsPerCubicCentimeter); + + [Fact] + public void NumberToNewtonsPerCubicMeterTest() => + Assert.Equal(SpecificWeight.FromNewtonsPerCubicMeter(2), 2.NewtonsPerCubicMeter); + + [Fact] + public void NumberToNewtonsPerCubicMillimeterTest() => + Assert.Equal(SpecificWeight.FromNewtonsPerCubicMillimeter(2), 2.NewtonsPerCubicMillimeter); + + [Fact] + public void NumberToPoundsForcePerCubicFootTest() => + Assert.Equal(SpecificWeight.FromPoundsForcePerCubicFoot(2), 2.PoundsForcePerCubicFoot); + + [Fact] + public void NumberToPoundsForcePerCubicInchTest() => + Assert.Equal(SpecificWeight.FromPoundsForcePerCubicInch(2), 2.PoundsForcePerCubicInch); + + [Fact] + public void NumberToTonnesForcePerCubicCentimeterTest() => + Assert.Equal(SpecificWeight.FromTonnesForcePerCubicCentimeter(2), 2.TonnesForcePerCubicCentimeter); + + [Fact] + public void NumberToTonnesForcePerCubicMeterTest() => + Assert.Equal(SpecificWeight.FromTonnesForcePerCubicMeter(2), 2.TonnesForcePerCubicMeter); + + [Fact] + public void NumberToTonnesForcePerCubicMillimeterTest() => + Assert.Equal(SpecificWeight.FromTonnesForcePerCubicMillimeter(2), 2.TonnesForcePerCubicMillimeter); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToSpeedExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToSpeedExtensionsTest.g.cs new file mode 100644 index 0000000000..d6a5fa3651 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToSpeedExtensionsTest.g.cs @@ -0,0 +1,160 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToSpeed; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToSpeedExtensionsTests + { + [Fact] + public void NumberToCentimetersPerHourTest() => + Assert.Equal(Speed.FromCentimetersPerHour(2), 2.CentimetersPerHour); + + [Fact] + public void NumberToCentimetersPerMinuteTest() => + Assert.Equal(Speed.FromCentimetersPerMinute(2), 2.CentimetersPerMinute); + + [Fact] + public void NumberToCentimetersPerSecondTest() => + Assert.Equal(Speed.FromCentimetersPerSecond(2), 2.CentimetersPerSecond); + + [Fact] + public void NumberToDecimetersPerMinuteTest() => + Assert.Equal(Speed.FromDecimetersPerMinute(2), 2.DecimetersPerMinute); + + [Fact] + public void NumberToDecimetersPerSecondTest() => + Assert.Equal(Speed.FromDecimetersPerSecond(2), 2.DecimetersPerSecond); + + [Fact] + public void NumberToFeetPerHourTest() => + Assert.Equal(Speed.FromFeetPerHour(2), 2.FeetPerHour); + + [Fact] + public void NumberToFeetPerMinuteTest() => + Assert.Equal(Speed.FromFeetPerMinute(2), 2.FeetPerMinute); + + [Fact] + public void NumberToFeetPerSecondTest() => + Assert.Equal(Speed.FromFeetPerSecond(2), 2.FeetPerSecond); + + [Fact] + public void NumberToInchesPerHourTest() => + Assert.Equal(Speed.FromInchesPerHour(2), 2.InchesPerHour); + + [Fact] + public void NumberToInchesPerMinuteTest() => + Assert.Equal(Speed.FromInchesPerMinute(2), 2.InchesPerMinute); + + [Fact] + public void NumberToInchesPerSecondTest() => + Assert.Equal(Speed.FromInchesPerSecond(2), 2.InchesPerSecond); + + [Fact] + public void NumberToKilometersPerHourTest() => + Assert.Equal(Speed.FromKilometersPerHour(2), 2.KilometersPerHour); + + [Fact] + public void NumberToKilometersPerMinuteTest() => + Assert.Equal(Speed.FromKilometersPerMinute(2), 2.KilometersPerMinute); + + [Fact] + public void NumberToKilometersPerSecondTest() => + Assert.Equal(Speed.FromKilometersPerSecond(2), 2.KilometersPerSecond); + + [Fact] + public void NumberToKnotsTest() => + Assert.Equal(Speed.FromKnots(2), 2.Knots); + + [Fact] + public void NumberToMachTest() => + Assert.Equal(Speed.FromMach(2), 2.Mach); + + [Fact] + public void NumberToMetersPerHourTest() => + Assert.Equal(Speed.FromMetersPerHour(2), 2.MetersPerHour); + + [Fact] + public void NumberToMetersPerMinuteTest() => + Assert.Equal(Speed.FromMetersPerMinute(2), 2.MetersPerMinute); + + [Fact] + public void NumberToMetersPerSecondTest() => + Assert.Equal(Speed.FromMetersPerSecond(2), 2.MetersPerSecond); + + [Fact] + public void NumberToMicrometersPerMinuteTest() => + Assert.Equal(Speed.FromMicrometersPerMinute(2), 2.MicrometersPerMinute); + + [Fact] + public void NumberToMicrometersPerSecondTest() => + Assert.Equal(Speed.FromMicrometersPerSecond(2), 2.MicrometersPerSecond); + + [Fact] + public void NumberToMilesPerHourTest() => + Assert.Equal(Speed.FromMilesPerHour(2), 2.MilesPerHour); + + [Fact] + public void NumberToMillimetersPerHourTest() => + Assert.Equal(Speed.FromMillimetersPerHour(2), 2.MillimetersPerHour); + + [Fact] + public void NumberToMillimetersPerMinuteTest() => + Assert.Equal(Speed.FromMillimetersPerMinute(2), 2.MillimetersPerMinute); + + [Fact] + public void NumberToMillimetersPerSecondTest() => + Assert.Equal(Speed.FromMillimetersPerSecond(2), 2.MillimetersPerSecond); + + [Fact] + public void NumberToNanometersPerMinuteTest() => + Assert.Equal(Speed.FromNanometersPerMinute(2), 2.NanometersPerMinute); + + [Fact] + public void NumberToNanometersPerSecondTest() => + Assert.Equal(Speed.FromNanometersPerSecond(2), 2.NanometersPerSecond); + + [Fact] + public void NumberToUsSurveyFeetPerHourTest() => + Assert.Equal(Speed.FromUsSurveyFeetPerHour(2), 2.UsSurveyFeetPerHour); + + [Fact] + public void NumberToUsSurveyFeetPerMinuteTest() => + Assert.Equal(Speed.FromUsSurveyFeetPerMinute(2), 2.UsSurveyFeetPerMinute); + + [Fact] + public void NumberToUsSurveyFeetPerSecondTest() => + Assert.Equal(Speed.FromUsSurveyFeetPerSecond(2), 2.UsSurveyFeetPerSecond); + + [Fact] + public void NumberToYardsPerHourTest() => + Assert.Equal(Speed.FromYardsPerHour(2), 2.YardsPerHour); + + [Fact] + public void NumberToYardsPerMinuteTest() => + Assert.Equal(Speed.FromYardsPerMinute(2), 2.YardsPerMinute); + + [Fact] + public void NumberToYardsPerSecondTest() => + Assert.Equal(Speed.FromYardsPerSecond(2), 2.YardsPerSecond); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToStandardVolumeFlowExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToStandardVolumeFlowExtensionsTest.g.cs new file mode 100644 index 0000000000..34bb17950d --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToStandardVolumeFlowExtensionsTest.g.cs @@ -0,0 +1,64 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToStandardVolumeFlow; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToStandardVolumeFlowExtensionsTests + { + [Fact] + public void NumberToStandardCubicCentimetersPerMinuteTest() => + Assert.Equal(StandardVolumeFlow.FromStandardCubicCentimetersPerMinute(2), 2.StandardCubicCentimetersPerMinute); + + [Fact] + public void NumberToStandardCubicFeetPerHourTest() => + Assert.Equal(StandardVolumeFlow.FromStandardCubicFeetPerHour(2), 2.StandardCubicFeetPerHour); + + [Fact] + public void NumberToStandardCubicFeetPerMinuteTest() => + Assert.Equal(StandardVolumeFlow.FromStandardCubicFeetPerMinute(2), 2.StandardCubicFeetPerMinute); + + [Fact] + public void NumberToStandardCubicFeetPerSecondTest() => + Assert.Equal(StandardVolumeFlow.FromStandardCubicFeetPerSecond(2), 2.StandardCubicFeetPerSecond); + + [Fact] + public void NumberToStandardCubicMetersPerDayTest() => + Assert.Equal(StandardVolumeFlow.FromStandardCubicMetersPerDay(2), 2.StandardCubicMetersPerDay); + + [Fact] + public void NumberToStandardCubicMetersPerHourTest() => + Assert.Equal(StandardVolumeFlow.FromStandardCubicMetersPerHour(2), 2.StandardCubicMetersPerHour); + + [Fact] + public void NumberToStandardCubicMetersPerMinuteTest() => + Assert.Equal(StandardVolumeFlow.FromStandardCubicMetersPerMinute(2), 2.StandardCubicMetersPerMinute); + + [Fact] + public void NumberToStandardCubicMetersPerSecondTest() => + Assert.Equal(StandardVolumeFlow.FromStandardCubicMetersPerSecond(2), 2.StandardCubicMetersPerSecond); + + [Fact] + public void NumberToStandardLitersPerMinuteTest() => + Assert.Equal(StandardVolumeFlow.FromStandardLitersPerMinute(2), 2.StandardLitersPerMinute); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToTemperatureChangeRateExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToTemperatureChangeRateExtensionsTest.g.cs new file mode 100644 index 0000000000..70adffaf66 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToTemperatureChangeRateExtensionsTest.g.cs @@ -0,0 +1,96 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToTemperatureChangeRate; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToTemperatureChangeRateExtensionsTests + { + [Fact] + public void NumberToCentidegreesCelsiusPerSecondTest() => + Assert.Equal(TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(2), 2.CentidegreesCelsiusPerSecond); + + [Fact] + public void NumberToDecadegreesCelsiusPerSecondTest() => + Assert.Equal(TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(2), 2.DecadegreesCelsiusPerSecond); + + [Fact] + public void NumberToDecidegreesCelsiusPerSecondTest() => + Assert.Equal(TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(2), 2.DecidegreesCelsiusPerSecond); + + [Fact] + public void NumberToDegreesCelsiusPerHourTest() => + Assert.Equal(TemperatureChangeRate.FromDegreesCelsiusPerHour(2), 2.DegreesCelsiusPerHour); + + [Fact] + public void NumberToDegreesCelsiusPerMinuteTest() => + Assert.Equal(TemperatureChangeRate.FromDegreesCelsiusPerMinute(2), 2.DegreesCelsiusPerMinute); + + [Fact] + public void NumberToDegreesCelsiusPerSecondTest() => + Assert.Equal(TemperatureChangeRate.FromDegreesCelsiusPerSecond(2), 2.DegreesCelsiusPerSecond); + + [Fact] + public void NumberToDegreesFahrenheitPerHourTest() => + Assert.Equal(TemperatureChangeRate.FromDegreesFahrenheitPerHour(2), 2.DegreesFahrenheitPerHour); + + [Fact] + public void NumberToDegreesFahrenheitPerMinuteTest() => + Assert.Equal(TemperatureChangeRate.FromDegreesFahrenheitPerMinute(2), 2.DegreesFahrenheitPerMinute); + + [Fact] + public void NumberToDegreesFahrenheitPerSecondTest() => + Assert.Equal(TemperatureChangeRate.FromDegreesFahrenheitPerSecond(2), 2.DegreesFahrenheitPerSecond); + + [Fact] + public void NumberToDegreesKelvinPerHourTest() => + Assert.Equal(TemperatureChangeRate.FromDegreesKelvinPerHour(2), 2.DegreesKelvinPerHour); + + [Fact] + public void NumberToDegreesKelvinPerMinuteTest() => + Assert.Equal(TemperatureChangeRate.FromDegreesKelvinPerMinute(2), 2.DegreesKelvinPerMinute); + + [Fact] + public void NumberToDegreesKelvinPerSecondTest() => + Assert.Equal(TemperatureChangeRate.FromDegreesKelvinPerSecond(2), 2.DegreesKelvinPerSecond); + + [Fact] + public void NumberToHectodegreesCelsiusPerSecondTest() => + Assert.Equal(TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(2), 2.HectodegreesCelsiusPerSecond); + + [Fact] + public void NumberToKilodegreesCelsiusPerSecondTest() => + Assert.Equal(TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(2), 2.KilodegreesCelsiusPerSecond); + + [Fact] + public void NumberToMicrodegreesCelsiusPerSecondTest() => + Assert.Equal(TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(2), 2.MicrodegreesCelsiusPerSecond); + + [Fact] + public void NumberToMillidegreesCelsiusPerSecondTest() => + Assert.Equal(TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(2), 2.MillidegreesCelsiusPerSecond); + + [Fact] + public void NumberToNanodegreesCelsiusPerSecondTest() => + Assert.Equal(TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(2), 2.NanodegreesCelsiusPerSecond); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToTemperatureDeltaExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToTemperatureDeltaExtensionsTest.g.cs new file mode 100644 index 0000000000..459f4eb971 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToTemperatureDeltaExtensionsTest.g.cs @@ -0,0 +1,64 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToTemperatureDelta; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToTemperatureDeltaExtensionsTests + { + [Fact] + public void NumberToDegreesCelsiusTest() => + Assert.Equal(TemperatureDelta.FromDegreesCelsius(2), 2.DegreesCelsius); + + [Fact] + public void NumberToDegreesDelisleTest() => + Assert.Equal(TemperatureDelta.FromDegreesDelisle(2), 2.DegreesDelisle); + + [Fact] + public void NumberToDegreesFahrenheitTest() => + Assert.Equal(TemperatureDelta.FromDegreesFahrenheit(2), 2.DegreesFahrenheit); + + [Fact] + public void NumberToDegreesNewtonTest() => + Assert.Equal(TemperatureDelta.FromDegreesNewton(2), 2.DegreesNewton); + + [Fact] + public void NumberToDegreesRankineTest() => + Assert.Equal(TemperatureDelta.FromDegreesRankine(2), 2.DegreesRankine); + + [Fact] + public void NumberToDegreesReaumurTest() => + Assert.Equal(TemperatureDelta.FromDegreesReaumur(2), 2.DegreesReaumur); + + [Fact] + public void NumberToDegreesRoemerTest() => + Assert.Equal(TemperatureDelta.FromDegreesRoemer(2), 2.DegreesRoemer); + + [Fact] + public void NumberToKelvinsTest() => + Assert.Equal(TemperatureDelta.FromKelvins(2), 2.Kelvins); + + [Fact] + public void NumberToMillidegreesCelsiusTest() => + Assert.Equal(TemperatureDelta.FromMillidegreesCelsius(2), 2.MillidegreesCelsius); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToTemperatureExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToTemperatureExtensionsTest.g.cs new file mode 100644 index 0000000000..b50f3e0e1e --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToTemperatureExtensionsTest.g.cs @@ -0,0 +1,68 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToTemperature; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToTemperatureExtensionsTests + { + [Fact] + public void NumberToDegreesCelsiusTest() => + Assert.Equal(Temperature.FromDegreesCelsius(2), 2.DegreesCelsius); + + [Fact] + public void NumberToDegreesDelisleTest() => + Assert.Equal(Temperature.FromDegreesDelisle(2), 2.DegreesDelisle); + + [Fact] + public void NumberToDegreesFahrenheitTest() => + Assert.Equal(Temperature.FromDegreesFahrenheit(2), 2.DegreesFahrenheit); + + [Fact] + public void NumberToDegreesNewtonTest() => + Assert.Equal(Temperature.FromDegreesNewton(2), 2.DegreesNewton); + + [Fact] + public void NumberToDegreesRankineTest() => + Assert.Equal(Temperature.FromDegreesRankine(2), 2.DegreesRankine); + + [Fact] + public void NumberToDegreesReaumurTest() => + Assert.Equal(Temperature.FromDegreesReaumur(2), 2.DegreesReaumur); + + [Fact] + public void NumberToDegreesRoemerTest() => + Assert.Equal(Temperature.FromDegreesRoemer(2), 2.DegreesRoemer); + + [Fact] + public void NumberToKelvinsTest() => + Assert.Equal(Temperature.FromKelvins(2), 2.Kelvins); + + [Fact] + public void NumberToMillidegreesCelsiusTest() => + Assert.Equal(Temperature.FromMillidegreesCelsius(2), 2.MillidegreesCelsius); + + [Fact] + public void NumberToSolarTemperaturesTest() => + Assert.Equal(Temperature.FromSolarTemperatures(2), 2.SolarTemperatures); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToTemperatureGradientExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToTemperatureGradientExtensionsTest.g.cs new file mode 100644 index 0000000000..7977423c76 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToTemperatureGradientExtensionsTest.g.cs @@ -0,0 +1,44 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToTemperatureGradient; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToTemperatureGradientExtensionsTests + { + [Fact] + public void NumberToDegreesCelsiusPerKilometerTest() => + Assert.Equal(TemperatureGradient.FromDegreesCelsiusPerKilometer(2), 2.DegreesCelsiusPerKilometer); + + [Fact] + public void NumberToDegreesCelsiusPerMeterTest() => + Assert.Equal(TemperatureGradient.FromDegreesCelsiusPerMeter(2), 2.DegreesCelsiusPerMeter); + + [Fact] + public void NumberToDegreesFahrenheitPerFootTest() => + Assert.Equal(TemperatureGradient.FromDegreesFahrenheitPerFoot(2), 2.DegreesFahrenheitPerFoot); + + [Fact] + public void NumberToKelvinsPerMeterTest() => + Assert.Equal(TemperatureGradient.FromKelvinsPerMeter(2), 2.KelvinsPerMeter); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToThermalConductivityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToThermalConductivityExtensionsTest.g.cs new file mode 100644 index 0000000000..f3876ae5b0 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToThermalConductivityExtensionsTest.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 UnitsNet.NumberExtensions.NumberToThermalConductivity; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToThermalConductivityExtensionsTests + { + [Fact] + public void NumberToBtusPerHourFootFahrenheitTest() => + Assert.Equal(ThermalConductivity.FromBtusPerHourFootFahrenheit(2), 2.BtusPerHourFootFahrenheit); + + [Fact] + public void NumberToWattsPerMeterKelvinTest() => + Assert.Equal(ThermalConductivity.FromWattsPerMeterKelvin(2), 2.WattsPerMeterKelvin); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToThermalInsulanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToThermalInsulanceExtensionsTest.g.cs new file mode 100644 index 0000000000..4195eb6730 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToThermalInsulanceExtensionsTest.g.cs @@ -0,0 +1,56 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToThermalInsulance; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToThermalInsulanceExtensionsTests + { + [Fact] + public void NumberToHourSquareFeetDegreesFahrenheitPerBtuTest() => + Assert.Equal(ThermalInsulance.FromHourSquareFeetDegreesFahrenheitPerBtu(2), 2.HourSquareFeetDegreesFahrenheitPerBtu); + + [Fact] + public void NumberToSquareCentimeterHourDegreesCelsiusPerKilocalorieTest() => + Assert.Equal(ThermalInsulance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(2), 2.SquareCentimeterHourDegreesCelsiusPerKilocalorie); + + [Fact] + public void NumberToSquareCentimeterKelvinsPerWattTest() => + Assert.Equal(ThermalInsulance.FromSquareCentimeterKelvinsPerWatt(2), 2.SquareCentimeterKelvinsPerWatt); + + [Fact] + public void NumberToSquareMeterDegreesCelsiusPerWattTest() => + Assert.Equal(ThermalInsulance.FromSquareMeterDegreesCelsiusPerWatt(2), 2.SquareMeterDegreesCelsiusPerWatt); + + [Fact] + public void NumberToSquareMeterKelvinsPerKilowattTest() => + Assert.Equal(ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(2), 2.SquareMeterKelvinsPerKilowatt); + + [Fact] + public void NumberToSquareMeterKelvinsPerWattTest() => + Assert.Equal(ThermalInsulance.FromSquareMeterKelvinsPerWatt(2), 2.SquareMeterKelvinsPerWatt); + + [Fact] + public void NumberToSquareMillimeterKelvinsPerWattTest() => + Assert.Equal(ThermalInsulance.FromSquareMillimeterKelvinsPerWatt(2), 2.SquareMillimeterKelvinsPerWatt); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToThermalResistanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToThermalResistanceExtensionsTest.g.cs new file mode 100644 index 0000000000..a06db66e5d --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToThermalResistanceExtensionsTest.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 UnitsNet.NumberExtensions.NumberToThermalResistance; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToThermalResistanceExtensionsTests + { + [Fact] + public void NumberToDegreesCelsiusPerWattTest() => + Assert.Equal(ThermalResistance.FromDegreesCelsiusPerWatt(2), 2.DegreesCelsiusPerWatt); + + [Fact] + public void NumberToKelvinsPerWattTest() => + Assert.Equal(ThermalResistance.FromKelvinsPerWatt(2), 2.KelvinsPerWatt); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToTorqueExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToTorqueExtensionsTest.g.cs new file mode 100644 index 0000000000..cf28ae5f83 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToTorqueExtensionsTest.g.cs @@ -0,0 +1,128 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToTorque; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToTorqueExtensionsTests + { + [Fact] + public void NumberToGramForceCentimetersTest() => + Assert.Equal(Torque.FromGramForceCentimeters(2), 2.GramForceCentimeters); + + [Fact] + public void NumberToGramForceMetersTest() => + Assert.Equal(Torque.FromGramForceMeters(2), 2.GramForceMeters); + + [Fact] + public void NumberToGramForceMillimetersTest() => + Assert.Equal(Torque.FromGramForceMillimeters(2), 2.GramForceMillimeters); + + [Fact] + public void NumberToKilogramForceCentimetersTest() => + Assert.Equal(Torque.FromKilogramForceCentimeters(2), 2.KilogramForceCentimeters); + + [Fact] + public void NumberToKilogramForceMetersTest() => + Assert.Equal(Torque.FromKilogramForceMeters(2), 2.KilogramForceMeters); + + [Fact] + public void NumberToKilogramForceMillimetersTest() => + Assert.Equal(Torque.FromKilogramForceMillimeters(2), 2.KilogramForceMillimeters); + + [Fact] + public void NumberToKilonewtonCentimetersTest() => + Assert.Equal(Torque.FromKilonewtonCentimeters(2), 2.KilonewtonCentimeters); + + [Fact] + public void NumberToKilonewtonMetersTest() => + Assert.Equal(Torque.FromKilonewtonMeters(2), 2.KilonewtonMeters); + + [Fact] + public void NumberToKilonewtonMillimetersTest() => + Assert.Equal(Torque.FromKilonewtonMillimeters(2), 2.KilonewtonMillimeters); + + [Fact] + public void NumberToKilopoundForceFeetTest() => + Assert.Equal(Torque.FromKilopoundForceFeet(2), 2.KilopoundForceFeet); + + [Fact] + public void NumberToKilopoundForceInchesTest() => + Assert.Equal(Torque.FromKilopoundForceInches(2), 2.KilopoundForceInches); + + [Fact] + public void NumberToMeganewtonCentimetersTest() => + Assert.Equal(Torque.FromMeganewtonCentimeters(2), 2.MeganewtonCentimeters); + + [Fact] + public void NumberToMeganewtonMetersTest() => + Assert.Equal(Torque.FromMeganewtonMeters(2), 2.MeganewtonMeters); + + [Fact] + public void NumberToMeganewtonMillimetersTest() => + Assert.Equal(Torque.FromMeganewtonMillimeters(2), 2.MeganewtonMillimeters); + + [Fact] + public void NumberToMegapoundForceFeetTest() => + Assert.Equal(Torque.FromMegapoundForceFeet(2), 2.MegapoundForceFeet); + + [Fact] + public void NumberToMegapoundForceInchesTest() => + Assert.Equal(Torque.FromMegapoundForceInches(2), 2.MegapoundForceInches); + + [Fact] + public void NumberToNewtonCentimetersTest() => + Assert.Equal(Torque.FromNewtonCentimeters(2), 2.NewtonCentimeters); + + [Fact] + public void NumberToNewtonMetersTest() => + Assert.Equal(Torque.FromNewtonMeters(2), 2.NewtonMeters); + + [Fact] + public void NumberToNewtonMillimetersTest() => + Assert.Equal(Torque.FromNewtonMillimeters(2), 2.NewtonMillimeters); + + [Fact] + public void NumberToPoundalFeetTest() => + Assert.Equal(Torque.FromPoundalFeet(2), 2.PoundalFeet); + + [Fact] + public void NumberToPoundForceFeetTest() => + Assert.Equal(Torque.FromPoundForceFeet(2), 2.PoundForceFeet); + + [Fact] + public void NumberToPoundForceInchesTest() => + Assert.Equal(Torque.FromPoundForceInches(2), 2.PoundForceInches); + + [Fact] + public void NumberToTonneForceCentimetersTest() => + Assert.Equal(Torque.FromTonneForceCentimeters(2), 2.TonneForceCentimeters); + + [Fact] + public void NumberToTonneForceMetersTest() => + Assert.Equal(Torque.FromTonneForceMeters(2), 2.TonneForceMeters); + + [Fact] + public void NumberToTonneForceMillimetersTest() => + Assert.Equal(Torque.FromTonneForceMillimeters(2), 2.TonneForceMillimeters); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToTurbidityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToTurbidityExtensionsTest.g.cs new file mode 100644 index 0000000000..14a7e5378a --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToTurbidityExtensionsTest.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.NumberToTurbidity; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToTurbidityExtensionsTests + { + [Fact] + public void NumberToNTUTest() => + Assert.Equal(Turbidity.FromNTU(2), 2.NTU); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVitaminAExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVitaminAExtensionsTest.g.cs new file mode 100644 index 0000000000..96ce053629 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVitaminAExtensionsTest.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.NumberToVitaminA; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToVitaminAExtensionsTests + { + [Fact] + public void NumberToInternationalUnitsTest() => + Assert.Equal(VitaminA.FromInternationalUnits(2), 2.InternationalUnits); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVolumeConcentrationExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVolumeConcentrationExtensionsTest.g.cs new file mode 100644 index 0000000000..63cbfbfc35 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVolumeConcentrationExtensionsTest.g.cs @@ -0,0 +1,108 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToVolumeConcentration; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToVolumeConcentrationExtensionsTests + { + [Fact] + public void NumberToCentilitersPerLiterTest() => + Assert.Equal(VolumeConcentration.FromCentilitersPerLiter(2), 2.CentilitersPerLiter); + + [Fact] + public void NumberToCentilitersPerMilliliterTest() => + Assert.Equal(VolumeConcentration.FromCentilitersPerMilliliter(2), 2.CentilitersPerMilliliter); + + [Fact] + public void NumberToDecilitersPerLiterTest() => + Assert.Equal(VolumeConcentration.FromDecilitersPerLiter(2), 2.DecilitersPerLiter); + + [Fact] + public void NumberToDecilitersPerMilliliterTest() => + Assert.Equal(VolumeConcentration.FromDecilitersPerMilliliter(2), 2.DecilitersPerMilliliter); + + [Fact] + public void NumberToDecimalFractionsTest() => + Assert.Equal(VolumeConcentration.FromDecimalFractions(2), 2.DecimalFractions); + + [Fact] + public void NumberToLitersPerLiterTest() => + Assert.Equal(VolumeConcentration.FromLitersPerLiter(2), 2.LitersPerLiter); + + [Fact] + public void NumberToLitersPerMilliliterTest() => + Assert.Equal(VolumeConcentration.FromLitersPerMilliliter(2), 2.LitersPerMilliliter); + + [Fact] + public void NumberToMicrolitersPerLiterTest() => + Assert.Equal(VolumeConcentration.FromMicrolitersPerLiter(2), 2.MicrolitersPerLiter); + + [Fact] + public void NumberToMicrolitersPerMilliliterTest() => + Assert.Equal(VolumeConcentration.FromMicrolitersPerMilliliter(2), 2.MicrolitersPerMilliliter); + + [Fact] + public void NumberToMillilitersPerLiterTest() => + Assert.Equal(VolumeConcentration.FromMillilitersPerLiter(2), 2.MillilitersPerLiter); + + [Fact] + public void NumberToMillilitersPerMilliliterTest() => + Assert.Equal(VolumeConcentration.FromMillilitersPerMilliliter(2), 2.MillilitersPerMilliliter); + + [Fact] + public void NumberToNanolitersPerLiterTest() => + Assert.Equal(VolumeConcentration.FromNanolitersPerLiter(2), 2.NanolitersPerLiter); + + [Fact] + public void NumberToNanolitersPerMilliliterTest() => + Assert.Equal(VolumeConcentration.FromNanolitersPerMilliliter(2), 2.NanolitersPerMilliliter); + + [Fact] + public void NumberToPartsPerBillionTest() => + Assert.Equal(VolumeConcentration.FromPartsPerBillion(2), 2.PartsPerBillion); + + [Fact] + public void NumberToPartsPerMillionTest() => + Assert.Equal(VolumeConcentration.FromPartsPerMillion(2), 2.PartsPerMillion); + + [Fact] + public void NumberToPartsPerThousandTest() => + Assert.Equal(VolumeConcentration.FromPartsPerThousand(2), 2.PartsPerThousand); + + [Fact] + public void NumberToPartsPerTrillionTest() => + Assert.Equal(VolumeConcentration.FromPartsPerTrillion(2), 2.PartsPerTrillion); + + [Fact] + public void NumberToPercentTest() => + Assert.Equal(VolumeConcentration.FromPercent(2), 2.Percent); + + [Fact] + public void NumberToPicolitersPerLiterTest() => + Assert.Equal(VolumeConcentration.FromPicolitersPerLiter(2), 2.PicolitersPerLiter); + + [Fact] + public void NumberToPicolitersPerMilliliterTest() => + Assert.Equal(VolumeConcentration.FromPicolitersPerMilliliter(2), 2.PicolitersPerMilliliter); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVolumeExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVolumeExtensionsTest.g.cs new file mode 100644 index 0000000000..a7560d2f66 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVolumeExtensionsTest.g.cs @@ -0,0 +1,248 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToVolume; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToVolumeExtensionsTests + { + [Fact] + public void NumberToAcreFeetTest() => + Assert.Equal(Volume.FromAcreFeet(2), 2.AcreFeet); + + [Fact] + public void NumberToAuTablespoonsTest() => + Assert.Equal(Volume.FromAuTablespoons(2), 2.AuTablespoons); + + [Fact] + public void NumberToBoardFeetTest() => + Assert.Equal(Volume.FromBoardFeet(2), 2.BoardFeet); + + [Fact] + public void NumberToCentilitersTest() => + Assert.Equal(Volume.FromCentiliters(2), 2.Centiliters); + + [Fact] + public void NumberToCubicCentimetersTest() => + Assert.Equal(Volume.FromCubicCentimeters(2), 2.CubicCentimeters); + + [Fact] + public void NumberToCubicDecimetersTest() => + Assert.Equal(Volume.FromCubicDecimeters(2), 2.CubicDecimeters); + + [Fact] + public void NumberToCubicFeetTest() => + Assert.Equal(Volume.FromCubicFeet(2), 2.CubicFeet); + + [Fact] + public void NumberToCubicHectometersTest() => + Assert.Equal(Volume.FromCubicHectometers(2), 2.CubicHectometers); + + [Fact] + public void NumberToCubicInchesTest() => + Assert.Equal(Volume.FromCubicInches(2), 2.CubicInches); + + [Fact] + public void NumberToCubicKilometersTest() => + Assert.Equal(Volume.FromCubicKilometers(2), 2.CubicKilometers); + + [Fact] + public void NumberToCubicMetersTest() => + Assert.Equal(Volume.FromCubicMeters(2), 2.CubicMeters); + + [Fact] + public void NumberToCubicMicrometersTest() => + Assert.Equal(Volume.FromCubicMicrometers(2), 2.CubicMicrometers); + + [Fact] + public void NumberToCubicMilesTest() => + Assert.Equal(Volume.FromCubicMiles(2), 2.CubicMiles); + + [Fact] + public void NumberToCubicMillimetersTest() => + Assert.Equal(Volume.FromCubicMillimeters(2), 2.CubicMillimeters); + + [Fact] + public void NumberToCubicYardsTest() => + Assert.Equal(Volume.FromCubicYards(2), 2.CubicYards); + + [Fact] + public void NumberToDecalitersTest() => + Assert.Equal(Volume.FromDecaliters(2), 2.Decaliters); + + [Fact] + public void NumberToDecausGallonsTest() => + Assert.Equal(Volume.FromDecausGallons(2), 2.DecausGallons); + + [Fact] + public void NumberToDecilitersTest() => + Assert.Equal(Volume.FromDeciliters(2), 2.Deciliters); + + [Fact] + public void NumberToDeciusGallonsTest() => + Assert.Equal(Volume.FromDeciusGallons(2), 2.DeciusGallons); + + [Fact] + public void NumberToHectocubicFeetTest() => + Assert.Equal(Volume.FromHectocubicFeet(2), 2.HectocubicFeet); + + [Fact] + public void NumberToHectocubicMetersTest() => + Assert.Equal(Volume.FromHectocubicMeters(2), 2.HectocubicMeters); + + [Fact] + public void NumberToHectolitersTest() => + Assert.Equal(Volume.FromHectoliters(2), 2.Hectoliters); + + [Fact] + public void NumberToHectousGallonsTest() => + Assert.Equal(Volume.FromHectousGallons(2), 2.HectousGallons); + + [Fact] + public void NumberToImperialBeerBarrelsTest() => + Assert.Equal(Volume.FromImperialBeerBarrels(2), 2.ImperialBeerBarrels); + + [Fact] + public void NumberToImperialGallonsTest() => + Assert.Equal(Volume.FromImperialGallons(2), 2.ImperialGallons); + + [Fact] + public void NumberToImperialOuncesTest() => + Assert.Equal(Volume.FromImperialOunces(2), 2.ImperialOunces); + + [Fact] + public void NumberToImperialPintsTest() => + Assert.Equal(Volume.FromImperialPints(2), 2.ImperialPints); + + [Fact] + public void NumberToImperialQuartsTest() => + Assert.Equal(Volume.FromImperialQuarts(2), 2.ImperialQuarts); + + [Fact] + public void NumberToKilocubicFeetTest() => + Assert.Equal(Volume.FromKilocubicFeet(2), 2.KilocubicFeet); + + [Fact] + public void NumberToKilocubicMetersTest() => + Assert.Equal(Volume.FromKilocubicMeters(2), 2.KilocubicMeters); + + [Fact] + public void NumberToKiloimperialGallonsTest() => + Assert.Equal(Volume.FromKiloimperialGallons(2), 2.KiloimperialGallons); + + [Fact] + public void NumberToKilolitersTest() => + Assert.Equal(Volume.FromKiloliters(2), 2.Kiloliters); + + [Fact] + public void NumberToKilousGallonsTest() => + Assert.Equal(Volume.FromKilousGallons(2), 2.KilousGallons); + + [Fact] + public void NumberToLitersTest() => + Assert.Equal(Volume.FromLiters(2), 2.Liters); + + [Fact] + public void NumberToMegacubicFeetTest() => + Assert.Equal(Volume.FromMegacubicFeet(2), 2.MegacubicFeet); + + [Fact] + public void NumberToMegaimperialGallonsTest() => + Assert.Equal(Volume.FromMegaimperialGallons(2), 2.MegaimperialGallons); + + [Fact] + public void NumberToMegalitersTest() => + Assert.Equal(Volume.FromMegaliters(2), 2.Megaliters); + + [Fact] + public void NumberToMegausGallonsTest() => + Assert.Equal(Volume.FromMegausGallons(2), 2.MegausGallons); + + [Fact] + public void NumberToMetricCupsTest() => + Assert.Equal(Volume.FromMetricCups(2), 2.MetricCups); + + [Fact] + public void NumberToMetricTablespoonsTest() => + Assert.Equal(Volume.FromMetricTablespoons(2), 2.MetricTablespoons); + + [Fact] + public void NumberToMetricTeaspoonsTest() => + Assert.Equal(Volume.FromMetricTeaspoons(2), 2.MetricTeaspoons); + + [Fact] + public void NumberToMicrolitersTest() => + Assert.Equal(Volume.FromMicroliters(2), 2.Microliters); + + [Fact] + public void NumberToMillilitersTest() => + Assert.Equal(Volume.FromMilliliters(2), 2.Milliliters); + + [Fact] + public void NumberToNanolitersTest() => + Assert.Equal(Volume.FromNanoliters(2), 2.Nanoliters); + + [Fact] + public void NumberToOilBarrelsTest() => + Assert.Equal(Volume.FromOilBarrels(2), 2.OilBarrels); + + [Fact] + public void NumberToUkTablespoonsTest() => + Assert.Equal(Volume.FromUkTablespoons(2), 2.UkTablespoons); + + [Fact] + public void NumberToUsBeerBarrelsTest() => + Assert.Equal(Volume.FromUsBeerBarrels(2), 2.UsBeerBarrels); + + [Fact] + public void NumberToUsCustomaryCupsTest() => + Assert.Equal(Volume.FromUsCustomaryCups(2), 2.UsCustomaryCups); + + [Fact] + public void NumberToUsGallonsTest() => + Assert.Equal(Volume.FromUsGallons(2), 2.UsGallons); + + [Fact] + public void NumberToUsLegalCupsTest() => + Assert.Equal(Volume.FromUsLegalCups(2), 2.UsLegalCups); + + [Fact] + public void NumberToUsOuncesTest() => + Assert.Equal(Volume.FromUsOunces(2), 2.UsOunces); + + [Fact] + public void NumberToUsPintsTest() => + Assert.Equal(Volume.FromUsPints(2), 2.UsPints); + + [Fact] + public void NumberToUsQuartsTest() => + Assert.Equal(Volume.FromUsQuarts(2), 2.UsQuarts); + + [Fact] + public void NumberToUsTablespoonsTest() => + Assert.Equal(Volume.FromUsTablespoons(2), 2.UsTablespoons); + + [Fact] + public void NumberToUsTeaspoonsTest() => + Assert.Equal(Volume.FromUsTeaspoons(2), 2.UsTeaspoons); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVolumeFlowExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVolumeFlowExtensionsTest.g.cs new file mode 100644 index 0000000000..9bee6763e6 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVolumeFlowExtensionsTest.g.cs @@ -0,0 +1,328 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToVolumeFlow; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToVolumeFlowExtensionsTests + { + [Fact] + public void NumberToAcreFeetPerDayTest() => + Assert.Equal(VolumeFlow.FromAcreFeetPerDay(2), 2.AcreFeetPerDay); + + [Fact] + public void NumberToAcreFeetPerHourTest() => + Assert.Equal(VolumeFlow.FromAcreFeetPerHour(2), 2.AcreFeetPerHour); + + [Fact] + public void NumberToAcreFeetPerMinuteTest() => + Assert.Equal(VolumeFlow.FromAcreFeetPerMinute(2), 2.AcreFeetPerMinute); + + [Fact] + public void NumberToAcreFeetPerSecondTest() => + Assert.Equal(VolumeFlow.FromAcreFeetPerSecond(2), 2.AcreFeetPerSecond); + + [Fact] + public void NumberToCentilitersPerDayTest() => + Assert.Equal(VolumeFlow.FromCentilitersPerDay(2), 2.CentilitersPerDay); + + [Fact] + public void NumberToCentilitersPerHourTest() => + Assert.Equal(VolumeFlow.FromCentilitersPerHour(2), 2.CentilitersPerHour); + + [Fact] + public void NumberToCentilitersPerMinuteTest() => + Assert.Equal(VolumeFlow.FromCentilitersPerMinute(2), 2.CentilitersPerMinute); + + [Fact] + public void NumberToCentilitersPerSecondTest() => + Assert.Equal(VolumeFlow.FromCentilitersPerSecond(2), 2.CentilitersPerSecond); + + [Fact] + public void NumberToCubicCentimetersPerMinuteTest() => + Assert.Equal(VolumeFlow.FromCubicCentimetersPerMinute(2), 2.CubicCentimetersPerMinute); + + [Fact] + public void NumberToCubicDecimetersPerMinuteTest() => + Assert.Equal(VolumeFlow.FromCubicDecimetersPerMinute(2), 2.CubicDecimetersPerMinute); + + [Fact] + public void NumberToCubicFeetPerHourTest() => + Assert.Equal(VolumeFlow.FromCubicFeetPerHour(2), 2.CubicFeetPerHour); + + [Fact] + public void NumberToCubicFeetPerMinuteTest() => + Assert.Equal(VolumeFlow.FromCubicFeetPerMinute(2), 2.CubicFeetPerMinute); + + [Fact] + public void NumberToCubicFeetPerSecondTest() => + Assert.Equal(VolumeFlow.FromCubicFeetPerSecond(2), 2.CubicFeetPerSecond); + + [Fact] + public void NumberToCubicMetersPerDayTest() => + Assert.Equal(VolumeFlow.FromCubicMetersPerDay(2), 2.CubicMetersPerDay); + + [Fact] + public void NumberToCubicMetersPerHourTest() => + Assert.Equal(VolumeFlow.FromCubicMetersPerHour(2), 2.CubicMetersPerHour); + + [Fact] + public void NumberToCubicMetersPerMinuteTest() => + Assert.Equal(VolumeFlow.FromCubicMetersPerMinute(2), 2.CubicMetersPerMinute); + + [Fact] + public void NumberToCubicMetersPerSecondTest() => + Assert.Equal(VolumeFlow.FromCubicMetersPerSecond(2), 2.CubicMetersPerSecond); + + [Fact] + public void NumberToCubicMillimetersPerSecondTest() => + Assert.Equal(VolumeFlow.FromCubicMillimetersPerSecond(2), 2.CubicMillimetersPerSecond); + + [Fact] + public void NumberToCubicYardsPerDayTest() => + Assert.Equal(VolumeFlow.FromCubicYardsPerDay(2), 2.CubicYardsPerDay); + + [Fact] + public void NumberToCubicYardsPerHourTest() => + Assert.Equal(VolumeFlow.FromCubicYardsPerHour(2), 2.CubicYardsPerHour); + + [Fact] + public void NumberToCubicYardsPerMinuteTest() => + Assert.Equal(VolumeFlow.FromCubicYardsPerMinute(2), 2.CubicYardsPerMinute); + + [Fact] + public void NumberToCubicYardsPerSecondTest() => + Assert.Equal(VolumeFlow.FromCubicYardsPerSecond(2), 2.CubicYardsPerSecond); + + [Fact] + public void NumberToDecalitersPerDayTest() => + Assert.Equal(VolumeFlow.FromDecalitersPerDay(2), 2.DecalitersPerDay); + + [Fact] + public void NumberToDecalitersPerHourTest() => + Assert.Equal(VolumeFlow.FromDecalitersPerHour(2), 2.DecalitersPerHour); + + [Fact] + public void NumberToDecalitersPerMinuteTest() => + Assert.Equal(VolumeFlow.FromDecalitersPerMinute(2), 2.DecalitersPerMinute); + + [Fact] + public void NumberToDecalitersPerSecondTest() => + Assert.Equal(VolumeFlow.FromDecalitersPerSecond(2), 2.DecalitersPerSecond); + + [Fact] + public void NumberToDecilitersPerDayTest() => + Assert.Equal(VolumeFlow.FromDecilitersPerDay(2), 2.DecilitersPerDay); + + [Fact] + public void NumberToDecilitersPerHourTest() => + Assert.Equal(VolumeFlow.FromDecilitersPerHour(2), 2.DecilitersPerHour); + + [Fact] + public void NumberToDecilitersPerMinuteTest() => + Assert.Equal(VolumeFlow.FromDecilitersPerMinute(2), 2.DecilitersPerMinute); + + [Fact] + public void NumberToDecilitersPerSecondTest() => + Assert.Equal(VolumeFlow.FromDecilitersPerSecond(2), 2.DecilitersPerSecond); + + [Fact] + public void NumberToHectolitersPerDayTest() => + Assert.Equal(VolumeFlow.FromHectolitersPerDay(2), 2.HectolitersPerDay); + + [Fact] + public void NumberToHectolitersPerHourTest() => + Assert.Equal(VolumeFlow.FromHectolitersPerHour(2), 2.HectolitersPerHour); + + [Fact] + public void NumberToHectolitersPerMinuteTest() => + Assert.Equal(VolumeFlow.FromHectolitersPerMinute(2), 2.HectolitersPerMinute); + + [Fact] + public void NumberToHectolitersPerSecondTest() => + Assert.Equal(VolumeFlow.FromHectolitersPerSecond(2), 2.HectolitersPerSecond); + + [Fact] + public void NumberToKilolitersPerDayTest() => + Assert.Equal(VolumeFlow.FromKilolitersPerDay(2), 2.KilolitersPerDay); + + [Fact] + public void NumberToKilolitersPerHourTest() => + Assert.Equal(VolumeFlow.FromKilolitersPerHour(2), 2.KilolitersPerHour); + + [Fact] + public void NumberToKilolitersPerMinuteTest() => + Assert.Equal(VolumeFlow.FromKilolitersPerMinute(2), 2.KilolitersPerMinute); + + [Fact] + public void NumberToKilolitersPerSecondTest() => + Assert.Equal(VolumeFlow.FromKilolitersPerSecond(2), 2.KilolitersPerSecond); + + [Fact] + public void NumberToKilousGallonsPerMinuteTest() => + Assert.Equal(VolumeFlow.FromKilousGallonsPerMinute(2), 2.KilousGallonsPerMinute); + + [Fact] + public void NumberToLitersPerDayTest() => + Assert.Equal(VolumeFlow.FromLitersPerDay(2), 2.LitersPerDay); + + [Fact] + public void NumberToLitersPerHourTest() => + Assert.Equal(VolumeFlow.FromLitersPerHour(2), 2.LitersPerHour); + + [Fact] + public void NumberToLitersPerMinuteTest() => + Assert.Equal(VolumeFlow.FromLitersPerMinute(2), 2.LitersPerMinute); + + [Fact] + public void NumberToLitersPerSecondTest() => + Assert.Equal(VolumeFlow.FromLitersPerSecond(2), 2.LitersPerSecond); + + [Fact] + public void NumberToMegalitersPerDayTest() => + Assert.Equal(VolumeFlow.FromMegalitersPerDay(2), 2.MegalitersPerDay); + + [Fact] + public void NumberToMegalitersPerHourTest() => + Assert.Equal(VolumeFlow.FromMegalitersPerHour(2), 2.MegalitersPerHour); + + [Fact] + public void NumberToMegalitersPerMinuteTest() => + Assert.Equal(VolumeFlow.FromMegalitersPerMinute(2), 2.MegalitersPerMinute); + + [Fact] + public void NumberToMegalitersPerSecondTest() => + Assert.Equal(VolumeFlow.FromMegalitersPerSecond(2), 2.MegalitersPerSecond); + + [Fact] + public void NumberToMegaukGallonsPerDayTest() => + Assert.Equal(VolumeFlow.FromMegaukGallonsPerDay(2), 2.MegaukGallonsPerDay); + + [Fact] + public void NumberToMegaukGallonsPerSecondTest() => + Assert.Equal(VolumeFlow.FromMegaukGallonsPerSecond(2), 2.MegaukGallonsPerSecond); + + [Fact] + public void NumberToMegausGallonsPerDayTest() => + Assert.Equal(VolumeFlow.FromMegausGallonsPerDay(2), 2.MegausGallonsPerDay); + + [Fact] + public void NumberToMicrolitersPerDayTest() => + Assert.Equal(VolumeFlow.FromMicrolitersPerDay(2), 2.MicrolitersPerDay); + + [Fact] + public void NumberToMicrolitersPerHourTest() => + Assert.Equal(VolumeFlow.FromMicrolitersPerHour(2), 2.MicrolitersPerHour); + + [Fact] + public void NumberToMicrolitersPerMinuteTest() => + Assert.Equal(VolumeFlow.FromMicrolitersPerMinute(2), 2.MicrolitersPerMinute); + + [Fact] + public void NumberToMicrolitersPerSecondTest() => + Assert.Equal(VolumeFlow.FromMicrolitersPerSecond(2), 2.MicrolitersPerSecond); + + [Fact] + public void NumberToMillilitersPerDayTest() => + Assert.Equal(VolumeFlow.FromMillilitersPerDay(2), 2.MillilitersPerDay); + + [Fact] + public void NumberToMillilitersPerHourTest() => + Assert.Equal(VolumeFlow.FromMillilitersPerHour(2), 2.MillilitersPerHour); + + [Fact] + public void NumberToMillilitersPerMinuteTest() => + Assert.Equal(VolumeFlow.FromMillilitersPerMinute(2), 2.MillilitersPerMinute); + + [Fact] + public void NumberToMillilitersPerSecondTest() => + Assert.Equal(VolumeFlow.FromMillilitersPerSecond(2), 2.MillilitersPerSecond); + + [Fact] + public void NumberToMillionUsGallonsPerDayTest() => + Assert.Equal(VolumeFlow.FromMillionUsGallonsPerDay(2), 2.MillionUsGallonsPerDay); + + [Fact] + public void NumberToNanolitersPerDayTest() => + Assert.Equal(VolumeFlow.FromNanolitersPerDay(2), 2.NanolitersPerDay); + + [Fact] + public void NumberToNanolitersPerHourTest() => + Assert.Equal(VolumeFlow.FromNanolitersPerHour(2), 2.NanolitersPerHour); + + [Fact] + public void NumberToNanolitersPerMinuteTest() => + Assert.Equal(VolumeFlow.FromNanolitersPerMinute(2), 2.NanolitersPerMinute); + + [Fact] + public void NumberToNanolitersPerSecondTest() => + Assert.Equal(VolumeFlow.FromNanolitersPerSecond(2), 2.NanolitersPerSecond); + + [Fact] + public void NumberToOilBarrelsPerDayTest() => + Assert.Equal(VolumeFlow.FromOilBarrelsPerDay(2), 2.OilBarrelsPerDay); + + [Fact] + public void NumberToOilBarrelsPerHourTest() => + Assert.Equal(VolumeFlow.FromOilBarrelsPerHour(2), 2.OilBarrelsPerHour); + + [Fact] + public void NumberToOilBarrelsPerMinuteTest() => + Assert.Equal(VolumeFlow.FromOilBarrelsPerMinute(2), 2.OilBarrelsPerMinute); + + [Fact] + public void NumberToOilBarrelsPerSecondTest() => + Assert.Equal(VolumeFlow.FromOilBarrelsPerSecond(2), 2.OilBarrelsPerSecond); + + [Fact] + public void NumberToUkGallonsPerDayTest() => + Assert.Equal(VolumeFlow.FromUkGallonsPerDay(2), 2.UkGallonsPerDay); + + [Fact] + public void NumberToUkGallonsPerHourTest() => + Assert.Equal(VolumeFlow.FromUkGallonsPerHour(2), 2.UkGallonsPerHour); + + [Fact] + public void NumberToUkGallonsPerMinuteTest() => + Assert.Equal(VolumeFlow.FromUkGallonsPerMinute(2), 2.UkGallonsPerMinute); + + [Fact] + public void NumberToUkGallonsPerSecondTest() => + Assert.Equal(VolumeFlow.FromUkGallonsPerSecond(2), 2.UkGallonsPerSecond); + + [Fact] + public void NumberToUsGallonsPerDayTest() => + Assert.Equal(VolumeFlow.FromUsGallonsPerDay(2), 2.UsGallonsPerDay); + + [Fact] + public void NumberToUsGallonsPerHourTest() => + Assert.Equal(VolumeFlow.FromUsGallonsPerHour(2), 2.UsGallonsPerHour); + + [Fact] + public void NumberToUsGallonsPerMinuteTest() => + Assert.Equal(VolumeFlow.FromUsGallonsPerMinute(2), 2.UsGallonsPerMinute); + + [Fact] + public void NumberToUsGallonsPerSecondTest() => + Assert.Equal(VolumeFlow.FromUsGallonsPerSecond(2), 2.UsGallonsPerSecond); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVolumeFlowPerAreaExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVolumeFlowPerAreaExtensionsTest.g.cs new file mode 100644 index 0000000000..468559b59b --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVolumeFlowPerAreaExtensionsTest.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 UnitsNet.NumberExtensions.NumberToVolumeFlowPerArea; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToVolumeFlowPerAreaExtensionsTests + { + [Fact] + public void NumberToCubicFeetPerMinutePerSquareFootTest() => + Assert.Equal(VolumeFlowPerArea.FromCubicFeetPerMinutePerSquareFoot(2), 2.CubicFeetPerMinutePerSquareFoot); + + [Fact] + public void NumberToCubicMetersPerSecondPerSquareMeterTest() => + Assert.Equal(VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(2), 2.CubicMetersPerSecondPerSquareMeter); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVolumePerLengthExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVolumePerLengthExtensionsTest.g.cs new file mode 100644 index 0000000000..5fb9dcbbc9 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVolumePerLengthExtensionsTest.g.cs @@ -0,0 +1,64 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToVolumePerLength; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToVolumePerLengthExtensionsTests + { + [Fact] + public void NumberToCubicMetersPerMeterTest() => + Assert.Equal(VolumePerLength.FromCubicMetersPerMeter(2), 2.CubicMetersPerMeter); + + [Fact] + public void NumberToCubicYardsPerFootTest() => + Assert.Equal(VolumePerLength.FromCubicYardsPerFoot(2), 2.CubicYardsPerFoot); + + [Fact] + public void NumberToCubicYardsPerUsSurveyFootTest() => + Assert.Equal(VolumePerLength.FromCubicYardsPerUsSurveyFoot(2), 2.CubicYardsPerUsSurveyFoot); + + [Fact] + public void NumberToImperialGallonsPerMileTest() => + Assert.Equal(VolumePerLength.FromImperialGallonsPerMile(2), 2.ImperialGallonsPerMile); + + [Fact] + public void NumberToLitersPerKilometerTest() => + Assert.Equal(VolumePerLength.FromLitersPerKilometer(2), 2.LitersPerKilometer); + + [Fact] + public void NumberToLitersPerMeterTest() => + Assert.Equal(VolumePerLength.FromLitersPerMeter(2), 2.LitersPerMeter); + + [Fact] + public void NumberToLitersPerMillimeterTest() => + Assert.Equal(VolumePerLength.FromLitersPerMillimeter(2), 2.LitersPerMillimeter); + + [Fact] + public void NumberToOilBarrelsPerFootTest() => + Assert.Equal(VolumePerLength.FromOilBarrelsPerFoot(2), 2.OilBarrelsPerFoot); + + [Fact] + public void NumberToUsGallonsPerMileTest() => + Assert.Equal(VolumePerLength.FromUsGallonsPerMile(2), 2.UsGallonsPerMile); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVolumetricHeatCapacityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVolumetricHeatCapacityExtensionsTest.g.cs new file mode 100644 index 0000000000..fd40de9611 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToVolumetricHeatCapacityExtensionsTest.g.cs @@ -0,0 +1,64 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToVolumetricHeatCapacity; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToVolumetricHeatCapacityExtensionsTests + { + [Fact] + public void NumberToBtusPerCubicFootDegreeFahrenheitTest() => + Assert.Equal(VolumetricHeatCapacity.FromBtusPerCubicFootDegreeFahrenheit(2), 2.BtusPerCubicFootDegreeFahrenheit); + + [Fact] + public void NumberToCaloriesPerCubicCentimeterDegreeCelsiusTest() => + Assert.Equal(VolumetricHeatCapacity.FromCaloriesPerCubicCentimeterDegreeCelsius(2), 2.CaloriesPerCubicCentimeterDegreeCelsius); + + [Fact] + public void NumberToJoulesPerCubicMeterDegreeCelsiusTest() => + Assert.Equal(VolumetricHeatCapacity.FromJoulesPerCubicMeterDegreeCelsius(2), 2.JoulesPerCubicMeterDegreeCelsius); + + [Fact] + public void NumberToJoulesPerCubicMeterKelvinTest() => + Assert.Equal(VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(2), 2.JoulesPerCubicMeterKelvin); + + [Fact] + public void NumberToKilocaloriesPerCubicCentimeterDegreeCelsiusTest() => + Assert.Equal(VolumetricHeatCapacity.FromKilocaloriesPerCubicCentimeterDegreeCelsius(2), 2.KilocaloriesPerCubicCentimeterDegreeCelsius); + + [Fact] + public void NumberToKilojoulesPerCubicMeterDegreeCelsiusTest() => + Assert.Equal(VolumetricHeatCapacity.FromKilojoulesPerCubicMeterDegreeCelsius(2), 2.KilojoulesPerCubicMeterDegreeCelsius); + + [Fact] + public void NumberToKilojoulesPerCubicMeterKelvinTest() => + Assert.Equal(VolumetricHeatCapacity.FromKilojoulesPerCubicMeterKelvin(2), 2.KilojoulesPerCubicMeterKelvin); + + [Fact] + public void NumberToMegajoulesPerCubicMeterDegreeCelsiusTest() => + Assert.Equal(VolumetricHeatCapacity.FromMegajoulesPerCubicMeterDegreeCelsius(2), 2.MegajoulesPerCubicMeterDegreeCelsius); + + [Fact] + public void NumberToMegajoulesPerCubicMeterKelvinTest() => + Assert.Equal(VolumetricHeatCapacity.FromMegajoulesPerCubicMeterKelvin(2), 2.MegajoulesPerCubicMeterKelvin); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToWarpingMomentOfInertiaExtensionsTest.g.cs b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToWarpingMomentOfInertiaExtensionsTest.g.cs new file mode 100644 index 0000000000..0cfc5615ed --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/GeneratedCode/NumberToWarpingMomentOfInertiaExtensionsTest.g.cs @@ -0,0 +1,52 @@ +//------------------------------------------------------------------------------ +// +// 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.NumberToWarpingMomentOfInertia; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToWarpingMomentOfInertiaExtensionsTests + { + [Fact] + public void NumberToCentimetersToTheSixthTest() => + Assert.Equal(WarpingMomentOfInertia.FromCentimetersToTheSixth(2), 2.CentimetersToTheSixth); + + [Fact] + public void NumberToDecimetersToTheSixthTest() => + Assert.Equal(WarpingMomentOfInertia.FromDecimetersToTheSixth(2), 2.DecimetersToTheSixth); + + [Fact] + public void NumberToFeetToTheSixthTest() => + Assert.Equal(WarpingMomentOfInertia.FromFeetToTheSixth(2), 2.FeetToTheSixth); + + [Fact] + public void NumberToInchesToTheSixthTest() => + Assert.Equal(WarpingMomentOfInertia.FromInchesToTheSixth(2), 2.InchesToTheSixth); + + [Fact] + public void NumberToMetersToTheSixthTest() => + Assert.Equal(WarpingMomentOfInertia.FromMetersToTheSixth(2), 2.MetersToTheSixth); + + [Fact] + public void NumberToMillimetersToTheSixthTest() => + Assert.Equal(WarpingMomentOfInertia.FromMillimetersToTheSixth(2), 2.MillimetersToTheSixth); + + } +} diff --git a/UnitsNet.NumberExtensions.CS14.Tests/UnitsNet.NumberExtensions.CS14.Tests.csproj b/UnitsNet.NumberExtensions.CS14.Tests/UnitsNet.NumberExtensions.CS14.Tests.csproj new file mode 100644 index 0000000000..58930bd6c3 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14.Tests/UnitsNet.NumberExtensions.CS14.Tests.csproj @@ -0,0 +1,34 @@ + + + + net48;net8.0;net9.0 + UnitsNet.NumberExtensions.Tests + preview + enable + true + CS0618 + + + + + ../UnitsNet.snk + false + true + UnitsNet.NumberExtensions.Tests + true + + + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + + + + + diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAbsorbedDoseOfIonizingRadiationExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAbsorbedDoseOfIonizingRadiationExtensions.g.cs new file mode 100644 index 0000000000..9bbace06e6 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAbsorbedDoseOfIonizingRadiationExtensions.g.cs @@ -0,0 +1,183 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToAbsorbedDoseOfIonizingRadiation +{ + /// + /// A number to AbsorbedDoseOfIonizingRadiation Extensions + /// + public static class NumberToAbsorbedDoseOfIonizingRadiationExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public AbsorbedDoseOfIonizingRadiation Centigrays +#if NET7_0_OR_GREATER + => AbsorbedDoseOfIonizingRadiation.FromCentigrays(double.CreateChecked(value)); +#else + => AbsorbedDoseOfIonizingRadiation.FromCentigrays(value.ToDouble(null)); +#endif + + /// + public AbsorbedDoseOfIonizingRadiation Decigrays +#if NET7_0_OR_GREATER + => AbsorbedDoseOfIonizingRadiation.FromDecigrays(double.CreateChecked(value)); +#else + => AbsorbedDoseOfIonizingRadiation.FromDecigrays(value.ToDouble(null)); +#endif + + /// + public AbsorbedDoseOfIonizingRadiation Femtograys +#if NET7_0_OR_GREATER + => AbsorbedDoseOfIonizingRadiation.FromFemtograys(double.CreateChecked(value)); +#else + => AbsorbedDoseOfIonizingRadiation.FromFemtograys(value.ToDouble(null)); +#endif + + /// + public AbsorbedDoseOfIonizingRadiation Gigagrays +#if NET7_0_OR_GREATER + => AbsorbedDoseOfIonizingRadiation.FromGigagrays(double.CreateChecked(value)); +#else + => AbsorbedDoseOfIonizingRadiation.FromGigagrays(value.ToDouble(null)); +#endif + + /// + public AbsorbedDoseOfIonizingRadiation Grays +#if NET7_0_OR_GREATER + => AbsorbedDoseOfIonizingRadiation.FromGrays(double.CreateChecked(value)); +#else + => AbsorbedDoseOfIonizingRadiation.FromGrays(value.ToDouble(null)); +#endif + + /// + public AbsorbedDoseOfIonizingRadiation Kilograys +#if NET7_0_OR_GREATER + => AbsorbedDoseOfIonizingRadiation.FromKilograys(double.CreateChecked(value)); +#else + => AbsorbedDoseOfIonizingRadiation.FromKilograys(value.ToDouble(null)); +#endif + + /// + public AbsorbedDoseOfIonizingRadiation Kilorads +#if NET7_0_OR_GREATER + => AbsorbedDoseOfIonizingRadiation.FromKilorads(double.CreateChecked(value)); +#else + => AbsorbedDoseOfIonizingRadiation.FromKilorads(value.ToDouble(null)); +#endif + + /// + public AbsorbedDoseOfIonizingRadiation Megagrays +#if NET7_0_OR_GREATER + => AbsorbedDoseOfIonizingRadiation.FromMegagrays(double.CreateChecked(value)); +#else + => AbsorbedDoseOfIonizingRadiation.FromMegagrays(value.ToDouble(null)); +#endif + + /// + public AbsorbedDoseOfIonizingRadiation Megarads +#if NET7_0_OR_GREATER + => AbsorbedDoseOfIonizingRadiation.FromMegarads(double.CreateChecked(value)); +#else + => AbsorbedDoseOfIonizingRadiation.FromMegarads(value.ToDouble(null)); +#endif + + /// + public AbsorbedDoseOfIonizingRadiation Micrograys +#if NET7_0_OR_GREATER + => AbsorbedDoseOfIonizingRadiation.FromMicrograys(double.CreateChecked(value)); +#else + => AbsorbedDoseOfIonizingRadiation.FromMicrograys(value.ToDouble(null)); +#endif + + /// + public AbsorbedDoseOfIonizingRadiation Milligrays +#if NET7_0_OR_GREATER + => AbsorbedDoseOfIonizingRadiation.FromMilligrays(double.CreateChecked(value)); +#else + => AbsorbedDoseOfIonizingRadiation.FromMilligrays(value.ToDouble(null)); +#endif + + /// + public AbsorbedDoseOfIonizingRadiation Millirads +#if NET7_0_OR_GREATER + => AbsorbedDoseOfIonizingRadiation.FromMillirads(double.CreateChecked(value)); +#else + => AbsorbedDoseOfIonizingRadiation.FromMillirads(value.ToDouble(null)); +#endif + + /// + public AbsorbedDoseOfIonizingRadiation Nanograys +#if NET7_0_OR_GREATER + => AbsorbedDoseOfIonizingRadiation.FromNanograys(double.CreateChecked(value)); +#else + => AbsorbedDoseOfIonizingRadiation.FromNanograys(value.ToDouble(null)); +#endif + + /// + public AbsorbedDoseOfIonizingRadiation Petagrays +#if NET7_0_OR_GREATER + => AbsorbedDoseOfIonizingRadiation.FromPetagrays(double.CreateChecked(value)); +#else + => AbsorbedDoseOfIonizingRadiation.FromPetagrays(value.ToDouble(null)); +#endif + + /// + public AbsorbedDoseOfIonizingRadiation Picograys +#if NET7_0_OR_GREATER + => AbsorbedDoseOfIonizingRadiation.FromPicograys(double.CreateChecked(value)); +#else + => AbsorbedDoseOfIonizingRadiation.FromPicograys(value.ToDouble(null)); +#endif + + /// + public AbsorbedDoseOfIonizingRadiation Rads +#if NET7_0_OR_GREATER + => AbsorbedDoseOfIonizingRadiation.FromRads(double.CreateChecked(value)); +#else + => AbsorbedDoseOfIonizingRadiation.FromRads(value.ToDouble(null)); +#endif + + /// + public AbsorbedDoseOfIonizingRadiation Teragrays +#if NET7_0_OR_GREATER + => AbsorbedDoseOfIonizingRadiation.FromTeragrays(double.CreateChecked(value)); +#else + => AbsorbedDoseOfIonizingRadiation.FromTeragrays(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAccelerationExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAccelerationExtensions.g.cs new file mode 100644 index 0000000000..8b649ad509 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAccelerationExtensions.g.cs @@ -0,0 +1,159 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToAcceleration +{ + /// + /// A number to Acceleration Extensions + /// + public static class NumberToAccelerationExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Acceleration CentimetersPerSecondSquared +#if NET7_0_OR_GREATER + => Acceleration.FromCentimetersPerSecondSquared(double.CreateChecked(value)); +#else + => Acceleration.FromCentimetersPerSecondSquared(value.ToDouble(null)); +#endif + + /// + public Acceleration DecimetersPerSecondSquared +#if NET7_0_OR_GREATER + => Acceleration.FromDecimetersPerSecondSquared(double.CreateChecked(value)); +#else + => Acceleration.FromDecimetersPerSecondSquared(value.ToDouble(null)); +#endif + + /// + public Acceleration FeetPerSecondSquared +#if NET7_0_OR_GREATER + => Acceleration.FromFeetPerSecondSquared(double.CreateChecked(value)); +#else + => Acceleration.FromFeetPerSecondSquared(value.ToDouble(null)); +#endif + + /// + public Acceleration InchesPerSecondSquared +#if NET7_0_OR_GREATER + => Acceleration.FromInchesPerSecondSquared(double.CreateChecked(value)); +#else + => Acceleration.FromInchesPerSecondSquared(value.ToDouble(null)); +#endif + + /// + public Acceleration KilometersPerSecondSquared +#if NET7_0_OR_GREATER + => Acceleration.FromKilometersPerSecondSquared(double.CreateChecked(value)); +#else + => Acceleration.FromKilometersPerSecondSquared(value.ToDouble(null)); +#endif + + /// + public Acceleration KnotsPerHour +#if NET7_0_OR_GREATER + => Acceleration.FromKnotsPerHour(double.CreateChecked(value)); +#else + => Acceleration.FromKnotsPerHour(value.ToDouble(null)); +#endif + + /// + public Acceleration KnotsPerMinute +#if NET7_0_OR_GREATER + => Acceleration.FromKnotsPerMinute(double.CreateChecked(value)); +#else + => Acceleration.FromKnotsPerMinute(value.ToDouble(null)); +#endif + + /// + public Acceleration KnotsPerSecond +#if NET7_0_OR_GREATER + => Acceleration.FromKnotsPerSecond(double.CreateChecked(value)); +#else + => Acceleration.FromKnotsPerSecond(value.ToDouble(null)); +#endif + + /// + public Acceleration MetersPerSecondSquared +#if NET7_0_OR_GREATER + => Acceleration.FromMetersPerSecondSquared(double.CreateChecked(value)); +#else + => Acceleration.FromMetersPerSecondSquared(value.ToDouble(null)); +#endif + + /// + public Acceleration MicrometersPerSecondSquared +#if NET7_0_OR_GREATER + => Acceleration.FromMicrometersPerSecondSquared(double.CreateChecked(value)); +#else + => Acceleration.FromMicrometersPerSecondSquared(value.ToDouble(null)); +#endif + + /// + public Acceleration MillimetersPerSecondSquared +#if NET7_0_OR_GREATER + => Acceleration.FromMillimetersPerSecondSquared(double.CreateChecked(value)); +#else + => Acceleration.FromMillimetersPerSecondSquared(value.ToDouble(null)); +#endif + + /// + public Acceleration MillistandardGravity +#if NET7_0_OR_GREATER + => Acceleration.FromMillistandardGravity(double.CreateChecked(value)); +#else + => Acceleration.FromMillistandardGravity(value.ToDouble(null)); +#endif + + /// + public Acceleration NanometersPerSecondSquared +#if NET7_0_OR_GREATER + => Acceleration.FromNanometersPerSecondSquared(double.CreateChecked(value)); +#else + => Acceleration.FromNanometersPerSecondSquared(value.ToDouble(null)); +#endif + + /// + public Acceleration StandardGravity +#if NET7_0_OR_GREATER + => Acceleration.FromStandardGravity(double.CreateChecked(value)); +#else + => Acceleration.FromStandardGravity(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAmountOfSubstanceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAmountOfSubstanceExtensions.g.cs new file mode 100644 index 0000000000..06336e0b63 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAmountOfSubstanceExtensions.g.cs @@ -0,0 +1,183 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToAmountOfSubstance +{ + /// + /// A number to AmountOfSubstance Extensions + /// + public static class NumberToAmountOfSubstanceExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public AmountOfSubstance Centimoles +#if NET7_0_OR_GREATER + => AmountOfSubstance.FromCentimoles(double.CreateChecked(value)); +#else + => AmountOfSubstance.FromCentimoles(value.ToDouble(null)); +#endif + + /// + public AmountOfSubstance CentipoundMoles +#if NET7_0_OR_GREATER + => AmountOfSubstance.FromCentipoundMoles(double.CreateChecked(value)); +#else + => AmountOfSubstance.FromCentipoundMoles(value.ToDouble(null)); +#endif + + /// + public AmountOfSubstance Decimoles +#if NET7_0_OR_GREATER + => AmountOfSubstance.FromDecimoles(double.CreateChecked(value)); +#else + => AmountOfSubstance.FromDecimoles(value.ToDouble(null)); +#endif + + /// + public AmountOfSubstance DecipoundMoles +#if NET7_0_OR_GREATER + => AmountOfSubstance.FromDecipoundMoles(double.CreateChecked(value)); +#else + => AmountOfSubstance.FromDecipoundMoles(value.ToDouble(null)); +#endif + + /// + public AmountOfSubstance Femtomoles +#if NET7_0_OR_GREATER + => AmountOfSubstance.FromFemtomoles(double.CreateChecked(value)); +#else + => AmountOfSubstance.FromFemtomoles(value.ToDouble(null)); +#endif + + /// + public AmountOfSubstance Kilomoles +#if NET7_0_OR_GREATER + => AmountOfSubstance.FromKilomoles(double.CreateChecked(value)); +#else + => AmountOfSubstance.FromKilomoles(value.ToDouble(null)); +#endif + + /// + public AmountOfSubstance KilopoundMoles +#if NET7_0_OR_GREATER + => AmountOfSubstance.FromKilopoundMoles(double.CreateChecked(value)); +#else + => AmountOfSubstance.FromKilopoundMoles(value.ToDouble(null)); +#endif + + /// + public AmountOfSubstance Megamoles +#if NET7_0_OR_GREATER + => AmountOfSubstance.FromMegamoles(double.CreateChecked(value)); +#else + => AmountOfSubstance.FromMegamoles(value.ToDouble(null)); +#endif + + /// + public AmountOfSubstance Micromoles +#if NET7_0_OR_GREATER + => AmountOfSubstance.FromMicromoles(double.CreateChecked(value)); +#else + => AmountOfSubstance.FromMicromoles(value.ToDouble(null)); +#endif + + /// + public AmountOfSubstance MicropoundMoles +#if NET7_0_OR_GREATER + => AmountOfSubstance.FromMicropoundMoles(double.CreateChecked(value)); +#else + => AmountOfSubstance.FromMicropoundMoles(value.ToDouble(null)); +#endif + + /// + public AmountOfSubstance Millimoles +#if NET7_0_OR_GREATER + => AmountOfSubstance.FromMillimoles(double.CreateChecked(value)); +#else + => AmountOfSubstance.FromMillimoles(value.ToDouble(null)); +#endif + + /// + public AmountOfSubstance MillipoundMoles +#if NET7_0_OR_GREATER + => AmountOfSubstance.FromMillipoundMoles(double.CreateChecked(value)); +#else + => AmountOfSubstance.FromMillipoundMoles(value.ToDouble(null)); +#endif + + /// + public AmountOfSubstance Moles +#if NET7_0_OR_GREATER + => AmountOfSubstance.FromMoles(double.CreateChecked(value)); +#else + => AmountOfSubstance.FromMoles(value.ToDouble(null)); +#endif + + /// + public AmountOfSubstance Nanomoles +#if NET7_0_OR_GREATER + => AmountOfSubstance.FromNanomoles(double.CreateChecked(value)); +#else + => AmountOfSubstance.FromNanomoles(value.ToDouble(null)); +#endif + + /// + public AmountOfSubstance NanopoundMoles +#if NET7_0_OR_GREATER + => AmountOfSubstance.FromNanopoundMoles(double.CreateChecked(value)); +#else + => AmountOfSubstance.FromNanopoundMoles(value.ToDouble(null)); +#endif + + /// + public AmountOfSubstance Picomoles +#if NET7_0_OR_GREATER + => AmountOfSubstance.FromPicomoles(double.CreateChecked(value)); +#else + => AmountOfSubstance.FromPicomoles(value.ToDouble(null)); +#endif + + /// + public AmountOfSubstance PoundMoles +#if NET7_0_OR_GREATER + => AmountOfSubstance.FromPoundMoles(double.CreateChecked(value)); +#else + => AmountOfSubstance.FromPoundMoles(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAmplitudeRatioExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAmplitudeRatioExtensions.g.cs new file mode 100644 index 0000000000..7aca317d77 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAmplitudeRatioExtensions.g.cs @@ -0,0 +1,79 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToAmplitudeRatio +{ + /// + /// A number to AmplitudeRatio Extensions + /// + public static class NumberToAmplitudeRatioExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public AmplitudeRatio DecibelMicrovolts +#if NET7_0_OR_GREATER + => AmplitudeRatio.FromDecibelMicrovolts(double.CreateChecked(value)); +#else + => AmplitudeRatio.FromDecibelMicrovolts(value.ToDouble(null)); +#endif + + /// + public AmplitudeRatio DecibelMillivolts +#if NET7_0_OR_GREATER + => AmplitudeRatio.FromDecibelMillivolts(double.CreateChecked(value)); +#else + => AmplitudeRatio.FromDecibelMillivolts(value.ToDouble(null)); +#endif + + /// + public AmplitudeRatio DecibelsUnloaded +#if NET7_0_OR_GREATER + => AmplitudeRatio.FromDecibelsUnloaded(double.CreateChecked(value)); +#else + => AmplitudeRatio.FromDecibelsUnloaded(value.ToDouble(null)); +#endif + + /// + public AmplitudeRatio DecibelVolts +#if NET7_0_OR_GREATER + => AmplitudeRatio.FromDecibelVolts(double.CreateChecked(value)); +#else + => AmplitudeRatio.FromDecibelVolts(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAngleExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAngleExtensions.g.cs new file mode 100644 index 0000000000..5399e3ba9f --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAngleExtensions.g.cs @@ -0,0 +1,167 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToAngle +{ + /// + /// A number to Angle Extensions + /// + public static class NumberToAngleExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Angle Arcminutes +#if NET7_0_OR_GREATER + => Angle.FromArcminutes(double.CreateChecked(value)); +#else + => Angle.FromArcminutes(value.ToDouble(null)); +#endif + + /// + public Angle Arcseconds +#if NET7_0_OR_GREATER + => Angle.FromArcseconds(double.CreateChecked(value)); +#else + => Angle.FromArcseconds(value.ToDouble(null)); +#endif + + /// + public Angle Centiradians +#if NET7_0_OR_GREATER + => Angle.FromCentiradians(double.CreateChecked(value)); +#else + => Angle.FromCentiradians(value.ToDouble(null)); +#endif + + /// + public Angle Deciradians +#if NET7_0_OR_GREATER + => Angle.FromDeciradians(double.CreateChecked(value)); +#else + => Angle.FromDeciradians(value.ToDouble(null)); +#endif + + /// + public Angle Degrees +#if NET7_0_OR_GREATER + => Angle.FromDegrees(double.CreateChecked(value)); +#else + => Angle.FromDegrees(value.ToDouble(null)); +#endif + + /// + public Angle Gradians +#if NET7_0_OR_GREATER + => Angle.FromGradians(double.CreateChecked(value)); +#else + => Angle.FromGradians(value.ToDouble(null)); +#endif + + /// + public Angle Microdegrees +#if NET7_0_OR_GREATER + => Angle.FromMicrodegrees(double.CreateChecked(value)); +#else + => Angle.FromMicrodegrees(value.ToDouble(null)); +#endif + + /// + public Angle Microradians +#if NET7_0_OR_GREATER + => Angle.FromMicroradians(double.CreateChecked(value)); +#else + => Angle.FromMicroradians(value.ToDouble(null)); +#endif + + /// + public Angle Millidegrees +#if NET7_0_OR_GREATER + => Angle.FromMillidegrees(double.CreateChecked(value)); +#else + => Angle.FromMillidegrees(value.ToDouble(null)); +#endif + + /// + public Angle Milliradians +#if NET7_0_OR_GREATER + => Angle.FromMilliradians(double.CreateChecked(value)); +#else + => Angle.FromMilliradians(value.ToDouble(null)); +#endif + + /// + public Angle Nanodegrees +#if NET7_0_OR_GREATER + => Angle.FromNanodegrees(double.CreateChecked(value)); +#else + => Angle.FromNanodegrees(value.ToDouble(null)); +#endif + + /// + public Angle Nanoradians +#if NET7_0_OR_GREATER + => Angle.FromNanoradians(double.CreateChecked(value)); +#else + => Angle.FromNanoradians(value.ToDouble(null)); +#endif + + /// + public Angle NatoMils +#if NET7_0_OR_GREATER + => Angle.FromNatoMils(double.CreateChecked(value)); +#else + => Angle.FromNatoMils(value.ToDouble(null)); +#endif + + /// + public Angle Radians +#if NET7_0_OR_GREATER + => Angle.FromRadians(double.CreateChecked(value)); +#else + => Angle.FromRadians(value.ToDouble(null)); +#endif + + /// + public Angle Revolutions +#if NET7_0_OR_GREATER + => Angle.FromRevolutions(double.CreateChecked(value)); +#else + => Angle.FromRevolutions(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAreaDensityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAreaDensityExtensions.g.cs new file mode 100644 index 0000000000..76d03f1fc8 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAreaDensityExtensions.g.cs @@ -0,0 +1,71 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToAreaDensity +{ + /// + /// A number to AreaDensity Extensions + /// + public static class NumberToAreaDensityExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public AreaDensity GramsPerSquareMeter +#if NET7_0_OR_GREATER + => AreaDensity.FromGramsPerSquareMeter(double.CreateChecked(value)); +#else + => AreaDensity.FromGramsPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public AreaDensity KilogramsPerSquareMeter +#if NET7_0_OR_GREATER + => AreaDensity.FromKilogramsPerSquareMeter(double.CreateChecked(value)); +#else + => AreaDensity.FromKilogramsPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public AreaDensity MilligramsPerSquareMeter +#if NET7_0_OR_GREATER + => AreaDensity.FromMilligramsPerSquareMeter(double.CreateChecked(value)); +#else + => AreaDensity.FromMilligramsPerSquareMeter(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAreaExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAreaExtensions.g.cs new file mode 100644 index 0000000000..89c652417e --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAreaExtensions.g.cs @@ -0,0 +1,159 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToArea +{ + /// + /// A number to Area Extensions + /// + public static class NumberToAreaExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Area Acres +#if NET7_0_OR_GREATER + => Area.FromAcres(double.CreateChecked(value)); +#else + => Area.FromAcres(value.ToDouble(null)); +#endif + + /// + public Area Hectares +#if NET7_0_OR_GREATER + => Area.FromHectares(double.CreateChecked(value)); +#else + => Area.FromHectares(value.ToDouble(null)); +#endif + + /// + public Area SquareCentimeters +#if NET7_0_OR_GREATER + => Area.FromSquareCentimeters(double.CreateChecked(value)); +#else + => Area.FromSquareCentimeters(value.ToDouble(null)); +#endif + + /// + public Area SquareDecimeters +#if NET7_0_OR_GREATER + => Area.FromSquareDecimeters(double.CreateChecked(value)); +#else + => Area.FromSquareDecimeters(value.ToDouble(null)); +#endif + + /// + public Area SquareFeet +#if NET7_0_OR_GREATER + => Area.FromSquareFeet(double.CreateChecked(value)); +#else + => Area.FromSquareFeet(value.ToDouble(null)); +#endif + + /// + public Area SquareInches +#if NET7_0_OR_GREATER + => Area.FromSquareInches(double.CreateChecked(value)); +#else + => Area.FromSquareInches(value.ToDouble(null)); +#endif + + /// + public Area SquareKilometers +#if NET7_0_OR_GREATER + => Area.FromSquareKilometers(double.CreateChecked(value)); +#else + => Area.FromSquareKilometers(value.ToDouble(null)); +#endif + + /// + public Area SquareMeters +#if NET7_0_OR_GREATER + => Area.FromSquareMeters(double.CreateChecked(value)); +#else + => Area.FromSquareMeters(value.ToDouble(null)); +#endif + + /// + public Area SquareMicrometers +#if NET7_0_OR_GREATER + => Area.FromSquareMicrometers(double.CreateChecked(value)); +#else + => Area.FromSquareMicrometers(value.ToDouble(null)); +#endif + + /// + public Area SquareMiles +#if NET7_0_OR_GREATER + => Area.FromSquareMiles(double.CreateChecked(value)); +#else + => Area.FromSquareMiles(value.ToDouble(null)); +#endif + + /// + public Area SquareMillimeters +#if NET7_0_OR_GREATER + => Area.FromSquareMillimeters(double.CreateChecked(value)); +#else + => Area.FromSquareMillimeters(value.ToDouble(null)); +#endif + + /// + public Area SquareNauticalMiles +#if NET7_0_OR_GREATER + => Area.FromSquareNauticalMiles(double.CreateChecked(value)); +#else + => Area.FromSquareNauticalMiles(value.ToDouble(null)); +#endif + + /// + public Area SquareYards +#if NET7_0_OR_GREATER + => Area.FromSquareYards(double.CreateChecked(value)); +#else + => Area.FromSquareYards(value.ToDouble(null)); +#endif + + /// + public Area UsSurveySquareFeet +#if NET7_0_OR_GREATER + => Area.FromUsSurveySquareFeet(double.CreateChecked(value)); +#else + => Area.FromUsSurveySquareFeet(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAreaMomentOfInertiaExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAreaMomentOfInertiaExtensions.g.cs new file mode 100644 index 0000000000..02cdb9014e --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToAreaMomentOfInertiaExtensions.g.cs @@ -0,0 +1,95 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToAreaMomentOfInertia +{ + /// + /// A number to AreaMomentOfInertia Extensions + /// + public static class NumberToAreaMomentOfInertiaExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public AreaMomentOfInertia CentimetersToTheFourth +#if NET7_0_OR_GREATER + => AreaMomentOfInertia.FromCentimetersToTheFourth(double.CreateChecked(value)); +#else + => AreaMomentOfInertia.FromCentimetersToTheFourth(value.ToDouble(null)); +#endif + + /// + public AreaMomentOfInertia DecimetersToTheFourth +#if NET7_0_OR_GREATER + => AreaMomentOfInertia.FromDecimetersToTheFourth(double.CreateChecked(value)); +#else + => AreaMomentOfInertia.FromDecimetersToTheFourth(value.ToDouble(null)); +#endif + + /// + public AreaMomentOfInertia FeetToTheFourth +#if NET7_0_OR_GREATER + => AreaMomentOfInertia.FromFeetToTheFourth(double.CreateChecked(value)); +#else + => AreaMomentOfInertia.FromFeetToTheFourth(value.ToDouble(null)); +#endif + + /// + public AreaMomentOfInertia InchesToTheFourth +#if NET7_0_OR_GREATER + => AreaMomentOfInertia.FromInchesToTheFourth(double.CreateChecked(value)); +#else + => AreaMomentOfInertia.FromInchesToTheFourth(value.ToDouble(null)); +#endif + + /// + public AreaMomentOfInertia MetersToTheFourth +#if NET7_0_OR_GREATER + => AreaMomentOfInertia.FromMetersToTheFourth(double.CreateChecked(value)); +#else + => AreaMomentOfInertia.FromMetersToTheFourth(value.ToDouble(null)); +#endif + + /// + public AreaMomentOfInertia MillimetersToTheFourth +#if NET7_0_OR_GREATER + => AreaMomentOfInertia.FromMillimetersToTheFourth(double.CreateChecked(value)); +#else + => AreaMomentOfInertia.FromMillimetersToTheFourth(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToBitRateExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToBitRateExtensions.g.cs new file mode 100644 index 0000000000..1b21581427 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToBitRateExtensions.g.cs @@ -0,0 +1,359 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToBitRate +{ + /// + /// A number to BitRate Extensions + /// + public static class NumberToBitRateExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public BitRate BitsPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromBitsPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromBitsPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate BytesPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromBytesPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromBytesPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate ExabitsPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromExabitsPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromExabitsPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate ExabytesPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromExabytesPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromExabytesPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate ExaoctetsPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromExaoctetsPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromExaoctetsPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate ExbibitsPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromExbibitsPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromExbibitsPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate ExbibytesPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromExbibytesPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromExbibytesPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate ExbioctetsPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromExbioctetsPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromExbioctetsPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate GibibitsPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromGibibitsPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromGibibitsPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate GibibytesPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromGibibytesPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromGibibytesPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate GibioctetsPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromGibioctetsPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromGibioctetsPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate GigabitsPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromGigabitsPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromGigabitsPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate GigabytesPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromGigabytesPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromGigabytesPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate GigaoctetsPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromGigaoctetsPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromGigaoctetsPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate KibibitsPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromKibibitsPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromKibibitsPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate KibibytesPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromKibibytesPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromKibibytesPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate KibioctetsPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromKibioctetsPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromKibioctetsPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate KilobitsPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromKilobitsPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromKilobitsPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate KilobytesPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromKilobytesPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromKilobytesPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate KilooctetsPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromKilooctetsPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromKilooctetsPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate MebibitsPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromMebibitsPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromMebibitsPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate MebibytesPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromMebibytesPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromMebibytesPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate MebioctetsPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromMebioctetsPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromMebioctetsPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate MegabitsPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromMegabitsPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromMegabitsPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate MegabytesPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromMegabytesPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromMegabytesPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate MegaoctetsPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromMegaoctetsPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromMegaoctetsPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate OctetsPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromOctetsPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromOctetsPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate PebibitsPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromPebibitsPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromPebibitsPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate PebibytesPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromPebibytesPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromPebibytesPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate PebioctetsPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromPebioctetsPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromPebioctetsPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate PetabitsPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromPetabitsPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromPetabitsPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate PetabytesPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromPetabytesPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromPetabytesPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate PetaoctetsPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromPetaoctetsPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromPetaoctetsPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate TebibitsPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromTebibitsPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromTebibitsPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate TebibytesPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromTebibytesPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromTebibytesPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate TebioctetsPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromTebioctetsPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromTebioctetsPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate TerabitsPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromTerabitsPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromTerabitsPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate TerabytesPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromTerabytesPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromTerabytesPerSecond(value.ToDouble(null)); +#endif + + /// + public BitRate TeraoctetsPerSecond +#if NET7_0_OR_GREATER + => BitRate.FromTeraoctetsPerSecond(double.CreateChecked(value)); +#else + => BitRate.FromTeraoctetsPerSecond(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs new file mode 100644 index 0000000000..f50bac3761 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs @@ -0,0 +1,71 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToBrakeSpecificFuelConsumption +{ + /// + /// A number to BrakeSpecificFuelConsumption Extensions + /// + public static class NumberToBrakeSpecificFuelConsumptionExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public BrakeSpecificFuelConsumption GramsPerKiloWattHour +#if NET7_0_OR_GREATER + => BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(double.CreateChecked(value)); +#else + => BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(value.ToDouble(null)); +#endif + + /// + public BrakeSpecificFuelConsumption KilogramsPerJoule +#if NET7_0_OR_GREATER + => BrakeSpecificFuelConsumption.FromKilogramsPerJoule(double.CreateChecked(value)); +#else + => BrakeSpecificFuelConsumption.FromKilogramsPerJoule(value.ToDouble(null)); +#endif + + /// + public BrakeSpecificFuelConsumption PoundsPerMechanicalHorsepowerHour +#if NET7_0_OR_GREATER + => BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(double.CreateChecked(value)); +#else + => BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensions.g.cs new file mode 100644 index 0000000000..e274125c58 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensions.g.cs @@ -0,0 +1,95 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToCoefficientOfThermalExpansion +{ + /// + /// A number to CoefficientOfThermalExpansion Extensions + /// + public static class NumberToCoefficientOfThermalExpansionExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public CoefficientOfThermalExpansion PerDegreeCelsius +#if NET7_0_OR_GREATER + => CoefficientOfThermalExpansion.FromPerDegreeCelsius(double.CreateChecked(value)); +#else + => CoefficientOfThermalExpansion.FromPerDegreeCelsius(value.ToDouble(null)); +#endif + + /// + public CoefficientOfThermalExpansion PerDegreeFahrenheit +#if NET7_0_OR_GREATER + => CoefficientOfThermalExpansion.FromPerDegreeFahrenheit(double.CreateChecked(value)); +#else + => CoefficientOfThermalExpansion.FromPerDegreeFahrenheit(value.ToDouble(null)); +#endif + + /// + public CoefficientOfThermalExpansion PerKelvin +#if NET7_0_OR_GREATER + => CoefficientOfThermalExpansion.FromPerKelvin(double.CreateChecked(value)); +#else + => CoefficientOfThermalExpansion.FromPerKelvin(value.ToDouble(null)); +#endif + + /// + public CoefficientOfThermalExpansion PpmPerDegreeCelsius +#if NET7_0_OR_GREATER + => CoefficientOfThermalExpansion.FromPpmPerDegreeCelsius(double.CreateChecked(value)); +#else + => CoefficientOfThermalExpansion.FromPpmPerDegreeCelsius(value.ToDouble(null)); +#endif + + /// + public CoefficientOfThermalExpansion PpmPerDegreeFahrenheit +#if NET7_0_OR_GREATER + => CoefficientOfThermalExpansion.FromPpmPerDegreeFahrenheit(double.CreateChecked(value)); +#else + => CoefficientOfThermalExpansion.FromPpmPerDegreeFahrenheit(value.ToDouble(null)); +#endif + + /// + public CoefficientOfThermalExpansion PpmPerKelvin +#if NET7_0_OR_GREATER + => CoefficientOfThermalExpansion.FromPpmPerKelvin(double.CreateChecked(value)); +#else + => CoefficientOfThermalExpansion.FromPpmPerKelvin(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToCompressibilityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToCompressibilityExtensions.g.cs new file mode 100644 index 0000000000..7c46b12b14 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToCompressibilityExtensions.g.cs @@ -0,0 +1,103 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToCompressibility +{ + /// + /// A number to Compressibility Extensions + /// + public static class NumberToCompressibilityExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Compressibility InverseAtmospheres +#if NET7_0_OR_GREATER + => Compressibility.FromInverseAtmospheres(double.CreateChecked(value)); +#else + => Compressibility.FromInverseAtmospheres(value.ToDouble(null)); +#endif + + /// + public Compressibility InverseBars +#if NET7_0_OR_GREATER + => Compressibility.FromInverseBars(double.CreateChecked(value)); +#else + => Compressibility.FromInverseBars(value.ToDouble(null)); +#endif + + /// + public Compressibility InverseKilopascals +#if NET7_0_OR_GREATER + => Compressibility.FromInverseKilopascals(double.CreateChecked(value)); +#else + => Compressibility.FromInverseKilopascals(value.ToDouble(null)); +#endif + + /// + public Compressibility InverseMegapascals +#if NET7_0_OR_GREATER + => Compressibility.FromInverseMegapascals(double.CreateChecked(value)); +#else + => Compressibility.FromInverseMegapascals(value.ToDouble(null)); +#endif + + /// + public Compressibility InverseMillibars +#if NET7_0_OR_GREATER + => Compressibility.FromInverseMillibars(double.CreateChecked(value)); +#else + => Compressibility.FromInverseMillibars(value.ToDouble(null)); +#endif + + /// + public Compressibility InversePascals +#if NET7_0_OR_GREATER + => Compressibility.FromInversePascals(double.CreateChecked(value)); +#else + => Compressibility.FromInversePascals(value.ToDouble(null)); +#endif + + /// + public Compressibility InversePoundsForcePerSquareInch +#if NET7_0_OR_GREATER + => Compressibility.FromInversePoundsForcePerSquareInch(double.CreateChecked(value)); +#else + => Compressibility.FromInversePoundsForcePerSquareInch(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToDensityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToDensityExtensions.g.cs new file mode 100644 index 0000000000..b268407a7f --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToDensityExtensions.g.cs @@ -0,0 +1,495 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToDensity +{ + /// + /// A number to Density Extensions + /// + public static class NumberToDensityExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Density CentigramsPerDeciliter +#if NET7_0_OR_GREATER + => Density.FromCentigramsPerDeciliter(double.CreateChecked(value)); +#else + => Density.FromCentigramsPerDeciliter(value.ToDouble(null)); +#endif + + /// + public Density CentigramsPerLiter +#if NET7_0_OR_GREATER + => Density.FromCentigramsPerLiter(double.CreateChecked(value)); +#else + => Density.FromCentigramsPerLiter(value.ToDouble(null)); +#endif + + /// + public Density CentigramsPerMilliliter +#if NET7_0_OR_GREATER + => Density.FromCentigramsPerMilliliter(double.CreateChecked(value)); +#else + => Density.FromCentigramsPerMilliliter(value.ToDouble(null)); +#endif + + /// + public Density DecigramsPerDeciliter +#if NET7_0_OR_GREATER + => Density.FromDecigramsPerDeciliter(double.CreateChecked(value)); +#else + => Density.FromDecigramsPerDeciliter(value.ToDouble(null)); +#endif + + /// + public Density DecigramsPerLiter +#if NET7_0_OR_GREATER + => Density.FromDecigramsPerLiter(double.CreateChecked(value)); +#else + => Density.FromDecigramsPerLiter(value.ToDouble(null)); +#endif + + /// + public Density DecigramsPerMilliliter +#if NET7_0_OR_GREATER + => Density.FromDecigramsPerMilliliter(double.CreateChecked(value)); +#else + => Density.FromDecigramsPerMilliliter(value.ToDouble(null)); +#endif + + /// + public Density FemtogramsPerDeciliter +#if NET7_0_OR_GREATER + => Density.FromFemtogramsPerDeciliter(double.CreateChecked(value)); +#else + => Density.FromFemtogramsPerDeciliter(value.ToDouble(null)); +#endif + + /// + public Density FemtogramsPerLiter +#if NET7_0_OR_GREATER + => Density.FromFemtogramsPerLiter(double.CreateChecked(value)); +#else + => Density.FromFemtogramsPerLiter(value.ToDouble(null)); +#endif + + /// + public Density FemtogramsPerMilliliter +#if NET7_0_OR_GREATER + => Density.FromFemtogramsPerMilliliter(double.CreateChecked(value)); +#else + => Density.FromFemtogramsPerMilliliter(value.ToDouble(null)); +#endif + + /// + public Density GramsPerCubicCentimeter +#if NET7_0_OR_GREATER + => Density.FromGramsPerCubicCentimeter(double.CreateChecked(value)); +#else + => Density.FromGramsPerCubicCentimeter(value.ToDouble(null)); +#endif + + /// + public Density GramsPerCubicFoot +#if NET7_0_OR_GREATER + => Density.FromGramsPerCubicFoot(double.CreateChecked(value)); +#else + => Density.FromGramsPerCubicFoot(value.ToDouble(null)); +#endif + + /// + public Density GramsPerCubicInch +#if NET7_0_OR_GREATER + => Density.FromGramsPerCubicInch(double.CreateChecked(value)); +#else + => Density.FromGramsPerCubicInch(value.ToDouble(null)); +#endif + + /// + public Density GramsPerCubicMeter +#if NET7_0_OR_GREATER + => Density.FromGramsPerCubicMeter(double.CreateChecked(value)); +#else + => Density.FromGramsPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public Density GramsPerCubicMillimeter +#if NET7_0_OR_GREATER + => Density.FromGramsPerCubicMillimeter(double.CreateChecked(value)); +#else + => Density.FromGramsPerCubicMillimeter(value.ToDouble(null)); +#endif + + /// + public Density GramsPerDeciliter +#if NET7_0_OR_GREATER + => Density.FromGramsPerDeciliter(double.CreateChecked(value)); +#else + => Density.FromGramsPerDeciliter(value.ToDouble(null)); +#endif + + /// + public Density GramsPerLiter +#if NET7_0_OR_GREATER + => Density.FromGramsPerLiter(double.CreateChecked(value)); +#else + => Density.FromGramsPerLiter(value.ToDouble(null)); +#endif + + /// + public Density GramsPerMilliliter +#if NET7_0_OR_GREATER + => Density.FromGramsPerMilliliter(double.CreateChecked(value)); +#else + => Density.FromGramsPerMilliliter(value.ToDouble(null)); +#endif + + /// + public Density KilogramsPerCubicCentimeter +#if NET7_0_OR_GREATER + => Density.FromKilogramsPerCubicCentimeter(double.CreateChecked(value)); +#else + => Density.FromKilogramsPerCubicCentimeter(value.ToDouble(null)); +#endif + + /// + public Density KilogramsPerCubicMeter +#if NET7_0_OR_GREATER + => Density.FromKilogramsPerCubicMeter(double.CreateChecked(value)); +#else + => Density.FromKilogramsPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public Density KilogramsPerCubicMillimeter +#if NET7_0_OR_GREATER + => Density.FromKilogramsPerCubicMillimeter(double.CreateChecked(value)); +#else + => Density.FromKilogramsPerCubicMillimeter(value.ToDouble(null)); +#endif + + /// + public Density KilogramsPerLiter +#if NET7_0_OR_GREATER + => Density.FromKilogramsPerLiter(double.CreateChecked(value)); +#else + => Density.FromKilogramsPerLiter(value.ToDouble(null)); +#endif + + /// + public Density KilopoundsPerCubicFoot +#if NET7_0_OR_GREATER + => Density.FromKilopoundsPerCubicFoot(double.CreateChecked(value)); +#else + => Density.FromKilopoundsPerCubicFoot(value.ToDouble(null)); +#endif + + /// + public Density KilopoundsPerCubicInch +#if NET7_0_OR_GREATER + => Density.FromKilopoundsPerCubicInch(double.CreateChecked(value)); +#else + => Density.FromKilopoundsPerCubicInch(value.ToDouble(null)); +#endif + + /// + public Density KilopoundsPerCubicYard +#if NET7_0_OR_GREATER + => Density.FromKilopoundsPerCubicYard(double.CreateChecked(value)); +#else + => Density.FromKilopoundsPerCubicYard(value.ToDouble(null)); +#endif + + /// + public Density MicrogramsPerCubicMeter +#if NET7_0_OR_GREATER + => Density.FromMicrogramsPerCubicMeter(double.CreateChecked(value)); +#else + => Density.FromMicrogramsPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public Density MicrogramsPerDeciliter +#if NET7_0_OR_GREATER + => Density.FromMicrogramsPerDeciliter(double.CreateChecked(value)); +#else + => Density.FromMicrogramsPerDeciliter(value.ToDouble(null)); +#endif + + /// + public Density MicrogramsPerLiter +#if NET7_0_OR_GREATER + => Density.FromMicrogramsPerLiter(double.CreateChecked(value)); +#else + => Density.FromMicrogramsPerLiter(value.ToDouble(null)); +#endif + + /// + public Density MicrogramsPerMilliliter +#if NET7_0_OR_GREATER + => Density.FromMicrogramsPerMilliliter(double.CreateChecked(value)); +#else + => Density.FromMicrogramsPerMilliliter(value.ToDouble(null)); +#endif + + /// + public Density MilligramsPerCubicMeter +#if NET7_0_OR_GREATER + => Density.FromMilligramsPerCubicMeter(double.CreateChecked(value)); +#else + => Density.FromMilligramsPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public Density MilligramsPerDeciliter +#if NET7_0_OR_GREATER + => Density.FromMilligramsPerDeciliter(double.CreateChecked(value)); +#else + => Density.FromMilligramsPerDeciliter(value.ToDouble(null)); +#endif + + /// + public Density MilligramsPerLiter +#if NET7_0_OR_GREATER + => Density.FromMilligramsPerLiter(double.CreateChecked(value)); +#else + => Density.FromMilligramsPerLiter(value.ToDouble(null)); +#endif + + /// + public Density MilligramsPerMilliliter +#if NET7_0_OR_GREATER + => Density.FromMilligramsPerMilliliter(double.CreateChecked(value)); +#else + => Density.FromMilligramsPerMilliliter(value.ToDouble(null)); +#endif + + /// + public Density NanogramsPerDeciliter +#if NET7_0_OR_GREATER + => Density.FromNanogramsPerDeciliter(double.CreateChecked(value)); +#else + => Density.FromNanogramsPerDeciliter(value.ToDouble(null)); +#endif + + /// + public Density NanogramsPerLiter +#if NET7_0_OR_GREATER + => Density.FromNanogramsPerLiter(double.CreateChecked(value)); +#else + => Density.FromNanogramsPerLiter(value.ToDouble(null)); +#endif + + /// + public Density NanogramsPerMilliliter +#if NET7_0_OR_GREATER + => Density.FromNanogramsPerMilliliter(double.CreateChecked(value)); +#else + => Density.FromNanogramsPerMilliliter(value.ToDouble(null)); +#endif + + /// + public Density PicogramsPerDeciliter +#if NET7_0_OR_GREATER + => Density.FromPicogramsPerDeciliter(double.CreateChecked(value)); +#else + => Density.FromPicogramsPerDeciliter(value.ToDouble(null)); +#endif + + /// + public Density PicogramsPerLiter +#if NET7_0_OR_GREATER + => Density.FromPicogramsPerLiter(double.CreateChecked(value)); +#else + => Density.FromPicogramsPerLiter(value.ToDouble(null)); +#endif + + /// + public Density PicogramsPerMilliliter +#if NET7_0_OR_GREATER + => Density.FromPicogramsPerMilliliter(double.CreateChecked(value)); +#else + => Density.FromPicogramsPerMilliliter(value.ToDouble(null)); +#endif + + /// + public Density PoundsPerCubicCentimeter +#if NET7_0_OR_GREATER + => Density.FromPoundsPerCubicCentimeter(double.CreateChecked(value)); +#else + => Density.FromPoundsPerCubicCentimeter(value.ToDouble(null)); +#endif + + /// + public Density PoundsPerCubicFoot +#if NET7_0_OR_GREATER + => Density.FromPoundsPerCubicFoot(double.CreateChecked(value)); +#else + => Density.FromPoundsPerCubicFoot(value.ToDouble(null)); +#endif + + /// + public Density PoundsPerCubicInch +#if NET7_0_OR_GREATER + => Density.FromPoundsPerCubicInch(double.CreateChecked(value)); +#else + => Density.FromPoundsPerCubicInch(value.ToDouble(null)); +#endif + + /// + public Density PoundsPerCubicMeter +#if NET7_0_OR_GREATER + => Density.FromPoundsPerCubicMeter(double.CreateChecked(value)); +#else + => Density.FromPoundsPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public Density PoundsPerCubicMillimeter +#if NET7_0_OR_GREATER + => Density.FromPoundsPerCubicMillimeter(double.CreateChecked(value)); +#else + => Density.FromPoundsPerCubicMillimeter(value.ToDouble(null)); +#endif + + /// + public Density PoundsPerCubicYard +#if NET7_0_OR_GREATER + => Density.FromPoundsPerCubicYard(double.CreateChecked(value)); +#else + => Density.FromPoundsPerCubicYard(value.ToDouble(null)); +#endif + + /// + public Density PoundsPerImperialGallon +#if NET7_0_OR_GREATER + => Density.FromPoundsPerImperialGallon(double.CreateChecked(value)); +#else + => Density.FromPoundsPerImperialGallon(value.ToDouble(null)); +#endif + + /// + public Density PoundsPerUSGallon +#if NET7_0_OR_GREATER + => Density.FromPoundsPerUSGallon(double.CreateChecked(value)); +#else + => Density.FromPoundsPerUSGallon(value.ToDouble(null)); +#endif + + /// + public Density SlugsPerCubicCentimeter +#if NET7_0_OR_GREATER + => Density.FromSlugsPerCubicCentimeter(double.CreateChecked(value)); +#else + => Density.FromSlugsPerCubicCentimeter(value.ToDouble(null)); +#endif + + /// + public Density SlugsPerCubicFoot +#if NET7_0_OR_GREATER + => Density.FromSlugsPerCubicFoot(double.CreateChecked(value)); +#else + => Density.FromSlugsPerCubicFoot(value.ToDouble(null)); +#endif + + /// + public Density SlugsPerCubicInch +#if NET7_0_OR_GREATER + => Density.FromSlugsPerCubicInch(double.CreateChecked(value)); +#else + => Density.FromSlugsPerCubicInch(value.ToDouble(null)); +#endif + + /// + public Density SlugsPerCubicMeter +#if NET7_0_OR_GREATER + => Density.FromSlugsPerCubicMeter(double.CreateChecked(value)); +#else + => Density.FromSlugsPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public Density SlugsPerCubicMillimeter +#if NET7_0_OR_GREATER + => Density.FromSlugsPerCubicMillimeter(double.CreateChecked(value)); +#else + => Density.FromSlugsPerCubicMillimeter(value.ToDouble(null)); +#endif + + /// + public Density TonnesPerCubicCentimeter +#if NET7_0_OR_GREATER + => Density.FromTonnesPerCubicCentimeter(double.CreateChecked(value)); +#else + => Density.FromTonnesPerCubicCentimeter(value.ToDouble(null)); +#endif + + /// + public Density TonnesPerCubicFoot +#if NET7_0_OR_GREATER + => Density.FromTonnesPerCubicFoot(double.CreateChecked(value)); +#else + => Density.FromTonnesPerCubicFoot(value.ToDouble(null)); +#endif + + /// + public Density TonnesPerCubicInch +#if NET7_0_OR_GREATER + => Density.FromTonnesPerCubicInch(double.CreateChecked(value)); +#else + => Density.FromTonnesPerCubicInch(value.ToDouble(null)); +#endif + + /// + public Density TonnesPerCubicMeter +#if NET7_0_OR_GREATER + => Density.FromTonnesPerCubicMeter(double.CreateChecked(value)); +#else + => Density.FromTonnesPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public Density TonnesPerCubicMillimeter +#if NET7_0_OR_GREATER + => Density.FromTonnesPerCubicMillimeter(double.CreateChecked(value)); +#else + => Density.FromTonnesPerCubicMillimeter(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToDoseAreaProductExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToDoseAreaProductExtensions.g.cs new file mode 100644 index 0000000000..91326ba09f --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToDoseAreaProductExtensions.g.cs @@ -0,0 +1,247 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToDoseAreaProduct +{ + /// + /// A number to DoseAreaProduct Extensions + /// + public static class NumberToDoseAreaProductExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public DoseAreaProduct CentigraySquareCentimeters +#if NET7_0_OR_GREATER + => DoseAreaProduct.FromCentigraySquareCentimeters(double.CreateChecked(value)); +#else + => DoseAreaProduct.FromCentigraySquareCentimeters(value.ToDouble(null)); +#endif + + /// + public DoseAreaProduct CentigraySquareDecimeters +#if NET7_0_OR_GREATER + => DoseAreaProduct.FromCentigraySquareDecimeters(double.CreateChecked(value)); +#else + => DoseAreaProduct.FromCentigraySquareDecimeters(value.ToDouble(null)); +#endif + + /// + public DoseAreaProduct CentigraySquareMeters +#if NET7_0_OR_GREATER + => DoseAreaProduct.FromCentigraySquareMeters(double.CreateChecked(value)); +#else + => DoseAreaProduct.FromCentigraySquareMeters(value.ToDouble(null)); +#endif + + /// + public DoseAreaProduct CentigraySquareMicrometers +#if NET7_0_OR_GREATER + => DoseAreaProduct.FromCentigraySquareMicrometers(double.CreateChecked(value)); +#else + => DoseAreaProduct.FromCentigraySquareMicrometers(value.ToDouble(null)); +#endif + + /// + public DoseAreaProduct CentigraySquareMillimeters +#if NET7_0_OR_GREATER + => DoseAreaProduct.FromCentigraySquareMillimeters(double.CreateChecked(value)); +#else + => DoseAreaProduct.FromCentigraySquareMillimeters(value.ToDouble(null)); +#endif + + /// + public DoseAreaProduct DecigraySquareCentimeters +#if NET7_0_OR_GREATER + => DoseAreaProduct.FromDecigraySquareCentimeters(double.CreateChecked(value)); +#else + => DoseAreaProduct.FromDecigraySquareCentimeters(value.ToDouble(null)); +#endif + + /// + public DoseAreaProduct DecigraySquareDecimeters +#if NET7_0_OR_GREATER + => DoseAreaProduct.FromDecigraySquareDecimeters(double.CreateChecked(value)); +#else + => DoseAreaProduct.FromDecigraySquareDecimeters(value.ToDouble(null)); +#endif + + /// + public DoseAreaProduct DecigraySquareMeters +#if NET7_0_OR_GREATER + => DoseAreaProduct.FromDecigraySquareMeters(double.CreateChecked(value)); +#else + => DoseAreaProduct.FromDecigraySquareMeters(value.ToDouble(null)); +#endif + + /// + public DoseAreaProduct DecigraySquareMicrometers +#if NET7_0_OR_GREATER + => DoseAreaProduct.FromDecigraySquareMicrometers(double.CreateChecked(value)); +#else + => DoseAreaProduct.FromDecigraySquareMicrometers(value.ToDouble(null)); +#endif + + /// + public DoseAreaProduct DecigraySquareMillimeters +#if NET7_0_OR_GREATER + => DoseAreaProduct.FromDecigraySquareMillimeters(double.CreateChecked(value)); +#else + => DoseAreaProduct.FromDecigraySquareMillimeters(value.ToDouble(null)); +#endif + + /// + public DoseAreaProduct GraySquareCentimeters +#if NET7_0_OR_GREATER + => DoseAreaProduct.FromGraySquareCentimeters(double.CreateChecked(value)); +#else + => DoseAreaProduct.FromGraySquareCentimeters(value.ToDouble(null)); +#endif + + /// + public DoseAreaProduct GraySquareDecimeters +#if NET7_0_OR_GREATER + => DoseAreaProduct.FromGraySquareDecimeters(double.CreateChecked(value)); +#else + => DoseAreaProduct.FromGraySquareDecimeters(value.ToDouble(null)); +#endif + + /// + public DoseAreaProduct GraySquareMeters +#if NET7_0_OR_GREATER + => DoseAreaProduct.FromGraySquareMeters(double.CreateChecked(value)); +#else + => DoseAreaProduct.FromGraySquareMeters(value.ToDouble(null)); +#endif + + /// + public DoseAreaProduct GraySquareMicrometers +#if NET7_0_OR_GREATER + => DoseAreaProduct.FromGraySquareMicrometers(double.CreateChecked(value)); +#else + => DoseAreaProduct.FromGraySquareMicrometers(value.ToDouble(null)); +#endif + + /// + public DoseAreaProduct GraySquareMillimeters +#if NET7_0_OR_GREATER + => DoseAreaProduct.FromGraySquareMillimeters(double.CreateChecked(value)); +#else + => DoseAreaProduct.FromGraySquareMillimeters(value.ToDouble(null)); +#endif + + /// + public DoseAreaProduct MicrograySquareCentimeters +#if NET7_0_OR_GREATER + => DoseAreaProduct.FromMicrograySquareCentimeters(double.CreateChecked(value)); +#else + => DoseAreaProduct.FromMicrograySquareCentimeters(value.ToDouble(null)); +#endif + + /// + public DoseAreaProduct MicrograySquareDecimeters +#if NET7_0_OR_GREATER + => DoseAreaProduct.FromMicrograySquareDecimeters(double.CreateChecked(value)); +#else + => DoseAreaProduct.FromMicrograySquareDecimeters(value.ToDouble(null)); +#endif + + /// + public DoseAreaProduct MicrograySquareMeters +#if NET7_0_OR_GREATER + => DoseAreaProduct.FromMicrograySquareMeters(double.CreateChecked(value)); +#else + => DoseAreaProduct.FromMicrograySquareMeters(value.ToDouble(null)); +#endif + + /// + public DoseAreaProduct MicrograySquareMicrometers +#if NET7_0_OR_GREATER + => DoseAreaProduct.FromMicrograySquareMicrometers(double.CreateChecked(value)); +#else + => DoseAreaProduct.FromMicrograySquareMicrometers(value.ToDouble(null)); +#endif + + /// + public DoseAreaProduct MicrograySquareMillimeters +#if NET7_0_OR_GREATER + => DoseAreaProduct.FromMicrograySquareMillimeters(double.CreateChecked(value)); +#else + => DoseAreaProduct.FromMicrograySquareMillimeters(value.ToDouble(null)); +#endif + + /// + public DoseAreaProduct MilligraySquareCentimeters +#if NET7_0_OR_GREATER + => DoseAreaProduct.FromMilligraySquareCentimeters(double.CreateChecked(value)); +#else + => DoseAreaProduct.FromMilligraySquareCentimeters(value.ToDouble(null)); +#endif + + /// + public DoseAreaProduct MilligraySquareDecimeters +#if NET7_0_OR_GREATER + => DoseAreaProduct.FromMilligraySquareDecimeters(double.CreateChecked(value)); +#else + => DoseAreaProduct.FromMilligraySquareDecimeters(value.ToDouble(null)); +#endif + + /// + public DoseAreaProduct MilligraySquareMeters +#if NET7_0_OR_GREATER + => DoseAreaProduct.FromMilligraySquareMeters(double.CreateChecked(value)); +#else + => DoseAreaProduct.FromMilligraySquareMeters(value.ToDouble(null)); +#endif + + /// + public DoseAreaProduct MilligraySquareMicrometers +#if NET7_0_OR_GREATER + => DoseAreaProduct.FromMilligraySquareMicrometers(double.CreateChecked(value)); +#else + => DoseAreaProduct.FromMilligraySquareMicrometers(value.ToDouble(null)); +#endif + + /// + public DoseAreaProduct MilligraySquareMillimeters +#if NET7_0_OR_GREATER + => DoseAreaProduct.FromMilligraySquareMillimeters(double.CreateChecked(value)); +#else + => DoseAreaProduct.FromMilligraySquareMillimeters(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToDurationExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToDurationExtensions.g.cs new file mode 100644 index 0000000000..3f4269f2cb --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToDurationExtensions.g.cs @@ -0,0 +1,151 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToDuration +{ + /// + /// A number to Duration Extensions + /// + public static class NumberToDurationExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Duration Days +#if NET7_0_OR_GREATER + => Duration.FromDays(double.CreateChecked(value)); +#else + => Duration.FromDays(value.ToDouble(null)); +#endif + + /// + public Duration Hours +#if NET7_0_OR_GREATER + => Duration.FromHours(double.CreateChecked(value)); +#else + => Duration.FromHours(value.ToDouble(null)); +#endif + + /// + public Duration JulianYears +#if NET7_0_OR_GREATER + => Duration.FromJulianYears(double.CreateChecked(value)); +#else + => Duration.FromJulianYears(value.ToDouble(null)); +#endif + + /// + public Duration Microseconds +#if NET7_0_OR_GREATER + => Duration.FromMicroseconds(double.CreateChecked(value)); +#else + => Duration.FromMicroseconds(value.ToDouble(null)); +#endif + + /// + public Duration Milliseconds +#if NET7_0_OR_GREATER + => Duration.FromMilliseconds(double.CreateChecked(value)); +#else + => Duration.FromMilliseconds(value.ToDouble(null)); +#endif + + /// + public Duration Minutes +#if NET7_0_OR_GREATER + => Duration.FromMinutes(double.CreateChecked(value)); +#else + => Duration.FromMinutes(value.ToDouble(null)); +#endif + + /// + public Duration Months30 +#if NET7_0_OR_GREATER + => Duration.FromMonths30(double.CreateChecked(value)); +#else + => Duration.FromMonths30(value.ToDouble(null)); +#endif + + /// + public Duration Nanoseconds +#if NET7_0_OR_GREATER + => Duration.FromNanoseconds(double.CreateChecked(value)); +#else + => Duration.FromNanoseconds(value.ToDouble(null)); +#endif + + /// + public Duration Picoseconds +#if NET7_0_OR_GREATER + => Duration.FromPicoseconds(double.CreateChecked(value)); +#else + => Duration.FromPicoseconds(value.ToDouble(null)); +#endif + + /// + public Duration Seconds +#if NET7_0_OR_GREATER + => Duration.FromSeconds(double.CreateChecked(value)); +#else + => Duration.FromSeconds(value.ToDouble(null)); +#endif + + /// + public Duration Sols +#if NET7_0_OR_GREATER + => Duration.FromSols(double.CreateChecked(value)); +#else + => Duration.FromSols(value.ToDouble(null)); +#endif + + /// + public Duration Weeks +#if NET7_0_OR_GREATER + => Duration.FromWeeks(double.CreateChecked(value)); +#else + => Duration.FromWeeks(value.ToDouble(null)); +#endif + + /// + public Duration Years365 +#if NET7_0_OR_GREATER + => Duration.FromYears365(double.CreateChecked(value)); +#else + => Duration.FromYears365(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToDynamicViscosityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToDynamicViscosityExtensions.g.cs new file mode 100644 index 0000000000..7cf7925aff --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToDynamicViscosityExtensions.g.cs @@ -0,0 +1,127 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToDynamicViscosity +{ + /// + /// A number to DynamicViscosity Extensions + /// + public static class NumberToDynamicViscosityExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public DynamicViscosity Centipoise +#if NET7_0_OR_GREATER + => DynamicViscosity.FromCentipoise(double.CreateChecked(value)); +#else + => DynamicViscosity.FromCentipoise(value.ToDouble(null)); +#endif + + /// + public DynamicViscosity MicropascalSeconds +#if NET7_0_OR_GREATER + => DynamicViscosity.FromMicropascalSeconds(double.CreateChecked(value)); +#else + => DynamicViscosity.FromMicropascalSeconds(value.ToDouble(null)); +#endif + + /// + public DynamicViscosity MillipascalSeconds +#if NET7_0_OR_GREATER + => DynamicViscosity.FromMillipascalSeconds(double.CreateChecked(value)); +#else + => DynamicViscosity.FromMillipascalSeconds(value.ToDouble(null)); +#endif + + /// + public DynamicViscosity NewtonSecondsPerMeterSquared +#if NET7_0_OR_GREATER + => DynamicViscosity.FromNewtonSecondsPerMeterSquared(double.CreateChecked(value)); +#else + => DynamicViscosity.FromNewtonSecondsPerMeterSquared(value.ToDouble(null)); +#endif + + /// + public DynamicViscosity PascalSeconds +#if NET7_0_OR_GREATER + => DynamicViscosity.FromPascalSeconds(double.CreateChecked(value)); +#else + => DynamicViscosity.FromPascalSeconds(value.ToDouble(null)); +#endif + + /// + public DynamicViscosity Poise +#if NET7_0_OR_GREATER + => DynamicViscosity.FromPoise(double.CreateChecked(value)); +#else + => DynamicViscosity.FromPoise(value.ToDouble(null)); +#endif + + /// + public DynamicViscosity PoundsForceSecondPerSquareFoot +#if NET7_0_OR_GREATER + => DynamicViscosity.FromPoundsForceSecondPerSquareFoot(double.CreateChecked(value)); +#else + => DynamicViscosity.FromPoundsForceSecondPerSquareFoot(value.ToDouble(null)); +#endif + + /// + public DynamicViscosity PoundsForceSecondPerSquareInch +#if NET7_0_OR_GREATER + => DynamicViscosity.FromPoundsForceSecondPerSquareInch(double.CreateChecked(value)); +#else + => DynamicViscosity.FromPoundsForceSecondPerSquareInch(value.ToDouble(null)); +#endif + + /// + public DynamicViscosity PoundsPerFootSecond +#if NET7_0_OR_GREATER + => DynamicViscosity.FromPoundsPerFootSecond(double.CreateChecked(value)); +#else + => DynamicViscosity.FromPoundsPerFootSecond(value.ToDouble(null)); +#endif + + /// + public DynamicViscosity Reyns +#if NET7_0_OR_GREATER + => DynamicViscosity.FromReyns(double.CreateChecked(value)); +#else + => DynamicViscosity.FromReyns(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricAdmittanceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricAdmittanceExtensions.g.cs new file mode 100644 index 0000000000..b4f5d9e7e4 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricAdmittanceExtensions.g.cs @@ -0,0 +1,192 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToElectricAdmittance +{ + /// + /// A number to ElectricAdmittance Extensions + /// + [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")] + public static class NumberToElectricAdmittanceExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")] + public ElectricAdmittance Gigamhos +#if NET7_0_OR_GREATER + => ElectricAdmittance.FromGigamhos(double.CreateChecked(value)); +#else + => ElectricAdmittance.FromGigamhos(value.ToDouble(null)); +#endif + + /// + [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")] + public ElectricAdmittance Gigasiemens +#if NET7_0_OR_GREATER + => ElectricAdmittance.FromGigasiemens(double.CreateChecked(value)); +#else + => ElectricAdmittance.FromGigasiemens(value.ToDouble(null)); +#endif + + /// + [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")] + public ElectricAdmittance Kilomhos +#if NET7_0_OR_GREATER + => ElectricAdmittance.FromKilomhos(double.CreateChecked(value)); +#else + => ElectricAdmittance.FromKilomhos(value.ToDouble(null)); +#endif + + /// + [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")] + public ElectricAdmittance Kilosiemens +#if NET7_0_OR_GREATER + => ElectricAdmittance.FromKilosiemens(double.CreateChecked(value)); +#else + => ElectricAdmittance.FromKilosiemens(value.ToDouble(null)); +#endif + + /// + [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")] + public ElectricAdmittance Megamhos +#if NET7_0_OR_GREATER + => ElectricAdmittance.FromMegamhos(double.CreateChecked(value)); +#else + => ElectricAdmittance.FromMegamhos(value.ToDouble(null)); +#endif + + /// + [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")] + public ElectricAdmittance Megasiemens +#if NET7_0_OR_GREATER + => ElectricAdmittance.FromMegasiemens(double.CreateChecked(value)); +#else + => ElectricAdmittance.FromMegasiemens(value.ToDouble(null)); +#endif + + /// + [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")] + public ElectricAdmittance Mhos +#if NET7_0_OR_GREATER + => ElectricAdmittance.FromMhos(double.CreateChecked(value)); +#else + => ElectricAdmittance.FromMhos(value.ToDouble(null)); +#endif + + /// + [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")] + public ElectricAdmittance Micromhos +#if NET7_0_OR_GREATER + => ElectricAdmittance.FromMicromhos(double.CreateChecked(value)); +#else + => ElectricAdmittance.FromMicromhos(value.ToDouble(null)); +#endif + + /// + [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")] + public ElectricAdmittance Microsiemens +#if NET7_0_OR_GREATER + => ElectricAdmittance.FromMicrosiemens(double.CreateChecked(value)); +#else + => ElectricAdmittance.FromMicrosiemens(value.ToDouble(null)); +#endif + + /// + [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")] + public ElectricAdmittance Millimhos +#if NET7_0_OR_GREATER + => ElectricAdmittance.FromMillimhos(double.CreateChecked(value)); +#else + => ElectricAdmittance.FromMillimhos(value.ToDouble(null)); +#endif + + /// + [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")] + public ElectricAdmittance Millisiemens +#if NET7_0_OR_GREATER + => ElectricAdmittance.FromMillisiemens(double.CreateChecked(value)); +#else + => ElectricAdmittance.FromMillisiemens(value.ToDouble(null)); +#endif + + /// + [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")] + public ElectricAdmittance Nanomhos +#if NET7_0_OR_GREATER + => ElectricAdmittance.FromNanomhos(double.CreateChecked(value)); +#else + => ElectricAdmittance.FromNanomhos(value.ToDouble(null)); +#endif + + /// + [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")] + public ElectricAdmittance Nanosiemens +#if NET7_0_OR_GREATER + => ElectricAdmittance.FromNanosiemens(double.CreateChecked(value)); +#else + => ElectricAdmittance.FromNanosiemens(value.ToDouble(null)); +#endif + + /// + [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")] + public ElectricAdmittance Siemens +#if NET7_0_OR_GREATER + => ElectricAdmittance.FromSiemens(double.CreateChecked(value)); +#else + => ElectricAdmittance.FromSiemens(value.ToDouble(null)); +#endif + + /// + [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")] + public ElectricAdmittance Teramhos +#if NET7_0_OR_GREATER + => ElectricAdmittance.FromTeramhos(double.CreateChecked(value)); +#else + => ElectricAdmittance.FromTeramhos(value.ToDouble(null)); +#endif + + /// + [Obsolete("Admittance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricConductance or ElectricSusceptance instead.")] + public ElectricAdmittance Terasiemens +#if NET7_0_OR_GREATER + => ElectricAdmittance.FromTerasiemens(double.CreateChecked(value)); +#else + => ElectricAdmittance.FromTerasiemens(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricApparentEnergyExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricApparentEnergyExtensions.g.cs new file mode 100644 index 0000000000..4f2e2c6322 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricApparentEnergyExtensions.g.cs @@ -0,0 +1,71 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToElectricApparentEnergy +{ + /// + /// A number to ElectricApparentEnergy Extensions + /// + public static class NumberToElectricApparentEnergyExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public ElectricApparentEnergy KilovoltampereHours +#if NET7_0_OR_GREATER + => ElectricApparentEnergy.FromKilovoltampereHours(double.CreateChecked(value)); +#else + => ElectricApparentEnergy.FromKilovoltampereHours(value.ToDouble(null)); +#endif + + /// + public ElectricApparentEnergy MegavoltampereHours +#if NET7_0_OR_GREATER + => ElectricApparentEnergy.FromMegavoltampereHours(double.CreateChecked(value)); +#else + => ElectricApparentEnergy.FromMegavoltampereHours(value.ToDouble(null)); +#endif + + /// + public ElectricApparentEnergy VoltampereHours +#if NET7_0_OR_GREATER + => ElectricApparentEnergy.FromVoltampereHours(double.CreateChecked(value)); +#else + => ElectricApparentEnergy.FromVoltampereHours(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricApparentPowerExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricApparentPowerExtensions.g.cs new file mode 100644 index 0000000000..ea53ccfbd9 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricApparentPowerExtensions.g.cs @@ -0,0 +1,95 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToElectricApparentPower +{ + /// + /// A number to ElectricApparentPower Extensions + /// + public static class NumberToElectricApparentPowerExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public ElectricApparentPower Gigavoltamperes +#if NET7_0_OR_GREATER + => ElectricApparentPower.FromGigavoltamperes(double.CreateChecked(value)); +#else + => ElectricApparentPower.FromGigavoltamperes(value.ToDouble(null)); +#endif + + /// + public ElectricApparentPower Kilovoltamperes +#if NET7_0_OR_GREATER + => ElectricApparentPower.FromKilovoltamperes(double.CreateChecked(value)); +#else + => ElectricApparentPower.FromKilovoltamperes(value.ToDouble(null)); +#endif + + /// + public ElectricApparentPower Megavoltamperes +#if NET7_0_OR_GREATER + => ElectricApparentPower.FromMegavoltamperes(double.CreateChecked(value)); +#else + => ElectricApparentPower.FromMegavoltamperes(value.ToDouble(null)); +#endif + + /// + public ElectricApparentPower Microvoltamperes +#if NET7_0_OR_GREATER + => ElectricApparentPower.FromMicrovoltamperes(double.CreateChecked(value)); +#else + => ElectricApparentPower.FromMicrovoltamperes(value.ToDouble(null)); +#endif + + /// + public ElectricApparentPower Millivoltamperes +#if NET7_0_OR_GREATER + => ElectricApparentPower.FromMillivoltamperes(double.CreateChecked(value)); +#else + => ElectricApparentPower.FromMillivoltamperes(value.ToDouble(null)); +#endif + + /// + public ElectricApparentPower Voltamperes +#if NET7_0_OR_GREATER + => ElectricApparentPower.FromVoltamperes(double.CreateChecked(value)); +#else + => ElectricApparentPower.FromVoltamperes(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricCapacitanceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricCapacitanceExtensions.g.cs new file mode 100644 index 0000000000..31cb55f95e --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricCapacitanceExtensions.g.cs @@ -0,0 +1,103 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToElectricCapacitance +{ + /// + /// A number to ElectricCapacitance Extensions + /// + public static class NumberToElectricCapacitanceExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public ElectricCapacitance Farads +#if NET7_0_OR_GREATER + => ElectricCapacitance.FromFarads(double.CreateChecked(value)); +#else + => ElectricCapacitance.FromFarads(value.ToDouble(null)); +#endif + + /// + public ElectricCapacitance Kilofarads +#if NET7_0_OR_GREATER + => ElectricCapacitance.FromKilofarads(double.CreateChecked(value)); +#else + => ElectricCapacitance.FromKilofarads(value.ToDouble(null)); +#endif + + /// + public ElectricCapacitance Megafarads +#if NET7_0_OR_GREATER + => ElectricCapacitance.FromMegafarads(double.CreateChecked(value)); +#else + => ElectricCapacitance.FromMegafarads(value.ToDouble(null)); +#endif + + /// + public ElectricCapacitance Microfarads +#if NET7_0_OR_GREATER + => ElectricCapacitance.FromMicrofarads(double.CreateChecked(value)); +#else + => ElectricCapacitance.FromMicrofarads(value.ToDouble(null)); +#endif + + /// + public ElectricCapacitance Millifarads +#if NET7_0_OR_GREATER + => ElectricCapacitance.FromMillifarads(double.CreateChecked(value)); +#else + => ElectricCapacitance.FromMillifarads(value.ToDouble(null)); +#endif + + /// + public ElectricCapacitance Nanofarads +#if NET7_0_OR_GREATER + => ElectricCapacitance.FromNanofarads(double.CreateChecked(value)); +#else + => ElectricCapacitance.FromNanofarads(value.ToDouble(null)); +#endif + + /// + public ElectricCapacitance Picofarads +#if NET7_0_OR_GREATER + => ElectricCapacitance.FromPicofarads(double.CreateChecked(value)); +#else + => ElectricCapacitance.FromPicofarads(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricChargeDensityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricChargeDensityExtensions.g.cs new file mode 100644 index 0000000000..3fd2e2b553 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricChargeDensityExtensions.g.cs @@ -0,0 +1,55 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToElectricChargeDensity +{ + /// + /// A number to ElectricChargeDensity Extensions + /// + public static class NumberToElectricChargeDensityExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public ElectricChargeDensity CoulombsPerCubicMeter +#if NET7_0_OR_GREATER + => ElectricChargeDensity.FromCoulombsPerCubicMeter(double.CreateChecked(value)); +#else + => ElectricChargeDensity.FromCoulombsPerCubicMeter(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricChargeExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricChargeExtensions.g.cs new file mode 100644 index 0000000000..0c6dbc79e1 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricChargeExtensions.g.cs @@ -0,0 +1,135 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToElectricCharge +{ + /// + /// A number to ElectricCharge Extensions + /// + public static class NumberToElectricChargeExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public ElectricCharge AmpereHours +#if NET7_0_OR_GREATER + => ElectricCharge.FromAmpereHours(double.CreateChecked(value)); +#else + => ElectricCharge.FromAmpereHours(value.ToDouble(null)); +#endif + + /// + public ElectricCharge Coulombs +#if NET7_0_OR_GREATER + => ElectricCharge.FromCoulombs(double.CreateChecked(value)); +#else + => ElectricCharge.FromCoulombs(value.ToDouble(null)); +#endif + + /// + public ElectricCharge KiloampereHours +#if NET7_0_OR_GREATER + => ElectricCharge.FromKiloampereHours(double.CreateChecked(value)); +#else + => ElectricCharge.FromKiloampereHours(value.ToDouble(null)); +#endif + + /// + public ElectricCharge Kilocoulombs +#if NET7_0_OR_GREATER + => ElectricCharge.FromKilocoulombs(double.CreateChecked(value)); +#else + => ElectricCharge.FromKilocoulombs(value.ToDouble(null)); +#endif + + /// + public ElectricCharge MegaampereHours +#if NET7_0_OR_GREATER + => ElectricCharge.FromMegaampereHours(double.CreateChecked(value)); +#else + => ElectricCharge.FromMegaampereHours(value.ToDouble(null)); +#endif + + /// + public ElectricCharge Megacoulombs +#if NET7_0_OR_GREATER + => ElectricCharge.FromMegacoulombs(double.CreateChecked(value)); +#else + => ElectricCharge.FromMegacoulombs(value.ToDouble(null)); +#endif + + /// + public ElectricCharge Microcoulombs +#if NET7_0_OR_GREATER + => ElectricCharge.FromMicrocoulombs(double.CreateChecked(value)); +#else + => ElectricCharge.FromMicrocoulombs(value.ToDouble(null)); +#endif + + /// + public ElectricCharge MilliampereHours +#if NET7_0_OR_GREATER + => ElectricCharge.FromMilliampereHours(double.CreateChecked(value)); +#else + => ElectricCharge.FromMilliampereHours(value.ToDouble(null)); +#endif + + /// + public ElectricCharge Millicoulombs +#if NET7_0_OR_GREATER + => ElectricCharge.FromMillicoulombs(double.CreateChecked(value)); +#else + => ElectricCharge.FromMillicoulombs(value.ToDouble(null)); +#endif + + /// + public ElectricCharge Nanocoulombs +#if NET7_0_OR_GREATER + => ElectricCharge.FromNanocoulombs(double.CreateChecked(value)); +#else + => ElectricCharge.FromNanocoulombs(value.ToDouble(null)); +#endif + + /// + public ElectricCharge Picocoulombs +#if NET7_0_OR_GREATER + => ElectricCharge.FromPicocoulombs(double.CreateChecked(value)); +#else + => ElectricCharge.FromPicocoulombs(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricConductanceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricConductanceExtensions.g.cs new file mode 100644 index 0000000000..601f3ced2e --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricConductanceExtensions.g.cs @@ -0,0 +1,175 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToElectricConductance +{ + /// + /// A number to ElectricConductance Extensions + /// + public static class NumberToElectricConductanceExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public ElectricConductance Gigamhos +#if NET7_0_OR_GREATER + => ElectricConductance.FromGigamhos(double.CreateChecked(value)); +#else + => ElectricConductance.FromGigamhos(value.ToDouble(null)); +#endif + + /// + public ElectricConductance Gigasiemens +#if NET7_0_OR_GREATER + => ElectricConductance.FromGigasiemens(double.CreateChecked(value)); +#else + => ElectricConductance.FromGigasiemens(value.ToDouble(null)); +#endif + + /// + public ElectricConductance Kilomhos +#if NET7_0_OR_GREATER + => ElectricConductance.FromKilomhos(double.CreateChecked(value)); +#else + => ElectricConductance.FromKilomhos(value.ToDouble(null)); +#endif + + /// + public ElectricConductance Kilosiemens +#if NET7_0_OR_GREATER + => ElectricConductance.FromKilosiemens(double.CreateChecked(value)); +#else + => ElectricConductance.FromKilosiemens(value.ToDouble(null)); +#endif + + /// + public ElectricConductance Megamhos +#if NET7_0_OR_GREATER + => ElectricConductance.FromMegamhos(double.CreateChecked(value)); +#else + => ElectricConductance.FromMegamhos(value.ToDouble(null)); +#endif + + /// + public ElectricConductance Megasiemens +#if NET7_0_OR_GREATER + => ElectricConductance.FromMegasiemens(double.CreateChecked(value)); +#else + => ElectricConductance.FromMegasiemens(value.ToDouble(null)); +#endif + + /// + public ElectricConductance Mhos +#if NET7_0_OR_GREATER + => ElectricConductance.FromMhos(double.CreateChecked(value)); +#else + => ElectricConductance.FromMhos(value.ToDouble(null)); +#endif + + /// + public ElectricConductance Micromhos +#if NET7_0_OR_GREATER + => ElectricConductance.FromMicromhos(double.CreateChecked(value)); +#else + => ElectricConductance.FromMicromhos(value.ToDouble(null)); +#endif + + /// + public ElectricConductance Microsiemens +#if NET7_0_OR_GREATER + => ElectricConductance.FromMicrosiemens(double.CreateChecked(value)); +#else + => ElectricConductance.FromMicrosiemens(value.ToDouble(null)); +#endif + + /// + public ElectricConductance Millimhos +#if NET7_0_OR_GREATER + => ElectricConductance.FromMillimhos(double.CreateChecked(value)); +#else + => ElectricConductance.FromMillimhos(value.ToDouble(null)); +#endif + + /// + public ElectricConductance Millisiemens +#if NET7_0_OR_GREATER + => ElectricConductance.FromMillisiemens(double.CreateChecked(value)); +#else + => ElectricConductance.FromMillisiemens(value.ToDouble(null)); +#endif + + /// + public ElectricConductance Nanomhos +#if NET7_0_OR_GREATER + => ElectricConductance.FromNanomhos(double.CreateChecked(value)); +#else + => ElectricConductance.FromNanomhos(value.ToDouble(null)); +#endif + + /// + public ElectricConductance Nanosiemens +#if NET7_0_OR_GREATER + => ElectricConductance.FromNanosiemens(double.CreateChecked(value)); +#else + => ElectricConductance.FromNanosiemens(value.ToDouble(null)); +#endif + + /// + public ElectricConductance Siemens +#if NET7_0_OR_GREATER + => ElectricConductance.FromSiemens(double.CreateChecked(value)); +#else + => ElectricConductance.FromSiemens(value.ToDouble(null)); +#endif + + /// + public ElectricConductance Teramhos +#if NET7_0_OR_GREATER + => ElectricConductance.FromTeramhos(double.CreateChecked(value)); +#else + => ElectricConductance.FromTeramhos(value.ToDouble(null)); +#endif + + /// + public ElectricConductance Terasiemens +#if NET7_0_OR_GREATER + => ElectricConductance.FromTerasiemens(double.CreateChecked(value)); +#else + => ElectricConductance.FromTerasiemens(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricConductivityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricConductivityExtensions.g.cs new file mode 100644 index 0000000000..771194c184 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricConductivityExtensions.g.cs @@ -0,0 +1,95 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToElectricConductivity +{ + /// + /// A number to ElectricConductivity Extensions + /// + public static class NumberToElectricConductivityExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public ElectricConductivity MicrosiemensPerCentimeter +#if NET7_0_OR_GREATER + => ElectricConductivity.FromMicrosiemensPerCentimeter(double.CreateChecked(value)); +#else + => ElectricConductivity.FromMicrosiemensPerCentimeter(value.ToDouble(null)); +#endif + + /// + public ElectricConductivity MillisiemensPerCentimeter +#if NET7_0_OR_GREATER + => ElectricConductivity.FromMillisiemensPerCentimeter(double.CreateChecked(value)); +#else + => ElectricConductivity.FromMillisiemensPerCentimeter(value.ToDouble(null)); +#endif + + /// + public ElectricConductivity SiemensPerCentimeter +#if NET7_0_OR_GREATER + => ElectricConductivity.FromSiemensPerCentimeter(double.CreateChecked(value)); +#else + => ElectricConductivity.FromSiemensPerCentimeter(value.ToDouble(null)); +#endif + + /// + public ElectricConductivity SiemensPerFoot +#if NET7_0_OR_GREATER + => ElectricConductivity.FromSiemensPerFoot(double.CreateChecked(value)); +#else + => ElectricConductivity.FromSiemensPerFoot(value.ToDouble(null)); +#endif + + /// + public ElectricConductivity SiemensPerInch +#if NET7_0_OR_GREATER + => ElectricConductivity.FromSiemensPerInch(double.CreateChecked(value)); +#else + => ElectricConductivity.FromSiemensPerInch(value.ToDouble(null)); +#endif + + /// + public ElectricConductivity SiemensPerMeter +#if NET7_0_OR_GREATER + => ElectricConductivity.FromSiemensPerMeter(double.CreateChecked(value)); +#else + => ElectricConductivity.FromSiemensPerMeter(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricCurrentDensityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricCurrentDensityExtensions.g.cs new file mode 100644 index 0000000000..f52bd339c7 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricCurrentDensityExtensions.g.cs @@ -0,0 +1,71 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToElectricCurrentDensity +{ + /// + /// A number to ElectricCurrentDensity Extensions + /// + public static class NumberToElectricCurrentDensityExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public ElectricCurrentDensity AmperesPerSquareFoot +#if NET7_0_OR_GREATER + => ElectricCurrentDensity.FromAmperesPerSquareFoot(double.CreateChecked(value)); +#else + => ElectricCurrentDensity.FromAmperesPerSquareFoot(value.ToDouble(null)); +#endif + + /// + public ElectricCurrentDensity AmperesPerSquareInch +#if NET7_0_OR_GREATER + => ElectricCurrentDensity.FromAmperesPerSquareInch(double.CreateChecked(value)); +#else + => ElectricCurrentDensity.FromAmperesPerSquareInch(value.ToDouble(null)); +#endif + + /// + public ElectricCurrentDensity AmperesPerSquareMeter +#if NET7_0_OR_GREATER + => ElectricCurrentDensity.FromAmperesPerSquareMeter(double.CreateChecked(value)); +#else + => ElectricCurrentDensity.FromAmperesPerSquareMeter(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricCurrentExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricCurrentExtensions.g.cs new file mode 100644 index 0000000000..e2353cc400 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricCurrentExtensions.g.cs @@ -0,0 +1,119 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToElectricCurrent +{ + /// + /// A number to ElectricCurrent Extensions + /// + public static class NumberToElectricCurrentExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public ElectricCurrent Amperes +#if NET7_0_OR_GREATER + => ElectricCurrent.FromAmperes(double.CreateChecked(value)); +#else + => ElectricCurrent.FromAmperes(value.ToDouble(null)); +#endif + + /// + public ElectricCurrent Centiamperes +#if NET7_0_OR_GREATER + => ElectricCurrent.FromCentiamperes(double.CreateChecked(value)); +#else + => ElectricCurrent.FromCentiamperes(value.ToDouble(null)); +#endif + + /// + public ElectricCurrent Femtoamperes +#if NET7_0_OR_GREATER + => ElectricCurrent.FromFemtoamperes(double.CreateChecked(value)); +#else + => ElectricCurrent.FromFemtoamperes(value.ToDouble(null)); +#endif + + /// + public ElectricCurrent Kiloamperes +#if NET7_0_OR_GREATER + => ElectricCurrent.FromKiloamperes(double.CreateChecked(value)); +#else + => ElectricCurrent.FromKiloamperes(value.ToDouble(null)); +#endif + + /// + public ElectricCurrent Megaamperes +#if NET7_0_OR_GREATER + => ElectricCurrent.FromMegaamperes(double.CreateChecked(value)); +#else + => ElectricCurrent.FromMegaamperes(value.ToDouble(null)); +#endif + + /// + public ElectricCurrent Microamperes +#if NET7_0_OR_GREATER + => ElectricCurrent.FromMicroamperes(double.CreateChecked(value)); +#else + => ElectricCurrent.FromMicroamperes(value.ToDouble(null)); +#endif + + /// + public ElectricCurrent Milliamperes +#if NET7_0_OR_GREATER + => ElectricCurrent.FromMilliamperes(double.CreateChecked(value)); +#else + => ElectricCurrent.FromMilliamperes(value.ToDouble(null)); +#endif + + /// + public ElectricCurrent Nanoamperes +#if NET7_0_OR_GREATER + => ElectricCurrent.FromNanoamperes(double.CreateChecked(value)); +#else + => ElectricCurrent.FromNanoamperes(value.ToDouble(null)); +#endif + + /// + public ElectricCurrent Picoamperes +#if NET7_0_OR_GREATER + => ElectricCurrent.FromPicoamperes(double.CreateChecked(value)); +#else + => ElectricCurrent.FromPicoamperes(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricCurrentGradientExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricCurrentGradientExtensions.g.cs new file mode 100644 index 0000000000..92759d3167 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricCurrentGradientExtensions.g.cs @@ -0,0 +1,103 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToElectricCurrentGradient +{ + /// + /// A number to ElectricCurrentGradient Extensions + /// + public static class NumberToElectricCurrentGradientExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public ElectricCurrentGradient AmperesPerMicrosecond +#if NET7_0_OR_GREATER + => ElectricCurrentGradient.FromAmperesPerMicrosecond(double.CreateChecked(value)); +#else + => ElectricCurrentGradient.FromAmperesPerMicrosecond(value.ToDouble(null)); +#endif + + /// + public ElectricCurrentGradient AmperesPerMillisecond +#if NET7_0_OR_GREATER + => ElectricCurrentGradient.FromAmperesPerMillisecond(double.CreateChecked(value)); +#else + => ElectricCurrentGradient.FromAmperesPerMillisecond(value.ToDouble(null)); +#endif + + /// + public ElectricCurrentGradient AmperesPerMinute +#if NET7_0_OR_GREATER + => ElectricCurrentGradient.FromAmperesPerMinute(double.CreateChecked(value)); +#else + => ElectricCurrentGradient.FromAmperesPerMinute(value.ToDouble(null)); +#endif + + /// + public ElectricCurrentGradient AmperesPerNanosecond +#if NET7_0_OR_GREATER + => ElectricCurrentGradient.FromAmperesPerNanosecond(double.CreateChecked(value)); +#else + => ElectricCurrentGradient.FromAmperesPerNanosecond(value.ToDouble(null)); +#endif + + /// + public ElectricCurrentGradient AmperesPerSecond +#if NET7_0_OR_GREATER + => ElectricCurrentGradient.FromAmperesPerSecond(double.CreateChecked(value)); +#else + => ElectricCurrentGradient.FromAmperesPerSecond(value.ToDouble(null)); +#endif + + /// + public ElectricCurrentGradient MilliamperesPerMinute +#if NET7_0_OR_GREATER + => ElectricCurrentGradient.FromMilliamperesPerMinute(double.CreateChecked(value)); +#else + => ElectricCurrentGradient.FromMilliamperesPerMinute(value.ToDouble(null)); +#endif + + /// + public ElectricCurrentGradient MilliamperesPerSecond +#if NET7_0_OR_GREATER + => ElectricCurrentGradient.FromMilliamperesPerSecond(double.CreateChecked(value)); +#else + => ElectricCurrentGradient.FromMilliamperesPerSecond(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricFieldExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricFieldExtensions.g.cs new file mode 100644 index 0000000000..37d5db5a71 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricFieldExtensions.g.cs @@ -0,0 +1,55 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToElectricField +{ + /// + /// A number to ElectricField Extensions + /// + public static class NumberToElectricFieldExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public ElectricField VoltsPerMeter +#if NET7_0_OR_GREATER + => ElectricField.FromVoltsPerMeter(double.CreateChecked(value)); +#else + => ElectricField.FromVoltsPerMeter(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricImpedanceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricImpedanceExtensions.g.cs new file mode 100644 index 0000000000..9f93ae72b0 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricImpedanceExtensions.g.cs @@ -0,0 +1,120 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToElectricImpedance +{ + /// + /// A number to ElectricImpedance Extensions + /// + [Obsolete("Impedance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricResistance or ElectricReactance instead.")] + public static class NumberToElectricImpedanceExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + [Obsolete("Impedance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricResistance or ElectricReactance instead.")] + public ElectricImpedance Gigaohms +#if NET7_0_OR_GREATER + => ElectricImpedance.FromGigaohms(double.CreateChecked(value)); +#else + => ElectricImpedance.FromGigaohms(value.ToDouble(null)); +#endif + + /// + [Obsolete("Impedance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricResistance or ElectricReactance instead.")] + public ElectricImpedance Kiloohms +#if NET7_0_OR_GREATER + => ElectricImpedance.FromKiloohms(double.CreateChecked(value)); +#else + => ElectricImpedance.FromKiloohms(value.ToDouble(null)); +#endif + + /// + [Obsolete("Impedance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricResistance or ElectricReactance instead.")] + public ElectricImpedance Megaohms +#if NET7_0_OR_GREATER + => ElectricImpedance.FromMegaohms(double.CreateChecked(value)); +#else + => ElectricImpedance.FromMegaohms(value.ToDouble(null)); +#endif + + /// + [Obsolete("Impedance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricResistance or ElectricReactance instead.")] + public ElectricImpedance Microohms +#if NET7_0_OR_GREATER + => ElectricImpedance.FromMicroohms(double.CreateChecked(value)); +#else + => ElectricImpedance.FromMicroohms(value.ToDouble(null)); +#endif + + /// + [Obsolete("Impedance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricResistance or ElectricReactance instead.")] + public ElectricImpedance Milliohms +#if NET7_0_OR_GREATER + => ElectricImpedance.FromMilliohms(double.CreateChecked(value)); +#else + => ElectricImpedance.FromMilliohms(value.ToDouble(null)); +#endif + + /// + [Obsolete("Impedance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricResistance or ElectricReactance instead.")] + public ElectricImpedance Nanoohms +#if NET7_0_OR_GREATER + => ElectricImpedance.FromNanoohms(double.CreateChecked(value)); +#else + => ElectricImpedance.FromNanoohms(value.ToDouble(null)); +#endif + + /// + [Obsolete("Impedance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricResistance or ElectricReactance instead.")] + public ElectricImpedance Ohms +#if NET7_0_OR_GREATER + => ElectricImpedance.FromOhms(double.CreateChecked(value)); +#else + => ElectricImpedance.FromOhms(value.ToDouble(null)); +#endif + + /// + [Obsolete("Impedance is a complex number, which is not currently supported by UnitsNet. Please use either ElectricResistance or ElectricReactance instead.")] + public ElectricImpedance Teraohms +#if NET7_0_OR_GREATER + => ElectricImpedance.FromTeraohms(double.CreateChecked(value)); +#else + => ElectricImpedance.FromTeraohms(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricInductanceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricInductanceExtensions.g.cs new file mode 100644 index 0000000000..88cacce674 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricInductanceExtensions.g.cs @@ -0,0 +1,87 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToElectricInductance +{ + /// + /// A number to ElectricInductance Extensions + /// + public static class NumberToElectricInductanceExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public ElectricInductance Henries +#if NET7_0_OR_GREATER + => ElectricInductance.FromHenries(double.CreateChecked(value)); +#else + => ElectricInductance.FromHenries(value.ToDouble(null)); +#endif + + /// + public ElectricInductance Microhenries +#if NET7_0_OR_GREATER + => ElectricInductance.FromMicrohenries(double.CreateChecked(value)); +#else + => ElectricInductance.FromMicrohenries(value.ToDouble(null)); +#endif + + /// + public ElectricInductance Millihenries +#if NET7_0_OR_GREATER + => ElectricInductance.FromMillihenries(double.CreateChecked(value)); +#else + => ElectricInductance.FromMillihenries(value.ToDouble(null)); +#endif + + /// + public ElectricInductance Nanohenries +#if NET7_0_OR_GREATER + => ElectricInductance.FromNanohenries(double.CreateChecked(value)); +#else + => ElectricInductance.FromNanohenries(value.ToDouble(null)); +#endif + + /// + public ElectricInductance Picohenries +#if NET7_0_OR_GREATER + => ElectricInductance.FromPicohenries(double.CreateChecked(value)); +#else + => ElectricInductance.FromPicohenries(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricPotentialChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricPotentialChangeRateExtensions.g.cs new file mode 100644 index 0000000000..a5fe74376c --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricPotentialChangeRateExtensions.g.cs @@ -0,0 +1,207 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToElectricPotentialChangeRate +{ + /// + /// A number to ElectricPotentialChangeRate Extensions + /// + public static class NumberToElectricPotentialChangeRateExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public ElectricPotentialChangeRate KilovoltsPerHour +#if NET7_0_OR_GREATER + => ElectricPotentialChangeRate.FromKilovoltsPerHour(double.CreateChecked(value)); +#else + => ElectricPotentialChangeRate.FromKilovoltsPerHour(value.ToDouble(null)); +#endif + + /// + public ElectricPotentialChangeRate KilovoltsPerMicrosecond +#if NET7_0_OR_GREATER + => ElectricPotentialChangeRate.FromKilovoltsPerMicrosecond(double.CreateChecked(value)); +#else + => ElectricPotentialChangeRate.FromKilovoltsPerMicrosecond(value.ToDouble(null)); +#endif + + /// + public ElectricPotentialChangeRate KilovoltsPerMinute +#if NET7_0_OR_GREATER + => ElectricPotentialChangeRate.FromKilovoltsPerMinute(double.CreateChecked(value)); +#else + => ElectricPotentialChangeRate.FromKilovoltsPerMinute(value.ToDouble(null)); +#endif + + /// + public ElectricPotentialChangeRate KilovoltsPerSecond +#if NET7_0_OR_GREATER + => ElectricPotentialChangeRate.FromKilovoltsPerSecond(double.CreateChecked(value)); +#else + => ElectricPotentialChangeRate.FromKilovoltsPerSecond(value.ToDouble(null)); +#endif + + /// + public ElectricPotentialChangeRate MegavoltsPerHour +#if NET7_0_OR_GREATER + => ElectricPotentialChangeRate.FromMegavoltsPerHour(double.CreateChecked(value)); +#else + => ElectricPotentialChangeRate.FromMegavoltsPerHour(value.ToDouble(null)); +#endif + + /// + public ElectricPotentialChangeRate MegavoltsPerMicrosecond +#if NET7_0_OR_GREATER + => ElectricPotentialChangeRate.FromMegavoltsPerMicrosecond(double.CreateChecked(value)); +#else + => ElectricPotentialChangeRate.FromMegavoltsPerMicrosecond(value.ToDouble(null)); +#endif + + /// + public ElectricPotentialChangeRate MegavoltsPerMinute +#if NET7_0_OR_GREATER + => ElectricPotentialChangeRate.FromMegavoltsPerMinute(double.CreateChecked(value)); +#else + => ElectricPotentialChangeRate.FromMegavoltsPerMinute(value.ToDouble(null)); +#endif + + /// + public ElectricPotentialChangeRate MegavoltsPerSecond +#if NET7_0_OR_GREATER + => ElectricPotentialChangeRate.FromMegavoltsPerSecond(double.CreateChecked(value)); +#else + => ElectricPotentialChangeRate.FromMegavoltsPerSecond(value.ToDouble(null)); +#endif + + /// + public ElectricPotentialChangeRate MicrovoltsPerHour +#if NET7_0_OR_GREATER + => ElectricPotentialChangeRate.FromMicrovoltsPerHour(double.CreateChecked(value)); +#else + => ElectricPotentialChangeRate.FromMicrovoltsPerHour(value.ToDouble(null)); +#endif + + /// + public ElectricPotentialChangeRate MicrovoltsPerMicrosecond +#if NET7_0_OR_GREATER + => ElectricPotentialChangeRate.FromMicrovoltsPerMicrosecond(double.CreateChecked(value)); +#else + => ElectricPotentialChangeRate.FromMicrovoltsPerMicrosecond(value.ToDouble(null)); +#endif + + /// + public ElectricPotentialChangeRate MicrovoltsPerMinute +#if NET7_0_OR_GREATER + => ElectricPotentialChangeRate.FromMicrovoltsPerMinute(double.CreateChecked(value)); +#else + => ElectricPotentialChangeRate.FromMicrovoltsPerMinute(value.ToDouble(null)); +#endif + + /// + public ElectricPotentialChangeRate MicrovoltsPerSecond +#if NET7_0_OR_GREATER + => ElectricPotentialChangeRate.FromMicrovoltsPerSecond(double.CreateChecked(value)); +#else + => ElectricPotentialChangeRate.FromMicrovoltsPerSecond(value.ToDouble(null)); +#endif + + /// + public ElectricPotentialChangeRate MillivoltsPerHour +#if NET7_0_OR_GREATER + => ElectricPotentialChangeRate.FromMillivoltsPerHour(double.CreateChecked(value)); +#else + => ElectricPotentialChangeRate.FromMillivoltsPerHour(value.ToDouble(null)); +#endif + + /// + public ElectricPotentialChangeRate MillivoltsPerMicrosecond +#if NET7_0_OR_GREATER + => ElectricPotentialChangeRate.FromMillivoltsPerMicrosecond(double.CreateChecked(value)); +#else + => ElectricPotentialChangeRate.FromMillivoltsPerMicrosecond(value.ToDouble(null)); +#endif + + /// + public ElectricPotentialChangeRate MillivoltsPerMinute +#if NET7_0_OR_GREATER + => ElectricPotentialChangeRate.FromMillivoltsPerMinute(double.CreateChecked(value)); +#else + => ElectricPotentialChangeRate.FromMillivoltsPerMinute(value.ToDouble(null)); +#endif + + /// + public ElectricPotentialChangeRate MillivoltsPerSecond +#if NET7_0_OR_GREATER + => ElectricPotentialChangeRate.FromMillivoltsPerSecond(double.CreateChecked(value)); +#else + => ElectricPotentialChangeRate.FromMillivoltsPerSecond(value.ToDouble(null)); +#endif + + /// + public ElectricPotentialChangeRate VoltsPerHour +#if NET7_0_OR_GREATER + => ElectricPotentialChangeRate.FromVoltsPerHour(double.CreateChecked(value)); +#else + => ElectricPotentialChangeRate.FromVoltsPerHour(value.ToDouble(null)); +#endif + + /// + public ElectricPotentialChangeRate VoltsPerMicrosecond +#if NET7_0_OR_GREATER + => ElectricPotentialChangeRate.FromVoltsPerMicrosecond(double.CreateChecked(value)); +#else + => ElectricPotentialChangeRate.FromVoltsPerMicrosecond(value.ToDouble(null)); +#endif + + /// + public ElectricPotentialChangeRate VoltsPerMinute +#if NET7_0_OR_GREATER + => ElectricPotentialChangeRate.FromVoltsPerMinute(double.CreateChecked(value)); +#else + => ElectricPotentialChangeRate.FromVoltsPerMinute(value.ToDouble(null)); +#endif + + /// + public ElectricPotentialChangeRate VoltsPerSecond +#if NET7_0_OR_GREATER + => ElectricPotentialChangeRate.FromVoltsPerSecond(double.CreateChecked(value)); +#else + => ElectricPotentialChangeRate.FromVoltsPerSecond(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricPotentialExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricPotentialExtensions.g.cs new file mode 100644 index 0000000000..eae86858a2 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricPotentialExtensions.g.cs @@ -0,0 +1,95 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToElectricPotential +{ + /// + /// A number to ElectricPotential Extensions + /// + public static class NumberToElectricPotentialExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public ElectricPotential Kilovolts +#if NET7_0_OR_GREATER + => ElectricPotential.FromKilovolts(double.CreateChecked(value)); +#else + => ElectricPotential.FromKilovolts(value.ToDouble(null)); +#endif + + /// + public ElectricPotential Megavolts +#if NET7_0_OR_GREATER + => ElectricPotential.FromMegavolts(double.CreateChecked(value)); +#else + => ElectricPotential.FromMegavolts(value.ToDouble(null)); +#endif + + /// + public ElectricPotential Microvolts +#if NET7_0_OR_GREATER + => ElectricPotential.FromMicrovolts(double.CreateChecked(value)); +#else + => ElectricPotential.FromMicrovolts(value.ToDouble(null)); +#endif + + /// + public ElectricPotential Millivolts +#if NET7_0_OR_GREATER + => ElectricPotential.FromMillivolts(double.CreateChecked(value)); +#else + => ElectricPotential.FromMillivolts(value.ToDouble(null)); +#endif + + /// + public ElectricPotential Nanovolts +#if NET7_0_OR_GREATER + => ElectricPotential.FromNanovolts(double.CreateChecked(value)); +#else + => ElectricPotential.FromNanovolts(value.ToDouble(null)); +#endif + + /// + public ElectricPotential Volts +#if NET7_0_OR_GREATER + => ElectricPotential.FromVolts(double.CreateChecked(value)); +#else + => ElectricPotential.FromVolts(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricReactanceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricReactanceExtensions.g.cs new file mode 100644 index 0000000000..2a615184b6 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricReactanceExtensions.g.cs @@ -0,0 +1,111 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToElectricReactance +{ + /// + /// A number to ElectricReactance Extensions + /// + public static class NumberToElectricReactanceExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public ElectricReactance Gigaohms +#if NET7_0_OR_GREATER + => ElectricReactance.FromGigaohms(double.CreateChecked(value)); +#else + => ElectricReactance.FromGigaohms(value.ToDouble(null)); +#endif + + /// + public ElectricReactance Kiloohms +#if NET7_0_OR_GREATER + => ElectricReactance.FromKiloohms(double.CreateChecked(value)); +#else + => ElectricReactance.FromKiloohms(value.ToDouble(null)); +#endif + + /// + public ElectricReactance Megaohms +#if NET7_0_OR_GREATER + => ElectricReactance.FromMegaohms(double.CreateChecked(value)); +#else + => ElectricReactance.FromMegaohms(value.ToDouble(null)); +#endif + + /// + public ElectricReactance Microohms +#if NET7_0_OR_GREATER + => ElectricReactance.FromMicroohms(double.CreateChecked(value)); +#else + => ElectricReactance.FromMicroohms(value.ToDouble(null)); +#endif + + /// + public ElectricReactance Milliohms +#if NET7_0_OR_GREATER + => ElectricReactance.FromMilliohms(double.CreateChecked(value)); +#else + => ElectricReactance.FromMilliohms(value.ToDouble(null)); +#endif + + /// + public ElectricReactance Nanoohms +#if NET7_0_OR_GREATER + => ElectricReactance.FromNanoohms(double.CreateChecked(value)); +#else + => ElectricReactance.FromNanoohms(value.ToDouble(null)); +#endif + + /// + public ElectricReactance Ohms +#if NET7_0_OR_GREATER + => ElectricReactance.FromOhms(double.CreateChecked(value)); +#else + => ElectricReactance.FromOhms(value.ToDouble(null)); +#endif + + /// + public ElectricReactance Teraohms +#if NET7_0_OR_GREATER + => ElectricReactance.FromTeraohms(double.CreateChecked(value)); +#else + => ElectricReactance.FromTeraohms(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricReactiveEnergyExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricReactiveEnergyExtensions.g.cs new file mode 100644 index 0000000000..883bc97964 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricReactiveEnergyExtensions.g.cs @@ -0,0 +1,71 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToElectricReactiveEnergy +{ + /// + /// A number to ElectricReactiveEnergy Extensions + /// + public static class NumberToElectricReactiveEnergyExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public ElectricReactiveEnergy KilovoltampereReactiveHours +#if NET7_0_OR_GREATER + => ElectricReactiveEnergy.FromKilovoltampereReactiveHours(double.CreateChecked(value)); +#else + => ElectricReactiveEnergy.FromKilovoltampereReactiveHours(value.ToDouble(null)); +#endif + + /// + public ElectricReactiveEnergy MegavoltampereReactiveHours +#if NET7_0_OR_GREATER + => ElectricReactiveEnergy.FromMegavoltampereReactiveHours(double.CreateChecked(value)); +#else + => ElectricReactiveEnergy.FromMegavoltampereReactiveHours(value.ToDouble(null)); +#endif + + /// + public ElectricReactiveEnergy VoltampereReactiveHours +#if NET7_0_OR_GREATER + => ElectricReactiveEnergy.FromVoltampereReactiveHours(double.CreateChecked(value)); +#else + => ElectricReactiveEnergy.FromVoltampereReactiveHours(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricReactivePowerExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricReactivePowerExtensions.g.cs new file mode 100644 index 0000000000..c9287f83de --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricReactivePowerExtensions.g.cs @@ -0,0 +1,79 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToElectricReactivePower +{ + /// + /// A number to ElectricReactivePower Extensions + /// + public static class NumberToElectricReactivePowerExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public ElectricReactivePower GigavoltamperesReactive +#if NET7_0_OR_GREATER + => ElectricReactivePower.FromGigavoltamperesReactive(double.CreateChecked(value)); +#else + => ElectricReactivePower.FromGigavoltamperesReactive(value.ToDouble(null)); +#endif + + /// + public ElectricReactivePower KilovoltamperesReactive +#if NET7_0_OR_GREATER + => ElectricReactivePower.FromKilovoltamperesReactive(double.CreateChecked(value)); +#else + => ElectricReactivePower.FromKilovoltamperesReactive(value.ToDouble(null)); +#endif + + /// + public ElectricReactivePower MegavoltamperesReactive +#if NET7_0_OR_GREATER + => ElectricReactivePower.FromMegavoltamperesReactive(double.CreateChecked(value)); +#else + => ElectricReactivePower.FromMegavoltamperesReactive(value.ToDouble(null)); +#endif + + /// + public ElectricReactivePower VoltamperesReactive +#if NET7_0_OR_GREATER + => ElectricReactivePower.FromVoltamperesReactive(double.CreateChecked(value)); +#else + => ElectricReactivePower.FromVoltamperesReactive(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricResistanceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricResistanceExtensions.g.cs new file mode 100644 index 0000000000..7c54e42ad1 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricResistanceExtensions.g.cs @@ -0,0 +1,111 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToElectricResistance +{ + /// + /// A number to ElectricResistance Extensions + /// + public static class NumberToElectricResistanceExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public ElectricResistance Gigaohms +#if NET7_0_OR_GREATER + => ElectricResistance.FromGigaohms(double.CreateChecked(value)); +#else + => ElectricResistance.FromGigaohms(value.ToDouble(null)); +#endif + + /// + public ElectricResistance Kiloohms +#if NET7_0_OR_GREATER + => ElectricResistance.FromKiloohms(double.CreateChecked(value)); +#else + => ElectricResistance.FromKiloohms(value.ToDouble(null)); +#endif + + /// + public ElectricResistance Megaohms +#if NET7_0_OR_GREATER + => ElectricResistance.FromMegaohms(double.CreateChecked(value)); +#else + => ElectricResistance.FromMegaohms(value.ToDouble(null)); +#endif + + /// + public ElectricResistance Microohms +#if NET7_0_OR_GREATER + => ElectricResistance.FromMicroohms(double.CreateChecked(value)); +#else + => ElectricResistance.FromMicroohms(value.ToDouble(null)); +#endif + + /// + public ElectricResistance Milliohms +#if NET7_0_OR_GREATER + => ElectricResistance.FromMilliohms(double.CreateChecked(value)); +#else + => ElectricResistance.FromMilliohms(value.ToDouble(null)); +#endif + + /// + public ElectricResistance Nanoohms +#if NET7_0_OR_GREATER + => ElectricResistance.FromNanoohms(double.CreateChecked(value)); +#else + => ElectricResistance.FromNanoohms(value.ToDouble(null)); +#endif + + /// + public ElectricResistance Ohms +#if NET7_0_OR_GREATER + => ElectricResistance.FromOhms(double.CreateChecked(value)); +#else + => ElectricResistance.FromOhms(value.ToDouble(null)); +#endif + + /// + public ElectricResistance Teraohms +#if NET7_0_OR_GREATER + => ElectricResistance.FromTeraohms(double.CreateChecked(value)); +#else + => ElectricResistance.FromTeraohms(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricResistivityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricResistivityExtensions.g.cs new file mode 100644 index 0000000000..621882e58e --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricResistivityExtensions.g.cs @@ -0,0 +1,159 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToElectricResistivity +{ + /// + /// A number to ElectricResistivity Extensions + /// + public static class NumberToElectricResistivityExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public ElectricResistivity KiloohmsCentimeter +#if NET7_0_OR_GREATER + => ElectricResistivity.FromKiloohmsCentimeter(double.CreateChecked(value)); +#else + => ElectricResistivity.FromKiloohmsCentimeter(value.ToDouble(null)); +#endif + + /// + public ElectricResistivity KiloohmMeters +#if NET7_0_OR_GREATER + => ElectricResistivity.FromKiloohmMeters(double.CreateChecked(value)); +#else + => ElectricResistivity.FromKiloohmMeters(value.ToDouble(null)); +#endif + + /// + public ElectricResistivity MegaohmsCentimeter +#if NET7_0_OR_GREATER + => ElectricResistivity.FromMegaohmsCentimeter(double.CreateChecked(value)); +#else + => ElectricResistivity.FromMegaohmsCentimeter(value.ToDouble(null)); +#endif + + /// + public ElectricResistivity MegaohmMeters +#if NET7_0_OR_GREATER + => ElectricResistivity.FromMegaohmMeters(double.CreateChecked(value)); +#else + => ElectricResistivity.FromMegaohmMeters(value.ToDouble(null)); +#endif + + /// + public ElectricResistivity MicroohmsCentimeter +#if NET7_0_OR_GREATER + => ElectricResistivity.FromMicroohmsCentimeter(double.CreateChecked(value)); +#else + => ElectricResistivity.FromMicroohmsCentimeter(value.ToDouble(null)); +#endif + + /// + public ElectricResistivity MicroohmMeters +#if NET7_0_OR_GREATER + => ElectricResistivity.FromMicroohmMeters(double.CreateChecked(value)); +#else + => ElectricResistivity.FromMicroohmMeters(value.ToDouble(null)); +#endif + + /// + public ElectricResistivity MilliohmsCentimeter +#if NET7_0_OR_GREATER + => ElectricResistivity.FromMilliohmsCentimeter(double.CreateChecked(value)); +#else + => ElectricResistivity.FromMilliohmsCentimeter(value.ToDouble(null)); +#endif + + /// + public ElectricResistivity MilliohmMeters +#if NET7_0_OR_GREATER + => ElectricResistivity.FromMilliohmMeters(double.CreateChecked(value)); +#else + => ElectricResistivity.FromMilliohmMeters(value.ToDouble(null)); +#endif + + /// + public ElectricResistivity NanoohmsCentimeter +#if NET7_0_OR_GREATER + => ElectricResistivity.FromNanoohmsCentimeter(double.CreateChecked(value)); +#else + => ElectricResistivity.FromNanoohmsCentimeter(value.ToDouble(null)); +#endif + + /// + public ElectricResistivity NanoohmMeters +#if NET7_0_OR_GREATER + => ElectricResistivity.FromNanoohmMeters(double.CreateChecked(value)); +#else + => ElectricResistivity.FromNanoohmMeters(value.ToDouble(null)); +#endif + + /// + public ElectricResistivity OhmsCentimeter +#if NET7_0_OR_GREATER + => ElectricResistivity.FromOhmsCentimeter(double.CreateChecked(value)); +#else + => ElectricResistivity.FromOhmsCentimeter(value.ToDouble(null)); +#endif + + /// + public ElectricResistivity OhmMeters +#if NET7_0_OR_GREATER + => ElectricResistivity.FromOhmMeters(double.CreateChecked(value)); +#else + => ElectricResistivity.FromOhmMeters(value.ToDouble(null)); +#endif + + /// + public ElectricResistivity PicoohmsCentimeter +#if NET7_0_OR_GREATER + => ElectricResistivity.FromPicoohmsCentimeter(double.CreateChecked(value)); +#else + => ElectricResistivity.FromPicoohmsCentimeter(value.ToDouble(null)); +#endif + + /// + public ElectricResistivity PicoohmMeters +#if NET7_0_OR_GREATER + => ElectricResistivity.FromPicoohmMeters(double.CreateChecked(value)); +#else + => ElectricResistivity.FromPicoohmMeters(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensions.g.cs new file mode 100644 index 0000000000..de5bbb812c --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensions.g.cs @@ -0,0 +1,71 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToElectricSurfaceChargeDensity +{ + /// + /// A number to ElectricSurfaceChargeDensity Extensions + /// + public static class NumberToElectricSurfaceChargeDensityExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public ElectricSurfaceChargeDensity CoulombsPerSquareCentimeter +#if NET7_0_OR_GREATER + => ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(double.CreateChecked(value)); +#else + => ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(value.ToDouble(null)); +#endif + + /// + public ElectricSurfaceChargeDensity CoulombsPerSquareInch +#if NET7_0_OR_GREATER + => ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(double.CreateChecked(value)); +#else + => ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(value.ToDouble(null)); +#endif + + /// + public ElectricSurfaceChargeDensity CoulombsPerSquareMeter +#if NET7_0_OR_GREATER + => ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(double.CreateChecked(value)); +#else + => ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricSusceptanceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricSusceptanceExtensions.g.cs new file mode 100644 index 0000000000..f3635c9923 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToElectricSusceptanceExtensions.g.cs @@ -0,0 +1,175 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToElectricSusceptance +{ + /// + /// A number to ElectricSusceptance Extensions + /// + public static class NumberToElectricSusceptanceExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public ElectricSusceptance Gigamhos +#if NET7_0_OR_GREATER + => ElectricSusceptance.FromGigamhos(double.CreateChecked(value)); +#else + => ElectricSusceptance.FromGigamhos(value.ToDouble(null)); +#endif + + /// + public ElectricSusceptance Gigasiemens +#if NET7_0_OR_GREATER + => ElectricSusceptance.FromGigasiemens(double.CreateChecked(value)); +#else + => ElectricSusceptance.FromGigasiemens(value.ToDouble(null)); +#endif + + /// + public ElectricSusceptance Kilomhos +#if NET7_0_OR_GREATER + => ElectricSusceptance.FromKilomhos(double.CreateChecked(value)); +#else + => ElectricSusceptance.FromKilomhos(value.ToDouble(null)); +#endif + + /// + public ElectricSusceptance Kilosiemens +#if NET7_0_OR_GREATER + => ElectricSusceptance.FromKilosiemens(double.CreateChecked(value)); +#else + => ElectricSusceptance.FromKilosiemens(value.ToDouble(null)); +#endif + + /// + public ElectricSusceptance Megamhos +#if NET7_0_OR_GREATER + => ElectricSusceptance.FromMegamhos(double.CreateChecked(value)); +#else + => ElectricSusceptance.FromMegamhos(value.ToDouble(null)); +#endif + + /// + public ElectricSusceptance Megasiemens +#if NET7_0_OR_GREATER + => ElectricSusceptance.FromMegasiemens(double.CreateChecked(value)); +#else + => ElectricSusceptance.FromMegasiemens(value.ToDouble(null)); +#endif + + /// + public ElectricSusceptance Mhos +#if NET7_0_OR_GREATER + => ElectricSusceptance.FromMhos(double.CreateChecked(value)); +#else + => ElectricSusceptance.FromMhos(value.ToDouble(null)); +#endif + + /// + public ElectricSusceptance Micromhos +#if NET7_0_OR_GREATER + => ElectricSusceptance.FromMicromhos(double.CreateChecked(value)); +#else + => ElectricSusceptance.FromMicromhos(value.ToDouble(null)); +#endif + + /// + public ElectricSusceptance Microsiemens +#if NET7_0_OR_GREATER + => ElectricSusceptance.FromMicrosiemens(double.CreateChecked(value)); +#else + => ElectricSusceptance.FromMicrosiemens(value.ToDouble(null)); +#endif + + /// + public ElectricSusceptance Millimhos +#if NET7_0_OR_GREATER + => ElectricSusceptance.FromMillimhos(double.CreateChecked(value)); +#else + => ElectricSusceptance.FromMillimhos(value.ToDouble(null)); +#endif + + /// + public ElectricSusceptance Millisiemens +#if NET7_0_OR_GREATER + => ElectricSusceptance.FromMillisiemens(double.CreateChecked(value)); +#else + => ElectricSusceptance.FromMillisiemens(value.ToDouble(null)); +#endif + + /// + public ElectricSusceptance Nanomhos +#if NET7_0_OR_GREATER + => ElectricSusceptance.FromNanomhos(double.CreateChecked(value)); +#else + => ElectricSusceptance.FromNanomhos(value.ToDouble(null)); +#endif + + /// + public ElectricSusceptance Nanosiemens +#if NET7_0_OR_GREATER + => ElectricSusceptance.FromNanosiemens(double.CreateChecked(value)); +#else + => ElectricSusceptance.FromNanosiemens(value.ToDouble(null)); +#endif + + /// + public ElectricSusceptance Siemens +#if NET7_0_OR_GREATER + => ElectricSusceptance.FromSiemens(double.CreateChecked(value)); +#else + => ElectricSusceptance.FromSiemens(value.ToDouble(null)); +#endif + + /// + public ElectricSusceptance Teramhos +#if NET7_0_OR_GREATER + => ElectricSusceptance.FromTeramhos(double.CreateChecked(value)); +#else + => ElectricSusceptance.FromTeramhos(value.ToDouble(null)); +#endif + + /// + public ElectricSusceptance Terasiemens +#if NET7_0_OR_GREATER + => ElectricSusceptance.FromTerasiemens(double.CreateChecked(value)); +#else + => ElectricSusceptance.FromTerasiemens(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToEnergyDensityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToEnergyDensityExtensions.g.cs new file mode 100644 index 0000000000..f3674b0e4f --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToEnergyDensityExtensions.g.cs @@ -0,0 +1,143 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToEnergyDensity +{ + /// + /// A number to EnergyDensity Extensions + /// + public static class NumberToEnergyDensityExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public EnergyDensity GigajoulesPerCubicMeter +#if NET7_0_OR_GREATER + => EnergyDensity.FromGigajoulesPerCubicMeter(double.CreateChecked(value)); +#else + => EnergyDensity.FromGigajoulesPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public EnergyDensity GigawattHoursPerCubicMeter +#if NET7_0_OR_GREATER + => EnergyDensity.FromGigawattHoursPerCubicMeter(double.CreateChecked(value)); +#else + => EnergyDensity.FromGigawattHoursPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public EnergyDensity JoulesPerCubicMeter +#if NET7_0_OR_GREATER + => EnergyDensity.FromJoulesPerCubicMeter(double.CreateChecked(value)); +#else + => EnergyDensity.FromJoulesPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public EnergyDensity KilojoulesPerCubicMeter +#if NET7_0_OR_GREATER + => EnergyDensity.FromKilojoulesPerCubicMeter(double.CreateChecked(value)); +#else + => EnergyDensity.FromKilojoulesPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public EnergyDensity KilowattHoursPerCubicMeter +#if NET7_0_OR_GREATER + => EnergyDensity.FromKilowattHoursPerCubicMeter(double.CreateChecked(value)); +#else + => EnergyDensity.FromKilowattHoursPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public EnergyDensity MegajoulesPerCubicMeter +#if NET7_0_OR_GREATER + => EnergyDensity.FromMegajoulesPerCubicMeter(double.CreateChecked(value)); +#else + => EnergyDensity.FromMegajoulesPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public EnergyDensity MegawattHoursPerCubicMeter +#if NET7_0_OR_GREATER + => EnergyDensity.FromMegawattHoursPerCubicMeter(double.CreateChecked(value)); +#else + => EnergyDensity.FromMegawattHoursPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public EnergyDensity PetajoulesPerCubicMeter +#if NET7_0_OR_GREATER + => EnergyDensity.FromPetajoulesPerCubicMeter(double.CreateChecked(value)); +#else + => EnergyDensity.FromPetajoulesPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public EnergyDensity PetawattHoursPerCubicMeter +#if NET7_0_OR_GREATER + => EnergyDensity.FromPetawattHoursPerCubicMeter(double.CreateChecked(value)); +#else + => EnergyDensity.FromPetawattHoursPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public EnergyDensity TerajoulesPerCubicMeter +#if NET7_0_OR_GREATER + => EnergyDensity.FromTerajoulesPerCubicMeter(double.CreateChecked(value)); +#else + => EnergyDensity.FromTerajoulesPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public EnergyDensity TerawattHoursPerCubicMeter +#if NET7_0_OR_GREATER + => EnergyDensity.FromTerawattHoursPerCubicMeter(double.CreateChecked(value)); +#else + => EnergyDensity.FromTerawattHoursPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public EnergyDensity WattHoursPerCubicMeter +#if NET7_0_OR_GREATER + => EnergyDensity.FromWattHoursPerCubicMeter(double.CreateChecked(value)); +#else + => EnergyDensity.FromWattHoursPerCubicMeter(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToEnergyExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToEnergyExtensions.g.cs new file mode 100644 index 0000000000..d600983c22 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToEnergyExtensions.g.cs @@ -0,0 +1,367 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToEnergy +{ + /// + /// A number to Energy Extensions + /// + public static class NumberToEnergyExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Energy BritishThermalUnits +#if NET7_0_OR_GREATER + => Energy.FromBritishThermalUnits(double.CreateChecked(value)); +#else + => Energy.FromBritishThermalUnits(value.ToDouble(null)); +#endif + + /// + public Energy Calories +#if NET7_0_OR_GREATER + => Energy.FromCalories(double.CreateChecked(value)); +#else + => Energy.FromCalories(value.ToDouble(null)); +#endif + + /// + public Energy DecathermsEc +#if NET7_0_OR_GREATER + => Energy.FromDecathermsEc(double.CreateChecked(value)); +#else + => Energy.FromDecathermsEc(value.ToDouble(null)); +#endif + + /// + public Energy DecathermsImperial +#if NET7_0_OR_GREATER + => Energy.FromDecathermsImperial(double.CreateChecked(value)); +#else + => Energy.FromDecathermsImperial(value.ToDouble(null)); +#endif + + /// + public Energy DecathermsUs +#if NET7_0_OR_GREATER + => Energy.FromDecathermsUs(double.CreateChecked(value)); +#else + => Energy.FromDecathermsUs(value.ToDouble(null)); +#endif + + /// + public Energy ElectronVolts +#if NET7_0_OR_GREATER + => Energy.FromElectronVolts(double.CreateChecked(value)); +#else + => Energy.FromElectronVolts(value.ToDouble(null)); +#endif + + /// + public Energy Ergs +#if NET7_0_OR_GREATER + => Energy.FromErgs(double.CreateChecked(value)); +#else + => Energy.FromErgs(value.ToDouble(null)); +#endif + + /// + public Energy FootPounds +#if NET7_0_OR_GREATER + => Energy.FromFootPounds(double.CreateChecked(value)); +#else + => Energy.FromFootPounds(value.ToDouble(null)); +#endif + + /// + public Energy GigabritishThermalUnits +#if NET7_0_OR_GREATER + => Energy.FromGigabritishThermalUnits(double.CreateChecked(value)); +#else + => Energy.FromGigabritishThermalUnits(value.ToDouble(null)); +#endif + + /// + public Energy GigaelectronVolts +#if NET7_0_OR_GREATER + => Energy.FromGigaelectronVolts(double.CreateChecked(value)); +#else + => Energy.FromGigaelectronVolts(value.ToDouble(null)); +#endif + + /// + public Energy Gigajoules +#if NET7_0_OR_GREATER + => Energy.FromGigajoules(double.CreateChecked(value)); +#else + => Energy.FromGigajoules(value.ToDouble(null)); +#endif + + /// + public Energy GigawattDays +#if NET7_0_OR_GREATER + => Energy.FromGigawattDays(double.CreateChecked(value)); +#else + => Energy.FromGigawattDays(value.ToDouble(null)); +#endif + + /// + public Energy GigawattHours +#if NET7_0_OR_GREATER + => Energy.FromGigawattHours(double.CreateChecked(value)); +#else + => Energy.FromGigawattHours(value.ToDouble(null)); +#endif + + /// + public Energy HorsepowerHours +#if NET7_0_OR_GREATER + => Energy.FromHorsepowerHours(double.CreateChecked(value)); +#else + => Energy.FromHorsepowerHours(value.ToDouble(null)); +#endif + + /// + public Energy Joules +#if NET7_0_OR_GREATER + => Energy.FromJoules(double.CreateChecked(value)); +#else + => Energy.FromJoules(value.ToDouble(null)); +#endif + + /// + public Energy KilobritishThermalUnits +#if NET7_0_OR_GREATER + => Energy.FromKilobritishThermalUnits(double.CreateChecked(value)); +#else + => Energy.FromKilobritishThermalUnits(value.ToDouble(null)); +#endif + + /// + public Energy Kilocalories +#if NET7_0_OR_GREATER + => Energy.FromKilocalories(double.CreateChecked(value)); +#else + => Energy.FromKilocalories(value.ToDouble(null)); +#endif + + /// + public Energy KiloelectronVolts +#if NET7_0_OR_GREATER + => Energy.FromKiloelectronVolts(double.CreateChecked(value)); +#else + => Energy.FromKiloelectronVolts(value.ToDouble(null)); +#endif + + /// + public Energy Kilojoules +#if NET7_0_OR_GREATER + => Energy.FromKilojoules(double.CreateChecked(value)); +#else + => Energy.FromKilojoules(value.ToDouble(null)); +#endif + + /// + public Energy KilowattDays +#if NET7_0_OR_GREATER + => Energy.FromKilowattDays(double.CreateChecked(value)); +#else + => Energy.FromKilowattDays(value.ToDouble(null)); +#endif + + /// + public Energy KilowattHours +#if NET7_0_OR_GREATER + => Energy.FromKilowattHours(double.CreateChecked(value)); +#else + => Energy.FromKilowattHours(value.ToDouble(null)); +#endif + + /// + public Energy MegabritishThermalUnits +#if NET7_0_OR_GREATER + => Energy.FromMegabritishThermalUnits(double.CreateChecked(value)); +#else + => Energy.FromMegabritishThermalUnits(value.ToDouble(null)); +#endif + + /// + public Energy Megacalories +#if NET7_0_OR_GREATER + => Energy.FromMegacalories(double.CreateChecked(value)); +#else + => Energy.FromMegacalories(value.ToDouble(null)); +#endif + + /// + public Energy MegaelectronVolts +#if NET7_0_OR_GREATER + => Energy.FromMegaelectronVolts(double.CreateChecked(value)); +#else + => Energy.FromMegaelectronVolts(value.ToDouble(null)); +#endif + + /// + public Energy Megajoules +#if NET7_0_OR_GREATER + => Energy.FromMegajoules(double.CreateChecked(value)); +#else + => Energy.FromMegajoules(value.ToDouble(null)); +#endif + + /// + public Energy MegawattDays +#if NET7_0_OR_GREATER + => Energy.FromMegawattDays(double.CreateChecked(value)); +#else + => Energy.FromMegawattDays(value.ToDouble(null)); +#endif + + /// + public Energy MegawattHours +#if NET7_0_OR_GREATER + => Energy.FromMegawattHours(double.CreateChecked(value)); +#else + => Energy.FromMegawattHours(value.ToDouble(null)); +#endif + + /// + public Energy Microjoules +#if NET7_0_OR_GREATER + => Energy.FromMicrojoules(double.CreateChecked(value)); +#else + => Energy.FromMicrojoules(value.ToDouble(null)); +#endif + + /// + public Energy Millijoules +#if NET7_0_OR_GREATER + => Energy.FromMillijoules(double.CreateChecked(value)); +#else + => Energy.FromMillijoules(value.ToDouble(null)); +#endif + + /// + public Energy Nanojoules +#if NET7_0_OR_GREATER + => Energy.FromNanojoules(double.CreateChecked(value)); +#else + => Energy.FromNanojoules(value.ToDouble(null)); +#endif + + /// + public Energy Petajoules +#if NET7_0_OR_GREATER + => Energy.FromPetajoules(double.CreateChecked(value)); +#else + => Energy.FromPetajoules(value.ToDouble(null)); +#endif + + /// + public Energy TeraelectronVolts +#if NET7_0_OR_GREATER + => Energy.FromTeraelectronVolts(double.CreateChecked(value)); +#else + => Energy.FromTeraelectronVolts(value.ToDouble(null)); +#endif + + /// + public Energy Terajoules +#if NET7_0_OR_GREATER + => Energy.FromTerajoules(double.CreateChecked(value)); +#else + => Energy.FromTerajoules(value.ToDouble(null)); +#endif + + /// + public Energy TerawattDays +#if NET7_0_OR_GREATER + => Energy.FromTerawattDays(double.CreateChecked(value)); +#else + => Energy.FromTerawattDays(value.ToDouble(null)); +#endif + + /// + public Energy TerawattHours +#if NET7_0_OR_GREATER + => Energy.FromTerawattHours(double.CreateChecked(value)); +#else + => Energy.FromTerawattHours(value.ToDouble(null)); +#endif + + /// + public Energy ThermsEc +#if NET7_0_OR_GREATER + => Energy.FromThermsEc(double.CreateChecked(value)); +#else + => Energy.FromThermsEc(value.ToDouble(null)); +#endif + + /// + public Energy ThermsImperial +#if NET7_0_OR_GREATER + => Energy.FromThermsImperial(double.CreateChecked(value)); +#else + => Energy.FromThermsImperial(value.ToDouble(null)); +#endif + + /// + public Energy ThermsUs +#if NET7_0_OR_GREATER + => Energy.FromThermsUs(double.CreateChecked(value)); +#else + => Energy.FromThermsUs(value.ToDouble(null)); +#endif + + /// + public Energy WattDays +#if NET7_0_OR_GREATER + => Energy.FromWattDays(double.CreateChecked(value)); +#else + => Energy.FromWattDays(value.ToDouble(null)); +#endif + + /// + public Energy WattHours +#if NET7_0_OR_GREATER + => Energy.FromWattHours(double.CreateChecked(value)); +#else + => Energy.FromWattHours(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToEntropyExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToEntropyExtensions.g.cs new file mode 100644 index 0000000000..ff957f3db7 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToEntropyExtensions.g.cs @@ -0,0 +1,103 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToEntropy +{ + /// + /// A number to Entropy Extensions + /// + public static class NumberToEntropyExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Entropy CaloriesPerKelvin +#if NET7_0_OR_GREATER + => Entropy.FromCaloriesPerKelvin(double.CreateChecked(value)); +#else + => Entropy.FromCaloriesPerKelvin(value.ToDouble(null)); +#endif + + /// + public Entropy JoulesPerDegreeCelsius +#if NET7_0_OR_GREATER + => Entropy.FromJoulesPerDegreeCelsius(double.CreateChecked(value)); +#else + => Entropy.FromJoulesPerDegreeCelsius(value.ToDouble(null)); +#endif + + /// + public Entropy JoulesPerKelvin +#if NET7_0_OR_GREATER + => Entropy.FromJoulesPerKelvin(double.CreateChecked(value)); +#else + => Entropy.FromJoulesPerKelvin(value.ToDouble(null)); +#endif + + /// + public Entropy KilocaloriesPerKelvin +#if NET7_0_OR_GREATER + => Entropy.FromKilocaloriesPerKelvin(double.CreateChecked(value)); +#else + => Entropy.FromKilocaloriesPerKelvin(value.ToDouble(null)); +#endif + + /// + public Entropy KilojoulesPerDegreeCelsius +#if NET7_0_OR_GREATER + => Entropy.FromKilojoulesPerDegreeCelsius(double.CreateChecked(value)); +#else + => Entropy.FromKilojoulesPerDegreeCelsius(value.ToDouble(null)); +#endif + + /// + public Entropy KilojoulesPerKelvin +#if NET7_0_OR_GREATER + => Entropy.FromKilojoulesPerKelvin(double.CreateChecked(value)); +#else + => Entropy.FromKilojoulesPerKelvin(value.ToDouble(null)); +#endif + + /// + public Entropy MegajoulesPerKelvin +#if NET7_0_OR_GREATER + => Entropy.FromMegajoulesPerKelvin(double.CreateChecked(value)); +#else + => Entropy.FromMegajoulesPerKelvin(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToFluidResistanceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToFluidResistanceExtensions.g.cs new file mode 100644 index 0000000000..6c6101e38d --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToFluidResistanceExtensions.g.cs @@ -0,0 +1,199 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToFluidResistance +{ + /// + /// A number to FluidResistance Extensions + /// + public static class NumberToFluidResistanceExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public FluidResistance DyneSecondsPerCentimeterToTheFifth +#if NET7_0_OR_GREATER + => FluidResistance.FromDyneSecondsPerCentimeterToTheFifth(double.CreateChecked(value)); +#else + => FluidResistance.FromDyneSecondsPerCentimeterToTheFifth(value.ToDouble(null)); +#endif + + /// + public FluidResistance MegapascalSecondsPerCubicMeter +#if NET7_0_OR_GREATER + => FluidResistance.FromMegapascalSecondsPerCubicMeter(double.CreateChecked(value)); +#else + => FluidResistance.FromMegapascalSecondsPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public FluidResistance MillimeterMercuryMinutesPerCubicCentimeter +#if NET7_0_OR_GREATER + => FluidResistance.FromMillimeterMercuryMinutesPerCubicCentimeter(double.CreateChecked(value)); +#else + => FluidResistance.FromMillimeterMercuryMinutesPerCubicCentimeter(value.ToDouble(null)); +#endif + + /// + public FluidResistance MillimeterMercuryMinutesPerCubicMeter +#if NET7_0_OR_GREATER + => FluidResistance.FromMillimeterMercuryMinutesPerCubicMeter(double.CreateChecked(value)); +#else + => FluidResistance.FromMillimeterMercuryMinutesPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public FluidResistance MillimeterMercuryMinutesPerLiter +#if NET7_0_OR_GREATER + => FluidResistance.FromMillimeterMercuryMinutesPerLiter(double.CreateChecked(value)); +#else + => FluidResistance.FromMillimeterMercuryMinutesPerLiter(value.ToDouble(null)); +#endif + + /// + public FluidResistance MillimeterMercuryMinutesPerMilliliter +#if NET7_0_OR_GREATER + => FluidResistance.FromMillimeterMercuryMinutesPerMilliliter(double.CreateChecked(value)); +#else + => FluidResistance.FromMillimeterMercuryMinutesPerMilliliter(value.ToDouble(null)); +#endif + + /// + public FluidResistance MillimeterMercurySecondsPerCubicCentimeter +#if NET7_0_OR_GREATER + => FluidResistance.FromMillimeterMercurySecondsPerCubicCentimeter(double.CreateChecked(value)); +#else + => FluidResistance.FromMillimeterMercurySecondsPerCubicCentimeter(value.ToDouble(null)); +#endif + + /// + public FluidResistance MillimeterMercurySecondsPerCubicMeter +#if NET7_0_OR_GREATER + => FluidResistance.FromMillimeterMercurySecondsPerCubicMeter(double.CreateChecked(value)); +#else + => FluidResistance.FromMillimeterMercurySecondsPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public FluidResistance MillimeterMercurySecondsPerLiter +#if NET7_0_OR_GREATER + => FluidResistance.FromMillimeterMercurySecondsPerLiter(double.CreateChecked(value)); +#else + => FluidResistance.FromMillimeterMercurySecondsPerLiter(value.ToDouble(null)); +#endif + + /// + public FluidResistance MillimeterMercurySecondsPerMilliliter +#if NET7_0_OR_GREATER + => FluidResistance.FromMillimeterMercurySecondsPerMilliliter(double.CreateChecked(value)); +#else + => FluidResistance.FromMillimeterMercurySecondsPerMilliliter(value.ToDouble(null)); +#endif + + /// + public FluidResistance PascalMinutesPerCubicCentimeter +#if NET7_0_OR_GREATER + => FluidResistance.FromPascalMinutesPerCubicCentimeter(double.CreateChecked(value)); +#else + => FluidResistance.FromPascalMinutesPerCubicCentimeter(value.ToDouble(null)); +#endif + + /// + public FluidResistance PascalMinutesPerCubicMeter +#if NET7_0_OR_GREATER + => FluidResistance.FromPascalMinutesPerCubicMeter(double.CreateChecked(value)); +#else + => FluidResistance.FromPascalMinutesPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public FluidResistance PascalMinutesPerLiter +#if NET7_0_OR_GREATER + => FluidResistance.FromPascalMinutesPerLiter(double.CreateChecked(value)); +#else + => FluidResistance.FromPascalMinutesPerLiter(value.ToDouble(null)); +#endif + + /// + public FluidResistance PascalMinutesPerMilliliter +#if NET7_0_OR_GREATER + => FluidResistance.FromPascalMinutesPerMilliliter(double.CreateChecked(value)); +#else + => FluidResistance.FromPascalMinutesPerMilliliter(value.ToDouble(null)); +#endif + + /// + public FluidResistance PascalSecondsPerCubicCentimeter +#if NET7_0_OR_GREATER + => FluidResistance.FromPascalSecondsPerCubicCentimeter(double.CreateChecked(value)); +#else + => FluidResistance.FromPascalSecondsPerCubicCentimeter(value.ToDouble(null)); +#endif + + /// + public FluidResistance PascalSecondsPerCubicMeter +#if NET7_0_OR_GREATER + => FluidResistance.FromPascalSecondsPerCubicMeter(double.CreateChecked(value)); +#else + => FluidResistance.FromPascalSecondsPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public FluidResistance PascalSecondsPerLiter +#if NET7_0_OR_GREATER + => FluidResistance.FromPascalSecondsPerLiter(double.CreateChecked(value)); +#else + => FluidResistance.FromPascalSecondsPerLiter(value.ToDouble(null)); +#endif + + /// + public FluidResistance PascalSecondsPerMilliliter +#if NET7_0_OR_GREATER + => FluidResistance.FromPascalSecondsPerMilliliter(double.CreateChecked(value)); +#else + => FluidResistance.FromPascalSecondsPerMilliliter(value.ToDouble(null)); +#endif + + /// + public FluidResistance WoodUnits +#if NET7_0_OR_GREATER + => FluidResistance.FromWoodUnits(double.CreateChecked(value)); +#else + => FluidResistance.FromWoodUnits(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToForceChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToForceChangeRateExtensions.g.cs new file mode 100644 index 0000000000..9f66485090 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToForceChangeRateExtensions.g.cs @@ -0,0 +1,167 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToForceChangeRate +{ + /// + /// A number to ForceChangeRate Extensions + /// + public static class NumberToForceChangeRateExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public ForceChangeRate CentinewtonsPerSecond +#if NET7_0_OR_GREATER + => ForceChangeRate.FromCentinewtonsPerSecond(double.CreateChecked(value)); +#else + => ForceChangeRate.FromCentinewtonsPerSecond(value.ToDouble(null)); +#endif + + /// + public ForceChangeRate DecanewtonsPerMinute +#if NET7_0_OR_GREATER + => ForceChangeRate.FromDecanewtonsPerMinute(double.CreateChecked(value)); +#else + => ForceChangeRate.FromDecanewtonsPerMinute(value.ToDouble(null)); +#endif + + /// + public ForceChangeRate DecanewtonsPerSecond +#if NET7_0_OR_GREATER + => ForceChangeRate.FromDecanewtonsPerSecond(double.CreateChecked(value)); +#else + => ForceChangeRate.FromDecanewtonsPerSecond(value.ToDouble(null)); +#endif + + /// + public ForceChangeRate DecinewtonsPerSecond +#if NET7_0_OR_GREATER + => ForceChangeRate.FromDecinewtonsPerSecond(double.CreateChecked(value)); +#else + => ForceChangeRate.FromDecinewtonsPerSecond(value.ToDouble(null)); +#endif + + /// + public ForceChangeRate KilonewtonsPerMinute +#if NET7_0_OR_GREATER + => ForceChangeRate.FromKilonewtonsPerMinute(double.CreateChecked(value)); +#else + => ForceChangeRate.FromKilonewtonsPerMinute(value.ToDouble(null)); +#endif + + /// + public ForceChangeRate KilonewtonsPerSecond +#if NET7_0_OR_GREATER + => ForceChangeRate.FromKilonewtonsPerSecond(double.CreateChecked(value)); +#else + => ForceChangeRate.FromKilonewtonsPerSecond(value.ToDouble(null)); +#endif + + /// + public ForceChangeRate KilopoundsForcePerMinute +#if NET7_0_OR_GREATER + => ForceChangeRate.FromKilopoundsForcePerMinute(double.CreateChecked(value)); +#else + => ForceChangeRate.FromKilopoundsForcePerMinute(value.ToDouble(null)); +#endif + + /// + public ForceChangeRate KilopoundsForcePerSecond +#if NET7_0_OR_GREATER + => ForceChangeRate.FromKilopoundsForcePerSecond(double.CreateChecked(value)); +#else + => ForceChangeRate.FromKilopoundsForcePerSecond(value.ToDouble(null)); +#endif + + /// + public ForceChangeRate MicronewtonsPerSecond +#if NET7_0_OR_GREATER + => ForceChangeRate.FromMicronewtonsPerSecond(double.CreateChecked(value)); +#else + => ForceChangeRate.FromMicronewtonsPerSecond(value.ToDouble(null)); +#endif + + /// + public ForceChangeRate MillinewtonsPerSecond +#if NET7_0_OR_GREATER + => ForceChangeRate.FromMillinewtonsPerSecond(double.CreateChecked(value)); +#else + => ForceChangeRate.FromMillinewtonsPerSecond(value.ToDouble(null)); +#endif + + /// + public ForceChangeRate NanonewtonsPerSecond +#if NET7_0_OR_GREATER + => ForceChangeRate.FromNanonewtonsPerSecond(double.CreateChecked(value)); +#else + => ForceChangeRate.FromNanonewtonsPerSecond(value.ToDouble(null)); +#endif + + /// + public ForceChangeRate NewtonsPerMinute +#if NET7_0_OR_GREATER + => ForceChangeRate.FromNewtonsPerMinute(double.CreateChecked(value)); +#else + => ForceChangeRate.FromNewtonsPerMinute(value.ToDouble(null)); +#endif + + /// + public ForceChangeRate NewtonsPerSecond +#if NET7_0_OR_GREATER + => ForceChangeRate.FromNewtonsPerSecond(double.CreateChecked(value)); +#else + => ForceChangeRate.FromNewtonsPerSecond(value.ToDouble(null)); +#endif + + /// + public ForceChangeRate PoundsForcePerMinute +#if NET7_0_OR_GREATER + => ForceChangeRate.FromPoundsForcePerMinute(double.CreateChecked(value)); +#else + => ForceChangeRate.FromPoundsForcePerMinute(value.ToDouble(null)); +#endif + + /// + public ForceChangeRate PoundsForcePerSecond +#if NET7_0_OR_GREATER + => ForceChangeRate.FromPoundsForcePerSecond(double.CreateChecked(value)); +#else + => ForceChangeRate.FromPoundsForcePerSecond(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToForceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToForceExtensions.g.cs new file mode 100644 index 0000000000..2ace22a6e0 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToForceExtensions.g.cs @@ -0,0 +1,167 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToForce +{ + /// + /// A number to Force Extensions + /// + public static class NumberToForceExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Force Decanewtons +#if NET7_0_OR_GREATER + => Force.FromDecanewtons(double.CreateChecked(value)); +#else + => Force.FromDecanewtons(value.ToDouble(null)); +#endif + + /// + public Force Dyne +#if NET7_0_OR_GREATER + => Force.FromDyne(double.CreateChecked(value)); +#else + => Force.FromDyne(value.ToDouble(null)); +#endif + + /// + public Force KilogramsForce +#if NET7_0_OR_GREATER + => Force.FromKilogramsForce(double.CreateChecked(value)); +#else + => Force.FromKilogramsForce(value.ToDouble(null)); +#endif + + /// + public Force Kilonewtons +#if NET7_0_OR_GREATER + => Force.FromKilonewtons(double.CreateChecked(value)); +#else + => Force.FromKilonewtons(value.ToDouble(null)); +#endif + + /// + public Force Kiloponds +#if NET7_0_OR_GREATER + => Force.FromKiloponds(double.CreateChecked(value)); +#else + => Force.FromKiloponds(value.ToDouble(null)); +#endif + + /// + public Force KilopoundsForce +#if NET7_0_OR_GREATER + => Force.FromKilopoundsForce(double.CreateChecked(value)); +#else + => Force.FromKilopoundsForce(value.ToDouble(null)); +#endif + + /// + public Force Meganewtons +#if NET7_0_OR_GREATER + => Force.FromMeganewtons(double.CreateChecked(value)); +#else + => Force.FromMeganewtons(value.ToDouble(null)); +#endif + + /// + public Force Micronewtons +#if NET7_0_OR_GREATER + => Force.FromMicronewtons(double.CreateChecked(value)); +#else + => Force.FromMicronewtons(value.ToDouble(null)); +#endif + + /// + public Force Millinewtons +#if NET7_0_OR_GREATER + => Force.FromMillinewtons(double.CreateChecked(value)); +#else + => Force.FromMillinewtons(value.ToDouble(null)); +#endif + + /// + public Force Newtons +#if NET7_0_OR_GREATER + => Force.FromNewtons(double.CreateChecked(value)); +#else + => Force.FromNewtons(value.ToDouble(null)); +#endif + + /// + public Force OunceForce +#if NET7_0_OR_GREATER + => Force.FromOunceForce(double.CreateChecked(value)); +#else + => Force.FromOunceForce(value.ToDouble(null)); +#endif + + /// + public Force Poundals +#if NET7_0_OR_GREATER + => Force.FromPoundals(double.CreateChecked(value)); +#else + => Force.FromPoundals(value.ToDouble(null)); +#endif + + /// + public Force PoundsForce +#if NET7_0_OR_GREATER + => Force.FromPoundsForce(double.CreateChecked(value)); +#else + => Force.FromPoundsForce(value.ToDouble(null)); +#endif + + /// + public Force ShortTonsForce +#if NET7_0_OR_GREATER + => Force.FromShortTonsForce(double.CreateChecked(value)); +#else + => Force.FromShortTonsForce(value.ToDouble(null)); +#endif + + /// + public Force TonnesForce +#if NET7_0_OR_GREATER + => Force.FromTonnesForce(double.CreateChecked(value)); +#else + => Force.FromTonnesForce(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToForcePerLengthExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToForcePerLengthExtensions.g.cs new file mode 100644 index 0000000000..fb37a160c1 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToForcePerLengthExtensions.g.cs @@ -0,0 +1,351 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToForcePerLength +{ + /// + /// A number to ForcePerLength Extensions + /// + public static class NumberToForcePerLengthExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public ForcePerLength CentinewtonsPerCentimeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromCentinewtonsPerCentimeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromCentinewtonsPerCentimeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength CentinewtonsPerMeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromCentinewtonsPerMeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromCentinewtonsPerMeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength CentinewtonsPerMillimeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromCentinewtonsPerMillimeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromCentinewtonsPerMillimeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength DecanewtonsPerCentimeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromDecanewtonsPerCentimeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromDecanewtonsPerCentimeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength DecanewtonsPerMeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromDecanewtonsPerMeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromDecanewtonsPerMeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength DecanewtonsPerMillimeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromDecanewtonsPerMillimeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromDecanewtonsPerMillimeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength DecinewtonsPerCentimeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromDecinewtonsPerCentimeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromDecinewtonsPerCentimeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength DecinewtonsPerMeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromDecinewtonsPerMeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromDecinewtonsPerMeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength DecinewtonsPerMillimeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromDecinewtonsPerMillimeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromDecinewtonsPerMillimeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength KilogramsForcePerCentimeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromKilogramsForcePerCentimeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromKilogramsForcePerCentimeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength KilogramsForcePerMeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromKilogramsForcePerMeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromKilogramsForcePerMeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength KilogramsForcePerMillimeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromKilogramsForcePerMillimeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromKilogramsForcePerMillimeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength KilonewtonsPerCentimeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromKilonewtonsPerCentimeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromKilonewtonsPerCentimeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength KilonewtonsPerMeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromKilonewtonsPerMeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromKilonewtonsPerMeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength KilonewtonsPerMillimeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromKilonewtonsPerMillimeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromKilonewtonsPerMillimeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength KilopoundsForcePerFoot +#if NET7_0_OR_GREATER + => ForcePerLength.FromKilopoundsForcePerFoot(double.CreateChecked(value)); +#else + => ForcePerLength.FromKilopoundsForcePerFoot(value.ToDouble(null)); +#endif + + /// + public ForcePerLength KilopoundsForcePerInch +#if NET7_0_OR_GREATER + => ForcePerLength.FromKilopoundsForcePerInch(double.CreateChecked(value)); +#else + => ForcePerLength.FromKilopoundsForcePerInch(value.ToDouble(null)); +#endif + + /// + public ForcePerLength MeganewtonsPerCentimeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromMeganewtonsPerCentimeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromMeganewtonsPerCentimeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength MeganewtonsPerMeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromMeganewtonsPerMeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromMeganewtonsPerMeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength MeganewtonsPerMillimeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromMeganewtonsPerMillimeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromMeganewtonsPerMillimeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength MicronewtonsPerCentimeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromMicronewtonsPerCentimeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromMicronewtonsPerCentimeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength MicronewtonsPerMeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromMicronewtonsPerMeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromMicronewtonsPerMeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength MicronewtonsPerMillimeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromMicronewtonsPerMillimeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromMicronewtonsPerMillimeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength MillinewtonsPerCentimeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromMillinewtonsPerCentimeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromMillinewtonsPerCentimeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength MillinewtonsPerMeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromMillinewtonsPerMeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromMillinewtonsPerMeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength MillinewtonsPerMillimeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromMillinewtonsPerMillimeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromMillinewtonsPerMillimeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength NanonewtonsPerCentimeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromNanonewtonsPerCentimeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromNanonewtonsPerCentimeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength NanonewtonsPerMeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromNanonewtonsPerMeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromNanonewtonsPerMeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength NanonewtonsPerMillimeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromNanonewtonsPerMillimeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromNanonewtonsPerMillimeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength NewtonsPerCentimeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromNewtonsPerCentimeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromNewtonsPerCentimeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength NewtonsPerMeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromNewtonsPerMeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromNewtonsPerMeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength NewtonsPerMillimeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromNewtonsPerMillimeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromNewtonsPerMillimeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength PoundsForcePerFoot +#if NET7_0_OR_GREATER + => ForcePerLength.FromPoundsForcePerFoot(double.CreateChecked(value)); +#else + => ForcePerLength.FromPoundsForcePerFoot(value.ToDouble(null)); +#endif + + /// + public ForcePerLength PoundsForcePerInch +#if NET7_0_OR_GREATER + => ForcePerLength.FromPoundsForcePerInch(double.CreateChecked(value)); +#else + => ForcePerLength.FromPoundsForcePerInch(value.ToDouble(null)); +#endif + + /// + public ForcePerLength PoundsForcePerYard +#if NET7_0_OR_GREATER + => ForcePerLength.FromPoundsForcePerYard(double.CreateChecked(value)); +#else + => ForcePerLength.FromPoundsForcePerYard(value.ToDouble(null)); +#endif + + /// + public ForcePerLength TonnesForcePerCentimeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromTonnesForcePerCentimeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromTonnesForcePerCentimeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength TonnesForcePerMeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromTonnesForcePerMeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromTonnesForcePerMeter(value.ToDouble(null)); +#endif + + /// + public ForcePerLength TonnesForcePerMillimeter +#if NET7_0_OR_GREATER + => ForcePerLength.FromTonnesForcePerMillimeter(double.CreateChecked(value)); +#else + => ForcePerLength.FromTonnesForcePerMillimeter(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToFrequencyExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToFrequencyExtensions.g.cs new file mode 100644 index 0000000000..59ac6feb4e --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToFrequencyExtensions.g.cs @@ -0,0 +1,143 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToFrequency +{ + /// + /// A number to Frequency Extensions + /// + public static class NumberToFrequencyExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Frequency BeatsPerMinute +#if NET7_0_OR_GREATER + => Frequency.FromBeatsPerMinute(double.CreateChecked(value)); +#else + => Frequency.FromBeatsPerMinute(value.ToDouble(null)); +#endif + + /// + public Frequency CyclesPerHour +#if NET7_0_OR_GREATER + => Frequency.FromCyclesPerHour(double.CreateChecked(value)); +#else + => Frequency.FromCyclesPerHour(value.ToDouble(null)); +#endif + + /// + public Frequency CyclesPerMinute +#if NET7_0_OR_GREATER + => Frequency.FromCyclesPerMinute(double.CreateChecked(value)); +#else + => Frequency.FromCyclesPerMinute(value.ToDouble(null)); +#endif + + /// + public Frequency Gigahertz +#if NET7_0_OR_GREATER + => Frequency.FromGigahertz(double.CreateChecked(value)); +#else + => Frequency.FromGigahertz(value.ToDouble(null)); +#endif + + /// + public Frequency Hertz +#if NET7_0_OR_GREATER + => Frequency.FromHertz(double.CreateChecked(value)); +#else + => Frequency.FromHertz(value.ToDouble(null)); +#endif + + /// + public Frequency Kilohertz +#if NET7_0_OR_GREATER + => Frequency.FromKilohertz(double.CreateChecked(value)); +#else + => Frequency.FromKilohertz(value.ToDouble(null)); +#endif + + /// + public Frequency Megahertz +#if NET7_0_OR_GREATER + => Frequency.FromMegahertz(double.CreateChecked(value)); +#else + => Frequency.FromMegahertz(value.ToDouble(null)); +#endif + + /// + public Frequency Microhertz +#if NET7_0_OR_GREATER + => Frequency.FromMicrohertz(double.CreateChecked(value)); +#else + => Frequency.FromMicrohertz(value.ToDouble(null)); +#endif + + /// + public Frequency Millihertz +#if NET7_0_OR_GREATER + => Frequency.FromMillihertz(double.CreateChecked(value)); +#else + => Frequency.FromMillihertz(value.ToDouble(null)); +#endif + + /// + public Frequency PerSecond +#if NET7_0_OR_GREATER + => Frequency.FromPerSecond(double.CreateChecked(value)); +#else + => Frequency.FromPerSecond(value.ToDouble(null)); +#endif + + /// + public Frequency RadiansPerSecond +#if NET7_0_OR_GREATER + => Frequency.FromRadiansPerSecond(double.CreateChecked(value)); +#else + => Frequency.FromRadiansPerSecond(value.ToDouble(null)); +#endif + + /// + public Frequency Terahertz +#if NET7_0_OR_GREATER + => Frequency.FromTerahertz(double.CreateChecked(value)); +#else + => Frequency.FromTerahertz(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToFuelEfficiencyExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToFuelEfficiencyExtensions.g.cs new file mode 100644 index 0000000000..f0a7095afa --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToFuelEfficiencyExtensions.g.cs @@ -0,0 +1,79 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToFuelEfficiency +{ + /// + /// A number to FuelEfficiency Extensions + /// + public static class NumberToFuelEfficiencyExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public FuelEfficiency KilometersPerLiter +#if NET7_0_OR_GREATER + => FuelEfficiency.FromKilometersPerLiter(double.CreateChecked(value)); +#else + => FuelEfficiency.FromKilometersPerLiter(value.ToDouble(null)); +#endif + + /// + public FuelEfficiency LitersPer100Kilometers +#if NET7_0_OR_GREATER + => FuelEfficiency.FromLitersPer100Kilometers(double.CreateChecked(value)); +#else + => FuelEfficiency.FromLitersPer100Kilometers(value.ToDouble(null)); +#endif + + /// + public FuelEfficiency MilesPerUkGallon +#if NET7_0_OR_GREATER + => FuelEfficiency.FromMilesPerUkGallon(double.CreateChecked(value)); +#else + => FuelEfficiency.FromMilesPerUkGallon(value.ToDouble(null)); +#endif + + /// + public FuelEfficiency MilesPerUsGallon +#if NET7_0_OR_GREATER + => FuelEfficiency.FromMilesPerUsGallon(double.CreateChecked(value)); +#else + => FuelEfficiency.FromMilesPerUsGallon(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToHeatFluxExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToHeatFluxExtensions.g.cs new file mode 100644 index 0000000000..f7b649bafe --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToHeatFluxExtensions.g.cs @@ -0,0 +1,191 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToHeatFlux +{ + /// + /// A number to HeatFlux Extensions + /// + public static class NumberToHeatFluxExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public HeatFlux BtusPerHourSquareFoot +#if NET7_0_OR_GREATER + => HeatFlux.FromBtusPerHourSquareFoot(double.CreateChecked(value)); +#else + => HeatFlux.FromBtusPerHourSquareFoot(value.ToDouble(null)); +#endif + + /// + public HeatFlux BtusPerMinuteSquareFoot +#if NET7_0_OR_GREATER + => HeatFlux.FromBtusPerMinuteSquareFoot(double.CreateChecked(value)); +#else + => HeatFlux.FromBtusPerMinuteSquareFoot(value.ToDouble(null)); +#endif + + /// + public HeatFlux BtusPerSecondSquareFoot +#if NET7_0_OR_GREATER + => HeatFlux.FromBtusPerSecondSquareFoot(double.CreateChecked(value)); +#else + => HeatFlux.FromBtusPerSecondSquareFoot(value.ToDouble(null)); +#endif + + /// + public HeatFlux BtusPerSecondSquareInch +#if NET7_0_OR_GREATER + => HeatFlux.FromBtusPerSecondSquareInch(double.CreateChecked(value)); +#else + => HeatFlux.FromBtusPerSecondSquareInch(value.ToDouble(null)); +#endif + + /// + public HeatFlux CaloriesPerSecondSquareCentimeter +#if NET7_0_OR_GREATER + => HeatFlux.FromCaloriesPerSecondSquareCentimeter(double.CreateChecked(value)); +#else + => HeatFlux.FromCaloriesPerSecondSquareCentimeter(value.ToDouble(null)); +#endif + + /// + public HeatFlux CentiwattsPerSquareMeter +#if NET7_0_OR_GREATER + => HeatFlux.FromCentiwattsPerSquareMeter(double.CreateChecked(value)); +#else + => HeatFlux.FromCentiwattsPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public HeatFlux DeciwattsPerSquareMeter +#if NET7_0_OR_GREATER + => HeatFlux.FromDeciwattsPerSquareMeter(double.CreateChecked(value)); +#else + => HeatFlux.FromDeciwattsPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public HeatFlux KilocaloriesPerHourSquareMeter +#if NET7_0_OR_GREATER + => HeatFlux.FromKilocaloriesPerHourSquareMeter(double.CreateChecked(value)); +#else + => HeatFlux.FromKilocaloriesPerHourSquareMeter(value.ToDouble(null)); +#endif + + /// + public HeatFlux KilocaloriesPerSecondSquareCentimeter +#if NET7_0_OR_GREATER + => HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(double.CreateChecked(value)); +#else + => HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(value.ToDouble(null)); +#endif + + /// + public HeatFlux KilowattsPerSquareMeter +#if NET7_0_OR_GREATER + => HeatFlux.FromKilowattsPerSquareMeter(double.CreateChecked(value)); +#else + => HeatFlux.FromKilowattsPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public HeatFlux MicrowattsPerSquareMeter +#if NET7_0_OR_GREATER + => HeatFlux.FromMicrowattsPerSquareMeter(double.CreateChecked(value)); +#else + => HeatFlux.FromMicrowattsPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public HeatFlux MilliwattsPerSquareMeter +#if NET7_0_OR_GREATER + => HeatFlux.FromMilliwattsPerSquareMeter(double.CreateChecked(value)); +#else + => HeatFlux.FromMilliwattsPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public HeatFlux NanowattsPerSquareMeter +#if NET7_0_OR_GREATER + => HeatFlux.FromNanowattsPerSquareMeter(double.CreateChecked(value)); +#else + => HeatFlux.FromNanowattsPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public HeatFlux PoundsForcePerFootSecond +#if NET7_0_OR_GREATER + => HeatFlux.FromPoundsForcePerFootSecond(double.CreateChecked(value)); +#else + => HeatFlux.FromPoundsForcePerFootSecond(value.ToDouble(null)); +#endif + + /// + public HeatFlux PoundsPerSecondCubed +#if NET7_0_OR_GREATER + => HeatFlux.FromPoundsPerSecondCubed(double.CreateChecked(value)); +#else + => HeatFlux.FromPoundsPerSecondCubed(value.ToDouble(null)); +#endif + + /// + public HeatFlux WattsPerSquareFoot +#if NET7_0_OR_GREATER + => HeatFlux.FromWattsPerSquareFoot(double.CreateChecked(value)); +#else + => HeatFlux.FromWattsPerSquareFoot(value.ToDouble(null)); +#endif + + /// + public HeatFlux WattsPerSquareInch +#if NET7_0_OR_GREATER + => HeatFlux.FromWattsPerSquareInch(double.CreateChecked(value)); +#else + => HeatFlux.FromWattsPerSquareInch(value.ToDouble(null)); +#endif + + /// + public HeatFlux WattsPerSquareMeter +#if NET7_0_OR_GREATER + => HeatFlux.FromWattsPerSquareMeter(double.CreateChecked(value)); +#else + => HeatFlux.FromWattsPerSquareMeter(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToHeatTransferCoefficientExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToHeatTransferCoefficientExtensions.g.cs new file mode 100644 index 0000000000..275731d2e0 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToHeatTransferCoefficientExtensions.g.cs @@ -0,0 +1,87 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToHeatTransferCoefficient +{ + /// + /// A number to HeatTransferCoefficient Extensions + /// + public static class NumberToHeatTransferCoefficientExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public HeatTransferCoefficient BtusPerHourSquareFootDegreeFahrenheit +#if NET7_0_OR_GREATER + => HeatTransferCoefficient.FromBtusPerHourSquareFootDegreeFahrenheit(double.CreateChecked(value)); +#else + => HeatTransferCoefficient.FromBtusPerHourSquareFootDegreeFahrenheit(value.ToDouble(null)); +#endif + + /// + public HeatTransferCoefficient CaloriesPerHourSquareMeterDegreeCelsius +#if NET7_0_OR_GREATER + => HeatTransferCoefficient.FromCaloriesPerHourSquareMeterDegreeCelsius(double.CreateChecked(value)); +#else + => HeatTransferCoefficient.FromCaloriesPerHourSquareMeterDegreeCelsius(value.ToDouble(null)); +#endif + + /// + public HeatTransferCoefficient KilocaloriesPerHourSquareMeterDegreeCelsius +#if NET7_0_OR_GREATER + => HeatTransferCoefficient.FromKilocaloriesPerHourSquareMeterDegreeCelsius(double.CreateChecked(value)); +#else + => HeatTransferCoefficient.FromKilocaloriesPerHourSquareMeterDegreeCelsius(value.ToDouble(null)); +#endif + + /// + public HeatTransferCoefficient WattsPerSquareMeterCelsius +#if NET7_0_OR_GREATER + => HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(double.CreateChecked(value)); +#else + => HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(value.ToDouble(null)); +#endif + + /// + public HeatTransferCoefficient WattsPerSquareMeterKelvin +#if NET7_0_OR_GREATER + => HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(double.CreateChecked(value)); +#else + => HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToIlluminanceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToIlluminanceExtensions.g.cs new file mode 100644 index 0000000000..bd3195f004 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToIlluminanceExtensions.g.cs @@ -0,0 +1,79 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToIlluminance +{ + /// + /// A number to Illuminance Extensions + /// + public static class NumberToIlluminanceExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Illuminance Kilolux +#if NET7_0_OR_GREATER + => Illuminance.FromKilolux(double.CreateChecked(value)); +#else + => Illuminance.FromKilolux(value.ToDouble(null)); +#endif + + /// + public Illuminance Lux +#if NET7_0_OR_GREATER + => Illuminance.FromLux(double.CreateChecked(value)); +#else + => Illuminance.FromLux(value.ToDouble(null)); +#endif + + /// + public Illuminance Megalux +#if NET7_0_OR_GREATER + => Illuminance.FromMegalux(double.CreateChecked(value)); +#else + => Illuminance.FromMegalux(value.ToDouble(null)); +#endif + + /// + public Illuminance Millilux +#if NET7_0_OR_GREATER + => Illuminance.FromMillilux(double.CreateChecked(value)); +#else + => Illuminance.FromMillilux(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToImpulseExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToImpulseExtensions.g.cs new file mode 100644 index 0000000000..d85140e38e --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToImpulseExtensions.g.cs @@ -0,0 +1,151 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToImpulse +{ + /// + /// A number to Impulse Extensions + /// + public static class NumberToImpulseExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Impulse CentinewtonSeconds +#if NET7_0_OR_GREATER + => Impulse.FromCentinewtonSeconds(double.CreateChecked(value)); +#else + => Impulse.FromCentinewtonSeconds(value.ToDouble(null)); +#endif + + /// + public Impulse DecanewtonSeconds +#if NET7_0_OR_GREATER + => Impulse.FromDecanewtonSeconds(double.CreateChecked(value)); +#else + => Impulse.FromDecanewtonSeconds(value.ToDouble(null)); +#endif + + /// + public Impulse DecinewtonSeconds +#if NET7_0_OR_GREATER + => Impulse.FromDecinewtonSeconds(double.CreateChecked(value)); +#else + => Impulse.FromDecinewtonSeconds(value.ToDouble(null)); +#endif + + /// + public Impulse KilogramMetersPerSecond +#if NET7_0_OR_GREATER + => Impulse.FromKilogramMetersPerSecond(double.CreateChecked(value)); +#else + => Impulse.FromKilogramMetersPerSecond(value.ToDouble(null)); +#endif + + /// + public Impulse KilonewtonSeconds +#if NET7_0_OR_GREATER + => Impulse.FromKilonewtonSeconds(double.CreateChecked(value)); +#else + => Impulse.FromKilonewtonSeconds(value.ToDouble(null)); +#endif + + /// + public Impulse MeganewtonSeconds +#if NET7_0_OR_GREATER + => Impulse.FromMeganewtonSeconds(double.CreateChecked(value)); +#else + => Impulse.FromMeganewtonSeconds(value.ToDouble(null)); +#endif + + /// + public Impulse MicronewtonSeconds +#if NET7_0_OR_GREATER + => Impulse.FromMicronewtonSeconds(double.CreateChecked(value)); +#else + => Impulse.FromMicronewtonSeconds(value.ToDouble(null)); +#endif + + /// + public Impulse MillinewtonSeconds +#if NET7_0_OR_GREATER + => Impulse.FromMillinewtonSeconds(double.CreateChecked(value)); +#else + => Impulse.FromMillinewtonSeconds(value.ToDouble(null)); +#endif + + /// + public Impulse NanonewtonSeconds +#if NET7_0_OR_GREATER + => Impulse.FromNanonewtonSeconds(double.CreateChecked(value)); +#else + => Impulse.FromNanonewtonSeconds(value.ToDouble(null)); +#endif + + /// + public Impulse NewtonSeconds +#if NET7_0_OR_GREATER + => Impulse.FromNewtonSeconds(double.CreateChecked(value)); +#else + => Impulse.FromNewtonSeconds(value.ToDouble(null)); +#endif + + /// + public Impulse PoundFeetPerSecond +#if NET7_0_OR_GREATER + => Impulse.FromPoundFeetPerSecond(double.CreateChecked(value)); +#else + => Impulse.FromPoundFeetPerSecond(value.ToDouble(null)); +#endif + + /// + public Impulse PoundForceSeconds +#if NET7_0_OR_GREATER + => Impulse.FromPoundForceSeconds(double.CreateChecked(value)); +#else + => Impulse.FromPoundForceSeconds(value.ToDouble(null)); +#endif + + /// + public Impulse SlugFeetPerSecond +#if NET7_0_OR_GREATER + => Impulse.FromSlugFeetPerSecond(double.CreateChecked(value)); +#else + => Impulse.FromSlugFeetPerSecond(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToInformationExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToInformationExtensions.g.cs new file mode 100644 index 0000000000..8cc433e6c3 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToInformationExtensions.g.cs @@ -0,0 +1,359 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToInformation +{ + /// + /// A number to Information Extensions + /// + public static class NumberToInformationExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Information Bits +#if NET7_0_OR_GREATER + => Information.FromBits(double.CreateChecked(value)); +#else + => Information.FromBits(value.ToDouble(null)); +#endif + + /// + public Information Bytes +#if NET7_0_OR_GREATER + => Information.FromBytes(double.CreateChecked(value)); +#else + => Information.FromBytes(value.ToDouble(null)); +#endif + + /// + public Information Exabits +#if NET7_0_OR_GREATER + => Information.FromExabits(double.CreateChecked(value)); +#else + => Information.FromExabits(value.ToDouble(null)); +#endif + + /// + public Information Exabytes +#if NET7_0_OR_GREATER + => Information.FromExabytes(double.CreateChecked(value)); +#else + => Information.FromExabytes(value.ToDouble(null)); +#endif + + /// + public Information Exaoctets +#if NET7_0_OR_GREATER + => Information.FromExaoctets(double.CreateChecked(value)); +#else + => Information.FromExaoctets(value.ToDouble(null)); +#endif + + /// + public Information Exbibits +#if NET7_0_OR_GREATER + => Information.FromExbibits(double.CreateChecked(value)); +#else + => Information.FromExbibits(value.ToDouble(null)); +#endif + + /// + public Information Exbibytes +#if NET7_0_OR_GREATER + => Information.FromExbibytes(double.CreateChecked(value)); +#else + => Information.FromExbibytes(value.ToDouble(null)); +#endif + + /// + public Information Exbioctets +#if NET7_0_OR_GREATER + => Information.FromExbioctets(double.CreateChecked(value)); +#else + => Information.FromExbioctets(value.ToDouble(null)); +#endif + + /// + public Information Gibibits +#if NET7_0_OR_GREATER + => Information.FromGibibits(double.CreateChecked(value)); +#else + => Information.FromGibibits(value.ToDouble(null)); +#endif + + /// + public Information Gibibytes +#if NET7_0_OR_GREATER + => Information.FromGibibytes(double.CreateChecked(value)); +#else + => Information.FromGibibytes(value.ToDouble(null)); +#endif + + /// + public Information Gibioctets +#if NET7_0_OR_GREATER + => Information.FromGibioctets(double.CreateChecked(value)); +#else + => Information.FromGibioctets(value.ToDouble(null)); +#endif + + /// + public Information Gigabits +#if NET7_0_OR_GREATER + => Information.FromGigabits(double.CreateChecked(value)); +#else + => Information.FromGigabits(value.ToDouble(null)); +#endif + + /// + public Information Gigabytes +#if NET7_0_OR_GREATER + => Information.FromGigabytes(double.CreateChecked(value)); +#else + => Information.FromGigabytes(value.ToDouble(null)); +#endif + + /// + public Information Gigaoctets +#if NET7_0_OR_GREATER + => Information.FromGigaoctets(double.CreateChecked(value)); +#else + => Information.FromGigaoctets(value.ToDouble(null)); +#endif + + /// + public Information Kibibits +#if NET7_0_OR_GREATER + => Information.FromKibibits(double.CreateChecked(value)); +#else + => Information.FromKibibits(value.ToDouble(null)); +#endif + + /// + public Information Kibibytes +#if NET7_0_OR_GREATER + => Information.FromKibibytes(double.CreateChecked(value)); +#else + => Information.FromKibibytes(value.ToDouble(null)); +#endif + + /// + public Information Kibioctets +#if NET7_0_OR_GREATER + => Information.FromKibioctets(double.CreateChecked(value)); +#else + => Information.FromKibioctets(value.ToDouble(null)); +#endif + + /// + public Information Kilobits +#if NET7_0_OR_GREATER + => Information.FromKilobits(double.CreateChecked(value)); +#else + => Information.FromKilobits(value.ToDouble(null)); +#endif + + /// + public Information Kilobytes +#if NET7_0_OR_GREATER + => Information.FromKilobytes(double.CreateChecked(value)); +#else + => Information.FromKilobytes(value.ToDouble(null)); +#endif + + /// + public Information Kilooctets +#if NET7_0_OR_GREATER + => Information.FromKilooctets(double.CreateChecked(value)); +#else + => Information.FromKilooctets(value.ToDouble(null)); +#endif + + /// + public Information Mebibits +#if NET7_0_OR_GREATER + => Information.FromMebibits(double.CreateChecked(value)); +#else + => Information.FromMebibits(value.ToDouble(null)); +#endif + + /// + public Information Mebibytes +#if NET7_0_OR_GREATER + => Information.FromMebibytes(double.CreateChecked(value)); +#else + => Information.FromMebibytes(value.ToDouble(null)); +#endif + + /// + public Information Mebioctets +#if NET7_0_OR_GREATER + => Information.FromMebioctets(double.CreateChecked(value)); +#else + => Information.FromMebioctets(value.ToDouble(null)); +#endif + + /// + public Information Megabits +#if NET7_0_OR_GREATER + => Information.FromMegabits(double.CreateChecked(value)); +#else + => Information.FromMegabits(value.ToDouble(null)); +#endif + + /// + public Information Megabytes +#if NET7_0_OR_GREATER + => Information.FromMegabytes(double.CreateChecked(value)); +#else + => Information.FromMegabytes(value.ToDouble(null)); +#endif + + /// + public Information Megaoctets +#if NET7_0_OR_GREATER + => Information.FromMegaoctets(double.CreateChecked(value)); +#else + => Information.FromMegaoctets(value.ToDouble(null)); +#endif + + /// + public Information Octets +#if NET7_0_OR_GREATER + => Information.FromOctets(double.CreateChecked(value)); +#else + => Information.FromOctets(value.ToDouble(null)); +#endif + + /// + public Information Pebibits +#if NET7_0_OR_GREATER + => Information.FromPebibits(double.CreateChecked(value)); +#else + => Information.FromPebibits(value.ToDouble(null)); +#endif + + /// + public Information Pebibytes +#if NET7_0_OR_GREATER + => Information.FromPebibytes(double.CreateChecked(value)); +#else + => Information.FromPebibytes(value.ToDouble(null)); +#endif + + /// + public Information Pebioctets +#if NET7_0_OR_GREATER + => Information.FromPebioctets(double.CreateChecked(value)); +#else + => Information.FromPebioctets(value.ToDouble(null)); +#endif + + /// + public Information Petabits +#if NET7_0_OR_GREATER + => Information.FromPetabits(double.CreateChecked(value)); +#else + => Information.FromPetabits(value.ToDouble(null)); +#endif + + /// + public Information Petabytes +#if NET7_0_OR_GREATER + => Information.FromPetabytes(double.CreateChecked(value)); +#else + => Information.FromPetabytes(value.ToDouble(null)); +#endif + + /// + public Information Petaoctets +#if NET7_0_OR_GREATER + => Information.FromPetaoctets(double.CreateChecked(value)); +#else + => Information.FromPetaoctets(value.ToDouble(null)); +#endif + + /// + public Information Tebibits +#if NET7_0_OR_GREATER + => Information.FromTebibits(double.CreateChecked(value)); +#else + => Information.FromTebibits(value.ToDouble(null)); +#endif + + /// + public Information Tebibytes +#if NET7_0_OR_GREATER + => Information.FromTebibytes(double.CreateChecked(value)); +#else + => Information.FromTebibytes(value.ToDouble(null)); +#endif + + /// + public Information Tebioctets +#if NET7_0_OR_GREATER + => Information.FromTebioctets(double.CreateChecked(value)); +#else + => Information.FromTebioctets(value.ToDouble(null)); +#endif + + /// + public Information Terabits +#if NET7_0_OR_GREATER + => Information.FromTerabits(double.CreateChecked(value)); +#else + => Information.FromTerabits(value.ToDouble(null)); +#endif + + /// + public Information Terabytes +#if NET7_0_OR_GREATER + => Information.FromTerabytes(double.CreateChecked(value)); +#else + => Information.FromTerabytes(value.ToDouble(null)); +#endif + + /// + public Information Teraoctets +#if NET7_0_OR_GREATER + => Information.FromTeraoctets(double.CreateChecked(value)); +#else + => Information.FromTeraoctets(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToIrradianceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToIrradianceExtensions.g.cs new file mode 100644 index 0000000000..61ae70193c --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToIrradianceExtensions.g.cs @@ -0,0 +1,159 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToIrradiance +{ + /// + /// A number to Irradiance Extensions + /// + public static class NumberToIrradianceExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Irradiance KilowattsPerSquareCentimeter +#if NET7_0_OR_GREATER + => Irradiance.FromKilowattsPerSquareCentimeter(double.CreateChecked(value)); +#else + => Irradiance.FromKilowattsPerSquareCentimeter(value.ToDouble(null)); +#endif + + /// + public Irradiance KilowattsPerSquareMeter +#if NET7_0_OR_GREATER + => Irradiance.FromKilowattsPerSquareMeter(double.CreateChecked(value)); +#else + => Irradiance.FromKilowattsPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public Irradiance MegawattsPerSquareCentimeter +#if NET7_0_OR_GREATER + => Irradiance.FromMegawattsPerSquareCentimeter(double.CreateChecked(value)); +#else + => Irradiance.FromMegawattsPerSquareCentimeter(value.ToDouble(null)); +#endif + + /// + public Irradiance MegawattsPerSquareMeter +#if NET7_0_OR_GREATER + => Irradiance.FromMegawattsPerSquareMeter(double.CreateChecked(value)); +#else + => Irradiance.FromMegawattsPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public Irradiance MicrowattsPerSquareCentimeter +#if NET7_0_OR_GREATER + => Irradiance.FromMicrowattsPerSquareCentimeter(double.CreateChecked(value)); +#else + => Irradiance.FromMicrowattsPerSquareCentimeter(value.ToDouble(null)); +#endif + + /// + public Irradiance MicrowattsPerSquareMeter +#if NET7_0_OR_GREATER + => Irradiance.FromMicrowattsPerSquareMeter(double.CreateChecked(value)); +#else + => Irradiance.FromMicrowattsPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public Irradiance MilliwattsPerSquareCentimeter +#if NET7_0_OR_GREATER + => Irradiance.FromMilliwattsPerSquareCentimeter(double.CreateChecked(value)); +#else + => Irradiance.FromMilliwattsPerSquareCentimeter(value.ToDouble(null)); +#endif + + /// + public Irradiance MilliwattsPerSquareMeter +#if NET7_0_OR_GREATER + => Irradiance.FromMilliwattsPerSquareMeter(double.CreateChecked(value)); +#else + => Irradiance.FromMilliwattsPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public Irradiance NanowattsPerSquareCentimeter +#if NET7_0_OR_GREATER + => Irradiance.FromNanowattsPerSquareCentimeter(double.CreateChecked(value)); +#else + => Irradiance.FromNanowattsPerSquareCentimeter(value.ToDouble(null)); +#endif + + /// + public Irradiance NanowattsPerSquareMeter +#if NET7_0_OR_GREATER + => Irradiance.FromNanowattsPerSquareMeter(double.CreateChecked(value)); +#else + => Irradiance.FromNanowattsPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public Irradiance PicowattsPerSquareCentimeter +#if NET7_0_OR_GREATER + => Irradiance.FromPicowattsPerSquareCentimeter(double.CreateChecked(value)); +#else + => Irradiance.FromPicowattsPerSquareCentimeter(value.ToDouble(null)); +#endif + + /// + public Irradiance PicowattsPerSquareMeter +#if NET7_0_OR_GREATER + => Irradiance.FromPicowattsPerSquareMeter(double.CreateChecked(value)); +#else + => Irradiance.FromPicowattsPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public Irradiance WattsPerSquareCentimeter +#if NET7_0_OR_GREATER + => Irradiance.FromWattsPerSquareCentimeter(double.CreateChecked(value)); +#else + => Irradiance.FromWattsPerSquareCentimeter(value.ToDouble(null)); +#endif + + /// + public Irradiance WattsPerSquareMeter +#if NET7_0_OR_GREATER + => Irradiance.FromWattsPerSquareMeter(double.CreateChecked(value)); +#else + => Irradiance.FromWattsPerSquareMeter(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToIrradiationExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToIrradiationExtensions.g.cs new file mode 100644 index 0000000000..4a873284ec --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToIrradiationExtensions.g.cs @@ -0,0 +1,119 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToIrradiation +{ + /// + /// A number to Irradiation Extensions + /// + public static class NumberToIrradiationExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Irradiation BtusPerSquareFoot +#if NET7_0_OR_GREATER + => Irradiation.FromBtusPerSquareFoot(double.CreateChecked(value)); +#else + => Irradiation.FromBtusPerSquareFoot(value.ToDouble(null)); +#endif + + /// + public Irradiation JoulesPerSquareCentimeter +#if NET7_0_OR_GREATER + => Irradiation.FromJoulesPerSquareCentimeter(double.CreateChecked(value)); +#else + => Irradiation.FromJoulesPerSquareCentimeter(value.ToDouble(null)); +#endif + + /// + public Irradiation JoulesPerSquareMeter +#if NET7_0_OR_GREATER + => Irradiation.FromJoulesPerSquareMeter(double.CreateChecked(value)); +#else + => Irradiation.FromJoulesPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public Irradiation JoulesPerSquareMillimeter +#if NET7_0_OR_GREATER + => Irradiation.FromJoulesPerSquareMillimeter(double.CreateChecked(value)); +#else + => Irradiation.FromJoulesPerSquareMillimeter(value.ToDouble(null)); +#endif + + /// + public Irradiation KilobtusPerSquareFoot +#if NET7_0_OR_GREATER + => Irradiation.FromKilobtusPerSquareFoot(double.CreateChecked(value)); +#else + => Irradiation.FromKilobtusPerSquareFoot(value.ToDouble(null)); +#endif + + /// + public Irradiation KilojoulesPerSquareMeter +#if NET7_0_OR_GREATER + => Irradiation.FromKilojoulesPerSquareMeter(double.CreateChecked(value)); +#else + => Irradiation.FromKilojoulesPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public Irradiation KilowattHoursPerSquareMeter +#if NET7_0_OR_GREATER + => Irradiation.FromKilowattHoursPerSquareMeter(double.CreateChecked(value)); +#else + => Irradiation.FromKilowattHoursPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public Irradiation MillijoulesPerSquareCentimeter +#if NET7_0_OR_GREATER + => Irradiation.FromMillijoulesPerSquareCentimeter(double.CreateChecked(value)); +#else + => Irradiation.FromMillijoulesPerSquareCentimeter(value.ToDouble(null)); +#endif + + /// + public Irradiation WattHoursPerSquareMeter +#if NET7_0_OR_GREATER + => Irradiation.FromWattHoursPerSquareMeter(double.CreateChecked(value)); +#else + => Irradiation.FromWattHoursPerSquareMeter(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToJerkExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToJerkExtensions.g.cs new file mode 100644 index 0000000000..0f7e6a25da --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToJerkExtensions.g.cs @@ -0,0 +1,135 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToJerk +{ + /// + /// A number to Jerk Extensions + /// + public static class NumberToJerkExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Jerk CentimetersPerSecondCubed +#if NET7_0_OR_GREATER + => Jerk.FromCentimetersPerSecondCubed(double.CreateChecked(value)); +#else + => Jerk.FromCentimetersPerSecondCubed(value.ToDouble(null)); +#endif + + /// + public Jerk DecimetersPerSecondCubed +#if NET7_0_OR_GREATER + => Jerk.FromDecimetersPerSecondCubed(double.CreateChecked(value)); +#else + => Jerk.FromDecimetersPerSecondCubed(value.ToDouble(null)); +#endif + + /// + public Jerk FeetPerSecondCubed +#if NET7_0_OR_GREATER + => Jerk.FromFeetPerSecondCubed(double.CreateChecked(value)); +#else + => Jerk.FromFeetPerSecondCubed(value.ToDouble(null)); +#endif + + /// + public Jerk InchesPerSecondCubed +#if NET7_0_OR_GREATER + => Jerk.FromInchesPerSecondCubed(double.CreateChecked(value)); +#else + => Jerk.FromInchesPerSecondCubed(value.ToDouble(null)); +#endif + + /// + public Jerk KilometersPerSecondCubed +#if NET7_0_OR_GREATER + => Jerk.FromKilometersPerSecondCubed(double.CreateChecked(value)); +#else + => Jerk.FromKilometersPerSecondCubed(value.ToDouble(null)); +#endif + + /// + public Jerk MetersPerSecondCubed +#if NET7_0_OR_GREATER + => Jerk.FromMetersPerSecondCubed(double.CreateChecked(value)); +#else + => Jerk.FromMetersPerSecondCubed(value.ToDouble(null)); +#endif + + /// + public Jerk MicrometersPerSecondCubed +#if NET7_0_OR_GREATER + => Jerk.FromMicrometersPerSecondCubed(double.CreateChecked(value)); +#else + => Jerk.FromMicrometersPerSecondCubed(value.ToDouble(null)); +#endif + + /// + public Jerk MillimetersPerSecondCubed +#if NET7_0_OR_GREATER + => Jerk.FromMillimetersPerSecondCubed(double.CreateChecked(value)); +#else + => Jerk.FromMillimetersPerSecondCubed(value.ToDouble(null)); +#endif + + /// + public Jerk MillistandardGravitiesPerSecond +#if NET7_0_OR_GREATER + => Jerk.FromMillistandardGravitiesPerSecond(double.CreateChecked(value)); +#else + => Jerk.FromMillistandardGravitiesPerSecond(value.ToDouble(null)); +#endif + + /// + public Jerk NanometersPerSecondCubed +#if NET7_0_OR_GREATER + => Jerk.FromNanometersPerSecondCubed(double.CreateChecked(value)); +#else + => Jerk.FromNanometersPerSecondCubed(value.ToDouble(null)); +#endif + + /// + public Jerk StandardGravitiesPerSecond +#if NET7_0_OR_GREATER + => Jerk.FromStandardGravitiesPerSecond(double.CreateChecked(value)); +#else + => Jerk.FromStandardGravitiesPerSecond(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToKinematicViscosityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToKinematicViscosityExtensions.g.cs new file mode 100644 index 0000000000..2106f8c877 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToKinematicViscosityExtensions.g.cs @@ -0,0 +1,119 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToKinematicViscosity +{ + /// + /// A number to KinematicViscosity Extensions + /// + public static class NumberToKinematicViscosityExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public KinematicViscosity Centistokes +#if NET7_0_OR_GREATER + => KinematicViscosity.FromCentistokes(double.CreateChecked(value)); +#else + => KinematicViscosity.FromCentistokes(value.ToDouble(null)); +#endif + + /// + public KinematicViscosity Decistokes +#if NET7_0_OR_GREATER + => KinematicViscosity.FromDecistokes(double.CreateChecked(value)); +#else + => KinematicViscosity.FromDecistokes(value.ToDouble(null)); +#endif + + /// + public KinematicViscosity Kilostokes +#if NET7_0_OR_GREATER + => KinematicViscosity.FromKilostokes(double.CreateChecked(value)); +#else + => KinematicViscosity.FromKilostokes(value.ToDouble(null)); +#endif + + /// + public KinematicViscosity Microstokes +#if NET7_0_OR_GREATER + => KinematicViscosity.FromMicrostokes(double.CreateChecked(value)); +#else + => KinematicViscosity.FromMicrostokes(value.ToDouble(null)); +#endif + + /// + public KinematicViscosity Millistokes +#if NET7_0_OR_GREATER + => KinematicViscosity.FromMillistokes(double.CreateChecked(value)); +#else + => KinematicViscosity.FromMillistokes(value.ToDouble(null)); +#endif + + /// + public KinematicViscosity Nanostokes +#if NET7_0_OR_GREATER + => KinematicViscosity.FromNanostokes(double.CreateChecked(value)); +#else + => KinematicViscosity.FromNanostokes(value.ToDouble(null)); +#endif + + /// + public KinematicViscosity SquareFeetPerSecond +#if NET7_0_OR_GREATER + => KinematicViscosity.FromSquareFeetPerSecond(double.CreateChecked(value)); +#else + => KinematicViscosity.FromSquareFeetPerSecond(value.ToDouble(null)); +#endif + + /// + public KinematicViscosity SquareMetersPerSecond +#if NET7_0_OR_GREATER + => KinematicViscosity.FromSquareMetersPerSecond(double.CreateChecked(value)); +#else + => KinematicViscosity.FromSquareMetersPerSecond(value.ToDouble(null)); +#endif + + /// + public KinematicViscosity Stokes +#if NET7_0_OR_GREATER + => KinematicViscosity.FromStokes(double.CreateChecked(value)); +#else + => KinematicViscosity.FromStokes(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLeakRateExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLeakRateExtensions.g.cs new file mode 100644 index 0000000000..4945d7541c --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLeakRateExtensions.g.cs @@ -0,0 +1,79 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToLeakRate +{ + /// + /// A number to LeakRate Extensions + /// + public static class NumberToLeakRateExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public LeakRate AtmCubicCentimetersPerSecond +#if NET7_0_OR_GREATER + => LeakRate.FromAtmCubicCentimetersPerSecond(double.CreateChecked(value)); +#else + => LeakRate.FromAtmCubicCentimetersPerSecond(value.ToDouble(null)); +#endif + + /// + public LeakRate MillibarLitersPerSecond +#if NET7_0_OR_GREATER + => LeakRate.FromMillibarLitersPerSecond(double.CreateChecked(value)); +#else + => LeakRate.FromMillibarLitersPerSecond(value.ToDouble(null)); +#endif + + /// + public LeakRate PascalCubicMetersPerSecond +#if NET7_0_OR_GREATER + => LeakRate.FromPascalCubicMetersPerSecond(double.CreateChecked(value)); +#else + => LeakRate.FromPascalCubicMetersPerSecond(value.ToDouble(null)); +#endif + + /// + public LeakRate TorrLitersPerSecond +#if NET7_0_OR_GREATER + => LeakRate.FromTorrLitersPerSecond(double.CreateChecked(value)); +#else + => LeakRate.FromTorrLitersPerSecond(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLengthExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLengthExtensions.g.cs new file mode 100644 index 0000000000..716ebe78b0 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLengthExtensions.g.cs @@ -0,0 +1,383 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToLength +{ + /// + /// A number to Length Extensions + /// + public static class NumberToLengthExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Length Angstroms +#if NET7_0_OR_GREATER + => Length.FromAngstroms(double.CreateChecked(value)); +#else + => Length.FromAngstroms(value.ToDouble(null)); +#endif + + /// + public Length AstronomicalUnits +#if NET7_0_OR_GREATER + => Length.FromAstronomicalUnits(double.CreateChecked(value)); +#else + => Length.FromAstronomicalUnits(value.ToDouble(null)); +#endif + + /// + public Length Centimeters +#if NET7_0_OR_GREATER + => Length.FromCentimeters(double.CreateChecked(value)); +#else + => Length.FromCentimeters(value.ToDouble(null)); +#endif + + /// + public Length Chains +#if NET7_0_OR_GREATER + => Length.FromChains(double.CreateChecked(value)); +#else + => Length.FromChains(value.ToDouble(null)); +#endif + + /// + public Length DataMiles +#if NET7_0_OR_GREATER + => Length.FromDataMiles(double.CreateChecked(value)); +#else + => Length.FromDataMiles(value.ToDouble(null)); +#endif + + /// + public Length Decameters +#if NET7_0_OR_GREATER + => Length.FromDecameters(double.CreateChecked(value)); +#else + => Length.FromDecameters(value.ToDouble(null)); +#endif + + /// + public Length Decimeters +#if NET7_0_OR_GREATER + => Length.FromDecimeters(double.CreateChecked(value)); +#else + => Length.FromDecimeters(value.ToDouble(null)); +#endif + + /// + public Length DtpPicas +#if NET7_0_OR_GREATER + => Length.FromDtpPicas(double.CreateChecked(value)); +#else + => Length.FromDtpPicas(value.ToDouble(null)); +#endif + + /// + public Length DtpPoints +#if NET7_0_OR_GREATER + => Length.FromDtpPoints(double.CreateChecked(value)); +#else + => Length.FromDtpPoints(value.ToDouble(null)); +#endif + + /// + public Length Fathoms +#if NET7_0_OR_GREATER + => Length.FromFathoms(double.CreateChecked(value)); +#else + => Length.FromFathoms(value.ToDouble(null)); +#endif + + /// + public Length Femtometers +#if NET7_0_OR_GREATER + => Length.FromFemtometers(double.CreateChecked(value)); +#else + => Length.FromFemtometers(value.ToDouble(null)); +#endif + + /// + public Length Feet +#if NET7_0_OR_GREATER + => Length.FromFeet(double.CreateChecked(value)); +#else + => Length.FromFeet(value.ToDouble(null)); +#endif + + /// + public Length Gigameters +#if NET7_0_OR_GREATER + => Length.FromGigameters(double.CreateChecked(value)); +#else + => Length.FromGigameters(value.ToDouble(null)); +#endif + + /// + public Length Hands +#if NET7_0_OR_GREATER + => Length.FromHands(double.CreateChecked(value)); +#else + => Length.FromHands(value.ToDouble(null)); +#endif + + /// + public Length Hectometers +#if NET7_0_OR_GREATER + => Length.FromHectometers(double.CreateChecked(value)); +#else + => Length.FromHectometers(value.ToDouble(null)); +#endif + + /// + public Length Inches +#if NET7_0_OR_GREATER + => Length.FromInches(double.CreateChecked(value)); +#else + => Length.FromInches(value.ToDouble(null)); +#endif + + /// + public Length Kilofeet +#if NET7_0_OR_GREATER + => Length.FromKilofeet(double.CreateChecked(value)); +#else + => Length.FromKilofeet(value.ToDouble(null)); +#endif + + /// + public Length KilolightYears +#if NET7_0_OR_GREATER + => Length.FromKilolightYears(double.CreateChecked(value)); +#else + => Length.FromKilolightYears(value.ToDouble(null)); +#endif + + /// + public Length Kilometers +#if NET7_0_OR_GREATER + => Length.FromKilometers(double.CreateChecked(value)); +#else + => Length.FromKilometers(value.ToDouble(null)); +#endif + + /// + public Length Kiloparsecs +#if NET7_0_OR_GREATER + => Length.FromKiloparsecs(double.CreateChecked(value)); +#else + => Length.FromKiloparsecs(value.ToDouble(null)); +#endif + + /// + public Length Kiloyards +#if NET7_0_OR_GREATER + => Length.FromKiloyards(double.CreateChecked(value)); +#else + => Length.FromKiloyards(value.ToDouble(null)); +#endif + + /// + public Length LightYears +#if NET7_0_OR_GREATER + => Length.FromLightYears(double.CreateChecked(value)); +#else + => Length.FromLightYears(value.ToDouble(null)); +#endif + + /// + public Length MegalightYears +#if NET7_0_OR_GREATER + => Length.FromMegalightYears(double.CreateChecked(value)); +#else + => Length.FromMegalightYears(value.ToDouble(null)); +#endif + + /// + public Length Megameters +#if NET7_0_OR_GREATER + => Length.FromMegameters(double.CreateChecked(value)); +#else + => Length.FromMegameters(value.ToDouble(null)); +#endif + + /// + public Length Megaparsecs +#if NET7_0_OR_GREATER + => Length.FromMegaparsecs(double.CreateChecked(value)); +#else + => Length.FromMegaparsecs(value.ToDouble(null)); +#endif + + /// + public Length Meters +#if NET7_0_OR_GREATER + => Length.FromMeters(double.CreateChecked(value)); +#else + => Length.FromMeters(value.ToDouble(null)); +#endif + + /// + public Length Microinches +#if NET7_0_OR_GREATER + => Length.FromMicroinches(double.CreateChecked(value)); +#else + => Length.FromMicroinches(value.ToDouble(null)); +#endif + + /// + public Length Micrometers +#if NET7_0_OR_GREATER + => Length.FromMicrometers(double.CreateChecked(value)); +#else + => Length.FromMicrometers(value.ToDouble(null)); +#endif + + /// + public Length Mils +#if NET7_0_OR_GREATER + => Length.FromMils(double.CreateChecked(value)); +#else + => Length.FromMils(value.ToDouble(null)); +#endif + + /// + public Length Miles +#if NET7_0_OR_GREATER + => Length.FromMiles(double.CreateChecked(value)); +#else + => Length.FromMiles(value.ToDouble(null)); +#endif + + /// + public Length Millimeters +#if NET7_0_OR_GREATER + => Length.FromMillimeters(double.CreateChecked(value)); +#else + => Length.FromMillimeters(value.ToDouble(null)); +#endif + + /// + public Length Nanometers +#if NET7_0_OR_GREATER + => Length.FromNanometers(double.CreateChecked(value)); +#else + => Length.FromNanometers(value.ToDouble(null)); +#endif + + /// + public Length NauticalMiles +#if NET7_0_OR_GREATER + => Length.FromNauticalMiles(double.CreateChecked(value)); +#else + => Length.FromNauticalMiles(value.ToDouble(null)); +#endif + + /// + public Length Parsecs +#if NET7_0_OR_GREATER + => Length.FromParsecs(double.CreateChecked(value)); +#else + => Length.FromParsecs(value.ToDouble(null)); +#endif + + /// + public Length Picometers +#if NET7_0_OR_GREATER + => Length.FromPicometers(double.CreateChecked(value)); +#else + => Length.FromPicometers(value.ToDouble(null)); +#endif + + /// + public Length PrinterPicas +#if NET7_0_OR_GREATER + => Length.FromPrinterPicas(double.CreateChecked(value)); +#else + => Length.FromPrinterPicas(value.ToDouble(null)); +#endif + + /// + public Length PrinterPoints +#if NET7_0_OR_GREATER + => Length.FromPrinterPoints(double.CreateChecked(value)); +#else + => Length.FromPrinterPoints(value.ToDouble(null)); +#endif + + /// + public Length Shackles +#if NET7_0_OR_GREATER + => Length.FromShackles(double.CreateChecked(value)); +#else + => Length.FromShackles(value.ToDouble(null)); +#endif + + /// + public Length SolarRadiuses +#if NET7_0_OR_GREATER + => Length.FromSolarRadiuses(double.CreateChecked(value)); +#else + => Length.FromSolarRadiuses(value.ToDouble(null)); +#endif + + /// + public Length Twips +#if NET7_0_OR_GREATER + => Length.FromTwips(double.CreateChecked(value)); +#else + => Length.FromTwips(value.ToDouble(null)); +#endif + + /// + public Length UsSurveyFeet +#if NET7_0_OR_GREATER + => Length.FromUsSurveyFeet(double.CreateChecked(value)); +#else + => Length.FromUsSurveyFeet(value.ToDouble(null)); +#endif + + /// + public Length Yards +#if NET7_0_OR_GREATER + => Length.FromYards(double.CreateChecked(value)); +#else + => Length.FromYards(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLevelExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLevelExtensions.g.cs new file mode 100644 index 0000000000..62c3eeb0ae --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLevelExtensions.g.cs @@ -0,0 +1,63 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToLevel +{ + /// + /// A number to Level Extensions + /// + public static class NumberToLevelExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Level Decibels +#if NET7_0_OR_GREATER + => Level.FromDecibels(double.CreateChecked(value)); +#else + => Level.FromDecibels(value.ToDouble(null)); +#endif + + /// + public Level Nepers +#if NET7_0_OR_GREATER + => Level.FromNepers(double.CreateChecked(value)); +#else + => Level.FromNepers(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLinearDensityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLinearDensityExtensions.g.cs new file mode 100644 index 0000000000..53427c828e --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLinearDensityExtensions.g.cs @@ -0,0 +1,191 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToLinearDensity +{ + /// + /// A number to LinearDensity Extensions + /// + public static class NumberToLinearDensityExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public LinearDensity GramsPerCentimeter +#if NET7_0_OR_GREATER + => LinearDensity.FromGramsPerCentimeter(double.CreateChecked(value)); +#else + => LinearDensity.FromGramsPerCentimeter(value.ToDouble(null)); +#endif + + /// + public LinearDensity GramsPerFoot +#if NET7_0_OR_GREATER + => LinearDensity.FromGramsPerFoot(double.CreateChecked(value)); +#else + => LinearDensity.FromGramsPerFoot(value.ToDouble(null)); +#endif + + /// + public LinearDensity GramsPerMeter +#if NET7_0_OR_GREATER + => LinearDensity.FromGramsPerMeter(double.CreateChecked(value)); +#else + => LinearDensity.FromGramsPerMeter(value.ToDouble(null)); +#endif + + /// + public LinearDensity GramsPerMillimeter +#if NET7_0_OR_GREATER + => LinearDensity.FromGramsPerMillimeter(double.CreateChecked(value)); +#else + => LinearDensity.FromGramsPerMillimeter(value.ToDouble(null)); +#endif + + /// + public LinearDensity KilogramsPerCentimeter +#if NET7_0_OR_GREATER + => LinearDensity.FromKilogramsPerCentimeter(double.CreateChecked(value)); +#else + => LinearDensity.FromKilogramsPerCentimeter(value.ToDouble(null)); +#endif + + /// + public LinearDensity KilogramsPerFoot +#if NET7_0_OR_GREATER + => LinearDensity.FromKilogramsPerFoot(double.CreateChecked(value)); +#else + => LinearDensity.FromKilogramsPerFoot(value.ToDouble(null)); +#endif + + /// + public LinearDensity KilogramsPerMeter +#if NET7_0_OR_GREATER + => LinearDensity.FromKilogramsPerMeter(double.CreateChecked(value)); +#else + => LinearDensity.FromKilogramsPerMeter(value.ToDouble(null)); +#endif + + /// + public LinearDensity KilogramsPerMillimeter +#if NET7_0_OR_GREATER + => LinearDensity.FromKilogramsPerMillimeter(double.CreateChecked(value)); +#else + => LinearDensity.FromKilogramsPerMillimeter(value.ToDouble(null)); +#endif + + /// + public LinearDensity MicrogramsPerCentimeter +#if NET7_0_OR_GREATER + => LinearDensity.FromMicrogramsPerCentimeter(double.CreateChecked(value)); +#else + => LinearDensity.FromMicrogramsPerCentimeter(value.ToDouble(null)); +#endif + + /// + public LinearDensity MicrogramsPerFoot +#if NET7_0_OR_GREATER + => LinearDensity.FromMicrogramsPerFoot(double.CreateChecked(value)); +#else + => LinearDensity.FromMicrogramsPerFoot(value.ToDouble(null)); +#endif + + /// + public LinearDensity MicrogramsPerMeter +#if NET7_0_OR_GREATER + => LinearDensity.FromMicrogramsPerMeter(double.CreateChecked(value)); +#else + => LinearDensity.FromMicrogramsPerMeter(value.ToDouble(null)); +#endif + + /// + public LinearDensity MicrogramsPerMillimeter +#if NET7_0_OR_GREATER + => LinearDensity.FromMicrogramsPerMillimeter(double.CreateChecked(value)); +#else + => LinearDensity.FromMicrogramsPerMillimeter(value.ToDouble(null)); +#endif + + /// + public LinearDensity MilligramsPerCentimeter +#if NET7_0_OR_GREATER + => LinearDensity.FromMilligramsPerCentimeter(double.CreateChecked(value)); +#else + => LinearDensity.FromMilligramsPerCentimeter(value.ToDouble(null)); +#endif + + /// + public LinearDensity MilligramsPerFoot +#if NET7_0_OR_GREATER + => LinearDensity.FromMilligramsPerFoot(double.CreateChecked(value)); +#else + => LinearDensity.FromMilligramsPerFoot(value.ToDouble(null)); +#endif + + /// + public LinearDensity MilligramsPerMeter +#if NET7_0_OR_GREATER + => LinearDensity.FromMilligramsPerMeter(double.CreateChecked(value)); +#else + => LinearDensity.FromMilligramsPerMeter(value.ToDouble(null)); +#endif + + /// + public LinearDensity MilligramsPerMillimeter +#if NET7_0_OR_GREATER + => LinearDensity.FromMilligramsPerMillimeter(double.CreateChecked(value)); +#else + => LinearDensity.FromMilligramsPerMillimeter(value.ToDouble(null)); +#endif + + /// + public LinearDensity PoundsPerFoot +#if NET7_0_OR_GREATER + => LinearDensity.FromPoundsPerFoot(double.CreateChecked(value)); +#else + => LinearDensity.FromPoundsPerFoot(value.ToDouble(null)); +#endif + + /// + public LinearDensity PoundsPerInch +#if NET7_0_OR_GREATER + => LinearDensity.FromPoundsPerInch(double.CreateChecked(value)); +#else + => LinearDensity.FromPoundsPerInch(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLinearPowerDensityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLinearPowerDensityExtensions.g.cs new file mode 100644 index 0000000000..8bec43de16 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLinearPowerDensityExtensions.g.cs @@ -0,0 +1,247 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToLinearPowerDensity +{ + /// + /// A number to LinearPowerDensity Extensions + /// + public static class NumberToLinearPowerDensityExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public LinearPowerDensity GigawattsPerCentimeter +#if NET7_0_OR_GREATER + => LinearPowerDensity.FromGigawattsPerCentimeter(double.CreateChecked(value)); +#else + => LinearPowerDensity.FromGigawattsPerCentimeter(value.ToDouble(null)); +#endif + + /// + public LinearPowerDensity GigawattsPerFoot +#if NET7_0_OR_GREATER + => LinearPowerDensity.FromGigawattsPerFoot(double.CreateChecked(value)); +#else + => LinearPowerDensity.FromGigawattsPerFoot(value.ToDouble(null)); +#endif + + /// + public LinearPowerDensity GigawattsPerInch +#if NET7_0_OR_GREATER + => LinearPowerDensity.FromGigawattsPerInch(double.CreateChecked(value)); +#else + => LinearPowerDensity.FromGigawattsPerInch(value.ToDouble(null)); +#endif + + /// + public LinearPowerDensity GigawattsPerMeter +#if NET7_0_OR_GREATER + => LinearPowerDensity.FromGigawattsPerMeter(double.CreateChecked(value)); +#else + => LinearPowerDensity.FromGigawattsPerMeter(value.ToDouble(null)); +#endif + + /// + public LinearPowerDensity GigawattsPerMillimeter +#if NET7_0_OR_GREATER + => LinearPowerDensity.FromGigawattsPerMillimeter(double.CreateChecked(value)); +#else + => LinearPowerDensity.FromGigawattsPerMillimeter(value.ToDouble(null)); +#endif + + /// + public LinearPowerDensity KilowattsPerCentimeter +#if NET7_0_OR_GREATER + => LinearPowerDensity.FromKilowattsPerCentimeter(double.CreateChecked(value)); +#else + => LinearPowerDensity.FromKilowattsPerCentimeter(value.ToDouble(null)); +#endif + + /// + public LinearPowerDensity KilowattsPerFoot +#if NET7_0_OR_GREATER + => LinearPowerDensity.FromKilowattsPerFoot(double.CreateChecked(value)); +#else + => LinearPowerDensity.FromKilowattsPerFoot(value.ToDouble(null)); +#endif + + /// + public LinearPowerDensity KilowattsPerInch +#if NET7_0_OR_GREATER + => LinearPowerDensity.FromKilowattsPerInch(double.CreateChecked(value)); +#else + => LinearPowerDensity.FromKilowattsPerInch(value.ToDouble(null)); +#endif + + /// + public LinearPowerDensity KilowattsPerMeter +#if NET7_0_OR_GREATER + => LinearPowerDensity.FromKilowattsPerMeter(double.CreateChecked(value)); +#else + => LinearPowerDensity.FromKilowattsPerMeter(value.ToDouble(null)); +#endif + + /// + public LinearPowerDensity KilowattsPerMillimeter +#if NET7_0_OR_GREATER + => LinearPowerDensity.FromKilowattsPerMillimeter(double.CreateChecked(value)); +#else + => LinearPowerDensity.FromKilowattsPerMillimeter(value.ToDouble(null)); +#endif + + /// + public LinearPowerDensity MegawattsPerCentimeter +#if NET7_0_OR_GREATER + => LinearPowerDensity.FromMegawattsPerCentimeter(double.CreateChecked(value)); +#else + => LinearPowerDensity.FromMegawattsPerCentimeter(value.ToDouble(null)); +#endif + + /// + public LinearPowerDensity MegawattsPerFoot +#if NET7_0_OR_GREATER + => LinearPowerDensity.FromMegawattsPerFoot(double.CreateChecked(value)); +#else + => LinearPowerDensity.FromMegawattsPerFoot(value.ToDouble(null)); +#endif + + /// + public LinearPowerDensity MegawattsPerInch +#if NET7_0_OR_GREATER + => LinearPowerDensity.FromMegawattsPerInch(double.CreateChecked(value)); +#else + => LinearPowerDensity.FromMegawattsPerInch(value.ToDouble(null)); +#endif + + /// + public LinearPowerDensity MegawattsPerMeter +#if NET7_0_OR_GREATER + => LinearPowerDensity.FromMegawattsPerMeter(double.CreateChecked(value)); +#else + => LinearPowerDensity.FromMegawattsPerMeter(value.ToDouble(null)); +#endif + + /// + public LinearPowerDensity MegawattsPerMillimeter +#if NET7_0_OR_GREATER + => LinearPowerDensity.FromMegawattsPerMillimeter(double.CreateChecked(value)); +#else + => LinearPowerDensity.FromMegawattsPerMillimeter(value.ToDouble(null)); +#endif + + /// + public LinearPowerDensity MilliwattsPerCentimeter +#if NET7_0_OR_GREATER + => LinearPowerDensity.FromMilliwattsPerCentimeter(double.CreateChecked(value)); +#else + => LinearPowerDensity.FromMilliwattsPerCentimeter(value.ToDouble(null)); +#endif + + /// + public LinearPowerDensity MilliwattsPerFoot +#if NET7_0_OR_GREATER + => LinearPowerDensity.FromMilliwattsPerFoot(double.CreateChecked(value)); +#else + => LinearPowerDensity.FromMilliwattsPerFoot(value.ToDouble(null)); +#endif + + /// + public LinearPowerDensity MilliwattsPerInch +#if NET7_0_OR_GREATER + => LinearPowerDensity.FromMilliwattsPerInch(double.CreateChecked(value)); +#else + => LinearPowerDensity.FromMilliwattsPerInch(value.ToDouble(null)); +#endif + + /// + public LinearPowerDensity MilliwattsPerMeter +#if NET7_0_OR_GREATER + => LinearPowerDensity.FromMilliwattsPerMeter(double.CreateChecked(value)); +#else + => LinearPowerDensity.FromMilliwattsPerMeter(value.ToDouble(null)); +#endif + + /// + public LinearPowerDensity MilliwattsPerMillimeter +#if NET7_0_OR_GREATER + => LinearPowerDensity.FromMilliwattsPerMillimeter(double.CreateChecked(value)); +#else + => LinearPowerDensity.FromMilliwattsPerMillimeter(value.ToDouble(null)); +#endif + + /// + public LinearPowerDensity WattsPerCentimeter +#if NET7_0_OR_GREATER + => LinearPowerDensity.FromWattsPerCentimeter(double.CreateChecked(value)); +#else + => LinearPowerDensity.FromWattsPerCentimeter(value.ToDouble(null)); +#endif + + /// + public LinearPowerDensity WattsPerFoot +#if NET7_0_OR_GREATER + => LinearPowerDensity.FromWattsPerFoot(double.CreateChecked(value)); +#else + => LinearPowerDensity.FromWattsPerFoot(value.ToDouble(null)); +#endif + + /// + public LinearPowerDensity WattsPerInch +#if NET7_0_OR_GREATER + => LinearPowerDensity.FromWattsPerInch(double.CreateChecked(value)); +#else + => LinearPowerDensity.FromWattsPerInch(value.ToDouble(null)); +#endif + + /// + public LinearPowerDensity WattsPerMeter +#if NET7_0_OR_GREATER + => LinearPowerDensity.FromWattsPerMeter(double.CreateChecked(value)); +#else + => LinearPowerDensity.FromWattsPerMeter(value.ToDouble(null)); +#endif + + /// + public LinearPowerDensity WattsPerMillimeter +#if NET7_0_OR_GREATER + => LinearPowerDensity.FromWattsPerMillimeter(double.CreateChecked(value)); +#else + => LinearPowerDensity.FromWattsPerMillimeter(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLuminanceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLuminanceExtensions.g.cs new file mode 100644 index 0000000000..34bef2c23b --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLuminanceExtensions.g.cs @@ -0,0 +1,127 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToLuminance +{ + /// + /// A number to Luminance Extensions + /// + public static class NumberToLuminanceExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Luminance CandelasPerSquareFoot +#if NET7_0_OR_GREATER + => Luminance.FromCandelasPerSquareFoot(double.CreateChecked(value)); +#else + => Luminance.FromCandelasPerSquareFoot(value.ToDouble(null)); +#endif + + /// + public Luminance CandelasPerSquareInch +#if NET7_0_OR_GREATER + => Luminance.FromCandelasPerSquareInch(double.CreateChecked(value)); +#else + => Luminance.FromCandelasPerSquareInch(value.ToDouble(null)); +#endif + + /// + public Luminance CandelasPerSquareMeter +#if NET7_0_OR_GREATER + => Luminance.FromCandelasPerSquareMeter(double.CreateChecked(value)); +#else + => Luminance.FromCandelasPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public Luminance CenticandelasPerSquareMeter +#if NET7_0_OR_GREATER + => Luminance.FromCenticandelasPerSquareMeter(double.CreateChecked(value)); +#else + => Luminance.FromCenticandelasPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public Luminance DecicandelasPerSquareMeter +#if NET7_0_OR_GREATER + => Luminance.FromDecicandelasPerSquareMeter(double.CreateChecked(value)); +#else + => Luminance.FromDecicandelasPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public Luminance KilocandelasPerSquareMeter +#if NET7_0_OR_GREATER + => Luminance.FromKilocandelasPerSquareMeter(double.CreateChecked(value)); +#else + => Luminance.FromKilocandelasPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public Luminance MicrocandelasPerSquareMeter +#if NET7_0_OR_GREATER + => Luminance.FromMicrocandelasPerSquareMeter(double.CreateChecked(value)); +#else + => Luminance.FromMicrocandelasPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public Luminance MillicandelasPerSquareMeter +#if NET7_0_OR_GREATER + => Luminance.FromMillicandelasPerSquareMeter(double.CreateChecked(value)); +#else + => Luminance.FromMillicandelasPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public Luminance NanocandelasPerSquareMeter +#if NET7_0_OR_GREATER + => Luminance.FromNanocandelasPerSquareMeter(double.CreateChecked(value)); +#else + => Luminance.FromNanocandelasPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public Luminance Nits +#if NET7_0_OR_GREATER + => Luminance.FromNits(double.CreateChecked(value)); +#else + => Luminance.FromNits(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLuminosityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLuminosityExtensions.g.cs new file mode 100644 index 0000000000..30b3b188f5 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLuminosityExtensions.g.cs @@ -0,0 +1,159 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToLuminosity +{ + /// + /// A number to Luminosity Extensions + /// + public static class NumberToLuminosityExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Luminosity Decawatts +#if NET7_0_OR_GREATER + => Luminosity.FromDecawatts(double.CreateChecked(value)); +#else + => Luminosity.FromDecawatts(value.ToDouble(null)); +#endif + + /// + public Luminosity Deciwatts +#if NET7_0_OR_GREATER + => Luminosity.FromDeciwatts(double.CreateChecked(value)); +#else + => Luminosity.FromDeciwatts(value.ToDouble(null)); +#endif + + /// + public Luminosity Femtowatts +#if NET7_0_OR_GREATER + => Luminosity.FromFemtowatts(double.CreateChecked(value)); +#else + => Luminosity.FromFemtowatts(value.ToDouble(null)); +#endif + + /// + public Luminosity Gigawatts +#if NET7_0_OR_GREATER + => Luminosity.FromGigawatts(double.CreateChecked(value)); +#else + => Luminosity.FromGigawatts(value.ToDouble(null)); +#endif + + /// + public Luminosity Kilowatts +#if NET7_0_OR_GREATER + => Luminosity.FromKilowatts(double.CreateChecked(value)); +#else + => Luminosity.FromKilowatts(value.ToDouble(null)); +#endif + + /// + public Luminosity Megawatts +#if NET7_0_OR_GREATER + => Luminosity.FromMegawatts(double.CreateChecked(value)); +#else + => Luminosity.FromMegawatts(value.ToDouble(null)); +#endif + + /// + public Luminosity Microwatts +#if NET7_0_OR_GREATER + => Luminosity.FromMicrowatts(double.CreateChecked(value)); +#else + => Luminosity.FromMicrowatts(value.ToDouble(null)); +#endif + + /// + public Luminosity Milliwatts +#if NET7_0_OR_GREATER + => Luminosity.FromMilliwatts(double.CreateChecked(value)); +#else + => Luminosity.FromMilliwatts(value.ToDouble(null)); +#endif + + /// + public Luminosity Nanowatts +#if NET7_0_OR_GREATER + => Luminosity.FromNanowatts(double.CreateChecked(value)); +#else + => Luminosity.FromNanowatts(value.ToDouble(null)); +#endif + + /// + public Luminosity Petawatts +#if NET7_0_OR_GREATER + => Luminosity.FromPetawatts(double.CreateChecked(value)); +#else + => Luminosity.FromPetawatts(value.ToDouble(null)); +#endif + + /// + public Luminosity Picowatts +#if NET7_0_OR_GREATER + => Luminosity.FromPicowatts(double.CreateChecked(value)); +#else + => Luminosity.FromPicowatts(value.ToDouble(null)); +#endif + + /// + public Luminosity SolarLuminosities +#if NET7_0_OR_GREATER + => Luminosity.FromSolarLuminosities(double.CreateChecked(value)); +#else + => Luminosity.FromSolarLuminosities(value.ToDouble(null)); +#endif + + /// + public Luminosity Terawatts +#if NET7_0_OR_GREATER + => Luminosity.FromTerawatts(double.CreateChecked(value)); +#else + => Luminosity.FromTerawatts(value.ToDouble(null)); +#endif + + /// + public Luminosity Watts +#if NET7_0_OR_GREATER + => Luminosity.FromWatts(double.CreateChecked(value)); +#else + => Luminosity.FromWatts(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLuminousFluxExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLuminousFluxExtensions.g.cs new file mode 100644 index 0000000000..f33229ff3d --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLuminousFluxExtensions.g.cs @@ -0,0 +1,55 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToLuminousFlux +{ + /// + /// A number to LuminousFlux Extensions + /// + public static class NumberToLuminousFluxExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public LuminousFlux Lumens +#if NET7_0_OR_GREATER + => LuminousFlux.FromLumens(double.CreateChecked(value)); +#else + => LuminousFlux.FromLumens(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLuminousIntensityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLuminousIntensityExtensions.g.cs new file mode 100644 index 0000000000..6a4697278e --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToLuminousIntensityExtensions.g.cs @@ -0,0 +1,55 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToLuminousIntensity +{ + /// + /// A number to LuminousIntensity Extensions + /// + public static class NumberToLuminousIntensityExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public LuminousIntensity Candela +#if NET7_0_OR_GREATER + => LuminousIntensity.FromCandela(double.CreateChecked(value)); +#else + => LuminousIntensity.FromCandela(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMagneticFieldExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMagneticFieldExtensions.g.cs new file mode 100644 index 0000000000..d00c79035d --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMagneticFieldExtensions.g.cs @@ -0,0 +1,95 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToMagneticField +{ + /// + /// A number to MagneticField Extensions + /// + public static class NumberToMagneticFieldExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public MagneticField Gausses +#if NET7_0_OR_GREATER + => MagneticField.FromGausses(double.CreateChecked(value)); +#else + => MagneticField.FromGausses(value.ToDouble(null)); +#endif + + /// + public MagneticField Microteslas +#if NET7_0_OR_GREATER + => MagneticField.FromMicroteslas(double.CreateChecked(value)); +#else + => MagneticField.FromMicroteslas(value.ToDouble(null)); +#endif + + /// + public MagneticField Milligausses +#if NET7_0_OR_GREATER + => MagneticField.FromMilligausses(double.CreateChecked(value)); +#else + => MagneticField.FromMilligausses(value.ToDouble(null)); +#endif + + /// + public MagneticField Milliteslas +#if NET7_0_OR_GREATER + => MagneticField.FromMilliteslas(double.CreateChecked(value)); +#else + => MagneticField.FromMilliteslas(value.ToDouble(null)); +#endif + + /// + public MagneticField Nanoteslas +#if NET7_0_OR_GREATER + => MagneticField.FromNanoteslas(double.CreateChecked(value)); +#else + => MagneticField.FromNanoteslas(value.ToDouble(null)); +#endif + + /// + public MagneticField Teslas +#if NET7_0_OR_GREATER + => MagneticField.FromTeslas(double.CreateChecked(value)); +#else + => MagneticField.FromTeslas(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMagneticFluxExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMagneticFluxExtensions.g.cs new file mode 100644 index 0000000000..e44579feb9 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMagneticFluxExtensions.g.cs @@ -0,0 +1,55 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToMagneticFlux +{ + /// + /// A number to MagneticFlux Extensions + /// + public static class NumberToMagneticFluxExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public MagneticFlux Webers +#if NET7_0_OR_GREATER + => MagneticFlux.FromWebers(double.CreateChecked(value)); +#else + => MagneticFlux.FromWebers(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMagnetizationExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMagnetizationExtensions.g.cs new file mode 100644 index 0000000000..32498d022e --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMagnetizationExtensions.g.cs @@ -0,0 +1,55 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToMagnetization +{ + /// + /// A number to Magnetization Extensions + /// + public static class NumberToMagnetizationExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Magnetization AmperesPerMeter +#if NET7_0_OR_GREATER + => Magnetization.FromAmperesPerMeter(double.CreateChecked(value)); +#else + => Magnetization.FromAmperesPerMeter(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassConcentrationExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassConcentrationExtensions.g.cs new file mode 100644 index 0000000000..31e563b531 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassConcentrationExtensions.g.cs @@ -0,0 +1,439 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToMassConcentration +{ + /// + /// A number to MassConcentration Extensions + /// + public static class NumberToMassConcentrationExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public MassConcentration CentigramsPerDeciliter +#if NET7_0_OR_GREATER + => MassConcentration.FromCentigramsPerDeciliter(double.CreateChecked(value)); +#else + => MassConcentration.FromCentigramsPerDeciliter(value.ToDouble(null)); +#endif + + /// + public MassConcentration CentigramsPerLiter +#if NET7_0_OR_GREATER + => MassConcentration.FromCentigramsPerLiter(double.CreateChecked(value)); +#else + => MassConcentration.FromCentigramsPerLiter(value.ToDouble(null)); +#endif + + /// + public MassConcentration CentigramsPerMicroliter +#if NET7_0_OR_GREATER + => MassConcentration.FromCentigramsPerMicroliter(double.CreateChecked(value)); +#else + => MassConcentration.FromCentigramsPerMicroliter(value.ToDouble(null)); +#endif + + /// + public MassConcentration CentigramsPerMilliliter +#if NET7_0_OR_GREATER + => MassConcentration.FromCentigramsPerMilliliter(double.CreateChecked(value)); +#else + => MassConcentration.FromCentigramsPerMilliliter(value.ToDouble(null)); +#endif + + /// + public MassConcentration DecigramsPerDeciliter +#if NET7_0_OR_GREATER + => MassConcentration.FromDecigramsPerDeciliter(double.CreateChecked(value)); +#else + => MassConcentration.FromDecigramsPerDeciliter(value.ToDouble(null)); +#endif + + /// + public MassConcentration DecigramsPerLiter +#if NET7_0_OR_GREATER + => MassConcentration.FromDecigramsPerLiter(double.CreateChecked(value)); +#else + => MassConcentration.FromDecigramsPerLiter(value.ToDouble(null)); +#endif + + /// + public MassConcentration DecigramsPerMicroliter +#if NET7_0_OR_GREATER + => MassConcentration.FromDecigramsPerMicroliter(double.CreateChecked(value)); +#else + => MassConcentration.FromDecigramsPerMicroliter(value.ToDouble(null)); +#endif + + /// + public MassConcentration DecigramsPerMilliliter +#if NET7_0_OR_GREATER + => MassConcentration.FromDecigramsPerMilliliter(double.CreateChecked(value)); +#else + => MassConcentration.FromDecigramsPerMilliliter(value.ToDouble(null)); +#endif + + /// + public MassConcentration GramsPerCubicCentimeter +#if NET7_0_OR_GREATER + => MassConcentration.FromGramsPerCubicCentimeter(double.CreateChecked(value)); +#else + => MassConcentration.FromGramsPerCubicCentimeter(value.ToDouble(null)); +#endif + + /// + public MassConcentration GramsPerCubicMeter +#if NET7_0_OR_GREATER + => MassConcentration.FromGramsPerCubicMeter(double.CreateChecked(value)); +#else + => MassConcentration.FromGramsPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public MassConcentration GramsPerCubicMillimeter +#if NET7_0_OR_GREATER + => MassConcentration.FromGramsPerCubicMillimeter(double.CreateChecked(value)); +#else + => MassConcentration.FromGramsPerCubicMillimeter(value.ToDouble(null)); +#endif + + /// + public MassConcentration GramsPerDeciliter +#if NET7_0_OR_GREATER + => MassConcentration.FromGramsPerDeciliter(double.CreateChecked(value)); +#else + => MassConcentration.FromGramsPerDeciliter(value.ToDouble(null)); +#endif + + /// + public MassConcentration GramsPerLiter +#if NET7_0_OR_GREATER + => MassConcentration.FromGramsPerLiter(double.CreateChecked(value)); +#else + => MassConcentration.FromGramsPerLiter(value.ToDouble(null)); +#endif + + /// + public MassConcentration GramsPerMicroliter +#if NET7_0_OR_GREATER + => MassConcentration.FromGramsPerMicroliter(double.CreateChecked(value)); +#else + => MassConcentration.FromGramsPerMicroliter(value.ToDouble(null)); +#endif + + /// + public MassConcentration GramsPerMilliliter +#if NET7_0_OR_GREATER + => MassConcentration.FromGramsPerMilliliter(double.CreateChecked(value)); +#else + => MassConcentration.FromGramsPerMilliliter(value.ToDouble(null)); +#endif + + /// + public MassConcentration KilogramsPerCubicCentimeter +#if NET7_0_OR_GREATER + => MassConcentration.FromKilogramsPerCubicCentimeter(double.CreateChecked(value)); +#else + => MassConcentration.FromKilogramsPerCubicCentimeter(value.ToDouble(null)); +#endif + + /// + public MassConcentration KilogramsPerCubicMeter +#if NET7_0_OR_GREATER + => MassConcentration.FromKilogramsPerCubicMeter(double.CreateChecked(value)); +#else + => MassConcentration.FromKilogramsPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public MassConcentration KilogramsPerCubicMillimeter +#if NET7_0_OR_GREATER + => MassConcentration.FromKilogramsPerCubicMillimeter(double.CreateChecked(value)); +#else + => MassConcentration.FromKilogramsPerCubicMillimeter(value.ToDouble(null)); +#endif + + /// + public MassConcentration KilogramsPerLiter +#if NET7_0_OR_GREATER + => MassConcentration.FromKilogramsPerLiter(double.CreateChecked(value)); +#else + => MassConcentration.FromKilogramsPerLiter(value.ToDouble(null)); +#endif + + /// + public MassConcentration KilopoundsPerCubicFoot +#if NET7_0_OR_GREATER + => MassConcentration.FromKilopoundsPerCubicFoot(double.CreateChecked(value)); +#else + => MassConcentration.FromKilopoundsPerCubicFoot(value.ToDouble(null)); +#endif + + /// + public MassConcentration KilopoundsPerCubicInch +#if NET7_0_OR_GREATER + => MassConcentration.FromKilopoundsPerCubicInch(double.CreateChecked(value)); +#else + => MassConcentration.FromKilopoundsPerCubicInch(value.ToDouble(null)); +#endif + + /// + public MassConcentration MicrogramsPerCubicMeter +#if NET7_0_OR_GREATER + => MassConcentration.FromMicrogramsPerCubicMeter(double.CreateChecked(value)); +#else + => MassConcentration.FromMicrogramsPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public MassConcentration MicrogramsPerDeciliter +#if NET7_0_OR_GREATER + => MassConcentration.FromMicrogramsPerDeciliter(double.CreateChecked(value)); +#else + => MassConcentration.FromMicrogramsPerDeciliter(value.ToDouble(null)); +#endif + + /// + public MassConcentration MicrogramsPerLiter +#if NET7_0_OR_GREATER + => MassConcentration.FromMicrogramsPerLiter(double.CreateChecked(value)); +#else + => MassConcentration.FromMicrogramsPerLiter(value.ToDouble(null)); +#endif + + /// + public MassConcentration MicrogramsPerMicroliter +#if NET7_0_OR_GREATER + => MassConcentration.FromMicrogramsPerMicroliter(double.CreateChecked(value)); +#else + => MassConcentration.FromMicrogramsPerMicroliter(value.ToDouble(null)); +#endif + + /// + public MassConcentration MicrogramsPerMilliliter +#if NET7_0_OR_GREATER + => MassConcentration.FromMicrogramsPerMilliliter(double.CreateChecked(value)); +#else + => MassConcentration.FromMicrogramsPerMilliliter(value.ToDouble(null)); +#endif + + /// + public MassConcentration MilligramsPerCubicMeter +#if NET7_0_OR_GREATER + => MassConcentration.FromMilligramsPerCubicMeter(double.CreateChecked(value)); +#else + => MassConcentration.FromMilligramsPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public MassConcentration MilligramsPerDeciliter +#if NET7_0_OR_GREATER + => MassConcentration.FromMilligramsPerDeciliter(double.CreateChecked(value)); +#else + => MassConcentration.FromMilligramsPerDeciliter(value.ToDouble(null)); +#endif + + /// + public MassConcentration MilligramsPerLiter +#if NET7_0_OR_GREATER + => MassConcentration.FromMilligramsPerLiter(double.CreateChecked(value)); +#else + => MassConcentration.FromMilligramsPerLiter(value.ToDouble(null)); +#endif + + /// + public MassConcentration MilligramsPerMicroliter +#if NET7_0_OR_GREATER + => MassConcentration.FromMilligramsPerMicroliter(double.CreateChecked(value)); +#else + => MassConcentration.FromMilligramsPerMicroliter(value.ToDouble(null)); +#endif + + /// + public MassConcentration MilligramsPerMilliliter +#if NET7_0_OR_GREATER + => MassConcentration.FromMilligramsPerMilliliter(double.CreateChecked(value)); +#else + => MassConcentration.FromMilligramsPerMilliliter(value.ToDouble(null)); +#endif + + /// + public MassConcentration NanogramsPerDeciliter +#if NET7_0_OR_GREATER + => MassConcentration.FromNanogramsPerDeciliter(double.CreateChecked(value)); +#else + => MassConcentration.FromNanogramsPerDeciliter(value.ToDouble(null)); +#endif + + /// + public MassConcentration NanogramsPerLiter +#if NET7_0_OR_GREATER + => MassConcentration.FromNanogramsPerLiter(double.CreateChecked(value)); +#else + => MassConcentration.FromNanogramsPerLiter(value.ToDouble(null)); +#endif + + /// + public MassConcentration NanogramsPerMicroliter +#if NET7_0_OR_GREATER + => MassConcentration.FromNanogramsPerMicroliter(double.CreateChecked(value)); +#else + => MassConcentration.FromNanogramsPerMicroliter(value.ToDouble(null)); +#endif + + /// + public MassConcentration NanogramsPerMilliliter +#if NET7_0_OR_GREATER + => MassConcentration.FromNanogramsPerMilliliter(double.CreateChecked(value)); +#else + => MassConcentration.FromNanogramsPerMilliliter(value.ToDouble(null)); +#endif + + /// + public MassConcentration OuncesPerImperialGallon +#if NET7_0_OR_GREATER + => MassConcentration.FromOuncesPerImperialGallon(double.CreateChecked(value)); +#else + => MassConcentration.FromOuncesPerImperialGallon(value.ToDouble(null)); +#endif + + /// + public MassConcentration OuncesPerUSGallon +#if NET7_0_OR_GREATER + => MassConcentration.FromOuncesPerUSGallon(double.CreateChecked(value)); +#else + => MassConcentration.FromOuncesPerUSGallon(value.ToDouble(null)); +#endif + + /// + public MassConcentration PicogramsPerDeciliter +#if NET7_0_OR_GREATER + => MassConcentration.FromPicogramsPerDeciliter(double.CreateChecked(value)); +#else + => MassConcentration.FromPicogramsPerDeciliter(value.ToDouble(null)); +#endif + + /// + public MassConcentration PicogramsPerLiter +#if NET7_0_OR_GREATER + => MassConcentration.FromPicogramsPerLiter(double.CreateChecked(value)); +#else + => MassConcentration.FromPicogramsPerLiter(value.ToDouble(null)); +#endif + + /// + public MassConcentration PicogramsPerMicroliter +#if NET7_0_OR_GREATER + => MassConcentration.FromPicogramsPerMicroliter(double.CreateChecked(value)); +#else + => MassConcentration.FromPicogramsPerMicroliter(value.ToDouble(null)); +#endif + + /// + public MassConcentration PicogramsPerMilliliter +#if NET7_0_OR_GREATER + => MassConcentration.FromPicogramsPerMilliliter(double.CreateChecked(value)); +#else + => MassConcentration.FromPicogramsPerMilliliter(value.ToDouble(null)); +#endif + + /// + public MassConcentration PoundsPerCubicFoot +#if NET7_0_OR_GREATER + => MassConcentration.FromPoundsPerCubicFoot(double.CreateChecked(value)); +#else + => MassConcentration.FromPoundsPerCubicFoot(value.ToDouble(null)); +#endif + + /// + public MassConcentration PoundsPerCubicInch +#if NET7_0_OR_GREATER + => MassConcentration.FromPoundsPerCubicInch(double.CreateChecked(value)); +#else + => MassConcentration.FromPoundsPerCubicInch(value.ToDouble(null)); +#endif + + /// + public MassConcentration PoundsPerImperialGallon +#if NET7_0_OR_GREATER + => MassConcentration.FromPoundsPerImperialGallon(double.CreateChecked(value)); +#else + => MassConcentration.FromPoundsPerImperialGallon(value.ToDouble(null)); +#endif + + /// + public MassConcentration PoundsPerUSGallon +#if NET7_0_OR_GREATER + => MassConcentration.FromPoundsPerUSGallon(double.CreateChecked(value)); +#else + => MassConcentration.FromPoundsPerUSGallon(value.ToDouble(null)); +#endif + + /// + public MassConcentration SlugsPerCubicFoot +#if NET7_0_OR_GREATER + => MassConcentration.FromSlugsPerCubicFoot(double.CreateChecked(value)); +#else + => MassConcentration.FromSlugsPerCubicFoot(value.ToDouble(null)); +#endif + + /// + public MassConcentration TonnesPerCubicCentimeter +#if NET7_0_OR_GREATER + => MassConcentration.FromTonnesPerCubicCentimeter(double.CreateChecked(value)); +#else + => MassConcentration.FromTonnesPerCubicCentimeter(value.ToDouble(null)); +#endif + + /// + public MassConcentration TonnesPerCubicMeter +#if NET7_0_OR_GREATER + => MassConcentration.FromTonnesPerCubicMeter(double.CreateChecked(value)); +#else + => MassConcentration.FromTonnesPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public MassConcentration TonnesPerCubicMillimeter +#if NET7_0_OR_GREATER + => MassConcentration.FromTonnesPerCubicMillimeter(double.CreateChecked(value)); +#else + => MassConcentration.FromTonnesPerCubicMillimeter(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassExtensions.g.cs new file mode 100644 index 0000000000..cd35f99541 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassExtensions.g.cs @@ -0,0 +1,263 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToMass +{ + /// + /// A number to Mass Extensions + /// + public static class NumberToMassExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Mass Centigrams +#if NET7_0_OR_GREATER + => Mass.FromCentigrams(double.CreateChecked(value)); +#else + => Mass.FromCentigrams(value.ToDouble(null)); +#endif + + /// + public Mass Decagrams +#if NET7_0_OR_GREATER + => Mass.FromDecagrams(double.CreateChecked(value)); +#else + => Mass.FromDecagrams(value.ToDouble(null)); +#endif + + /// + public Mass Decigrams +#if NET7_0_OR_GREATER + => Mass.FromDecigrams(double.CreateChecked(value)); +#else + => Mass.FromDecigrams(value.ToDouble(null)); +#endif + + /// + public Mass EarthMasses +#if NET7_0_OR_GREATER + => Mass.FromEarthMasses(double.CreateChecked(value)); +#else + => Mass.FromEarthMasses(value.ToDouble(null)); +#endif + + /// + public Mass Femtograms +#if NET7_0_OR_GREATER + => Mass.FromFemtograms(double.CreateChecked(value)); +#else + => Mass.FromFemtograms(value.ToDouble(null)); +#endif + + /// + public Mass Grains +#if NET7_0_OR_GREATER + => Mass.FromGrains(double.CreateChecked(value)); +#else + => Mass.FromGrains(value.ToDouble(null)); +#endif + + /// + public Mass Grams +#if NET7_0_OR_GREATER + => Mass.FromGrams(double.CreateChecked(value)); +#else + => Mass.FromGrams(value.ToDouble(null)); +#endif + + /// + public Mass Hectograms +#if NET7_0_OR_GREATER + => Mass.FromHectograms(double.CreateChecked(value)); +#else + => Mass.FromHectograms(value.ToDouble(null)); +#endif + + /// + public Mass Kilograms +#if NET7_0_OR_GREATER + => Mass.FromKilograms(double.CreateChecked(value)); +#else + => Mass.FromKilograms(value.ToDouble(null)); +#endif + + /// + public Mass Kilopounds +#if NET7_0_OR_GREATER + => Mass.FromKilopounds(double.CreateChecked(value)); +#else + => Mass.FromKilopounds(value.ToDouble(null)); +#endif + + /// + public Mass Kilotonnes +#if NET7_0_OR_GREATER + => Mass.FromKilotonnes(double.CreateChecked(value)); +#else + => Mass.FromKilotonnes(value.ToDouble(null)); +#endif + + /// + public Mass LongHundredweight +#if NET7_0_OR_GREATER + => Mass.FromLongHundredweight(double.CreateChecked(value)); +#else + => Mass.FromLongHundredweight(value.ToDouble(null)); +#endif + + /// + public Mass LongTons +#if NET7_0_OR_GREATER + => Mass.FromLongTons(double.CreateChecked(value)); +#else + => Mass.FromLongTons(value.ToDouble(null)); +#endif + + /// + public Mass Megapounds +#if NET7_0_OR_GREATER + => Mass.FromMegapounds(double.CreateChecked(value)); +#else + => Mass.FromMegapounds(value.ToDouble(null)); +#endif + + /// + public Mass Megatonnes +#if NET7_0_OR_GREATER + => Mass.FromMegatonnes(double.CreateChecked(value)); +#else + => Mass.FromMegatonnes(value.ToDouble(null)); +#endif + + /// + public Mass Micrograms +#if NET7_0_OR_GREATER + => Mass.FromMicrograms(double.CreateChecked(value)); +#else + => Mass.FromMicrograms(value.ToDouble(null)); +#endif + + /// + public Mass Milligrams +#if NET7_0_OR_GREATER + => Mass.FromMilligrams(double.CreateChecked(value)); +#else + => Mass.FromMilligrams(value.ToDouble(null)); +#endif + + /// + public Mass Nanograms +#if NET7_0_OR_GREATER + => Mass.FromNanograms(double.CreateChecked(value)); +#else + => Mass.FromNanograms(value.ToDouble(null)); +#endif + + /// + public Mass Ounces +#if NET7_0_OR_GREATER + => Mass.FromOunces(double.CreateChecked(value)); +#else + => Mass.FromOunces(value.ToDouble(null)); +#endif + + /// + public Mass Picograms +#if NET7_0_OR_GREATER + => Mass.FromPicograms(double.CreateChecked(value)); +#else + => Mass.FromPicograms(value.ToDouble(null)); +#endif + + /// + public Mass Pounds +#if NET7_0_OR_GREATER + => Mass.FromPounds(double.CreateChecked(value)); +#else + => Mass.FromPounds(value.ToDouble(null)); +#endif + + /// + public Mass ShortHundredweight +#if NET7_0_OR_GREATER + => Mass.FromShortHundredweight(double.CreateChecked(value)); +#else + => Mass.FromShortHundredweight(value.ToDouble(null)); +#endif + + /// + public Mass ShortTons +#if NET7_0_OR_GREATER + => Mass.FromShortTons(double.CreateChecked(value)); +#else + => Mass.FromShortTons(value.ToDouble(null)); +#endif + + /// + public Mass Slugs +#if NET7_0_OR_GREATER + => Mass.FromSlugs(double.CreateChecked(value)); +#else + => Mass.FromSlugs(value.ToDouble(null)); +#endif + + /// + public Mass SolarMasses +#if NET7_0_OR_GREATER + => Mass.FromSolarMasses(double.CreateChecked(value)); +#else + => Mass.FromSolarMasses(value.ToDouble(null)); +#endif + + /// + public Mass Stone +#if NET7_0_OR_GREATER + => Mass.FromStone(double.CreateChecked(value)); +#else + => Mass.FromStone(value.ToDouble(null)); +#endif + + /// + public Mass Tonnes +#if NET7_0_OR_GREATER + => Mass.FromTonnes(double.CreateChecked(value)); +#else + => Mass.FromTonnes(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassFlowExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassFlowExtensions.g.cs new file mode 100644 index 0000000000..fa4446a774 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassFlowExtensions.g.cs @@ -0,0 +1,311 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToMassFlow +{ + /// + /// A number to MassFlow Extensions + /// + public static class NumberToMassFlowExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public MassFlow CentigramsPerDay +#if NET7_0_OR_GREATER + => MassFlow.FromCentigramsPerDay(double.CreateChecked(value)); +#else + => MassFlow.FromCentigramsPerDay(value.ToDouble(null)); +#endif + + /// + public MassFlow CentigramsPerSecond +#if NET7_0_OR_GREATER + => MassFlow.FromCentigramsPerSecond(double.CreateChecked(value)); +#else + => MassFlow.FromCentigramsPerSecond(value.ToDouble(null)); +#endif + + /// + public MassFlow DecagramsPerDay +#if NET7_0_OR_GREATER + => MassFlow.FromDecagramsPerDay(double.CreateChecked(value)); +#else + => MassFlow.FromDecagramsPerDay(value.ToDouble(null)); +#endif + + /// + public MassFlow DecagramsPerSecond +#if NET7_0_OR_GREATER + => MassFlow.FromDecagramsPerSecond(double.CreateChecked(value)); +#else + => MassFlow.FromDecagramsPerSecond(value.ToDouble(null)); +#endif + + /// + public MassFlow DecigramsPerDay +#if NET7_0_OR_GREATER + => MassFlow.FromDecigramsPerDay(double.CreateChecked(value)); +#else + => MassFlow.FromDecigramsPerDay(value.ToDouble(null)); +#endif + + /// + public MassFlow DecigramsPerSecond +#if NET7_0_OR_GREATER + => MassFlow.FromDecigramsPerSecond(double.CreateChecked(value)); +#else + => MassFlow.FromDecigramsPerSecond(value.ToDouble(null)); +#endif + + /// + public MassFlow GramsPerDay +#if NET7_0_OR_GREATER + => MassFlow.FromGramsPerDay(double.CreateChecked(value)); +#else + => MassFlow.FromGramsPerDay(value.ToDouble(null)); +#endif + + /// + public MassFlow GramsPerHour +#if NET7_0_OR_GREATER + => MassFlow.FromGramsPerHour(double.CreateChecked(value)); +#else + => MassFlow.FromGramsPerHour(value.ToDouble(null)); +#endif + + /// + public MassFlow GramsPerSecond +#if NET7_0_OR_GREATER + => MassFlow.FromGramsPerSecond(double.CreateChecked(value)); +#else + => MassFlow.FromGramsPerSecond(value.ToDouble(null)); +#endif + + /// + public MassFlow HectogramsPerDay +#if NET7_0_OR_GREATER + => MassFlow.FromHectogramsPerDay(double.CreateChecked(value)); +#else + => MassFlow.FromHectogramsPerDay(value.ToDouble(null)); +#endif + + /// + public MassFlow HectogramsPerSecond +#if NET7_0_OR_GREATER + => MassFlow.FromHectogramsPerSecond(double.CreateChecked(value)); +#else + => MassFlow.FromHectogramsPerSecond(value.ToDouble(null)); +#endif + + /// + public MassFlow KilogramsPerDay +#if NET7_0_OR_GREATER + => MassFlow.FromKilogramsPerDay(double.CreateChecked(value)); +#else + => MassFlow.FromKilogramsPerDay(value.ToDouble(null)); +#endif + + /// + public MassFlow KilogramsPerHour +#if NET7_0_OR_GREATER + => MassFlow.FromKilogramsPerHour(double.CreateChecked(value)); +#else + => MassFlow.FromKilogramsPerHour(value.ToDouble(null)); +#endif + + /// + public MassFlow KilogramsPerMinute +#if NET7_0_OR_GREATER + => MassFlow.FromKilogramsPerMinute(double.CreateChecked(value)); +#else + => MassFlow.FromKilogramsPerMinute(value.ToDouble(null)); +#endif + + /// + public MassFlow KilogramsPerSecond +#if NET7_0_OR_GREATER + => MassFlow.FromKilogramsPerSecond(double.CreateChecked(value)); +#else + => MassFlow.FromKilogramsPerSecond(value.ToDouble(null)); +#endif + + /// + public MassFlow MegagramsPerDay +#if NET7_0_OR_GREATER + => MassFlow.FromMegagramsPerDay(double.CreateChecked(value)); +#else + => MassFlow.FromMegagramsPerDay(value.ToDouble(null)); +#endif + + /// + public MassFlow MegapoundsPerDay +#if NET7_0_OR_GREATER + => MassFlow.FromMegapoundsPerDay(double.CreateChecked(value)); +#else + => MassFlow.FromMegapoundsPerDay(value.ToDouble(null)); +#endif + + /// + public MassFlow MegapoundsPerHour +#if NET7_0_OR_GREATER + => MassFlow.FromMegapoundsPerHour(double.CreateChecked(value)); +#else + => MassFlow.FromMegapoundsPerHour(value.ToDouble(null)); +#endif + + /// + public MassFlow MegapoundsPerMinute +#if NET7_0_OR_GREATER + => MassFlow.FromMegapoundsPerMinute(double.CreateChecked(value)); +#else + => MassFlow.FromMegapoundsPerMinute(value.ToDouble(null)); +#endif + + /// + public MassFlow MegapoundsPerSecond +#if NET7_0_OR_GREATER + => MassFlow.FromMegapoundsPerSecond(double.CreateChecked(value)); +#else + => MassFlow.FromMegapoundsPerSecond(value.ToDouble(null)); +#endif + + /// + public MassFlow MicrogramsPerDay +#if NET7_0_OR_GREATER + => MassFlow.FromMicrogramsPerDay(double.CreateChecked(value)); +#else + => MassFlow.FromMicrogramsPerDay(value.ToDouble(null)); +#endif + + /// + public MassFlow MicrogramsPerSecond +#if NET7_0_OR_GREATER + => MassFlow.FromMicrogramsPerSecond(double.CreateChecked(value)); +#else + => MassFlow.FromMicrogramsPerSecond(value.ToDouble(null)); +#endif + + /// + public MassFlow MilligramsPerDay +#if NET7_0_OR_GREATER + => MassFlow.FromMilligramsPerDay(double.CreateChecked(value)); +#else + => MassFlow.FromMilligramsPerDay(value.ToDouble(null)); +#endif + + /// + public MassFlow MilligramsPerSecond +#if NET7_0_OR_GREATER + => MassFlow.FromMilligramsPerSecond(double.CreateChecked(value)); +#else + => MassFlow.FromMilligramsPerSecond(value.ToDouble(null)); +#endif + + /// + public MassFlow NanogramsPerDay +#if NET7_0_OR_GREATER + => MassFlow.FromNanogramsPerDay(double.CreateChecked(value)); +#else + => MassFlow.FromNanogramsPerDay(value.ToDouble(null)); +#endif + + /// + public MassFlow NanogramsPerSecond +#if NET7_0_OR_GREATER + => MassFlow.FromNanogramsPerSecond(double.CreateChecked(value)); +#else + => MassFlow.FromNanogramsPerSecond(value.ToDouble(null)); +#endif + + /// + public MassFlow PoundsPerDay +#if NET7_0_OR_GREATER + => MassFlow.FromPoundsPerDay(double.CreateChecked(value)); +#else + => MassFlow.FromPoundsPerDay(value.ToDouble(null)); +#endif + + /// + public MassFlow PoundsPerHour +#if NET7_0_OR_GREATER + => MassFlow.FromPoundsPerHour(double.CreateChecked(value)); +#else + => MassFlow.FromPoundsPerHour(value.ToDouble(null)); +#endif + + /// + public MassFlow PoundsPerMinute +#if NET7_0_OR_GREATER + => MassFlow.FromPoundsPerMinute(double.CreateChecked(value)); +#else + => MassFlow.FromPoundsPerMinute(value.ToDouble(null)); +#endif + + /// + public MassFlow PoundsPerSecond +#if NET7_0_OR_GREATER + => MassFlow.FromPoundsPerSecond(double.CreateChecked(value)); +#else + => MassFlow.FromPoundsPerSecond(value.ToDouble(null)); +#endif + + /// + public MassFlow ShortTonsPerHour +#if NET7_0_OR_GREATER + => MassFlow.FromShortTonsPerHour(double.CreateChecked(value)); +#else + => MassFlow.FromShortTonsPerHour(value.ToDouble(null)); +#endif + + /// + public MassFlow TonnesPerDay +#if NET7_0_OR_GREATER + => MassFlow.FromTonnesPerDay(double.CreateChecked(value)); +#else + => MassFlow.FromTonnesPerDay(value.ToDouble(null)); +#endif + + /// + public MassFlow TonnesPerHour +#if NET7_0_OR_GREATER + => MassFlow.FromTonnesPerHour(double.CreateChecked(value)); +#else + => MassFlow.FromTonnesPerHour(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassFluxExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassFluxExtensions.g.cs new file mode 100644 index 0000000000..1739177f50 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassFluxExtensions.g.cs @@ -0,0 +1,143 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToMassFlux +{ + /// + /// A number to MassFlux Extensions + /// + public static class NumberToMassFluxExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public MassFlux GramsPerHourPerSquareCentimeter +#if NET7_0_OR_GREATER + => MassFlux.FromGramsPerHourPerSquareCentimeter(double.CreateChecked(value)); +#else + => MassFlux.FromGramsPerHourPerSquareCentimeter(value.ToDouble(null)); +#endif + + /// + public MassFlux GramsPerHourPerSquareMeter +#if NET7_0_OR_GREATER + => MassFlux.FromGramsPerHourPerSquareMeter(double.CreateChecked(value)); +#else + => MassFlux.FromGramsPerHourPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public MassFlux GramsPerHourPerSquareMillimeter +#if NET7_0_OR_GREATER + => MassFlux.FromGramsPerHourPerSquareMillimeter(double.CreateChecked(value)); +#else + => MassFlux.FromGramsPerHourPerSquareMillimeter(value.ToDouble(null)); +#endif + + /// + public MassFlux GramsPerSecondPerSquareCentimeter +#if NET7_0_OR_GREATER + => MassFlux.FromGramsPerSecondPerSquareCentimeter(double.CreateChecked(value)); +#else + => MassFlux.FromGramsPerSecondPerSquareCentimeter(value.ToDouble(null)); +#endif + + /// + public MassFlux GramsPerSecondPerSquareMeter +#if NET7_0_OR_GREATER + => MassFlux.FromGramsPerSecondPerSquareMeter(double.CreateChecked(value)); +#else + => MassFlux.FromGramsPerSecondPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public MassFlux GramsPerSecondPerSquareMillimeter +#if NET7_0_OR_GREATER + => MassFlux.FromGramsPerSecondPerSquareMillimeter(double.CreateChecked(value)); +#else + => MassFlux.FromGramsPerSecondPerSquareMillimeter(value.ToDouble(null)); +#endif + + /// + public MassFlux KilogramsPerHourPerSquareCentimeter +#if NET7_0_OR_GREATER + => MassFlux.FromKilogramsPerHourPerSquareCentimeter(double.CreateChecked(value)); +#else + => MassFlux.FromKilogramsPerHourPerSquareCentimeter(value.ToDouble(null)); +#endif + + /// + public MassFlux KilogramsPerHourPerSquareMeter +#if NET7_0_OR_GREATER + => MassFlux.FromKilogramsPerHourPerSquareMeter(double.CreateChecked(value)); +#else + => MassFlux.FromKilogramsPerHourPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public MassFlux KilogramsPerHourPerSquareMillimeter +#if NET7_0_OR_GREATER + => MassFlux.FromKilogramsPerHourPerSquareMillimeter(double.CreateChecked(value)); +#else + => MassFlux.FromKilogramsPerHourPerSquareMillimeter(value.ToDouble(null)); +#endif + + /// + public MassFlux KilogramsPerSecondPerSquareCentimeter +#if NET7_0_OR_GREATER + => MassFlux.FromKilogramsPerSecondPerSquareCentimeter(double.CreateChecked(value)); +#else + => MassFlux.FromKilogramsPerSecondPerSquareCentimeter(value.ToDouble(null)); +#endif + + /// + public MassFlux KilogramsPerSecondPerSquareMeter +#if NET7_0_OR_GREATER + => MassFlux.FromKilogramsPerSecondPerSquareMeter(double.CreateChecked(value)); +#else + => MassFlux.FromKilogramsPerSecondPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public MassFlux KilogramsPerSecondPerSquareMillimeter +#if NET7_0_OR_GREATER + => MassFlux.FromKilogramsPerSecondPerSquareMillimeter(double.CreateChecked(value)); +#else + => MassFlux.FromKilogramsPerSecondPerSquareMillimeter(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassFractionExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassFractionExtensions.g.cs new file mode 100644 index 0000000000..e9a92982e2 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassFractionExtensions.g.cs @@ -0,0 +1,239 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToMassFraction +{ + /// + /// A number to MassFraction Extensions + /// + public static class NumberToMassFractionExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public MassFraction CentigramsPerGram +#if NET7_0_OR_GREATER + => MassFraction.FromCentigramsPerGram(double.CreateChecked(value)); +#else + => MassFraction.FromCentigramsPerGram(value.ToDouble(null)); +#endif + + /// + public MassFraction CentigramsPerKilogram +#if NET7_0_OR_GREATER + => MassFraction.FromCentigramsPerKilogram(double.CreateChecked(value)); +#else + => MassFraction.FromCentigramsPerKilogram(value.ToDouble(null)); +#endif + + /// + public MassFraction DecagramsPerGram +#if NET7_0_OR_GREATER + => MassFraction.FromDecagramsPerGram(double.CreateChecked(value)); +#else + => MassFraction.FromDecagramsPerGram(value.ToDouble(null)); +#endif + + /// + public MassFraction DecagramsPerKilogram +#if NET7_0_OR_GREATER + => MassFraction.FromDecagramsPerKilogram(double.CreateChecked(value)); +#else + => MassFraction.FromDecagramsPerKilogram(value.ToDouble(null)); +#endif + + /// + public MassFraction DecigramsPerGram +#if NET7_0_OR_GREATER + => MassFraction.FromDecigramsPerGram(double.CreateChecked(value)); +#else + => MassFraction.FromDecigramsPerGram(value.ToDouble(null)); +#endif + + /// + public MassFraction DecigramsPerKilogram +#if NET7_0_OR_GREATER + => MassFraction.FromDecigramsPerKilogram(double.CreateChecked(value)); +#else + => MassFraction.FromDecigramsPerKilogram(value.ToDouble(null)); +#endif + + /// + public MassFraction DecimalFractions +#if NET7_0_OR_GREATER + => MassFraction.FromDecimalFractions(double.CreateChecked(value)); +#else + => MassFraction.FromDecimalFractions(value.ToDouble(null)); +#endif + + /// + public MassFraction GramsPerGram +#if NET7_0_OR_GREATER + => MassFraction.FromGramsPerGram(double.CreateChecked(value)); +#else + => MassFraction.FromGramsPerGram(value.ToDouble(null)); +#endif + + /// + public MassFraction GramsPerKilogram +#if NET7_0_OR_GREATER + => MassFraction.FromGramsPerKilogram(double.CreateChecked(value)); +#else + => MassFraction.FromGramsPerKilogram(value.ToDouble(null)); +#endif + + /// + public MassFraction HectogramsPerGram +#if NET7_0_OR_GREATER + => MassFraction.FromHectogramsPerGram(double.CreateChecked(value)); +#else + => MassFraction.FromHectogramsPerGram(value.ToDouble(null)); +#endif + + /// + public MassFraction HectogramsPerKilogram +#if NET7_0_OR_GREATER + => MassFraction.FromHectogramsPerKilogram(double.CreateChecked(value)); +#else + => MassFraction.FromHectogramsPerKilogram(value.ToDouble(null)); +#endif + + /// + public MassFraction KilogramsPerGram +#if NET7_0_OR_GREATER + => MassFraction.FromKilogramsPerGram(double.CreateChecked(value)); +#else + => MassFraction.FromKilogramsPerGram(value.ToDouble(null)); +#endif + + /// + public MassFraction KilogramsPerKilogram +#if NET7_0_OR_GREATER + => MassFraction.FromKilogramsPerKilogram(double.CreateChecked(value)); +#else + => MassFraction.FromKilogramsPerKilogram(value.ToDouble(null)); +#endif + + /// + public MassFraction MicrogramsPerGram +#if NET7_0_OR_GREATER + => MassFraction.FromMicrogramsPerGram(double.CreateChecked(value)); +#else + => MassFraction.FromMicrogramsPerGram(value.ToDouble(null)); +#endif + + /// + public MassFraction MicrogramsPerKilogram +#if NET7_0_OR_GREATER + => MassFraction.FromMicrogramsPerKilogram(double.CreateChecked(value)); +#else + => MassFraction.FromMicrogramsPerKilogram(value.ToDouble(null)); +#endif + + /// + public MassFraction MilligramsPerGram +#if NET7_0_OR_GREATER + => MassFraction.FromMilligramsPerGram(double.CreateChecked(value)); +#else + => MassFraction.FromMilligramsPerGram(value.ToDouble(null)); +#endif + + /// + public MassFraction MilligramsPerKilogram +#if NET7_0_OR_GREATER + => MassFraction.FromMilligramsPerKilogram(double.CreateChecked(value)); +#else + => MassFraction.FromMilligramsPerKilogram(value.ToDouble(null)); +#endif + + /// + public MassFraction NanogramsPerGram +#if NET7_0_OR_GREATER + => MassFraction.FromNanogramsPerGram(double.CreateChecked(value)); +#else + => MassFraction.FromNanogramsPerGram(value.ToDouble(null)); +#endif + + /// + public MassFraction NanogramsPerKilogram +#if NET7_0_OR_GREATER + => MassFraction.FromNanogramsPerKilogram(double.CreateChecked(value)); +#else + => MassFraction.FromNanogramsPerKilogram(value.ToDouble(null)); +#endif + + /// + public MassFraction PartsPerBillion +#if NET7_0_OR_GREATER + => MassFraction.FromPartsPerBillion(double.CreateChecked(value)); +#else + => MassFraction.FromPartsPerBillion(value.ToDouble(null)); +#endif + + /// + public MassFraction PartsPerMillion +#if NET7_0_OR_GREATER + => MassFraction.FromPartsPerMillion(double.CreateChecked(value)); +#else + => MassFraction.FromPartsPerMillion(value.ToDouble(null)); +#endif + + /// + public MassFraction PartsPerThousand +#if NET7_0_OR_GREATER + => MassFraction.FromPartsPerThousand(double.CreateChecked(value)); +#else + => MassFraction.FromPartsPerThousand(value.ToDouble(null)); +#endif + + /// + public MassFraction PartsPerTrillion +#if NET7_0_OR_GREATER + => MassFraction.FromPartsPerTrillion(double.CreateChecked(value)); +#else + => MassFraction.FromPartsPerTrillion(value.ToDouble(null)); +#endif + + /// + public MassFraction Percent +#if NET7_0_OR_GREATER + => MassFraction.FromPercent(double.CreateChecked(value)); +#else + => MassFraction.FromPercent(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassMomentOfInertiaExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassMomentOfInertiaExtensions.g.cs new file mode 100644 index 0000000000..450d9f78eb --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMassMomentOfInertiaExtensions.g.cs @@ -0,0 +1,271 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToMassMomentOfInertia +{ + /// + /// A number to MassMomentOfInertia Extensions + /// + public static class NumberToMassMomentOfInertiaExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public MassMomentOfInertia GramSquareCentimeters +#if NET7_0_OR_GREATER + => MassMomentOfInertia.FromGramSquareCentimeters(double.CreateChecked(value)); +#else + => MassMomentOfInertia.FromGramSquareCentimeters(value.ToDouble(null)); +#endif + + /// + public MassMomentOfInertia GramSquareDecimeters +#if NET7_0_OR_GREATER + => MassMomentOfInertia.FromGramSquareDecimeters(double.CreateChecked(value)); +#else + => MassMomentOfInertia.FromGramSquareDecimeters(value.ToDouble(null)); +#endif + + /// + public MassMomentOfInertia GramSquareMeters +#if NET7_0_OR_GREATER + => MassMomentOfInertia.FromGramSquareMeters(double.CreateChecked(value)); +#else + => MassMomentOfInertia.FromGramSquareMeters(value.ToDouble(null)); +#endif + + /// + public MassMomentOfInertia GramSquareMillimeters +#if NET7_0_OR_GREATER + => MassMomentOfInertia.FromGramSquareMillimeters(double.CreateChecked(value)); +#else + => MassMomentOfInertia.FromGramSquareMillimeters(value.ToDouble(null)); +#endif + + /// + public MassMomentOfInertia KilogramSquareCentimeters +#if NET7_0_OR_GREATER + => MassMomentOfInertia.FromKilogramSquareCentimeters(double.CreateChecked(value)); +#else + => MassMomentOfInertia.FromKilogramSquareCentimeters(value.ToDouble(null)); +#endif + + /// + public MassMomentOfInertia KilogramSquareDecimeters +#if NET7_0_OR_GREATER + => MassMomentOfInertia.FromKilogramSquareDecimeters(double.CreateChecked(value)); +#else + => MassMomentOfInertia.FromKilogramSquareDecimeters(value.ToDouble(null)); +#endif + + /// + public MassMomentOfInertia KilogramSquareMeters +#if NET7_0_OR_GREATER + => MassMomentOfInertia.FromKilogramSquareMeters(double.CreateChecked(value)); +#else + => MassMomentOfInertia.FromKilogramSquareMeters(value.ToDouble(null)); +#endif + + /// + public MassMomentOfInertia KilogramSquareMillimeters +#if NET7_0_OR_GREATER + => MassMomentOfInertia.FromKilogramSquareMillimeters(double.CreateChecked(value)); +#else + => MassMomentOfInertia.FromKilogramSquareMillimeters(value.ToDouble(null)); +#endif + + /// + public MassMomentOfInertia KilotonneSquareCentimeters +#if NET7_0_OR_GREATER + => MassMomentOfInertia.FromKilotonneSquareCentimeters(double.CreateChecked(value)); +#else + => MassMomentOfInertia.FromKilotonneSquareCentimeters(value.ToDouble(null)); +#endif + + /// + public MassMomentOfInertia KilotonneSquareDecimeters +#if NET7_0_OR_GREATER + => MassMomentOfInertia.FromKilotonneSquareDecimeters(double.CreateChecked(value)); +#else + => MassMomentOfInertia.FromKilotonneSquareDecimeters(value.ToDouble(null)); +#endif + + /// + public MassMomentOfInertia KilotonneSquareMeters +#if NET7_0_OR_GREATER + => MassMomentOfInertia.FromKilotonneSquareMeters(double.CreateChecked(value)); +#else + => MassMomentOfInertia.FromKilotonneSquareMeters(value.ToDouble(null)); +#endif + + /// + public MassMomentOfInertia KilotonneSquareMillimeters +#if NET7_0_OR_GREATER + => MassMomentOfInertia.FromKilotonneSquareMillimeters(double.CreateChecked(value)); +#else + => MassMomentOfInertia.FromKilotonneSquareMillimeters(value.ToDouble(null)); +#endif + + /// + public MassMomentOfInertia MegatonneSquareCentimeters +#if NET7_0_OR_GREATER + => MassMomentOfInertia.FromMegatonneSquareCentimeters(double.CreateChecked(value)); +#else + => MassMomentOfInertia.FromMegatonneSquareCentimeters(value.ToDouble(null)); +#endif + + /// + public MassMomentOfInertia MegatonneSquareDecimeters +#if NET7_0_OR_GREATER + => MassMomentOfInertia.FromMegatonneSquareDecimeters(double.CreateChecked(value)); +#else + => MassMomentOfInertia.FromMegatonneSquareDecimeters(value.ToDouble(null)); +#endif + + /// + public MassMomentOfInertia MegatonneSquareMeters +#if NET7_0_OR_GREATER + => MassMomentOfInertia.FromMegatonneSquareMeters(double.CreateChecked(value)); +#else + => MassMomentOfInertia.FromMegatonneSquareMeters(value.ToDouble(null)); +#endif + + /// + public MassMomentOfInertia MegatonneSquareMillimeters +#if NET7_0_OR_GREATER + => MassMomentOfInertia.FromMegatonneSquareMillimeters(double.CreateChecked(value)); +#else + => MassMomentOfInertia.FromMegatonneSquareMillimeters(value.ToDouble(null)); +#endif + + /// + public MassMomentOfInertia MilligramSquareCentimeters +#if NET7_0_OR_GREATER + => MassMomentOfInertia.FromMilligramSquareCentimeters(double.CreateChecked(value)); +#else + => MassMomentOfInertia.FromMilligramSquareCentimeters(value.ToDouble(null)); +#endif + + /// + public MassMomentOfInertia MilligramSquareDecimeters +#if NET7_0_OR_GREATER + => MassMomentOfInertia.FromMilligramSquareDecimeters(double.CreateChecked(value)); +#else + => MassMomentOfInertia.FromMilligramSquareDecimeters(value.ToDouble(null)); +#endif + + /// + public MassMomentOfInertia MilligramSquareMeters +#if NET7_0_OR_GREATER + => MassMomentOfInertia.FromMilligramSquareMeters(double.CreateChecked(value)); +#else + => MassMomentOfInertia.FromMilligramSquareMeters(value.ToDouble(null)); +#endif + + /// + public MassMomentOfInertia MilligramSquareMillimeters +#if NET7_0_OR_GREATER + => MassMomentOfInertia.FromMilligramSquareMillimeters(double.CreateChecked(value)); +#else + => MassMomentOfInertia.FromMilligramSquareMillimeters(value.ToDouble(null)); +#endif + + /// + public MassMomentOfInertia PoundSquareFeet +#if NET7_0_OR_GREATER + => MassMomentOfInertia.FromPoundSquareFeet(double.CreateChecked(value)); +#else + => MassMomentOfInertia.FromPoundSquareFeet(value.ToDouble(null)); +#endif + + /// + public MassMomentOfInertia PoundSquareInches +#if NET7_0_OR_GREATER + => MassMomentOfInertia.FromPoundSquareInches(double.CreateChecked(value)); +#else + => MassMomentOfInertia.FromPoundSquareInches(value.ToDouble(null)); +#endif + + /// + public MassMomentOfInertia SlugSquareFeet +#if NET7_0_OR_GREATER + => MassMomentOfInertia.FromSlugSquareFeet(double.CreateChecked(value)); +#else + => MassMomentOfInertia.FromSlugSquareFeet(value.ToDouble(null)); +#endif + + /// + public MassMomentOfInertia SlugSquareInches +#if NET7_0_OR_GREATER + => MassMomentOfInertia.FromSlugSquareInches(double.CreateChecked(value)); +#else + => MassMomentOfInertia.FromSlugSquareInches(value.ToDouble(null)); +#endif + + /// + public MassMomentOfInertia TonneSquareCentimeters +#if NET7_0_OR_GREATER + => MassMomentOfInertia.FromTonneSquareCentimeters(double.CreateChecked(value)); +#else + => MassMomentOfInertia.FromTonneSquareCentimeters(value.ToDouble(null)); +#endif + + /// + public MassMomentOfInertia TonneSquareDecimeters +#if NET7_0_OR_GREATER + => MassMomentOfInertia.FromTonneSquareDecimeters(double.CreateChecked(value)); +#else + => MassMomentOfInertia.FromTonneSquareDecimeters(value.ToDouble(null)); +#endif + + /// + public MassMomentOfInertia TonneSquareMeters +#if NET7_0_OR_GREATER + => MassMomentOfInertia.FromTonneSquareMeters(double.CreateChecked(value)); +#else + => MassMomentOfInertia.FromTonneSquareMeters(value.ToDouble(null)); +#endif + + /// + public MassMomentOfInertia TonneSquareMillimeters +#if NET7_0_OR_GREATER + => MassMomentOfInertia.FromTonneSquareMillimeters(double.CreateChecked(value)); +#else + => MassMomentOfInertia.FromTonneSquareMillimeters(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolalityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolalityExtensions.g.cs new file mode 100644 index 0000000000..0e7a18e631 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolalityExtensions.g.cs @@ -0,0 +1,71 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToMolality +{ + /// + /// A number to Molality Extensions + /// + public static class NumberToMolalityExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Molality MillimolesPerKilogram +#if NET7_0_OR_GREATER + => Molality.FromMillimolesPerKilogram(double.CreateChecked(value)); +#else + => Molality.FromMillimolesPerKilogram(value.ToDouble(null)); +#endif + + /// + public Molality MolesPerGram +#if NET7_0_OR_GREATER + => Molality.FromMolesPerGram(double.CreateChecked(value)); +#else + => Molality.FromMolesPerGram(value.ToDouble(null)); +#endif + + /// + public Molality MolesPerKilogram +#if NET7_0_OR_GREATER + => Molality.FromMolesPerKilogram(double.CreateChecked(value)); +#else + => Molality.FromMolesPerKilogram(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarEnergyExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarEnergyExtensions.g.cs new file mode 100644 index 0000000000..a67cb580e7 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarEnergyExtensions.g.cs @@ -0,0 +1,71 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToMolarEnergy +{ + /// + /// A number to MolarEnergy Extensions + /// + public static class NumberToMolarEnergyExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public MolarEnergy JoulesPerMole +#if NET7_0_OR_GREATER + => MolarEnergy.FromJoulesPerMole(double.CreateChecked(value)); +#else + => MolarEnergy.FromJoulesPerMole(value.ToDouble(null)); +#endif + + /// + public MolarEnergy KilojoulesPerMole +#if NET7_0_OR_GREATER + => MolarEnergy.FromKilojoulesPerMole(double.CreateChecked(value)); +#else + => MolarEnergy.FromKilojoulesPerMole(value.ToDouble(null)); +#endif + + /// + public MolarEnergy MegajoulesPerMole +#if NET7_0_OR_GREATER + => MolarEnergy.FromMegajoulesPerMole(double.CreateChecked(value)); +#else + => MolarEnergy.FromMegajoulesPerMole(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarEntropyExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarEntropyExtensions.g.cs new file mode 100644 index 0000000000..f1e7dd57a9 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarEntropyExtensions.g.cs @@ -0,0 +1,71 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToMolarEntropy +{ + /// + /// A number to MolarEntropy Extensions + /// + public static class NumberToMolarEntropyExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public MolarEntropy JoulesPerMoleKelvin +#if NET7_0_OR_GREATER + => MolarEntropy.FromJoulesPerMoleKelvin(double.CreateChecked(value)); +#else + => MolarEntropy.FromJoulesPerMoleKelvin(value.ToDouble(null)); +#endif + + /// + public MolarEntropy KilojoulesPerMoleKelvin +#if NET7_0_OR_GREATER + => MolarEntropy.FromKilojoulesPerMoleKelvin(double.CreateChecked(value)); +#else + => MolarEntropy.FromKilojoulesPerMoleKelvin(value.ToDouble(null)); +#endif + + /// + public MolarEntropy MegajoulesPerMoleKelvin +#if NET7_0_OR_GREATER + => MolarEntropy.FromMegajoulesPerMoleKelvin(double.CreateChecked(value)); +#else + => MolarEntropy.FromMegajoulesPerMoleKelvin(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarFlowExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarFlowExtensions.g.cs new file mode 100644 index 0000000000..c7511d2b5b --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarFlowExtensions.g.cs @@ -0,0 +1,119 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToMolarFlow +{ + /// + /// A number to MolarFlow Extensions + /// + public static class NumberToMolarFlowExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public MolarFlow KilomolesPerHour +#if NET7_0_OR_GREATER + => MolarFlow.FromKilomolesPerHour(double.CreateChecked(value)); +#else + => MolarFlow.FromKilomolesPerHour(value.ToDouble(null)); +#endif + + /// + public MolarFlow KilomolesPerMinute +#if NET7_0_OR_GREATER + => MolarFlow.FromKilomolesPerMinute(double.CreateChecked(value)); +#else + => MolarFlow.FromKilomolesPerMinute(value.ToDouble(null)); +#endif + + /// + public MolarFlow KilomolesPerSecond +#if NET7_0_OR_GREATER + => MolarFlow.FromKilomolesPerSecond(double.CreateChecked(value)); +#else + => MolarFlow.FromKilomolesPerSecond(value.ToDouble(null)); +#endif + + /// + public MolarFlow MolesPerHour +#if NET7_0_OR_GREATER + => MolarFlow.FromMolesPerHour(double.CreateChecked(value)); +#else + => MolarFlow.FromMolesPerHour(value.ToDouble(null)); +#endif + + /// + public MolarFlow MolesPerMinute +#if NET7_0_OR_GREATER + => MolarFlow.FromMolesPerMinute(double.CreateChecked(value)); +#else + => MolarFlow.FromMolesPerMinute(value.ToDouble(null)); +#endif + + /// + public MolarFlow MolesPerSecond +#if NET7_0_OR_GREATER + => MolarFlow.FromMolesPerSecond(double.CreateChecked(value)); +#else + => MolarFlow.FromMolesPerSecond(value.ToDouble(null)); +#endif + + /// + public MolarFlow PoundMolesPerHour +#if NET7_0_OR_GREATER + => MolarFlow.FromPoundMolesPerHour(double.CreateChecked(value)); +#else + => MolarFlow.FromPoundMolesPerHour(value.ToDouble(null)); +#endif + + /// + public MolarFlow PoundMolesPerMinute +#if NET7_0_OR_GREATER + => MolarFlow.FromPoundMolesPerMinute(double.CreateChecked(value)); +#else + => MolarFlow.FromPoundMolesPerMinute(value.ToDouble(null)); +#endif + + /// + public MolarFlow PoundMolesPerSecond +#if NET7_0_OR_GREATER + => MolarFlow.FromPoundMolesPerSecond(double.CreateChecked(value)); +#else + => MolarFlow.FromPoundMolesPerSecond(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarMassExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarMassExtensions.g.cs new file mode 100644 index 0000000000..d8c37c284d --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarMassExtensions.g.cs @@ -0,0 +1,151 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToMolarMass +{ + /// + /// A number to MolarMass Extensions + /// + public static class NumberToMolarMassExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public MolarMass CentigramsPerMole +#if NET7_0_OR_GREATER + => MolarMass.FromCentigramsPerMole(double.CreateChecked(value)); +#else + => MolarMass.FromCentigramsPerMole(value.ToDouble(null)); +#endif + + /// + public MolarMass DecagramsPerMole +#if NET7_0_OR_GREATER + => MolarMass.FromDecagramsPerMole(double.CreateChecked(value)); +#else + => MolarMass.FromDecagramsPerMole(value.ToDouble(null)); +#endif + + /// + public MolarMass DecigramsPerMole +#if NET7_0_OR_GREATER + => MolarMass.FromDecigramsPerMole(double.CreateChecked(value)); +#else + => MolarMass.FromDecigramsPerMole(value.ToDouble(null)); +#endif + + /// + public MolarMass GramsPerMole +#if NET7_0_OR_GREATER + => MolarMass.FromGramsPerMole(double.CreateChecked(value)); +#else + => MolarMass.FromGramsPerMole(value.ToDouble(null)); +#endif + + /// + public MolarMass HectogramsPerMole +#if NET7_0_OR_GREATER + => MolarMass.FromHectogramsPerMole(double.CreateChecked(value)); +#else + => MolarMass.FromHectogramsPerMole(value.ToDouble(null)); +#endif + + /// + public MolarMass KilogramsPerKilomole +#if NET7_0_OR_GREATER + => MolarMass.FromKilogramsPerKilomole(double.CreateChecked(value)); +#else + => MolarMass.FromKilogramsPerKilomole(value.ToDouble(null)); +#endif + + /// + public MolarMass KilogramsPerMole +#if NET7_0_OR_GREATER + => MolarMass.FromKilogramsPerMole(double.CreateChecked(value)); +#else + => MolarMass.FromKilogramsPerMole(value.ToDouble(null)); +#endif + + /// + public MolarMass KilopoundsPerMole +#if NET7_0_OR_GREATER + => MolarMass.FromKilopoundsPerMole(double.CreateChecked(value)); +#else + => MolarMass.FromKilopoundsPerMole(value.ToDouble(null)); +#endif + + /// + public MolarMass MegapoundsPerMole +#if NET7_0_OR_GREATER + => MolarMass.FromMegapoundsPerMole(double.CreateChecked(value)); +#else + => MolarMass.FromMegapoundsPerMole(value.ToDouble(null)); +#endif + + /// + public MolarMass MicrogramsPerMole +#if NET7_0_OR_GREATER + => MolarMass.FromMicrogramsPerMole(double.CreateChecked(value)); +#else + => MolarMass.FromMicrogramsPerMole(value.ToDouble(null)); +#endif + + /// + public MolarMass MilligramsPerMole +#if NET7_0_OR_GREATER + => MolarMass.FromMilligramsPerMole(double.CreateChecked(value)); +#else + => MolarMass.FromMilligramsPerMole(value.ToDouble(null)); +#endif + + /// + public MolarMass NanogramsPerMole +#if NET7_0_OR_GREATER + => MolarMass.FromNanogramsPerMole(double.CreateChecked(value)); +#else + => MolarMass.FromNanogramsPerMole(value.ToDouble(null)); +#endif + + /// + public MolarMass PoundsPerMole +#if NET7_0_OR_GREATER + => MolarMass.FromPoundsPerMole(double.CreateChecked(value)); +#else + => MolarMass.FromPoundsPerMole(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarityExtensions.g.cs new file mode 100644 index 0000000000..8f57674541 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToMolarityExtensions.g.cs @@ -0,0 +1,135 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToMolarity +{ + /// + /// A number to Molarity Extensions + /// + public static class NumberToMolarityExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Molarity CentimolesPerLiter +#if NET7_0_OR_GREATER + => Molarity.FromCentimolesPerLiter(double.CreateChecked(value)); +#else + => Molarity.FromCentimolesPerLiter(value.ToDouble(null)); +#endif + + /// + public Molarity DecimolesPerLiter +#if NET7_0_OR_GREATER + => Molarity.FromDecimolesPerLiter(double.CreateChecked(value)); +#else + => Molarity.FromDecimolesPerLiter(value.ToDouble(null)); +#endif + + /// + public Molarity FemtomolesPerLiter +#if NET7_0_OR_GREATER + => Molarity.FromFemtomolesPerLiter(double.CreateChecked(value)); +#else + => Molarity.FromFemtomolesPerLiter(value.ToDouble(null)); +#endif + + /// + public Molarity KilomolesPerCubicMeter +#if NET7_0_OR_GREATER + => Molarity.FromKilomolesPerCubicMeter(double.CreateChecked(value)); +#else + => Molarity.FromKilomolesPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public Molarity MicromolesPerLiter +#if NET7_0_OR_GREATER + => Molarity.FromMicromolesPerLiter(double.CreateChecked(value)); +#else + => Molarity.FromMicromolesPerLiter(value.ToDouble(null)); +#endif + + /// + public Molarity MillimolesPerLiter +#if NET7_0_OR_GREATER + => Molarity.FromMillimolesPerLiter(double.CreateChecked(value)); +#else + => Molarity.FromMillimolesPerLiter(value.ToDouble(null)); +#endif + + /// + public Molarity MolesPerCubicMeter +#if NET7_0_OR_GREATER + => Molarity.FromMolesPerCubicMeter(double.CreateChecked(value)); +#else + => Molarity.FromMolesPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public Molarity MolesPerLiter +#if NET7_0_OR_GREATER + => Molarity.FromMolesPerLiter(double.CreateChecked(value)); +#else + => Molarity.FromMolesPerLiter(value.ToDouble(null)); +#endif + + /// + public Molarity NanomolesPerLiter +#if NET7_0_OR_GREATER + => Molarity.FromNanomolesPerLiter(double.CreateChecked(value)); +#else + => Molarity.FromNanomolesPerLiter(value.ToDouble(null)); +#endif + + /// + public Molarity PicomolesPerLiter +#if NET7_0_OR_GREATER + => Molarity.FromPicomolesPerLiter(double.CreateChecked(value)); +#else + => Molarity.FromPicomolesPerLiter(value.ToDouble(null)); +#endif + + /// + public Molarity PoundMolesPerCubicFoot +#if NET7_0_OR_GREATER + => Molarity.FromPoundMolesPerCubicFoot(double.CreateChecked(value)); +#else + => Molarity.FromPoundMolesPerCubicFoot(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPermeabilityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPermeabilityExtensions.g.cs new file mode 100644 index 0000000000..8acd2c2e8f --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPermeabilityExtensions.g.cs @@ -0,0 +1,55 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToPermeability +{ + /// + /// A number to Permeability Extensions + /// + public static class NumberToPermeabilityExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Permeability HenriesPerMeter +#if NET7_0_OR_GREATER + => Permeability.FromHenriesPerMeter(double.CreateChecked(value)); +#else + => Permeability.FromHenriesPerMeter(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPermittivityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPermittivityExtensions.g.cs new file mode 100644 index 0000000000..568334d284 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPermittivityExtensions.g.cs @@ -0,0 +1,55 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToPermittivity +{ + /// + /// A number to Permittivity Extensions + /// + public static class NumberToPermittivityExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Permittivity FaradsPerMeter +#if NET7_0_OR_GREATER + => Permittivity.FromFaradsPerMeter(double.CreateChecked(value)); +#else + => Permittivity.FromFaradsPerMeter(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPorousMediumPermeabilityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPorousMediumPermeabilityExtensions.g.cs new file mode 100644 index 0000000000..307668807d --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPorousMediumPermeabilityExtensions.g.cs @@ -0,0 +1,87 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToPorousMediumPermeability +{ + /// + /// A number to PorousMediumPermeability Extensions + /// + public static class NumberToPorousMediumPermeabilityExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public PorousMediumPermeability Darcys +#if NET7_0_OR_GREATER + => PorousMediumPermeability.FromDarcys(double.CreateChecked(value)); +#else + => PorousMediumPermeability.FromDarcys(value.ToDouble(null)); +#endif + + /// + public PorousMediumPermeability Microdarcys +#if NET7_0_OR_GREATER + => PorousMediumPermeability.FromMicrodarcys(double.CreateChecked(value)); +#else + => PorousMediumPermeability.FromMicrodarcys(value.ToDouble(null)); +#endif + + /// + public PorousMediumPermeability Millidarcys +#if NET7_0_OR_GREATER + => PorousMediumPermeability.FromMillidarcys(double.CreateChecked(value)); +#else + => PorousMediumPermeability.FromMillidarcys(value.ToDouble(null)); +#endif + + /// + public PorousMediumPermeability SquareCentimeters +#if NET7_0_OR_GREATER + => PorousMediumPermeability.FromSquareCentimeters(double.CreateChecked(value)); +#else + => PorousMediumPermeability.FromSquareCentimeters(value.ToDouble(null)); +#endif + + /// + public PorousMediumPermeability SquareMeters +#if NET7_0_OR_GREATER + => PorousMediumPermeability.FromSquareMeters(double.CreateChecked(value)); +#else + => PorousMediumPermeability.FromSquareMeters(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPowerDensityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPowerDensityExtensions.g.cs new file mode 100644 index 0000000000..76f5cfb9a3 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPowerDensityExtensions.g.cs @@ -0,0 +1,399 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToPowerDensity +{ + /// + /// A number to PowerDensity Extensions + /// + public static class NumberToPowerDensityExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public PowerDensity DecawattsPerCubicFoot +#if NET7_0_OR_GREATER + => PowerDensity.FromDecawattsPerCubicFoot(double.CreateChecked(value)); +#else + => PowerDensity.FromDecawattsPerCubicFoot(value.ToDouble(null)); +#endif + + /// + public PowerDensity DecawattsPerCubicInch +#if NET7_0_OR_GREATER + => PowerDensity.FromDecawattsPerCubicInch(double.CreateChecked(value)); +#else + => PowerDensity.FromDecawattsPerCubicInch(value.ToDouble(null)); +#endif + + /// + public PowerDensity DecawattsPerCubicMeter +#if NET7_0_OR_GREATER + => PowerDensity.FromDecawattsPerCubicMeter(double.CreateChecked(value)); +#else + => PowerDensity.FromDecawattsPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public PowerDensity DecawattsPerLiter +#if NET7_0_OR_GREATER + => PowerDensity.FromDecawattsPerLiter(double.CreateChecked(value)); +#else + => PowerDensity.FromDecawattsPerLiter(value.ToDouble(null)); +#endif + + /// + public PowerDensity DeciwattsPerCubicFoot +#if NET7_0_OR_GREATER + => PowerDensity.FromDeciwattsPerCubicFoot(double.CreateChecked(value)); +#else + => PowerDensity.FromDeciwattsPerCubicFoot(value.ToDouble(null)); +#endif + + /// + public PowerDensity DeciwattsPerCubicInch +#if NET7_0_OR_GREATER + => PowerDensity.FromDeciwattsPerCubicInch(double.CreateChecked(value)); +#else + => PowerDensity.FromDeciwattsPerCubicInch(value.ToDouble(null)); +#endif + + /// + public PowerDensity DeciwattsPerCubicMeter +#if NET7_0_OR_GREATER + => PowerDensity.FromDeciwattsPerCubicMeter(double.CreateChecked(value)); +#else + => PowerDensity.FromDeciwattsPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public PowerDensity DeciwattsPerLiter +#if NET7_0_OR_GREATER + => PowerDensity.FromDeciwattsPerLiter(double.CreateChecked(value)); +#else + => PowerDensity.FromDeciwattsPerLiter(value.ToDouble(null)); +#endif + + /// + public PowerDensity GigawattsPerCubicFoot +#if NET7_0_OR_GREATER + => PowerDensity.FromGigawattsPerCubicFoot(double.CreateChecked(value)); +#else + => PowerDensity.FromGigawattsPerCubicFoot(value.ToDouble(null)); +#endif + + /// + public PowerDensity GigawattsPerCubicInch +#if NET7_0_OR_GREATER + => PowerDensity.FromGigawattsPerCubicInch(double.CreateChecked(value)); +#else + => PowerDensity.FromGigawattsPerCubicInch(value.ToDouble(null)); +#endif + + /// + public PowerDensity GigawattsPerCubicMeter +#if NET7_0_OR_GREATER + => PowerDensity.FromGigawattsPerCubicMeter(double.CreateChecked(value)); +#else + => PowerDensity.FromGigawattsPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public PowerDensity GigawattsPerLiter +#if NET7_0_OR_GREATER + => PowerDensity.FromGigawattsPerLiter(double.CreateChecked(value)); +#else + => PowerDensity.FromGigawattsPerLiter(value.ToDouble(null)); +#endif + + /// + public PowerDensity KilowattsPerCubicFoot +#if NET7_0_OR_GREATER + => PowerDensity.FromKilowattsPerCubicFoot(double.CreateChecked(value)); +#else + => PowerDensity.FromKilowattsPerCubicFoot(value.ToDouble(null)); +#endif + + /// + public PowerDensity KilowattsPerCubicInch +#if NET7_0_OR_GREATER + => PowerDensity.FromKilowattsPerCubicInch(double.CreateChecked(value)); +#else + => PowerDensity.FromKilowattsPerCubicInch(value.ToDouble(null)); +#endif + + /// + public PowerDensity KilowattsPerCubicMeter +#if NET7_0_OR_GREATER + => PowerDensity.FromKilowattsPerCubicMeter(double.CreateChecked(value)); +#else + => PowerDensity.FromKilowattsPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public PowerDensity KilowattsPerLiter +#if NET7_0_OR_GREATER + => PowerDensity.FromKilowattsPerLiter(double.CreateChecked(value)); +#else + => PowerDensity.FromKilowattsPerLiter(value.ToDouble(null)); +#endif + + /// + public PowerDensity MegawattsPerCubicFoot +#if NET7_0_OR_GREATER + => PowerDensity.FromMegawattsPerCubicFoot(double.CreateChecked(value)); +#else + => PowerDensity.FromMegawattsPerCubicFoot(value.ToDouble(null)); +#endif + + /// + public PowerDensity MegawattsPerCubicInch +#if NET7_0_OR_GREATER + => PowerDensity.FromMegawattsPerCubicInch(double.CreateChecked(value)); +#else + => PowerDensity.FromMegawattsPerCubicInch(value.ToDouble(null)); +#endif + + /// + public PowerDensity MegawattsPerCubicMeter +#if NET7_0_OR_GREATER + => PowerDensity.FromMegawattsPerCubicMeter(double.CreateChecked(value)); +#else + => PowerDensity.FromMegawattsPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public PowerDensity MegawattsPerLiter +#if NET7_0_OR_GREATER + => PowerDensity.FromMegawattsPerLiter(double.CreateChecked(value)); +#else + => PowerDensity.FromMegawattsPerLiter(value.ToDouble(null)); +#endif + + /// + public PowerDensity MicrowattsPerCubicFoot +#if NET7_0_OR_GREATER + => PowerDensity.FromMicrowattsPerCubicFoot(double.CreateChecked(value)); +#else + => PowerDensity.FromMicrowattsPerCubicFoot(value.ToDouble(null)); +#endif + + /// + public PowerDensity MicrowattsPerCubicInch +#if NET7_0_OR_GREATER + => PowerDensity.FromMicrowattsPerCubicInch(double.CreateChecked(value)); +#else + => PowerDensity.FromMicrowattsPerCubicInch(value.ToDouble(null)); +#endif + + /// + public PowerDensity MicrowattsPerCubicMeter +#if NET7_0_OR_GREATER + => PowerDensity.FromMicrowattsPerCubicMeter(double.CreateChecked(value)); +#else + => PowerDensity.FromMicrowattsPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public PowerDensity MicrowattsPerLiter +#if NET7_0_OR_GREATER + => PowerDensity.FromMicrowattsPerLiter(double.CreateChecked(value)); +#else + => PowerDensity.FromMicrowattsPerLiter(value.ToDouble(null)); +#endif + + /// + public PowerDensity MilliwattsPerCubicFoot +#if NET7_0_OR_GREATER + => PowerDensity.FromMilliwattsPerCubicFoot(double.CreateChecked(value)); +#else + => PowerDensity.FromMilliwattsPerCubicFoot(value.ToDouble(null)); +#endif + + /// + public PowerDensity MilliwattsPerCubicInch +#if NET7_0_OR_GREATER + => PowerDensity.FromMilliwattsPerCubicInch(double.CreateChecked(value)); +#else + => PowerDensity.FromMilliwattsPerCubicInch(value.ToDouble(null)); +#endif + + /// + public PowerDensity MilliwattsPerCubicMeter +#if NET7_0_OR_GREATER + => PowerDensity.FromMilliwattsPerCubicMeter(double.CreateChecked(value)); +#else + => PowerDensity.FromMilliwattsPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public PowerDensity MilliwattsPerLiter +#if NET7_0_OR_GREATER + => PowerDensity.FromMilliwattsPerLiter(double.CreateChecked(value)); +#else + => PowerDensity.FromMilliwattsPerLiter(value.ToDouble(null)); +#endif + + /// + public PowerDensity NanowattsPerCubicFoot +#if NET7_0_OR_GREATER + => PowerDensity.FromNanowattsPerCubicFoot(double.CreateChecked(value)); +#else + => PowerDensity.FromNanowattsPerCubicFoot(value.ToDouble(null)); +#endif + + /// + public PowerDensity NanowattsPerCubicInch +#if NET7_0_OR_GREATER + => PowerDensity.FromNanowattsPerCubicInch(double.CreateChecked(value)); +#else + => PowerDensity.FromNanowattsPerCubicInch(value.ToDouble(null)); +#endif + + /// + public PowerDensity NanowattsPerCubicMeter +#if NET7_0_OR_GREATER + => PowerDensity.FromNanowattsPerCubicMeter(double.CreateChecked(value)); +#else + => PowerDensity.FromNanowattsPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public PowerDensity NanowattsPerLiter +#if NET7_0_OR_GREATER + => PowerDensity.FromNanowattsPerLiter(double.CreateChecked(value)); +#else + => PowerDensity.FromNanowattsPerLiter(value.ToDouble(null)); +#endif + + /// + public PowerDensity PicowattsPerCubicFoot +#if NET7_0_OR_GREATER + => PowerDensity.FromPicowattsPerCubicFoot(double.CreateChecked(value)); +#else + => PowerDensity.FromPicowattsPerCubicFoot(value.ToDouble(null)); +#endif + + /// + public PowerDensity PicowattsPerCubicInch +#if NET7_0_OR_GREATER + => PowerDensity.FromPicowattsPerCubicInch(double.CreateChecked(value)); +#else + => PowerDensity.FromPicowattsPerCubicInch(value.ToDouble(null)); +#endif + + /// + public PowerDensity PicowattsPerCubicMeter +#if NET7_0_OR_GREATER + => PowerDensity.FromPicowattsPerCubicMeter(double.CreateChecked(value)); +#else + => PowerDensity.FromPicowattsPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public PowerDensity PicowattsPerLiter +#if NET7_0_OR_GREATER + => PowerDensity.FromPicowattsPerLiter(double.CreateChecked(value)); +#else + => PowerDensity.FromPicowattsPerLiter(value.ToDouble(null)); +#endif + + /// + public PowerDensity TerawattsPerCubicFoot +#if NET7_0_OR_GREATER + => PowerDensity.FromTerawattsPerCubicFoot(double.CreateChecked(value)); +#else + => PowerDensity.FromTerawattsPerCubicFoot(value.ToDouble(null)); +#endif + + /// + public PowerDensity TerawattsPerCubicInch +#if NET7_0_OR_GREATER + => PowerDensity.FromTerawattsPerCubicInch(double.CreateChecked(value)); +#else + => PowerDensity.FromTerawattsPerCubicInch(value.ToDouble(null)); +#endif + + /// + public PowerDensity TerawattsPerCubicMeter +#if NET7_0_OR_GREATER + => PowerDensity.FromTerawattsPerCubicMeter(double.CreateChecked(value)); +#else + => PowerDensity.FromTerawattsPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public PowerDensity TerawattsPerLiter +#if NET7_0_OR_GREATER + => PowerDensity.FromTerawattsPerLiter(double.CreateChecked(value)); +#else + => PowerDensity.FromTerawattsPerLiter(value.ToDouble(null)); +#endif + + /// + public PowerDensity WattsPerCubicFoot +#if NET7_0_OR_GREATER + => PowerDensity.FromWattsPerCubicFoot(double.CreateChecked(value)); +#else + => PowerDensity.FromWattsPerCubicFoot(value.ToDouble(null)); +#endif + + /// + public PowerDensity WattsPerCubicInch +#if NET7_0_OR_GREATER + => PowerDensity.FromWattsPerCubicInch(double.CreateChecked(value)); +#else + => PowerDensity.FromWattsPerCubicInch(value.ToDouble(null)); +#endif + + /// + public PowerDensity WattsPerCubicMeter +#if NET7_0_OR_GREATER + => PowerDensity.FromWattsPerCubicMeter(double.CreateChecked(value)); +#else + => PowerDensity.FromWattsPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public PowerDensity WattsPerLiter +#if NET7_0_OR_GREATER + => PowerDensity.FromWattsPerLiter(double.CreateChecked(value)); +#else + => PowerDensity.FromWattsPerLiter(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPowerExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPowerExtensions.g.cs new file mode 100644 index 0000000000..6b0b8226b7 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPowerExtensions.g.cs @@ -0,0 +1,263 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToPower +{ + /// + /// A number to Power Extensions + /// + public static class NumberToPowerExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Power BoilerHorsepower +#if NET7_0_OR_GREATER + => Power.FromBoilerHorsepower(double.CreateChecked(value)); +#else + => Power.FromBoilerHorsepower(value.ToDouble(null)); +#endif + + /// + public Power BritishThermalUnitsPerHour +#if NET7_0_OR_GREATER + => Power.FromBritishThermalUnitsPerHour(double.CreateChecked(value)); +#else + => Power.FromBritishThermalUnitsPerHour(value.ToDouble(null)); +#endif + + /// + public Power Decawatts +#if NET7_0_OR_GREATER + => Power.FromDecawatts(double.CreateChecked(value)); +#else + => Power.FromDecawatts(value.ToDouble(null)); +#endif + + /// + public Power Deciwatts +#if NET7_0_OR_GREATER + => Power.FromDeciwatts(double.CreateChecked(value)); +#else + => Power.FromDeciwatts(value.ToDouble(null)); +#endif + + /// + public Power ElectricalHorsepower +#if NET7_0_OR_GREATER + => Power.FromElectricalHorsepower(double.CreateChecked(value)); +#else + => Power.FromElectricalHorsepower(value.ToDouble(null)); +#endif + + /// + public Power Femtowatts +#if NET7_0_OR_GREATER + => Power.FromFemtowatts(double.CreateChecked(value)); +#else + => Power.FromFemtowatts(value.ToDouble(null)); +#endif + + /// + public Power GigajoulesPerHour +#if NET7_0_OR_GREATER + => Power.FromGigajoulesPerHour(double.CreateChecked(value)); +#else + => Power.FromGigajoulesPerHour(value.ToDouble(null)); +#endif + + /// + public Power Gigawatts +#if NET7_0_OR_GREATER + => Power.FromGigawatts(double.CreateChecked(value)); +#else + => Power.FromGigawatts(value.ToDouble(null)); +#endif + + /// + public Power HydraulicHorsepower +#if NET7_0_OR_GREATER + => Power.FromHydraulicHorsepower(double.CreateChecked(value)); +#else + => Power.FromHydraulicHorsepower(value.ToDouble(null)); +#endif + + /// + public Power JoulesPerHour +#if NET7_0_OR_GREATER + => Power.FromJoulesPerHour(double.CreateChecked(value)); +#else + => Power.FromJoulesPerHour(value.ToDouble(null)); +#endif + + /// + public Power KilobritishThermalUnitsPerHour +#if NET7_0_OR_GREATER + => Power.FromKilobritishThermalUnitsPerHour(double.CreateChecked(value)); +#else + => Power.FromKilobritishThermalUnitsPerHour(value.ToDouble(null)); +#endif + + /// + public Power KilojoulesPerHour +#if NET7_0_OR_GREATER + => Power.FromKilojoulesPerHour(double.CreateChecked(value)); +#else + => Power.FromKilojoulesPerHour(value.ToDouble(null)); +#endif + + /// + public Power Kilowatts +#if NET7_0_OR_GREATER + => Power.FromKilowatts(double.CreateChecked(value)); +#else + => Power.FromKilowatts(value.ToDouble(null)); +#endif + + /// + public Power MechanicalHorsepower +#if NET7_0_OR_GREATER + => Power.FromMechanicalHorsepower(double.CreateChecked(value)); +#else + => Power.FromMechanicalHorsepower(value.ToDouble(null)); +#endif + + /// + public Power MegabritishThermalUnitsPerHour +#if NET7_0_OR_GREATER + => Power.FromMegabritishThermalUnitsPerHour(double.CreateChecked(value)); +#else + => Power.FromMegabritishThermalUnitsPerHour(value.ToDouble(null)); +#endif + + /// + public Power MegajoulesPerHour +#if NET7_0_OR_GREATER + => Power.FromMegajoulesPerHour(double.CreateChecked(value)); +#else + => Power.FromMegajoulesPerHour(value.ToDouble(null)); +#endif + + /// + public Power Megawatts +#if NET7_0_OR_GREATER + => Power.FromMegawatts(double.CreateChecked(value)); +#else + => Power.FromMegawatts(value.ToDouble(null)); +#endif + + /// + public Power MetricHorsepower +#if NET7_0_OR_GREATER + => Power.FromMetricHorsepower(double.CreateChecked(value)); +#else + => Power.FromMetricHorsepower(value.ToDouble(null)); +#endif + + /// + public Power Microwatts +#if NET7_0_OR_GREATER + => Power.FromMicrowatts(double.CreateChecked(value)); +#else + => Power.FromMicrowatts(value.ToDouble(null)); +#endif + + /// + public Power MillijoulesPerHour +#if NET7_0_OR_GREATER + => Power.FromMillijoulesPerHour(double.CreateChecked(value)); +#else + => Power.FromMillijoulesPerHour(value.ToDouble(null)); +#endif + + /// + public Power Milliwatts +#if NET7_0_OR_GREATER + => Power.FromMilliwatts(double.CreateChecked(value)); +#else + => Power.FromMilliwatts(value.ToDouble(null)); +#endif + + /// + public Power Nanowatts +#if NET7_0_OR_GREATER + => Power.FromNanowatts(double.CreateChecked(value)); +#else + => Power.FromNanowatts(value.ToDouble(null)); +#endif + + /// + public Power Petawatts +#if NET7_0_OR_GREATER + => Power.FromPetawatts(double.CreateChecked(value)); +#else + => Power.FromPetawatts(value.ToDouble(null)); +#endif + + /// + public Power Picowatts +#if NET7_0_OR_GREATER + => Power.FromPicowatts(double.CreateChecked(value)); +#else + => Power.FromPicowatts(value.ToDouble(null)); +#endif + + /// + public Power Terawatts +#if NET7_0_OR_GREATER + => Power.FromTerawatts(double.CreateChecked(value)); +#else + => Power.FromTerawatts(value.ToDouble(null)); +#endif + + /// + public Power TonsOfRefrigeration +#if NET7_0_OR_GREATER + => Power.FromTonsOfRefrigeration(double.CreateChecked(value)); +#else + => Power.FromTonsOfRefrigeration(value.ToDouble(null)); +#endif + + /// + public Power Watts +#if NET7_0_OR_GREATER + => Power.FromWatts(double.CreateChecked(value)); +#else + => Power.FromWatts(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPowerRatioExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPowerRatioExtensions.g.cs new file mode 100644 index 0000000000..9f64c8e0ff --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPowerRatioExtensions.g.cs @@ -0,0 +1,63 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToPowerRatio +{ + /// + /// A number to PowerRatio Extensions + /// + public static class NumberToPowerRatioExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public PowerRatio DecibelMilliwatts +#if NET7_0_OR_GREATER + => PowerRatio.FromDecibelMilliwatts(double.CreateChecked(value)); +#else + => PowerRatio.FromDecibelMilliwatts(value.ToDouble(null)); +#endif + + /// + public PowerRatio DecibelWatts +#if NET7_0_OR_GREATER + => PowerRatio.FromDecibelWatts(double.CreateChecked(value)); +#else + => PowerRatio.FromDecibelWatts(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs new file mode 100644 index 0000000000..bd8155d7d4 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs @@ -0,0 +1,191 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToPressureChangeRate +{ + /// + /// A number to PressureChangeRate Extensions + /// + public static class NumberToPressureChangeRateExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public PressureChangeRate AtmospheresPerSecond +#if NET7_0_OR_GREATER + => PressureChangeRate.FromAtmospheresPerSecond(double.CreateChecked(value)); +#else + => PressureChangeRate.FromAtmospheresPerSecond(value.ToDouble(null)); +#endif + + /// + public PressureChangeRate BarsPerMinute +#if NET7_0_OR_GREATER + => PressureChangeRate.FromBarsPerMinute(double.CreateChecked(value)); +#else + => PressureChangeRate.FromBarsPerMinute(value.ToDouble(null)); +#endif + + /// + public PressureChangeRate BarsPerSecond +#if NET7_0_OR_GREATER + => PressureChangeRate.FromBarsPerSecond(double.CreateChecked(value)); +#else + => PressureChangeRate.FromBarsPerSecond(value.ToDouble(null)); +#endif + + /// + public PressureChangeRate KilopascalsPerMinute +#if NET7_0_OR_GREATER + => PressureChangeRate.FromKilopascalsPerMinute(double.CreateChecked(value)); +#else + => PressureChangeRate.FromKilopascalsPerMinute(value.ToDouble(null)); +#endif + + /// + public PressureChangeRate KilopascalsPerSecond +#if NET7_0_OR_GREATER + => PressureChangeRate.FromKilopascalsPerSecond(double.CreateChecked(value)); +#else + => PressureChangeRate.FromKilopascalsPerSecond(value.ToDouble(null)); +#endif + + /// + public PressureChangeRate KilopoundsForcePerSquareInchPerMinute +#if NET7_0_OR_GREATER + => PressureChangeRate.FromKilopoundsForcePerSquareInchPerMinute(double.CreateChecked(value)); +#else + => PressureChangeRate.FromKilopoundsForcePerSquareInchPerMinute(value.ToDouble(null)); +#endif + + /// + public PressureChangeRate KilopoundsForcePerSquareInchPerSecond +#if NET7_0_OR_GREATER + => PressureChangeRate.FromKilopoundsForcePerSquareInchPerSecond(double.CreateChecked(value)); +#else + => PressureChangeRate.FromKilopoundsForcePerSquareInchPerSecond(value.ToDouble(null)); +#endif + + /// + public PressureChangeRate MegapascalsPerMinute +#if NET7_0_OR_GREATER + => PressureChangeRate.FromMegapascalsPerMinute(double.CreateChecked(value)); +#else + => PressureChangeRate.FromMegapascalsPerMinute(value.ToDouble(null)); +#endif + + /// + public PressureChangeRate MegapascalsPerSecond +#if NET7_0_OR_GREATER + => PressureChangeRate.FromMegapascalsPerSecond(double.CreateChecked(value)); +#else + => PressureChangeRate.FromMegapascalsPerSecond(value.ToDouble(null)); +#endif + + /// + public PressureChangeRate MegapoundsForcePerSquareInchPerMinute +#if NET7_0_OR_GREATER + => PressureChangeRate.FromMegapoundsForcePerSquareInchPerMinute(double.CreateChecked(value)); +#else + => PressureChangeRate.FromMegapoundsForcePerSquareInchPerMinute(value.ToDouble(null)); +#endif + + /// + public PressureChangeRate MegapoundsForcePerSquareInchPerSecond +#if NET7_0_OR_GREATER + => PressureChangeRate.FromMegapoundsForcePerSquareInchPerSecond(double.CreateChecked(value)); +#else + => PressureChangeRate.FromMegapoundsForcePerSquareInchPerSecond(value.ToDouble(null)); +#endif + + /// + public PressureChangeRate MillibarsPerMinute +#if NET7_0_OR_GREATER + => PressureChangeRate.FromMillibarsPerMinute(double.CreateChecked(value)); +#else + => PressureChangeRate.FromMillibarsPerMinute(value.ToDouble(null)); +#endif + + /// + public PressureChangeRate MillibarsPerSecond +#if NET7_0_OR_GREATER + => PressureChangeRate.FromMillibarsPerSecond(double.CreateChecked(value)); +#else + => PressureChangeRate.FromMillibarsPerSecond(value.ToDouble(null)); +#endif + + /// + public PressureChangeRate MillimetersOfMercuryPerSecond +#if NET7_0_OR_GREATER + => PressureChangeRate.FromMillimetersOfMercuryPerSecond(double.CreateChecked(value)); +#else + => PressureChangeRate.FromMillimetersOfMercuryPerSecond(value.ToDouble(null)); +#endif + + /// + public PressureChangeRate PascalsPerMinute +#if NET7_0_OR_GREATER + => PressureChangeRate.FromPascalsPerMinute(double.CreateChecked(value)); +#else + => PressureChangeRate.FromPascalsPerMinute(value.ToDouble(null)); +#endif + + /// + public PressureChangeRate PascalsPerSecond +#if NET7_0_OR_GREATER + => PressureChangeRate.FromPascalsPerSecond(double.CreateChecked(value)); +#else + => PressureChangeRate.FromPascalsPerSecond(value.ToDouble(null)); +#endif + + /// + public PressureChangeRate PoundsForcePerSquareInchPerMinute +#if NET7_0_OR_GREATER + => PressureChangeRate.FromPoundsForcePerSquareInchPerMinute(double.CreateChecked(value)); +#else + => PressureChangeRate.FromPoundsForcePerSquareInchPerMinute(value.ToDouble(null)); +#endif + + /// + public PressureChangeRate PoundsForcePerSquareInchPerSecond +#if NET7_0_OR_GREATER + => PressureChangeRate.FromPoundsForcePerSquareInchPerSecond(double.CreateChecked(value)); +#else + => PressureChangeRate.FromPoundsForcePerSquareInchPerSecond(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPressureExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPressureExtensions.g.cs new file mode 100644 index 0000000000..538f5530f5 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToPressureExtensions.g.cs @@ -0,0 +1,431 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToPressure +{ + /// + /// A number to Pressure Extensions + /// + public static class NumberToPressureExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Pressure Atmospheres +#if NET7_0_OR_GREATER + => Pressure.FromAtmospheres(double.CreateChecked(value)); +#else + => Pressure.FromAtmospheres(value.ToDouble(null)); +#endif + + /// + public Pressure Bars +#if NET7_0_OR_GREATER + => Pressure.FromBars(double.CreateChecked(value)); +#else + => Pressure.FromBars(value.ToDouble(null)); +#endif + + /// + public Pressure Centibars +#if NET7_0_OR_GREATER + => Pressure.FromCentibars(double.CreateChecked(value)); +#else + => Pressure.FromCentibars(value.ToDouble(null)); +#endif + + /// + public Pressure CentimetersOfWaterColumn +#if NET7_0_OR_GREATER + => Pressure.FromCentimetersOfWaterColumn(double.CreateChecked(value)); +#else + => Pressure.FromCentimetersOfWaterColumn(value.ToDouble(null)); +#endif + + /// + public Pressure Decapascals +#if NET7_0_OR_GREATER + => Pressure.FromDecapascals(double.CreateChecked(value)); +#else + => Pressure.FromDecapascals(value.ToDouble(null)); +#endif + + /// + public Pressure Decibars +#if NET7_0_OR_GREATER + => Pressure.FromDecibars(double.CreateChecked(value)); +#else + => Pressure.FromDecibars(value.ToDouble(null)); +#endif + + /// + public Pressure DynesPerSquareCentimeter +#if NET7_0_OR_GREATER + => Pressure.FromDynesPerSquareCentimeter(double.CreateChecked(value)); +#else + => Pressure.FromDynesPerSquareCentimeter(value.ToDouble(null)); +#endif + + /// + public Pressure FeetOfHead +#if NET7_0_OR_GREATER + => Pressure.FromFeetOfHead(double.CreateChecked(value)); +#else + => Pressure.FromFeetOfHead(value.ToDouble(null)); +#endif + + /// + public Pressure Gigapascals +#if NET7_0_OR_GREATER + => Pressure.FromGigapascals(double.CreateChecked(value)); +#else + => Pressure.FromGigapascals(value.ToDouble(null)); +#endif + + /// + public Pressure Hectopascals +#if NET7_0_OR_GREATER + => Pressure.FromHectopascals(double.CreateChecked(value)); +#else + => Pressure.FromHectopascals(value.ToDouble(null)); +#endif + + /// + public Pressure InchesOfMercury +#if NET7_0_OR_GREATER + => Pressure.FromInchesOfMercury(double.CreateChecked(value)); +#else + => Pressure.FromInchesOfMercury(value.ToDouble(null)); +#endif + + /// + public Pressure InchesOfWaterColumn +#if NET7_0_OR_GREATER + => Pressure.FromInchesOfWaterColumn(double.CreateChecked(value)); +#else + => Pressure.FromInchesOfWaterColumn(value.ToDouble(null)); +#endif + + /// + public Pressure Kilobars +#if NET7_0_OR_GREATER + => Pressure.FromKilobars(double.CreateChecked(value)); +#else + => Pressure.FromKilobars(value.ToDouble(null)); +#endif + + /// + public Pressure KilogramsForcePerSquareCentimeter +#if NET7_0_OR_GREATER + => Pressure.FromKilogramsForcePerSquareCentimeter(double.CreateChecked(value)); +#else + => Pressure.FromKilogramsForcePerSquareCentimeter(value.ToDouble(null)); +#endif + + /// + public Pressure KilogramsForcePerSquareMeter +#if NET7_0_OR_GREATER + => Pressure.FromKilogramsForcePerSquareMeter(double.CreateChecked(value)); +#else + => Pressure.FromKilogramsForcePerSquareMeter(value.ToDouble(null)); +#endif + + /// + public Pressure KilogramsForcePerSquareMillimeter +#if NET7_0_OR_GREATER + => Pressure.FromKilogramsForcePerSquareMillimeter(double.CreateChecked(value)); +#else + => Pressure.FromKilogramsForcePerSquareMillimeter(value.ToDouble(null)); +#endif + + /// + public Pressure KilonewtonsPerSquareCentimeter +#if NET7_0_OR_GREATER + => Pressure.FromKilonewtonsPerSquareCentimeter(double.CreateChecked(value)); +#else + => Pressure.FromKilonewtonsPerSquareCentimeter(value.ToDouble(null)); +#endif + + /// + public Pressure KilonewtonsPerSquareMeter +#if NET7_0_OR_GREATER + => Pressure.FromKilonewtonsPerSquareMeter(double.CreateChecked(value)); +#else + => Pressure.FromKilonewtonsPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public Pressure KilonewtonsPerSquareMillimeter +#if NET7_0_OR_GREATER + => Pressure.FromKilonewtonsPerSquareMillimeter(double.CreateChecked(value)); +#else + => Pressure.FromKilonewtonsPerSquareMillimeter(value.ToDouble(null)); +#endif + + /// + public Pressure Kilopascals +#if NET7_0_OR_GREATER + => Pressure.FromKilopascals(double.CreateChecked(value)); +#else + => Pressure.FromKilopascals(value.ToDouble(null)); +#endif + + /// + public Pressure KilopoundsForcePerSquareFoot +#if NET7_0_OR_GREATER + => Pressure.FromKilopoundsForcePerSquareFoot(double.CreateChecked(value)); +#else + => Pressure.FromKilopoundsForcePerSquareFoot(value.ToDouble(null)); +#endif + + /// + public Pressure KilopoundsForcePerSquareInch +#if NET7_0_OR_GREATER + => Pressure.FromKilopoundsForcePerSquareInch(double.CreateChecked(value)); +#else + => Pressure.FromKilopoundsForcePerSquareInch(value.ToDouble(null)); +#endif + + /// + public Pressure KilopoundsForcePerSquareMil +#if NET7_0_OR_GREATER + => Pressure.FromKilopoundsForcePerSquareMil(double.CreateChecked(value)); +#else + => Pressure.FromKilopoundsForcePerSquareMil(value.ToDouble(null)); +#endif + + /// + public Pressure Megabars +#if NET7_0_OR_GREATER + => Pressure.FromMegabars(double.CreateChecked(value)); +#else + => Pressure.FromMegabars(value.ToDouble(null)); +#endif + + /// + public Pressure MeganewtonsPerSquareMeter +#if NET7_0_OR_GREATER + => Pressure.FromMeganewtonsPerSquareMeter(double.CreateChecked(value)); +#else + => Pressure.FromMeganewtonsPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public Pressure Megapascals +#if NET7_0_OR_GREATER + => Pressure.FromMegapascals(double.CreateChecked(value)); +#else + => Pressure.FromMegapascals(value.ToDouble(null)); +#endif + + /// + public Pressure MetersOfHead +#if NET7_0_OR_GREATER + => Pressure.FromMetersOfHead(double.CreateChecked(value)); +#else + => Pressure.FromMetersOfHead(value.ToDouble(null)); +#endif + + /// + public Pressure MetersOfWaterColumn +#if NET7_0_OR_GREATER + => Pressure.FromMetersOfWaterColumn(double.CreateChecked(value)); +#else + => Pressure.FromMetersOfWaterColumn(value.ToDouble(null)); +#endif + + /// + public Pressure Microbars +#if NET7_0_OR_GREATER + => Pressure.FromMicrobars(double.CreateChecked(value)); +#else + => Pressure.FromMicrobars(value.ToDouble(null)); +#endif + + /// + public Pressure Micropascals +#if NET7_0_OR_GREATER + => Pressure.FromMicropascals(double.CreateChecked(value)); +#else + => Pressure.FromMicropascals(value.ToDouble(null)); +#endif + + /// + public Pressure Millibars +#if NET7_0_OR_GREATER + => Pressure.FromMillibars(double.CreateChecked(value)); +#else + => Pressure.FromMillibars(value.ToDouble(null)); +#endif + + /// + public Pressure MillimetersOfMercury +#if NET7_0_OR_GREATER + => Pressure.FromMillimetersOfMercury(double.CreateChecked(value)); +#else + => Pressure.FromMillimetersOfMercury(value.ToDouble(null)); +#endif + + /// + public Pressure MillimetersOfWaterColumn +#if NET7_0_OR_GREATER + => Pressure.FromMillimetersOfWaterColumn(double.CreateChecked(value)); +#else + => Pressure.FromMillimetersOfWaterColumn(value.ToDouble(null)); +#endif + + /// + public Pressure Millipascals +#if NET7_0_OR_GREATER + => Pressure.FromMillipascals(double.CreateChecked(value)); +#else + => Pressure.FromMillipascals(value.ToDouble(null)); +#endif + + /// + public Pressure Millitorrs +#if NET7_0_OR_GREATER + => Pressure.FromMillitorrs(double.CreateChecked(value)); +#else + => Pressure.FromMillitorrs(value.ToDouble(null)); +#endif + + /// + public Pressure NewtonsPerSquareCentimeter +#if NET7_0_OR_GREATER + => Pressure.FromNewtonsPerSquareCentimeter(double.CreateChecked(value)); +#else + => Pressure.FromNewtonsPerSquareCentimeter(value.ToDouble(null)); +#endif + + /// + public Pressure NewtonsPerSquareMeter +#if NET7_0_OR_GREATER + => Pressure.FromNewtonsPerSquareMeter(double.CreateChecked(value)); +#else + => Pressure.FromNewtonsPerSquareMeter(value.ToDouble(null)); +#endif + + /// + public Pressure NewtonsPerSquareMillimeter +#if NET7_0_OR_GREATER + => Pressure.FromNewtonsPerSquareMillimeter(double.CreateChecked(value)); +#else + => Pressure.FromNewtonsPerSquareMillimeter(value.ToDouble(null)); +#endif + + /// + public Pressure Pascals +#if NET7_0_OR_GREATER + => Pressure.FromPascals(double.CreateChecked(value)); +#else + => Pressure.FromPascals(value.ToDouble(null)); +#endif + + /// + public Pressure PoundsForcePerSquareFoot +#if NET7_0_OR_GREATER + => Pressure.FromPoundsForcePerSquareFoot(double.CreateChecked(value)); +#else + => Pressure.FromPoundsForcePerSquareFoot(value.ToDouble(null)); +#endif + + /// + public Pressure PoundsForcePerSquareInch +#if NET7_0_OR_GREATER + => Pressure.FromPoundsForcePerSquareInch(double.CreateChecked(value)); +#else + => Pressure.FromPoundsForcePerSquareInch(value.ToDouble(null)); +#endif + + /// + public Pressure PoundsForcePerSquareMil +#if NET7_0_OR_GREATER + => Pressure.FromPoundsForcePerSquareMil(double.CreateChecked(value)); +#else + => Pressure.FromPoundsForcePerSquareMil(value.ToDouble(null)); +#endif + + /// + public Pressure PoundsPerInchSecondSquared +#if NET7_0_OR_GREATER + => Pressure.FromPoundsPerInchSecondSquared(double.CreateChecked(value)); +#else + => Pressure.FromPoundsPerInchSecondSquared(value.ToDouble(null)); +#endif + + /// + public Pressure TechnicalAtmospheres +#if NET7_0_OR_GREATER + => Pressure.FromTechnicalAtmospheres(double.CreateChecked(value)); +#else + => Pressure.FromTechnicalAtmospheres(value.ToDouble(null)); +#endif + + /// + public Pressure TonnesForcePerSquareCentimeter +#if NET7_0_OR_GREATER + => Pressure.FromTonnesForcePerSquareCentimeter(double.CreateChecked(value)); +#else + => Pressure.FromTonnesForcePerSquareCentimeter(value.ToDouble(null)); +#endif + + /// + public Pressure TonnesForcePerSquareMeter +#if NET7_0_OR_GREATER + => Pressure.FromTonnesForcePerSquareMeter(double.CreateChecked(value)); +#else + => Pressure.FromTonnesForcePerSquareMeter(value.ToDouble(null)); +#endif + + /// + public Pressure TonnesForcePerSquareMillimeter +#if NET7_0_OR_GREATER + => Pressure.FromTonnesForcePerSquareMillimeter(double.CreateChecked(value)); +#else + => Pressure.FromTonnesForcePerSquareMillimeter(value.ToDouble(null)); +#endif + + /// + public Pressure Torrs +#if NET7_0_OR_GREATER + => Pressure.FromTorrs(double.CreateChecked(value)); +#else + => Pressure.FromTorrs(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRadiationEquivalentDoseExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRadiationEquivalentDoseExtensions.g.cs new file mode 100644 index 0000000000..dd6408e8ed --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRadiationEquivalentDoseExtensions.g.cs @@ -0,0 +1,95 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToRadiationEquivalentDose +{ + /// + /// A number to RadiationEquivalentDose Extensions + /// + public static class NumberToRadiationEquivalentDoseExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public RadiationEquivalentDose Microsieverts +#if NET7_0_OR_GREATER + => RadiationEquivalentDose.FromMicrosieverts(double.CreateChecked(value)); +#else + => RadiationEquivalentDose.FromMicrosieverts(value.ToDouble(null)); +#endif + + /// + public RadiationEquivalentDose MilliroentgensEquivalentMan +#if NET7_0_OR_GREATER + => RadiationEquivalentDose.FromMilliroentgensEquivalentMan(double.CreateChecked(value)); +#else + => RadiationEquivalentDose.FromMilliroentgensEquivalentMan(value.ToDouble(null)); +#endif + + /// + public RadiationEquivalentDose Millisieverts +#if NET7_0_OR_GREATER + => RadiationEquivalentDose.FromMillisieverts(double.CreateChecked(value)); +#else + => RadiationEquivalentDose.FromMillisieverts(value.ToDouble(null)); +#endif + + /// + public RadiationEquivalentDose Nanosieverts +#if NET7_0_OR_GREATER + => RadiationEquivalentDose.FromNanosieverts(double.CreateChecked(value)); +#else + => RadiationEquivalentDose.FromNanosieverts(value.ToDouble(null)); +#endif + + /// + public RadiationEquivalentDose RoentgensEquivalentMan +#if NET7_0_OR_GREATER + => RadiationEquivalentDose.FromRoentgensEquivalentMan(double.CreateChecked(value)); +#else + => RadiationEquivalentDose.FromRoentgensEquivalentMan(value.ToDouble(null)); +#endif + + /// + public RadiationEquivalentDose Sieverts +#if NET7_0_OR_GREATER + => RadiationEquivalentDose.FromSieverts(double.CreateChecked(value)); +#else + => RadiationEquivalentDose.FromSieverts(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRadiationEquivalentDoseRateExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRadiationEquivalentDoseRateExtensions.g.cs new file mode 100644 index 0000000000..e37019c0aa --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRadiationEquivalentDoseRateExtensions.g.cs @@ -0,0 +1,127 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToRadiationEquivalentDoseRate +{ + /// + /// A number to RadiationEquivalentDoseRate Extensions + /// + public static class NumberToRadiationEquivalentDoseRateExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public RadiationEquivalentDoseRate MicrosievertsPerHour +#if NET7_0_OR_GREATER + => RadiationEquivalentDoseRate.FromMicrosievertsPerHour(double.CreateChecked(value)); +#else + => RadiationEquivalentDoseRate.FromMicrosievertsPerHour(value.ToDouble(null)); +#endif + + /// + public RadiationEquivalentDoseRate MicrosievertsPerSecond +#if NET7_0_OR_GREATER + => RadiationEquivalentDoseRate.FromMicrosievertsPerSecond(double.CreateChecked(value)); +#else + => RadiationEquivalentDoseRate.FromMicrosievertsPerSecond(value.ToDouble(null)); +#endif + + /// + public RadiationEquivalentDoseRate MilliroentgensEquivalentManPerHour +#if NET7_0_OR_GREATER + => RadiationEquivalentDoseRate.FromMilliroentgensEquivalentManPerHour(double.CreateChecked(value)); +#else + => RadiationEquivalentDoseRate.FromMilliroentgensEquivalentManPerHour(value.ToDouble(null)); +#endif + + /// + public RadiationEquivalentDoseRate MillisievertsPerHour +#if NET7_0_OR_GREATER + => RadiationEquivalentDoseRate.FromMillisievertsPerHour(double.CreateChecked(value)); +#else + => RadiationEquivalentDoseRate.FromMillisievertsPerHour(value.ToDouble(null)); +#endif + + /// + public RadiationEquivalentDoseRate MillisievertsPerSecond +#if NET7_0_OR_GREATER + => RadiationEquivalentDoseRate.FromMillisievertsPerSecond(double.CreateChecked(value)); +#else + => RadiationEquivalentDoseRate.FromMillisievertsPerSecond(value.ToDouble(null)); +#endif + + /// + public RadiationEquivalentDoseRate NanosievertsPerHour +#if NET7_0_OR_GREATER + => RadiationEquivalentDoseRate.FromNanosievertsPerHour(double.CreateChecked(value)); +#else + => RadiationEquivalentDoseRate.FromNanosievertsPerHour(value.ToDouble(null)); +#endif + + /// + public RadiationEquivalentDoseRate NanosievertsPerSecond +#if NET7_0_OR_GREATER + => RadiationEquivalentDoseRate.FromNanosievertsPerSecond(double.CreateChecked(value)); +#else + => RadiationEquivalentDoseRate.FromNanosievertsPerSecond(value.ToDouble(null)); +#endif + + /// + public RadiationEquivalentDoseRate RoentgensEquivalentManPerHour +#if NET7_0_OR_GREATER + => RadiationEquivalentDoseRate.FromRoentgensEquivalentManPerHour(double.CreateChecked(value)); +#else + => RadiationEquivalentDoseRate.FromRoentgensEquivalentManPerHour(value.ToDouble(null)); +#endif + + /// + public RadiationEquivalentDoseRate SievertsPerHour +#if NET7_0_OR_GREATER + => RadiationEquivalentDoseRate.FromSievertsPerHour(double.CreateChecked(value)); +#else + => RadiationEquivalentDoseRate.FromSievertsPerHour(value.ToDouble(null)); +#endif + + /// + public RadiationEquivalentDoseRate SievertsPerSecond +#if NET7_0_OR_GREATER + => RadiationEquivalentDoseRate.FromSievertsPerSecond(double.CreateChecked(value)); +#else + => RadiationEquivalentDoseRate.FromSievertsPerSecond(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRadiationExposureExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRadiationExposureExtensions.g.cs new file mode 100644 index 0000000000..e6a6a5b0a6 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRadiationExposureExtensions.g.cs @@ -0,0 +1,111 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToRadiationExposure +{ + /// + /// A number to RadiationExposure Extensions + /// + public static class NumberToRadiationExposureExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public RadiationExposure CoulombsPerKilogram +#if NET7_0_OR_GREATER + => RadiationExposure.FromCoulombsPerKilogram(double.CreateChecked(value)); +#else + => RadiationExposure.FromCoulombsPerKilogram(value.ToDouble(null)); +#endif + + /// + public RadiationExposure MicrocoulombsPerKilogram +#if NET7_0_OR_GREATER + => RadiationExposure.FromMicrocoulombsPerKilogram(double.CreateChecked(value)); +#else + => RadiationExposure.FromMicrocoulombsPerKilogram(value.ToDouble(null)); +#endif + + /// + public RadiationExposure Microroentgens +#if NET7_0_OR_GREATER + => RadiationExposure.FromMicroroentgens(double.CreateChecked(value)); +#else + => RadiationExposure.FromMicroroentgens(value.ToDouble(null)); +#endif + + /// + public RadiationExposure MillicoulombsPerKilogram +#if NET7_0_OR_GREATER + => RadiationExposure.FromMillicoulombsPerKilogram(double.CreateChecked(value)); +#else + => RadiationExposure.FromMillicoulombsPerKilogram(value.ToDouble(null)); +#endif + + /// + public RadiationExposure Milliroentgens +#if NET7_0_OR_GREATER + => RadiationExposure.FromMilliroentgens(double.CreateChecked(value)); +#else + => RadiationExposure.FromMilliroentgens(value.ToDouble(null)); +#endif + + /// + public RadiationExposure NanocoulombsPerKilogram +#if NET7_0_OR_GREATER + => RadiationExposure.FromNanocoulombsPerKilogram(double.CreateChecked(value)); +#else + => RadiationExposure.FromNanocoulombsPerKilogram(value.ToDouble(null)); +#endif + + /// + public RadiationExposure PicocoulombsPerKilogram +#if NET7_0_OR_GREATER + => RadiationExposure.FromPicocoulombsPerKilogram(double.CreateChecked(value)); +#else + => RadiationExposure.FromPicocoulombsPerKilogram(value.ToDouble(null)); +#endif + + /// + public RadiationExposure Roentgens +#if NET7_0_OR_GREATER + => RadiationExposure.FromRoentgens(double.CreateChecked(value)); +#else + => RadiationExposure.FromRoentgens(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRadioactivityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRadioactivityExtensions.g.cs new file mode 100644 index 0000000000..f6e447bf48 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRadioactivityExtensions.g.cs @@ -0,0 +1,279 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToRadioactivity +{ + /// + /// A number to Radioactivity Extensions + /// + public static class NumberToRadioactivityExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Radioactivity Becquerels +#if NET7_0_OR_GREATER + => Radioactivity.FromBecquerels(double.CreateChecked(value)); +#else + => Radioactivity.FromBecquerels(value.ToDouble(null)); +#endif + + /// + public Radioactivity Curies +#if NET7_0_OR_GREATER + => Radioactivity.FromCuries(double.CreateChecked(value)); +#else + => Radioactivity.FromCuries(value.ToDouble(null)); +#endif + + /// + public Radioactivity Exabecquerels +#if NET7_0_OR_GREATER + => Radioactivity.FromExabecquerels(double.CreateChecked(value)); +#else + => Radioactivity.FromExabecquerels(value.ToDouble(null)); +#endif + + /// + public Radioactivity Gigabecquerels +#if NET7_0_OR_GREATER + => Radioactivity.FromGigabecquerels(double.CreateChecked(value)); +#else + => Radioactivity.FromGigabecquerels(value.ToDouble(null)); +#endif + + /// + public Radioactivity Gigacuries +#if NET7_0_OR_GREATER + => Radioactivity.FromGigacuries(double.CreateChecked(value)); +#else + => Radioactivity.FromGigacuries(value.ToDouble(null)); +#endif + + /// + public Radioactivity Gigarutherfords +#if NET7_0_OR_GREATER + => Radioactivity.FromGigarutherfords(double.CreateChecked(value)); +#else + => Radioactivity.FromGigarutherfords(value.ToDouble(null)); +#endif + + /// + public Radioactivity Kilobecquerels +#if NET7_0_OR_GREATER + => Radioactivity.FromKilobecquerels(double.CreateChecked(value)); +#else + => Radioactivity.FromKilobecquerels(value.ToDouble(null)); +#endif + + /// + public Radioactivity Kilocuries +#if NET7_0_OR_GREATER + => Radioactivity.FromKilocuries(double.CreateChecked(value)); +#else + => Radioactivity.FromKilocuries(value.ToDouble(null)); +#endif + + /// + public Radioactivity Kilorutherfords +#if NET7_0_OR_GREATER + => Radioactivity.FromKilorutherfords(double.CreateChecked(value)); +#else + => Radioactivity.FromKilorutherfords(value.ToDouble(null)); +#endif + + /// + public Radioactivity Megabecquerels +#if NET7_0_OR_GREATER + => Radioactivity.FromMegabecquerels(double.CreateChecked(value)); +#else + => Radioactivity.FromMegabecquerels(value.ToDouble(null)); +#endif + + /// + public Radioactivity Megacuries +#if NET7_0_OR_GREATER + => Radioactivity.FromMegacuries(double.CreateChecked(value)); +#else + => Radioactivity.FromMegacuries(value.ToDouble(null)); +#endif + + /// + public Radioactivity Megarutherfords +#if NET7_0_OR_GREATER + => Radioactivity.FromMegarutherfords(double.CreateChecked(value)); +#else + => Radioactivity.FromMegarutherfords(value.ToDouble(null)); +#endif + + /// + public Radioactivity Microbecquerels +#if NET7_0_OR_GREATER + => Radioactivity.FromMicrobecquerels(double.CreateChecked(value)); +#else + => Radioactivity.FromMicrobecquerels(value.ToDouble(null)); +#endif + + /// + public Radioactivity Microcuries +#if NET7_0_OR_GREATER + => Radioactivity.FromMicrocuries(double.CreateChecked(value)); +#else + => Radioactivity.FromMicrocuries(value.ToDouble(null)); +#endif + + /// + public Radioactivity Microrutherfords +#if NET7_0_OR_GREATER + => Radioactivity.FromMicrorutherfords(double.CreateChecked(value)); +#else + => Radioactivity.FromMicrorutherfords(value.ToDouble(null)); +#endif + + /// + public Radioactivity Millibecquerels +#if NET7_0_OR_GREATER + => Radioactivity.FromMillibecquerels(double.CreateChecked(value)); +#else + => Radioactivity.FromMillibecquerels(value.ToDouble(null)); +#endif + + /// + public Radioactivity Millicuries +#if NET7_0_OR_GREATER + => Radioactivity.FromMillicuries(double.CreateChecked(value)); +#else + => Radioactivity.FromMillicuries(value.ToDouble(null)); +#endif + + /// + public Radioactivity Millirutherfords +#if NET7_0_OR_GREATER + => Radioactivity.FromMillirutherfords(double.CreateChecked(value)); +#else + => Radioactivity.FromMillirutherfords(value.ToDouble(null)); +#endif + + /// + public Radioactivity Nanobecquerels +#if NET7_0_OR_GREATER + => Radioactivity.FromNanobecquerels(double.CreateChecked(value)); +#else + => Radioactivity.FromNanobecquerels(value.ToDouble(null)); +#endif + + /// + public Radioactivity Nanocuries +#if NET7_0_OR_GREATER + => Radioactivity.FromNanocuries(double.CreateChecked(value)); +#else + => Radioactivity.FromNanocuries(value.ToDouble(null)); +#endif + + /// + public Radioactivity Nanorutherfords +#if NET7_0_OR_GREATER + => Radioactivity.FromNanorutherfords(double.CreateChecked(value)); +#else + => Radioactivity.FromNanorutherfords(value.ToDouble(null)); +#endif + + /// + public Radioactivity Petabecquerels +#if NET7_0_OR_GREATER + => Radioactivity.FromPetabecquerels(double.CreateChecked(value)); +#else + => Radioactivity.FromPetabecquerels(value.ToDouble(null)); +#endif + + /// + public Radioactivity Picobecquerels +#if NET7_0_OR_GREATER + => Radioactivity.FromPicobecquerels(double.CreateChecked(value)); +#else + => Radioactivity.FromPicobecquerels(value.ToDouble(null)); +#endif + + /// + public Radioactivity Picocuries +#if NET7_0_OR_GREATER + => Radioactivity.FromPicocuries(double.CreateChecked(value)); +#else + => Radioactivity.FromPicocuries(value.ToDouble(null)); +#endif + + /// + public Radioactivity Picorutherfords +#if NET7_0_OR_GREATER + => Radioactivity.FromPicorutherfords(double.CreateChecked(value)); +#else + => Radioactivity.FromPicorutherfords(value.ToDouble(null)); +#endif + + /// + public Radioactivity Rutherfords +#if NET7_0_OR_GREATER + => Radioactivity.FromRutherfords(double.CreateChecked(value)); +#else + => Radioactivity.FromRutherfords(value.ToDouble(null)); +#endif + + /// + public Radioactivity Terabecquerels +#if NET7_0_OR_GREATER + => Radioactivity.FromTerabecquerels(double.CreateChecked(value)); +#else + => Radioactivity.FromTerabecquerels(value.ToDouble(null)); +#endif + + /// + public Radioactivity Teracuries +#if NET7_0_OR_GREATER + => Radioactivity.FromTeracuries(double.CreateChecked(value)); +#else + => Radioactivity.FromTeracuries(value.ToDouble(null)); +#endif + + /// + public Radioactivity Terarutherfords +#if NET7_0_OR_GREATER + => Radioactivity.FromTerarutherfords(double.CreateChecked(value)); +#else + => Radioactivity.FromTerarutherfords(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRatioChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRatioChangeRateExtensions.g.cs new file mode 100644 index 0000000000..87ab8bbd5e --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRatioChangeRateExtensions.g.cs @@ -0,0 +1,63 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToRatioChangeRate +{ + /// + /// A number to RatioChangeRate Extensions + /// + public static class NumberToRatioChangeRateExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public RatioChangeRate DecimalFractionsPerSecond +#if NET7_0_OR_GREATER + => RatioChangeRate.FromDecimalFractionsPerSecond(double.CreateChecked(value)); +#else + => RatioChangeRate.FromDecimalFractionsPerSecond(value.ToDouble(null)); +#endif + + /// + public RatioChangeRate PercentsPerSecond +#if NET7_0_OR_GREATER + => RatioChangeRate.FromPercentsPerSecond(double.CreateChecked(value)); +#else + => RatioChangeRate.FromPercentsPerSecond(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRatioExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRatioExtensions.g.cs new file mode 100644 index 0000000000..2645ed3511 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRatioExtensions.g.cs @@ -0,0 +1,95 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToRatio +{ + /// + /// A number to Ratio Extensions + /// + public static class NumberToRatioExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Ratio DecimalFractions +#if NET7_0_OR_GREATER + => Ratio.FromDecimalFractions(double.CreateChecked(value)); +#else + => Ratio.FromDecimalFractions(value.ToDouble(null)); +#endif + + /// + public Ratio PartsPerBillion +#if NET7_0_OR_GREATER + => Ratio.FromPartsPerBillion(double.CreateChecked(value)); +#else + => Ratio.FromPartsPerBillion(value.ToDouble(null)); +#endif + + /// + public Ratio PartsPerMillion +#if NET7_0_OR_GREATER + => Ratio.FromPartsPerMillion(double.CreateChecked(value)); +#else + => Ratio.FromPartsPerMillion(value.ToDouble(null)); +#endif + + /// + public Ratio PartsPerThousand +#if NET7_0_OR_GREATER + => Ratio.FromPartsPerThousand(double.CreateChecked(value)); +#else + => Ratio.FromPartsPerThousand(value.ToDouble(null)); +#endif + + /// + public Ratio PartsPerTrillion +#if NET7_0_OR_GREATER + => Ratio.FromPartsPerTrillion(double.CreateChecked(value)); +#else + => Ratio.FromPartsPerTrillion(value.ToDouble(null)); +#endif + + /// + public Ratio Percent +#if NET7_0_OR_GREATER + => Ratio.FromPercent(double.CreateChecked(value)); +#else + => Ratio.FromPercent(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToReciprocalAreaExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToReciprocalAreaExtensions.g.cs new file mode 100644 index 0000000000..4f5f008539 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToReciprocalAreaExtensions.g.cs @@ -0,0 +1,135 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToReciprocalArea +{ + /// + /// A number to ReciprocalArea Extensions + /// + public static class NumberToReciprocalAreaExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public ReciprocalArea InverseSquareCentimeters +#if NET7_0_OR_GREATER + => ReciprocalArea.FromInverseSquareCentimeters(double.CreateChecked(value)); +#else + => ReciprocalArea.FromInverseSquareCentimeters(value.ToDouble(null)); +#endif + + /// + public ReciprocalArea InverseSquareDecimeters +#if NET7_0_OR_GREATER + => ReciprocalArea.FromInverseSquareDecimeters(double.CreateChecked(value)); +#else + => ReciprocalArea.FromInverseSquareDecimeters(value.ToDouble(null)); +#endif + + /// + public ReciprocalArea InverseSquareFeet +#if NET7_0_OR_GREATER + => ReciprocalArea.FromInverseSquareFeet(double.CreateChecked(value)); +#else + => ReciprocalArea.FromInverseSquareFeet(value.ToDouble(null)); +#endif + + /// + public ReciprocalArea InverseSquareInches +#if NET7_0_OR_GREATER + => ReciprocalArea.FromInverseSquareInches(double.CreateChecked(value)); +#else + => ReciprocalArea.FromInverseSquareInches(value.ToDouble(null)); +#endif + + /// + public ReciprocalArea InverseSquareKilometers +#if NET7_0_OR_GREATER + => ReciprocalArea.FromInverseSquareKilometers(double.CreateChecked(value)); +#else + => ReciprocalArea.FromInverseSquareKilometers(value.ToDouble(null)); +#endif + + /// + public ReciprocalArea InverseSquareMeters +#if NET7_0_OR_GREATER + => ReciprocalArea.FromInverseSquareMeters(double.CreateChecked(value)); +#else + => ReciprocalArea.FromInverseSquareMeters(value.ToDouble(null)); +#endif + + /// + public ReciprocalArea InverseSquareMicrometers +#if NET7_0_OR_GREATER + => ReciprocalArea.FromInverseSquareMicrometers(double.CreateChecked(value)); +#else + => ReciprocalArea.FromInverseSquareMicrometers(value.ToDouble(null)); +#endif + + /// + public ReciprocalArea InverseSquareMiles +#if NET7_0_OR_GREATER + => ReciprocalArea.FromInverseSquareMiles(double.CreateChecked(value)); +#else + => ReciprocalArea.FromInverseSquareMiles(value.ToDouble(null)); +#endif + + /// + public ReciprocalArea InverseSquareMillimeters +#if NET7_0_OR_GREATER + => ReciprocalArea.FromInverseSquareMillimeters(double.CreateChecked(value)); +#else + => ReciprocalArea.FromInverseSquareMillimeters(value.ToDouble(null)); +#endif + + /// + public ReciprocalArea InverseSquareYards +#if NET7_0_OR_GREATER + => ReciprocalArea.FromInverseSquareYards(double.CreateChecked(value)); +#else + => ReciprocalArea.FromInverseSquareYards(value.ToDouble(null)); +#endif + + /// + public ReciprocalArea InverseUsSurveySquareFeet +#if NET7_0_OR_GREATER + => ReciprocalArea.FromInverseUsSurveySquareFeet(double.CreateChecked(value)); +#else + => ReciprocalArea.FromInverseUsSurveySquareFeet(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToReciprocalLengthExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToReciprocalLengthExtensions.g.cs new file mode 100644 index 0000000000..6b880dfb95 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToReciprocalLengthExtensions.g.cs @@ -0,0 +1,127 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToReciprocalLength +{ + /// + /// A number to ReciprocalLength Extensions + /// + public static class NumberToReciprocalLengthExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public ReciprocalLength InverseCentimeters +#if NET7_0_OR_GREATER + => ReciprocalLength.FromInverseCentimeters(double.CreateChecked(value)); +#else + => ReciprocalLength.FromInverseCentimeters(value.ToDouble(null)); +#endif + + /// + public ReciprocalLength InverseFeet +#if NET7_0_OR_GREATER + => ReciprocalLength.FromInverseFeet(double.CreateChecked(value)); +#else + => ReciprocalLength.FromInverseFeet(value.ToDouble(null)); +#endif + + /// + public ReciprocalLength InverseInches +#if NET7_0_OR_GREATER + => ReciprocalLength.FromInverseInches(double.CreateChecked(value)); +#else + => ReciprocalLength.FromInverseInches(value.ToDouble(null)); +#endif + + /// + public ReciprocalLength InverseMeters +#if NET7_0_OR_GREATER + => ReciprocalLength.FromInverseMeters(double.CreateChecked(value)); +#else + => ReciprocalLength.FromInverseMeters(value.ToDouble(null)); +#endif + + /// + public ReciprocalLength InverseMicroinches +#if NET7_0_OR_GREATER + => ReciprocalLength.FromInverseMicroinches(double.CreateChecked(value)); +#else + => ReciprocalLength.FromInverseMicroinches(value.ToDouble(null)); +#endif + + /// + public ReciprocalLength InverseMils +#if NET7_0_OR_GREATER + => ReciprocalLength.FromInverseMils(double.CreateChecked(value)); +#else + => ReciprocalLength.FromInverseMils(value.ToDouble(null)); +#endif + + /// + public ReciprocalLength InverseMiles +#if NET7_0_OR_GREATER + => ReciprocalLength.FromInverseMiles(double.CreateChecked(value)); +#else + => ReciprocalLength.FromInverseMiles(value.ToDouble(null)); +#endif + + /// + public ReciprocalLength InverseMillimeters +#if NET7_0_OR_GREATER + => ReciprocalLength.FromInverseMillimeters(double.CreateChecked(value)); +#else + => ReciprocalLength.FromInverseMillimeters(value.ToDouble(null)); +#endif + + /// + public ReciprocalLength InverseUsSurveyFeet +#if NET7_0_OR_GREATER + => ReciprocalLength.FromInverseUsSurveyFeet(double.CreateChecked(value)); +#else + => ReciprocalLength.FromInverseUsSurveyFeet(value.ToDouble(null)); +#endif + + /// + public ReciprocalLength InverseYards +#if NET7_0_OR_GREATER + => ReciprocalLength.FromInverseYards(double.CreateChecked(value)); +#else + => ReciprocalLength.FromInverseYards(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRelativeHumidityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRelativeHumidityExtensions.g.cs new file mode 100644 index 0000000000..af37a8c3e5 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRelativeHumidityExtensions.g.cs @@ -0,0 +1,55 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToRelativeHumidity +{ + /// + /// A number to RelativeHumidity Extensions + /// + public static class NumberToRelativeHumidityExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public RelativeHumidity Percent +#if NET7_0_OR_GREATER + => RelativeHumidity.FromPercent(double.CreateChecked(value)); +#else + => RelativeHumidity.FromPercent(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRotationalAccelerationExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRotationalAccelerationExtensions.g.cs new file mode 100644 index 0000000000..4b09a09679 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRotationalAccelerationExtensions.g.cs @@ -0,0 +1,79 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToRotationalAcceleration +{ + /// + /// A number to RotationalAcceleration Extensions + /// + public static class NumberToRotationalAccelerationExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public RotationalAcceleration DegreesPerSecondSquared +#if NET7_0_OR_GREATER + => RotationalAcceleration.FromDegreesPerSecondSquared(double.CreateChecked(value)); +#else + => RotationalAcceleration.FromDegreesPerSecondSquared(value.ToDouble(null)); +#endif + + /// + public RotationalAcceleration RadiansPerSecondSquared +#if NET7_0_OR_GREATER + => RotationalAcceleration.FromRadiansPerSecondSquared(double.CreateChecked(value)); +#else + => RotationalAcceleration.FromRadiansPerSecondSquared(value.ToDouble(null)); +#endif + + /// + public RotationalAcceleration RevolutionsPerMinutePerSecond +#if NET7_0_OR_GREATER + => RotationalAcceleration.FromRevolutionsPerMinutePerSecond(double.CreateChecked(value)); +#else + => RotationalAcceleration.FromRevolutionsPerMinutePerSecond(value.ToDouble(null)); +#endif + + /// + public RotationalAcceleration RevolutionsPerSecondSquared +#if NET7_0_OR_GREATER + => RotationalAcceleration.FromRevolutionsPerSecondSquared(double.CreateChecked(value)); +#else + => RotationalAcceleration.FromRevolutionsPerSecondSquared(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRotationalSpeedExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRotationalSpeedExtensions.g.cs new file mode 100644 index 0000000000..16c614240a --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRotationalSpeedExtensions.g.cs @@ -0,0 +1,151 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToRotationalSpeed +{ + /// + /// A number to RotationalSpeed Extensions + /// + public static class NumberToRotationalSpeedExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public RotationalSpeed CentiradiansPerSecond +#if NET7_0_OR_GREATER + => RotationalSpeed.FromCentiradiansPerSecond(double.CreateChecked(value)); +#else + => RotationalSpeed.FromCentiradiansPerSecond(value.ToDouble(null)); +#endif + + /// + public RotationalSpeed DeciradiansPerSecond +#if NET7_0_OR_GREATER + => RotationalSpeed.FromDeciradiansPerSecond(double.CreateChecked(value)); +#else + => RotationalSpeed.FromDeciradiansPerSecond(value.ToDouble(null)); +#endif + + /// + public RotationalSpeed DegreesPerMinute +#if NET7_0_OR_GREATER + => RotationalSpeed.FromDegreesPerMinute(double.CreateChecked(value)); +#else + => RotationalSpeed.FromDegreesPerMinute(value.ToDouble(null)); +#endif + + /// + public RotationalSpeed DegreesPerSecond +#if NET7_0_OR_GREATER + => RotationalSpeed.FromDegreesPerSecond(double.CreateChecked(value)); +#else + => RotationalSpeed.FromDegreesPerSecond(value.ToDouble(null)); +#endif + + /// + public RotationalSpeed MicrodegreesPerSecond +#if NET7_0_OR_GREATER + => RotationalSpeed.FromMicrodegreesPerSecond(double.CreateChecked(value)); +#else + => RotationalSpeed.FromMicrodegreesPerSecond(value.ToDouble(null)); +#endif + + /// + public RotationalSpeed MicroradiansPerSecond +#if NET7_0_OR_GREATER + => RotationalSpeed.FromMicroradiansPerSecond(double.CreateChecked(value)); +#else + => RotationalSpeed.FromMicroradiansPerSecond(value.ToDouble(null)); +#endif + + /// + public RotationalSpeed MillidegreesPerSecond +#if NET7_0_OR_GREATER + => RotationalSpeed.FromMillidegreesPerSecond(double.CreateChecked(value)); +#else + => RotationalSpeed.FromMillidegreesPerSecond(value.ToDouble(null)); +#endif + + /// + public RotationalSpeed MilliradiansPerSecond +#if NET7_0_OR_GREATER + => RotationalSpeed.FromMilliradiansPerSecond(double.CreateChecked(value)); +#else + => RotationalSpeed.FromMilliradiansPerSecond(value.ToDouble(null)); +#endif + + /// + public RotationalSpeed NanodegreesPerSecond +#if NET7_0_OR_GREATER + => RotationalSpeed.FromNanodegreesPerSecond(double.CreateChecked(value)); +#else + => RotationalSpeed.FromNanodegreesPerSecond(value.ToDouble(null)); +#endif + + /// + public RotationalSpeed NanoradiansPerSecond +#if NET7_0_OR_GREATER + => RotationalSpeed.FromNanoradiansPerSecond(double.CreateChecked(value)); +#else + => RotationalSpeed.FromNanoradiansPerSecond(value.ToDouble(null)); +#endif + + /// + public RotationalSpeed RadiansPerSecond +#if NET7_0_OR_GREATER + => RotationalSpeed.FromRadiansPerSecond(double.CreateChecked(value)); +#else + => RotationalSpeed.FromRadiansPerSecond(value.ToDouble(null)); +#endif + + /// + public RotationalSpeed RevolutionsPerMinute +#if NET7_0_OR_GREATER + => RotationalSpeed.FromRevolutionsPerMinute(double.CreateChecked(value)); +#else + => RotationalSpeed.FromRevolutionsPerMinute(value.ToDouble(null)); +#endif + + /// + public RotationalSpeed RevolutionsPerSecond +#if NET7_0_OR_GREATER + => RotationalSpeed.FromRevolutionsPerSecond(double.CreateChecked(value)); +#else + => RotationalSpeed.FromRevolutionsPerSecond(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRotationalStiffnessExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRotationalStiffnessExtensions.g.cs new file mode 100644 index 0000000000..a1ea32c95c --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRotationalStiffnessExtensions.g.cs @@ -0,0 +1,311 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToRotationalStiffness +{ + /// + /// A number to RotationalStiffness Extensions + /// + public static class NumberToRotationalStiffnessExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public RotationalStiffness CentinewtonMetersPerDegree +#if NET7_0_OR_GREATER + => RotationalStiffness.FromCentinewtonMetersPerDegree(double.CreateChecked(value)); +#else + => RotationalStiffness.FromCentinewtonMetersPerDegree(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness CentinewtonMillimetersPerDegree +#if NET7_0_OR_GREATER + => RotationalStiffness.FromCentinewtonMillimetersPerDegree(double.CreateChecked(value)); +#else + => RotationalStiffness.FromCentinewtonMillimetersPerDegree(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness CentinewtonMillimetersPerRadian +#if NET7_0_OR_GREATER + => RotationalStiffness.FromCentinewtonMillimetersPerRadian(double.CreateChecked(value)); +#else + => RotationalStiffness.FromCentinewtonMillimetersPerRadian(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness DecanewtonMetersPerDegree +#if NET7_0_OR_GREATER + => RotationalStiffness.FromDecanewtonMetersPerDegree(double.CreateChecked(value)); +#else + => RotationalStiffness.FromDecanewtonMetersPerDegree(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness DecanewtonMillimetersPerDegree +#if NET7_0_OR_GREATER + => RotationalStiffness.FromDecanewtonMillimetersPerDegree(double.CreateChecked(value)); +#else + => RotationalStiffness.FromDecanewtonMillimetersPerDegree(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness DecanewtonMillimetersPerRadian +#if NET7_0_OR_GREATER + => RotationalStiffness.FromDecanewtonMillimetersPerRadian(double.CreateChecked(value)); +#else + => RotationalStiffness.FromDecanewtonMillimetersPerRadian(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness DecinewtonMetersPerDegree +#if NET7_0_OR_GREATER + => RotationalStiffness.FromDecinewtonMetersPerDegree(double.CreateChecked(value)); +#else + => RotationalStiffness.FromDecinewtonMetersPerDegree(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness DecinewtonMillimetersPerDegree +#if NET7_0_OR_GREATER + => RotationalStiffness.FromDecinewtonMillimetersPerDegree(double.CreateChecked(value)); +#else + => RotationalStiffness.FromDecinewtonMillimetersPerDegree(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness DecinewtonMillimetersPerRadian +#if NET7_0_OR_GREATER + => RotationalStiffness.FromDecinewtonMillimetersPerRadian(double.CreateChecked(value)); +#else + => RotationalStiffness.FromDecinewtonMillimetersPerRadian(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness KilonewtonMetersPerDegree +#if NET7_0_OR_GREATER + => RotationalStiffness.FromKilonewtonMetersPerDegree(double.CreateChecked(value)); +#else + => RotationalStiffness.FromKilonewtonMetersPerDegree(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness KilonewtonMetersPerRadian +#if NET7_0_OR_GREATER + => RotationalStiffness.FromKilonewtonMetersPerRadian(double.CreateChecked(value)); +#else + => RotationalStiffness.FromKilonewtonMetersPerRadian(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness KilonewtonMillimetersPerDegree +#if NET7_0_OR_GREATER + => RotationalStiffness.FromKilonewtonMillimetersPerDegree(double.CreateChecked(value)); +#else + => RotationalStiffness.FromKilonewtonMillimetersPerDegree(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness KilonewtonMillimetersPerRadian +#if NET7_0_OR_GREATER + => RotationalStiffness.FromKilonewtonMillimetersPerRadian(double.CreateChecked(value)); +#else + => RotationalStiffness.FromKilonewtonMillimetersPerRadian(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness KilopoundForceFeetPerDegrees +#if NET7_0_OR_GREATER + => RotationalStiffness.FromKilopoundForceFeetPerDegrees(double.CreateChecked(value)); +#else + => RotationalStiffness.FromKilopoundForceFeetPerDegrees(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness MeganewtonMetersPerDegree +#if NET7_0_OR_GREATER + => RotationalStiffness.FromMeganewtonMetersPerDegree(double.CreateChecked(value)); +#else + => RotationalStiffness.FromMeganewtonMetersPerDegree(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness MeganewtonMetersPerRadian +#if NET7_0_OR_GREATER + => RotationalStiffness.FromMeganewtonMetersPerRadian(double.CreateChecked(value)); +#else + => RotationalStiffness.FromMeganewtonMetersPerRadian(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness MeganewtonMillimetersPerDegree +#if NET7_0_OR_GREATER + => RotationalStiffness.FromMeganewtonMillimetersPerDegree(double.CreateChecked(value)); +#else + => RotationalStiffness.FromMeganewtonMillimetersPerDegree(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness MeganewtonMillimetersPerRadian +#if NET7_0_OR_GREATER + => RotationalStiffness.FromMeganewtonMillimetersPerRadian(double.CreateChecked(value)); +#else + => RotationalStiffness.FromMeganewtonMillimetersPerRadian(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness MicronewtonMetersPerDegree +#if NET7_0_OR_GREATER + => RotationalStiffness.FromMicronewtonMetersPerDegree(double.CreateChecked(value)); +#else + => RotationalStiffness.FromMicronewtonMetersPerDegree(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness MicronewtonMillimetersPerDegree +#if NET7_0_OR_GREATER + => RotationalStiffness.FromMicronewtonMillimetersPerDegree(double.CreateChecked(value)); +#else + => RotationalStiffness.FromMicronewtonMillimetersPerDegree(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness MicronewtonMillimetersPerRadian +#if NET7_0_OR_GREATER + => RotationalStiffness.FromMicronewtonMillimetersPerRadian(double.CreateChecked(value)); +#else + => RotationalStiffness.FromMicronewtonMillimetersPerRadian(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness MillinewtonMetersPerDegree +#if NET7_0_OR_GREATER + => RotationalStiffness.FromMillinewtonMetersPerDegree(double.CreateChecked(value)); +#else + => RotationalStiffness.FromMillinewtonMetersPerDegree(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness MillinewtonMillimetersPerDegree +#if NET7_0_OR_GREATER + => RotationalStiffness.FromMillinewtonMillimetersPerDegree(double.CreateChecked(value)); +#else + => RotationalStiffness.FromMillinewtonMillimetersPerDegree(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness MillinewtonMillimetersPerRadian +#if NET7_0_OR_GREATER + => RotationalStiffness.FromMillinewtonMillimetersPerRadian(double.CreateChecked(value)); +#else + => RotationalStiffness.FromMillinewtonMillimetersPerRadian(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness NanonewtonMetersPerDegree +#if NET7_0_OR_GREATER + => RotationalStiffness.FromNanonewtonMetersPerDegree(double.CreateChecked(value)); +#else + => RotationalStiffness.FromNanonewtonMetersPerDegree(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness NanonewtonMillimetersPerDegree +#if NET7_0_OR_GREATER + => RotationalStiffness.FromNanonewtonMillimetersPerDegree(double.CreateChecked(value)); +#else + => RotationalStiffness.FromNanonewtonMillimetersPerDegree(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness NanonewtonMillimetersPerRadian +#if NET7_0_OR_GREATER + => RotationalStiffness.FromNanonewtonMillimetersPerRadian(double.CreateChecked(value)); +#else + => RotationalStiffness.FromNanonewtonMillimetersPerRadian(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness NewtonMetersPerDegree +#if NET7_0_OR_GREATER + => RotationalStiffness.FromNewtonMetersPerDegree(double.CreateChecked(value)); +#else + => RotationalStiffness.FromNewtonMetersPerDegree(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness NewtonMetersPerRadian +#if NET7_0_OR_GREATER + => RotationalStiffness.FromNewtonMetersPerRadian(double.CreateChecked(value)); +#else + => RotationalStiffness.FromNewtonMetersPerRadian(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness NewtonMillimetersPerDegree +#if NET7_0_OR_GREATER + => RotationalStiffness.FromNewtonMillimetersPerDegree(double.CreateChecked(value)); +#else + => RotationalStiffness.FromNewtonMillimetersPerDegree(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness NewtonMillimetersPerRadian +#if NET7_0_OR_GREATER + => RotationalStiffness.FromNewtonMillimetersPerRadian(double.CreateChecked(value)); +#else + => RotationalStiffness.FromNewtonMillimetersPerRadian(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness PoundForceFeetPerRadian +#if NET7_0_OR_GREATER + => RotationalStiffness.FromPoundForceFeetPerRadian(double.CreateChecked(value)); +#else + => RotationalStiffness.FromPoundForceFeetPerRadian(value.ToDouble(null)); +#endif + + /// + public RotationalStiffness PoundForceFeetPerDegrees +#if NET7_0_OR_GREATER + => RotationalStiffness.FromPoundForceFeetPerDegrees(double.CreateChecked(value)); +#else + => RotationalStiffness.FromPoundForceFeetPerDegrees(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensions.g.cs new file mode 100644 index 0000000000..4856cde4fa --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensions.g.cs @@ -0,0 +1,87 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToRotationalStiffnessPerLength +{ + /// + /// A number to RotationalStiffnessPerLength Extensions + /// + public static class NumberToRotationalStiffnessPerLengthExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public RotationalStiffnessPerLength KilonewtonMetersPerRadianPerMeter +#if NET7_0_OR_GREATER + => RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(double.CreateChecked(value)); +#else + => RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(value.ToDouble(null)); +#endif + + /// + public RotationalStiffnessPerLength KilopoundForceFeetPerDegreesPerFeet +#if NET7_0_OR_GREATER + => RotationalStiffnessPerLength.FromKilopoundForceFeetPerDegreesPerFeet(double.CreateChecked(value)); +#else + => RotationalStiffnessPerLength.FromKilopoundForceFeetPerDegreesPerFeet(value.ToDouble(null)); +#endif + + /// + public RotationalStiffnessPerLength MeganewtonMetersPerRadianPerMeter +#if NET7_0_OR_GREATER + => RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(double.CreateChecked(value)); +#else + => RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(value.ToDouble(null)); +#endif + + /// + public RotationalStiffnessPerLength NewtonMetersPerRadianPerMeter +#if NET7_0_OR_GREATER + => RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(double.CreateChecked(value)); +#else + => RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(value.ToDouble(null)); +#endif + + /// + public RotationalStiffnessPerLength PoundForceFeetPerDegreesPerFeet +#if NET7_0_OR_GREATER + => RotationalStiffnessPerLength.FromPoundForceFeetPerDegreesPerFeet(double.CreateChecked(value)); +#else + => RotationalStiffnessPerLength.FromPoundForceFeetPerDegreesPerFeet(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToScalarExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToScalarExtensions.g.cs new file mode 100644 index 0000000000..62ce75ab9d --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToScalarExtensions.g.cs @@ -0,0 +1,55 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToScalar +{ + /// + /// A number to Scalar Extensions + /// + public static class NumberToScalarExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Scalar Amount +#if NET7_0_OR_GREATER + => Scalar.FromAmount(double.CreateChecked(value)); +#else + => Scalar.FromAmount(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSolidAngleExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSolidAngleExtensions.g.cs new file mode 100644 index 0000000000..a6050dcc68 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSolidAngleExtensions.g.cs @@ -0,0 +1,55 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToSolidAngle +{ + /// + /// A number to SolidAngle Extensions + /// + public static class NumberToSolidAngleExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public SolidAngle Steradians +#if NET7_0_OR_GREATER + => SolidAngle.FromSteradians(double.CreateChecked(value)); +#else + => SolidAngle.FromSteradians(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificEnergyExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificEnergyExtensions.g.cs new file mode 100644 index 0000000000..7067d994c5 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificEnergyExtensions.g.cs @@ -0,0 +1,287 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToSpecificEnergy +{ + /// + /// A number to SpecificEnergy Extensions + /// + public static class NumberToSpecificEnergyExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public SpecificEnergy BtuPerPound +#if NET7_0_OR_GREATER + => SpecificEnergy.FromBtuPerPound(double.CreateChecked(value)); +#else + => SpecificEnergy.FromBtuPerPound(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy CaloriesPerGram +#if NET7_0_OR_GREATER + => SpecificEnergy.FromCaloriesPerGram(double.CreateChecked(value)); +#else + => SpecificEnergy.FromCaloriesPerGram(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy GigawattDaysPerKilogram +#if NET7_0_OR_GREATER + => SpecificEnergy.FromGigawattDaysPerKilogram(double.CreateChecked(value)); +#else + => SpecificEnergy.FromGigawattDaysPerKilogram(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy GigawattDaysPerShortTon +#if NET7_0_OR_GREATER + => SpecificEnergy.FromGigawattDaysPerShortTon(double.CreateChecked(value)); +#else + => SpecificEnergy.FromGigawattDaysPerShortTon(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy GigawattDaysPerTonne +#if NET7_0_OR_GREATER + => SpecificEnergy.FromGigawattDaysPerTonne(double.CreateChecked(value)); +#else + => SpecificEnergy.FromGigawattDaysPerTonne(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy GigawattHoursPerKilogram +#if NET7_0_OR_GREATER + => SpecificEnergy.FromGigawattHoursPerKilogram(double.CreateChecked(value)); +#else + => SpecificEnergy.FromGigawattHoursPerKilogram(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy GigawattHoursPerPound +#if NET7_0_OR_GREATER + => SpecificEnergy.FromGigawattHoursPerPound(double.CreateChecked(value)); +#else + => SpecificEnergy.FromGigawattHoursPerPound(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy JoulesPerKilogram +#if NET7_0_OR_GREATER + => SpecificEnergy.FromJoulesPerKilogram(double.CreateChecked(value)); +#else + => SpecificEnergy.FromJoulesPerKilogram(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy KilocaloriesPerGram +#if NET7_0_OR_GREATER + => SpecificEnergy.FromKilocaloriesPerGram(double.CreateChecked(value)); +#else + => SpecificEnergy.FromKilocaloriesPerGram(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy KilojoulesPerKilogram +#if NET7_0_OR_GREATER + => SpecificEnergy.FromKilojoulesPerKilogram(double.CreateChecked(value)); +#else + => SpecificEnergy.FromKilojoulesPerKilogram(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy KilowattDaysPerKilogram +#if NET7_0_OR_GREATER + => SpecificEnergy.FromKilowattDaysPerKilogram(double.CreateChecked(value)); +#else + => SpecificEnergy.FromKilowattDaysPerKilogram(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy KilowattDaysPerShortTon +#if NET7_0_OR_GREATER + => SpecificEnergy.FromKilowattDaysPerShortTon(double.CreateChecked(value)); +#else + => SpecificEnergy.FromKilowattDaysPerShortTon(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy KilowattDaysPerTonne +#if NET7_0_OR_GREATER + => SpecificEnergy.FromKilowattDaysPerTonne(double.CreateChecked(value)); +#else + => SpecificEnergy.FromKilowattDaysPerTonne(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy KilowattHoursPerKilogram +#if NET7_0_OR_GREATER + => SpecificEnergy.FromKilowattHoursPerKilogram(double.CreateChecked(value)); +#else + => SpecificEnergy.FromKilowattHoursPerKilogram(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy KilowattHoursPerPound +#if NET7_0_OR_GREATER + => SpecificEnergy.FromKilowattHoursPerPound(double.CreateChecked(value)); +#else + => SpecificEnergy.FromKilowattHoursPerPound(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy MegajoulesPerKilogram +#if NET7_0_OR_GREATER + => SpecificEnergy.FromMegajoulesPerKilogram(double.CreateChecked(value)); +#else + => SpecificEnergy.FromMegajoulesPerKilogram(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy MegajoulesPerTonne +#if NET7_0_OR_GREATER + => SpecificEnergy.FromMegajoulesPerTonne(double.CreateChecked(value)); +#else + => SpecificEnergy.FromMegajoulesPerTonne(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy MegawattDaysPerKilogram +#if NET7_0_OR_GREATER + => SpecificEnergy.FromMegawattDaysPerKilogram(double.CreateChecked(value)); +#else + => SpecificEnergy.FromMegawattDaysPerKilogram(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy MegawattDaysPerShortTon +#if NET7_0_OR_GREATER + => SpecificEnergy.FromMegawattDaysPerShortTon(double.CreateChecked(value)); +#else + => SpecificEnergy.FromMegawattDaysPerShortTon(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy MegawattDaysPerTonne +#if NET7_0_OR_GREATER + => SpecificEnergy.FromMegawattDaysPerTonne(double.CreateChecked(value)); +#else + => SpecificEnergy.FromMegawattDaysPerTonne(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy MegawattHoursPerKilogram +#if NET7_0_OR_GREATER + => SpecificEnergy.FromMegawattHoursPerKilogram(double.CreateChecked(value)); +#else + => SpecificEnergy.FromMegawattHoursPerKilogram(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy MegawattHoursPerPound +#if NET7_0_OR_GREATER + => SpecificEnergy.FromMegawattHoursPerPound(double.CreateChecked(value)); +#else + => SpecificEnergy.FromMegawattHoursPerPound(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy TerawattDaysPerKilogram +#if NET7_0_OR_GREATER + => SpecificEnergy.FromTerawattDaysPerKilogram(double.CreateChecked(value)); +#else + => SpecificEnergy.FromTerawattDaysPerKilogram(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy TerawattDaysPerShortTon +#if NET7_0_OR_GREATER + => SpecificEnergy.FromTerawattDaysPerShortTon(double.CreateChecked(value)); +#else + => SpecificEnergy.FromTerawattDaysPerShortTon(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy TerawattDaysPerTonne +#if NET7_0_OR_GREATER + => SpecificEnergy.FromTerawattDaysPerTonne(double.CreateChecked(value)); +#else + => SpecificEnergy.FromTerawattDaysPerTonne(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy WattDaysPerKilogram +#if NET7_0_OR_GREATER + => SpecificEnergy.FromWattDaysPerKilogram(double.CreateChecked(value)); +#else + => SpecificEnergy.FromWattDaysPerKilogram(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy WattDaysPerShortTon +#if NET7_0_OR_GREATER + => SpecificEnergy.FromWattDaysPerShortTon(double.CreateChecked(value)); +#else + => SpecificEnergy.FromWattDaysPerShortTon(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy WattDaysPerTonne +#if NET7_0_OR_GREATER + => SpecificEnergy.FromWattDaysPerTonne(double.CreateChecked(value)); +#else + => SpecificEnergy.FromWattDaysPerTonne(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy WattHoursPerKilogram +#if NET7_0_OR_GREATER + => SpecificEnergy.FromWattHoursPerKilogram(double.CreateChecked(value)); +#else + => SpecificEnergy.FromWattHoursPerKilogram(value.ToDouble(null)); +#endif + + /// + public SpecificEnergy WattHoursPerPound +#if NET7_0_OR_GREATER + => SpecificEnergy.FromWattHoursPerPound(double.CreateChecked(value)); +#else + => SpecificEnergy.FromWattHoursPerPound(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificEntropyExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificEntropyExtensions.g.cs new file mode 100644 index 0000000000..71542313ed --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificEntropyExtensions.g.cs @@ -0,0 +1,119 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToSpecificEntropy +{ + /// + /// A number to SpecificEntropy Extensions + /// + public static class NumberToSpecificEntropyExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public SpecificEntropy BtusPerPoundFahrenheit +#if NET7_0_OR_GREATER + => SpecificEntropy.FromBtusPerPoundFahrenheit(double.CreateChecked(value)); +#else + => SpecificEntropy.FromBtusPerPoundFahrenheit(value.ToDouble(null)); +#endif + + /// + public SpecificEntropy CaloriesPerGramKelvin +#if NET7_0_OR_GREATER + => SpecificEntropy.FromCaloriesPerGramKelvin(double.CreateChecked(value)); +#else + => SpecificEntropy.FromCaloriesPerGramKelvin(value.ToDouble(null)); +#endif + + /// + public SpecificEntropy JoulesPerKilogramDegreeCelsius +#if NET7_0_OR_GREATER + => SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(double.CreateChecked(value)); +#else + => SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(value.ToDouble(null)); +#endif + + /// + public SpecificEntropy JoulesPerKilogramKelvin +#if NET7_0_OR_GREATER + => SpecificEntropy.FromJoulesPerKilogramKelvin(double.CreateChecked(value)); +#else + => SpecificEntropy.FromJoulesPerKilogramKelvin(value.ToDouble(null)); +#endif + + /// + public SpecificEntropy KilocaloriesPerGramKelvin +#if NET7_0_OR_GREATER + => SpecificEntropy.FromKilocaloriesPerGramKelvin(double.CreateChecked(value)); +#else + => SpecificEntropy.FromKilocaloriesPerGramKelvin(value.ToDouble(null)); +#endif + + /// + public SpecificEntropy KilojoulesPerKilogramDegreeCelsius +#if NET7_0_OR_GREATER + => SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(double.CreateChecked(value)); +#else + => SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(value.ToDouble(null)); +#endif + + /// + public SpecificEntropy KilojoulesPerKilogramKelvin +#if NET7_0_OR_GREATER + => SpecificEntropy.FromKilojoulesPerKilogramKelvin(double.CreateChecked(value)); +#else + => SpecificEntropy.FromKilojoulesPerKilogramKelvin(value.ToDouble(null)); +#endif + + /// + public SpecificEntropy MegajoulesPerKilogramDegreeCelsius +#if NET7_0_OR_GREATER + => SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(double.CreateChecked(value)); +#else + => SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(value.ToDouble(null)); +#endif + + /// + public SpecificEntropy MegajoulesPerKilogramKelvin +#if NET7_0_OR_GREATER + => SpecificEntropy.FromMegajoulesPerKilogramKelvin(double.CreateChecked(value)); +#else + => SpecificEntropy.FromMegajoulesPerKilogramKelvin(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificFuelConsumptionExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificFuelConsumptionExtensions.g.cs new file mode 100644 index 0000000000..4473785b64 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificFuelConsumptionExtensions.g.cs @@ -0,0 +1,79 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToSpecificFuelConsumption +{ + /// + /// A number to SpecificFuelConsumption Extensions + /// + public static class NumberToSpecificFuelConsumptionExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public SpecificFuelConsumption GramsPerKilonewtonSecond +#if NET7_0_OR_GREATER + => SpecificFuelConsumption.FromGramsPerKilonewtonSecond(double.CreateChecked(value)); +#else + => SpecificFuelConsumption.FromGramsPerKilonewtonSecond(value.ToDouble(null)); +#endif + + /// + public SpecificFuelConsumption KilogramsPerKilogramForceHour +#if NET7_0_OR_GREATER + => SpecificFuelConsumption.FromKilogramsPerKilogramForceHour(double.CreateChecked(value)); +#else + => SpecificFuelConsumption.FromKilogramsPerKilogramForceHour(value.ToDouble(null)); +#endif + + /// + public SpecificFuelConsumption KilogramsPerKilonewtonSecond +#if NET7_0_OR_GREATER + => SpecificFuelConsumption.FromKilogramsPerKilonewtonSecond(double.CreateChecked(value)); +#else + => SpecificFuelConsumption.FromKilogramsPerKilonewtonSecond(value.ToDouble(null)); +#endif + + /// + public SpecificFuelConsumption PoundsMassPerPoundForceHour +#if NET7_0_OR_GREATER + => SpecificFuelConsumption.FromPoundsMassPerPoundForceHour(double.CreateChecked(value)); +#else + => SpecificFuelConsumption.FromPoundsMassPerPoundForceHour(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificVolumeExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificVolumeExtensions.g.cs new file mode 100644 index 0000000000..b8762fcea6 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificVolumeExtensions.g.cs @@ -0,0 +1,71 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToSpecificVolume +{ + /// + /// A number to SpecificVolume Extensions + /// + public static class NumberToSpecificVolumeExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public SpecificVolume CubicFeetPerPound +#if NET7_0_OR_GREATER + => SpecificVolume.FromCubicFeetPerPound(double.CreateChecked(value)); +#else + => SpecificVolume.FromCubicFeetPerPound(value.ToDouble(null)); +#endif + + /// + public SpecificVolume CubicMetersPerKilogram +#if NET7_0_OR_GREATER + => SpecificVolume.FromCubicMetersPerKilogram(double.CreateChecked(value)); +#else + => SpecificVolume.FromCubicMetersPerKilogram(value.ToDouble(null)); +#endif + + /// + public SpecificVolume MillicubicMetersPerKilogram +#if NET7_0_OR_GREATER + => SpecificVolume.FromMillicubicMetersPerKilogram(double.CreateChecked(value)); +#else + => SpecificVolume.FromMillicubicMetersPerKilogram(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificWeightExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificWeightExtensions.g.cs new file mode 100644 index 0000000000..45ae4bcb2f --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpecificWeightExtensions.g.cs @@ -0,0 +1,183 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToSpecificWeight +{ + /// + /// A number to SpecificWeight Extensions + /// + public static class NumberToSpecificWeightExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public SpecificWeight KilogramsForcePerCubicCentimeter +#if NET7_0_OR_GREATER + => SpecificWeight.FromKilogramsForcePerCubicCentimeter(double.CreateChecked(value)); +#else + => SpecificWeight.FromKilogramsForcePerCubicCentimeter(value.ToDouble(null)); +#endif + + /// + public SpecificWeight KilogramsForcePerCubicMeter +#if NET7_0_OR_GREATER + => SpecificWeight.FromKilogramsForcePerCubicMeter(double.CreateChecked(value)); +#else + => SpecificWeight.FromKilogramsForcePerCubicMeter(value.ToDouble(null)); +#endif + + /// + public SpecificWeight KilogramsForcePerCubicMillimeter +#if NET7_0_OR_GREATER + => SpecificWeight.FromKilogramsForcePerCubicMillimeter(double.CreateChecked(value)); +#else + => SpecificWeight.FromKilogramsForcePerCubicMillimeter(value.ToDouble(null)); +#endif + + /// + public SpecificWeight KilonewtonsPerCubicCentimeter +#if NET7_0_OR_GREATER + => SpecificWeight.FromKilonewtonsPerCubicCentimeter(double.CreateChecked(value)); +#else + => SpecificWeight.FromKilonewtonsPerCubicCentimeter(value.ToDouble(null)); +#endif + + /// + public SpecificWeight KilonewtonsPerCubicMeter +#if NET7_0_OR_GREATER + => SpecificWeight.FromKilonewtonsPerCubicMeter(double.CreateChecked(value)); +#else + => SpecificWeight.FromKilonewtonsPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public SpecificWeight KilonewtonsPerCubicMillimeter +#if NET7_0_OR_GREATER + => SpecificWeight.FromKilonewtonsPerCubicMillimeter(double.CreateChecked(value)); +#else + => SpecificWeight.FromKilonewtonsPerCubicMillimeter(value.ToDouble(null)); +#endif + + /// + public SpecificWeight KilopoundsForcePerCubicFoot +#if NET7_0_OR_GREATER + => SpecificWeight.FromKilopoundsForcePerCubicFoot(double.CreateChecked(value)); +#else + => SpecificWeight.FromKilopoundsForcePerCubicFoot(value.ToDouble(null)); +#endif + + /// + public SpecificWeight KilopoundsForcePerCubicInch +#if NET7_0_OR_GREATER + => SpecificWeight.FromKilopoundsForcePerCubicInch(double.CreateChecked(value)); +#else + => SpecificWeight.FromKilopoundsForcePerCubicInch(value.ToDouble(null)); +#endif + + /// + public SpecificWeight MeganewtonsPerCubicMeter +#if NET7_0_OR_GREATER + => SpecificWeight.FromMeganewtonsPerCubicMeter(double.CreateChecked(value)); +#else + => SpecificWeight.FromMeganewtonsPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public SpecificWeight NewtonsPerCubicCentimeter +#if NET7_0_OR_GREATER + => SpecificWeight.FromNewtonsPerCubicCentimeter(double.CreateChecked(value)); +#else + => SpecificWeight.FromNewtonsPerCubicCentimeter(value.ToDouble(null)); +#endif + + /// + public SpecificWeight NewtonsPerCubicMeter +#if NET7_0_OR_GREATER + => SpecificWeight.FromNewtonsPerCubicMeter(double.CreateChecked(value)); +#else + => SpecificWeight.FromNewtonsPerCubicMeter(value.ToDouble(null)); +#endif + + /// + public SpecificWeight NewtonsPerCubicMillimeter +#if NET7_0_OR_GREATER + => SpecificWeight.FromNewtonsPerCubicMillimeter(double.CreateChecked(value)); +#else + => SpecificWeight.FromNewtonsPerCubicMillimeter(value.ToDouble(null)); +#endif + + /// + public SpecificWeight PoundsForcePerCubicFoot +#if NET7_0_OR_GREATER + => SpecificWeight.FromPoundsForcePerCubicFoot(double.CreateChecked(value)); +#else + => SpecificWeight.FromPoundsForcePerCubicFoot(value.ToDouble(null)); +#endif + + /// + public SpecificWeight PoundsForcePerCubicInch +#if NET7_0_OR_GREATER + => SpecificWeight.FromPoundsForcePerCubicInch(double.CreateChecked(value)); +#else + => SpecificWeight.FromPoundsForcePerCubicInch(value.ToDouble(null)); +#endif + + /// + public SpecificWeight TonnesForcePerCubicCentimeter +#if NET7_0_OR_GREATER + => SpecificWeight.FromTonnesForcePerCubicCentimeter(double.CreateChecked(value)); +#else + => SpecificWeight.FromTonnesForcePerCubicCentimeter(value.ToDouble(null)); +#endif + + /// + public SpecificWeight TonnesForcePerCubicMeter +#if NET7_0_OR_GREATER + => SpecificWeight.FromTonnesForcePerCubicMeter(double.CreateChecked(value)); +#else + => SpecificWeight.FromTonnesForcePerCubicMeter(value.ToDouble(null)); +#endif + + /// + public SpecificWeight TonnesForcePerCubicMillimeter +#if NET7_0_OR_GREATER + => SpecificWeight.FromTonnesForcePerCubicMillimeter(double.CreateChecked(value)); +#else + => SpecificWeight.FromTonnesForcePerCubicMillimeter(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpeedExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpeedExtensions.g.cs new file mode 100644 index 0000000000..c71cf409a3 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToSpeedExtensions.g.cs @@ -0,0 +1,311 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToSpeed +{ + /// + /// A number to Speed Extensions + /// + public static class NumberToSpeedExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Speed CentimetersPerHour +#if NET7_0_OR_GREATER + => Speed.FromCentimetersPerHour(double.CreateChecked(value)); +#else + => Speed.FromCentimetersPerHour(value.ToDouble(null)); +#endif + + /// + public Speed CentimetersPerMinute +#if NET7_0_OR_GREATER + => Speed.FromCentimetersPerMinute(double.CreateChecked(value)); +#else + => Speed.FromCentimetersPerMinute(value.ToDouble(null)); +#endif + + /// + public Speed CentimetersPerSecond +#if NET7_0_OR_GREATER + => Speed.FromCentimetersPerSecond(double.CreateChecked(value)); +#else + => Speed.FromCentimetersPerSecond(value.ToDouble(null)); +#endif + + /// + public Speed DecimetersPerMinute +#if NET7_0_OR_GREATER + => Speed.FromDecimetersPerMinute(double.CreateChecked(value)); +#else + => Speed.FromDecimetersPerMinute(value.ToDouble(null)); +#endif + + /// + public Speed DecimetersPerSecond +#if NET7_0_OR_GREATER + => Speed.FromDecimetersPerSecond(double.CreateChecked(value)); +#else + => Speed.FromDecimetersPerSecond(value.ToDouble(null)); +#endif + + /// + public Speed FeetPerHour +#if NET7_0_OR_GREATER + => Speed.FromFeetPerHour(double.CreateChecked(value)); +#else + => Speed.FromFeetPerHour(value.ToDouble(null)); +#endif + + /// + public Speed FeetPerMinute +#if NET7_0_OR_GREATER + => Speed.FromFeetPerMinute(double.CreateChecked(value)); +#else + => Speed.FromFeetPerMinute(value.ToDouble(null)); +#endif + + /// + public Speed FeetPerSecond +#if NET7_0_OR_GREATER + => Speed.FromFeetPerSecond(double.CreateChecked(value)); +#else + => Speed.FromFeetPerSecond(value.ToDouble(null)); +#endif + + /// + public Speed InchesPerHour +#if NET7_0_OR_GREATER + => Speed.FromInchesPerHour(double.CreateChecked(value)); +#else + => Speed.FromInchesPerHour(value.ToDouble(null)); +#endif + + /// + public Speed InchesPerMinute +#if NET7_0_OR_GREATER + => Speed.FromInchesPerMinute(double.CreateChecked(value)); +#else + => Speed.FromInchesPerMinute(value.ToDouble(null)); +#endif + + /// + public Speed InchesPerSecond +#if NET7_0_OR_GREATER + => Speed.FromInchesPerSecond(double.CreateChecked(value)); +#else + => Speed.FromInchesPerSecond(value.ToDouble(null)); +#endif + + /// + public Speed KilometersPerHour +#if NET7_0_OR_GREATER + => Speed.FromKilometersPerHour(double.CreateChecked(value)); +#else + => Speed.FromKilometersPerHour(value.ToDouble(null)); +#endif + + /// + public Speed KilometersPerMinute +#if NET7_0_OR_GREATER + => Speed.FromKilometersPerMinute(double.CreateChecked(value)); +#else + => Speed.FromKilometersPerMinute(value.ToDouble(null)); +#endif + + /// + public Speed KilometersPerSecond +#if NET7_0_OR_GREATER + => Speed.FromKilometersPerSecond(double.CreateChecked(value)); +#else + => Speed.FromKilometersPerSecond(value.ToDouble(null)); +#endif + + /// + public Speed Knots +#if NET7_0_OR_GREATER + => Speed.FromKnots(double.CreateChecked(value)); +#else + => Speed.FromKnots(value.ToDouble(null)); +#endif + + /// + public Speed Mach +#if NET7_0_OR_GREATER + => Speed.FromMach(double.CreateChecked(value)); +#else + => Speed.FromMach(value.ToDouble(null)); +#endif + + /// + public Speed MetersPerHour +#if NET7_0_OR_GREATER + => Speed.FromMetersPerHour(double.CreateChecked(value)); +#else + => Speed.FromMetersPerHour(value.ToDouble(null)); +#endif + + /// + public Speed MetersPerMinute +#if NET7_0_OR_GREATER + => Speed.FromMetersPerMinute(double.CreateChecked(value)); +#else + => Speed.FromMetersPerMinute(value.ToDouble(null)); +#endif + + /// + public Speed MetersPerSecond +#if NET7_0_OR_GREATER + => Speed.FromMetersPerSecond(double.CreateChecked(value)); +#else + => Speed.FromMetersPerSecond(value.ToDouble(null)); +#endif + + /// + public Speed MicrometersPerMinute +#if NET7_0_OR_GREATER + => Speed.FromMicrometersPerMinute(double.CreateChecked(value)); +#else + => Speed.FromMicrometersPerMinute(value.ToDouble(null)); +#endif + + /// + public Speed MicrometersPerSecond +#if NET7_0_OR_GREATER + => Speed.FromMicrometersPerSecond(double.CreateChecked(value)); +#else + => Speed.FromMicrometersPerSecond(value.ToDouble(null)); +#endif + + /// + public Speed MilesPerHour +#if NET7_0_OR_GREATER + => Speed.FromMilesPerHour(double.CreateChecked(value)); +#else + => Speed.FromMilesPerHour(value.ToDouble(null)); +#endif + + /// + public Speed MillimetersPerHour +#if NET7_0_OR_GREATER + => Speed.FromMillimetersPerHour(double.CreateChecked(value)); +#else + => Speed.FromMillimetersPerHour(value.ToDouble(null)); +#endif + + /// + public Speed MillimetersPerMinute +#if NET7_0_OR_GREATER + => Speed.FromMillimetersPerMinute(double.CreateChecked(value)); +#else + => Speed.FromMillimetersPerMinute(value.ToDouble(null)); +#endif + + /// + public Speed MillimetersPerSecond +#if NET7_0_OR_GREATER + => Speed.FromMillimetersPerSecond(double.CreateChecked(value)); +#else + => Speed.FromMillimetersPerSecond(value.ToDouble(null)); +#endif + + /// + public Speed NanometersPerMinute +#if NET7_0_OR_GREATER + => Speed.FromNanometersPerMinute(double.CreateChecked(value)); +#else + => Speed.FromNanometersPerMinute(value.ToDouble(null)); +#endif + + /// + public Speed NanometersPerSecond +#if NET7_0_OR_GREATER + => Speed.FromNanometersPerSecond(double.CreateChecked(value)); +#else + => Speed.FromNanometersPerSecond(value.ToDouble(null)); +#endif + + /// + public Speed UsSurveyFeetPerHour +#if NET7_0_OR_GREATER + => Speed.FromUsSurveyFeetPerHour(double.CreateChecked(value)); +#else + => Speed.FromUsSurveyFeetPerHour(value.ToDouble(null)); +#endif + + /// + public Speed UsSurveyFeetPerMinute +#if NET7_0_OR_GREATER + => Speed.FromUsSurveyFeetPerMinute(double.CreateChecked(value)); +#else + => Speed.FromUsSurveyFeetPerMinute(value.ToDouble(null)); +#endif + + /// + public Speed UsSurveyFeetPerSecond +#if NET7_0_OR_GREATER + => Speed.FromUsSurveyFeetPerSecond(double.CreateChecked(value)); +#else + => Speed.FromUsSurveyFeetPerSecond(value.ToDouble(null)); +#endif + + /// + public Speed YardsPerHour +#if NET7_0_OR_GREATER + => Speed.FromYardsPerHour(double.CreateChecked(value)); +#else + => Speed.FromYardsPerHour(value.ToDouble(null)); +#endif + + /// + public Speed YardsPerMinute +#if NET7_0_OR_GREATER + => Speed.FromYardsPerMinute(double.CreateChecked(value)); +#else + => Speed.FromYardsPerMinute(value.ToDouble(null)); +#endif + + /// + public Speed YardsPerSecond +#if NET7_0_OR_GREATER + => Speed.FromYardsPerSecond(double.CreateChecked(value)); +#else + => Speed.FromYardsPerSecond(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToStandardVolumeFlowExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToStandardVolumeFlowExtensions.g.cs new file mode 100644 index 0000000000..136ac4c994 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToStandardVolumeFlowExtensions.g.cs @@ -0,0 +1,119 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToStandardVolumeFlow +{ + /// + /// A number to StandardVolumeFlow Extensions + /// + public static class NumberToStandardVolumeFlowExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public StandardVolumeFlow StandardCubicCentimetersPerMinute +#if NET7_0_OR_GREATER + => StandardVolumeFlow.FromStandardCubicCentimetersPerMinute(double.CreateChecked(value)); +#else + => StandardVolumeFlow.FromStandardCubicCentimetersPerMinute(value.ToDouble(null)); +#endif + + /// + public StandardVolumeFlow StandardCubicFeetPerHour +#if NET7_0_OR_GREATER + => StandardVolumeFlow.FromStandardCubicFeetPerHour(double.CreateChecked(value)); +#else + => StandardVolumeFlow.FromStandardCubicFeetPerHour(value.ToDouble(null)); +#endif + + /// + public StandardVolumeFlow StandardCubicFeetPerMinute +#if NET7_0_OR_GREATER + => StandardVolumeFlow.FromStandardCubicFeetPerMinute(double.CreateChecked(value)); +#else + => StandardVolumeFlow.FromStandardCubicFeetPerMinute(value.ToDouble(null)); +#endif + + /// + public StandardVolumeFlow StandardCubicFeetPerSecond +#if NET7_0_OR_GREATER + => StandardVolumeFlow.FromStandardCubicFeetPerSecond(double.CreateChecked(value)); +#else + => StandardVolumeFlow.FromStandardCubicFeetPerSecond(value.ToDouble(null)); +#endif + + /// + public StandardVolumeFlow StandardCubicMetersPerDay +#if NET7_0_OR_GREATER + => StandardVolumeFlow.FromStandardCubicMetersPerDay(double.CreateChecked(value)); +#else + => StandardVolumeFlow.FromStandardCubicMetersPerDay(value.ToDouble(null)); +#endif + + /// + public StandardVolumeFlow StandardCubicMetersPerHour +#if NET7_0_OR_GREATER + => StandardVolumeFlow.FromStandardCubicMetersPerHour(double.CreateChecked(value)); +#else + => StandardVolumeFlow.FromStandardCubicMetersPerHour(value.ToDouble(null)); +#endif + + /// + public StandardVolumeFlow StandardCubicMetersPerMinute +#if NET7_0_OR_GREATER + => StandardVolumeFlow.FromStandardCubicMetersPerMinute(double.CreateChecked(value)); +#else + => StandardVolumeFlow.FromStandardCubicMetersPerMinute(value.ToDouble(null)); +#endif + + /// + public StandardVolumeFlow StandardCubicMetersPerSecond +#if NET7_0_OR_GREATER + => StandardVolumeFlow.FromStandardCubicMetersPerSecond(double.CreateChecked(value)); +#else + => StandardVolumeFlow.FromStandardCubicMetersPerSecond(value.ToDouble(null)); +#endif + + /// + public StandardVolumeFlow StandardLitersPerMinute +#if NET7_0_OR_GREATER + => StandardVolumeFlow.FromStandardLitersPerMinute(double.CreateChecked(value)); +#else + => StandardVolumeFlow.FromStandardLitersPerMinute(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTemperatureChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTemperatureChangeRateExtensions.g.cs new file mode 100644 index 0000000000..c8a51389e1 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTemperatureChangeRateExtensions.g.cs @@ -0,0 +1,183 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToTemperatureChangeRate +{ + /// + /// A number to TemperatureChangeRate Extensions + /// + public static class NumberToTemperatureChangeRateExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public TemperatureChangeRate CentidegreesCelsiusPerSecond +#if NET7_0_OR_GREATER + => TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(double.CreateChecked(value)); +#else + => TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(value.ToDouble(null)); +#endif + + /// + public TemperatureChangeRate DecadegreesCelsiusPerSecond +#if NET7_0_OR_GREATER + => TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(double.CreateChecked(value)); +#else + => TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(value.ToDouble(null)); +#endif + + /// + public TemperatureChangeRate DecidegreesCelsiusPerSecond +#if NET7_0_OR_GREATER + => TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(double.CreateChecked(value)); +#else + => TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(value.ToDouble(null)); +#endif + + /// + public TemperatureChangeRate DegreesCelsiusPerHour +#if NET7_0_OR_GREATER + => TemperatureChangeRate.FromDegreesCelsiusPerHour(double.CreateChecked(value)); +#else + => TemperatureChangeRate.FromDegreesCelsiusPerHour(value.ToDouble(null)); +#endif + + /// + public TemperatureChangeRate DegreesCelsiusPerMinute +#if NET7_0_OR_GREATER + => TemperatureChangeRate.FromDegreesCelsiusPerMinute(double.CreateChecked(value)); +#else + => TemperatureChangeRate.FromDegreesCelsiusPerMinute(value.ToDouble(null)); +#endif + + /// + public TemperatureChangeRate DegreesCelsiusPerSecond +#if NET7_0_OR_GREATER + => TemperatureChangeRate.FromDegreesCelsiusPerSecond(double.CreateChecked(value)); +#else + => TemperatureChangeRate.FromDegreesCelsiusPerSecond(value.ToDouble(null)); +#endif + + /// + public TemperatureChangeRate DegreesFahrenheitPerHour +#if NET7_0_OR_GREATER + => TemperatureChangeRate.FromDegreesFahrenheitPerHour(double.CreateChecked(value)); +#else + => TemperatureChangeRate.FromDegreesFahrenheitPerHour(value.ToDouble(null)); +#endif + + /// + public TemperatureChangeRate DegreesFahrenheitPerMinute +#if NET7_0_OR_GREATER + => TemperatureChangeRate.FromDegreesFahrenheitPerMinute(double.CreateChecked(value)); +#else + => TemperatureChangeRate.FromDegreesFahrenheitPerMinute(value.ToDouble(null)); +#endif + + /// + public TemperatureChangeRate DegreesFahrenheitPerSecond +#if NET7_0_OR_GREATER + => TemperatureChangeRate.FromDegreesFahrenheitPerSecond(double.CreateChecked(value)); +#else + => TemperatureChangeRate.FromDegreesFahrenheitPerSecond(value.ToDouble(null)); +#endif + + /// + public TemperatureChangeRate DegreesKelvinPerHour +#if NET7_0_OR_GREATER + => TemperatureChangeRate.FromDegreesKelvinPerHour(double.CreateChecked(value)); +#else + => TemperatureChangeRate.FromDegreesKelvinPerHour(value.ToDouble(null)); +#endif + + /// + public TemperatureChangeRate DegreesKelvinPerMinute +#if NET7_0_OR_GREATER + => TemperatureChangeRate.FromDegreesKelvinPerMinute(double.CreateChecked(value)); +#else + => TemperatureChangeRate.FromDegreesKelvinPerMinute(value.ToDouble(null)); +#endif + + /// + public TemperatureChangeRate DegreesKelvinPerSecond +#if NET7_0_OR_GREATER + => TemperatureChangeRate.FromDegreesKelvinPerSecond(double.CreateChecked(value)); +#else + => TemperatureChangeRate.FromDegreesKelvinPerSecond(value.ToDouble(null)); +#endif + + /// + public TemperatureChangeRate HectodegreesCelsiusPerSecond +#if NET7_0_OR_GREATER + => TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(double.CreateChecked(value)); +#else + => TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(value.ToDouble(null)); +#endif + + /// + public TemperatureChangeRate KilodegreesCelsiusPerSecond +#if NET7_0_OR_GREATER + => TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(double.CreateChecked(value)); +#else + => TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(value.ToDouble(null)); +#endif + + /// + public TemperatureChangeRate MicrodegreesCelsiusPerSecond +#if NET7_0_OR_GREATER + => TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(double.CreateChecked(value)); +#else + => TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(value.ToDouble(null)); +#endif + + /// + public TemperatureChangeRate MillidegreesCelsiusPerSecond +#if NET7_0_OR_GREATER + => TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(double.CreateChecked(value)); +#else + => TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(value.ToDouble(null)); +#endif + + /// + public TemperatureChangeRate NanodegreesCelsiusPerSecond +#if NET7_0_OR_GREATER + => TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(double.CreateChecked(value)); +#else + => TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTemperatureDeltaExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTemperatureDeltaExtensions.g.cs new file mode 100644 index 0000000000..e7f019d3be --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTemperatureDeltaExtensions.g.cs @@ -0,0 +1,119 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToTemperatureDelta +{ + /// + /// A number to TemperatureDelta Extensions + /// + public static class NumberToTemperatureDeltaExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public TemperatureDelta DegreesCelsius +#if NET7_0_OR_GREATER + => TemperatureDelta.FromDegreesCelsius(double.CreateChecked(value)); +#else + => TemperatureDelta.FromDegreesCelsius(value.ToDouble(null)); +#endif + + /// + public TemperatureDelta DegreesDelisle +#if NET7_0_OR_GREATER + => TemperatureDelta.FromDegreesDelisle(double.CreateChecked(value)); +#else + => TemperatureDelta.FromDegreesDelisle(value.ToDouble(null)); +#endif + + /// + public TemperatureDelta DegreesFahrenheit +#if NET7_0_OR_GREATER + => TemperatureDelta.FromDegreesFahrenheit(double.CreateChecked(value)); +#else + => TemperatureDelta.FromDegreesFahrenheit(value.ToDouble(null)); +#endif + + /// + public TemperatureDelta DegreesNewton +#if NET7_0_OR_GREATER + => TemperatureDelta.FromDegreesNewton(double.CreateChecked(value)); +#else + => TemperatureDelta.FromDegreesNewton(value.ToDouble(null)); +#endif + + /// + public TemperatureDelta DegreesRankine +#if NET7_0_OR_GREATER + => TemperatureDelta.FromDegreesRankine(double.CreateChecked(value)); +#else + => TemperatureDelta.FromDegreesRankine(value.ToDouble(null)); +#endif + + /// + public TemperatureDelta DegreesReaumur +#if NET7_0_OR_GREATER + => TemperatureDelta.FromDegreesReaumur(double.CreateChecked(value)); +#else + => TemperatureDelta.FromDegreesReaumur(value.ToDouble(null)); +#endif + + /// + public TemperatureDelta DegreesRoemer +#if NET7_0_OR_GREATER + => TemperatureDelta.FromDegreesRoemer(double.CreateChecked(value)); +#else + => TemperatureDelta.FromDegreesRoemer(value.ToDouble(null)); +#endif + + /// + public TemperatureDelta Kelvins +#if NET7_0_OR_GREATER + => TemperatureDelta.FromKelvins(double.CreateChecked(value)); +#else + => TemperatureDelta.FromKelvins(value.ToDouble(null)); +#endif + + /// + public TemperatureDelta MillidegreesCelsius +#if NET7_0_OR_GREATER + => TemperatureDelta.FromMillidegreesCelsius(double.CreateChecked(value)); +#else + => TemperatureDelta.FromMillidegreesCelsius(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTemperatureExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTemperatureExtensions.g.cs new file mode 100644 index 0000000000..9fb7dbb94b --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTemperatureExtensions.g.cs @@ -0,0 +1,127 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToTemperature +{ + /// + /// A number to Temperature Extensions + /// + public static class NumberToTemperatureExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Temperature DegreesCelsius +#if NET7_0_OR_GREATER + => Temperature.FromDegreesCelsius(double.CreateChecked(value)); +#else + => Temperature.FromDegreesCelsius(value.ToDouble(null)); +#endif + + /// + public Temperature DegreesDelisle +#if NET7_0_OR_GREATER + => Temperature.FromDegreesDelisle(double.CreateChecked(value)); +#else + => Temperature.FromDegreesDelisle(value.ToDouble(null)); +#endif + + /// + public Temperature DegreesFahrenheit +#if NET7_0_OR_GREATER + => Temperature.FromDegreesFahrenheit(double.CreateChecked(value)); +#else + => Temperature.FromDegreesFahrenheit(value.ToDouble(null)); +#endif + + /// + public Temperature DegreesNewton +#if NET7_0_OR_GREATER + => Temperature.FromDegreesNewton(double.CreateChecked(value)); +#else + => Temperature.FromDegreesNewton(value.ToDouble(null)); +#endif + + /// + public Temperature DegreesRankine +#if NET7_0_OR_GREATER + => Temperature.FromDegreesRankine(double.CreateChecked(value)); +#else + => Temperature.FromDegreesRankine(value.ToDouble(null)); +#endif + + /// + public Temperature DegreesReaumur +#if NET7_0_OR_GREATER + => Temperature.FromDegreesReaumur(double.CreateChecked(value)); +#else + => Temperature.FromDegreesReaumur(value.ToDouble(null)); +#endif + + /// + public Temperature DegreesRoemer +#if NET7_0_OR_GREATER + => Temperature.FromDegreesRoemer(double.CreateChecked(value)); +#else + => Temperature.FromDegreesRoemer(value.ToDouble(null)); +#endif + + /// + public Temperature Kelvins +#if NET7_0_OR_GREATER + => Temperature.FromKelvins(double.CreateChecked(value)); +#else + => Temperature.FromKelvins(value.ToDouble(null)); +#endif + + /// + public Temperature MillidegreesCelsius +#if NET7_0_OR_GREATER + => Temperature.FromMillidegreesCelsius(double.CreateChecked(value)); +#else + => Temperature.FromMillidegreesCelsius(value.ToDouble(null)); +#endif + + /// + public Temperature SolarTemperatures +#if NET7_0_OR_GREATER + => Temperature.FromSolarTemperatures(double.CreateChecked(value)); +#else + => Temperature.FromSolarTemperatures(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTemperatureGradientExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTemperatureGradientExtensions.g.cs new file mode 100644 index 0000000000..073efe31f7 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTemperatureGradientExtensions.g.cs @@ -0,0 +1,79 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToTemperatureGradient +{ + /// + /// A number to TemperatureGradient Extensions + /// + public static class NumberToTemperatureGradientExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public TemperatureGradient DegreesCelsiusPerKilometer +#if NET7_0_OR_GREATER + => TemperatureGradient.FromDegreesCelsiusPerKilometer(double.CreateChecked(value)); +#else + => TemperatureGradient.FromDegreesCelsiusPerKilometer(value.ToDouble(null)); +#endif + + /// + public TemperatureGradient DegreesCelsiusPerMeter +#if NET7_0_OR_GREATER + => TemperatureGradient.FromDegreesCelsiusPerMeter(double.CreateChecked(value)); +#else + => TemperatureGradient.FromDegreesCelsiusPerMeter(value.ToDouble(null)); +#endif + + /// + public TemperatureGradient DegreesFahrenheitPerFoot +#if NET7_0_OR_GREATER + => TemperatureGradient.FromDegreesFahrenheitPerFoot(double.CreateChecked(value)); +#else + => TemperatureGradient.FromDegreesFahrenheitPerFoot(value.ToDouble(null)); +#endif + + /// + public TemperatureGradient KelvinsPerMeter +#if NET7_0_OR_GREATER + => TemperatureGradient.FromKelvinsPerMeter(double.CreateChecked(value)); +#else + => TemperatureGradient.FromKelvinsPerMeter(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToThermalConductivityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToThermalConductivityExtensions.g.cs new file mode 100644 index 0000000000..c3b662365a --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToThermalConductivityExtensions.g.cs @@ -0,0 +1,63 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToThermalConductivity +{ + /// + /// A number to ThermalConductivity Extensions + /// + public static class NumberToThermalConductivityExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public ThermalConductivity BtusPerHourFootFahrenheit +#if NET7_0_OR_GREATER + => ThermalConductivity.FromBtusPerHourFootFahrenheit(double.CreateChecked(value)); +#else + => ThermalConductivity.FromBtusPerHourFootFahrenheit(value.ToDouble(null)); +#endif + + /// + public ThermalConductivity WattsPerMeterKelvin +#if NET7_0_OR_GREATER + => ThermalConductivity.FromWattsPerMeterKelvin(double.CreateChecked(value)); +#else + => ThermalConductivity.FromWattsPerMeterKelvin(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToThermalInsulanceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToThermalInsulanceExtensions.g.cs new file mode 100644 index 0000000000..5298a28686 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToThermalInsulanceExtensions.g.cs @@ -0,0 +1,103 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToThermalInsulance +{ + /// + /// A number to ThermalInsulance Extensions + /// + public static class NumberToThermalInsulanceExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public ThermalInsulance HourSquareFeetDegreesFahrenheitPerBtu +#if NET7_0_OR_GREATER + => ThermalInsulance.FromHourSquareFeetDegreesFahrenheitPerBtu(double.CreateChecked(value)); +#else + => ThermalInsulance.FromHourSquareFeetDegreesFahrenheitPerBtu(value.ToDouble(null)); +#endif + + /// + public ThermalInsulance SquareCentimeterHourDegreesCelsiusPerKilocalorie +#if NET7_0_OR_GREATER + => ThermalInsulance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(double.CreateChecked(value)); +#else + => ThermalInsulance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(value.ToDouble(null)); +#endif + + /// + public ThermalInsulance SquareCentimeterKelvinsPerWatt +#if NET7_0_OR_GREATER + => ThermalInsulance.FromSquareCentimeterKelvinsPerWatt(double.CreateChecked(value)); +#else + => ThermalInsulance.FromSquareCentimeterKelvinsPerWatt(value.ToDouble(null)); +#endif + + /// + public ThermalInsulance SquareMeterDegreesCelsiusPerWatt +#if NET7_0_OR_GREATER + => ThermalInsulance.FromSquareMeterDegreesCelsiusPerWatt(double.CreateChecked(value)); +#else + => ThermalInsulance.FromSquareMeterDegreesCelsiusPerWatt(value.ToDouble(null)); +#endif + + /// + public ThermalInsulance SquareMeterKelvinsPerKilowatt +#if NET7_0_OR_GREATER + => ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(double.CreateChecked(value)); +#else + => ThermalInsulance.FromSquareMeterKelvinsPerKilowatt(value.ToDouble(null)); +#endif + + /// + public ThermalInsulance SquareMeterKelvinsPerWatt +#if NET7_0_OR_GREATER + => ThermalInsulance.FromSquareMeterKelvinsPerWatt(double.CreateChecked(value)); +#else + => ThermalInsulance.FromSquareMeterKelvinsPerWatt(value.ToDouble(null)); +#endif + + /// + public ThermalInsulance SquareMillimeterKelvinsPerWatt +#if NET7_0_OR_GREATER + => ThermalInsulance.FromSquareMillimeterKelvinsPerWatt(double.CreateChecked(value)); +#else + => ThermalInsulance.FromSquareMillimeterKelvinsPerWatt(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToThermalResistanceExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToThermalResistanceExtensions.g.cs new file mode 100644 index 0000000000..ff84646a34 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToThermalResistanceExtensions.g.cs @@ -0,0 +1,63 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToThermalResistance +{ + /// + /// A number to ThermalResistance Extensions + /// + public static class NumberToThermalResistanceExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public ThermalResistance DegreesCelsiusPerWatt +#if NET7_0_OR_GREATER + => ThermalResistance.FromDegreesCelsiusPerWatt(double.CreateChecked(value)); +#else + => ThermalResistance.FromDegreesCelsiusPerWatt(value.ToDouble(null)); +#endif + + /// + public ThermalResistance KelvinsPerWatt +#if NET7_0_OR_GREATER + => ThermalResistance.FromKelvinsPerWatt(double.CreateChecked(value)); +#else + => ThermalResistance.FromKelvinsPerWatt(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTorqueExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTorqueExtensions.g.cs new file mode 100644 index 0000000000..1f146d4cbe --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTorqueExtensions.g.cs @@ -0,0 +1,247 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToTorque +{ + /// + /// A number to Torque Extensions + /// + public static class NumberToTorqueExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Torque GramForceCentimeters +#if NET7_0_OR_GREATER + => Torque.FromGramForceCentimeters(double.CreateChecked(value)); +#else + => Torque.FromGramForceCentimeters(value.ToDouble(null)); +#endif + + /// + public Torque GramForceMeters +#if NET7_0_OR_GREATER + => Torque.FromGramForceMeters(double.CreateChecked(value)); +#else + => Torque.FromGramForceMeters(value.ToDouble(null)); +#endif + + /// + public Torque GramForceMillimeters +#if NET7_0_OR_GREATER + => Torque.FromGramForceMillimeters(double.CreateChecked(value)); +#else + => Torque.FromGramForceMillimeters(value.ToDouble(null)); +#endif + + /// + public Torque KilogramForceCentimeters +#if NET7_0_OR_GREATER + => Torque.FromKilogramForceCentimeters(double.CreateChecked(value)); +#else + => Torque.FromKilogramForceCentimeters(value.ToDouble(null)); +#endif + + /// + public Torque KilogramForceMeters +#if NET7_0_OR_GREATER + => Torque.FromKilogramForceMeters(double.CreateChecked(value)); +#else + => Torque.FromKilogramForceMeters(value.ToDouble(null)); +#endif + + /// + public Torque KilogramForceMillimeters +#if NET7_0_OR_GREATER + => Torque.FromKilogramForceMillimeters(double.CreateChecked(value)); +#else + => Torque.FromKilogramForceMillimeters(value.ToDouble(null)); +#endif + + /// + public Torque KilonewtonCentimeters +#if NET7_0_OR_GREATER + => Torque.FromKilonewtonCentimeters(double.CreateChecked(value)); +#else + => Torque.FromKilonewtonCentimeters(value.ToDouble(null)); +#endif + + /// + public Torque KilonewtonMeters +#if NET7_0_OR_GREATER + => Torque.FromKilonewtonMeters(double.CreateChecked(value)); +#else + => Torque.FromKilonewtonMeters(value.ToDouble(null)); +#endif + + /// + public Torque KilonewtonMillimeters +#if NET7_0_OR_GREATER + => Torque.FromKilonewtonMillimeters(double.CreateChecked(value)); +#else + => Torque.FromKilonewtonMillimeters(value.ToDouble(null)); +#endif + + /// + public Torque KilopoundForceFeet +#if NET7_0_OR_GREATER + => Torque.FromKilopoundForceFeet(double.CreateChecked(value)); +#else + => Torque.FromKilopoundForceFeet(value.ToDouble(null)); +#endif + + /// + public Torque KilopoundForceInches +#if NET7_0_OR_GREATER + => Torque.FromKilopoundForceInches(double.CreateChecked(value)); +#else + => Torque.FromKilopoundForceInches(value.ToDouble(null)); +#endif + + /// + public Torque MeganewtonCentimeters +#if NET7_0_OR_GREATER + => Torque.FromMeganewtonCentimeters(double.CreateChecked(value)); +#else + => Torque.FromMeganewtonCentimeters(value.ToDouble(null)); +#endif + + /// + public Torque MeganewtonMeters +#if NET7_0_OR_GREATER + => Torque.FromMeganewtonMeters(double.CreateChecked(value)); +#else + => Torque.FromMeganewtonMeters(value.ToDouble(null)); +#endif + + /// + public Torque MeganewtonMillimeters +#if NET7_0_OR_GREATER + => Torque.FromMeganewtonMillimeters(double.CreateChecked(value)); +#else + => Torque.FromMeganewtonMillimeters(value.ToDouble(null)); +#endif + + /// + public Torque MegapoundForceFeet +#if NET7_0_OR_GREATER + => Torque.FromMegapoundForceFeet(double.CreateChecked(value)); +#else + => Torque.FromMegapoundForceFeet(value.ToDouble(null)); +#endif + + /// + public Torque MegapoundForceInches +#if NET7_0_OR_GREATER + => Torque.FromMegapoundForceInches(double.CreateChecked(value)); +#else + => Torque.FromMegapoundForceInches(value.ToDouble(null)); +#endif + + /// + public Torque NewtonCentimeters +#if NET7_0_OR_GREATER + => Torque.FromNewtonCentimeters(double.CreateChecked(value)); +#else + => Torque.FromNewtonCentimeters(value.ToDouble(null)); +#endif + + /// + public Torque NewtonMeters +#if NET7_0_OR_GREATER + => Torque.FromNewtonMeters(double.CreateChecked(value)); +#else + => Torque.FromNewtonMeters(value.ToDouble(null)); +#endif + + /// + public Torque NewtonMillimeters +#if NET7_0_OR_GREATER + => Torque.FromNewtonMillimeters(double.CreateChecked(value)); +#else + => Torque.FromNewtonMillimeters(value.ToDouble(null)); +#endif + + /// + public Torque PoundalFeet +#if NET7_0_OR_GREATER + => Torque.FromPoundalFeet(double.CreateChecked(value)); +#else + => Torque.FromPoundalFeet(value.ToDouble(null)); +#endif + + /// + public Torque PoundForceFeet +#if NET7_0_OR_GREATER + => Torque.FromPoundForceFeet(double.CreateChecked(value)); +#else + => Torque.FromPoundForceFeet(value.ToDouble(null)); +#endif + + /// + public Torque PoundForceInches +#if NET7_0_OR_GREATER + => Torque.FromPoundForceInches(double.CreateChecked(value)); +#else + => Torque.FromPoundForceInches(value.ToDouble(null)); +#endif + + /// + public Torque TonneForceCentimeters +#if NET7_0_OR_GREATER + => Torque.FromTonneForceCentimeters(double.CreateChecked(value)); +#else + => Torque.FromTonneForceCentimeters(value.ToDouble(null)); +#endif + + /// + public Torque TonneForceMeters +#if NET7_0_OR_GREATER + => Torque.FromTonneForceMeters(double.CreateChecked(value)); +#else + => Torque.FromTonneForceMeters(value.ToDouble(null)); +#endif + + /// + public Torque TonneForceMillimeters +#if NET7_0_OR_GREATER + => Torque.FromTonneForceMillimeters(double.CreateChecked(value)); +#else + => Torque.FromTonneForceMillimeters(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTurbidityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTurbidityExtensions.g.cs new file mode 100644 index 0000000000..2baa5b9556 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToTurbidityExtensions.g.cs @@ -0,0 +1,55 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToTurbidity +{ + /// + /// A number to Turbidity Extensions + /// + public static class NumberToTurbidityExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Turbidity NTU +#if NET7_0_OR_GREATER + => Turbidity.FromNTU(double.CreateChecked(value)); +#else + => Turbidity.FromNTU(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVitaminAExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVitaminAExtensions.g.cs new file mode 100644 index 0000000000..680e4b5632 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVitaminAExtensions.g.cs @@ -0,0 +1,55 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToVitaminA +{ + /// + /// A number to VitaminA Extensions + /// + public static class NumberToVitaminAExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public VitaminA InternationalUnits +#if NET7_0_OR_GREATER + => VitaminA.FromInternationalUnits(double.CreateChecked(value)); +#else + => VitaminA.FromInternationalUnits(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumeConcentrationExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumeConcentrationExtensions.g.cs new file mode 100644 index 0000000000..cf0bb7207c --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumeConcentrationExtensions.g.cs @@ -0,0 +1,207 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToVolumeConcentration +{ + /// + /// A number to VolumeConcentration Extensions + /// + public static class NumberToVolumeConcentrationExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public VolumeConcentration CentilitersPerLiter +#if NET7_0_OR_GREATER + => VolumeConcentration.FromCentilitersPerLiter(double.CreateChecked(value)); +#else + => VolumeConcentration.FromCentilitersPerLiter(value.ToDouble(null)); +#endif + + /// + public VolumeConcentration CentilitersPerMilliliter +#if NET7_0_OR_GREATER + => VolumeConcentration.FromCentilitersPerMilliliter(double.CreateChecked(value)); +#else + => VolumeConcentration.FromCentilitersPerMilliliter(value.ToDouble(null)); +#endif + + /// + public VolumeConcentration DecilitersPerLiter +#if NET7_0_OR_GREATER + => VolumeConcentration.FromDecilitersPerLiter(double.CreateChecked(value)); +#else + => VolumeConcentration.FromDecilitersPerLiter(value.ToDouble(null)); +#endif + + /// + public VolumeConcentration DecilitersPerMilliliter +#if NET7_0_OR_GREATER + => VolumeConcentration.FromDecilitersPerMilliliter(double.CreateChecked(value)); +#else + => VolumeConcentration.FromDecilitersPerMilliliter(value.ToDouble(null)); +#endif + + /// + public VolumeConcentration DecimalFractions +#if NET7_0_OR_GREATER + => VolumeConcentration.FromDecimalFractions(double.CreateChecked(value)); +#else + => VolumeConcentration.FromDecimalFractions(value.ToDouble(null)); +#endif + + /// + public VolumeConcentration LitersPerLiter +#if NET7_0_OR_GREATER + => VolumeConcentration.FromLitersPerLiter(double.CreateChecked(value)); +#else + => VolumeConcentration.FromLitersPerLiter(value.ToDouble(null)); +#endif + + /// + public VolumeConcentration LitersPerMilliliter +#if NET7_0_OR_GREATER + => VolumeConcentration.FromLitersPerMilliliter(double.CreateChecked(value)); +#else + => VolumeConcentration.FromLitersPerMilliliter(value.ToDouble(null)); +#endif + + /// + public VolumeConcentration MicrolitersPerLiter +#if NET7_0_OR_GREATER + => VolumeConcentration.FromMicrolitersPerLiter(double.CreateChecked(value)); +#else + => VolumeConcentration.FromMicrolitersPerLiter(value.ToDouble(null)); +#endif + + /// + public VolumeConcentration MicrolitersPerMilliliter +#if NET7_0_OR_GREATER + => VolumeConcentration.FromMicrolitersPerMilliliter(double.CreateChecked(value)); +#else + => VolumeConcentration.FromMicrolitersPerMilliliter(value.ToDouble(null)); +#endif + + /// + public VolumeConcentration MillilitersPerLiter +#if NET7_0_OR_GREATER + => VolumeConcentration.FromMillilitersPerLiter(double.CreateChecked(value)); +#else + => VolumeConcentration.FromMillilitersPerLiter(value.ToDouble(null)); +#endif + + /// + public VolumeConcentration MillilitersPerMilliliter +#if NET7_0_OR_GREATER + => VolumeConcentration.FromMillilitersPerMilliliter(double.CreateChecked(value)); +#else + => VolumeConcentration.FromMillilitersPerMilliliter(value.ToDouble(null)); +#endif + + /// + public VolumeConcentration NanolitersPerLiter +#if NET7_0_OR_GREATER + => VolumeConcentration.FromNanolitersPerLiter(double.CreateChecked(value)); +#else + => VolumeConcentration.FromNanolitersPerLiter(value.ToDouble(null)); +#endif + + /// + public VolumeConcentration NanolitersPerMilliliter +#if NET7_0_OR_GREATER + => VolumeConcentration.FromNanolitersPerMilliliter(double.CreateChecked(value)); +#else + => VolumeConcentration.FromNanolitersPerMilliliter(value.ToDouble(null)); +#endif + + /// + public VolumeConcentration PartsPerBillion +#if NET7_0_OR_GREATER + => VolumeConcentration.FromPartsPerBillion(double.CreateChecked(value)); +#else + => VolumeConcentration.FromPartsPerBillion(value.ToDouble(null)); +#endif + + /// + public VolumeConcentration PartsPerMillion +#if NET7_0_OR_GREATER + => VolumeConcentration.FromPartsPerMillion(double.CreateChecked(value)); +#else + => VolumeConcentration.FromPartsPerMillion(value.ToDouble(null)); +#endif + + /// + public VolumeConcentration PartsPerThousand +#if NET7_0_OR_GREATER + => VolumeConcentration.FromPartsPerThousand(double.CreateChecked(value)); +#else + => VolumeConcentration.FromPartsPerThousand(value.ToDouble(null)); +#endif + + /// + public VolumeConcentration PartsPerTrillion +#if NET7_0_OR_GREATER + => VolumeConcentration.FromPartsPerTrillion(double.CreateChecked(value)); +#else + => VolumeConcentration.FromPartsPerTrillion(value.ToDouble(null)); +#endif + + /// + public VolumeConcentration Percent +#if NET7_0_OR_GREATER + => VolumeConcentration.FromPercent(double.CreateChecked(value)); +#else + => VolumeConcentration.FromPercent(value.ToDouble(null)); +#endif + + /// + public VolumeConcentration PicolitersPerLiter +#if NET7_0_OR_GREATER + => VolumeConcentration.FromPicolitersPerLiter(double.CreateChecked(value)); +#else + => VolumeConcentration.FromPicolitersPerLiter(value.ToDouble(null)); +#endif + + /// + public VolumeConcentration PicolitersPerMilliliter +#if NET7_0_OR_GREATER + => VolumeConcentration.FromPicolitersPerMilliliter(double.CreateChecked(value)); +#else + => VolumeConcentration.FromPicolitersPerMilliliter(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumeExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumeExtensions.g.cs new file mode 100644 index 0000000000..4d20b2f1a6 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumeExtensions.g.cs @@ -0,0 +1,487 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToVolume +{ + /// + /// A number to Volume Extensions + /// + public static class NumberToVolumeExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public Volume AcreFeet +#if NET7_0_OR_GREATER + => Volume.FromAcreFeet(double.CreateChecked(value)); +#else + => Volume.FromAcreFeet(value.ToDouble(null)); +#endif + + /// + public Volume AuTablespoons +#if NET7_0_OR_GREATER + => Volume.FromAuTablespoons(double.CreateChecked(value)); +#else + => Volume.FromAuTablespoons(value.ToDouble(null)); +#endif + + /// + public Volume BoardFeet +#if NET7_0_OR_GREATER + => Volume.FromBoardFeet(double.CreateChecked(value)); +#else + => Volume.FromBoardFeet(value.ToDouble(null)); +#endif + + /// + public Volume Centiliters +#if NET7_0_OR_GREATER + => Volume.FromCentiliters(double.CreateChecked(value)); +#else + => Volume.FromCentiliters(value.ToDouble(null)); +#endif + + /// + public Volume CubicCentimeters +#if NET7_0_OR_GREATER + => Volume.FromCubicCentimeters(double.CreateChecked(value)); +#else + => Volume.FromCubicCentimeters(value.ToDouble(null)); +#endif + + /// + public Volume CubicDecimeters +#if NET7_0_OR_GREATER + => Volume.FromCubicDecimeters(double.CreateChecked(value)); +#else + => Volume.FromCubicDecimeters(value.ToDouble(null)); +#endif + + /// + public Volume CubicFeet +#if NET7_0_OR_GREATER + => Volume.FromCubicFeet(double.CreateChecked(value)); +#else + => Volume.FromCubicFeet(value.ToDouble(null)); +#endif + + /// + public Volume CubicHectometers +#if NET7_0_OR_GREATER + => Volume.FromCubicHectometers(double.CreateChecked(value)); +#else + => Volume.FromCubicHectometers(value.ToDouble(null)); +#endif + + /// + public Volume CubicInches +#if NET7_0_OR_GREATER + => Volume.FromCubicInches(double.CreateChecked(value)); +#else + => Volume.FromCubicInches(value.ToDouble(null)); +#endif + + /// + public Volume CubicKilometers +#if NET7_0_OR_GREATER + => Volume.FromCubicKilometers(double.CreateChecked(value)); +#else + => Volume.FromCubicKilometers(value.ToDouble(null)); +#endif + + /// + public Volume CubicMeters +#if NET7_0_OR_GREATER + => Volume.FromCubicMeters(double.CreateChecked(value)); +#else + => Volume.FromCubicMeters(value.ToDouble(null)); +#endif + + /// + public Volume CubicMicrometers +#if NET7_0_OR_GREATER + => Volume.FromCubicMicrometers(double.CreateChecked(value)); +#else + => Volume.FromCubicMicrometers(value.ToDouble(null)); +#endif + + /// + public Volume CubicMiles +#if NET7_0_OR_GREATER + => Volume.FromCubicMiles(double.CreateChecked(value)); +#else + => Volume.FromCubicMiles(value.ToDouble(null)); +#endif + + /// + public Volume CubicMillimeters +#if NET7_0_OR_GREATER + => Volume.FromCubicMillimeters(double.CreateChecked(value)); +#else + => Volume.FromCubicMillimeters(value.ToDouble(null)); +#endif + + /// + public Volume CubicYards +#if NET7_0_OR_GREATER + => Volume.FromCubicYards(double.CreateChecked(value)); +#else + => Volume.FromCubicYards(value.ToDouble(null)); +#endif + + /// + public Volume Decaliters +#if NET7_0_OR_GREATER + => Volume.FromDecaliters(double.CreateChecked(value)); +#else + => Volume.FromDecaliters(value.ToDouble(null)); +#endif + + /// + public Volume DecausGallons +#if NET7_0_OR_GREATER + => Volume.FromDecausGallons(double.CreateChecked(value)); +#else + => Volume.FromDecausGallons(value.ToDouble(null)); +#endif + + /// + public Volume Deciliters +#if NET7_0_OR_GREATER + => Volume.FromDeciliters(double.CreateChecked(value)); +#else + => Volume.FromDeciliters(value.ToDouble(null)); +#endif + + /// + public Volume DeciusGallons +#if NET7_0_OR_GREATER + => Volume.FromDeciusGallons(double.CreateChecked(value)); +#else + => Volume.FromDeciusGallons(value.ToDouble(null)); +#endif + + /// + public Volume HectocubicFeet +#if NET7_0_OR_GREATER + => Volume.FromHectocubicFeet(double.CreateChecked(value)); +#else + => Volume.FromHectocubicFeet(value.ToDouble(null)); +#endif + + /// + public Volume HectocubicMeters +#if NET7_0_OR_GREATER + => Volume.FromHectocubicMeters(double.CreateChecked(value)); +#else + => Volume.FromHectocubicMeters(value.ToDouble(null)); +#endif + + /// + public Volume Hectoliters +#if NET7_0_OR_GREATER + => Volume.FromHectoliters(double.CreateChecked(value)); +#else + => Volume.FromHectoliters(value.ToDouble(null)); +#endif + + /// + public Volume HectousGallons +#if NET7_0_OR_GREATER + => Volume.FromHectousGallons(double.CreateChecked(value)); +#else + => Volume.FromHectousGallons(value.ToDouble(null)); +#endif + + /// + public Volume ImperialBeerBarrels +#if NET7_0_OR_GREATER + => Volume.FromImperialBeerBarrels(double.CreateChecked(value)); +#else + => Volume.FromImperialBeerBarrels(value.ToDouble(null)); +#endif + + /// + public Volume ImperialGallons +#if NET7_0_OR_GREATER + => Volume.FromImperialGallons(double.CreateChecked(value)); +#else + => Volume.FromImperialGallons(value.ToDouble(null)); +#endif + + /// + public Volume ImperialOunces +#if NET7_0_OR_GREATER + => Volume.FromImperialOunces(double.CreateChecked(value)); +#else + => Volume.FromImperialOunces(value.ToDouble(null)); +#endif + + /// + public Volume ImperialPints +#if NET7_0_OR_GREATER + => Volume.FromImperialPints(double.CreateChecked(value)); +#else + => Volume.FromImperialPints(value.ToDouble(null)); +#endif + + /// + public Volume ImperialQuarts +#if NET7_0_OR_GREATER + => Volume.FromImperialQuarts(double.CreateChecked(value)); +#else + => Volume.FromImperialQuarts(value.ToDouble(null)); +#endif + + /// + public Volume KilocubicFeet +#if NET7_0_OR_GREATER + => Volume.FromKilocubicFeet(double.CreateChecked(value)); +#else + => Volume.FromKilocubicFeet(value.ToDouble(null)); +#endif + + /// + public Volume KilocubicMeters +#if NET7_0_OR_GREATER + => Volume.FromKilocubicMeters(double.CreateChecked(value)); +#else + => Volume.FromKilocubicMeters(value.ToDouble(null)); +#endif + + /// + public Volume KiloimperialGallons +#if NET7_0_OR_GREATER + => Volume.FromKiloimperialGallons(double.CreateChecked(value)); +#else + => Volume.FromKiloimperialGallons(value.ToDouble(null)); +#endif + + /// + public Volume Kiloliters +#if NET7_0_OR_GREATER + => Volume.FromKiloliters(double.CreateChecked(value)); +#else + => Volume.FromKiloliters(value.ToDouble(null)); +#endif + + /// + public Volume KilousGallons +#if NET7_0_OR_GREATER + => Volume.FromKilousGallons(double.CreateChecked(value)); +#else + => Volume.FromKilousGallons(value.ToDouble(null)); +#endif + + /// + public Volume Liters +#if NET7_0_OR_GREATER + => Volume.FromLiters(double.CreateChecked(value)); +#else + => Volume.FromLiters(value.ToDouble(null)); +#endif + + /// + public Volume MegacubicFeet +#if NET7_0_OR_GREATER + => Volume.FromMegacubicFeet(double.CreateChecked(value)); +#else + => Volume.FromMegacubicFeet(value.ToDouble(null)); +#endif + + /// + public Volume MegaimperialGallons +#if NET7_0_OR_GREATER + => Volume.FromMegaimperialGallons(double.CreateChecked(value)); +#else + => Volume.FromMegaimperialGallons(value.ToDouble(null)); +#endif + + /// + public Volume Megaliters +#if NET7_0_OR_GREATER + => Volume.FromMegaliters(double.CreateChecked(value)); +#else + => Volume.FromMegaliters(value.ToDouble(null)); +#endif + + /// + public Volume MegausGallons +#if NET7_0_OR_GREATER + => Volume.FromMegausGallons(double.CreateChecked(value)); +#else + => Volume.FromMegausGallons(value.ToDouble(null)); +#endif + + /// + public Volume MetricCups +#if NET7_0_OR_GREATER + => Volume.FromMetricCups(double.CreateChecked(value)); +#else + => Volume.FromMetricCups(value.ToDouble(null)); +#endif + + /// + public Volume MetricTablespoons +#if NET7_0_OR_GREATER + => Volume.FromMetricTablespoons(double.CreateChecked(value)); +#else + => Volume.FromMetricTablespoons(value.ToDouble(null)); +#endif + + /// + public Volume MetricTeaspoons +#if NET7_0_OR_GREATER + => Volume.FromMetricTeaspoons(double.CreateChecked(value)); +#else + => Volume.FromMetricTeaspoons(value.ToDouble(null)); +#endif + + /// + public Volume Microliters +#if NET7_0_OR_GREATER + => Volume.FromMicroliters(double.CreateChecked(value)); +#else + => Volume.FromMicroliters(value.ToDouble(null)); +#endif + + /// + public Volume Milliliters +#if NET7_0_OR_GREATER + => Volume.FromMilliliters(double.CreateChecked(value)); +#else + => Volume.FromMilliliters(value.ToDouble(null)); +#endif + + /// + public Volume Nanoliters +#if NET7_0_OR_GREATER + => Volume.FromNanoliters(double.CreateChecked(value)); +#else + => Volume.FromNanoliters(value.ToDouble(null)); +#endif + + /// + public Volume OilBarrels +#if NET7_0_OR_GREATER + => Volume.FromOilBarrels(double.CreateChecked(value)); +#else + => Volume.FromOilBarrels(value.ToDouble(null)); +#endif + + /// + public Volume UkTablespoons +#if NET7_0_OR_GREATER + => Volume.FromUkTablespoons(double.CreateChecked(value)); +#else + => Volume.FromUkTablespoons(value.ToDouble(null)); +#endif + + /// + public Volume UsBeerBarrels +#if NET7_0_OR_GREATER + => Volume.FromUsBeerBarrels(double.CreateChecked(value)); +#else + => Volume.FromUsBeerBarrels(value.ToDouble(null)); +#endif + + /// + public Volume UsCustomaryCups +#if NET7_0_OR_GREATER + => Volume.FromUsCustomaryCups(double.CreateChecked(value)); +#else + => Volume.FromUsCustomaryCups(value.ToDouble(null)); +#endif + + /// + public Volume UsGallons +#if NET7_0_OR_GREATER + => Volume.FromUsGallons(double.CreateChecked(value)); +#else + => Volume.FromUsGallons(value.ToDouble(null)); +#endif + + /// + public Volume UsLegalCups +#if NET7_0_OR_GREATER + => Volume.FromUsLegalCups(double.CreateChecked(value)); +#else + => Volume.FromUsLegalCups(value.ToDouble(null)); +#endif + + /// + public Volume UsOunces +#if NET7_0_OR_GREATER + => Volume.FromUsOunces(double.CreateChecked(value)); +#else + => Volume.FromUsOunces(value.ToDouble(null)); +#endif + + /// + public Volume UsPints +#if NET7_0_OR_GREATER + => Volume.FromUsPints(double.CreateChecked(value)); +#else + => Volume.FromUsPints(value.ToDouble(null)); +#endif + + /// + public Volume UsQuarts +#if NET7_0_OR_GREATER + => Volume.FromUsQuarts(double.CreateChecked(value)); +#else + => Volume.FromUsQuarts(value.ToDouble(null)); +#endif + + /// + public Volume UsTablespoons +#if NET7_0_OR_GREATER + => Volume.FromUsTablespoons(double.CreateChecked(value)); +#else + => Volume.FromUsTablespoons(value.ToDouble(null)); +#endif + + /// + public Volume UsTeaspoons +#if NET7_0_OR_GREATER + => Volume.FromUsTeaspoons(double.CreateChecked(value)); +#else + => Volume.FromUsTeaspoons(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumeFlowExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumeFlowExtensions.g.cs new file mode 100644 index 0000000000..50dc5ee625 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumeFlowExtensions.g.cs @@ -0,0 +1,647 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToVolumeFlow +{ + /// + /// A number to VolumeFlow Extensions + /// + public static class NumberToVolumeFlowExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public VolumeFlow AcreFeetPerDay +#if NET7_0_OR_GREATER + => VolumeFlow.FromAcreFeetPerDay(double.CreateChecked(value)); +#else + => VolumeFlow.FromAcreFeetPerDay(value.ToDouble(null)); +#endif + + /// + public VolumeFlow AcreFeetPerHour +#if NET7_0_OR_GREATER + => VolumeFlow.FromAcreFeetPerHour(double.CreateChecked(value)); +#else + => VolumeFlow.FromAcreFeetPerHour(value.ToDouble(null)); +#endif + + /// + public VolumeFlow AcreFeetPerMinute +#if NET7_0_OR_GREATER + => VolumeFlow.FromAcreFeetPerMinute(double.CreateChecked(value)); +#else + => VolumeFlow.FromAcreFeetPerMinute(value.ToDouble(null)); +#endif + + /// + public VolumeFlow AcreFeetPerSecond +#if NET7_0_OR_GREATER + => VolumeFlow.FromAcreFeetPerSecond(double.CreateChecked(value)); +#else + => VolumeFlow.FromAcreFeetPerSecond(value.ToDouble(null)); +#endif + + /// + public VolumeFlow CentilitersPerDay +#if NET7_0_OR_GREATER + => VolumeFlow.FromCentilitersPerDay(double.CreateChecked(value)); +#else + => VolumeFlow.FromCentilitersPerDay(value.ToDouble(null)); +#endif + + /// + public VolumeFlow CentilitersPerHour +#if NET7_0_OR_GREATER + => VolumeFlow.FromCentilitersPerHour(double.CreateChecked(value)); +#else + => VolumeFlow.FromCentilitersPerHour(value.ToDouble(null)); +#endif + + /// + public VolumeFlow CentilitersPerMinute +#if NET7_0_OR_GREATER + => VolumeFlow.FromCentilitersPerMinute(double.CreateChecked(value)); +#else + => VolumeFlow.FromCentilitersPerMinute(value.ToDouble(null)); +#endif + + /// + public VolumeFlow CentilitersPerSecond +#if NET7_0_OR_GREATER + => VolumeFlow.FromCentilitersPerSecond(double.CreateChecked(value)); +#else + => VolumeFlow.FromCentilitersPerSecond(value.ToDouble(null)); +#endif + + /// + public VolumeFlow CubicCentimetersPerMinute +#if NET7_0_OR_GREATER + => VolumeFlow.FromCubicCentimetersPerMinute(double.CreateChecked(value)); +#else + => VolumeFlow.FromCubicCentimetersPerMinute(value.ToDouble(null)); +#endif + + /// + public VolumeFlow CubicDecimetersPerMinute +#if NET7_0_OR_GREATER + => VolumeFlow.FromCubicDecimetersPerMinute(double.CreateChecked(value)); +#else + => VolumeFlow.FromCubicDecimetersPerMinute(value.ToDouble(null)); +#endif + + /// + public VolumeFlow CubicFeetPerHour +#if NET7_0_OR_GREATER + => VolumeFlow.FromCubicFeetPerHour(double.CreateChecked(value)); +#else + => VolumeFlow.FromCubicFeetPerHour(value.ToDouble(null)); +#endif + + /// + public VolumeFlow CubicFeetPerMinute +#if NET7_0_OR_GREATER + => VolumeFlow.FromCubicFeetPerMinute(double.CreateChecked(value)); +#else + => VolumeFlow.FromCubicFeetPerMinute(value.ToDouble(null)); +#endif + + /// + public VolumeFlow CubicFeetPerSecond +#if NET7_0_OR_GREATER + => VolumeFlow.FromCubicFeetPerSecond(double.CreateChecked(value)); +#else + => VolumeFlow.FromCubicFeetPerSecond(value.ToDouble(null)); +#endif + + /// + public VolumeFlow CubicMetersPerDay +#if NET7_0_OR_GREATER + => VolumeFlow.FromCubicMetersPerDay(double.CreateChecked(value)); +#else + => VolumeFlow.FromCubicMetersPerDay(value.ToDouble(null)); +#endif + + /// + public VolumeFlow CubicMetersPerHour +#if NET7_0_OR_GREATER + => VolumeFlow.FromCubicMetersPerHour(double.CreateChecked(value)); +#else + => VolumeFlow.FromCubicMetersPerHour(value.ToDouble(null)); +#endif + + /// + public VolumeFlow CubicMetersPerMinute +#if NET7_0_OR_GREATER + => VolumeFlow.FromCubicMetersPerMinute(double.CreateChecked(value)); +#else + => VolumeFlow.FromCubicMetersPerMinute(value.ToDouble(null)); +#endif + + /// + public VolumeFlow CubicMetersPerSecond +#if NET7_0_OR_GREATER + => VolumeFlow.FromCubicMetersPerSecond(double.CreateChecked(value)); +#else + => VolumeFlow.FromCubicMetersPerSecond(value.ToDouble(null)); +#endif + + /// + public VolumeFlow CubicMillimetersPerSecond +#if NET7_0_OR_GREATER + => VolumeFlow.FromCubicMillimetersPerSecond(double.CreateChecked(value)); +#else + => VolumeFlow.FromCubicMillimetersPerSecond(value.ToDouble(null)); +#endif + + /// + public VolumeFlow CubicYardsPerDay +#if NET7_0_OR_GREATER + => VolumeFlow.FromCubicYardsPerDay(double.CreateChecked(value)); +#else + => VolumeFlow.FromCubicYardsPerDay(value.ToDouble(null)); +#endif + + /// + public VolumeFlow CubicYardsPerHour +#if NET7_0_OR_GREATER + => VolumeFlow.FromCubicYardsPerHour(double.CreateChecked(value)); +#else + => VolumeFlow.FromCubicYardsPerHour(value.ToDouble(null)); +#endif + + /// + public VolumeFlow CubicYardsPerMinute +#if NET7_0_OR_GREATER + => VolumeFlow.FromCubicYardsPerMinute(double.CreateChecked(value)); +#else + => VolumeFlow.FromCubicYardsPerMinute(value.ToDouble(null)); +#endif + + /// + public VolumeFlow CubicYardsPerSecond +#if NET7_0_OR_GREATER + => VolumeFlow.FromCubicYardsPerSecond(double.CreateChecked(value)); +#else + => VolumeFlow.FromCubicYardsPerSecond(value.ToDouble(null)); +#endif + + /// + public VolumeFlow DecalitersPerDay +#if NET7_0_OR_GREATER + => VolumeFlow.FromDecalitersPerDay(double.CreateChecked(value)); +#else + => VolumeFlow.FromDecalitersPerDay(value.ToDouble(null)); +#endif + + /// + public VolumeFlow DecalitersPerHour +#if NET7_0_OR_GREATER + => VolumeFlow.FromDecalitersPerHour(double.CreateChecked(value)); +#else + => VolumeFlow.FromDecalitersPerHour(value.ToDouble(null)); +#endif + + /// + public VolumeFlow DecalitersPerMinute +#if NET7_0_OR_GREATER + => VolumeFlow.FromDecalitersPerMinute(double.CreateChecked(value)); +#else + => VolumeFlow.FromDecalitersPerMinute(value.ToDouble(null)); +#endif + + /// + public VolumeFlow DecalitersPerSecond +#if NET7_0_OR_GREATER + => VolumeFlow.FromDecalitersPerSecond(double.CreateChecked(value)); +#else + => VolumeFlow.FromDecalitersPerSecond(value.ToDouble(null)); +#endif + + /// + public VolumeFlow DecilitersPerDay +#if NET7_0_OR_GREATER + => VolumeFlow.FromDecilitersPerDay(double.CreateChecked(value)); +#else + => VolumeFlow.FromDecilitersPerDay(value.ToDouble(null)); +#endif + + /// + public VolumeFlow DecilitersPerHour +#if NET7_0_OR_GREATER + => VolumeFlow.FromDecilitersPerHour(double.CreateChecked(value)); +#else + => VolumeFlow.FromDecilitersPerHour(value.ToDouble(null)); +#endif + + /// + public VolumeFlow DecilitersPerMinute +#if NET7_0_OR_GREATER + => VolumeFlow.FromDecilitersPerMinute(double.CreateChecked(value)); +#else + => VolumeFlow.FromDecilitersPerMinute(value.ToDouble(null)); +#endif + + /// + public VolumeFlow DecilitersPerSecond +#if NET7_0_OR_GREATER + => VolumeFlow.FromDecilitersPerSecond(double.CreateChecked(value)); +#else + => VolumeFlow.FromDecilitersPerSecond(value.ToDouble(null)); +#endif + + /// + public VolumeFlow HectolitersPerDay +#if NET7_0_OR_GREATER + => VolumeFlow.FromHectolitersPerDay(double.CreateChecked(value)); +#else + => VolumeFlow.FromHectolitersPerDay(value.ToDouble(null)); +#endif + + /// + public VolumeFlow HectolitersPerHour +#if NET7_0_OR_GREATER + => VolumeFlow.FromHectolitersPerHour(double.CreateChecked(value)); +#else + => VolumeFlow.FromHectolitersPerHour(value.ToDouble(null)); +#endif + + /// + public VolumeFlow HectolitersPerMinute +#if NET7_0_OR_GREATER + => VolumeFlow.FromHectolitersPerMinute(double.CreateChecked(value)); +#else + => VolumeFlow.FromHectolitersPerMinute(value.ToDouble(null)); +#endif + + /// + public VolumeFlow HectolitersPerSecond +#if NET7_0_OR_GREATER + => VolumeFlow.FromHectolitersPerSecond(double.CreateChecked(value)); +#else + => VolumeFlow.FromHectolitersPerSecond(value.ToDouble(null)); +#endif + + /// + public VolumeFlow KilolitersPerDay +#if NET7_0_OR_GREATER + => VolumeFlow.FromKilolitersPerDay(double.CreateChecked(value)); +#else + => VolumeFlow.FromKilolitersPerDay(value.ToDouble(null)); +#endif + + /// + public VolumeFlow KilolitersPerHour +#if NET7_0_OR_GREATER + => VolumeFlow.FromKilolitersPerHour(double.CreateChecked(value)); +#else + => VolumeFlow.FromKilolitersPerHour(value.ToDouble(null)); +#endif + + /// + public VolumeFlow KilolitersPerMinute +#if NET7_0_OR_GREATER + => VolumeFlow.FromKilolitersPerMinute(double.CreateChecked(value)); +#else + => VolumeFlow.FromKilolitersPerMinute(value.ToDouble(null)); +#endif + + /// + public VolumeFlow KilolitersPerSecond +#if NET7_0_OR_GREATER + => VolumeFlow.FromKilolitersPerSecond(double.CreateChecked(value)); +#else + => VolumeFlow.FromKilolitersPerSecond(value.ToDouble(null)); +#endif + + /// + public VolumeFlow KilousGallonsPerMinute +#if NET7_0_OR_GREATER + => VolumeFlow.FromKilousGallonsPerMinute(double.CreateChecked(value)); +#else + => VolumeFlow.FromKilousGallonsPerMinute(value.ToDouble(null)); +#endif + + /// + public VolumeFlow LitersPerDay +#if NET7_0_OR_GREATER + => VolumeFlow.FromLitersPerDay(double.CreateChecked(value)); +#else + => VolumeFlow.FromLitersPerDay(value.ToDouble(null)); +#endif + + /// + public VolumeFlow LitersPerHour +#if NET7_0_OR_GREATER + => VolumeFlow.FromLitersPerHour(double.CreateChecked(value)); +#else + => VolumeFlow.FromLitersPerHour(value.ToDouble(null)); +#endif + + /// + public VolumeFlow LitersPerMinute +#if NET7_0_OR_GREATER + => VolumeFlow.FromLitersPerMinute(double.CreateChecked(value)); +#else + => VolumeFlow.FromLitersPerMinute(value.ToDouble(null)); +#endif + + /// + public VolumeFlow LitersPerSecond +#if NET7_0_OR_GREATER + => VolumeFlow.FromLitersPerSecond(double.CreateChecked(value)); +#else + => VolumeFlow.FromLitersPerSecond(value.ToDouble(null)); +#endif + + /// + public VolumeFlow MegalitersPerDay +#if NET7_0_OR_GREATER + => VolumeFlow.FromMegalitersPerDay(double.CreateChecked(value)); +#else + => VolumeFlow.FromMegalitersPerDay(value.ToDouble(null)); +#endif + + /// + public VolumeFlow MegalitersPerHour +#if NET7_0_OR_GREATER + => VolumeFlow.FromMegalitersPerHour(double.CreateChecked(value)); +#else + => VolumeFlow.FromMegalitersPerHour(value.ToDouble(null)); +#endif + + /// + public VolumeFlow MegalitersPerMinute +#if NET7_0_OR_GREATER + => VolumeFlow.FromMegalitersPerMinute(double.CreateChecked(value)); +#else + => VolumeFlow.FromMegalitersPerMinute(value.ToDouble(null)); +#endif + + /// + public VolumeFlow MegalitersPerSecond +#if NET7_0_OR_GREATER + => VolumeFlow.FromMegalitersPerSecond(double.CreateChecked(value)); +#else + => VolumeFlow.FromMegalitersPerSecond(value.ToDouble(null)); +#endif + + /// + public VolumeFlow MegaukGallonsPerDay +#if NET7_0_OR_GREATER + => VolumeFlow.FromMegaukGallonsPerDay(double.CreateChecked(value)); +#else + => VolumeFlow.FromMegaukGallonsPerDay(value.ToDouble(null)); +#endif + + /// + public VolumeFlow MegaukGallonsPerSecond +#if NET7_0_OR_GREATER + => VolumeFlow.FromMegaukGallonsPerSecond(double.CreateChecked(value)); +#else + => VolumeFlow.FromMegaukGallonsPerSecond(value.ToDouble(null)); +#endif + + /// + public VolumeFlow MegausGallonsPerDay +#if NET7_0_OR_GREATER + => VolumeFlow.FromMegausGallonsPerDay(double.CreateChecked(value)); +#else + => VolumeFlow.FromMegausGallonsPerDay(value.ToDouble(null)); +#endif + + /// + public VolumeFlow MicrolitersPerDay +#if NET7_0_OR_GREATER + => VolumeFlow.FromMicrolitersPerDay(double.CreateChecked(value)); +#else + => VolumeFlow.FromMicrolitersPerDay(value.ToDouble(null)); +#endif + + /// + public VolumeFlow MicrolitersPerHour +#if NET7_0_OR_GREATER + => VolumeFlow.FromMicrolitersPerHour(double.CreateChecked(value)); +#else + => VolumeFlow.FromMicrolitersPerHour(value.ToDouble(null)); +#endif + + /// + public VolumeFlow MicrolitersPerMinute +#if NET7_0_OR_GREATER + => VolumeFlow.FromMicrolitersPerMinute(double.CreateChecked(value)); +#else + => VolumeFlow.FromMicrolitersPerMinute(value.ToDouble(null)); +#endif + + /// + public VolumeFlow MicrolitersPerSecond +#if NET7_0_OR_GREATER + => VolumeFlow.FromMicrolitersPerSecond(double.CreateChecked(value)); +#else + => VolumeFlow.FromMicrolitersPerSecond(value.ToDouble(null)); +#endif + + /// + public VolumeFlow MillilitersPerDay +#if NET7_0_OR_GREATER + => VolumeFlow.FromMillilitersPerDay(double.CreateChecked(value)); +#else + => VolumeFlow.FromMillilitersPerDay(value.ToDouble(null)); +#endif + + /// + public VolumeFlow MillilitersPerHour +#if NET7_0_OR_GREATER + => VolumeFlow.FromMillilitersPerHour(double.CreateChecked(value)); +#else + => VolumeFlow.FromMillilitersPerHour(value.ToDouble(null)); +#endif + + /// + public VolumeFlow MillilitersPerMinute +#if NET7_0_OR_GREATER + => VolumeFlow.FromMillilitersPerMinute(double.CreateChecked(value)); +#else + => VolumeFlow.FromMillilitersPerMinute(value.ToDouble(null)); +#endif + + /// + public VolumeFlow MillilitersPerSecond +#if NET7_0_OR_GREATER + => VolumeFlow.FromMillilitersPerSecond(double.CreateChecked(value)); +#else + => VolumeFlow.FromMillilitersPerSecond(value.ToDouble(null)); +#endif + + /// + public VolumeFlow MillionUsGallonsPerDay +#if NET7_0_OR_GREATER + => VolumeFlow.FromMillionUsGallonsPerDay(double.CreateChecked(value)); +#else + => VolumeFlow.FromMillionUsGallonsPerDay(value.ToDouble(null)); +#endif + + /// + public VolumeFlow NanolitersPerDay +#if NET7_0_OR_GREATER + => VolumeFlow.FromNanolitersPerDay(double.CreateChecked(value)); +#else + => VolumeFlow.FromNanolitersPerDay(value.ToDouble(null)); +#endif + + /// + public VolumeFlow NanolitersPerHour +#if NET7_0_OR_GREATER + => VolumeFlow.FromNanolitersPerHour(double.CreateChecked(value)); +#else + => VolumeFlow.FromNanolitersPerHour(value.ToDouble(null)); +#endif + + /// + public VolumeFlow NanolitersPerMinute +#if NET7_0_OR_GREATER + => VolumeFlow.FromNanolitersPerMinute(double.CreateChecked(value)); +#else + => VolumeFlow.FromNanolitersPerMinute(value.ToDouble(null)); +#endif + + /// + public VolumeFlow NanolitersPerSecond +#if NET7_0_OR_GREATER + => VolumeFlow.FromNanolitersPerSecond(double.CreateChecked(value)); +#else + => VolumeFlow.FromNanolitersPerSecond(value.ToDouble(null)); +#endif + + /// + public VolumeFlow OilBarrelsPerDay +#if NET7_0_OR_GREATER + => VolumeFlow.FromOilBarrelsPerDay(double.CreateChecked(value)); +#else + => VolumeFlow.FromOilBarrelsPerDay(value.ToDouble(null)); +#endif + + /// + public VolumeFlow OilBarrelsPerHour +#if NET7_0_OR_GREATER + => VolumeFlow.FromOilBarrelsPerHour(double.CreateChecked(value)); +#else + => VolumeFlow.FromOilBarrelsPerHour(value.ToDouble(null)); +#endif + + /// + public VolumeFlow OilBarrelsPerMinute +#if NET7_0_OR_GREATER + => VolumeFlow.FromOilBarrelsPerMinute(double.CreateChecked(value)); +#else + => VolumeFlow.FromOilBarrelsPerMinute(value.ToDouble(null)); +#endif + + /// + public VolumeFlow OilBarrelsPerSecond +#if NET7_0_OR_GREATER + => VolumeFlow.FromOilBarrelsPerSecond(double.CreateChecked(value)); +#else + => VolumeFlow.FromOilBarrelsPerSecond(value.ToDouble(null)); +#endif + + /// + public VolumeFlow UkGallonsPerDay +#if NET7_0_OR_GREATER + => VolumeFlow.FromUkGallonsPerDay(double.CreateChecked(value)); +#else + => VolumeFlow.FromUkGallonsPerDay(value.ToDouble(null)); +#endif + + /// + public VolumeFlow UkGallonsPerHour +#if NET7_0_OR_GREATER + => VolumeFlow.FromUkGallonsPerHour(double.CreateChecked(value)); +#else + => VolumeFlow.FromUkGallonsPerHour(value.ToDouble(null)); +#endif + + /// + public VolumeFlow UkGallonsPerMinute +#if NET7_0_OR_GREATER + => VolumeFlow.FromUkGallonsPerMinute(double.CreateChecked(value)); +#else + => VolumeFlow.FromUkGallonsPerMinute(value.ToDouble(null)); +#endif + + /// + public VolumeFlow UkGallonsPerSecond +#if NET7_0_OR_GREATER + => VolumeFlow.FromUkGallonsPerSecond(double.CreateChecked(value)); +#else + => VolumeFlow.FromUkGallonsPerSecond(value.ToDouble(null)); +#endif + + /// + public VolumeFlow UsGallonsPerDay +#if NET7_0_OR_GREATER + => VolumeFlow.FromUsGallonsPerDay(double.CreateChecked(value)); +#else + => VolumeFlow.FromUsGallonsPerDay(value.ToDouble(null)); +#endif + + /// + public VolumeFlow UsGallonsPerHour +#if NET7_0_OR_GREATER + => VolumeFlow.FromUsGallonsPerHour(double.CreateChecked(value)); +#else + => VolumeFlow.FromUsGallonsPerHour(value.ToDouble(null)); +#endif + + /// + public VolumeFlow UsGallonsPerMinute +#if NET7_0_OR_GREATER + => VolumeFlow.FromUsGallonsPerMinute(double.CreateChecked(value)); +#else + => VolumeFlow.FromUsGallonsPerMinute(value.ToDouble(null)); +#endif + + /// + public VolumeFlow UsGallonsPerSecond +#if NET7_0_OR_GREATER + => VolumeFlow.FromUsGallonsPerSecond(double.CreateChecked(value)); +#else + => VolumeFlow.FromUsGallonsPerSecond(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumeFlowPerAreaExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumeFlowPerAreaExtensions.g.cs new file mode 100644 index 0000000000..eed8f9a6f6 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumeFlowPerAreaExtensions.g.cs @@ -0,0 +1,63 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToVolumeFlowPerArea +{ + /// + /// A number to VolumeFlowPerArea Extensions + /// + public static class NumberToVolumeFlowPerAreaExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public VolumeFlowPerArea CubicFeetPerMinutePerSquareFoot +#if NET7_0_OR_GREATER + => VolumeFlowPerArea.FromCubicFeetPerMinutePerSquareFoot(double.CreateChecked(value)); +#else + => VolumeFlowPerArea.FromCubicFeetPerMinutePerSquareFoot(value.ToDouble(null)); +#endif + + /// + public VolumeFlowPerArea CubicMetersPerSecondPerSquareMeter +#if NET7_0_OR_GREATER + => VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(double.CreateChecked(value)); +#else + => VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumePerLengthExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumePerLengthExtensions.g.cs new file mode 100644 index 0000000000..d8a6ffed9e --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumePerLengthExtensions.g.cs @@ -0,0 +1,119 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToVolumePerLength +{ + /// + /// A number to VolumePerLength Extensions + /// + public static class NumberToVolumePerLengthExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public VolumePerLength CubicMetersPerMeter +#if NET7_0_OR_GREATER + => VolumePerLength.FromCubicMetersPerMeter(double.CreateChecked(value)); +#else + => VolumePerLength.FromCubicMetersPerMeter(value.ToDouble(null)); +#endif + + /// + public VolumePerLength CubicYardsPerFoot +#if NET7_0_OR_GREATER + => VolumePerLength.FromCubicYardsPerFoot(double.CreateChecked(value)); +#else + => VolumePerLength.FromCubicYardsPerFoot(value.ToDouble(null)); +#endif + + /// + public VolumePerLength CubicYardsPerUsSurveyFoot +#if NET7_0_OR_GREATER + => VolumePerLength.FromCubicYardsPerUsSurveyFoot(double.CreateChecked(value)); +#else + => VolumePerLength.FromCubicYardsPerUsSurveyFoot(value.ToDouble(null)); +#endif + + /// + public VolumePerLength ImperialGallonsPerMile +#if NET7_0_OR_GREATER + => VolumePerLength.FromImperialGallonsPerMile(double.CreateChecked(value)); +#else + => VolumePerLength.FromImperialGallonsPerMile(value.ToDouble(null)); +#endif + + /// + public VolumePerLength LitersPerKilometer +#if NET7_0_OR_GREATER + => VolumePerLength.FromLitersPerKilometer(double.CreateChecked(value)); +#else + => VolumePerLength.FromLitersPerKilometer(value.ToDouble(null)); +#endif + + /// + public VolumePerLength LitersPerMeter +#if NET7_0_OR_GREATER + => VolumePerLength.FromLitersPerMeter(double.CreateChecked(value)); +#else + => VolumePerLength.FromLitersPerMeter(value.ToDouble(null)); +#endif + + /// + public VolumePerLength LitersPerMillimeter +#if NET7_0_OR_GREATER + => VolumePerLength.FromLitersPerMillimeter(double.CreateChecked(value)); +#else + => VolumePerLength.FromLitersPerMillimeter(value.ToDouble(null)); +#endif + + /// + public VolumePerLength OilBarrelsPerFoot +#if NET7_0_OR_GREATER + => VolumePerLength.FromOilBarrelsPerFoot(double.CreateChecked(value)); +#else + => VolumePerLength.FromOilBarrelsPerFoot(value.ToDouble(null)); +#endif + + /// + public VolumePerLength UsGallonsPerMile +#if NET7_0_OR_GREATER + => VolumePerLength.FromUsGallonsPerMile(double.CreateChecked(value)); +#else + => VolumePerLength.FromUsGallonsPerMile(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumetricHeatCapacityExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumetricHeatCapacityExtensions.g.cs new file mode 100644 index 0000000000..9d52803c04 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToVolumetricHeatCapacityExtensions.g.cs @@ -0,0 +1,119 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToVolumetricHeatCapacity +{ + /// + /// A number to VolumetricHeatCapacity Extensions + /// + public static class NumberToVolumetricHeatCapacityExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public VolumetricHeatCapacity BtusPerCubicFootDegreeFahrenheit +#if NET7_0_OR_GREATER + => VolumetricHeatCapacity.FromBtusPerCubicFootDegreeFahrenheit(double.CreateChecked(value)); +#else + => VolumetricHeatCapacity.FromBtusPerCubicFootDegreeFahrenheit(value.ToDouble(null)); +#endif + + /// + public VolumetricHeatCapacity CaloriesPerCubicCentimeterDegreeCelsius +#if NET7_0_OR_GREATER + => VolumetricHeatCapacity.FromCaloriesPerCubicCentimeterDegreeCelsius(double.CreateChecked(value)); +#else + => VolumetricHeatCapacity.FromCaloriesPerCubicCentimeterDegreeCelsius(value.ToDouble(null)); +#endif + + /// + public VolumetricHeatCapacity JoulesPerCubicMeterDegreeCelsius +#if NET7_0_OR_GREATER + => VolumetricHeatCapacity.FromJoulesPerCubicMeterDegreeCelsius(double.CreateChecked(value)); +#else + => VolumetricHeatCapacity.FromJoulesPerCubicMeterDegreeCelsius(value.ToDouble(null)); +#endif + + /// + public VolumetricHeatCapacity JoulesPerCubicMeterKelvin +#if NET7_0_OR_GREATER + => VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(double.CreateChecked(value)); +#else + => VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(value.ToDouble(null)); +#endif + + /// + public VolumetricHeatCapacity KilocaloriesPerCubicCentimeterDegreeCelsius +#if NET7_0_OR_GREATER + => VolumetricHeatCapacity.FromKilocaloriesPerCubicCentimeterDegreeCelsius(double.CreateChecked(value)); +#else + => VolumetricHeatCapacity.FromKilocaloriesPerCubicCentimeterDegreeCelsius(value.ToDouble(null)); +#endif + + /// + public VolumetricHeatCapacity KilojoulesPerCubicMeterDegreeCelsius +#if NET7_0_OR_GREATER + => VolumetricHeatCapacity.FromKilojoulesPerCubicMeterDegreeCelsius(double.CreateChecked(value)); +#else + => VolumetricHeatCapacity.FromKilojoulesPerCubicMeterDegreeCelsius(value.ToDouble(null)); +#endif + + /// + public VolumetricHeatCapacity KilojoulesPerCubicMeterKelvin +#if NET7_0_OR_GREATER + => VolumetricHeatCapacity.FromKilojoulesPerCubicMeterKelvin(double.CreateChecked(value)); +#else + => VolumetricHeatCapacity.FromKilojoulesPerCubicMeterKelvin(value.ToDouble(null)); +#endif + + /// + public VolumetricHeatCapacity MegajoulesPerCubicMeterDegreeCelsius +#if NET7_0_OR_GREATER + => VolumetricHeatCapacity.FromMegajoulesPerCubicMeterDegreeCelsius(double.CreateChecked(value)); +#else + => VolumetricHeatCapacity.FromMegajoulesPerCubicMeterDegreeCelsius(value.ToDouble(null)); +#endif + + /// + public VolumetricHeatCapacity MegajoulesPerCubicMeterKelvin +#if NET7_0_OR_GREATER + => VolumetricHeatCapacity.FromMegajoulesPerCubicMeterKelvin(double.CreateChecked(value)); +#else + => VolumetricHeatCapacity.FromMegajoulesPerCubicMeterKelvin(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToWarpingMomentOfInertiaExtensions.g.cs b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToWarpingMomentOfInertiaExtensions.g.cs new file mode 100644 index 0000000000..46da4dd527 --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/GeneratedCode/NumberToWarpingMomentOfInertiaExtensions.g.cs @@ -0,0 +1,95 @@ +//------------------------------------------------------------------------------ +// +// 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; + +#if NET7_0_OR_GREATER +using System.Numerics; +#endif + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToWarpingMomentOfInertia +{ + /// + /// A number to WarpingMomentOfInertia Extensions + /// + public static class NumberToWarpingMomentOfInertiaExtensions + { +#pragma warning disable CS1591 + extension(T value) +#pragma warning restore CS1591 + where T : notnull +#if NET7_0_OR_GREATER + , INumber +#else + , IConvertible +#endif + { + /// + public WarpingMomentOfInertia CentimetersToTheSixth +#if NET7_0_OR_GREATER + => WarpingMomentOfInertia.FromCentimetersToTheSixth(double.CreateChecked(value)); +#else + => WarpingMomentOfInertia.FromCentimetersToTheSixth(value.ToDouble(null)); +#endif + + /// + public WarpingMomentOfInertia DecimetersToTheSixth +#if NET7_0_OR_GREATER + => WarpingMomentOfInertia.FromDecimetersToTheSixth(double.CreateChecked(value)); +#else + => WarpingMomentOfInertia.FromDecimetersToTheSixth(value.ToDouble(null)); +#endif + + /// + public WarpingMomentOfInertia FeetToTheSixth +#if NET7_0_OR_GREATER + => WarpingMomentOfInertia.FromFeetToTheSixth(double.CreateChecked(value)); +#else + => WarpingMomentOfInertia.FromFeetToTheSixth(value.ToDouble(null)); +#endif + + /// + public WarpingMomentOfInertia InchesToTheSixth +#if NET7_0_OR_GREATER + => WarpingMomentOfInertia.FromInchesToTheSixth(double.CreateChecked(value)); +#else + => WarpingMomentOfInertia.FromInchesToTheSixth(value.ToDouble(null)); +#endif + + /// + public WarpingMomentOfInertia MetersToTheSixth +#if NET7_0_OR_GREATER + => WarpingMomentOfInertia.FromMetersToTheSixth(double.CreateChecked(value)); +#else + => WarpingMomentOfInertia.FromMetersToTheSixth(value.ToDouble(null)); +#endif + + /// + public WarpingMomentOfInertia MillimetersToTheSixth +#if NET7_0_OR_GREATER + => WarpingMomentOfInertia.FromMillimetersToTheSixth(double.CreateChecked(value)); +#else + => WarpingMomentOfInertia.FromMillimetersToTheSixth(value.ToDouble(null)); +#endif + + } + } +} diff --git a/UnitsNet.NumberExtensions.CS14/UnitsNet.NumberExtensions.CS14.csproj b/UnitsNet.NumberExtensions.CS14/UnitsNet.NumberExtensions.CS14.csproj new file mode 100644 index 0000000000..6e27fedaff --- /dev/null +++ b/UnitsNet.NumberExtensions.CS14/UnitsNet.NumberExtensions.CS14.csproj @@ -0,0 +1,59 @@ + + + + UnitsNet.NumberExtensions.CS14 + 6.0.0-pre017 + Andreas Gullberg Larsen, Lu Li, Jon Suda + Units.NET NumberExtensions for C# 14 + C# 14 extension members for number types to create quantities using the new syntax, such as 5.Meters instead of Length.FromMeters(5). Requires C# 14 preview. + Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). + true + https://github.com/angularsen/UnitsNet + logo-32.png + https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png + https://github.com/angularsen/UnitsNet + MIT-0 + false + UnitsNet Extensions NumberToExtensions NumberToUnitsExtensions NumberExtensions NumberToUnits convert conversion parse + + + + + + $([System.Text.RegularExpressions.Regex]::Match($(Version), '^[0-9.]+')).0 + 6.0.0.0 + $(VersionNoSuffix) + preview + enable + UnitsNet + netstandard2.0;net8.0;net9.0 + + + false + + + + + + + + + + ../UnitsNet.snk + false + true + + + + + + + + + + + + + diff --git a/UnitsNet.slnx b/UnitsNet.slnx index 25055fc949..954149d514 100644 --- a/UnitsNet.slnx +++ b/UnitsNet.slnx @@ -46,10 +46,12 @@ + + - + \ No newline at end of file diff --git a/azure-pipelines-pr.yml b/azure-pipelines-pr.yml index 67ce4db2b0..e3c0ad742c 100644 --- a/azure-pipelines-pr.yml +++ b/azure-pipelines-pr.yml @@ -37,6 +37,28 @@ stages: submodules: false fetchTags: false + - task: UseDotNet@2 + displayName: 'Install .NET 8 SDK' + inputs: + packageType: 'sdk' + version: '8.x' + + - task: UseDotNet@2 + displayName: 'Install .NET 9 SDK' + inputs: + packageType: 'sdk' + version: '9.x' + + - task: UseDotNet@2 + displayName: 'Install .NET 10 SDK Preview (for C# 14)' + inputs: + packageType: 'sdk' + version: '10.x' + includePreviewVersions: true + + - task: InstallNanoMSBuildComponents@1 + displayName: Install .NET nanoFramework MSBuild components + - task: PowerShell@2 displayName: 'Build, test, pack' inputs: diff --git a/azure-pipelines.yml b/azure-pipelines.yml index d6be13461c..567befc561 100644 --- a/azure-pipelines.yml +++ b/azure-pipelines.yml @@ -30,6 +30,25 @@ stages: submodules: false fetchTags: false + - task: UseDotNet@2 + displayName: 'Install .NET 8 SDK' + inputs: + packageType: 'sdk' + version: '8.x' + + - task: UseDotNet@2 + displayName: 'Install .NET 9 SDK' + inputs: + packageType: 'sdk' + version: '9.x' + + - task: UseDotNet@2 + displayName: 'Install .NET 10 SDK Preview (for C# 14)' + inputs: + packageType: 'sdk' + version: '10.x' + includePreviewVersions: true + - task: InstallNanoMSBuildComponents@1 displayName: Install .NET nanoFramework MSBuild components diff --git a/global.json b/global.json new file mode 100644 index 0000000000..b2ff2b6822 --- /dev/null +++ b/global.json @@ -0,0 +1,7 @@ +{ + "sdk": { + "version": "9.0.0", + "allowPrerelease": true, + "rollForward": "latestMajor" + } +} \ No newline at end of file