Unity Mathematics

https://docs.unity3d.com/Packages/com.unity.mathematics@1.3/
Admin
Unity Mathematics is a C# math library providing vector types and math functions with shader-like...
Tokens:936,081
Snippets:9,181
Trust Score:10
Update:2 months ago
Show doc for...
Tokens:
Raw
### bool2x2 Constructors

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.bool2x2.html

Methods to initialize a new bool2x2 matrix instance.

```APIDOC
## Constructors

- **bool2x2(bool v)**: Constructs a bool2x2 matrix from a single bool value by assigning it to every component.
- **bool2x2(bool m00, bool m01, bool m10, bool m11)**: Constructs a bool2x2 matrix from 4 bool values given in row-major order.
- **bool2x2(bool2 c0, bool2 c1)**: Constructs a bool2x2 matrix from two bool2 vectors.
```

--------------------------------

### public static double4 unlerp(double4 start, double4 end, double4 x)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.unlerp.html

Calculates the componentwise result of normalizing a floating point value x to a range [start, end]. This is the inverse of lerp and is equivalent to (x - start) / (end - start).

```APIDOC
## public static double4 unlerp(double4 start, double4 end, double4 x)

### Description
Returns the componentwise result of normalizing a floating point value x to a range [start, end]. This method is the inverse of lerp.

### Parameters
- **start** (double4) - The start point of the range.
- **end** (double4) - The end point of the range.
- **x** (double4) - The value to normalize to the range.

### Returns
- **double4** - The componentwise interpolation parameter of x with respect to the input range [start, end].
```

--------------------------------

### public float3 Normal { get; set; }

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.Geometry.Plane.Normal.html

Gets or sets the normal vector of the plane. It is assumed that the normal is unit length. If the normal is not unit length, the plane must be normalized using Normalize(Plane).

```APIDOC
## Property: Normal

### Description
Gets or sets the normal vector of the plane. The normal is expected to be of unit length.

### Declaration
`public float3 Normal { get; set; }`

### Property Value
- **Type**: float3

### Remarks
It is assumed that the normal is unit length. If you set a new plane such that Ax + By + Cz + Dw = 0 but (A, B, C) is not unit length, then you must normalize the plane by calling Normalize(Plane).
```

--------------------------------

### int2xN Constructors

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.html

Constructors for creating int2x2, int2x3, and int2x4 matrices.

```APIDOC
## int2x2(value)
## int2x3(value)
## int2x4(value)

### Description
Constructs an int matrix from a single scalar value or from component-wise conversion of other matrix types.

### Parameters
- **value** (various) - The input value or matrix to construct the int2xN matrix from.
```

--------------------------------

### public float Distance { get; set; }

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.Geometry.Plane.Distance.html

Gets or sets the distance of the plane from the origin. Note that this value may be negative. It is assumed that the plane's normal is unit length; if not, the plane must be normalized using Normalize(Plane) after setting this property.

```APIDOC
## Property: Distance

### Description
Gets or sets the distance of the plane from the origin. This value represents the 'd' component in the plane equation Ax + By + Cz + D = 0.

### Declaration
`public float Distance { get; set; }`

### Property Value
- **Type**: float

### Remarks
It is assumed that the normal is unit length. If you set a new plane such that Ax + By + Cz + D = 0 but (A, B, C) is not unit length, you must normalize the plane by calling Normalize(Plane).
```

--------------------------------

### bool3x3 Constructors

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.bool3x3.html

Methods to initialize a new bool3x3 matrix instance.

```APIDOC
## Constructors

- **bool3x3(bool v)**: Constructs a bool3x3 matrix from a single bool value by assigning it to every component.
- **bool3x3(bool m00, bool m01, bool m02, bool m10, bool m11, bool m12, bool m20, bool m21, bool m22)**: Constructs a bool3x3 matrix from 9 bool values given in row-major order.
- **bool3x3(bool3 c0, bool3 c1, bool3 c2)**: Constructs a bool3x3 matrix from three bool3 vectors.
```

--------------------------------

### MinValueAsHalf

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.half.MinValueAsHalf.html

Gets the minimum finite half value as a half.

```APIDOC
## public static half MinValueAsHalf

### Description
Returns the minimum finite half value as a half.

### Declaration
`public static half MinValueAsHalf { get; }`

### Property Value
- **Type**: half
- **Description**: The minimum finite half-precision floating-point value.
```

--------------------------------

### uint2x3 Constructors

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.html

Constructors for creating uint2x3 matrices from various input types.

```APIDOC
## uint2x3 Constructors

### Description
Creates a uint2x3 matrix from scalars or by converting existing types.

### Signatures
- uint2x3(bool)
- uint2x3(double)
- uint2x3(int)
- uint2x3(float)
- uint2x3(uint)
```

--------------------------------

### ToString Declaration

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.RigidTransform.ToString.html

Standard override to get the string representation of a RigidTransform.

```csharp
public override string ToString()
```

--------------------------------

### uint3x3(uint3, uint3, uint3)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.uint3x3.html

Constructs a uint3x3 matrix from three uint3 column vectors.

```APIDOC
## uint3x3(uint3 c0, uint3 c1, uint3 c2)

### Description
Returns a uint3x3 matrix constructed from three uint3 vectors.

### Parameters
- **c0** (uint3) - The matrix column c0 will be set to this value.
- **c1** (uint3) - The matrix column c1 will be set to this value.
- **c2** (uint3) - The matrix column c2 will be set to this value.

### Returns
- **uint3x3** - uint3x3 constructed from arguments.
```

--------------------------------

### uint4x3(uint, uint, uint, uint, uint, uint, uint, uint, uint, uint, uint, uint)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.uint4x3.html

Constructs a uint4x3 matrix from 12 individual uint values.

```APIDOC
## uint4x3(uint m00, uint m01, uint m02, uint m10, uint m11, uint m12, uint m20, uint m21, uint m22, uint m30, uint m31, uint m32)

### Description
Returns a uint4x3 matrix constructed from 12 uint values given in row-major order.

### Parameters
- **m00-m32** (uint) - The matrix at row i, column j will be set to this value.
```

--------------------------------

### unlerp(double, double, double)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.unlerp.html

Normalizes a double value to a range [start, end].

```APIDOC
## public static double unlerp(double start, double end, double x)

### Description
Returns the result of normalizing a double value x to a range [start, end].

### Parameters
- **start** (double) - The start point of the range.
- **end** (double) - The end point of the range.
- **x** (double) - The value to normalize to the range.

### Returns
- **double** - The interpolation parameter of x with respect to the input range [start, end].
```

--------------------------------

### unlerp(double3, double3, double3)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.unlerp.html

Normalizes a double3 value componentwise to a range [start, end].

```APIDOC
## public static double3 unlerp(double3 start, double3 end, double3 x)

### Description
Returns the componentwise result of normalizing a double3 value x to a range [start, end].

### Parameters
- **start** (double3) - The start point of the range.
- **end** (double3) - The end point of the range.
- **x** (double3) - The value to normalize to the range.

### Returns
- **double3** - The componentwise interpolation parameter of x with respect to the input range [start, end].
```

--------------------------------

### bool4x4 Constructors

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.bool4x4.html

Methods to initialize a new bool4x4 matrix instance.

```APIDOC
## Constructors

### bool4x4(bool)
Constructs a bool4x4 matrix from a single bool value by assigning it to every component.

### bool4x4(bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool)
Constructs a bool4x4 matrix from 16 bool values given in row-major order.

### bool4x4(bool4, bool4, bool4, bool4)
Constructs a bool4x4 matrix from four bool4 vectors.
```

--------------------------------

### uint2x2 Constructors

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.uint2x2.-ctor.html

Constructors for creating a uint2x2 matrix from various inputs.

```APIDOC
## uint2x2(uint2 c0, uint2 c1)
Constructs a uint2x2 matrix from two uint2 vectors.

## uint2x2(uint m00, uint m01, uint m10, uint m11)
Constructs a uint2x2 matrix from 4 uint values given in row-major order.

## uint2x2(uint v)
Constructs a uint2x2 matrix from a single uint value by assigning it to every component.

## uint2x2(bool v)
Constructs a uint2x2 matrix from a single bool value by converting it to uint and assigning it to every component.

## uint2x2(bool2x2 v)
Constructs a uint2x2 matrix from a bool2x2 matrix by componentwise conversion.

## uint2x2(int v)
Constructs a uint2x2 matrix from a single int value by converting it to uint and assigning it to every component.

## uint2x2(int2x2 v)
Constructs a uint2x2 matrix from a int2x2 matrix by componentwise conversion.

## uint2x2(float v)
Constructs a uint2x2 matrix from a single float value by converting it to uint and assigning it to every component.

## uint2x2(float2x2 v)
Constructs a uint2x2 matrix from a float2x2 matrix by componentwise conversion.

## uint2x2(double v)
Constructs a uint2x2 matrix from a single double value by converting it to uint and assigning it to every component.
```

--------------------------------

### unlerp(double2, double2, double2)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.unlerp.html

Normalizes a double2 value componentwise to a range [start, end].

```APIDOC
## public static double2 unlerp(double2 start, double2 end, double2 x)

### Description
Returns the componentwise result of normalizing a double2 value x to a range [start, end].

### Parameters
- **start** (double2) - The start point of the range.
- **end** (double2) - The end point of the range.
- **x** (double2) - The value to normalize to the range.

### Returns
- **double2** - The componentwise interpolation parameter of x with respect to the input range [start, end].
```

--------------------------------

### unlerp(float4, float4, float4)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.unlerp.html

Normalizes a float4 value componentwise to a range [start, end].

```APIDOC
## public static float4 unlerp(float4 start, float4 end, float4 x)

### Description
Returns the componentwise result of normalizing a float4 value x to a range [start, end].

### Parameters
- **start** (float4) - The start point of the range.
- **end** (float4) - The end point of the range.
- **x** (float4) - The value to normalize to the range.

### Returns
- **float4** - The componentwise interpolation parameter of x with respect to the input range [start, end].
```

--------------------------------

### uint3x3(uint, uint, uint, uint, uint, uint, uint, uint, uint)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.uint3x3.html

Constructs a uint3x3 matrix from 9 individual uint values.

```APIDOC
## uint3x3(uint m00, uint m01, uint m02, uint m10, uint m11, uint m12, uint m20, uint m21, uint m22)

### Description
Returns a uint3x3 matrix constructed from 9 uint values given in row-major order.

### Parameters
- **m00** (uint) - The matrix at row 0, column 0 will be set to this value.
- **m01** (uint) - The matrix at row 0, column 1 will be set to this value.
- **m02** (uint) - The matrix at row 0, column 2 will be set to this value.
- **m10** (uint) - The matrix at row 1, column 0 will be set to this value.
- **m11** (uint) - The matrix at row 1, column 1 will be set to this value.
- **m12** (uint) - The matrix at row 1, column 2 will be set to this value.
- **m20** (uint) - The matrix at row 2, column 0 will be set to this value.
- **m21** (uint) - The matrix at row 2, column 1 will be set to this value.
- **m22** (uint) - The matrix at row 2, column 2 will be set to this value.

### Returns
- **uint3x3** - uint3x3 constructed from arguments.
```

--------------------------------

### unlerp(float3, float3, float3)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.unlerp.html

Normalizes a float3 value componentwise to a range [start, end].

```APIDOC
## public static float3 unlerp(float3 start, float3 end, float3 x)

### Description
Returns the componentwise result of normalizing a float3 value x to a range [start, end].

### Parameters
- **start** (float3) - The start point of the range.
- **end** (float3) - The end point of the range.
- **x** (float3) - The value to normalize to the range.

### Returns
- **float3** - The componentwise interpolation parameter of x with respect to the input range [start, end].
```

--------------------------------

### uint3x4(uint, uint, uint, uint, uint, uint, uint, uint, uint, uint, uint, uint)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.uint3x4.html

Constructs a uint3x4 matrix from 12 individual uint values.

```APIDOC
## uint3x4(uint m00, uint m01, uint m02, uint m03, uint m10, uint m11, uint m12, uint m13, uint m20, uint m21, uint m22, uint m23)

### Description
Returns a uint3x4 matrix constructed from 12 uint values given in row-major order.

### Parameters
- **m00-m23** (uint) - The matrix at row i, column j will be set to this value.
```

--------------------------------

### uint2x3(uint2, uint2, uint2)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.uint2x3.html

Constructs a uint2x3 matrix from three uint2 column vectors.

```APIDOC
## uint2x3(uint2 c0, uint2 c1, uint2 c2)

### Description
Returns a uint2x3 matrix constructed from three uint2 vectors.

### Parameters
- **c0** (uint2) - The matrix column c0 will be set to this value.
- **c1** (uint2) - The matrix column c1 will be set to this value.
- **c2** (uint2) - The matrix column c2 will be set to this value.

### Returns
- **uint2x3** - uint2x3 constructed from arguments.
```

--------------------------------

### unlerp(float2, float2, float2)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.unlerp.html

Normalizes a float2 value componentwise to a range [start, end].

```APIDOC
## public static float2 unlerp(float2 start, float2 end, float2 x)

### Description
Returns the componentwise result of normalizing a float2 value x to a range [start, end].

### Parameters
- **start** (float2) - The start point of the range.
- **end** (float2) - The end point of the range.
- **x** (float2) - The value to normalize to the range.

### Returns
- **float2** - The componentwise interpolation parameter of x with respect to the input range [start, end].
```

--------------------------------

### unlerp(float, float, float)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.unlerp.html

Normalizes a floating point value x to a range [start, end].

```APIDOC
## public static float unlerp(float start, float end, float x)

### Description
Returns the result of normalizing a floating point value x to a range [start, end]. This is the inverse of lerp.

### Parameters
- **start** (float) - The start point of the range.
- **end** (float) - The end point of the range.
- **x** (float) - The value to normalize to the range.

### Returns
- **float** - The interpolation parameter of x with respect to the input range [start, end].
```

--------------------------------

### Construct uint4x3 from 12 uint values

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.uint4x3.html

Creates a uint4x3 matrix using 12 individual uint values provided in row-major order.

```csharp
public static uint4x3 uint4x3(uint m00, uint m01, uint m02, uint m10, uint m11, uint m12, uint m20, uint m21, uint m22, uint m30, uint m31, uint m32)
```

--------------------------------

### modf(double, out double)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.modf.html

Splits a double value into an integral part i and a fractional part that gets returned.

```APIDOC
## public static double modf(double x, out double i)

### Description
Splits a double value into an integral part i and a fractional part that gets returned. Both parts take the sign of the input.

### Parameters
- **x** (double) - Value to split into integral and fractional part.
- **i** (double) - Output value containing integral part of x.

### Returns
- **double** - The fractional part of x.
```

--------------------------------

### uint2x3(uint, uint, uint, uint, uint, uint)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.uint2x3.html

Constructs a uint2x3 matrix from 6 individual uint values.

```APIDOC
## uint2x3(uint m00, uint m01, uint m02, uint m10, uint m11, uint m12)

### Description
Returns a uint2x3 matrix constructed from 6 uint values given in row-major order.

### Parameters
- **m00** (uint) - The matrix at row 0, column 0 will be set to this value.
- **m01** (uint) - The matrix at row 0, column 1 will be set to this value.
- **m02** (uint) - The matrix at row 0, column 2 will be set to this value.
- **m10** (uint) - The matrix at row 1, column 0 will be set to this value.
- **m11** (uint) - The matrix at row 1, column 1 will be set to this value.
- **m12** (uint) - The matrix at row 1, column 2 will be set to this value.

### Returns
- **uint2x3** - uint2x3 constructed from arguments.
```

--------------------------------

### uint4x2(uint, uint, uint, uint, uint, uint, uint, uint)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.uint4x2.-ctor.html

Constructs a uint4x2 matrix from 8 uint values given in row-major order.

```APIDOC
## uint4x2(uint m00, uint m01, uint m10, uint m11, uint m20, uint m21, uint m30, uint m31)

### Description
Constructs a uint4x2 matrix from 8 uint values given in row-major order.
```

--------------------------------

### Random.CreateFromIndex(uint index)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.Random.CreateFromIndex.html

Constructs a Random instance with an index that gets hashed. The index must not be uint.MaxValue.

```APIDOC
## Random.CreateFromIndex(uint index)

### Description
Constructs a Random instance with an index that gets hashed. Use this function when you expect to create several Random instances in a loop.

### Signature
`public static Random CreateFromIndex(uint index)`

### Parameters
- **index** (uint) - Required - An index that will be hashed for Random creation. Must not be uint.MaxValue.

### Returns
- **Random** - A Random instance created from the provided index.

### Example
```csharp
for (uint i = 0; i < 4096; ++i)
{
    Random rand = Random.CreateFromIndex(i);

    // Random numbers drawn from loop iteration j will be very different
    // from every other loop iteration k.
    rand.NextUInt();
}
```
```

--------------------------------

### Compress uint4 components

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.compress.html

Packs enabled components of a uint4 vector into an output array starting at a specified index.

```csharp
public static int compress(uint* output, int index, uint4 val, bool4 mask)
```

--------------------------------

### Construct float3x3 from columns

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.float3x3.html

Initializes a matrix using three float3 vectors as columns.

```csharp
public static float3x3 float3x3(float3 c0, float3 c1, float3 c2)
```

--------------------------------

### Compress int4 components

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.compress.html

Packs enabled components of an int4 vector into an output array starting at a specified index.

```csharp
public static int compress(int* output, int index, int4 val, bool4 mask)
```

--------------------------------

### Construct uint3x2 from individual uint values

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.uint3x2.html

Creates a uint3x2 matrix using 6 uint values provided in row-major order.

```csharp
public static uint3x2 uint3x2(uint m00, uint m01, uint m10, uint m11, uint m20, uint m21)
```

--------------------------------

### uint4x3(uint4, uint4, uint4)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.uint4x3.html

Constructs a uint4x3 matrix from three uint4 column vectors.

```APIDOC
## uint4x3(uint4 c0, uint4 c1, uint4 c2)

### Description
Returns a uint4x3 matrix constructed from three uint4 vectors.

### Parameters
- **c0** (uint4) - The matrix column c0 will be set to this value.
- **c1** (uint4) - The matrix column c1 will be set to this value.
- **c2** (uint4) - The matrix column c2 will be set to this value.

### Returns
- **uint4x3** - uint4x3 constructed from arguments.
```

--------------------------------

### TORADIANS

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.TORADIANS.html

The conversion constant used to convert degrees to radians. Multiply the degree value by this constant to get radians.

```APIDOC
## public const float TORADIANS

### Description
The conversion constant used to convert degrees to radians. Multiplying by this constant is equivalent to using radians(float).

### Syntax
`public const float TORADIANS = 0.017453292f;`

### Returns
- **float** - The value of the constant used for degree to radian conversion.
```

--------------------------------

### TODEGREES_DBL

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.TODEGREES_DBL.html

The conversion constant used to convert radians to degrees. Multiply the radian value by this constant to get degrees.

```APIDOC
## public const double TODEGREES_DBL

### Description
The conversion constant used to convert radians to degrees. Multiplying by this constant is equivalent to using the degrees(double) method.

### Syntax
`public const double TODEGREES_DBL = 57.29577951308232`

### Returns
- **double** - The conversion factor for radians to degrees.
```

--------------------------------

### uint2x3(bool2x3)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.uint2x3.html

Constructs a uint2x3 matrix from a bool2x3 matrix.

```APIDOC
## uint2x3(bool2x3 v)

### Description
Return a uint2x3 matrix constructed from a bool2x3 matrix by componentwise conversion.

### Parameters
- **v** (bool2x3) - bool2x3 to convert to uint2x3

### Returns
- **uint2x3** - Converted value.
```

--------------------------------

### uint4x3(bool4x3)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.uint4x3.html

Constructs a uint4x3 matrix from a bool4x3 matrix.

```APIDOC
## uint4x3(bool4x3 v)

### Description
Return a uint4x3 matrix constructed from a bool4x3 matrix by componentwise conversion.
```

--------------------------------

### public float3 Extents { get; }

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.Geometry.MinMaxAABB.Extents.html

Computes the extents of the AABB, representing the componentwise distance between the min and max vectors.

```APIDOC
## Property: Extents

### Description
Computes the extents of the AABB. The extents are defined as the componentwise distance between the minimum and maximum points of the bounding box.

### Declaration
`public float3 Extents { get; }`

### Property Value
- **Type**: float3
- **Description**: The componentwise distance between min and max.
```

--------------------------------

### math.lerp(float, float, float)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.lerp.html

Returns the result of linearly interpolating from start to end using the interpolation parameter t.

```APIDOC
## public static float lerp(float start, float end, float t)

### Description
Returns the result of linearly interpolating from start to end using the interpolation parameter t.

### Parameters
- **start** (float) - The start point, corresponding to the interpolation parameter value of 0.
- **end** (float) - The end point, corresponding to the interpolation parameter value of 1.
- **t** (float) - The interpolation parameter. May be a value outside the interval [0, 1].

### Returns
- **float** - The interpolation from start to end.

### Remarks
If the interpolation parameter is not in the range [0, 1], then this function extrapolates.
```

--------------------------------

### uint3x2(bool)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.uint3x2.html

Constructs a uint3x2 matrix by converting a bool to uint and assigning it to every component.

```APIDOC
## uint3x2(bool v)

### Description
Returns a uint3x2 matrix constructed from a single bool value by converting it to uint and assigning it to every component.

### Parameters
- **v** (bool) - bool to convert to uint3x2

### Returns
- **uint3x2** - Converted value.
```

--------------------------------

### uint2x2(bool)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.uint2x2.html

Constructs a uint2x2 matrix by converting a bool to uint and assigning it to every component.

```APIDOC
## uint2x2(bool v)

### Description
Returns a uint2x2 matrix constructed from a single bool value by converting it to uint and assigning it to every component.

### Parameters
- **v** (bool) - bool to convert to uint2x2

### Returns
- **uint2x2** - Converted value.
```

--------------------------------

### modf(double3, out double3)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.modf.html

Performs a componentwise split of a double3 vector into an integral part i and a fractional part that gets returned.

```APIDOC
## public static double3 modf(double3 x, out double3 i)

### Description
Performs a componentwise split of a double3 vector into an integral part i and a fractional part that gets returned. Both parts take the sign of the corresponding input component.

### Parameters
- **x** (double3) - Value to split into integral and fractional part.
- **i** (double3) - Output value containing integral part of x.

### Returns
- **double3** - The componentwise fractional part of x.
```

--------------------------------

### Construct int3x4 from columns

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.int3x4.-ctor.html

Initializes a new int3x4 matrix using four int3 column vectors.

```csharp
public int3x4(int3 c0, int3 c1, int3 c2, int3 c3)
```

--------------------------------

### modf(double2, out double2)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.modf.html

Performs a componentwise split of a double2 vector into an integral part i and a fractional part that gets returned.

```APIDOC
## public static double2 modf(double2 x, out double2 i)

### Description
Performs a componentwise split of a double2 vector into an integral part i and a fractional part that gets returned. Both parts take the sign of the corresponding input component.

### Parameters
- **x** (double2) - Value to split into integral and fractional part.
- **i** (double2) - Output value containing integral part of x.

### Returns
- **double2** - The componentwise fractional part of x.
```

--------------------------------

### modf(float4, out float4)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.modf.html

Performs a componentwise split of a float4 vector into an integral part i and a fractional part that gets returned.

```APIDOC
## public static float4 modf(float4 x, out float4 i)

### Description
Performs a componentwise split of a float4 vector into an integral part i and a fractional part that gets returned. Both parts take the sign of the corresponding input component.

### Parameters
- **x** (float4) - Value to split into integral and fractional part.
- **i** (float4) - Output value containing integral part of x.

### Returns
- **float4** - The componentwise fractional part of x.
```

--------------------------------

### uint4x2(bool4x2)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.uint4x2.html

Constructs a uint4x2 matrix from a bool4x2 matrix.

```APIDOC
## uint4x2(bool4x2 v)

### Description
Return a uint4x2 matrix constructed from a bool4x2 matrix by componentwise conversion.

### Parameters
- **v** (bool4x2) - bool4x2 to convert to uint4x2

### Returns
- **uint4x2** - Converted value.
```

--------------------------------

### Vector and Matrix Constructors

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.html

Methods for constructing bool vectors and matrices from various inputs.

```APIDOC
## bool4 Constructors
- bool4(bool, bool2, bool)
- bool4(bool, bool3)
- bool4(bool2, bool, bool)
- bool4(bool2, bool2)
- bool4(bool3, bool)
- bool4(bool4)

## bool4x2 Constructors
- bool4x2(bool)
- bool4x2(bool, bool, bool, bool, bool, bool, bool, bool)
- bool4x2(bool4, bool4)

## bool4x3 Constructors
- bool4x3(bool)
- bool4x3(bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool)
- bool4x3(bool4, bool4, bool4)

## bool4x4 Constructors
- bool4x4(bool)
- bool4x4(bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool)
- bool4x4(bool4, bool4, bool4, bool4)
```

--------------------------------

### modf(float3, out float3)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.modf.html

Performs a componentwise split of a float3 vector into an integral part i and a fractional part that gets returned.

```APIDOC
## public static float3 modf(float3 x, out float3 i)

### Description
Performs a componentwise split of a float3 vector into an integral part i and a fractional part that gets returned. Both parts take the sign of the corresponding input component.

### Parameters
- **x** (float3) - Value to split into integral and fractional part.
- **i** (float3) - Output value containing integral part of x.

### Returns
- **float3** - The componentwise fractional part of x.
```

--------------------------------

### uint3x2(uint, uint, uint, uint, uint, uint)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.uint3x2.html

Constructs a uint3x2 matrix from 6 individual uint values in row-major order.

```APIDOC
## uint3x2(uint m00, uint m01, uint m10, uint m11, uint m20, uint m21)

### Description
Returns a uint3x2 matrix constructed from 6 uint values given in row-major order.

### Parameters
- **m00** (uint) - The matrix at row 0, column 0 will be set to this value.
- **m01** (uint) - The matrix at row 0, column 1 will be set to this value.
- **m10** (uint) - The matrix at row 1, column 0 will be set to this value.
- **m11** (uint) - The matrix at row 1, column 1 will be set to this value.
- **m20** (uint) - The matrix at row 2, column 0 will be set to this value.
- **m21** (uint) - The matrix at row 2, column 1 will be set to this value.

### Returns
- **uint3x2** - uint3x2 constructed from arguments.
```

--------------------------------

### modf(float2, out float2)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.modf.html

Performs a componentwise split of a float2 vector into an integral part i and a fractional part that gets returned.

```APIDOC
## public static float2 modf(float2 x, out float2 i)

### Description
Performs a componentwise split of a float2 vector into an integral part i and a fractional part that gets returned. Both parts take the sign of the corresponding input component.

### Parameters
- **x** (float2) - Value to split into integral and fractional part.
- **i** (float2) - Output value containing integral part of x.

### Returns
- **float2** - The componentwise fractional part of x.
```

--------------------------------

### uint4x2(uint, uint, uint, uint, uint, uint, uint, uint)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.uint4x2.html

Constructs a uint4x2 matrix from 8 individual uint values.

```APIDOC
## uint4x2(uint m00, uint m01, uint m10, uint m11, uint m20, uint m21, uint m30, uint m31)

### Description
Returns a uint4x2 matrix constructed from 8 uint values given in row-major order.

### Parameters
- **m00** (uint) - The matrix at row 0, column 0.
- **m01** (uint) - The matrix at row 0, column 1.
- **m10** (uint) - The matrix at row 1, column 0.
- **m11** (uint) - The matrix at row 1, column 1.
- **m20** (uint) - The matrix at row 2, column 0.
- **m21** (uint) - The matrix at row 2, column 1.
- **m30** (uint) - The matrix at row 3, column 0.
- **m31** (uint) - The matrix at row 3, column 1.

### Returns
- **uint4x2** - uint4x2 constructed from arguments.
```

--------------------------------

### Plane.Flipped

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.Geometry.Plane.Flipped.html

Gets a new Plane instance that is the result of flipping the current plane, causing the normal to point in the opposite direction.

```APIDOC
## public Plane Flipped { get; }

### Description
Flips the plane so the normal points in the opposite direction.

### Property Value
- **Type**: Plane
- **Description**: A new Plane instance with the normal vector inverted.
```

--------------------------------

### compress(uint*, int, uint4, bool4)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.compress.html

Packs enabled components of a uint4 vector into an output array starting at a specified index.

```APIDOC
## compress(uint* output, int index, uint4 val, bool4 mask)

### Description
Packs components with an enabled mask to the left. This function is also known as left packing and is used to filter out components that are not enabled, leaving an output buffer tightly packed with only the enabled components.

### Parameters
- **output** (uint*) - Pointer to packed output array where enabled components should be stored.
- **index** (int) - Index into output array where the first enabled component should be stored.
- **val** (uint4) - The value to compress.
- **mask** (bool4) - Mask indicating which components are enabled.

### Returns
- **int** - Index to the element after the last one stored.
```

--------------------------------

### uint2x2(uint, uint, uint, uint)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.uint2x2.html

Constructs a uint2x2 matrix from four individual uint values in row-major order.

```APIDOC
## uint2x2(uint m00, uint m01, uint m10, uint m11)

### Description
Returns a uint2x2 matrix constructed from 4 uint values given in row-major order.

### Parameters
- **m00** (uint) - The matrix at row 0, column 0 will be set to this value.
- **m01** (uint) - The matrix at row 0, column 1 will be set to this value.
- **m10** (uint) - The matrix at row 1, column 0 will be set to this value.
- **m11** (uint) - The matrix at row 1, column 1 will be set to this value.

### Returns
- **uint2x2** - uint2x2 constructed from arguments.
```

--------------------------------

### compress(int*, int, int4, bool4)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.compress.html

Packs enabled components of an int4 vector into an output array starting at a specified index.

```APIDOC
## compress(int* output, int index, int4 val, bool4 mask)

### Description
Packs components with an enabled mask to the left. This function is also known as left packing and is used to filter out components that are not enabled, leaving an output buffer tightly packed with only the enabled components.

### Parameters
- **output** (int*) - Pointer to packed output array where enabled components should be stored.
- **index** (int) - Index into output array where the first enabled component should be stored.
- **val** (int4) - The value to compress.
- **mask** (bool4) - Mask indicating which components are enabled.

### Returns
- **int** - Index to the element after the last one stored.
```

--------------------------------

### Construct uint4 from uint, uint2, and uint

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.uint4.html

Creates a uint4 vector using a uint, a uint2 vector, and a final uint.

```csharp
public static uint4 uint4(uint x, uint2 yz, uint w)
```

--------------------------------

### Access half3 elements by index

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.half3.Item.html

Use the indexer to get or set the half value at a specific index within the half3 vector.

```csharp
public half this[int index] { get; set; }
```

--------------------------------

### Construct uint2x2 from a single scalar

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.uint2x2.html

Initializes all components of a uint2x2 matrix with a single scalar value.

```csharp
public static uint2x2 uint2x2(uint v)
```

```csharp
public static uint2x2 uint2x2(bool v)
```

```csharp
public static uint2x2 uint2x2(int v)
```

```csharp
public static uint2x2 uint2x2(float v)
```

```csharp
public static uint2x2 uint2x2(double v)
```

--------------------------------

### public bool IsValid { get; }

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.Geometry.MinMaxAABB.IsValid.html

Checks if the AABB is valid. An AABB is considered valid if Min is component-wise less than or equal to Max.

```APIDOC
## Property: IsValid

### Description
Checks if the AABB is valid. An AABB is considered valid if Min is component-wise less than or equal to Max.

### Declaration
`public bool IsValid { get; }`

### Property Value
- **bool** - True if Min is component-wise less than or equal to Max.
```

--------------------------------

### int4x3 Constructors

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.int4x3.-ctor.html

Various ways to instantiate an int4x3 matrix, including column-based, row-major, and type-conversion constructors.

```APIDOC
## int4x3(int4, int4, int4)
Constructs a int4x3 matrix from three int4 vectors.

## int4x3(int, int, int, int, int, int, int, int, int, int, int, int)
Constructs a int4x3 matrix from 12 int values given in row-major order.

## int4x3(int)
Constructs a int4x3 matrix from a single int value by assigning it to every component.

## int4x3(bool)
Constructs a int4x3 matrix from a single bool value by converting it to int and assigning it to every component.

## int4x3(bool4x3)
Constructs a int4x3 matrix from a bool4x3 matrix by componentwise conversion.

## int4x3(uint)
Constructs a int4x3 matrix from a single uint value by converting it to int and assigning it to every component.

## int4x3(uint4x3)
Constructs a int4x3 matrix from a uint4x3 matrix by componentwise conversion.

## int4x3(float)
Constructs a int4x3 matrix from a single float value by converting it to int and assigning it to every component.

## int4x3(float4x3)
Constructs a int4x3 matrix from a float4x3 matrix by componentwise conversion.

## int4x3(double)
Constructs a int4x3 matrix from a single double value by converting it to int and assigning it to every component.
```

--------------------------------

### modf(float, out float)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.modf.html

Splits a float value into an integral part i and a fractional part that gets returned. Both parts take the sign of the input.

```APIDOC
## public static float modf(float x, out float i)

### Description
Splits a float value into an integral part i and a fractional part that gets returned. Both parts take the sign of the input.

### Parameters
- **x** (float) - Value to split into integral and fractional part.
- **i** (float) - Output value containing integral part of x.

### Returns
- **float** - The fractional part of x.
```

--------------------------------

### uint3x4(uint3, uint3, uint3, uint3)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.uint3x4.html

Constructs a uint3x4 matrix from four uint3 column vectors.

```APIDOC
## uint3x4(uint3 c0, uint3 c1, uint3 c2, uint3 c3)

### Description
Returns a uint3x4 matrix constructed from four uint3 vectors.

### Parameters
- **c0** (uint3) - The matrix column c0 will be set to this value.
- **c1** (uint3) - The matrix column c1 will be set to this value.
- **c2** (uint3) - The matrix column c2 will be set to this value.
- **c3** (uint3) - The matrix column c3 will be set to this value.

### Returns
- **uint3x4** - uint3x4 constructed from arguments.
```

--------------------------------

### public float3 HalfExtents { get; }

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.Geometry.MinMaxAABB.HalfExtents.html

Computes the half extents of the AABB. Subtracting HalfExtents from Center gives Min and adding HalfExtents to Center gives Max.

```APIDOC
## Property: HalfExtents

### Description
Computes the half extents of the AABB. This value is half of the componentwise distance between the minimum and maximum points of the bounding box.

### Declaration
`public float3 HalfExtents { get; }`

### Property Value
- **Type**: float3

### Remarks
Subtracting HalfExtents from the Center property yields the Min point, while adding HalfExtents to the Center property yields the Max point.
```

--------------------------------

### Construct uint3x2 from a single scalar

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.uint3x2.html

Initializes all components of a uint3x2 matrix with a single scalar value.

```csharp
public static uint3x2 uint3x2(uint v)
```

```csharp
public static uint3x2 uint3x2(bool v)
```

```csharp
public static uint3x2 uint3x2(int v)
```

```csharp
public static uint3x2 uint3x2(float v)
```

```csharp
public static uint3x2 uint3x2(double v)
```

--------------------------------

### bool4x2 Constructors

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.bool4x2.html

Constructors for initializing a bool4x2 matrix.

```APIDOC
## Constructors

- **bool4x2(bool v)**: Constructs a bool4x2 matrix from a single bool value assigned to every component.
- **bool4x2(bool c00, bool c01, bool c02, bool c03, bool c10, bool c11, bool c12, bool c13)**: Constructs a bool4x2 matrix from 8 bool values in row-major order.
- **bool4x2(bool4 c0, bool4 c1)**: Constructs a bool4x2 matrix from two bool4 vectors.
```

--------------------------------

### modf(double4, out double4)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.modf.html

Performs a componentwise split of a double4 vector into an integral part i and a fractional part that gets returned. Both parts take the sign of the corresponding input component.

```APIDOC
## public static double4 modf(double4 x, out double4 i)

### Description
Performs a componentwise split of a double4 vector into an integral part i and a fractional part that gets returned. Both parts take the sign of the corresponding input component.

### Parameters
- **x** (double4) - Value to split into integral and fractional part.
- **i** (out double4) - Output value containing integral part of x.

### Returns
- **double4** - The componentwise fractional part of x.
```

--------------------------------

### uint4x4(uint, uint, ..., uint)

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.uint4x4.html

Constructs a uint4x4 matrix from 16 individual uint values.

```APIDOC
## uint4x4(uint m00, uint m01, uint m02, uint m03, uint m10, uint m11, uint m12, uint m13, uint m20, uint m21, uint m22, uint m23, uint m30, uint m31, uint m32, uint m33)

### Description
Returns a uint4x4 matrix constructed from 16 uint values given in row-major order.

### Returns
- **uint4x4** - uint4x4 constructed from arguments.
```

--------------------------------

### public const double TORADIANS_DBL

Source: https://docs.unity3d.com/Packages/com.unity.mathematics%401.3/api/Unity.Mathematics.math.TORADIANS_DBL.html

The conversion constant used to convert degrees to radians. Multiply the degree value by this constant to get radians. Multiplying by this constant is equivalent to using radians(double).

```APIDOC
## Field TORADIANS_DBL

### Description
The conversion constant used to convert degrees to radians. Multiply the degree value by this constant to get radians.

### Syntax
`public const double TORADIANS_DBL = 0.017453292519943295`

### Returns
- **double** - The conversion constant value.
```
Tokens:
Raw