csharpfftfsharpintegrationinterpolationlinear-algebramathdifferentiationmatrixnumericsrandomregressionstatisticsmathnet
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
55 lines
2.7 KiB
55 lines
2.7 KiB
//=========================================================================
|
|
// (c) Microsoft Corporation 2005-2009.
|
|
//=========================================================================
|
|
|
|
/// This namespace contains some common collections in a style primarily designed for use from F#.
|
|
|
|
namespace Microsoft.FSharp.Collections
|
|
open Microsoft.FSharp.Core
|
|
open Microsoft.FSharp.Collections
|
|
open Microsoft.FSharp.Primitives.Basics
|
|
open System
|
|
open System.Collections.Generic
|
|
|
|
/// Common notions of comparison identity used with sorted data structures.
|
|
module ComparisonIdentity =
|
|
|
|
/// Structural comparison. Compare using Operators.compare.
|
|
val Structural<'T> : IComparer<'T>
|
|
|
|
/// Convert an existing IComparer object into a comparison function with a fast entry point
|
|
/// If comparer was originally built using ComparisonIdentity.FromFunction then the original function will be
|
|
/// returned
|
|
val GetFastComparisonFunction : comparer:IComparer<'T> -> OptimizedClosures.FastFunc2<'T,'T,int>
|
|
|
|
/// Convert an existing IComparer object into a comparison function with a fast entry point
|
|
val GetFastStructuralComparisonFunction : unit -> OptimizedClosures.FastFunc2<'T,'T,int>
|
|
|
|
/// Compare using the given comparer function
|
|
val FromFunction : comparer:('T -> 'T -> int) -> IComparer<'T>
|
|
|
|
/// Common notions of value identity used with hash tables.
|
|
module HashIdentity =
|
|
|
|
/// Structural hashing. Hash using Operators.(=) and Operators.hash.
|
|
|
|
// inline justification: allows specialization of structural hash functions based on type
|
|
val inline Structural<'T> : IEqualityComparer<'T>
|
|
|
|
val LimitedStructural<'T> : limit: int -> IEqualityComparer<'T>
|
|
|
|
/// Physical hashing (hash on reference identity of objects, and the contents of value types).
|
|
/// Hash using LanguagePrimitives.PhysicalEquality and LanguagePrimitives.PhysicalHash,
|
|
/// That is, for value types use GetHashCode and Object.Equals (if no other optimization available),
|
|
/// and for reference types use System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode and
|
|
/// reference equality.
|
|
//
|
|
// inline justification: allows specialization of reference hash functions based on type
|
|
val Reference<'T> : IEqualityComparer<'T>
|
|
|
|
/// Hash using the given hashing and equality functions
|
|
//
|
|
// inline justification: allows inlining of hash functions
|
|
val inline FromFunctions<'T> : hasher:('T -> int) -> equality:('T -> 'T -> bool) -> IEqualityComparer<'T>
|
|
|
|
|
|
|