Acceleration.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>
    ///     Acceleration, in physics, is the rate at which the velocity of an object changes over time. An object's acceleration is the net result of any and all forces acting on the object, as described by Newton's Second Law. The SI unit for acceleration is the Meter per second squared (m/s²). Accelerations are vector quantities (they have magnitude and direction) and add according to the parallelogram law. As a vector, the calculated net force is equal to the product of the object's mass (a scalar quantity) and the acceleration.
    /// </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 Acceleration : 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 AccelerationUnit? _unit;

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

        /// <summary>
        ///     Creates the quantity with a value of 0 in the base unit MeterPerSecondSquared.
        /// </summary>
        /// <remarks>
        ///     Windows Runtime Component requires a default constructor.
        /// </remarks>
        public Acceleration()
        {
            _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 Acceleration(double value, AccelerationUnit unit)
        {
            if(unit == AccelerationUnit.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 Acceleration, which is MeterPerSecondSquared. All conversions go via this value.
        /// </summary>
        public static AccelerationUnit BaseUnit { get; } = AccelerationUnit.MeterPerSecondSquared;

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

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

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

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

        /// <summary>
        ///     Gets an instance of this quantity with a value of 0 in the base unit MeterPerSecondSquared.
        /// </summary>
        public static Acceleration Zero { get; } = new Acceleration(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 AccelerationUnit Unit => _unit.GetValueOrDefault(BaseUnit);

        internal QuantityInfo QuantityInfo => Info;

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

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

        #endregion

        #region Conversion Properties

        /// <summary>
        ///     Get Acceleration in CentimetersPerSecondSquared.
        /// </summary>
        public double CentimetersPerSecondSquared => As(AccelerationUnit.CentimeterPerSecondSquared);

        /// <summary>
        ///     Get Acceleration in DecimetersPerSecondSquared.
        /// </summary>
        public double DecimetersPerSecondSquared => As(AccelerationUnit.DecimeterPerSecondSquared);

        /// <summary>
        ///     Get Acceleration in FeetPerSecondSquared.
        /// </summary>
        public double FeetPerSecondSquared => As(AccelerationUnit.FootPerSecondSquared);

        /// <summary>
        ///     Get Acceleration in InchesPerSecondSquared.
        /// </summary>
        public double InchesPerSecondSquared => As(AccelerationUnit.InchPerSecondSquared);

        /// <summary>
        ///     Get Acceleration in KilometersPerSecondSquared.
        /// </summary>
        public double KilometersPerSecondSquared => As(AccelerationUnit.KilometerPerSecondSquared);

        /// <summary>
        ///     Get Acceleration in KnotsPerHour.
        /// </summary>
        public double KnotsPerHour => As(AccelerationUnit.KnotPerHour);

        /// <summary>
        ///     Get Acceleration in KnotsPerMinute.
        /// </summary>
        public double KnotsPerMinute => As(AccelerationUnit.KnotPerMinute);

        /// <summary>
        ///     Get Acceleration in KnotsPerSecond.
        /// </summary>
        public double KnotsPerSecond => As(AccelerationUnit.KnotPerSecond);

        /// <summary>
        ///     Get Acceleration in MetersPerSecondSquared.
        /// </summary>
        public double MetersPerSecondSquared => As(AccelerationUnit.MeterPerSecondSquared);

        /// <summary>
        ///     Get Acceleration in MicrometersPerSecondSquared.
        /// </summary>
        public double MicrometersPerSecondSquared => As(AccelerationUnit.MicrometerPerSecondSquared);

        /// <summary>
        ///     Get Acceleration in MillimetersPerSecondSquared.
        /// </summary>
        public double MillimetersPerSecondSquared => As(AccelerationUnit.MillimeterPerSecondSquared);

        /// <summary>
        ///     Get Acceleration in MillistandardGravity.
        /// </summary>
        public double MillistandardGravity => As(AccelerationUnit.MillistandardGravity);

        /// <summary>
        ///     Get Acceleration in NanometersPerSecondSquared.
        /// </summary>
        public double NanometersPerSecondSquared => As(AccelerationUnit.NanometerPerSecondSquared);

        /// <summary>
        ///     Get Acceleration in StandardGravity.
        /// </summary>
        public double StandardGravity => As(AccelerationUnit.StandardGravity);

        #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(AccelerationUnit 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(AccelerationUnit unit, [CanBeNull] string cultureName)
        {
            IFormatProvider provider = GetFormatProviderFromCultureName(cultureName);
            return UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit, provider);
        }

        #endregion

        #region Static Factory Methods

        /// <summary>
        ///     Get Acceleration from CentimetersPerSecondSquared.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Acceleration FromCentimetersPerSecondSquared(double centimeterspersecondsquared)
        {
            double value = (double) centimeterspersecondsquared;
            return new Acceleration(value, AccelerationUnit.CentimeterPerSecondSquared);
        }
        /// <summary>
        ///     Get Acceleration from DecimetersPerSecondSquared.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Acceleration FromDecimetersPerSecondSquared(double decimeterspersecondsquared)
        {
            double value = (double) decimeterspersecondsquared;
            return new Acceleration(value, AccelerationUnit.DecimeterPerSecondSquared);
        }
        /// <summary>
        ///     Get Acceleration from FeetPerSecondSquared.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Acceleration FromFeetPerSecondSquared(double feetpersecondsquared)
        {
            double value = (double) feetpersecondsquared;
            return new Acceleration(value, AccelerationUnit.FootPerSecondSquared);
        }
        /// <summary>
        ///     Get Acceleration from InchesPerSecondSquared.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Acceleration FromInchesPerSecondSquared(double inchespersecondsquared)
        {
            double value = (double) inchespersecondsquared;
            return new Acceleration(value, AccelerationUnit.InchPerSecondSquared);
        }
        /// <summary>
        ///     Get Acceleration from KilometersPerSecondSquared.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Acceleration FromKilometersPerSecondSquared(double kilometerspersecondsquared)
        {
            double value = (double) kilometerspersecondsquared;
            return new Acceleration(value, AccelerationUnit.KilometerPerSecondSquared);
        }
        /// <summary>
        ///     Get Acceleration from KnotsPerHour.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Acceleration FromKnotsPerHour(double knotsperhour)
        {
            double value = (double) knotsperhour;
            return new Acceleration(value, AccelerationUnit.KnotPerHour);
        }
        /// <summary>
        ///     Get Acceleration from KnotsPerMinute.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Acceleration FromKnotsPerMinute(double knotsperminute)
        {
            double value = (double) knotsperminute;
            return new Acceleration(value, AccelerationUnit.KnotPerMinute);
        }
        /// <summary>
        ///     Get Acceleration from KnotsPerSecond.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Acceleration FromKnotsPerSecond(double knotspersecond)
        {
            double value = (double) knotspersecond;
            return new Acceleration(value, AccelerationUnit.KnotPerSecond);
        }
        /// <summary>
        ///     Get Acceleration from MetersPerSecondSquared.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Acceleration FromMetersPerSecondSquared(double meterspersecondsquared)
        {
            double value = (double) meterspersecondsquared;
            return new Acceleration(value, AccelerationUnit.MeterPerSecondSquared);
        }
        /// <summary>
        ///     Get Acceleration from MicrometersPerSecondSquared.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Acceleration FromMicrometersPerSecondSquared(double micrometerspersecondsquared)
        {
            double value = (double) micrometerspersecondsquared;
            return new Acceleration(value, AccelerationUnit.MicrometerPerSecondSquared);
        }
        /// <summary>
        ///     Get Acceleration from MillimetersPerSecondSquared.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Acceleration FromMillimetersPerSecondSquared(double millimeterspersecondsquared)
        {
            double value = (double) millimeterspersecondsquared;
            return new Acceleration(value, AccelerationUnit.MillimeterPerSecondSquared);
        }
        /// <summary>
        ///     Get Acceleration from MillistandardGravity.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Acceleration FromMillistandardGravity(double millistandardgravity)
        {
            double value = (double) millistandardgravity;
            return new Acceleration(value, AccelerationUnit.MillistandardGravity);
        }
        /// <summary>
        ///     Get Acceleration from NanometersPerSecondSquared.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Acceleration FromNanometersPerSecondSquared(double nanometerspersecondsquared)
        {
            double value = (double) nanometerspersecondsquared;
            return new Acceleration(value, AccelerationUnit.NanometerPerSecondSquared);
        }
        /// <summary>
        ///     Get Acceleration from StandardGravity.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static Acceleration FromStandardGravity(double standardgravity)
        {
            double value = (double) standardgravity;
            return new Acceleration(value, AccelerationUnit.StandardGravity);
        }

        /// <summary>
        ///     Dynamically convert from value and unit enum <see cref="AccelerationUnit" /> to <see cref="Acceleration" />.
        /// </summary>
        /// <param name="value">Value to convert from.</param>
        /// <param name="fromUnit">Unit to convert from.</param>
        /// <returns>Acceleration unit value.</returns>
        // Fix name conflict with parameter "value"
        [return: System.Runtime.InteropServices.WindowsRuntime.ReturnValueName("returnValue")]
        public static Acceleration From(double value, AccelerationUnit fromUnit)
        {
            return new Acceleration((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 Acceleration 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 Acceleration Parse(string str, [CanBeNull] string cultureName)
        {
            IFormatProvider provider = GetFormatProviderFromCultureName(cultureName);
            return QuantityParser.Default.Parse<Acceleration, AccelerationUnit>(
                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 Acceleration 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 Acceleration result)
        {
            IFormatProvider provider = GetFormatProviderFromCultureName(cultureName);
            return QuantityParser.Default.TryParse<Acceleration, AccelerationUnit>(
                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 AccelerationUnit 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 AccelerationUnit ParseUnit(string str, [CanBeNull] string cultureName)
        {
            IFormatProvider provider = GetFormatProviderFromCultureName(cultureName);
            return UnitParser.Default.Parse<AccelerationUnit>(str, provider);
        }

        public static bool TryParseUnit(string str, out AccelerationUnit 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 AccelerationUnit unit)
        {
            IFormatProvider provider = GetFormatProviderFromCultureName(cultureName);
            return UnitParser.Default.TryParse<AccelerationUnit>(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 Acceleration objAcceleration)) throw new ArgumentException("Expected type Acceleration.", nameof(obj));

            return CompareTo(objAcceleration);
        }

        // 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(Acceleration other)
        {
            return _value.CompareTo(other.AsBaseNumericType(this.Unit));
        }

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

            return Equals(objAcceleration);
        }

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

        /// <summary>
        ///     <para>
        ///     Compare equality to another Acceleration 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(Acceleration 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 Acceleration.</returns>
        public override int GetHashCode()
        {
            return new { QuantityType, Value, Unit }.GetHashCode();
        }

        #endregion

        #region Conversion Methods

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

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

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

        /// <summary>
        ///     Converts this Acceleration to another Acceleration with the unit representation <paramref name="unit" />.
        /// </summary>
        /// <returns>A Acceleration with the specified unit.</returns>
        public Acceleration ToUnit(AccelerationUnit unit)
        {
            var convertedValue = AsBaseNumericType(unit);
            return new Acceleration(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 AccelerationUnit.CentimeterPerSecondSquared: return (_value) * 1e-2d;
                case AccelerationUnit.DecimeterPerSecondSquared: return (_value) * 1e-1d;
                case AccelerationUnit.FootPerSecondSquared: return _value*0.304800;
                case AccelerationUnit.InchPerSecondSquared: return _value*0.0254;
                case AccelerationUnit.KilometerPerSecondSquared: return (_value) * 1e3d;
                case AccelerationUnit.KnotPerHour: return _value*0.5144444444444/3600;
                case AccelerationUnit.KnotPerMinute: return _value*0.5144444444444/60;
                case AccelerationUnit.KnotPerSecond: return _value*0.5144444444444;
                case AccelerationUnit.MeterPerSecondSquared: return _value;
                case AccelerationUnit.MicrometerPerSecondSquared: return (_value) * 1e-6d;
                case AccelerationUnit.MillimeterPerSecondSquared: return (_value) * 1e-3d;
                case AccelerationUnit.MillistandardGravity: return (_value*9.80665) * 1e-3d;
                case AccelerationUnit.NanometerPerSecondSquared: return (_value) * 1e-9d;
                case AccelerationUnit.StandardGravity: return _value*9.80665;
                default:
                    throw new NotImplementedException($"Can not convert {Unit} to base units.");
            }
        }

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

            var baseUnitValue = AsBaseUnit();

            switch(unit)
            {
                case AccelerationUnit.CentimeterPerSecondSquared: return (baseUnitValue) / 1e-2d;
                case AccelerationUnit.DecimeterPerSecondSquared: return (baseUnitValue) / 1e-1d;
                case AccelerationUnit.FootPerSecondSquared: return baseUnitValue/0.304800;
                case AccelerationUnit.InchPerSecondSquared: return baseUnitValue/0.0254;
                case AccelerationUnit.KilometerPerSecondSquared: return (baseUnitValue) / 1e3d;
                case AccelerationUnit.KnotPerHour: return baseUnitValue/0.5144444444444*3600;
                case AccelerationUnit.KnotPerMinute: return baseUnitValue/0.5144444444444*60;
                case AccelerationUnit.KnotPerSecond: return baseUnitValue/0.5144444444444;
                case AccelerationUnit.MeterPerSecondSquared: return baseUnitValue;
                case AccelerationUnit.MicrometerPerSecondSquared: return (baseUnitValue) / 1e-6d;
                case AccelerationUnit.MillimeterPerSecondSquared: return (baseUnitValue) / 1e-3d;
                case AccelerationUnit.MillistandardGravity: return (baseUnitValue/9.80665) / 1e-3d;
                case AccelerationUnit.NanometerPerSecondSquared: return (baseUnitValue) / 1e-9d;
                case AccelerationUnit.StandardGravity: return baseUnitValue/9.80665;
                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;
        }
    }
}