diff --git a/Common/UnitDefinitions/ReciprocalArea.json b/Common/UnitDefinitions/ReciprocalArea.json new file mode 100644 index 0000000000..99be49adfe --- /dev/null +++ b/Common/UnitDefinitions/ReciprocalArea.json @@ -0,0 +1,144 @@ +{ + "Name": "ReciprocalArea", + "BaseUnit": "InverseSquareMeter", + "XmlDoc": "Reciprocal area (Inverse-square) quantity is used to specify a physical quantity inversely proportional to the square of the distance.", + "XmlDocRemarks": "https://en.wikipedia.org/wiki/Inverse-square_law", + "BaseDimensions": { + "L": -2 + }, + "Units": [ + { + "SingularName": "InverseSquareMeter", + "PluralName": "InverseSquareMeters", + "FromUnitToBaseFunc": "x", + "FromBaseToUnitFunc": "x", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "m⁻²" ] + } + ] + }, + { + "SingularName": "InverseSquareKilometer", + "PluralName": "InverseSquareKilometers", + "FromUnitToBaseFunc": "x/1e6", + "FromBaseToUnitFunc": "x*1e6", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "km⁻²" ] + } + ] + }, + { + "SingularName": "InverseSquareDecimeter", + "PluralName": "InverseSquareDecimeters", + "FromUnitToBaseFunc": "x/1e-2", + "FromBaseToUnitFunc": "x*1e-2", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "dm⁻²" ] + } + ] + }, + { + "SingularName": "InverseSquareCentimeter", + "PluralName": "InverseSquareCentimeters", + "FromUnitToBaseFunc": "x/1e-4", + "FromBaseToUnitFunc": "x*1e-4", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "cm⁻²" ] + } + ] + }, + { + "SingularName": "InverseSquareMillimeter", + "PluralName": "InverseSquareMillimeters", + "FromUnitToBaseFunc": "x/1e-6", + "FromBaseToUnitFunc": "x*1e-6", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "mm⁻²" ] + } + ] + }, + { + "SingularName": "InverseSquareMicrometer", + "PluralName": "InverseSquareMicrometers", + "FromUnitToBaseFunc": "x/1e-12", + "FromBaseToUnitFunc": "x*1e-12", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "µm⁻²" ] + } + ] + }, + { + "SingularName": "InverseSquareMile", + "PluralName": "InverseSquareMiles", + "FromUnitToBaseFunc": "x/2.59e6", + "FromBaseToUnitFunc": "x*2.59e6", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "mi⁻²" ] + } + ] + }, + { + "SingularName": "InverseSquareYard", + "PluralName": "InverseSquareYards", + "FromUnitToBaseFunc": "x/0.836127", + "FromBaseToUnitFunc": "x*0.836127", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "yd⁻²" ] + } + ] + }, + { + "SingularName": "InverseSquareFoot", + "PluralName": "InverseSquareFeet", + "FromUnitToBaseFunc": "x/0.092903", + "FromBaseToUnitFunc": "x*0.092903", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "ft⁻²" ] + } + ] + }, + { + "SingularName": "InverseUsSurveySquareFoot", + "PluralName": "InverseUsSurveySquareFeet", + "FromUnitToBaseFunc": "x/0.09290341161", + "FromBaseToUnitFunc": "x*0.09290341161", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "ft⁻² (US)" ] + } + ] + }, + { + "SingularName": "InverseSquareInch", + "PluralName": "InverseSquareInches", + "FromUnitToBaseFunc": "x/0.00064516", + "FromBaseToUnitFunc": "x*0.00064516", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "in⁻²" ] + } + ] + } + ] +} + \ No newline at end of file diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/ReciprocalArea.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ReciprocalArea.g.cs new file mode 100644 index 0000000000..0941da4332 --- /dev/null +++ b/UnitsNet.NanoFramework/GeneratedCode/Quantities/ReciprocalArea.g.cs @@ -0,0 +1,296 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by \generate-code.bat. +// +// Changes to this file will be lost when the code is regenerated. +// The build server regenerates the code before each build and a pre-build +// step will regenerate the code on each local build. +// +// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units. +// +// Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities. +// Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities. +// +// +//------------------------------------------------------------------------------ + +// Licensed under MIT No Attribution, see LICENSE file at the root. +// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet. + +using System; +using UnitsNet.Units; + +namespace UnitsNet +{ + /// + /// + /// Reciprocal area (Inverse-square) quantity is used to specify a physical quantity inversely proportional to the square of the distance. + /// + /// + /// https://en.wikipedia.org/wiki/Inverse-square_law + /// + public struct ReciprocalArea + { + /// + /// The numeric value this quantity was constructed with. + /// + private readonly double _value; + + /// + /// The unit this quantity was constructed with. + /// + private readonly ReciprocalAreaUnit _unit; + + /// + /// The numeric value this quantity was constructed with. + /// + public double Value => _value; + + /// + public ReciprocalAreaUnit Unit => _unit; + /// + /// Creates the quantity with the given numeric value and unit. + /// + /// The numeric value to construct this quantity with. + /// The unit representation to construct this quantity with. + /// If value is NaN or Infinity. + public ReciprocalArea(double value, ReciprocalAreaUnit unit) + { + _value = value; + _unit = unit; + } + + /// + /// The base unit of Duration, which is Second. All conversions go via this value. + /// + public static ReciprocalAreaUnit BaseUnit { get; } = ReciprocalAreaUnit.InverseSquareMeter; + + /// + /// Represents the largest possible value of Duration + /// + public static ReciprocalArea MaxValue { get; } = new ReciprocalArea(double.MaxValue, BaseUnit); + + /// + /// Represents the smallest possible value of Duration + /// + public static ReciprocalArea MinValue { get; } = new ReciprocalArea(double.MinValue, BaseUnit); + /// + /// Gets an instance of this quantity with a value of 0 in the base unit Second. + /// + public static ReciprocalArea Zero { get; } = new ReciprocalArea(0, BaseUnit); + #region Conversion Properties + + /// + /// Get ReciprocalArea in InverseSquareCentimeters. + /// + public double InverseSquareCentimeters => As(ReciprocalAreaUnit.InverseSquareCentimeter); + + /// + /// Get ReciprocalArea in InverseSquareDecimeters. + /// + public double InverseSquareDecimeters => As(ReciprocalAreaUnit.InverseSquareDecimeter); + + /// + /// Get ReciprocalArea in InverseSquareFeet. + /// + public double InverseSquareFeet => As(ReciprocalAreaUnit.InverseSquareFoot); + + /// + /// Get ReciprocalArea in InverseSquareInches. + /// + public double InverseSquareInches => As(ReciprocalAreaUnit.InverseSquareInch); + + /// + /// Get ReciprocalArea in InverseSquareKilometers. + /// + public double InverseSquareKilometers => As(ReciprocalAreaUnit.InverseSquareKilometer); + + /// + /// Get ReciprocalArea in InverseSquareMeters. + /// + public double InverseSquareMeters => As(ReciprocalAreaUnit.InverseSquareMeter); + + /// + /// Get ReciprocalArea in InverseSquareMicrometers. + /// + public double InverseSquareMicrometers => As(ReciprocalAreaUnit.InverseSquareMicrometer); + + /// + /// Get ReciprocalArea in InverseSquareMiles. + /// + public double InverseSquareMiles => As(ReciprocalAreaUnit.InverseSquareMile); + + /// + /// Get ReciprocalArea in InverseSquareMillimeters. + /// + public double InverseSquareMillimeters => As(ReciprocalAreaUnit.InverseSquareMillimeter); + + /// + /// Get ReciprocalArea in InverseSquareYards. + /// + public double InverseSquareYards => As(ReciprocalAreaUnit.InverseSquareYard); + + /// + /// Get ReciprocalArea in InverseUsSurveySquareFeet. + /// + public double InverseUsSurveySquareFeet => As(ReciprocalAreaUnit.InverseUsSurveySquareFoot); + + #endregion + + #region Static Factory Methods + + /// + /// Get ReciprocalArea from InverseSquareCentimeters. + /// + /// If value is NaN or Infinity. + public static ReciprocalArea FromInverseSquareCentimeters(double inversesquarecentimeters) => new ReciprocalArea(inversesquarecentimeters, ReciprocalAreaUnit.InverseSquareCentimeter); + + /// + /// Get ReciprocalArea from InverseSquareDecimeters. + /// + /// If value is NaN or Infinity. + public static ReciprocalArea FromInverseSquareDecimeters(double inversesquaredecimeters) => new ReciprocalArea(inversesquaredecimeters, ReciprocalAreaUnit.InverseSquareDecimeter); + + /// + /// Get ReciprocalArea from InverseSquareFeet. + /// + /// If value is NaN or Infinity. + public static ReciprocalArea FromInverseSquareFeet(double inversesquarefeet) => new ReciprocalArea(inversesquarefeet, ReciprocalAreaUnit.InverseSquareFoot); + + /// + /// Get ReciprocalArea from InverseSquareInches. + /// + /// If value is NaN or Infinity. + public static ReciprocalArea FromInverseSquareInches(double inversesquareinches) => new ReciprocalArea(inversesquareinches, ReciprocalAreaUnit.InverseSquareInch); + + /// + /// Get ReciprocalArea from InverseSquareKilometers. + /// + /// If value is NaN or Infinity. + public static ReciprocalArea FromInverseSquareKilometers(double inversesquarekilometers) => new ReciprocalArea(inversesquarekilometers, ReciprocalAreaUnit.InverseSquareKilometer); + + /// + /// Get ReciprocalArea from InverseSquareMeters. + /// + /// If value is NaN or Infinity. + public static ReciprocalArea FromInverseSquareMeters(double inversesquaremeters) => new ReciprocalArea(inversesquaremeters, ReciprocalAreaUnit.InverseSquareMeter); + + /// + /// Get ReciprocalArea from InverseSquareMicrometers. + /// + /// If value is NaN or Infinity. + public static ReciprocalArea FromInverseSquareMicrometers(double inversesquaremicrometers) => new ReciprocalArea(inversesquaremicrometers, ReciprocalAreaUnit.InverseSquareMicrometer); + + /// + /// Get ReciprocalArea from InverseSquareMiles. + /// + /// If value is NaN or Infinity. + public static ReciprocalArea FromInverseSquareMiles(double inversesquaremiles) => new ReciprocalArea(inversesquaremiles, ReciprocalAreaUnit.InverseSquareMile); + + /// + /// Get ReciprocalArea from InverseSquareMillimeters. + /// + /// If value is NaN or Infinity. + public static ReciprocalArea FromInverseSquareMillimeters(double inversesquaremillimeters) => new ReciprocalArea(inversesquaremillimeters, ReciprocalAreaUnit.InverseSquareMillimeter); + + /// + /// Get ReciprocalArea from InverseSquareYards. + /// + /// If value is NaN or Infinity. + public static ReciprocalArea FromInverseSquareYards(double inversesquareyards) => new ReciprocalArea(inversesquareyards, ReciprocalAreaUnit.InverseSquareYard); + + /// + /// Get ReciprocalArea from InverseUsSurveySquareFeet. + /// + /// If value is NaN or Infinity. + public static ReciprocalArea FromInverseUsSurveySquareFeet(double inverseussurveysquarefeet) => new ReciprocalArea(inverseussurveysquarefeet, ReciprocalAreaUnit.InverseUsSurveySquareFoot); + + + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// ReciprocalArea unit value. + public static ReciprocalArea From(double value, ReciprocalAreaUnit fromUnit) + { + return new ReciprocalArea(value, fromUnit); + } + + #endregion + + #region Conversion Methods + + /// + /// Convert to the unit representation . + /// + /// Value converted to the specified unit. + public double As(ReciprocalAreaUnit unit) => GetValueAs(unit); + + /// + /// Converts this Duration to another Duration with the unit representation . + /// + /// A Duration with the specified unit. + public ReciprocalArea ToUnit(ReciprocalAreaUnit unit) + { + + var convertedValue = GetValueAs(unit); + return new ReciprocalArea(convertedValue, unit); + } + + + /// + /// Converts the current value + unit to the base unit. + /// This is typically the first step in converting from one unit to another. + /// + /// The value in the base unit representation. + private double GetValueInBaseUnit() + { + switch(Unit) + { + case ReciprocalAreaUnit.InverseSquareCentimeter: return _value/1e-4; + case ReciprocalAreaUnit.InverseSquareDecimeter: return _value/1e-2; + case ReciprocalAreaUnit.InverseSquareFoot: return _value/0.092903; + case ReciprocalAreaUnit.InverseSquareInch: return _value/0.00064516; + case ReciprocalAreaUnit.InverseSquareKilometer: return _value/1e6; + case ReciprocalAreaUnit.InverseSquareMeter: return _value; + case ReciprocalAreaUnit.InverseSquareMicrometer: return _value/1e-12; + case ReciprocalAreaUnit.InverseSquareMile: return _value/2.59e6; + case ReciprocalAreaUnit.InverseSquareMillimeter: return _value/1e-6; + case ReciprocalAreaUnit.InverseSquareYard: return _value/0.836127; + case ReciprocalAreaUnit.InverseUsSurveySquareFoot: return _value/0.09290341161; + default: + throw new NotImplementedException($"Can not convert {Unit} to base units."); + } + } + + private double GetValueAs(ReciprocalAreaUnit unit) + { + if(Unit == unit) + return _value; + + var baseUnitValue = GetValueInBaseUnit(); + + switch(unit) + { + case ReciprocalAreaUnit.InverseSquareCentimeter: return baseUnitValue*1e-4; + case ReciprocalAreaUnit.InverseSquareDecimeter: return baseUnitValue*1e-2; + case ReciprocalAreaUnit.InverseSquareFoot: return baseUnitValue*0.092903; + case ReciprocalAreaUnit.InverseSquareInch: return baseUnitValue*0.00064516; + case ReciprocalAreaUnit.InverseSquareKilometer: return baseUnitValue*1e6; + case ReciprocalAreaUnit.InverseSquareMeter: return baseUnitValue; + case ReciprocalAreaUnit.InverseSquareMicrometer: return baseUnitValue*1e-12; + case ReciprocalAreaUnit.InverseSquareMile: return baseUnitValue*2.59e6; + case ReciprocalAreaUnit.InverseSquareMillimeter: return baseUnitValue*1e-6; + case ReciprocalAreaUnit.InverseSquareYard: return baseUnitValue*0.836127; + case ReciprocalAreaUnit.InverseUsSurveySquareFoot: return baseUnitValue*0.09290341161; + default: + throw new NotImplementedException($"Can not convert {Unit} to {unit}."); + } + } + + #endregion + + } +} + diff --git a/UnitsNet.NanoFramework/GeneratedCode/ReciprocalArea/ReciprocalArea.nfproj b/UnitsNet.NanoFramework/GeneratedCode/ReciprocalArea/ReciprocalArea.nfproj new file mode 100644 index 0000000000..fcd4bea1e7 --- /dev/null +++ b/UnitsNet.NanoFramework/GeneratedCode/ReciprocalArea/ReciprocalArea.nfproj @@ -0,0 +1,42 @@ + + + + $(MSBuildToolsPath)..\..\..\nanoFramework\v1.0\ + + + + Debug + AnyCPU + {11A8DD76-328B-46DF-9F39-F559912D0360};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + {30fee563-a3f0-9c50-bfd1-1af707aaf3c4} + Library + Properties + 512 + UnitsNet + UnitsNet.ReciprocalArea + v1.0 + bin\$(Configuration)\$(AssemblyName).xml + + + + + + + + + + ..\packages\nanoFramework.CoreLibrary.1.10.5-preview.18\lib\mscorlib.dll + True + True + + + + + + + + + + + + diff --git a/UnitsNet.NanoFramework/GeneratedCode/ReciprocalArea/UnitsNet.NanoFramework.ReciprocalArea.nuspec b/UnitsNet.NanoFramework/GeneratedCode/ReciprocalArea/UnitsNet.NanoFramework.ReciprocalArea.nuspec new file mode 100644 index 0000000000..0ce8bd4695 --- /dev/null +++ b/UnitsNet.NanoFramework/GeneratedCode/ReciprocalArea/UnitsNet.NanoFramework.ReciprocalArea.nuspec @@ -0,0 +1,26 @@ + + + + UnitsNet.nanoFramework.ReciprocalArea + 4.99.0 + Units.NET ReciprocalArea - nanoFramework + Andreas Gullberg Larsen,nanoFramework project contributors + UnitsNet + MIT + https://github.com/angularsen/UnitsNet + false + Adds ReciprocalArea units for Units.NET on .NET nanoFramework. For .NET or .NET Core, use UnitsNet instead. + https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png + + + Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). + en-US + nanoframework unit units measurement si metric imperial abbreviation abbreviations convert conversion parse c# .net immutable uwp uap winrt win10 windows runtime component reciprocalarea + + + + + + + + diff --git a/UnitsNet.NanoFramework/GeneratedCode/ReciprocalArea/packages.config b/UnitsNet.NanoFramework/GeneratedCode/ReciprocalArea/packages.config new file mode 100644 index 0000000000..dc595a08dd --- /dev/null +++ b/UnitsNet.NanoFramework/GeneratedCode/ReciprocalArea/packages.config @@ -0,0 +1,4 @@ + + + + diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/ReciprocalAreaUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/ReciprocalAreaUnit.g.cs new file mode 100644 index 0000000000..822c6e03eb --- /dev/null +++ b/UnitsNet.NanoFramework/GeneratedCode/Units/ReciprocalAreaUnit.g.cs @@ -0,0 +1,43 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by \generate-code.bat. +// +// Changes to this file will be lost when the code is regenerated. +// The build server regenerates the code before each build and a pre-build +// step will regenerate the code on each local build. +// +// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units. +// +// Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities. +// Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities. +// +// +//------------------------------------------------------------------------------ + +// Licensed under MIT 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 ReciprocalAreaUnit + { + Undefined = 0, + InverseSquareCentimeter, + InverseSquareDecimeter, + InverseSquareFoot, + InverseSquareInch, + InverseSquareKilometer, + InverseSquareMeter, + InverseSquareMicrometer, + InverseSquareMile, + InverseSquareMillimeter, + InverseSquareYard, + InverseUsSurveySquareFoot, + } + + #pragma warning restore 1591 +} diff --git a/UnitsNet.NanoFramework/GeneratedCode/UnitsNet.nanoFramework.sln b/UnitsNet.NanoFramework/GeneratedCode/UnitsNet.nanoFramework.sln index dedb565eb6..ceda8aa2fb 100644 --- a/UnitsNet.NanoFramework/GeneratedCode/UnitsNet.nanoFramework.sln +++ b/UnitsNet.NanoFramework/GeneratedCode/UnitsNet.nanoFramework.sln @@ -160,6 +160,8 @@ Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ReactiveEnergy", "ReactiveE EndProject Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ReactivePower", "ReactivePower\ReactivePower.nfproj", "{6821b87e-65eb-bfdb-8fdc-8b183edf739e}" EndProject +Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ReciprocalArea", "ReciprocalArea\ReciprocalArea.nfproj", "{30fee563-a3f0-9c50-bfd1-1af707aaf3c4}" +EndProject Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "ReciprocalLength", "ReciprocalLength\ReciprocalLength.nfproj", "{83d6c79a-c71a-d467-284c-28edbbd059d2}" EndProject Project("{d608a2b1-6ead-4383-a205-ad1ce69d9ef7}") = "RelativeHumidity", "RelativeHumidity\RelativeHumidity.nfproj", "{4ac05c74-08c5-2153-f38c-976975747b5c}" @@ -700,6 +702,12 @@ Global {6821b87e-65eb-bfdb-8fdc-8b183edf739e}.Release|Any CPU.ActiveCfg = Release|Any CPU {6821b87e-65eb-bfdb-8fdc-8b183edf739e}.Release|Any CPU.Build.0 = Release|Any CPU {6821b87e-65eb-bfdb-8fdc-8b183edf739e}.Release|Any CPU.Deploy.0 = Release|Any CPU +{30fee563-a3f0-9c50-bfd1-1af707aaf3c4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU +{30fee563-a3f0-9c50-bfd1-1af707aaf3c4}.Debug|Any CPU.Build.0 = Debug|Any CPU +{30fee563-a3f0-9c50-bfd1-1af707aaf3c4}.Debug|Any CPU.Deploy.0 = Debug|Any CPU +{30fee563-a3f0-9c50-bfd1-1af707aaf3c4}.Release|Any CPU.ActiveCfg = Release|Any CPU +{30fee563-a3f0-9c50-bfd1-1af707aaf3c4}.Release|Any CPU.Build.0 = Release|Any CPU +{30fee563-a3f0-9c50-bfd1-1af707aaf3c4}.Release|Any CPU.Deploy.0 = Release|Any CPU {83d6c79a-c71a-d467-284c-28edbbd059d2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {83d6c79a-c71a-d467-284c-28edbbd059d2}.Debug|Any CPU.Build.0 = Debug|Any CPU {83d6c79a-c71a-d467-284c-28edbbd059d2}.Debug|Any CPU.Deploy.0 = Debug|Any CPU diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToReciprocalAreaExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToReciprocalAreaExtensionsTest.g.cs new file mode 100644 index 0000000000..b1cc9651f1 --- /dev/null +++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToReciprocalAreaExtensionsTest.g.cs @@ -0,0 +1,72 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by \generate-code.bat. +// +// Changes to this file will be lost when the code is regenerated. +// The build server regenerates the code before each build and a pre-build +// step will regenerate the code on each local build. +// +// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units. +// +// Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities. +// Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities. +// +// +//------------------------------------------------------------------------------ + +// Licensed under MIT No Attribution, see LICENSE file at the root. +// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet. + +using UnitsNet.NumberExtensions.NumberToReciprocalArea; +using Xunit; + +namespace UnitsNet.Tests +{ + public class NumberToReciprocalAreaExtensionsTests + { + [Fact] + public void NumberToInverseSquareCentimetersTest() => + Assert.Equal(ReciprocalArea.FromInverseSquareCentimeters(2), 2.InverseSquareCentimeters()); + + [Fact] + public void NumberToInverseSquareDecimetersTest() => + Assert.Equal(ReciprocalArea.FromInverseSquareDecimeters(2), 2.InverseSquareDecimeters()); + + [Fact] + public void NumberToInverseSquareFeetTest() => + Assert.Equal(ReciprocalArea.FromInverseSquareFeet(2), 2.InverseSquareFeet()); + + [Fact] + public void NumberToInverseSquareInchesTest() => + Assert.Equal(ReciprocalArea.FromInverseSquareInches(2), 2.InverseSquareInches()); + + [Fact] + public void NumberToInverseSquareKilometersTest() => + Assert.Equal(ReciprocalArea.FromInverseSquareKilometers(2), 2.InverseSquareKilometers()); + + [Fact] + public void NumberToInverseSquareMetersTest() => + Assert.Equal(ReciprocalArea.FromInverseSquareMeters(2), 2.InverseSquareMeters()); + + [Fact] + public void NumberToInverseSquareMicrometersTest() => + Assert.Equal(ReciprocalArea.FromInverseSquareMicrometers(2), 2.InverseSquareMicrometers()); + + [Fact] + public void NumberToInverseSquareMilesTest() => + Assert.Equal(ReciprocalArea.FromInverseSquareMiles(2), 2.InverseSquareMiles()); + + [Fact] + public void NumberToInverseSquareMillimetersTest() => + Assert.Equal(ReciprocalArea.FromInverseSquareMillimeters(2), 2.InverseSquareMillimeters()); + + [Fact] + public void NumberToInverseSquareYardsTest() => + Assert.Equal(ReciprocalArea.FromInverseSquareYards(2), 2.InverseSquareYards()); + + [Fact] + public void NumberToInverseUsSurveySquareFeetTest() => + Assert.Equal(ReciprocalArea.FromInverseUsSurveySquareFeet(2), 2.InverseUsSurveySquareFeet()); + + } +} diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToReciprocalAreaExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToReciprocalAreaExtensions.g.cs new file mode 100644 index 0000000000..49dbeb9d31 --- /dev/null +++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToReciprocalAreaExtensions.g.cs @@ -0,0 +1,76 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by \generate-code.bat. +// +// Changes to this file will be lost when the code is regenerated. +// The build server regenerates the code before each build and a pre-build +// step will regenerate the code on each local build. +// +// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units. +// +// Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities. +// Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities. +// +// +//------------------------------------------------------------------------------ + +// Licensed under MIT No Attribution, see LICENSE file at the root. +// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet. + +using System; + +#nullable enable + +namespace UnitsNet.NumberExtensions.NumberToReciprocalArea +{ + /// + /// A number to ReciprocalArea Extensions + /// + public static class NumberToReciprocalAreaExtensions + { + /// + public static ReciprocalArea InverseSquareCentimeters(this T value) => + ReciprocalArea.FromInverseSquareCentimeters(Convert.ToDouble(value)); + + /// + public static ReciprocalArea InverseSquareDecimeters(this T value) => + ReciprocalArea.FromInverseSquareDecimeters(Convert.ToDouble(value)); + + /// + public static ReciprocalArea InverseSquareFeet(this T value) => + ReciprocalArea.FromInverseSquareFeet(Convert.ToDouble(value)); + + /// + public static ReciprocalArea InverseSquareInches(this T value) => + ReciprocalArea.FromInverseSquareInches(Convert.ToDouble(value)); + + /// + public static ReciprocalArea InverseSquareKilometers(this T value) => + ReciprocalArea.FromInverseSquareKilometers(Convert.ToDouble(value)); + + /// + public static ReciprocalArea InverseSquareMeters(this T value) => + ReciprocalArea.FromInverseSquareMeters(Convert.ToDouble(value)); + + /// + public static ReciprocalArea InverseSquareMicrometers(this T value) => + ReciprocalArea.FromInverseSquareMicrometers(Convert.ToDouble(value)); + + /// + public static ReciprocalArea InverseSquareMiles(this T value) => + ReciprocalArea.FromInverseSquareMiles(Convert.ToDouble(value)); + + /// + public static ReciprocalArea InverseSquareMillimeters(this T value) => + ReciprocalArea.FromInverseSquareMillimeters(Convert.ToDouble(value)); + + /// + public static ReciprocalArea InverseSquareYards(this T value) => + ReciprocalArea.FromInverseSquareYards(Convert.ToDouble(value)); + + /// + public static ReciprocalArea InverseUsSurveySquareFeet(this T value) => + ReciprocalArea.FromInverseUsSurveySquareFeet(Convert.ToDouble(value)); + + } +} diff --git a/UnitsNet.Tests/CustomCode/AreaTests.cs b/UnitsNet.Tests/CustomCode/AreaTests.cs index c917293d45..a235ee2dbe 100644 --- a/UnitsNet.Tests/CustomCode/AreaTests.cs +++ b/UnitsNet.Tests/CustomCode/AreaTests.cs @@ -118,5 +118,25 @@ public void ToUnit_GivenSIUnitSystem_ReturnsSIQuantity() Assert.Equal(0.00129032, inSI.Value); Assert.Equal(AreaUnit.SquareMeter, inSI.Unit); } + + [Theory] + [InlineData(-2.0, -0.5)] + [InlineData(-1.0, -1.0)] + [InlineData(0.0, 0.0)] + [InlineData(1.0, 1.0)] + [InlineData(2.0, 0.5)] + public void InverseReturnsReciprocalArea(double value, double expected) + { + var area = new Area(value, AreaUnit.SquareMeter); + var inverseArea = area.Inverse(); + Assert.Equal(expected, inverseArea.InverseSquareMeters); + } + + [Fact] + public void AreaTimesReciprocalAreaEqualsRatio() + { + Ratio ratio = Area.FromSquareMeters(0.5) * ReciprocalArea.FromInverseSquareMeters(10); + Assert.Equal(5.0, ratio.Value); + } } } diff --git a/UnitsNet.Tests/CustomCode/ElectricConductivityTests.cs b/UnitsNet.Tests/CustomCode/ElectricConductivityTests.cs index e737605987..11a68892b4 100644 --- a/UnitsNet.Tests/CustomCode/ElectricConductivityTests.cs +++ b/UnitsNet.Tests/CustomCode/ElectricConductivityTests.cs @@ -45,7 +45,7 @@ public static void InverseTest( double value, double expected ) var unit = new ElectricConductivity( value, ElectricConductivityUnit.SiemensPerMeter ); var inverse = unit.Inverse(); - AssertEx.Equals( expected, inverse.OhmMeters ); + Assert.Equal( expected, inverse.OhmMeters ); } } } diff --git a/UnitsNet.Tests/CustomCode/ElectricResistivityTests.cs b/UnitsNet.Tests/CustomCode/ElectricResistivityTests.cs index 378ec9a82d..e46e323a8e 100644 --- a/UnitsNet.Tests/CustomCode/ElectricResistivityTests.cs +++ b/UnitsNet.Tests/CustomCode/ElectricResistivityTests.cs @@ -69,7 +69,7 @@ public static void InverseTest( double value, double expected ) var unit = new ElectricResistivity( value, ElectricResistivityUnit.OhmMeter ); var inverse = unit.Inverse(); - AssertEx.Equals( expected, inverse.SiemensPerMeter ); + Assert.Equal( expected, inverse.SiemensPerMeter ); } } } diff --git a/UnitsNet.Tests/CustomCode/ForceTests.cs b/UnitsNet.Tests/CustomCode/ForceTests.cs index e87ed077c5..90e4b588c2 100644 --- a/UnitsNet.Tests/CustomCode/ForceTests.cs +++ b/UnitsNet.Tests/CustomCode/ForceTests.cs @@ -90,5 +90,12 @@ public void SpeedTimesForceEqualsPower() Power power = Speed.FromMetersPerSecond(10.0)*Force.FromNewtons(27.0); Assert.Equal(power, Power.FromWatts(270)); } + + [Fact] + public void ForceTimesReciprocalAreaEqualsPressure() + { + Pressure pressure = Force.FromNewtons(2) * ReciprocalArea.FromInverseSquareMeters(25); + Assert.Equal(pressure, Pressure.FromNewtonsPerSquareMeter(50)); + } } } diff --git a/UnitsNet.Tests/CustomCode/LengthTests.cs b/UnitsNet.Tests/CustomCode/LengthTests.cs index b665632d03..cf340ecf0f 100644 --- a/UnitsNet.Tests/CustomCode/LengthTests.cs +++ b/UnitsNet.Tests/CustomCode/LengthTests.cs @@ -225,7 +225,7 @@ public static void InverseReturnsReciprocalLength(double value, double expected) var length = new Length(value, Units.LengthUnit.Meter); var inverseLength = length.Inverse(); - AssertEx.Equals(expected, inverseLength.InverseMeters); + Assert.Equal(expected, inverseLength.InverseMeters); } } } diff --git a/UnitsNet.Tests/CustomCode/PressureTests.cs b/UnitsNet.Tests/CustomCode/PressureTests.cs index 2fedf52398..ef560dda04 100644 --- a/UnitsNet.Tests/CustomCode/PressureTests.cs +++ b/UnitsNet.Tests/CustomCode/PressureTests.cs @@ -237,5 +237,12 @@ public void Vacuum_WithVacuumPressureReference_IsEqual() var refPressure = new ReferencePressure(Pressure.FromAtmospheres(1), PressureReference.Vacuum); AssertEx.EqualTolerance(1, refPressure.Vacuum.Atmospheres, AtmospheresTolerance); } + + [Fact] + public void PressureDividedByReciprocalAreaEqualsForce() + { + Force force = Pressure.FromPascals(200) / ReciprocalArea.FromInverseSquareMeters(5); + Assert.Equal(force, Force.FromNewtons(40)); + } } } diff --git a/UnitsNet.Tests/CustomCode/ReciprocalAreaTests.cs b/UnitsNet.Tests/CustomCode/ReciprocalAreaTests.cs new file mode 100644 index 0000000000..dcb1625f6e --- /dev/null +++ b/UnitsNet.Tests/CustomCode/ReciprocalAreaTests.cs @@ -0,0 +1,78 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by \generate-code.bat. +// +// Changes to this file will be lost when the code is regenerated. +// The build server regenerates the code before each build and a pre-build +// step will regenerate the code on each local build. +// +// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units. +// +// Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities. +// Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities. +// +// +//------------------------------------------------------------------------------ + +// Licensed under MIT No 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.Units; +using Xunit; + +namespace UnitsNet.Tests.CustomCode +{ + public class ReciprocalAreaTests : ReciprocalAreaTestsBase + { + protected override bool SupportsSIUnitSystem => false; + + protected override double InverseSquareMetersInOneInverseSquareMeter => 1; + protected override double InverseSquareKilometersInOneInverseSquareMeter => 1E6; + protected override double InverseSquareDecimetersInOneInverseSquareMeter => 1E-2; + protected override double InverseSquareCentimetersInOneInverseSquareMeter => 1E-4; + protected override double InverseSquareMillimetersInOneInverseSquareMeter => 1E-6; + protected override double InverseSquareMicrometersInOneInverseSquareMeter => 1E-12; + + + protected override double InverseSquareMilesInOneInverseSquareMeter => 2.59E6; + protected override double InverseSquareYardsInOneInverseSquareMeter => 0.836127; + protected override double InverseSquareFeetInOneInverseSquareMeter => 0.092903; + protected override double InverseUsSurveySquareFeetInOneInverseSquareMeter => 0.09290341161; + protected override double InverseSquareInchesInOneInverseSquareMeter => 0.00064516; + + [Theory] + [InlineData(-2.0, -0.5)] + [InlineData(-1.0, -1.0)] + [InlineData(0.0, 0.0)] + [InlineData(1.0, 1.0)] + [InlineData(2.0, 0.5)] + public void InverseReturnsArea(double value, double expected) + { + var inverseArea = new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMeter); + var area = inverseArea.Inverse(); + + Assert.Equal(expected, area.SquareMeters); + } + + [Fact] + public void ReciprocalAreaTimesForceEqualsPressure() + { + Pressure pressure = ReciprocalArea.FromInverseSquareMeters(25) * Force.FromNewtons(2); + Assert.Equal(pressure, Pressure.FromNewtonsPerSquareMeter(50)); + } + + [Fact] + public void ReciprocalAreaTimesAreaEqualsRatio() + { + Ratio ratio = ReciprocalArea.FromInverseSquareMeters(10) * Area.FromSquareMeters(0.5); + Assert.Equal(5.0, ratio.Value); + } + + [Fact] + public void ReciprocalAreaDividedByReciprocalLengthEqualsReciprocalLength() + { + ReciprocalLength reciprocalLength = ReciprocalArea.FromInverseSquareMeters(10) / ReciprocalLength.FromInverseMeters(0.5); + Assert.Equal(reciprocalLength, ReciprocalLength.FromInverseMeters(20)); + } + } +} diff --git a/UnitsNet.Tests/CustomCode/ReciprocalLengthTests.cs b/UnitsNet.Tests/CustomCode/ReciprocalLengthTests.cs index 03ac14b0a8..5b217bb961 100644 --- a/UnitsNet.Tests/CustomCode/ReciprocalLengthTests.cs +++ b/UnitsNet.Tests/CustomCode/ReciprocalLengthTests.cs @@ -51,7 +51,7 @@ public static void InverseReturnsLength(double value, double expected) var inverseLength = new ReciprocalLength(value, ReciprocalLengthUnit.InverseMeter); var length = inverseLength.Inverse(); - AssertEx.Equals(expected, length.Meters); + Assert.Equal(expected, length.Meters); } [Fact] @@ -95,5 +95,19 @@ public static void ReciprocalLengthTimesForceEqualsForcePerLength() ForcePerLength forcePerLength = ReciprocalLength.FromInverseMeters(5) * Force.FromNewtons(10); Assert.Equal(forcePerLength, ForcePerLength.FromNewtonsPerMeter(50)); } + + [Fact] + public void ReciprocalLengthTimesReciprocalLengthEqualsReciprocalArea() + { + ReciprocalArea reciprocalArea = ReciprocalLength.FromInverseMeters(10) * ReciprocalLength.FromInverseMeters(20); + Assert.Equal(reciprocalArea, ReciprocalArea.FromInverseSquareMeters(200)); + } + + [Fact] + public void ReciprocalLengthDividedByReciprocalAreaEqualsLength() + { + Length length = ReciprocalLength.FromInverseMeters(5) / ReciprocalArea.FromInverseSquareMeters(10); + Assert.Equal(length, Length.FromMeters(0.5)); + } } } diff --git a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs index 26134289f8..a135be39b0 100644 --- a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs +++ b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs @@ -113,6 +113,7 @@ void Assertion(int expectedValue, Enum expectedUnit, IQuantity quantity) Assertion(3, RatioChangeRateUnit.PercentPerSecond, Quantity.From(3, RatioChangeRateUnit.PercentPerSecond)); Assertion(3, ReactiveEnergyUnit.VoltampereReactiveHour, Quantity.From(3, ReactiveEnergyUnit.VoltampereReactiveHour)); Assertion(3, ReactivePowerUnit.VoltampereReactive, Quantity.From(3, ReactivePowerUnit.VoltampereReactive)); + Assertion(3, ReciprocalAreaUnit.InverseUsSurveySquareFoot, Quantity.From(3, ReciprocalAreaUnit.InverseUsSurveySquareFoot)); Assertion(3, ReciprocalLengthUnit.InverseYard, Quantity.From(3, ReciprocalLengthUnit.InverseYard)); Assertion(3, RelativeHumidityUnit.Percent, Quantity.From(3, RelativeHumidityUnit.Percent)); Assertion(3, RotationalAccelerationUnit.RevolutionPerSecondSquared, Quantity.From(3, RotationalAccelerationUnit.RevolutionPerSecondSquared)); @@ -229,6 +230,7 @@ public void QuantityInfo_IsSameAsStaticInfoProperty() Assertion(RatioChangeRate.Info, RatioChangeRate.Zero); Assertion(ReactiveEnergy.Info, ReactiveEnergy.Zero); Assertion(ReactivePower.Info, ReactivePower.Zero); + Assertion(ReciprocalArea.Info, ReciprocalArea.Zero); Assertion(ReciprocalLength.Info, ReciprocalLength.Zero); Assertion(RelativeHumidity.Info, RelativeHumidity.Zero); Assertion(RotationalAcceleration.Info, RotationalAcceleration.Zero); @@ -345,6 +347,7 @@ public void Type_EqualsStaticQuantityTypeProperty() Assertion(RatioChangeRate.QuantityType, RatioChangeRate.Zero); Assertion(ReactiveEnergy.QuantityType, ReactiveEnergy.Zero); Assertion(ReactivePower.QuantityType, ReactivePower.Zero); + Assertion(ReciprocalArea.QuantityType, ReciprocalArea.Zero); Assertion(ReciprocalLength.QuantityType, ReciprocalLength.Zero); Assertion(RelativeHumidity.QuantityType, RelativeHumidity.Zero); Assertion(RotationalAcceleration.QuantityType, RotationalAcceleration.Zero); @@ -461,6 +464,7 @@ public void Dimensions_IsSameAsStaticBaseDimensions() Assertion(RatioChangeRate.BaseDimensions, RatioChangeRate.Zero); Assertion(ReactiveEnergy.BaseDimensions, ReactiveEnergy.Zero); Assertion(ReactivePower.BaseDimensions, ReactivePower.Zero); + Assertion(ReciprocalArea.BaseDimensions, ReciprocalArea.Zero); Assertion(ReciprocalLength.BaseDimensions, ReciprocalLength.Zero); Assertion(RelativeHumidity.BaseDimensions, RelativeHumidity.Zero); Assertion(RotationalAcceleration.BaseDimensions, RotationalAcceleration.Zero); diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ReciprocalAreaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ReciprocalAreaTestsBase.g.cs new file mode 100644 index 0000000000..b64695166c --- /dev/null +++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ReciprocalAreaTestsBase.g.cs @@ -0,0 +1,728 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by \generate-code.bat. +// +// Changes to this file will be lost when the code is regenerated. +// The build server regenerates the code before each build and a pre-build +// step will regenerate the code on each local build. +// +// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units. +// +// Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities. +// Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities. +// +// +//------------------------------------------------------------------------------ + +// Licensed under MIT No 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.Tests.TestsBase; +using UnitsNet.Units; +using Xunit; + +// Disable build warning CS1718: Comparison made to same variable; did you mean to compare something else? +#pragma warning disable 1718 + +// ReSharper disable once CheckNamespace +namespace UnitsNet.Tests +{ + /// + /// Test of ReciprocalArea. + /// +// ReSharper disable once PartialTypeWithSinglePart + public abstract partial class ReciprocalAreaTestsBase : QuantityTestsBase + { + protected abstract double InverseSquareCentimetersInOneInverseSquareMeter { get; } + protected abstract double InverseSquareDecimetersInOneInverseSquareMeter { get; } + protected abstract double InverseSquareFeetInOneInverseSquareMeter { get; } + protected abstract double InverseSquareInchesInOneInverseSquareMeter { get; } + protected abstract double InverseSquareKilometersInOneInverseSquareMeter { get; } + protected abstract double InverseSquareMetersInOneInverseSquareMeter { get; } + protected abstract double InverseSquareMicrometersInOneInverseSquareMeter { get; } + protected abstract double InverseSquareMilesInOneInverseSquareMeter { get; } + protected abstract double InverseSquareMillimetersInOneInverseSquareMeter { get; } + protected abstract double InverseSquareYardsInOneInverseSquareMeter { get; } + protected abstract double InverseUsSurveySquareFeetInOneInverseSquareMeter { get; } + +// ReSharper disable VirtualMemberNeverOverriden.Global + protected virtual double InverseSquareCentimetersTolerance { get { return 1e-5; } } + protected virtual double InverseSquareDecimetersTolerance { get { return 1e-5; } } + protected virtual double InverseSquareFeetTolerance { get { return 1e-5; } } + protected virtual double InverseSquareInchesTolerance { get { return 1e-5; } } + protected virtual double InverseSquareKilometersTolerance { get { return 1e-5; } } + protected virtual double InverseSquareMetersTolerance { get { return 1e-5; } } + protected virtual double InverseSquareMicrometersTolerance { get { return 1e-5; } } + protected virtual double InverseSquareMilesTolerance { get { return 1e-5; } } + protected virtual double InverseSquareMillimetersTolerance { get { return 1e-5; } } + protected virtual double InverseSquareYardsTolerance { get { return 1e-5; } } + protected virtual double InverseUsSurveySquareFeetTolerance { get { return 1e-5; } } +// ReSharper restore VirtualMemberNeverOverriden.Global + + [Fact] + public void Ctor_WithUndefinedUnit_ThrowsArgumentException() + { + Assert.Throws(() => new ReciprocalArea((double)0.0, ReciprocalAreaUnit.Undefined)); + } + + [Fact] + public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit() + { + var quantity = new ReciprocalArea(); + Assert.Equal(0, quantity.Value); + Assert.Equal(ReciprocalAreaUnit.InverseSquareMeter, quantity.Unit); + } + + + [Fact] + public void Ctor_WithInfinityValue_ThrowsArgumentException() + { + Assert.Throws(() => new ReciprocalArea(double.PositiveInfinity, ReciprocalAreaUnit.InverseSquareMeter)); + Assert.Throws(() => new ReciprocalArea(double.NegativeInfinity, ReciprocalAreaUnit.InverseSquareMeter)); + } + + [Fact] + public void Ctor_WithNaNValue_ThrowsArgumentException() + { + Assert.Throws(() => new ReciprocalArea(double.NaN, ReciprocalAreaUnit.InverseSquareMeter)); + } + + [Fact] + public void Ctor_NullAsUnitSystem_ThrowsArgumentNullException() + { + Assert.Throws(() => new ReciprocalArea(value: 1, unitSystem: null)); + } + + [Fact] + public void Ctor_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported() + { + Func TestCode = () => new ReciprocalArea(value: 1, unitSystem: UnitSystem.SI); + if (SupportsSIUnitSystem) + { + var quantity = (ReciprocalArea) TestCode(); + Assert.Equal(1, quantity.Value); + } + else + { + Assert.Throws(TestCode); + } + } + + [Fact] + public void ReciprocalArea_QuantityInfo_ReturnsQuantityInfoDescribingQuantity() + { + var quantity = new ReciprocalArea(1, ReciprocalAreaUnit.InverseSquareMeter); + + QuantityInfo quantityInfo = quantity.QuantityInfo; + + Assert.Equal(ReciprocalArea.Zero, quantityInfo.Zero); + Assert.Equal("ReciprocalArea", quantityInfo.Name); + Assert.Equal(QuantityType.ReciprocalArea, quantityInfo.QuantityType); + + var units = EnumUtils.GetEnumValues().Except(new[] {ReciprocalAreaUnit.Undefined}).ToArray(); + var unitNames = units.Select(x => x.ToString()); + + // Obsolete members + Assert.Equal(units, quantityInfo.Units); + Assert.Equal(unitNames, quantityInfo.UnitNames); + } + + [Fact] + public void InverseSquareMeterToReciprocalAreaUnits() + { + ReciprocalArea inversesquaremeter = ReciprocalArea.FromInverseSquareMeters(1); + AssertEx.EqualTolerance(InverseSquareCentimetersInOneInverseSquareMeter, inversesquaremeter.InverseSquareCentimeters, InverseSquareCentimetersTolerance); + AssertEx.EqualTolerance(InverseSquareDecimetersInOneInverseSquareMeter, inversesquaremeter.InverseSquareDecimeters, InverseSquareDecimetersTolerance); + AssertEx.EqualTolerance(InverseSquareFeetInOneInverseSquareMeter, inversesquaremeter.InverseSquareFeet, InverseSquareFeetTolerance); + AssertEx.EqualTolerance(InverseSquareInchesInOneInverseSquareMeter, inversesquaremeter.InverseSquareInches, InverseSquareInchesTolerance); + AssertEx.EqualTolerance(InverseSquareKilometersInOneInverseSquareMeter, inversesquaremeter.InverseSquareKilometers, InverseSquareKilometersTolerance); + AssertEx.EqualTolerance(InverseSquareMetersInOneInverseSquareMeter, inversesquaremeter.InverseSquareMeters, InverseSquareMetersTolerance); + AssertEx.EqualTolerance(InverseSquareMicrometersInOneInverseSquareMeter, inversesquaremeter.InverseSquareMicrometers, InverseSquareMicrometersTolerance); + AssertEx.EqualTolerance(InverseSquareMilesInOneInverseSquareMeter, inversesquaremeter.InverseSquareMiles, InverseSquareMilesTolerance); + AssertEx.EqualTolerance(InverseSquareMillimetersInOneInverseSquareMeter, inversesquaremeter.InverseSquareMillimeters, InverseSquareMillimetersTolerance); + AssertEx.EqualTolerance(InverseSquareYardsInOneInverseSquareMeter, inversesquaremeter.InverseSquareYards, InverseSquareYardsTolerance); + AssertEx.EqualTolerance(InverseUsSurveySquareFeetInOneInverseSquareMeter, inversesquaremeter.InverseUsSurveySquareFeet, InverseUsSurveySquareFeetTolerance); + } + + [Fact] + public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit() + { + var quantity00 = ReciprocalArea.From(1, ReciprocalAreaUnit.InverseSquareCentimeter); + AssertEx.EqualTolerance(1, quantity00.InverseSquareCentimeters, InverseSquareCentimetersTolerance); + Assert.Equal(ReciprocalAreaUnit.InverseSquareCentimeter, quantity00.Unit); + + var quantity01 = ReciprocalArea.From(1, ReciprocalAreaUnit.InverseSquareDecimeter); + AssertEx.EqualTolerance(1, quantity01.InverseSquareDecimeters, InverseSquareDecimetersTolerance); + Assert.Equal(ReciprocalAreaUnit.InverseSquareDecimeter, quantity01.Unit); + + var quantity02 = ReciprocalArea.From(1, ReciprocalAreaUnit.InverseSquareFoot); + AssertEx.EqualTolerance(1, quantity02.InverseSquareFeet, InverseSquareFeetTolerance); + Assert.Equal(ReciprocalAreaUnit.InverseSquareFoot, quantity02.Unit); + + var quantity03 = ReciprocalArea.From(1, ReciprocalAreaUnit.InverseSquareInch); + AssertEx.EqualTolerance(1, quantity03.InverseSquareInches, InverseSquareInchesTolerance); + Assert.Equal(ReciprocalAreaUnit.InverseSquareInch, quantity03.Unit); + + var quantity04 = ReciprocalArea.From(1, ReciprocalAreaUnit.InverseSquareKilometer); + AssertEx.EqualTolerance(1, quantity04.InverseSquareKilometers, InverseSquareKilometersTolerance); + Assert.Equal(ReciprocalAreaUnit.InverseSquareKilometer, quantity04.Unit); + + var quantity05 = ReciprocalArea.From(1, ReciprocalAreaUnit.InverseSquareMeter); + AssertEx.EqualTolerance(1, quantity05.InverseSquareMeters, InverseSquareMetersTolerance); + Assert.Equal(ReciprocalAreaUnit.InverseSquareMeter, quantity05.Unit); + + var quantity06 = ReciprocalArea.From(1, ReciprocalAreaUnit.InverseSquareMicrometer); + AssertEx.EqualTolerance(1, quantity06.InverseSquareMicrometers, InverseSquareMicrometersTolerance); + Assert.Equal(ReciprocalAreaUnit.InverseSquareMicrometer, quantity06.Unit); + + var quantity07 = ReciprocalArea.From(1, ReciprocalAreaUnit.InverseSquareMile); + AssertEx.EqualTolerance(1, quantity07.InverseSquareMiles, InverseSquareMilesTolerance); + Assert.Equal(ReciprocalAreaUnit.InverseSquareMile, quantity07.Unit); + + var quantity08 = ReciprocalArea.From(1, ReciprocalAreaUnit.InverseSquareMillimeter); + AssertEx.EqualTolerance(1, quantity08.InverseSquareMillimeters, InverseSquareMillimetersTolerance); + Assert.Equal(ReciprocalAreaUnit.InverseSquareMillimeter, quantity08.Unit); + + var quantity09 = ReciprocalArea.From(1, ReciprocalAreaUnit.InverseSquareYard); + AssertEx.EqualTolerance(1, quantity09.InverseSquareYards, InverseSquareYardsTolerance); + Assert.Equal(ReciprocalAreaUnit.InverseSquareYard, quantity09.Unit); + + var quantity10 = ReciprocalArea.From(1, ReciprocalAreaUnit.InverseUsSurveySquareFoot); + AssertEx.EqualTolerance(1, quantity10.InverseUsSurveySquareFeet, InverseUsSurveySquareFeetTolerance); + Assert.Equal(ReciprocalAreaUnit.InverseUsSurveySquareFoot, quantity10.Unit); + + } + + [Fact] + public void FromInverseSquareMeters_WithInfinityValue_ThrowsArgumentException() + { + Assert.Throws(() => ReciprocalArea.FromInverseSquareMeters(double.PositiveInfinity)); + Assert.Throws(() => ReciprocalArea.FromInverseSquareMeters(double.NegativeInfinity)); + } + + [Fact] + public void FromInverseSquareMeters_WithNanValue_ThrowsArgumentException() + { + Assert.Throws(() => ReciprocalArea.FromInverseSquareMeters(double.NaN)); + } + + [Fact] + public void As() + { + var inversesquaremeter = ReciprocalArea.FromInverseSquareMeters(1); + AssertEx.EqualTolerance(InverseSquareCentimetersInOneInverseSquareMeter, inversesquaremeter.As(ReciprocalAreaUnit.InverseSquareCentimeter), InverseSquareCentimetersTolerance); + AssertEx.EqualTolerance(InverseSquareDecimetersInOneInverseSquareMeter, inversesquaremeter.As(ReciprocalAreaUnit.InverseSquareDecimeter), InverseSquareDecimetersTolerance); + AssertEx.EqualTolerance(InverseSquareFeetInOneInverseSquareMeter, inversesquaremeter.As(ReciprocalAreaUnit.InverseSquareFoot), InverseSquareFeetTolerance); + AssertEx.EqualTolerance(InverseSquareInchesInOneInverseSquareMeter, inversesquaremeter.As(ReciprocalAreaUnit.InverseSquareInch), InverseSquareInchesTolerance); + AssertEx.EqualTolerance(InverseSquareKilometersInOneInverseSquareMeter, inversesquaremeter.As(ReciprocalAreaUnit.InverseSquareKilometer), InverseSquareKilometersTolerance); + AssertEx.EqualTolerance(InverseSquareMetersInOneInverseSquareMeter, inversesquaremeter.As(ReciprocalAreaUnit.InverseSquareMeter), InverseSquareMetersTolerance); + AssertEx.EqualTolerance(InverseSquareMicrometersInOneInverseSquareMeter, inversesquaremeter.As(ReciprocalAreaUnit.InverseSquareMicrometer), InverseSquareMicrometersTolerance); + AssertEx.EqualTolerance(InverseSquareMilesInOneInverseSquareMeter, inversesquaremeter.As(ReciprocalAreaUnit.InverseSquareMile), InverseSquareMilesTolerance); + AssertEx.EqualTolerance(InverseSquareMillimetersInOneInverseSquareMeter, inversesquaremeter.As(ReciprocalAreaUnit.InverseSquareMillimeter), InverseSquareMillimetersTolerance); + AssertEx.EqualTolerance(InverseSquareYardsInOneInverseSquareMeter, inversesquaremeter.As(ReciprocalAreaUnit.InverseSquareYard), InverseSquareYardsTolerance); + AssertEx.EqualTolerance(InverseUsSurveySquareFeetInOneInverseSquareMeter, inversesquaremeter.As(ReciprocalAreaUnit.InverseUsSurveySquareFoot), InverseUsSurveySquareFeetTolerance); + } + + [Fact] + public void As_SIUnitSystem_ThrowsArgumentExceptionIfNotSupported() + { + var quantity = new ReciprocalArea(value: 1, unit: ReciprocalArea.BaseUnit); + Func AsWithSIUnitSystem = () => quantity.As(UnitSystem.SI); + + if (SupportsSIUnitSystem) + { + var value = (double) AsWithSIUnitSystem(); + Assert.Equal(1, value); + } + else + { + Assert.Throws(AsWithSIUnitSystem); + } + } + + [Fact] + public void ToUnit() + { + var inversesquaremeter = ReciprocalArea.FromInverseSquareMeters(1); + + var inversesquarecentimeterQuantity = inversesquaremeter.ToUnit(ReciprocalAreaUnit.InverseSquareCentimeter); + AssertEx.EqualTolerance(InverseSquareCentimetersInOneInverseSquareMeter, (double)inversesquarecentimeterQuantity.Value, InverseSquareCentimetersTolerance); + Assert.Equal(ReciprocalAreaUnit.InverseSquareCentimeter, inversesquarecentimeterQuantity.Unit); + + var inversesquaredecimeterQuantity = inversesquaremeter.ToUnit(ReciprocalAreaUnit.InverseSquareDecimeter); + AssertEx.EqualTolerance(InverseSquareDecimetersInOneInverseSquareMeter, (double)inversesquaredecimeterQuantity.Value, InverseSquareDecimetersTolerance); + Assert.Equal(ReciprocalAreaUnit.InverseSquareDecimeter, inversesquaredecimeterQuantity.Unit); + + var inversesquarefootQuantity = inversesquaremeter.ToUnit(ReciprocalAreaUnit.InverseSquareFoot); + AssertEx.EqualTolerance(InverseSquareFeetInOneInverseSquareMeter, (double)inversesquarefootQuantity.Value, InverseSquareFeetTolerance); + Assert.Equal(ReciprocalAreaUnit.InverseSquareFoot, inversesquarefootQuantity.Unit); + + var inversesquareinchQuantity = inversesquaremeter.ToUnit(ReciprocalAreaUnit.InverseSquareInch); + AssertEx.EqualTolerance(InverseSquareInchesInOneInverseSquareMeter, (double)inversesquareinchQuantity.Value, InverseSquareInchesTolerance); + Assert.Equal(ReciprocalAreaUnit.InverseSquareInch, inversesquareinchQuantity.Unit); + + var inversesquarekilometerQuantity = inversesquaremeter.ToUnit(ReciprocalAreaUnit.InverseSquareKilometer); + AssertEx.EqualTolerance(InverseSquareKilometersInOneInverseSquareMeter, (double)inversesquarekilometerQuantity.Value, InverseSquareKilometersTolerance); + Assert.Equal(ReciprocalAreaUnit.InverseSquareKilometer, inversesquarekilometerQuantity.Unit); + + var inversesquaremeterQuantity = inversesquaremeter.ToUnit(ReciprocalAreaUnit.InverseSquareMeter); + AssertEx.EqualTolerance(InverseSquareMetersInOneInverseSquareMeter, (double)inversesquaremeterQuantity.Value, InverseSquareMetersTolerance); + Assert.Equal(ReciprocalAreaUnit.InverseSquareMeter, inversesquaremeterQuantity.Unit); + + var inversesquaremicrometerQuantity = inversesquaremeter.ToUnit(ReciprocalAreaUnit.InverseSquareMicrometer); + AssertEx.EqualTolerance(InverseSquareMicrometersInOneInverseSquareMeter, (double)inversesquaremicrometerQuantity.Value, InverseSquareMicrometersTolerance); + Assert.Equal(ReciprocalAreaUnit.InverseSquareMicrometer, inversesquaremicrometerQuantity.Unit); + + var inversesquaremileQuantity = inversesquaremeter.ToUnit(ReciprocalAreaUnit.InverseSquareMile); + AssertEx.EqualTolerance(InverseSquareMilesInOneInverseSquareMeter, (double)inversesquaremileQuantity.Value, InverseSquareMilesTolerance); + Assert.Equal(ReciprocalAreaUnit.InverseSquareMile, inversesquaremileQuantity.Unit); + + var inversesquaremillimeterQuantity = inversesquaremeter.ToUnit(ReciprocalAreaUnit.InverseSquareMillimeter); + AssertEx.EqualTolerance(InverseSquareMillimetersInOneInverseSquareMeter, (double)inversesquaremillimeterQuantity.Value, InverseSquareMillimetersTolerance); + Assert.Equal(ReciprocalAreaUnit.InverseSquareMillimeter, inversesquaremillimeterQuantity.Unit); + + var inversesquareyardQuantity = inversesquaremeter.ToUnit(ReciprocalAreaUnit.InverseSquareYard); + AssertEx.EqualTolerance(InverseSquareYardsInOneInverseSquareMeter, (double)inversesquareyardQuantity.Value, InverseSquareYardsTolerance); + Assert.Equal(ReciprocalAreaUnit.InverseSquareYard, inversesquareyardQuantity.Unit); + + var inverseussurveysquarefootQuantity = inversesquaremeter.ToUnit(ReciprocalAreaUnit.InverseUsSurveySquareFoot); + AssertEx.EqualTolerance(InverseUsSurveySquareFeetInOneInverseSquareMeter, (double)inverseussurveysquarefootQuantity.Value, InverseUsSurveySquareFeetTolerance); + Assert.Equal(ReciprocalAreaUnit.InverseUsSurveySquareFoot, inverseussurveysquarefootQuantity.Unit); + } + + [Fact] + public void ToBaseUnit_ReturnsQuantityWithBaseUnit() + { + var quantityInBaseUnit = ReciprocalArea.FromInverseSquareMeters(1).ToBaseUnit(); + Assert.Equal(ReciprocalArea.BaseUnit, quantityInBaseUnit.Unit); + } + + [Fact] + public void ConversionRoundTrip() + { + ReciprocalArea inversesquaremeter = ReciprocalArea.FromInverseSquareMeters(1); + AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareCentimeters(inversesquaremeter.InverseSquareCentimeters).InverseSquareMeters, InverseSquareCentimetersTolerance); + AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareDecimeters(inversesquaremeter.InverseSquareDecimeters).InverseSquareMeters, InverseSquareDecimetersTolerance); + AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareFeet(inversesquaremeter.InverseSquareFeet).InverseSquareMeters, InverseSquareFeetTolerance); + AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareInches(inversesquaremeter.InverseSquareInches).InverseSquareMeters, InverseSquareInchesTolerance); + AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareKilometers(inversesquaremeter.InverseSquareKilometers).InverseSquareMeters, InverseSquareKilometersTolerance); + AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareMeters(inversesquaremeter.InverseSquareMeters).InverseSquareMeters, InverseSquareMetersTolerance); + AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareMicrometers(inversesquaremeter.InverseSquareMicrometers).InverseSquareMeters, InverseSquareMicrometersTolerance); + AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareMiles(inversesquaremeter.InverseSquareMiles).InverseSquareMeters, InverseSquareMilesTolerance); + AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareMillimeters(inversesquaremeter.InverseSquareMillimeters).InverseSquareMeters, InverseSquareMillimetersTolerance); + AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseSquareYards(inversesquaremeter.InverseSquareYards).InverseSquareMeters, InverseSquareYardsTolerance); + AssertEx.EqualTolerance(1, ReciprocalArea.FromInverseUsSurveySquareFeet(inversesquaremeter.InverseUsSurveySquareFeet).InverseSquareMeters, InverseUsSurveySquareFeetTolerance); + } + + [Fact] + public void ArithmeticOperators() + { + ReciprocalArea v = ReciprocalArea.FromInverseSquareMeters(1); + AssertEx.EqualTolerance(-1, -v.InverseSquareMeters, InverseSquareMetersTolerance); + AssertEx.EqualTolerance(2, (ReciprocalArea.FromInverseSquareMeters(3)-v).InverseSquareMeters, InverseSquareMetersTolerance); + AssertEx.EqualTolerance(2, (v + v).InverseSquareMeters, InverseSquareMetersTolerance); + AssertEx.EqualTolerance(10, (v*10).InverseSquareMeters, InverseSquareMetersTolerance); + AssertEx.EqualTolerance(10, (10*v).InverseSquareMeters, InverseSquareMetersTolerance); + AssertEx.EqualTolerance(2, (ReciprocalArea.FromInverseSquareMeters(10)/5).InverseSquareMeters, InverseSquareMetersTolerance); + AssertEx.EqualTolerance(2, ReciprocalArea.FromInverseSquareMeters(10)/ReciprocalArea.FromInverseSquareMeters(5), InverseSquareMetersTolerance); + } + + [Fact] + public void ComparisonOperators() + { + ReciprocalArea oneInverseSquareMeter = ReciprocalArea.FromInverseSquareMeters(1); + ReciprocalArea twoInverseSquareMeters = ReciprocalArea.FromInverseSquareMeters(2); + + Assert.True(oneInverseSquareMeter < twoInverseSquareMeters); + Assert.True(oneInverseSquareMeter <= twoInverseSquareMeters); + Assert.True(twoInverseSquareMeters > oneInverseSquareMeter); + Assert.True(twoInverseSquareMeters >= oneInverseSquareMeter); + + Assert.False(oneInverseSquareMeter > twoInverseSquareMeters); + Assert.False(oneInverseSquareMeter >= twoInverseSquareMeters); + Assert.False(twoInverseSquareMeters < oneInverseSquareMeter); + Assert.False(twoInverseSquareMeters <= oneInverseSquareMeter); + } + + [Fact] + public void CompareToIsImplemented() + { + ReciprocalArea inversesquaremeter = ReciprocalArea.FromInverseSquareMeters(1); + Assert.Equal(0, inversesquaremeter.CompareTo(inversesquaremeter)); + Assert.True(inversesquaremeter.CompareTo(ReciprocalArea.Zero) > 0); + Assert.True(ReciprocalArea.Zero.CompareTo(inversesquaremeter) < 0); + } + + [Fact] + public void CompareToThrowsOnTypeMismatch() + { + ReciprocalArea inversesquaremeter = ReciprocalArea.FromInverseSquareMeters(1); + Assert.Throws(() => inversesquaremeter.CompareTo(new object())); + } + + [Fact] + public void CompareToThrowsOnNull() + { + ReciprocalArea inversesquaremeter = ReciprocalArea.FromInverseSquareMeters(1); + Assert.Throws(() => inversesquaremeter.CompareTo(null)); + } + + [Fact] + public void EqualityOperators() + { + var a = ReciprocalArea.FromInverseSquareMeters(1); + var b = ReciprocalArea.FromInverseSquareMeters(2); + +#pragma warning disable CS8073 +// ReSharper disable EqualExpressionComparison + + Assert.True(a == a); + Assert.False(a != a); + + Assert.True(a != b); + Assert.False(a == b); + + Assert.False(a == null); + Assert.False(null == a); + +// ReSharper restore EqualExpressionComparison +#pragma warning restore CS8073 + } + + [Fact] + public void Equals_SameType_IsImplemented() + { + var a = ReciprocalArea.FromInverseSquareMeters(1); + var b = ReciprocalArea.FromInverseSquareMeters(2); + + Assert.True(a.Equals(a)); + Assert.False(a.Equals(b)); + } + + [Fact] + public void Equals_QuantityAsObject_IsImplemented() + { + object a = ReciprocalArea.FromInverseSquareMeters(1); + object b = ReciprocalArea.FromInverseSquareMeters(2); + + Assert.True(a.Equals(a)); + Assert.False(a.Equals(b)); + Assert.False(a.Equals((object)null)); + } + + [Fact] + public void Equals_RelativeTolerance_IsImplemented() + { + var v = ReciprocalArea.FromInverseSquareMeters(1); + Assert.True(v.Equals(ReciprocalArea.FromInverseSquareMeters(1), InverseSquareMetersTolerance, ComparisonType.Relative)); + Assert.False(v.Equals(ReciprocalArea.Zero, InverseSquareMetersTolerance, ComparisonType.Relative)); + } + + [Fact] + public void Equals_NegativeRelativeTolerance_ThrowsArgumentOutOfRangeException() + { + var v = ReciprocalArea.FromInverseSquareMeters(1); + Assert.Throws(() => v.Equals(ReciprocalArea.FromInverseSquareMeters(1), -1, ComparisonType.Relative)); + } + + [Fact] + public void EqualsReturnsFalseOnTypeMismatch() + { + ReciprocalArea inversesquaremeter = ReciprocalArea.FromInverseSquareMeters(1); + Assert.False(inversesquaremeter.Equals(new object())); + } + + [Fact] + public void EqualsReturnsFalseOnNull() + { + ReciprocalArea inversesquaremeter = ReciprocalArea.FromInverseSquareMeters(1); + Assert.False(inversesquaremeter.Equals(null)); + } + + [Fact] + public void UnitsDoesNotContainUndefined() + { + Assert.DoesNotContain(ReciprocalAreaUnit.Undefined, ReciprocalArea.Units); + } + + [Fact] + public void HasAtLeastOneAbbreviationSpecified() + { + var units = Enum.GetValues(typeof(ReciprocalAreaUnit)).Cast(); + foreach(var unit in units) + { + if(unit == ReciprocalAreaUnit.Undefined) + continue; + + var defaultAbbreviation = UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit); + } + } + + [Fact] + public void BaseDimensionsShouldNeverBeNull() + { + Assert.False(ReciprocalArea.BaseDimensions is null); + } + + [Fact] + public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture() + { + var prevCulture = Thread.CurrentThread.CurrentUICulture; + Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo("en-US"); + try { + Assert.Equal("1 cm⁻²", new ReciprocalArea(1, ReciprocalAreaUnit.InverseSquareCentimeter).ToString()); + Assert.Equal("1 dm⁻²", new ReciprocalArea(1, ReciprocalAreaUnit.InverseSquareDecimeter).ToString()); + Assert.Equal("1 ft⁻²", new ReciprocalArea(1, ReciprocalAreaUnit.InverseSquareFoot).ToString()); + Assert.Equal("1 in⁻²", new ReciprocalArea(1, ReciprocalAreaUnit.InverseSquareInch).ToString()); + Assert.Equal("1 km⁻²", new ReciprocalArea(1, ReciprocalAreaUnit.InverseSquareKilometer).ToString()); + Assert.Equal("1 m⁻²", new ReciprocalArea(1, ReciprocalAreaUnit.InverseSquareMeter).ToString()); + Assert.Equal("1 µm⁻²", new ReciprocalArea(1, ReciprocalAreaUnit.InverseSquareMicrometer).ToString()); + Assert.Equal("1 mi⁻²", new ReciprocalArea(1, ReciprocalAreaUnit.InverseSquareMile).ToString()); + Assert.Equal("1 mm⁻²", new ReciprocalArea(1, ReciprocalAreaUnit.InverseSquareMillimeter).ToString()); + Assert.Equal("1 yd⁻²", new ReciprocalArea(1, ReciprocalAreaUnit.InverseSquareYard).ToString()); + Assert.Equal("1 ft⁻² (US)", new ReciprocalArea(1, ReciprocalAreaUnit.InverseUsSurveySquareFoot).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 cm⁻²", new ReciprocalArea(1, ReciprocalAreaUnit.InverseSquareCentimeter).ToString(swedishCulture)); + Assert.Equal("1 dm⁻²", new ReciprocalArea(1, ReciprocalAreaUnit.InverseSquareDecimeter).ToString(swedishCulture)); + Assert.Equal("1 ft⁻²", new ReciprocalArea(1, ReciprocalAreaUnit.InverseSquareFoot).ToString(swedishCulture)); + Assert.Equal("1 in⁻²", new ReciprocalArea(1, ReciprocalAreaUnit.InverseSquareInch).ToString(swedishCulture)); + Assert.Equal("1 km⁻²", new ReciprocalArea(1, ReciprocalAreaUnit.InverseSquareKilometer).ToString(swedishCulture)); + Assert.Equal("1 m⁻²", new ReciprocalArea(1, ReciprocalAreaUnit.InverseSquareMeter).ToString(swedishCulture)); + Assert.Equal("1 µm⁻²", new ReciprocalArea(1, ReciprocalAreaUnit.InverseSquareMicrometer).ToString(swedishCulture)); + Assert.Equal("1 mi⁻²", new ReciprocalArea(1, ReciprocalAreaUnit.InverseSquareMile).ToString(swedishCulture)); + Assert.Equal("1 mm⁻²", new ReciprocalArea(1, ReciprocalAreaUnit.InverseSquareMillimeter).ToString(swedishCulture)); + Assert.Equal("1 yd⁻²", new ReciprocalArea(1, ReciprocalAreaUnit.InverseSquareYard).ToString(swedishCulture)); + Assert.Equal("1 ft⁻² (US)", new ReciprocalArea(1, ReciprocalAreaUnit.InverseUsSurveySquareFoot).ToString(swedishCulture)); + } + + [Fact] + public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCulture() + { + var oldCulture = CultureInfo.CurrentUICulture; + try + { + CultureInfo.CurrentUICulture = CultureInfo.InvariantCulture; + Assert.Equal("0.1 m⁻²", new ReciprocalArea(0.123456, ReciprocalAreaUnit.InverseSquareMeter).ToString("s1")); + Assert.Equal("0.12 m⁻²", new ReciprocalArea(0.123456, ReciprocalAreaUnit.InverseSquareMeter).ToString("s2")); + Assert.Equal("0.123 m⁻²", new ReciprocalArea(0.123456, ReciprocalAreaUnit.InverseSquareMeter).ToString("s3")); + Assert.Equal("0.1235 m⁻²", new ReciprocalArea(0.123456, ReciprocalAreaUnit.InverseSquareMeter).ToString("s4")); + } + finally + { + CultureInfo.CurrentUICulture = oldCulture; + } + } + + [Fact] + public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture() + { + var culture = CultureInfo.InvariantCulture; + Assert.Equal("0.1 m⁻²", new ReciprocalArea(0.123456, ReciprocalAreaUnit.InverseSquareMeter).ToString("s1", culture)); + Assert.Equal("0.12 m⁻²", new ReciprocalArea(0.123456, ReciprocalAreaUnit.InverseSquareMeter).ToString("s2", culture)); + Assert.Equal("0.123 m⁻²", new ReciprocalArea(0.123456, ReciprocalAreaUnit.InverseSquareMeter).ToString("s3", culture)); + Assert.Equal("0.1235 m⁻²", new ReciprocalArea(0.123456, ReciprocalAreaUnit.InverseSquareMeter).ToString("s4", culture)); + } + + + [Fact] + public void ToString_NullFormat_ThrowsArgumentNullException() + { + var quantity = ReciprocalArea.FromInverseSquareMeters(1.0); + Assert.Throws(() => quantity.ToString(null, null, null)); + } + + [Fact] + public void ToString_NullArgs_ThrowsArgumentNullException() + { + var quantity = ReciprocalArea.FromInverseSquareMeters(1.0); + Assert.Throws(() => quantity.ToString(null, "g", null)); + } + + [Fact] + public void ToString_NullProvider_EqualsCurrentUICulture() + { + var quantity = ReciprocalArea.FromInverseSquareMeters(1.0); + Assert.Equal(quantity.ToString(CultureInfo.CurrentUICulture, "g"), quantity.ToString(null, "g")); + } + + + [Fact] + public void Convert_ToBool_ThrowsInvalidCastException() + { + var quantity = ReciprocalArea.FromInverseSquareMeters(1.0); + Assert.Throws(() => Convert.ToBoolean(quantity)); + } + + [Fact] + public void Convert_ToByte_EqualsValueAsSameType() + { + var quantity = ReciprocalArea.FromInverseSquareMeters(1.0); + Assert.Equal((byte)quantity.Value, Convert.ToByte(quantity)); + } + + [Fact] + public void Convert_ToChar_ThrowsInvalidCastException() + { + var quantity = ReciprocalArea.FromInverseSquareMeters(1.0); + Assert.Throws(() => Convert.ToChar(quantity)); + } + + [Fact] + public void Convert_ToDateTime_ThrowsInvalidCastException() + { + var quantity = ReciprocalArea.FromInverseSquareMeters(1.0); + Assert.Throws(() => Convert.ToDateTime(quantity)); + } + + [Fact] + public void Convert_ToDecimal_EqualsValueAsSameType() + { + var quantity = ReciprocalArea.FromInverseSquareMeters(1.0); + Assert.Equal((decimal)quantity.Value, Convert.ToDecimal(quantity)); + } + + [Fact] + public void Convert_ToDouble_EqualsValueAsSameType() + { + var quantity = ReciprocalArea.FromInverseSquareMeters(1.0); + Assert.Equal((double)quantity.Value, Convert.ToDouble(quantity)); + } + + [Fact] + public void Convert_ToInt16_EqualsValueAsSameType() + { + var quantity = ReciprocalArea.FromInverseSquareMeters(1.0); + Assert.Equal((short)quantity.Value, Convert.ToInt16(quantity)); + } + + [Fact] + public void Convert_ToInt32_EqualsValueAsSameType() + { + var quantity = ReciprocalArea.FromInverseSquareMeters(1.0); + Assert.Equal((int)quantity.Value, Convert.ToInt32(quantity)); + } + + [Fact] + public void Convert_ToInt64_EqualsValueAsSameType() + { + var quantity = ReciprocalArea.FromInverseSquareMeters(1.0); + Assert.Equal((long)quantity.Value, Convert.ToInt64(quantity)); + } + + [Fact] + public void Convert_ToSByte_EqualsValueAsSameType() + { + var quantity = ReciprocalArea.FromInverseSquareMeters(1.0); + Assert.Equal((sbyte)quantity.Value, Convert.ToSByte(quantity)); + } + + [Fact] + public void Convert_ToSingle_EqualsValueAsSameType() + { + var quantity = ReciprocalArea.FromInverseSquareMeters(1.0); + Assert.Equal((float)quantity.Value, Convert.ToSingle(quantity)); + } + + [Fact] + public void Convert_ToString_EqualsToString() + { + var quantity = ReciprocalArea.FromInverseSquareMeters(1.0); + Assert.Equal(quantity.ToString(), Convert.ToString(quantity)); + } + + [Fact] + public void Convert_ToUInt16_EqualsValueAsSameType() + { + var quantity = ReciprocalArea.FromInverseSquareMeters(1.0); + Assert.Equal((ushort)quantity.Value, Convert.ToUInt16(quantity)); + } + + [Fact] + public void Convert_ToUInt32_EqualsValueAsSameType() + { + var quantity = ReciprocalArea.FromInverseSquareMeters(1.0); + Assert.Equal((uint)quantity.Value, Convert.ToUInt32(quantity)); + } + + [Fact] + public void Convert_ToUInt64_EqualsValueAsSameType() + { + var quantity = ReciprocalArea.FromInverseSquareMeters(1.0); + Assert.Equal((ulong)quantity.Value, Convert.ToUInt64(quantity)); + } + + [Fact] + public void Convert_ChangeType_SelfType_EqualsSelf() + { + var quantity = ReciprocalArea.FromInverseSquareMeters(1.0); + Assert.Equal(quantity, Convert.ChangeType(quantity, typeof(ReciprocalArea))); + } + + [Fact] + public void Convert_ChangeType_UnitType_EqualsUnit() + { + var quantity = ReciprocalArea.FromInverseSquareMeters(1.0); + Assert.Equal(quantity.Unit, Convert.ChangeType(quantity, typeof(ReciprocalAreaUnit))); + } + + [Fact] + public void Convert_ChangeType_QuantityType_EqualsQuantityType() + { + var quantity = ReciprocalArea.FromInverseSquareMeters(1.0); + Assert.Equal(QuantityType.ReciprocalArea, Convert.ChangeType(quantity, typeof(QuantityType))); + } + + [Fact] + public void Convert_ChangeType_QuantityInfo_EqualsQuantityInfo() + { + var quantity = ReciprocalArea.FromInverseSquareMeters(1.0); + Assert.Equal(ReciprocalArea.Info, Convert.ChangeType(quantity, typeof(QuantityInfo))); + } + + [Fact] + public void Convert_ChangeType_BaseDimensions_EqualsBaseDimensions() + { + var quantity = ReciprocalArea.FromInverseSquareMeters(1.0); + Assert.Equal(ReciprocalArea.BaseDimensions, Convert.ChangeType(quantity, typeof(BaseDimensions))); + } + + [Fact] + public void Convert_ChangeType_InvalidType_ThrowsInvalidCastException() + { + var quantity = ReciprocalArea.FromInverseSquareMeters(1.0); + Assert.Throws(() => Convert.ChangeType(quantity, typeof(QuantityFormatter))); + } + + [Fact] + public void GetHashCode_Equals() + { + var quantity = ReciprocalArea.FromInverseSquareMeters(1.0); + Assert.Equal(new {ReciprocalArea.Info.Name, quantity.Value, quantity.Unit}.GetHashCode(), quantity.GetHashCode()); + } + + [Theory] + [InlineData(1.0)] + [InlineData(-1.0)] + public void NegationOperator_ReturnsQuantity_WithNegatedValue(double value) + { + var quantity = ReciprocalArea.FromInverseSquareMeters(value); + Assert.Equal(ReciprocalArea.FromInverseSquareMeters(-value), -quantity); + } + } +} diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReciprocalArea.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReciprocalArea.g.cs new file mode 100644 index 0000000000..ff9fa40dce --- /dev/null +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReciprocalArea.g.cs @@ -0,0 +1,753 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by \generate-code.bat. +// +// Changes to this file will be lost when the code is regenerated. +// The build server regenerates the code before each build and a pre-build +// step will regenerate the code on each local build. +// +// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units. +// +// Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities. +// Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities. +// +// +//------------------------------------------------------------------------------ + +// Licensed under MIT No 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 +{ + /// + /// Reciprocal area (Inverse-square) quantity is used to specify a physical quantity inversely proportional to the square of the distance. + /// + /// + /// https://en.wikipedia.org/wiki/Inverse-square_law + /// + // 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 ReciprocalArea : IQuantity + { + /// + /// The numeric value this quantity was constructed with. + /// + private readonly double _value; + + /// + /// The unit this quantity was constructed with. + /// + private readonly ReciprocalAreaUnit? _unit; + + static ReciprocalArea() + { + BaseDimensions = new BaseDimensions(-2, 0, 0, 0, 0, 0, 0); + Info = new QuantityInfo(QuantityType.ReciprocalArea, Units.Cast().ToArray(), BaseUnit, Zero, BaseDimensions); + } + + /// + /// Creates the quantity with a value of 0 in the base unit InverseSquareMeter. + /// + /// + /// Windows Runtime Component requires a default constructor. + /// + public ReciprocalArea() + { + _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 ReciprocalArea(double value, ReciprocalAreaUnit unit) + { + if(unit == ReciprocalAreaUnit.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 ReciprocalArea, which is InverseSquareMeter. All conversions go via this value. + /// + public static ReciprocalAreaUnit BaseUnit { get; } = ReciprocalAreaUnit.InverseSquareMeter; + + /// + /// Represents the largest possible value of ReciprocalArea + /// + public static ReciprocalArea MaxValue { get; } = new ReciprocalArea(double.MaxValue, BaseUnit); + + /// + /// Represents the smallest possible value of ReciprocalArea + /// + public static ReciprocalArea MinValue { get; } = new ReciprocalArea(double.MinValue, BaseUnit); + + /// + /// The of this quantity. + /// + public static QuantityType QuantityType { get; } = QuantityType.ReciprocalArea; + + /// + /// All units of measurement for the ReciprocalArea quantity. + /// + public static ReciprocalAreaUnit[] Units { get; } = Enum.GetValues(typeof(ReciprocalAreaUnit)).Cast().Except(new ReciprocalAreaUnit[]{ ReciprocalAreaUnit.Undefined }).ToArray(); + + /// + /// Gets an instance of this quantity with a value of 0 in the base unit InverseSquareMeter. + /// + public static ReciprocalArea Zero { get; } = new ReciprocalArea(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 ReciprocalAreaUnit Unit => _unit.GetValueOrDefault(BaseUnit); + + internal QuantityInfo QuantityInfo => Info; + + /// + /// The of this quantity. + /// + public QuantityType Type => ReciprocalArea.QuantityType; + + /// + /// The of this quantity. + /// + public BaseDimensions Dimensions => ReciprocalArea.BaseDimensions; + + #endregion + + #region Conversion Properties + + /// + /// Get ReciprocalArea in InverseSquareCentimeters. + /// + public double InverseSquareCentimeters => As(ReciprocalAreaUnit.InverseSquareCentimeter); + + /// + /// Get ReciprocalArea in InverseSquareDecimeters. + /// + public double InverseSquareDecimeters => As(ReciprocalAreaUnit.InverseSquareDecimeter); + + /// + /// Get ReciprocalArea in InverseSquareFeet. + /// + public double InverseSquareFeet => As(ReciprocalAreaUnit.InverseSquareFoot); + + /// + /// Get ReciprocalArea in InverseSquareInches. + /// + public double InverseSquareInches => As(ReciprocalAreaUnit.InverseSquareInch); + + /// + /// Get ReciprocalArea in InverseSquareKilometers. + /// + public double InverseSquareKilometers => As(ReciprocalAreaUnit.InverseSquareKilometer); + + /// + /// Get ReciprocalArea in InverseSquareMeters. + /// + public double InverseSquareMeters => As(ReciprocalAreaUnit.InverseSquareMeter); + + /// + /// Get ReciprocalArea in InverseSquareMicrometers. + /// + public double InverseSquareMicrometers => As(ReciprocalAreaUnit.InverseSquareMicrometer); + + /// + /// Get ReciprocalArea in InverseSquareMiles. + /// + public double InverseSquareMiles => As(ReciprocalAreaUnit.InverseSquareMile); + + /// + /// Get ReciprocalArea in InverseSquareMillimeters. + /// + public double InverseSquareMillimeters => As(ReciprocalAreaUnit.InverseSquareMillimeter); + + /// + /// Get ReciprocalArea in InverseSquareYards. + /// + public double InverseSquareYards => As(ReciprocalAreaUnit.InverseSquareYard); + + /// + /// Get ReciprocalArea in InverseUsSurveySquareFeet. + /// + public double InverseUsSurveySquareFeet => As(ReciprocalAreaUnit.InverseUsSurveySquareFoot); + + #endregion + + #region Static Methods + + /// + /// Get unit abbreviation string. + /// + /// Unit to get abbreviation for. + /// Unit abbreviation string. + public static string GetAbbreviation(ReciprocalAreaUnit 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(ReciprocalAreaUnit unit, [CanBeNull] string cultureName) + { + IFormatProvider provider = GetFormatProviderFromCultureName(cultureName); + return UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit, provider); + } + + #endregion + + #region Static Factory Methods + + /// + /// Get ReciprocalArea from InverseSquareCentimeters. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static ReciprocalArea FromInverseSquareCentimeters(double inversesquarecentimeters) + { + double value = (double) inversesquarecentimeters; + return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareCentimeter); + } + /// + /// Get ReciprocalArea from InverseSquareDecimeters. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static ReciprocalArea FromInverseSquareDecimeters(double inversesquaredecimeters) + { + double value = (double) inversesquaredecimeters; + return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareDecimeter); + } + /// + /// Get ReciprocalArea from InverseSquareFeet. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static ReciprocalArea FromInverseSquareFeet(double inversesquarefeet) + { + double value = (double) inversesquarefeet; + return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareFoot); + } + /// + /// Get ReciprocalArea from InverseSquareInches. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static ReciprocalArea FromInverseSquareInches(double inversesquareinches) + { + double value = (double) inversesquareinches; + return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareInch); + } + /// + /// Get ReciprocalArea from InverseSquareKilometers. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static ReciprocalArea FromInverseSquareKilometers(double inversesquarekilometers) + { + double value = (double) inversesquarekilometers; + return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareKilometer); + } + /// + /// Get ReciprocalArea from InverseSquareMeters. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static ReciprocalArea FromInverseSquareMeters(double inversesquaremeters) + { + double value = (double) inversesquaremeters; + return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMeter); + } + /// + /// Get ReciprocalArea from InverseSquareMicrometers. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static ReciprocalArea FromInverseSquareMicrometers(double inversesquaremicrometers) + { + double value = (double) inversesquaremicrometers; + return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMicrometer); + } + /// + /// Get ReciprocalArea from InverseSquareMiles. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static ReciprocalArea FromInverseSquareMiles(double inversesquaremiles) + { + double value = (double) inversesquaremiles; + return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMile); + } + /// + /// Get ReciprocalArea from InverseSquareMillimeters. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static ReciprocalArea FromInverseSquareMillimeters(double inversesquaremillimeters) + { + double value = (double) inversesquaremillimeters; + return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMillimeter); + } + /// + /// Get ReciprocalArea from InverseSquareYards. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static ReciprocalArea FromInverseSquareYards(double inversesquareyards) + { + double value = (double) inversesquareyards; + return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareYard); + } + /// + /// Get ReciprocalArea from InverseUsSurveySquareFeet. + /// + /// If value is NaN or Infinity. + [Windows.Foundation.Metadata.DefaultOverload] + public static ReciprocalArea FromInverseUsSurveySquareFeet(double inverseussurveysquarefeet) + { + double value = (double) inverseussurveysquarefeet; + return new ReciprocalArea(value, ReciprocalAreaUnit.InverseUsSurveySquareFoot); + } + + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// ReciprocalArea unit value. + // Fix name conflict with parameter "value" + [return: System.Runtime.InteropServices.WindowsRuntime.ReturnValueName("returnValue")] + public static ReciprocalArea From(double value, ReciprocalAreaUnit fromUnit) + { + return new ReciprocalArea((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 ReciprocalArea 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 ReciprocalArea 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 ReciprocalArea 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 ReciprocalArea 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 ReciprocalAreaUnit 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 ReciprocalAreaUnit ParseUnit(string str, [CanBeNull] string cultureName) + { + IFormatProvider provider = GetFormatProviderFromCultureName(cultureName); + return UnitParser.Default.Parse(str, provider); + } + + public static bool TryParseUnit(string str, out ReciprocalAreaUnit 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 ReciprocalAreaUnit 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 ReciprocalArea objReciprocalArea)) throw new ArgumentException("Expected type ReciprocalArea.", nameof(obj)); + + return CompareTo(objReciprocalArea); + } + + // 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(ReciprocalArea other) + { + return _value.CompareTo(other.AsBaseNumericType(this.Unit)); + } + + [Windows.Foundation.Metadata.DefaultOverload] + public override bool Equals(object obj) + { + if(obj is null || !(obj is ReciprocalArea objReciprocalArea)) + return false; + + return Equals(objReciprocalArea); + } + + public bool Equals(ReciprocalArea other) + { + return _value.Equals(other.AsBaseNumericType(this.Unit)); + } + + /// + /// + /// Compare equality to another ReciprocalArea 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(ReciprocalArea 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 ReciprocalArea. + public override int GetHashCode() + { + return new { QuantityType, Value, Unit }.GetHashCode(); + } + + #endregion + + #region Conversion Methods + + double IQuantity.As(object unit) => As((ReciprocalAreaUnit)unit); + + /// + /// Convert to the unit representation . + /// + /// Value converted to the specified unit. + public double As(ReciprocalAreaUnit unit) + { + if(Unit == unit) + return Convert.ToDouble(Value); + + var converted = AsBaseNumericType(unit); + return Convert.ToDouble(converted); + } + + /// + /// Converts this ReciprocalArea to another ReciprocalArea with the unit representation . + /// + /// A ReciprocalArea with the specified unit. + public ReciprocalArea ToUnit(ReciprocalAreaUnit unit) + { + var convertedValue = AsBaseNumericType(unit); + return new ReciprocalArea(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 ReciprocalAreaUnit.InverseSquareCentimeter: return _value/1e-4; + case ReciprocalAreaUnit.InverseSquareDecimeter: return _value/1e-2; + case ReciprocalAreaUnit.InverseSquareFoot: return _value/0.092903; + case ReciprocalAreaUnit.InverseSquareInch: return _value/0.00064516; + case ReciprocalAreaUnit.InverseSquareKilometer: return _value/1e6; + case ReciprocalAreaUnit.InverseSquareMeter: return _value; + case ReciprocalAreaUnit.InverseSquareMicrometer: return _value/1e-12; + case ReciprocalAreaUnit.InverseSquareMile: return _value/2.59e6; + case ReciprocalAreaUnit.InverseSquareMillimeter: return _value/1e-6; + case ReciprocalAreaUnit.InverseSquareYard: return _value/0.836127; + case ReciprocalAreaUnit.InverseUsSurveySquareFoot: return _value/0.09290341161; + default: + throw new NotImplementedException($"Can not convert {Unit} to base units."); + } + } + + private double AsBaseNumericType(ReciprocalAreaUnit unit) + { + if(Unit == unit) + return _value; + + var baseUnitValue = AsBaseUnit(); + + switch(unit) + { + case ReciprocalAreaUnit.InverseSquareCentimeter: return baseUnitValue*1e-4; + case ReciprocalAreaUnit.InverseSquareDecimeter: return baseUnitValue*1e-2; + case ReciprocalAreaUnit.InverseSquareFoot: return baseUnitValue*0.092903; + case ReciprocalAreaUnit.InverseSquareInch: return baseUnitValue*0.00064516; + case ReciprocalAreaUnit.InverseSquareKilometer: return baseUnitValue*1e6; + case ReciprocalAreaUnit.InverseSquareMeter: return baseUnitValue; + case ReciprocalAreaUnit.InverseSquareMicrometer: return baseUnitValue*1e-12; + case ReciprocalAreaUnit.InverseSquareMile: return baseUnitValue*2.59e6; + case ReciprocalAreaUnit.InverseSquareMillimeter: return baseUnitValue*1e-6; + case ReciprocalAreaUnit.InverseSquareYard: return baseUnitValue*0.836127; + case ReciprocalAreaUnit.InverseUsSurveySquareFoot: return baseUnitValue*0.09290341161; + 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 e73842df63..77af9b86c2 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantity.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantity.g.cs @@ -278,6 +278,9 @@ internal static bool TryFrom(double value, Enum unit, out IQuantity quantity) case ReactivePowerUnit reactivePowerUnit: quantity = ReactivePower.From(value, reactivePowerUnit); return true; + case ReciprocalAreaUnit reciprocalAreaUnit: + quantity = ReciprocalArea.From(value, reciprocalAreaUnit); + return true; case ReciprocalLengthUnit reciprocalLengthUnit: quantity = ReciprocalLength.From(value, reciprocalLengthUnit); return true; @@ -655,6 +658,9 @@ internal static bool TryParse([CanBeNull] IFormatProvider formatProvider, Type q if (quantityType == typeof(ReactivePower)) return parser.TryParse(quantityString, formatProvider, ReactivePower.From, out quantity); + if (quantityType == typeof(ReciprocalArea)) + return parser.TryParse(quantityString, formatProvider, ReciprocalArea.From, out quantity); + if (quantityType == typeof(ReciprocalLength)) return parser.TryParse(quantityString, formatProvider, ReciprocalLength.From, out quantity); diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/QuantityType.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/QuantityType.g.cs index a728042709..1ec94a2e45 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/QuantityType.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/QuantityType.g.cs @@ -108,6 +108,7 @@ public enum QuantityType RatioChangeRate, ReactiveEnergy, ReactivePower, + ReciprocalArea, ReciprocalLength, RelativeHumidity, RotationalAcceleration, diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs index 40c01eb3ad..23577c6621 100644 --- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs @@ -1200,6 +1200,17 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(ReactivePowerUnit), (int)ReactivePowerUnit.KilovoltampereReactive, new string[]{"kvar"}), ("en-US", typeof(ReactivePowerUnit), (int)ReactivePowerUnit.MegavoltampereReactive, new string[]{"Mvar"}), ("en-US", typeof(ReactivePowerUnit), (int)ReactivePowerUnit.VoltampereReactive, new string[]{"var"}), + ("en-US", typeof(ReciprocalAreaUnit), (int)ReciprocalAreaUnit.InverseSquareCentimeter, new string[]{"cm⁻²"}), + ("en-US", typeof(ReciprocalAreaUnit), (int)ReciprocalAreaUnit.InverseSquareDecimeter, new string[]{"dm⁻²"}), + ("en-US", typeof(ReciprocalAreaUnit), (int)ReciprocalAreaUnit.InverseSquareFoot, new string[]{"ft⁻²"}), + ("en-US", typeof(ReciprocalAreaUnit), (int)ReciprocalAreaUnit.InverseSquareInch, new string[]{"in⁻²"}), + ("en-US", typeof(ReciprocalAreaUnit), (int)ReciprocalAreaUnit.InverseSquareKilometer, new string[]{"km⁻²"}), + ("en-US", typeof(ReciprocalAreaUnit), (int)ReciprocalAreaUnit.InverseSquareMeter, new string[]{"m⁻²"}), + ("en-US", typeof(ReciprocalAreaUnit), (int)ReciprocalAreaUnit.InverseSquareMicrometer, new string[]{"µm⁻²"}), + ("en-US", typeof(ReciprocalAreaUnit), (int)ReciprocalAreaUnit.InverseSquareMile, new string[]{"mi⁻²"}), + ("en-US", typeof(ReciprocalAreaUnit), (int)ReciprocalAreaUnit.InverseSquareMillimeter, new string[]{"mm⁻²"}), + ("en-US", typeof(ReciprocalAreaUnit), (int)ReciprocalAreaUnit.InverseSquareYard, new string[]{"yd⁻²"}), + ("en-US", typeof(ReciprocalAreaUnit), (int)ReciprocalAreaUnit.InverseUsSurveySquareFoot, new string[]{"ft⁻² (US)"}), ("en-US", typeof(ReciprocalLengthUnit), (int)ReciprocalLengthUnit.InverseCentimeter, new string[]{"cm⁻¹", "1/cm"}), ("en-US", typeof(ReciprocalLengthUnit), (int)ReciprocalLengthUnit.InverseFoot, new string[]{"ft⁻¹", "1/ft"}), ("en-US", typeof(ReciprocalLengthUnit), (int)ReciprocalLengthUnit.InverseInch, new string[]{"in⁻¹", "1/in"}), diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/ReciprocalAreaUnit.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/ReciprocalAreaUnit.g.cs new file mode 100644 index 0000000000..822c6e03eb --- /dev/null +++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/ReciprocalAreaUnit.g.cs @@ -0,0 +1,43 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by \generate-code.bat. +// +// Changes to this file will be lost when the code is regenerated. +// The build server regenerates the code before each build and a pre-build +// step will regenerate the code on each local build. +// +// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units. +// +// Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities. +// Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities. +// +// +//------------------------------------------------------------------------------ + +// Licensed under MIT 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 ReciprocalAreaUnit + { + Undefined = 0, + InverseSquareCentimeter, + InverseSquareDecimeter, + InverseSquareFoot, + InverseSquareInch, + InverseSquareKilometer, + InverseSquareMeter, + InverseSquareMicrometer, + InverseSquareMile, + InverseSquareMillimeter, + InverseSquareYard, + InverseUsSurveySquareFoot, + } + + #pragma warning restore 1591 +} diff --git a/UnitsNet/CustomCode/Quantities/Area.extra.cs b/UnitsNet/CustomCode/Quantities/Area.extra.cs index 5a89d29521..8df2a275d3 100644 --- a/UnitsNet/CustomCode/Quantities/Area.extra.cs +++ b/UnitsNet/CustomCode/Quantities/Area.extra.cs @@ -24,6 +24,18 @@ public static Area FromCircleRadius(Length radius) #endregion + /// + /// Calculates the inverse of this quantity. + /// + /// The corresponding inverse quantity, . + public ReciprocalArea Inverse() + { + if (SquareMeters == 0.0) + return new ReciprocalArea(0.0, UnitsNet.Units.ReciprocalAreaUnit.InverseSquareMeter); + + return new ReciprocalArea(1 / SquareMeters, UnitsNet.Units.ReciprocalAreaUnit.InverseSquareMeter); + } + /// Get from divided by . public static Length operator /(Area area, Length length) { @@ -47,5 +59,11 @@ public static Area FromCircleRadius(Length radius) { return LinearDensity.FromKilogramsPerMeter(area.SquareMeters * density.KilogramsPerCubicMeter); } + + /// Get from times . + public static Ratio operator *(Area area, ReciprocalArea reciprocalArea) + { + return Ratio.FromDecimalFractions(area.SquareMeters * reciprocalArea.InverseSquareMeters); + } } } diff --git a/UnitsNet/CustomCode/Quantities/Force.extra.cs b/UnitsNet/CustomCode/Quantities/Force.extra.cs index 4019b245df..67d738d97b 100644 --- a/UnitsNet/CustomCode/Quantities/Force.extra.cs +++ b/UnitsNet/CustomCode/Quantities/Force.extra.cs @@ -38,6 +38,12 @@ public static Force FromMassByAcceleration(Mass mass, Acceleration acceleration) return ForcePerLength.FromNewtonsPerMeter(force.Newtons * reciprocalLength.InverseMeters); } + /// Get from times . + public static Pressure operator *(Force force, ReciprocalArea reciprocalArea) + { + return Pressure.FromNewtonsPerSquareMeter(force.Newtons * reciprocalArea.InverseSquareMeters); + } + /// Get from divided by . public static Acceleration operator /(Force force, Mass mass) { diff --git a/UnitsNet/CustomCode/Quantities/Pressure.extra.cs b/UnitsNet/CustomCode/Quantities/Pressure.extra.cs index 75ccdcb3f1..9328b9541f 100644 --- a/UnitsNet/CustomCode/Quantities/Pressure.extra.cs +++ b/UnitsNet/CustomCode/Quantities/Pressure.extra.cs @@ -34,5 +34,11 @@ public partial struct Pressure { return new ForcePerLength(pressure.Pascals / reciprocalLength.InverseMeters, UnitsNet.Units.ForcePerLengthUnit.NewtonPerMeter); } + + /// Get from divided by . + public static Force operator /(Pressure pressure, ReciprocalArea reciprocalArea) + { + return new Force(pressure.Pascals / reciprocalArea.InverseSquareMeters, UnitsNet.Units.ForceUnit.Newton); + } } } diff --git a/UnitsNet/CustomCode/Quantities/ReciprocalArea.extra.cs b/UnitsNet/CustomCode/Quantities/ReciprocalArea.extra.cs new file mode 100644 index 0000000000..067fd556f0 --- /dev/null +++ b/UnitsNet/CustomCode/Quantities/ReciprocalArea.extra.cs @@ -0,0 +1,40 @@ +// Licensed under MIT No 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.Units; + +namespace UnitsNet +{ + public partial struct ReciprocalArea + { + /// + /// Calculates the inverse of this quantity. + /// + /// The corresponding inverse quantity, . + public Area Inverse() + { + if (InverseSquareMeters == 0.0) + return new Area(0.0, AreaUnit.SquareMeter); + + return new Area(1 / InverseSquareMeters, AreaUnit.SquareMeter); + } + + /// Get from multiplied by . + public static Pressure operator *(ReciprocalArea reciprocalArea, Force force) + { + return Pressure.FromNewtonsPerSquareMeter(reciprocalArea.InverseSquareMeters * force.Newtons); + } + + /// Get from multiplied by . + public static Ratio operator *(ReciprocalArea reciprocalArea, Area area) + { + return new Ratio(reciprocalArea.InverseSquareMeters * area.SquareMeters, RatioUnit.DecimalFraction); + } + + /// Get from divided by . + public static ReciprocalLength operator /(ReciprocalArea reciprocalArea, ReciprocalLength reciprocalLength) + { + return ReciprocalLength.FromInverseMeters(reciprocalArea.InverseSquareMeters / reciprocalLength.InverseMeters); + } + } +} diff --git a/UnitsNet/CustomCode/Quantities/ReciprocalLength.extra.cs b/UnitsNet/CustomCode/Quantities/ReciprocalLength.extra.cs index ce72f9b423..caf649773c 100644 --- a/UnitsNet/CustomCode/Quantities/ReciprocalLength.extra.cs +++ b/UnitsNet/CustomCode/Quantities/ReciprocalLength.extra.cs @@ -30,5 +30,17 @@ public Length Inverse() { return ForcePerLength.FromNewtonsPerMeter(reciprocalLength.InverseMeters * force.Newtons); } + + /// Get from times . + public static ReciprocalArea operator *(ReciprocalLength reciprocalLength, ReciprocalLength other) + { + return ReciprocalArea.FromInverseSquareMeters(reciprocalLength.InverseMeters * other.InverseMeters); + } + + /// Get from times . + public static Length operator /(ReciprocalLength reciprocalLength, ReciprocalArea reciprocalArea) + { + return Length.FromMeters(reciprocalLength.InverseMeters / reciprocalArea.InverseSquareMeters); + } } } diff --git a/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs b/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs new file mode 100644 index 0000000000..82e64503f2 --- /dev/null +++ b/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs @@ -0,0 +1,1030 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by \generate-code.bat. +// +// Changes to this file will be lost when the code is regenerated. +// The build server regenerates the code before each build and a pre-build +// step will regenerate the code on each local build. +// +// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units. +// +// Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities. +// Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities. +// +// +//------------------------------------------------------------------------------ + +// Licensed under MIT No 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; + +#nullable enable + +// ReSharper disable once CheckNamespace + +namespace UnitsNet +{ + /// + /// + /// Reciprocal area (Inverse-square) quantity is used to specify a physical quantity inversely proportional to the square of the distance. + /// + /// + /// https://en.wikipedia.org/wiki/Inverse-square_law + /// + public partial struct ReciprocalArea : 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 ReciprocalAreaUnit? _unit; + + static ReciprocalArea() + { + BaseDimensions = new BaseDimensions(-2, 0, 0, 0, 0, 0, 0); + + Info = new QuantityInfo("ReciprocalArea", + new UnitInfo[] { + new UnitInfo(ReciprocalAreaUnit.InverseSquareCentimeter, BaseUnits.Undefined), + new UnitInfo(ReciprocalAreaUnit.InverseSquareDecimeter, BaseUnits.Undefined), + new UnitInfo(ReciprocalAreaUnit.InverseSquareFoot, BaseUnits.Undefined), + new UnitInfo(ReciprocalAreaUnit.InverseSquareInch, BaseUnits.Undefined), + new UnitInfo(ReciprocalAreaUnit.InverseSquareKilometer, BaseUnits.Undefined), + new UnitInfo(ReciprocalAreaUnit.InverseSquareMeter, BaseUnits.Undefined), + new UnitInfo(ReciprocalAreaUnit.InverseSquareMicrometer, BaseUnits.Undefined), + new UnitInfo(ReciprocalAreaUnit.InverseSquareMile, BaseUnits.Undefined), + new UnitInfo(ReciprocalAreaUnit.InverseSquareMillimeter, BaseUnits.Undefined), + new UnitInfo(ReciprocalAreaUnit.InverseSquareYard, BaseUnits.Undefined), + new UnitInfo(ReciprocalAreaUnit.InverseUsSurveySquareFoot, BaseUnits.Undefined), + }, + BaseUnit, Zero, BaseDimensions, QuantityType.ReciprocalArea); + } + + /// + /// 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 ReciprocalArea(double value, ReciprocalAreaUnit unit) + { + if(unit == ReciprocalAreaUnit.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 ReciprocalArea(double value, UnitSystem unitSystem) + { + if(unitSystem is null) throw new ArgumentNullException(nameof(unitSystem)); + + var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits); + var firstUnitInfo = unitInfos.FirstOrDefault(); + + _value = Guard.EnsureValidNumber(value, nameof(value)); + _unit = firstUnitInfo?.Value ?? throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem)); + } + + #region Static Properties + + /// + public static QuantityInfo Info { get; } + + /// + /// The of this quantity. + /// + public static BaseDimensions BaseDimensions { get; } + + /// + /// The base unit of ReciprocalArea, which is InverseSquareMeter. All conversions go via this value. + /// + public static ReciprocalAreaUnit BaseUnit { get; } = ReciprocalAreaUnit.InverseSquareMeter; + + /// + /// Represents the largest possible value of ReciprocalArea + /// + [Obsolete("MaxValue and MinValue will be removed. Choose your own value or use nullability for unbounded lower/upper range checks. See discussion in https://github.com/angularsen/UnitsNet/issues/848.")] + public static ReciprocalArea MaxValue { get; } = new ReciprocalArea(double.MaxValue, BaseUnit); + + /// + /// Represents the smallest possible value of ReciprocalArea + /// + [Obsolete("MaxValue and MinValue will be removed. Choose your own value or use nullability for unbounded lower/upper range checks. See discussion in https://github.com/angularsen/UnitsNet/issues/848.")] + public static ReciprocalArea MinValue { get; } = new ReciprocalArea(double.MinValue, BaseUnit); + + /// + /// The of this quantity. + /// + [Obsolete("QuantityType will be removed in the future. Use Info property instead.")] + public static QuantityType QuantityType { get; } = QuantityType.ReciprocalArea; + + /// + /// All units of measurement for the ReciprocalArea quantity. + /// + public static ReciprocalAreaUnit[] Units { get; } = Enum.GetValues(typeof(ReciprocalAreaUnit)).Cast().Except(new ReciprocalAreaUnit[]{ ReciprocalAreaUnit.Undefined }).ToArray(); + + /// + /// Gets an instance of this quantity with a value of 0 in the base unit InverseSquareMeter. + /// + public static ReciprocalArea Zero { get; } = new ReciprocalArea(0, BaseUnit); + + #endregion + + #region Properties + + /// + /// The numeric value this quantity was constructed with. + /// + public double Value => _value; + + Enum IQuantity.Unit => Unit; + + /// + public ReciprocalAreaUnit Unit => _unit.GetValueOrDefault(BaseUnit); + + /// + public QuantityInfo QuantityInfo => Info; + + /// + QuantityInfo IQuantity.QuantityInfo => Info; + + /// + /// The of this quantity. + /// + public QuantityType Type => ReciprocalArea.QuantityType; + + /// + /// The of this quantity. + /// + public BaseDimensions Dimensions => ReciprocalArea.BaseDimensions; + + #endregion + + #region Conversion Properties + + /// + /// Get ReciprocalArea in InverseSquareCentimeters. + /// + public double InverseSquareCentimeters => As(ReciprocalAreaUnit.InverseSquareCentimeter); + + /// + /// Get ReciprocalArea in InverseSquareDecimeters. + /// + public double InverseSquareDecimeters => As(ReciprocalAreaUnit.InverseSquareDecimeter); + + /// + /// Get ReciprocalArea in InverseSquareFeet. + /// + public double InverseSquareFeet => As(ReciprocalAreaUnit.InverseSquareFoot); + + /// + /// Get ReciprocalArea in InverseSquareInches. + /// + public double InverseSquareInches => As(ReciprocalAreaUnit.InverseSquareInch); + + /// + /// Get ReciprocalArea in InverseSquareKilometers. + /// + public double InverseSquareKilometers => As(ReciprocalAreaUnit.InverseSquareKilometer); + + /// + /// Get ReciprocalArea in InverseSquareMeters. + /// + public double InverseSquareMeters => As(ReciprocalAreaUnit.InverseSquareMeter); + + /// + /// Get ReciprocalArea in InverseSquareMicrometers. + /// + public double InverseSquareMicrometers => As(ReciprocalAreaUnit.InverseSquareMicrometer); + + /// + /// Get ReciprocalArea in InverseSquareMiles. + /// + public double InverseSquareMiles => As(ReciprocalAreaUnit.InverseSquareMile); + + /// + /// Get ReciprocalArea in InverseSquareMillimeters. + /// + public double InverseSquareMillimeters => As(ReciprocalAreaUnit.InverseSquareMillimeter); + + /// + /// Get ReciprocalArea in InverseSquareYards. + /// + public double InverseSquareYards => As(ReciprocalAreaUnit.InverseSquareYard); + + /// + /// Get ReciprocalArea in InverseUsSurveySquareFeet. + /// + public double InverseUsSurveySquareFeet => As(ReciprocalAreaUnit.InverseUsSurveySquareFoot); + + #endregion + + #region Static Methods + + /// + /// Get unit abbreviation string. + /// + /// Unit to get abbreviation for. + /// Unit abbreviation string. + public static string GetAbbreviation(ReciprocalAreaUnit 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(ReciprocalAreaUnit unit, IFormatProvider? provider) + { + return UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit, provider); + } + + #endregion + + #region Static Factory Methods + + /// + /// Get ReciprocalArea from InverseSquareCentimeters. + /// + /// If value is NaN or Infinity. + public static ReciprocalArea FromInverseSquareCentimeters(QuantityValue inversesquarecentimeters) + { + double value = (double) inversesquarecentimeters; + return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareCentimeter); + } + /// + /// Get ReciprocalArea from InverseSquareDecimeters. + /// + /// If value is NaN or Infinity. + public static ReciprocalArea FromInverseSquareDecimeters(QuantityValue inversesquaredecimeters) + { + double value = (double) inversesquaredecimeters; + return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareDecimeter); + } + /// + /// Get ReciprocalArea from InverseSquareFeet. + /// + /// If value is NaN or Infinity. + public static ReciprocalArea FromInverseSquareFeet(QuantityValue inversesquarefeet) + { + double value = (double) inversesquarefeet; + return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareFoot); + } + /// + /// Get ReciprocalArea from InverseSquareInches. + /// + /// If value is NaN or Infinity. + public static ReciprocalArea FromInverseSquareInches(QuantityValue inversesquareinches) + { + double value = (double) inversesquareinches; + return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareInch); + } + /// + /// Get ReciprocalArea from InverseSquareKilometers. + /// + /// If value is NaN or Infinity. + public static ReciprocalArea FromInverseSquareKilometers(QuantityValue inversesquarekilometers) + { + double value = (double) inversesquarekilometers; + return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareKilometer); + } + /// + /// Get ReciprocalArea from InverseSquareMeters. + /// + /// If value is NaN or Infinity. + public static ReciprocalArea FromInverseSquareMeters(QuantityValue inversesquaremeters) + { + double value = (double) inversesquaremeters; + return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMeter); + } + /// + /// Get ReciprocalArea from InverseSquareMicrometers. + /// + /// If value is NaN or Infinity. + public static ReciprocalArea FromInverseSquareMicrometers(QuantityValue inversesquaremicrometers) + { + double value = (double) inversesquaremicrometers; + return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMicrometer); + } + /// + /// Get ReciprocalArea from InverseSquareMiles. + /// + /// If value is NaN or Infinity. + public static ReciprocalArea FromInverseSquareMiles(QuantityValue inversesquaremiles) + { + double value = (double) inversesquaremiles; + return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMile); + } + /// + /// Get ReciprocalArea from InverseSquareMillimeters. + /// + /// If value is NaN or Infinity. + public static ReciprocalArea FromInverseSquareMillimeters(QuantityValue inversesquaremillimeters) + { + double value = (double) inversesquaremillimeters; + return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMillimeter); + } + /// + /// Get ReciprocalArea from InverseSquareYards. + /// + /// If value is NaN or Infinity. + public static ReciprocalArea FromInverseSquareYards(QuantityValue inversesquareyards) + { + double value = (double) inversesquareyards; + return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareYard); + } + /// + /// Get ReciprocalArea from InverseUsSurveySquareFeet. + /// + /// If value is NaN or Infinity. + public static ReciprocalArea FromInverseUsSurveySquareFeet(QuantityValue inverseussurveysquarefeet) + { + double value = (double) inverseussurveysquarefeet; + return new ReciprocalArea(value, ReciprocalAreaUnit.InverseUsSurveySquareFoot); + } + + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// ReciprocalArea unit value. + public static ReciprocalArea From(QuantityValue value, ReciprocalAreaUnit fromUnit) + { + return new ReciprocalArea((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 ReciprocalArea 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 ReciprocalArea Parse(string str, IFormatProvider? provider) + { + return QuantityParser.Default.Parse( + str, + provider, + From); + } + + /// + /// Try to parse a string with one or two quantities of the format "<quantity> <unit>". + /// + /// String to parse. Typically in the form: {number} {unit} + /// Resulting unit quantity if successful. + /// + /// Length.Parse("5.5 m", new CultureInfo("en-US")); + /// + public static bool TryParse(string? str, out ReciprocalArea result) + { + return TryParse(str, null, out result); + } + + /// + /// Try to parse a string with one or two quantities of the format "<quantity> <unit>". + /// + /// String to parse. Typically in the form: {number} {unit} + /// Resulting unit quantity if successful. + /// True if successful, otherwise false. + /// + /// Length.Parse("5.5 m", new CultureInfo("en-US")); + /// + /// Format to use when parsing number and unit. Defaults to if null. + public static bool TryParse(string? str, IFormatProvider? provider, out ReciprocalArea 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 ReciprocalAreaUnit 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 ReciprocalAreaUnit ParseUnit(string str, IFormatProvider? provider) + { + return UnitParser.Default.Parse(str, provider); + } + + /// + public static bool TryParseUnit(string str, out ReciprocalAreaUnit 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 ReciprocalAreaUnit unit) + { + return UnitParser.Default.TryParse(str, provider, out unit); + } + + #endregion + + #region Arithmetic Operators + + /// Negate the value. + public static ReciprocalArea operator -(ReciprocalArea right) + { + return new ReciprocalArea(-right.Value, right.Unit); + } + + /// Get from adding two . + public static ReciprocalArea operator +(ReciprocalArea left, ReciprocalArea right) + { + return new ReciprocalArea(left.Value + right.GetValueAs(left.Unit), left.Unit); + } + + /// Get from subtracting two . + public static ReciprocalArea operator -(ReciprocalArea left, ReciprocalArea right) + { + return new ReciprocalArea(left.Value - right.GetValueAs(left.Unit), left.Unit); + } + + /// Get from multiplying value and . + public static ReciprocalArea operator *(double left, ReciprocalArea right) + { + return new ReciprocalArea(left * right.Value, right.Unit); + } + + /// Get from multiplying value and . + public static ReciprocalArea operator *(ReciprocalArea left, double right) + { + return new ReciprocalArea(left.Value * right, left.Unit); + } + + /// Get from dividing by value. + public static ReciprocalArea operator /(ReciprocalArea left, double right) + { + return new ReciprocalArea(left.Value / right, left.Unit); + } + + /// Get ratio value from dividing by . + public static double operator /(ReciprocalArea left, ReciprocalArea right) + { + return left.InverseSquareMeters / right.InverseSquareMeters; + } + + #endregion + + #region Equality / IComparable + + /// Returns true if less or equal to. + public static bool operator <=(ReciprocalArea left, ReciprocalArea right) + { + return left.Value <= right.GetValueAs(left.Unit); + } + + /// Returns true if greater than or equal to. + public static bool operator >=(ReciprocalArea left, ReciprocalArea right) + { + return left.Value >= right.GetValueAs(left.Unit); + } + + /// Returns true if less than. + public static bool operator <(ReciprocalArea left, ReciprocalArea right) + { + return left.Value < right.GetValueAs(left.Unit); + } + + /// Returns true if greater than. + public static bool operator >(ReciprocalArea left, ReciprocalArea 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 ==(ReciprocalArea left, ReciprocalArea right) + { + return left.Equals(right); + } + + /// Returns true if not exactly equal. + /// Consider using for safely comparing floating point values. + public static bool operator !=(ReciprocalArea left, ReciprocalArea right) + { + return !(left == right); + } + + /// + public int CompareTo(object obj) + { + if(obj is null) throw new ArgumentNullException(nameof(obj)); + if(!(obj is ReciprocalArea objReciprocalArea)) throw new ArgumentException("Expected type ReciprocalArea.", nameof(obj)); + + return CompareTo(objReciprocalArea); + } + + /// + public int CompareTo(ReciprocalArea 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 ReciprocalArea objReciprocalArea)) + return false; + + return Equals(objReciprocalArea); + } + + /// + /// Consider using for safely comparing floating point values. + public bool Equals(ReciprocalArea other) + { + return _value.Equals(other.GetValueAs(this.Unit)); + } + + /// + /// + /// Compare equality to another ReciprocalArea 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(ReciprocalArea 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 ReciprocalArea. + public override int GetHashCode() + { + return new { Info.Name, Value, Unit }.GetHashCode(); + } + + #endregion + + #region Conversion Methods + + /// + /// Convert to the unit representation . + /// + /// Value converted to the specified unit. + public double As(ReciprocalAreaUnit unit) + { + if(Unit == unit) + return Convert.ToDouble(Value); + + var converted = GetValueAs(unit); + return Convert.ToDouble(converted); + } + + /// + public double As(UnitSystem unitSystem) + { + if(unitSystem is null) + throw new ArgumentNullException(nameof(unitSystem)); + + var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits); + + var firstUnitInfo = unitInfos.FirstOrDefault(); + if(firstUnitInfo == null) + throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem)); + + return As(firstUnitInfo.Value); + } + + /// + double IQuantity.As(Enum unit) + { + if(!(unit is ReciprocalAreaUnit unitAsReciprocalAreaUnit)) + throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ReciprocalAreaUnit)} is supported.", nameof(unit)); + + return As(unitAsReciprocalAreaUnit); + } + + /// + /// Converts this ReciprocalArea to another ReciprocalArea with the unit representation . + /// + /// A ReciprocalArea with the specified unit. + public ReciprocalArea ToUnit(ReciprocalAreaUnit unit) + { + var convertedValue = GetValueAs(unit); + return new ReciprocalArea(convertedValue, unit); + } + + /// + IQuantity IQuantity.ToUnit(Enum unit) + { + if(!(unit is ReciprocalAreaUnit unitAsReciprocalAreaUnit)) + throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ReciprocalAreaUnit)} is supported.", nameof(unit)); + + return ToUnit(unitAsReciprocalAreaUnit); + } + + /// + public ReciprocalArea ToUnit(UnitSystem unitSystem) + { + if(unitSystem is null) + throw new ArgumentNullException(nameof(unitSystem)); + + var unitInfos = Info.GetUnitInfosFor(unitSystem.BaseUnits); + + var firstUnitInfo = unitInfos.FirstOrDefault(); + if(firstUnitInfo == null) + throw new ArgumentException("No units were found for the given UnitSystem.", nameof(unitSystem)); + + return ToUnit(firstUnitInfo.Value); + } + + /// + IQuantity IQuantity.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem); + + /// + IQuantity IQuantity.ToUnit(ReciprocalAreaUnit 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 ReciprocalAreaUnit.InverseSquareCentimeter: return _value/1e-4; + case ReciprocalAreaUnit.InverseSquareDecimeter: return _value/1e-2; + case ReciprocalAreaUnit.InverseSquareFoot: return _value/0.092903; + case ReciprocalAreaUnit.InverseSquareInch: return _value/0.00064516; + case ReciprocalAreaUnit.InverseSquareKilometer: return _value/1e6; + case ReciprocalAreaUnit.InverseSquareMeter: return _value; + case ReciprocalAreaUnit.InverseSquareMicrometer: return _value/1e-12; + case ReciprocalAreaUnit.InverseSquareMile: return _value/2.59e6; + case ReciprocalAreaUnit.InverseSquareMillimeter: return _value/1e-6; + case ReciprocalAreaUnit.InverseSquareYard: return _value/0.836127; + case ReciprocalAreaUnit.InverseUsSurveySquareFoot: return _value/0.09290341161; + 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 ReciprocalArea ToBaseUnit() + { + var baseUnitValue = GetValueInBaseUnit(); + return new ReciprocalArea(baseUnitValue, BaseUnit); + } + + private double GetValueAs(ReciprocalAreaUnit unit) + { + if(Unit == unit) + return _value; + + var baseUnitValue = GetValueInBaseUnit(); + + switch(unit) + { + case ReciprocalAreaUnit.InverseSquareCentimeter: return baseUnitValue*1e-4; + case ReciprocalAreaUnit.InverseSquareDecimeter: return baseUnitValue*1e-2; + case ReciprocalAreaUnit.InverseSquareFoot: return baseUnitValue*0.092903; + case ReciprocalAreaUnit.InverseSquareInch: return baseUnitValue*0.00064516; + case ReciprocalAreaUnit.InverseSquareKilometer: return baseUnitValue*1e6; + case ReciprocalAreaUnit.InverseSquareMeter: return baseUnitValue; + case ReciprocalAreaUnit.InverseSquareMicrometer: return baseUnitValue*1e-12; + case ReciprocalAreaUnit.InverseSquareMile: return baseUnitValue*2.59e6; + case ReciprocalAreaUnit.InverseSquareMillimeter: return baseUnitValue*1e-6; + case ReciprocalAreaUnit.InverseSquareYard: return baseUnitValue*0.836127; + case ReciprocalAreaUnit.InverseUsSurveySquareFoot: return baseUnitValue*0.09290341161; + 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(IFormatProvider? provider) + { + return ToString("g", provider); + } + + /// + /// Get string representation of value and unit. + /// + /// The number of significant digits after the radix point. + /// String representation. + /// Format to use for localization and number formatting. Defaults to if null. + [Obsolete(@"This method is deprecated and will be removed at a future release. Please use ToString(""s2"") or ToString(""s2"", provider) where 2 is an example of the number passed to significantDigitsAfterRadix.")] + public string ToString(IFormatProvider? provider, int significantDigitsAfterRadix) + { + var value = Convert.ToDouble(Value); + var format = UnitFormatter.GetFormat(value, significantDigitsAfterRadix); + return ToString(provider, format); + } + + /// + /// Get string representation of value and unit. + /// + /// String format to use. Default: "{0:0.##} {1} for value and unit abbreviation respectively." + /// Arguments for string format. Value and unit are implicitly included as arguments 0 and 1. + /// String representation. + /// Format to use for localization and number formatting. Defaults to if null. + [Obsolete("This method is deprecated and will be removed at a future release. Please use string.Format().")] + public string ToString(IFormatProvider? provider, [NotNull] string format, [NotNull] params object[] args) + { + if (format == null) throw new ArgumentNullException(nameof(format)); + if (args == null) throw new ArgumentNullException(nameof(args)); + + provider = provider ?? CultureInfo.CurrentUICulture; + + var value = Convert.ToDouble(Value); + var formatArgs = UnitFormatter.GetFormatArgs(Unit, value, provider, args); + return string.Format(provider, format, formatArgs); + } + + /// + /// + /// Gets the string representation of this instance in the specified format string using . + /// + /// The format string. + /// The string representation. + public string ToString(string format) + { + return ToString(format, CultureInfo.CurrentUICulture); + } + + /// + /// + /// Gets the string representation of this instance in the specified format string using the specified format provider, or if null. + /// + /// The format string. + /// Format to use for localization and number formatting. Defaults to if null. + /// The string representation. + public string ToString(string format, IFormatProvider? provider) + { + return QuantityFormatter.Format(this, format, provider); + } + + #endregion + + #region IConvertible Methods + + TypeCode IConvertible.GetTypeCode() + { + return TypeCode.Object; + } + + bool IConvertible.ToBoolean(IFormatProvider provider) + { + throw new InvalidCastException($"Converting {typeof(ReciprocalArea)} to bool is not supported."); + } + + byte IConvertible.ToByte(IFormatProvider provider) + { + return Convert.ToByte(_value); + } + + char IConvertible.ToChar(IFormatProvider provider) + { + throw new InvalidCastException($"Converting {typeof(ReciprocalArea)} to char is not supported."); + } + + DateTime IConvertible.ToDateTime(IFormatProvider provider) + { + throw new InvalidCastException($"Converting {typeof(ReciprocalArea)} 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(ReciprocalArea)) + return this; + else if(conversionType == typeof(ReciprocalAreaUnit)) + return Unit; + else if(conversionType == typeof(QuantityType)) + return ReciprocalArea.QuantityType; + else if(conversionType == typeof(QuantityInfo)) + return ReciprocalArea.Info; + else if(conversionType == typeof(BaseDimensions)) + return ReciprocalArea.BaseDimensions; + else + throw new InvalidCastException($"Converting {typeof(ReciprocalArea)} 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 17e8e4aa1a..44f07e2aa5 100644 --- a/UnitsNet/GeneratedCode/Quantity.g.cs +++ b/UnitsNet/GeneratedCode/Quantity.g.cs @@ -117,6 +117,7 @@ public static partial class Quantity { "RatioChangeRate", RatioChangeRate.Info }, { "ReactiveEnergy", ReactiveEnergy.Info }, { "ReactivePower", ReactivePower.Info }, + { "ReciprocalArea", ReciprocalArea.Info }, { "ReciprocalLength", ReciprocalLength.Info }, { "RelativeHumidity", RelativeHumidity.Info }, { "RotationalAcceleration", RotationalAcceleration.Info }, @@ -232,6 +233,7 @@ public static partial class Quantity { "RatioChangeRate", QuantityType.RatioChangeRate }, { "ReactiveEnergy", QuantityType.ReactiveEnergy }, { "ReactivePower", QuantityType.ReactivePower }, + { "ReciprocalArea", QuantityType.ReciprocalArea }, { "ReciprocalLength", QuantityType.ReciprocalLength }, { "RelativeHumidity", QuantityType.RelativeHumidity }, { "RotationalAcceleration", QuantityType.RotationalAcceleration }, @@ -433,6 +435,8 @@ public static IQuantity FromQuantityType(QuantityType quantityType, QuantityValu return ReactiveEnergy.From(value, ReactiveEnergy.BaseUnit); case QuantityType.ReactivePower: return ReactivePower.From(value, ReactivePower.BaseUnit); + case QuantityType.ReciprocalArea: + return ReciprocalArea.From(value, ReciprocalArea.BaseUnit); case QuantityType.ReciprocalLength: return ReciprocalLength.From(value, ReciprocalLength.BaseUnit); case QuantityType.RelativeHumidity: @@ -666,6 +670,8 @@ public static IQuantity FromQuantityInfo(QuantityInfo quantityInfo, QuantityValu return ReactiveEnergy.From(value, ReactiveEnergy.BaseUnit); case "ReactivePower": return ReactivePower.From(value, ReactivePower.BaseUnit); + case "ReciprocalArea": + return ReciprocalArea.From(value, ReciprocalArea.BaseUnit); case "ReciprocalLength": return ReciprocalLength.From(value, ReciprocalLength.BaseUnit); case "RelativeHumidity": @@ -979,6 +985,9 @@ public static bool TryFrom(QuantityValue value, Enum unit, out IQuantity? quanti case ReactivePowerUnit reactivePowerUnit: quantity = ReactivePower.From(value, reactivePowerUnit); return true; + case ReciprocalAreaUnit reciprocalAreaUnit: + quantity = ReciprocalArea.From(value, reciprocalAreaUnit); + return true; case ReciprocalLengthUnit reciprocalLengthUnit: quantity = ReciprocalLength.From(value, reciprocalLengthUnit); return true; @@ -1254,6 +1263,8 @@ public static bool TryParse(IFormatProvider? formatProvider, Type quantityType, return parser.TryParse(quantityString, formatProvider, ReactiveEnergy.From, out quantity); case Type _ when quantityType == typeof(ReactivePower): return parser.TryParse(quantityString, formatProvider, ReactivePower.From, out quantity); + case Type _ when quantityType == typeof(ReciprocalArea): + return parser.TryParse(quantityString, formatProvider, ReciprocalArea.From, out quantity); case Type _ when quantityType == typeof(ReciprocalLength): return parser.TryParse(quantityString, formatProvider, ReciprocalLength.From, out quantity); case Type _ when quantityType == typeof(RelativeHumidity): diff --git a/UnitsNet/GeneratedCode/QuantityType.g.cs b/UnitsNet/GeneratedCode/QuantityType.g.cs index 4e4aa97330..f9f36fdc40 100644 --- a/UnitsNet/GeneratedCode/QuantityType.g.cs +++ b/UnitsNet/GeneratedCode/QuantityType.g.cs @@ -110,6 +110,7 @@ public enum QuantityType RatioChangeRate, ReactiveEnergy, ReactivePower, + ReciprocalArea, ReciprocalLength, RelativeHumidity, RotationalAcceleration, diff --git a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs index d9cdf4b74a..3ae246425f 100644 --- a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs +++ b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs @@ -1200,6 +1200,17 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin ("en-US", typeof(ReactivePowerUnit), (int)ReactivePowerUnit.KilovoltampereReactive, new string[]{"kvar"}), ("en-US", typeof(ReactivePowerUnit), (int)ReactivePowerUnit.MegavoltampereReactive, new string[]{"Mvar"}), ("en-US", typeof(ReactivePowerUnit), (int)ReactivePowerUnit.VoltampereReactive, new string[]{"var"}), + ("en-US", typeof(ReciprocalAreaUnit), (int)ReciprocalAreaUnit.InverseSquareCentimeter, new string[]{"cm⁻²"}), + ("en-US", typeof(ReciprocalAreaUnit), (int)ReciprocalAreaUnit.InverseSquareDecimeter, new string[]{"dm⁻²"}), + ("en-US", typeof(ReciprocalAreaUnit), (int)ReciprocalAreaUnit.InverseSquareFoot, new string[]{"ft⁻²"}), + ("en-US", typeof(ReciprocalAreaUnit), (int)ReciprocalAreaUnit.InverseSquareInch, new string[]{"in⁻²"}), + ("en-US", typeof(ReciprocalAreaUnit), (int)ReciprocalAreaUnit.InverseSquareKilometer, new string[]{"km⁻²"}), + ("en-US", typeof(ReciprocalAreaUnit), (int)ReciprocalAreaUnit.InverseSquareMeter, new string[]{"m⁻²"}), + ("en-US", typeof(ReciprocalAreaUnit), (int)ReciprocalAreaUnit.InverseSquareMicrometer, new string[]{"µm⁻²"}), + ("en-US", typeof(ReciprocalAreaUnit), (int)ReciprocalAreaUnit.InverseSquareMile, new string[]{"mi⁻²"}), + ("en-US", typeof(ReciprocalAreaUnit), (int)ReciprocalAreaUnit.InverseSquareMillimeter, new string[]{"mm⁻²"}), + ("en-US", typeof(ReciprocalAreaUnit), (int)ReciprocalAreaUnit.InverseSquareYard, new string[]{"yd⁻²"}), + ("en-US", typeof(ReciprocalAreaUnit), (int)ReciprocalAreaUnit.InverseUsSurveySquareFoot, new string[]{"ft⁻² (US)"}), ("en-US", typeof(ReciprocalLengthUnit), (int)ReciprocalLengthUnit.InverseCentimeter, new string[]{"cm⁻¹", "1/cm"}), ("en-US", typeof(ReciprocalLengthUnit), (int)ReciprocalLengthUnit.InverseFoot, new string[]{"ft⁻¹", "1/ft"}), ("en-US", typeof(ReciprocalLengthUnit), (int)ReciprocalLengthUnit.InverseInch, new string[]{"in⁻¹", "1/in"}), diff --git a/UnitsNet/GeneratedCode/UnitConverter.g.cs b/UnitsNet/GeneratedCode/UnitConverter.g.cs index 0bf3728146..c87a5614b5 100644 --- a/UnitsNet/GeneratedCode/UnitConverter.g.cs +++ b/UnitsNet/GeneratedCode/UnitConverter.g.cs @@ -1787,6 +1787,27 @@ public static void RegisterDefaultConversions(UnitConverter unitConverter) unitConverter.SetConversionFunction(ReactivePower.BaseUnit, ReactivePowerUnit.MegavoltampereReactive, q => q.ToUnit(ReactivePowerUnit.MegavoltampereReactive)); unitConverter.SetConversionFunction(ReactivePowerUnit.MegavoltampereReactive, ReactivePower.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(ReactivePower.BaseUnit, ReactivePower.BaseUnit, q => q); + unitConverter.SetConversionFunction(ReciprocalArea.BaseUnit, ReciprocalAreaUnit.InverseSquareCentimeter, q => q.ToUnit(ReciprocalAreaUnit.InverseSquareCentimeter)); + unitConverter.SetConversionFunction(ReciprocalAreaUnit.InverseSquareCentimeter, ReciprocalArea.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ReciprocalArea.BaseUnit, ReciprocalAreaUnit.InverseSquareDecimeter, q => q.ToUnit(ReciprocalAreaUnit.InverseSquareDecimeter)); + unitConverter.SetConversionFunction(ReciprocalAreaUnit.InverseSquareDecimeter, ReciprocalArea.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ReciprocalArea.BaseUnit, ReciprocalAreaUnit.InverseSquareFoot, q => q.ToUnit(ReciprocalAreaUnit.InverseSquareFoot)); + unitConverter.SetConversionFunction(ReciprocalAreaUnit.InverseSquareFoot, ReciprocalArea.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ReciprocalArea.BaseUnit, ReciprocalAreaUnit.InverseSquareInch, q => q.ToUnit(ReciprocalAreaUnit.InverseSquareInch)); + unitConverter.SetConversionFunction(ReciprocalAreaUnit.InverseSquareInch, ReciprocalArea.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ReciprocalArea.BaseUnit, ReciprocalAreaUnit.InverseSquareKilometer, q => q.ToUnit(ReciprocalAreaUnit.InverseSquareKilometer)); + unitConverter.SetConversionFunction(ReciprocalAreaUnit.InverseSquareKilometer, ReciprocalArea.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ReciprocalArea.BaseUnit, ReciprocalArea.BaseUnit, q => q); + unitConverter.SetConversionFunction(ReciprocalArea.BaseUnit, ReciprocalAreaUnit.InverseSquareMicrometer, q => q.ToUnit(ReciprocalAreaUnit.InverseSquareMicrometer)); + unitConverter.SetConversionFunction(ReciprocalAreaUnit.InverseSquareMicrometer, ReciprocalArea.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ReciprocalArea.BaseUnit, ReciprocalAreaUnit.InverseSquareMile, q => q.ToUnit(ReciprocalAreaUnit.InverseSquareMile)); + unitConverter.SetConversionFunction(ReciprocalAreaUnit.InverseSquareMile, ReciprocalArea.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ReciprocalArea.BaseUnit, ReciprocalAreaUnit.InverseSquareMillimeter, q => q.ToUnit(ReciprocalAreaUnit.InverseSquareMillimeter)); + unitConverter.SetConversionFunction(ReciprocalAreaUnit.InverseSquareMillimeter, ReciprocalArea.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ReciprocalArea.BaseUnit, ReciprocalAreaUnit.InverseSquareYard, q => q.ToUnit(ReciprocalAreaUnit.InverseSquareYard)); + unitConverter.SetConversionFunction(ReciprocalAreaUnit.InverseSquareYard, ReciprocalArea.BaseUnit, q => q.ToBaseUnit()); + unitConverter.SetConversionFunction(ReciprocalArea.BaseUnit, ReciprocalAreaUnit.InverseUsSurveySquareFoot, q => q.ToUnit(ReciprocalAreaUnit.InverseUsSurveySquareFoot)); + unitConverter.SetConversionFunction(ReciprocalAreaUnit.InverseUsSurveySquareFoot, ReciprocalArea.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(ReciprocalLength.BaseUnit, ReciprocalLengthUnit.InverseCentimeter, q => q.ToUnit(ReciprocalLengthUnit.InverseCentimeter)); unitConverter.SetConversionFunction(ReciprocalLengthUnit.InverseCentimeter, ReciprocalLength.BaseUnit, q => q.ToBaseUnit()); unitConverter.SetConversionFunction(ReciprocalLength.BaseUnit, ReciprocalLengthUnit.InverseFoot, q => q.ToUnit(ReciprocalLengthUnit.InverseFoot)); diff --git a/UnitsNet/GeneratedCode/Units/ReciprocalAreaUnit.g.cs b/UnitsNet/GeneratedCode/Units/ReciprocalAreaUnit.g.cs new file mode 100644 index 0000000000..822c6e03eb --- /dev/null +++ b/UnitsNet/GeneratedCode/Units/ReciprocalAreaUnit.g.cs @@ -0,0 +1,43 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by \generate-code.bat. +// +// Changes to this file will be lost when the code is regenerated. +// The build server regenerates the code before each build and a pre-build +// step will regenerate the code on each local build. +// +// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units. +// +// Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities. +// Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities. +// +// +//------------------------------------------------------------------------------ + +// Licensed under MIT 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 ReciprocalAreaUnit + { + Undefined = 0, + InverseSquareCentimeter, + InverseSquareDecimeter, + InverseSquareFoot, + InverseSquareInch, + InverseSquareKilometer, + InverseSquareMeter, + InverseSquareMicrometer, + InverseSquareMile, + InverseSquareMillimeter, + InverseSquareYard, + InverseUsSurveySquareFoot, + } + + #pragma warning restore 1591 +}