C# IQuantity.VerifyDimensions方法代码示例

        /// <summary>
        /// 
        /// </summary>
        /// <param name="qty"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        private static IQuantity CalculateRadiusFromDiameter(IQuantity qty, CircularCalculationType type)
        {
            if (!type.HasMask(CircularCalculationType.Diameter)) return null;

            // The dimension should be consistently Length, although the unit itself may be different.
            qty.VerifyDimensions(L.Meter);

            var resultQty = (Quantity) qty/2d;

            return resultQty;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="qty"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        private static IQuantity CalculateAreaFromDiameter(IQuantity qty, CircularCalculationType type)
        {
            if (!type.HasFlag(CircularCalculationType.Diameter)) return null;

            // The dimension should be consistently Length, although the unit itself may be different.
            qty.VerifyDimensions(L.Meter);

            var resultQty = (Quantity) ((Quantity) qty/2d).Squared()*Math.PI;

            return resultQty;
        }

        /// <summary>
        /// Returns the Radius calculated from the given <see cref="IArea"/> expressed through
        /// <paramref name="qty"/>. The resulting units will be in alignment with said Qty.
        /// </summary>
        /// <param name="qty"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        /// <a href="!:http://en.wikipedia.org/wiki/Arc_%28geometry%29" >Area (geometry)</a>
        private static IQuantity CalculateRadiusFromArea(IQuantity qty, CircularCalculationType type)
        {
            if (!type.HasMask(CircularCalculationType.Area)) return null;

            // Dimensions should be Length Squared. Does not matter the unit at this moment.
            qty.VerifyDimensions(L.Meter.Squared());

            var resultQty = ((Quantity) qty/Math.PI).SquareRoot();

            return resultQty;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="qty"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        /// <a href="!:http://en.wikipedia.org/wiki/Circumference" >Circumference</a>
        /// <a href="!:http://en.wikipedia.org/wiki/Pi" >Pi</a>
        private static IQuantity CalculateRadiusFromCircumference(IQuantity qty, CircularCalculationType type)
        {
            if (!type.HasMask(CircularCalculationType.Circumference)) return null;

            //TODO: for these types of calculations, it might make sense to capture a "derived" unit of "circumference", based on "length", but for first class treatment...
            qty.VerifyDimensions(L.Meter);

            var resultQty = (Quantity) qty/(2d*Math.PI);

            return resultQty;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="aQty"></param>
        /// <param name="bQty"></param>
        /// <returns></returns>
        /// <a href="http://www.mathsisfun.com/geometry/ellipse.html" >Ellipse</a>
        /// <a href="http://mathworld.wolfram.com/Ellipse.html" >Ellipse</a>
        private static IQuantity CalculateEllipticalArea(IQuantity aQty, IQuantity bQty)
        {
            /* There is no such thing as types here, since by definition elliptical
             * area is calculated from A and B components, or major and minor axes. */

            {
                // The dimensions should be consistently Length, although the unit itself may be different.
                var m = L.Meter;
                aQty.VerifyDimensions(m);
                bQty.VerifyDimensions(m);
            }

            var resultQty = (Quantity) aQty*bQty*Math.PI;

            return resultQty;
        }

        private static IQuantity CalculateDiameterFromRadius(IQuantity qty, CircularCalculationType type)
        {
            if (!type.HasFlag(CircularCalculationType.Radius)) return null;

            qty.VerifyDimensions(L.Meter);

            var resultQty = (Quantity) qty*2d;

            return resultQty;
        }

        private static IQuantity Modulus(IQuantity a, IQuantity b, Func<double, double, double> modulus,
            Func<IEnumerable<IDimension>, IEnumerable<IDimension>> dimensionality = null)
        {
            dimensionality = dimensionality ?? (x => x);

            var aBase = a.ToBase();
            var bBase = b.ToBase();

            //TODO: must B really be dimensionless? what are the ramifications for modulus being a close neighbor of division?
            // A can be any dimension, however, b must be dimensionless.
            b.VerifyDimensions();

            var aDims = aBase.Dimensions.EnumerateAll();

            return new Quantity(modulus(aBase.Value, bBase.Value),
                dimensionality(aDims).Reduce().ToArray());
        }

 private static IQuantity Add(IQuantity a, double b, Func<double, double, double> adder)
 {
     a.VerifyDimensions();
     return new Quantity(adder(a.Value, b));
 }