Code:
/ DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Shared / MS / Internal / DoubleUtil.cs / 1 / DoubleUtil.cs
//---------------------------------------------------------------------------- // // Copyright (C) Microsoft Corporation. All rights reserved. // // File: DoubleUtil.cs // // Description: This file contains the implementation of DoubleUtil, which // provides "fuzzy" comparison functionality for doubles and // double-based classes and structs in our code. // // History: // 04/28/2003 : [....] - Created // 05/20/2003 : [....] - Moved it to Shared, so Base, Core and Framework can all share. // //--------------------------------------------------------------------------- using System; using System.Windows; using System.Runtime.InteropServices; #if WINDOWS_BASE using MS.Internal.WindowsBase; #elif PRESENTATION_CORE using MS.Internal.PresentationCore; #elif PRESENTATIONFRAMEWORK using MS.Internal.PresentationFramework; #elif DRT using MS.Internal.Drt; #else #error Attempt to use FriendAccessAllowedAttribute from an unknown assembly. using MS.Internal.YourAssemblyName; #endif namespace MS.Internal { [FriendAccessAllowed] internal static class DoubleUtil { // Const values come from sdk\inc\crt\float.h internal const double DBL_EPSILON = 2.2204460492503131e-016; /* smallest such that 1.0+DBL_EPSILON != 1.0 */ internal const float FLT_MIN = 1.175494351e-38F; /* Number close to zero, where float.MinValue is -float.MaxValue */ ////// AreClose - Returns whether or not two doubles are "close". That is, whether or /// not they are within epsilon of each other. Note that this epsilon is proportional /// to the numbers themselves to that AreClose survives scalar multiplication. /// There are plenty of ways for this to return false even for numbers which /// are theoretically identical, so no code calling this should fail to work if this /// returns false. This is important enough to repeat: /// NB: NO CODE CALLING THIS FUNCTION SHOULD DEPEND ON ACCURATE RESULTS - this should be /// used for optimizations *only*. /// ////// bool - the result of the AreClose comparision. /// /// The first double to compare. /// The second double to compare. public static bool AreClose(double value1, double value2) { //in case they are Infinities (then epsilon check does not work) if(value1 == value2) return true; // This computes (|value1-value2| / (|value1| + |value2| + 10.0)) < DBL_EPSILON double eps = (Math.Abs(value1) + Math.Abs(value2) + 10.0) * DBL_EPSILON; double delta = value1 - value2; return(-eps < delta) && (eps > delta); } ////// LessThan - Returns whether or not the first double is less than the second double. /// That is, whether or not the first is strictly less than *and* not within epsilon of /// the other number. Note that this epsilon is proportional to the numbers themselves /// to that AreClose survives scalar multiplication. Note, /// There are plenty of ways for this to return false even for numbers which /// are theoretically identical, so no code calling this should fail to work if this /// returns false. This is important enough to repeat: /// NB: NO CODE CALLING THIS FUNCTION SHOULD DEPEND ON ACCURATE RESULTS - this should be /// used for optimizations *only*. /// ////// bool - the result of the LessThan comparision. /// /// The first double to compare. /// The second double to compare. public static bool LessThan(double value1, double value2) { return (value1 < value2) && !AreClose(value1, value2); } ////// GreaterThan - Returns whether or not the first double is greater than the second double. /// That is, whether or not the first is strictly greater than *and* not within epsilon of /// the other number. Note that this epsilon is proportional to the numbers themselves /// to that AreClose survives scalar multiplication. Note, /// There are plenty of ways for this to return false even for numbers which /// are theoretically identical, so no code calling this should fail to work if this /// returns false. This is important enough to repeat: /// NB: NO CODE CALLING THIS FUNCTION SHOULD DEPEND ON ACCURATE RESULTS - this should be /// used for optimizations *only*. /// ////// bool - the result of the GreaterThan comparision. /// /// The first double to compare. /// The second double to compare. public static bool GreaterThan(double value1, double value2) { return (value1 > value2) && !AreClose(value1, value2); } ////// LessThanOrClose - Returns whether or not the first double is less than or close to /// the second double. That is, whether or not the first is strictly less than or within /// epsilon of the other number. Note that this epsilon is proportional to the numbers /// themselves to that AreClose survives scalar multiplication. Note, /// There are plenty of ways for this to return false even for numbers which /// are theoretically identical, so no code calling this should fail to work if this /// returns false. This is important enough to repeat: /// NB: NO CODE CALLING THIS FUNCTION SHOULD DEPEND ON ACCURATE RESULTS - this should be /// used for optimizations *only*. /// ////// bool - the result of the LessThanOrClose comparision. /// /// The first double to compare. /// The second double to compare. public static bool LessThanOrClose(double value1, double value2) { return (value1 < value2) || AreClose(value1, value2); } ////// GreaterThanOrClose - Returns whether or not the first double is greater than or close to /// the second double. That is, whether or not the first is strictly greater than or within /// epsilon of the other number. Note that this epsilon is proportional to the numbers /// themselves to that AreClose survives scalar multiplication. Note, /// There are plenty of ways for this to return false even for numbers which /// are theoretically identical, so no code calling this should fail to work if this /// returns false. This is important enough to repeat: /// NB: NO CODE CALLING THIS FUNCTION SHOULD DEPEND ON ACCURATE RESULTS - this should be /// used for optimizations *only*. /// ////// bool - the result of the GreaterThanOrClose comparision. /// /// The first double to compare. /// The second double to compare. public static bool GreaterThanOrClose(double value1, double value2) { return (value1 > value2) || AreClose(value1, value2); } ////// IsOne - Returns whether or not the double is "close" to 1. Same as AreClose(double, 1), /// but this is faster. /// ////// bool - the result of the AreClose comparision. /// /// The double to compare to 1. public static bool IsOne(double value) { return Math.Abs(value-1.0) < 10.0 * DBL_EPSILON; } ////// IsZero - Returns whether or not the double is "close" to 0. Same as AreClose(double, 0), /// but this is faster. /// ////// bool - the result of the AreClose comparision. /// /// The double to compare to 0. public static bool IsZero(double value) { return Math.Abs(value) < 10.0 * DBL_EPSILON; } // The Point, Size, Rect and Matrix class have moved to WinCorLib. However, we provide // internal AreClose methods for our own use here. ////// Compares two points for fuzzy equality. This function /// helps compensate for the fact that double values can /// acquire error when operated upon /// /// The first point to compare /// The second point to compare ///Whether or not the two points are equal public static bool AreClose(Point point1, Point point2) { return DoubleUtil.AreClose(point1.X, point2.X) && DoubleUtil.AreClose(point1.Y, point2.Y); } ////// Compares two Size instances for fuzzy equality. This function /// helps compensate for the fact that double values can /// acquire error when operated upon /// /// The first size to compare /// The second size to compare ///Whether or not the two Size instances are equal public static bool AreClose(Size size1, Size size2) { return DoubleUtil.AreClose(size1.Width, size2.Width) && DoubleUtil.AreClose(size1.Height, size2.Height); } ////// Compares two Vector instances for fuzzy equality. This function /// helps compensate for the fact that double values can /// acquire error when operated upon /// /// The first Vector to compare /// The second Vector to compare ///Whether or not the two Vector instances are equal public static bool AreClose(System.Windows.Vector vector1, System.Windows.Vector vector2) { return DoubleUtil.AreClose(vector1.X, vector2.X) && DoubleUtil.AreClose(vector1.Y, vector2.Y); } ////// Compares two rectangles for fuzzy equality. This function /// helps compensate for the fact that double values can /// acquire error when operated upon /// /// The first rectangle to compare /// The second rectangle to compare ///Whether or not the two rectangles are equal public static bool AreClose(Rect rect1, Rect rect2) { // If they're both empty, don't bother with the double logic. if (rect1.IsEmpty) { return rect2.IsEmpty; } // At this point, rect1 isn't empty, so the first thing we can test is // rect2.IsEmpty, followed by property-wise compares. return (!rect2.IsEmpty) && DoubleUtil.AreClose(rect1.X, rect2.X) && DoubleUtil.AreClose(rect1.Y, rect2.Y) && DoubleUtil.AreClose(rect1.Height, rect2.Height) && DoubleUtil.AreClose(rect1.Width, rect2.Width); } ////// /// /// ///public static bool IsBetweenZeroAndOne(double val) { return (GreaterThanOrClose(val, 0) && LessThanOrClose(val, 1)); } /// /// /// /// ///public static int DoubleToInt(double val) { return (0 < val) ? (int)(val + 0.5) : (int)(val - 0.5); } /// /// rectHasNaN - this returns true if this rect has X, Y , Height or Width as NaN. /// /// The rectangle to test ///returns whether the Rect has NaN public static bool RectHasNaN(Rect r) { if ( DoubleUtil.IsNaN(r.X) || DoubleUtil.IsNaN(r.Y) || DoubleUtil.IsNaN(r.Height) || DoubleUtil.IsNaN(r.Width) ) { return true; } return false; } #if !PBTCOMPILER [StructLayout(LayoutKind.Explicit)] private struct NanUnion { [FieldOffset(0)] internal double DoubleValue; [FieldOffset(0)] internal UInt64 UintValue; } // The standard CLR double.IsNaN() function is approximately 100 times slower than our own wrapper, // so please make sure to use DoubleUtil.IsNaN() in performance sensitive code. // PS item that tracks the CLR improvement is DevDiv Schedule : 26916. // IEEE 754 : If the argument is any value in the range 0x7ff0000000000001L through 0x7fffffffffffffffL // or in the range 0xfff0000000000001L through 0xffffffffffffffffL, the result will be NaN. public static bool IsNaN(double value) { NanUnion t = new NanUnion(); t.DoubleValue = value; UInt64 exp = t.UintValue & 0xfff0000000000000; UInt64 man = t.UintValue & 0x000fffffffffffff; return (exp == 0x7ff0000000000000 || exp == 0xfff0000000000000) && (man != 0); } #endif } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007. // Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- CompatibleComparer.cs
- securestring.cs
- DefaultBinder.cs
- NonSerializedAttribute.cs
- ItemDragEvent.cs
- LinkLabel.cs
- VectorKeyFrameCollection.cs
- PersonalizationStateInfo.cs
- ListViewDesigner.cs
- HttpRawResponse.cs
- WebScriptEnablingElement.cs
- CopyNodeSetAction.cs
- WebPartUtil.cs
- ObjectKeyFrameCollection.cs
- SafeIUnknown.cs
- PageResolution.cs
- Model3DCollection.cs
- ControlAdapter.cs
- WebPartCancelEventArgs.cs
- DataPagerFieldItem.cs
- MarkupExtensionParser.cs
- FileStream.cs
- BatchWriter.cs
- WebPartsPersonalization.cs
- WebPartConnectionsEventArgs.cs
- TextSpanModifier.cs
- Stacktrace.cs
- WindowsAuthenticationEventArgs.cs
- NetMsmqSecurityElement.cs
- TrackPointCollection.cs
- LazyInitializer.cs
- OrderedHashRepartitionStream.cs
- HwndKeyboardInputProvider.cs
- AuthenticationModuleElement.cs
- SelectQueryOperator.cs
- EnumConverter.cs
- VisualTreeFlattener.cs
- EFAssociationProvider.cs
- SplayTreeNode.cs
- FocusWithinProperty.cs
- SoapFault.cs
- ConstructorExpr.cs
- PersonalizationStateQuery.cs
- StringSource.cs
- ChangeInterceptorAttribute.cs
- SerializationSectionGroup.cs
- CompleteWizardStep.cs
- DesignerActionItemCollection.cs
- SqlUdtInfo.cs
- DataGridLinkButton.cs
- SHA1CryptoServiceProvider.cs
- XmlNodeComparer.cs
- DesignerAdapterAttribute.cs
- IntSumAggregationOperator.cs
- UnsafeNativeMethodsTablet.cs
- SqlProfileProvider.cs
- Oid.cs
- XsdBuilder.cs
- ColorBuilder.cs
- Transform3D.cs
- PerformanceCounterNameAttribute.cs
- DbProviderFactory.cs
- Models.cs
- ApplyTemplatesAction.cs
- MultipartIdentifier.cs
- x509utils.cs
- BinaryUtilClasses.cs
- PhysicalFontFamily.cs
- TimerTable.cs
- RbTree.cs
- WebPartTransformer.cs
- IntSecurity.cs
- DataViewListener.cs
- NoneExcludedImageIndexConverter.cs
- QueryTask.cs
- MultiPartWriter.cs
- ListSurrogate.cs
- BoundField.cs
- ParallelDesigner.cs
- StatusStrip.cs
- RewritingProcessor.cs
- OrderByBuilder.cs
- TraceRecord.cs
- WindowsAuthenticationEventArgs.cs
- XmlUrlResolver.cs
- SiteMapProvider.cs
- KeyEvent.cs
- NotFiniteNumberException.cs
- DataGridViewRowContextMenuStripNeededEventArgs.cs
- WindowsTitleBar.cs
- MobileContainerDesigner.cs
- KnownBoxes.cs
- GradientStop.cs
- BulletDecorator.cs
- SqlCacheDependencyDatabaseCollection.cs
- XmlCDATASection.cs
- UriSectionReader.cs
- SqlTypesSchemaImporter.cs
- PreProcessInputEventArgs.cs
- AssemblyHelper.cs