From 496168191780cd8bdce449ed668a004f40ce6581 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ferit=20Tun=C3=A7er?= Date: Fri, 27 Oct 2017 18:10:08 +0300 Subject: [PATCH 1/8] added MolarMass --- UnitsNet/UnitDefinitions/MolarMass.json | 43 +++++++++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 UnitsNet/UnitDefinitions/MolarMass.json diff --git a/UnitsNet/UnitDefinitions/MolarMass.json b/UnitsNet/UnitDefinitions/MolarMass.json new file mode 100644 index 0000000000..fc73fd6b6a --- /dev/null +++ b/UnitsNet/UnitDefinitions/MolarMass.json @@ -0,0 +1,43 @@ +{ + "Name": "MolarMass", + "BaseUnit": "KilogramPerMole", + "XmlDoc": "In chemistry, the molar mass M is a physical property defined as the mass of a given substance (chemical element or chemical compound) divided by the amount of substance.", + "Units": [ + { + "SingularName": "GramPerMole", + "PluralName": "GramsPerMoles", + "FromUnitToBaseFunc": "x/1e3", + "FromBaseToUnitFunc": "x*1e3", + "Prefixes": [ "Nano", "Micro", "Milli", "Centi", "Deci", "Deca", "Hecto", "Kilo" ], + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "g/mol" ] + }, + { + "Culture": "ru-RU", + "Abbreviations": [ "г" ], + "AbbreviationsWithPrefixes": [ "нг", "мкг", "мг", "сг", "дг", "даг", "гг", "кг" ] // TODO Russian abbreviations + } + ] + }, + { + "SingularName": "PoundPerMole", + "PluralName": "PoundsPerMoles", + "FromUnitToBaseFunc": "x*0.45359237", + "FromBaseToUnitFunc": "x/0.45359237", + "Prefixes": [ "Kilo", "Mega" ], + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "lb/mol" ], + "AbbreviationsWithPrefixes": [ "KLbs/mol", "MLbs/mol" ] + }, + { + "Culture": "ru-RU", + "Abbreviations": [ "фунт" ] // TODO Russian abbreviations + } + ] + } + ] +} \ No newline at end of file From 6002b73a4cfaf36fa71594fb921963cdb0175ac8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ferit=20Tun=C3=A7er?= Date: Fri, 27 Oct 2017 18:17:02 +0300 Subject: [PATCH 2/8] added russian abbreviations --- UnitsNet/UnitDefinitions/MolarMass.json | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/UnitsNet/UnitDefinitions/MolarMass.json b/UnitsNet/UnitDefinitions/MolarMass.json index fc73fd6b6a..b71f298f7d 100644 --- a/UnitsNet/UnitDefinitions/MolarMass.json +++ b/UnitsNet/UnitDefinitions/MolarMass.json @@ -16,8 +16,8 @@ }, { "Culture": "ru-RU", - "Abbreviations": [ "г" ], - "AbbreviationsWithPrefixes": [ "нг", "мкг", "мг", "сг", "дг", "даг", "гг", "кг" ] // TODO Russian abbreviations + "Abbreviations": [ "г/моль" ], + "AbbreviationsWithPrefixes": [ "нг/моль", "мкг/моль", "мг/моль", "сг/моль", "дг/моль", "даг/моль", "гг/моль", "кг/моль" ] } ] }, @@ -35,7 +35,7 @@ }, { "Culture": "ru-RU", - "Abbreviations": [ "фунт" ] // TODO Russian abbreviations + "Abbreviations": [ "фунт/моль" ] } ] } From 51a412dd62135930a3ed98309de7992bc76852e3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ferit=20Tun=C3=A7er?= Date: Fri, 27 Oct 2017 18:18:34 +0300 Subject: [PATCH 3/8] generated units --- UnitsNet.Tests/CustomCode/MolarMassTests.cs | 51 + .../GeneratedCode/MolarMassTestsBase.g.cs | 245 +++ .../Number/NumberToMolarMassExtensions.g.cs | 457 ++++ .../GeneratedCode/Quantities/MolarMass.g.cs | 1952 +++++++++++++++++ UnitsNet/GeneratedCode/QuantityType.g.cs | 1 + .../GeneratedCode/UnitSystem.Default.g.cs | 76 + .../GeneratedCode/Units/MolarMassUnit.g.cs | 58 + 7 files changed, 2840 insertions(+) create mode 100644 UnitsNet.Tests/CustomCode/MolarMassTests.cs create mode 100644 UnitsNet.Tests/GeneratedCode/MolarMassTestsBase.g.cs create mode 100644 UnitsNet/GeneratedCode/Extensions/Number/NumberToMolarMassExtensions.g.cs create mode 100644 UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs create mode 100644 UnitsNet/GeneratedCode/Units/MolarMassUnit.g.cs diff --git a/UnitsNet.Tests/CustomCode/MolarMassTests.cs b/UnitsNet.Tests/CustomCode/MolarMassTests.cs new file mode 100644 index 0000000000..804c43b391 --- /dev/null +++ b/UnitsNet.Tests/CustomCode/MolarMassTests.cs @@ -0,0 +1,51 @@ +//------------------------------------------------------------------------------ +// +// This code was generated (once) by \generate-code.bat, but will not be +// regenerated when it already exists. The purpose of creating this file is to make +// it easier to remember to implement all the unit conversion test cases. +// +// Whenever a new unit is added to this quantity and \generate-code.bat is run, +// the base test class will get a new abstract property and cause a compile error +// in this derived class, reminding the developer to implement the test case +// for the new unit. +// +// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units. +// +// Add CustomCode\Quantities\MyUnit.extra.cs files to add code to generated quantities. +// Add Extensions\MyUnitExtensions.cs to decorate quantities with new behavior. +// Add UnitDefinitions\MyUnit.json and run GeneratUnits.bat to generate new units or quantities. +// +// +//------------------------------------------------------------------------------ + +// Copyright (c) 2007 Andreas Gullberg Larsen (angularsen@gmail.com). +// https://github.com/angularsen/UnitsNet +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + + +using System; + +namespace UnitsNet.Tests.CustomCode +{ + public class MolarMassTests : MolarMassTestsBase + { + // TODO Override properties in base class here + } +} diff --git a/UnitsNet.Tests/GeneratedCode/MolarMassTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MolarMassTestsBase.g.cs new file mode 100644 index 0000000000..c03de84a87 --- /dev/null +++ b/UnitsNet.Tests/GeneratedCode/MolarMassTestsBase.g.cs @@ -0,0 +1,245 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by \generate-code.bat. +// +// Changes to this file will be lost when the code is regenerated. +// The build server regenerates the code before each build and a pre-build +// step will regenerate the code on each local build. +// +// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units. +// +// Add CustomCode\Quantities\MyUnit.extra.cs files to add code to generated quantities. +// Add Extensions\MyUnitExtensions.cs to decorate quantities with new behavior. +// Add UnitDefinitions\MyUnit.json and run GeneratUnits.bat to generate new units or quantities. +// +// +//------------------------------------------------------------------------------ + +// Copyright (c) 2007 Andreas Gullberg Larsen (angularsen@gmail.com). +// https://github.com/angularsen/UnitsNet +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +using System; +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 MolarMass. + /// +// ReSharper disable once PartialTypeWithSinglePart + public abstract partial class MolarMassTestsBase + { + protected abstract double CentigramsPerMolesInOneKilogramPerMole { get; } + protected abstract double DecagramsPerMolesInOneKilogramPerMole { get; } + protected abstract double DecigramsPerMolesInOneKilogramPerMole { get; } + protected abstract double GramsPerMolesInOneKilogramPerMole { get; } + protected abstract double HectogramsPerMolesInOneKilogramPerMole { get; } + protected abstract double KilogramsPerMolesInOneKilogramPerMole { get; } + protected abstract double KilopoundsPerMolesInOneKilogramPerMole { get; } + protected abstract double MegapoundsPerMolesInOneKilogramPerMole { get; } + protected abstract double MicrogramsPerMolesInOneKilogramPerMole { get; } + protected abstract double MilligramsPerMolesInOneKilogramPerMole { get; } + protected abstract double NanogramsPerMolesInOneKilogramPerMole { get; } + protected abstract double PoundsPerMolesInOneKilogramPerMole { get; } + +// ReSharper disable VirtualMemberNeverOverriden.Global + protected virtual double CentigramsPerMolesTolerance { get { return 1e-5; } } + protected virtual double DecagramsPerMolesTolerance { get { return 1e-5; } } + protected virtual double DecigramsPerMolesTolerance { get { return 1e-5; } } + protected virtual double GramsPerMolesTolerance { get { return 1e-5; } } + protected virtual double HectogramsPerMolesTolerance { get { return 1e-5; } } + protected virtual double KilogramsPerMolesTolerance { get { return 1e-5; } } + protected virtual double KilopoundsPerMolesTolerance { get { return 1e-5; } } + protected virtual double MegapoundsPerMolesTolerance { get { return 1e-5; } } + protected virtual double MicrogramsPerMolesTolerance { get { return 1e-5; } } + protected virtual double MilligramsPerMolesTolerance { get { return 1e-5; } } + protected virtual double NanogramsPerMolesTolerance { get { return 1e-5; } } + protected virtual double PoundsPerMolesTolerance { get { return 1e-5; } } +// ReSharper restore VirtualMemberNeverOverriden.Global + + [Fact] + public void KilogramPerMoleToMolarMassUnits() + { + MolarMass kilogrampermole = MolarMass.FromKilogramsPerMoles(1); + AssertEx.EqualTolerance(CentigramsPerMolesInOneKilogramPerMole, kilogrampermole.CentigramsPerMoles, CentigramsPerMolesTolerance); + AssertEx.EqualTolerance(DecagramsPerMolesInOneKilogramPerMole, kilogrampermole.DecagramsPerMoles, DecagramsPerMolesTolerance); + AssertEx.EqualTolerance(DecigramsPerMolesInOneKilogramPerMole, kilogrampermole.DecigramsPerMoles, DecigramsPerMolesTolerance); + AssertEx.EqualTolerance(GramsPerMolesInOneKilogramPerMole, kilogrampermole.GramsPerMoles, GramsPerMolesTolerance); + AssertEx.EqualTolerance(HectogramsPerMolesInOneKilogramPerMole, kilogrampermole.HectogramsPerMoles, HectogramsPerMolesTolerance); + AssertEx.EqualTolerance(KilogramsPerMolesInOneKilogramPerMole, kilogrampermole.KilogramsPerMoles, KilogramsPerMolesTolerance); + AssertEx.EqualTolerance(KilopoundsPerMolesInOneKilogramPerMole, kilogrampermole.KilopoundsPerMoles, KilopoundsPerMolesTolerance); + AssertEx.EqualTolerance(MegapoundsPerMolesInOneKilogramPerMole, kilogrampermole.MegapoundsPerMoles, MegapoundsPerMolesTolerance); + AssertEx.EqualTolerance(MicrogramsPerMolesInOneKilogramPerMole, kilogrampermole.MicrogramsPerMoles, MicrogramsPerMolesTolerance); + AssertEx.EqualTolerance(MilligramsPerMolesInOneKilogramPerMole, kilogrampermole.MilligramsPerMoles, MilligramsPerMolesTolerance); + AssertEx.EqualTolerance(NanogramsPerMolesInOneKilogramPerMole, kilogrampermole.NanogramsPerMoles, NanogramsPerMolesTolerance); + AssertEx.EqualTolerance(PoundsPerMolesInOneKilogramPerMole, kilogrampermole.PoundsPerMoles, PoundsPerMolesTolerance); + } + + [Fact] + public void FromValueAndUnit() + { + AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.CentigramPerMole).CentigramsPerMoles, CentigramsPerMolesTolerance); + AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.DecagramPerMole).DecagramsPerMoles, DecagramsPerMolesTolerance); + AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.DecigramPerMole).DecigramsPerMoles, DecigramsPerMolesTolerance); + AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.GramPerMole).GramsPerMoles, GramsPerMolesTolerance); + AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.HectogramPerMole).HectogramsPerMoles, HectogramsPerMolesTolerance); + AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.KilogramPerMole).KilogramsPerMoles, KilogramsPerMolesTolerance); + AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.KilopoundPerMole).KilopoundsPerMoles, KilopoundsPerMolesTolerance); + AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.MegapoundPerMole).MegapoundsPerMoles, MegapoundsPerMolesTolerance); + AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.MicrogramPerMole).MicrogramsPerMoles, MicrogramsPerMolesTolerance); + AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.MilligramPerMole).MilligramsPerMoles, MilligramsPerMolesTolerance); + AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.NanogramPerMole).NanogramsPerMoles, NanogramsPerMolesTolerance); + AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.PoundPerMole).PoundsPerMoles, PoundsPerMolesTolerance); + } + + [Fact] + public void As() + { + var kilogrampermole = MolarMass.FromKilogramsPerMoles(1); + AssertEx.EqualTolerance(CentigramsPerMolesInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.CentigramPerMole), CentigramsPerMolesTolerance); + AssertEx.EqualTolerance(DecagramsPerMolesInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.DecagramPerMole), DecagramsPerMolesTolerance); + AssertEx.EqualTolerance(DecigramsPerMolesInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.DecigramPerMole), DecigramsPerMolesTolerance); + AssertEx.EqualTolerance(GramsPerMolesInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.GramPerMole), GramsPerMolesTolerance); + AssertEx.EqualTolerance(HectogramsPerMolesInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.HectogramPerMole), HectogramsPerMolesTolerance); + AssertEx.EqualTolerance(KilogramsPerMolesInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.KilogramPerMole), KilogramsPerMolesTolerance); + AssertEx.EqualTolerance(KilopoundsPerMolesInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.KilopoundPerMole), KilopoundsPerMolesTolerance); + AssertEx.EqualTolerance(MegapoundsPerMolesInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.MegapoundPerMole), MegapoundsPerMolesTolerance); + AssertEx.EqualTolerance(MicrogramsPerMolesInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.MicrogramPerMole), MicrogramsPerMolesTolerance); + AssertEx.EqualTolerance(MilligramsPerMolesInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.MilligramPerMole), MilligramsPerMolesTolerance); + AssertEx.EqualTolerance(NanogramsPerMolesInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.NanogramPerMole), NanogramsPerMolesTolerance); + AssertEx.EqualTolerance(PoundsPerMolesInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.PoundPerMole), PoundsPerMolesTolerance); + } + + [Fact] + public void ConversionRoundTrip() + { + MolarMass kilogrampermole = MolarMass.FromKilogramsPerMoles(1); + AssertEx.EqualTolerance(1, MolarMass.FromCentigramsPerMoles(kilogrampermole.CentigramsPerMoles).KilogramsPerMoles, CentigramsPerMolesTolerance); + AssertEx.EqualTolerance(1, MolarMass.FromDecagramsPerMoles(kilogrampermole.DecagramsPerMoles).KilogramsPerMoles, DecagramsPerMolesTolerance); + AssertEx.EqualTolerance(1, MolarMass.FromDecigramsPerMoles(kilogrampermole.DecigramsPerMoles).KilogramsPerMoles, DecigramsPerMolesTolerance); + AssertEx.EqualTolerance(1, MolarMass.FromGramsPerMoles(kilogrampermole.GramsPerMoles).KilogramsPerMoles, GramsPerMolesTolerance); + AssertEx.EqualTolerance(1, MolarMass.FromHectogramsPerMoles(kilogrampermole.HectogramsPerMoles).KilogramsPerMoles, HectogramsPerMolesTolerance); + AssertEx.EqualTolerance(1, MolarMass.FromKilogramsPerMoles(kilogrampermole.KilogramsPerMoles).KilogramsPerMoles, KilogramsPerMolesTolerance); + AssertEx.EqualTolerance(1, MolarMass.FromKilopoundsPerMoles(kilogrampermole.KilopoundsPerMoles).KilogramsPerMoles, KilopoundsPerMolesTolerance); + AssertEx.EqualTolerance(1, MolarMass.FromMegapoundsPerMoles(kilogrampermole.MegapoundsPerMoles).KilogramsPerMoles, MegapoundsPerMolesTolerance); + AssertEx.EqualTolerance(1, MolarMass.FromMicrogramsPerMoles(kilogrampermole.MicrogramsPerMoles).KilogramsPerMoles, MicrogramsPerMolesTolerance); + AssertEx.EqualTolerance(1, MolarMass.FromMilligramsPerMoles(kilogrampermole.MilligramsPerMoles).KilogramsPerMoles, MilligramsPerMolesTolerance); + AssertEx.EqualTolerance(1, MolarMass.FromNanogramsPerMoles(kilogrampermole.NanogramsPerMoles).KilogramsPerMoles, NanogramsPerMolesTolerance); + AssertEx.EqualTolerance(1, MolarMass.FromPoundsPerMoles(kilogrampermole.PoundsPerMoles).KilogramsPerMoles, PoundsPerMolesTolerance); + } + + [Fact] + public void ArithmeticOperators() + { + MolarMass v = MolarMass.FromKilogramsPerMoles(1); + AssertEx.EqualTolerance(-1, -v.KilogramsPerMoles, KilogramsPerMolesTolerance); + AssertEx.EqualTolerance(2, (MolarMass.FromKilogramsPerMoles(3)-v).KilogramsPerMoles, KilogramsPerMolesTolerance); + AssertEx.EqualTolerance(2, (v + v).KilogramsPerMoles, KilogramsPerMolesTolerance); + AssertEx.EqualTolerance(10, (v*10).KilogramsPerMoles, KilogramsPerMolesTolerance); + AssertEx.EqualTolerance(10, (10*v).KilogramsPerMoles, KilogramsPerMolesTolerance); + AssertEx.EqualTolerance(2, (MolarMass.FromKilogramsPerMoles(10)/5).KilogramsPerMoles, KilogramsPerMolesTolerance); + AssertEx.EqualTolerance(2, MolarMass.FromKilogramsPerMoles(10)/MolarMass.FromKilogramsPerMoles(5), KilogramsPerMolesTolerance); + } + + [Fact] + public void ComparisonOperators() + { + MolarMass oneKilogramPerMole = MolarMass.FromKilogramsPerMoles(1); + MolarMass twoKilogramsPerMoles = MolarMass.FromKilogramsPerMoles(2); + + Assert.True(oneKilogramPerMole < twoKilogramsPerMoles); + Assert.True(oneKilogramPerMole <= twoKilogramsPerMoles); + Assert.True(twoKilogramsPerMoles > oneKilogramPerMole); + Assert.True(twoKilogramsPerMoles >= oneKilogramPerMole); + + Assert.False(oneKilogramPerMole > twoKilogramsPerMoles); + Assert.False(oneKilogramPerMole >= twoKilogramsPerMoles); + Assert.False(twoKilogramsPerMoles < oneKilogramPerMole); + Assert.False(twoKilogramsPerMoles <= oneKilogramPerMole); + } + + [Fact] + public void CompareToIsImplemented() + { + MolarMass kilogrampermole = MolarMass.FromKilogramsPerMoles(1); + Assert.Equal(0, kilogrampermole.CompareTo(kilogrampermole)); + Assert.True(kilogrampermole.CompareTo(MolarMass.Zero) > 0); + Assert.True(MolarMass.Zero.CompareTo(kilogrampermole) < 0); + } + + [Fact] + public void CompareToThrowsOnTypeMismatch() + { + MolarMass kilogrampermole = MolarMass.FromKilogramsPerMoles(1); + Assert.Throws(() => kilogrampermole.CompareTo(new object())); + } + + [Fact] + public void CompareToThrowsOnNull() + { + MolarMass kilogrampermole = MolarMass.FromKilogramsPerMoles(1); + Assert.Throws(() => kilogrampermole.CompareTo(null)); + } + + + [Fact] + public void EqualityOperators() + { + MolarMass a = MolarMass.FromKilogramsPerMoles(1); + MolarMass b = MolarMass.FromKilogramsPerMoles(2); + +// ReSharper disable EqualExpressionComparison + Assert.True(a == a); + Assert.True(a != b); + + Assert.False(a == b); + Assert.False(a != a); +// ReSharper restore EqualExpressionComparison + } + + [Fact] + public void EqualsIsImplemented() + { + MolarMass v = MolarMass.FromKilogramsPerMoles(1); + Assert.True(v.Equals(MolarMass.FromKilogramsPerMoles(1))); + Assert.False(v.Equals(MolarMass.Zero)); + } + + [Fact] + public void EqualsReturnsFalseOnTypeMismatch() + { + MolarMass kilogrampermole = MolarMass.FromKilogramsPerMoles(1); + Assert.False(kilogrampermole.Equals(new object())); + } + + [Fact] + public void EqualsReturnsFalseOnNull() + { + MolarMass kilogrampermole = MolarMass.FromKilogramsPerMoles(1); + Assert.False(kilogrampermole.Equals(null)); + } + } +} diff --git a/UnitsNet/GeneratedCode/Extensions/Number/NumberToMolarMassExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/Number/NumberToMolarMassExtensions.g.cs new file mode 100644 index 0000000000..bbe4326f0e --- /dev/null +++ b/UnitsNet/GeneratedCode/Extensions/Number/NumberToMolarMassExtensions.g.cs @@ -0,0 +1,457 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by \generate-code.bat. +// +// Changes to this file will be lost when the code is regenerated. +// The build server regenerates the code before each build and a pre-build +// step will regenerate the code on each local build. +// +// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units. +// +// Add CustomCode\Quantities\MyUnit.extra.cs files to add code to generated quantities. +// Add Extensions\MyUnitExtensions.cs to decorate quantities with new behavior. +// Add UnitDefinitions\MyUnit.json and run GeneratUnits.bat to generate new units or quantities. +// +// +//------------------------------------------------------------------------------ + +// Copyright (c) 2007 Andreas Gullberg Larsen (angularsen@gmail.com). +// https://github.com/angularsen/UnitsNet +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +using System; + +// Windows Runtime Component does not support extension methods and method overloads: https://msdn.microsoft.com/en-us/library/br230301.aspx +#if !WINDOWS_UWP +namespace UnitsNet.Extensions.NumberToMolarMass +{ + public static class NumberToMolarMassExtensions + { + #region CentigramPerMole + + /// + public static MolarMass CentigramsPerMoles(this int value) => MolarMass.FromCentigramsPerMoles(value); + + /// + public static MolarMass? CentigramsPerMoles(this int? value) => MolarMass.FromCentigramsPerMoles(value); + + /// + public static MolarMass CentigramsPerMoles(this long value) => MolarMass.FromCentigramsPerMoles(value); + + /// + public static MolarMass? CentigramsPerMoles(this long? value) => MolarMass.FromCentigramsPerMoles(value); + + /// + public static MolarMass CentigramsPerMoles(this double value) => MolarMass.FromCentigramsPerMoles(value); + + /// + public static MolarMass? CentigramsPerMoles(this double? value) => MolarMass.FromCentigramsPerMoles(value); + + /// + public static MolarMass CentigramsPerMoles(this float value) => MolarMass.FromCentigramsPerMoles(value); + + /// + public static MolarMass? CentigramsPerMoles(this float? value) => MolarMass.FromCentigramsPerMoles(value); + + /// + public static MolarMass CentigramsPerMoles(this decimal value) => MolarMass.FromCentigramsPerMoles(Convert.ToDouble(value)); + + /// + public static MolarMass? CentigramsPerMoles(this decimal? value) => MolarMass.FromCentigramsPerMoles(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + + #region DecagramPerMole + + /// + public static MolarMass DecagramsPerMoles(this int value) => MolarMass.FromDecagramsPerMoles(value); + + /// + public static MolarMass? DecagramsPerMoles(this int? value) => MolarMass.FromDecagramsPerMoles(value); + + /// + public static MolarMass DecagramsPerMoles(this long value) => MolarMass.FromDecagramsPerMoles(value); + + /// + public static MolarMass? DecagramsPerMoles(this long? value) => MolarMass.FromDecagramsPerMoles(value); + + /// + public static MolarMass DecagramsPerMoles(this double value) => MolarMass.FromDecagramsPerMoles(value); + + /// + public static MolarMass? DecagramsPerMoles(this double? value) => MolarMass.FromDecagramsPerMoles(value); + + /// + public static MolarMass DecagramsPerMoles(this float value) => MolarMass.FromDecagramsPerMoles(value); + + /// + public static MolarMass? DecagramsPerMoles(this float? value) => MolarMass.FromDecagramsPerMoles(value); + + /// + public static MolarMass DecagramsPerMoles(this decimal value) => MolarMass.FromDecagramsPerMoles(Convert.ToDouble(value)); + + /// + public static MolarMass? DecagramsPerMoles(this decimal? value) => MolarMass.FromDecagramsPerMoles(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + + #region DecigramPerMole + + /// + public static MolarMass DecigramsPerMoles(this int value) => MolarMass.FromDecigramsPerMoles(value); + + /// + public static MolarMass? DecigramsPerMoles(this int? value) => MolarMass.FromDecigramsPerMoles(value); + + /// + public static MolarMass DecigramsPerMoles(this long value) => MolarMass.FromDecigramsPerMoles(value); + + /// + public static MolarMass? DecigramsPerMoles(this long? value) => MolarMass.FromDecigramsPerMoles(value); + + /// + public static MolarMass DecigramsPerMoles(this double value) => MolarMass.FromDecigramsPerMoles(value); + + /// + public static MolarMass? DecigramsPerMoles(this double? value) => MolarMass.FromDecigramsPerMoles(value); + + /// + public static MolarMass DecigramsPerMoles(this float value) => MolarMass.FromDecigramsPerMoles(value); + + /// + public static MolarMass? DecigramsPerMoles(this float? value) => MolarMass.FromDecigramsPerMoles(value); + + /// + public static MolarMass DecigramsPerMoles(this decimal value) => MolarMass.FromDecigramsPerMoles(Convert.ToDouble(value)); + + /// + public static MolarMass? DecigramsPerMoles(this decimal? value) => MolarMass.FromDecigramsPerMoles(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + + #region GramPerMole + + /// + public static MolarMass GramsPerMoles(this int value) => MolarMass.FromGramsPerMoles(value); + + /// + public static MolarMass? GramsPerMoles(this int? value) => MolarMass.FromGramsPerMoles(value); + + /// + public static MolarMass GramsPerMoles(this long value) => MolarMass.FromGramsPerMoles(value); + + /// + public static MolarMass? GramsPerMoles(this long? value) => MolarMass.FromGramsPerMoles(value); + + /// + public static MolarMass GramsPerMoles(this double value) => MolarMass.FromGramsPerMoles(value); + + /// + public static MolarMass? GramsPerMoles(this double? value) => MolarMass.FromGramsPerMoles(value); + + /// + public static MolarMass GramsPerMoles(this float value) => MolarMass.FromGramsPerMoles(value); + + /// + public static MolarMass? GramsPerMoles(this float? value) => MolarMass.FromGramsPerMoles(value); + + /// + public static MolarMass GramsPerMoles(this decimal value) => MolarMass.FromGramsPerMoles(Convert.ToDouble(value)); + + /// + public static MolarMass? GramsPerMoles(this decimal? value) => MolarMass.FromGramsPerMoles(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + + #region HectogramPerMole + + /// + public static MolarMass HectogramsPerMoles(this int value) => MolarMass.FromHectogramsPerMoles(value); + + /// + public static MolarMass? HectogramsPerMoles(this int? value) => MolarMass.FromHectogramsPerMoles(value); + + /// + public static MolarMass HectogramsPerMoles(this long value) => MolarMass.FromHectogramsPerMoles(value); + + /// + public static MolarMass? HectogramsPerMoles(this long? value) => MolarMass.FromHectogramsPerMoles(value); + + /// + public static MolarMass HectogramsPerMoles(this double value) => MolarMass.FromHectogramsPerMoles(value); + + /// + public static MolarMass? HectogramsPerMoles(this double? value) => MolarMass.FromHectogramsPerMoles(value); + + /// + public static MolarMass HectogramsPerMoles(this float value) => MolarMass.FromHectogramsPerMoles(value); + + /// + public static MolarMass? HectogramsPerMoles(this float? value) => MolarMass.FromHectogramsPerMoles(value); + + /// + public static MolarMass HectogramsPerMoles(this decimal value) => MolarMass.FromHectogramsPerMoles(Convert.ToDouble(value)); + + /// + public static MolarMass? HectogramsPerMoles(this decimal? value) => MolarMass.FromHectogramsPerMoles(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + + #region KilogramPerMole + + /// + public static MolarMass KilogramsPerMoles(this int value) => MolarMass.FromKilogramsPerMoles(value); + + /// + public static MolarMass? KilogramsPerMoles(this int? value) => MolarMass.FromKilogramsPerMoles(value); + + /// + public static MolarMass KilogramsPerMoles(this long value) => MolarMass.FromKilogramsPerMoles(value); + + /// + public static MolarMass? KilogramsPerMoles(this long? value) => MolarMass.FromKilogramsPerMoles(value); + + /// + public static MolarMass KilogramsPerMoles(this double value) => MolarMass.FromKilogramsPerMoles(value); + + /// + public static MolarMass? KilogramsPerMoles(this double? value) => MolarMass.FromKilogramsPerMoles(value); + + /// + public static MolarMass KilogramsPerMoles(this float value) => MolarMass.FromKilogramsPerMoles(value); + + /// + public static MolarMass? KilogramsPerMoles(this float? value) => MolarMass.FromKilogramsPerMoles(value); + + /// + public static MolarMass KilogramsPerMoles(this decimal value) => MolarMass.FromKilogramsPerMoles(Convert.ToDouble(value)); + + /// + public static MolarMass? KilogramsPerMoles(this decimal? value) => MolarMass.FromKilogramsPerMoles(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + + #region KilopoundPerMole + + /// + public static MolarMass KilopoundsPerMoles(this int value) => MolarMass.FromKilopoundsPerMoles(value); + + /// + public static MolarMass? KilopoundsPerMoles(this int? value) => MolarMass.FromKilopoundsPerMoles(value); + + /// + public static MolarMass KilopoundsPerMoles(this long value) => MolarMass.FromKilopoundsPerMoles(value); + + /// + public static MolarMass? KilopoundsPerMoles(this long? value) => MolarMass.FromKilopoundsPerMoles(value); + + /// + public static MolarMass KilopoundsPerMoles(this double value) => MolarMass.FromKilopoundsPerMoles(value); + + /// + public static MolarMass? KilopoundsPerMoles(this double? value) => MolarMass.FromKilopoundsPerMoles(value); + + /// + public static MolarMass KilopoundsPerMoles(this float value) => MolarMass.FromKilopoundsPerMoles(value); + + /// + public static MolarMass? KilopoundsPerMoles(this float? value) => MolarMass.FromKilopoundsPerMoles(value); + + /// + public static MolarMass KilopoundsPerMoles(this decimal value) => MolarMass.FromKilopoundsPerMoles(Convert.ToDouble(value)); + + /// + public static MolarMass? KilopoundsPerMoles(this decimal? value) => MolarMass.FromKilopoundsPerMoles(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + + #region MegapoundPerMole + + /// + public static MolarMass MegapoundsPerMoles(this int value) => MolarMass.FromMegapoundsPerMoles(value); + + /// + public static MolarMass? MegapoundsPerMoles(this int? value) => MolarMass.FromMegapoundsPerMoles(value); + + /// + public static MolarMass MegapoundsPerMoles(this long value) => MolarMass.FromMegapoundsPerMoles(value); + + /// + public static MolarMass? MegapoundsPerMoles(this long? value) => MolarMass.FromMegapoundsPerMoles(value); + + /// + public static MolarMass MegapoundsPerMoles(this double value) => MolarMass.FromMegapoundsPerMoles(value); + + /// + public static MolarMass? MegapoundsPerMoles(this double? value) => MolarMass.FromMegapoundsPerMoles(value); + + /// + public static MolarMass MegapoundsPerMoles(this float value) => MolarMass.FromMegapoundsPerMoles(value); + + /// + public static MolarMass? MegapoundsPerMoles(this float? value) => MolarMass.FromMegapoundsPerMoles(value); + + /// + public static MolarMass MegapoundsPerMoles(this decimal value) => MolarMass.FromMegapoundsPerMoles(Convert.ToDouble(value)); + + /// + public static MolarMass? MegapoundsPerMoles(this decimal? value) => MolarMass.FromMegapoundsPerMoles(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + + #region MicrogramPerMole + + /// + public static MolarMass MicrogramsPerMoles(this int value) => MolarMass.FromMicrogramsPerMoles(value); + + /// + public static MolarMass? MicrogramsPerMoles(this int? value) => MolarMass.FromMicrogramsPerMoles(value); + + /// + public static MolarMass MicrogramsPerMoles(this long value) => MolarMass.FromMicrogramsPerMoles(value); + + /// + public static MolarMass? MicrogramsPerMoles(this long? value) => MolarMass.FromMicrogramsPerMoles(value); + + /// + public static MolarMass MicrogramsPerMoles(this double value) => MolarMass.FromMicrogramsPerMoles(value); + + /// + public static MolarMass? MicrogramsPerMoles(this double? value) => MolarMass.FromMicrogramsPerMoles(value); + + /// + public static MolarMass MicrogramsPerMoles(this float value) => MolarMass.FromMicrogramsPerMoles(value); + + /// + public static MolarMass? MicrogramsPerMoles(this float? value) => MolarMass.FromMicrogramsPerMoles(value); + + /// + public static MolarMass MicrogramsPerMoles(this decimal value) => MolarMass.FromMicrogramsPerMoles(Convert.ToDouble(value)); + + /// + public static MolarMass? MicrogramsPerMoles(this decimal? value) => MolarMass.FromMicrogramsPerMoles(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + + #region MilligramPerMole + + /// + public static MolarMass MilligramsPerMoles(this int value) => MolarMass.FromMilligramsPerMoles(value); + + /// + public static MolarMass? MilligramsPerMoles(this int? value) => MolarMass.FromMilligramsPerMoles(value); + + /// + public static MolarMass MilligramsPerMoles(this long value) => MolarMass.FromMilligramsPerMoles(value); + + /// + public static MolarMass? MilligramsPerMoles(this long? value) => MolarMass.FromMilligramsPerMoles(value); + + /// + public static MolarMass MilligramsPerMoles(this double value) => MolarMass.FromMilligramsPerMoles(value); + + /// + public static MolarMass? MilligramsPerMoles(this double? value) => MolarMass.FromMilligramsPerMoles(value); + + /// + public static MolarMass MilligramsPerMoles(this float value) => MolarMass.FromMilligramsPerMoles(value); + + /// + public static MolarMass? MilligramsPerMoles(this float? value) => MolarMass.FromMilligramsPerMoles(value); + + /// + public static MolarMass MilligramsPerMoles(this decimal value) => MolarMass.FromMilligramsPerMoles(Convert.ToDouble(value)); + + /// + public static MolarMass? MilligramsPerMoles(this decimal? value) => MolarMass.FromMilligramsPerMoles(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + + #region NanogramPerMole + + /// + public static MolarMass NanogramsPerMoles(this int value) => MolarMass.FromNanogramsPerMoles(value); + + /// + public static MolarMass? NanogramsPerMoles(this int? value) => MolarMass.FromNanogramsPerMoles(value); + + /// + public static MolarMass NanogramsPerMoles(this long value) => MolarMass.FromNanogramsPerMoles(value); + + /// + public static MolarMass? NanogramsPerMoles(this long? value) => MolarMass.FromNanogramsPerMoles(value); + + /// + public static MolarMass NanogramsPerMoles(this double value) => MolarMass.FromNanogramsPerMoles(value); + + /// + public static MolarMass? NanogramsPerMoles(this double? value) => MolarMass.FromNanogramsPerMoles(value); + + /// + public static MolarMass NanogramsPerMoles(this float value) => MolarMass.FromNanogramsPerMoles(value); + + /// + public static MolarMass? NanogramsPerMoles(this float? value) => MolarMass.FromNanogramsPerMoles(value); + + /// + public static MolarMass NanogramsPerMoles(this decimal value) => MolarMass.FromNanogramsPerMoles(Convert.ToDouble(value)); + + /// + public static MolarMass? NanogramsPerMoles(this decimal? value) => MolarMass.FromNanogramsPerMoles(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + + #region PoundPerMole + + /// + public static MolarMass PoundsPerMoles(this int value) => MolarMass.FromPoundsPerMoles(value); + + /// + public static MolarMass? PoundsPerMoles(this int? value) => MolarMass.FromPoundsPerMoles(value); + + /// + public static MolarMass PoundsPerMoles(this long value) => MolarMass.FromPoundsPerMoles(value); + + /// + public static MolarMass? PoundsPerMoles(this long? value) => MolarMass.FromPoundsPerMoles(value); + + /// + public static MolarMass PoundsPerMoles(this double value) => MolarMass.FromPoundsPerMoles(value); + + /// + public static MolarMass? PoundsPerMoles(this double? value) => MolarMass.FromPoundsPerMoles(value); + + /// + public static MolarMass PoundsPerMoles(this float value) => MolarMass.FromPoundsPerMoles(value); + + /// + public static MolarMass? PoundsPerMoles(this float? value) => MolarMass.FromPoundsPerMoles(value); + + /// + public static MolarMass PoundsPerMoles(this decimal value) => MolarMass.FromPoundsPerMoles(Convert.ToDouble(value)); + + /// + public static MolarMass? PoundsPerMoles(this decimal? value) => MolarMass.FromPoundsPerMoles(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + + } +} +#endif diff --git a/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs new file mode 100644 index 0000000000..97d3b9c802 --- /dev/null +++ b/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs @@ -0,0 +1,1952 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by \generate-code.bat. +// +// Changes to this file will be lost when the code is regenerated. +// The build server regenerates the code before each build and a pre-build +// step will regenerate the code on each local build. +// +// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units. +// +// Add CustomCode\Quantities\MyUnit.extra.cs files to add code to generated quantities. +// Add Extensions\MyUnitExtensions.cs to decorate quantities with new behavior. +// Add UnitDefinitions\MyUnit.json and run GeneratUnits.bat to generate new units or quantities. +// +// +//------------------------------------------------------------------------------ + +// Copyright (c) 2007 Andreas Gullberg Larsen (angularsen@gmail.com). +// https://github.com/angularsen/UnitsNet +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Globalization; +using System.Text.RegularExpressions; +using System.Linq; +using JetBrains.Annotations; +using UnitsNet.Units; + +// Windows Runtime Component does not support CultureInfo type, so use culture name string instead for public methods: https://msdn.microsoft.com/en-us/library/br230301.aspx +#if WINDOWS_UWP +using Culture = System.String; +#else +using Culture = System.IFormatProvider; +#endif + +// ReSharper disable once CheckNamespace + +namespace UnitsNet +{ + /// + /// In chemistry, the molar mass M is a physical property defined as the mass of a given substance (chemical element or chemical compound) divided by the amount of substance. + /// + // ReSharper disable once PartialTypeWithSinglePart + + // 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. +#if WINDOWS_UWP + public sealed partial class MolarMass +#else + public partial struct MolarMass : IComparable, IComparable +#endif + { + /// + /// Base unit of MolarMass. + /// + private readonly double _kilogramsPerMoles; + + // Windows Runtime Component requires a default constructor +#if WINDOWS_UWP + public MolarMass() : this(0) + { + } +#endif + + public MolarMass(double kilogramspermoles) + { + _kilogramsPerMoles = Convert.ToDouble(kilogramspermoles); + } + + // 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 +#if WINDOWS_UWP + private +#else + public +#endif + MolarMass(long kilogramspermoles) + { + _kilogramsPerMoles = Convert.ToDouble(kilogramspermoles); + } + + // 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 + // Windows Runtime Component does not support decimal type +#if WINDOWS_UWP + private +#else + public +#endif + MolarMass(decimal kilogramspermoles) + { + _kilogramsPerMoles = Convert.ToDouble(kilogramspermoles); + } + + #region Properties + + /// + /// The of this quantity. + /// + public static QuantityType QuantityType => QuantityType.MolarMass; + + /// + /// The base unit representation of this quantity for the numeric value stored internally. All conversions go via this value. + /// + public static MolarMassUnit BaseUnit + { + get { return MolarMassUnit.KilogramPerMole; } + } + + /// + /// All units of measurement for the MolarMass quantity. + /// + public static MolarMassUnit[] Units { get; } = Enum.GetValues(typeof(MolarMassUnit)).Cast().ToArray(); + + /// + /// Get MolarMass in CentigramsPerMoles. + /// + public double CentigramsPerMoles + { + get { return (_kilogramsPerMoles*1e3) / 1e-2d; } + } + + /// + /// Get MolarMass in DecagramsPerMoles. + /// + public double DecagramsPerMoles + { + get { return (_kilogramsPerMoles*1e3) / 1e1d; } + } + + /// + /// Get MolarMass in DecigramsPerMoles. + /// + public double DecigramsPerMoles + { + get { return (_kilogramsPerMoles*1e3) / 1e-1d; } + } + + /// + /// Get MolarMass in GramsPerMoles. + /// + public double GramsPerMoles + { + get { return _kilogramsPerMoles*1e3; } + } + + /// + /// Get MolarMass in HectogramsPerMoles. + /// + public double HectogramsPerMoles + { + get { return (_kilogramsPerMoles*1e3) / 1e2d; } + } + + /// + /// Get MolarMass in KilogramsPerMoles. + /// + public double KilogramsPerMoles + { + get { return (_kilogramsPerMoles*1e3) / 1e3d; } + } + + /// + /// Get MolarMass in KilopoundsPerMoles. + /// + public double KilopoundsPerMoles + { + get { return (_kilogramsPerMoles/0.45359237) / 1e3d; } + } + + /// + /// Get MolarMass in MegapoundsPerMoles. + /// + public double MegapoundsPerMoles + { + get { return (_kilogramsPerMoles/0.45359237) / 1e6d; } + } + + /// + /// Get MolarMass in MicrogramsPerMoles. + /// + public double MicrogramsPerMoles + { + get { return (_kilogramsPerMoles*1e3) / 1e-6d; } + } + + /// + /// Get MolarMass in MilligramsPerMoles. + /// + public double MilligramsPerMoles + { + get { return (_kilogramsPerMoles*1e3) / 1e-3d; } + } + + /// + /// Get MolarMass in NanogramsPerMoles. + /// + public double NanogramsPerMoles + { + get { return (_kilogramsPerMoles*1e3) / 1e-9d; } + } + + /// + /// Get MolarMass in PoundsPerMoles. + /// + public double PoundsPerMoles + { + get { return _kilogramsPerMoles/0.45359237; } + } + + #endregion + + #region Static + + public static MolarMass Zero + { + get { return new MolarMass(); } + } + + /// + /// Get MolarMass from CentigramsPerMoles. + /// +#if NETFX_CORE + [Windows.Foundation.Metadata.DefaultOverload] +#endif + public static MolarMass FromCentigramsPerMoles(double centigramspermoles) + { + return new MolarMass((centigramspermoles/1e3) * 1e-2d); + } + + /// + /// Get MolarMass from CentigramsPerMoles. + /// + public static MolarMass FromCentigramsPerMoles(int centigramspermoles) + { + return new MolarMass((centigramspermoles/1e3) * 1e-2d); + } + + /// + /// Get MolarMass from CentigramsPerMoles. + /// + public static MolarMass FromCentigramsPerMoles(long centigramspermoles) + { + return new MolarMass((centigramspermoles/1e3) * 1e-2d); + } + + // Windows Runtime Component does not support decimal type +#if !WINDOWS_UWP + /// + /// Get MolarMass from CentigramsPerMoles of type decimal. + /// + public static MolarMass FromCentigramsPerMoles(decimal centigramspermoles) + { + return new MolarMass((Convert.ToDouble(centigramspermoles)/1e3) * 1e-2d); + } +#endif + + /// + /// Get MolarMass from DecagramsPerMoles. + /// +#if NETFX_CORE + [Windows.Foundation.Metadata.DefaultOverload] +#endif + public static MolarMass FromDecagramsPerMoles(double decagramspermoles) + { + return new MolarMass((decagramspermoles/1e3) * 1e1d); + } + + /// + /// Get MolarMass from DecagramsPerMoles. + /// + public static MolarMass FromDecagramsPerMoles(int decagramspermoles) + { + return new MolarMass((decagramspermoles/1e3) * 1e1d); + } + + /// + /// Get MolarMass from DecagramsPerMoles. + /// + public static MolarMass FromDecagramsPerMoles(long decagramspermoles) + { + return new MolarMass((decagramspermoles/1e3) * 1e1d); + } + + // Windows Runtime Component does not support decimal type +#if !WINDOWS_UWP + /// + /// Get MolarMass from DecagramsPerMoles of type decimal. + /// + public static MolarMass FromDecagramsPerMoles(decimal decagramspermoles) + { + return new MolarMass((Convert.ToDouble(decagramspermoles)/1e3) * 1e1d); + } +#endif + + /// + /// Get MolarMass from DecigramsPerMoles. + /// +#if NETFX_CORE + [Windows.Foundation.Metadata.DefaultOverload] +#endif + public static MolarMass FromDecigramsPerMoles(double decigramspermoles) + { + return new MolarMass((decigramspermoles/1e3) * 1e-1d); + } + + /// + /// Get MolarMass from DecigramsPerMoles. + /// + public static MolarMass FromDecigramsPerMoles(int decigramspermoles) + { + return new MolarMass((decigramspermoles/1e3) * 1e-1d); + } + + /// + /// Get MolarMass from DecigramsPerMoles. + /// + public static MolarMass FromDecigramsPerMoles(long decigramspermoles) + { + return new MolarMass((decigramspermoles/1e3) * 1e-1d); + } + + // Windows Runtime Component does not support decimal type +#if !WINDOWS_UWP + /// + /// Get MolarMass from DecigramsPerMoles of type decimal. + /// + public static MolarMass FromDecigramsPerMoles(decimal decigramspermoles) + { + return new MolarMass((Convert.ToDouble(decigramspermoles)/1e3) * 1e-1d); + } +#endif + + /// + /// Get MolarMass from GramsPerMoles. + /// +#if NETFX_CORE + [Windows.Foundation.Metadata.DefaultOverload] +#endif + public static MolarMass FromGramsPerMoles(double gramspermoles) + { + return new MolarMass(gramspermoles/1e3); + } + + /// + /// Get MolarMass from GramsPerMoles. + /// + public static MolarMass FromGramsPerMoles(int gramspermoles) + { + return new MolarMass(gramspermoles/1e3); + } + + /// + /// Get MolarMass from GramsPerMoles. + /// + public static MolarMass FromGramsPerMoles(long gramspermoles) + { + return new MolarMass(gramspermoles/1e3); + } + + // Windows Runtime Component does not support decimal type +#if !WINDOWS_UWP + /// + /// Get MolarMass from GramsPerMoles of type decimal. + /// + public static MolarMass FromGramsPerMoles(decimal gramspermoles) + { + return new MolarMass(Convert.ToDouble(gramspermoles)/1e3); + } +#endif + + /// + /// Get MolarMass from HectogramsPerMoles. + /// +#if NETFX_CORE + [Windows.Foundation.Metadata.DefaultOverload] +#endif + public static MolarMass FromHectogramsPerMoles(double hectogramspermoles) + { + return new MolarMass((hectogramspermoles/1e3) * 1e2d); + } + + /// + /// Get MolarMass from HectogramsPerMoles. + /// + public static MolarMass FromHectogramsPerMoles(int hectogramspermoles) + { + return new MolarMass((hectogramspermoles/1e3) * 1e2d); + } + + /// + /// Get MolarMass from HectogramsPerMoles. + /// + public static MolarMass FromHectogramsPerMoles(long hectogramspermoles) + { + return new MolarMass((hectogramspermoles/1e3) * 1e2d); + } + + // Windows Runtime Component does not support decimal type +#if !WINDOWS_UWP + /// + /// Get MolarMass from HectogramsPerMoles of type decimal. + /// + public static MolarMass FromHectogramsPerMoles(decimal hectogramspermoles) + { + return new MolarMass((Convert.ToDouble(hectogramspermoles)/1e3) * 1e2d); + } +#endif + + /// + /// Get MolarMass from KilogramsPerMoles. + /// +#if NETFX_CORE + [Windows.Foundation.Metadata.DefaultOverload] +#endif + public static MolarMass FromKilogramsPerMoles(double kilogramspermoles) + { + return new MolarMass((kilogramspermoles/1e3) * 1e3d); + } + + /// + /// Get MolarMass from KilogramsPerMoles. + /// + public static MolarMass FromKilogramsPerMoles(int kilogramspermoles) + { + return new MolarMass((kilogramspermoles/1e3) * 1e3d); + } + + /// + /// Get MolarMass from KilogramsPerMoles. + /// + public static MolarMass FromKilogramsPerMoles(long kilogramspermoles) + { + return new MolarMass((kilogramspermoles/1e3) * 1e3d); + } + + // Windows Runtime Component does not support decimal type +#if !WINDOWS_UWP + /// + /// Get MolarMass from KilogramsPerMoles of type decimal. + /// + public static MolarMass FromKilogramsPerMoles(decimal kilogramspermoles) + { + return new MolarMass((Convert.ToDouble(kilogramspermoles)/1e3) * 1e3d); + } +#endif + + /// + /// Get MolarMass from KilopoundsPerMoles. + /// +#if NETFX_CORE + [Windows.Foundation.Metadata.DefaultOverload] +#endif + public static MolarMass FromKilopoundsPerMoles(double kilopoundspermoles) + { + return new MolarMass((kilopoundspermoles*0.45359237) * 1e3d); + } + + /// + /// Get MolarMass from KilopoundsPerMoles. + /// + public static MolarMass FromKilopoundsPerMoles(int kilopoundspermoles) + { + return new MolarMass((kilopoundspermoles*0.45359237) * 1e3d); + } + + /// + /// Get MolarMass from KilopoundsPerMoles. + /// + public static MolarMass FromKilopoundsPerMoles(long kilopoundspermoles) + { + return new MolarMass((kilopoundspermoles*0.45359237) * 1e3d); + } + + // Windows Runtime Component does not support decimal type +#if !WINDOWS_UWP + /// + /// Get MolarMass from KilopoundsPerMoles of type decimal. + /// + public static MolarMass FromKilopoundsPerMoles(decimal kilopoundspermoles) + { + return new MolarMass((Convert.ToDouble(kilopoundspermoles)*0.45359237) * 1e3d); + } +#endif + + /// + /// Get MolarMass from MegapoundsPerMoles. + /// +#if NETFX_CORE + [Windows.Foundation.Metadata.DefaultOverload] +#endif + public static MolarMass FromMegapoundsPerMoles(double megapoundspermoles) + { + return new MolarMass((megapoundspermoles*0.45359237) * 1e6d); + } + + /// + /// Get MolarMass from MegapoundsPerMoles. + /// + public static MolarMass FromMegapoundsPerMoles(int megapoundspermoles) + { + return new MolarMass((megapoundspermoles*0.45359237) * 1e6d); + } + + /// + /// Get MolarMass from MegapoundsPerMoles. + /// + public static MolarMass FromMegapoundsPerMoles(long megapoundspermoles) + { + return new MolarMass((megapoundspermoles*0.45359237) * 1e6d); + } + + // Windows Runtime Component does not support decimal type +#if !WINDOWS_UWP + /// + /// Get MolarMass from MegapoundsPerMoles of type decimal. + /// + public static MolarMass FromMegapoundsPerMoles(decimal megapoundspermoles) + { + return new MolarMass((Convert.ToDouble(megapoundspermoles)*0.45359237) * 1e6d); + } +#endif + + /// + /// Get MolarMass from MicrogramsPerMoles. + /// +#if NETFX_CORE + [Windows.Foundation.Metadata.DefaultOverload] +#endif + public static MolarMass FromMicrogramsPerMoles(double microgramspermoles) + { + return new MolarMass((microgramspermoles/1e3) * 1e-6d); + } + + /// + /// Get MolarMass from MicrogramsPerMoles. + /// + public static MolarMass FromMicrogramsPerMoles(int microgramspermoles) + { + return new MolarMass((microgramspermoles/1e3) * 1e-6d); + } + + /// + /// Get MolarMass from MicrogramsPerMoles. + /// + public static MolarMass FromMicrogramsPerMoles(long microgramspermoles) + { + return new MolarMass((microgramspermoles/1e3) * 1e-6d); + } + + // Windows Runtime Component does not support decimal type +#if !WINDOWS_UWP + /// + /// Get MolarMass from MicrogramsPerMoles of type decimal. + /// + public static MolarMass FromMicrogramsPerMoles(decimal microgramspermoles) + { + return new MolarMass((Convert.ToDouble(microgramspermoles)/1e3) * 1e-6d); + } +#endif + + /// + /// Get MolarMass from MilligramsPerMoles. + /// +#if NETFX_CORE + [Windows.Foundation.Metadata.DefaultOverload] +#endif + public static MolarMass FromMilligramsPerMoles(double milligramspermoles) + { + return new MolarMass((milligramspermoles/1e3) * 1e-3d); + } + + /// + /// Get MolarMass from MilligramsPerMoles. + /// + public static MolarMass FromMilligramsPerMoles(int milligramspermoles) + { + return new MolarMass((milligramspermoles/1e3) * 1e-3d); + } + + /// + /// Get MolarMass from MilligramsPerMoles. + /// + public static MolarMass FromMilligramsPerMoles(long milligramspermoles) + { + return new MolarMass((milligramspermoles/1e3) * 1e-3d); + } + + // Windows Runtime Component does not support decimal type +#if !WINDOWS_UWP + /// + /// Get MolarMass from MilligramsPerMoles of type decimal. + /// + public static MolarMass FromMilligramsPerMoles(decimal milligramspermoles) + { + return new MolarMass((Convert.ToDouble(milligramspermoles)/1e3) * 1e-3d); + } +#endif + + /// + /// Get MolarMass from NanogramsPerMoles. + /// +#if NETFX_CORE + [Windows.Foundation.Metadata.DefaultOverload] +#endif + public static MolarMass FromNanogramsPerMoles(double nanogramspermoles) + { + return new MolarMass((nanogramspermoles/1e3) * 1e-9d); + } + + /// + /// Get MolarMass from NanogramsPerMoles. + /// + public static MolarMass FromNanogramsPerMoles(int nanogramspermoles) + { + return new MolarMass((nanogramspermoles/1e3) * 1e-9d); + } + + /// + /// Get MolarMass from NanogramsPerMoles. + /// + public static MolarMass FromNanogramsPerMoles(long nanogramspermoles) + { + return new MolarMass((nanogramspermoles/1e3) * 1e-9d); + } + + // Windows Runtime Component does not support decimal type +#if !WINDOWS_UWP + /// + /// Get MolarMass from NanogramsPerMoles of type decimal. + /// + public static MolarMass FromNanogramsPerMoles(decimal nanogramspermoles) + { + return new MolarMass((Convert.ToDouble(nanogramspermoles)/1e3) * 1e-9d); + } +#endif + + /// + /// Get MolarMass from PoundsPerMoles. + /// +#if NETFX_CORE + [Windows.Foundation.Metadata.DefaultOverload] +#endif + public static MolarMass FromPoundsPerMoles(double poundspermoles) + { + return new MolarMass(poundspermoles*0.45359237); + } + + /// + /// Get MolarMass from PoundsPerMoles. + /// + public static MolarMass FromPoundsPerMoles(int poundspermoles) + { + return new MolarMass(poundspermoles*0.45359237); + } + + /// + /// Get MolarMass from PoundsPerMoles. + /// + public static MolarMass FromPoundsPerMoles(long poundspermoles) + { + return new MolarMass(poundspermoles*0.45359237); + } + + // Windows Runtime Component does not support decimal type +#if !WINDOWS_UWP + /// + /// Get MolarMass from PoundsPerMoles of type decimal. + /// + public static MolarMass FromPoundsPerMoles(decimal poundspermoles) + { + return new MolarMass(Convert.ToDouble(poundspermoles)*0.45359237); + } +#endif + + // Windows Runtime Component does not support nullable types (double?): https://msdn.microsoft.com/en-us/library/br230301.aspx +#if !WINDOWS_UWP + /// + /// Get nullable MolarMass from nullable CentigramsPerMoles. + /// + public static MolarMass? FromCentigramsPerMoles(double? centigramspermoles) + { + if (centigramspermoles.HasValue) + { + return FromCentigramsPerMoles(centigramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable CentigramsPerMoles. + /// + public static MolarMass? FromCentigramsPerMoles(int? centigramspermoles) + { + if (centigramspermoles.HasValue) + { + return FromCentigramsPerMoles(centigramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable CentigramsPerMoles. + /// + public static MolarMass? FromCentigramsPerMoles(long? centigramspermoles) + { + if (centigramspermoles.HasValue) + { + return FromCentigramsPerMoles(centigramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from CentigramsPerMoles of type decimal. + /// + public static MolarMass? FromCentigramsPerMoles(decimal? centigramspermoles) + { + if (centigramspermoles.HasValue) + { + return FromCentigramsPerMoles(centigramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable DecagramsPerMoles. + /// + public static MolarMass? FromDecagramsPerMoles(double? decagramspermoles) + { + if (decagramspermoles.HasValue) + { + return FromDecagramsPerMoles(decagramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable DecagramsPerMoles. + /// + public static MolarMass? FromDecagramsPerMoles(int? decagramspermoles) + { + if (decagramspermoles.HasValue) + { + return FromDecagramsPerMoles(decagramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable DecagramsPerMoles. + /// + public static MolarMass? FromDecagramsPerMoles(long? decagramspermoles) + { + if (decagramspermoles.HasValue) + { + return FromDecagramsPerMoles(decagramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from DecagramsPerMoles of type decimal. + /// + public static MolarMass? FromDecagramsPerMoles(decimal? decagramspermoles) + { + if (decagramspermoles.HasValue) + { + return FromDecagramsPerMoles(decagramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable DecigramsPerMoles. + /// + public static MolarMass? FromDecigramsPerMoles(double? decigramspermoles) + { + if (decigramspermoles.HasValue) + { + return FromDecigramsPerMoles(decigramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable DecigramsPerMoles. + /// + public static MolarMass? FromDecigramsPerMoles(int? decigramspermoles) + { + if (decigramspermoles.HasValue) + { + return FromDecigramsPerMoles(decigramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable DecigramsPerMoles. + /// + public static MolarMass? FromDecigramsPerMoles(long? decigramspermoles) + { + if (decigramspermoles.HasValue) + { + return FromDecigramsPerMoles(decigramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from DecigramsPerMoles of type decimal. + /// + public static MolarMass? FromDecigramsPerMoles(decimal? decigramspermoles) + { + if (decigramspermoles.HasValue) + { + return FromDecigramsPerMoles(decigramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable GramsPerMoles. + /// + public static MolarMass? FromGramsPerMoles(double? gramspermoles) + { + if (gramspermoles.HasValue) + { + return FromGramsPerMoles(gramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable GramsPerMoles. + /// + public static MolarMass? FromGramsPerMoles(int? gramspermoles) + { + if (gramspermoles.HasValue) + { + return FromGramsPerMoles(gramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable GramsPerMoles. + /// + public static MolarMass? FromGramsPerMoles(long? gramspermoles) + { + if (gramspermoles.HasValue) + { + return FromGramsPerMoles(gramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from GramsPerMoles of type decimal. + /// + public static MolarMass? FromGramsPerMoles(decimal? gramspermoles) + { + if (gramspermoles.HasValue) + { + return FromGramsPerMoles(gramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable HectogramsPerMoles. + /// + public static MolarMass? FromHectogramsPerMoles(double? hectogramspermoles) + { + if (hectogramspermoles.HasValue) + { + return FromHectogramsPerMoles(hectogramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable HectogramsPerMoles. + /// + public static MolarMass? FromHectogramsPerMoles(int? hectogramspermoles) + { + if (hectogramspermoles.HasValue) + { + return FromHectogramsPerMoles(hectogramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable HectogramsPerMoles. + /// + public static MolarMass? FromHectogramsPerMoles(long? hectogramspermoles) + { + if (hectogramspermoles.HasValue) + { + return FromHectogramsPerMoles(hectogramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from HectogramsPerMoles of type decimal. + /// + public static MolarMass? FromHectogramsPerMoles(decimal? hectogramspermoles) + { + if (hectogramspermoles.HasValue) + { + return FromHectogramsPerMoles(hectogramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable KilogramsPerMoles. + /// + public static MolarMass? FromKilogramsPerMoles(double? kilogramspermoles) + { + if (kilogramspermoles.HasValue) + { + return FromKilogramsPerMoles(kilogramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable KilogramsPerMoles. + /// + public static MolarMass? FromKilogramsPerMoles(int? kilogramspermoles) + { + if (kilogramspermoles.HasValue) + { + return FromKilogramsPerMoles(kilogramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable KilogramsPerMoles. + /// + public static MolarMass? FromKilogramsPerMoles(long? kilogramspermoles) + { + if (kilogramspermoles.HasValue) + { + return FromKilogramsPerMoles(kilogramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from KilogramsPerMoles of type decimal. + /// + public static MolarMass? FromKilogramsPerMoles(decimal? kilogramspermoles) + { + if (kilogramspermoles.HasValue) + { + return FromKilogramsPerMoles(kilogramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable KilopoundsPerMoles. + /// + public static MolarMass? FromKilopoundsPerMoles(double? kilopoundspermoles) + { + if (kilopoundspermoles.HasValue) + { + return FromKilopoundsPerMoles(kilopoundspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable KilopoundsPerMoles. + /// + public static MolarMass? FromKilopoundsPerMoles(int? kilopoundspermoles) + { + if (kilopoundspermoles.HasValue) + { + return FromKilopoundsPerMoles(kilopoundspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable KilopoundsPerMoles. + /// + public static MolarMass? FromKilopoundsPerMoles(long? kilopoundspermoles) + { + if (kilopoundspermoles.HasValue) + { + return FromKilopoundsPerMoles(kilopoundspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from KilopoundsPerMoles of type decimal. + /// + public static MolarMass? FromKilopoundsPerMoles(decimal? kilopoundspermoles) + { + if (kilopoundspermoles.HasValue) + { + return FromKilopoundsPerMoles(kilopoundspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable MegapoundsPerMoles. + /// + public static MolarMass? FromMegapoundsPerMoles(double? megapoundspermoles) + { + if (megapoundspermoles.HasValue) + { + return FromMegapoundsPerMoles(megapoundspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable MegapoundsPerMoles. + /// + public static MolarMass? FromMegapoundsPerMoles(int? megapoundspermoles) + { + if (megapoundspermoles.HasValue) + { + return FromMegapoundsPerMoles(megapoundspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable MegapoundsPerMoles. + /// + public static MolarMass? FromMegapoundsPerMoles(long? megapoundspermoles) + { + if (megapoundspermoles.HasValue) + { + return FromMegapoundsPerMoles(megapoundspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from MegapoundsPerMoles of type decimal. + /// + public static MolarMass? FromMegapoundsPerMoles(decimal? megapoundspermoles) + { + if (megapoundspermoles.HasValue) + { + return FromMegapoundsPerMoles(megapoundspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable MicrogramsPerMoles. + /// + public static MolarMass? FromMicrogramsPerMoles(double? microgramspermoles) + { + if (microgramspermoles.HasValue) + { + return FromMicrogramsPerMoles(microgramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable MicrogramsPerMoles. + /// + public static MolarMass? FromMicrogramsPerMoles(int? microgramspermoles) + { + if (microgramspermoles.HasValue) + { + return FromMicrogramsPerMoles(microgramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable MicrogramsPerMoles. + /// + public static MolarMass? FromMicrogramsPerMoles(long? microgramspermoles) + { + if (microgramspermoles.HasValue) + { + return FromMicrogramsPerMoles(microgramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from MicrogramsPerMoles of type decimal. + /// + public static MolarMass? FromMicrogramsPerMoles(decimal? microgramspermoles) + { + if (microgramspermoles.HasValue) + { + return FromMicrogramsPerMoles(microgramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable MilligramsPerMoles. + /// + public static MolarMass? FromMilligramsPerMoles(double? milligramspermoles) + { + if (milligramspermoles.HasValue) + { + return FromMilligramsPerMoles(milligramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable MilligramsPerMoles. + /// + public static MolarMass? FromMilligramsPerMoles(int? milligramspermoles) + { + if (milligramspermoles.HasValue) + { + return FromMilligramsPerMoles(milligramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable MilligramsPerMoles. + /// + public static MolarMass? FromMilligramsPerMoles(long? milligramspermoles) + { + if (milligramspermoles.HasValue) + { + return FromMilligramsPerMoles(milligramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from MilligramsPerMoles of type decimal. + /// + public static MolarMass? FromMilligramsPerMoles(decimal? milligramspermoles) + { + if (milligramspermoles.HasValue) + { + return FromMilligramsPerMoles(milligramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable NanogramsPerMoles. + /// + public static MolarMass? FromNanogramsPerMoles(double? nanogramspermoles) + { + if (nanogramspermoles.HasValue) + { + return FromNanogramsPerMoles(nanogramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable NanogramsPerMoles. + /// + public static MolarMass? FromNanogramsPerMoles(int? nanogramspermoles) + { + if (nanogramspermoles.HasValue) + { + return FromNanogramsPerMoles(nanogramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable NanogramsPerMoles. + /// + public static MolarMass? FromNanogramsPerMoles(long? nanogramspermoles) + { + if (nanogramspermoles.HasValue) + { + return FromNanogramsPerMoles(nanogramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from NanogramsPerMoles of type decimal. + /// + public static MolarMass? FromNanogramsPerMoles(decimal? nanogramspermoles) + { + if (nanogramspermoles.HasValue) + { + return FromNanogramsPerMoles(nanogramspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable PoundsPerMoles. + /// + public static MolarMass? FromPoundsPerMoles(double? poundspermoles) + { + if (poundspermoles.HasValue) + { + return FromPoundsPerMoles(poundspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable PoundsPerMoles. + /// + public static MolarMass? FromPoundsPerMoles(int? poundspermoles) + { + if (poundspermoles.HasValue) + { + return FromPoundsPerMoles(poundspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from nullable PoundsPerMoles. + /// + public static MolarMass? FromPoundsPerMoles(long? poundspermoles) + { + if (poundspermoles.HasValue) + { + return FromPoundsPerMoles(poundspermoles.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable MolarMass from PoundsPerMoles of type decimal. + /// + public static MolarMass? FromPoundsPerMoles(decimal? poundspermoles) + { + if (poundspermoles.HasValue) + { + return FromPoundsPerMoles(poundspermoles.Value); + } + else + { + return null; + } + } + +#endif + + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// MolarMass unit value. + public static MolarMass From(double val, MolarMassUnit fromUnit) + { + switch (fromUnit) + { + case MolarMassUnit.CentigramPerMole: + return FromCentigramsPerMoles(val); + case MolarMassUnit.DecagramPerMole: + return FromDecagramsPerMoles(val); + case MolarMassUnit.DecigramPerMole: + return FromDecigramsPerMoles(val); + case MolarMassUnit.GramPerMole: + return FromGramsPerMoles(val); + case MolarMassUnit.HectogramPerMole: + return FromHectogramsPerMoles(val); + case MolarMassUnit.KilogramPerMole: + return FromKilogramsPerMoles(val); + case MolarMassUnit.KilopoundPerMole: + return FromKilopoundsPerMoles(val); + case MolarMassUnit.MegapoundPerMole: + return FromMegapoundsPerMoles(val); + case MolarMassUnit.MicrogramPerMole: + return FromMicrogramsPerMoles(val); + case MolarMassUnit.MilligramPerMole: + return FromMilligramsPerMoles(val); + case MolarMassUnit.NanogramPerMole: + return FromNanogramsPerMoles(val); + case MolarMassUnit.PoundPerMole: + return FromPoundsPerMoles(val); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } + + // Windows Runtime Component does not support nullable types (double?): https://msdn.microsoft.com/en-us/library/br230301.aspx +#if !WINDOWS_UWP + /// + /// Dynamically convert from value and unit enum to . + /// + /// Value to convert from. + /// Unit to convert from. + /// MolarMass unit value. + public static MolarMass? From(double? value, MolarMassUnit fromUnit) + { + if (!value.HasValue) + { + return null; + } + switch (fromUnit) + { + case MolarMassUnit.CentigramPerMole: + return FromCentigramsPerMoles(value.Value); + case MolarMassUnit.DecagramPerMole: + return FromDecagramsPerMoles(value.Value); + case MolarMassUnit.DecigramPerMole: + return FromDecigramsPerMoles(value.Value); + case MolarMassUnit.GramPerMole: + return FromGramsPerMoles(value.Value); + case MolarMassUnit.HectogramPerMole: + return FromHectogramsPerMoles(value.Value); + case MolarMassUnit.KilogramPerMole: + return FromKilogramsPerMoles(value.Value); + case MolarMassUnit.KilopoundPerMole: + return FromKilopoundsPerMoles(value.Value); + case MolarMassUnit.MegapoundPerMole: + return FromMegapoundsPerMoles(value.Value); + case MolarMassUnit.MicrogramPerMole: + return FromMicrogramsPerMoles(value.Value); + case MolarMassUnit.MilligramPerMole: + return FromMilligramsPerMoles(value.Value); + case MolarMassUnit.NanogramPerMole: + return FromNanogramsPerMoles(value.Value); + case MolarMassUnit.PoundPerMole: + return FromPoundsPerMoles(value.Value); + + default: + throw new NotImplementedException("fromUnit: " + fromUnit); + } + } +#endif + + /// + /// Get unit abbreviation string. + /// + /// Unit to get abbreviation for. + /// Unit abbreviation string. + [UsedImplicitly] + public static string GetAbbreviation(MolarMassUnit unit) + { + return GetAbbreviation(unit, null); + } + + /// + /// Get unit abbreviation string. + /// + /// Unit to get abbreviation for. + /// Culture to use for localization. Defaults to Thread.CurrentUICulture. + /// Unit abbreviation string. + [UsedImplicitly] + public static string GetAbbreviation(MolarMassUnit unit, [CanBeNull] Culture culture) + { + return UnitSystem.GetCached(culture).GetDefaultAbbreviation(unit); + } + + #endregion + + #region Arithmetic Operators + + // Windows Runtime Component does not allow operator overloads: https://msdn.microsoft.com/en-us/library/br230301.aspx +#if !WINDOWS_UWP + public static MolarMass operator -(MolarMass right) + { + return new MolarMass(-right._kilogramsPerMoles); + } + + public static MolarMass operator +(MolarMass left, MolarMass right) + { + return new MolarMass(left._kilogramsPerMoles + right._kilogramsPerMoles); + } + + public static MolarMass operator -(MolarMass left, MolarMass right) + { + return new MolarMass(left._kilogramsPerMoles - right._kilogramsPerMoles); + } + + public static MolarMass operator *(double left, MolarMass right) + { + return new MolarMass(left*right._kilogramsPerMoles); + } + + public static MolarMass operator *(MolarMass left, double right) + { + return new MolarMass(left._kilogramsPerMoles*(double)right); + } + + public static MolarMass operator /(MolarMass left, double right) + { + return new MolarMass(left._kilogramsPerMoles/(double)right); + } + + public static double operator /(MolarMass left, MolarMass right) + { + return Convert.ToDouble(left._kilogramsPerMoles/right._kilogramsPerMoles); + } +#endif + + #endregion + + #region Equality / IComparable + + public int CompareTo(object obj) + { + if (obj == null) throw new ArgumentNullException("obj"); + if (!(obj is MolarMass)) throw new ArgumentException("Expected type MolarMass.", "obj"); + return CompareTo((MolarMass) obj); + } + + // 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 +#if WINDOWS_UWP + internal +#else + public +#endif + int CompareTo(MolarMass other) + { + return _kilogramsPerMoles.CompareTo(other._kilogramsPerMoles); + } + + // Windows Runtime Component does not allow operator overloads: https://msdn.microsoft.com/en-us/library/br230301.aspx +#if !WINDOWS_UWP + public static bool operator <=(MolarMass left, MolarMass right) + { + return left._kilogramsPerMoles <= right._kilogramsPerMoles; + } + + public static bool operator >=(MolarMass left, MolarMass right) + { + return left._kilogramsPerMoles >= right._kilogramsPerMoles; + } + + public static bool operator <(MolarMass left, MolarMass right) + { + return left._kilogramsPerMoles < right._kilogramsPerMoles; + } + + public static bool operator >(MolarMass left, MolarMass right) + { + return left._kilogramsPerMoles > right._kilogramsPerMoles; + } + + public static bool operator ==(MolarMass left, MolarMass right) + { + // ReSharper disable once CompareOfFloatsByEqualityOperator + return left._kilogramsPerMoles == right._kilogramsPerMoles; + } + + public static bool operator !=(MolarMass left, MolarMass right) + { + // ReSharper disable once CompareOfFloatsByEqualityOperator + return left._kilogramsPerMoles != right._kilogramsPerMoles; + } +#endif + + public override bool Equals(object obj) + { + if (obj == null || GetType() != obj.GetType()) + { + return false; + } + + return _kilogramsPerMoles.Equals(((MolarMass) obj)._kilogramsPerMoles); + } + + public override int GetHashCode() + { + return _kilogramsPerMoles.GetHashCode(); + } + + #endregion + + #region Conversion + + /// + /// Convert to the unit representation . + /// + /// Value in new unit if successful, exception otherwise. + /// If conversion was not successful. + public double As(MolarMassUnit unit) + { + switch (unit) + { + case MolarMassUnit.CentigramPerMole: + return CentigramsPerMoles; + case MolarMassUnit.DecagramPerMole: + return DecagramsPerMoles; + case MolarMassUnit.DecigramPerMole: + return DecigramsPerMoles; + case MolarMassUnit.GramPerMole: + return GramsPerMoles; + case MolarMassUnit.HectogramPerMole: + return HectogramsPerMoles; + case MolarMassUnit.KilogramPerMole: + return KilogramsPerMoles; + case MolarMassUnit.KilopoundPerMole: + return KilopoundsPerMoles; + case MolarMassUnit.MegapoundPerMole: + return MegapoundsPerMoles; + case MolarMassUnit.MicrogramPerMole: + return MicrogramsPerMoles; + case MolarMassUnit.MilligramPerMole: + return MilligramsPerMoles; + case MolarMassUnit.NanogramPerMole: + return NanogramsPerMoles; + case MolarMassUnit.PoundPerMole: + return PoundsPerMoles; + + default: + throw new NotImplementedException("unit: " + unit); + } + } + + #endregion + + #region Parsing + + /// + /// 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 MolarMass 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} + /// Format to use when parsing number and unit. If it is null, it defaults to for parsing the number and for parsing the unit abbreviation by culture/language. + /// + /// 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 MolarMass Parse(string str, [CanBeNull] Culture culture) + { + if (str == null) throw new ArgumentNullException("str"); + + // Windows Runtime Component does not support CultureInfo type, so use culture name string for public methods instead: https://msdn.microsoft.com/en-us/library/br230301.aspx +#if WINDOWS_UWP + IFormatProvider formatProvider = culture == null ? null : new CultureInfo(culture); +#else + IFormatProvider formatProvider = culture; +#endif + return QuantityParser.Parse(str, formatProvider, + delegate(string value, string unit, IFormatProvider formatProvider2) + { + double parsedValue = double.Parse(value, formatProvider2); + MolarMassUnit parsedUnit = ParseUnit(unit, formatProvider2); + return From(parsedValue, parsedUnit); + }, (x, y) => FromKilogramsPerMoles(x.KilogramsPerMoles + y.KilogramsPerMoles)); + } + + /// + /// 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 MolarMass 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} + /// Format to use when parsing number and unit. If it is null, it defaults to for parsing the number and for parsing the unit abbreviation by culture/language. + /// Resulting unit quantity if successful. + /// + /// Length.Parse("5.5 m", new CultureInfo("en-US")); + /// + public static bool TryParse([CanBeNull] string str, [CanBeNull] Culture culture, out MolarMass result) + { + try + { + result = Parse(str, culture); + return true; + } + catch + { + result = default(MolarMass); + return false; + } + } + + /// + /// Parse a unit string. + /// + /// + /// Length.ParseUnit("m", new CultureInfo("en-US")); + /// + /// The value of 'str' cannot be null. + /// Error parsing string. + public static MolarMassUnit ParseUnit(string str) + { + return ParseUnit(str, (IFormatProvider)null); + } + + /// + /// Parse a unit string. + /// + /// + /// Length.ParseUnit("m", new CultureInfo("en-US")); + /// + /// The value of 'str' cannot be null. + /// Error parsing string. + public static MolarMassUnit ParseUnit(string str, [CanBeNull] string cultureName) + { + return ParseUnit(str, cultureName == null ? null : new CultureInfo(cultureName)); + } + + /// + /// Parse a unit string. + /// + /// + /// Length.ParseUnit("m", new CultureInfo("en-US")); + /// + /// The value of 'str' cannot be null. + /// Error parsing string. + + // 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 +#if WINDOWS_UWP + internal +#else + public +#endif + static MolarMassUnit ParseUnit(string str, IFormatProvider formatProvider = null) + { + if (str == null) throw new ArgumentNullException("str"); + + var unitSystem = UnitSystem.GetCached(formatProvider); + var unit = unitSystem.Parse(str.Trim()); + + if (unit == MolarMassUnit.Undefined) + { + var newEx = new UnitsNetException("Error parsing string. The unit is not a recognized MolarMassUnit."); + newEx.Data["input"] = str; + newEx.Data["formatprovider"] = formatProvider?.ToString() ?? "(null)"; + throw newEx; + } + + return unit; + } + + #endregion + + /// + /// Set the default unit used by ToString(). Default is KilogramPerMole + /// + public static MolarMassUnit ToStringDefaultUnit { get; set; } = MolarMassUnit.KilogramPerMole; + + /// + /// Get default string representation of value and unit. + /// + /// String representation. + public override string ToString() + { + return ToString(ToStringDefaultUnit); + } + + /// + /// Get string representation of value and unit. Using current UI culture and two significant digits after radix. + /// + /// Unit representation to use. + /// String representation. + public string ToString(MolarMassUnit unit) + { + return ToString(unit, null, 2); + } + + /// + /// Get string representation of value and unit. Using two significant digits after radix. + /// + /// Unit representation to use. + /// Culture to use for localization and number formatting. + /// String representation. + public string ToString(MolarMassUnit unit, [CanBeNull] Culture culture) + { + return ToString(unit, culture, 2); + } + + /// + /// Get string representation of value and unit. + /// + /// Unit representation to use. + /// Culture to use for localization and number formatting. + /// The number of significant digits after the radix point. + /// String representation. + [UsedImplicitly] + public string ToString(MolarMassUnit unit, [CanBeNull] Culture culture, int significantDigitsAfterRadix) + { + double value = As(unit); + string format = UnitFormatter.GetFormat(value, significantDigitsAfterRadix); + return ToString(unit, culture, format); + } + + /// + /// Get string representation of value and unit. + /// + /// Culture to use for localization and number formatting. + /// Unit representation to use. + /// String format to use. Default: "{0:0.##} {1} for value and unit abbreviation respectively." + /// Arguments for string format. Value and unit are implictly included as arguments 0 and 1. + /// String representation. + [UsedImplicitly] + public string ToString(MolarMassUnit unit, [CanBeNull] Culture culture, [NotNull] string format, + [NotNull] params object[] args) + { + if (format == null) throw new ArgumentNullException(nameof(format)); + if (args == null) throw new ArgumentNullException(nameof(args)); + + // Windows Runtime Component does not support CultureInfo type, so use culture name string for public methods instead: https://msdn.microsoft.com/en-us/library/br230301.aspx +#if WINDOWS_UWP + IFormatProvider formatProvider = culture == null ? null : new CultureInfo(culture); +#else + IFormatProvider formatProvider = culture; +#endif + double value = As(unit); + object[] formatArgs = UnitFormatter.GetFormatArgs(unit, value, formatProvider, args); + return string.Format(formatProvider, format, formatArgs); + } + + /// + /// Represents the largest possible value of MolarMass + /// + public static MolarMass MaxValue + { + get + { + return new MolarMass(double.MaxValue); + } + } + + /// + /// Represents the smallest possible value of MolarMass + /// + public static MolarMass MinValue + { + get + { + return new MolarMass(double.MinValue); + } + } + } +} diff --git a/UnitsNet/GeneratedCode/QuantityType.g.cs b/UnitsNet/GeneratedCode/QuantityType.g.cs index 753bf3bf6b..83b20ab126 100644 --- a/UnitsNet/GeneratedCode/QuantityType.g.cs +++ b/UnitsNet/GeneratedCode/QuantityType.g.cs @@ -79,6 +79,7 @@ public enum QuantityType MassFlow, MassMomentOfInertia, Molarity, + MolarMass, Power, PowerRatio, Pressure, diff --git a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs index 9582a43b3a..d75c000f35 100644 --- a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs +++ b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs @@ -1923,6 +1923,82 @@ private static readonly ReadOnlyCollection DefaultLocalization new AbbreviationsForCulture("en-US", "pmol/L"), }), }), + new UnitLocalization(typeof (MolarMassUnit), + new[] + { + new CulturesForEnumValue((int) MolarMassUnit.CentigramPerMole, + new[] + { + new AbbreviationsForCulture("en-US", "cg/mol"), + new AbbreviationsForCulture("ru-RU", "сг/моль"), + }), + new CulturesForEnumValue((int) MolarMassUnit.DecagramPerMole, + new[] + { + new AbbreviationsForCulture("en-US", "dag/mol"), + new AbbreviationsForCulture("ru-RU", "даг/моль"), + }), + new CulturesForEnumValue((int) MolarMassUnit.DecigramPerMole, + new[] + { + new AbbreviationsForCulture("en-US", "dg/mol"), + new AbbreviationsForCulture("ru-RU", "дг/моль"), + }), + new CulturesForEnumValue((int) MolarMassUnit.GramPerMole, + new[] + { + new AbbreviationsForCulture("en-US", "g/mol"), + new AbbreviationsForCulture("ru-RU", "г/моль"), + }), + new CulturesForEnumValue((int) MolarMassUnit.HectogramPerMole, + new[] + { + new AbbreviationsForCulture("en-US", "hg/mol"), + new AbbreviationsForCulture("ru-RU", "гг/моль"), + }), + new CulturesForEnumValue((int) MolarMassUnit.KilogramPerMole, + new[] + { + new AbbreviationsForCulture("en-US", "kg/mol"), + new AbbreviationsForCulture("ru-RU", "кг/моль"), + }), + new CulturesForEnumValue((int) MolarMassUnit.KilopoundPerMole, + new[] + { + new AbbreviationsForCulture("en-US", "KLbs/mol"), + new AbbreviationsForCulture("ru-RU", "kфунт/моль"), + }), + new CulturesForEnumValue((int) MolarMassUnit.MegapoundPerMole, + new[] + { + new AbbreviationsForCulture("en-US", "MLbs/mol"), + new AbbreviationsForCulture("ru-RU", "Mфунт/моль"), + }), + new CulturesForEnumValue((int) MolarMassUnit.MicrogramPerMole, + new[] + { + new AbbreviationsForCulture("en-US", "µg/mol"), + new AbbreviationsForCulture("ru-RU", "мкг/моль"), + }), + new CulturesForEnumValue((int) MolarMassUnit.MilligramPerMole, + new[] + { + new AbbreviationsForCulture("en-US", "mg/mol"), + new AbbreviationsForCulture("ru-RU", "мг/моль"), + }), + new CulturesForEnumValue((int) MolarMassUnit.NanogramPerMole, + new[] + { + new AbbreviationsForCulture("en-US", "ng/mol"), + new AbbreviationsForCulture("ru-RU", "нг/моль"), + }), + new CulturesForEnumValue((int) MolarMassUnit.PoundPerMole, + new[] + { + new AbbreviationsForCulture("en-US", "lb/mol"), + new AbbreviationsForCulture("ru-RU", "фунт/моль"), + }), + }), new UnitLocalization(typeof (PowerUnit), new[] { diff --git a/UnitsNet/GeneratedCode/Units/MolarMassUnit.g.cs b/UnitsNet/GeneratedCode/Units/MolarMassUnit.g.cs new file mode 100644 index 0000000000..7d0bf7645a --- /dev/null +++ b/UnitsNet/GeneratedCode/Units/MolarMassUnit.g.cs @@ -0,0 +1,58 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by \generate-code.bat. +// +// Changes to this file will be lost when the code is regenerated. +// The build server regenerates the code before each build and a pre-build +// step will regenerate the code on each local build. +// +// See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units. +// +// Add CustomCode\Quantities\MyUnit.extra.cs files to add code to generated quantities. +// Add Extensions\MyUnitExtensions.cs to decorate quantities with new behavior. +// Add UnitDefinitions\MyUnit.json and run GeneratUnits.bat to generate new units or quantities. +// +// +//------------------------------------------------------------------------------ + +// Copyright (c) 2007 Andreas Gullberg Larsen (angularsen@gmail.com). +// https://github.com/angularsen/UnitsNet +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +// ReSharper disable once CheckNamespace +namespace UnitsNet.Units +{ + public enum MolarMassUnit + { + Undefined = 0, + CentigramPerMole, + DecagramPerMole, + DecigramPerMole, + GramPerMole, + HectogramPerMole, + KilogramPerMole, + KilopoundPerMole, + MegapoundPerMole, + MicrogramPerMole, + MilligramPerMole, + NanogramPerMole, + PoundPerMole, + } +} From e9c3895bbfa5b23ea4d68bbc718f400ce8a75c7d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ferit=20Tun=C3=A7er?= Date: Fri, 27 Oct 2017 19:36:22 +0300 Subject: [PATCH 4/8] tests implemented NanogramPerMole to KilogramPerMole convertion tests were failing, so we set the tolerance to 1e-3 like in massTests --- UnitsNet.Tests/CustomCode/MolarMassTests.cs | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/UnitsNet.Tests/CustomCode/MolarMassTests.cs b/UnitsNet.Tests/CustomCode/MolarMassTests.cs index 804c43b391..f59694a938 100644 --- a/UnitsNet.Tests/CustomCode/MolarMassTests.cs +++ b/UnitsNet.Tests/CustomCode/MolarMassTests.cs @@ -46,6 +46,18 @@ namespace UnitsNet.Tests.CustomCode { public class MolarMassTests : MolarMassTestsBase { - // TODO Override properties in base class here + protected override double CentigramsPerMolesInOneKilogramPerMole => 1e5; + protected override double DecagramsPerMolesInOneKilogramPerMole => 1e2; + protected override double DecigramsPerMolesInOneKilogramPerMole => 1e4; + protected override double GramsPerMolesInOneKilogramPerMole => 1e3; + protected override double HectogramsPerMolesInOneKilogramPerMole => 10; + protected override double KilogramsPerMolesInOneKilogramPerMole => 1; + protected override double KilopoundsPerMolesInOneKilogramPerMole => 2.2046226218487757e-3; + protected override double MegapoundsPerMolesInOneKilogramPerMole => 2.2046226218487757e-6; + protected override double MicrogramsPerMolesInOneKilogramPerMole => 1e9; + protected override double MilligramsPerMolesInOneKilogramPerMole => 1e6; + protected override double NanogramsPerMolesTolerance => 1E-3; + protected override double NanogramsPerMolesInOneKilogramPerMole => 1e12; + protected override double PoundsPerMolesInOneKilogramPerMole => 2.2046226218487757; } } From ff15f3db8380b089a19c40dcea7894d5a920542f Mon Sep 17 00:00:00 2001 From: Andreas Gullberg Larsen Date: Fri, 27 Oct 2017 19:36:16 +0200 Subject: [PATCH 5/8] Fixed lowercase exponential `e` --- UnitsNet.Tests/CustomCode/MolarMassTests.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/UnitsNet.Tests/CustomCode/MolarMassTests.cs b/UnitsNet.Tests/CustomCode/MolarMassTests.cs index f59694a938..29dac3a844 100644 --- a/UnitsNet.Tests/CustomCode/MolarMassTests.cs +++ b/UnitsNet.Tests/CustomCode/MolarMassTests.cs @@ -56,7 +56,7 @@ public class MolarMassTests : MolarMassTestsBase protected override double MegapoundsPerMolesInOneKilogramPerMole => 2.2046226218487757e-6; protected override double MicrogramsPerMolesInOneKilogramPerMole => 1e9; protected override double MilligramsPerMolesInOneKilogramPerMole => 1e6; - protected override double NanogramsPerMolesTolerance => 1E-3; + protected override double NanogramsPerMolesTolerance => 1e-3; protected override double NanogramsPerMolesInOneKilogramPerMole => 1e12; protected override double PoundsPerMolesInOneKilogramPerMole => 2.2046226218487757; } From 42624d1d07afcb26336f24915f98f33d8c2b4264 Mon Sep 17 00:00:00 2001 From: Andreas Gullberg Larsen Date: Fri, 27 Oct 2017 19:39:15 +0200 Subject: [PATCH 6/8] Fix plural form --- UnitsNet/UnitDefinitions/MolarMass.json | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/UnitsNet/UnitDefinitions/MolarMass.json b/UnitsNet/UnitDefinitions/MolarMass.json index b71f298f7d..647ee5a734 100644 --- a/UnitsNet/UnitDefinitions/MolarMass.json +++ b/UnitsNet/UnitDefinitions/MolarMass.json @@ -5,7 +5,7 @@ "Units": [ { "SingularName": "GramPerMole", - "PluralName": "GramsPerMoles", + "PluralName": "GramsPerMole", "FromUnitToBaseFunc": "x/1e3", "FromBaseToUnitFunc": "x*1e3", "Prefixes": [ "Nano", "Micro", "Milli", "Centi", "Deci", "Deca", "Hecto", "Kilo" ], @@ -23,7 +23,7 @@ }, { "SingularName": "PoundPerMole", - "PluralName": "PoundsPerMoles", + "PluralName": "PoundsPerMole", "FromUnitToBaseFunc": "x*0.45359237", "FromBaseToUnitFunc": "x/0.45359237", "Prefixes": [ "Kilo", "Mega" ], @@ -40,4 +40,4 @@ ] } ] -} \ No newline at end of file +} From 7e3da11b43a9939eb332baf12c5270846063c68a Mon Sep 17 00:00:00 2001 From: Andreas Gullberg Larsen Date: Fri, 27 Oct 2017 19:43:55 +0200 Subject: [PATCH 7/8] Remove plural form of English abbreviations --- UnitsNet/UnitDefinitions/MolarMass.json | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/UnitsNet/UnitDefinitions/MolarMass.json b/UnitsNet/UnitDefinitions/MolarMass.json index 647ee5a734..03674da0f2 100644 --- a/UnitsNet/UnitDefinitions/MolarMass.json +++ b/UnitsNet/UnitDefinitions/MolarMass.json @@ -30,8 +30,7 @@ "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "lb/mol" ], - "AbbreviationsWithPrefixes": [ "KLbs/mol", "MLbs/mol" ] + "Abbreviations": [ "lb/mol" ] }, { "Culture": "ru-RU", From c679d36df090ee27ff7d34ec14ef8105ed6d78e9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ferit=20Tun=C3=A7er?= Date: Mon, 6 Nov 2017 14:24:01 +0300 Subject: [PATCH 8/8] run generate-code.bat - fixed test names --- UnitsNet.Tests/CustomCode/MolarMassTests.cs | 26 +- .../GeneratedCode/MolarMassTestsBase.g.cs | 208 ++--- .../Number/NumberToMolarMassExtensions.g.cs | 480 +++++----- .../GeneratedCode/Quantities/MolarMass.g.cs | 864 +++++++++--------- .../GeneratedCode/UnitSystem.Default.g.cs | 4 +- 5 files changed, 791 insertions(+), 791 deletions(-) diff --git a/UnitsNet.Tests/CustomCode/MolarMassTests.cs b/UnitsNet.Tests/CustomCode/MolarMassTests.cs index 29dac3a844..2d7f772681 100644 --- a/UnitsNet.Tests/CustomCode/MolarMassTests.cs +++ b/UnitsNet.Tests/CustomCode/MolarMassTests.cs @@ -46,18 +46,18 @@ namespace UnitsNet.Tests.CustomCode { public class MolarMassTests : MolarMassTestsBase { - protected override double CentigramsPerMolesInOneKilogramPerMole => 1e5; - protected override double DecagramsPerMolesInOneKilogramPerMole => 1e2; - protected override double DecigramsPerMolesInOneKilogramPerMole => 1e4; - protected override double GramsPerMolesInOneKilogramPerMole => 1e3; - protected override double HectogramsPerMolesInOneKilogramPerMole => 10; - protected override double KilogramsPerMolesInOneKilogramPerMole => 1; - protected override double KilopoundsPerMolesInOneKilogramPerMole => 2.2046226218487757e-3; - protected override double MegapoundsPerMolesInOneKilogramPerMole => 2.2046226218487757e-6; - protected override double MicrogramsPerMolesInOneKilogramPerMole => 1e9; - protected override double MilligramsPerMolesInOneKilogramPerMole => 1e6; - protected override double NanogramsPerMolesTolerance => 1e-3; - protected override double NanogramsPerMolesInOneKilogramPerMole => 1e12; - protected override double PoundsPerMolesInOneKilogramPerMole => 2.2046226218487757; + protected override double CentigramsPerMoleInOneKilogramPerMole => 1e5; + protected override double DecagramsPerMoleInOneKilogramPerMole => 1e2; + protected override double DecigramsPerMoleInOneKilogramPerMole => 1e4; + protected override double GramsPerMoleInOneKilogramPerMole => 1e3; + protected override double HectogramsPerMoleInOneKilogramPerMole => 10; + protected override double KilogramsPerMoleInOneKilogramPerMole => 1; + protected override double KilopoundsPerMoleInOneKilogramPerMole => 2.2046226218487757e-3; + protected override double MegapoundsPerMoleInOneKilogramPerMole => 2.2046226218487757e-6; + protected override double MicrogramsPerMoleInOneKilogramPerMole => 1e9; + protected override double MilligramsPerMoleInOneKilogramPerMole => 1e6; + protected override double NanogramsPerMoleTolerance => 1e-3; + protected override double NanogramsPerMoleInOneKilogramPerMole => 1e12; + protected override double PoundsPerMoleInOneKilogramPerMole => 2.2046226218487757; } } diff --git a/UnitsNet.Tests/GeneratedCode/MolarMassTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MolarMassTestsBase.g.cs index c03de84a87..562233904f 100644 --- a/UnitsNet.Tests/GeneratedCode/MolarMassTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/MolarMassTestsBase.g.cs @@ -52,139 +52,139 @@ namespace UnitsNet.Tests // ReSharper disable once PartialTypeWithSinglePart public abstract partial class MolarMassTestsBase { - protected abstract double CentigramsPerMolesInOneKilogramPerMole { get; } - protected abstract double DecagramsPerMolesInOneKilogramPerMole { get; } - protected abstract double DecigramsPerMolesInOneKilogramPerMole { get; } - protected abstract double GramsPerMolesInOneKilogramPerMole { get; } - protected abstract double HectogramsPerMolesInOneKilogramPerMole { get; } - protected abstract double KilogramsPerMolesInOneKilogramPerMole { get; } - protected abstract double KilopoundsPerMolesInOneKilogramPerMole { get; } - protected abstract double MegapoundsPerMolesInOneKilogramPerMole { get; } - protected abstract double MicrogramsPerMolesInOneKilogramPerMole { get; } - protected abstract double MilligramsPerMolesInOneKilogramPerMole { get; } - protected abstract double NanogramsPerMolesInOneKilogramPerMole { get; } - protected abstract double PoundsPerMolesInOneKilogramPerMole { get; } + protected abstract double CentigramsPerMoleInOneKilogramPerMole { get; } + protected abstract double DecagramsPerMoleInOneKilogramPerMole { get; } + protected abstract double DecigramsPerMoleInOneKilogramPerMole { get; } + protected abstract double GramsPerMoleInOneKilogramPerMole { get; } + protected abstract double HectogramsPerMoleInOneKilogramPerMole { get; } + protected abstract double KilogramsPerMoleInOneKilogramPerMole { get; } + protected abstract double KilopoundsPerMoleInOneKilogramPerMole { get; } + protected abstract double MegapoundsPerMoleInOneKilogramPerMole { get; } + protected abstract double MicrogramsPerMoleInOneKilogramPerMole { get; } + protected abstract double MilligramsPerMoleInOneKilogramPerMole { get; } + protected abstract double NanogramsPerMoleInOneKilogramPerMole { get; } + protected abstract double PoundsPerMoleInOneKilogramPerMole { get; } // ReSharper disable VirtualMemberNeverOverriden.Global - protected virtual double CentigramsPerMolesTolerance { get { return 1e-5; } } - protected virtual double DecagramsPerMolesTolerance { get { return 1e-5; } } - protected virtual double DecigramsPerMolesTolerance { get { return 1e-5; } } - protected virtual double GramsPerMolesTolerance { get { return 1e-5; } } - protected virtual double HectogramsPerMolesTolerance { get { return 1e-5; } } - protected virtual double KilogramsPerMolesTolerance { get { return 1e-5; } } - protected virtual double KilopoundsPerMolesTolerance { get { return 1e-5; } } - protected virtual double MegapoundsPerMolesTolerance { get { return 1e-5; } } - protected virtual double MicrogramsPerMolesTolerance { get { return 1e-5; } } - protected virtual double MilligramsPerMolesTolerance { get { return 1e-5; } } - protected virtual double NanogramsPerMolesTolerance { get { return 1e-5; } } - protected virtual double PoundsPerMolesTolerance { get { return 1e-5; } } + protected virtual double CentigramsPerMoleTolerance { get { return 1e-5; } } + protected virtual double DecagramsPerMoleTolerance { get { return 1e-5; } } + protected virtual double DecigramsPerMoleTolerance { get { return 1e-5; } } + protected virtual double GramsPerMoleTolerance { get { return 1e-5; } } + protected virtual double HectogramsPerMoleTolerance { get { return 1e-5; } } + protected virtual double KilogramsPerMoleTolerance { get { return 1e-5; } } + protected virtual double KilopoundsPerMoleTolerance { get { return 1e-5; } } + protected virtual double MegapoundsPerMoleTolerance { get { return 1e-5; } } + protected virtual double MicrogramsPerMoleTolerance { get { return 1e-5; } } + protected virtual double MilligramsPerMoleTolerance { get { return 1e-5; } } + protected virtual double NanogramsPerMoleTolerance { get { return 1e-5; } } + protected virtual double PoundsPerMoleTolerance { get { return 1e-5; } } // ReSharper restore VirtualMemberNeverOverriden.Global [Fact] public void KilogramPerMoleToMolarMassUnits() { - MolarMass kilogrampermole = MolarMass.FromKilogramsPerMoles(1); - AssertEx.EqualTolerance(CentigramsPerMolesInOneKilogramPerMole, kilogrampermole.CentigramsPerMoles, CentigramsPerMolesTolerance); - AssertEx.EqualTolerance(DecagramsPerMolesInOneKilogramPerMole, kilogrampermole.DecagramsPerMoles, DecagramsPerMolesTolerance); - AssertEx.EqualTolerance(DecigramsPerMolesInOneKilogramPerMole, kilogrampermole.DecigramsPerMoles, DecigramsPerMolesTolerance); - AssertEx.EqualTolerance(GramsPerMolesInOneKilogramPerMole, kilogrampermole.GramsPerMoles, GramsPerMolesTolerance); - AssertEx.EqualTolerance(HectogramsPerMolesInOneKilogramPerMole, kilogrampermole.HectogramsPerMoles, HectogramsPerMolesTolerance); - AssertEx.EqualTolerance(KilogramsPerMolesInOneKilogramPerMole, kilogrampermole.KilogramsPerMoles, KilogramsPerMolesTolerance); - AssertEx.EqualTolerance(KilopoundsPerMolesInOneKilogramPerMole, kilogrampermole.KilopoundsPerMoles, KilopoundsPerMolesTolerance); - AssertEx.EqualTolerance(MegapoundsPerMolesInOneKilogramPerMole, kilogrampermole.MegapoundsPerMoles, MegapoundsPerMolesTolerance); - AssertEx.EqualTolerance(MicrogramsPerMolesInOneKilogramPerMole, kilogrampermole.MicrogramsPerMoles, MicrogramsPerMolesTolerance); - AssertEx.EqualTolerance(MilligramsPerMolesInOneKilogramPerMole, kilogrampermole.MilligramsPerMoles, MilligramsPerMolesTolerance); - AssertEx.EqualTolerance(NanogramsPerMolesInOneKilogramPerMole, kilogrampermole.NanogramsPerMoles, NanogramsPerMolesTolerance); - AssertEx.EqualTolerance(PoundsPerMolesInOneKilogramPerMole, kilogrampermole.PoundsPerMoles, PoundsPerMolesTolerance); + MolarMass kilogrampermole = MolarMass.FromKilogramsPerMole(1); + AssertEx.EqualTolerance(CentigramsPerMoleInOneKilogramPerMole, kilogrampermole.CentigramsPerMole, CentigramsPerMoleTolerance); + AssertEx.EqualTolerance(DecagramsPerMoleInOneKilogramPerMole, kilogrampermole.DecagramsPerMole, DecagramsPerMoleTolerance); + AssertEx.EqualTolerance(DecigramsPerMoleInOneKilogramPerMole, kilogrampermole.DecigramsPerMole, DecigramsPerMoleTolerance); + AssertEx.EqualTolerance(GramsPerMoleInOneKilogramPerMole, kilogrampermole.GramsPerMole, GramsPerMoleTolerance); + AssertEx.EqualTolerance(HectogramsPerMoleInOneKilogramPerMole, kilogrampermole.HectogramsPerMole, HectogramsPerMoleTolerance); + AssertEx.EqualTolerance(KilogramsPerMoleInOneKilogramPerMole, kilogrampermole.KilogramsPerMole, KilogramsPerMoleTolerance); + AssertEx.EqualTolerance(KilopoundsPerMoleInOneKilogramPerMole, kilogrampermole.KilopoundsPerMole, KilopoundsPerMoleTolerance); + AssertEx.EqualTolerance(MegapoundsPerMoleInOneKilogramPerMole, kilogrampermole.MegapoundsPerMole, MegapoundsPerMoleTolerance); + AssertEx.EqualTolerance(MicrogramsPerMoleInOneKilogramPerMole, kilogrampermole.MicrogramsPerMole, MicrogramsPerMoleTolerance); + AssertEx.EqualTolerance(MilligramsPerMoleInOneKilogramPerMole, kilogrampermole.MilligramsPerMole, MilligramsPerMoleTolerance); + AssertEx.EqualTolerance(NanogramsPerMoleInOneKilogramPerMole, kilogrampermole.NanogramsPerMole, NanogramsPerMoleTolerance); + AssertEx.EqualTolerance(PoundsPerMoleInOneKilogramPerMole, kilogrampermole.PoundsPerMole, PoundsPerMoleTolerance); } [Fact] public void FromValueAndUnit() { - AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.CentigramPerMole).CentigramsPerMoles, CentigramsPerMolesTolerance); - AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.DecagramPerMole).DecagramsPerMoles, DecagramsPerMolesTolerance); - AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.DecigramPerMole).DecigramsPerMoles, DecigramsPerMolesTolerance); - AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.GramPerMole).GramsPerMoles, GramsPerMolesTolerance); - AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.HectogramPerMole).HectogramsPerMoles, HectogramsPerMolesTolerance); - AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.KilogramPerMole).KilogramsPerMoles, KilogramsPerMolesTolerance); - AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.KilopoundPerMole).KilopoundsPerMoles, KilopoundsPerMolesTolerance); - AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.MegapoundPerMole).MegapoundsPerMoles, MegapoundsPerMolesTolerance); - AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.MicrogramPerMole).MicrogramsPerMoles, MicrogramsPerMolesTolerance); - AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.MilligramPerMole).MilligramsPerMoles, MilligramsPerMolesTolerance); - AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.NanogramPerMole).NanogramsPerMoles, NanogramsPerMolesTolerance); - AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.PoundPerMole).PoundsPerMoles, PoundsPerMolesTolerance); + AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.CentigramPerMole).CentigramsPerMole, CentigramsPerMoleTolerance); + AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.DecagramPerMole).DecagramsPerMole, DecagramsPerMoleTolerance); + AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.DecigramPerMole).DecigramsPerMole, DecigramsPerMoleTolerance); + AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.GramPerMole).GramsPerMole, GramsPerMoleTolerance); + AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.HectogramPerMole).HectogramsPerMole, HectogramsPerMoleTolerance); + AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.KilogramPerMole).KilogramsPerMole, KilogramsPerMoleTolerance); + AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.KilopoundPerMole).KilopoundsPerMole, KilopoundsPerMoleTolerance); + AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.MegapoundPerMole).MegapoundsPerMole, MegapoundsPerMoleTolerance); + AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.MicrogramPerMole).MicrogramsPerMole, MicrogramsPerMoleTolerance); + AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.MilligramPerMole).MilligramsPerMole, MilligramsPerMoleTolerance); + AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.NanogramPerMole).NanogramsPerMole, NanogramsPerMoleTolerance); + AssertEx.EqualTolerance(1, MolarMass.From(1, MolarMassUnit.PoundPerMole).PoundsPerMole, PoundsPerMoleTolerance); } [Fact] public void As() { - var kilogrampermole = MolarMass.FromKilogramsPerMoles(1); - AssertEx.EqualTolerance(CentigramsPerMolesInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.CentigramPerMole), CentigramsPerMolesTolerance); - AssertEx.EqualTolerance(DecagramsPerMolesInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.DecagramPerMole), DecagramsPerMolesTolerance); - AssertEx.EqualTolerance(DecigramsPerMolesInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.DecigramPerMole), DecigramsPerMolesTolerance); - AssertEx.EqualTolerance(GramsPerMolesInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.GramPerMole), GramsPerMolesTolerance); - AssertEx.EqualTolerance(HectogramsPerMolesInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.HectogramPerMole), HectogramsPerMolesTolerance); - AssertEx.EqualTolerance(KilogramsPerMolesInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.KilogramPerMole), KilogramsPerMolesTolerance); - AssertEx.EqualTolerance(KilopoundsPerMolesInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.KilopoundPerMole), KilopoundsPerMolesTolerance); - AssertEx.EqualTolerance(MegapoundsPerMolesInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.MegapoundPerMole), MegapoundsPerMolesTolerance); - AssertEx.EqualTolerance(MicrogramsPerMolesInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.MicrogramPerMole), MicrogramsPerMolesTolerance); - AssertEx.EqualTolerance(MilligramsPerMolesInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.MilligramPerMole), MilligramsPerMolesTolerance); - AssertEx.EqualTolerance(NanogramsPerMolesInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.NanogramPerMole), NanogramsPerMolesTolerance); - AssertEx.EqualTolerance(PoundsPerMolesInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.PoundPerMole), PoundsPerMolesTolerance); + var kilogrampermole = MolarMass.FromKilogramsPerMole(1); + AssertEx.EqualTolerance(CentigramsPerMoleInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.CentigramPerMole), CentigramsPerMoleTolerance); + AssertEx.EqualTolerance(DecagramsPerMoleInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.DecagramPerMole), DecagramsPerMoleTolerance); + AssertEx.EqualTolerance(DecigramsPerMoleInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.DecigramPerMole), DecigramsPerMoleTolerance); + AssertEx.EqualTolerance(GramsPerMoleInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.GramPerMole), GramsPerMoleTolerance); + AssertEx.EqualTolerance(HectogramsPerMoleInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.HectogramPerMole), HectogramsPerMoleTolerance); + AssertEx.EqualTolerance(KilogramsPerMoleInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.KilogramPerMole), KilogramsPerMoleTolerance); + AssertEx.EqualTolerance(KilopoundsPerMoleInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.KilopoundPerMole), KilopoundsPerMoleTolerance); + AssertEx.EqualTolerance(MegapoundsPerMoleInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.MegapoundPerMole), MegapoundsPerMoleTolerance); + AssertEx.EqualTolerance(MicrogramsPerMoleInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.MicrogramPerMole), MicrogramsPerMoleTolerance); + AssertEx.EqualTolerance(MilligramsPerMoleInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.MilligramPerMole), MilligramsPerMoleTolerance); + AssertEx.EqualTolerance(NanogramsPerMoleInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.NanogramPerMole), NanogramsPerMoleTolerance); + AssertEx.EqualTolerance(PoundsPerMoleInOneKilogramPerMole, kilogrampermole.As(MolarMassUnit.PoundPerMole), PoundsPerMoleTolerance); } [Fact] public void ConversionRoundTrip() { - MolarMass kilogrampermole = MolarMass.FromKilogramsPerMoles(1); - AssertEx.EqualTolerance(1, MolarMass.FromCentigramsPerMoles(kilogrampermole.CentigramsPerMoles).KilogramsPerMoles, CentigramsPerMolesTolerance); - AssertEx.EqualTolerance(1, MolarMass.FromDecagramsPerMoles(kilogrampermole.DecagramsPerMoles).KilogramsPerMoles, DecagramsPerMolesTolerance); - AssertEx.EqualTolerance(1, MolarMass.FromDecigramsPerMoles(kilogrampermole.DecigramsPerMoles).KilogramsPerMoles, DecigramsPerMolesTolerance); - AssertEx.EqualTolerance(1, MolarMass.FromGramsPerMoles(kilogrampermole.GramsPerMoles).KilogramsPerMoles, GramsPerMolesTolerance); - AssertEx.EqualTolerance(1, MolarMass.FromHectogramsPerMoles(kilogrampermole.HectogramsPerMoles).KilogramsPerMoles, HectogramsPerMolesTolerance); - AssertEx.EqualTolerance(1, MolarMass.FromKilogramsPerMoles(kilogrampermole.KilogramsPerMoles).KilogramsPerMoles, KilogramsPerMolesTolerance); - AssertEx.EqualTolerance(1, MolarMass.FromKilopoundsPerMoles(kilogrampermole.KilopoundsPerMoles).KilogramsPerMoles, KilopoundsPerMolesTolerance); - AssertEx.EqualTolerance(1, MolarMass.FromMegapoundsPerMoles(kilogrampermole.MegapoundsPerMoles).KilogramsPerMoles, MegapoundsPerMolesTolerance); - AssertEx.EqualTolerance(1, MolarMass.FromMicrogramsPerMoles(kilogrampermole.MicrogramsPerMoles).KilogramsPerMoles, MicrogramsPerMolesTolerance); - AssertEx.EqualTolerance(1, MolarMass.FromMilligramsPerMoles(kilogrampermole.MilligramsPerMoles).KilogramsPerMoles, MilligramsPerMolesTolerance); - AssertEx.EqualTolerance(1, MolarMass.FromNanogramsPerMoles(kilogrampermole.NanogramsPerMoles).KilogramsPerMoles, NanogramsPerMolesTolerance); - AssertEx.EqualTolerance(1, MolarMass.FromPoundsPerMoles(kilogrampermole.PoundsPerMoles).KilogramsPerMoles, PoundsPerMolesTolerance); + MolarMass kilogrampermole = MolarMass.FromKilogramsPerMole(1); + AssertEx.EqualTolerance(1, MolarMass.FromCentigramsPerMole(kilogrampermole.CentigramsPerMole).KilogramsPerMole, CentigramsPerMoleTolerance); + AssertEx.EqualTolerance(1, MolarMass.FromDecagramsPerMole(kilogrampermole.DecagramsPerMole).KilogramsPerMole, DecagramsPerMoleTolerance); + AssertEx.EqualTolerance(1, MolarMass.FromDecigramsPerMole(kilogrampermole.DecigramsPerMole).KilogramsPerMole, DecigramsPerMoleTolerance); + AssertEx.EqualTolerance(1, MolarMass.FromGramsPerMole(kilogrampermole.GramsPerMole).KilogramsPerMole, GramsPerMoleTolerance); + AssertEx.EqualTolerance(1, MolarMass.FromHectogramsPerMole(kilogrampermole.HectogramsPerMole).KilogramsPerMole, HectogramsPerMoleTolerance); + AssertEx.EqualTolerance(1, MolarMass.FromKilogramsPerMole(kilogrampermole.KilogramsPerMole).KilogramsPerMole, KilogramsPerMoleTolerance); + AssertEx.EqualTolerance(1, MolarMass.FromKilopoundsPerMole(kilogrampermole.KilopoundsPerMole).KilogramsPerMole, KilopoundsPerMoleTolerance); + AssertEx.EqualTolerance(1, MolarMass.FromMegapoundsPerMole(kilogrampermole.MegapoundsPerMole).KilogramsPerMole, MegapoundsPerMoleTolerance); + AssertEx.EqualTolerance(1, MolarMass.FromMicrogramsPerMole(kilogrampermole.MicrogramsPerMole).KilogramsPerMole, MicrogramsPerMoleTolerance); + AssertEx.EqualTolerance(1, MolarMass.FromMilligramsPerMole(kilogrampermole.MilligramsPerMole).KilogramsPerMole, MilligramsPerMoleTolerance); + AssertEx.EqualTolerance(1, MolarMass.FromNanogramsPerMole(kilogrampermole.NanogramsPerMole).KilogramsPerMole, NanogramsPerMoleTolerance); + AssertEx.EqualTolerance(1, MolarMass.FromPoundsPerMole(kilogrampermole.PoundsPerMole).KilogramsPerMole, PoundsPerMoleTolerance); } [Fact] public void ArithmeticOperators() { - MolarMass v = MolarMass.FromKilogramsPerMoles(1); - AssertEx.EqualTolerance(-1, -v.KilogramsPerMoles, KilogramsPerMolesTolerance); - AssertEx.EqualTolerance(2, (MolarMass.FromKilogramsPerMoles(3)-v).KilogramsPerMoles, KilogramsPerMolesTolerance); - AssertEx.EqualTolerance(2, (v + v).KilogramsPerMoles, KilogramsPerMolesTolerance); - AssertEx.EqualTolerance(10, (v*10).KilogramsPerMoles, KilogramsPerMolesTolerance); - AssertEx.EqualTolerance(10, (10*v).KilogramsPerMoles, KilogramsPerMolesTolerance); - AssertEx.EqualTolerance(2, (MolarMass.FromKilogramsPerMoles(10)/5).KilogramsPerMoles, KilogramsPerMolesTolerance); - AssertEx.EqualTolerance(2, MolarMass.FromKilogramsPerMoles(10)/MolarMass.FromKilogramsPerMoles(5), KilogramsPerMolesTolerance); + MolarMass v = MolarMass.FromKilogramsPerMole(1); + AssertEx.EqualTolerance(-1, -v.KilogramsPerMole, KilogramsPerMoleTolerance); + AssertEx.EqualTolerance(2, (MolarMass.FromKilogramsPerMole(3)-v).KilogramsPerMole, KilogramsPerMoleTolerance); + AssertEx.EqualTolerance(2, (v + v).KilogramsPerMole, KilogramsPerMoleTolerance); + AssertEx.EqualTolerance(10, (v*10).KilogramsPerMole, KilogramsPerMoleTolerance); + AssertEx.EqualTolerance(10, (10*v).KilogramsPerMole, KilogramsPerMoleTolerance); + AssertEx.EqualTolerance(2, (MolarMass.FromKilogramsPerMole(10)/5).KilogramsPerMole, KilogramsPerMoleTolerance); + AssertEx.EqualTolerance(2, MolarMass.FromKilogramsPerMole(10)/MolarMass.FromKilogramsPerMole(5), KilogramsPerMoleTolerance); } [Fact] public void ComparisonOperators() { - MolarMass oneKilogramPerMole = MolarMass.FromKilogramsPerMoles(1); - MolarMass twoKilogramsPerMoles = MolarMass.FromKilogramsPerMoles(2); - - Assert.True(oneKilogramPerMole < twoKilogramsPerMoles); - Assert.True(oneKilogramPerMole <= twoKilogramsPerMoles); - Assert.True(twoKilogramsPerMoles > oneKilogramPerMole); - Assert.True(twoKilogramsPerMoles >= oneKilogramPerMole); - - Assert.False(oneKilogramPerMole > twoKilogramsPerMoles); - Assert.False(oneKilogramPerMole >= twoKilogramsPerMoles); - Assert.False(twoKilogramsPerMoles < oneKilogramPerMole); - Assert.False(twoKilogramsPerMoles <= oneKilogramPerMole); + MolarMass oneKilogramPerMole = MolarMass.FromKilogramsPerMole(1); + MolarMass twoKilogramsPerMole = MolarMass.FromKilogramsPerMole(2); + + Assert.True(oneKilogramPerMole < twoKilogramsPerMole); + Assert.True(oneKilogramPerMole <= twoKilogramsPerMole); + Assert.True(twoKilogramsPerMole > oneKilogramPerMole); + Assert.True(twoKilogramsPerMole >= oneKilogramPerMole); + + Assert.False(oneKilogramPerMole > twoKilogramsPerMole); + Assert.False(oneKilogramPerMole >= twoKilogramsPerMole); + Assert.False(twoKilogramsPerMole < oneKilogramPerMole); + Assert.False(twoKilogramsPerMole <= oneKilogramPerMole); } [Fact] public void CompareToIsImplemented() { - MolarMass kilogrampermole = MolarMass.FromKilogramsPerMoles(1); + MolarMass kilogrampermole = MolarMass.FromKilogramsPerMole(1); Assert.Equal(0, kilogrampermole.CompareTo(kilogrampermole)); Assert.True(kilogrampermole.CompareTo(MolarMass.Zero) > 0); Assert.True(MolarMass.Zero.CompareTo(kilogrampermole) < 0); @@ -193,14 +193,14 @@ public void CompareToIsImplemented() [Fact] public void CompareToThrowsOnTypeMismatch() { - MolarMass kilogrampermole = MolarMass.FromKilogramsPerMoles(1); + MolarMass kilogrampermole = MolarMass.FromKilogramsPerMole(1); Assert.Throws(() => kilogrampermole.CompareTo(new object())); } [Fact] public void CompareToThrowsOnNull() { - MolarMass kilogrampermole = MolarMass.FromKilogramsPerMoles(1); + MolarMass kilogrampermole = MolarMass.FromKilogramsPerMole(1); Assert.Throws(() => kilogrampermole.CompareTo(null)); } @@ -208,8 +208,8 @@ public void CompareToThrowsOnNull() [Fact] public void EqualityOperators() { - MolarMass a = MolarMass.FromKilogramsPerMoles(1); - MolarMass b = MolarMass.FromKilogramsPerMoles(2); + MolarMass a = MolarMass.FromKilogramsPerMole(1); + MolarMass b = MolarMass.FromKilogramsPerMole(2); // ReSharper disable EqualExpressionComparison Assert.True(a == a); @@ -223,22 +223,22 @@ public void EqualityOperators() [Fact] public void EqualsIsImplemented() { - MolarMass v = MolarMass.FromKilogramsPerMoles(1); - Assert.True(v.Equals(MolarMass.FromKilogramsPerMoles(1))); + MolarMass v = MolarMass.FromKilogramsPerMole(1); + Assert.True(v.Equals(MolarMass.FromKilogramsPerMole(1))); Assert.False(v.Equals(MolarMass.Zero)); } [Fact] public void EqualsReturnsFalseOnTypeMismatch() { - MolarMass kilogrampermole = MolarMass.FromKilogramsPerMoles(1); + MolarMass kilogrampermole = MolarMass.FromKilogramsPerMole(1); Assert.False(kilogrampermole.Equals(new object())); } [Fact] public void EqualsReturnsFalseOnNull() { - MolarMass kilogrampermole = MolarMass.FromKilogramsPerMoles(1); + MolarMass kilogrampermole = MolarMass.FromKilogramsPerMole(1); Assert.False(kilogrampermole.Equals(null)); } } diff --git a/UnitsNet/GeneratedCode/Extensions/Number/NumberToMolarMassExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/Number/NumberToMolarMassExtensions.g.cs index bbe4326f0e..a4b7fd9ed4 100644 --- a/UnitsNet/GeneratedCode/Extensions/Number/NumberToMolarMassExtensions.g.cs +++ b/UnitsNet/GeneratedCode/Extensions/Number/NumberToMolarMassExtensions.g.cs @@ -46,409 +46,409 @@ public static class NumberToMolarMassExtensions { #region CentigramPerMole - /// - public static MolarMass CentigramsPerMoles(this int value) => MolarMass.FromCentigramsPerMoles(value); + /// + public static MolarMass CentigramsPerMole(this int value) => MolarMass.FromCentigramsPerMole(value); - /// - public static MolarMass? CentigramsPerMoles(this int? value) => MolarMass.FromCentigramsPerMoles(value); + /// + public static MolarMass? CentigramsPerMole(this int? value) => MolarMass.FromCentigramsPerMole(value); - /// - public static MolarMass CentigramsPerMoles(this long value) => MolarMass.FromCentigramsPerMoles(value); + /// + public static MolarMass CentigramsPerMole(this long value) => MolarMass.FromCentigramsPerMole(value); - /// - public static MolarMass? CentigramsPerMoles(this long? value) => MolarMass.FromCentigramsPerMoles(value); + /// + public static MolarMass? CentigramsPerMole(this long? value) => MolarMass.FromCentigramsPerMole(value); - /// - public static MolarMass CentigramsPerMoles(this double value) => MolarMass.FromCentigramsPerMoles(value); + /// + public static MolarMass CentigramsPerMole(this double value) => MolarMass.FromCentigramsPerMole(value); - /// - public static MolarMass? CentigramsPerMoles(this double? value) => MolarMass.FromCentigramsPerMoles(value); + /// + public static MolarMass? CentigramsPerMole(this double? value) => MolarMass.FromCentigramsPerMole(value); - /// - public static MolarMass CentigramsPerMoles(this float value) => MolarMass.FromCentigramsPerMoles(value); + /// + public static MolarMass CentigramsPerMole(this float value) => MolarMass.FromCentigramsPerMole(value); - /// - public static MolarMass? CentigramsPerMoles(this float? value) => MolarMass.FromCentigramsPerMoles(value); + /// + public static MolarMass? CentigramsPerMole(this float? value) => MolarMass.FromCentigramsPerMole(value); - /// - public static MolarMass CentigramsPerMoles(this decimal value) => MolarMass.FromCentigramsPerMoles(Convert.ToDouble(value)); + /// + public static MolarMass CentigramsPerMole(this decimal value) => MolarMass.FromCentigramsPerMole(Convert.ToDouble(value)); - /// - public static MolarMass? CentigramsPerMoles(this decimal? value) => MolarMass.FromCentigramsPerMoles(value == null ? (double?)null : Convert.ToDouble(value.Value)); + /// + public static MolarMass? CentigramsPerMole(this decimal? value) => MolarMass.FromCentigramsPerMole(value == null ? (double?)null : Convert.ToDouble(value.Value)); #endregion #region DecagramPerMole - /// - public static MolarMass DecagramsPerMoles(this int value) => MolarMass.FromDecagramsPerMoles(value); + /// + public static MolarMass DecagramsPerMole(this int value) => MolarMass.FromDecagramsPerMole(value); - /// - public static MolarMass? DecagramsPerMoles(this int? value) => MolarMass.FromDecagramsPerMoles(value); + /// + public static MolarMass? DecagramsPerMole(this int? value) => MolarMass.FromDecagramsPerMole(value); - /// - public static MolarMass DecagramsPerMoles(this long value) => MolarMass.FromDecagramsPerMoles(value); + /// + public static MolarMass DecagramsPerMole(this long value) => MolarMass.FromDecagramsPerMole(value); - /// - public static MolarMass? DecagramsPerMoles(this long? value) => MolarMass.FromDecagramsPerMoles(value); + /// + public static MolarMass? DecagramsPerMole(this long? value) => MolarMass.FromDecagramsPerMole(value); - /// - public static MolarMass DecagramsPerMoles(this double value) => MolarMass.FromDecagramsPerMoles(value); + /// + public static MolarMass DecagramsPerMole(this double value) => MolarMass.FromDecagramsPerMole(value); - /// - public static MolarMass? DecagramsPerMoles(this double? value) => MolarMass.FromDecagramsPerMoles(value); + /// + public static MolarMass? DecagramsPerMole(this double? value) => MolarMass.FromDecagramsPerMole(value); - /// - public static MolarMass DecagramsPerMoles(this float value) => MolarMass.FromDecagramsPerMoles(value); + /// + public static MolarMass DecagramsPerMole(this float value) => MolarMass.FromDecagramsPerMole(value); - /// - public static MolarMass? DecagramsPerMoles(this float? value) => MolarMass.FromDecagramsPerMoles(value); + /// + public static MolarMass? DecagramsPerMole(this float? value) => MolarMass.FromDecagramsPerMole(value); - /// - public static MolarMass DecagramsPerMoles(this decimal value) => MolarMass.FromDecagramsPerMoles(Convert.ToDouble(value)); + /// + public static MolarMass DecagramsPerMole(this decimal value) => MolarMass.FromDecagramsPerMole(Convert.ToDouble(value)); - /// - public static MolarMass? DecagramsPerMoles(this decimal? value) => MolarMass.FromDecagramsPerMoles(value == null ? (double?)null : Convert.ToDouble(value.Value)); + /// + public static MolarMass? DecagramsPerMole(this decimal? value) => MolarMass.FromDecagramsPerMole(value == null ? (double?)null : Convert.ToDouble(value.Value)); #endregion #region DecigramPerMole - /// - public static MolarMass DecigramsPerMoles(this int value) => MolarMass.FromDecigramsPerMoles(value); + /// + public static MolarMass DecigramsPerMole(this int value) => MolarMass.FromDecigramsPerMole(value); - /// - public static MolarMass? DecigramsPerMoles(this int? value) => MolarMass.FromDecigramsPerMoles(value); + /// + public static MolarMass? DecigramsPerMole(this int? value) => MolarMass.FromDecigramsPerMole(value); - /// - public static MolarMass DecigramsPerMoles(this long value) => MolarMass.FromDecigramsPerMoles(value); + /// + public static MolarMass DecigramsPerMole(this long value) => MolarMass.FromDecigramsPerMole(value); - /// - public static MolarMass? DecigramsPerMoles(this long? value) => MolarMass.FromDecigramsPerMoles(value); + /// + public static MolarMass? DecigramsPerMole(this long? value) => MolarMass.FromDecigramsPerMole(value); - /// - public static MolarMass DecigramsPerMoles(this double value) => MolarMass.FromDecigramsPerMoles(value); + /// + public static MolarMass DecigramsPerMole(this double value) => MolarMass.FromDecigramsPerMole(value); - /// - public static MolarMass? DecigramsPerMoles(this double? value) => MolarMass.FromDecigramsPerMoles(value); + /// + public static MolarMass? DecigramsPerMole(this double? value) => MolarMass.FromDecigramsPerMole(value); - /// - public static MolarMass DecigramsPerMoles(this float value) => MolarMass.FromDecigramsPerMoles(value); + /// + public static MolarMass DecigramsPerMole(this float value) => MolarMass.FromDecigramsPerMole(value); - /// - public static MolarMass? DecigramsPerMoles(this float? value) => MolarMass.FromDecigramsPerMoles(value); + /// + public static MolarMass? DecigramsPerMole(this float? value) => MolarMass.FromDecigramsPerMole(value); - /// - public static MolarMass DecigramsPerMoles(this decimal value) => MolarMass.FromDecigramsPerMoles(Convert.ToDouble(value)); + /// + public static MolarMass DecigramsPerMole(this decimal value) => MolarMass.FromDecigramsPerMole(Convert.ToDouble(value)); - /// - public static MolarMass? DecigramsPerMoles(this decimal? value) => MolarMass.FromDecigramsPerMoles(value == null ? (double?)null : Convert.ToDouble(value.Value)); + /// + public static MolarMass? DecigramsPerMole(this decimal? value) => MolarMass.FromDecigramsPerMole(value == null ? (double?)null : Convert.ToDouble(value.Value)); #endregion #region GramPerMole - /// - public static MolarMass GramsPerMoles(this int value) => MolarMass.FromGramsPerMoles(value); + /// + public static MolarMass GramsPerMole(this int value) => MolarMass.FromGramsPerMole(value); - /// - public static MolarMass? GramsPerMoles(this int? value) => MolarMass.FromGramsPerMoles(value); + /// + public static MolarMass? GramsPerMole(this int? value) => MolarMass.FromGramsPerMole(value); - /// - public static MolarMass GramsPerMoles(this long value) => MolarMass.FromGramsPerMoles(value); + /// + public static MolarMass GramsPerMole(this long value) => MolarMass.FromGramsPerMole(value); - /// - public static MolarMass? GramsPerMoles(this long? value) => MolarMass.FromGramsPerMoles(value); + /// + public static MolarMass? GramsPerMole(this long? value) => MolarMass.FromGramsPerMole(value); - /// - public static MolarMass GramsPerMoles(this double value) => MolarMass.FromGramsPerMoles(value); + /// + public static MolarMass GramsPerMole(this double value) => MolarMass.FromGramsPerMole(value); - /// - public static MolarMass? GramsPerMoles(this double? value) => MolarMass.FromGramsPerMoles(value); + /// + public static MolarMass? GramsPerMole(this double? value) => MolarMass.FromGramsPerMole(value); - /// - public static MolarMass GramsPerMoles(this float value) => MolarMass.FromGramsPerMoles(value); + /// + public static MolarMass GramsPerMole(this float value) => MolarMass.FromGramsPerMole(value); - /// - public static MolarMass? GramsPerMoles(this float? value) => MolarMass.FromGramsPerMoles(value); + /// + public static MolarMass? GramsPerMole(this float? value) => MolarMass.FromGramsPerMole(value); - /// - public static MolarMass GramsPerMoles(this decimal value) => MolarMass.FromGramsPerMoles(Convert.ToDouble(value)); + /// + public static MolarMass GramsPerMole(this decimal value) => MolarMass.FromGramsPerMole(Convert.ToDouble(value)); - /// - public static MolarMass? GramsPerMoles(this decimal? value) => MolarMass.FromGramsPerMoles(value == null ? (double?)null : Convert.ToDouble(value.Value)); + /// + public static MolarMass? GramsPerMole(this decimal? value) => MolarMass.FromGramsPerMole(value == null ? (double?)null : Convert.ToDouble(value.Value)); #endregion #region HectogramPerMole - /// - public static MolarMass HectogramsPerMoles(this int value) => MolarMass.FromHectogramsPerMoles(value); + /// + public static MolarMass HectogramsPerMole(this int value) => MolarMass.FromHectogramsPerMole(value); - /// - public static MolarMass? HectogramsPerMoles(this int? value) => MolarMass.FromHectogramsPerMoles(value); + /// + public static MolarMass? HectogramsPerMole(this int? value) => MolarMass.FromHectogramsPerMole(value); - /// - public static MolarMass HectogramsPerMoles(this long value) => MolarMass.FromHectogramsPerMoles(value); + /// + public static MolarMass HectogramsPerMole(this long value) => MolarMass.FromHectogramsPerMole(value); - /// - public static MolarMass? HectogramsPerMoles(this long? value) => MolarMass.FromHectogramsPerMoles(value); + /// + public static MolarMass? HectogramsPerMole(this long? value) => MolarMass.FromHectogramsPerMole(value); - /// - public static MolarMass HectogramsPerMoles(this double value) => MolarMass.FromHectogramsPerMoles(value); + /// + public static MolarMass HectogramsPerMole(this double value) => MolarMass.FromHectogramsPerMole(value); - /// - public static MolarMass? HectogramsPerMoles(this double? value) => MolarMass.FromHectogramsPerMoles(value); + /// + public static MolarMass? HectogramsPerMole(this double? value) => MolarMass.FromHectogramsPerMole(value); - /// - public static MolarMass HectogramsPerMoles(this float value) => MolarMass.FromHectogramsPerMoles(value); + /// + public static MolarMass HectogramsPerMole(this float value) => MolarMass.FromHectogramsPerMole(value); - /// - public static MolarMass? HectogramsPerMoles(this float? value) => MolarMass.FromHectogramsPerMoles(value); + /// + public static MolarMass? HectogramsPerMole(this float? value) => MolarMass.FromHectogramsPerMole(value); - /// - public static MolarMass HectogramsPerMoles(this decimal value) => MolarMass.FromHectogramsPerMoles(Convert.ToDouble(value)); + /// + public static MolarMass HectogramsPerMole(this decimal value) => MolarMass.FromHectogramsPerMole(Convert.ToDouble(value)); - /// - public static MolarMass? HectogramsPerMoles(this decimal? value) => MolarMass.FromHectogramsPerMoles(value == null ? (double?)null : Convert.ToDouble(value.Value)); + /// + public static MolarMass? HectogramsPerMole(this decimal? value) => MolarMass.FromHectogramsPerMole(value == null ? (double?)null : Convert.ToDouble(value.Value)); #endregion #region KilogramPerMole - /// - public static MolarMass KilogramsPerMoles(this int value) => MolarMass.FromKilogramsPerMoles(value); + /// + public static MolarMass KilogramsPerMole(this int value) => MolarMass.FromKilogramsPerMole(value); - /// - public static MolarMass? KilogramsPerMoles(this int? value) => MolarMass.FromKilogramsPerMoles(value); + /// + public static MolarMass? KilogramsPerMole(this int? value) => MolarMass.FromKilogramsPerMole(value); - /// - public static MolarMass KilogramsPerMoles(this long value) => MolarMass.FromKilogramsPerMoles(value); + /// + public static MolarMass KilogramsPerMole(this long value) => MolarMass.FromKilogramsPerMole(value); - /// - public static MolarMass? KilogramsPerMoles(this long? value) => MolarMass.FromKilogramsPerMoles(value); + /// + public static MolarMass? KilogramsPerMole(this long? value) => MolarMass.FromKilogramsPerMole(value); - /// - public static MolarMass KilogramsPerMoles(this double value) => MolarMass.FromKilogramsPerMoles(value); + /// + public static MolarMass KilogramsPerMole(this double value) => MolarMass.FromKilogramsPerMole(value); - /// - public static MolarMass? KilogramsPerMoles(this double? value) => MolarMass.FromKilogramsPerMoles(value); + /// + public static MolarMass? KilogramsPerMole(this double? value) => MolarMass.FromKilogramsPerMole(value); - /// - public static MolarMass KilogramsPerMoles(this float value) => MolarMass.FromKilogramsPerMoles(value); + /// + public static MolarMass KilogramsPerMole(this float value) => MolarMass.FromKilogramsPerMole(value); - /// - public static MolarMass? KilogramsPerMoles(this float? value) => MolarMass.FromKilogramsPerMoles(value); + /// + public static MolarMass? KilogramsPerMole(this float? value) => MolarMass.FromKilogramsPerMole(value); - /// - public static MolarMass KilogramsPerMoles(this decimal value) => MolarMass.FromKilogramsPerMoles(Convert.ToDouble(value)); + /// + public static MolarMass KilogramsPerMole(this decimal value) => MolarMass.FromKilogramsPerMole(Convert.ToDouble(value)); - /// - public static MolarMass? KilogramsPerMoles(this decimal? value) => MolarMass.FromKilogramsPerMoles(value == null ? (double?)null : Convert.ToDouble(value.Value)); + /// + public static MolarMass? KilogramsPerMole(this decimal? value) => MolarMass.FromKilogramsPerMole(value == null ? (double?)null : Convert.ToDouble(value.Value)); #endregion #region KilopoundPerMole - /// - public static MolarMass KilopoundsPerMoles(this int value) => MolarMass.FromKilopoundsPerMoles(value); + /// + public static MolarMass KilopoundsPerMole(this int value) => MolarMass.FromKilopoundsPerMole(value); - /// - public static MolarMass? KilopoundsPerMoles(this int? value) => MolarMass.FromKilopoundsPerMoles(value); + /// + public static MolarMass? KilopoundsPerMole(this int? value) => MolarMass.FromKilopoundsPerMole(value); - /// - public static MolarMass KilopoundsPerMoles(this long value) => MolarMass.FromKilopoundsPerMoles(value); + /// + public static MolarMass KilopoundsPerMole(this long value) => MolarMass.FromKilopoundsPerMole(value); - /// - public static MolarMass? KilopoundsPerMoles(this long? value) => MolarMass.FromKilopoundsPerMoles(value); + /// + public static MolarMass? KilopoundsPerMole(this long? value) => MolarMass.FromKilopoundsPerMole(value); - /// - public static MolarMass KilopoundsPerMoles(this double value) => MolarMass.FromKilopoundsPerMoles(value); + /// + public static MolarMass KilopoundsPerMole(this double value) => MolarMass.FromKilopoundsPerMole(value); - /// - public static MolarMass? KilopoundsPerMoles(this double? value) => MolarMass.FromKilopoundsPerMoles(value); + /// + public static MolarMass? KilopoundsPerMole(this double? value) => MolarMass.FromKilopoundsPerMole(value); - /// - public static MolarMass KilopoundsPerMoles(this float value) => MolarMass.FromKilopoundsPerMoles(value); + /// + public static MolarMass KilopoundsPerMole(this float value) => MolarMass.FromKilopoundsPerMole(value); - /// - public static MolarMass? KilopoundsPerMoles(this float? value) => MolarMass.FromKilopoundsPerMoles(value); + /// + public static MolarMass? KilopoundsPerMole(this float? value) => MolarMass.FromKilopoundsPerMole(value); - /// - public static MolarMass KilopoundsPerMoles(this decimal value) => MolarMass.FromKilopoundsPerMoles(Convert.ToDouble(value)); + /// + public static MolarMass KilopoundsPerMole(this decimal value) => MolarMass.FromKilopoundsPerMole(Convert.ToDouble(value)); - /// - public static MolarMass? KilopoundsPerMoles(this decimal? value) => MolarMass.FromKilopoundsPerMoles(value == null ? (double?)null : Convert.ToDouble(value.Value)); + /// + public static MolarMass? KilopoundsPerMole(this decimal? value) => MolarMass.FromKilopoundsPerMole(value == null ? (double?)null : Convert.ToDouble(value.Value)); #endregion #region MegapoundPerMole - /// - public static MolarMass MegapoundsPerMoles(this int value) => MolarMass.FromMegapoundsPerMoles(value); + /// + public static MolarMass MegapoundsPerMole(this int value) => MolarMass.FromMegapoundsPerMole(value); - /// - public static MolarMass? MegapoundsPerMoles(this int? value) => MolarMass.FromMegapoundsPerMoles(value); + /// + public static MolarMass? MegapoundsPerMole(this int? value) => MolarMass.FromMegapoundsPerMole(value); - /// - public static MolarMass MegapoundsPerMoles(this long value) => MolarMass.FromMegapoundsPerMoles(value); + /// + public static MolarMass MegapoundsPerMole(this long value) => MolarMass.FromMegapoundsPerMole(value); - /// - public static MolarMass? MegapoundsPerMoles(this long? value) => MolarMass.FromMegapoundsPerMoles(value); + /// + public static MolarMass? MegapoundsPerMole(this long? value) => MolarMass.FromMegapoundsPerMole(value); - /// - public static MolarMass MegapoundsPerMoles(this double value) => MolarMass.FromMegapoundsPerMoles(value); + /// + public static MolarMass MegapoundsPerMole(this double value) => MolarMass.FromMegapoundsPerMole(value); - /// - public static MolarMass? MegapoundsPerMoles(this double? value) => MolarMass.FromMegapoundsPerMoles(value); + /// + public static MolarMass? MegapoundsPerMole(this double? value) => MolarMass.FromMegapoundsPerMole(value); - /// - public static MolarMass MegapoundsPerMoles(this float value) => MolarMass.FromMegapoundsPerMoles(value); + /// + public static MolarMass MegapoundsPerMole(this float value) => MolarMass.FromMegapoundsPerMole(value); - /// - public static MolarMass? MegapoundsPerMoles(this float? value) => MolarMass.FromMegapoundsPerMoles(value); + /// + public static MolarMass? MegapoundsPerMole(this float? value) => MolarMass.FromMegapoundsPerMole(value); - /// - public static MolarMass MegapoundsPerMoles(this decimal value) => MolarMass.FromMegapoundsPerMoles(Convert.ToDouble(value)); + /// + public static MolarMass MegapoundsPerMole(this decimal value) => MolarMass.FromMegapoundsPerMole(Convert.ToDouble(value)); - /// - public static MolarMass? MegapoundsPerMoles(this decimal? value) => MolarMass.FromMegapoundsPerMoles(value == null ? (double?)null : Convert.ToDouble(value.Value)); + /// + public static MolarMass? MegapoundsPerMole(this decimal? value) => MolarMass.FromMegapoundsPerMole(value == null ? (double?)null : Convert.ToDouble(value.Value)); #endregion #region MicrogramPerMole - /// - public static MolarMass MicrogramsPerMoles(this int value) => MolarMass.FromMicrogramsPerMoles(value); + /// + public static MolarMass MicrogramsPerMole(this int value) => MolarMass.FromMicrogramsPerMole(value); - /// - public static MolarMass? MicrogramsPerMoles(this int? value) => MolarMass.FromMicrogramsPerMoles(value); + /// + public static MolarMass? MicrogramsPerMole(this int? value) => MolarMass.FromMicrogramsPerMole(value); - /// - public static MolarMass MicrogramsPerMoles(this long value) => MolarMass.FromMicrogramsPerMoles(value); + /// + public static MolarMass MicrogramsPerMole(this long value) => MolarMass.FromMicrogramsPerMole(value); - /// - public static MolarMass? MicrogramsPerMoles(this long? value) => MolarMass.FromMicrogramsPerMoles(value); + /// + public static MolarMass? MicrogramsPerMole(this long? value) => MolarMass.FromMicrogramsPerMole(value); - /// - public static MolarMass MicrogramsPerMoles(this double value) => MolarMass.FromMicrogramsPerMoles(value); + /// + public static MolarMass MicrogramsPerMole(this double value) => MolarMass.FromMicrogramsPerMole(value); - /// - public static MolarMass? MicrogramsPerMoles(this double? value) => MolarMass.FromMicrogramsPerMoles(value); + /// + public static MolarMass? MicrogramsPerMole(this double? value) => MolarMass.FromMicrogramsPerMole(value); - /// - public static MolarMass MicrogramsPerMoles(this float value) => MolarMass.FromMicrogramsPerMoles(value); + /// + public static MolarMass MicrogramsPerMole(this float value) => MolarMass.FromMicrogramsPerMole(value); - /// - public static MolarMass? MicrogramsPerMoles(this float? value) => MolarMass.FromMicrogramsPerMoles(value); + /// + public static MolarMass? MicrogramsPerMole(this float? value) => MolarMass.FromMicrogramsPerMole(value); - /// - public static MolarMass MicrogramsPerMoles(this decimal value) => MolarMass.FromMicrogramsPerMoles(Convert.ToDouble(value)); + /// + public static MolarMass MicrogramsPerMole(this decimal value) => MolarMass.FromMicrogramsPerMole(Convert.ToDouble(value)); - /// - public static MolarMass? MicrogramsPerMoles(this decimal? value) => MolarMass.FromMicrogramsPerMoles(value == null ? (double?)null : Convert.ToDouble(value.Value)); + /// + public static MolarMass? MicrogramsPerMole(this decimal? value) => MolarMass.FromMicrogramsPerMole(value == null ? (double?)null : Convert.ToDouble(value.Value)); #endregion #region MilligramPerMole - /// - public static MolarMass MilligramsPerMoles(this int value) => MolarMass.FromMilligramsPerMoles(value); + /// + public static MolarMass MilligramsPerMole(this int value) => MolarMass.FromMilligramsPerMole(value); - /// - public static MolarMass? MilligramsPerMoles(this int? value) => MolarMass.FromMilligramsPerMoles(value); + /// + public static MolarMass? MilligramsPerMole(this int? value) => MolarMass.FromMilligramsPerMole(value); - /// - public static MolarMass MilligramsPerMoles(this long value) => MolarMass.FromMilligramsPerMoles(value); + /// + public static MolarMass MilligramsPerMole(this long value) => MolarMass.FromMilligramsPerMole(value); - /// - public static MolarMass? MilligramsPerMoles(this long? value) => MolarMass.FromMilligramsPerMoles(value); + /// + public static MolarMass? MilligramsPerMole(this long? value) => MolarMass.FromMilligramsPerMole(value); - /// - public static MolarMass MilligramsPerMoles(this double value) => MolarMass.FromMilligramsPerMoles(value); + /// + public static MolarMass MilligramsPerMole(this double value) => MolarMass.FromMilligramsPerMole(value); - /// - public static MolarMass? MilligramsPerMoles(this double? value) => MolarMass.FromMilligramsPerMoles(value); + /// + public static MolarMass? MilligramsPerMole(this double? value) => MolarMass.FromMilligramsPerMole(value); - /// - public static MolarMass MilligramsPerMoles(this float value) => MolarMass.FromMilligramsPerMoles(value); + /// + public static MolarMass MilligramsPerMole(this float value) => MolarMass.FromMilligramsPerMole(value); - /// - public static MolarMass? MilligramsPerMoles(this float? value) => MolarMass.FromMilligramsPerMoles(value); + /// + public static MolarMass? MilligramsPerMole(this float? value) => MolarMass.FromMilligramsPerMole(value); - /// - public static MolarMass MilligramsPerMoles(this decimal value) => MolarMass.FromMilligramsPerMoles(Convert.ToDouble(value)); + /// + public static MolarMass MilligramsPerMole(this decimal value) => MolarMass.FromMilligramsPerMole(Convert.ToDouble(value)); - /// - public static MolarMass? MilligramsPerMoles(this decimal? value) => MolarMass.FromMilligramsPerMoles(value == null ? (double?)null : Convert.ToDouble(value.Value)); + /// + public static MolarMass? MilligramsPerMole(this decimal? value) => MolarMass.FromMilligramsPerMole(value == null ? (double?)null : Convert.ToDouble(value.Value)); #endregion #region NanogramPerMole - /// - public static MolarMass NanogramsPerMoles(this int value) => MolarMass.FromNanogramsPerMoles(value); + /// + public static MolarMass NanogramsPerMole(this int value) => MolarMass.FromNanogramsPerMole(value); - /// - public static MolarMass? NanogramsPerMoles(this int? value) => MolarMass.FromNanogramsPerMoles(value); + /// + public static MolarMass? NanogramsPerMole(this int? value) => MolarMass.FromNanogramsPerMole(value); - /// - public static MolarMass NanogramsPerMoles(this long value) => MolarMass.FromNanogramsPerMoles(value); + /// + public static MolarMass NanogramsPerMole(this long value) => MolarMass.FromNanogramsPerMole(value); - /// - public static MolarMass? NanogramsPerMoles(this long? value) => MolarMass.FromNanogramsPerMoles(value); + /// + public static MolarMass? NanogramsPerMole(this long? value) => MolarMass.FromNanogramsPerMole(value); - /// - public static MolarMass NanogramsPerMoles(this double value) => MolarMass.FromNanogramsPerMoles(value); + /// + public static MolarMass NanogramsPerMole(this double value) => MolarMass.FromNanogramsPerMole(value); - /// - public static MolarMass? NanogramsPerMoles(this double? value) => MolarMass.FromNanogramsPerMoles(value); + /// + public static MolarMass? NanogramsPerMole(this double? value) => MolarMass.FromNanogramsPerMole(value); - /// - public static MolarMass NanogramsPerMoles(this float value) => MolarMass.FromNanogramsPerMoles(value); + /// + public static MolarMass NanogramsPerMole(this float value) => MolarMass.FromNanogramsPerMole(value); - /// - public static MolarMass? NanogramsPerMoles(this float? value) => MolarMass.FromNanogramsPerMoles(value); + /// + public static MolarMass? NanogramsPerMole(this float? value) => MolarMass.FromNanogramsPerMole(value); - /// - public static MolarMass NanogramsPerMoles(this decimal value) => MolarMass.FromNanogramsPerMoles(Convert.ToDouble(value)); + /// + public static MolarMass NanogramsPerMole(this decimal value) => MolarMass.FromNanogramsPerMole(Convert.ToDouble(value)); - /// - public static MolarMass? NanogramsPerMoles(this decimal? value) => MolarMass.FromNanogramsPerMoles(value == null ? (double?)null : Convert.ToDouble(value.Value)); + /// + public static MolarMass? NanogramsPerMole(this decimal? value) => MolarMass.FromNanogramsPerMole(value == null ? (double?)null : Convert.ToDouble(value.Value)); #endregion #region PoundPerMole - /// - public static MolarMass PoundsPerMoles(this int value) => MolarMass.FromPoundsPerMoles(value); + /// + public static MolarMass PoundsPerMole(this int value) => MolarMass.FromPoundsPerMole(value); - /// - public static MolarMass? PoundsPerMoles(this int? value) => MolarMass.FromPoundsPerMoles(value); + /// + public static MolarMass? PoundsPerMole(this int? value) => MolarMass.FromPoundsPerMole(value); - /// - public static MolarMass PoundsPerMoles(this long value) => MolarMass.FromPoundsPerMoles(value); + /// + public static MolarMass PoundsPerMole(this long value) => MolarMass.FromPoundsPerMole(value); - /// - public static MolarMass? PoundsPerMoles(this long? value) => MolarMass.FromPoundsPerMoles(value); + /// + public static MolarMass? PoundsPerMole(this long? value) => MolarMass.FromPoundsPerMole(value); - /// - public static MolarMass PoundsPerMoles(this double value) => MolarMass.FromPoundsPerMoles(value); + /// + public static MolarMass PoundsPerMole(this double value) => MolarMass.FromPoundsPerMole(value); - /// - public static MolarMass? PoundsPerMoles(this double? value) => MolarMass.FromPoundsPerMoles(value); + /// + public static MolarMass? PoundsPerMole(this double? value) => MolarMass.FromPoundsPerMole(value); - /// - public static MolarMass PoundsPerMoles(this float value) => MolarMass.FromPoundsPerMoles(value); + /// + public static MolarMass PoundsPerMole(this float value) => MolarMass.FromPoundsPerMole(value); - /// - public static MolarMass? PoundsPerMoles(this float? value) => MolarMass.FromPoundsPerMoles(value); + /// + public static MolarMass? PoundsPerMole(this float? value) => MolarMass.FromPoundsPerMole(value); - /// - public static MolarMass PoundsPerMoles(this decimal value) => MolarMass.FromPoundsPerMoles(Convert.ToDouble(value)); + /// + public static MolarMass PoundsPerMole(this decimal value) => MolarMass.FromPoundsPerMole(Convert.ToDouble(value)); - /// - public static MolarMass? PoundsPerMoles(this decimal? value) => MolarMass.FromPoundsPerMoles(value == null ? (double?)null : Convert.ToDouble(value.Value)); + /// + public static MolarMass? PoundsPerMole(this decimal? value) => MolarMass.FromPoundsPerMole(value == null ? (double?)null : Convert.ToDouble(value.Value)); #endregion diff --git a/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs index 97d3b9c802..ad83e7044f 100644 --- a/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs @@ -72,7 +72,7 @@ public partial struct MolarMass : IComparable, IComparable /// /// Base unit of MolarMass. /// - private readonly double _kilogramsPerMoles; + private readonly double _kilogramsPerMole; // Windows Runtime Component requires a default constructor #if WINDOWS_UWP @@ -81,9 +81,9 @@ public MolarMass() : this(0) } #endif - public MolarMass(double kilogramspermoles) + public MolarMass(double kilogramspermole) { - _kilogramsPerMoles = Convert.ToDouble(kilogramspermoles); + _kilogramsPerMole = Convert.ToDouble(kilogramspermole); } // 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 @@ -92,9 +92,9 @@ public MolarMass(double kilogramspermoles) #else public #endif - MolarMass(long kilogramspermoles) + MolarMass(long kilogramspermole) { - _kilogramsPerMoles = Convert.ToDouble(kilogramspermoles); + _kilogramsPerMole = Convert.ToDouble(kilogramspermole); } // 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 @@ -104,9 +104,9 @@ public MolarMass(double kilogramspermoles) #else public #endif - MolarMass(decimal kilogramspermoles) + MolarMass(decimal kilogramspermole) { - _kilogramsPerMoles = Convert.ToDouble(kilogramspermoles); + _kilogramsPerMole = Convert.ToDouble(kilogramspermole); } #region Properties @@ -130,99 +130,99 @@ public static MolarMassUnit BaseUnit public static MolarMassUnit[] Units { get; } = Enum.GetValues(typeof(MolarMassUnit)).Cast().ToArray(); /// - /// Get MolarMass in CentigramsPerMoles. + /// Get MolarMass in CentigramsPerMole. /// - public double CentigramsPerMoles + public double CentigramsPerMole { - get { return (_kilogramsPerMoles*1e3) / 1e-2d; } + get { return (_kilogramsPerMole*1e3) / 1e-2d; } } /// - /// Get MolarMass in DecagramsPerMoles. + /// Get MolarMass in DecagramsPerMole. /// - public double DecagramsPerMoles + public double DecagramsPerMole { - get { return (_kilogramsPerMoles*1e3) / 1e1d; } + get { return (_kilogramsPerMole*1e3) / 1e1d; } } /// - /// Get MolarMass in DecigramsPerMoles. + /// Get MolarMass in DecigramsPerMole. /// - public double DecigramsPerMoles + public double DecigramsPerMole { - get { return (_kilogramsPerMoles*1e3) / 1e-1d; } + get { return (_kilogramsPerMole*1e3) / 1e-1d; } } /// - /// Get MolarMass in GramsPerMoles. + /// Get MolarMass in GramsPerMole. /// - public double GramsPerMoles + public double GramsPerMole { - get { return _kilogramsPerMoles*1e3; } + get { return _kilogramsPerMole*1e3; } } /// - /// Get MolarMass in HectogramsPerMoles. + /// Get MolarMass in HectogramsPerMole. /// - public double HectogramsPerMoles + public double HectogramsPerMole { - get { return (_kilogramsPerMoles*1e3) / 1e2d; } + get { return (_kilogramsPerMole*1e3) / 1e2d; } } /// - /// Get MolarMass in KilogramsPerMoles. + /// Get MolarMass in KilogramsPerMole. /// - public double KilogramsPerMoles + public double KilogramsPerMole { - get { return (_kilogramsPerMoles*1e3) / 1e3d; } + get { return (_kilogramsPerMole*1e3) / 1e3d; } } /// - /// Get MolarMass in KilopoundsPerMoles. + /// Get MolarMass in KilopoundsPerMole. /// - public double KilopoundsPerMoles + public double KilopoundsPerMole { - get { return (_kilogramsPerMoles/0.45359237) / 1e3d; } + get { return (_kilogramsPerMole/0.45359237) / 1e3d; } } /// - /// Get MolarMass in MegapoundsPerMoles. + /// Get MolarMass in MegapoundsPerMole. /// - public double MegapoundsPerMoles + public double MegapoundsPerMole { - get { return (_kilogramsPerMoles/0.45359237) / 1e6d; } + get { return (_kilogramsPerMole/0.45359237) / 1e6d; } } /// - /// Get MolarMass in MicrogramsPerMoles. + /// Get MolarMass in MicrogramsPerMole. /// - public double MicrogramsPerMoles + public double MicrogramsPerMole { - get { return (_kilogramsPerMoles*1e3) / 1e-6d; } + get { return (_kilogramsPerMole*1e3) / 1e-6d; } } /// - /// Get MolarMass in MilligramsPerMoles. + /// Get MolarMass in MilligramsPerMole. /// - public double MilligramsPerMoles + public double MilligramsPerMole { - get { return (_kilogramsPerMoles*1e3) / 1e-3d; } + get { return (_kilogramsPerMole*1e3) / 1e-3d; } } /// - /// Get MolarMass in NanogramsPerMoles. + /// Get MolarMass in NanogramsPerMole. /// - public double NanogramsPerMoles + public double NanogramsPerMole { - get { return (_kilogramsPerMoles*1e3) / 1e-9d; } + get { return (_kilogramsPerMole*1e3) / 1e-9d; } } /// - /// Get MolarMass in PoundsPerMoles. + /// Get MolarMass in PoundsPerMole. /// - public double PoundsPerMoles + public double PoundsPerMole { - get { return _kilogramsPerMoles/0.45359237; } + get { return _kilogramsPerMole/0.45359237; } } #endregion @@ -235,471 +235,471 @@ public static MolarMass Zero } /// - /// Get MolarMass from CentigramsPerMoles. + /// Get MolarMass from CentigramsPerMole. /// #if NETFX_CORE [Windows.Foundation.Metadata.DefaultOverload] #endif - public static MolarMass FromCentigramsPerMoles(double centigramspermoles) + public static MolarMass FromCentigramsPerMole(double centigramspermole) { - return new MolarMass((centigramspermoles/1e3) * 1e-2d); + return new MolarMass((centigramspermole/1e3) * 1e-2d); } /// - /// Get MolarMass from CentigramsPerMoles. + /// Get MolarMass from CentigramsPerMole. /// - public static MolarMass FromCentigramsPerMoles(int centigramspermoles) + public static MolarMass FromCentigramsPerMole(int centigramspermole) { - return new MolarMass((centigramspermoles/1e3) * 1e-2d); + return new MolarMass((centigramspermole/1e3) * 1e-2d); } /// - /// Get MolarMass from CentigramsPerMoles. + /// Get MolarMass from CentigramsPerMole. /// - public static MolarMass FromCentigramsPerMoles(long centigramspermoles) + public static MolarMass FromCentigramsPerMole(long centigramspermole) { - return new MolarMass((centigramspermoles/1e3) * 1e-2d); + return new MolarMass((centigramspermole/1e3) * 1e-2d); } // Windows Runtime Component does not support decimal type #if !WINDOWS_UWP /// - /// Get MolarMass from CentigramsPerMoles of type decimal. + /// Get MolarMass from CentigramsPerMole of type decimal. /// - public static MolarMass FromCentigramsPerMoles(decimal centigramspermoles) + public static MolarMass FromCentigramsPerMole(decimal centigramspermole) { - return new MolarMass((Convert.ToDouble(centigramspermoles)/1e3) * 1e-2d); + return new MolarMass((Convert.ToDouble(centigramspermole)/1e3) * 1e-2d); } #endif /// - /// Get MolarMass from DecagramsPerMoles. + /// Get MolarMass from DecagramsPerMole. /// #if NETFX_CORE [Windows.Foundation.Metadata.DefaultOverload] #endif - public static MolarMass FromDecagramsPerMoles(double decagramspermoles) + public static MolarMass FromDecagramsPerMole(double decagramspermole) { - return new MolarMass((decagramspermoles/1e3) * 1e1d); + return new MolarMass((decagramspermole/1e3) * 1e1d); } /// - /// Get MolarMass from DecagramsPerMoles. + /// Get MolarMass from DecagramsPerMole. /// - public static MolarMass FromDecagramsPerMoles(int decagramspermoles) + public static MolarMass FromDecagramsPerMole(int decagramspermole) { - return new MolarMass((decagramspermoles/1e3) * 1e1d); + return new MolarMass((decagramspermole/1e3) * 1e1d); } /// - /// Get MolarMass from DecagramsPerMoles. + /// Get MolarMass from DecagramsPerMole. /// - public static MolarMass FromDecagramsPerMoles(long decagramspermoles) + public static MolarMass FromDecagramsPerMole(long decagramspermole) { - return new MolarMass((decagramspermoles/1e3) * 1e1d); + return new MolarMass((decagramspermole/1e3) * 1e1d); } // Windows Runtime Component does not support decimal type #if !WINDOWS_UWP /// - /// Get MolarMass from DecagramsPerMoles of type decimal. + /// Get MolarMass from DecagramsPerMole of type decimal. /// - public static MolarMass FromDecagramsPerMoles(decimal decagramspermoles) + public static MolarMass FromDecagramsPerMole(decimal decagramspermole) { - return new MolarMass((Convert.ToDouble(decagramspermoles)/1e3) * 1e1d); + return new MolarMass((Convert.ToDouble(decagramspermole)/1e3) * 1e1d); } #endif /// - /// Get MolarMass from DecigramsPerMoles. + /// Get MolarMass from DecigramsPerMole. /// #if NETFX_CORE [Windows.Foundation.Metadata.DefaultOverload] #endif - public static MolarMass FromDecigramsPerMoles(double decigramspermoles) + public static MolarMass FromDecigramsPerMole(double decigramspermole) { - return new MolarMass((decigramspermoles/1e3) * 1e-1d); + return new MolarMass((decigramspermole/1e3) * 1e-1d); } /// - /// Get MolarMass from DecigramsPerMoles. + /// Get MolarMass from DecigramsPerMole. /// - public static MolarMass FromDecigramsPerMoles(int decigramspermoles) + public static MolarMass FromDecigramsPerMole(int decigramspermole) { - return new MolarMass((decigramspermoles/1e3) * 1e-1d); + return new MolarMass((decigramspermole/1e3) * 1e-1d); } /// - /// Get MolarMass from DecigramsPerMoles. + /// Get MolarMass from DecigramsPerMole. /// - public static MolarMass FromDecigramsPerMoles(long decigramspermoles) + public static MolarMass FromDecigramsPerMole(long decigramspermole) { - return new MolarMass((decigramspermoles/1e3) * 1e-1d); + return new MolarMass((decigramspermole/1e3) * 1e-1d); } // Windows Runtime Component does not support decimal type #if !WINDOWS_UWP /// - /// Get MolarMass from DecigramsPerMoles of type decimal. + /// Get MolarMass from DecigramsPerMole of type decimal. /// - public static MolarMass FromDecigramsPerMoles(decimal decigramspermoles) + public static MolarMass FromDecigramsPerMole(decimal decigramspermole) { - return new MolarMass((Convert.ToDouble(decigramspermoles)/1e3) * 1e-1d); + return new MolarMass((Convert.ToDouble(decigramspermole)/1e3) * 1e-1d); } #endif /// - /// Get MolarMass from GramsPerMoles. + /// Get MolarMass from GramsPerMole. /// #if NETFX_CORE [Windows.Foundation.Metadata.DefaultOverload] #endif - public static MolarMass FromGramsPerMoles(double gramspermoles) + public static MolarMass FromGramsPerMole(double gramspermole) { - return new MolarMass(gramspermoles/1e3); + return new MolarMass(gramspermole/1e3); } /// - /// Get MolarMass from GramsPerMoles. + /// Get MolarMass from GramsPerMole. /// - public static MolarMass FromGramsPerMoles(int gramspermoles) + public static MolarMass FromGramsPerMole(int gramspermole) { - return new MolarMass(gramspermoles/1e3); + return new MolarMass(gramspermole/1e3); } /// - /// Get MolarMass from GramsPerMoles. + /// Get MolarMass from GramsPerMole. /// - public static MolarMass FromGramsPerMoles(long gramspermoles) + public static MolarMass FromGramsPerMole(long gramspermole) { - return new MolarMass(gramspermoles/1e3); + return new MolarMass(gramspermole/1e3); } // Windows Runtime Component does not support decimal type #if !WINDOWS_UWP /// - /// Get MolarMass from GramsPerMoles of type decimal. + /// Get MolarMass from GramsPerMole of type decimal. /// - public static MolarMass FromGramsPerMoles(decimal gramspermoles) + public static MolarMass FromGramsPerMole(decimal gramspermole) { - return new MolarMass(Convert.ToDouble(gramspermoles)/1e3); + return new MolarMass(Convert.ToDouble(gramspermole)/1e3); } #endif /// - /// Get MolarMass from HectogramsPerMoles. + /// Get MolarMass from HectogramsPerMole. /// #if NETFX_CORE [Windows.Foundation.Metadata.DefaultOverload] #endif - public static MolarMass FromHectogramsPerMoles(double hectogramspermoles) + public static MolarMass FromHectogramsPerMole(double hectogramspermole) { - return new MolarMass((hectogramspermoles/1e3) * 1e2d); + return new MolarMass((hectogramspermole/1e3) * 1e2d); } /// - /// Get MolarMass from HectogramsPerMoles. + /// Get MolarMass from HectogramsPerMole. /// - public static MolarMass FromHectogramsPerMoles(int hectogramspermoles) + public static MolarMass FromHectogramsPerMole(int hectogramspermole) { - return new MolarMass((hectogramspermoles/1e3) * 1e2d); + return new MolarMass((hectogramspermole/1e3) * 1e2d); } /// - /// Get MolarMass from HectogramsPerMoles. + /// Get MolarMass from HectogramsPerMole. /// - public static MolarMass FromHectogramsPerMoles(long hectogramspermoles) + public static MolarMass FromHectogramsPerMole(long hectogramspermole) { - return new MolarMass((hectogramspermoles/1e3) * 1e2d); + return new MolarMass((hectogramspermole/1e3) * 1e2d); } // Windows Runtime Component does not support decimal type #if !WINDOWS_UWP /// - /// Get MolarMass from HectogramsPerMoles of type decimal. + /// Get MolarMass from HectogramsPerMole of type decimal. /// - public static MolarMass FromHectogramsPerMoles(decimal hectogramspermoles) + public static MolarMass FromHectogramsPerMole(decimal hectogramspermole) { - return new MolarMass((Convert.ToDouble(hectogramspermoles)/1e3) * 1e2d); + return new MolarMass((Convert.ToDouble(hectogramspermole)/1e3) * 1e2d); } #endif /// - /// Get MolarMass from KilogramsPerMoles. + /// Get MolarMass from KilogramsPerMole. /// #if NETFX_CORE [Windows.Foundation.Metadata.DefaultOverload] #endif - public static MolarMass FromKilogramsPerMoles(double kilogramspermoles) + public static MolarMass FromKilogramsPerMole(double kilogramspermole) { - return new MolarMass((kilogramspermoles/1e3) * 1e3d); + return new MolarMass((kilogramspermole/1e3) * 1e3d); } /// - /// Get MolarMass from KilogramsPerMoles. + /// Get MolarMass from KilogramsPerMole. /// - public static MolarMass FromKilogramsPerMoles(int kilogramspermoles) + public static MolarMass FromKilogramsPerMole(int kilogramspermole) { - return new MolarMass((kilogramspermoles/1e3) * 1e3d); + return new MolarMass((kilogramspermole/1e3) * 1e3d); } /// - /// Get MolarMass from KilogramsPerMoles. + /// Get MolarMass from KilogramsPerMole. /// - public static MolarMass FromKilogramsPerMoles(long kilogramspermoles) + public static MolarMass FromKilogramsPerMole(long kilogramspermole) { - return new MolarMass((kilogramspermoles/1e3) * 1e3d); + return new MolarMass((kilogramspermole/1e3) * 1e3d); } // Windows Runtime Component does not support decimal type #if !WINDOWS_UWP /// - /// Get MolarMass from KilogramsPerMoles of type decimal. + /// Get MolarMass from KilogramsPerMole of type decimal. /// - public static MolarMass FromKilogramsPerMoles(decimal kilogramspermoles) + public static MolarMass FromKilogramsPerMole(decimal kilogramspermole) { - return new MolarMass((Convert.ToDouble(kilogramspermoles)/1e3) * 1e3d); + return new MolarMass((Convert.ToDouble(kilogramspermole)/1e3) * 1e3d); } #endif /// - /// Get MolarMass from KilopoundsPerMoles. + /// Get MolarMass from KilopoundsPerMole. /// #if NETFX_CORE [Windows.Foundation.Metadata.DefaultOverload] #endif - public static MolarMass FromKilopoundsPerMoles(double kilopoundspermoles) + public static MolarMass FromKilopoundsPerMole(double kilopoundspermole) { - return new MolarMass((kilopoundspermoles*0.45359237) * 1e3d); + return new MolarMass((kilopoundspermole*0.45359237) * 1e3d); } /// - /// Get MolarMass from KilopoundsPerMoles. + /// Get MolarMass from KilopoundsPerMole. /// - public static MolarMass FromKilopoundsPerMoles(int kilopoundspermoles) + public static MolarMass FromKilopoundsPerMole(int kilopoundspermole) { - return new MolarMass((kilopoundspermoles*0.45359237) * 1e3d); + return new MolarMass((kilopoundspermole*0.45359237) * 1e3d); } /// - /// Get MolarMass from KilopoundsPerMoles. + /// Get MolarMass from KilopoundsPerMole. /// - public static MolarMass FromKilopoundsPerMoles(long kilopoundspermoles) + public static MolarMass FromKilopoundsPerMole(long kilopoundspermole) { - return new MolarMass((kilopoundspermoles*0.45359237) * 1e3d); + return new MolarMass((kilopoundspermole*0.45359237) * 1e3d); } // Windows Runtime Component does not support decimal type #if !WINDOWS_UWP /// - /// Get MolarMass from KilopoundsPerMoles of type decimal. + /// Get MolarMass from KilopoundsPerMole of type decimal. /// - public static MolarMass FromKilopoundsPerMoles(decimal kilopoundspermoles) + public static MolarMass FromKilopoundsPerMole(decimal kilopoundspermole) { - return new MolarMass((Convert.ToDouble(kilopoundspermoles)*0.45359237) * 1e3d); + return new MolarMass((Convert.ToDouble(kilopoundspermole)*0.45359237) * 1e3d); } #endif /// - /// Get MolarMass from MegapoundsPerMoles. + /// Get MolarMass from MegapoundsPerMole. /// #if NETFX_CORE [Windows.Foundation.Metadata.DefaultOverload] #endif - public static MolarMass FromMegapoundsPerMoles(double megapoundspermoles) + public static MolarMass FromMegapoundsPerMole(double megapoundspermole) { - return new MolarMass((megapoundspermoles*0.45359237) * 1e6d); + return new MolarMass((megapoundspermole*0.45359237) * 1e6d); } /// - /// Get MolarMass from MegapoundsPerMoles. + /// Get MolarMass from MegapoundsPerMole. /// - public static MolarMass FromMegapoundsPerMoles(int megapoundspermoles) + public static MolarMass FromMegapoundsPerMole(int megapoundspermole) { - return new MolarMass((megapoundspermoles*0.45359237) * 1e6d); + return new MolarMass((megapoundspermole*0.45359237) * 1e6d); } /// - /// Get MolarMass from MegapoundsPerMoles. + /// Get MolarMass from MegapoundsPerMole. /// - public static MolarMass FromMegapoundsPerMoles(long megapoundspermoles) + public static MolarMass FromMegapoundsPerMole(long megapoundspermole) { - return new MolarMass((megapoundspermoles*0.45359237) * 1e6d); + return new MolarMass((megapoundspermole*0.45359237) * 1e6d); } // Windows Runtime Component does not support decimal type #if !WINDOWS_UWP /// - /// Get MolarMass from MegapoundsPerMoles of type decimal. + /// Get MolarMass from MegapoundsPerMole of type decimal. /// - public static MolarMass FromMegapoundsPerMoles(decimal megapoundspermoles) + public static MolarMass FromMegapoundsPerMole(decimal megapoundspermole) { - return new MolarMass((Convert.ToDouble(megapoundspermoles)*0.45359237) * 1e6d); + return new MolarMass((Convert.ToDouble(megapoundspermole)*0.45359237) * 1e6d); } #endif /// - /// Get MolarMass from MicrogramsPerMoles. + /// Get MolarMass from MicrogramsPerMole. /// #if NETFX_CORE [Windows.Foundation.Metadata.DefaultOverload] #endif - public static MolarMass FromMicrogramsPerMoles(double microgramspermoles) + public static MolarMass FromMicrogramsPerMole(double microgramspermole) { - return new MolarMass((microgramspermoles/1e3) * 1e-6d); + return new MolarMass((microgramspermole/1e3) * 1e-6d); } /// - /// Get MolarMass from MicrogramsPerMoles. + /// Get MolarMass from MicrogramsPerMole. /// - public static MolarMass FromMicrogramsPerMoles(int microgramspermoles) + public static MolarMass FromMicrogramsPerMole(int microgramspermole) { - return new MolarMass((microgramspermoles/1e3) * 1e-6d); + return new MolarMass((microgramspermole/1e3) * 1e-6d); } /// - /// Get MolarMass from MicrogramsPerMoles. + /// Get MolarMass from MicrogramsPerMole. /// - public static MolarMass FromMicrogramsPerMoles(long microgramspermoles) + public static MolarMass FromMicrogramsPerMole(long microgramspermole) { - return new MolarMass((microgramspermoles/1e3) * 1e-6d); + return new MolarMass((microgramspermole/1e3) * 1e-6d); } // Windows Runtime Component does not support decimal type #if !WINDOWS_UWP /// - /// Get MolarMass from MicrogramsPerMoles of type decimal. + /// Get MolarMass from MicrogramsPerMole of type decimal. /// - public static MolarMass FromMicrogramsPerMoles(decimal microgramspermoles) + public static MolarMass FromMicrogramsPerMole(decimal microgramspermole) { - return new MolarMass((Convert.ToDouble(microgramspermoles)/1e3) * 1e-6d); + return new MolarMass((Convert.ToDouble(microgramspermole)/1e3) * 1e-6d); } #endif /// - /// Get MolarMass from MilligramsPerMoles. + /// Get MolarMass from MilligramsPerMole. /// #if NETFX_CORE [Windows.Foundation.Metadata.DefaultOverload] #endif - public static MolarMass FromMilligramsPerMoles(double milligramspermoles) + public static MolarMass FromMilligramsPerMole(double milligramspermole) { - return new MolarMass((milligramspermoles/1e3) * 1e-3d); + return new MolarMass((milligramspermole/1e3) * 1e-3d); } /// - /// Get MolarMass from MilligramsPerMoles. + /// Get MolarMass from MilligramsPerMole. /// - public static MolarMass FromMilligramsPerMoles(int milligramspermoles) + public static MolarMass FromMilligramsPerMole(int milligramspermole) { - return new MolarMass((milligramspermoles/1e3) * 1e-3d); + return new MolarMass((milligramspermole/1e3) * 1e-3d); } /// - /// Get MolarMass from MilligramsPerMoles. + /// Get MolarMass from MilligramsPerMole. /// - public static MolarMass FromMilligramsPerMoles(long milligramspermoles) + public static MolarMass FromMilligramsPerMole(long milligramspermole) { - return new MolarMass((milligramspermoles/1e3) * 1e-3d); + return new MolarMass((milligramspermole/1e3) * 1e-3d); } // Windows Runtime Component does not support decimal type #if !WINDOWS_UWP /// - /// Get MolarMass from MilligramsPerMoles of type decimal. + /// Get MolarMass from MilligramsPerMole of type decimal. /// - public static MolarMass FromMilligramsPerMoles(decimal milligramspermoles) + public static MolarMass FromMilligramsPerMole(decimal milligramspermole) { - return new MolarMass((Convert.ToDouble(milligramspermoles)/1e3) * 1e-3d); + return new MolarMass((Convert.ToDouble(milligramspermole)/1e3) * 1e-3d); } #endif /// - /// Get MolarMass from NanogramsPerMoles. + /// Get MolarMass from NanogramsPerMole. /// #if NETFX_CORE [Windows.Foundation.Metadata.DefaultOverload] #endif - public static MolarMass FromNanogramsPerMoles(double nanogramspermoles) + public static MolarMass FromNanogramsPerMole(double nanogramspermole) { - return new MolarMass((nanogramspermoles/1e3) * 1e-9d); + return new MolarMass((nanogramspermole/1e3) * 1e-9d); } /// - /// Get MolarMass from NanogramsPerMoles. + /// Get MolarMass from NanogramsPerMole. /// - public static MolarMass FromNanogramsPerMoles(int nanogramspermoles) + public static MolarMass FromNanogramsPerMole(int nanogramspermole) { - return new MolarMass((nanogramspermoles/1e3) * 1e-9d); + return new MolarMass((nanogramspermole/1e3) * 1e-9d); } /// - /// Get MolarMass from NanogramsPerMoles. + /// Get MolarMass from NanogramsPerMole. /// - public static MolarMass FromNanogramsPerMoles(long nanogramspermoles) + public static MolarMass FromNanogramsPerMole(long nanogramspermole) { - return new MolarMass((nanogramspermoles/1e3) * 1e-9d); + return new MolarMass((nanogramspermole/1e3) * 1e-9d); } // Windows Runtime Component does not support decimal type #if !WINDOWS_UWP /// - /// Get MolarMass from NanogramsPerMoles of type decimal. + /// Get MolarMass from NanogramsPerMole of type decimal. /// - public static MolarMass FromNanogramsPerMoles(decimal nanogramspermoles) + public static MolarMass FromNanogramsPerMole(decimal nanogramspermole) { - return new MolarMass((Convert.ToDouble(nanogramspermoles)/1e3) * 1e-9d); + return new MolarMass((Convert.ToDouble(nanogramspermole)/1e3) * 1e-9d); } #endif /// - /// Get MolarMass from PoundsPerMoles. + /// Get MolarMass from PoundsPerMole. /// #if NETFX_CORE [Windows.Foundation.Metadata.DefaultOverload] #endif - public static MolarMass FromPoundsPerMoles(double poundspermoles) + public static MolarMass FromPoundsPerMole(double poundspermole) { - return new MolarMass(poundspermoles*0.45359237); + return new MolarMass(poundspermole*0.45359237); } /// - /// Get MolarMass from PoundsPerMoles. + /// Get MolarMass from PoundsPerMole. /// - public static MolarMass FromPoundsPerMoles(int poundspermoles) + public static MolarMass FromPoundsPerMole(int poundspermole) { - return new MolarMass(poundspermoles*0.45359237); + return new MolarMass(poundspermole*0.45359237); } /// - /// Get MolarMass from PoundsPerMoles. + /// Get MolarMass from PoundsPerMole. /// - public static MolarMass FromPoundsPerMoles(long poundspermoles) + public static MolarMass FromPoundsPerMole(long poundspermole) { - return new MolarMass(poundspermoles*0.45359237); + return new MolarMass(poundspermole*0.45359237); } // Windows Runtime Component does not support decimal type #if !WINDOWS_UWP /// - /// Get MolarMass from PoundsPerMoles of type decimal. + /// Get MolarMass from PoundsPerMole of type decimal. /// - public static MolarMass FromPoundsPerMoles(decimal poundspermoles) + public static MolarMass FromPoundsPerMole(decimal poundspermole) { - return new MolarMass(Convert.ToDouble(poundspermoles)*0.45359237); + return new MolarMass(Convert.ToDouble(poundspermole)*0.45359237); } #endif // Windows Runtime Component does not support nullable types (double?): https://msdn.microsoft.com/en-us/library/br230301.aspx #if !WINDOWS_UWP /// - /// Get nullable MolarMass from nullable CentigramsPerMoles. + /// Get nullable MolarMass from nullable CentigramsPerMole. /// - public static MolarMass? FromCentigramsPerMoles(double? centigramspermoles) + public static MolarMass? FromCentigramsPerMole(double? centigramspermole) { - if (centigramspermoles.HasValue) + if (centigramspermole.HasValue) { - return FromCentigramsPerMoles(centigramspermoles.Value); + return FromCentigramsPerMole(centigramspermole.Value); } else { @@ -708,13 +708,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable CentigramsPerMoles. + /// Get nullable MolarMass from nullable CentigramsPerMole. /// - public static MolarMass? FromCentigramsPerMoles(int? centigramspermoles) + public static MolarMass? FromCentigramsPerMole(int? centigramspermole) { - if (centigramspermoles.HasValue) + if (centigramspermole.HasValue) { - return FromCentigramsPerMoles(centigramspermoles.Value); + return FromCentigramsPerMole(centigramspermole.Value); } else { @@ -723,13 +723,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable CentigramsPerMoles. + /// Get nullable MolarMass from nullable CentigramsPerMole. /// - public static MolarMass? FromCentigramsPerMoles(long? centigramspermoles) + public static MolarMass? FromCentigramsPerMole(long? centigramspermole) { - if (centigramspermoles.HasValue) + if (centigramspermole.HasValue) { - return FromCentigramsPerMoles(centigramspermoles.Value); + return FromCentigramsPerMole(centigramspermole.Value); } else { @@ -738,13 +738,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from CentigramsPerMoles of type decimal. + /// Get nullable MolarMass from CentigramsPerMole of type decimal. /// - public static MolarMass? FromCentigramsPerMoles(decimal? centigramspermoles) + public static MolarMass? FromCentigramsPerMole(decimal? centigramspermole) { - if (centigramspermoles.HasValue) + if (centigramspermole.HasValue) { - return FromCentigramsPerMoles(centigramspermoles.Value); + return FromCentigramsPerMole(centigramspermole.Value); } else { @@ -753,13 +753,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable DecagramsPerMoles. + /// Get nullable MolarMass from nullable DecagramsPerMole. /// - public static MolarMass? FromDecagramsPerMoles(double? decagramspermoles) + public static MolarMass? FromDecagramsPerMole(double? decagramspermole) { - if (decagramspermoles.HasValue) + if (decagramspermole.HasValue) { - return FromDecagramsPerMoles(decagramspermoles.Value); + return FromDecagramsPerMole(decagramspermole.Value); } else { @@ -768,13 +768,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable DecagramsPerMoles. + /// Get nullable MolarMass from nullable DecagramsPerMole. /// - public static MolarMass? FromDecagramsPerMoles(int? decagramspermoles) + public static MolarMass? FromDecagramsPerMole(int? decagramspermole) { - if (decagramspermoles.HasValue) + if (decagramspermole.HasValue) { - return FromDecagramsPerMoles(decagramspermoles.Value); + return FromDecagramsPerMole(decagramspermole.Value); } else { @@ -783,13 +783,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable DecagramsPerMoles. + /// Get nullable MolarMass from nullable DecagramsPerMole. /// - public static MolarMass? FromDecagramsPerMoles(long? decagramspermoles) + public static MolarMass? FromDecagramsPerMole(long? decagramspermole) { - if (decagramspermoles.HasValue) + if (decagramspermole.HasValue) { - return FromDecagramsPerMoles(decagramspermoles.Value); + return FromDecagramsPerMole(decagramspermole.Value); } else { @@ -798,13 +798,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from DecagramsPerMoles of type decimal. + /// Get nullable MolarMass from DecagramsPerMole of type decimal. /// - public static MolarMass? FromDecagramsPerMoles(decimal? decagramspermoles) + public static MolarMass? FromDecagramsPerMole(decimal? decagramspermole) { - if (decagramspermoles.HasValue) + if (decagramspermole.HasValue) { - return FromDecagramsPerMoles(decagramspermoles.Value); + return FromDecagramsPerMole(decagramspermole.Value); } else { @@ -813,13 +813,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable DecigramsPerMoles. + /// Get nullable MolarMass from nullable DecigramsPerMole. /// - public static MolarMass? FromDecigramsPerMoles(double? decigramspermoles) + public static MolarMass? FromDecigramsPerMole(double? decigramspermole) { - if (decigramspermoles.HasValue) + if (decigramspermole.HasValue) { - return FromDecigramsPerMoles(decigramspermoles.Value); + return FromDecigramsPerMole(decigramspermole.Value); } else { @@ -828,13 +828,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable DecigramsPerMoles. + /// Get nullable MolarMass from nullable DecigramsPerMole. /// - public static MolarMass? FromDecigramsPerMoles(int? decigramspermoles) + public static MolarMass? FromDecigramsPerMole(int? decigramspermole) { - if (decigramspermoles.HasValue) + if (decigramspermole.HasValue) { - return FromDecigramsPerMoles(decigramspermoles.Value); + return FromDecigramsPerMole(decigramspermole.Value); } else { @@ -843,13 +843,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable DecigramsPerMoles. + /// Get nullable MolarMass from nullable DecigramsPerMole. /// - public static MolarMass? FromDecigramsPerMoles(long? decigramspermoles) + public static MolarMass? FromDecigramsPerMole(long? decigramspermole) { - if (decigramspermoles.HasValue) + if (decigramspermole.HasValue) { - return FromDecigramsPerMoles(decigramspermoles.Value); + return FromDecigramsPerMole(decigramspermole.Value); } else { @@ -858,13 +858,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from DecigramsPerMoles of type decimal. + /// Get nullable MolarMass from DecigramsPerMole of type decimal. /// - public static MolarMass? FromDecigramsPerMoles(decimal? decigramspermoles) + public static MolarMass? FromDecigramsPerMole(decimal? decigramspermole) { - if (decigramspermoles.HasValue) + if (decigramspermole.HasValue) { - return FromDecigramsPerMoles(decigramspermoles.Value); + return FromDecigramsPerMole(decigramspermole.Value); } else { @@ -873,13 +873,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable GramsPerMoles. + /// Get nullable MolarMass from nullable GramsPerMole. /// - public static MolarMass? FromGramsPerMoles(double? gramspermoles) + public static MolarMass? FromGramsPerMole(double? gramspermole) { - if (gramspermoles.HasValue) + if (gramspermole.HasValue) { - return FromGramsPerMoles(gramspermoles.Value); + return FromGramsPerMole(gramspermole.Value); } else { @@ -888,13 +888,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable GramsPerMoles. + /// Get nullable MolarMass from nullable GramsPerMole. /// - public static MolarMass? FromGramsPerMoles(int? gramspermoles) + public static MolarMass? FromGramsPerMole(int? gramspermole) { - if (gramspermoles.HasValue) + if (gramspermole.HasValue) { - return FromGramsPerMoles(gramspermoles.Value); + return FromGramsPerMole(gramspermole.Value); } else { @@ -903,13 +903,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable GramsPerMoles. + /// Get nullable MolarMass from nullable GramsPerMole. /// - public static MolarMass? FromGramsPerMoles(long? gramspermoles) + public static MolarMass? FromGramsPerMole(long? gramspermole) { - if (gramspermoles.HasValue) + if (gramspermole.HasValue) { - return FromGramsPerMoles(gramspermoles.Value); + return FromGramsPerMole(gramspermole.Value); } else { @@ -918,13 +918,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from GramsPerMoles of type decimal. + /// Get nullable MolarMass from GramsPerMole of type decimal. /// - public static MolarMass? FromGramsPerMoles(decimal? gramspermoles) + public static MolarMass? FromGramsPerMole(decimal? gramspermole) { - if (gramspermoles.HasValue) + if (gramspermole.HasValue) { - return FromGramsPerMoles(gramspermoles.Value); + return FromGramsPerMole(gramspermole.Value); } else { @@ -933,13 +933,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable HectogramsPerMoles. + /// Get nullable MolarMass from nullable HectogramsPerMole. /// - public static MolarMass? FromHectogramsPerMoles(double? hectogramspermoles) + public static MolarMass? FromHectogramsPerMole(double? hectogramspermole) { - if (hectogramspermoles.HasValue) + if (hectogramspermole.HasValue) { - return FromHectogramsPerMoles(hectogramspermoles.Value); + return FromHectogramsPerMole(hectogramspermole.Value); } else { @@ -948,13 +948,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable HectogramsPerMoles. + /// Get nullable MolarMass from nullable HectogramsPerMole. /// - public static MolarMass? FromHectogramsPerMoles(int? hectogramspermoles) + public static MolarMass? FromHectogramsPerMole(int? hectogramspermole) { - if (hectogramspermoles.HasValue) + if (hectogramspermole.HasValue) { - return FromHectogramsPerMoles(hectogramspermoles.Value); + return FromHectogramsPerMole(hectogramspermole.Value); } else { @@ -963,13 +963,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable HectogramsPerMoles. + /// Get nullable MolarMass from nullable HectogramsPerMole. /// - public static MolarMass? FromHectogramsPerMoles(long? hectogramspermoles) + public static MolarMass? FromHectogramsPerMole(long? hectogramspermole) { - if (hectogramspermoles.HasValue) + if (hectogramspermole.HasValue) { - return FromHectogramsPerMoles(hectogramspermoles.Value); + return FromHectogramsPerMole(hectogramspermole.Value); } else { @@ -978,13 +978,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from HectogramsPerMoles of type decimal. + /// Get nullable MolarMass from HectogramsPerMole of type decimal. /// - public static MolarMass? FromHectogramsPerMoles(decimal? hectogramspermoles) + public static MolarMass? FromHectogramsPerMole(decimal? hectogramspermole) { - if (hectogramspermoles.HasValue) + if (hectogramspermole.HasValue) { - return FromHectogramsPerMoles(hectogramspermoles.Value); + return FromHectogramsPerMole(hectogramspermole.Value); } else { @@ -993,13 +993,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable KilogramsPerMoles. + /// Get nullable MolarMass from nullable KilogramsPerMole. /// - public static MolarMass? FromKilogramsPerMoles(double? kilogramspermoles) + public static MolarMass? FromKilogramsPerMole(double? kilogramspermole) { - if (kilogramspermoles.HasValue) + if (kilogramspermole.HasValue) { - return FromKilogramsPerMoles(kilogramspermoles.Value); + return FromKilogramsPerMole(kilogramspermole.Value); } else { @@ -1008,13 +1008,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable KilogramsPerMoles. + /// Get nullable MolarMass from nullable KilogramsPerMole. /// - public static MolarMass? FromKilogramsPerMoles(int? kilogramspermoles) + public static MolarMass? FromKilogramsPerMole(int? kilogramspermole) { - if (kilogramspermoles.HasValue) + if (kilogramspermole.HasValue) { - return FromKilogramsPerMoles(kilogramspermoles.Value); + return FromKilogramsPerMole(kilogramspermole.Value); } else { @@ -1023,13 +1023,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable KilogramsPerMoles. + /// Get nullable MolarMass from nullable KilogramsPerMole. /// - public static MolarMass? FromKilogramsPerMoles(long? kilogramspermoles) + public static MolarMass? FromKilogramsPerMole(long? kilogramspermole) { - if (kilogramspermoles.HasValue) + if (kilogramspermole.HasValue) { - return FromKilogramsPerMoles(kilogramspermoles.Value); + return FromKilogramsPerMole(kilogramspermole.Value); } else { @@ -1038,13 +1038,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from KilogramsPerMoles of type decimal. + /// Get nullable MolarMass from KilogramsPerMole of type decimal. /// - public static MolarMass? FromKilogramsPerMoles(decimal? kilogramspermoles) + public static MolarMass? FromKilogramsPerMole(decimal? kilogramspermole) { - if (kilogramspermoles.HasValue) + if (kilogramspermole.HasValue) { - return FromKilogramsPerMoles(kilogramspermoles.Value); + return FromKilogramsPerMole(kilogramspermole.Value); } else { @@ -1053,13 +1053,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable KilopoundsPerMoles. + /// Get nullable MolarMass from nullable KilopoundsPerMole. /// - public static MolarMass? FromKilopoundsPerMoles(double? kilopoundspermoles) + public static MolarMass? FromKilopoundsPerMole(double? kilopoundspermole) { - if (kilopoundspermoles.HasValue) + if (kilopoundspermole.HasValue) { - return FromKilopoundsPerMoles(kilopoundspermoles.Value); + return FromKilopoundsPerMole(kilopoundspermole.Value); } else { @@ -1068,13 +1068,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable KilopoundsPerMoles. + /// Get nullable MolarMass from nullable KilopoundsPerMole. /// - public static MolarMass? FromKilopoundsPerMoles(int? kilopoundspermoles) + public static MolarMass? FromKilopoundsPerMole(int? kilopoundspermole) { - if (kilopoundspermoles.HasValue) + if (kilopoundspermole.HasValue) { - return FromKilopoundsPerMoles(kilopoundspermoles.Value); + return FromKilopoundsPerMole(kilopoundspermole.Value); } else { @@ -1083,13 +1083,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable KilopoundsPerMoles. + /// Get nullable MolarMass from nullable KilopoundsPerMole. /// - public static MolarMass? FromKilopoundsPerMoles(long? kilopoundspermoles) + public static MolarMass? FromKilopoundsPerMole(long? kilopoundspermole) { - if (kilopoundspermoles.HasValue) + if (kilopoundspermole.HasValue) { - return FromKilopoundsPerMoles(kilopoundspermoles.Value); + return FromKilopoundsPerMole(kilopoundspermole.Value); } else { @@ -1098,13 +1098,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from KilopoundsPerMoles of type decimal. + /// Get nullable MolarMass from KilopoundsPerMole of type decimal. /// - public static MolarMass? FromKilopoundsPerMoles(decimal? kilopoundspermoles) + public static MolarMass? FromKilopoundsPerMole(decimal? kilopoundspermole) { - if (kilopoundspermoles.HasValue) + if (kilopoundspermole.HasValue) { - return FromKilopoundsPerMoles(kilopoundspermoles.Value); + return FromKilopoundsPerMole(kilopoundspermole.Value); } else { @@ -1113,13 +1113,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable MegapoundsPerMoles. + /// Get nullable MolarMass from nullable MegapoundsPerMole. /// - public static MolarMass? FromMegapoundsPerMoles(double? megapoundspermoles) + public static MolarMass? FromMegapoundsPerMole(double? megapoundspermole) { - if (megapoundspermoles.HasValue) + if (megapoundspermole.HasValue) { - return FromMegapoundsPerMoles(megapoundspermoles.Value); + return FromMegapoundsPerMole(megapoundspermole.Value); } else { @@ -1128,13 +1128,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable MegapoundsPerMoles. + /// Get nullable MolarMass from nullable MegapoundsPerMole. /// - public static MolarMass? FromMegapoundsPerMoles(int? megapoundspermoles) + public static MolarMass? FromMegapoundsPerMole(int? megapoundspermole) { - if (megapoundspermoles.HasValue) + if (megapoundspermole.HasValue) { - return FromMegapoundsPerMoles(megapoundspermoles.Value); + return FromMegapoundsPerMole(megapoundspermole.Value); } else { @@ -1143,13 +1143,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable MegapoundsPerMoles. + /// Get nullable MolarMass from nullable MegapoundsPerMole. /// - public static MolarMass? FromMegapoundsPerMoles(long? megapoundspermoles) + public static MolarMass? FromMegapoundsPerMole(long? megapoundspermole) { - if (megapoundspermoles.HasValue) + if (megapoundspermole.HasValue) { - return FromMegapoundsPerMoles(megapoundspermoles.Value); + return FromMegapoundsPerMole(megapoundspermole.Value); } else { @@ -1158,13 +1158,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from MegapoundsPerMoles of type decimal. + /// Get nullable MolarMass from MegapoundsPerMole of type decimal. /// - public static MolarMass? FromMegapoundsPerMoles(decimal? megapoundspermoles) + public static MolarMass? FromMegapoundsPerMole(decimal? megapoundspermole) { - if (megapoundspermoles.HasValue) + if (megapoundspermole.HasValue) { - return FromMegapoundsPerMoles(megapoundspermoles.Value); + return FromMegapoundsPerMole(megapoundspermole.Value); } else { @@ -1173,13 +1173,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable MicrogramsPerMoles. + /// Get nullable MolarMass from nullable MicrogramsPerMole. /// - public static MolarMass? FromMicrogramsPerMoles(double? microgramspermoles) + public static MolarMass? FromMicrogramsPerMole(double? microgramspermole) { - if (microgramspermoles.HasValue) + if (microgramspermole.HasValue) { - return FromMicrogramsPerMoles(microgramspermoles.Value); + return FromMicrogramsPerMole(microgramspermole.Value); } else { @@ -1188,13 +1188,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable MicrogramsPerMoles. + /// Get nullable MolarMass from nullable MicrogramsPerMole. /// - public static MolarMass? FromMicrogramsPerMoles(int? microgramspermoles) + public static MolarMass? FromMicrogramsPerMole(int? microgramspermole) { - if (microgramspermoles.HasValue) + if (microgramspermole.HasValue) { - return FromMicrogramsPerMoles(microgramspermoles.Value); + return FromMicrogramsPerMole(microgramspermole.Value); } else { @@ -1203,13 +1203,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable MicrogramsPerMoles. + /// Get nullable MolarMass from nullable MicrogramsPerMole. /// - public static MolarMass? FromMicrogramsPerMoles(long? microgramspermoles) + public static MolarMass? FromMicrogramsPerMole(long? microgramspermole) { - if (microgramspermoles.HasValue) + if (microgramspermole.HasValue) { - return FromMicrogramsPerMoles(microgramspermoles.Value); + return FromMicrogramsPerMole(microgramspermole.Value); } else { @@ -1218,13 +1218,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from MicrogramsPerMoles of type decimal. + /// Get nullable MolarMass from MicrogramsPerMole of type decimal. /// - public static MolarMass? FromMicrogramsPerMoles(decimal? microgramspermoles) + public static MolarMass? FromMicrogramsPerMole(decimal? microgramspermole) { - if (microgramspermoles.HasValue) + if (microgramspermole.HasValue) { - return FromMicrogramsPerMoles(microgramspermoles.Value); + return FromMicrogramsPerMole(microgramspermole.Value); } else { @@ -1233,13 +1233,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable MilligramsPerMoles. + /// Get nullable MolarMass from nullable MilligramsPerMole. /// - public static MolarMass? FromMilligramsPerMoles(double? milligramspermoles) + public static MolarMass? FromMilligramsPerMole(double? milligramspermole) { - if (milligramspermoles.HasValue) + if (milligramspermole.HasValue) { - return FromMilligramsPerMoles(milligramspermoles.Value); + return FromMilligramsPerMole(milligramspermole.Value); } else { @@ -1248,13 +1248,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable MilligramsPerMoles. + /// Get nullable MolarMass from nullable MilligramsPerMole. /// - public static MolarMass? FromMilligramsPerMoles(int? milligramspermoles) + public static MolarMass? FromMilligramsPerMole(int? milligramspermole) { - if (milligramspermoles.HasValue) + if (milligramspermole.HasValue) { - return FromMilligramsPerMoles(milligramspermoles.Value); + return FromMilligramsPerMole(milligramspermole.Value); } else { @@ -1263,13 +1263,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable MilligramsPerMoles. + /// Get nullable MolarMass from nullable MilligramsPerMole. /// - public static MolarMass? FromMilligramsPerMoles(long? milligramspermoles) + public static MolarMass? FromMilligramsPerMole(long? milligramspermole) { - if (milligramspermoles.HasValue) + if (milligramspermole.HasValue) { - return FromMilligramsPerMoles(milligramspermoles.Value); + return FromMilligramsPerMole(milligramspermole.Value); } else { @@ -1278,13 +1278,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from MilligramsPerMoles of type decimal. + /// Get nullable MolarMass from MilligramsPerMole of type decimal. /// - public static MolarMass? FromMilligramsPerMoles(decimal? milligramspermoles) + public static MolarMass? FromMilligramsPerMole(decimal? milligramspermole) { - if (milligramspermoles.HasValue) + if (milligramspermole.HasValue) { - return FromMilligramsPerMoles(milligramspermoles.Value); + return FromMilligramsPerMole(milligramspermole.Value); } else { @@ -1293,13 +1293,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable NanogramsPerMoles. + /// Get nullable MolarMass from nullable NanogramsPerMole. /// - public static MolarMass? FromNanogramsPerMoles(double? nanogramspermoles) + public static MolarMass? FromNanogramsPerMole(double? nanogramspermole) { - if (nanogramspermoles.HasValue) + if (nanogramspermole.HasValue) { - return FromNanogramsPerMoles(nanogramspermoles.Value); + return FromNanogramsPerMole(nanogramspermole.Value); } else { @@ -1308,13 +1308,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable NanogramsPerMoles. + /// Get nullable MolarMass from nullable NanogramsPerMole. /// - public static MolarMass? FromNanogramsPerMoles(int? nanogramspermoles) + public static MolarMass? FromNanogramsPerMole(int? nanogramspermole) { - if (nanogramspermoles.HasValue) + if (nanogramspermole.HasValue) { - return FromNanogramsPerMoles(nanogramspermoles.Value); + return FromNanogramsPerMole(nanogramspermole.Value); } else { @@ -1323,13 +1323,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable NanogramsPerMoles. + /// Get nullable MolarMass from nullable NanogramsPerMole. /// - public static MolarMass? FromNanogramsPerMoles(long? nanogramspermoles) + public static MolarMass? FromNanogramsPerMole(long? nanogramspermole) { - if (nanogramspermoles.HasValue) + if (nanogramspermole.HasValue) { - return FromNanogramsPerMoles(nanogramspermoles.Value); + return FromNanogramsPerMole(nanogramspermole.Value); } else { @@ -1338,13 +1338,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from NanogramsPerMoles of type decimal. + /// Get nullable MolarMass from NanogramsPerMole of type decimal. /// - public static MolarMass? FromNanogramsPerMoles(decimal? nanogramspermoles) + public static MolarMass? FromNanogramsPerMole(decimal? nanogramspermole) { - if (nanogramspermoles.HasValue) + if (nanogramspermole.HasValue) { - return FromNanogramsPerMoles(nanogramspermoles.Value); + return FromNanogramsPerMole(nanogramspermole.Value); } else { @@ -1353,13 +1353,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable PoundsPerMoles. + /// Get nullable MolarMass from nullable PoundsPerMole. /// - public static MolarMass? FromPoundsPerMoles(double? poundspermoles) + public static MolarMass? FromPoundsPerMole(double? poundspermole) { - if (poundspermoles.HasValue) + if (poundspermole.HasValue) { - return FromPoundsPerMoles(poundspermoles.Value); + return FromPoundsPerMole(poundspermole.Value); } else { @@ -1368,13 +1368,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable PoundsPerMoles. + /// Get nullable MolarMass from nullable PoundsPerMole. /// - public static MolarMass? FromPoundsPerMoles(int? poundspermoles) + public static MolarMass? FromPoundsPerMole(int? poundspermole) { - if (poundspermoles.HasValue) + if (poundspermole.HasValue) { - return FromPoundsPerMoles(poundspermoles.Value); + return FromPoundsPerMole(poundspermole.Value); } else { @@ -1383,13 +1383,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from nullable PoundsPerMoles. + /// Get nullable MolarMass from nullable PoundsPerMole. /// - public static MolarMass? FromPoundsPerMoles(long? poundspermoles) + public static MolarMass? FromPoundsPerMole(long? poundspermole) { - if (poundspermoles.HasValue) + if (poundspermole.HasValue) { - return FromPoundsPerMoles(poundspermoles.Value); + return FromPoundsPerMole(poundspermole.Value); } else { @@ -1398,13 +1398,13 @@ public static MolarMass FromPoundsPerMoles(decimal poundspermoles) } /// - /// Get nullable MolarMass from PoundsPerMoles of type decimal. + /// Get nullable MolarMass from PoundsPerMole of type decimal. /// - public static MolarMass? FromPoundsPerMoles(decimal? poundspermoles) + public static MolarMass? FromPoundsPerMole(decimal? poundspermole) { - if (poundspermoles.HasValue) + if (poundspermole.HasValue) { - return FromPoundsPerMoles(poundspermoles.Value); + return FromPoundsPerMole(poundspermole.Value); } else { @@ -1425,29 +1425,29 @@ public static MolarMass From(double val, MolarMassUnit fromUnit) switch (fromUnit) { case MolarMassUnit.CentigramPerMole: - return FromCentigramsPerMoles(val); + return FromCentigramsPerMole(val); case MolarMassUnit.DecagramPerMole: - return FromDecagramsPerMoles(val); + return FromDecagramsPerMole(val); case MolarMassUnit.DecigramPerMole: - return FromDecigramsPerMoles(val); + return FromDecigramsPerMole(val); case MolarMassUnit.GramPerMole: - return FromGramsPerMoles(val); + return FromGramsPerMole(val); case MolarMassUnit.HectogramPerMole: - return FromHectogramsPerMoles(val); + return FromHectogramsPerMole(val); case MolarMassUnit.KilogramPerMole: - return FromKilogramsPerMoles(val); + return FromKilogramsPerMole(val); case MolarMassUnit.KilopoundPerMole: - return FromKilopoundsPerMoles(val); + return FromKilopoundsPerMole(val); case MolarMassUnit.MegapoundPerMole: - return FromMegapoundsPerMoles(val); + return FromMegapoundsPerMole(val); case MolarMassUnit.MicrogramPerMole: - return FromMicrogramsPerMoles(val); + return FromMicrogramsPerMole(val); case MolarMassUnit.MilligramPerMole: - return FromMilligramsPerMoles(val); + return FromMilligramsPerMole(val); case MolarMassUnit.NanogramPerMole: - return FromNanogramsPerMoles(val); + return FromNanogramsPerMole(val); case MolarMassUnit.PoundPerMole: - return FromPoundsPerMoles(val); + return FromPoundsPerMole(val); default: throw new NotImplementedException("fromUnit: " + fromUnit); @@ -1471,29 +1471,29 @@ public static MolarMass From(double val, MolarMassUnit fromUnit) switch (fromUnit) { case MolarMassUnit.CentigramPerMole: - return FromCentigramsPerMoles(value.Value); + return FromCentigramsPerMole(value.Value); case MolarMassUnit.DecagramPerMole: - return FromDecagramsPerMoles(value.Value); + return FromDecagramsPerMole(value.Value); case MolarMassUnit.DecigramPerMole: - return FromDecigramsPerMoles(value.Value); + return FromDecigramsPerMole(value.Value); case MolarMassUnit.GramPerMole: - return FromGramsPerMoles(value.Value); + return FromGramsPerMole(value.Value); case MolarMassUnit.HectogramPerMole: - return FromHectogramsPerMoles(value.Value); + return FromHectogramsPerMole(value.Value); case MolarMassUnit.KilogramPerMole: - return FromKilogramsPerMoles(value.Value); + return FromKilogramsPerMole(value.Value); case MolarMassUnit.KilopoundPerMole: - return FromKilopoundsPerMoles(value.Value); + return FromKilopoundsPerMole(value.Value); case MolarMassUnit.MegapoundPerMole: - return FromMegapoundsPerMoles(value.Value); + return FromMegapoundsPerMole(value.Value); case MolarMassUnit.MicrogramPerMole: - return FromMicrogramsPerMoles(value.Value); + return FromMicrogramsPerMole(value.Value); case MolarMassUnit.MilligramPerMole: - return FromMilligramsPerMoles(value.Value); + return FromMilligramsPerMole(value.Value); case MolarMassUnit.NanogramPerMole: - return FromNanogramsPerMoles(value.Value); + return FromNanogramsPerMole(value.Value); case MolarMassUnit.PoundPerMole: - return FromPoundsPerMoles(value.Value); + return FromPoundsPerMole(value.Value); default: throw new NotImplementedException("fromUnit: " + fromUnit); @@ -1532,37 +1532,37 @@ public static string GetAbbreviation(MolarMassUnit unit, [CanBeNull] Culture cul #if !WINDOWS_UWP public static MolarMass operator -(MolarMass right) { - return new MolarMass(-right._kilogramsPerMoles); + return new MolarMass(-right._kilogramsPerMole); } public static MolarMass operator +(MolarMass left, MolarMass right) { - return new MolarMass(left._kilogramsPerMoles + right._kilogramsPerMoles); + return new MolarMass(left._kilogramsPerMole + right._kilogramsPerMole); } public static MolarMass operator -(MolarMass left, MolarMass right) { - return new MolarMass(left._kilogramsPerMoles - right._kilogramsPerMoles); + return new MolarMass(left._kilogramsPerMole - right._kilogramsPerMole); } public static MolarMass operator *(double left, MolarMass right) { - return new MolarMass(left*right._kilogramsPerMoles); + return new MolarMass(left*right._kilogramsPerMole); } public static MolarMass operator *(MolarMass left, double right) { - return new MolarMass(left._kilogramsPerMoles*(double)right); + return new MolarMass(left._kilogramsPerMole*(double)right); } public static MolarMass operator /(MolarMass left, double right) { - return new MolarMass(left._kilogramsPerMoles/(double)right); + return new MolarMass(left._kilogramsPerMole/(double)right); } public static double operator /(MolarMass left, MolarMass right) { - return Convert.ToDouble(left._kilogramsPerMoles/right._kilogramsPerMoles); + return Convert.ToDouble(left._kilogramsPerMole/right._kilogramsPerMole); } #endif @@ -1585,41 +1585,41 @@ public int CompareTo(object obj) #endif int CompareTo(MolarMass other) { - return _kilogramsPerMoles.CompareTo(other._kilogramsPerMoles); + return _kilogramsPerMole.CompareTo(other._kilogramsPerMole); } // Windows Runtime Component does not allow operator overloads: https://msdn.microsoft.com/en-us/library/br230301.aspx #if !WINDOWS_UWP public static bool operator <=(MolarMass left, MolarMass right) { - return left._kilogramsPerMoles <= right._kilogramsPerMoles; + return left._kilogramsPerMole <= right._kilogramsPerMole; } public static bool operator >=(MolarMass left, MolarMass right) { - return left._kilogramsPerMoles >= right._kilogramsPerMoles; + return left._kilogramsPerMole >= right._kilogramsPerMole; } public static bool operator <(MolarMass left, MolarMass right) { - return left._kilogramsPerMoles < right._kilogramsPerMoles; + return left._kilogramsPerMole < right._kilogramsPerMole; } public static bool operator >(MolarMass left, MolarMass right) { - return left._kilogramsPerMoles > right._kilogramsPerMoles; + return left._kilogramsPerMole > right._kilogramsPerMole; } public static bool operator ==(MolarMass left, MolarMass right) { // ReSharper disable once CompareOfFloatsByEqualityOperator - return left._kilogramsPerMoles == right._kilogramsPerMoles; + return left._kilogramsPerMole == right._kilogramsPerMole; } public static bool operator !=(MolarMass left, MolarMass right) { // ReSharper disable once CompareOfFloatsByEqualityOperator - return left._kilogramsPerMoles != right._kilogramsPerMoles; + return left._kilogramsPerMole != right._kilogramsPerMole; } #endif @@ -1630,12 +1630,12 @@ public override bool Equals(object obj) return false; } - return _kilogramsPerMoles.Equals(((MolarMass) obj)._kilogramsPerMoles); + return _kilogramsPerMole.Equals(((MolarMass) obj)._kilogramsPerMole); } public override int GetHashCode() { - return _kilogramsPerMoles.GetHashCode(); + return _kilogramsPerMole.GetHashCode(); } #endregion @@ -1652,29 +1652,29 @@ public double As(MolarMassUnit unit) switch (unit) { case MolarMassUnit.CentigramPerMole: - return CentigramsPerMoles; + return CentigramsPerMole; case MolarMassUnit.DecagramPerMole: - return DecagramsPerMoles; + return DecagramsPerMole; case MolarMassUnit.DecigramPerMole: - return DecigramsPerMoles; + return DecigramsPerMole; case MolarMassUnit.GramPerMole: - return GramsPerMoles; + return GramsPerMole; case MolarMassUnit.HectogramPerMole: - return HectogramsPerMoles; + return HectogramsPerMole; case MolarMassUnit.KilogramPerMole: - return KilogramsPerMoles; + return KilogramsPerMole; case MolarMassUnit.KilopoundPerMole: - return KilopoundsPerMoles; + return KilopoundsPerMole; case MolarMassUnit.MegapoundPerMole: - return MegapoundsPerMoles; + return MegapoundsPerMole; case MolarMassUnit.MicrogramPerMole: - return MicrogramsPerMoles; + return MicrogramsPerMole; case MolarMassUnit.MilligramPerMole: - return MilligramsPerMoles; + return MilligramsPerMole; case MolarMassUnit.NanogramPerMole: - return NanogramsPerMoles; + return NanogramsPerMole; case MolarMassUnit.PoundPerMole: - return PoundsPerMoles; + return PoundsPerMole; default: throw new NotImplementedException("unit: " + unit); @@ -1751,7 +1751,7 @@ public static MolarMass Parse(string str, [CanBeNull] Culture culture) double parsedValue = double.Parse(value, formatProvider2); MolarMassUnit parsedUnit = ParseUnit(unit, formatProvider2); return From(parsedValue, parsedUnit); - }, (x, y) => FromKilogramsPerMoles(x.KilogramsPerMoles + y.KilogramsPerMoles)); + }, (x, y) => FromKilogramsPerMole(x.KilogramsPerMole + y.KilogramsPerMole)); } /// diff --git a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs index d75c000f35..9deefc4110 100644 --- a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs +++ b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs @@ -1965,13 +1965,13 @@ private static readonly ReadOnlyCollection DefaultLocalization new CulturesForEnumValue((int) MolarMassUnit.KilopoundPerMole, new[] { - new AbbreviationsForCulture("en-US", "KLbs/mol"), + new AbbreviationsForCulture("en-US", "klb/mol"), new AbbreviationsForCulture("ru-RU", "kфунт/моль"), }), new CulturesForEnumValue((int) MolarMassUnit.MegapoundPerMole, new[] { - new AbbreviationsForCulture("en-US", "MLbs/mol"), + new AbbreviationsForCulture("en-US", "Mlb/mol"), new AbbreviationsForCulture("ru-RU", "Mфунт/моль"), }), new CulturesForEnumValue((int) MolarMassUnit.MicrogramPerMole,