# AreApproximatelyEqual

> Assert the values are approximately equal.

## Definition

* **Type:** Method
* **Namespace:** [UnityEngine.Assertions](/engine/6000.7/script-reference/unityengine/assertions.md)
* **Assembly:** UnityEngine.CoreModule

## AreApproximatelyEqual(float, float)

Assert the values are approximately equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreApproximatelyEqual(float expected, float actual)
```

### Parameters

**** (\[float]\(https\://learn.microsoft.com/dotnet/api/system.single)): The assumed [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[float]\(https\://learn.microsoft.com/dotnet/api/system.single)): The exact [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.

### Remarks

An absolute error check is used for approximate equality check (|a-b| \< tolerance). Default `tolerance` is 0.00001f.

Note: Every time you call the method with tolerance specified, a new instance of [FloatComparer](/engine/6000.7/script-reference/unityengine/assertions/comparers/floatcomparer.md) is created. For performance reasons you might want to instance your own comparer and pass it to the [Assert.AreApproximatelyEqual](/engine/6000.7/script-reference/unityengine/assertions/assert/areapproximatelyequal.md) method. If the tolerance is not specifies, a default comparer is used and the issue does not occur.

### Examples

```csharp
using UnityEngine;
using UnityEngine.Assertions;

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the position of the GameObject is always in the center of the Scene.
        // AreApproximatelyEqual should be used for comparing floating point variables.
        // Unless specified, default error tolerance will be used.
        Assert.AreApproximatelyEqual(0.0f, transform.position.x);
        Assert.AreApproximatelyEqual(0.0f, transform.position.y);
        Assert.AreApproximatelyEqual(0.0f, transform.position.z);
    }
}
```

## AreApproximatelyEqual(float, float, string)

Assert the values are approximately equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreApproximatelyEqual(float expected, float actual, string message)
```

### Parameters

**** (\[float]\(https\://learn.microsoft.com/dotnet/api/system.single)): The assumed [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[float]\(https\://learn.microsoft.com/dotnet/api/system.single)): The exact [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[string]\(https\://learn.microsoft.com/dotnet/api/system.string)): The string used to describe the [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md).

### Remarks

An absolute error check is used for approximate equality check (|a-b| \< tolerance). Default `tolerance` is 0.00001f.

Note: Every time you call the method with tolerance specified, a new instance of [FloatComparer](/engine/6000.7/script-reference/unityengine/assertions/comparers/floatcomparer.md) is created. For performance reasons you might want to instance your own comparer and pass it to the [Assert.AreApproximatelyEqual](/engine/6000.7/script-reference/unityengine/assertions/assert/areapproximatelyequal.md) method. If the tolerance is not specifies, a default comparer is used and the issue does not occur.

### Examples

```csharp
using UnityEngine;
using UnityEngine.Assertions;

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the position of the GameObject is always in the center of the Scene.
        // AreApproximatelyEqual should be used for comparing floating point variables.
        // Unless specified, default error tolerance will be used.
        Assert.AreApproximatelyEqual(0.0f, transform.position.x);
        Assert.AreApproximatelyEqual(0.0f, transform.position.y);
        Assert.AreApproximatelyEqual(0.0f, transform.position.z);
    }
}
```

## AreApproximatelyEqual(float, float, float)

Assert the values are approximately equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreApproximatelyEqual(float expected, float actual, float tolerance)
```

### Parameters

**** (\[float]\(https\://learn.microsoft.com/dotnet/api/system.single)): The assumed [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[float]\(https\://learn.microsoft.com/dotnet/api/system.single)): The exact [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[float]\(https\://learn.microsoft.com/dotnet/api/system.single)): Tolerance of approximation.

### Remarks

An absolute error check is used for approximate equality check (|a-b| \< tolerance). Default `tolerance` is 0.00001f.

Note: Every time you call the method with tolerance specified, a new instance of [FloatComparer](/engine/6000.7/script-reference/unityengine/assertions/comparers/floatcomparer.md) is created. For performance reasons you might want to instance your own comparer and pass it to the [Assert.AreApproximatelyEqual](/engine/6000.7/script-reference/unityengine/assertions/assert/areapproximatelyequal.md) method. If the tolerance is not specifies, a default comparer is used and the issue does not occur.

### Examples

```csharp
using UnityEngine;
using UnityEngine.Assertions;

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the position of the GameObject is always in the center of the Scene.
        // AreApproximatelyEqual should be used for comparing floating point variables.
        // Unless specified, default error tolerance will be used.
        Assert.AreApproximatelyEqual(0.0f, transform.position.x);
        Assert.AreApproximatelyEqual(0.0f, transform.position.y);
        Assert.AreApproximatelyEqual(0.0f, transform.position.z);
    }
}
```

## AreApproximatelyEqual(float, float, float, string)

Assert the values are approximately equal.

```csharp
[Conditional("UNITY_ASSERTIONS")]
public static void AreApproximatelyEqual(float expected, float actual, float tolerance, string message)
```

### Parameters

**** (\[float]\(https\://learn.microsoft.com/dotnet/api/system.single)): The assumed [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[float]\(https\://learn.microsoft.com/dotnet/api/system.single)): The exact [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md) value.**** (\[float]\(https\://learn.microsoft.com/dotnet/api/system.single)): Tolerance of approximation.**** (\[string]\(https\://learn.microsoft.com/dotnet/api/system.string)): The string used to describe the [Assert](/engine/6000.7/script-reference/unityengine/assertions/assert.md).

### Remarks

An absolute error check is used for approximate equality check (|a-b| \< tolerance). Default `tolerance` is 0.00001f.

Note: Every time you call the method with tolerance specified, a new instance of [FloatComparer](/engine/6000.7/script-reference/unityengine/assertions/comparers/floatcomparer.md) is created. For performance reasons you might want to instance your own comparer and pass it to the [Assert.AreApproximatelyEqual](/engine/6000.7/script-reference/unityengine/assertions/assert/areapproximatelyequal.md) method. If the tolerance is not specifies, a default comparer is used and the issue does not occur.

### Examples

```csharp
using UnityEngine;
using UnityEngine.Assertions;

public class AssertionExampleClass : MonoBehaviour
{
    void Update()
    {
        // Make sure the position of the GameObject is always in the center of the Scene.
        // AreApproximatelyEqual should be used for comparing floating point variables.
        // Unless specified, default error tolerance will be used.
        Assert.AreApproximatelyEqual(0.0f, transform.position.x);
        Assert.AreApproximatelyEqual(0.0f, transform.position.y);
        Assert.AreApproximatelyEqual(0.0f, transform.position.z);
    }
}
```