/// <summary> /// Gets the math ml. /// </summary> /// <param name="quantity">The quantity.</param> /// <param name="unitFormat">The unit format.</param> /// <param name="multiplicationSign">The multiplication sign.</param> /// <returns>The root math ml element.</returns> public static XElement ToMathML( this IQuantity quantity, UnitFormat unitFormat = UnitFormat.Default, MultiplicationSign multiplicationSign = MultiplicationSign.Invisible) { return QuantityToMathMLConverter.DefaultConverter.GetMathML(quantity, unitFormat, multiplicationSign); }
public void Velocity_ToString_When_UnitModeIsSpecified_Then_ResultShouldBeExpected( UnitFormat unitFormat, string expected) { var testee = new Velocity(1, x => x.Kilo.Meters / x.Hours); var result = testee.ToString(unitFormat); result.Should().Be(expected); }
public void Force_ToString_When_UnitModeIsSpecified_Then_ResultShouldBeExpected( UnitFormat unitFormat, string expected) { var testee = new Force(1, x => x.Newtons); var result = testee.ToString(unitFormat); result.Should().Be(expected); }
/// <summary> /// The be approximately. /// </summary> /// <param name="quantityAssertions"> /// The quantity assertions. /// </param> /// <param name="expectedValue"> /// The expected value. /// </param> /// <param name="expectedUnit"> /// The expected unit. /// </param> /// <param name="unitFormat"> /// The unit format. /// </param> /// <param name="precision"> /// The precision. /// </param> /// <returns> /// The <see cref="AndConstraint{T}"/>. /// </returns> public static AndConstraint <ComparableTypeAssertions <IQuantity> > BeApproximately( this ComparableTypeAssertions <IQuantity> quantityAssertions, double expectedValue, string expectedUnit, UnitFormat unitFormat, double precision) { var quantity = (IQuantity)quantityAssertions.Subject; var quantityValue = quantity.Value; var quantityUnit = UnitFormatHelper.GetNotation(quantity.Unit, unitFormat); Execute.Assertion.ForCondition(quantityValue == expectedValue || Math.Abs(quantityValue - expectedValue) < precision) .FailWith("The value: {0}, but found: {1}", expectedValue, quantityValue); AssertUnit(quantityUnit, expectedUnit); return(new AndConstraint <ComparableTypeAssertions <IQuantity> >(quantityAssertions)); }
public static string FormatUnits(double value, UnitFormat unitFormat, int unitPrecision) { var prefix = Math.Sign(value) < 0 ? "-" : ""; value = Math.Abs(value); switch (unitFormat) { case UnitFormat.Architectural: return(string.Concat(prefix, FormatArchitectural(value, unitPrecision))); case UnitFormat.Metric: return(string.Concat(prefix, FormatMetric(value, unitPrecision))); default: throw new ArgumentException("value"); } }
/// <summary> /// The be. /// </summary> /// <param name="quantityAssertions"> /// The quantity assertions. /// </param> /// <param name="expectedValue"> /// The expected value. /// </param> /// <param name="expectedUnit"> /// The expected unit. /// </param> /// <param name="unitFormat"> /// The unit format. /// </param> /// <returns> /// The <see cref="AndConstraint{T}"/>. /// </returns> public static AndConstraint<ComparableTypeAssertions<IQuantity>> Be( this ComparableTypeAssertions<IQuantity> quantityAssertions, double expectedValue, string expectedUnit, UnitFormat unitFormat) { var quantity = (IQuantity)quantityAssertions.Subject; var quantityValue = quantity.Value; var quantityUnit = UnitHelper.GetNotation(quantity.Unit, unitFormat); Execute.Assertion.ForCondition(quantityValue.Equals(expectedValue)) .FailWith( "The value: {0}, but found: {1}", expectedValue.ToString("N20"), quantityValue.ToString("N20")); AssertUnit(quantityUnit, expectedUnit); return new AndConstraint<ComparableTypeAssertions<IQuantity>>(quantityAssertions); }
/// <summary> /// The be. /// </summary> /// <param name="quantityAssertions"> /// The quantity assertions. /// </param> /// <param name="expectedValue"> /// The expected value. /// </param> /// <param name="expectedUnit"> /// The expected unit. /// </param> /// <param name="unitFormat"> /// The unit format. /// </param> /// <returns> /// The <see cref="AndConstraint{T}"/>. /// </returns> public static AndConstraint <ComparableTypeAssertions <IQuantity> > Be( this ComparableTypeAssertions <IQuantity> quantityAssertions, double expectedValue, string expectedUnit, UnitFormat unitFormat) { var quantity = (IQuantity)quantityAssertions.Subject; var quantityValue = quantity.Value; var quantityUnit = UnitFormatHelper.GetNotation(quantity.Unit, unitFormat); Execute.Assertion.ForCondition(quantityValue.Equals(expectedValue)) .FailWith( "The value: {0}, but found: {1}", expectedValue.ToString("N20"), quantityValue.ToString("N20")); AssertUnit(quantityUnit, expectedUnit); return(new AndConstraint <ComparableTypeAssertions <IQuantity> >(quantityAssertions)); }
public DrawingSettings(string path, UnitFormat unitFormat, int unitPrecision) { this.fileName = path; this.unitFormat = unitFormat; this.unitPrecision = unitPrecision < 0 ? 0 : unitPrecision; switch (unitFormat) { case UnitFormat.Architectural: // only allowable values are 0, 2, 4, 8, 16, 32 this.unitPrecision = AllowedArchitecturalPrecisions.Where(x => x <= this.unitPrecision).Max(); break; case UnitFormat.Metric: // only allowable values are [0, 16] this.unitPrecision = Math.Max(0, this.unitPrecision); this.unitPrecision = Math.Min(16, this.unitPrecision); break; } }
public void Quantity_Multiplication_Then_ResultShouldBeExpected( double lhs, string lhsUnit, double rhs, string rhsUnit, UnitFormat unitFormat, double expectedValue, string expectedUnit) { var testee1 = new Quantity( lhs, UnitSystem.GetUnitFrom(lhsUnit, ParseSettings.DefaultInvariantCulture).Value); var testee2 = new Quantity( rhs, UnitSystem.GetUnitFrom(rhsUnit, ParseSettings.DefaultInvariantCulture).Value); var result = testee1 * testee2; result.Should().Be(expectedValue, expectedUnit, unitFormat); }
/// <summary> /// Gets the math ml. /// </summary> /// <param name="quantity">The quantity.</param> /// <param name="unitFormat">The unit format.</param> /// <param name="multiplicationSign">The multiplication sign.</param> /// <returns>The root <see cref="XElement"/> node.</returns> public XElement GetMathML( IQuantity quantity, UnitFormat unitFormat = UnitFormat.Default, MultiplicationSign multiplicationSign = MultiplicationSign.Invisible) { var mn = new XElement(MathML.Mn, quantity.Value); var mrow = new XElement(MathML.Mrow, mn); var unitElement = mrow; if (unitFormat.HasFlag(UnitFormat.SurroundInBrackets)) { var mfenced = new XElement(MathML.Mfenced, MathML.OpenLeftBracket, MathML.CloseRightBrack); mrow.Add(mfenced); unitElement = mfenced; } ExpressionToMathMLVisitor.DefaultMathMLVisitor.Visit( quantity.Unit.GetExpression(), multiplicationSign, unitElement); return new XElement(MathML.Math, new XAttribute(MathML.NamespaceAlias, MathML.Namespace), mrow); }
public DrawingSettings(string path, UnitFormat unitFormat, int unitPrecision, int anglePrecision) { FileName = path; UnitFormat = unitFormat; UnitPrecision = unitPrecision < 0 ? 0 : unitPrecision; AnglePrecision = anglePrecision < 0 ? 0 : anglePrecision; switch (unitFormat) { case UnitFormat.Architectural: // only allowable values are 0, 2, 4, 8, 16, 32 UnitPrecision = AllowedArchitecturalPrecisions.Where(x => x <= UnitPrecision).Max(); break; case UnitFormat.Metric: // only allowable values are [0, 16] UnitPrecision = Math.Max(0, UnitPrecision); UnitPrecision = Math.Min(16, UnitPrecision); break; } }
/// <summary> /// Gets the math ml. /// </summary> /// <param name="quantity">The quantity.</param> /// <param name="unitFormat">The unit format.</param> /// <param name="multiplicationSign">The multiplication sign.</param> /// <returns>The root <see cref="XElement"/> node.</returns> public XElement GetMathML( IQuantity quantity, UnitFormat unitFormat = UnitFormat.Default, MultiplicationSign multiplicationSign = MultiplicationSign.Invisible) { var mn = new XElement(MathML.Mn, quantity.Value); var mrow = new XElement(MathML.Mrow, mn); var unitElement = mrow; if (unitFormat.HasFlag(UnitFormat.SurroundInBrackets)) { var mfenced = new XElement(MathML.Mfenced, MathML.OpenLeftBracket, MathML.CloseRightBrack); mrow.Add(mfenced); unitElement = mfenced; } ExpressionToMathMLVisitor.DefaultMathMLVisitor.Visit( quantity.Unit.GetExpression(), multiplicationSign, unitElement); return(new XElement(MathML.Math, new XAttribute(MathML.NamespaceAlias, MathML.Namespace), mrow)); }
internal UnitDefinitionDescriptor(UnitFormat format) { Format = format; }
/// <summary> /// Returns a <see cref="string" /> that represents this instance. /// </summary> /// <param name="unitFormat">The unit format.</param> /// <param name="formatProvider">The format provider.</param> /// <returns> /// A <see cref="string" /> that represents this instance. /// </returns> public string ToString(UnitFormat unitFormat, IFormatProvider formatProvider) { return this.ToString(unitFormat, null, formatProvider); }
/// <summary> /// Gets the notation. /// </summary> /// <param name="unit">The quantity unit.</param> /// <param name="unitFormat">The unit format.</param> /// <returns>The notation.</returns> public static string GetNotation(IUnit unit, UnitFormat unitFormat) { Contract.Requires(unit != null); var notation = unit.Notation; if (unitFormat.HasFlag(UnitFormat.SurroundInBrackets)) { return $"[{notation}]"; } return notation; }
/// <summary> /// Returns a <see cref="string" /> that represents this instance. /// </summary> /// <param name="unitFormat">The unit format.</param> /// <param name="format">The format.</param> /// <param name="formatProvider">The format provider.</param> /// <returns> /// A <see cref="string" /> that represents this instance. /// </returns> public string ToString(UnitFormat unitFormat, string format, IFormatProvider formatProvider) { return QuantityHelper.ToString( this.Unit.FormatValue(this.value, format, formatProvider), UnitFormatHelper.GetNotation(this.Unit, unitFormat)); }
/// <summary> /// Returns a <see cref="string" /> that represents this instance. /// </summary> /// <param name="unitFormat">The unit format.</param> /// <param name="format">The format.</param> /// <returns> /// A <see cref="string" /> that represents this instance. /// </returns> public string ToString(UnitFormat unitFormat, string format) { return this.ToString(unitFormat, format, CultureInfo.CurrentCulture); }
/// <summary> /// The be approximately. /// </summary> /// <param name="quantityAssertions"> /// The quantity assertions. /// </param> /// <param name="expectedValue"> /// The expected value. /// </param> /// <param name="expectedUnit"> /// The expected unit. /// </param> /// <param name="unitFormat"> /// The unit format. /// </param> /// <param name="precision"> /// The precision. /// </param> /// <returns> /// The <see cref="AndConstraint{T}"/>. /// </returns> public static AndConstraint<ComparableTypeAssertions<IQuantity>> BeApproximately( this ComparableTypeAssertions<IQuantity> quantityAssertions, double expectedValue, string expectedUnit, UnitFormat unitFormat, double precision) { var quantity = (IQuantity)quantityAssertions.Subject; var quantityValue = quantity.Value; var quantityUnit = UnitHelper.GetNotation(quantity.Unit, unitFormat); Execute.Assertion.ForCondition(quantityValue == expectedValue || Math.Abs(quantityValue - expectedValue) < precision) .FailWith("The value: {0}, but found: {1}", expectedValue, quantityValue); AssertUnit(quantityUnit, expectedUnit); return new AndConstraint<ComparableTypeAssertions<IQuantity>>(quantityAssertions); }
/// <summary> /// 获取单位定义信息。 /// </summary> /// <param name="format">给定的 <see cref="UnitFormat"/>。</param> /// <param name="notation">给定的 <see cref="UnitNotation"/>。</param> /// <returns>返回 <see cref="UnitDefinitionInfo"/>。</returns> public static UnitDefinitionInfo GetInfo(UnitFormat format, UnitNotation notation) { var info = GetDescriptor(format); return(notation == UnitNotation.BinarySystem ? info.BinaryInfo : info.DecimalInfo); }
/// <summary> /// 获取指定单位格式的单位定义描述符。 /// </summary> /// <param name="format">给定的 <see cref="UnitFormat"/>。</param> /// <returns>返回 <see cref="UnitDefinitionDescriptor"/>。</returns> public static UnitDefinitionDescriptor GetDescriptor(UnitFormat format) => SupportDescriptors.First(info => info.Format == format);