Compare.SequenceAlmostEqualAbsolute Method

Definition

Namespace: Numerics.NET
Assembly: Numerics.NET (in Numerics.NET.dll) Version: 9.0.6

Overload List

SequenceAlmostEqualAbsolute<T>(T[], T, Boolean, Boolean)	Returns whether the values in the specified array are all close to the reference value within the default absolute tolerance.
SequenceAlmostEqualAbsolute<T>(T[], T[], Boolean, Boolean)	Returns whether the specified values in the arrays are close to each other within the default absolute tolerance.
SequenceAlmostEqualAbsolute<T>(IEnumerable<T>, T, Boolean, Boolean)	Returns whether the values in the specified sequence are all close to the reference value within the default absolute tolerance.
SequenceAlmostEqualAbsolute<T>(IEnumerable<T>, IEnumerable<T>, Boolean, Boolean)	Returns whether the specified values in the sequences are close to each other within the default absolute tolerance.
SequenceAlmostEqualAbsolute<T>(ReadOnlySpan<T>, T, Boolean, Boolean)	Returns whether the values in the specified span are all close to the reference value within the default absolute tolerance.
SequenceAlmostEqualAbsolute<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, Boolean, Boolean)	Returns whether the specified values in the spans are close to each other within the default absolute tolerance.
SequenceAlmostEqualAbsolute<T>(T[], T, T, Boolean, Boolean)	Returns whether the values in the specified array are all close to the reference value within the given absolute tolerance.
SequenceAlmostEqualAbsolute<T>(T[], T[], T, Boolean, Boolean)	Returns whether the specified values in the arrays are close to each other within the given absolute tolerance.
SequenceAlmostEqualAbsolute<T>(IEnumerable<T>, T, T, Boolean, Boolean)	Returns whether the values in the specified sequence are all close to the reference value within the given absolute tolerance.
SequenceAlmostEqualAbsolute<T>(IEnumerable<T>, IEnumerable<T>, T, Boolean, Boolean)	Returns whether the specified values in the sequences are close to each other within the given absolute tolerance.
SequenceAlmostEqualAbsolute<T>(ReadOnlySpan<T>, T, T, Boolean, Boolean)	Returns whether the values in the specified span are all close to the reference value within the given absolute tolerance.
SequenceAlmostEqualAbsolute<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, T, Boolean, Boolean)	Returns whether the specified values in the spans are close to each other within the given absolute tolerance.

SequenceAlmostEqualAbsolute<T>(T[], T, Boolean, Boolean)

Returns whether the values in the specified array are all close to the reference value within the default absolute tolerance.

public static bool SequenceAlmostEqualAbsolute<T>(
	this T[] values,
	T referenceValue,
	bool equalNaN = false,
	bool equalInfinity = true
)
where T : Object, IComparable<T>

Visual Basic

<ExtensionAttribute>
Public Shared Function SequenceAlmostEqualAbsolute(Of T As {Object, IComparable(Of T)}) ( 
	values As T(),
	referenceValue As T,
	Optional equalNaN As Boolean = false,
	Optional equalInfinity As Boolean = true
) As Boolean

C++/CLI

public:
[ExtensionAttribute]
generic<typename T>
where T : Object, IComparable<T>
static bool SequenceAlmostEqualAbsolute(
	array<T>^ values, 
	T referenceValue, 
	bool equalNaN = false, 
	bool equalInfinity = true
)

[<ExtensionAttribute>]
static member SequenceAlmostEqualAbsolute : 
        values : 'T[] * 
        referenceValue : 'T * 
        ?equalNaN : bool * 
        ?equalInfinity : bool 
(* Defaults:
        let _equalNaN = defaultArg equalNaN false
        let _equalInfinity = defaultArg equalInfinity true
*)
-> bool  when 'T : Object and IComparable<'T>

Parameters

values T[]: The array of values to compare.
referenceValue T: The reference value to compare against.
equalNaN Boolean (Optional): Optional. Specifies whether NaN values are considered equal. The default is false.
equalInfinity Boolean (Optional): Optional. Specifies whether infinite values with the same sign are considered equal. The default is true.

Type Parameters

T: The type of the values to compare.

Return Value

Boolean
true if all values are close; otherwise, false.

Usage Note

In Visual Basic and C#, you can call this method as an instance method on any object of type T[]. When you use instance method syntax to call this method, omit the first parameter. For more information, see Extension Methods (Visual Basic) or Extension Methods (C# Programming Guide).

Remarks

Absolute comparisons are always symmetric.

SequenceAlmostEqualAbsolute<T>(T[], T[], Boolean, Boolean)

Returns whether the specified values in the arrays are close to each other within the default absolute tolerance.

public static bool SequenceAlmostEqualAbsolute<T>(
	this T[] values,
	T[] referenceValues,
	bool equalNaN = false,
	bool equalInfinity = true
)
where T : Object, IComparable<T>

Visual Basic

<ExtensionAttribute>
Public Shared Function SequenceAlmostEqualAbsolute(Of T As {Object, IComparable(Of T)}) ( 
	values As T(),
	referenceValues As T(),
	Optional equalNaN As Boolean = false,
	Optional equalInfinity As Boolean = true
) As Boolean

C++/CLI

public:
[ExtensionAttribute]
generic<typename T>
where T : Object, IComparable<T>
static bool SequenceAlmostEqualAbsolute(
	array<T>^ values, 
	array<T>^ referenceValues, 
	bool equalNaN = false, 
	bool equalInfinity = true
)

[<ExtensionAttribute>]
static member SequenceAlmostEqualAbsolute : 
        values : 'T[] * 
        referenceValues : 'T[] * 
        ?equalNaN : bool * 
        ?equalInfinity : bool 
(* Defaults:
        let _equalNaN = defaultArg equalNaN false
        let _equalInfinity = defaultArg equalInfinity true
*)
-> bool  when 'T : Object and IComparable<'T>

Parameters

values T[]: The array of values to compare.
referenceValues T[]: The array of reference values to compare against.
equalNaN Boolean (Optional): Optional. Specifies whether NaN values are considered equal. The default is false.
equalInfinity Boolean (Optional): Optional. Specifies whether infinite values with the same sign are considered equal. The default is true.

Type Parameters

T: The type of the values to compare.

Return Value

Boolean
true if all values are close; otherwise, false.

Usage Note

Remarks

Absolute comparisons are always symmetric.

SequenceAlmostEqualAbsolute<T>(IEnumerable<T>, T, Boolean, Boolean)

Returns whether the values in the specified sequence are all close to the reference value within the default absolute tolerance.

public static bool SequenceAlmostEqualAbsolute<T>(
	this IEnumerable<T> values,
	T referenceValue,
	bool equalNaN = false,
	bool equalInfinity = true
)
where T : Object, IComparable<T>

Visual Basic

<ExtensionAttribute>
Public Shared Function SequenceAlmostEqualAbsolute(Of T As {Object, IComparable(Of T)}) ( 
	values As IEnumerable(Of T),
	referenceValue As T,
	Optional equalNaN As Boolean = false,
	Optional equalInfinity As Boolean = true
) As Boolean

C++/CLI

public:
[ExtensionAttribute]
generic<typename T>
where T : Object, IComparable<T>
static bool SequenceAlmostEqualAbsolute(
	IEnumerable<T>^ values, 
	T referenceValue, 
	bool equalNaN = false, 
	bool equalInfinity = true
)

[<ExtensionAttribute>]
static member SequenceAlmostEqualAbsolute : 
        values : IEnumerable<'T> * 
        referenceValue : 'T * 
        ?equalNaN : bool * 
        ?equalInfinity : bool 
(* Defaults:
        let _equalNaN = defaultArg equalNaN false
        let _equalInfinity = defaultArg equalInfinity true
*)
-> bool  when 'T : Object and IComparable<'T>

Parameters

values IEnumerable<T>: The sequence of values to compare.
referenceValue T: The reference value to compare against.
equalNaN Boolean (Optional): Optional. Specifies whether NaN values are considered equal. The default is false.
equalInfinity Boolean (Optional): Optional. Specifies whether infinite values with the same sign are considered equal. The default is true.

Type Parameters

T: The type of the values to compare.

Return Value

Boolean
true if all values are close; otherwise, false.

Usage Note

In Visual Basic and C#, you can call this method as an instance method on any object of type IEnumerable<T>. When you use instance method syntax to call this method, omit the first parameter. For more information, see Extension Methods (Visual Basic) or Extension Methods (C# Programming Guide).

Remarks

Absolute comparisons are always symmetric.

SequenceAlmostEqualAbsolute<T>(IEnumerable<T>, IEnumerable<T>, Boolean, Boolean)

Returns whether the specified values in the sequences are close to each other within the default absolute tolerance.

public static bool SequenceAlmostEqualAbsolute<T>(
	this IEnumerable<T> values,
	IEnumerable<T> referenceValues,
	bool equalNaN = false,
	bool equalInfinity = true
)
where T : Object, IComparable<T>

Visual Basic

<ExtensionAttribute>
Public Shared Function SequenceAlmostEqualAbsolute(Of T As {Object, IComparable(Of T)}) ( 
	values As IEnumerable(Of T),
	referenceValues As IEnumerable(Of T),
	Optional equalNaN As Boolean = false,
	Optional equalInfinity As Boolean = true
) As Boolean

C++/CLI

public:
[ExtensionAttribute]
generic<typename T>
where T : Object, IComparable<T>
static bool SequenceAlmostEqualAbsolute(
	IEnumerable<T>^ values, 
	IEnumerable<T>^ referenceValues, 
	bool equalNaN = false, 
	bool equalInfinity = true
)

[<ExtensionAttribute>]
static member SequenceAlmostEqualAbsolute : 
        values : IEnumerable<'T> * 
        referenceValues : IEnumerable<'T> * 
        ?equalNaN : bool * 
        ?equalInfinity : bool 
(* Defaults:
        let _equalNaN = defaultArg equalNaN false
        let _equalInfinity = defaultArg equalInfinity true
*)
-> bool  when 'T : Object and IComparable<'T>

Parameters

values IEnumerable<T>: The sequence of values to compare.
referenceValues IEnumerable<T>: The sequence of reference values to compare against.
equalNaN Boolean (Optional): Optional. Specifies whether NaN values are considered equal. The default is false.
equalInfinity Boolean (Optional): Optional. Specifies whether infinite values with the same sign are considered equal. The default is true.

Type Parameters

T: The type of the values to compare.

Return Value

Boolean
true if all values are close; otherwise, false.

Usage Note

Remarks

Absolute comparisons are always symmetric.

SequenceAlmostEqualAbsolute<T>(ReadOnlySpan<T>, T, Boolean, Boolean)

Returns whether the values in the specified span are all close to the reference value within the default absolute tolerance.

public static bool SequenceAlmostEqualAbsolute<T>(
	this ReadOnlySpan<T> values,
	T referenceValue,
	bool equalNaN = false,
	bool equalInfinity = true
)
where T : Object, IComparable<T>

Visual Basic

<ExtensionAttribute>
Public Shared Function SequenceAlmostEqualAbsolute(Of T As {Object, IComparable(Of T)}) ( 
	values As ReadOnlySpan(Of T),
	referenceValue As T,
	Optional equalNaN As Boolean = false,
	Optional equalInfinity As Boolean = true
) As Boolean

C++/CLI

public:
[ExtensionAttribute]
generic<typename T>
where T : Object, IComparable<T>
static bool SequenceAlmostEqualAbsolute(
	ReadOnlySpan<T> values, 
	T referenceValue, 
	bool equalNaN = false, 
	bool equalInfinity = true
)

[<ExtensionAttribute>]
static member SequenceAlmostEqualAbsolute : 
        values : ReadOnlySpan<'T> * 
        referenceValue : 'T * 
        ?equalNaN : bool * 
        ?equalInfinity : bool 
(* Defaults:
        let _equalNaN = defaultArg equalNaN false
        let _equalInfinity = defaultArg equalInfinity true
*)
-> bool  when 'T : Object and IComparable<'T>

Parameters

values ReadOnlySpan<T>: The span of values to compare.
referenceValue T: The reference value to compare against.
equalNaN Boolean (Optional): Optional. Specifies whether NaN values are considered equal. The default is false.
equalInfinity Boolean (Optional): Optional. Specifies whether infinite values with the same sign are considered equal. The default is true.

Type Parameters

T: The type of the values to compare.

Return Value

Boolean
true if all values are close; otherwise, false.

Usage Note

In Visual Basic and C#, you can call this method as an instance method on any object of type ReadOnlySpan<T>. When you use instance method syntax to call this method, omit the first parameter. For more information, see Extension Methods (Visual Basic) or Extension Methods (C# Programming Guide).

Remarks

Absolute comparisons are always symmetric.

SequenceAlmostEqualAbsolute<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, Boolean, Boolean)

Returns whether the specified values in the spans are close to each other within the default absolute tolerance.

public static bool SequenceAlmostEqualAbsolute<T>(
	this ReadOnlySpan<T> values,
	ReadOnlySpan<T> referenceValues,
	bool equalNaN = false,
	bool equalInfinity = true
)
where T : Object, IComparable<T>

Visual Basic

<ExtensionAttribute>
Public Shared Function SequenceAlmostEqualAbsolute(Of T As {Object, IComparable(Of T)}) ( 
	values As ReadOnlySpan(Of T),
	referenceValues As ReadOnlySpan(Of T),
	Optional equalNaN As Boolean = false,
	Optional equalInfinity As Boolean = true
) As Boolean

C++/CLI

public:
[ExtensionAttribute]
generic<typename T>
where T : Object, IComparable<T>
static bool SequenceAlmostEqualAbsolute(
	ReadOnlySpan<T> values, 
	ReadOnlySpan<T> referenceValues, 
	bool equalNaN = false, 
	bool equalInfinity = true
)

[<ExtensionAttribute>]
static member SequenceAlmostEqualAbsolute : 
        values : ReadOnlySpan<'T> * 
        referenceValues : ReadOnlySpan<'T> * 
        ?equalNaN : bool * 
        ?equalInfinity : bool 
(* Defaults:
        let _equalNaN = defaultArg equalNaN false
        let _equalInfinity = defaultArg equalInfinity true
*)
-> bool  when 'T : Object and IComparable<'T>

Parameters

values ReadOnlySpan<T>: The span of values to compare.
referenceValues ReadOnlySpan<T>: The span of reference values to compare against.
equalNaN Boolean (Optional): Optional. Specifies whether NaN values are considered equal. The default is false.
equalInfinity Boolean (Optional): Optional. Specifies whether infinite values with the same sign are considered equal. The default is true.

Type Parameters

T: The type of the values to compare.

Return Value

Boolean
true if all values are close; otherwise, false.

Usage Note

Remarks

Absolute comparisons are always symmetric.

SequenceAlmostEqualAbsolute<T>(T[], T, T, Boolean, Boolean)

Returns whether the values in the specified array are all close to the reference value within the given absolute tolerance.

public static bool SequenceAlmostEqualAbsolute<T>(
	this T[] values,
	T referenceValue,
	T absoluteTolerance,
	bool equalNaN = false,
	bool equalInfinity = true
)
where T : Object, IComparable<T>

Visual Basic

<ExtensionAttribute>
Public Shared Function SequenceAlmostEqualAbsolute(Of T As {Object, IComparable(Of T)}) ( 
	values As T(),
	referenceValue As T,
	absoluteTolerance As T,
	Optional equalNaN As Boolean = false,
	Optional equalInfinity As Boolean = true
) As Boolean

C++/CLI

public:
[ExtensionAttribute]
generic<typename T>
where T : Object, IComparable<T>
static bool SequenceAlmostEqualAbsolute(
	array<T>^ values, 
	T referenceValue, 
	T absoluteTolerance, 
	bool equalNaN = false, 
	bool equalInfinity = true
)

[<ExtensionAttribute>]
static member SequenceAlmostEqualAbsolute : 
        values : 'T[] * 
        referenceValue : 'T * 
        absoluteTolerance : 'T * 
        ?equalNaN : bool * 
        ?equalInfinity : bool 
(* Defaults:
        let _equalNaN = defaultArg equalNaN false
        let _equalInfinity = defaultArg equalInfinity true
*)
-> bool  when 'T : Object and IComparable<'T>

Parameters

values T[]: The array of values to compare.
referenceValue T: The reference value to compare against.
absoluteTolerance T: Optional. The absolute tolerance.
equalNaN Boolean (Optional): Optional. Specifies whether NaN values are considered equal. The default is false.
equalInfinity Boolean (Optional): Optional. Specifies whether infinite values with the same sign are considered equal. The default is true.

Type Parameters

T: The type of the values to compare.

Return Value

Boolean
true if all values are close; otherwise, false.

Usage Note

Remarks

Absolute comparisons are always symmetric.

SequenceAlmostEqualAbsolute<T>(T[], T[], T, Boolean, Boolean)

Returns whether the specified values in the arrays are close to each other within the given absolute tolerance.

public static bool SequenceAlmostEqualAbsolute<T>(
	this T[] values,
	T[] referenceValues,
	T absoluteTolerance,
	bool equalNaN = false,
	bool equalInfinity = true
)
where T : Object, IComparable<T>

Visual Basic

<ExtensionAttribute>
Public Shared Function SequenceAlmostEqualAbsolute(Of T As {Object, IComparable(Of T)}) ( 
	values As T(),
	referenceValues As T(),
	absoluteTolerance As T,
	Optional equalNaN As Boolean = false,
	Optional equalInfinity As Boolean = true
) As Boolean

C++/CLI

public:
[ExtensionAttribute]
generic<typename T>
where T : Object, IComparable<T>
static bool SequenceAlmostEqualAbsolute(
	array<T>^ values, 
	array<T>^ referenceValues, 
	T absoluteTolerance, 
	bool equalNaN = false, 
	bool equalInfinity = true
)

[<ExtensionAttribute>]
static member SequenceAlmostEqualAbsolute : 
        values : 'T[] * 
        referenceValues : 'T[] * 
        absoluteTolerance : 'T * 
        ?equalNaN : bool * 
        ?equalInfinity : bool 
(* Defaults:
        let _equalNaN = defaultArg equalNaN false
        let _equalInfinity = defaultArg equalInfinity true
*)
-> bool  when 'T : Object and IComparable<'T>

Parameters

values T[]: The array of values to compare.
referenceValues T[]: The array of reference values to compare against.
absoluteTolerance T: Optional. The absolute tolerance.
equalNaN Boolean (Optional): Optional. Specifies whether NaN values are considered equal. The default is false.
equalInfinity Boolean (Optional): Optional. Specifies whether infinite values with the same sign are considered equal. The default is true.

Type Parameters

T: The type of the values to compare.

Return Value

Boolean
true if all values are close; otherwise, false.

Usage Note

Remarks

Absolute comparisons are always symmetric.

SequenceAlmostEqualAbsolute<T>(IEnumerable<T>, T, T, Boolean, Boolean)

Returns whether the values in the specified sequence are all close to the reference value within the given absolute tolerance.

public static bool SequenceAlmostEqualAbsolute<T>(
	this IEnumerable<T> values,
	T referenceValue,
	T absoluteTolerance,
	bool equalNaN = false,
	bool equalInfinity = true
)
where T : Object, IComparable<T>

Visual Basic

<ExtensionAttribute>
Public Shared Function SequenceAlmostEqualAbsolute(Of T As {Object, IComparable(Of T)}) ( 
	values As IEnumerable(Of T),
	referenceValue As T,
	absoluteTolerance As T,
	Optional equalNaN As Boolean = false,
	Optional equalInfinity As Boolean = true
) As Boolean

C++/CLI

public:
[ExtensionAttribute]
generic<typename T>
where T : Object, IComparable<T>
static bool SequenceAlmostEqualAbsolute(
	IEnumerable<T>^ values, 
	T referenceValue, 
	T absoluteTolerance, 
	bool equalNaN = false, 
	bool equalInfinity = true
)

[<ExtensionAttribute>]
static member SequenceAlmostEqualAbsolute : 
        values : IEnumerable<'T> * 
        referenceValue : 'T * 
        absoluteTolerance : 'T * 
        ?equalNaN : bool * 
        ?equalInfinity : bool 
(* Defaults:
        let _equalNaN = defaultArg equalNaN false
        let _equalInfinity = defaultArg equalInfinity true
*)
-> bool  when 'T : Object and IComparable<'T>

Parameters

values IEnumerable<T>: The sequence of values to compare.
referenceValue T: The reference value to compare against.
absoluteTolerance T: Optional. The absolute tolerance.
equalNaN Boolean (Optional): Optional. Specifies whether NaN values are considered equal. The default is false.
equalInfinity Boolean (Optional): Optional. Specifies whether infinite values with the same sign are considered equal. The default is true.

Type Parameters

T: The type of the values to compare.

Return Value

Boolean
true if all values are close; otherwise, false.

Usage Note

Remarks

Absolute comparisons are always symmetric.

SequenceAlmostEqualAbsolute<T>(IEnumerable<T>, IEnumerable<T>, T, Boolean, Boolean)

Returns whether the specified values in the sequences are close to each other within the given absolute tolerance.

public static bool SequenceAlmostEqualAbsolute<T>(
	this IEnumerable<T> values,
	IEnumerable<T> referenceValues,
	T absoluteTolerance,
	bool equalNaN = false,
	bool equalInfinity = true
)
where T : Object, IComparable<T>

Visual Basic

<ExtensionAttribute>
Public Shared Function SequenceAlmostEqualAbsolute(Of T As {Object, IComparable(Of T)}) ( 
	values As IEnumerable(Of T),
	referenceValues As IEnumerable(Of T),
	absoluteTolerance As T,
	Optional equalNaN As Boolean = false,
	Optional equalInfinity As Boolean = true
) As Boolean

C++/CLI

public:
[ExtensionAttribute]
generic<typename T>
where T : Object, IComparable<T>
static bool SequenceAlmostEqualAbsolute(
	IEnumerable<T>^ values, 
	IEnumerable<T>^ referenceValues, 
	T absoluteTolerance, 
	bool equalNaN = false, 
	bool equalInfinity = true
)

[<ExtensionAttribute>]
static member SequenceAlmostEqualAbsolute : 
        values : IEnumerable<'T> * 
        referenceValues : IEnumerable<'T> * 
        absoluteTolerance : 'T * 
        ?equalNaN : bool * 
        ?equalInfinity : bool 
(* Defaults:
        let _equalNaN = defaultArg equalNaN false
        let _equalInfinity = defaultArg equalInfinity true
*)
-> bool  when 'T : Object and IComparable<'T>

Parameters

values IEnumerable<T>: The sequence of values to compare.
referenceValues IEnumerable<T>: The sequence of reference values to compare against.
absoluteTolerance T: Optional. The absolute tolerance.
equalNaN Boolean (Optional): Optional. Specifies whether NaN values are considered equal. The default is false.
equalInfinity Boolean (Optional): Optional. Specifies whether infinite values with the same sign are considered equal. The default is true.

Type Parameters

T: The type of the values to compare.

Return Value

Boolean
true if all values are close; otherwise, false.

Usage Note

Remarks

Absolute comparisons are always symmetric.

SequenceAlmostEqualAbsolute<T>(ReadOnlySpan<T>, T, T, Boolean, Boolean)

Returns whether the values in the specified span are all close to the reference value within the given absolute tolerance.

public static bool SequenceAlmostEqualAbsolute<T>(
	this ReadOnlySpan<T> values,
	T referenceValue,
	T absoluteTolerance,
	bool equalNaN = false,
	bool equalInfinity = true
)
where T : Object, IComparable<T>

Visual Basic

<ExtensionAttribute>
Public Shared Function SequenceAlmostEqualAbsolute(Of T As {Object, IComparable(Of T)}) ( 
	values As ReadOnlySpan(Of T),
	referenceValue As T,
	absoluteTolerance As T,
	Optional equalNaN As Boolean = false,
	Optional equalInfinity As Boolean = true
) As Boolean

C++/CLI

public:
[ExtensionAttribute]
generic<typename T>
where T : Object, IComparable<T>
static bool SequenceAlmostEqualAbsolute(
	ReadOnlySpan<T> values, 
	T referenceValue, 
	T absoluteTolerance, 
	bool equalNaN = false, 
	bool equalInfinity = true
)

[<ExtensionAttribute>]
static member SequenceAlmostEqualAbsolute : 
        values : ReadOnlySpan<'T> * 
        referenceValue : 'T * 
        absoluteTolerance : 'T * 
        ?equalNaN : bool * 
        ?equalInfinity : bool 
(* Defaults:
        let _equalNaN = defaultArg equalNaN false
        let _equalInfinity = defaultArg equalInfinity true
*)
-> bool  when 'T : Object and IComparable<'T>

Parameters

values ReadOnlySpan<T>: The span of values to compare.
referenceValue T: The reference value to compare against.
absoluteTolerance T: Optional. The absolute tolerance.
equalNaN Boolean (Optional): Optional. Specifies whether NaN values are considered equal. The default is false.
equalInfinity Boolean (Optional): Optional. Specifies whether infinite values with the same sign are considered equal. The default is true.

Type Parameters

T: The type of the values to compare.

Return Value

Boolean
true if all values are close; otherwise, false.

Usage Note

Remarks

Absolute comparisons are always symmetric.

SequenceAlmostEqualAbsolute<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, T, Boolean, Boolean)

Returns whether the specified values in the spans are close to each other within the given absolute tolerance.

public static bool SequenceAlmostEqualAbsolute<T>(
	this ReadOnlySpan<T> values,
	ReadOnlySpan<T> referenceValues,
	T absoluteTolerance,
	bool equalNaN = false,
	bool equalInfinity = true
)
where T : Object, IComparable<T>

Visual Basic

<ExtensionAttribute>
Public Shared Function SequenceAlmostEqualAbsolute(Of T As {Object, IComparable(Of T)}) ( 
	values As ReadOnlySpan(Of T),
	referenceValues As ReadOnlySpan(Of T),
	absoluteTolerance As T,
	Optional equalNaN As Boolean = false,
	Optional equalInfinity As Boolean = true
) As Boolean

C++/CLI

public:
[ExtensionAttribute]
generic<typename T>
where T : Object, IComparable<T>
static bool SequenceAlmostEqualAbsolute(
	ReadOnlySpan<T> values, 
	ReadOnlySpan<T> referenceValues, 
	T absoluteTolerance, 
	bool equalNaN = false, 
	bool equalInfinity = true
)

[<ExtensionAttribute>]
static member SequenceAlmostEqualAbsolute : 
        values : ReadOnlySpan<'T> * 
        referenceValues : ReadOnlySpan<'T> * 
        absoluteTolerance : 'T * 
        ?equalNaN : bool * 
        ?equalInfinity : bool 
(* Defaults:
        let _equalNaN = defaultArg equalNaN false
        let _equalInfinity = defaultArg equalInfinity true
*)
-> bool  when 'T : Object and IComparable<'T>

Parameters

values ReadOnlySpan<T>: The span of values to compare.
referenceValues ReadOnlySpan<T>: The span of reference values to compare against.
absoluteTolerance T: Optional. The absolute tolerance.
equalNaN Boolean (Optional): Optional. Specifies whether NaN values are considered equal. The default is false.
equalInfinity Boolean (Optional): Optional. Specifies whether infinite values with the same sign are considered equal. The default is true.

Type Parameters

T: The type of the values to compare.

Return Value

Boolean
true if all values are close; otherwise, false.

Usage Note

Remarks

Absolute comparisons are always symmetric.

Compare.SequenceAlmostEqualAbsolute Method

Definition

Overload List

SequenceAlmostEqualAbsolute<T>(T[], T, Boolean, Boolean)

Parameters

Type Parameters

Return Value

Usage Note

Remarks

SequenceAlmostEqualAbsolute<T>(T[], T[], Boolean, Boolean)

Parameters

Type Parameters

Return Value

Usage Note

Remarks

SequenceAlmostEqualAbsolute<T>(IEnumerable<T>, T, Boolean, Boolean)

Parameters

Type Parameters

Return Value

Usage Note

Remarks

SequenceAlmostEqualAbsolute<T>(IEnumerable<T>, IEnumerable<T>, Boolean, Boolean)

Parameters

Type Parameters

Return Value

Usage Note

Remarks

SequenceAlmostEqualAbsolute<T>(ReadOnlySpan<T>, T, Boolean, Boolean)

Parameters

Type Parameters

Return Value

Usage Note

Remarks

SequenceAlmostEqualAbsolute<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, Boolean, Boolean)

Parameters

Type Parameters

Return Value

Usage Note

Remarks

SequenceAlmostEqualAbsolute<T>(T[], T, T, Boolean, Boolean)

Parameters

Type Parameters

Return Value

Usage Note

Remarks

SequenceAlmostEqualAbsolute<T>(T[], T[], T, Boolean, Boolean)

Parameters

Type Parameters

Return Value

Usage Note

Remarks

SequenceAlmostEqualAbsolute<T>(IEnumerable<T>, T, T, Boolean, Boolean)

Parameters

Type Parameters

Return Value

Usage Note

Remarks

SequenceAlmostEqualAbsolute<T>(IEnumerable<T>, IEnumerable<T>, T, Boolean, Boolean)

Parameters

Type Parameters

Return Value

Usage Note

Remarks

SequenceAlmostEqualAbsolute<T>(ReadOnlySpan<T>, T, T, Boolean, Boolean)

Parameters

Type Parameters

Return Value

Usage Note

Remarks

SequenceAlmostEqualAbsolute<T>(ReadOnlySpan<T>, ReadOnlySpan<T>, T, Boolean, Boolean)

Parameters

Type Parameters

Return Value

Usage Note

Remarks

See Also

Reference