hanzoai/jube-fork
2
0
Fork 0
mirror of https://github.com/hanzoai/jube-fork.git synced 2026-10-30 18:33:33 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
118-cache-use-reduction-features
jube-fork/Accord.Math/Matrix/Matrix.Comparisons.Generated.cs
T
richard-churchman cc0a2bee21 Extensive modifications to the serialisation of Neural Network models to support Newtonsoft Json.net rather than Binary Serializer. 
Included open-source Accord.net library code natively to the solution given the deprecated state of that project.  Accord.net will be supported inside Jube for own needs (such as upgrading to .Net 7+).

Accord.net libraries modified to compile to .Net 6.

Modified Accord.net libraries to better support Newtonsoft Json.net serialisation.

Included annotations in the Accord.net libraries to house important dependency statistics. Serialised json can be used independently of Jube to recall a Neural Network.

Removal of Binary Serializer totally as a precursor to the projects support of .Net 7+.

Extensive bug fixing in crucial functions of Neural Network training and recall.  While this part of the system remains in Alpha, it is substantially more fit for purpose.
2023-12-24 10:22:22 +01:00

54687 lines
1.1 MiB
Plaintext
Raw Permalink Blame History

// Accord Math Library
// The Accord.NET Framework
// http://accord-framework.net
//
// Copyright © César Souza, 2009-2017
// cesarsouza at gmail.com
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
//
// ======================================================================
// This code has been generated by a tool; do not edit manually. Instead,
// edit the T4 template Matrix.Comparisons.tt so this file can be regenerated.
// ======================================================================
namespace Accord.Math
{
using System;
using System.CodeDom.Compiler;
using Accord.Math;
using System.Runtime.CompilerServices;
// [GeneratedCode("Accord.NET T4 Templates", "3.6")]
public static partial class Matrix
{
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[] a, Int32[] b, Int32 atol = 0, Double rtol = 0)
{
if (a == b)
return true;
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[,] a, Int32[,] b, Int32 atol = 0, Double rtol = 0)
{
if (a == b)
return true;
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Int32* ptrA = a)
fixed (Int32* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[,] a, Int32[][] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[][] a, Int32[,] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[][] a, Int32[][] b, Int32 atol = 0, Double rtol = 0)
{
if (a == b)
return true;
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[] a, Int32 b, Int32 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[,] a, Int32 b, Int32 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Int32* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[][] a, Int32 b, Int32 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, Int32[] b, Int32 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, Int32[,] b, Int32 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, Int32[][] b, Int32 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, Int32 b, Int32 atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[] a, Int16[] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[,] a, Int16[,] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Int32* ptrA = a)
fixed (Int16* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[,] a, Int16[][] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[][] a, Int16[,] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[][] a, Int16[][] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[] a, Int16 b, Int32 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[,] a, Int16 b, Int32 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Int32* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[][] a, Int16 b, Int32 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, Int16[] b, Int32 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, Int16[,] b, Int32 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, Int16[][] b, Int32 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, Int16 b, Int32 atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[] a, Single[] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[,] a, Single[,] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Int32* ptrA = a)
fixed (Single* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[,] a, Single[][] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[][] a, Single[,] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[][] a, Single[][] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[] a, Single b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[,] a, Single b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Int32* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[][] a, Single b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, Single[] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, Single[,] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, Single[][] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, Single b, Single atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[] a, Double[] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[,] a, Double[,] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Int32* ptrA = a)
fixed (Double* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[,] a, Double[][] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[][] a, Double[,] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[][] a, Double[][] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[] a, Double b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[,] a, Double b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Int32* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[][] a, Double b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, Double[] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, Double[,] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, Double[][] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, Double b, Double atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[] a, Int64[] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[,] a, Int64[,] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Int32* ptrA = a)
fixed (Int64* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[,] a, Int64[][] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[][] a, Int64[,] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[][] a, Int64[][] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[] a, Int64 b, Int64 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[,] a, Int64 b, Int64 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Int32* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[][] a, Int64 b, Int64 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, Int64[] b, Int64 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, Int64[,] b, Int64 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, Int64[][] b, Int64 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, Int64 b, Int64 atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[] a, Decimal[] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[,] a, Decimal[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Int32* ptrA = a)
fixed (Decimal* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[,] a, Decimal[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = (decimal)a[i, j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[][] a, Decimal[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[][] a, Decimal[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[] a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[,] a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Int32* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[][] a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, Decimal[] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, Decimal[,] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, Decimal[][] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = (decimal)a;
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[] a, Byte[] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[,] a, Byte[,] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Int32* ptrA = a)
fixed (Byte* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[,] a, Byte[][] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[][] a, Byte[,] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[][] a, Byte[][] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[] a, Byte b, Int32 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[,] a, Byte b, Int32 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Int32* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[][] a, Byte b, Int32 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, Byte[] b, Int32 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, Byte[,] b, Int32 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, Byte[][] b, Int32 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, Byte b, Int32 atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[] a, sbyte[] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[,] a, sbyte[,] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Int32* ptrA = a)
fixed (sbyte* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[,] a, sbyte[][] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[][] a, sbyte[,] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[][] a, sbyte[][] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[] a, sbyte b, Int32 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[,] a, sbyte b, Int32 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Int32* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32[][] a, sbyte b, Int32 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, sbyte[] b, Int32 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, sbyte[,] b, Int32 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, sbyte[][] b, Int32 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int32 a, sbyte b, Int32 atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[] a, Int32[] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[,] a, Int32[,] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Int16* ptrA = a)
fixed (Int32* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[,] a, Int32[][] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[][] a, Int32[,] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[][] a, Int32[][] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[] a, Int32 b, Int32 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[,] a, Int32 b, Int32 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Int16* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[][] a, Int32 b, Int32 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, Int32[] b, Int32 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, Int32[,] b, Int32 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, Int32[][] b, Int32 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, Int32 b, Int32 atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[] a, Int16[] b, Int16 atol = 0, Double rtol = 0)
{
if (a == b)
return true;
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[,] a, Int16[,] b, Int16 atol = 0, Double rtol = 0)
{
if (a == b)
return true;
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Int16* ptrA = a)
fixed (Int16* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[,] a, Int16[][] b, Int16 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[][] a, Int16[,] b, Int16 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[][] a, Int16[][] b, Int16 atol = 0, Double rtol = 0)
{
if (a == b)
return true;
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[] a, Int16 b, Int16 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[,] a, Int16 b, Int16 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Int16* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[][] a, Int16 b, Int16 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, Int16[] b, Int16 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, Int16[,] b, Int16 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, Int16[][] b, Int16 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, Int16 b, Int16 atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[] a, Single[] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[,] a, Single[,] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Int16* ptrA = a)
fixed (Single* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[,] a, Single[][] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[][] a, Single[,] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[][] a, Single[][] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[] a, Single b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[,] a, Single b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Int16* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[][] a, Single b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, Single[] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, Single[,] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, Single[][] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, Single b, Single atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[] a, Double[] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[,] a, Double[,] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Int16* ptrA = a)
fixed (Double* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[,] a, Double[][] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[][] a, Double[,] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[][] a, Double[][] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[] a, Double b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[,] a, Double b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Int16* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[][] a, Double b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, Double[] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, Double[,] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, Double[][] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, Double b, Double atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[] a, Int64[] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[,] a, Int64[,] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Int16* ptrA = a)
fixed (Int64* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[,] a, Int64[][] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[][] a, Int64[,] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[][] a, Int64[][] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[] a, Int64 b, Int64 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[,] a, Int64 b, Int64 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Int16* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[][] a, Int64 b, Int64 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, Int64[] b, Int64 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, Int64[,] b, Int64 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, Int64[][] b, Int64 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, Int64 b, Int64 atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[] a, Decimal[] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[,] a, Decimal[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Int16* ptrA = a)
fixed (Decimal* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[,] a, Decimal[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = (decimal)a[i, j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[][] a, Decimal[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[][] a, Decimal[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[] a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[,] a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Int16* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[][] a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, Decimal[] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, Decimal[,] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, Decimal[][] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = (decimal)a;
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[] a, Byte[] b, Int16 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[,] a, Byte[,] b, Int16 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Int16* ptrA = a)
fixed (Byte* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[,] a, Byte[][] b, Int16 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[][] a, Byte[,] b, Int16 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[][] a, Byte[][] b, Int16 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[] a, Byte b, Int16 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[,] a, Byte b, Int16 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Int16* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[][] a, Byte b, Int16 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, Byte[] b, Int16 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, Byte[,] b, Int16 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, Byte[][] b, Int16 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, Byte b, Int16 atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[] a, sbyte[] b, Int16 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[,] a, sbyte[,] b, Int16 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Int16* ptrA = a)
fixed (sbyte* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[,] a, sbyte[][] b, Int16 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[][] a, sbyte[,] b, Int16 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[][] a, sbyte[][] b, Int16 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[] a, sbyte b, Int16 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[,] a, sbyte b, Int16 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Int16* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16[][] a, sbyte b, Int16 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, sbyte[] b, Int16 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, sbyte[,] b, Int16 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, sbyte[][] b, Int16 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int16 a, sbyte b, Int16 atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[] a, Int32[] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[,] a, Int32[,] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Single* ptrA = a)
fixed (Int32* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[,] a, Int32[][] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[][] a, Int32[,] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[][] a, Int32[][] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[] a, Int32 b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[,] a, Int32 b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Single* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[][] a, Int32 b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, Int32[] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, Int32[,] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, Int32[][] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, Int32 b, Single atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[] a, Int16[] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[,] a, Int16[,] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Single* ptrA = a)
fixed (Int16* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[,] a, Int16[][] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[][] a, Int16[,] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[][] a, Int16[][] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[] a, Int16 b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[,] a, Int16 b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Single* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[][] a, Int16 b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, Int16[] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, Int16[,] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, Int16[][] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, Int16 b, Single atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[] a, Single[] b, Single atol = 0, Double rtol = 0)
{
if (a == b)
return true;
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[,] a, Single[,] b, Single atol = 0, Double rtol = 0)
{
if (a == b)
return true;
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Single* ptrA = a)
fixed (Single* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[,] a, Single[][] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[][] a, Single[,] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[][] a, Single[][] b, Single atol = 0, Double rtol = 0)
{
if (a == b)
return true;
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[] a, Single b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[,] a, Single b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Single* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[][] a, Single b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, Single[] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, Single[,] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, Single[][] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, Single b, Single atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Single.IsNaN(A) && Single.IsNaN(B))
return true;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Single.IsNaN(A) && Single.IsNaN(B))
return true;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (Single.IsNaN(A) && Single.IsNaN(B))
return true;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[] a, Double[] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Single.IsNaN(A) && Double.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Single.IsNaN(A) && Double.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Single.IsNaN(A) && Double.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[,] a, Double[,] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Single* ptrA = a)
fixed (Double* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Single.IsNaN(A) && Double.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Single.IsNaN(A) && Double.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Single.IsNaN(A) && Double.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[,] a, Double[][] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(A) && Double.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(A) && Double.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Single.IsNaN(A) && Double.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[][] a, Double[,] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Single.IsNaN(A) && Double.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Single.IsNaN(A) && Double.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Single.IsNaN(A) && Double.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[][] a, Double[][] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(A) && Double.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(A) && Double.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Single.IsNaN(A) && Double.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[] a, Double b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A) && Double.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A) && Double.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Single.IsNaN(A) && Double.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[,] a, Double b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Single* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A) && Double.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A) && Double.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Single.IsNaN(A) && Double.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[][] a, Double b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A) && Double.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A) && Double.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Single.IsNaN(A) && Double.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, Double[] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, Double[,] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, Double[][] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, Double b, Double atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Single.IsNaN(A) && Double.IsNaN(B))
return true;
if (Single.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Single.IsNaN(A) && Double.IsNaN(B))
return true;
if (Single.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (Single.IsNaN(A) && Double.IsNaN(B))
return true;
if (Single.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[] a, Int64[] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[,] a, Int64[,] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Single* ptrA = a)
fixed (Int64* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[,] a, Int64[][] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[][] a, Int64[,] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[][] a, Int64[][] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[] a, Int64 b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[,] a, Int64 b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Single* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[][] a, Int64 b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, Int64[] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, Int64[,] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, Int64[][] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, Int64 b, Single atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[] a, Decimal[] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[,] a, Decimal[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Single* ptrA = a)
fixed (Decimal* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[,] a, Decimal[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = (decimal)a[i, j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[][] a, Decimal[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[][] a, Decimal[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[] a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[,] a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Single* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[][] a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, Decimal[] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, Decimal[,] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, Decimal[][] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = (decimal)a;
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[] a, Byte[] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[,] a, Byte[,] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Single* ptrA = a)
fixed (Byte* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[,] a, Byte[][] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[][] a, Byte[,] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[][] a, Byte[][] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[] a, Byte b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[,] a, Byte b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Single* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[][] a, Byte b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, Byte[] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, Byte[,] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, Byte[][] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, Byte b, Single atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[] a, sbyte[] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[,] a, sbyte[,] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Single* ptrA = a)
fixed (sbyte* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[,] a, sbyte[][] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[][] a, sbyte[,] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[][] a, sbyte[][] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[] a, sbyte b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[,] a, sbyte b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Single* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single[][] a, sbyte b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, sbyte[] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, sbyte[,] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, sbyte[][] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Single a, sbyte b, Single atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (Single.IsNaN(A))
return false;
if (Single.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[] a, Int32[] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[,] a, Int32[,] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Double* ptrA = a)
fixed (Int32* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[,] a, Int32[][] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[][] a, Int32[,] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[][] a, Int32[][] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[] a, Int32 b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[,] a, Int32 b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Double* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[][] a, Int32 b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, Int32[] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, Int32[,] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, Int32[][] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, Int32 b, Double atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[] a, Int16[] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[,] a, Int16[,] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Double* ptrA = a)
fixed (Int16* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[,] a, Int16[][] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[][] a, Int16[,] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[][] a, Int16[][] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[] a, Int16 b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[,] a, Int16 b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Double* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[][] a, Int16 b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, Int16[] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, Int16[,] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, Int16[][] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, Int16 b, Double atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[] a, Single[] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Double.IsNaN(A) && Single.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Double.IsNaN(A) && Single.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Double.IsNaN(A) && Single.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[,] a, Single[,] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Double* ptrA = a)
fixed (Single* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Double.IsNaN(A) && Single.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Double.IsNaN(A) && Single.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Double.IsNaN(A) && Single.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[,] a, Single[][] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(A) && Single.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(A) && Single.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Double.IsNaN(A) && Single.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[][] a, Single[,] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Double.IsNaN(A) && Single.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Double.IsNaN(A) && Single.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Double.IsNaN(A) && Single.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[][] a, Single[][] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(A) && Single.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(A) && Single.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Double.IsNaN(A) && Single.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[] a, Single b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A) && Single.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A) && Single.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Double.IsNaN(A) && Single.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[,] a, Single b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Double* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A) && Single.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A) && Single.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Double.IsNaN(A) && Single.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[][] a, Single b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A) && Single.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A) && Single.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Double.IsNaN(A) && Single.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, Single[] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, Single[,] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, Single[][] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, Single b, Double atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Double.IsNaN(A) && Single.IsNaN(B))
return true;
if (Double.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Double.IsNaN(A) && Single.IsNaN(B))
return true;
if (Double.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (Double.IsNaN(A) && Single.IsNaN(B))
return true;
if (Double.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[] a, Double[] b, Double atol = 0, Double rtol = 0)
{
if (a == b)
return true;
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[,] a, Double[,] b, Double atol = 0, Double rtol = 0)
{
if (a == b)
return true;
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Double* ptrA = a)
fixed (Double* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[,] a, Double[][] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[][] a, Double[,] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[][] a, Double[][] b, Double atol = 0, Double rtol = 0)
{
if (a == b)
return true;
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[] a, Double b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[,] a, Double b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Double* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[][] a, Double b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, Double[] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, Double[,] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, Double[][] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, Double b, Double atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Double.IsNaN(A) && Double.IsNaN(B))
return true;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Double.IsNaN(A) && Double.IsNaN(B))
return true;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (Double.IsNaN(A) && Double.IsNaN(B))
return true;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[] a, Int64[] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[,] a, Int64[,] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Double* ptrA = a)
fixed (Int64* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[,] a, Int64[][] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[][] a, Int64[,] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[][] a, Int64[][] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[] a, Int64 b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[,] a, Int64 b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Double* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[][] a, Int64 b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, Int64[] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, Int64[,] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, Int64[][] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, Int64 b, Double atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[] a, Decimal[] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[,] a, Decimal[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Double* ptrA = a)
fixed (Decimal* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[,] a, Decimal[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = (decimal)a[i, j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[][] a, Decimal[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[][] a, Decimal[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[] a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[,] a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Double* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[][] a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, Decimal[] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, Decimal[,] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, Decimal[][] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = (decimal)a;
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[] a, Byte[] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[,] a, Byte[,] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Double* ptrA = a)
fixed (Byte* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[,] a, Byte[][] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[][] a, Byte[,] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[][] a, Byte[][] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[] a, Byte b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[,] a, Byte b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Double* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[][] a, Byte b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, Byte[] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, Byte[,] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, Byte[][] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, Byte b, Double atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[] a, sbyte[] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[,] a, sbyte[,] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Double* ptrA = a)
fixed (sbyte* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[,] a, sbyte[][] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[][] a, sbyte[,] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[][] a, sbyte[][] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[] a, sbyte b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[,] a, sbyte b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Double* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double[][] a, sbyte b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, sbyte[] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, sbyte[,] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, sbyte[][] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Double a, sbyte b, Double atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (Double.IsNaN(A))
return false;
if (Double.IsInfinity(A))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[] a, Int32[] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[,] a, Int32[,] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Int64* ptrA = a)
fixed (Int32* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[,] a, Int32[][] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[][] a, Int32[,] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[][] a, Int32[][] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[] a, Int32 b, Int64 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[,] a, Int32 b, Int64 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Int64* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[][] a, Int32 b, Int64 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, Int32[] b, Int64 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, Int32[,] b, Int64 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, Int32[][] b, Int64 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, Int32 b, Int64 atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[] a, Int16[] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[,] a, Int16[,] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Int64* ptrA = a)
fixed (Int16* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[,] a, Int16[][] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[][] a, Int16[,] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[][] a, Int16[][] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[] a, Int16 b, Int64 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[,] a, Int16 b, Int64 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Int64* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[][] a, Int16 b, Int64 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, Int16[] b, Int64 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, Int16[,] b, Int64 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, Int16[][] b, Int64 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, Int16 b, Int64 atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[] a, Single[] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[,] a, Single[,] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Int64* ptrA = a)
fixed (Single* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[,] a, Single[][] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[][] a, Single[,] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[][] a, Single[][] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[] a, Single b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[,] a, Single b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Int64* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[][] a, Single b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, Single[] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, Single[,] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, Single[][] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, Single b, Single atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[] a, Double[] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[,] a, Double[,] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Int64* ptrA = a)
fixed (Double* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[,] a, Double[][] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[][] a, Double[,] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[][] a, Double[][] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[] a, Double b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[,] a, Double b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Int64* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[][] a, Double b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, Double[] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, Double[,] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, Double[][] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, Double b, Double atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[] a, Int64[] b, Int64 atol = 0, Double rtol = 0)
{
if (a == b)
return true;
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[,] a, Int64[,] b, Int64 atol = 0, Double rtol = 0)
{
if (a == b)
return true;
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Int64* ptrA = a)
fixed (Int64* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[,] a, Int64[][] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[][] a, Int64[,] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[][] a, Int64[][] b, Int64 atol = 0, Double rtol = 0)
{
if (a == b)
return true;
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[] a, Int64 b, Int64 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[,] a, Int64 b, Int64 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Int64* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[][] a, Int64 b, Int64 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, Int64[] b, Int64 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, Int64[,] b, Int64 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, Int64[][] b, Int64 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, Int64 b, Int64 atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[] a, Decimal[] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[,] a, Decimal[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Int64* ptrA = a)
fixed (Decimal* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[,] a, Decimal[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = (decimal)a[i, j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[][] a, Decimal[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[][] a, Decimal[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[] a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[,] a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Int64* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[][] a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, Decimal[] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, Decimal[,] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, Decimal[][] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = (decimal)a;
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[] a, Byte[] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[,] a, Byte[,] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Int64* ptrA = a)
fixed (Byte* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[,] a, Byte[][] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[][] a, Byte[,] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[][] a, Byte[][] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[] a, Byte b, Int64 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[,] a, Byte b, Int64 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Int64* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[][] a, Byte b, Int64 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, Byte[] b, Int64 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, Byte[,] b, Int64 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, Byte[][] b, Int64 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, Byte b, Int64 atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[] a, sbyte[] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[,] a, sbyte[,] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Int64* ptrA = a)
fixed (sbyte* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[,] a, sbyte[][] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[][] a, sbyte[,] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[][] a, sbyte[][] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[] a, sbyte b, Int64 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[,] a, sbyte b, Int64 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Int64* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64[][] a, sbyte b, Int64 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, sbyte[] b, Int64 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, sbyte[,] b, Int64 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, sbyte[][] b, Int64 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Int64 a, sbyte b, Int64 atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[] a, Int32[] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[,] a, Int32[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Decimal* ptrA = a)
fixed (Int32* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[,] a, Int32[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = (decimal)a[i, j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[][] a, Int32[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[][] a, Int32[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[] a, Int32 b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[,] a, Int32 b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Decimal* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[][] a, Int32 b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, Int32[] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, Int32[,] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, Int32[][] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, Int32 b, Decimal atol = 0, Decimal rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = (decimal)a;
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[] a, Int16[] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[,] a, Int16[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Decimal* ptrA = a)
fixed (Int16* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[,] a, Int16[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = (decimal)a[i, j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[][] a, Int16[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[][] a, Int16[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[] a, Int16 b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[,] a, Int16 b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Decimal* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[][] a, Int16 b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, Int16[] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, Int16[,] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, Int16[][] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, Int16 b, Decimal atol = 0, Decimal rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = (decimal)a;
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[] a, Single[] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[,] a, Single[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Decimal* ptrA = a)
fixed (Single* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[,] a, Single[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = (decimal)a[i, j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[][] a, Single[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[][] a, Single[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[] a, Single b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[,] a, Single b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Decimal* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[][] a, Single b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, Single[] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, Single[,] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, Single[][] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, Single b, Decimal atol = 0, Decimal rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = (decimal)a;
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[] a, Double[] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[,] a, Double[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Decimal* ptrA = a)
fixed (Double* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[,] a, Double[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = (decimal)a[i, j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[][] a, Double[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[][] a, Double[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[] a, Double b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[,] a, Double b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Decimal* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[][] a, Double b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, Double[] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, Double[,] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, Double[][] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, Double b, Decimal atol = 0, Decimal rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = (decimal)a;
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[] a, Int64[] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[,] a, Int64[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Decimal* ptrA = a)
fixed (Int64* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[,] a, Int64[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = (decimal)a[i, j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[][] a, Int64[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[][] a, Int64[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[] a, Int64 b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[,] a, Int64 b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Decimal* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[][] a, Int64 b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, Int64[] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, Int64[,] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, Int64[][] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, Int64 b, Decimal atol = 0, Decimal rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = (decimal)a;
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[] a, Decimal[] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == b)
return true;
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[,] a, Decimal[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == b)
return true;
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Decimal* ptrA = a)
fixed (Decimal* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[,] a, Decimal[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = (decimal)a[i, j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[][] a, Decimal[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[][] a, Decimal[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == b)
return true;
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[] a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[,] a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Decimal* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[][] a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, Decimal[] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, Decimal[,] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, Decimal[][] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = (decimal)a;
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[] a, Byte[] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[,] a, Byte[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Decimal* ptrA = a)
fixed (Byte* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[,] a, Byte[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = (decimal)a[i, j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[][] a, Byte[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[][] a, Byte[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[] a, Byte b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[,] a, Byte b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Decimal* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[][] a, Byte b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, Byte[] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, Byte[,] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, Byte[][] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, Byte b, Decimal atol = 0, Decimal rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = (decimal)a;
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[] a, sbyte[] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[,] a, sbyte[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Decimal* ptrA = a)
fixed (sbyte* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[,] a, sbyte[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = (decimal)a[i, j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[][] a, sbyte[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[][] a, sbyte[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[] a, sbyte b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[,] a, sbyte b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Decimal* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal[][] a, sbyte b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, sbyte[] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, sbyte[,] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, sbyte[][] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Decimal a, sbyte b, Decimal atol = 0, Decimal rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = (decimal)a;
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[] a, Int32[] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[,] a, Int32[,] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Byte* ptrA = a)
fixed (Int32* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[,] a, Int32[][] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[][] a, Int32[,] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[][] a, Int32[][] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[] a, Int32 b, Int32 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[,] a, Int32 b, Int32 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Byte* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[][] a, Int32 b, Int32 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, Int32[] b, Int32 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, Int32[,] b, Int32 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, Int32[][] b, Int32 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, Int32 b, Int32 atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[] a, Int16[] b, Int16 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[,] a, Int16[,] b, Int16 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Byte* ptrA = a)
fixed (Int16* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[,] a, Int16[][] b, Int16 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[][] a, Int16[,] b, Int16 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[][] a, Int16[][] b, Int16 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[] a, Int16 b, Int16 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[,] a, Int16 b, Int16 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Byte* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[][] a, Int16 b, Int16 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, Int16[] b, Int16 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, Int16[,] b, Int16 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, Int16[][] b, Int16 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, Int16 b, Int16 atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[] a, Single[] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[,] a, Single[,] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Byte* ptrA = a)
fixed (Single* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[,] a, Single[][] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[][] a, Single[,] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[][] a, Single[][] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[] a, Single b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[,] a, Single b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Byte* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[][] a, Single b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, Single[] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, Single[,] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, Single[][] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, Single b, Single atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[] a, Double[] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[,] a, Double[,] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Byte* ptrA = a)
fixed (Double* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[,] a, Double[][] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[][] a, Double[,] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[][] a, Double[][] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[] a, Double b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[,] a, Double b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Byte* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[][] a, Double b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, Double[] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, Double[,] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, Double[][] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, Double b, Double atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[] a, Int64[] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[,] a, Int64[,] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Byte* ptrA = a)
fixed (Int64* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[,] a, Int64[][] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[][] a, Int64[,] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[][] a, Int64[][] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[] a, Int64 b, Int64 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[,] a, Int64 b, Int64 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Byte* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[][] a, Int64 b, Int64 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, Int64[] b, Int64 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, Int64[,] b, Int64 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, Int64[][] b, Int64 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, Int64 b, Int64 atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[] a, Decimal[] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[,] a, Decimal[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Byte* ptrA = a)
fixed (Decimal* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[,] a, Decimal[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = (decimal)a[i, j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[][] a, Decimal[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[][] a, Decimal[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[] a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[,] a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Byte* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[][] a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, Decimal[] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, Decimal[,] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, Decimal[][] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = (decimal)a;
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[] a, Byte[] b, Byte atol = 0, Double rtol = 0)
{
if (a == b)
return true;
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[,] a, Byte[,] b, Byte atol = 0, Double rtol = 0)
{
if (a == b)
return true;
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Byte* ptrA = a)
fixed (Byte* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[,] a, Byte[][] b, Byte atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[][] a, Byte[,] b, Byte atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[][] a, Byte[][] b, Byte atol = 0, Double rtol = 0)
{
if (a == b)
return true;
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[] a, Byte b, Byte atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[,] a, Byte b, Byte atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Byte* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[][] a, Byte b, Byte atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, Byte[] b, Byte atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, Byte[,] b, Byte atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, Byte[][] b, Byte atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, Byte b, Byte atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[] a, sbyte[] b, Byte atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[,] a, sbyte[,] b, Byte atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (Byte* ptrA = a)
fixed (sbyte* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[,] a, sbyte[][] b, Byte atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[][] a, sbyte[,] b, Byte atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[][] a, sbyte[][] b, Byte atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[] a, sbyte b, Byte atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[,] a, sbyte b, Byte atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (Byte* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte[][] a, sbyte b, Byte atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, sbyte[] b, Byte atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, sbyte[,] b, Byte atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, sbyte[][] b, Byte atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this Byte a, sbyte b, Byte atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[] a, Int32[] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[,] a, Int32[,] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (sbyte* ptrA = a)
fixed (Int32* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[,] a, Int32[][] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[][] a, Int32[,] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[][] a, Int32[][] b, Int32 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[] a, Int32 b, Int32 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[,] a, Int32 b, Int32 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (sbyte* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[][] a, Int32 b, Int32 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, Int32[] b, Int32 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, Int32[,] b, Int32 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, Int32[][] b, Int32 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, Int32 b, Int32 atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[] a, Int16[] b, Int16 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[,] a, Int16[,] b, Int16 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (sbyte* ptrA = a)
fixed (Int16* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[,] a, Int16[][] b, Int16 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[][] a, Int16[,] b, Int16 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[][] a, Int16[][] b, Int16 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[] a, Int16 b, Int16 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[,] a, Int16 b, Int16 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (sbyte* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[][] a, Int16 b, Int16 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, Int16[] b, Int16 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, Int16[,] b, Int16 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, Int16[][] b, Int16 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, Int16 b, Int16 atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[] a, Single[] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[,] a, Single[,] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (sbyte* ptrA = a)
fixed (Single* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[,] a, Single[][] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[][] a, Single[,] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[][] a, Single[][] b, Single atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[] a, Single b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[,] a, Single b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (sbyte* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[][] a, Single b, Single atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, Single[] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, Single[,] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, Single[][] b, Single atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, Single b, Single atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (Single.IsNaN(B))
return false;
if (Single.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[] a, Double[] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[,] a, Double[,] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (sbyte* ptrA = a)
fixed (Double* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[,] a, Double[][] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[][] a, Double[,] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[][] a, Double[][] b, Double atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[] a, Double b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[,] a, Double b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (sbyte* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[][] a, Double b, Double atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, Double[] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, Double[,] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, Double[][] b, Double atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, Double b, Double atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (Double.IsNaN(B))
return false;
if (Double.IsInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[] a, Int64[] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[,] a, Int64[,] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (sbyte* ptrA = a)
fixed (Int64* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[,] a, Int64[][] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[][] a, Int64[,] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[][] a, Int64[][] b, Int64 atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[] a, Int64 b, Int64 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[,] a, Int64 b, Int64 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (sbyte* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[][] a, Int64 b, Int64 atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, Int64[] b, Int64 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, Int64[,] b, Int64 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, Int64[][] b, Int64 atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, Int64 b, Int64 atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[] a, Decimal[] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[,] a, Decimal[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (sbyte* ptrA = a)
fixed (Decimal* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[,] a, Decimal[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = (decimal)a[i, j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[][] a, Decimal[,] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[][] a, Decimal[][] b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[] a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)a[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[,] a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (sbyte* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = (decimal)ptrA[i];
var B = (decimal)b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[][] a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, Decimal[] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, Decimal[,] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, Decimal[][] b, Decimal atol = 0, Decimal rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, Decimal b, Decimal atol = 0, Decimal rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
return true;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = (decimal)a;
var B = (decimal)b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[] a, Byte[] b, Byte atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[,] a, Byte[,] b, Byte atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (sbyte* ptrA = a)
fixed (Byte* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[,] a, Byte[][] b, Byte atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[][] a, Byte[,] b, Byte atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[][] a, Byte[][] b, Byte atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[] a, Byte b, Byte atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[,] a, Byte b, Byte atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (sbyte* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[][] a, Byte b, Byte atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, Byte[] b, Byte atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, Byte[,] b, Byte atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, Byte[][] b, Byte atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, Byte b, Byte atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[] a, sbyte[] b, byte atol = 0, Double rtol = 0)
{
if (a == b)
return true;
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b[i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[,] a, sbyte[,] b, byte atol = 0, Double rtol = 0)
{
if (a == b)
return true;
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
unsafe
{
fixed (sbyte* ptrA = a)
fixed (sbyte* ptrB = b)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = ptrB[i];
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[,] a, sbyte[][] b, byte atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < b.Length; i++)
for (int j = 0; j < b[i].Length; j++)
{
var A = a[i, j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[][] a, sbyte[,] b, byte atol = 0, Double rtol = 0)
{
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i, j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[][] a, sbyte[][] b, byte atol = 0, Double rtol = 0)
{
if (a == b)
return true;
if (a == null && b == null)
return true;
if (a == null ^ b == null)
return false;
int[] la = a.GetLength(true);
int[] lb = b.GetLength(true);
if (la.Length != lb.Length)
return false;
for (int i = 0; i < la.Length; i++)
if (la[i] != lb[i])
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b[i][j];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[] a, sbyte b, byte atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = a[i];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[,] a, sbyte b, byte atol = 0, Double rtol = 0)
{
if (a == null)
return true;
unsafe
{
fixed (sbyte* ptrA = a)
{
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
var A = ptrA[i];
var B = b;
if (A != B)
return false;
}
}
}
}
return true;
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte[][] a, sbyte b, byte atol = 0, Double rtol = 0)
{
if (a == null)
return true;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, sbyte[] b, byte atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, sbyte[,] b, byte atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two matrices contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, sbyte[][] b, byte atol = 0, Double rtol = 0)
{
return IsEqual(b, a, rtol, atol);
}
/// <summary>
/// Determines whether two vectors contain the same values.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsEqual(this sbyte a, sbyte b, byte atol = 0, Double rtol = 0)
{
if (rtol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
return true;
}
else if (D == 0)
{
if (delta <= rtol)
return true;
}
if (delta <= Math.Abs(C) * rtol)
return true;
return false;
}
}
else if (atol > 0)
{
{
var A = a;
var B = b;
if (A == B)
return true;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
return true;
return false;
}
}
else
{
{
var A = a;
var B = b;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines a matrix is symmetric.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsSymmetric(this Int32[][] a, Int32 atol = 0, Double rtol = 0)
{
if (!a.IsSquare())
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = a[j][i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = a[j][i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = a[j][i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines a matrix is symmetric.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsSymmetric(this Int32[,] a, Int32 atol = 0, Double rtol = 0)
{
if (!a.IsSquare())
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Rows(); i++)
for (int j = 0; j < i; j++)
{
var A = a[i, j];
var B = a[j, i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Rows(); i++)
for (int j = 0; j < i; j++)
{
var A = a[i, j];
var B = a[j, i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Rows(); i++)
for (int j = 0; j < i; j++)
{
var A = a[i, j];
var B = a[j, i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines a matrix is symmetric.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsSymmetric(this Int16[][] a, Int16 atol = 0, Double rtol = 0)
{
if (!a.IsSquare())
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = a[j][i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = a[j][i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = a[j][i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines a matrix is symmetric.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsSymmetric(this Int16[,] a, Int16 atol = 0, Double rtol = 0)
{
if (!a.IsSquare())
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Rows(); i++)
for (int j = 0; j < i; j++)
{
var A = a[i, j];
var B = a[j, i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Rows(); i++)
for (int j = 0; j < i; j++)
{
var A = a[i, j];
var B = a[j, i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Rows(); i++)
for (int j = 0; j < i; j++)
{
var A = a[i, j];
var B = a[j, i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines a matrix is symmetric.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsSymmetric(this Single[][] a, Single atol = 0, Double rtol = 0)
{
if (!a.IsSquare())
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = a[j][i];
if (A == B)
continue;
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = a[j][i];
if (A == B)
continue;
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = a[j][i];
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines a matrix is symmetric.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsSymmetric(this Single[,] a, Single atol = 0, Double rtol = 0)
{
if (!a.IsSquare())
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Rows(); i++)
for (int j = 0; j < i; j++)
{
var A = a[i, j];
var B = a[j, i];
if (A == B)
continue;
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Rows(); i++)
for (int j = 0; j < i; j++)
{
var A = a[i, j];
var B = a[j, i];
if (A == B)
continue;
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Rows(); i++)
for (int j = 0; j < i; j++)
{
var A = a[i, j];
var B = a[j, i];
if (Single.IsNaN(A) && Single.IsNaN(B))
continue;
if (Single.IsNaN(A) ^ Single.IsNaN(B))
return false;
if (Single.IsPositiveInfinity(A) ^ Single.IsPositiveInfinity(B))
return false;
if (Single.IsNegativeInfinity(A) ^ Single.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines a matrix is symmetric.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsSymmetric(this Double[][] a, Double atol = 0, Double rtol = 0)
{
if (!a.IsSquare())
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = a[j][i];
if (A == B)
continue;
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = a[j][i];
if (A == B)
continue;
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = a[j][i];
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines a matrix is symmetric.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsSymmetric(this Double[,] a, Double atol = 0, Double rtol = 0)
{
if (!a.IsSquare())
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Rows(); i++)
for (int j = 0; j < i; j++)
{
var A = a[i, j];
var B = a[j, i];
if (A == B)
continue;
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Rows(); i++)
for (int j = 0; j < i; j++)
{
var A = a[i, j];
var B = a[j, i];
if (A == B)
continue;
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Rows(); i++)
for (int j = 0; j < i; j++)
{
var A = a[i, j];
var B = a[j, i];
if (Double.IsNaN(A) && Double.IsNaN(B))
continue;
if (Double.IsNaN(A) ^ Double.IsNaN(B))
return false;
if (Double.IsPositiveInfinity(A) ^ Double.IsPositiveInfinity(B))
return false;
if (Double.IsNegativeInfinity(A) ^ Double.IsNegativeInfinity(B))
return false;
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines a matrix is symmetric.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsSymmetric(this Int64[][] a, Int64 atol = 0, Double rtol = 0)
{
if (!a.IsSquare())
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = a[j][i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = a[j][i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = a[j][i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines a matrix is symmetric.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsSymmetric(this Int64[,] a, Int64 atol = 0, Double rtol = 0)
{
if (!a.IsSquare())
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Rows(); i++)
for (int j = 0; j < i; j++)
{
var A = a[i, j];
var B = a[j, i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Rows(); i++)
for (int j = 0; j < i; j++)
{
var A = a[i, j];
var B = a[j, i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Rows(); i++)
for (int j = 0; j < i; j++)
{
var A = a[i, j];
var B = a[j, i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines a matrix is symmetric.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsSymmetric(this Decimal[][] a, Decimal atol = 0, Decimal rtol = 0)
{
if (!a.IsSquare())
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = a[j][i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = a[j][i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = (decimal)a[i][j];
var B = (decimal)a[j][i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines a matrix is symmetric.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsSymmetric(this Decimal[,] a, Decimal atol = 0, Decimal rtol = 0)
{
if (!a.IsSquare())
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Rows(); i++)
for (int j = 0; j < i; j++)
{
var A = a[i, j];
var B = a[j, i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Rows(); i++)
for (int j = 0; j < i; j++)
{
var A = a[i, j];
var B = a[j, i];
decimal C = (decimal)A;
decimal D = (decimal)B;
if (C == D)
continue;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Rows(); i++)
for (int j = 0; j < i; j++)
{
var A = (decimal)a[i, j];
var B = (decimal)a[j, i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines a matrix is symmetric.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsSymmetric(this Byte[][] a, Byte atol = 0, Double rtol = 0)
{
if (!a.IsSquare())
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = a[j][i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = a[j][i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = a[j][i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines a matrix is symmetric.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsSymmetric(this Byte[,] a, Byte atol = 0, Double rtol = 0)
{
if (!a.IsSquare())
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Rows(); i++)
for (int j = 0; j < i; j++)
{
var A = a[i, j];
var B = a[j, i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Rows(); i++)
for (int j = 0; j < i; j++)
{
var A = a[i, j];
var B = a[j, i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Rows(); i++)
for (int j = 0; j < i; j++)
{
var A = a[i, j];
var B = a[j, i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines a matrix is symmetric.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsSymmetric(this sbyte[][] a, byte atol = 0, Double rtol = 0)
{
if (!a.IsSquare())
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = a[j][i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = a[j][i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < a[i].Length; j++)
{
var A = a[i][j];
var B = a[j][i];
if (A != B)
return false;
}
}
return true;
}
/// <summary>
/// Determines a matrix is symmetric.
/// </summary>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static bool IsSymmetric(this sbyte[,] a, byte atol = 0, Double rtol = 0)
{
if (!a.IsSquare())
return false;
if (rtol > 0)
{
for (int i = 0; i < a.Rows(); i++)
for (int j = 0; j < i; j++)
{
var A = a[i, j];
var B = a[j, i];
if (A == B)
continue;
var C = A;
var D = B;
var delta = Math.Abs(C - D);
if (C == 0)
{
if (delta <= rtol)
continue;
}
else if (D == 0)
{
if (delta <= rtol)
continue;
}
if (delta <= Math.Abs(C) * rtol)
continue;
return false;
}
}
else if (atol > 0)
{
for (int i = 0; i < a.Rows(); i++)
for (int j = 0; j < i; j++)
{
var A = a[i, j];
var B = a[j, i];
if (A == B)
continue;
var C = A;
var D = B;
if (Math.Abs(C - D) <= atol)
continue;
return false;
}
}
else
{
for (int i = 0; i < a.Rows(); i++)
for (int j = 0; j < i; j++)
{
var A = a[i, j];
var B = a[j, i];
if (A != B)
return false;
}
}
return true;
}
}
}
Reference in New Issue View Git Blame Copy Permalink