diff --git a/Common/UnitDefinitions/LinearPowerDensity.json b/Common/UnitDefinitions/LinearPowerDensity.json new file mode 100644 index 0000000000..6e11a3640b --- /dev/null +++ b/Common/UnitDefinitions/LinearPowerDensity.json @@ -0,0 +1,78 @@ +{ + "Name": "LinearPowerDensity", + "BaseUnit": "WattPerMeter", + "XmlDoc": "The Linear Power Density of a substance is its power per unit length. The term linear density is most often used when describing the characteristics of one-dimensional objects, although linear density can also be used to describe the density of a three-dimensional quantity along one particular dimension.", + "XmlDocRemarks": "http://en.wikipedia.org/wiki/Linear_density", + "BaseDimensions": { + "M": 1, + "L": 1, + "T": -3 + }, + "Units": [ + { + "SingularName": "WattPerMeter", + "PluralName": "WattsPerMeter", + "FromUnitToBaseFunc": "x", + "FromBaseToUnitFunc": "x", + "Prefixes": [ "Milli", "Kilo", "Mega", "Giga" ], + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "W/m" ] + } + ] + }, + { + "SingularName": "WattPerCentimeter", + "PluralName": "WattsPerCentimeter", + "FromUnitToBaseFunc": "x*1e2", + "FromBaseToUnitFunc": "x/1e2", + "Prefixes": [ "Milli", "Kilo", "Mega", "Giga" ], + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "W/cm" ] + } + ] + }, + { + "SingularName": "WattPerMillimeter", + "PluralName": "WattsPerMillimeter", + "FromUnitToBaseFunc": "x*1e3", + "FromBaseToUnitFunc": "x/1e3", + "Prefixes": [ "Milli", "Kilo", "Mega", "Giga" ], + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "W/mm" ] + } + ] + }, + { + "SingularName": "WattPerInch", + "PluralName": "WattsPerInch", + "FromUnitToBaseFunc": "x*39.37007874", + "FromBaseToUnitFunc": "x/39.37007874", + "Prefixes": [ "Milli", "Kilo", "Mega", "Giga" ], + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "W/in" ] + } + ] + }, + { + "SingularName": "WattPerFoot", + "PluralName": "WattsPerFoot", + "FromUnitToBaseFunc": "x*3.280839895", + "FromBaseToUnitFunc": "x/3.280839895", + "Prefixes": [ "Milli", "Kilo", "Mega", "Giga" ], + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "W/ft" ] + } + ] + } + ] +} \ No newline at end of file diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLinearPowerDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLinearPowerDensityExtensionsTest.g.cs new file mode 100644 index 0000000000..deb623e4dd --- /dev/null +++ b/UnitsNet.NumberExtensions.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/GeneratedCode/NumberToLinearPowerDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearPowerDensityExtensions.g.cs new file mode 100644 index 0000000000..a41a12af63 --- /dev/null +++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearPowerDensityExtensions.g.cs @@ -0,0 +1,130 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by \generate-code.bat. +// +// Changes to this file will be lost when the code is regenerated. +// The build server regenerates the code before each build and a pre-build +// step will regenerate the code on each local build. +// +// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units. +// +// Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities. +// Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities. +// +// +//------------------------------------------------------------------------------ + +// Licensed under MIT No Attribution, see LICENSE file at the root. +// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet. + +using System; + +namespace UnitsNet.NumberExtensions.NumberToLinearPowerDensity +{ + /// + /// A number to LinearPowerDensity Extensions + /// + public static class NumberToLinearPowerDensityExtensions + { + /// + public static LinearPowerDensity GigawattsPerCentimeter(this T value) => + LinearPowerDensity.FromGigawattsPerCentimeter(Convert.ToDouble(value)); + + /// + public static LinearPowerDensity GigawattsPerFoot(this T value) => + LinearPowerDensity.FromGigawattsPerFoot(Convert.ToDouble(value)); + + /// + public static LinearPowerDensity GigawattsPerInch(this T value) => + LinearPowerDensity.FromGigawattsPerInch(Convert.ToDouble(value)); + + /// + public static LinearPowerDensity GigawattsPerMeter(this T value) => + LinearPowerDensity.FromGigawattsPerMeter(Convert.ToDouble(value)); + + /// + public static LinearPowerDensity GigawattsPerMillimeter(this T value) => + LinearPowerDensity.FromGigawattsPerMillimeter(Convert.ToDouble(value)); + + /// + public static LinearPowerDensity KilowattsPerCentimeter(this T value) => + LinearPowerDensity.FromKilowattsPerCentimeter(Convert.ToDouble(value)); + + /// + public static LinearPowerDensity KilowattsPerFoot(this T value) => + LinearPowerDensity.FromKilowattsPerFoot(Convert.ToDouble(value)); + + /// + public static LinearPowerDensity KilowattsPerInch(this T value) => + LinearPowerDensity.FromKilowattsPerInch(Convert.ToDouble(value)); + + /// + public static LinearPowerDensity KilowattsPerMeter(this T value) => + LinearPowerDensity.FromKilowattsPerMeter(Convert.ToDouble(value)); + + /// + public static LinearPowerDensity KilowattsPerMillimeter(this T value) => + LinearPowerDensity.FromKilowattsPerMillimeter(Convert.ToDouble(value)); + + /// + public static LinearPowerDensity MegawattsPerCentimeter(this T value) => + LinearPowerDensity.FromMegawattsPerCentimeter(Convert.ToDouble(value)); + + /// + public static LinearPowerDensity MegawattsPerFoot(this T value) => + LinearPowerDensity.FromMegawattsPerFoot(Convert.ToDouble(value)); + + /// + public static LinearPowerDensity MegawattsPerInch(this T value) => + LinearPowerDensity.FromMegawattsPerInch(Convert.ToDouble(value)); + + /// + public static LinearPowerDensity MegawattsPerMeter(this T value) => + LinearPowerDensity.FromMegawattsPerMeter(Convert.ToDouble(value)); + + /// + public static LinearPowerDensity MegawattsPerMillimeter(this T value) => + LinearPowerDensity.FromMegawattsPerMillimeter(Convert.ToDouble(value)); + + /// + public static LinearPowerDensity MilliwattsPerCentimeter(this T value) => + LinearPowerDensity.FromMilliwattsPerCentimeter(Convert.ToDouble(value)); + + /// + public static LinearPowerDensity MilliwattsPerFoot(this T value) => + LinearPowerDensity.FromMilliwattsPerFoot(Convert.ToDouble(value)); + + /// + public static LinearPowerDensity MilliwattsPerInch(this T value) => + LinearPowerDensity.FromMilliwattsPerInch(Convert.ToDouble(value)); + + /// + public static LinearPowerDensity MilliwattsPerMeter(this T value) => + LinearPowerDensity.FromMilliwattsPerMeter(Convert.ToDouble(value)); + + /// + public static LinearPowerDensity MilliwattsPerMillimeter(this T value) => + LinearPowerDensity.FromMilliwattsPerMillimeter(Convert.ToDouble(value)); + + /// + public static LinearPowerDensity WattsPerCentimeter(this T value) => + LinearPowerDensity.FromWattsPerCentimeter(Convert.ToDouble(value)); + + /// + public static LinearPowerDensity WattsPerFoot(this T value) => + LinearPowerDensity.FromWattsPerFoot(Convert.ToDouble(value)); + + /// + public static LinearPowerDensity WattsPerInch(this T value) => + LinearPowerDensity.FromWattsPerInch(Convert.ToDouble(value)); + + /// + public static LinearPowerDensity WattsPerMeter(this T value) => + LinearPowerDensity.FromWattsPerMeter(Convert.ToDouble(value)); + + /// + public static LinearPowerDensity WattsPerMillimeter(this T value) => + LinearPowerDensity.FromWattsPerMillimeter(Convert.ToDouble(value)); + + } +} diff --git a/UnitsNet.Tests/CustomCode/LinearPowerDensityTests.cs b/UnitsNet.Tests/CustomCode/LinearPowerDensityTests.cs new file mode 100644 index 0000000000..c45766cbfa --- /dev/null +++ b/UnitsNet.Tests/CustomCode/LinearPowerDensityTests.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 System; + +namespace UnitsNet.Tests.CustomCode +{ + public class LinearPowerDensityTests : LinearPowerDensityTestsBase + { + protected override double GigawattsPerCentimeterInOneWattPerMeter => 1e-11; + protected override double GigawattsPerFootInOneWattPerMeter => 3.0480e-10; + protected override double GigawattsPerInchInOneWattPerMeter => 2.5400e-11; + protected override double GigawattsPerMeterInOneWattPerMeter => 1e-9; + protected override double GigawattsPerMillimeterInOneWattPerMeter => 1e-12; + + protected override double MegawattsPerCentimeterInOneWattPerMeter => 1e-8; + protected override double MegawattsPerFootInOneWattPerMeter => 3.0480e-7; + protected override double MegawattsPerInchInOneWattPerMeter => 2.5400e-8; + protected override double MegawattsPerMeterInOneWattPerMeter => 1e-6; + protected override double MegawattsPerMillimeterInOneWattPerMeter => 1e-9; + + protected override double KilowattsPerCentimeterInOneWattPerMeter => 1e-5; + protected override double KilowattsPerFootInOneWattPerMeter => 3.0480e-4; + protected override double KilowattsPerInchInOneWattPerMeter => 2.5400e-5; + protected override double KilowattsPerMeterInOneWattPerMeter => 1e-3; + protected override double KilowattsPerMillimeterInOneWattPerMeter => 1e-6; + + protected override double WattsPerCentimeterInOneWattPerMeter => 1e-2; + protected override double WattsPerFootInOneWattPerMeter => 3.0480e-1; + protected override double WattsPerInchInOneWattPerMeter => 2.5400e-2; + protected override double WattsPerMeterInOneWattPerMeter => 1; + protected override double WattsPerMillimeterInOneWattPerMeter => 1e-3; + + protected override double MilliwattsPerCentimeterInOneWattPerMeter => 1e1; + protected override double MilliwattsPerFootInOneWattPerMeter => 3.0480e2; + protected override double MilliwattsPerInchInOneWattPerMeter => 2.5400e1; + protected override double MilliwattsPerMeterInOneWattPerMeter => 1e3; + protected override double MilliwattsPerMillimeterInOneWattPerMeter => 1; + } +} diff --git a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs index 9d58a715be..2944626e9b 100644 --- a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs +++ b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs @@ -85,6 +85,7 @@ void Assertion(int expectedValue, Enum expectedUnit, IQuantity quantity) Assertion(3, LengthUnit.Yard, Quantity.From(3, LengthUnit.Yard)); Assertion(3, LevelUnit.Neper, Quantity.From(3, LevelUnit.Neper)); Assertion(3, LinearDensityUnit.PoundPerInch, Quantity.From(3, LinearDensityUnit.PoundPerInch)); + Assertion(3, LinearPowerDensityUnit.WattPerMillimeter, Quantity.From(3, LinearPowerDensityUnit.WattPerMillimeter)); Assertion(3, LuminosityUnit.Watt, Quantity.From(3, LuminosityUnit.Watt)); Assertion(3, LuminousFluxUnit.Lumen, Quantity.From(3, LuminousFluxUnit.Lumen)); Assertion(3, LuminousIntensityUnit.Candela, Quantity.From(3, LuminousIntensityUnit.Candela)); @@ -192,6 +193,7 @@ public void QuantityInfo_IsSameAsStaticInfoProperty() Assertion(Length.Info, Length.Zero); Assertion(Level.Info, Level.Zero); Assertion(LinearDensity.Info, LinearDensity.Zero); + Assertion(LinearPowerDensity.Info, LinearPowerDensity.Zero); Assertion(Luminosity.Info, Luminosity.Zero); Assertion(LuminousFlux.Info, LuminousFlux.Zero); Assertion(LuminousIntensity.Info, LuminousIntensity.Zero); @@ -299,6 +301,7 @@ public void Type_EqualsStaticQuantityTypeProperty() Assertion(Length.QuantityType, Length.Zero); Assertion(Level.QuantityType, Level.Zero); Assertion(LinearDensity.QuantityType, LinearDensity.Zero); + Assertion(LinearPowerDensity.QuantityType, LinearPowerDensity.Zero); Assertion(Luminosity.QuantityType, Luminosity.Zero); Assertion(LuminousFlux.QuantityType, LuminousFlux.Zero); Assertion(LuminousIntensity.QuantityType, LuminousIntensity.Zero); @@ -406,6 +409,7 @@ public void Dimensions_IsSameAsStaticBaseDimensions() Assertion(Length.BaseDimensions, Length.Zero); Assertion(Level.BaseDimensions, Level.Zero); Assertion(LinearDensity.BaseDimensions, LinearDensity.Zero); + Assertion(LinearPowerDensity.BaseDimensions, LinearPowerDensity.Zero); Assertion(Luminosity.BaseDimensions, Luminosity.Zero); Assertion(LuminousFlux.BaseDimensions, LuminousFlux.Zero); Assertion(LuminousIntensity.BaseDimensions, LuminousIntensity.Zero); diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/LinearPowerDensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/LinearPowerDensityTestsBase.g.cs new file mode 100644 index 0000000000..dd54935429 --- /dev/null +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/LinearPowerDensityTestsBase.g.cs @@ -0,0 +1,695 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by \generate-code.bat. +// +// Changes to this file will be lost when the code is regenerated. +// The build server regenerates the code before each build and a pre-build +// step will regenerate the code on each local build. +// +// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units. +// +// Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities. +// Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities. +// +// +//------------------------------------------------------------------------------ + +// Licensed under MIT No Attribution, see LICENSE file at the root. +// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet. + +using System; +using System.Globalization; +using System.Linq; +using System.Threading; +using UnitsNet.Units; +using Xunit; + +// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else? +#pragma warning disable 1718 + +// ReSharper disable once CheckNamespace +namespace UnitsNet.Tests +{ + /// + /// Test of LinearPowerDensity. + /// +// ReSharper disable once PartialTypeWithSinglePart + public abstract partial class LinearPowerDensityTestsBase + { + protected abstract double GigawattsPerCentimeterInOneWattPerMeter { get; } + protected abstract double GigawattsPerFootInOneWattPerMeter { get; } + protected abstract double GigawattsPerInchInOneWattPerMeter { get; } + protected abstract double GigawattsPerMeterInOneWattPerMeter { get; } + protected abstract double GigawattsPerMillimeterInOneWattPerMeter { get; } + protected abstract double KilowattsPerCentimeterInOneWattPerMeter { get; } + protected abstract double KilowattsPerFootInOneWattPerMeter { get; } + protected abstract double KilowattsPerInchInOneWattPerMeter { get; } + protected abstract double KilowattsPerMeterInOneWattPerMeter { get; } + protected abstract double KilowattsPerMillimeterInOneWattPerMeter { get; } + protected abstract double MegawattsPerCentimeterInOneWattPerMeter { get; } + protected abstract double MegawattsPerFootInOneWattPerMeter { get; } + protected abstract double MegawattsPerInchInOneWattPerMeter { get; } + protected abstract double MegawattsPerMeterInOneWattPerMeter { get; } + protected abstract double MegawattsPerMillimeterInOneWattPerMeter { get; } + protected abstract double MilliwattsPerCentimeterInOneWattPerMeter { get; } + protected abstract double MilliwattsPerFootInOneWattPerMeter { get; } + protected abstract double MilliwattsPerInchInOneWattPerMeter { get; } + protected abstract double MilliwattsPerMeterInOneWattPerMeter { get; } + protected abstract double MilliwattsPerMillimeterInOneWattPerMeter { get; } + protected abstract double WattsPerCentimeterInOneWattPerMeter { get; } + protected abstract double WattsPerFootInOneWattPerMeter { get; } + protected abstract double WattsPerInchInOneWattPerMeter { get; } + protected abstract double WattsPerMeterInOneWattPerMeter { get; } + protected abstract double WattsPerMillimeterInOneWattPerMeter { get; } + +// ReSharper disable VirtualMemberNeverOverriden.Global + protected virtual double GigawattsPerCentimeterTolerance { get { return 1e-5; } } + protected virtual double GigawattsPerFootTolerance { get { return 1e-5; } } + protected virtual double GigawattsPerInchTolerance { get { return 1e-5; } } + protected virtual double GigawattsPerMeterTolerance { get { return 1e-5; } } + protected virtual double GigawattsPerMillimeterTolerance { get { return 1e-5; } } + protected virtual double KilowattsPerCentimeterTolerance { get { return 1e-5; } } + protected virtual double KilowattsPerFootTolerance { get { return 1e-5; } } + protected virtual double KilowattsPerInchTolerance { get { return 1e-5; } } + protected virtual double KilowattsPerMeterTolerance { get { return 1e-5; } } + protected virtual double KilowattsPerMillimeterTolerance { get { return 1e-5; } } + protected virtual double MegawattsPerCentimeterTolerance { get { return 1e-5; } } + protected virtual double MegawattsPerFootTolerance { get { return 1e-5; } } + protected virtual double MegawattsPerInchTolerance { get { return 1e-5; } } + protected virtual double MegawattsPerMeterTolerance { get { return 1e-5; } } + protected virtual double MegawattsPerMillimeterTolerance { get { return 1e-5; } } + protected virtual double MilliwattsPerCentimeterTolerance { get { return 1e-5; } } + protected virtual double MilliwattsPerFootTolerance { get { return 1e-5; } } + protected virtual double MilliwattsPerInchTolerance { get { return 1e-5; } } + protected virtual double MilliwattsPerMeterTolerance { get { return 1e-5; } } + protected virtual double MilliwattsPerMillimeterTolerance { get { return 1e-5; } } + protected virtual double WattsPerCentimeterTolerance { get { return 1e-5; } } + protected virtual double WattsPerFootTolerance { get { return 1e-5; } } + protected virtual double WattsPerInchTolerance { get { return 1e-5; } } + protected virtual double WattsPerMeterTolerance { get { return 1e-5; } } + protected virtual double WattsPerMillimeterTolerance { get { return 1e-5; } } +// ReSharper restore VirtualMemberNeverOverriden.Global + + [Fact] + public void Ctor_WithUndefinedUnit_ThrowsArgumentException() + { + Assert.Throws(() => new LinearPowerDensity((double)0.0, LinearPowerDensityUnit.Undefined)); + } + + [Fact] + public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit() + { + var quantity = new LinearPowerDensity(); + Assert.Equal(0, quantity.Value); + Assert.Equal(LinearPowerDensityUnit.WattPerMeter, quantity.Unit); + } + + + [Fact] + public void Ctor_WithInfinityValue_ThrowsArgumentException() + { + Assert.Throws(() => new LinearPowerDensity(double.PositiveInfinity, LinearPowerDensityUnit.WattPerMeter)); + Assert.Throws(() => new LinearPowerDensity(double.NegativeInfinity, LinearPowerDensityUnit.WattPerMeter)); + } + + [Fact] + public void Ctor_WithNaNValue_ThrowsArgumentException() + { + Assert.Throws(() => new LinearPowerDensity(double.NaN, LinearPowerDensityUnit.WattPerMeter)); + } + + [Fact] + public void Ctor_NullAsUnitSystem_ThrowsArgumentNullException() + { + Assert.Throws(() => new LinearPowerDensity(value: 1.0, unitSystem: null)); + } + + [Fact] + public void LinearPowerDensity_QuantityInfo_ReturnsQuantityInfoDescribingQuantity() + { + var quantity = new LinearPowerDensity(1, LinearPowerDensityUnit.WattPerMeter); + + QuantityInfo quantityInfo = quantity.QuantityInfo; + + Assert.Equal(LinearPowerDensity.Zero, quantityInfo.Zero); + Assert.Equal("LinearPowerDensity", quantityInfo.Name); + Assert.Equal(QuantityType.LinearPowerDensity, quantityInfo.QuantityType); + + var units = EnumUtils.GetEnumValues().Except(new[] {LinearPowerDensityUnit.Undefined}).ToArray(); + var unitNames = units.Select(x => x.ToString()); + + // Obsolete members +#pragma warning disable 618 + Assert.Equal(units, quantityInfo.Units); + Assert.Equal(unitNames, quantityInfo.UnitNames); +#pragma warning restore 618 + } + + [Fact] + public void WattPerMeterToLinearPowerDensityUnits() + { + LinearPowerDensity wattpermeter = LinearPowerDensity.FromWattsPerMeter(1); + AssertEx.EqualTolerance(GigawattsPerCentimeterInOneWattPerMeter, wattpermeter.GigawattsPerCentimeter, GigawattsPerCentimeterTolerance); + AssertEx.EqualTolerance(GigawattsPerFootInOneWattPerMeter, wattpermeter.GigawattsPerFoot, GigawattsPerFootTolerance); + AssertEx.EqualTolerance(GigawattsPerInchInOneWattPerMeter, wattpermeter.GigawattsPerInch, GigawattsPerInchTolerance); + AssertEx.EqualTolerance(GigawattsPerMeterInOneWattPerMeter, wattpermeter.GigawattsPerMeter, GigawattsPerMeterTolerance); + AssertEx.EqualTolerance(GigawattsPerMillimeterInOneWattPerMeter, wattpermeter.GigawattsPerMillimeter, GigawattsPerMillimeterTolerance); + AssertEx.EqualTolerance(KilowattsPerCentimeterInOneWattPerMeter, wattpermeter.KilowattsPerCentimeter, KilowattsPerCentimeterTolerance); + AssertEx.EqualTolerance(KilowattsPerFootInOneWattPerMeter, wattpermeter.KilowattsPerFoot, KilowattsPerFootTolerance); + AssertEx.EqualTolerance(KilowattsPerInchInOneWattPerMeter, wattpermeter.KilowattsPerInch, KilowattsPerInchTolerance); + AssertEx.EqualTolerance(KilowattsPerMeterInOneWattPerMeter, wattpermeter.KilowattsPerMeter, KilowattsPerMeterTolerance); + AssertEx.EqualTolerance(KilowattsPerMillimeterInOneWattPerMeter, wattpermeter.KilowattsPerMillimeter, KilowattsPerMillimeterTolerance); + AssertEx.EqualTolerance(MegawattsPerCentimeterInOneWattPerMeter, wattpermeter.MegawattsPerCentimeter, MegawattsPerCentimeterTolerance); + AssertEx.EqualTolerance(MegawattsPerFootInOneWattPerMeter, wattpermeter.MegawattsPerFoot, MegawattsPerFootTolerance); + AssertEx.EqualTolerance(MegawattsPerInchInOneWattPerMeter, wattpermeter.MegawattsPerInch, MegawattsPerInchTolerance); + AssertEx.EqualTolerance(MegawattsPerMeterInOneWattPerMeter, wattpermeter.MegawattsPerMeter, MegawattsPerMeterTolerance); + AssertEx.EqualTolerance(MegawattsPerMillimeterInOneWattPerMeter, wattpermeter.MegawattsPerMillimeter, MegawattsPerMillimeterTolerance); + AssertEx.EqualTolerance(MilliwattsPerCentimeterInOneWattPerMeter, wattpermeter.MilliwattsPerCentimeter, MilliwattsPerCentimeterTolerance); + AssertEx.EqualTolerance(MilliwattsPerFootInOneWattPerMeter, wattpermeter.MilliwattsPerFoot, MilliwattsPerFootTolerance); + AssertEx.EqualTolerance(MilliwattsPerInchInOneWattPerMeter, wattpermeter.MilliwattsPerInch, MilliwattsPerInchTolerance); + AssertEx.EqualTolerance(MilliwattsPerMeterInOneWattPerMeter, wattpermeter.MilliwattsPerMeter, MilliwattsPerMeterTolerance); + AssertEx.EqualTolerance(MilliwattsPerMillimeterInOneWattPerMeter, wattpermeter.MilliwattsPerMillimeter, MilliwattsPerMillimeterTolerance); + AssertEx.EqualTolerance(WattsPerCentimeterInOneWattPerMeter, wattpermeter.WattsPerCentimeter, WattsPerCentimeterTolerance); + AssertEx.EqualTolerance(WattsPerFootInOneWattPerMeter, wattpermeter.WattsPerFoot, WattsPerFootTolerance); + AssertEx.EqualTolerance(WattsPerInchInOneWattPerMeter, wattpermeter.WattsPerInch, WattsPerInchTolerance); + AssertEx.EqualTolerance(WattsPerMeterInOneWattPerMeter, wattpermeter.WattsPerMeter, WattsPerMeterTolerance); + AssertEx.EqualTolerance(WattsPerMillimeterInOneWattPerMeter, wattpermeter.WattsPerMillimeter, WattsPerMillimeterTolerance); + } + + [Fact] + public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() + { + var quantity00 = LinearPowerDensity.From(1, LinearPowerDensityUnit.GigawattPerCentimeter); + AssertEx.EqualTolerance(1, quantity00.GigawattsPerCentimeter, GigawattsPerCentimeterTolerance); + Assert.Equal(LinearPowerDensityUnit.GigawattPerCentimeter, quantity00.Unit); + + var quantity01 = LinearPowerDensity.From(1, LinearPowerDensityUnit.GigawattPerFoot); + AssertEx.EqualTolerance(1, quantity01.GigawattsPerFoot, GigawattsPerFootTolerance); + Assert.Equal(LinearPowerDensityUnit.GigawattPerFoot, quantity01.Unit); + + var quantity02 = LinearPowerDensity.From(1, LinearPowerDensityUnit.GigawattPerInch); + AssertEx.EqualTolerance(1, quantity02.GigawattsPerInch, GigawattsPerInchTolerance); + Assert.Equal(LinearPowerDensityUnit.GigawattPerInch, quantity02.Unit); + + var quantity03 = LinearPowerDensity.From(1, LinearPowerDensityUnit.GigawattPerMeter); + AssertEx.EqualTolerance(1, quantity03.GigawattsPerMeter, GigawattsPerMeterTolerance); + Assert.Equal(LinearPowerDensityUnit.GigawattPerMeter, quantity03.Unit); + + var quantity04 = LinearPowerDensity.From(1, LinearPowerDensityUnit.GigawattPerMillimeter); + AssertEx.EqualTolerance(1, quantity04.GigawattsPerMillimeter, GigawattsPerMillimeterTolerance); + Assert.Equal(LinearPowerDensityUnit.GigawattPerMillimeter, quantity04.Unit); + + var quantity05 = LinearPowerDensity.From(1, LinearPowerDensityUnit.KilowattPerCentimeter); + AssertEx.EqualTolerance(1, quantity05.KilowattsPerCentimeter, KilowattsPerCentimeterTolerance); + Assert.Equal(LinearPowerDensityUnit.KilowattPerCentimeter, quantity05.Unit); + + var quantity06 = LinearPowerDensity.From(1, LinearPowerDensityUnit.KilowattPerFoot); + AssertEx.EqualTolerance(1, quantity06.KilowattsPerFoot, KilowattsPerFootTolerance); + Assert.Equal(LinearPowerDensityUnit.KilowattPerFoot, quantity06.Unit); + + var quantity07 = LinearPowerDensity.From(1, LinearPowerDensityUnit.KilowattPerInch); + AssertEx.EqualTolerance(1, quantity07.KilowattsPerInch, KilowattsPerInchTolerance); + Assert.Equal(LinearPowerDensityUnit.KilowattPerInch, quantity07.Unit); + + var quantity08 = LinearPowerDensity.From(1, LinearPowerDensityUnit.KilowattPerMeter); + AssertEx.EqualTolerance(1, quantity08.KilowattsPerMeter, KilowattsPerMeterTolerance); + Assert.Equal(LinearPowerDensityUnit.KilowattPerMeter, quantity08.Unit); + + var quantity09 = LinearPowerDensity.From(1, LinearPowerDensityUnit.KilowattPerMillimeter); + AssertEx.EqualTolerance(1, quantity09.KilowattsPerMillimeter, KilowattsPerMillimeterTolerance); + Assert.Equal(LinearPowerDensityUnit.KilowattPerMillimeter, quantity09.Unit); + + var quantity10 = LinearPowerDensity.From(1, LinearPowerDensityUnit.MegawattPerCentimeter); + AssertEx.EqualTolerance(1, quantity10.MegawattsPerCentimeter, MegawattsPerCentimeterTolerance); + Assert.Equal(LinearPowerDensityUnit.MegawattPerCentimeter, quantity10.Unit); + + var quantity11 = LinearPowerDensity.From(1, LinearPowerDensityUnit.MegawattPerFoot); + AssertEx.EqualTolerance(1, quantity11.MegawattsPerFoot, MegawattsPerFootTolerance); + Assert.Equal(LinearPowerDensityUnit.MegawattPerFoot, quantity11.Unit); + + var quantity12 = LinearPowerDensity.From(1, LinearPowerDensityUnit.MegawattPerInch); + AssertEx.EqualTolerance(1, quantity12.MegawattsPerInch, MegawattsPerInchTolerance); + Assert.Equal(LinearPowerDensityUnit.MegawattPerInch, quantity12.Unit); + + var quantity13 = LinearPowerDensity.From(1, LinearPowerDensityUnit.MegawattPerMeter); + AssertEx.EqualTolerance(1, quantity13.MegawattsPerMeter, MegawattsPerMeterTolerance); + Assert.Equal(LinearPowerDensityUnit.MegawattPerMeter, quantity13.Unit); + + var quantity14 = LinearPowerDensity.From(1, LinearPowerDensityUnit.MegawattPerMillimeter); + AssertEx.EqualTolerance(1, quantity14.MegawattsPerMillimeter, MegawattsPerMillimeterTolerance); + Assert.Equal(LinearPowerDensityUnit.MegawattPerMillimeter, quantity14.Unit); + + var quantity15 = LinearPowerDensity.From(1, LinearPowerDensityUnit.MilliwattPerCentimeter); + AssertEx.EqualTolerance(1, quantity15.MilliwattsPerCentimeter, MilliwattsPerCentimeterTolerance); + Assert.Equal(LinearPowerDensityUnit.MilliwattPerCentimeter, quantity15.Unit); + + var quantity16 = LinearPowerDensity.From(1, LinearPowerDensityUnit.MilliwattPerFoot); + AssertEx.EqualTolerance(1, quantity16.MilliwattsPerFoot, MilliwattsPerFootTolerance); + Assert.Equal(LinearPowerDensityUnit.MilliwattPerFoot, quantity16.Unit); + + var quantity17 = LinearPowerDensity.From(1, LinearPowerDensityUnit.MilliwattPerInch); + AssertEx.EqualTolerance(1, quantity17.MilliwattsPerInch, MilliwattsPerInchTolerance); + Assert.Equal(LinearPowerDensityUnit.MilliwattPerInch, quantity17.Unit); + + var quantity18 = LinearPowerDensity.From(1, LinearPowerDensityUnit.MilliwattPerMeter); + AssertEx.EqualTolerance(1, quantity18.MilliwattsPerMeter, MilliwattsPerMeterTolerance); + Assert.Equal(LinearPowerDensityUnit.MilliwattPerMeter, quantity18.Unit); + + var quantity19 = LinearPowerDensity.From(1, LinearPowerDensityUnit.MilliwattPerMillimeter); + AssertEx.EqualTolerance(1, quantity19.MilliwattsPerMillimeter, MilliwattsPerMillimeterTolerance); + Assert.Equal(LinearPowerDensityUnit.MilliwattPerMillimeter, quantity19.Unit); + + var quantity20 = LinearPowerDensity.From(1, LinearPowerDensityUnit.WattPerCentimeter); + AssertEx.EqualTolerance(1, quantity20.WattsPerCentimeter, WattsPerCentimeterTolerance); + Assert.Equal(LinearPowerDensityUnit.WattPerCentimeter, quantity20.Unit); + + var quantity21 = LinearPowerDensity.From(1, LinearPowerDensityUnit.WattPerFoot); + AssertEx.EqualTolerance(1, quantity21.WattsPerFoot, WattsPerFootTolerance); + Assert.Equal(LinearPowerDensityUnit.WattPerFoot, quantity21.Unit); + + var quantity22 = LinearPowerDensity.From(1, LinearPowerDensityUnit.WattPerInch); + AssertEx.EqualTolerance(1, quantity22.WattsPerInch, WattsPerInchTolerance); + Assert.Equal(LinearPowerDensityUnit.WattPerInch, quantity22.Unit); + + var quantity23 = LinearPowerDensity.From(1, LinearPowerDensityUnit.WattPerMeter); + AssertEx.EqualTolerance(1, quantity23.WattsPerMeter, WattsPerMeterTolerance); + Assert.Equal(LinearPowerDensityUnit.WattPerMeter, quantity23.Unit); + + var quantity24 = LinearPowerDensity.From(1, LinearPowerDensityUnit.WattPerMillimeter); + AssertEx.EqualTolerance(1, quantity24.WattsPerMillimeter, WattsPerMillimeterTolerance); + Assert.Equal(LinearPowerDensityUnit.WattPerMillimeter, quantity24.Unit); + + } + + [Fact] + public void FromWattsPerMeter_WithInfinityValue_ThrowsArgumentException() + { + Assert.Throws(() => LinearPowerDensity.FromWattsPerMeter(double.PositiveInfinity)); + Assert.Throws(() => LinearPowerDensity.FromWattsPerMeter(double.NegativeInfinity)); + } + + [Fact] + public void FromWattsPerMeter_WithNanValue_ThrowsArgumentException() + { + Assert.Throws(() => LinearPowerDensity.FromWattsPerMeter(double.NaN)); + } + + [Fact] + public void As() + { + var wattpermeter = LinearPowerDensity.FromWattsPerMeter(1); + AssertEx.EqualTolerance(GigawattsPerCentimeterInOneWattPerMeter, wattpermeter.As(LinearPowerDensityUnit.GigawattPerCentimeter), GigawattsPerCentimeterTolerance); + AssertEx.EqualTolerance(GigawattsPerFootInOneWattPerMeter, wattpermeter.As(LinearPowerDensityUnit.GigawattPerFoot), GigawattsPerFootTolerance); + AssertEx.EqualTolerance(GigawattsPerInchInOneWattPerMeter, wattpermeter.As(LinearPowerDensityUnit.GigawattPerInch), GigawattsPerInchTolerance); + AssertEx.EqualTolerance(GigawattsPerMeterInOneWattPerMeter, wattpermeter.As(LinearPowerDensityUnit.GigawattPerMeter), GigawattsPerMeterTolerance); + AssertEx.EqualTolerance(GigawattsPerMillimeterInOneWattPerMeter, wattpermeter.As(LinearPowerDensityUnit.GigawattPerMillimeter), GigawattsPerMillimeterTolerance); + AssertEx.EqualTolerance(KilowattsPerCentimeterInOneWattPerMeter, wattpermeter.As(LinearPowerDensityUnit.KilowattPerCentimeter), KilowattsPerCentimeterTolerance); + AssertEx.EqualTolerance(KilowattsPerFootInOneWattPerMeter, wattpermeter.As(LinearPowerDensityUnit.KilowattPerFoot), KilowattsPerFootTolerance); + AssertEx.EqualTolerance(KilowattsPerInchInOneWattPerMeter, wattpermeter.As(LinearPowerDensityUnit.KilowattPerInch), KilowattsPerInchTolerance); + AssertEx.EqualTolerance(KilowattsPerMeterInOneWattPerMeter, wattpermeter.As(LinearPowerDensityUnit.KilowattPerMeter), KilowattsPerMeterTolerance); + AssertEx.EqualTolerance(KilowattsPerMillimeterInOneWattPerMeter, wattpermeter.As(LinearPowerDensityUnit.KilowattPerMillimeter), KilowattsPerMillimeterTolerance); + AssertEx.EqualTolerance(MegawattsPerCentimeterInOneWattPerMeter, wattpermeter.As(LinearPowerDensityUnit.MegawattPerCentimeter), MegawattsPerCentimeterTolerance); + AssertEx.EqualTolerance(MegawattsPerFootInOneWattPerMeter, wattpermeter.As(LinearPowerDensityUnit.MegawattPerFoot), MegawattsPerFootTolerance); + AssertEx.EqualTolerance(MegawattsPerInchInOneWattPerMeter, wattpermeter.As(LinearPowerDensityUnit.MegawattPerInch), MegawattsPerInchTolerance); + AssertEx.EqualTolerance(MegawattsPerMeterInOneWattPerMeter, wattpermeter.As(LinearPowerDensityUnit.MegawattPerMeter), MegawattsPerMeterTolerance); + AssertEx.EqualTolerance(MegawattsPerMillimeterInOneWattPerMeter, wattpermeter.As(LinearPowerDensityUnit.MegawattPerMillimeter), MegawattsPerMillimeterTolerance); + AssertEx.EqualTolerance(MilliwattsPerCentimeterInOneWattPerMeter, wattpermeter.As(LinearPowerDensityUnit.MilliwattPerCentimeter), MilliwattsPerCentimeterTolerance); + AssertEx.EqualTolerance(MilliwattsPerFootInOneWattPerMeter, wattpermeter.As(LinearPowerDensityUnit.MilliwattPerFoot), MilliwattsPerFootTolerance); + AssertEx.EqualTolerance(MilliwattsPerInchInOneWattPerMeter, wattpermeter.As(LinearPowerDensityUnit.MilliwattPerInch), MilliwattsPerInchTolerance); + AssertEx.EqualTolerance(MilliwattsPerMeterInOneWattPerMeter, wattpermeter.As(LinearPowerDensityUnit.MilliwattPerMeter), MilliwattsPerMeterTolerance); + AssertEx.EqualTolerance(MilliwattsPerMillimeterInOneWattPerMeter, wattpermeter.As(LinearPowerDensityUnit.MilliwattPerMillimeter), MilliwattsPerMillimeterTolerance); + AssertEx.EqualTolerance(WattsPerCentimeterInOneWattPerMeter, wattpermeter.As(LinearPowerDensityUnit.WattPerCentimeter), WattsPerCentimeterTolerance); + AssertEx.EqualTolerance(WattsPerFootInOneWattPerMeter, wattpermeter.As(LinearPowerDensityUnit.WattPerFoot), WattsPerFootTolerance); + AssertEx.EqualTolerance(WattsPerInchInOneWattPerMeter, wattpermeter.As(LinearPowerDensityUnit.WattPerInch), WattsPerInchTolerance); + AssertEx.EqualTolerance(WattsPerMeterInOneWattPerMeter, wattpermeter.As(LinearPowerDensityUnit.WattPerMeter), WattsPerMeterTolerance); + AssertEx.EqualTolerance(WattsPerMillimeterInOneWattPerMeter, wattpermeter.As(LinearPowerDensityUnit.WattPerMillimeter), WattsPerMillimeterTolerance); + } + + [Fact] + public void ToUnit() + { + var wattpermeter = LinearPowerDensity.FromWattsPerMeter(1); + + var gigawattpercentimeterQuantity = wattpermeter.ToUnit(LinearPowerDensityUnit.GigawattPerCentimeter); + AssertEx.EqualTolerance(GigawattsPerCentimeterInOneWattPerMeter, (double)gigawattpercentimeterQuantity.Value, GigawattsPerCentimeterTolerance); + Assert.Equal(LinearPowerDensityUnit.GigawattPerCentimeter, gigawattpercentimeterQuantity.Unit); + + var gigawattperfootQuantity = wattpermeter.ToUnit(LinearPowerDensityUnit.GigawattPerFoot); + AssertEx.EqualTolerance(GigawattsPerFootInOneWattPerMeter, (double)gigawattperfootQuantity.Value, GigawattsPerFootTolerance); + Assert.Equal(LinearPowerDensityUnit.GigawattPerFoot, gigawattperfootQuantity.Unit); + + var gigawattperinchQuantity = wattpermeter.ToUnit(LinearPowerDensityUnit.GigawattPerInch); + AssertEx.EqualTolerance(GigawattsPerInchInOneWattPerMeter, (double)gigawattperinchQuantity.Value, GigawattsPerInchTolerance); + Assert.Equal(LinearPowerDensityUnit.GigawattPerInch, gigawattperinchQuantity.Unit); + + var gigawattpermeterQuantity = wattpermeter.ToUnit(LinearPowerDensityUnit.GigawattPerMeter); + AssertEx.EqualTolerance(GigawattsPerMeterInOneWattPerMeter, (double)gigawattpermeterQuantity.Value, GigawattsPerMeterTolerance); + Assert.Equal(LinearPowerDensityUnit.GigawattPerMeter, gigawattpermeterQuantity.Unit); + + var gigawattpermillimeterQuantity = wattpermeter.ToUnit(LinearPowerDensityUnit.GigawattPerMillimeter); + AssertEx.EqualTolerance(GigawattsPerMillimeterInOneWattPerMeter, (double)gigawattpermillimeterQuantity.Value, GigawattsPerMillimeterTolerance); + Assert.Equal(LinearPowerDensityUnit.GigawattPerMillimeter, gigawattpermillimeterQuantity.Unit); + + var kilowattpercentimeterQuantity = wattpermeter.ToUnit(LinearPowerDensityUnit.KilowattPerCentimeter); + AssertEx.EqualTolerance(KilowattsPerCentimeterInOneWattPerMeter, (double)kilowattpercentimeterQuantity.Value, KilowattsPerCentimeterTolerance); + Assert.Equal(LinearPowerDensityUnit.KilowattPerCentimeter, kilowattpercentimeterQuantity.Unit); + + var kilowattperfootQuantity = wattpermeter.ToUnit(LinearPowerDensityUnit.KilowattPerFoot); + AssertEx.EqualTolerance(KilowattsPerFootInOneWattPerMeter, (double)kilowattperfootQuantity.Value, KilowattsPerFootTolerance); + Assert.Equal(LinearPowerDensityUnit.KilowattPerFoot, kilowattperfootQuantity.Unit); + + var kilowattperinchQuantity = wattpermeter.ToUnit(LinearPowerDensityUnit.KilowattPerInch); + AssertEx.EqualTolerance(KilowattsPerInchInOneWattPerMeter, (double)kilowattperinchQuantity.Value, KilowattsPerInchTolerance); + Assert.Equal(LinearPowerDensityUnit.KilowattPerInch, kilowattperinchQuantity.Unit); + + var kilowattpermeterQuantity = wattpermeter.ToUnit(LinearPowerDensityUnit.KilowattPerMeter); + AssertEx.EqualTolerance(KilowattsPerMeterInOneWattPerMeter, (double)kilowattpermeterQuantity.Value, KilowattsPerMeterTolerance); + Assert.Equal(LinearPowerDensityUnit.KilowattPerMeter, kilowattpermeterQuantity.Unit); + + var kilowattpermillimeterQuantity = wattpermeter.ToUnit(LinearPowerDensityUnit.KilowattPerMillimeter); + AssertEx.EqualTolerance(KilowattsPerMillimeterInOneWattPerMeter, (double)kilowattpermillimeterQuantity.Value, KilowattsPerMillimeterTolerance); + Assert.Equal(LinearPowerDensityUnit.KilowattPerMillimeter, kilowattpermillimeterQuantity.Unit); + + var megawattpercentimeterQuantity = wattpermeter.ToUnit(LinearPowerDensityUnit.MegawattPerCentimeter); + AssertEx.EqualTolerance(MegawattsPerCentimeterInOneWattPerMeter, (double)megawattpercentimeterQuantity.Value, MegawattsPerCentimeterTolerance); + Assert.Equal(LinearPowerDensityUnit.MegawattPerCentimeter, megawattpercentimeterQuantity.Unit); + + var megawattperfootQuantity = wattpermeter.ToUnit(LinearPowerDensityUnit.MegawattPerFoot); + AssertEx.EqualTolerance(MegawattsPerFootInOneWattPerMeter, (double)megawattperfootQuantity.Value, MegawattsPerFootTolerance); + Assert.Equal(LinearPowerDensityUnit.MegawattPerFoot, megawattperfootQuantity.Unit); + + var megawattperinchQuantity = wattpermeter.ToUnit(LinearPowerDensityUnit.MegawattPerInch); + AssertEx.EqualTolerance(MegawattsPerInchInOneWattPerMeter, (double)megawattperinchQuantity.Value, MegawattsPerInchTolerance); + Assert.Equal(LinearPowerDensityUnit.MegawattPerInch, megawattperinchQuantity.Unit); + + var megawattpermeterQuantity = wattpermeter.ToUnit(LinearPowerDensityUnit.MegawattPerMeter); + AssertEx.EqualTolerance(MegawattsPerMeterInOneWattPerMeter, (double)megawattpermeterQuantity.Value, MegawattsPerMeterTolerance); + Assert.Equal(LinearPowerDensityUnit.MegawattPerMeter, megawattpermeterQuantity.Unit); + + var megawattpermillimeterQuantity = wattpermeter.ToUnit(LinearPowerDensityUnit.MegawattPerMillimeter); + AssertEx.EqualTolerance(MegawattsPerMillimeterInOneWattPerMeter, (double)megawattpermillimeterQuantity.Value, MegawattsPerMillimeterTolerance); + Assert.Equal(LinearPowerDensityUnit.MegawattPerMillimeter, megawattpermillimeterQuantity.Unit); + + var milliwattpercentimeterQuantity = wattpermeter.ToUnit(LinearPowerDensityUnit.MilliwattPerCentimeter); + AssertEx.EqualTolerance(MilliwattsPerCentimeterInOneWattPerMeter, (double)milliwattpercentimeterQuantity.Value, MilliwattsPerCentimeterTolerance); + Assert.Equal(LinearPowerDensityUnit.MilliwattPerCentimeter, milliwattpercentimeterQuantity.Unit); + + var milliwattperfootQuantity = wattpermeter.ToUnit(LinearPowerDensityUnit.MilliwattPerFoot); + AssertEx.EqualTolerance(MilliwattsPerFootInOneWattPerMeter, (double)milliwattperfootQuantity.Value, MilliwattsPerFootTolerance); + Assert.Equal(LinearPowerDensityUnit.MilliwattPerFoot, milliwattperfootQuantity.Unit); + + var milliwattperinchQuantity = wattpermeter.ToUnit(LinearPowerDensityUnit.MilliwattPerInch); + AssertEx.EqualTolerance(MilliwattsPerInchInOneWattPerMeter, (double)milliwattperinchQuantity.Value, MilliwattsPerInchTolerance); + Assert.Equal(LinearPowerDensityUnit.MilliwattPerInch, milliwattperinchQuantity.Unit); + + var milliwattpermeterQuantity = wattpermeter.ToUnit(LinearPowerDensityUnit.MilliwattPerMeter); + AssertEx.EqualTolerance(MilliwattsPerMeterInOneWattPerMeter, (double)milliwattpermeterQuantity.Value, MilliwattsPerMeterTolerance); + Assert.Equal(LinearPowerDensityUnit.MilliwattPerMeter, milliwattpermeterQuantity.Unit); + + var milliwattpermillimeterQuantity = wattpermeter.ToUnit(LinearPowerDensityUnit.MilliwattPerMillimeter); + AssertEx.EqualTolerance(MilliwattsPerMillimeterInOneWattPerMeter, (double)milliwattpermillimeterQuantity.Value, MilliwattsPerMillimeterTolerance); + Assert.Equal(LinearPowerDensityUnit.MilliwattPerMillimeter, milliwattpermillimeterQuantity.Unit); + + var wattpercentimeterQuantity = wattpermeter.ToUnit(LinearPowerDensityUnit.WattPerCentimeter); + AssertEx.EqualTolerance(WattsPerCentimeterInOneWattPerMeter, (double)wattpercentimeterQuantity.Value, WattsPerCentimeterTolerance); + Assert.Equal(LinearPowerDensityUnit.WattPerCentimeter, wattpercentimeterQuantity.Unit); + + var wattperfootQuantity = wattpermeter.ToUnit(LinearPowerDensityUnit.WattPerFoot); + AssertEx.EqualTolerance(WattsPerFootInOneWattPerMeter, (double)wattperfootQuantity.Value, WattsPerFootTolerance); + Assert.Equal(LinearPowerDensityUnit.WattPerFoot, wattperfootQuantity.Unit); + + var wattperinchQuantity = wattpermeter.ToUnit(LinearPowerDensityUnit.WattPerInch); + AssertEx.EqualTolerance(WattsPerInchInOneWattPerMeter, (double)wattperinchQuantity.Value, WattsPerInchTolerance); + Assert.Equal(LinearPowerDensityUnit.WattPerInch, wattperinchQuantity.Unit); + + var wattpermeterQuantity = wattpermeter.ToUnit(LinearPowerDensityUnit.WattPerMeter); + AssertEx.EqualTolerance(WattsPerMeterInOneWattPerMeter, (double)wattpermeterQuantity.Value, WattsPerMeterTolerance); + Assert.Equal(LinearPowerDensityUnit.WattPerMeter, wattpermeterQuantity.Unit); + + var wattpermillimeterQuantity = wattpermeter.ToUnit(LinearPowerDensityUnit.WattPerMillimeter); + AssertEx.EqualTolerance(WattsPerMillimeterInOneWattPerMeter, (double)wattpermillimeterQuantity.Value, WattsPerMillimeterTolerance); + Assert.Equal(LinearPowerDensityUnit.WattPerMillimeter, wattpermillimeterQuantity.Unit); + } + + [Fact] + public void ConversionRoundTrip() + { + LinearPowerDensity wattpermeter = LinearPowerDensity.FromWattsPerMeter(1); + AssertEx.EqualTolerance(1, LinearPowerDensity.FromGigawattsPerCentimeter(wattpermeter.GigawattsPerCentimeter).WattsPerMeter, GigawattsPerCentimeterTolerance); + AssertEx.EqualTolerance(1, LinearPowerDensity.FromGigawattsPerFoot(wattpermeter.GigawattsPerFoot).WattsPerMeter, GigawattsPerFootTolerance); + AssertEx.EqualTolerance(1, LinearPowerDensity.FromGigawattsPerInch(wattpermeter.GigawattsPerInch).WattsPerMeter, GigawattsPerInchTolerance); + AssertEx.EqualTolerance(1, LinearPowerDensity.FromGigawattsPerMeter(wattpermeter.GigawattsPerMeter).WattsPerMeter, GigawattsPerMeterTolerance); + AssertEx.EqualTolerance(1, LinearPowerDensity.FromGigawattsPerMillimeter(wattpermeter.GigawattsPerMillimeter).WattsPerMeter, GigawattsPerMillimeterTolerance); + AssertEx.EqualTolerance(1, LinearPowerDensity.FromKilowattsPerCentimeter(wattpermeter.KilowattsPerCentimeter).WattsPerMeter, KilowattsPerCentimeterTolerance); + AssertEx.EqualTolerance(1, LinearPowerDensity.FromKilowattsPerFoot(wattpermeter.KilowattsPerFoot).WattsPerMeter, KilowattsPerFootTolerance); + AssertEx.EqualTolerance(1, LinearPowerDensity.FromKilowattsPerInch(wattpermeter.KilowattsPerInch).WattsPerMeter, KilowattsPerInchTolerance); + AssertEx.EqualTolerance(1, LinearPowerDensity.FromKilowattsPerMeter(wattpermeter.KilowattsPerMeter).WattsPerMeter, KilowattsPerMeterTolerance); + AssertEx.EqualTolerance(1, LinearPowerDensity.FromKilowattsPerMillimeter(wattpermeter.KilowattsPerMillimeter).WattsPerMeter, KilowattsPerMillimeterTolerance); + AssertEx.EqualTolerance(1, LinearPowerDensity.FromMegawattsPerCentimeter(wattpermeter.MegawattsPerCentimeter).WattsPerMeter, MegawattsPerCentimeterTolerance); + AssertEx.EqualTolerance(1, LinearPowerDensity.FromMegawattsPerFoot(wattpermeter.MegawattsPerFoot).WattsPerMeter, MegawattsPerFootTolerance); + AssertEx.EqualTolerance(1, LinearPowerDensity.FromMegawattsPerInch(wattpermeter.MegawattsPerInch).WattsPerMeter, MegawattsPerInchTolerance); + AssertEx.EqualTolerance(1, LinearPowerDensity.FromMegawattsPerMeter(wattpermeter.MegawattsPerMeter).WattsPerMeter, MegawattsPerMeterTolerance); + AssertEx.EqualTolerance(1, LinearPowerDensity.FromMegawattsPerMillimeter(wattpermeter.MegawattsPerMillimeter).WattsPerMeter, MegawattsPerMillimeterTolerance); + AssertEx.EqualTolerance(1, LinearPowerDensity.FromMilliwattsPerCentimeter(wattpermeter.MilliwattsPerCentimeter).WattsPerMeter, MilliwattsPerCentimeterTolerance); + AssertEx.EqualTolerance(1, LinearPowerDensity.FromMilliwattsPerFoot(wattpermeter.MilliwattsPerFoot).WattsPerMeter, MilliwattsPerFootTolerance); + AssertEx.EqualTolerance(1, LinearPowerDensity.FromMilliwattsPerInch(wattpermeter.MilliwattsPerInch).WattsPerMeter, MilliwattsPerInchTolerance); + AssertEx.EqualTolerance(1, LinearPowerDensity.FromMilliwattsPerMeter(wattpermeter.MilliwattsPerMeter).WattsPerMeter, MilliwattsPerMeterTolerance); + AssertEx.EqualTolerance(1, LinearPowerDensity.FromMilliwattsPerMillimeter(wattpermeter.MilliwattsPerMillimeter).WattsPerMeter, MilliwattsPerMillimeterTolerance); + AssertEx.EqualTolerance(1, LinearPowerDensity.FromWattsPerCentimeter(wattpermeter.WattsPerCentimeter).WattsPerMeter, WattsPerCentimeterTolerance); + AssertEx.EqualTolerance(1, LinearPowerDensity.FromWattsPerFoot(wattpermeter.WattsPerFoot).WattsPerMeter, WattsPerFootTolerance); + AssertEx.EqualTolerance(1, LinearPowerDensity.FromWattsPerInch(wattpermeter.WattsPerInch).WattsPerMeter, WattsPerInchTolerance); + AssertEx.EqualTolerance(1, LinearPowerDensity.FromWattsPerMeter(wattpermeter.WattsPerMeter).WattsPerMeter, WattsPerMeterTolerance); + AssertEx.EqualTolerance(1, LinearPowerDensity.FromWattsPerMillimeter(wattpermeter.WattsPerMillimeter).WattsPerMeter, WattsPerMillimeterTolerance); + } + + [Fact] + public void ArithmeticOperators() + { + LinearPowerDensity v = LinearPowerDensity.FromWattsPerMeter(1); + AssertEx.EqualTolerance(-1, -v.WattsPerMeter, WattsPerMeterTolerance); + AssertEx.EqualTolerance(2, (LinearPowerDensity.FromWattsPerMeter(3)-v).WattsPerMeter, WattsPerMeterTolerance); + AssertEx.EqualTolerance(2, (v + v).WattsPerMeter, WattsPerMeterTolerance); + AssertEx.EqualTolerance(10, (v*10).WattsPerMeter, WattsPerMeterTolerance); + AssertEx.EqualTolerance(10, (10*v).WattsPerMeter, WattsPerMeterTolerance); + AssertEx.EqualTolerance(2, (LinearPowerDensity.FromWattsPerMeter(10)/5).WattsPerMeter, WattsPerMeterTolerance); + AssertEx.EqualTolerance(2, LinearPowerDensity.FromWattsPerMeter(10)/LinearPowerDensity.FromWattsPerMeter(5), WattsPerMeterTolerance); + } + + [Fact] + public void ComparisonOperators() + { + LinearPowerDensity oneWattPerMeter = LinearPowerDensity.FromWattsPerMeter(1); + LinearPowerDensity twoWattsPerMeter = LinearPowerDensity.FromWattsPerMeter(2); + + Assert.True(oneWattPerMeter < twoWattsPerMeter); + Assert.True(oneWattPerMeter <= twoWattsPerMeter); + Assert.True(twoWattsPerMeter > oneWattPerMeter); + Assert.True(twoWattsPerMeter >= oneWattPerMeter); + + Assert.False(oneWattPerMeter > twoWattsPerMeter); + Assert.False(oneWattPerMeter >= twoWattsPerMeter); + Assert.False(twoWattsPerMeter < oneWattPerMeter); + Assert.False(twoWattsPerMeter <= oneWattPerMeter); + } + + [Fact] + public void CompareToIsImplemented() + { + LinearPowerDensity wattpermeter = LinearPowerDensity.FromWattsPerMeter(1); + Assert.Equal(0, wattpermeter.CompareTo(wattpermeter)); + Assert.True(wattpermeter.CompareTo(LinearPowerDensity.Zero) > 0); + Assert.True(LinearPowerDensity.Zero.CompareTo(wattpermeter) < 0); + } + + [Fact] + public void CompareToThrowsOnTypeMismatch() + { + LinearPowerDensity wattpermeter = LinearPowerDensity.FromWattsPerMeter(1); + Assert.Throws(() => wattpermeter.CompareTo(new object())); + } + + [Fact] + public void CompareToThrowsOnNull() + { + LinearPowerDensity wattpermeter = LinearPowerDensity.FromWattsPerMeter(1); + Assert.Throws(() => wattpermeter.CompareTo(null)); + } + + [Fact] + public void EqualityOperators() + { + var a = LinearPowerDensity.FromWattsPerMeter(1); + var b = LinearPowerDensity.FromWattsPerMeter(2); + + // ReSharper disable EqualExpressionComparison + + Assert.True(a == a); + Assert.False(a != a); + + Assert.True(a != b); + Assert.False(a == b); + + Assert.False(a == null); + Assert.False(null == a); + +// ReSharper restore EqualExpressionComparison + } + + [Fact] + public void EqualsIsImplemented() + { + var a = LinearPowerDensity.FromWattsPerMeter(1); + var b = LinearPowerDensity.FromWattsPerMeter(2); + + Assert.True(a.Equals(a)); + Assert.False(a.Equals(b)); + Assert.False(a.Equals(null)); + } + + [Fact] + public void EqualsRelativeToleranceIsImplemented() + { + var v = LinearPowerDensity.FromWattsPerMeter(1); + Assert.True(v.Equals(LinearPowerDensity.FromWattsPerMeter(1), WattsPerMeterTolerance, ComparisonType.Relative)); + Assert.False(v.Equals(LinearPowerDensity.Zero, WattsPerMeterTolerance, ComparisonType.Relative)); + } + + [Fact] + public void EqualsReturnsFalseOnTypeMismatch() + { + LinearPowerDensity wattpermeter = LinearPowerDensity.FromWattsPerMeter(1); + Assert.False(wattpermeter.Equals(new object())); + } + + [Fact] + public void EqualsReturnsFalseOnNull() + { + LinearPowerDensity wattpermeter = LinearPowerDensity.FromWattsPerMeter(1); + Assert.False(wattpermeter.Equals(null)); + } + + [Fact] + public void UnitsDoesNotContainUndefined() + { + Assert.DoesNotContain(LinearPowerDensityUnit.Undefined, LinearPowerDensity.Units); + } + + [Fact] + public void HasAtLeastOneAbbreviationSpecified() + { + var units = Enum.GetValues(typeof(LinearPowerDensityUnit)).Cast(); + foreach(var unit in units) + { + if(unit == LinearPowerDensityUnit.Undefined) + continue; + + var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit); + } + } + + [Fact] + public void BaseDimensionsShouldNeverBeNull() + { + Assert.False(LinearPowerDensity.BaseDimensions is null); + } + + [Fact] + public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture() + { + var prevCulture = Thread.CurrentThread.CurrentUICulture; + Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo("en-US"); + try { + Assert.Equal("1 GW/cm", new LinearPowerDensity(1, LinearPowerDensityUnit.GigawattPerCentimeter).ToString()); + Assert.Equal("1 GW/ft", new LinearPowerDensity(1, LinearPowerDensityUnit.GigawattPerFoot).ToString()); + Assert.Equal("1 GW/in", new LinearPowerDensity(1, LinearPowerDensityUnit.GigawattPerInch).ToString()); + Assert.Equal("1 GW/m", new LinearPowerDensity(1, LinearPowerDensityUnit.GigawattPerMeter).ToString()); + Assert.Equal("1 GW/mm", new LinearPowerDensity(1, LinearPowerDensityUnit.GigawattPerMillimeter).ToString()); + Assert.Equal("1 kW/cm", new LinearPowerDensity(1, LinearPowerDensityUnit.KilowattPerCentimeter).ToString()); + Assert.Equal("1 kW/ft", new LinearPowerDensity(1, LinearPowerDensityUnit.KilowattPerFoot).ToString()); + Assert.Equal("1 kW/in", new LinearPowerDensity(1, LinearPowerDensityUnit.KilowattPerInch).ToString()); + Assert.Equal("1 kW/m", new LinearPowerDensity(1, LinearPowerDensityUnit.KilowattPerMeter).ToString()); + Assert.Equal("1 kW/mm", new LinearPowerDensity(1, LinearPowerDensityUnit.KilowattPerMillimeter).ToString()); + Assert.Equal("1 MW/cm", new LinearPowerDensity(1, LinearPowerDensityUnit.MegawattPerCentimeter).ToString()); + Assert.Equal("1 MW/ft", new LinearPowerDensity(1, LinearPowerDensityUnit.MegawattPerFoot).ToString()); + Assert.Equal("1 MW/in", new LinearPowerDensity(1, LinearPowerDensityUnit.MegawattPerInch).ToString()); + Assert.Equal("1 MW/m", new LinearPowerDensity(1, LinearPowerDensityUnit.MegawattPerMeter).ToString()); + Assert.Equal("1 MW/mm", new LinearPowerDensity(1, LinearPowerDensityUnit.MegawattPerMillimeter).ToString()); + Assert.Equal("1 mW/cm", new LinearPowerDensity(1, LinearPowerDensityUnit.MilliwattPerCentimeter).ToString()); + Assert.Equal("1 mW/ft", new LinearPowerDensity(1, LinearPowerDensityUnit.MilliwattPerFoot).ToString()); + Assert.Equal("1 mW/in", new LinearPowerDensity(1, LinearPowerDensityUnit.MilliwattPerInch).ToString()); + Assert.Equal("1 mW/m", new LinearPowerDensity(1, LinearPowerDensityUnit.MilliwattPerMeter).ToString()); + Assert.Equal("1 mW/mm", new LinearPowerDensity(1, LinearPowerDensityUnit.MilliwattPerMillimeter).ToString()); + Assert.Equal("1 W/cm", new LinearPowerDensity(1, LinearPowerDensityUnit.WattPerCentimeter).ToString()); + Assert.Equal("1 W/ft", new LinearPowerDensity(1, LinearPowerDensityUnit.WattPerFoot).ToString()); + Assert.Equal("1 W/in", new LinearPowerDensity(1, LinearPowerDensityUnit.WattPerInch).ToString()); + Assert.Equal("1 W/m", new LinearPowerDensity(1, LinearPowerDensityUnit.WattPerMeter).ToString()); + Assert.Equal("1 W/mm", new LinearPowerDensity(1, LinearPowerDensityUnit.WattPerMillimeter).ToString()); + } + finally + { + Thread.CurrentThread.CurrentUICulture = prevCulture; + } + } + + [Fact] + public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCultureSinceThereAreNoMappings() + { + // Chose this culture, because we don't currently have any abbreviations mapped for that culture and we expect the en-US to be used as fallback. + var swedishCulture = CultureInfo.GetCultureInfo("sv-SE"); + + Assert.Equal("1 GW/cm", new LinearPowerDensity(1, LinearPowerDensityUnit.GigawattPerCentimeter).ToString(swedishCulture)); + Assert.Equal("1 GW/ft", new LinearPowerDensity(1, LinearPowerDensityUnit.GigawattPerFoot).ToString(swedishCulture)); + Assert.Equal("1 GW/in", new LinearPowerDensity(1, LinearPowerDensityUnit.GigawattPerInch).ToString(swedishCulture)); + Assert.Equal("1 GW/m", new LinearPowerDensity(1, LinearPowerDensityUnit.GigawattPerMeter).ToString(swedishCulture)); + Assert.Equal("1 GW/mm", new LinearPowerDensity(1, LinearPowerDensityUnit.GigawattPerMillimeter).ToString(swedishCulture)); + Assert.Equal("1 kW/cm", new LinearPowerDensity(1, LinearPowerDensityUnit.KilowattPerCentimeter).ToString(swedishCulture)); + Assert.Equal("1 kW/ft", new LinearPowerDensity(1, LinearPowerDensityUnit.KilowattPerFoot).ToString(swedishCulture)); + Assert.Equal("1 kW/in", new LinearPowerDensity(1, LinearPowerDensityUnit.KilowattPerInch).ToString(swedishCulture)); + Assert.Equal("1 kW/m", new LinearPowerDensity(1, LinearPowerDensityUnit.KilowattPerMeter).ToString(swedishCulture)); + Assert.Equal("1 kW/mm", new LinearPowerDensity(1, LinearPowerDensityUnit.KilowattPerMillimeter).ToString(swedishCulture)); + Assert.Equal("1 MW/cm", new LinearPowerDensity(1, LinearPowerDensityUnit.MegawattPerCentimeter).ToString(swedishCulture)); + Assert.Equal("1 MW/ft", new LinearPowerDensity(1, LinearPowerDensityUnit.MegawattPerFoot).ToString(swedishCulture)); + Assert.Equal("1 MW/in", new LinearPowerDensity(1, LinearPowerDensityUnit.MegawattPerInch).ToString(swedishCulture)); + Assert.Equal("1 MW/m", new LinearPowerDensity(1, LinearPowerDensityUnit.MegawattPerMeter).ToString(swedishCulture)); + Assert.Equal("1 MW/mm", new LinearPowerDensity(1, LinearPowerDensityUnit.MegawattPerMillimeter).ToString(swedishCulture)); + Assert.Equal("1 mW/cm", new LinearPowerDensity(1, LinearPowerDensityUnit.MilliwattPerCentimeter).ToString(swedishCulture)); + Assert.Equal("1 mW/ft", new LinearPowerDensity(1, LinearPowerDensityUnit.MilliwattPerFoot).ToString(swedishCulture)); + Assert.Equal("1 mW/in", new LinearPowerDensity(1, LinearPowerDensityUnit.MilliwattPerInch).ToString(swedishCulture)); + Assert.Equal("1 mW/m", new LinearPowerDensity(1, LinearPowerDensityUnit.MilliwattPerMeter).ToString(swedishCulture)); + Assert.Equal("1 mW/mm", new LinearPowerDensity(1, LinearPowerDensityUnit.MilliwattPerMillimeter).ToString(swedishCulture)); + Assert.Equal("1 W/cm", new LinearPowerDensity(1, LinearPowerDensityUnit.WattPerCentimeter).ToString(swedishCulture)); + Assert.Equal("1 W/ft", new LinearPowerDensity(1, LinearPowerDensityUnit.WattPerFoot).ToString(swedishCulture)); + Assert.Equal("1 W/in", new LinearPowerDensity(1, LinearPowerDensityUnit.WattPerInch).ToString(swedishCulture)); + Assert.Equal("1 W/m", new LinearPowerDensity(1, LinearPowerDensityUnit.WattPerMeter).ToString(swedishCulture)); + Assert.Equal("1 W/mm", new LinearPowerDensity(1, LinearPowerDensityUnit.WattPerMillimeter).ToString(swedishCulture)); + } + + [Fact] + public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture() + { + var oldCulture = CultureInfo.CurrentUICulture; + try + { + CultureInfo.CurrentUICulture = CultureInfo.InvariantCulture; + Assert.Equal("0.1 W/m", new LinearPowerDensity(0.123456, LinearPowerDensityUnit.WattPerMeter).ToString("s1")); + Assert.Equal("0.12 W/m", new LinearPowerDensity(0.123456, LinearPowerDensityUnit.WattPerMeter).ToString("s2")); + Assert.Equal("0.123 W/m", new LinearPowerDensity(0.123456, LinearPowerDensityUnit.WattPerMeter).ToString("s3")); + Assert.Equal("0.1235 W/m", new LinearPowerDensity(0.123456, LinearPowerDensityUnit.WattPerMeter).ToString("s4")); + } + finally + { + CultureInfo.CurrentUICulture = oldCulture; + } + } + + [Fact] + public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture() + { + var culture = CultureInfo.InvariantCulture; + Assert.Equal("0.1 W/m", new LinearPowerDensity(0.123456, LinearPowerDensityUnit.WattPerMeter).ToString("s1", culture)); + Assert.Equal("0.12 W/m", new LinearPowerDensity(0.123456, LinearPowerDensityUnit.WattPerMeter).ToString("s2", culture)); + Assert.Equal("0.123 W/m", new LinearPowerDensity(0.123456, LinearPowerDensityUnit.WattPerMeter).ToString("s3", culture)); + Assert.Equal("0.1235 W/m", new LinearPowerDensity(0.123456, LinearPowerDensityUnit.WattPerMeter).ToString("s4", culture)); + } + } +} diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearPowerDensity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearPowerDensity.g.cs new file mode 100644 index 0000000000..6f361343a0 --- /dev/null +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearPowerDensity.g.cs @@ -0,0 +1,991 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by \generate-code.bat. +// +// Changes to this file will be lost when the code is regenerated. +// The build server regenerates the code before each build and a pre-build +// step will regenerate the code on each local build. +// +// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units. +// +// Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities. +// Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities. +// +// +//------------------------------------------------------------------------------ + +// Licensed under MIT No Attribution, see LICENSE file at the root. +// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet. + +using System; +using System.Globalization; +using System.Linq; +using JetBrains.Annotations; +using UnitsNet.Units; +using UnitsNet.InternalHelpers; + +// ReSharper disable once CheckNamespace + +namespace UnitsNet +{ + /// + /// The Linear Power Density of a substance is its power per unit length. The term linear density is most often used when describing the characteristics of one-dimensional objects, although linear density can also be used to describe the density of a three-dimensional quantity along one particular dimension. + /// + /// + /// http://en.wikipedia.org/wiki/Linear_density + /// + // Windows Runtime Component has constraints on public types: https://msdn.microsoft.com/en-us/library/br230301.aspx#Declaring types in Windows Runtime Components + // Public structures can't have any members other than public fields, and those fields must be value types or strings. + // Public classes must be sealed (NotInheritable in Visual Basic). If your programming model requires polymorphism, you can create a public interface and implement that interface on the classes that must be polymorphic. + public sealed partial class LinearPowerDensity : IQuantity + { + /// + /// The numeric value this quantity was constructed with. + /// + private readonly double _value; + + /// + /// The unit this quantity was constructed with. + /// + private readonly LinearPowerDensityUnit? _unit; + + static LinearPowerDensity() + { + BaseDimensions = new BaseDimensions(1, 1, -3, 0, 0, 0, 0); + Info = new QuantityInfo(QuantityType.LinearPowerDensity, Units.Cast().ToArray(), BaseUnit, Zero, BaseDimensions); + } + + /// + /// Creates the quantity with a value of 0 in the base unit WattPerMeter. + /// + /// + /// Windows Runtime Component requires a default constructor. + /// + public LinearPowerDensity() + { + _value = 0; + _unit = BaseUnit; + } + + /// + /// Creates the quantity with the given numeric value and unit. + /// + /// The numeric value to construct this quantity with. + /// The unit representation to construct this quantity with. + /// Value parameter cannot be named 'value' due to constraint when targeting Windows Runtime Component. + /// If value is NaN or Infinity. + private LinearPowerDensity(double value, LinearPowerDensityUnit unit) + { + if(unit == LinearPowerDensityUnit.Undefined) + throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit)); + + _value = Guard.EnsureValidNumber(value, nameof(value)); + _unit = unit; + } + + #region Static Properties + + /// + /// Information about the quantity type, such as unit values and names. + /// + internal static QuantityInfo Info { get; } + + /// + /// The of this quantity. + /// + public static BaseDimensions BaseDimensions { get; } + + /// + /// The base unit of LinearPowerDensity, which is WattPerMeter. All conversions go via this value. + /// + public static LinearPowerDensityUnit BaseUnit { get; } = LinearPowerDensityUnit.WattPerMeter; + + /// + /// Represents the largest possible value of LinearPowerDensity + /// + public static LinearPowerDensity MaxValue { get; } = new LinearPowerDensity(double.MaxValue, BaseUnit); + + /// + /// Represents the smallest possible value of LinearPowerDensity + /// + public static LinearPowerDensity MinValue { get; } = new LinearPowerDensity(double.MinValue, BaseUnit); + + /// + /// The of this quantity. + /// + public static QuantityType QuantityType { get; } = QuantityType.LinearPowerDensity; + + /// + /// All units of measurement for the LinearPowerDensity quantity. + /// + public static LinearPowerDensityUnit[] Units { get; } = Enum.GetValues(typeof(LinearPowerDensityUnit)).Cast().Except(new LinearPowerDensityUnit[]{ LinearPowerDensityUnit.Undefined }).ToArray(); + + /// + /// Gets an instance of this quantity with a value of 0 in the base unit WattPerMeter. + /// + public static LinearPowerDensity Zero { get; } = new LinearPowerDensity(0, BaseUnit); + + #endregion + + #region Properties + + /// + /// The numeric value this quantity was constructed with. + /// + public double Value => Convert.ToDouble(_value); + + /// + object IQuantity.Unit => Unit; + + /// + /// The unit this quantity was constructed with -or- if default ctor was used. + /// + public LinearPowerDensityUnit Unit => _unit.GetValueOrDefault(BaseUnit); + + internal QuantityInfo QuantityInfo => Info; + + /// + /// The of this quantity. + /// + public QuantityType Type => LinearPowerDensity.QuantityType; + + /// + /// The of this quantity. + /// + public BaseDimensions Dimensions => LinearPowerDensity.BaseDimensions; + + #endregion + + #region Conversion Properties + + /// + /// Get LinearPowerDensity in GigawattsPerCentimeter. + /// + public double GigawattsPerCentimeter => As(LinearPowerDensityUnit.GigawattPerCentimeter); + + /// + /// Get LinearPowerDensity in GigawattsPerFoot. + /// + public double GigawattsPerFoot => As(LinearPowerDensityUnit.GigawattPerFoot); + + /// + /// Get LinearPowerDensity in GigawattsPerInch. + /// + public double GigawattsPerInch => As(LinearPowerDensityUnit.GigawattPerInch); + + /// + /// Get LinearPowerDensity in GigawattsPerMeter. + /// + public double GigawattsPerMeter => As(LinearPowerDensityUnit.GigawattPerMeter); + + /// + /// Get LinearPowerDensity in GigawattsPerMillimeter. + /// + public double GigawattsPerMillimeter => As(LinearPowerDensityUnit.GigawattPerMillimeter); + + /// + /// Get LinearPowerDensity in KilowattsPerCentimeter. + /// + public double KilowattsPerCentimeter => As(LinearPowerDensityUnit.KilowattPerCentimeter); + + /// + /// Get LinearPowerDensity in KilowattsPerFoot. + /// + public double KilowattsPerFoot => As(LinearPowerDensityUnit.KilowattPerFoot); + + /// + /// Get LinearPowerDensity in KilowattsPerInch. + /// + public double KilowattsPerInch => As(LinearPowerDensityUnit.KilowattPerInch); + + /// + /// Get LinearPowerDensity in KilowattsPerMeter. + /// + public double KilowattsPerMeter => As(LinearPowerDensityUnit.KilowattPerMeter); + + /// + /// Get LinearPowerDensity in KilowattsPerMillimeter. + /// + public double KilowattsPerMillimeter => As(LinearPowerDensityUnit.KilowattPerMillimeter); + + /// + /// Get LinearPowerDensity in MegawattsPerCentimeter. + /// + public double MegawattsPerCentimeter => As(LinearPowerDensityUnit.MegawattPerCentimeter); + + /// + /// Get LinearPowerDensity in MegawattsPerFoot. + /// + public double MegawattsPerFoot => As(LinearPowerDensityUnit.MegawattPerFoot); + + /// + /// Get LinearPowerDensity in MegawattsPerInch. + /// + public double MegawattsPerInch => As(LinearPowerDensityUnit.MegawattPerInch); + + /// + /// Get LinearPowerDensity in MegawattsPerMeter. + /// + public double MegawattsPerMeter => As(LinearPowerDensityUnit.MegawattPerMeter); + + /// + /// Get LinearPowerDensity in MegawattsPerMillimeter. + /// + public double MegawattsPerMillimeter => As(LinearPowerDensityUnit.MegawattPerMillimeter); + + /// + /// Get LinearPowerDensity in MilliwattsPerCentimeter. + /// + public double MilliwattsPerCentimeter => As(LinearPowerDensityUnit.MilliwattPerCentimeter); + + /// + /// Get LinearPowerDensity in MilliwattsPerFoot. + /// + public double MilliwattsPerFoot => As(LinearPowerDensityUnit.MilliwattPerFoot); + + /// + /// Get LinearPowerDensity in MilliwattsPerInch. + /// + public double MilliwattsPerInch => As(LinearPowerDensityUnit.MilliwattPerInch); + + /// + /// Get LinearPowerDensity in MilliwattsPerMeter. + /// + public double MilliwattsPerMeter => As(LinearPowerDensityUnit.MilliwattPerMeter); + + /// + /// Get LinearPowerDensity in MilliwattsPerMillimeter. + /// + public double MilliwattsPerMillimeter => As(LinearPowerDensityUnit.MilliwattPerMillimeter); + + /// + /// Get LinearPowerDensity in WattsPerCentimeter. + /// + public double WattsPerCentimeter => As(LinearPowerDensityUnit.WattPerCentimeter); + + /// + /// Get LinearPowerDensity in WattsPerFoot. + /// + public double WattsPerFoot => As(LinearPowerDensityUnit.WattPerFoot); + + /// + /// Get LinearPowerDensity in WattsPerInch. + /// + public double WattsPerInch => As(LinearPowerDensityUnit.WattPerInch); + + /// + /// Get LinearPowerDensity in WattsPerMeter. + /// + public double WattsPerMeter => As(LinearPowerDensityUnit.WattPerMeter); + + /// + /// Get LinearPowerDensity in WattsPerMillimeter. + /// + public double WattsPerMillimeter => As(LinearPowerDensityUnit.WattPerMillimeter); + + #endregion + + #region Static Methods + + /// + /// Get unit abbreviation string. + /// + /// Unit to get abbreviation for. + /// Unit abbreviation string. + public static string GetAbbreviation(LinearPowerDensityUnit unit) + { + return GetAbbreviation(unit, null); + } + + /// + /// Get unit abbreviation string. + /// + /// Unit to get abbreviation for. + /// Unit abbreviation string. + /// Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to if null. + public static string GetAbbreviation(LinearPowerDensityUnit unit, [CanBeNull] string cultureName) + { + IFormatProvider provider = GetFormatProviderFromCultureName(cultureName); + return UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit, provider); + } + + #endregion + + #region Static Factory Methods + + /// + /// Get LinearPowerDensity from GigawattsPerCentimeter. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static LinearPowerDensity FromGigawattsPerCentimeter(double gigawattspercentimeter) + { + double value = (double) gigawattspercentimeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerCentimeter); + } + /// + /// Get LinearPowerDensity from GigawattsPerFoot. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static LinearPowerDensity FromGigawattsPerFoot(double gigawattsperfoot) + { + double value = (double) gigawattsperfoot; + return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerFoot); + } + /// + /// Get LinearPowerDensity from GigawattsPerInch. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static LinearPowerDensity FromGigawattsPerInch(double gigawattsperinch) + { + double value = (double) gigawattsperinch; + return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerInch); + } + /// + /// Get LinearPowerDensity from GigawattsPerMeter. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static LinearPowerDensity FromGigawattsPerMeter(double gigawattspermeter) + { + double value = (double) gigawattspermeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerMeter); + } + /// + /// Get LinearPowerDensity from GigawattsPerMillimeter. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static LinearPowerDensity FromGigawattsPerMillimeter(double gigawattspermillimeter) + { + double value = (double) gigawattspermillimeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerMillimeter); + } + /// + /// Get LinearPowerDensity from KilowattsPerCentimeter. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static LinearPowerDensity FromKilowattsPerCentimeter(double kilowattspercentimeter) + { + double value = (double) kilowattspercentimeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerCentimeter); + } + /// + /// Get LinearPowerDensity from KilowattsPerFoot. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static LinearPowerDensity FromKilowattsPerFoot(double kilowattsperfoot) + { + double value = (double) kilowattsperfoot; + return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerFoot); + } + /// + /// Get LinearPowerDensity from KilowattsPerInch. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static LinearPowerDensity FromKilowattsPerInch(double kilowattsperinch) + { + double value = (double) kilowattsperinch; + return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerInch); + } + /// + /// Get LinearPowerDensity from KilowattsPerMeter. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static LinearPowerDensity FromKilowattsPerMeter(double kilowattspermeter) + { + double value = (double) kilowattspermeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerMeter); + } + /// + /// Get LinearPowerDensity from KilowattsPerMillimeter. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static LinearPowerDensity FromKilowattsPerMillimeter(double kilowattspermillimeter) + { + double value = (double) kilowattspermillimeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerMillimeter); + } + /// + /// Get LinearPowerDensity from MegawattsPerCentimeter. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static LinearPowerDensity FromMegawattsPerCentimeter(double megawattspercentimeter) + { + double value = (double) megawattspercentimeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerCentimeter); + } + /// + /// Get LinearPowerDensity from MegawattsPerFoot. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static LinearPowerDensity FromMegawattsPerFoot(double megawattsperfoot) + { + double value = (double) megawattsperfoot; + return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerFoot); + } + /// + /// Get LinearPowerDensity from MegawattsPerInch. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static LinearPowerDensity FromMegawattsPerInch(double megawattsperinch) + { + double value = (double) megawattsperinch; + return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerInch); + } + /// + /// Get LinearPowerDensity from MegawattsPerMeter. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static LinearPowerDensity FromMegawattsPerMeter(double megawattspermeter) + { + double value = (double) megawattspermeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerMeter); + } + /// + /// Get LinearPowerDensity from MegawattsPerMillimeter. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static LinearPowerDensity FromMegawattsPerMillimeter(double megawattspermillimeter) + { + double value = (double) megawattspermillimeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerMillimeter); + } + /// + /// Get LinearPowerDensity from MilliwattsPerCentimeter. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static LinearPowerDensity FromMilliwattsPerCentimeter(double milliwattspercentimeter) + { + double value = (double) milliwattspercentimeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerCentimeter); + } + /// + /// Get LinearPowerDensity from MilliwattsPerFoot. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static LinearPowerDensity FromMilliwattsPerFoot(double milliwattsperfoot) + { + double value = (double) milliwattsperfoot; + return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerFoot); + } + /// + /// Get LinearPowerDensity from MilliwattsPerInch. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static LinearPowerDensity FromMilliwattsPerInch(double milliwattsperinch) + { + double value = (double) milliwattsperinch; + return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerInch); + } + /// + /// Get LinearPowerDensity from MilliwattsPerMeter. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static LinearPowerDensity FromMilliwattsPerMeter(double milliwattspermeter) + { + double value = (double) milliwattspermeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerMeter); + } + /// + /// Get LinearPowerDensity from MilliwattsPerMillimeter. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static LinearPowerDensity FromMilliwattsPerMillimeter(double milliwattspermillimeter) + { + double value = (double) milliwattspermillimeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerMillimeter); + } + /// + /// Get LinearPowerDensity from WattsPerCentimeter. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static LinearPowerDensity FromWattsPerCentimeter(double wattspercentimeter) + { + double value = (double) wattspercentimeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerCentimeter); + } + /// + /// Get LinearPowerDensity from WattsPerFoot. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static LinearPowerDensity FromWattsPerFoot(double wattsperfoot) + { + double value = (double) wattsperfoot; + return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerFoot); + } + /// + /// Get LinearPowerDensity from WattsPerInch. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static LinearPowerDensity FromWattsPerInch(double wattsperinch) + { + double value = (double) wattsperinch; + return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerInch); + } + /// + /// Get LinearPowerDensity from WattsPerMeter. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static LinearPowerDensity FromWattsPerMeter(double wattspermeter) + { + double value = (double) wattspermeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerMeter); + } + /// + /// Get LinearPowerDensity from WattsPerMillimeter. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static LinearPowerDensity FromWattsPerMillimeter(double wattspermillimeter) + { + double value = (double) wattspermillimeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerMillimeter); + } + + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// LinearPowerDensity unit value. + // Fix name conflict with parameter "value" + [return: System.Runtime.InteropServices.WindowsRuntime.ReturnValueName("returnValue")] + public static LinearPowerDensity From(double value, LinearPowerDensityUnit fromUnit) + { + return new LinearPowerDensity((double)value, fromUnit); + } + + #endregion + + #region Static Parse Methods + + /// + /// Parse a string with one or two quantities of the format "<quantity> <unit>". + /// + /// String to parse. Typically in the form: {number} {unit} + /// + /// Length.Parse("5.5 m", new CultureInfo("en-US")); + /// + /// The value of 'str' cannot be null. + /// + /// Expected string to have one or two pairs of quantity and unit in the format + /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" + /// + /// + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . + /// + /// + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. + /// + public static LinearPowerDensity Parse(string str) + { + return Parse(str, null); + } + + /// + /// Parse a string with one or two quantities of the format "<quantity> <unit>". + /// + /// String to parse. Typically in the form: {number} {unit} + /// + /// Length.Parse("5.5 m", new CultureInfo("en-US")); + /// + /// The value of 'str' cannot be null. + /// + /// Expected string to have one or two pairs of quantity and unit in the format + /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" + /// + /// + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . + /// + /// + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. + /// + /// Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to if null. + public static LinearPowerDensity Parse(string str, [CanBeNull] string cultureName) + { + IFormatProvider provider = GetFormatProviderFromCultureName(cultureName); + return QuantityParser.Default.Parse( + str, + provider, + From); + } + + /// + /// Try to parse a string with one or two quantities of the format "<quantity> <unit>". + /// + /// String to parse. Typically in the form: {number} {unit} + /// Resulting unit quantity if successful. + /// + /// Length.Parse("5.5 m", new CultureInfo("en-US")); + /// + public static bool TryParse([CanBeNull] string str, out LinearPowerDensity result) + { + return TryParse(str, null, out result); + } + + /// + /// Try to parse a string with one or two quantities of the format "<quantity> <unit>". + /// + /// String to parse. Typically in the form: {number} {unit} + /// Resulting unit quantity if successful. + /// True if successful, otherwise false. + /// + /// Length.Parse("5.5 m", new CultureInfo("en-US")); + /// + /// Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to if null. + public static bool TryParse([CanBeNull] string str, [CanBeNull] string cultureName, out LinearPowerDensity result) + { + IFormatProvider provider = GetFormatProviderFromCultureName(cultureName); + return QuantityParser.Default.TryParse( + str, + provider, + From, + out result); + } + + /// + /// Parse a unit string. + /// + /// String to parse. Typically in the form: {number} {unit} + /// + /// Length.ParseUnit("m", new CultureInfo("en-US")); + /// + /// The value of 'str' cannot be null. + /// Error parsing string. + public static LinearPowerDensityUnit ParseUnit(string str) + { + return ParseUnit(str, null); + } + + /// + /// Parse a unit string. + /// + /// String to parse. Typically in the form: {number} {unit} + /// + /// Length.ParseUnit("m", new CultureInfo("en-US")); + /// + /// The value of 'str' cannot be null. + /// Error parsing string. + /// Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to if null. + public static LinearPowerDensityUnit ParseUnit(string str, [CanBeNull] string cultureName) + { + IFormatProvider provider = GetFormatProviderFromCultureName(cultureName); + return UnitParser.Default.Parse(str, provider); + } + + public static bool TryParseUnit(string str, out LinearPowerDensityUnit unit) + { + return TryParseUnit(str, null, out unit); + } + + /// + /// Parse a unit string. + /// + /// String to parse. Typically in the form: {number} {unit} + /// The parsed unit if successful. + /// True if successful, otherwise false. + /// + /// Length.TryParseUnit("m", new CultureInfo("en-US")); + /// + /// Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to if null. + public static bool TryParseUnit(string str, [CanBeNull] string cultureName, out LinearPowerDensityUnit unit) + { + IFormatProvider provider = GetFormatProviderFromCultureName(cultureName); + return UnitParser.Default.TryParse(str, provider, out unit); + } + + #endregion + + #region Equality / IComparable + + public int CompareTo(object obj) + { + if(obj is null) throw new ArgumentNullException(nameof(obj)); + if(!(obj is LinearPowerDensity objLinearPowerDensity)) throw new ArgumentException("Expected type LinearPowerDensity.", nameof(obj)); + + return CompareTo(objLinearPowerDensity); + } + + // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods + internal int CompareTo(LinearPowerDensity other) + { + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + } + + [Windows.Foundation.Metadata.DefaultOverload] + public override bool Equals(object obj) + { + if(obj is null || !(obj is LinearPowerDensity objLinearPowerDensity)) + return false; + + return Equals(objLinearPowerDensity); + } + + public bool Equals(LinearPowerDensity other) + { + return _value.Equals(other.AsBaseNumericType(this.Unit)); + } + + /// + /// + /// Compare equality to another LinearPowerDensity within the given absolute or relative tolerance. + /// + /// + /// Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and + /// as a percentage of this quantity's value. will be converted into + /// this quantity's unit for comparison. A relative tolerance of 0.01 means the absolute difference must be within +/- 1% of + /// this quantity's value to be considered equal. + /// + /// In this example, the two quantities will be equal if the value of b is within +/- 1% of a (0.02m or 2cm). + /// + /// var a = Length.FromMeters(2.0); + /// var b = Length.FromInches(50.0); + /// a.Equals(b, 0.01, ComparisonType.Relative); + /// + /// + /// + /// + /// Absolute tolerance is defined as the maximum allowable absolute difference between this quantity's value and + /// as a fixed number in this quantity's unit. will be converted into + /// this quantity's unit for comparison. + /// + /// In this example, the two quantities will be equal if the value of b is within 0.01 of a (0.01m or 1cm). + /// + /// var a = Length.FromMeters(2.0); + /// var b = Length.FromInches(50.0); + /// a.Equals(b, 0.01, ComparisonType.Absolute); + /// + /// + /// + /// + /// Note that it is advised against specifying zero difference, due to the nature + /// of floating point operations and using System.Double internally. + /// + /// + /// The other quantity to compare to. + /// The absolute or relative tolerance value. Must be greater than or equal to 0. + /// The comparison type: either relative or absolute. + /// True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance. + public bool Equals(LinearPowerDensity other, double tolerance, ComparisonType comparisonType) + { + if(tolerance < 0) + throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0."); + + double thisValue = (double)this.Value; + double otherValueInThisUnits = other.As(this.Unit); + + return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType); + } + + /// + /// Returns the hash code for this instance. + /// + /// A hash code for the current LinearPowerDensity. + public override int GetHashCode() + { + return new { QuantityType, Value, Unit }.GetHashCode(); + } + + #endregion + + #region Conversion Methods + + double IQuantity.As(object unit) => As((LinearPowerDensityUnit)unit); + + /// + /// Convert to the unit representation . + /// + /// Value converted to the specified unit. + public double As(LinearPowerDensityUnit unit) + { + if(Unit == unit) + return Convert.ToDouble(Value); + + var converted = AsBaseNumericType(unit); + return Convert.ToDouble(converted); + } + + /// + /// Converts this LinearPowerDensity to another LinearPowerDensity with the unit representation . + /// + /// A LinearPowerDensity with the specified unit. + public LinearPowerDensity ToUnit(LinearPowerDensityUnit unit) + { + var convertedValue = AsBaseNumericType(unit); + return new LinearPowerDensity(convertedValue, unit); + } + + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + private double AsBaseUnit() + { + switch(Unit) + { + case LinearPowerDensityUnit.GigawattPerCentimeter: return (_value*1e2) * 1e9d; + case LinearPowerDensityUnit.GigawattPerFoot: return (_value*3.280839895) * 1e9d; + case LinearPowerDensityUnit.GigawattPerInch: return (_value*39.37007874) * 1e9d; + case LinearPowerDensityUnit.GigawattPerMeter: return (_value) * 1e9d; + case LinearPowerDensityUnit.GigawattPerMillimeter: return (_value*1e3) * 1e9d; + case LinearPowerDensityUnit.KilowattPerCentimeter: return (_value*1e2) * 1e3d; + case LinearPowerDensityUnit.KilowattPerFoot: return (_value*3.280839895) * 1e3d; + case LinearPowerDensityUnit.KilowattPerInch: return (_value*39.37007874) * 1e3d; + case LinearPowerDensityUnit.KilowattPerMeter: return (_value) * 1e3d; + case LinearPowerDensityUnit.KilowattPerMillimeter: return (_value*1e3) * 1e3d; + case LinearPowerDensityUnit.MegawattPerCentimeter: return (_value*1e2) * 1e6d; + case LinearPowerDensityUnit.MegawattPerFoot: return (_value*3.280839895) * 1e6d; + case LinearPowerDensityUnit.MegawattPerInch: return (_value*39.37007874) * 1e6d; + case LinearPowerDensityUnit.MegawattPerMeter: return (_value) * 1e6d; + case LinearPowerDensityUnit.MegawattPerMillimeter: return (_value*1e3) * 1e6d; + case LinearPowerDensityUnit.MilliwattPerCentimeter: return (_value*1e2) * 1e-3d; + case LinearPowerDensityUnit.MilliwattPerFoot: return (_value*3.280839895) * 1e-3d; + case LinearPowerDensityUnit.MilliwattPerInch: return (_value*39.37007874) * 1e-3d; + case LinearPowerDensityUnit.MilliwattPerMeter: return (_value) * 1e-3d; + case LinearPowerDensityUnit.MilliwattPerMillimeter: return (_value*1e3) * 1e-3d; + case LinearPowerDensityUnit.WattPerCentimeter: return _value*1e2; + case LinearPowerDensityUnit.WattPerFoot: return _value*3.280839895; + case LinearPowerDensityUnit.WattPerInch: return _value*39.37007874; + case LinearPowerDensityUnit.WattPerMeter: return _value; + case LinearPowerDensityUnit.WattPerMillimeter: return _value*1e3; + default: + throw new NotImplementedException($"Can not convert {Unit} to base units."); + } + } + + private double AsBaseNumericType(LinearPowerDensityUnit unit) + { + if(Unit == unit) + return _value; + + var baseUnitValue = AsBaseUnit(); + + switch(unit) + { + case LinearPowerDensityUnit.GigawattPerCentimeter: return (baseUnitValue/1e2) / 1e9d; + case LinearPowerDensityUnit.GigawattPerFoot: return (baseUnitValue/3.280839895) / 1e9d; + case LinearPowerDensityUnit.GigawattPerInch: return (baseUnitValue/39.37007874) / 1e9d; + case LinearPowerDensityUnit.GigawattPerMeter: return (baseUnitValue) / 1e9d; + case LinearPowerDensityUnit.GigawattPerMillimeter: return (baseUnitValue/1e3) / 1e9d; + case LinearPowerDensityUnit.KilowattPerCentimeter: return (baseUnitValue/1e2) / 1e3d; + case LinearPowerDensityUnit.KilowattPerFoot: return (baseUnitValue/3.280839895) / 1e3d; + case LinearPowerDensityUnit.KilowattPerInch: return (baseUnitValue/39.37007874) / 1e3d; + case LinearPowerDensityUnit.KilowattPerMeter: return (baseUnitValue) / 1e3d; + case LinearPowerDensityUnit.KilowattPerMillimeter: return (baseUnitValue/1e3) / 1e3d; + case LinearPowerDensityUnit.MegawattPerCentimeter: return (baseUnitValue/1e2) / 1e6d; + case LinearPowerDensityUnit.MegawattPerFoot: return (baseUnitValue/3.280839895) / 1e6d; + case LinearPowerDensityUnit.MegawattPerInch: return (baseUnitValue/39.37007874) / 1e6d; + case LinearPowerDensityUnit.MegawattPerMeter: return (baseUnitValue) / 1e6d; + case LinearPowerDensityUnit.MegawattPerMillimeter: return (baseUnitValue/1e3) / 1e6d; + case LinearPowerDensityUnit.MilliwattPerCentimeter: return (baseUnitValue/1e2) / 1e-3d; + case LinearPowerDensityUnit.MilliwattPerFoot: return (baseUnitValue/3.280839895) / 1e-3d; + case LinearPowerDensityUnit.MilliwattPerInch: return (baseUnitValue/39.37007874) / 1e-3d; + case LinearPowerDensityUnit.MilliwattPerMeter: return (baseUnitValue) / 1e-3d; + case LinearPowerDensityUnit.MilliwattPerMillimeter: return (baseUnitValue/1e3) / 1e-3d; + case LinearPowerDensityUnit.WattPerCentimeter: return baseUnitValue/1e2; + case LinearPowerDensityUnit.WattPerFoot: return baseUnitValue/3.280839895; + case LinearPowerDensityUnit.WattPerInch: return baseUnitValue/39.37007874; + case LinearPowerDensityUnit.WattPerMeter: return baseUnitValue; + case LinearPowerDensityUnit.WattPerMillimeter: return baseUnitValue/1e3; + default: + throw new NotImplementedException($"Can not convert {Unit} to {unit}."); + } + } + + #endregion + + #region ToString Methods + + /// + /// Get default string representation of value and unit. + /// + /// String representation. + public override string ToString() + { + return ToString(null); + } + + /// + /// Get string representation of value and unit. Using two significant digits after radix. + /// + /// String representation. + /// Name of culture (ex: "en-US") to use for localization and number formatting. Defaults to if null. + public string ToString([CanBeNull] string cultureName) + { + var provider = cultureName; + return ToString(provider, 2); + } + + /// + /// Get string representation of value and unit. + /// + /// The number of significant digits after the radix point. + /// String representation. + /// Name of culture (ex: "en-US") to use for localization and number formatting. Defaults to if null. + public string ToString(string cultureName, int significantDigitsAfterRadix) + { + var provider = cultureName; + var value = Convert.ToDouble(Value); + var format = UnitFormatter.GetFormat(value, significantDigitsAfterRadix); + return ToString(provider, format); + } + + /// + /// Get string representation of value and unit. + /// + /// String format to use. Default: "{0:0.##} {1} for value and unit abbreviation respectively." + /// Arguments for string format. Value and unit are implicitly included as arguments 0 and 1. + /// String representation. + /// Name of culture (ex: "en-US") to use for localization and number formatting. Defaults to if null. + public string ToString([CanBeNull] string cultureName, [NotNull] string format, [NotNull] params object[] args) + { + var provider = GetFormatProviderFromCultureName(cultureName); + if (format == null) throw new ArgumentNullException(nameof(format)); + if (args == null) throw new ArgumentNullException(nameof(args)); + + provider = provider ?? GlobalConfiguration.DefaultCulture; + + var value = Convert.ToDouble(Value); + var formatArgs = UnitFormatter.GetFormatArgs(Unit, value, provider, args); + return string.Format(provider, format, formatArgs); + } + + #endregion + + private static IFormatProvider GetFormatProviderFromCultureName([CanBeNull] string cultureName) + { + return cultureName != null ? new CultureInfo(cultureName) : (IFormatProvider)null; + } + } +} diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantity.g.cs index 1b3d5f547e..b436f897ed 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantity.g.cs @@ -194,6 +194,9 @@ internal static bool TryFrom(double value, Enum unit, out IQuantity quantity) case LinearDensityUnit linearDensityUnit: quantity = LinearDensity.From(value, linearDensityUnit); return true; + case LinearPowerDensityUnit linearPowerDensityUnit: + quantity = LinearPowerDensity.From(value, linearPowerDensityUnit); + return true; case LuminosityUnit luminosityUnit: quantity = Luminosity.From(value, luminosityUnit); return true; @@ -544,6 +547,9 @@ internal static bool TryParse([CanBeNull] IFormatProvider formatProvider, Type q if (quantityType == typeof(LinearDensity)) return parser.TryParse(quantityString, formatProvider, LinearDensity.From, out quantity); + if (quantityType == typeof(LinearPowerDensity)) + return parser.TryParse(quantityString, formatProvider, LinearPowerDensity.From, out quantity); + if (quantityType == typeof(Luminosity)) return parser.TryParse(quantityString, formatProvider, Luminosity.From, out quantity); diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/QuantityType.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/QuantityType.g.cs index a6e4cec3e9..ecdb0c8b69 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/QuantityType.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/QuantityType.g.cs @@ -80,6 +80,7 @@ public enum QuantityType Length, Level, LinearDensity, + LinearPowerDensity, Luminosity, LuminousFlux, LuminousIntensity, diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs index 222b7d750d..f32b2d23c9 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs @@ -615,6 +615,31 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(LinearDensityUnit), (int)LinearDensityUnit.MilligramPerMillimeter, new string[]{"mg/mm"}), ("en-US", typeof(LinearDensityUnit), (int)LinearDensityUnit.PoundPerFoot, new string[]{"lb/ft"}), ("en-US", typeof(LinearDensityUnit), (int)LinearDensityUnit.PoundPerInch, new string[]{"lb/in"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.GigawattPerCentimeter, new string[]{"GW/cm"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.GigawattPerFoot, new string[]{"GW/ft"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.GigawattPerInch, new string[]{"GW/in"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.GigawattPerMeter, new string[]{"GW/m"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.GigawattPerMillimeter, new string[]{"GW/mm"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.KilowattPerCentimeter, new string[]{"kW/cm"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.KilowattPerFoot, new string[]{"kW/ft"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.KilowattPerInch, new string[]{"kW/in"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.KilowattPerMeter, new string[]{"kW/m"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.KilowattPerMillimeter, new string[]{"kW/mm"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.MegawattPerCentimeter, new string[]{"MW/cm"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.MegawattPerFoot, new string[]{"MW/ft"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.MegawattPerInch, new string[]{"MW/in"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.MegawattPerMeter, new string[]{"MW/m"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.MegawattPerMillimeter, new string[]{"MW/mm"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.MilliwattPerCentimeter, new string[]{"mW/cm"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.MilliwattPerFoot, new string[]{"mW/ft"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.MilliwattPerInch, new string[]{"mW/in"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.MilliwattPerMeter, new string[]{"mW/m"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.MilliwattPerMillimeter, new string[]{"mW/mm"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.WattPerCentimeter, new string[]{"W/cm"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.WattPerFoot, new string[]{"W/ft"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.WattPerInch, new string[]{"W/in"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.WattPerMeter, new string[]{"W/m"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.WattPerMillimeter, new string[]{"W/mm"}), ("en-US", typeof(LuminosityUnit), (int)LuminosityUnit.Decawatt, new string[]{"daW"}), ("en-US", typeof(LuminosityUnit), (int)LuminosityUnit.Deciwatt, new string[]{"dW"}), ("en-US", typeof(LuminosityUnit), (int)LuminosityUnit.Femtowatt, new string[]{"fW"}), diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/LinearPowerDensityUnit.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/LinearPowerDensityUnit.g.cs new file mode 100644 index 0000000000..8395416543 --- /dev/null +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/LinearPowerDensityUnit.g.cs @@ -0,0 +1,57 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by \generate-code.bat. +// +// Changes to this file will be lost when the code is regenerated. +// The build server regenerates the code before each build and a pre-build +// step will regenerate the code on each local build. +// +// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units. +// +// Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities. +// Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities. +// +// +//------------------------------------------------------------------------------ + +// Licensed under MIT No Attribution, see LICENSE file at the root. +// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet. + +// ReSharper disable once CheckNamespace +namespace UnitsNet.Units +{ + // Disable missing XML comment warnings for the generated unit enums. + #pragma warning disable 1591 + + public enum LinearPowerDensityUnit + { + Undefined = 0, + GigawattPerCentimeter, + GigawattPerFoot, + GigawattPerInch, + GigawattPerMeter, + GigawattPerMillimeter, + KilowattPerCentimeter, + KilowattPerFoot, + KilowattPerInch, + KilowattPerMeter, + KilowattPerMillimeter, + MegawattPerCentimeter, + MegawattPerFoot, + MegawattPerInch, + MegawattPerMeter, + MegawattPerMillimeter, + MilliwattPerCentimeter, + MilliwattPerFoot, + MilliwattPerInch, + MilliwattPerMeter, + MilliwattPerMillimeter, + WattPerCentimeter, + WattPerFoot, + WattPerInch, + WattPerMeter, + WattPerMillimeter, + } + + #pragma warning restore 1591 +} diff --git a/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs new file mode 100644 index 0000000000..a5de965729 --- /dev/null +++ b/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs @@ -0,0 +1,1261 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by \generate-code.bat. +// +// Changes to this file will be lost when the code is regenerated. +// The build server regenerates the code before each build and a pre-build +// step will regenerate the code on each local build. +// +// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units. +// +// Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities. +// Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities. +// +// +//------------------------------------------------------------------------------ + +// Licensed under MIT No Attribution, see LICENSE file at the root. +// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet. + +using System; +using System.Globalization; +using System.Linq; +using JetBrains.Annotations; +using UnitsNet.InternalHelpers; +using UnitsNet.Units; + +// ReSharper disable once CheckNamespace + +namespace UnitsNet +{ + /// + /// + /// The Linear Power Density of a substance is its power per unit length. The term linear density is most often used when describing the characteristics of one-dimensional objects, although linear density can also be used to describe the density of a three-dimensional quantity along one particular dimension. + /// + /// + /// http://en.wikipedia.org/wiki/Linear_density + /// + public partial struct LinearPowerDensity : IQuantity, IEquatable, IComparable, IComparable, IConvertible, IFormattable + { + /// + /// The numeric value this quantity was constructed with. + /// + private readonly double _value; + + /// + /// The unit this quantity was constructed with. + /// + private readonly LinearPowerDensityUnit? _unit; + + static LinearPowerDensity() + { + BaseDimensions = new BaseDimensions(1, 1, -3, 0, 0, 0, 0); + + Info = new QuantityInfo(QuantityType.LinearPowerDensity, + new UnitInfo[] { + new UnitInfo(LinearPowerDensityUnit.GigawattPerCentimeter, BaseUnits.Undefined), + new UnitInfo(LinearPowerDensityUnit.GigawattPerFoot, BaseUnits.Undefined), + new UnitInfo(LinearPowerDensityUnit.GigawattPerInch, BaseUnits.Undefined), + new UnitInfo(LinearPowerDensityUnit.GigawattPerMeter, BaseUnits.Undefined), + new UnitInfo(LinearPowerDensityUnit.GigawattPerMillimeter, BaseUnits.Undefined), + new UnitInfo(LinearPowerDensityUnit.KilowattPerCentimeter, BaseUnits.Undefined), + new UnitInfo(LinearPowerDensityUnit.KilowattPerFoot, BaseUnits.Undefined), + new UnitInfo(LinearPowerDensityUnit.KilowattPerInch, BaseUnits.Undefined), + new UnitInfo(LinearPowerDensityUnit.KilowattPerMeter, BaseUnits.Undefined), + new UnitInfo(LinearPowerDensityUnit.KilowattPerMillimeter, BaseUnits.Undefined), + new UnitInfo(LinearPowerDensityUnit.MegawattPerCentimeter, BaseUnits.Undefined), + new UnitInfo(LinearPowerDensityUnit.MegawattPerFoot, BaseUnits.Undefined), + new UnitInfo(LinearPowerDensityUnit.MegawattPerInch, BaseUnits.Undefined), + new UnitInfo(LinearPowerDensityUnit.MegawattPerMeter, BaseUnits.Undefined), + new UnitInfo(LinearPowerDensityUnit.MegawattPerMillimeter, BaseUnits.Undefined), + new UnitInfo(LinearPowerDensityUnit.MilliwattPerCentimeter, BaseUnits.Undefined), + new UnitInfo(LinearPowerDensityUnit.MilliwattPerFoot, BaseUnits.Undefined), + new UnitInfo(LinearPowerDensityUnit.MilliwattPerInch, BaseUnits.Undefined), + new UnitInfo(LinearPowerDensityUnit.MilliwattPerMeter, BaseUnits.Undefined), + new UnitInfo(LinearPowerDensityUnit.MilliwattPerMillimeter, BaseUnits.Undefined), + new UnitInfo(LinearPowerDensityUnit.WattPerCentimeter, BaseUnits.Undefined), + new UnitInfo(LinearPowerDensityUnit.WattPerFoot, BaseUnits.Undefined), + new UnitInfo(LinearPowerDensityUnit.WattPerInch, BaseUnits.Undefined), + new UnitInfo(LinearPowerDensityUnit.WattPerMeter, BaseUnits.Undefined), + new UnitInfo(LinearPowerDensityUnit.WattPerMillimeter, BaseUnits.Undefined), + }, + BaseUnit, Zero, BaseDimensions); + } + + /// + /// Creates the quantity with the given numeric value and unit. + /// + /// The numeric value to construct this quantity with. + /// The unit representation to construct this quantity with. + /// If value is NaN or Infinity. + public LinearPowerDensity(double value, LinearPowerDensityUnit unit) + { + if(unit == LinearPowerDensityUnit.Undefined) + throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit)); + + _value = Guard.EnsureValidNumber(value, nameof(value)); + _unit = unit; + } + + /// + /// Creates an instance of the quantity with the given numeric value in units compatible with the given . + /// If multiple compatible units were found, the first match is used. + /// + /// The numeric value to construct this quantity with. + /// The unit system to create the quantity with. + /// The given is null. + /// No unit was found for the given . + public LinearPowerDensity(double value, UnitSystem unitSystem) + { + if(unitSystem == null) throw new ArgumentNullException(nameof(unitSystem)); + + var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits); + var firstUnitInfo = unitInfos.FirstOrDefault(); + + _value = Guard.EnsureValidNumber(value, nameof(value)); + _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem)); + } + + #region Static Properties + + /// + public static QuantityInfo Info { get; } + + /// + /// The of this quantity. + /// + public static BaseDimensions BaseDimensions { get; } + + /// + /// The base unit of LinearPowerDensity, which is WattPerMeter. All conversions go via this value. + /// + public static LinearPowerDensityUnit BaseUnit { get; } = LinearPowerDensityUnit.WattPerMeter; + + /// + /// Represents the largest possible value of LinearPowerDensity + /// + public static LinearPowerDensity MaxValue { get; } = new LinearPowerDensity(double.MaxValue, BaseUnit); + + /// + /// Represents the smallest possible value of LinearPowerDensity + /// + public static LinearPowerDensity MinValue { get; } = new LinearPowerDensity(double.MinValue, BaseUnit); + + /// + /// The of this quantity. + /// + public static QuantityType QuantityType { get; } = QuantityType.LinearPowerDensity; + + /// + /// All units of measurement for the LinearPowerDensity quantity. + /// + public static LinearPowerDensityUnit[] Units { get; } = Enum.GetValues(typeof(LinearPowerDensityUnit)).Cast().Except(new LinearPowerDensityUnit[]{ LinearPowerDensityUnit.Undefined }).ToArray(); + + /// + /// Gets an instance of this quantity with a value of 0 in the base unit WattPerMeter. + /// + public static LinearPowerDensity Zero { get; } = new LinearPowerDensity(0, BaseUnit); + + #endregion + + #region Properties + + /// + /// The numeric value this quantity was constructed with. + /// + public double Value => _value; + + Enum IQuantity.Unit => Unit; + + /// + public LinearPowerDensityUnit Unit => _unit.GetValueOrDefault(BaseUnit); + + /// + public QuantityInfo QuantityInfo => Info; + + /// + QuantityInfo IQuantity.QuantityInfo => Info; + + /// + /// The of this quantity. + /// + public QuantityType Type => LinearPowerDensity.QuantityType; + + /// + /// The of this quantity. + /// + public BaseDimensions Dimensions => LinearPowerDensity.BaseDimensions; + + #endregion + + #region Conversion Properties + + /// + /// Get LinearPowerDensity in GigawattsPerCentimeter. + /// + public double GigawattsPerCentimeter => As(LinearPowerDensityUnit.GigawattPerCentimeter); + + /// + /// Get LinearPowerDensity in GigawattsPerFoot. + /// + public double GigawattsPerFoot => As(LinearPowerDensityUnit.GigawattPerFoot); + + /// + /// Get LinearPowerDensity in GigawattsPerInch. + /// + public double GigawattsPerInch => As(LinearPowerDensityUnit.GigawattPerInch); + + /// + /// Get LinearPowerDensity in GigawattsPerMeter. + /// + public double GigawattsPerMeter => As(LinearPowerDensityUnit.GigawattPerMeter); + + /// + /// Get LinearPowerDensity in GigawattsPerMillimeter. + /// + public double GigawattsPerMillimeter => As(LinearPowerDensityUnit.GigawattPerMillimeter); + + /// + /// Get LinearPowerDensity in KilowattsPerCentimeter. + /// + public double KilowattsPerCentimeter => As(LinearPowerDensityUnit.KilowattPerCentimeter); + + /// + /// Get LinearPowerDensity in KilowattsPerFoot. + /// + public double KilowattsPerFoot => As(LinearPowerDensityUnit.KilowattPerFoot); + + /// + /// Get LinearPowerDensity in KilowattsPerInch. + /// + public double KilowattsPerInch => As(LinearPowerDensityUnit.KilowattPerInch); + + /// + /// Get LinearPowerDensity in KilowattsPerMeter. + /// + public double KilowattsPerMeter => As(LinearPowerDensityUnit.KilowattPerMeter); + + /// + /// Get LinearPowerDensity in KilowattsPerMillimeter. + /// + public double KilowattsPerMillimeter => As(LinearPowerDensityUnit.KilowattPerMillimeter); + + /// + /// Get LinearPowerDensity in MegawattsPerCentimeter. + /// + public double MegawattsPerCentimeter => As(LinearPowerDensityUnit.MegawattPerCentimeter); + + /// + /// Get LinearPowerDensity in MegawattsPerFoot. + /// + public double MegawattsPerFoot => As(LinearPowerDensityUnit.MegawattPerFoot); + + /// + /// Get LinearPowerDensity in MegawattsPerInch. + /// + public double MegawattsPerInch => As(LinearPowerDensityUnit.MegawattPerInch); + + /// + /// Get LinearPowerDensity in MegawattsPerMeter. + /// + public double MegawattsPerMeter => As(LinearPowerDensityUnit.MegawattPerMeter); + + /// + /// Get LinearPowerDensity in MegawattsPerMillimeter. + /// + public double MegawattsPerMillimeter => As(LinearPowerDensityUnit.MegawattPerMillimeter); + + /// + /// Get LinearPowerDensity in MilliwattsPerCentimeter. + /// + public double MilliwattsPerCentimeter => As(LinearPowerDensityUnit.MilliwattPerCentimeter); + + /// + /// Get LinearPowerDensity in MilliwattsPerFoot. + /// + public double MilliwattsPerFoot => As(LinearPowerDensityUnit.MilliwattPerFoot); + + /// + /// Get LinearPowerDensity in MilliwattsPerInch. + /// + public double MilliwattsPerInch => As(LinearPowerDensityUnit.MilliwattPerInch); + + /// + /// Get LinearPowerDensity in MilliwattsPerMeter. + /// + public double MilliwattsPerMeter => As(LinearPowerDensityUnit.MilliwattPerMeter); + + /// + /// Get LinearPowerDensity in MilliwattsPerMillimeter. + /// + public double MilliwattsPerMillimeter => As(LinearPowerDensityUnit.MilliwattPerMillimeter); + + /// + /// Get LinearPowerDensity in WattsPerCentimeter. + /// + public double WattsPerCentimeter => As(LinearPowerDensityUnit.WattPerCentimeter); + + /// + /// Get LinearPowerDensity in WattsPerFoot. + /// + public double WattsPerFoot => As(LinearPowerDensityUnit.WattPerFoot); + + /// + /// Get LinearPowerDensity in WattsPerInch. + /// + public double WattsPerInch => As(LinearPowerDensityUnit.WattPerInch); + + /// + /// Get LinearPowerDensity in WattsPerMeter. + /// + public double WattsPerMeter => As(LinearPowerDensityUnit.WattPerMeter); + + /// + /// Get LinearPowerDensity in WattsPerMillimeter. + /// + public double WattsPerMillimeter => As(LinearPowerDensityUnit.WattPerMillimeter); + + #endregion + + #region Static Methods + + /// + /// Get unit abbreviation string. + /// + /// Unit to get abbreviation for. + /// Unit abbreviation string. + public static string GetAbbreviation(LinearPowerDensityUnit unit) + { + return GetAbbreviation(unit, null); + } + + /// + /// Get unit abbreviation string. + /// + /// Unit to get abbreviation for. + /// Unit abbreviation string. + /// Format to use for localization. Defaults to if null. + public static string GetAbbreviation(LinearPowerDensityUnit unit, [CanBeNull] IFormatProvider provider) + { + return UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit, provider); + } + + #endregion + + #region Static Factory Methods + + /// + /// Get LinearPowerDensity from GigawattsPerCentimeter. + /// + /// If value is NaN or Infinity. + public static LinearPowerDensity FromGigawattsPerCentimeter(QuantityValue gigawattspercentimeter) + { + double value = (double) gigawattspercentimeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerCentimeter); + } + /// + /// Get LinearPowerDensity from GigawattsPerFoot. + /// + /// If value is NaN or Infinity. + public static LinearPowerDensity FromGigawattsPerFoot(QuantityValue gigawattsperfoot) + { + double value = (double) gigawattsperfoot; + return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerFoot); + } + /// + /// Get LinearPowerDensity from GigawattsPerInch. + /// + /// If value is NaN or Infinity. + public static LinearPowerDensity FromGigawattsPerInch(QuantityValue gigawattsperinch) + { + double value = (double) gigawattsperinch; + return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerInch); + } + /// + /// Get LinearPowerDensity from GigawattsPerMeter. + /// + /// If value is NaN or Infinity. + public static LinearPowerDensity FromGigawattsPerMeter(QuantityValue gigawattspermeter) + { + double value = (double) gigawattspermeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerMeter); + } + /// + /// Get LinearPowerDensity from GigawattsPerMillimeter. + /// + /// If value is NaN or Infinity. + public static LinearPowerDensity FromGigawattsPerMillimeter(QuantityValue gigawattspermillimeter) + { + double value = (double) gigawattspermillimeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerMillimeter); + } + /// + /// Get LinearPowerDensity from KilowattsPerCentimeter. + /// + /// If value is NaN or Infinity. + public static LinearPowerDensity FromKilowattsPerCentimeter(QuantityValue kilowattspercentimeter) + { + double value = (double) kilowattspercentimeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerCentimeter); + } + /// + /// Get LinearPowerDensity from KilowattsPerFoot. + /// + /// If value is NaN or Infinity. + public static LinearPowerDensity FromKilowattsPerFoot(QuantityValue kilowattsperfoot) + { + double value = (double) kilowattsperfoot; + return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerFoot); + } + /// + /// Get LinearPowerDensity from KilowattsPerInch. + /// + /// If value is NaN or Infinity. + public static LinearPowerDensity FromKilowattsPerInch(QuantityValue kilowattsperinch) + { + double value = (double) kilowattsperinch; + return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerInch); + } + /// + /// Get LinearPowerDensity from KilowattsPerMeter. + /// + /// If value is NaN or Infinity. + public static LinearPowerDensity FromKilowattsPerMeter(QuantityValue kilowattspermeter) + { + double value = (double) kilowattspermeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerMeter); + } + /// + /// Get LinearPowerDensity from KilowattsPerMillimeter. + /// + /// If value is NaN or Infinity. + public static LinearPowerDensity FromKilowattsPerMillimeter(QuantityValue kilowattspermillimeter) + { + double value = (double) kilowattspermillimeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerMillimeter); + } + /// + /// Get LinearPowerDensity from MegawattsPerCentimeter. + /// + /// If value is NaN or Infinity. + public static LinearPowerDensity FromMegawattsPerCentimeter(QuantityValue megawattspercentimeter) + { + double value = (double) megawattspercentimeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerCentimeter); + } + /// + /// Get LinearPowerDensity from MegawattsPerFoot. + /// + /// If value is NaN or Infinity. + public static LinearPowerDensity FromMegawattsPerFoot(QuantityValue megawattsperfoot) + { + double value = (double) megawattsperfoot; + return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerFoot); + } + /// + /// Get LinearPowerDensity from MegawattsPerInch. + /// + /// If value is NaN or Infinity. + public static LinearPowerDensity FromMegawattsPerInch(QuantityValue megawattsperinch) + { + double value = (double) megawattsperinch; + return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerInch); + } + /// + /// Get LinearPowerDensity from MegawattsPerMeter. + /// + /// If value is NaN or Infinity. + public static LinearPowerDensity FromMegawattsPerMeter(QuantityValue megawattspermeter) + { + double value = (double) megawattspermeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerMeter); + } + /// + /// Get LinearPowerDensity from MegawattsPerMillimeter. + /// + /// If value is NaN or Infinity. + public static LinearPowerDensity FromMegawattsPerMillimeter(QuantityValue megawattspermillimeter) + { + double value = (double) megawattspermillimeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerMillimeter); + } + /// + /// Get LinearPowerDensity from MilliwattsPerCentimeter. + /// + /// If value is NaN or Infinity. + public static LinearPowerDensity FromMilliwattsPerCentimeter(QuantityValue milliwattspercentimeter) + { + double value = (double) milliwattspercentimeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerCentimeter); + } + /// + /// Get LinearPowerDensity from MilliwattsPerFoot. + /// + /// If value is NaN or Infinity. + public static LinearPowerDensity FromMilliwattsPerFoot(QuantityValue milliwattsperfoot) + { + double value = (double) milliwattsperfoot; + return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerFoot); + } + /// + /// Get LinearPowerDensity from MilliwattsPerInch. + /// + /// If value is NaN or Infinity. + public static LinearPowerDensity FromMilliwattsPerInch(QuantityValue milliwattsperinch) + { + double value = (double) milliwattsperinch; + return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerInch); + } + /// + /// Get LinearPowerDensity from MilliwattsPerMeter. + /// + /// If value is NaN or Infinity. + public static LinearPowerDensity FromMilliwattsPerMeter(QuantityValue milliwattspermeter) + { + double value = (double) milliwattspermeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerMeter); + } + /// + /// Get LinearPowerDensity from MilliwattsPerMillimeter. + /// + /// If value is NaN or Infinity. + public static LinearPowerDensity FromMilliwattsPerMillimeter(QuantityValue milliwattspermillimeter) + { + double value = (double) milliwattspermillimeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerMillimeter); + } + /// + /// Get LinearPowerDensity from WattsPerCentimeter. + /// + /// If value is NaN or Infinity. + public static LinearPowerDensity FromWattsPerCentimeter(QuantityValue wattspercentimeter) + { + double value = (double) wattspercentimeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerCentimeter); + } + /// + /// Get LinearPowerDensity from WattsPerFoot. + /// + /// If value is NaN or Infinity. + public static LinearPowerDensity FromWattsPerFoot(QuantityValue wattsperfoot) + { + double value = (double) wattsperfoot; + return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerFoot); + } + /// + /// Get LinearPowerDensity from WattsPerInch. + /// + /// If value is NaN or Infinity. + public static LinearPowerDensity FromWattsPerInch(QuantityValue wattsperinch) + { + double value = (double) wattsperinch; + return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerInch); + } + /// + /// Get LinearPowerDensity from WattsPerMeter. + /// + /// If value is NaN or Infinity. + public static LinearPowerDensity FromWattsPerMeter(QuantityValue wattspermeter) + { + double value = (double) wattspermeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerMeter); + } + /// + /// Get LinearPowerDensity from WattsPerMillimeter. + /// + /// If value is NaN or Infinity. + public static LinearPowerDensity FromWattsPerMillimeter(QuantityValue wattspermillimeter) + { + double value = (double) wattspermillimeter; + return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerMillimeter); + } + + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// LinearPowerDensity unit value. + public static LinearPowerDensity From(QuantityValue value, LinearPowerDensityUnit fromUnit) + { + return new LinearPowerDensity((double)value, fromUnit); + } + + #endregion + + #region Static Parse Methods + + /// + /// Parse a string with one or two quantities of the format "<quantity> <unit>". + /// + /// String to parse. Typically in the form: {number} {unit} + /// + /// Length.Parse("5.5 m", new CultureInfo("en-US")); + /// + /// The value of 'str' cannot be null. + /// + /// Expected string to have one or two pairs of quantity and unit in the format + /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" + /// + /// + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . + /// + /// + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. + /// + public static LinearPowerDensity Parse(string str) + { + return Parse(str, null); + } + + /// + /// Parse a string with one or two quantities of the format "<quantity> <unit>". + /// + /// String to parse. Typically in the form: {number} {unit} + /// + /// Length.Parse("5.5 m", new CultureInfo("en-US")); + /// + /// The value of 'str' cannot be null. + /// + /// Expected string to have one or two pairs of quantity and unit in the format + /// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in" + /// + /// + /// More than one unit is represented by the specified unit abbreviation. + /// Example: Volume.Parse("1 cup") will throw, because it can refer to any of + /// , and . + /// + /// + /// If anything else goes wrong, typically due to a bug or unhandled case. + /// We wrap exceptions in to allow you to distinguish + /// Units.NET exceptions from other exceptions. + /// + /// Format to use when parsing number and unit. Defaults to if null. + public static LinearPowerDensity Parse(string str, [CanBeNull] IFormatProvider provider) + { + return QuantityParser.Default.Parse( + str, + provider, + From); + } + + /// + /// Try to parse a string with one or two quantities of the format "<quantity> <unit>". + /// + /// String to parse. Typically in the form: {number} {unit} + /// Resulting unit quantity if successful. + /// + /// Length.Parse("5.5 m", new CultureInfo("en-US")); + /// + public static bool TryParse([CanBeNull] string str, out LinearPowerDensity result) + { + return TryParse(str, null, out result); + } + + /// + /// Try to parse a string with one or two quantities of the format "<quantity> <unit>". + /// + /// String to parse. Typically in the form: {number} {unit} + /// Resulting unit quantity if successful. + /// True if successful, otherwise false. + /// + /// Length.Parse("5.5 m", new CultureInfo("en-US")); + /// + /// Format to use when parsing number and unit. Defaults to if null. + public static bool TryParse([CanBeNull] string str, [CanBeNull] IFormatProvider provider, out LinearPowerDensity result) + { + return QuantityParser.Default.TryParse( + str, + provider, + From, + out result); + } + + /// + /// Parse a unit string. + /// + /// String to parse. Typically in the form: {number} {unit} + /// + /// Length.ParseUnit("m", new CultureInfo("en-US")); + /// + /// The value of 'str' cannot be null. + /// Error parsing string. + public static LinearPowerDensityUnit ParseUnit(string str) + { + return ParseUnit(str, null); + } + + /// + /// Parse a unit string. + /// + /// String to parse. Typically in the form: {number} {unit} + /// Format to use when parsing number and unit. Defaults to if null. + /// + /// Length.ParseUnit("m", new CultureInfo("en-US")); + /// + /// The value of 'str' cannot be null. + /// Error parsing string. + public static LinearPowerDensityUnit ParseUnit(string str, [CanBeNull] IFormatProvider provider) + { + return UnitParser.Default.Parse(str, provider); + } + + /// + public static bool TryParseUnit(string str, out LinearPowerDensityUnit unit) + { + return TryParseUnit(str, null, out unit); + } + + /// + /// Parse a unit string. + /// + /// String to parse. Typically in the form: {number} {unit} + /// The parsed unit if successful. + /// True if successful, otherwise false. + /// + /// Length.TryParseUnit("m", new CultureInfo("en-US")); + /// + /// Format to use when parsing number and unit. Defaults to if null. + public static bool TryParseUnit(string str, IFormatProvider provider, out LinearPowerDensityUnit unit) + { + return UnitParser.Default.TryParse(str, provider, out unit); + } + + #endregion + + #region Arithmetic Operators + + /// Negate the value. + public static LinearPowerDensity operator -(LinearPowerDensity right) + { + return new LinearPowerDensity(-right.Value, right.Unit); + } + + /// Get from adding two . + public static LinearPowerDensity operator +(LinearPowerDensity left, LinearPowerDensity right) + { + return new LinearPowerDensity(left.Value + right.GetValueAs(left.Unit), left.Unit); + } + + /// Get from subtracting two . + public static LinearPowerDensity operator -(LinearPowerDensity left, LinearPowerDensity right) + { + return new LinearPowerDensity(left.Value - right.GetValueAs(left.Unit), left.Unit); + } + + /// Get from multiplying value and . + public static LinearPowerDensity operator *(double left, LinearPowerDensity right) + { + return new LinearPowerDensity(left * right.Value, right.Unit); + } + + /// Get from multiplying value and . + public static LinearPowerDensity operator *(LinearPowerDensity left, double right) + { + return new LinearPowerDensity(left.Value * right, left.Unit); + } + + /// Get from dividing by value. + public static LinearPowerDensity operator /(LinearPowerDensity left, double right) + { + return new LinearPowerDensity(left.Value / right, left.Unit); + } + + /// Get ratio value from dividing by . + public static double operator /(LinearPowerDensity left, LinearPowerDensity right) + { + return left.WattsPerMeter / right.WattsPerMeter; + } + + #endregion + + #region Equality / IComparable + + /// Returns true if less or equal to. + public static bool operator <=(LinearPowerDensity left, LinearPowerDensity right) + { + return left.Value <= right.GetValueAs(left.Unit); + } + + /// Returns true if greater than or equal to. + public static bool operator >=(LinearPowerDensity left, LinearPowerDensity right) + { + return left.Value >= right.GetValueAs(left.Unit); + } + + /// Returns true if less than. + public static bool operator <(LinearPowerDensity left, LinearPowerDensity right) + { + return left.Value < right.GetValueAs(left.Unit); + } + + /// Returns true if greater than. + public static bool operator >(LinearPowerDensity left, LinearPowerDensity right) + { + return left.Value > right.GetValueAs(left.Unit); + } + + /// Returns true if exactly equal. + /// Consider using for safely comparing floating point values. + public static bool operator ==(LinearPowerDensity left, LinearPowerDensity right) + { + return left.Equals(right); + } + + /// Returns true if not exactly equal. + /// Consider using for safely comparing floating point values. + public static bool operator !=(LinearPowerDensity left, LinearPowerDensity right) + { + return !(left == right); + } + + /// + public int CompareTo(object obj) + { + if(obj is null) throw new ArgumentNullException(nameof(obj)); + if(!(obj is LinearPowerDensity objLinearPowerDensity)) throw new ArgumentException("Expected type LinearPowerDensity.", nameof(obj)); + + return CompareTo(objLinearPowerDensity); + } + + /// + public int CompareTo(LinearPowerDensity other) + { + return _value.CompareTo(other.GetValueAs(this.Unit)); + } + + /// + /// Consider using for safely comparing floating point values. + public override bool Equals(object obj) + { + if(obj is null || !(obj is LinearPowerDensity objLinearPowerDensity)) + return false; + + return Equals(objLinearPowerDensity); + } + + /// + /// Consider using for safely comparing floating point values. + public bool Equals(LinearPowerDensity other) + { + return _value.Equals(other.GetValueAs(this.Unit)); + } + + /// + /// + /// Compare equality to another LinearPowerDensity within the given absolute or relative tolerance. + /// + /// + /// Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and + /// as a percentage of this quantity's value. will be converted into + /// this quantity's unit for comparison. A relative tolerance of 0.01 means the absolute difference must be within +/- 1% of + /// this quantity's value to be considered equal. + /// + /// In this example, the two quantities will be equal if the value of b is within +/- 1% of a (0.02m or 2cm). + /// + /// var a = Length.FromMeters(2.0); + /// var b = Length.FromInches(50.0); + /// a.Equals(b, 0.01, ComparisonType.Relative); + /// + /// + /// + /// + /// Absolute tolerance is defined as the maximum allowable absolute difference between this quantity's value and + /// as a fixed number in this quantity's unit. will be converted into + /// this quantity's unit for comparison. + /// + /// In this example, the two quantities will be equal if the value of b is within 0.01 of a (0.01m or 1cm). + /// + /// var a = Length.FromMeters(2.0); + /// var b = Length.FromInches(50.0); + /// a.Equals(b, 0.01, ComparisonType.Absolute); + /// + /// + /// + /// + /// Note that it is advised against specifying zero difference, due to the nature + /// of floating point operations and using System.Double internally. + /// + /// + /// The other quantity to compare to. + /// The absolute or relative tolerance value. Must be greater than or equal to 0. + /// The comparison type: either relative or absolute. + /// True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance. + public bool Equals(LinearPowerDensity other, double tolerance, ComparisonType comparisonType) + { + if(tolerance < 0) + throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0."); + + double thisValue = (double)this.Value; + double otherValueInThisUnits = other.As(this.Unit); + + return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType); + } + + /// + /// Returns the hash code for this instance. + /// + /// A hash code for the current LinearPowerDensity. + public override int GetHashCode() + { + return new { QuantityType, Value, Unit }.GetHashCode(); + } + + #endregion + + #region Conversion Methods + + /// + /// Convert to the unit representation . + /// + /// Value converted to the specified unit. + public double As(LinearPowerDensityUnit unit) + { + if(Unit == unit) + return Convert.ToDouble(Value); + + var converted = GetValueAs(unit); + return Convert.ToDouble(converted); + } + + /// + public double As(UnitSystem unitSystem) + { + if(unitSystem == null) + throw new ArgumentNullException(nameof(unitSystem)); + + var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits); + + var firstUnitInfo = unitInfos.FirstOrDefault(); + if(firstUnitInfo == null) + throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem)); + + return As(firstUnitInfo.Value); + } + + /// + double IQuantity.As(Enum unit) + { + if(!(unit is LinearPowerDensityUnit unitAsLinearPowerDensityUnit)) + throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LinearPowerDensityUnit)} is supported.", nameof(unit)); + + return As(unitAsLinearPowerDensityUnit); + } + + /// + /// Converts this LinearPowerDensity to another LinearPowerDensity with the unit representation . + /// + /// A LinearPowerDensity with the specified unit. + public LinearPowerDensity ToUnit(LinearPowerDensityUnit unit) + { + var convertedValue = GetValueAs(unit); + return new LinearPowerDensity(convertedValue, unit); + } + + /// + IQuantity IQuantity.ToUnit(Enum unit) + { + if(!(unit is LinearPowerDensityUnit unitAsLinearPowerDensityUnit)) + throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LinearPowerDensityUnit)} is supported.", nameof(unit)); + + return ToUnit(unitAsLinearPowerDensityUnit); + } + + /// + public LinearPowerDensity ToUnit(UnitSystem unitSystem) + { + if(unitSystem == null) + throw new ArgumentNullException(nameof(unitSystem)); + + var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits); + + var firstUnitInfo = unitInfos.FirstOrDefault(); + if(firstUnitInfo == null) + throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem)); + + return ToUnit(firstUnitInfo.Value); + } + + /// + IQuantity IQuantity.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem); + + /// + IQuantity IQuantity.ToUnit(LinearPowerDensityUnit unit) => ToUnit(unit); + + /// + IQuantity IQuantity.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem); + + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + private double GetValueInBaseUnit() + { + switch(Unit) + { + case LinearPowerDensityUnit.GigawattPerCentimeter: return (_value*1e2) * 1e9d; + case LinearPowerDensityUnit.GigawattPerFoot: return (_value*3.280839895) * 1e9d; + case LinearPowerDensityUnit.GigawattPerInch: return (_value*39.37007874) * 1e9d; + case LinearPowerDensityUnit.GigawattPerMeter: return (_value) * 1e9d; + case LinearPowerDensityUnit.GigawattPerMillimeter: return (_value*1e3) * 1e9d; + case LinearPowerDensityUnit.KilowattPerCentimeter: return (_value*1e2) * 1e3d; + case LinearPowerDensityUnit.KilowattPerFoot: return (_value*3.280839895) * 1e3d; + case LinearPowerDensityUnit.KilowattPerInch: return (_value*39.37007874) * 1e3d; + case LinearPowerDensityUnit.KilowattPerMeter: return (_value) * 1e3d; + case LinearPowerDensityUnit.KilowattPerMillimeter: return (_value*1e3) * 1e3d; + case LinearPowerDensityUnit.MegawattPerCentimeter: return (_value*1e2) * 1e6d; + case LinearPowerDensityUnit.MegawattPerFoot: return (_value*3.280839895) * 1e6d; + case LinearPowerDensityUnit.MegawattPerInch: return (_value*39.37007874) * 1e6d; + case LinearPowerDensityUnit.MegawattPerMeter: return (_value) * 1e6d; + case LinearPowerDensityUnit.MegawattPerMillimeter: return (_value*1e3) * 1e6d; + case LinearPowerDensityUnit.MilliwattPerCentimeter: return (_value*1e2) * 1e-3d; + case LinearPowerDensityUnit.MilliwattPerFoot: return (_value*3.280839895) * 1e-3d; + case LinearPowerDensityUnit.MilliwattPerInch: return (_value*39.37007874) * 1e-3d; + case LinearPowerDensityUnit.MilliwattPerMeter: return (_value) * 1e-3d; + case LinearPowerDensityUnit.MilliwattPerMillimeter: return (_value*1e3) * 1e-3d; + case LinearPowerDensityUnit.WattPerCentimeter: return _value*1e2; + case LinearPowerDensityUnit.WattPerFoot: return _value*3.280839895; + case LinearPowerDensityUnit.WattPerInch: return _value*39.37007874; + case LinearPowerDensityUnit.WattPerMeter: return _value; + case LinearPowerDensityUnit.WattPerMillimeter: return _value*1e3; + default: + throw new NotImplementedException($"Can not convert {Unit} to base units."); + } + } + + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + internal LinearPowerDensity ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new LinearPowerDensity(baseUnitValue, BaseUnit); + } + + private double GetValueAs(LinearPowerDensityUnit unit) + { + if(Unit == unit) + return _value; + + var baseUnitValue = GetValueInBaseUnit(); + + switch(unit) + { + case LinearPowerDensityUnit.GigawattPerCentimeter: return (baseUnitValue/1e2) / 1e9d; + case LinearPowerDensityUnit.GigawattPerFoot: return (baseUnitValue/3.280839895) / 1e9d; + case LinearPowerDensityUnit.GigawattPerInch: return (baseUnitValue/39.37007874) / 1e9d; + case LinearPowerDensityUnit.GigawattPerMeter: return (baseUnitValue) / 1e9d; + case LinearPowerDensityUnit.GigawattPerMillimeter: return (baseUnitValue/1e3) / 1e9d; + case LinearPowerDensityUnit.KilowattPerCentimeter: return (baseUnitValue/1e2) / 1e3d; + case LinearPowerDensityUnit.KilowattPerFoot: return (baseUnitValue/3.280839895) / 1e3d; + case LinearPowerDensityUnit.KilowattPerInch: return (baseUnitValue/39.37007874) / 1e3d; + case LinearPowerDensityUnit.KilowattPerMeter: return (baseUnitValue) / 1e3d; + case LinearPowerDensityUnit.KilowattPerMillimeter: return (baseUnitValue/1e3) / 1e3d; + case LinearPowerDensityUnit.MegawattPerCentimeter: return (baseUnitValue/1e2) / 1e6d; + case LinearPowerDensityUnit.MegawattPerFoot: return (baseUnitValue/3.280839895) / 1e6d; + case LinearPowerDensityUnit.MegawattPerInch: return (baseUnitValue/39.37007874) / 1e6d; + case LinearPowerDensityUnit.MegawattPerMeter: return (baseUnitValue) / 1e6d; + case LinearPowerDensityUnit.MegawattPerMillimeter: return (baseUnitValue/1e3) / 1e6d; + case LinearPowerDensityUnit.MilliwattPerCentimeter: return (baseUnitValue/1e2) / 1e-3d; + case LinearPowerDensityUnit.MilliwattPerFoot: return (baseUnitValue/3.280839895) / 1e-3d; + case LinearPowerDensityUnit.MilliwattPerInch: return (baseUnitValue/39.37007874) / 1e-3d; + case LinearPowerDensityUnit.MilliwattPerMeter: return (baseUnitValue) / 1e-3d; + case LinearPowerDensityUnit.MilliwattPerMillimeter: return (baseUnitValue/1e3) / 1e-3d; + case LinearPowerDensityUnit.WattPerCentimeter: return baseUnitValue/1e2; + case LinearPowerDensityUnit.WattPerFoot: return baseUnitValue/3.280839895; + case LinearPowerDensityUnit.WattPerInch: return baseUnitValue/39.37007874; + case LinearPowerDensityUnit.WattPerMeter: return baseUnitValue; + case LinearPowerDensityUnit.WattPerMillimeter: return baseUnitValue/1e3; + default: + throw new NotImplementedException($"Can not convert {Unit} to {unit}."); + } + } + + #endregion + + #region ToString Methods + + /// + /// Gets the default string representation of value and unit. + /// + /// String representation. + public override string ToString() + { + return ToString("g"); + } + + /// + /// Gets the default string representation of value and unit using the given format provider. + /// + /// String representation. + /// Format to use for localization and number formatting. Defaults to if null. + public string ToString([CanBeNull] IFormatProvider provider) + { + return ToString("g", provider); + } + + /// + /// Get string representation of value and unit. + /// + /// The number of significant digits after the radix point. + /// String representation. + /// Format to use for localization and number formatting. Defaults to if null. + [Obsolete(@"This method is deprecated and will be removed at a future release. Please use ToString(""s2"") or ToString(""s2"", provider) where 2 is an example of the number passed to significantDigitsAfterRadix.")] + public string ToString([CanBeNull] IFormatProvider provider, int significantDigitsAfterRadix) + { + var value = Convert.ToDouble(Value); + var format = UnitFormatter.GetFormat(value, significantDigitsAfterRadix); + return ToString(provider, format); + } + + /// + /// Get string representation of value and unit. + /// + /// String format to use. Default: "{0:0.##} {1} for value and unit abbreviation respectively." + /// Arguments for string format. Value and unit are implicitly included as arguments 0 and 1. + /// String representation. + /// Format to use for localization and number formatting. Defaults to if null. + [Obsolete("This method is deprecated and will be removed at a future release. Please use string.Format().")] + public string ToString([CanBeNull] IFormatProvider provider, [NotNull] string format, [NotNull] params object[] args) + { + if (format == null) throw new ArgumentNullException(nameof(format)); + if (args == null) throw new ArgumentNullException(nameof(args)); + + provider = provider ?? CultureInfo.CurrentUICulture; + + var value = Convert.ToDouble(Value); + var formatArgs = UnitFormatter.GetFormatArgs(Unit, value, provider, args); + return string.Format(provider, format, formatArgs); + } + + /// + /// + /// Gets the string representation of this instance in the specified format string using . + /// + /// The format string. + /// The string representation. + public string ToString(string format) + { + return ToString(format, CultureInfo.CurrentUICulture); + } + + /// + /// + /// Gets the string representation of this instance in the specified format string using the specified format provider, or if null. + /// + /// The format string. + /// Format to use for localization and number formatting. Defaults to if null. + /// The string representation. + public string ToString(string format, IFormatProvider formatProvider) + { + return QuantityFormatter.Format(this, format, formatProvider); + } + + #endregion + + #region IConvertible Methods + + TypeCode IConvertible.GetTypeCode() + { + return TypeCode.Object; + } + + bool IConvertible.ToBoolean(IFormatProvider provider) + { + throw new InvalidCastException($"Converting {typeof(LinearPowerDensity)} to bool is not supported."); + } + + byte IConvertible.ToByte(IFormatProvider provider) + { + return Convert.ToByte(_value); + } + + char IConvertible.ToChar(IFormatProvider provider) + { + throw new InvalidCastException($"Converting {typeof(LinearPowerDensity)} to char is not supported."); + } + + DateTime IConvertible.ToDateTime(IFormatProvider provider) + { + throw new InvalidCastException($"Converting {typeof(LinearPowerDensity)} to DateTime is not supported."); + } + + decimal IConvertible.ToDecimal(IFormatProvider provider) + { + return Convert.ToDecimal(_value); + } + + double IConvertible.ToDouble(IFormatProvider provider) + { + return Convert.ToDouble(_value); + } + + short IConvertible.ToInt16(IFormatProvider provider) + { + return Convert.ToInt16(_value); + } + + int IConvertible.ToInt32(IFormatProvider provider) + { + return Convert.ToInt32(_value); + } + + long IConvertible.ToInt64(IFormatProvider provider) + { + return Convert.ToInt64(_value); + } + + sbyte IConvertible.ToSByte(IFormatProvider provider) + { + return Convert.ToSByte(_value); + } + + float IConvertible.ToSingle(IFormatProvider provider) + { + return Convert.ToSingle(_value); + } + + string IConvertible.ToString(IFormatProvider provider) + { + return ToString("g", provider); + } + + object IConvertible.ToType(Type conversionType, IFormatProvider provider) + { + if(conversionType == typeof(LinearPowerDensity)) + return this; + else if(conversionType == typeof(LinearPowerDensityUnit)) + return Unit; + else if(conversionType == typeof(QuantityType)) + return LinearPowerDensity.QuantityType; + else if(conversionType == typeof(BaseDimensions)) + return LinearPowerDensity.BaseDimensions; + else + throw new InvalidCastException($"Converting {typeof(LinearPowerDensity)} to {conversionType} is not supported."); + } + + ushort IConvertible.ToUInt16(IFormatProvider provider) + { + return Convert.ToUInt16(_value); + } + + uint IConvertible.ToUInt32(IFormatProvider provider) + { + return Convert.ToUInt32(_value); + } + + ulong IConvertible.ToUInt64(IFormatProvider provider) + { + return Convert.ToUInt64(_value); + } + + #endregion + } +} diff --git a/UnitsNet/GeneratedCode/Quantity.g.cs b/UnitsNet/GeneratedCode/Quantity.g.cs index f1d8016b23..4675003c8c 100644 --- a/UnitsNet/GeneratedCode/Quantity.g.cs +++ b/UnitsNet/GeneratedCode/Quantity.g.cs @@ -142,6 +142,8 @@ public static IQuantity FromQuantityType(QuantityType quantityType, QuantityValu return Level.From(value, Level.BaseUnit); case QuantityType.LinearDensity: return LinearDensity.From(value, LinearDensity.BaseUnit); + case QuantityType.LinearPowerDensity: + return LinearPowerDensity.From(value, LinearPowerDensity.BaseUnit); case QuantityType.Luminosity: return Luminosity.From(value, Luminosity.BaseUnit); case QuantityType.LuminousFlux: @@ -409,6 +411,9 @@ public static bool TryFrom(QuantityValue value, Enum unit, out IQuantity quantit case LinearDensityUnit linearDensityUnit: quantity = LinearDensity.From(value, linearDensityUnit); return true; + case LinearPowerDensityUnit linearPowerDensityUnit: + quantity = LinearPowerDensity.From(value, linearPowerDensityUnit); + return true; case LuminosityUnit luminosityUnit: quantity = Luminosity.From(value, luminosityUnit); return true; @@ -685,6 +690,8 @@ public static bool TryParse([CanBeNull] IFormatProvider formatProvider, Type qua return parser.TryParse(quantityString, formatProvider, Level.From, out quantity); case Type _ when quantityType == typeof(LinearDensity): return parser.TryParse(quantityString, formatProvider, LinearDensity.From, out quantity); + case Type _ when quantityType == typeof(LinearPowerDensity): + return parser.TryParse(quantityString, formatProvider, LinearPowerDensity.From, out quantity); case Type _ when quantityType == typeof(Luminosity): return parser.TryParse(quantityString, formatProvider, Luminosity.From, out quantity); case Type _ when quantityType == typeof(LuminousFlux): diff --git a/UnitsNet/GeneratedCode/QuantityType.g.cs b/UnitsNet/GeneratedCode/QuantityType.g.cs index b3f1f342fe..40ea6c9d6f 100644 --- a/UnitsNet/GeneratedCode/QuantityType.g.cs +++ b/UnitsNet/GeneratedCode/QuantityType.g.cs @@ -82,6 +82,7 @@ public enum QuantityType Length, Level, LinearDensity, + LinearPowerDensity, Luminosity, LuminousFlux, LuminousIntensity, diff --git a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs index cacb3b68c9..7cc6b1771f 100644 --- a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs +++ b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs @@ -615,6 +615,31 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(LinearDensityUnit), (int)LinearDensityUnit.MilligramPerMillimeter, new string[]{"mg/mm"}), ("en-US", typeof(LinearDensityUnit), (int)LinearDensityUnit.PoundPerFoot, new string[]{"lb/ft"}), ("en-US", typeof(LinearDensityUnit), (int)LinearDensityUnit.PoundPerInch, new string[]{"lb/in"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.GigawattPerCentimeter, new string[]{"GW/cm"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.GigawattPerFoot, new string[]{"GW/ft"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.GigawattPerInch, new string[]{"GW/in"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.GigawattPerMeter, new string[]{"GW/m"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.GigawattPerMillimeter, new string[]{"GW/mm"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.KilowattPerCentimeter, new string[]{"kW/cm"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.KilowattPerFoot, new string[]{"kW/ft"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.KilowattPerInch, new string[]{"kW/in"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.KilowattPerMeter, new string[]{"kW/m"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.KilowattPerMillimeter, new string[]{"kW/mm"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.MegawattPerCentimeter, new string[]{"MW/cm"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.MegawattPerFoot, new string[]{"MW/ft"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.MegawattPerInch, new string[]{"MW/in"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.MegawattPerMeter, new string[]{"MW/m"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.MegawattPerMillimeter, new string[]{"MW/mm"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.MilliwattPerCentimeter, new string[]{"mW/cm"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.MilliwattPerFoot, new string[]{"mW/ft"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.MilliwattPerInch, new string[]{"mW/in"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.MilliwattPerMeter, new string[]{"mW/m"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.MilliwattPerMillimeter, new string[]{"mW/mm"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.WattPerCentimeter, new string[]{"W/cm"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.WattPerFoot, new string[]{"W/ft"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.WattPerInch, new string[]{"W/in"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.WattPerMeter, new string[]{"W/m"}), + ("en-US", typeof(LinearPowerDensityUnit), (int)LinearPowerDensityUnit.WattPerMillimeter, new string[]{"W/mm"}), ("en-US", typeof(LuminosityUnit), (int)LuminosityUnit.Decawatt, new string[]{"daW"}), ("en-US", typeof(LuminosityUnit), (int)LuminosityUnit.Deciwatt, new string[]{"dW"}), ("en-US", typeof(LuminosityUnit), (int)LuminosityUnit.Femtowatt, new string[]{"fW"}), diff --git a/UnitsNet/GeneratedCode/UnitConverter.g.cs b/UnitsNet/GeneratedCode/UnitConverter.g.cs index 0e25bab244..de470f8dba 100644 --- a/UnitsNet/GeneratedCode/UnitConverter.g.cs +++ b/UnitsNet/GeneratedCode/UnitConverter.g.cs @@ -955,6 +955,55 @@ public static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(LinearDensityUnit.PoundPerFoot, LinearDensity.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(LinearDensity.BaseUnit, LinearDensityUnit.PoundPerInch, q => q.ToUnit(LinearDensityUnit.PoundPerInch)); unitConverter.SetConversionFunction(LinearDensityUnit.PoundPerInch, LinearDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.GigawattPerCentimeter, q => q.ToUnit(LinearPowerDensityUnit.GigawattPerCentimeter)); + unitConverter.SetConversionFunction(LinearPowerDensityUnit.GigawattPerCentimeter, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.GigawattPerFoot, q => q.ToUnit(LinearPowerDensityUnit.GigawattPerFoot)); + unitConverter.SetConversionFunction(LinearPowerDensityUnit.GigawattPerFoot, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.GigawattPerInch, q => q.ToUnit(LinearPowerDensityUnit.GigawattPerInch)); + unitConverter.SetConversionFunction(LinearPowerDensityUnit.GigawattPerInch, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.GigawattPerMeter, q => q.ToUnit(LinearPowerDensityUnit.GigawattPerMeter)); + unitConverter.SetConversionFunction(LinearPowerDensityUnit.GigawattPerMeter, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.GigawattPerMillimeter, q => q.ToUnit(LinearPowerDensityUnit.GigawattPerMillimeter)); + unitConverter.SetConversionFunction(LinearPowerDensityUnit.GigawattPerMillimeter, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.KilowattPerCentimeter, q => q.ToUnit(LinearPowerDensityUnit.KilowattPerCentimeter)); + unitConverter.SetConversionFunction(LinearPowerDensityUnit.KilowattPerCentimeter, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.KilowattPerFoot, q => q.ToUnit(LinearPowerDensityUnit.KilowattPerFoot)); + unitConverter.SetConversionFunction(LinearPowerDensityUnit.KilowattPerFoot, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.KilowattPerInch, q => q.ToUnit(LinearPowerDensityUnit.KilowattPerInch)); + unitConverter.SetConversionFunction(LinearPowerDensityUnit.KilowattPerInch, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.KilowattPerMeter, q => q.ToUnit(LinearPowerDensityUnit.KilowattPerMeter)); + unitConverter.SetConversionFunction(LinearPowerDensityUnit.KilowattPerMeter, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.KilowattPerMillimeter, q => q.ToUnit(LinearPowerDensityUnit.KilowattPerMillimeter)); + unitConverter.SetConversionFunction(LinearPowerDensityUnit.KilowattPerMillimeter, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.MegawattPerCentimeter, q => q.ToUnit(LinearPowerDensityUnit.MegawattPerCentimeter)); + unitConverter.SetConversionFunction(LinearPowerDensityUnit.MegawattPerCentimeter, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.MegawattPerFoot, q => q.ToUnit(LinearPowerDensityUnit.MegawattPerFoot)); + unitConverter.SetConversionFunction(LinearPowerDensityUnit.MegawattPerFoot, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.MegawattPerInch, q => q.ToUnit(LinearPowerDensityUnit.MegawattPerInch)); + unitConverter.SetConversionFunction(LinearPowerDensityUnit.MegawattPerInch, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.MegawattPerMeter, q => q.ToUnit(LinearPowerDensityUnit.MegawattPerMeter)); + unitConverter.SetConversionFunction(LinearPowerDensityUnit.MegawattPerMeter, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.MegawattPerMillimeter, q => q.ToUnit(LinearPowerDensityUnit.MegawattPerMillimeter)); + unitConverter.SetConversionFunction(LinearPowerDensityUnit.MegawattPerMillimeter, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.MilliwattPerCentimeter, q => q.ToUnit(LinearPowerDensityUnit.MilliwattPerCentimeter)); + unitConverter.SetConversionFunction(LinearPowerDensityUnit.MilliwattPerCentimeter, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.MilliwattPerFoot, q => q.ToUnit(LinearPowerDensityUnit.MilliwattPerFoot)); + unitConverter.SetConversionFunction(LinearPowerDensityUnit.MilliwattPerFoot, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.MilliwattPerInch, q => q.ToUnit(LinearPowerDensityUnit.MilliwattPerInch)); + unitConverter.SetConversionFunction(LinearPowerDensityUnit.MilliwattPerInch, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.MilliwattPerMeter, q => q.ToUnit(LinearPowerDensityUnit.MilliwattPerMeter)); + unitConverter.SetConversionFunction(LinearPowerDensityUnit.MilliwattPerMeter, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.MilliwattPerMillimeter, q => q.ToUnit(LinearPowerDensityUnit.MilliwattPerMillimeter)); + unitConverter.SetConversionFunction(LinearPowerDensityUnit.MilliwattPerMillimeter, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.WattPerCentimeter, q => q.ToUnit(LinearPowerDensityUnit.WattPerCentimeter)); + unitConverter.SetConversionFunction(LinearPowerDensityUnit.WattPerCentimeter, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.WattPerFoot, q => q.ToUnit(LinearPowerDensityUnit.WattPerFoot)); + unitConverter.SetConversionFunction(LinearPowerDensityUnit.WattPerFoot, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.WattPerInch, q => q.ToUnit(LinearPowerDensityUnit.WattPerInch)); + unitConverter.SetConversionFunction(LinearPowerDensityUnit.WattPerInch, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(LinearPowerDensity.BaseUnit, LinearPowerDensity.BaseUnit, q => q); + unitConverter.SetConversionFunction(LinearPowerDensity.BaseUnit, LinearPowerDensityUnit.WattPerMillimeter, q => q.ToUnit(LinearPowerDensityUnit.WattPerMillimeter)); + unitConverter.SetConversionFunction(LinearPowerDensityUnit.WattPerMillimeter, LinearPowerDensity.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Luminosity.BaseUnit, LuminosityUnit.Decawatt, q => q.ToUnit(LuminosityUnit.Decawatt)); unitConverter.SetConversionFunction(LuminosityUnit.Decawatt, Luminosity.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(Luminosity.BaseUnit, LuminosityUnit.Deciwatt, q => q.ToUnit(LuminosityUnit.Deciwatt)); diff --git a/UnitsNet/GeneratedCode/Units/LinearPowerDensityUnit.g.cs b/UnitsNet/GeneratedCode/Units/LinearPowerDensityUnit.g.cs new file mode 100644 index 0000000000..8395416543 --- /dev/null +++ b/UnitsNet/GeneratedCode/Units/LinearPowerDensityUnit.g.cs @@ -0,0 +1,57 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by \generate-code.bat. +// +// Changes to this file will be lost when the code is regenerated. +// The build server regenerates the code before each build and a pre-build +// step will regenerate the code on each local build. +// +// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units. +// +// Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities. +// Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities. +// +// +//------------------------------------------------------------------------------ + +// Licensed under MIT No Attribution, see LICENSE file at the root. +// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet. + +// ReSharper disable once CheckNamespace +namespace UnitsNet.Units +{ + // Disable missing XML comment warnings for the generated unit enums. + #pragma warning disable 1591 + + public enum LinearPowerDensityUnit + { + Undefined = 0, + GigawattPerCentimeter, + GigawattPerFoot, + GigawattPerInch, + GigawattPerMeter, + GigawattPerMillimeter, + KilowattPerCentimeter, + KilowattPerFoot, + KilowattPerInch, + KilowattPerMeter, + KilowattPerMillimeter, + MegawattPerCentimeter, + MegawattPerFoot, + MegawattPerInch, + MegawattPerMeter, + MegawattPerMillimeter, + MilliwattPerCentimeter, + MilliwattPerFoot, + MilliwattPerInch, + MilliwattPerMeter, + MilliwattPerMillimeter, + WattPerCentimeter, + WattPerFoot, + WattPerInch, + WattPerMeter, + WattPerMillimeter, + } + + #pragma warning restore 1591 +}