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)); }