# BigInteger.Equals Method

## Definition

Returns a value that indicates whether two numeric values are equal.

## Overloads

 Equals(UInt64) Returns a value that indicates whether the current instance and an unsigned 64-bit integer have the same value. Equals(Object) Returns a value that indicates whether the current instance and a specified object have the same value. Equals(BigInteger) Returns a value that indicates whether the current instance and a specified BigInteger object have the same value. Equals(Int64) Returns a value that indicates whether the current instance and a signed 64-bit integer have the same value.

## Equals(UInt64)

Source:
BigInteger.cs
Source:
BigInteger.cs
Source:
BigInteger.cs

Important

This API is not CLS-compliant.

Returns a value that indicates whether the current instance and an unsigned 64-bit integer have the same value.

``````public:
bool Equals(System::UInt64 other);``````
``````[System.CLSCompliant(false)]
public bool Equals (ulong other);``````
``````[<System.CLSCompliant(false)>]
override this.Equals : uint64 -> bool``````
``Public Function Equals (other As ULong) As Boolean``

#### Parameters

other
UInt64

The unsigned 64-bit integer to compare.

#### Returns

`true` if the current instance and the unsigned 64-bit integer have the same value; otherwise, `false`.

Attributes

### Examples

The following example compares the approximate distance of several stars from Earth with the distance of Epsilon Indi from Earth to determine whether they are equal. The example uses each overload of the Equals method to test for equality.

``````#using <System.Numerics.dll>

using namespace System;
using namespace System::Numerics;

void main()
{
const Int64 LIGHT_YEAR = 5878625373183;

BigInteger altairDistance = 17 * LIGHT_YEAR;
BigInteger epsilonIndiDistance = 12 * LIGHT_YEAR;
BigInteger ursaeMajoris47Distance = 46 * LIGHT_YEAR;
Int64 tauCetiDistance = 12 * LIGHT_YEAR;
UInt64 procyon2Distance = 12 * LIGHT_YEAR;
Object^ wolf424ABDistance = 14 * LIGHT_YEAR;

Console::WriteLine("Approx. equal distances from Epsilon Indi to:");
Console::WriteLine("   Altair: {0}",
epsilonIndiDistance.Equals(altairDistance));
Console::WriteLine("   Ursae Majoris 47: {0}",
epsilonIndiDistance.Equals(ursaeMajoris47Distance));
Console::WriteLine("   TauCeti: {0}",
epsilonIndiDistance.Equals(tauCetiDistance));
Console::WriteLine("   Procyon 2: {0}",
epsilonIndiDistance.Equals(procyon2Distance));
Console::WriteLine("   Wolf 424 AB: {0}",
epsilonIndiDistance.Equals(wolf424ABDistance));
}
/*
The example displays output like the following:
Approx. equal distances from Epsilon Indi to:
Altair: False
Ursae Majoris 47: False
TauCeti: True
Procyon 2: True
Wolf 424 AB: False
*/
``````
``````const long LIGHT_YEAR = 5878625373183;

BigInteger altairDistance = 17 * LIGHT_YEAR;
BigInteger epsilonIndiDistance = 12 * LIGHT_YEAR;
BigInteger ursaeMajoris47Distance = 46 * LIGHT_YEAR;
long tauCetiDistance = 12 * LIGHT_YEAR;
ulong procyon2Distance = 12 * LIGHT_YEAR;
object wolf424ABDistance = 14 * LIGHT_YEAR;

Console.WriteLine("Approx. equal distances from Epsilon Indi to:");
Console.WriteLine("   Altair: {0}",
epsilonIndiDistance.Equals(altairDistance));
Console.WriteLine("   Ursae Majoris 47: {0}",
epsilonIndiDistance.Equals(ursaeMajoris47Distance));
Console.WriteLine("   TauCeti: {0}",
epsilonIndiDistance.Equals(tauCetiDistance));
Console.WriteLine("   Procyon 2: {0}",
epsilonIndiDistance.Equals(procyon2Distance));
Console.WriteLine("   Wolf 424 AB: {0}",
epsilonIndiDistance.Equals(wolf424ABDistance));
// The example displays the following output:
//    Approx. equal distances from Epsilon Indi to:
//       Altair: False
//       Ursae Majoris 47: False
//       TauCeti: True
//       Procyon 2: True
//       Wolf 424 AB: False
``````
``````let LIGHT_YEAR = 5878625373183L

let altairDistance = 17I * bigint LIGHT_YEAR
let epsilonIndiDistance = 12I * bigint LIGHT_YEAR
let ursaeMajoris47Distance = 46I * bigint LIGHT_YEAR
let tauCetiDistance = 12L * LIGHT_YEAR
let procyon2Distance = 12uL * uint64 LIGHT_YEAR
let wolf424ABDistance = 14L * LIGHT_YEAR

printfn "Approx. equal distances from Epsilon Indi to:"
printfn \$"   Altair: {epsilonIndiDistance.Equals(altairDistance)}"
printfn \$"   Ursae Majoris 47: {epsilonIndiDistance.Equals(ursaeMajoris47Distance)}"
printfn \$"   TauCeti: {epsilonIndiDistance.Equals(tauCetiDistance)}"
printfn \$"   Procyon 2: {epsilonIndiDistance.Equals(procyon2Distance)}"
printfn \$"   Wolf 424 AB: {epsilonIndiDistance.Equals(wolf424ABDistance)}"
// The example displays the following output:
//    Approx. equal distances from Epsilon Indi to:
//       Altair: False
//       Ursae Majoris 47: False
//       TauCeti: True
//       Procyon 2: True
//       Wolf 424 AB: False
``````
``````   Const LIGHT_YEAR As Long = 5878625373183

Dim altairDistance As BigInteger = 17 * LIGHT_YEAR
Dim epsilonIndiDistance As BigInteger = 12 * LIGHT_YEAR
Dim ursaeMajoris47Distance As BigInteger = 46 * LIGHT_YEAR
Dim tauCetiDistance As BigInteger = 12 * LIGHT_YEAR
Dim procyon2Distance As Long = 12 * LIGHT_YEAR
Dim wolf424ABDistance As Object = 14 * LIGHT_YEAR

Console.WriteLine("Approx. equal distances from Epsilon Indi to:")
Console.WriteLine("   Altair: {0}", _
epsilonIndiDistance.Equals(altairDistance))
Console.WriteLine("   Ursae Majoris 47: {0}", _
epsilonIndiDistance.Equals(ursaeMajoris47Distance))
Console.WriteLine("   TauCeti: {0}", _
epsilonIndiDistance.Equals(tauCetiDistance))
Console.WriteLine("   Procyon 2: {0}", _
epsilonIndiDistance.Equals(procyon2Distance))
Console.WriteLine("   Wolf 424 AB: {0}", _
epsilonIndiDistance.Equals(wolf424ABDistance))
' The example displays the following output:
'    Approx. equal distances from Epsilon Indi to:
'       Altair: False
'       Ursae Majoris 47: False
'       TauCeti: True
'       Procyon 2: True
'       Wolf 424 AB: False
``````

### Remarks

To determine the relationship between the two objects instead of just testing for equality, call the BigInteger.CompareTo(UInt64) method.

## Equals(Object)

Source:
BigInteger.cs
Source:
BigInteger.cs
Source:
BigInteger.cs

Returns a value that indicates whether the current instance and a specified object have the same value.

``````public:
override bool Equals(System::Object ^ obj);``````
``public override bool Equals (object obj);``
``public override bool Equals (object? obj);``
``override this.Equals : obj -> bool``
``Public Overrides Function Equals (obj As Object) As Boolean``

#### Parameters

obj
Object

The object to compare.

#### Returns

`true` if the `obj` argument is a BigInteger object, and its value is equal to the value of the current BigInteger instance; otherwise, `false`.

### Examples

The following example defines parallel Object and BigInteger arrays. Each element of one array has the same value as the corresponding element of the second array. As the output from the example shows, the instance in the BigInteger array is considered to be equal to the instance in the Object array only if the latter is a BigInteger and their values are equal.

``````using System;
using System.Numerics;

public class Example
{
public static void Main()
{
object[] obj = { 0, 10, 100, new BigInteger(1000), -10 };
BigInteger[] bi = { BigInteger.Zero, new BigInteger(10),
new BigInteger(100), new BigInteger(1000),
new BigInteger(-10) };
for (int ctr = 0; ctr < bi.Length; ctr++)
Console.WriteLine(bi[ctr].Equals(obj[ctr]));
}
}
// The example displays the following output:
//       False
//       False
//       False
//       True
//       False
``````
``````open System.Numerics

let obj: obj[] = [| 0; 10; 100; BigInteger 1000; -10 |]

let bi =
[| BigInteger.Zero
BigInteger 10
BigInteger 100
BigInteger 1000
BigInteger -10 |]

for ctr = 0 to bi.Length - 1 do
printfn \$"{bi.[ctr].Equals(obj.[ctr])}"
// The example displays the following output:
//       False
//       False
//       False
//       True
//       False
``````
``````Imports System.Numerics

Module Example
Public Sub Main()
Dim obj() As object = { 0, 10, 100, New BigInteger(1000), -10 }
Dim bi() As BigInteger = { BigInteger.Zero, New BigInteger(10),
New BigInteger(100), New BigInteger(1000),
New BigInteger(-10) }
For ctr As Integer = 0 To bi.Length - 1
Console.WriteLine(bi(ctr).Equals(obj(ctr)))
Next
End Sub
End Module
' The example displays the following output:
'       False
'       False
'       False
'       True
'       False
``````

### Remarks

If the `obj` argument is not a BigInteger value, the method returns `false`. The method returns `true` only if `obj` is a BigInteger instance whose value is equal to the current instance.

To determine the relationship between the two objects instead of just testing for equality, call the CompareTo(Object) method.

## Equals(BigInteger)

Source:
BigInteger.cs
Source:
BigInteger.cs
Source:
BigInteger.cs

Returns a value that indicates whether the current instance and a specified BigInteger object have the same value.

``````public:
virtual bool Equals(System::Numerics::BigInteger other);``````
``public bool Equals (System.Numerics.BigInteger other);``
``override this.Equals : System.Numerics.BigInteger -> bool``
``Public Function Equals (other As BigInteger) As Boolean``

#### Parameters

other
BigInteger

The object to compare.

#### Returns

`true` if this BigInteger object and `other` have the same value; otherwise, `false`.

### Examples

The following example compares the approximate distance of several stars from Earth with the distance of Epsilon Indi from Earth to determine whether they are equal. The example uses each overload of the Equals method to test for equality.

``````#using <System.Numerics.dll>

using namespace System;
using namespace System::Numerics;

void main()
{
const Int64 LIGHT_YEAR = 5878625373183;

BigInteger altairDistance = 17 * LIGHT_YEAR;
BigInteger epsilonIndiDistance = 12 * LIGHT_YEAR;
BigInteger ursaeMajoris47Distance = 46 * LIGHT_YEAR;
Int64 tauCetiDistance = 12 * LIGHT_YEAR;
UInt64 procyon2Distance = 12 * LIGHT_YEAR;
Object^ wolf424ABDistance = 14 * LIGHT_YEAR;

Console::WriteLine("Approx. equal distances from Epsilon Indi to:");
Console::WriteLine("   Altair: {0}",
epsilonIndiDistance.Equals(altairDistance));
Console::WriteLine("   Ursae Majoris 47: {0}",
epsilonIndiDistance.Equals(ursaeMajoris47Distance));
Console::WriteLine("   TauCeti: {0}",
epsilonIndiDistance.Equals(tauCetiDistance));
Console::WriteLine("   Procyon 2: {0}",
epsilonIndiDistance.Equals(procyon2Distance));
Console::WriteLine("   Wolf 424 AB: {0}",
epsilonIndiDistance.Equals(wolf424ABDistance));
}
/*
The example displays output like the following:
Approx. equal distances from Epsilon Indi to:
Altair: False
Ursae Majoris 47: False
TauCeti: True
Procyon 2: True
Wolf 424 AB: False
*/
``````
``````const long LIGHT_YEAR = 5878625373183;

BigInteger altairDistance = 17 * LIGHT_YEAR;
BigInteger epsilonIndiDistance = 12 * LIGHT_YEAR;
BigInteger ursaeMajoris47Distance = 46 * LIGHT_YEAR;
long tauCetiDistance = 12 * LIGHT_YEAR;
ulong procyon2Distance = 12 * LIGHT_YEAR;
object wolf424ABDistance = 14 * LIGHT_YEAR;

Console.WriteLine("Approx. equal distances from Epsilon Indi to:");
Console.WriteLine("   Altair: {0}",
epsilonIndiDistance.Equals(altairDistance));
Console.WriteLine("   Ursae Majoris 47: {0}",
epsilonIndiDistance.Equals(ursaeMajoris47Distance));
Console.WriteLine("   TauCeti: {0}",
epsilonIndiDistance.Equals(tauCetiDistance));
Console.WriteLine("   Procyon 2: {0}",
epsilonIndiDistance.Equals(procyon2Distance));
Console.WriteLine("   Wolf 424 AB: {0}",
epsilonIndiDistance.Equals(wolf424ABDistance));
// The example displays the following output:
//    Approx. equal distances from Epsilon Indi to:
//       Altair: False
//       Ursae Majoris 47: False
//       TauCeti: True
//       Procyon 2: True
//       Wolf 424 AB: False
``````
``````let LIGHT_YEAR = 5878625373183L

let altairDistance = 17I * bigint LIGHT_YEAR
let epsilonIndiDistance = 12I * bigint LIGHT_YEAR
let ursaeMajoris47Distance = 46I * bigint LIGHT_YEAR
let tauCetiDistance = 12L * LIGHT_YEAR
let procyon2Distance = 12uL * uint64 LIGHT_YEAR
let wolf424ABDistance = 14L * LIGHT_YEAR

printfn "Approx. equal distances from Epsilon Indi to:"
printfn \$"   Altair: {epsilonIndiDistance.Equals(altairDistance)}"
printfn \$"   Ursae Majoris 47: {epsilonIndiDistance.Equals(ursaeMajoris47Distance)}"
printfn \$"   TauCeti: {epsilonIndiDistance.Equals(tauCetiDistance)}"
printfn \$"   Procyon 2: {epsilonIndiDistance.Equals(procyon2Distance)}"
printfn \$"   Wolf 424 AB: {epsilonIndiDistance.Equals(wolf424ABDistance)}"
// The example displays the following output:
//    Approx. equal distances from Epsilon Indi to:
//       Altair: False
//       Ursae Majoris 47: False
//       TauCeti: True
//       Procyon 2: True
//       Wolf 424 AB: False
``````
``````   Const LIGHT_YEAR As Long = 5878625373183

Dim altairDistance As BigInteger = 17 * LIGHT_YEAR
Dim epsilonIndiDistance As BigInteger = 12 * LIGHT_YEAR
Dim ursaeMajoris47Distance As BigInteger = 46 * LIGHT_YEAR
Dim tauCetiDistance As BigInteger = 12 * LIGHT_YEAR
Dim procyon2Distance As Long = 12 * LIGHT_YEAR
Dim wolf424ABDistance As Object = 14 * LIGHT_YEAR

Console.WriteLine("Approx. equal distances from Epsilon Indi to:")
Console.WriteLine("   Altair: {0}", _
epsilonIndiDistance.Equals(altairDistance))
Console.WriteLine("   Ursae Majoris 47: {0}", _
epsilonIndiDistance.Equals(ursaeMajoris47Distance))
Console.WriteLine("   TauCeti: {0}", _
epsilonIndiDistance.Equals(tauCetiDistance))
Console.WriteLine("   Procyon 2: {0}", _
epsilonIndiDistance.Equals(procyon2Distance))
Console.WriteLine("   Wolf 424 AB: {0}", _
epsilonIndiDistance.Equals(wolf424ABDistance))
' The example displays the following output:
'    Approx. equal distances from Epsilon Indi to:
'       Altair: False
'       Ursae Majoris 47: False
'       TauCeti: True
'       Procyon 2: True
'       Wolf 424 AB: False
``````

### Remarks

This method implements the IEquatable<T> interface and performs slightly better than Equals(Object) because it does not have to convert the `other` parameter to a BigInteger object.

To determine the relationship between the two BigInteger objects instead of just testing for equality, call the BigInteger.CompareTo(BigInteger) method.

## Equals(Int64)

Source:
BigInteger.cs
Source:
BigInteger.cs
Source:
BigInteger.cs

Returns a value that indicates whether the current instance and a signed 64-bit integer have the same value.

``````public:
bool Equals(long other);``````
``public bool Equals (long other);``
``override this.Equals : int64 -> bool``
``Public Function Equals (other As Long) As Boolean``

#### Parameters

other
Int64

The signed 64-bit integer value to compare.

#### Returns

`true` if the signed 64-bit integer and the current instance have the same value; otherwise, `false`.

### Examples

The following example instantiates a BigInteger object from each integral type except UInt64. It then calls the Equals(Int64) method to compare the BigInteger value with the original integer value that was passed to the BigInteger constructor. As the output shows, the values are equal in each case.

``````#using <System.Numerics.dll>

using namespace System;
using namespace System::Numerics;

void main()
{
BigInteger bigIntValue;

Byte byteValue = 16;
bigIntValue = BigInteger(byteValue);
Console::WriteLine("{0} {1} = {2} {3} : {4}",
bigIntValue.GetType()->Name, bigIntValue,
byteValue.GetType()->Name, byteValue,
bigIntValue.Equals((Int64)byteValue));

SByte sbyteValue = -16;
bigIntValue = BigInteger(sbyteValue);
Console::WriteLine("{0} {1} = {2} {3} : {4}",
bigIntValue.GetType()->Name, bigIntValue,
sbyteValue.GetType()->Name, sbyteValue,
bigIntValue.Equals((Int64)sbyteValue));

Int16 shortValue = 1233;
bigIntValue = BigInteger(shortValue);
Console::WriteLine("{0} {1} = {2} {3} : {4}",
bigIntValue.GetType()->Name, bigIntValue,
shortValue.GetType()->Name, shortValue,
bigIntValue.Equals((Int64)shortValue));

UInt16 ushortValue = 64000;
bigIntValue = BigInteger(ushortValue);
Console::WriteLine("{0} {1} = {2} {3} : {4}",
bigIntValue.GetType()->Name, bigIntValue,
ushortValue.GetType()->Name, ushortValue,
bigIntValue.Equals((Int64)ushortValue));

int intValue = -1603854;
bigIntValue = BigInteger(intValue);
Console::WriteLine("{0} {1} = {2} {3} : {4}",
bigIntValue.GetType()->Name, bigIntValue,
intValue.GetType()->Name, intValue,
bigIntValue.Equals((Int64)intValue));

UInt32 uintValue = 1223300;
bigIntValue = BigInteger(uintValue);
Console::WriteLine("{0} {1} = {2} {3} : {4}",
bigIntValue.GetType()->Name, bigIntValue,
uintValue.GetType()->Name, uintValue,
bigIntValue.Equals((Int64)uintValue));

Int64 longValue = -123822229012;
bigIntValue = BigInteger(longValue);
Console::WriteLine("{0} {1} = {2} {3} : {4}",
bigIntValue.GetType()->Name, bigIntValue,
longValue.GetType()->Name, longValue,
bigIntValue.Equals((Int64)longValue));
}
/*
The example displays output like the following:
BigInteger 16 = Byte 16 : True
BigInteger -16 = SByte -16 : True
BigInteger 1233 = Int16 1233 : True
BigInteger 64000 = UInt16 64000 : True
BigInteger -1603854 = Int32 -1603854 : True
BigInteger 1223300 = UInt32 1223300 : True
BigInteger -123822229012 = Int64 -123822229012 : True
*/
``````
``````BigInteger bigIntValue;

byte byteValue = 16;
bigIntValue = new BigInteger(byteValue);
Console.WriteLine("{0} {1} = {2} {3} : {4}",
bigIntValue.GetType().Name, bigIntValue,
byteValue.GetType().Name, byteValue,
bigIntValue.Equals(byteValue));

sbyte sbyteValue = -16;
bigIntValue = new BigInteger(sbyteValue);
Console.WriteLine("{0} {1} = {2} {3} : {4}",
bigIntValue.GetType().Name, bigIntValue,
sbyteValue.GetType().Name, sbyteValue,
bigIntValue.Equals(sbyteValue));

short shortValue = 1233;
bigIntValue = new BigInteger(shortValue);
Console.WriteLine("{0} {1} = {2} {3} : {4}",
bigIntValue.GetType().Name, bigIntValue,
shortValue.GetType().Name, shortValue,
bigIntValue.Equals(shortValue));

ushort ushortValue = 64000;
bigIntValue = new BigInteger(ushortValue);
Console.WriteLine("{0} {1} = {2} {3} : {4}",
bigIntValue.GetType().Name, bigIntValue,
ushortValue.GetType().Name, ushortValue,
bigIntValue.Equals(ushortValue));

int intValue = -1603854;
bigIntValue = new BigInteger(intValue);
Console.WriteLine("{0} {1} = {2} {3} : {4}",
bigIntValue.GetType().Name, bigIntValue,
intValue.GetType().Name, intValue,
bigIntValue.Equals(intValue));

uint uintValue = 1223300;
bigIntValue = new BigInteger(uintValue);
Console.WriteLine("{0} {1} = {2} {3} : {4}",
bigIntValue.GetType().Name, bigIntValue,
uintValue.GetType().Name, uintValue,
bigIntValue.Equals(uintValue));

long longValue = -123822229012;
bigIntValue = new BigInteger(longValue);
Console.WriteLine("{0} {1} = {2} {3} : {4}",
bigIntValue.GetType().Name, bigIntValue,
longValue.GetType().Name, longValue,
bigIntValue.Equals(longValue));
// The example displays the following output:
//    BigInteger 16 = Byte 16 : True
//    BigInteger -16 = SByte -16 : True
//    BigInteger 1233 = Int16 1233 : True
//    BigInteger 64000 = UInt16 64000 : True
//    BigInteger -1603854 = Int32 -1603854 : True
//    BigInteger 1223300 = UInt32 1223300 : True
//    BigInteger -123822229012 = Int64 -123822229012 : True
``````
``````let byteValue = 16uy
let bigIntValue = BigInteger byteValue

printfn
\$"{bigIntValue.GetType().Name} {bigIntValue} = {byteValue.GetType().Name} {byteValue} : {bigIntValue.Equals(byteValue)}"

let sbyteValue = -16y
let bigIntValue = BigInteger sbyteValue

printfn
\$"{bigIntValue.GetType().Name} {bigIntValue} = {sbyteValue.GetType().Name} {sbyteValue} : {bigIntValue.Equals(sbyteValue)}"

let shortValue = 1233s
let bigIntValue = BigInteger shortValue

printfn
\$"{bigIntValue.GetType().Name} {bigIntValue} = {shortValue.GetType().Name} {shortValue} : {bigIntValue.Equals(shortValue)}"

let ushortValue = 64000us
let bigIntValue = BigInteger ushortValue

printfn
\$"{bigIntValue.GetType().Name} {bigIntValue} = {ushortValue.GetType().Name} {ushortValue} : {bigIntValue.Equals(ushortValue)}"

let intValue = -1603854
let bigIntValue = BigInteger intValue

printfn
\$"{bigIntValue.GetType().Name} {bigIntValue} = {intValue.GetType().Name} {intValue} : {bigIntValue.Equals(intValue)}"

let uintValue = 1223300u
let bigIntValue = BigInteger uintValue

printfn
\$"{bigIntValue.GetType().Name} {bigIntValue} = {uintValue.GetType().Name} {uintValue} : {bigIntValue.Equals(uintValue)}"

let longValue = -123822229012L
let bigIntValue = BigInteger longValue

printfn
\$"{bigIntValue.GetType().Name} {bigIntValue} = {longValue.GetType().Name} {longValue} : {bigIntValue.Equals(longValue)}"
// The example displays the following output:
//    BigInteger 16 = Byte 16 : True
//    BigInteger -16 = SByte -16 : True
//    BigInteger 1233 = Int16 1233 : True
//    BigInteger 64000 = UInt16 64000 : True
//    BigInteger -1603854 = Int32 -1603854 : True
//    BigInteger 1223300 = UInt32 1223300 : True
//    BigInteger -123822229012 = Int64 -123822229012 : True
``````
``````Dim bigIntValue As BigInteger

Dim byteValue As Byte = 16
bigIntValue = New BigInteger(byteValue)
Console.WriteLine("{0} {1} = {2} {3} : {4}",
bigIntValue.GetType().Name, bigIntValue,
byteValue.GetType().Name, byteValue,
bigIntValue.Equals(byteValue))

Dim sbyteValue As SByte = -16
bigIntValue = New BigInteger(sbyteValue)
Console.WriteLine("{0} {1} = {2} {3} : {4}",
bigIntValue.GetType().Name, bigIntValue,
sbyteValue.GetType().Name, sbyteValue,
bigIntValue.Equals(sbyteValue))

Dim shortValue As Short = 1233
bigIntValue = New BigInteger(shortValue)
Console.WriteLine("{0} {1} = {2} {3} : {4}",
bigIntValue.GetType().Name, bigIntValue,
shortValue.GetType().Name, shortValue,
bigIntValue.Equals(shortValue))

Dim ushortValue As UShort = 64000
bigIntValue = New BigInteger(ushortValue)
Console.WriteLine("{0} {1} = {2} {3} : {4}",
bigIntValue.GetType().Name, bigIntValue,
ushortValue.GetType().Name, ushortValue,
bigIntValue.Equals(ushortValue))

Dim intValue As Integer = -1603854
bigIntValue = New BigInteger(intValue)
Console.WriteLine("{0} {1} = {2} {3} : {4}",
bigIntValue.GetType().Name, bigIntValue,
intValue.GetType().Name, intValue,
bigIntValue.Equals(intValue))

Dim uintValue As UInteger = 1223300
bigIntValue = New BigInteger(uintValue)
Console.WriteLine("{0} {1} = {2} {3} : {4}",
bigIntValue.GetType().Name, bigIntValue,
uintValue.GetType().Name, uintValue,
bigIntValue.Equals(uintValue))

Dim longValue As Long = -123822229012
bigIntValue = New BigInteger(longValue)
Console.WriteLine("{0} {1} = {2} {3} : {4}",
bigIntValue.GetType().Name, bigIntValue,
longValue.GetType().Name, longValue,
bigIntValue.Equals(longValue))
' The example displays the following output:
'    BigInteger 16 = Byte 16 : True
'    BigInteger -16 = SByte -16 : True
'    BigInteger 1233 = Int16 1233 : True
'    BigInteger 64000 = UInt16 64000 : True
'    BigInteger -1603854 = Int32 -1603854 : True
'    BigInteger 1223300 = UInt32 1223300 : True
'    BigInteger -123822229012 = Int64 -123822229012 : True
``````

### Remarks

If `other` is a Byte, Int16, Int32, SByte, UInt16, or UInt32 value, it is implicitly converted to an Int64 value when the method is called.

To determine the relationship between the two objects instead of just testing for equality, call the BigInteger.CompareTo(Int64) method.