ForcePerLength.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 magnitude of force per unit length.
    /// </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 ForcePerLength : 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 ForcePerLengthUnit? _unit;

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

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

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

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

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

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

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

        internal QuantityInfo QuantityInfo => Info;

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

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

        #endregion

        #region Conversion Properties

        /// <summary>
        ///     Get ForcePerLength in CentinewtonsPerCentimeter.
        /// </summary>
        public double CentinewtonsPerCentimeter => As(ForcePerLengthUnit.CentinewtonPerCentimeter);

        /// <summary>
        ///     Get ForcePerLength in CentinewtonsPerMeter.
        /// </summary>
        public double CentinewtonsPerMeter => As(ForcePerLengthUnit.CentinewtonPerMeter);

        /// <summary>
        ///     Get ForcePerLength in CentinewtonsPerMillimeter.
        /// </summary>
        public double CentinewtonsPerMillimeter => As(ForcePerLengthUnit.CentinewtonPerMillimeter);

        /// <summary>
        ///     Get ForcePerLength in DecanewtonsPerCentimeter.
        /// </summary>
        public double DecanewtonsPerCentimeter => As(ForcePerLengthUnit.DecanewtonPerCentimeter);

        /// <summary>
        ///     Get ForcePerLength in DecanewtonsPerMeter.
        /// </summary>
        public double DecanewtonsPerMeter => As(ForcePerLengthUnit.DecanewtonPerMeter);

        /// <summary>
        ///     Get ForcePerLength in DecanewtonsPerMillimeter.
        /// </summary>
        public double DecanewtonsPerMillimeter => As(ForcePerLengthUnit.DecanewtonPerMillimeter);

        /// <summary>
        ///     Get ForcePerLength in DecinewtonsPerCentimeter.
        /// </summary>
        public double DecinewtonsPerCentimeter => As(ForcePerLengthUnit.DecinewtonPerCentimeter);

        /// <summary>
        ///     Get ForcePerLength in DecinewtonsPerMeter.
        /// </summary>
        public double DecinewtonsPerMeter => As(ForcePerLengthUnit.DecinewtonPerMeter);

        /// <summary>
        ///     Get ForcePerLength in DecinewtonsPerMillimeter.
        /// </summary>
        public double DecinewtonsPerMillimeter => As(ForcePerLengthUnit.DecinewtonPerMillimeter);

        /// <summary>
        ///     Get ForcePerLength in KilogramsForcePerCentimeter.
        /// </summary>
        public double KilogramsForcePerCentimeter => As(ForcePerLengthUnit.KilogramForcePerCentimeter);

        /// <summary>
        ///     Get ForcePerLength in KilogramsForcePerMeter.
        /// </summary>
        public double KilogramsForcePerMeter => As(ForcePerLengthUnit.KilogramForcePerMeter);

        /// <summary>
        ///     Get ForcePerLength in KilogramsForcePerMillimeter.
        /// </summary>
        public double KilogramsForcePerMillimeter => As(ForcePerLengthUnit.KilogramForcePerMillimeter);

        /// <summary>
        ///     Get ForcePerLength in KilonewtonsPerCentimeter.
        /// </summary>
        public double KilonewtonsPerCentimeter => As(ForcePerLengthUnit.KilonewtonPerCentimeter);

        /// <summary>
        ///     Get ForcePerLength in KilonewtonsPerMeter.
        /// </summary>
        public double KilonewtonsPerMeter => As(ForcePerLengthUnit.KilonewtonPerMeter);

        /// <summary>
        ///     Get ForcePerLength in KilonewtonsPerMillimeter.
        /// </summary>
        public double KilonewtonsPerMillimeter => As(ForcePerLengthUnit.KilonewtonPerMillimeter);

        /// <summary>
        ///     Get ForcePerLength in KilopoundsForcePerFoot.
        /// </summary>
        public double KilopoundsForcePerFoot => As(ForcePerLengthUnit.KilopoundForcePerFoot);

        /// <summary>
        ///     Get ForcePerLength in KilopoundsForcePerInch.
        /// </summary>
        public double KilopoundsForcePerInch => As(ForcePerLengthUnit.KilopoundForcePerInch);

        /// <summary>
        ///     Get ForcePerLength in MeganewtonsPerCentimeter.
        /// </summary>
        public double MeganewtonsPerCentimeter => As(ForcePerLengthUnit.MeganewtonPerCentimeter);

        /// <summary>
        ///     Get ForcePerLength in MeganewtonsPerMeter.
        /// </summary>
        public double MeganewtonsPerMeter => As(ForcePerLengthUnit.MeganewtonPerMeter);

        /// <summary>
        ///     Get ForcePerLength in MeganewtonsPerMillimeter.
        /// </summary>
        public double MeganewtonsPerMillimeter => As(ForcePerLengthUnit.MeganewtonPerMillimeter);

        /// <summary>
        ///     Get ForcePerLength in MicronewtonsPerCentimeter.
        /// </summary>
        public double MicronewtonsPerCentimeter => As(ForcePerLengthUnit.MicronewtonPerCentimeter);

        /// <summary>
        ///     Get ForcePerLength in MicronewtonsPerMeter.
        /// </summary>
        public double MicronewtonsPerMeter => As(ForcePerLengthUnit.MicronewtonPerMeter);

        /// <summary>
        ///     Get ForcePerLength in MicronewtonsPerMillimeter.
        /// </summary>
        public double MicronewtonsPerMillimeter => As(ForcePerLengthUnit.MicronewtonPerMillimeter);

        /// <summary>
        ///     Get ForcePerLength in MillinewtonsPerCentimeter.
        /// </summary>
        public double MillinewtonsPerCentimeter => As(ForcePerLengthUnit.MillinewtonPerCentimeter);

        /// <summary>
        ///     Get ForcePerLength in MillinewtonsPerMeter.
        /// </summary>
        public double MillinewtonsPerMeter => As(ForcePerLengthUnit.MillinewtonPerMeter);

        /// <summary>
        ///     Get ForcePerLength in MillinewtonsPerMillimeter.
        /// </summary>
        public double MillinewtonsPerMillimeter => As(ForcePerLengthUnit.MillinewtonPerMillimeter);

        /// <summary>
        ///     Get ForcePerLength in NanonewtonsPerCentimeter.
        /// </summary>
        public double NanonewtonsPerCentimeter => As(ForcePerLengthUnit.NanonewtonPerCentimeter);

        /// <summary>
        ///     Get ForcePerLength in NanonewtonsPerMeter.
        /// </summary>
        public double NanonewtonsPerMeter => As(ForcePerLengthUnit.NanonewtonPerMeter);

        /// <summary>
        ///     Get ForcePerLength in NanonewtonsPerMillimeter.
        /// </summary>
        public double NanonewtonsPerMillimeter => As(ForcePerLengthUnit.NanonewtonPerMillimeter);

        /// <summary>
        ///     Get ForcePerLength in NewtonsPerCentimeter.
        /// </summary>
        public double NewtonsPerCentimeter => As(ForcePerLengthUnit.NewtonPerCentimeter);

        /// <summary>
        ///     Get ForcePerLength in NewtonsPerMeter.
        /// </summary>
        public double NewtonsPerMeter => As(ForcePerLengthUnit.NewtonPerMeter);

        /// <summary>
        ///     Get ForcePerLength in NewtonsPerMillimeter.
        /// </summary>
        public double NewtonsPerMillimeter => As(ForcePerLengthUnit.NewtonPerMillimeter);

        /// <summary>
        ///     Get ForcePerLength in PoundsForcePerFoot.
        /// </summary>
        public double PoundsForcePerFoot => As(ForcePerLengthUnit.PoundForcePerFoot);

        /// <summary>
        ///     Get ForcePerLength in PoundsForcePerInch.
        /// </summary>
        public double PoundsForcePerInch => As(ForcePerLengthUnit.PoundForcePerInch);

        /// <summary>
        ///     Get ForcePerLength in PoundsForcePerYard.
        /// </summary>
        public double PoundsForcePerYard => As(ForcePerLengthUnit.PoundForcePerYard);

        /// <summary>
        ///     Get ForcePerLength in TonnesForcePerCentimeter.
        /// </summary>
        public double TonnesForcePerCentimeter => As(ForcePerLengthUnit.TonneForcePerCentimeter);

        /// <summary>
        ///     Get ForcePerLength in TonnesForcePerMeter.
        /// </summary>
        public double TonnesForcePerMeter => As(ForcePerLengthUnit.TonneForcePerMeter);

        /// <summary>
        ///     Get ForcePerLength in TonnesForcePerMillimeter.
        /// </summary>
        public double TonnesForcePerMillimeter => As(ForcePerLengthUnit.TonneForcePerMillimeter);

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

        #endregion

        #region Static Factory Methods

        /// <summary>
        ///     Get ForcePerLength from CentinewtonsPerCentimeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromCentinewtonsPerCentimeter(double centinewtonspercentimeter)
        {
            double value = (double) centinewtonspercentimeter;
            return new ForcePerLength(value, ForcePerLengthUnit.CentinewtonPerCentimeter);
        }
        /// <summary>
        ///     Get ForcePerLength from CentinewtonsPerMeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromCentinewtonsPerMeter(double centinewtonspermeter)
        {
            double value = (double) centinewtonspermeter;
            return new ForcePerLength(value, ForcePerLengthUnit.CentinewtonPerMeter);
        }
        /// <summary>
        ///     Get ForcePerLength from CentinewtonsPerMillimeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromCentinewtonsPerMillimeter(double centinewtonspermillimeter)
        {
            double value = (double) centinewtonspermillimeter;
            return new ForcePerLength(value, ForcePerLengthUnit.CentinewtonPerMillimeter);
        }
        /// <summary>
        ///     Get ForcePerLength from DecanewtonsPerCentimeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromDecanewtonsPerCentimeter(double decanewtonspercentimeter)
        {
            double value = (double) decanewtonspercentimeter;
            return new ForcePerLength(value, ForcePerLengthUnit.DecanewtonPerCentimeter);
        }
        /// <summary>
        ///     Get ForcePerLength from DecanewtonsPerMeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromDecanewtonsPerMeter(double decanewtonspermeter)
        {
            double value = (double) decanewtonspermeter;
            return new ForcePerLength(value, ForcePerLengthUnit.DecanewtonPerMeter);
        }
        /// <summary>
        ///     Get ForcePerLength from DecanewtonsPerMillimeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromDecanewtonsPerMillimeter(double decanewtonspermillimeter)
        {
            double value = (double) decanewtonspermillimeter;
            return new ForcePerLength(value, ForcePerLengthUnit.DecanewtonPerMillimeter);
        }
        /// <summary>
        ///     Get ForcePerLength from DecinewtonsPerCentimeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromDecinewtonsPerCentimeter(double decinewtonspercentimeter)
        {
            double value = (double) decinewtonspercentimeter;
            return new ForcePerLength(value, ForcePerLengthUnit.DecinewtonPerCentimeter);
        }
        /// <summary>
        ///     Get ForcePerLength from DecinewtonsPerMeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromDecinewtonsPerMeter(double decinewtonspermeter)
        {
            double value = (double) decinewtonspermeter;
            return new ForcePerLength(value, ForcePerLengthUnit.DecinewtonPerMeter);
        }
        /// <summary>
        ///     Get ForcePerLength from DecinewtonsPerMillimeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromDecinewtonsPerMillimeter(double decinewtonspermillimeter)
        {
            double value = (double) decinewtonspermillimeter;
            return new ForcePerLength(value, ForcePerLengthUnit.DecinewtonPerMillimeter);
        }
        /// <summary>
        ///     Get ForcePerLength from KilogramsForcePerCentimeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromKilogramsForcePerCentimeter(double kilogramsforcepercentimeter)
        {
            double value = (double) kilogramsforcepercentimeter;
            return new ForcePerLength(value, ForcePerLengthUnit.KilogramForcePerCentimeter);
        }
        /// <summary>
        ///     Get ForcePerLength from KilogramsForcePerMeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromKilogramsForcePerMeter(double kilogramsforcepermeter)
        {
            double value = (double) kilogramsforcepermeter;
            return new ForcePerLength(value, ForcePerLengthUnit.KilogramForcePerMeter);
        }
        /// <summary>
        ///     Get ForcePerLength from KilogramsForcePerMillimeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromKilogramsForcePerMillimeter(double kilogramsforcepermillimeter)
        {
            double value = (double) kilogramsforcepermillimeter;
            return new ForcePerLength(value, ForcePerLengthUnit.KilogramForcePerMillimeter);
        }
        /// <summary>
        ///     Get ForcePerLength from KilonewtonsPerCentimeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromKilonewtonsPerCentimeter(double kilonewtonspercentimeter)
        {
            double value = (double) kilonewtonspercentimeter;
            return new ForcePerLength(value, ForcePerLengthUnit.KilonewtonPerCentimeter);
        }
        /// <summary>
        ///     Get ForcePerLength from KilonewtonsPerMeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromKilonewtonsPerMeter(double kilonewtonspermeter)
        {
            double value = (double) kilonewtonspermeter;
            return new ForcePerLength(value, ForcePerLengthUnit.KilonewtonPerMeter);
        }
        /// <summary>
        ///     Get ForcePerLength from KilonewtonsPerMillimeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromKilonewtonsPerMillimeter(double kilonewtonspermillimeter)
        {
            double value = (double) kilonewtonspermillimeter;
            return new ForcePerLength(value, ForcePerLengthUnit.KilonewtonPerMillimeter);
        }
        /// <summary>
        ///     Get ForcePerLength from KilopoundsForcePerFoot.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromKilopoundsForcePerFoot(double kilopoundsforceperfoot)
        {
            double value = (double) kilopoundsforceperfoot;
            return new ForcePerLength(value, ForcePerLengthUnit.KilopoundForcePerFoot);
        }
        /// <summary>
        ///     Get ForcePerLength from KilopoundsForcePerInch.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromKilopoundsForcePerInch(double kilopoundsforceperinch)
        {
            double value = (double) kilopoundsforceperinch;
            return new ForcePerLength(value, ForcePerLengthUnit.KilopoundForcePerInch);
        }
        /// <summary>
        ///     Get ForcePerLength from MeganewtonsPerCentimeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromMeganewtonsPerCentimeter(double meganewtonspercentimeter)
        {
            double value = (double) meganewtonspercentimeter;
            return new ForcePerLength(value, ForcePerLengthUnit.MeganewtonPerCentimeter);
        }
        /// <summary>
        ///     Get ForcePerLength from MeganewtonsPerMeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromMeganewtonsPerMeter(double meganewtonspermeter)
        {
            double value = (double) meganewtonspermeter;
            return new ForcePerLength(value, ForcePerLengthUnit.MeganewtonPerMeter);
        }
        /// <summary>
        ///     Get ForcePerLength from MeganewtonsPerMillimeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromMeganewtonsPerMillimeter(double meganewtonspermillimeter)
        {
            double value = (double) meganewtonspermillimeter;
            return new ForcePerLength(value, ForcePerLengthUnit.MeganewtonPerMillimeter);
        }
        /// <summary>
        ///     Get ForcePerLength from MicronewtonsPerCentimeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromMicronewtonsPerCentimeter(double micronewtonspercentimeter)
        {
            double value = (double) micronewtonspercentimeter;
            return new ForcePerLength(value, ForcePerLengthUnit.MicronewtonPerCentimeter);
        }
        /// <summary>
        ///     Get ForcePerLength from MicronewtonsPerMeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromMicronewtonsPerMeter(double micronewtonspermeter)
        {
            double value = (double) micronewtonspermeter;
            return new ForcePerLength(value, ForcePerLengthUnit.MicronewtonPerMeter);
        }
        /// <summary>
        ///     Get ForcePerLength from MicronewtonsPerMillimeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromMicronewtonsPerMillimeter(double micronewtonspermillimeter)
        {
            double value = (double) micronewtonspermillimeter;
            return new ForcePerLength(value, ForcePerLengthUnit.MicronewtonPerMillimeter);
        }
        /// <summary>
        ///     Get ForcePerLength from MillinewtonsPerCentimeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromMillinewtonsPerCentimeter(double millinewtonspercentimeter)
        {
            double value = (double) millinewtonspercentimeter;
            return new ForcePerLength(value, ForcePerLengthUnit.MillinewtonPerCentimeter);
        }
        /// <summary>
        ///     Get ForcePerLength from MillinewtonsPerMeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromMillinewtonsPerMeter(double millinewtonspermeter)
        {
            double value = (double) millinewtonspermeter;
            return new ForcePerLength(value, ForcePerLengthUnit.MillinewtonPerMeter);
        }
        /// <summary>
        ///     Get ForcePerLength from MillinewtonsPerMillimeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromMillinewtonsPerMillimeter(double millinewtonspermillimeter)
        {
            double value = (double) millinewtonspermillimeter;
            return new ForcePerLength(value, ForcePerLengthUnit.MillinewtonPerMillimeter);
        }
        /// <summary>
        ///     Get ForcePerLength from NanonewtonsPerCentimeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromNanonewtonsPerCentimeter(double nanonewtonspercentimeter)
        {
            double value = (double) nanonewtonspercentimeter;
            return new ForcePerLength(value, ForcePerLengthUnit.NanonewtonPerCentimeter);
        }
        /// <summary>
        ///     Get ForcePerLength from NanonewtonsPerMeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromNanonewtonsPerMeter(double nanonewtonspermeter)
        {
            double value = (double) nanonewtonspermeter;
            return new ForcePerLength(value, ForcePerLengthUnit.NanonewtonPerMeter);
        }
        /// <summary>
        ///     Get ForcePerLength from NanonewtonsPerMillimeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromNanonewtonsPerMillimeter(double nanonewtonspermillimeter)
        {
            double value = (double) nanonewtonspermillimeter;
            return new ForcePerLength(value, ForcePerLengthUnit.NanonewtonPerMillimeter);
        }
        /// <summary>
        ///     Get ForcePerLength from NewtonsPerCentimeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromNewtonsPerCentimeter(double newtonspercentimeter)
        {
            double value = (double) newtonspercentimeter;
            return new ForcePerLength(value, ForcePerLengthUnit.NewtonPerCentimeter);
        }
        /// <summary>
        ///     Get ForcePerLength from NewtonsPerMeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromNewtonsPerMeter(double newtonspermeter)
        {
            double value = (double) newtonspermeter;
            return new ForcePerLength(value, ForcePerLengthUnit.NewtonPerMeter);
        }
        /// <summary>
        ///     Get ForcePerLength from NewtonsPerMillimeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromNewtonsPerMillimeter(double newtonspermillimeter)
        {
            double value = (double) newtonspermillimeter;
            return new ForcePerLength(value, ForcePerLengthUnit.NewtonPerMillimeter);
        }
        /// <summary>
        ///     Get ForcePerLength from PoundsForcePerFoot.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromPoundsForcePerFoot(double poundsforceperfoot)
        {
            double value = (double) poundsforceperfoot;
            return new ForcePerLength(value, ForcePerLengthUnit.PoundForcePerFoot);
        }
        /// <summary>
        ///     Get ForcePerLength from PoundsForcePerInch.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromPoundsForcePerInch(double poundsforceperinch)
        {
            double value = (double) poundsforceperinch;
            return new ForcePerLength(value, ForcePerLengthUnit.PoundForcePerInch);
        }
        /// <summary>
        ///     Get ForcePerLength from PoundsForcePerYard.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromPoundsForcePerYard(double poundsforceperyard)
        {
            double value = (double) poundsforceperyard;
            return new ForcePerLength(value, ForcePerLengthUnit.PoundForcePerYard);
        }
        /// <summary>
        ///     Get ForcePerLength from TonnesForcePerCentimeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromTonnesForcePerCentimeter(double tonnesforcepercentimeter)
        {
            double value = (double) tonnesforcepercentimeter;
            return new ForcePerLength(value, ForcePerLengthUnit.TonneForcePerCentimeter);
        }
        /// <summary>
        ///     Get ForcePerLength from TonnesForcePerMeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromTonnesForcePerMeter(double tonnesforcepermeter)
        {
            double value = (double) tonnesforcepermeter;
            return new ForcePerLength(value, ForcePerLengthUnit.TonneForcePerMeter);
        }
        /// <summary>
        ///     Get ForcePerLength from TonnesForcePerMillimeter.
        /// </summary>
        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
        [Windows.Foundation.Metadata.DefaultOverload]
        public static ForcePerLength FromTonnesForcePerMillimeter(double tonnesforcepermillimeter)
        {
            double value = (double) tonnesforcepermillimeter;
            return new ForcePerLength(value, ForcePerLengthUnit.TonneForcePerMillimeter);
        }

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

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

            return CompareTo(objForcePerLength);
        }

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

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

            return Equals(objForcePerLength);
        }

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

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

        #endregion

        #region Conversion Methods

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

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

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

        /// <summary>
        ///     Converts this ForcePerLength to another ForcePerLength with the unit representation <paramref name="unit" />.
        /// </summary>
        /// <returns>A ForcePerLength with the specified unit.</returns>
        public ForcePerLength ToUnit(ForcePerLengthUnit unit)
        {
            var convertedValue = AsBaseNumericType(unit);
            return new ForcePerLength(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 ForcePerLengthUnit.CentinewtonPerCentimeter: return (_value*1e2) * 1e-2d;
                case ForcePerLengthUnit.CentinewtonPerMeter: return (_value) * 1e-2d;
                case ForcePerLengthUnit.CentinewtonPerMillimeter: return (_value*1e3) * 1e-2d;
                case ForcePerLengthUnit.DecanewtonPerCentimeter: return (_value*1e2) * 1e1d;
                case ForcePerLengthUnit.DecanewtonPerMeter: return (_value) * 1e1d;
                case ForcePerLengthUnit.DecanewtonPerMillimeter: return (_value*1e3) * 1e1d;
                case ForcePerLengthUnit.DecinewtonPerCentimeter: return (_value*1e2) * 1e-1d;
                case ForcePerLengthUnit.DecinewtonPerMeter: return (_value) * 1e-1d;
                case ForcePerLengthUnit.DecinewtonPerMillimeter: return (_value*1e3) * 1e-1d;
                case ForcePerLengthUnit.KilogramForcePerCentimeter: return _value*980.665002864;
                case ForcePerLengthUnit.KilogramForcePerMeter: return _value*9.80665002864;
                case ForcePerLengthUnit.KilogramForcePerMillimeter: return _value*9.80665002864e3;
                case ForcePerLengthUnit.KilonewtonPerCentimeter: return (_value*1e2) * 1e3d;
                case ForcePerLengthUnit.KilonewtonPerMeter: return (_value) * 1e3d;
                case ForcePerLengthUnit.KilonewtonPerMillimeter: return (_value*1e3) * 1e3d;
                case ForcePerLengthUnit.KilopoundForcePerFoot: return _value*14593.90292;
                case ForcePerLengthUnit.KilopoundForcePerInch: return _value*1.75126835e5;
                case ForcePerLengthUnit.MeganewtonPerCentimeter: return (_value*1e2) * 1e6d;
                case ForcePerLengthUnit.MeganewtonPerMeter: return (_value) * 1e6d;
                case ForcePerLengthUnit.MeganewtonPerMillimeter: return (_value*1e3) * 1e6d;
                case ForcePerLengthUnit.MicronewtonPerCentimeter: return (_value*1e2) * 1e-6d;
                case ForcePerLengthUnit.MicronewtonPerMeter: return (_value) * 1e-6d;
                case ForcePerLengthUnit.MicronewtonPerMillimeter: return (_value*1e3) * 1e-6d;
                case ForcePerLengthUnit.MillinewtonPerCentimeter: return (_value*1e2) * 1e-3d;
                case ForcePerLengthUnit.MillinewtonPerMeter: return (_value) * 1e-3d;
                case ForcePerLengthUnit.MillinewtonPerMillimeter: return (_value*1e3) * 1e-3d;
                case ForcePerLengthUnit.NanonewtonPerCentimeter: return (_value*1e2) * 1e-9d;
                case ForcePerLengthUnit.NanonewtonPerMeter: return (_value) * 1e-9d;
                case ForcePerLengthUnit.NanonewtonPerMillimeter: return (_value*1e3) * 1e-9d;
                case ForcePerLengthUnit.NewtonPerCentimeter: return _value*1e2;
                case ForcePerLengthUnit.NewtonPerMeter: return _value;
                case ForcePerLengthUnit.NewtonPerMillimeter: return _value*1e3;
                case ForcePerLengthUnit.PoundForcePerFoot: return _value*14.59390292;
                case ForcePerLengthUnit.PoundForcePerInch: return _value*1.75126835e2;
                case ForcePerLengthUnit.PoundForcePerYard: return _value*4.864634307;
                case ForcePerLengthUnit.TonneForcePerCentimeter: return _value*9.80665002864e5;
                case ForcePerLengthUnit.TonneForcePerMeter: return _value*9.80665002864e3;
                case ForcePerLengthUnit.TonneForcePerMillimeter: return _value*9.80665002864e6;
                default:
                    throw new NotImplementedException($"Can not convert {Unit} to base units.");
            }
        }

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

            var baseUnitValue = AsBaseUnit();

            switch(unit)
            {
                case ForcePerLengthUnit.CentinewtonPerCentimeter: return (baseUnitValue/1e2) / 1e-2d;
                case ForcePerLengthUnit.CentinewtonPerMeter: return (baseUnitValue) / 1e-2d;
                case ForcePerLengthUnit.CentinewtonPerMillimeter: return (baseUnitValue/1e3) / 1e-2d;
                case ForcePerLengthUnit.DecanewtonPerCentimeter: return (baseUnitValue/1e2) / 1e1d;
                case ForcePerLengthUnit.DecanewtonPerMeter: return (baseUnitValue) / 1e1d;
                case ForcePerLengthUnit.DecanewtonPerMillimeter: return (baseUnitValue/1e3) / 1e1d;
                case ForcePerLengthUnit.DecinewtonPerCentimeter: return (baseUnitValue/1e2) / 1e-1d;
                case ForcePerLengthUnit.DecinewtonPerMeter: return (baseUnitValue) / 1e-1d;
                case ForcePerLengthUnit.DecinewtonPerMillimeter: return (baseUnitValue/1e3) / 1e-1d;
                case ForcePerLengthUnit.KilogramForcePerCentimeter: return baseUnitValue/980.665002864;
                case ForcePerLengthUnit.KilogramForcePerMeter: return baseUnitValue/9.80665002864;
                case ForcePerLengthUnit.KilogramForcePerMillimeter: return baseUnitValue/9.80665002864e3;
                case ForcePerLengthUnit.KilonewtonPerCentimeter: return (baseUnitValue/1e2) / 1e3d;
                case ForcePerLengthUnit.KilonewtonPerMeter: return (baseUnitValue) / 1e3d;
                case ForcePerLengthUnit.KilonewtonPerMillimeter: return (baseUnitValue/1e3) / 1e3d;
                case ForcePerLengthUnit.KilopoundForcePerFoot: return baseUnitValue/14593.90292;
                case ForcePerLengthUnit.KilopoundForcePerInch: return baseUnitValue/1.75126835e5;
                case ForcePerLengthUnit.MeganewtonPerCentimeter: return (baseUnitValue/1e2) / 1e6d;
                case ForcePerLengthUnit.MeganewtonPerMeter: return (baseUnitValue) / 1e6d;
                case ForcePerLengthUnit.MeganewtonPerMillimeter: return (baseUnitValue/1e3) / 1e6d;
                case ForcePerLengthUnit.MicronewtonPerCentimeter: return (baseUnitValue/1e2) / 1e-6d;
                case ForcePerLengthUnit.MicronewtonPerMeter: return (baseUnitValue) / 1e-6d;
                case ForcePerLengthUnit.MicronewtonPerMillimeter: return (baseUnitValue/1e3) / 1e-6d;
                case ForcePerLengthUnit.MillinewtonPerCentimeter: return (baseUnitValue/1e2) / 1e-3d;
                case ForcePerLengthUnit.MillinewtonPerMeter: return (baseUnitValue) / 1e-3d;
                case ForcePerLengthUnit.MillinewtonPerMillimeter: return (baseUnitValue/1e3) / 1e-3d;
                case ForcePerLengthUnit.NanonewtonPerCentimeter: return (baseUnitValue/1e2) / 1e-9d;
                case ForcePerLengthUnit.NanonewtonPerMeter: return (baseUnitValue) / 1e-9d;
                case ForcePerLengthUnit.NanonewtonPerMillimeter: return (baseUnitValue/1e3) / 1e-9d;
                case ForcePerLengthUnit.NewtonPerCentimeter: return baseUnitValue/1e2;
                case ForcePerLengthUnit.NewtonPerMeter: return baseUnitValue;
                case ForcePerLengthUnit.NewtonPerMillimeter: return baseUnitValue/1e3;
                case ForcePerLengthUnit.PoundForcePerFoot: return baseUnitValue/14.59390292;
                case ForcePerLengthUnit.PoundForcePerInch: return baseUnitValue/1.75126835e2;
                case ForcePerLengthUnit.PoundForcePerYard: return baseUnitValue/4.864634307;
                case ForcePerLengthUnit.TonneForcePerCentimeter: return baseUnitValue/9.80665002864e5;
                case ForcePerLengthUnit.TonneForcePerMeter: return baseUnitValue/9.80665002864e3;
                case ForcePerLengthUnit.TonneForcePerMillimeter: return baseUnitValue/9.80665002864e6;
                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;
        }
    }
}