Energy.g.cs

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by \generate-code.bat.
//
//     Changes to this file will be lost when the code is regenerated.
//     The build server regenerates the code before each build and a pre-build
//     step will regenerate the code on each local build.
//
//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
//
//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
//
// </auto-generated>
//------------------------------------------------------------------------------

// Licensed under MIT No Attribution, see LICENSE file at the root.
// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.

using System;
using System.Globalization;
using System.Linq;
using JetBrains.Annotations;
using UnitsNet.Units;
using UnitsNet.InternalHelpers;

// ReSharper disable once CheckNamespace

namespace UnitsNet
{
    /// <summary>
    ///     The joule, symbol J, is a derived unit of energy, work, or amount of heat in the International System of Units. It is equal to the energy transferred (or work done) when applying a force of one newton through a distance of one metre (1 newton metre or N·m), or in passing an electric current of one ampere through a resistance of one ohm for one second. Many other units of energy are included. Please do not confuse this definition of the calorie with the one colloquially used by the food industry, the large calorie, which is equivalent to 1 kcal. Thermochemical definition of the calorie is used. For BTU, the IT definition is used.
    /// </summary>
    // Windows Runtime Component has constraints on public types: https://msdn.microsoft.com/en-us/library/br230301.aspx#Declaring types in Windows Runtime Components
    // Public structures can't have any members other than public fields, and those fields must be value types or strings.
    // Public classes must be sealed (NotInheritable in Visual Basic). If your programming model requires polymorphism, you can create a public interface and implement that interface on the classes that must be polymorphic.
    public sealed partial class Energy : IQuantity
    {
        /// <summary>
        ///     The numeric value this quantity was constructed with.
        /// </summary>
        private readonly double _value;

        /// <summary>
        ///     The unit this quantity was constructed with.
        /// </summary>
        private readonly EnergyUnit? _unit;

        static Energy()
        {
            BaseDimensions = new BaseDimensions(2, 1, -2, 0, 0, 0, 0, 0);
            Info = new QuantityInfo(QuantityType.Energy, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
        }

        /// <summary>
        ///     Creates the quantity with a value of 0 in the base unit Joule.
        /// </summary>
        /// <remarks>
        ///     Windows Runtime Component requires a default constructor.
        /// </remarks>
        public Energy()
        {
            _value = 0;
            _unit = BaseUnit;
        }

        /// <summary>
        ///     Creates the quantity with the given numeric value and unit.
        /// </summary>
        /// <param name="value">The numeric value to construct this quantity with.</param>
        /// <param name="unit">The unit representation to construct this quantity with.</param>
        /// <remarks>Value parameter cannot be named 'value' due to constraint when targeting Windows Runtime Component.</remarks>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        private Energy(double value, EnergyUnit unit)
        {
            if(unit == EnergyUnit.Undefined)
              throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));

            _value = Guard.EnsureValidNumber(value, nameof(value));
            _unit = unit;
        }

        #region Static Properties

        /// <summary>
        ///     Information about the quantity type, such as unit values and names.
        /// </summary>
        internal static QuantityInfo Info { get; }

        /// <summary>
        ///     The <see cref="BaseDimensions" /> of this quantity.
        /// </summary>
        public static BaseDimensions BaseDimensions { get; }

        /// <summary>
        ///     The base unit of Energy, which is Joule. All conversions go via this value.
        /// </summary>
        public static EnergyUnit BaseUnit { get; } = EnergyUnit.Joule;

        /// <summary>
        /// Represents the largest possible value of Energy
        /// </summary>
        public static Energy MaxValue { get; } = new Energy(double.MaxValue, BaseUnit);

        /// <summary>
        /// Represents the smallest possible value of Energy
        /// </summary>
        public static Energy MinValue { get; } = new Energy(double.MinValue, BaseUnit);

        /// <summary>
        ///     The <see cref="QuantityType" /> of this quantity.
        /// </summary>
        public static QuantityType QuantityType { get; } = QuantityType.Energy;

        /// <summary>
        ///     All units of measurement for the Energy quantity.
        /// </summary>
        public static EnergyUnit[] Units { get; } = Enum.GetValues(typeof(EnergyUnit)).Cast<EnergyUnit>().Except(new EnergyUnit[]{ EnergyUnit.Undefined }).ToArray();

        /// <summary>
        ///     Gets an instance of this quantity with a value of 0 in the base unit Joule.
        /// </summary>
        public static Energy Zero { get; } = new Energy(0, BaseUnit);

        #endregion

        #region Properties

        /// <summary>
        ///     The numeric value this quantity was constructed with.
        /// </summary>
        public double Value => Convert.ToDouble(_value);

        /// <inheritdoc cref="IQuantity.Unit"/>
        object IQuantity.Unit => Unit;

        /// <summary>
        ///     The unit this quantity was constructed with -or- <see cref="BaseUnit" /> if default ctor was used.
        /// </summary>
        public EnergyUnit Unit => _unit.GetValueOrDefault(BaseUnit);

        internal QuantityInfo QuantityInfo => Info;

        /// <summary>
        ///     The <see cref="QuantityType" /> of this quantity.
        /// </summary>
        public QuantityType Type => Energy.QuantityType;

        /// <summary>
        ///     The <see cref="BaseDimensions" /> of this quantity.
        /// </summary>
        public BaseDimensions Dimensions => Energy.BaseDimensions;

        #endregion

        #region Conversion Properties

        /// <summary>
        ///     Get Energy in BritishThermalUnits.
        /// </summary>
        public double BritishThermalUnits => As(EnergyUnit.BritishThermalUnit);

        /// <summary>
        ///     Get Energy in Calories.
        /// </summary>
        public double Calories => As(EnergyUnit.Calorie);

        /// <summary>
        ///     Get Energy in DecathermsEc.
        /// </summary>
        public double DecathermsEc => As(EnergyUnit.DecathermEc);

        /// <summary>
        ///     Get Energy in DecathermsImperial.
        /// </summary>
        public double DecathermsImperial => As(EnergyUnit.DecathermImperial);

        /// <summary>
        ///     Get Energy in DecathermsUs.
        /// </summary>
        public double DecathermsUs => As(EnergyUnit.DecathermUs);

        /// <summary>
        ///     Get Energy in ElectronVolts.
        /// </summary>
        public double ElectronVolts => As(EnergyUnit.ElectronVolt);

        /// <summary>
        ///     Get Energy in Ergs.
        /// </summary>
        public double Ergs => As(EnergyUnit.Erg);

        /// <summary>
        ///     Get Energy in FootPounds.
        /// </summary>
        public double FootPounds => As(EnergyUnit.FootPound);

        /// <summary>
        ///     Get Energy in GigabritishThermalUnits.
        /// </summary>
        public double GigabritishThermalUnits => As(EnergyUnit.GigabritishThermalUnit);

        /// <summary>
        ///     Get Energy in GigaelectronVolts.
        /// </summary>
        public double GigaelectronVolts => As(EnergyUnit.GigaelectronVolt);

        /// <summary>
        ///     Get Energy in Gigajoules.
        /// </summary>
        public double Gigajoules => As(EnergyUnit.Gigajoule);

        /// <summary>
        ///     Get Energy in GigawattDays.
        /// </summary>
        public double GigawattDays => As(EnergyUnit.GigawattDay);

        /// <summary>
        ///     Get Energy in GigawattHours.
        /// </summary>
        public double GigawattHours => As(EnergyUnit.GigawattHour);

        /// <summary>
        ///     Get Energy in HorsepowerHours.
        /// </summary>
        public double HorsepowerHours => As(EnergyUnit.HorsepowerHour);

        /// <summary>
        ///     Get Energy in Joules.
        /// </summary>
        public double Joules => As(EnergyUnit.Joule);

        /// <summary>
        ///     Get Energy in KilobritishThermalUnits.
        /// </summary>
        public double KilobritishThermalUnits => As(EnergyUnit.KilobritishThermalUnit);

        /// <summary>
        ///     Get Energy in Kilocalories.
        /// </summary>
        public double Kilocalories => As(EnergyUnit.Kilocalorie);

        /// <summary>
        ///     Get Energy in KiloelectronVolts.
        /// </summary>
        public double KiloelectronVolts => As(EnergyUnit.KiloelectronVolt);

        /// <summary>
        ///     Get Energy in Kilojoules.
        /// </summary>
        public double Kilojoules => As(EnergyUnit.Kilojoule);

        /// <summary>
        ///     Get Energy in KilowattDays.
        /// </summary>
        public double KilowattDays => As(EnergyUnit.KilowattDay);

        /// <summary>
        ///     Get Energy in KilowattHours.
        /// </summary>
        public double KilowattHours => As(EnergyUnit.KilowattHour);

        /// <summary>
        ///     Get Energy in MegabritishThermalUnits.
        /// </summary>
        public double MegabritishThermalUnits => As(EnergyUnit.MegabritishThermalUnit);

        /// <summary>
        ///     Get Energy in Megacalories.
        /// </summary>
        public double Megacalories => As(EnergyUnit.Megacalorie);

        /// <summary>
        ///     Get Energy in MegaelectronVolts.
        /// </summary>
        public double MegaelectronVolts => As(EnergyUnit.MegaelectronVolt);

        /// <summary>
        ///     Get Energy in Megajoules.
        /// </summary>
        public double Megajoules => As(EnergyUnit.Megajoule);

        /// <summary>
        ///     Get Energy in MegawattDays.
        /// </summary>
        public double MegawattDays => As(EnergyUnit.MegawattDay);

        /// <summary>
        ///     Get Energy in MegawattHours.
        /// </summary>
        public double MegawattHours => As(EnergyUnit.MegawattHour);

        /// <summary>
        ///     Get Energy in Millijoules.
        /// </summary>
        public double Millijoules => As(EnergyUnit.Millijoule);

        /// <summary>
        ///     Get Energy in TeraelectronVolts.
        /// </summary>
        public double TeraelectronVolts => As(EnergyUnit.TeraelectronVolt);

        /// <summary>
        ///     Get Energy in TerawattDays.
        /// </summary>
        public double TerawattDays => As(EnergyUnit.TerawattDay);

        /// <summary>
        ///     Get Energy in TerawattHours.
        /// </summary>
        public double TerawattHours => As(EnergyUnit.TerawattHour);

        /// <summary>
        ///     Get Energy in ThermsEc.
        /// </summary>
        public double ThermsEc => As(EnergyUnit.ThermEc);

        /// <summary>
        ///     Get Energy in ThermsImperial.
        /// </summary>
        public double ThermsImperial => As(EnergyUnit.ThermImperial);

        /// <summary>
        ///     Get Energy in ThermsUs.
        /// </summary>
        public double ThermsUs => As(EnergyUnit.ThermUs);

        /// <summary>
        ///     Get Energy in WattDays.
        /// </summary>
        public double WattDays => As(EnergyUnit.WattDay);

        /// <summary>
        ///     Get Energy in WattHours.
        /// </summary>
        public double WattHours => As(EnergyUnit.WattHour);

        #endregion

        #region Static Methods

        /// <summary>
        ///     Get unit abbreviation string.
        /// </summary>
        /// <param name="unit">Unit to get abbreviation for.</param>
        /// <returns>Unit abbreviation string.</returns>
        public static string GetAbbreviation(EnergyUnit unit)
        {
            return GetAbbreviation(unit, null);
        }

        /// <summary>
        ///     Get unit abbreviation string.
        /// </summary>
        /// <param name="unit">Unit to get abbreviation for.</param>
        /// <returns>Unit abbreviation string.</returns>
        /// <param name="cultureName">Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param>
        public static string GetAbbreviation(EnergyUnit unit, [CanBeNull] string cultureName)
        {
            IFormatProvider provider = GetFormatProviderFromCultureName(cultureName);
            return UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit, provider);
        }

        #endregion

        #region Static Factory Methods

        /// <summary>
        ///     Get Energy from BritishThermalUnits.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromBritishThermalUnits(double britishthermalunits)
        {
            double value = (double) britishthermalunits;
            return new Energy(value, EnergyUnit.BritishThermalUnit);
        }
        /// <summary>
        ///     Get Energy from Calories.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromCalories(double calories)
        {
            double value = (double) calories;
            return new Energy(value, EnergyUnit.Calorie);
        }
        /// <summary>
        ///     Get Energy from DecathermsEc.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromDecathermsEc(double decathermsec)
        {
            double value = (double) decathermsec;
            return new Energy(value, EnergyUnit.DecathermEc);
        }
        /// <summary>
        ///     Get Energy from DecathermsImperial.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromDecathermsImperial(double decathermsimperial)
        {
            double value = (double) decathermsimperial;
            return new Energy(value, EnergyUnit.DecathermImperial);
        }
        /// <summary>
        ///     Get Energy from DecathermsUs.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromDecathermsUs(double decathermsus)
        {
            double value = (double) decathermsus;
            return new Energy(value, EnergyUnit.DecathermUs);
        }
        /// <summary>
        ///     Get Energy from ElectronVolts.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromElectronVolts(double electronvolts)
        {
            double value = (double) electronvolts;
            return new Energy(value, EnergyUnit.ElectronVolt);
        }
        /// <summary>
        ///     Get Energy from Ergs.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromErgs(double ergs)
        {
            double value = (double) ergs;
            return new Energy(value, EnergyUnit.Erg);
        }
        /// <summary>
        ///     Get Energy from FootPounds.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromFootPounds(double footpounds)
        {
            double value = (double) footpounds;
            return new Energy(value, EnergyUnit.FootPound);
        }
        /// <summary>
        ///     Get Energy from GigabritishThermalUnits.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromGigabritishThermalUnits(double gigabritishthermalunits)
        {
            double value = (double) gigabritishthermalunits;
            return new Energy(value, EnergyUnit.GigabritishThermalUnit);
        }
        /// <summary>
        ///     Get Energy from GigaelectronVolts.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromGigaelectronVolts(double gigaelectronvolts)
        {
            double value = (double) gigaelectronvolts;
            return new Energy(value, EnergyUnit.GigaelectronVolt);
        }
        /// <summary>
        ///     Get Energy from Gigajoules.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromGigajoules(double gigajoules)
        {
            double value = (double) gigajoules;
            return new Energy(value, EnergyUnit.Gigajoule);
        }
        /// <summary>
        ///     Get Energy from GigawattDays.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromGigawattDays(double gigawattdays)
        {
            double value = (double) gigawattdays;
            return new Energy(value, EnergyUnit.GigawattDay);
        }
        /// <summary>
        ///     Get Energy from GigawattHours.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromGigawattHours(double gigawatthours)
        {
            double value = (double) gigawatthours;
            return new Energy(value, EnergyUnit.GigawattHour);
        }
        /// <summary>
        ///     Get Energy from HorsepowerHours.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromHorsepowerHours(double horsepowerhours)
        {
            double value = (double) horsepowerhours;
            return new Energy(value, EnergyUnit.HorsepowerHour);
        }
        /// <summary>
        ///     Get Energy from Joules.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromJoules(double joules)
        {
            double value = (double) joules;
            return new Energy(value, EnergyUnit.Joule);
        }
        /// <summary>
        ///     Get Energy from KilobritishThermalUnits.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromKilobritishThermalUnits(double kilobritishthermalunits)
        {
            double value = (double) kilobritishthermalunits;
            return new Energy(value, EnergyUnit.KilobritishThermalUnit);
        }
        /// <summary>
        ///     Get Energy from Kilocalories.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromKilocalories(double kilocalories)
        {
            double value = (double) kilocalories;
            return new Energy(value, EnergyUnit.Kilocalorie);
        }
        /// <summary>
        ///     Get Energy from KiloelectronVolts.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromKiloelectronVolts(double kiloelectronvolts)
        {
            double value = (double) kiloelectronvolts;
            return new Energy(value, EnergyUnit.KiloelectronVolt);
        }
        /// <summary>
        ///     Get Energy from Kilojoules.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromKilojoules(double kilojoules)
        {
            double value = (double) kilojoules;
            return new Energy(value, EnergyUnit.Kilojoule);
        }
        /// <summary>
        ///     Get Energy from KilowattDays.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromKilowattDays(double kilowattdays)
        {
            double value = (double) kilowattdays;
            return new Energy(value, EnergyUnit.KilowattDay);
        }
        /// <summary>
        ///     Get Energy from KilowattHours.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromKilowattHours(double kilowatthours)
        {
            double value = (double) kilowatthours;
            return new Energy(value, EnergyUnit.KilowattHour);
        }
        /// <summary>
        ///     Get Energy from MegabritishThermalUnits.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromMegabritishThermalUnits(double megabritishthermalunits)
        {
            double value = (double) megabritishthermalunits;
            return new Energy(value, EnergyUnit.MegabritishThermalUnit);
        }
        /// <summary>
        ///     Get Energy from Megacalories.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromMegacalories(double megacalories)
        {
            double value = (double) megacalories;
            return new Energy(value, EnergyUnit.Megacalorie);
        }
        /// <summary>
        ///     Get Energy from MegaelectronVolts.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromMegaelectronVolts(double megaelectronvolts)
        {
            double value = (double) megaelectronvolts;
            return new Energy(value, EnergyUnit.MegaelectronVolt);
        }
        /// <summary>
        ///     Get Energy from Megajoules.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromMegajoules(double megajoules)
        {
            double value = (double) megajoules;
            return new Energy(value, EnergyUnit.Megajoule);
        }
        /// <summary>
        ///     Get Energy from MegawattDays.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromMegawattDays(double megawattdays)
        {
            double value = (double) megawattdays;
            return new Energy(value, EnergyUnit.MegawattDay);
        }
        /// <summary>
        ///     Get Energy from MegawattHours.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromMegawattHours(double megawatthours)
        {
            double value = (double) megawatthours;
            return new Energy(value, EnergyUnit.MegawattHour);
        }
        /// <summary>
        ///     Get Energy from Millijoules.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromMillijoules(double millijoules)
        {
            double value = (double) millijoules;
            return new Energy(value, EnergyUnit.Millijoule);
        }
        /// <summary>
        ///     Get Energy from TeraelectronVolts.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromTeraelectronVolts(double teraelectronvolts)
        {
            double value = (double) teraelectronvolts;
            return new Energy(value, EnergyUnit.TeraelectronVolt);
        }
        /// <summary>
        ///     Get Energy from TerawattDays.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromTerawattDays(double terawattdays)
        {
            double value = (double) terawattdays;
            return new Energy(value, EnergyUnit.TerawattDay);
        }
        /// <summary>
        ///     Get Energy from TerawattHours.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromTerawattHours(double terawatthours)
        {
            double value = (double) terawatthours;
            return new Energy(value, EnergyUnit.TerawattHour);
        }
        /// <summary>
        ///     Get Energy from ThermsEc.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromThermsEc(double thermsec)
        {
            double value = (double) thermsec;
            return new Energy(value, EnergyUnit.ThermEc);
        }
        /// <summary>
        ///     Get Energy from ThermsImperial.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromThermsImperial(double thermsimperial)
        {
            double value = (double) thermsimperial;
            return new Energy(value, EnergyUnit.ThermImperial);
        }
        /// <summary>
        ///     Get Energy from ThermsUs.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromThermsUs(double thermsus)
        {
            double value = (double) thermsus;
            return new Energy(value, EnergyUnit.ThermUs);
        }
        /// <summary>
        ///     Get Energy from WattDays.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromWattDays(double wattdays)
        {
            double value = (double) wattdays;
            return new Energy(value, EnergyUnit.WattDay);
        }
        /// <summary>
        ///     Get Energy from WattHours.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Energy FromWattHours(double watthours)
        {
            double value = (double) watthours;
            return new Energy(value, EnergyUnit.WattHour);
        }

        /// <summary>
        ///     Dynamically convert from value and unit enum <see cref="EnergyUnit" /> to <see cref="Energy" />.
        /// </summary>
        /// <param name="value">Value to convert from.</param>
        /// <param name="fromUnit">Unit to convert from.</param>
        /// <returns>Energy unit value.</returns>
        // Fix name conflict with parameter "value"
        [return: System.Runtime.InteropServices.WindowsRuntime.ReturnValueName("returnValue")]
        public static Energy From(double value, EnergyUnit fromUnit)
        {
            return new Energy((double)value, fromUnit);
        }

        #endregion

        #region Static Parse Methods

        /// <summary>
        ///     Parse a string with one or two quantities of the format "&lt;quantity&gt; &lt;unit&gt;".
        /// </summary>
        /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
        /// <example>
        ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
        /// </example>
        /// <exception cref="ArgumentNullException">The value of 'str' cannot be null. </exception>
        /// <exception cref="ArgumentException">
        ///     Expected string to have one or two pairs of quantity and unit in the format
        ///     "&lt;quantity&gt; &lt;unit&gt;". Eg. "5.5 m" or "1ft 2in"
        /// </exception>
        /// <exception cref="AmbiguousUnitParseException">
        ///     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
        ///     <see cref="VolumeUnit.MetricCup" />, <see cref="VolumeUnit.UsLegalCup" /> and <see cref="VolumeUnit.UsCustomaryCup" />.
        /// </exception>
        /// <exception cref="UnitsNetException">
        ///     If anything else goes wrong, typically due to a bug or unhandled case.
        ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
        ///     Units.NET exceptions from other exceptions.
        /// </exception>
        public static Energy Parse(string str)
        {
            return Parse(str, null);
        }

        /// <summary>
        ///     Parse a string with one or two quantities of the format "&lt;quantity&gt; &lt;unit&gt;".
        /// </summary>
        /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
        /// <example>
        ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
        /// </example>
        /// <exception cref="ArgumentNullException">The value of 'str' cannot be null. </exception>
        /// <exception cref="ArgumentException">
        ///     Expected string to have one or two pairs of quantity and unit in the format
        ///     "&lt;quantity&gt; &lt;unit&gt;". Eg. "5.5 m" or "1ft 2in"
        /// </exception>
        /// <exception cref="AmbiguousUnitParseException">
        ///     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
        ///     <see cref="VolumeUnit.MetricCup" />, <see cref="VolumeUnit.UsLegalCup" /> and <see cref="VolumeUnit.UsCustomaryCup" />.
        /// </exception>
        /// <exception cref="UnitsNetException">
        ///     If anything else goes wrong, typically due to a bug or unhandled case.
        ///     We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
        ///     Units.NET exceptions from other exceptions.
        /// </exception>
        /// <param name="cultureName">Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param>
        public static Energy Parse(string str, [CanBeNull] string cultureName)
        {
            IFormatProvider provider = GetFormatProviderFromCultureName(cultureName);
            return QuantityParser.Default.Parse<Energy, EnergyUnit>(
                str,
                provider,
                From);
        }

        /// <summary>
        ///     Try to parse a string with one or two quantities of the format "&lt;quantity&gt; &lt;unit&gt;".
        /// </summary>
        /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
        /// <param name="result">Resulting unit quantity if successful.</param>
        /// <example>
        ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
        /// </example>
        public static bool TryParse([CanBeNull] string str, out Energy result)
        {
            return TryParse(str, null, out result);
        }

        /// <summary>
        ///     Try to parse a string with one or two quantities of the format "&lt;quantity&gt; &lt;unit&gt;".
        /// </summary>
        /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
        /// <param name="result">Resulting unit quantity if successful.</param>
        /// <returns>True if successful, otherwise false.</returns>
        /// <example>
        ///     Length.Parse("5.5 m", new CultureInfo("en-US"));
        /// </example>
        /// <param name="cultureName">Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param>
        public static bool TryParse([CanBeNull] string str, [CanBeNull] string cultureName, out Energy result)
        {
            IFormatProvider provider = GetFormatProviderFromCultureName(cultureName);
            return QuantityParser.Default.TryParse<Energy, EnergyUnit>(
                str,
                provider,
                From,
                out result);
        }

        /// <summary>
        ///     Parse a unit string.
        /// </summary>
        /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
        /// <example>
        ///     Length.ParseUnit("m", new CultureInfo("en-US"));
        /// </example>
        /// <exception cref="ArgumentNullException">The value of 'str' cannot be null. </exception>
        /// <exception cref="UnitsNetException">Error parsing string.</exception>
        public static EnergyUnit ParseUnit(string str)
        {
            return ParseUnit(str, null);
        }

        /// <summary>
        ///     Parse a unit string.
        /// </summary>
        /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
        /// <example>
        ///     Length.ParseUnit("m", new CultureInfo("en-US"));
        /// </example>
        /// <exception cref="ArgumentNullException">The value of 'str' cannot be null. </exception>
        /// <exception cref="UnitsNetException">Error parsing string.</exception>
        /// <param name="cultureName">Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param>
        public static EnergyUnit ParseUnit(string str, [CanBeNull] string cultureName)
        {
            IFormatProvider provider = GetFormatProviderFromCultureName(cultureName);
            return UnitParser.Default.Parse<EnergyUnit>(str, provider);
        }

        public static bool TryParseUnit(string str, out EnergyUnit unit)
        {
            return TryParseUnit(str, null, out unit);
        }

        /// <summary>
        ///     Parse a unit string.
        /// </summary>
        /// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
        /// <param name="unit">The parsed unit if successful.</param>
        /// <returns>True if successful, otherwise false.</returns>
        /// <example>
        ///     Length.TryParseUnit("m", new CultureInfo("en-US"));
        /// </example>
        /// <param name="cultureName">Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param>
        public static bool TryParseUnit(string str, [CanBeNull] string cultureName, out EnergyUnit unit)
        {
            IFormatProvider provider = GetFormatProviderFromCultureName(cultureName);
            return UnitParser.Default.TryParse<EnergyUnit>(str, provider, out unit);
        }

        #endregion

        #region Equality / IComparable

        public int CompareTo(object obj)
        {
            if(obj is null) throw new ArgumentNullException(nameof(obj));
            if(!(obj is Energy objEnergy)) throw new ArgumentException("Expected type Energy.", nameof(obj));

            return CompareTo(objEnergy);
        }

        // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods
        internal int CompareTo(Energy other)
        {
            return _value.CompareTo(other.AsBaseNumericType(this.Unit));
        }

        [Windows.Foundation.Metadata.DefaultOverload]
        public override bool Equals(object obj)
        {
            if(obj is null || !(obj is Energy objEnergy))
                return false;

            return Equals(objEnergy);
        }

        public bool Equals(Energy other)
        {
            return _value.Equals(other.AsBaseNumericType(this.Unit));
        }

        /// <summary>
        ///     <para>
        ///     Compare equality to another Energy within the given absolute or relative tolerance.
        ///     </para>
        ///     <para>
        ///     Relative tolerance is defined as the maximum allowable absolute difference between this quantity's value and
        ///     <paramref name="other"/> as a percentage of this quantity's value. <paramref name="other"/> will be converted into
        ///     this quantity's unit for comparison. A relative tolerance of 0.01 means the absolute difference must be within +/- 1% of
        ///     this quantity's value to be considered equal.
        ///     <example>
        ///     In this example, the two quantities will be equal if the value of b is within +/- 1% of a (0.02m or 2cm).
        ///     <code>
        ///     var a = Length.FromMeters(2.0);
        ///     var b = Length.FromInches(50.0);
        ///     a.Equals(b, 0.01, ComparisonType.Relative);
        ///     </code>
        ///     </example>
        ///     </para>
        ///     <para>
        ///     Absolute tolerance is defined as the maximum allowable absolute difference between this quantity's value and
        ///     <paramref name="other"/> as a fixed number in this quantity's unit. <paramref name="other"/> will be converted into
        ///     this quantity's unit for comparison.
        ///     <example>
        ///     In this example, the two quantities will be equal if the value of b is within 0.01 of a (0.01m or 1cm).
        ///     <code>
        ///     var a = Length.FromMeters(2.0);
        ///     var b = Length.FromInches(50.0);
        ///     a.Equals(b, 0.01, ComparisonType.Absolute);
        ///     </code>
        ///     </example>
        ///     </para>
        ///     <para>
        ///     Note that it is advised against specifying zero difference, due to the nature
        ///     of floating point operations and using System.Double internally.
        ///     </para>
        /// </summary>
        /// <param name="other">The other quantity to compare to.</param>
        /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
        /// <param name="comparisonType">The comparison type: either relative or absolute.</param>
        /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
        public bool Equals(Energy other, double tolerance, ComparisonType comparisonType)
        {
            if(tolerance < 0)
                throw new ArgumentOutOfRangeException("tolerance", "Tolerance must be greater than or equal to 0.");

            double thisValue = (double)this.Value;
            double otherValueInThisUnits = other.As(this.Unit);

            return UnitsNet.Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType);
        }

        /// <summary>
        ///     Returns the hash code for this instance.
        /// </summary>
        /// <returns>A hash code for the current Energy.</returns>
        public override int GetHashCode()
        {
            return new { QuantityType, Value, Unit }.GetHashCode();
        }

        #endregion

        #region Conversion Methods

        double IQuantity.As(object unit) => As((EnergyUnit)unit);

        /// <summary>
        ///     Convert to the unit representation <paramref name="unit" />.
        /// </summary>
        /// <returns>Value converted to the specified unit.</returns>
        public double As(EnergyUnit unit)
        {
            if(Unit == unit)
                return Convert.ToDouble(Value);

            var converted = AsBaseNumericType(unit);
            return Convert.ToDouble(converted);
        }

        /// <summary>
        ///     Converts this Energy to another Energy with the unit representation <paramref name="unit" />.
        /// </summary>
        /// <returns>A Energy with the specified unit.</returns>
        public Energy ToUnit(EnergyUnit unit)
        {
            var convertedValue = AsBaseNumericType(unit);
            return new Energy(convertedValue, unit);
        }

        /// <summary>
        ///     Converts the current value + unit to the base unit.
        ///     This is typically the first step in converting from one unit to another.
        /// </summary>
        /// <returns>The value in the base unit representation.</returns>
        private double AsBaseUnit()
        {
            switch(Unit)
            {
                case EnergyUnit.BritishThermalUnit: return _value*1055.05585262;
                case EnergyUnit.Calorie: return _value*4.184;
                case EnergyUnit.DecathermEc: return (_value*1.05505585262e8) * 1e1d;
                case EnergyUnit.DecathermImperial: return (_value*1.05505585257348e8) * 1e1d;
                case EnergyUnit.DecathermUs: return (_value*1.054804e8) * 1e1d;
                case EnergyUnit.ElectronVolt: return _value*1.602176565e-19;
                case EnergyUnit.Erg: return _value*1e-7;
                case EnergyUnit.FootPound: return _value*1.355817948;
                case EnergyUnit.GigabritishThermalUnit: return (_value*1055.05585262) * 1e9d;
                case EnergyUnit.GigaelectronVolt: return (_value*1.602176565e-19) * 1e9d;
                case EnergyUnit.Gigajoule: return (_value) * 1e9d;
                case EnergyUnit.GigawattDay: return (_value*24*3600d) * 1e9d;
                case EnergyUnit.GigawattHour: return (_value*3600d) * 1e9d;
                case EnergyUnit.HorsepowerHour: return _value*2.6845195377e6;
                case EnergyUnit.Joule: return _value;
                case EnergyUnit.KilobritishThermalUnit: return (_value*1055.05585262) * 1e3d;
                case EnergyUnit.Kilocalorie: return (_value*4.184) * 1e3d;
                case EnergyUnit.KiloelectronVolt: return (_value*1.602176565e-19) * 1e3d;
                case EnergyUnit.Kilojoule: return (_value) * 1e3d;
                case EnergyUnit.KilowattDay: return (_value*24*3600d) * 1e3d;
                case EnergyUnit.KilowattHour: return (_value*3600d) * 1e3d;
                case EnergyUnit.MegabritishThermalUnit: return (_value*1055.05585262) * 1e6d;
                case EnergyUnit.Megacalorie: return (_value*4.184) * 1e6d;
                case EnergyUnit.MegaelectronVolt: return (_value*1.602176565e-19) * 1e6d;
                case EnergyUnit.Megajoule: return (_value) * 1e6d;
                case EnergyUnit.MegawattDay: return (_value*24*3600d) * 1e6d;
                case EnergyUnit.MegawattHour: return (_value*3600d) * 1e6d;
                case EnergyUnit.Millijoule: return (_value) * 1e-3d;
                case EnergyUnit.TeraelectronVolt: return (_value*1.602176565e-19) * 1e12d;
                case EnergyUnit.TerawattDay: return (_value*24*3600d) * 1e12d;
                case EnergyUnit.TerawattHour: return (_value*3600d) * 1e12d;
                case EnergyUnit.ThermEc: return _value*1.05505585262e8;
                case EnergyUnit.ThermImperial: return _value*1.05505585257348e8;
                case EnergyUnit.ThermUs: return _value*1.054804e8;
                case EnergyUnit.WattDay: return _value*24*3600d;
                case EnergyUnit.WattHour: return _value*3600d;
                default:
                    throw new NotImplementedException($"Can not convert {Unit} to base units.");
            }
        }

        private double AsBaseNumericType(EnergyUnit unit)
        {
            if(Unit == unit)
                return _value;

            var baseUnitValue = AsBaseUnit();

            switch(unit)
            {
                case EnergyUnit.BritishThermalUnit: return baseUnitValue/1055.05585262;
                case EnergyUnit.Calorie: return baseUnitValue/4.184;
                case EnergyUnit.DecathermEc: return (baseUnitValue/1.05505585262e8) / 1e1d;
                case EnergyUnit.DecathermImperial: return (baseUnitValue/1.05505585257348e8) / 1e1d;
                case EnergyUnit.DecathermUs: return (baseUnitValue/1.054804e8) / 1e1d;
                case EnergyUnit.ElectronVolt: return baseUnitValue/1.602176565e-19;
                case EnergyUnit.Erg: return baseUnitValue/1e-7;
                case EnergyUnit.FootPound: return baseUnitValue/1.355817948;
                case EnergyUnit.GigabritishThermalUnit: return (baseUnitValue/1055.05585262) / 1e9d;
                case EnergyUnit.GigaelectronVolt: return (baseUnitValue/1.602176565e-19) / 1e9d;
                case EnergyUnit.Gigajoule: return (baseUnitValue) / 1e9d;
                case EnergyUnit.GigawattDay: return (baseUnitValue/(24*3600d)) / 1e9d;
                case EnergyUnit.GigawattHour: return (baseUnitValue/3600d) / 1e9d;
                case EnergyUnit.HorsepowerHour: return baseUnitValue/2.6845195377e6;
                case EnergyUnit.Joule: return baseUnitValue;
                case EnergyUnit.KilobritishThermalUnit: return (baseUnitValue/1055.05585262) / 1e3d;
                case EnergyUnit.Kilocalorie: return (baseUnitValue/4.184) / 1e3d;
                case EnergyUnit.KiloelectronVolt: return (baseUnitValue/1.602176565e-19) / 1e3d;
                case EnergyUnit.Kilojoule: return (baseUnitValue) / 1e3d;
                case EnergyUnit.KilowattDay: return (baseUnitValue/(24*3600d)) / 1e3d;
                case EnergyUnit.KilowattHour: return (baseUnitValue/3600d) / 1e3d;
                case EnergyUnit.MegabritishThermalUnit: return (baseUnitValue/1055.05585262) / 1e6d;
                case EnergyUnit.Megacalorie: return (baseUnitValue/4.184) / 1e6d;
                case EnergyUnit.MegaelectronVolt: return (baseUnitValue/1.602176565e-19) / 1e6d;
                case EnergyUnit.Megajoule: return (baseUnitValue) / 1e6d;
                case EnergyUnit.MegawattDay: return (baseUnitValue/(24*3600d)) / 1e6d;
                case EnergyUnit.MegawattHour: return (baseUnitValue/3600d) / 1e6d;
                case EnergyUnit.Millijoule: return (baseUnitValue) / 1e-3d;
                case EnergyUnit.TeraelectronVolt: return (baseUnitValue/1.602176565e-19) / 1e12d;
                case EnergyUnit.TerawattDay: return (baseUnitValue/(24*3600d)) / 1e12d;
                case EnergyUnit.TerawattHour: return (baseUnitValue/3600d) / 1e12d;
                case EnergyUnit.ThermEc: return baseUnitValue/1.05505585262e8;
                case EnergyUnit.ThermImperial: return baseUnitValue/1.05505585257348e8;
                case EnergyUnit.ThermUs: return baseUnitValue/1.054804e8;
                case EnergyUnit.WattDay: return baseUnitValue/(24*3600d);
                case EnergyUnit.WattHour: return baseUnitValue/3600d;
                default:
                    throw new NotImplementedException($"Can not convert {Unit} to {unit}.");
            }
        }

        #endregion

        #region ToString Methods

        /// <summary>
        ///     Get default string representation of value and unit.
        /// </summary>
        /// <returns>String representation.</returns>
        public override string ToString()
        {
            return ToString(null);
        }

        /// <summary>
        ///     Get string representation of value and unit. Using two significant digits after radix.
        /// </summary>
        /// <returns>String representation.</returns>
        /// <param name="cultureName">Name of culture (ex: "en-US") to use for localization and number formatting. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param>
        public string ToString([CanBeNull] string cultureName)
        {
            var provider = cultureName;
            return ToString(provider, 2);
        }

        /// <summary>
        ///     Get string representation of value and unit.
        /// </summary>
        /// <param name="significantDigitsAfterRadix">The number of significant digits after the radix point.</param>
        /// <returns>String representation.</returns>
        /// <param name="cultureName">Name of culture (ex: "en-US") to use for localization and number formatting. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param>
        public string ToString(string cultureName, int significantDigitsAfterRadix)
        {
            var provider = cultureName;
            var value = Convert.ToDouble(Value);
            var format = UnitFormatter.GetFormat(value, significantDigitsAfterRadix);
            return ToString(provider, format);
        }

        /// <summary>
        ///     Get string representation of value and unit.
        /// </summary>
        /// <param name="format">String format to use. Default:  "{0:0.##} {1} for value and unit abbreviation respectively."</param>
        /// <param name="args">Arguments for string format. Value and unit are implicitly included as arguments 0 and 1.</param>
        /// <returns>String representation.</returns>
        /// <param name="cultureName">Name of culture (ex: "en-US") to use for localization and number formatting. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param>
        public string ToString([CanBeNull] string cultureName, [NotNull] string format, [NotNull] params object[] args)
        {
            var provider = GetFormatProviderFromCultureName(cultureName);
            if (format == null) throw new ArgumentNullException(nameof(format));
            if (args == null) throw new ArgumentNullException(nameof(args));

            provider = provider ?? GlobalConfiguration.DefaultCulture;

            var value = Convert.ToDouble(Value);
            var formatArgs = UnitFormatter.GetFormatArgs(Unit, value, provider, args);
            return string.Format(provider, format, formatArgs);
        }

        #endregion

        private static IFormatProvider GetFormatProviderFromCultureName([CanBeNull] string cultureName)
        {
            return cultureName != null ? new CultureInfo(cultureName) : (IFormatProvider)null;
        }
    }
}