public UnitValue(IUnitDefinition unit, double value)
{
var unitValue = unit.ConvertToUnitValue(value);
Unit = unitValue.Unit;
Value = unitValue.Value;
}
public UnitPoint2D(SIPrefix prefix, IUnitDefinition unit, double x, double y)
: base(
prefix.GetMultiplier() * unit.ConvertToUnitValue(x).Value,
prefix.GetMultiplier() * unit.ConvertToUnitValue(y).Value)
{
Unit = unit.CorrespondingCompoundUnit;
}
public void CompoundUnitIsCorrectlyParsed(string unitString, IUnitDefinition expectedUnit)
{
var expected = expectedUnit.CorrespondingCompoundUnit;
var actual = CompoundUnitParser.Parse(1d, unitString);
Assert.That(actual.Unit, Is.EqualTo(expected));
}
public void CanParseUnitValue(string s, double expectedValue, IUnitDefinition expectedUnit)
{
UnitValue unitValue = null;
Assert.That(() => unitValue = UnitValue.Parse(s), Throws.Nothing);
Assert.That(unitValue.Value, Is.EqualTo(expectedValue).Within(expectedValue.Abs() * 1e-6));
Assert.That(unitValue.Unit, Is.EqualTo(expectedUnit));
}
private void AddUnitToStringRepresentationLookup(IUnitDefinition unit)
{
inverseStringRepresentationLookup.Add(unit.StringRepresentation, unit);
foreach (var alternativeStringRepresentation in unit.AlternativeStringRepresentations)
{
inverseStringRepresentationLookup.Add(alternativeStringRepresentation, unit);
}
}
public bool Equals(IUnitDefinition other)
{
if (other == null)
{
return(false);
}
return(Equals(other.CorrespondingCompoundUnit));
}
public void UnitConversionRoundtripReturnsInput(IUnitDefinition unit)
{
var number = StaticRandom.Rng.NextDouble();
var unitValue = number.To(unit);
var roundtripNumber = unitValue.In(unit);
Assert.That(roundtripNumber, Is.EqualTo(number).Within(1e-5));
}
public void SerializationRoundtripDoubleSpecialValues(double value, IUnitDefinition unit)
{
var unitValue = new UnitValue(unit, value);
var serializer = new Serializer <UnitValue>();
UnitValue deserializedUnitValue;
using (var stream = new MemoryStream())
{
serializer.Store(unitValue, stream);
stream.Seek(0, SeekOrigin.Begin);
deserializedUnitValue = serializer.Load(stream);
}
Assert.That(deserializedUnitValue, Is.EqualTo(unitValue));
}
private static void ParseSimpleUnit(string unitString, out IUnitDefinition unit, out SIPrefix siPrefix)
{
if (string.IsNullOrEmpty(unitString))
{
throw new FormatException($"Invalid unit '{unitString}'");
}
var normalizedUnitString = unitString.Trim();
if (Unit.Effective.InverseStringRepresentationLookup.ContainsKey(unitString))
{
siPrefix = SIPrefix.None;
unit = Unit.Effective.InverseStringRepresentationLookup[unitString];
return;
}
if (normalizedUnitString.Length == 1)
{
throw new FormatException($"Invalid unit '{unitString}'");
}
// Try with SI multiplier prefix
var prefixString = unitString.Substring(0, 1);
var newUnitString = unitString.Substring(1);
if (!Unit.Effective.InverseStringRepresentationLookup.ContainsKey(newUnitString))
{
throw new FormatException($"Invalid unit '{unitString}'");
}
unit = Unit.Effective.InverseStringRepresentationLookup[newUnitString];
if (UnitValueExtensions.InverseSIPrefixStringRepresentation.ContainsKey(prefixString))
{
siPrefix = UnitValueExtensions.InverseSIPrefixStringRepresentation[prefixString];
return;
}
throw new FormatException($"Invalid unit '{unitString}'");
}
public UnitPoint2D(IUnitDefinition unit, double x, double y)
: this(SIPrefix.None, unit, x, y)
{
}
public static UnitVector2D To(this Vector2D point, SIPrefix siPrefix, IUnitDefinition unit)
{
return(new UnitVector2D(siPrefix, unit, point.X, point.Y));
}
public static double ConvertUnit(this double value, IUnitDefinition fromUnit, IUnitDefinition toUnit)
{
return(toUnit.ConvertBack(fromUnit.ConvertToUnitValue(value)));
}
public static UnitValue Average <T>(this IEnumerable <T> items, Func <T, UnitValue> valueSelector,
SIPrefix siPrefix, IUnitDefinition unit)
{
return(items.Select(valueSelector).Average(siPrefix, unit));
}
public static UnitValue Sum(this IEnumerable <UnitValue> items, IUnitDefinition unit)
{
return(items.Select(item => item.In(unit)).Sum().To(unit));
}
public static double In(this UnitValue unitValue, SIPrefix prefix, IUnitDefinition unit)
{
var multiplier = GetMultiplier(prefix);
return(unitValue.In(unit) / multiplier);
}
public static UnitValue Average(this IEnumerable <UnitValue> items, IUnitDefinition unit)
{
return(items.Average(SIPrefix.None, unit));
}
public static UnitVector2D To(this Vector2D point, IUnitDefinition unit)
{
return(point.To(SIPrefix.None, unit));
}
public static UnitValue To(this int value, SIPrefix prefix, IUnitDefinition unit)
{
return(To((double)value, prefix, unit));
}
public static UnitValue Average(this IEnumerable <UnitValue> items, SIPrefix siPrefix, IUnitDefinition unit)
{
return(items.Select(uv => uv.In(siPrefix, unit)).Average().To(siPrefix, unit));
}
public static UnitValue To(this double value, SIPrefix prefix, IUnitDefinition unit)
{
var multiplier = GetMultiplier(prefix);
return(unit.ConvertToUnitValue(multiplier * value));
}
public static UnitValue To(this float value, IUnitDefinition unit)
{
return(To((double)value, unit));
}
public static UnitValue To(this double value, IUnitDefinition unit)
{
return(unit.ConvertToUnitValue(value));
}
public static Vector2D In(this UnitVector2D unitPoint, IUnitDefinition targetUnit)
{
return(unitPoint.In(SIPrefix.None, targetUnit));
}
public static UnitPoint3D To(this Point3D point, SIPrefix siPrefix, IUnitDefinition unit)
{
return(new UnitPoint3D(siPrefix, unit, point.X, point.Y, point.Z));
}
public static Vector2D In(this UnitVector2D unitPoint, SIPrefix targetSIPrefix, IUnitDefinition targetUnit)
{
var multiplier = new UnitValue(unitPoint.Unit, 1).In(targetSIPrefix, targetUnit);
return(new Vector2D(
multiplier * unitPoint.X,
multiplier * unitPoint.Y));
}
public static UnitPoint3D To(this Point3D point, IUnitDefinition unit)
{
return(point.To(SIPrefix.None, unit));
}
public void UnitConversionAsExpected(IUnitDefinition originalUnit, IUnitDefinition targetUnit, double expectedValue)
{
Assert.That(1.To(originalUnit).In(targetUnit), Is.EqualTo(expectedValue).Within(1e-3 * expectedValue));
}
public static bool CanConvertTo(this UnitValue unitValue, IUnitDefinition unit)
{
return(unitValue.Unit == unit.CorrespondingCompoundUnit);
}
public void CanConvertToTrueForCompatibleUnits(IUnitDefinition originalUnit, IUnitDefinition targetUnit)
{
var unitValue = 1.To(originalUnit);
Assert.That(unitValue.CanConvertTo(targetUnit), Is.True);
}
public static double In(this UnitValue unitValue, IUnitDefinition newUnit)
{
return(newUnit.ConvertBack(unitValue));
}
