コード例 #1
0
 /// <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="provider">Format to use when parsing number and unit. Defaults to <see cref="CultureInfo.CurrentUICulture" /> if null.</param>
 public static bool TryParse(string str, IFormatProvider provider, out WarpingMomentOfInertia result)
 {
     return(QuantityParser.Default.TryParse <WarpingMomentOfInertia, WarpingMomentOfInertiaUnit>(
                str,
                provider,
                From,
                out result));
 }
コード例 #2
0
        /// <summary>
        ///     <para>
        ///     Compare equality to another WarpingMomentOfInertia 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(WarpingMomentOfInertia 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(Comparison.Equals(thisValue, otherValueInThisUnits, tolerance, comparisonType));
        }
コード例 #3
0
 /// <inheritdoc />
 /// <remarks>Consider using <see cref="Equals(WarpingMomentOfInertia, double, ComparisonType)"/> for safely comparing floating point values.</remarks>
 public bool Equals(WarpingMomentOfInertia other)
 {
     return(_value.Equals(other.GetValueAs(this.Unit)));
 }
コード例 #4
0
 /// <inheritdoc />
 public int CompareTo(WarpingMomentOfInertia other)
 {
     return(_value.CompareTo(other.GetValueAs(this.Unit)));
 }
コード例 #5
0
 /// <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(string str, out WarpingMomentOfInertia result)
 {
     return(TryParse(str, null, out result));
 }