public Mass Convert(Mass from, MassUnit to) {
if (from.Unit.Equals(to))
return new Mass(from.Amount, to);
var tfs = new FromToConversion(from.Unit, to);
if(!_knownConversions.ContainsKey(tfs))
throw new NotImplementedException("This conversion has not yet been implemented");
return new Mass(from.Amount * _knownConversions[tfs], to);
}
public void MassConversions(double value1, MassUnit units1, double value2, MassUnit units2)
{
new Mass(value1, units1) {
Units = units2
}.Value.ShouldBeWithinEpsilonOf(value2);
new Mass(value2, units2) {
Units = units1
}.Value.ShouldBeWithinEpsilonOf(value1);
}
/// <summary>
/// Converts the specified from unit to the specified unit.
/// </summary>
/// <param name="fromUnit">Covert from unit.</param>
/// <param name="toUnit">Covert to unit.</param>
/// <param name="fromValue">Covert from value.</param>
/// <returns>The converted value.</returns>
public static double Convert(
MassUnit fromUnit,
MassUnit toUnit,
double fromValue)
{
if (fromUnit == toUnit)
return fromValue;
double fromFactor = factors[(int)fromUnit];
double toFactor = factors[(int)toUnit];
double result = fromFactor * fromValue / toFactor;
return result;
}
public Weight ConvertTo(MassUnit unit)
{
switch (_unit)
{
case MassUnit.Grams:
{
return FromGrams(unit);
}
case MassUnit.KiloGrams:
{
return FromKiloGrams(unit);
}
case MassUnit.Pounds:
{
return FromPounds(unit);
}
}
return null;
}
protected static string CreateSuffix(SymbolFormat format, MassUnit unit)
{
return default(Mass).ToString(unit, format).Trim('0');
}
private MassJsonConverter(MassUnit unit)
{
this.unit = unit;
}
public static string Weight(MassUnit unit) => $"Weight ({unit})";
/// <summary>
/// Converts this Mass to another Mass with the unit representation <paramref name="unit" />.
/// </summary>
/// <returns>A Mass with the specified unit.</returns>
public Mass ToUnit(MassUnit unit)
{
var convertedValue = AsBaseNumericType(unit);
return(new Mass(convertedValue, unit));
}
public static bool TryParseUnit(string str, out MassUnit unit)
{
return(TryParseUnit(str, null, out unit));
}
/// <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(MassUnit unit, [CanBeNull] string cultureName)
{
IFormatProvider provider = GetFormatProviderFromCultureName(cultureName);
return(UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit, provider));
}
public static string GetAbbreviation(MassUnit unit, [CanBeNull] Culture culture)
{
return(UnitSystem.GetCached(culture).GetDefaultAbbreviation(unit));
}
public static Mass From(double value, MassUnit fromUnit)
Mass(double numericValue, MassUnit unit)
{
_value = numericValue;
_unit = unit;
}
public string ToString(MassUnit unit, CultureInfo culture, string format, params object[] args)
{
return(string.Format(culture, format, UnitFormatter.GetFormatArgs(unit, As(unit), culture, args)));
}
public string ToString(MassUnit unit, CultureInfo culture = null, int significantDigitsAfterRadix = 2)
{
return(ToString(unit, culture, UnitFormatter.GetFormat(As(unit), significantDigitsAfterRadix)));
}
public static string GetAbbreviation(MassUnit unit, CultureInfo culture = null)
{
return(UnitSystem.GetCached(culture).GetDefaultAbbreviation(unit));
}
public static Mass From(double value, MassUnit fromUnit)
{
return(new Mass((double)value, fromUnit));
}
/// <summary>
/// Get string representation of value and unit. Using two significant digits after radix.
/// </summary>
/// <param name="unit">Unit representation to use.</param>
/// <param name="culture">Culture to use for localization and number formatting.</param>
/// <returns>String representation.</returns>
public string ToString(MassUnit unit, [CanBeNull] Culture culture)
{
return(ToString(unit, culture, 2));
}
/// <summary>
/// Dynamically convert from value and unit enum <see cref="MassUnit" /> to <see cref="Mass" />.
/// </summary>
/// <param name="value">Value to convert from.</param>
/// <param name="fromUnit">Unit to convert from.</param>
/// <returns>Mass unit value.</returns>
public static Mass?From(double?value, MassUnit fromUnit)
{
if (!value.HasValue)
{
return(null);
}
switch (fromUnit)
{
case MassUnit.Centigram:
return(FromCentigrams(value.Value));
case MassUnit.Decagram:
return(FromDecagrams(value.Value));
case MassUnit.Decigram:
return(FromDecigrams(value.Value));
case MassUnit.Gram:
return(FromGrams(value.Value));
case MassUnit.Hectogram:
return(FromHectograms(value.Value));
case MassUnit.Kilogram:
return(FromKilograms(value.Value));
case MassUnit.Kilotonne:
return(FromKilotonnes(value.Value));
case MassUnit.LongTon:
return(FromLongTons(value.Value));
case MassUnit.Megatonne:
return(FromMegatonnes(value.Value));
case MassUnit.Microgram:
return(FromMicrograms(value.Value));
case MassUnit.Milligram:
return(FromMilligrams(value.Value));
case MassUnit.Nanogram:
return(FromNanograms(value.Value));
case MassUnit.Ounce:
return(FromOunces(value.Value));
case MassUnit.Pound:
return(FromPounds(value.Value));
case MassUnit.ShortTon:
return(FromShortTons(value.Value));
case MassUnit.Stone:
return(FromStone(value.Value));
case MassUnit.Tonne:
return(FromTonnes(value.Value));
default:
throw new NotImplementedException("fromUnit: " + fromUnit);
}
}
public static Mass From(QuantityValue value, MassUnit fromUnit)
#endif
{
return(new Mass((double)value, fromUnit));
}
/// <summary>
/// Get unit abbreviation string.
/// </summary>
/// <param name="unit">Unit to get abbreviation for.</param>
/// <returns>Unit abbreviation string.</returns>
public static string GetAbbreviation(MassUnit unit)
{
return(GetAbbreviation(unit, null));
}
/// <summary>
/// Get string representation of value and unit. Using two significant digits after radix.
/// </summary>
/// <param name="unit">Unit representation to use.</param>
/// <param name="cultureName">Name of culture (ex: "en-US") to use for localization and number formatting. Defaults to <see cref="UnitSystem" />'s default culture.</param>
/// <returns>String representation.</returns>
public string ToString(MassUnit unit, [CanBeNull] string cultureName)
{
return(ToString(unit, cultureName, 2));
}
public static Mass From(decimal value, MassUnit fromUnit)
{
return(new Mass((decimal)value, fromUnit));
}
public static Mass?From(QuantityValue?value, MassUnit fromUnit)
{
return(value.HasValue ? new Mass((double)value.Value, fromUnit) : default(Mass?));
}
/// <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 MassUnit unit)
{
IFormatProvider provider = GetFormatProviderFromCultureName(cultureName);
return(UnitParser.Default.TryParse <MassUnit>(str, provider, out unit));
}
public static string GetAbbreviation(MassUnit unit, [CanBeNull] IFormatProvider provider)
{
provider = provider ?? UnitSystem.DefaultCulture;
return(UnitSystem.GetCached(provider).GetDefaultAbbreviation(unit));
}
private decimal AsBaseNumericType(MassUnit unit)
{
if (Unit == unit)
{
return(_value);
}
var baseUnitValue = AsBaseUnit();
switch (unit)
{
case MassUnit.Centigram: return((baseUnitValue * 1e3m) / 1e-2m);
case MassUnit.Decagram: return((baseUnitValue * 1e3m) / 1e1m);
case MassUnit.Decigram: return((baseUnitValue * 1e3m) / 1e-1m);
case MassUnit.EarthMass: return(baseUnitValue / 5.9722E+24m);
case MassUnit.Grain: return(baseUnitValue * 15432.358352941431m);
case MassUnit.Gram: return(baseUnitValue * 1e3m);
case MassUnit.Hectogram: return((baseUnitValue * 1e3m) / 1e2m);
case MassUnit.Kilogram: return((baseUnitValue * 1e3m) / 1e3m);
case MassUnit.Kilopound: return((baseUnitValue / 0.45359237m) / 1e3m);
case MassUnit.Kilotonne: return((baseUnitValue / 1e3m) / 1e3m);
case MassUnit.LongHundredweight: return(baseUnitValue * 0.01968413055222121m);
case MassUnit.LongTon: return(baseUnitValue / 1.0160469088e3m);
case MassUnit.Megapound: return((baseUnitValue / 0.45359237m) / 1e6m);
case MassUnit.Megatonne: return((baseUnitValue / 1e3m) / 1e6m);
case MassUnit.Microgram: return((baseUnitValue * 1e3m) / 1e-6m);
case MassUnit.Milligram: return((baseUnitValue * 1e3m) / 1e-3m);
case MassUnit.Nanogram: return((baseUnitValue * 1e3m) / 1e-9m);
case MassUnit.Ounce: return(baseUnitValue * 35.2739619m);
case MassUnit.Pound: return(baseUnitValue / 0.45359237m);
case MassUnit.ShortHundredweight: return(baseUnitValue * 0.022046226218487758m);
case MassUnit.ShortTon: return(baseUnitValue / 9.0718474e2m);
case MassUnit.Slug: return(baseUnitValue * 6.852176556196105e-2m);
case MassUnit.SolarMass: return(baseUnitValue / 1.98947e30m);
case MassUnit.Stone: return(baseUnitValue * 0.1574731728702698m);
case MassUnit.Tonne: return(baseUnitValue / 1e3m);
default:
throw new NotImplementedException($"Can not convert {Unit} to {unit}.");
}
}
/// <summary>
/// Get string representation of value and unit. Using two significant digits after radix.
/// </summary>
/// <param name="unit">Unit representation to use.</param>
/// <param name="provider">Format to use for localization and number formatting. Defaults to <see cref="UnitSystem.DefaultCulture" />.</param>
/// <returns>String representation.</returns>
public string ToString(MassUnit unit, [CanBeNull] IFormatProvider provider)
{
return(ToString(unit, provider, 2));
}
public static string AverageWeight(MassUnit unit) => $"Weight ({unit}, avg)";
private Weight FromPounds(MassUnit unit)
{
switch (unit)
{
case MassUnit.Grams:
{
return new Weight(_value * 453.592M, unit);
}
case MassUnit.KiloGrams:
{
return new Weight(_value / 1000M * 453.592M, unit);
}
case MassUnit.Pounds:
{
return new Weight(_value, unit);
}
}
return null;
}
protected override MassUnit __DoSubstraction(MassUnit right)
{
return new Kilogram(ConvertToBase().Value - right.ConvertToBase().Value);
}
public Weight(decimal value, MassUnit unit)
{
_value = value;
_unit = unit;
}
/// <summary>
/// Get string representation of value and unit. Using current UI culture and two significant digits after radix.
/// </summary>
/// <param name="unit">Unit representation to use.</param>
/// <returns>String representation.</returns>
public string ToString(MassUnit unit)
{
return(ToString(unit, null, 2));
}
private Weight FromKiloGrams(MassUnit unit)
{
switch (unit)
{
case MassUnit.Grams:
{
return new Weight(_value * 1000M, unit);
}
case MassUnit.KiloGrams:
{
return new Weight(_value, unit);
}
case MassUnit.Pounds:
{
return new Weight(_value * 2.20462M, unit);
}
}
return null;
}