# Compute

> Compute a hash of input data string.

## Definition

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

## Compute(string)

Compute a hash of input data string.

```csharp
public static Hash128 Compute(string data)
```

### Parameters

**** (\[string]\(https\://learn.microsoft.com/dotnet/api/system.string)): Input data string. Note that Unity interprets the string as UTF-8 data, even if internally in C# strings are UTF-16.

### Returns

| Type                                                              | Description       |
| ----------------------------------------------------------------- | ----------------- |
| [Hash128](/engine/6000.0/script-reference/unityengine/hash128.md) | The 128-bit hash. |

### Examples

```csharp
using UnityEngine;

public class ExampleScript : MonoBehaviour
{
    void Start()
    {
        var hash = Hash128.Compute("The quick brown fox jumps over the lazy dog");
        // prints "c79306aa46e8122b1b340724747e361d"
        Debug.Log(hash.ToString());
    }
}
```

## Compute\<T>(NativeArray\<T>)

Compute a hash of input data.

```csharp
public static Hash128 Compute<T>(NativeArray<T> data) where T : struct
```

### Parameters

**** (\[NativeArray\<T>]\(/engine/6000.0/script-reference/unity/collections/nativearray1)): Input data array.

### Returns

| Type                                                              | Description       |
| ----------------------------------------------------------------- | ----------------- |
| [Hash128](/engine/6000.0/script-reference/unityengine/hash128.md) | The 128-bit hash. |

### Examples

```csharp
using UnityEngine;

public class ExampleScript : MonoBehaviour
{
    void Start()
    {
        var data = new byte[] { 10, 20, 30, 40, 50 };
        var hash = Hash128.Compute(data);
        // prints "6e8dd00dc1d495a01d9e6dbffcd174b2"
        Debug.Log(hash.ToString());
    }
}
```

## Compute\<T>(NativeArray\<T>, int, int)

Compute a hash of a slice of input data.

```csharp
public static Hash128 Compute<T>(NativeArray<T> data, int start, int count) where T : struct
```

### Parameters

**** (\[NativeArray\<T>]\(/engine/6000.0/script-reference/unity/collections/nativearray1)): Input data array.**** (\[int]\(https\://learn.microsoft.com/dotnet/api/system.int32)): The first element in the data to start hashing from.**** (\[int]\(https\://learn.microsoft.com/dotnet/api/system.int32)): Number of array elements to hash.

### Returns

| Type                                                              | Description       |
| ----------------------------------------------------------------- | ----------------- |
| [Hash128](/engine/6000.0/script-reference/unityengine/hash128.md) | The 128-bit hash. |

### Examples

```csharp
using UnityEngine;

public class ExampleScript : MonoBehaviour
{
    void Start()
    {
        var data = new byte[] { 0, 10, 20, 30, 40, 50, 60 };
        // will hash bytes: 10, 20, 30, 40, 50
        var hash = Hash128.Compute(data, 1, 5);
        // prints "6e8dd00dc1d495a01d9e6dbffcd174b2"
        Debug.Log(hash.ToString());
    }
}
```

## Compute\<T>(\`\<>\[])

Compute a hash of input data.

```csharp
public static Hash128 Compute<T>(T[] data) where T : struct
```

### Parameters

**** (\[\<T>\[]]\(./)): Input data array.

### Returns

| Type                                                              | Description       |
| ----------------------------------------------------------------- | ----------------- |
| [Hash128](/engine/6000.0/script-reference/unityengine/hash128.md) | The 128-bit hash. |

### Examples

```csharp
using UnityEngine;

public class ExampleScript : MonoBehaviour
{
    void Start()
    {
        var data = new byte[] { 10, 20, 30, 40, 50 };
        var hash = Hash128.Compute(data);
        // prints "6e8dd00dc1d495a01d9e6dbffcd174b2"
        Debug.Log(hash.ToString());
    }
}
```

## Compute\<T>(\`\<>\[], int, int)

Compute a hash of a slice of input data.

```csharp
public static Hash128 Compute<T>(T[] data, int start, int count) where T : struct
```

### Parameters

**** (\[\<T>\[]]\(./)): Input data array.**** (\[int]\(https\://learn.microsoft.com/dotnet/api/system.int32)): The first element in the data to start hashing from.**** (\[int]\(https\://learn.microsoft.com/dotnet/api/system.int32)): Number of array elements to hash.

### Returns

| Type                                                              | Description       |
| ----------------------------------------------------------------- | ----------------- |
| [Hash128](/engine/6000.0/script-reference/unityengine/hash128.md) | The 128-bit hash. |

### Examples

```csharp
using UnityEngine;

public class ExampleScript : MonoBehaviour
{
    void Start()
    {
        var data = new byte[] { 0, 10, 20, 30, 40, 50, 60 };
        // will hash bytes: 10, 20, 30, 40, 50
        var hash = Hash128.Compute(data, 1, 5);
        // prints "6e8dd00dc1d495a01d9e6dbffcd174b2"
        Debug.Log(hash.ToString());
    }
}
```

## Compute\<T>(List\<T>)

Compute a hash of input data.

```csharp
public static Hash128 Compute<T>(List<T> data) where T : struct
```

### Parameters

**** (\[List\<T>]\(https\://learn.microsoft.com/dotnet/api/system.collections.generic.list-1)): Input data array.

### Returns

| Type                                                              | Description       |
| ----------------------------------------------------------------- | ----------------- |
| [Hash128](/engine/6000.0/script-reference/unityengine/hash128.md) | The 128-bit hash. |

### Examples

```csharp
using UnityEngine;

public class ExampleScript : MonoBehaviour
{
    void Start()
    {
        var data = new byte[] { 10, 20, 30, 40, 50 };
        var hash = Hash128.Compute(data);
        // prints "6e8dd00dc1d495a01d9e6dbffcd174b2"
        Debug.Log(hash.ToString());
    }
}
```

## Compute\<T>(List\<T>, int, int)

Compute a hash of a slice of input data.

```csharp
public static Hash128 Compute<T>(List<T> data, int start, int count) where T : struct
```

### Parameters

**** (\[List\<T>]\(https\://learn.microsoft.com/dotnet/api/system.collections.generic.list-1)): Input data array.**** (\[int]\(https\://learn.microsoft.com/dotnet/api/system.int32)): The first element in the data to start hashing from.**** (\[int]\(https\://learn.microsoft.com/dotnet/api/system.int32)): Number of array elements to hash.

### Returns

| Type                                                              | Description       |
| ----------------------------------------------------------------- | ----------------- |
| [Hash128](/engine/6000.0/script-reference/unityengine/hash128.md) | The 128-bit hash. |

### Examples

```csharp
using UnityEngine;

public class ExampleScript : MonoBehaviour
{
    void Start()
    {
        var data = new byte[] { 0, 10, 20, 30, 40, 50, 60 };
        // will hash bytes: 10, 20, 30, 40, 50
        var hash = Hash128.Compute(data, 1, 5);
        // prints "6e8dd00dc1d495a01d9e6dbffcd174b2"
        Debug.Log(hash.ToString());
    }
}
```

## Compute\<T>(T)

Compute a hash of input data.

```csharp
public static Hash128 Compute<T>(ref T val) where T : unmanaged
```

### Parameters

**** (T): Input value.

### Returns

| Type                                                              | Description       |
| ----------------------------------------------------------------- | ----------------- |
| [Hash128](/engine/6000.0/script-reference/unityengine/hash128.md) | The 128-bit hash. |

### Remarks

The value must be an "unmanaged" C# type. Primitive types like int, float, bool, enums, pointers, or structs containing primitive types are all unmanaged types. See [Unmanaged types](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/unmanaged-types) in C# language reference.

The int and float overloads use a dedicated hashing code path that is optimized for 4-byte data sizes.

### Examples

```csharp
using UnityEngine;

public class ExampleScript : MonoBehaviour
{
    void Start()
    {
        var data = new Vector3(1.5f, 7.0f, 42.0f);
        var hash = Hash128.Compute(ref data);
        // prints "abc99ce06a8d7acca0714cd64d661808"
        Debug.Log(hash.ToString());
    }
}
```

## Compute(int)

Compute a hash of input data.

```csharp
public static Hash128 Compute(int val)
```

### Parameters

**** (\[int]\(https\://learn.microsoft.com/dotnet/api/system.int32)): Input value.

### Returns

| Type                                                              | Description       |
| ----------------------------------------------------------------- | ----------------- |
| [Hash128](/engine/6000.0/script-reference/unityengine/hash128.md) | The 128-bit hash. |

### Remarks

The value must be an "unmanaged" C# type. Primitive types like int, float, bool, enums, pointers, or structs containing primitive types are all unmanaged types. See [Unmanaged types](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/unmanaged-types) in C# language reference.

The int and float overloads use a dedicated hashing code path that is optimized for 4-byte data sizes.

### Examples

```csharp
using UnityEngine;

public class ExampleScript : MonoBehaviour
{
    void Start()
    {
        var data = new Vector3(1.5f, 7.0f, 42.0f);
        var hash = Hash128.Compute(ref data);
        // prints "abc99ce06a8d7acca0714cd64d661808"
        Debug.Log(hash.ToString());
    }
}
```

## Compute(float)

Compute a hash of input data.

```csharp
public static Hash128 Compute(float val)
```

### Parameters

**** (\[float]\(https\://learn.microsoft.com/dotnet/api/system.single)): Input value.

### Returns

| Type                                                              | Description       |
| ----------------------------------------------------------------- | ----------------- |
| [Hash128](/engine/6000.0/script-reference/unityengine/hash128.md) | The 128-bit hash. |

### Remarks

The value must be an "unmanaged" C# type. Primitive types like int, float, bool, enums, pointers, or structs containing primitive types are all unmanaged types. See [Unmanaged types](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/unmanaged-types) in C# language reference.

The int and float overloads use a dedicated hashing code path that is optimized for 4-byte data sizes.

### Examples

```csharp
using UnityEngine;

public class ExampleScript : MonoBehaviour
{
    void Start()
    {
        var data = new Vector3(1.5f, 7.0f, 42.0f);
        var hash = Hash128.Compute(ref data);
        // prints "abc99ce06a8d7acca0714cd64d661808"
        Debug.Log(hash.ToString());
    }
}
```

## Compute(void\*, ulong)

Compute a hash of input data.

```csharp
public static Hash128 Compute(void* data, ulong size)
```

### Parameters

**** (\[void\*]\(https\://learn.microsoft.com/dotnet/api/system.void)): Raw data pointer, usually used with C# stackalloc data.**** (\[ulong]\(https\://learn.microsoft.com/dotnet/api/system.uint64)): Data size in bytes.

### Returns

| Type                                                              | Description       |
| ----------------------------------------------------------------- | ----------------- |
| [Hash128](/engine/6000.0/script-reference/unityengine/hash128.md) | The 128-bit hash. |