# mul

> Returns the result of transforming the AffineTransform b by the AffineTransform a.

## Definition

* **Type:** Method
* **Namespace:** [Unity.Mathematics](/engine/7000.0/script-reference/unity/mathematics.md)
* **Assembly:** UnityEngine.MathematicsModule

## mul(AffineTransform, AffineTransform)

Returns the result of transforming the AffineTransform b by the AffineTransform a.

```csharp
public static AffineTransform mul(AffineTransform a, AffineTransform b)
```

### Parameters

**** (\[AffineTransform]\(/engine/7000.0/script-reference/unity/mathematics/affinetransform)): The AffineTransform on the left.**** (\[AffineTransform]\(/engine/7000.0/script-reference/unity/mathematics/affinetransform)): The AffineTransform on the right.

### Returns

| Type                                                                                    | Description                              |
| --------------------------------------------------------------------------------------- | ---------------------------------------- |
| [AffineTransform](/engine/7000.0/script-reference/unity/mathematics/affinetransform.md) | The AffineTransform of a transforming b. |

## mul(float3x3, AffineTransform)

Returns the result of transforming the AffineTransform b by a float3x3 matrix a.

```csharp
public static AffineTransform mul(float3x3 a, AffineTransform b)
```

### Parameters

**** (\[float3x3]\(/engine/7000.0/script-reference/unity/mathematics/float3x3)): The float3x3 matrix on the left.**** (\[AffineTransform]\(/engine/7000.0/script-reference/unity/mathematics/affinetransform)): The AffineTransform on the right.

### Returns

| Type                                                                                    | Description                              |
| --------------------------------------------------------------------------------------- | ---------------------------------------- |
| [AffineTransform](/engine/7000.0/script-reference/unity/mathematics/affinetransform.md) | The AffineTransform of a transforming b. |

## mul(AffineTransform, float3x3)

Returns the result of transforming the float3x3 b by an AffineTransform a.

```csharp
public static AffineTransform mul(AffineTransform a, float3x3 b)
```

### Parameters

**** (\[AffineTransform]\(/engine/7000.0/script-reference/unity/mathematics/affinetransform)): The AffineTransform on the left.**** (\[float3x3]\(/engine/7000.0/script-reference/unity/mathematics/float3x3)): The float3x3 matrix on the right.

### Returns

| Type                                                                                    | Description                              |
| --------------------------------------------------------------------------------------- | ---------------------------------------- |
| [AffineTransform](/engine/7000.0/script-reference/unity/mathematics/affinetransform.md) | The AffineTransform of a transforming b. |

## mul(AffineTransform, float4)

Returns the result of transforming a float4 homogeneous coordinate by an AffineTransform.

```csharp
public static float4 mul(AffineTransform a, float4 pos)
```

### Parameters

**** (\[AffineTransform]\(/engine/7000.0/script-reference/unity/mathematics/affinetransform)): The AffineTransform.**** (\[float4]\(/engine/7000.0/script-reference/unity/mathematics/float4)): The position to be transformed.

### Returns

| Type                                                                  | Description               |
| --------------------------------------------------------------------- | ------------------------- |
| [float4](/engine/7000.0/script-reference/unity/mathematics/float4.md) | The transformed position. |

## mul(float, float)

Returns the float value result of a matrix multiplication between a float value and a float value.

```csharp
public static float mul(float a, float b)
```

### Parameters

**** (\[float]\(https\://learn.microsoft.com/dotnet/api/system.single)): Left hand side argument of the matrix multiply.**** (\[float]\(https\://learn.microsoft.com/dotnet/api/system.single)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                          | Description                         |
| ------------------------------------------------------------- | ----------------------------------- |
| [float](https://learn.microsoft.com/dotnet/api/system.single) | The computed matrix multiplication. |

## mul(float2, float2)

Returns the float value result of a matrix multiplication between a float2 row vector and a float2 column vector.

```csharp
public static float mul(float2 a, float2 b)
```

### Parameters

**** (\[float2]\(/engine/7000.0/script-reference/unity/mathematics/float2)): Left hand side argument of the matrix multiply.**** (\[float2]\(/engine/7000.0/script-reference/unity/mathematics/float2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                          | Description                         |
| ------------------------------------------------------------- | ----------------------------------- |
| [float](https://learn.microsoft.com/dotnet/api/system.single) | The computed matrix multiplication. |

## mul(float2, float2x2)

Returns the float2 row vector result of a matrix multiplication between a float2 row vector and a float2x2 matrix.

```csharp
public static float2 mul(float2 a, float2x2 b)
```

### Parameters

**** (\[float2]\(/engine/7000.0/script-reference/unity/mathematics/float2)): Left hand side argument of the matrix multiply.**** (\[float2x2]\(/engine/7000.0/script-reference/unity/mathematics/float2x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [float2](/engine/7000.0/script-reference/unity/mathematics/float2.md) | The computed matrix multiplication. |

## mul(float2, float2x3)

Returns the float3 row vector result of a matrix multiplication between a float2 row vector and a float2x3 matrix.

```csharp
public static float3 mul(float2 a, float2x3 b)
```

### Parameters

**** (\[float2]\(/engine/7000.0/script-reference/unity/mathematics/float2)): Left hand side argument of the matrix multiply.**** (\[float2x3]\(/engine/7000.0/script-reference/unity/mathematics/float2x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [float3](/engine/7000.0/script-reference/unity/mathematics/float3.md) | The computed matrix multiplication. |

## mul(float2, float2x4)

Returns the float4 row vector result of a matrix multiplication between a float2 row vector and a float2x4 matrix.

```csharp
public static float4 mul(float2 a, float2x4 b)
```

### Parameters

**** (\[float2]\(/engine/7000.0/script-reference/unity/mathematics/float2)): Left hand side argument of the matrix multiply.**** (\[float2x4]\(/engine/7000.0/script-reference/unity/mathematics/float2x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [float4](/engine/7000.0/script-reference/unity/mathematics/float4.md) | The computed matrix multiplication. |

## mul(float3, float3)

Returns the float value result of a matrix multiplication between a float3 row vector and a float3 column vector.

```csharp
public static float mul(float3 a, float3 b)
```

### Parameters

**** (\[float3]\(/engine/7000.0/script-reference/unity/mathematics/float3)): Left hand side argument of the matrix multiply.**** (\[float3]\(/engine/7000.0/script-reference/unity/mathematics/float3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                          | Description                         |
| ------------------------------------------------------------- | ----------------------------------- |
| [float](https://learn.microsoft.com/dotnet/api/system.single) | The computed matrix multiplication. |

## mul(float3, float3x2)

Returns the float2 row vector result of a matrix multiplication between a float3 row vector and a float3x2 matrix.

```csharp
public static float2 mul(float3 a, float3x2 b)
```

### Parameters

**** (\[float3]\(/engine/7000.0/script-reference/unity/mathematics/float3)): Left hand side argument of the matrix multiply.**** (\[float3x2]\(/engine/7000.0/script-reference/unity/mathematics/float3x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [float2](/engine/7000.0/script-reference/unity/mathematics/float2.md) | The computed matrix multiplication. |

## mul(float3, float3x3)

Returns the float3 row vector result of a matrix multiplication between a float3 row vector and a float3x3 matrix.

```csharp
public static float3 mul(float3 a, float3x3 b)
```

### Parameters

**** (\[float3]\(/engine/7000.0/script-reference/unity/mathematics/float3)): Left hand side argument of the matrix multiply.**** (\[float3x3]\(/engine/7000.0/script-reference/unity/mathematics/float3x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [float3](/engine/7000.0/script-reference/unity/mathematics/float3.md) | The computed matrix multiplication. |

## mul(float3, float3x4)

Returns the float4 row vector result of a matrix multiplication between a float3 row vector and a float3x4 matrix.

```csharp
public static float4 mul(float3 a, float3x4 b)
```

### Parameters

**** (\[float3]\(/engine/7000.0/script-reference/unity/mathematics/float3)): Left hand side argument of the matrix multiply.**** (\[float3x4]\(/engine/7000.0/script-reference/unity/mathematics/float3x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [float4](/engine/7000.0/script-reference/unity/mathematics/float4.md) | The computed matrix multiplication. |

## mul(float4, float4)

Returns the float value result of a matrix multiplication between a float4 row vector and a float4 column vector.

```csharp
public static float mul(float4 a, float4 b)
```

### Parameters

**** (\[float4]\(/engine/7000.0/script-reference/unity/mathematics/float4)): Left hand side argument of the matrix multiply.**** (\[float4]\(/engine/7000.0/script-reference/unity/mathematics/float4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                          | Description                         |
| ------------------------------------------------------------- | ----------------------------------- |
| [float](https://learn.microsoft.com/dotnet/api/system.single) | The computed matrix multiplication. |

## mul(float4, float4x2)

Returns the float2 row vector result of a matrix multiplication between a float4 row vector and a float4x2 matrix.

```csharp
public static float2 mul(float4 a, float4x2 b)
```

### Parameters

**** (\[float4]\(/engine/7000.0/script-reference/unity/mathematics/float4)): Left hand side argument of the matrix multiply.**** (\[float4x2]\(/engine/7000.0/script-reference/unity/mathematics/float4x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [float2](/engine/7000.0/script-reference/unity/mathematics/float2.md) | The computed matrix multiplication. |

## mul(float4, float4x3)

Returns the float3 row vector result of a matrix multiplication between a float4 row vector and a float4x3 matrix.

```csharp
public static float3 mul(float4 a, float4x3 b)
```

### Parameters

**** (\[float4]\(/engine/7000.0/script-reference/unity/mathematics/float4)): Left hand side argument of the matrix multiply.**** (\[float4x3]\(/engine/7000.0/script-reference/unity/mathematics/float4x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [float3](/engine/7000.0/script-reference/unity/mathematics/float3.md) | The computed matrix multiplication. |

## mul(float4, float4x4)

Returns the float4 row vector result of a matrix multiplication between a float4 row vector and a float4x4 matrix.

```csharp
public static float4 mul(float4 a, float4x4 b)
```

### Parameters

**** (\[float4]\(/engine/7000.0/script-reference/unity/mathematics/float4)): Left hand side argument of the matrix multiply.**** (\[float4x4]\(/engine/7000.0/script-reference/unity/mathematics/float4x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [float4](/engine/7000.0/script-reference/unity/mathematics/float4.md) | The computed matrix multiplication. |

## mul(float2x2, float2)

Returns the float2 column vector result of a matrix multiplication between a float2x2 matrix and a float2 column vector.

```csharp
public static float2 mul(float2x2 a, float2 b)
```

### Parameters

**** (\[float2x2]\(/engine/7000.0/script-reference/unity/mathematics/float2x2)): Left hand side argument of the matrix multiply.**** (\[float2]\(/engine/7000.0/script-reference/unity/mathematics/float2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [float2](/engine/7000.0/script-reference/unity/mathematics/float2.md) | The computed matrix multiplication. |

## mul(float2x2, float2x2)

Returns the float2x2 matrix result of a matrix multiplication between a float2x2 matrix and a float2x2 matrix.

```csharp
public static float2x2 mul(float2x2 a, float2x2 b)
```

### Parameters

**** (\[float2x2]\(/engine/7000.0/script-reference/unity/mathematics/float2x2)): Left hand side argument of the matrix multiply.**** (\[float2x2]\(/engine/7000.0/script-reference/unity/mathematics/float2x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                      | Description                         |
| ------------------------------------------------------------------------- | ----------------------------------- |
| [float2x2](/engine/7000.0/script-reference/unity/mathematics/float2x2.md) | The computed matrix multiplication. |

## mul(float2x2, float2x3)

Returns the float2x3 matrix result of a matrix multiplication between a float2x2 matrix and a float2x3 matrix.

```csharp
public static float2x3 mul(float2x2 a, float2x3 b)
```

### Parameters

**** (\[float2x2]\(/engine/7000.0/script-reference/unity/mathematics/float2x2)): Left hand side argument of the matrix multiply.**** (\[float2x3]\(/engine/7000.0/script-reference/unity/mathematics/float2x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                      | Description                         |
| ------------------------------------------------------------------------- | ----------------------------------- |
| [float2x3](/engine/7000.0/script-reference/unity/mathematics/float2x3.md) | The computed matrix multiplication. |

## mul(float2x2, float2x4)

Returns the float2x4 matrix result of a matrix multiplication between a float2x2 matrix and a float2x4 matrix.

```csharp
public static float2x4 mul(float2x2 a, float2x4 b)
```

### Parameters

**** (\[float2x2]\(/engine/7000.0/script-reference/unity/mathematics/float2x2)): Left hand side argument of the matrix multiply.**** (\[float2x4]\(/engine/7000.0/script-reference/unity/mathematics/float2x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                      | Description                         |
| ------------------------------------------------------------------------- | ----------------------------------- |
| [float2x4](/engine/7000.0/script-reference/unity/mathematics/float2x4.md) | The computed matrix multiplication. |

## mul(float2x3, float3)

Returns the float2 column vector result of a matrix multiplication between a float2x3 matrix and a float3 column vector.

```csharp
public static float2 mul(float2x3 a, float3 b)
```

### Parameters

**** (\[float2x3]\(/engine/7000.0/script-reference/unity/mathematics/float2x3)): Left hand side argument of the matrix multiply.**** (\[float3]\(/engine/7000.0/script-reference/unity/mathematics/float3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [float2](/engine/7000.0/script-reference/unity/mathematics/float2.md) | The computed matrix multiplication. |

## mul(float2x3, float3x2)

Returns the float2x2 matrix result of a matrix multiplication between a float2x3 matrix and a float3x2 matrix.

```csharp
public static float2x2 mul(float2x3 a, float3x2 b)
```

### Parameters

**** (\[float2x3]\(/engine/7000.0/script-reference/unity/mathematics/float2x3)): Left hand side argument of the matrix multiply.**** (\[float3x2]\(/engine/7000.0/script-reference/unity/mathematics/float3x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                      | Description                         |
| ------------------------------------------------------------------------- | ----------------------------------- |
| [float2x2](/engine/7000.0/script-reference/unity/mathematics/float2x2.md) | The computed matrix multiplication. |

## mul(float2x3, float3x3)

Returns the float2x3 matrix result of a matrix multiplication between a float2x3 matrix and a float3x3 matrix.

```csharp
public static float2x3 mul(float2x3 a, float3x3 b)
```

### Parameters

**** (\[float2x3]\(/engine/7000.0/script-reference/unity/mathematics/float2x3)): Left hand side argument of the matrix multiply.**** (\[float3x3]\(/engine/7000.0/script-reference/unity/mathematics/float3x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                      | Description                         |
| ------------------------------------------------------------------------- | ----------------------------------- |
| [float2x3](/engine/7000.0/script-reference/unity/mathematics/float2x3.md) | The computed matrix multiplication. |

## mul(float2x3, float3x4)

Returns the float2x4 matrix result of a matrix multiplication between a float2x3 matrix and a float3x4 matrix.

```csharp
public static float2x4 mul(float2x3 a, float3x4 b)
```

### Parameters

**** (\[float2x3]\(/engine/7000.0/script-reference/unity/mathematics/float2x3)): Left hand side argument of the matrix multiply.**** (\[float3x4]\(/engine/7000.0/script-reference/unity/mathematics/float3x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                      | Description                         |
| ------------------------------------------------------------------------- | ----------------------------------- |
| [float2x4](/engine/7000.0/script-reference/unity/mathematics/float2x4.md) | The computed matrix multiplication. |

## mul(float2x4, float4)

Returns the float2 column vector result of a matrix multiplication between a float2x4 matrix and a float4 column vector.

```csharp
public static float2 mul(float2x4 a, float4 b)
```

### Parameters

**** (\[float2x4]\(/engine/7000.0/script-reference/unity/mathematics/float2x4)): Left hand side argument of the matrix multiply.**** (\[float4]\(/engine/7000.0/script-reference/unity/mathematics/float4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [float2](/engine/7000.0/script-reference/unity/mathematics/float2.md) | The computed matrix multiplication. |

## mul(float2x4, float4x2)

Returns the float2x2 matrix result of a matrix multiplication between a float2x4 matrix and a float4x2 matrix.

```csharp
public static float2x2 mul(float2x4 a, float4x2 b)
```

### Parameters

**** (\[float2x4]\(/engine/7000.0/script-reference/unity/mathematics/float2x4)): Left hand side argument of the matrix multiply.**** (\[float4x2]\(/engine/7000.0/script-reference/unity/mathematics/float4x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                      | Description                         |
| ------------------------------------------------------------------------- | ----------------------------------- |
| [float2x2](/engine/7000.0/script-reference/unity/mathematics/float2x2.md) | The computed matrix multiplication. |

## mul(float2x4, float4x3)

Returns the float2x3 matrix result of a matrix multiplication between a float2x4 matrix and a float4x3 matrix.

```csharp
public static float2x3 mul(float2x4 a, float4x3 b)
```

### Parameters

**** (\[float2x4]\(/engine/7000.0/script-reference/unity/mathematics/float2x4)): Left hand side argument of the matrix multiply.**** (\[float4x3]\(/engine/7000.0/script-reference/unity/mathematics/float4x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                      | Description                         |
| ------------------------------------------------------------------------- | ----------------------------------- |
| [float2x3](/engine/7000.0/script-reference/unity/mathematics/float2x3.md) | The computed matrix multiplication. |

## mul(float2x4, float4x4)

Returns the float2x4 matrix result of a matrix multiplication between a float2x4 matrix and a float4x4 matrix.

```csharp
public static float2x4 mul(float2x4 a, float4x4 b)
```

### Parameters

**** (\[float2x4]\(/engine/7000.0/script-reference/unity/mathematics/float2x4)): Left hand side argument of the matrix multiply.**** (\[float4x4]\(/engine/7000.0/script-reference/unity/mathematics/float4x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                      | Description                         |
| ------------------------------------------------------------------------- | ----------------------------------- |
| [float2x4](/engine/7000.0/script-reference/unity/mathematics/float2x4.md) | The computed matrix multiplication. |

## mul(float3x2, float2)

Returns the float3 column vector result of a matrix multiplication between a float3x2 matrix and a float2 column vector.

```csharp
public static float3 mul(float3x2 a, float2 b)
```

### Parameters

**** (\[float3x2]\(/engine/7000.0/script-reference/unity/mathematics/float3x2)): Left hand side argument of the matrix multiply.**** (\[float2]\(/engine/7000.0/script-reference/unity/mathematics/float2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [float3](/engine/7000.0/script-reference/unity/mathematics/float3.md) | The computed matrix multiplication. |

## mul(float3x2, float2x2)

Returns the float3x2 matrix result of a matrix multiplication between a float3x2 matrix and a float2x2 matrix.

```csharp
public static float3x2 mul(float3x2 a, float2x2 b)
```

### Parameters

**** (\[float3x2]\(/engine/7000.0/script-reference/unity/mathematics/float3x2)): Left hand side argument of the matrix multiply.**** (\[float2x2]\(/engine/7000.0/script-reference/unity/mathematics/float2x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                      | Description                         |
| ------------------------------------------------------------------------- | ----------------------------------- |
| [float3x2](/engine/7000.0/script-reference/unity/mathematics/float3x2.md) | The computed matrix multiplication. |

## mul(float3x2, float2x3)

Returns the float3x3 matrix result of a matrix multiplication between a float3x2 matrix and a float2x3 matrix.

```csharp
public static float3x3 mul(float3x2 a, float2x3 b)
```

### Parameters

**** (\[float3x2]\(/engine/7000.0/script-reference/unity/mathematics/float3x2)): Left hand side argument of the matrix multiply.**** (\[float2x3]\(/engine/7000.0/script-reference/unity/mathematics/float2x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                      | Description                         |
| ------------------------------------------------------------------------- | ----------------------------------- |
| [float3x3](/engine/7000.0/script-reference/unity/mathematics/float3x3.md) | The computed matrix multiplication. |

## mul(float3x2, float2x4)

Returns the float3x4 matrix result of a matrix multiplication between a float3x2 matrix and a float2x4 matrix.

```csharp
public static float3x4 mul(float3x2 a, float2x4 b)
```

### Parameters

**** (\[float3x2]\(/engine/7000.0/script-reference/unity/mathematics/float3x2)): Left hand side argument of the matrix multiply.**** (\[float2x4]\(/engine/7000.0/script-reference/unity/mathematics/float2x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                      | Description                         |
| ------------------------------------------------------------------------- | ----------------------------------- |
| [float3x4](/engine/7000.0/script-reference/unity/mathematics/float3x4.md) | The computed matrix multiplication. |

## mul(float3x3, float3)

Returns the float3 column vector result of a matrix multiplication between a float3x3 matrix and a float3 column vector.

```csharp
public static float3 mul(float3x3 a, float3 b)
```

### Parameters

**** (\[float3x3]\(/engine/7000.0/script-reference/unity/mathematics/float3x3)): Left hand side argument of the matrix multiply.**** (\[float3]\(/engine/7000.0/script-reference/unity/mathematics/float3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [float3](/engine/7000.0/script-reference/unity/mathematics/float3.md) | The computed matrix multiplication. |

## mul(float3x3, float3x2)

Returns the float3x2 matrix result of a matrix multiplication between a float3x3 matrix and a float3x2 matrix.

```csharp
public static float3x2 mul(float3x3 a, float3x2 b)
```

### Parameters

**** (\[float3x3]\(/engine/7000.0/script-reference/unity/mathematics/float3x3)): Left hand side argument of the matrix multiply.**** (\[float3x2]\(/engine/7000.0/script-reference/unity/mathematics/float3x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                      | Description                         |
| ------------------------------------------------------------------------- | ----------------------------------- |
| [float3x2](/engine/7000.0/script-reference/unity/mathematics/float3x2.md) | The computed matrix multiplication. |

## mul(float3x3, float3x3)

Returns the float3x3 matrix result of a matrix multiplication between a float3x3 matrix and a float3x3 matrix.

```csharp
public static float3x3 mul(float3x3 a, float3x3 b)
```

### Parameters

**** (\[float3x3]\(/engine/7000.0/script-reference/unity/mathematics/float3x3)): Left hand side argument of the matrix multiply.**** (\[float3x3]\(/engine/7000.0/script-reference/unity/mathematics/float3x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                      | Description                         |
| ------------------------------------------------------------------------- | ----------------------------------- |
| [float3x3](/engine/7000.0/script-reference/unity/mathematics/float3x3.md) | The computed matrix multiplication. |

## mul(float3x3, float3x4)

Returns the float3x4 matrix result of a matrix multiplication between a float3x3 matrix and a float3x4 matrix.

```csharp
public static float3x4 mul(float3x3 a, float3x4 b)
```

### Parameters

**** (\[float3x3]\(/engine/7000.0/script-reference/unity/mathematics/float3x3)): Left hand side argument of the matrix multiply.**** (\[float3x4]\(/engine/7000.0/script-reference/unity/mathematics/float3x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                      | Description                         |
| ------------------------------------------------------------------------- | ----------------------------------- |
| [float3x4](/engine/7000.0/script-reference/unity/mathematics/float3x4.md) | The computed matrix multiplication. |

## mul(float3x4, float4)

Returns the float3 column vector result of a matrix multiplication between a float3x4 matrix and a float4 column vector.

```csharp
public static float3 mul(float3x4 a, float4 b)
```

### Parameters

**** (\[float3x4]\(/engine/7000.0/script-reference/unity/mathematics/float3x4)): Left hand side argument of the matrix multiply.**** (\[float4]\(/engine/7000.0/script-reference/unity/mathematics/float4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [float3](/engine/7000.0/script-reference/unity/mathematics/float3.md) | The computed matrix multiplication. |

## mul(float3x4, float4x2)

Returns the float3x2 matrix result of a matrix multiplication between a float3x4 matrix and a float4x2 matrix.

```csharp
public static float3x2 mul(float3x4 a, float4x2 b)
```

### Parameters

**** (\[float3x4]\(/engine/7000.0/script-reference/unity/mathematics/float3x4)): Left hand side argument of the matrix multiply.**** (\[float4x2]\(/engine/7000.0/script-reference/unity/mathematics/float4x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                      | Description                         |
| ------------------------------------------------------------------------- | ----------------------------------- |
| [float3x2](/engine/7000.0/script-reference/unity/mathematics/float3x2.md) | The computed matrix multiplication. |

## mul(float3x4, float4x3)

Returns the float3x3 matrix result of a matrix multiplication between a float3x4 matrix and a float4x3 matrix.

```csharp
public static float3x3 mul(float3x4 a, float4x3 b)
```

### Parameters

**** (\[float3x4]\(/engine/7000.0/script-reference/unity/mathematics/float3x4)): Left hand side argument of the matrix multiply.**** (\[float4x3]\(/engine/7000.0/script-reference/unity/mathematics/float4x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                      | Description                         |
| ------------------------------------------------------------------------- | ----------------------------------- |
| [float3x3](/engine/7000.0/script-reference/unity/mathematics/float3x3.md) | The computed matrix multiplication. |

## mul(float3x4, float4x4)

Returns the float3x4 matrix result of a matrix multiplication between a float3x4 matrix and a float4x4 matrix.

```csharp
public static float3x4 mul(float3x4 a, float4x4 b)
```

### Parameters

**** (\[float3x4]\(/engine/7000.0/script-reference/unity/mathematics/float3x4)): Left hand side argument of the matrix multiply.**** (\[float4x4]\(/engine/7000.0/script-reference/unity/mathematics/float4x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                      | Description                         |
| ------------------------------------------------------------------------- | ----------------------------------- |
| [float3x4](/engine/7000.0/script-reference/unity/mathematics/float3x4.md) | The computed matrix multiplication. |

## mul(float4x2, float2)

Returns the float4 column vector result of a matrix multiplication between a float4x2 matrix and a float2 column vector.

```csharp
public static float4 mul(float4x2 a, float2 b)
```

### Parameters

**** (\[float4x2]\(/engine/7000.0/script-reference/unity/mathematics/float4x2)): Left hand side argument of the matrix multiply.**** (\[float2]\(/engine/7000.0/script-reference/unity/mathematics/float2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [float4](/engine/7000.0/script-reference/unity/mathematics/float4.md) | The computed matrix multiplication. |

## mul(float4x2, float2x2)

Returns the float4x2 matrix result of a matrix multiplication between a float4x2 matrix and a float2x2 matrix.

```csharp
public static float4x2 mul(float4x2 a, float2x2 b)
```

### Parameters

**** (\[float4x2]\(/engine/7000.0/script-reference/unity/mathematics/float4x2)): Left hand side argument of the matrix multiply.**** (\[float2x2]\(/engine/7000.0/script-reference/unity/mathematics/float2x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                      | Description                         |
| ------------------------------------------------------------------------- | ----------------------------------- |
| [float4x2](/engine/7000.0/script-reference/unity/mathematics/float4x2.md) | The computed matrix multiplication. |

## mul(float4x2, float2x3)

Returns the float4x3 matrix result of a matrix multiplication between a float4x2 matrix and a float2x3 matrix.

```csharp
public static float4x3 mul(float4x2 a, float2x3 b)
```

### Parameters

**** (\[float4x2]\(/engine/7000.0/script-reference/unity/mathematics/float4x2)): Left hand side argument of the matrix multiply.**** (\[float2x3]\(/engine/7000.0/script-reference/unity/mathematics/float2x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                      | Description                         |
| ------------------------------------------------------------------------- | ----------------------------------- |
| [float4x3](/engine/7000.0/script-reference/unity/mathematics/float4x3.md) | The computed matrix multiplication. |

## mul(float4x2, float2x4)

Returns the float4x4 matrix result of a matrix multiplication between a float4x2 matrix and a float2x4 matrix.

```csharp
public static float4x4 mul(float4x2 a, float2x4 b)
```

### Parameters

**** (\[float4x2]\(/engine/7000.0/script-reference/unity/mathematics/float4x2)): Left hand side argument of the matrix multiply.**** (\[float2x4]\(/engine/7000.0/script-reference/unity/mathematics/float2x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                      | Description                         |
| ------------------------------------------------------------------------- | ----------------------------------- |
| [float4x4](/engine/7000.0/script-reference/unity/mathematics/float4x4.md) | The computed matrix multiplication. |

## mul(float4x3, float3)

Returns the float4 column vector result of a matrix multiplication between a float4x3 matrix and a float3 column vector.

```csharp
public static float4 mul(float4x3 a, float3 b)
```

### Parameters

**** (\[float4x3]\(/engine/7000.0/script-reference/unity/mathematics/float4x3)): Left hand side argument of the matrix multiply.**** (\[float3]\(/engine/7000.0/script-reference/unity/mathematics/float3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [float4](/engine/7000.0/script-reference/unity/mathematics/float4.md) | The computed matrix multiplication. |

## mul(float4x3, float3x2)

Returns the float4x2 matrix result of a matrix multiplication between a float4x3 matrix and a float3x2 matrix.

```csharp
public static float4x2 mul(float4x3 a, float3x2 b)
```

### Parameters

**** (\[float4x3]\(/engine/7000.0/script-reference/unity/mathematics/float4x3)): Left hand side argument of the matrix multiply.**** (\[float3x2]\(/engine/7000.0/script-reference/unity/mathematics/float3x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                      | Description                         |
| ------------------------------------------------------------------------- | ----------------------------------- |
| [float4x2](/engine/7000.0/script-reference/unity/mathematics/float4x2.md) | The computed matrix multiplication. |

## mul(float4x3, float3x3)

Returns the float4x3 matrix result of a matrix multiplication between a float4x3 matrix and a float3x3 matrix.

```csharp
public static float4x3 mul(float4x3 a, float3x3 b)
```

### Parameters

**** (\[float4x3]\(/engine/7000.0/script-reference/unity/mathematics/float4x3)): Left hand side argument of the matrix multiply.**** (\[float3x3]\(/engine/7000.0/script-reference/unity/mathematics/float3x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                      | Description                         |
| ------------------------------------------------------------------------- | ----------------------------------- |
| [float4x3](/engine/7000.0/script-reference/unity/mathematics/float4x3.md) | The computed matrix multiplication. |

## mul(float4x3, float3x4)

Returns the float4x4 matrix result of a matrix multiplication between a float4x3 matrix and a float3x4 matrix.

```csharp
public static float4x4 mul(float4x3 a, float3x4 b)
```

### Parameters

**** (\[float4x3]\(/engine/7000.0/script-reference/unity/mathematics/float4x3)): Left hand side argument of the matrix multiply.**** (\[float3x4]\(/engine/7000.0/script-reference/unity/mathematics/float3x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                      | Description                         |
| ------------------------------------------------------------------------- | ----------------------------------- |
| [float4x4](/engine/7000.0/script-reference/unity/mathematics/float4x4.md) | The computed matrix multiplication. |

## mul(float4x4, float4)

Returns the float4 column vector result of a matrix multiplication between a float4x4 matrix and a float4 column vector.

```csharp
public static float4 mul(float4x4 a, float4 b)
```

### Parameters

**** (\[float4x4]\(/engine/7000.0/script-reference/unity/mathematics/float4x4)): Left hand side argument of the matrix multiply.**** (\[float4]\(/engine/7000.0/script-reference/unity/mathematics/float4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [float4](/engine/7000.0/script-reference/unity/mathematics/float4.md) | The computed matrix multiplication. |

## mul(float4x4, float4x2)

Returns the float4x2 matrix result of a matrix multiplication between a float4x4 matrix and a float4x2 matrix.

```csharp
public static float4x2 mul(float4x4 a, float4x2 b)
```

### Parameters

**** (\[float4x4]\(/engine/7000.0/script-reference/unity/mathematics/float4x4)): Left hand side argument of the matrix multiply.**** (\[float4x2]\(/engine/7000.0/script-reference/unity/mathematics/float4x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                      | Description                         |
| ------------------------------------------------------------------------- | ----------------------------------- |
| [float4x2](/engine/7000.0/script-reference/unity/mathematics/float4x2.md) | The computed matrix multiplication. |

## mul(float4x4, float4x3)

Returns the float4x3 matrix result of a matrix multiplication between a float4x4 matrix and a float4x3 matrix.

```csharp
public static float4x3 mul(float4x4 a, float4x3 b)
```

### Parameters

**** (\[float4x4]\(/engine/7000.0/script-reference/unity/mathematics/float4x4)): Left hand side argument of the matrix multiply.**** (\[float4x3]\(/engine/7000.0/script-reference/unity/mathematics/float4x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                      | Description                         |
| ------------------------------------------------------------------------- | ----------------------------------- |
| [float4x3](/engine/7000.0/script-reference/unity/mathematics/float4x3.md) | The computed matrix multiplication. |

## mul(float4x4, float4x4)

Returns the float4x4 matrix result of a matrix multiplication between a float4x4 matrix and a float4x4 matrix.

```csharp
public static float4x4 mul(float4x4 a, float4x4 b)
```

### Parameters

**** (\[float4x4]\(/engine/7000.0/script-reference/unity/mathematics/float4x4)): Left hand side argument of the matrix multiply.**** (\[float4x4]\(/engine/7000.0/script-reference/unity/mathematics/float4x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                      | Description                         |
| ------------------------------------------------------------------------- | ----------------------------------- |
| [float4x4](/engine/7000.0/script-reference/unity/mathematics/float4x4.md) | The computed matrix multiplication. |

## mul(double, double)

Returns the double value result of a matrix multiplication between a double value and a double value.

```csharp
public static double mul(double a, double b)
```

### Parameters

**** (\[double]\(https\://learn.microsoft.com/dotnet/api/system.double)): Left hand side argument of the matrix multiply.**** (\[double]\(https\://learn.microsoft.com/dotnet/api/system.double)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                           | Description                         |
| -------------------------------------------------------------- | ----------------------------------- |
| [double](https://learn.microsoft.com/dotnet/api/system.double) | The computed matrix multiplication. |

## mul(double2, double2)

Returns the double value result of a matrix multiplication between a double2 row vector and a double2 column vector.

```csharp
public static double mul(double2 a, double2 b)
```

### Parameters

**** (\[double2]\(/engine/7000.0/script-reference/unity/mathematics/double2)): Left hand side argument of the matrix multiply.**** (\[double2]\(/engine/7000.0/script-reference/unity/mathematics/double2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                           | Description                         |
| -------------------------------------------------------------- | ----------------------------------- |
| [double](https://learn.microsoft.com/dotnet/api/system.double) | The computed matrix multiplication. |

## mul(double2, double2x2)

Returns the double2 row vector result of a matrix multiplication between a double2 row vector and a double2x2 matrix.

```csharp
public static double2 mul(double2 a, double2x2 b)
```

### Parameters

**** (\[double2]\(/engine/7000.0/script-reference/unity/mathematics/double2)): Left hand side argument of the matrix multiply.**** (\[double2x2]\(/engine/7000.0/script-reference/unity/mathematics/double2x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [double2](/engine/7000.0/script-reference/unity/mathematics/double2.md) | The computed matrix multiplication. |

## mul(double2, double2x3)

Returns the double3 row vector result of a matrix multiplication between a double2 row vector and a double2x3 matrix.

```csharp
public static double3 mul(double2 a, double2x3 b)
```

### Parameters

**** (\[double2]\(/engine/7000.0/script-reference/unity/mathematics/double2)): Left hand side argument of the matrix multiply.**** (\[double2x3]\(/engine/7000.0/script-reference/unity/mathematics/double2x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [double3](/engine/7000.0/script-reference/unity/mathematics/double3.md) | The computed matrix multiplication. |

## mul(double2, double2x4)

Returns the double4 row vector result of a matrix multiplication between a double2 row vector and a double2x4 matrix.

```csharp
public static double4 mul(double2 a, double2x4 b)
```

### Parameters

**** (\[double2]\(/engine/7000.0/script-reference/unity/mathematics/double2)): Left hand side argument of the matrix multiply.**** (\[double2x4]\(/engine/7000.0/script-reference/unity/mathematics/double2x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [double4](/engine/7000.0/script-reference/unity/mathematics/double4.md) | The computed matrix multiplication. |

## mul(double3, double3)

Returns the double value result of a matrix multiplication between a double3 row vector and a double3 column vector.

```csharp
public static double mul(double3 a, double3 b)
```

### Parameters

**** (\[double3]\(/engine/7000.0/script-reference/unity/mathematics/double3)): Left hand side argument of the matrix multiply.**** (\[double3]\(/engine/7000.0/script-reference/unity/mathematics/double3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                           | Description                         |
| -------------------------------------------------------------- | ----------------------------------- |
| [double](https://learn.microsoft.com/dotnet/api/system.double) | The computed matrix multiplication. |

## mul(double3, double3x2)

Returns the double2 row vector result of a matrix multiplication between a double3 row vector and a double3x2 matrix.

```csharp
public static double2 mul(double3 a, double3x2 b)
```

### Parameters

**** (\[double3]\(/engine/7000.0/script-reference/unity/mathematics/double3)): Left hand side argument of the matrix multiply.**** (\[double3x2]\(/engine/7000.0/script-reference/unity/mathematics/double3x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [double2](/engine/7000.0/script-reference/unity/mathematics/double2.md) | The computed matrix multiplication. |

## mul(double3, double3x3)

Returns the double3 row vector result of a matrix multiplication between a double3 row vector and a double3x3 matrix.

```csharp
public static double3 mul(double3 a, double3x3 b)
```

### Parameters

**** (\[double3]\(/engine/7000.0/script-reference/unity/mathematics/double3)): Left hand side argument of the matrix multiply.**** (\[double3x3]\(/engine/7000.0/script-reference/unity/mathematics/double3x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [double3](/engine/7000.0/script-reference/unity/mathematics/double3.md) | The computed matrix multiplication. |

## mul(double3, double3x4)

Returns the double4 row vector result of a matrix multiplication between a double3 row vector and a double3x4 matrix.

```csharp
public static double4 mul(double3 a, double3x4 b)
```

### Parameters

**** (\[double3]\(/engine/7000.0/script-reference/unity/mathematics/double3)): Left hand side argument of the matrix multiply.**** (\[double3x4]\(/engine/7000.0/script-reference/unity/mathematics/double3x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [double4](/engine/7000.0/script-reference/unity/mathematics/double4.md) | The computed matrix multiplication. |

## mul(double4, double4)

Returns the double value result of a matrix multiplication between a double4 row vector and a double4 column vector.

```csharp
public static double mul(double4 a, double4 b)
```

### Parameters

**** (\[double4]\(/engine/7000.0/script-reference/unity/mathematics/double4)): Left hand side argument of the matrix multiply.**** (\[double4]\(/engine/7000.0/script-reference/unity/mathematics/double4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                           | Description                         |
| -------------------------------------------------------------- | ----------------------------------- |
| [double](https://learn.microsoft.com/dotnet/api/system.double) | The computed matrix multiplication. |

## mul(double4, double4x2)

Returns the double2 row vector result of a matrix multiplication between a double4 row vector and a double4x2 matrix.

```csharp
public static double2 mul(double4 a, double4x2 b)
```

### Parameters

**** (\[double4]\(/engine/7000.0/script-reference/unity/mathematics/double4)): Left hand side argument of the matrix multiply.**** (\[double4x2]\(/engine/7000.0/script-reference/unity/mathematics/double4x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [double2](/engine/7000.0/script-reference/unity/mathematics/double2.md) | The computed matrix multiplication. |

## mul(double4, double4x3)

Returns the double3 row vector result of a matrix multiplication between a double4 row vector and a double4x3 matrix.

```csharp
public static double3 mul(double4 a, double4x3 b)
```

### Parameters

**** (\[double4]\(/engine/7000.0/script-reference/unity/mathematics/double4)): Left hand side argument of the matrix multiply.**** (\[double4x3]\(/engine/7000.0/script-reference/unity/mathematics/double4x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [double3](/engine/7000.0/script-reference/unity/mathematics/double3.md) | The computed matrix multiplication. |

## mul(double4, double4x4)

Returns the double4 row vector result of a matrix multiplication between a double4 row vector and a double4x4 matrix.

```csharp
public static double4 mul(double4 a, double4x4 b)
```

### Parameters

**** (\[double4]\(/engine/7000.0/script-reference/unity/mathematics/double4)): Left hand side argument of the matrix multiply.**** (\[double4x4]\(/engine/7000.0/script-reference/unity/mathematics/double4x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [double4](/engine/7000.0/script-reference/unity/mathematics/double4.md) | The computed matrix multiplication. |

## mul(double2x2, double2)

Returns the double2 column vector result of a matrix multiplication between a double2x2 matrix and a double2 column vector.

```csharp
public static double2 mul(double2x2 a, double2 b)
```

### Parameters

**** (\[double2x2]\(/engine/7000.0/script-reference/unity/mathematics/double2x2)): Left hand side argument of the matrix multiply.**** (\[double2]\(/engine/7000.0/script-reference/unity/mathematics/double2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [double2](/engine/7000.0/script-reference/unity/mathematics/double2.md) | The computed matrix multiplication. |

## mul(double2x2, double2x2)

Returns the double2x2 matrix result of a matrix multiplication between a double2x2 matrix and a double2x2 matrix.

```csharp
public static double2x2 mul(double2x2 a, double2x2 b)
```

### Parameters

**** (\[double2x2]\(/engine/7000.0/script-reference/unity/mathematics/double2x2)): Left hand side argument of the matrix multiply.**** (\[double2x2]\(/engine/7000.0/script-reference/unity/mathematics/double2x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                        | Description                         |
| --------------------------------------------------------------------------- | ----------------------------------- |
| [double2x2](/engine/7000.0/script-reference/unity/mathematics/double2x2.md) | The computed matrix multiplication. |

## mul(double2x2, double2x3)

Returns the double2x3 matrix result of a matrix multiplication between a double2x2 matrix and a double2x3 matrix.

```csharp
public static double2x3 mul(double2x2 a, double2x3 b)
```

### Parameters

**** (\[double2x2]\(/engine/7000.0/script-reference/unity/mathematics/double2x2)): Left hand side argument of the matrix multiply.**** (\[double2x3]\(/engine/7000.0/script-reference/unity/mathematics/double2x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                        | Description                         |
| --------------------------------------------------------------------------- | ----------------------------------- |
| [double2x3](/engine/7000.0/script-reference/unity/mathematics/double2x3.md) | The computed matrix multiplication. |

## mul(double2x2, double2x4)

Returns the double2x4 matrix result of a matrix multiplication between a double2x2 matrix and a double2x4 matrix.

```csharp
public static double2x4 mul(double2x2 a, double2x4 b)
```

### Parameters

**** (\[double2x2]\(/engine/7000.0/script-reference/unity/mathematics/double2x2)): Left hand side argument of the matrix multiply.**** (\[double2x4]\(/engine/7000.0/script-reference/unity/mathematics/double2x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                        | Description                         |
| --------------------------------------------------------------------------- | ----------------------------------- |
| [double2x4](/engine/7000.0/script-reference/unity/mathematics/double2x4.md) | The computed matrix multiplication. |

## mul(double2x3, double3)

Returns the double2 column vector result of a matrix multiplication between a double2x3 matrix and a double3 column vector.

```csharp
public static double2 mul(double2x3 a, double3 b)
```

### Parameters

**** (\[double2x3]\(/engine/7000.0/script-reference/unity/mathematics/double2x3)): Left hand side argument of the matrix multiply.**** (\[double3]\(/engine/7000.0/script-reference/unity/mathematics/double3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [double2](/engine/7000.0/script-reference/unity/mathematics/double2.md) | The computed matrix multiplication. |

## mul(double2x3, double3x2)

Returns the double2x2 matrix result of a matrix multiplication between a double2x3 matrix and a double3x2 matrix.

```csharp
public static double2x2 mul(double2x3 a, double3x2 b)
```

### Parameters

**** (\[double2x3]\(/engine/7000.0/script-reference/unity/mathematics/double2x3)): Left hand side argument of the matrix multiply.**** (\[double3x2]\(/engine/7000.0/script-reference/unity/mathematics/double3x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                        | Description                         |
| --------------------------------------------------------------------------- | ----------------------------------- |
| [double2x2](/engine/7000.0/script-reference/unity/mathematics/double2x2.md) | The computed matrix multiplication. |

## mul(double2x3, double3x3)

Returns the double2x3 matrix result of a matrix multiplication between a double2x3 matrix and a double3x3 matrix.

```csharp
public static double2x3 mul(double2x3 a, double3x3 b)
```

### Parameters

**** (\[double2x3]\(/engine/7000.0/script-reference/unity/mathematics/double2x3)): Left hand side argument of the matrix multiply.**** (\[double3x3]\(/engine/7000.0/script-reference/unity/mathematics/double3x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                        | Description                         |
| --------------------------------------------------------------------------- | ----------------------------------- |
| [double2x3](/engine/7000.0/script-reference/unity/mathematics/double2x3.md) | The computed matrix multiplication. |

## mul(double2x3, double3x4)

Returns the double2x4 matrix result of a matrix multiplication between a double2x3 matrix and a double3x4 matrix.

```csharp
public static double2x4 mul(double2x3 a, double3x4 b)
```

### Parameters

**** (\[double2x3]\(/engine/7000.0/script-reference/unity/mathematics/double2x3)): Left hand side argument of the matrix multiply.**** (\[double3x4]\(/engine/7000.0/script-reference/unity/mathematics/double3x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                        | Description                         |
| --------------------------------------------------------------------------- | ----------------------------------- |
| [double2x4](/engine/7000.0/script-reference/unity/mathematics/double2x4.md) | The computed matrix multiplication. |

## mul(double2x4, double4)

Returns the double2 column vector result of a matrix multiplication between a double2x4 matrix and a double4 column vector.

```csharp
public static double2 mul(double2x4 a, double4 b)
```

### Parameters

**** (\[double2x4]\(/engine/7000.0/script-reference/unity/mathematics/double2x4)): Left hand side argument of the matrix multiply.**** (\[double4]\(/engine/7000.0/script-reference/unity/mathematics/double4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [double2](/engine/7000.0/script-reference/unity/mathematics/double2.md) | The computed matrix multiplication. |

## mul(double2x4, double4x2)

Returns the double2x2 matrix result of a matrix multiplication between a double2x4 matrix and a double4x2 matrix.

```csharp
public static double2x2 mul(double2x4 a, double4x2 b)
```

### Parameters

**** (\[double2x4]\(/engine/7000.0/script-reference/unity/mathematics/double2x4)): Left hand side argument of the matrix multiply.**** (\[double4x2]\(/engine/7000.0/script-reference/unity/mathematics/double4x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                        | Description                         |
| --------------------------------------------------------------------------- | ----------------------------------- |
| [double2x2](/engine/7000.0/script-reference/unity/mathematics/double2x2.md) | The computed matrix multiplication. |

## mul(double2x4, double4x3)

Returns the double2x3 matrix result of a matrix multiplication between a double2x4 matrix and a double4x3 matrix.

```csharp
public static double2x3 mul(double2x4 a, double4x3 b)
```

### Parameters

**** (\[double2x4]\(/engine/7000.0/script-reference/unity/mathematics/double2x4)): Left hand side argument of the matrix multiply.**** (\[double4x3]\(/engine/7000.0/script-reference/unity/mathematics/double4x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                        | Description                         |
| --------------------------------------------------------------------------- | ----------------------------------- |
| [double2x3](/engine/7000.0/script-reference/unity/mathematics/double2x3.md) | The computed matrix multiplication. |

## mul(double2x4, double4x4)

Returns the double2x4 matrix result of a matrix multiplication between a double2x4 matrix and a double4x4 matrix.

```csharp
public static double2x4 mul(double2x4 a, double4x4 b)
```

### Parameters

**** (\[double2x4]\(/engine/7000.0/script-reference/unity/mathematics/double2x4)): Left hand side argument of the matrix multiply.**** (\[double4x4]\(/engine/7000.0/script-reference/unity/mathematics/double4x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                        | Description                         |
| --------------------------------------------------------------------------- | ----------------------------------- |
| [double2x4](/engine/7000.0/script-reference/unity/mathematics/double2x4.md) | The computed matrix multiplication. |

## mul(double3x2, double2)

Returns the double3 column vector result of a matrix multiplication between a double3x2 matrix and a double2 column vector.

```csharp
public static double3 mul(double3x2 a, double2 b)
```

### Parameters

**** (\[double3x2]\(/engine/7000.0/script-reference/unity/mathematics/double3x2)): Left hand side argument of the matrix multiply.**** (\[double2]\(/engine/7000.0/script-reference/unity/mathematics/double2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [double3](/engine/7000.0/script-reference/unity/mathematics/double3.md) | The computed matrix multiplication. |

## mul(double3x2, double2x2)

Returns the double3x2 matrix result of a matrix multiplication between a double3x2 matrix and a double2x2 matrix.

```csharp
public static double3x2 mul(double3x2 a, double2x2 b)
```

### Parameters

**** (\[double3x2]\(/engine/7000.0/script-reference/unity/mathematics/double3x2)): Left hand side argument of the matrix multiply.**** (\[double2x2]\(/engine/7000.0/script-reference/unity/mathematics/double2x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                        | Description                         |
| --------------------------------------------------------------------------- | ----------------------------------- |
| [double3x2](/engine/7000.0/script-reference/unity/mathematics/double3x2.md) | The computed matrix multiplication. |

## mul(double3x2, double2x3)

Returns the double3x3 matrix result of a matrix multiplication between a double3x2 matrix and a double2x3 matrix.

```csharp
public static double3x3 mul(double3x2 a, double2x3 b)
```

### Parameters

**** (\[double3x2]\(/engine/7000.0/script-reference/unity/mathematics/double3x2)): Left hand side argument of the matrix multiply.**** (\[double2x3]\(/engine/7000.0/script-reference/unity/mathematics/double2x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                        | Description                         |
| --------------------------------------------------------------------------- | ----------------------------------- |
| [double3x3](/engine/7000.0/script-reference/unity/mathematics/double3x3.md) | The computed matrix multiplication. |

## mul(double3x2, double2x4)

Returns the double3x4 matrix result of a matrix multiplication between a double3x2 matrix and a double2x4 matrix.

```csharp
public static double3x4 mul(double3x2 a, double2x4 b)
```

### Parameters

**** (\[double3x2]\(/engine/7000.0/script-reference/unity/mathematics/double3x2)): Left hand side argument of the matrix multiply.**** (\[double2x4]\(/engine/7000.0/script-reference/unity/mathematics/double2x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                        | Description                         |
| --------------------------------------------------------------------------- | ----------------------------------- |
| [double3x4](/engine/7000.0/script-reference/unity/mathematics/double3x4.md) | The computed matrix multiplication. |

## mul(double3x3, double3)

Returns the double3 column vector result of a matrix multiplication between a double3x3 matrix and a double3 column vector.

```csharp
public static double3 mul(double3x3 a, double3 b)
```

### Parameters

**** (\[double3x3]\(/engine/7000.0/script-reference/unity/mathematics/double3x3)): Left hand side argument of the matrix multiply.**** (\[double3]\(/engine/7000.0/script-reference/unity/mathematics/double3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [double3](/engine/7000.0/script-reference/unity/mathematics/double3.md) | The computed matrix multiplication. |

## mul(double3x3, double3x2)

Returns the double3x2 matrix result of a matrix multiplication between a double3x3 matrix and a double3x2 matrix.

```csharp
public static double3x2 mul(double3x3 a, double3x2 b)
```

### Parameters

**** (\[double3x3]\(/engine/7000.0/script-reference/unity/mathematics/double3x3)): Left hand side argument of the matrix multiply.**** (\[double3x2]\(/engine/7000.0/script-reference/unity/mathematics/double3x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                        | Description                         |
| --------------------------------------------------------------------------- | ----------------------------------- |
| [double3x2](/engine/7000.0/script-reference/unity/mathematics/double3x2.md) | The computed matrix multiplication. |

## mul(double3x3, double3x3)

Returns the double3x3 matrix result of a matrix multiplication between a double3x3 matrix and a double3x3 matrix.

```csharp
public static double3x3 mul(double3x3 a, double3x3 b)
```

### Parameters

**** (\[double3x3]\(/engine/7000.0/script-reference/unity/mathematics/double3x3)): Left hand side argument of the matrix multiply.**** (\[double3x3]\(/engine/7000.0/script-reference/unity/mathematics/double3x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                        | Description                         |
| --------------------------------------------------------------------------- | ----------------------------------- |
| [double3x3](/engine/7000.0/script-reference/unity/mathematics/double3x3.md) | The computed matrix multiplication. |

## mul(double3x3, double3x4)

Returns the double3x4 matrix result of a matrix multiplication between a double3x3 matrix and a double3x4 matrix.

```csharp
public static double3x4 mul(double3x3 a, double3x4 b)
```

### Parameters

**** (\[double3x3]\(/engine/7000.0/script-reference/unity/mathematics/double3x3)): Left hand side argument of the matrix multiply.**** (\[double3x4]\(/engine/7000.0/script-reference/unity/mathematics/double3x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                        | Description                         |
| --------------------------------------------------------------------------- | ----------------------------------- |
| [double3x4](/engine/7000.0/script-reference/unity/mathematics/double3x4.md) | The computed matrix multiplication. |

## mul(double3x4, double4)

Returns the double3 column vector result of a matrix multiplication between a double3x4 matrix and a double4 column vector.

```csharp
public static double3 mul(double3x4 a, double4 b)
```

### Parameters

**** (\[double3x4]\(/engine/7000.0/script-reference/unity/mathematics/double3x4)): Left hand side argument of the matrix multiply.**** (\[double4]\(/engine/7000.0/script-reference/unity/mathematics/double4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [double3](/engine/7000.0/script-reference/unity/mathematics/double3.md) | The computed matrix multiplication. |

## mul(double3x4, double4x2)

Returns the double3x2 matrix result of a matrix multiplication between a double3x4 matrix and a double4x2 matrix.

```csharp
public static double3x2 mul(double3x4 a, double4x2 b)
```

### Parameters

**** (\[double3x4]\(/engine/7000.0/script-reference/unity/mathematics/double3x4)): Left hand side argument of the matrix multiply.**** (\[double4x2]\(/engine/7000.0/script-reference/unity/mathematics/double4x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                        | Description                         |
| --------------------------------------------------------------------------- | ----------------------------------- |
| [double3x2](/engine/7000.0/script-reference/unity/mathematics/double3x2.md) | The computed matrix multiplication. |

## mul(double3x4, double4x3)

Returns the double3x3 matrix result of a matrix multiplication between a double3x4 matrix and a double4x3 matrix.

```csharp
public static double3x3 mul(double3x4 a, double4x3 b)
```

### Parameters

**** (\[double3x4]\(/engine/7000.0/script-reference/unity/mathematics/double3x4)): Left hand side argument of the matrix multiply.**** (\[double4x3]\(/engine/7000.0/script-reference/unity/mathematics/double4x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                        | Description                         |
| --------------------------------------------------------------------------- | ----------------------------------- |
| [double3x3](/engine/7000.0/script-reference/unity/mathematics/double3x3.md) | The computed matrix multiplication. |

## mul(double3x4, double4x4)

Returns the double3x4 matrix result of a matrix multiplication between a double3x4 matrix and a double4x4 matrix.

```csharp
public static double3x4 mul(double3x4 a, double4x4 b)
```

### Parameters

**** (\[double3x4]\(/engine/7000.0/script-reference/unity/mathematics/double3x4)): Left hand side argument of the matrix multiply.**** (\[double4x4]\(/engine/7000.0/script-reference/unity/mathematics/double4x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                        | Description                         |
| --------------------------------------------------------------------------- | ----------------------------------- |
| [double3x4](/engine/7000.0/script-reference/unity/mathematics/double3x4.md) | The computed matrix multiplication. |

## mul(double4x2, double2)

Returns the double4 column vector result of a matrix multiplication between a double4x2 matrix and a double2 column vector.

```csharp
public static double4 mul(double4x2 a, double2 b)
```

### Parameters

**** (\[double4x2]\(/engine/7000.0/script-reference/unity/mathematics/double4x2)): Left hand side argument of the matrix multiply.**** (\[double2]\(/engine/7000.0/script-reference/unity/mathematics/double2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [double4](/engine/7000.0/script-reference/unity/mathematics/double4.md) | The computed matrix multiplication. |

## mul(double4x2, double2x2)

Returns the double4x2 matrix result of a matrix multiplication between a double4x2 matrix and a double2x2 matrix.

```csharp
public static double4x2 mul(double4x2 a, double2x2 b)
```

### Parameters

**** (\[double4x2]\(/engine/7000.0/script-reference/unity/mathematics/double4x2)): Left hand side argument of the matrix multiply.**** (\[double2x2]\(/engine/7000.0/script-reference/unity/mathematics/double2x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                        | Description                         |
| --------------------------------------------------------------------------- | ----------------------------------- |
| [double4x2](/engine/7000.0/script-reference/unity/mathematics/double4x2.md) | The computed matrix multiplication. |

## mul(double4x2, double2x3)

Returns the double4x3 matrix result of a matrix multiplication between a double4x2 matrix and a double2x3 matrix.

```csharp
public static double4x3 mul(double4x2 a, double2x3 b)
```

### Parameters

**** (\[double4x2]\(/engine/7000.0/script-reference/unity/mathematics/double4x2)): Left hand side argument of the matrix multiply.**** (\[double2x3]\(/engine/7000.0/script-reference/unity/mathematics/double2x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                        | Description                         |
| --------------------------------------------------------------------------- | ----------------------------------- |
| [double4x3](/engine/7000.0/script-reference/unity/mathematics/double4x3.md) | The computed matrix multiplication. |

## mul(double4x2, double2x4)

Returns the double4x4 matrix result of a matrix multiplication between a double4x2 matrix and a double2x4 matrix.

```csharp
public static double4x4 mul(double4x2 a, double2x4 b)
```

### Parameters

**** (\[double4x2]\(/engine/7000.0/script-reference/unity/mathematics/double4x2)): Left hand side argument of the matrix multiply.**** (\[double2x4]\(/engine/7000.0/script-reference/unity/mathematics/double2x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                        | Description                         |
| --------------------------------------------------------------------------- | ----------------------------------- |
| [double4x4](/engine/7000.0/script-reference/unity/mathematics/double4x4.md) | The computed matrix multiplication. |

## mul(double4x3, double3)

Returns the double4 column vector result of a matrix multiplication between a double4x3 matrix and a double3 column vector.

```csharp
public static double4 mul(double4x3 a, double3 b)
```

### Parameters

**** (\[double4x3]\(/engine/7000.0/script-reference/unity/mathematics/double4x3)): Left hand side argument of the matrix multiply.**** (\[double3]\(/engine/7000.0/script-reference/unity/mathematics/double3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [double4](/engine/7000.0/script-reference/unity/mathematics/double4.md) | The computed matrix multiplication. |

## mul(double4x3, double3x2)

Returns the double4x2 matrix result of a matrix multiplication between a double4x3 matrix and a double3x2 matrix.

```csharp
public static double4x2 mul(double4x3 a, double3x2 b)
```

### Parameters

**** (\[double4x3]\(/engine/7000.0/script-reference/unity/mathematics/double4x3)): Left hand side argument of the matrix multiply.**** (\[double3x2]\(/engine/7000.0/script-reference/unity/mathematics/double3x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                        | Description                         |
| --------------------------------------------------------------------------- | ----------------------------------- |
| [double4x2](/engine/7000.0/script-reference/unity/mathematics/double4x2.md) | The computed matrix multiplication. |

## mul(double4x3, double3x3)

Returns the double4x3 matrix result of a matrix multiplication between a double4x3 matrix and a double3x3 matrix.

```csharp
public static double4x3 mul(double4x3 a, double3x3 b)
```

### Parameters

**** (\[double4x3]\(/engine/7000.0/script-reference/unity/mathematics/double4x3)): Left hand side argument of the matrix multiply.**** (\[double3x3]\(/engine/7000.0/script-reference/unity/mathematics/double3x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                        | Description                         |
| --------------------------------------------------------------------------- | ----------------------------------- |
| [double4x3](/engine/7000.0/script-reference/unity/mathematics/double4x3.md) | The computed matrix multiplication. |

## mul(double4x3, double3x4)

Returns the double4x4 matrix result of a matrix multiplication between a double4x3 matrix and a double3x4 matrix.

```csharp
public static double4x4 mul(double4x3 a, double3x4 b)
```

### Parameters

**** (\[double4x3]\(/engine/7000.0/script-reference/unity/mathematics/double4x3)): Left hand side argument of the matrix multiply.**** (\[double3x4]\(/engine/7000.0/script-reference/unity/mathematics/double3x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                        | Description                         |
| --------------------------------------------------------------------------- | ----------------------------------- |
| [double4x4](/engine/7000.0/script-reference/unity/mathematics/double4x4.md) | The computed matrix multiplication. |

## mul(double4x4, double4)

Returns the double4 column vector result of a matrix multiplication between a double4x4 matrix and a double4 column vector.

```csharp
public static double4 mul(double4x4 a, double4 b)
```

### Parameters

**** (\[double4x4]\(/engine/7000.0/script-reference/unity/mathematics/double4x4)): Left hand side argument of the matrix multiply.**** (\[double4]\(/engine/7000.0/script-reference/unity/mathematics/double4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [double4](/engine/7000.0/script-reference/unity/mathematics/double4.md) | The computed matrix multiplication. |

## mul(double4x4, double4x2)

Returns the double4x2 matrix result of a matrix multiplication between a double4x4 matrix and a double4x2 matrix.

```csharp
public static double4x2 mul(double4x4 a, double4x2 b)
```

### Parameters

**** (\[double4x4]\(/engine/7000.0/script-reference/unity/mathematics/double4x4)): Left hand side argument of the matrix multiply.**** (\[double4x2]\(/engine/7000.0/script-reference/unity/mathematics/double4x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                        | Description                         |
| --------------------------------------------------------------------------- | ----------------------------------- |
| [double4x2](/engine/7000.0/script-reference/unity/mathematics/double4x2.md) | The computed matrix multiplication. |

## mul(double4x4, double4x3)

Returns the double4x3 matrix result of a matrix multiplication between a double4x4 matrix and a double4x3 matrix.

```csharp
public static double4x3 mul(double4x4 a, double4x3 b)
```

### Parameters

**** (\[double4x4]\(/engine/7000.0/script-reference/unity/mathematics/double4x4)): Left hand side argument of the matrix multiply.**** (\[double4x3]\(/engine/7000.0/script-reference/unity/mathematics/double4x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                        | Description                         |
| --------------------------------------------------------------------------- | ----------------------------------- |
| [double4x3](/engine/7000.0/script-reference/unity/mathematics/double4x3.md) | The computed matrix multiplication. |

## mul(double4x4, double4x4)

Returns the double4x4 matrix result of a matrix multiplication between a double4x4 matrix and a double4x4 matrix.

```csharp
public static double4x4 mul(double4x4 a, double4x4 b)
```

### Parameters

**** (\[double4x4]\(/engine/7000.0/script-reference/unity/mathematics/double4x4)): Left hand side argument of the matrix multiply.**** (\[double4x4]\(/engine/7000.0/script-reference/unity/mathematics/double4x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                        | Description                         |
| --------------------------------------------------------------------------- | ----------------------------------- |
| [double4x4](/engine/7000.0/script-reference/unity/mathematics/double4x4.md) | The computed matrix multiplication. |

## mul(int, int)

Returns the int value result of a matrix multiplication between an int value and an int value.

```csharp
public static int mul(int a, int b)
```

### Parameters

**** (\[int]\(https\://learn.microsoft.com/dotnet/api/system.int32)): Left hand side argument of the matrix multiply.**** (\[int]\(https\://learn.microsoft.com/dotnet/api/system.int32)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                       | Description                         |
| ---------------------------------------------------------- | ----------------------------------- |
| [int](https://learn.microsoft.com/dotnet/api/system.int32) | The computed matrix multiplication. |

## mul(int2, int2)

Returns the int value result of a matrix multiplication between an int2 row vector and an int2 column vector.

```csharp
public static int mul(int2 a, int2 b)
```

### Parameters

**** (\[int2]\(/engine/7000.0/script-reference/unity/mathematics/int2)): Left hand side argument of the matrix multiply.**** (\[int2]\(/engine/7000.0/script-reference/unity/mathematics/int2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                       | Description                         |
| ---------------------------------------------------------- | ----------------------------------- |
| [int](https://learn.microsoft.com/dotnet/api/system.int32) | The computed matrix multiplication. |

## mul(int2, int2x2)

Returns the int2 row vector result of a matrix multiplication between an int2 row vector and an int2x2 matrix.

```csharp
public static int2 mul(int2 a, int2x2 b)
```

### Parameters

**** (\[int2]\(/engine/7000.0/script-reference/unity/mathematics/int2)): Left hand side argument of the matrix multiply.**** (\[int2x2]\(/engine/7000.0/script-reference/unity/mathematics/int2x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                              | Description                         |
| ----------------------------------------------------------------- | ----------------------------------- |
| [int2](/engine/7000.0/script-reference/unity/mathematics/int2.md) | The computed matrix multiplication. |

## mul(int2, int2x3)

Returns the int3 row vector result of a matrix multiplication between an int2 row vector and an int2x3 matrix.

```csharp
public static int3 mul(int2 a, int2x3 b)
```

### Parameters

**** (\[int2]\(/engine/7000.0/script-reference/unity/mathematics/int2)): Left hand side argument of the matrix multiply.**** (\[int2x3]\(/engine/7000.0/script-reference/unity/mathematics/int2x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                              | Description                         |
| ----------------------------------------------------------------- | ----------------------------------- |
| [int3](/engine/7000.0/script-reference/unity/mathematics/int3.md) | The computed matrix multiplication. |

## mul(int2, int2x4)

Returns the int4 row vector result of a matrix multiplication between an int2 row vector and an int2x4 matrix.

```csharp
public static int4 mul(int2 a, int2x4 b)
```

### Parameters

**** (\[int2]\(/engine/7000.0/script-reference/unity/mathematics/int2)): Left hand side argument of the matrix multiply.**** (\[int2x4]\(/engine/7000.0/script-reference/unity/mathematics/int2x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                              | Description                         |
| ----------------------------------------------------------------- | ----------------------------------- |
| [int4](/engine/7000.0/script-reference/unity/mathematics/int4.md) | The computed matrix multiplication. |

## mul(int3, int3)

Returns the int value result of a matrix multiplication between an int3 row vector and an int3 column vector.

```csharp
public static int mul(int3 a, int3 b)
```

### Parameters

**** (\[int3]\(/engine/7000.0/script-reference/unity/mathematics/int3)): Left hand side argument of the matrix multiply.**** (\[int3]\(/engine/7000.0/script-reference/unity/mathematics/int3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                       | Description                         |
| ---------------------------------------------------------- | ----------------------------------- |
| [int](https://learn.microsoft.com/dotnet/api/system.int32) | The computed matrix multiplication. |

## mul(int3, int3x2)

Returns the int2 row vector result of a matrix multiplication between an int3 row vector and an int3x2 matrix.

```csharp
public static int2 mul(int3 a, int3x2 b)
```

### Parameters

**** (\[int3]\(/engine/7000.0/script-reference/unity/mathematics/int3)): Left hand side argument of the matrix multiply.**** (\[int3x2]\(/engine/7000.0/script-reference/unity/mathematics/int3x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                              | Description                         |
| ----------------------------------------------------------------- | ----------------------------------- |
| [int2](/engine/7000.0/script-reference/unity/mathematics/int2.md) | The computed matrix multiplication. |

## mul(int3, int3x3)

Returns the int3 row vector result of a matrix multiplication between an int3 row vector and an int3x3 matrix.

```csharp
public static int3 mul(int3 a, int3x3 b)
```

### Parameters

**** (\[int3]\(/engine/7000.0/script-reference/unity/mathematics/int3)): Left hand side argument of the matrix multiply.**** (\[int3x3]\(/engine/7000.0/script-reference/unity/mathematics/int3x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                              | Description                         |
| ----------------------------------------------------------------- | ----------------------------------- |
| [int3](/engine/7000.0/script-reference/unity/mathematics/int3.md) | The computed matrix multiplication. |

## mul(int3, int3x4)

Returns the int4 row vector result of a matrix multiplication between an int3 row vector and an int3x4 matrix.

```csharp
public static int4 mul(int3 a, int3x4 b)
```

### Parameters

**** (\[int3]\(/engine/7000.0/script-reference/unity/mathematics/int3)): Left hand side argument of the matrix multiply.**** (\[int3x4]\(/engine/7000.0/script-reference/unity/mathematics/int3x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                              | Description                         |
| ----------------------------------------------------------------- | ----------------------------------- |
| [int4](/engine/7000.0/script-reference/unity/mathematics/int4.md) | The computed matrix multiplication. |

## mul(int4, int4)

Returns the int value result of a matrix multiplication between an int4 row vector and an int4 column vector.

```csharp
public static int mul(int4 a, int4 b)
```

### Parameters

**** (\[int4]\(/engine/7000.0/script-reference/unity/mathematics/int4)): Left hand side argument of the matrix multiply.**** (\[int4]\(/engine/7000.0/script-reference/unity/mathematics/int4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                       | Description                         |
| ---------------------------------------------------------- | ----------------------------------- |
| [int](https://learn.microsoft.com/dotnet/api/system.int32) | The computed matrix multiplication. |

## mul(int4, int4x2)

Returns the int2 row vector result of a matrix multiplication between an int4 row vector and an int4x2 matrix.

```csharp
public static int2 mul(int4 a, int4x2 b)
```

### Parameters

**** (\[int4]\(/engine/7000.0/script-reference/unity/mathematics/int4)): Left hand side argument of the matrix multiply.**** (\[int4x2]\(/engine/7000.0/script-reference/unity/mathematics/int4x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                              | Description                         |
| ----------------------------------------------------------------- | ----------------------------------- |
| [int2](/engine/7000.0/script-reference/unity/mathematics/int2.md) | The computed matrix multiplication. |

## mul(int4, int4x3)

Returns the int3 row vector result of a matrix multiplication between an int4 row vector and an int4x3 matrix.

```csharp
public static int3 mul(int4 a, int4x3 b)
```

### Parameters

**** (\[int4]\(/engine/7000.0/script-reference/unity/mathematics/int4)): Left hand side argument of the matrix multiply.**** (\[int4x3]\(/engine/7000.0/script-reference/unity/mathematics/int4x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                              | Description                         |
| ----------------------------------------------------------------- | ----------------------------------- |
| [int3](/engine/7000.0/script-reference/unity/mathematics/int3.md) | The computed matrix multiplication. |

## mul(int4, int4x4)

Returns the int4 row vector result of a matrix multiplication between an int4 row vector and an int4x4 matrix.

```csharp
public static int4 mul(int4 a, int4x4 b)
```

### Parameters

**** (\[int4]\(/engine/7000.0/script-reference/unity/mathematics/int4)): Left hand side argument of the matrix multiply.**** (\[int4x4]\(/engine/7000.0/script-reference/unity/mathematics/int4x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                              | Description                         |
| ----------------------------------------------------------------- | ----------------------------------- |
| [int4](/engine/7000.0/script-reference/unity/mathematics/int4.md) | The computed matrix multiplication. |

## mul(int2x2, int2)

Returns the int2 column vector result of a matrix multiplication between an int2x2 matrix and an int2 column vector.

```csharp
public static int2 mul(int2x2 a, int2 b)
```

### Parameters

**** (\[int2x2]\(/engine/7000.0/script-reference/unity/mathematics/int2x2)): Left hand side argument of the matrix multiply.**** (\[int2]\(/engine/7000.0/script-reference/unity/mathematics/int2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                              | Description                         |
| ----------------------------------------------------------------- | ----------------------------------- |
| [int2](/engine/7000.0/script-reference/unity/mathematics/int2.md) | The computed matrix multiplication. |

## mul(int2x2, int2x2)

Returns the int2x2 matrix result of a matrix multiplication between an int2x2 matrix and an int2x2 matrix.

```csharp
public static int2x2 mul(int2x2 a, int2x2 b)
```

### Parameters

**** (\[int2x2]\(/engine/7000.0/script-reference/unity/mathematics/int2x2)): Left hand side argument of the matrix multiply.**** (\[int2x2]\(/engine/7000.0/script-reference/unity/mathematics/int2x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [int2x2](/engine/7000.0/script-reference/unity/mathematics/int2x2.md) | The computed matrix multiplication. |

## mul(int2x2, int2x3)

Returns the int2x3 matrix result of a matrix multiplication between an int2x2 matrix and an int2x3 matrix.

```csharp
public static int2x3 mul(int2x2 a, int2x3 b)
```

### Parameters

**** (\[int2x2]\(/engine/7000.0/script-reference/unity/mathematics/int2x2)): Left hand side argument of the matrix multiply.**** (\[int2x3]\(/engine/7000.0/script-reference/unity/mathematics/int2x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [int2x3](/engine/7000.0/script-reference/unity/mathematics/int2x3.md) | The computed matrix multiplication. |

## mul(int2x2, int2x4)

Returns the int2x4 matrix result of a matrix multiplication between an int2x2 matrix and an int2x4 matrix.

```csharp
public static int2x4 mul(int2x2 a, int2x4 b)
```

### Parameters

**** (\[int2x2]\(/engine/7000.0/script-reference/unity/mathematics/int2x2)): Left hand side argument of the matrix multiply.**** (\[int2x4]\(/engine/7000.0/script-reference/unity/mathematics/int2x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [int2x4](/engine/7000.0/script-reference/unity/mathematics/int2x4.md) | The computed matrix multiplication. |

## mul(int2x3, int3)

Returns the int2 column vector result of a matrix multiplication between an int2x3 matrix and an int3 column vector.

```csharp
public static int2 mul(int2x3 a, int3 b)
```

### Parameters

**** (\[int2x3]\(/engine/7000.0/script-reference/unity/mathematics/int2x3)): Left hand side argument of the matrix multiply.**** (\[int3]\(/engine/7000.0/script-reference/unity/mathematics/int3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                              | Description                         |
| ----------------------------------------------------------------- | ----------------------------------- |
| [int2](/engine/7000.0/script-reference/unity/mathematics/int2.md) | The computed matrix multiplication. |

## mul(int2x3, int3x2)

Returns the int2x2 matrix result of a matrix multiplication between an int2x3 matrix and an int3x2 matrix.

```csharp
public static int2x2 mul(int2x3 a, int3x2 b)
```

### Parameters

**** (\[int2x3]\(/engine/7000.0/script-reference/unity/mathematics/int2x3)): Left hand side argument of the matrix multiply.**** (\[int3x2]\(/engine/7000.0/script-reference/unity/mathematics/int3x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [int2x2](/engine/7000.0/script-reference/unity/mathematics/int2x2.md) | The computed matrix multiplication. |

## mul(int2x3, int3x3)

Returns the int2x3 matrix result of a matrix multiplication between an int2x3 matrix and an int3x3 matrix.

```csharp
public static int2x3 mul(int2x3 a, int3x3 b)
```

### Parameters

**** (\[int2x3]\(/engine/7000.0/script-reference/unity/mathematics/int2x3)): Left hand side argument of the matrix multiply.**** (\[int3x3]\(/engine/7000.0/script-reference/unity/mathematics/int3x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [int2x3](/engine/7000.0/script-reference/unity/mathematics/int2x3.md) | The computed matrix multiplication. |

## mul(int2x3, int3x4)

Returns the int2x4 matrix result of a matrix multiplication between an int2x3 matrix and an int3x4 matrix.

```csharp
public static int2x4 mul(int2x3 a, int3x4 b)
```

### Parameters

**** (\[int2x3]\(/engine/7000.0/script-reference/unity/mathematics/int2x3)): Left hand side argument of the matrix multiply.**** (\[int3x4]\(/engine/7000.0/script-reference/unity/mathematics/int3x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [int2x4](/engine/7000.0/script-reference/unity/mathematics/int2x4.md) | The computed matrix multiplication. |

## mul(int2x4, int4)

Returns the int2 column vector result of a matrix multiplication between an int2x4 matrix and an int4 column vector.

```csharp
public static int2 mul(int2x4 a, int4 b)
```

### Parameters

**** (\[int2x4]\(/engine/7000.0/script-reference/unity/mathematics/int2x4)): Left hand side argument of the matrix multiply.**** (\[int4]\(/engine/7000.0/script-reference/unity/mathematics/int4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                              | Description                         |
| ----------------------------------------------------------------- | ----------------------------------- |
| [int2](/engine/7000.0/script-reference/unity/mathematics/int2.md) | The computed matrix multiplication. |

## mul(int2x4, int4x2)

Returns the int2x2 matrix result of a matrix multiplication between an int2x4 matrix and an int4x2 matrix.

```csharp
public static int2x2 mul(int2x4 a, int4x2 b)
```

### Parameters

**** (\[int2x4]\(/engine/7000.0/script-reference/unity/mathematics/int2x4)): Left hand side argument of the matrix multiply.**** (\[int4x2]\(/engine/7000.0/script-reference/unity/mathematics/int4x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [int2x2](/engine/7000.0/script-reference/unity/mathematics/int2x2.md) | The computed matrix multiplication. |

## mul(int2x4, int4x3)

Returns the int2x3 matrix result of a matrix multiplication between an int2x4 matrix and an int4x3 matrix.

```csharp
public static int2x3 mul(int2x4 a, int4x3 b)
```

### Parameters

**** (\[int2x4]\(/engine/7000.0/script-reference/unity/mathematics/int2x4)): Left hand side argument of the matrix multiply.**** (\[int4x3]\(/engine/7000.0/script-reference/unity/mathematics/int4x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [int2x3](/engine/7000.0/script-reference/unity/mathematics/int2x3.md) | The computed matrix multiplication. |

## mul(int2x4, int4x4)

Returns the int2x4 matrix result of a matrix multiplication between an int2x4 matrix and an int4x4 matrix.

```csharp
public static int2x4 mul(int2x4 a, int4x4 b)
```

### Parameters

**** (\[int2x4]\(/engine/7000.0/script-reference/unity/mathematics/int2x4)): Left hand side argument of the matrix multiply.**** (\[int4x4]\(/engine/7000.0/script-reference/unity/mathematics/int4x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [int2x4](/engine/7000.0/script-reference/unity/mathematics/int2x4.md) | The computed matrix multiplication. |

## mul(int3x2, int2)

Returns the int3 column vector result of a matrix multiplication between an int3x2 matrix and an int2 column vector.

```csharp
public static int3 mul(int3x2 a, int2 b)
```

### Parameters

**** (\[int3x2]\(/engine/7000.0/script-reference/unity/mathematics/int3x2)): Left hand side argument of the matrix multiply.**** (\[int2]\(/engine/7000.0/script-reference/unity/mathematics/int2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                              | Description                         |
| ----------------------------------------------------------------- | ----------------------------------- |
| [int3](/engine/7000.0/script-reference/unity/mathematics/int3.md) | The computed matrix multiplication. |

## mul(int3x2, int2x2)

Returns the int3x2 matrix result of a matrix multiplication between an int3x2 matrix and an int2x2 matrix.

```csharp
public static int3x2 mul(int3x2 a, int2x2 b)
```

### Parameters

**** (\[int3x2]\(/engine/7000.0/script-reference/unity/mathematics/int3x2)): Left hand side argument of the matrix multiply.**** (\[int2x2]\(/engine/7000.0/script-reference/unity/mathematics/int2x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [int3x2](/engine/7000.0/script-reference/unity/mathematics/int3x2.md) | The computed matrix multiplication. |

## mul(int3x2, int2x3)

Returns the int3x3 matrix result of a matrix multiplication between an int3x2 matrix and an int2x3 matrix.

```csharp
public static int3x3 mul(int3x2 a, int2x3 b)
```

### Parameters

**** (\[int3x2]\(/engine/7000.0/script-reference/unity/mathematics/int3x2)): Left hand side argument of the matrix multiply.**** (\[int2x3]\(/engine/7000.0/script-reference/unity/mathematics/int2x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [int3x3](/engine/7000.0/script-reference/unity/mathematics/int3x3.md) | The computed matrix multiplication. |

## mul(int3x2, int2x4)

Returns the int3x4 matrix result of a matrix multiplication between an int3x2 matrix and an int2x4 matrix.

```csharp
public static int3x4 mul(int3x2 a, int2x4 b)
```

### Parameters

**** (\[int3x2]\(/engine/7000.0/script-reference/unity/mathematics/int3x2)): Left hand side argument of the matrix multiply.**** (\[int2x4]\(/engine/7000.0/script-reference/unity/mathematics/int2x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [int3x4](/engine/7000.0/script-reference/unity/mathematics/int3x4.md) | The computed matrix multiplication. |

## mul(int3x3, int3)

Returns the int3 column vector result of a matrix multiplication between an int3x3 matrix and an int3 column vector.

```csharp
public static int3 mul(int3x3 a, int3 b)
```

### Parameters

**** (\[int3x3]\(/engine/7000.0/script-reference/unity/mathematics/int3x3)): Left hand side argument of the matrix multiply.**** (\[int3]\(/engine/7000.0/script-reference/unity/mathematics/int3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                              | Description                         |
| ----------------------------------------------------------------- | ----------------------------------- |
| [int3](/engine/7000.0/script-reference/unity/mathematics/int3.md) | The computed matrix multiplication. |

## mul(int3x3, int3x2)

Returns the int3x2 matrix result of a matrix multiplication between an int3x3 matrix and an int3x2 matrix.

```csharp
public static int3x2 mul(int3x3 a, int3x2 b)
```

### Parameters

**** (\[int3x3]\(/engine/7000.0/script-reference/unity/mathematics/int3x3)): Left hand side argument of the matrix multiply.**** (\[int3x2]\(/engine/7000.0/script-reference/unity/mathematics/int3x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [int3x2](/engine/7000.0/script-reference/unity/mathematics/int3x2.md) | The computed matrix multiplication. |

## mul(int3x3, int3x3)

Returns the int3x3 matrix result of a matrix multiplication between an int3x3 matrix and an int3x3 matrix.

```csharp
public static int3x3 mul(int3x3 a, int3x3 b)
```

### Parameters

**** (\[int3x3]\(/engine/7000.0/script-reference/unity/mathematics/int3x3)): Left hand side argument of the matrix multiply.**** (\[int3x3]\(/engine/7000.0/script-reference/unity/mathematics/int3x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [int3x3](/engine/7000.0/script-reference/unity/mathematics/int3x3.md) | The computed matrix multiplication. |

## mul(int3x3, int3x4)

Returns the int3x4 matrix result of a matrix multiplication between an int3x3 matrix and an int3x4 matrix.

```csharp
public static int3x4 mul(int3x3 a, int3x4 b)
```

### Parameters

**** (\[int3x3]\(/engine/7000.0/script-reference/unity/mathematics/int3x3)): Left hand side argument of the matrix multiply.**** (\[int3x4]\(/engine/7000.0/script-reference/unity/mathematics/int3x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [int3x4](/engine/7000.0/script-reference/unity/mathematics/int3x4.md) | The computed matrix multiplication. |

## mul(int3x4, int4)

Returns the int3 column vector result of a matrix multiplication between an int3x4 matrix and an int4 column vector.

```csharp
public static int3 mul(int3x4 a, int4 b)
```

### Parameters

**** (\[int3x4]\(/engine/7000.0/script-reference/unity/mathematics/int3x4)): Left hand side argument of the matrix multiply.**** (\[int4]\(/engine/7000.0/script-reference/unity/mathematics/int4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                              | Description                         |
| ----------------------------------------------------------------- | ----------------------------------- |
| [int3](/engine/7000.0/script-reference/unity/mathematics/int3.md) | The computed matrix multiplication. |

## mul(int3x4, int4x2)

Returns the int3x2 matrix result of a matrix multiplication between an int3x4 matrix and an int4x2 matrix.

```csharp
public static int3x2 mul(int3x4 a, int4x2 b)
```

### Parameters

**** (\[int3x4]\(/engine/7000.0/script-reference/unity/mathematics/int3x4)): Left hand side argument of the matrix multiply.**** (\[int4x2]\(/engine/7000.0/script-reference/unity/mathematics/int4x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [int3x2](/engine/7000.0/script-reference/unity/mathematics/int3x2.md) | The computed matrix multiplication. |

## mul(int3x4, int4x3)

Returns the int3x3 matrix result of a matrix multiplication between an int3x4 matrix and an int4x3 matrix.

```csharp
public static int3x3 mul(int3x4 a, int4x3 b)
```

### Parameters

**** (\[int3x4]\(/engine/7000.0/script-reference/unity/mathematics/int3x4)): Left hand side argument of the matrix multiply.**** (\[int4x3]\(/engine/7000.0/script-reference/unity/mathematics/int4x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [int3x3](/engine/7000.0/script-reference/unity/mathematics/int3x3.md) | The computed matrix multiplication. |

## mul(int3x4, int4x4)

Returns the int3x4 matrix result of a matrix multiplication between an int3x4 matrix and an int4x4 matrix.

```csharp
public static int3x4 mul(int3x4 a, int4x4 b)
```

### Parameters

**** (\[int3x4]\(/engine/7000.0/script-reference/unity/mathematics/int3x4)): Left hand side argument of the matrix multiply.**** (\[int4x4]\(/engine/7000.0/script-reference/unity/mathematics/int4x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [int3x4](/engine/7000.0/script-reference/unity/mathematics/int3x4.md) | The computed matrix multiplication. |

## mul(int4x2, int2)

Returns the int4 column vector result of a matrix multiplication between an int4x2 matrix and an int2 column vector.

```csharp
public static int4 mul(int4x2 a, int2 b)
```

### Parameters

**** (\[int4x2]\(/engine/7000.0/script-reference/unity/mathematics/int4x2)): Left hand side argument of the matrix multiply.**** (\[int2]\(/engine/7000.0/script-reference/unity/mathematics/int2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                              | Description                         |
| ----------------------------------------------------------------- | ----------------------------------- |
| [int4](/engine/7000.0/script-reference/unity/mathematics/int4.md) | The computed matrix multiplication. |

## mul(int4x2, int2x2)

Returns the int4x2 matrix result of a matrix multiplication between an int4x2 matrix and an int2x2 matrix.

```csharp
public static int4x2 mul(int4x2 a, int2x2 b)
```

### Parameters

**** (\[int4x2]\(/engine/7000.0/script-reference/unity/mathematics/int4x2)): Left hand side argument of the matrix multiply.**** (\[int2x2]\(/engine/7000.0/script-reference/unity/mathematics/int2x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [int4x2](/engine/7000.0/script-reference/unity/mathematics/int4x2.md) | The computed matrix multiplication. |

## mul(int4x2, int2x3)

Returns the int4x3 matrix result of a matrix multiplication between an int4x2 matrix and an int2x3 matrix.

```csharp
public static int4x3 mul(int4x2 a, int2x3 b)
```

### Parameters

**** (\[int4x2]\(/engine/7000.0/script-reference/unity/mathematics/int4x2)): Left hand side argument of the matrix multiply.**** (\[int2x3]\(/engine/7000.0/script-reference/unity/mathematics/int2x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [int4x3](/engine/7000.0/script-reference/unity/mathematics/int4x3.md) | The computed matrix multiplication. |

## mul(int4x2, int2x4)

Returns the int4x4 matrix result of a matrix multiplication between an int4x2 matrix and an int2x4 matrix.

```csharp
public static int4x4 mul(int4x2 a, int2x4 b)
```

### Parameters

**** (\[int4x2]\(/engine/7000.0/script-reference/unity/mathematics/int4x2)): Left hand side argument of the matrix multiply.**** (\[int2x4]\(/engine/7000.0/script-reference/unity/mathematics/int2x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [int4x4](/engine/7000.0/script-reference/unity/mathematics/int4x4.md) | The computed matrix multiplication. |

## mul(int4x3, int3)

Returns the int4 column vector result of a matrix multiplication between an int4x3 matrix and an int3 column vector.

```csharp
public static int4 mul(int4x3 a, int3 b)
```

### Parameters

**** (\[int4x3]\(/engine/7000.0/script-reference/unity/mathematics/int4x3)): Left hand side argument of the matrix multiply.**** (\[int3]\(/engine/7000.0/script-reference/unity/mathematics/int3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                              | Description                         |
| ----------------------------------------------------------------- | ----------------------------------- |
| [int4](/engine/7000.0/script-reference/unity/mathematics/int4.md) | The computed matrix multiplication. |

## mul(int4x3, int3x2)

Returns the int4x2 matrix result of a matrix multiplication between an int4x3 matrix and an int3x2 matrix.

```csharp
public static int4x2 mul(int4x3 a, int3x2 b)
```

### Parameters

**** (\[int4x3]\(/engine/7000.0/script-reference/unity/mathematics/int4x3)): Left hand side argument of the matrix multiply.**** (\[int3x2]\(/engine/7000.0/script-reference/unity/mathematics/int3x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [int4x2](/engine/7000.0/script-reference/unity/mathematics/int4x2.md) | The computed matrix multiplication. |

## mul(int4x3, int3x3)

Returns the int4x3 matrix result of a matrix multiplication between an int4x3 matrix and an int3x3 matrix.

```csharp
public static int4x3 mul(int4x3 a, int3x3 b)
```

### Parameters

**** (\[int4x3]\(/engine/7000.0/script-reference/unity/mathematics/int4x3)): Left hand side argument of the matrix multiply.**** (\[int3x3]\(/engine/7000.0/script-reference/unity/mathematics/int3x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [int4x3](/engine/7000.0/script-reference/unity/mathematics/int4x3.md) | The computed matrix multiplication. |

## mul(int4x3, int3x4)

Returns the int4x4 matrix result of a matrix multiplication between an int4x3 matrix and an int3x4 matrix.

```csharp
public static int4x4 mul(int4x3 a, int3x4 b)
```

### Parameters

**** (\[int4x3]\(/engine/7000.0/script-reference/unity/mathematics/int4x3)): Left hand side argument of the matrix multiply.**** (\[int3x4]\(/engine/7000.0/script-reference/unity/mathematics/int3x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [int4x4](/engine/7000.0/script-reference/unity/mathematics/int4x4.md) | The computed matrix multiplication. |

## mul(int4x4, int4)

Returns the int4 column vector result of a matrix multiplication between an int4x4 matrix and an int4 column vector.

```csharp
public static int4 mul(int4x4 a, int4 b)
```

### Parameters

**** (\[int4x4]\(/engine/7000.0/script-reference/unity/mathematics/int4x4)): Left hand side argument of the matrix multiply.**** (\[int4]\(/engine/7000.0/script-reference/unity/mathematics/int4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                              | Description                         |
| ----------------------------------------------------------------- | ----------------------------------- |
| [int4](/engine/7000.0/script-reference/unity/mathematics/int4.md) | The computed matrix multiplication. |

## mul(int4x4, int4x2)

Returns the int4x2 matrix result of a matrix multiplication between an int4x4 matrix and an int4x2 matrix.

```csharp
public static int4x2 mul(int4x4 a, int4x2 b)
```

### Parameters

**** (\[int4x4]\(/engine/7000.0/script-reference/unity/mathematics/int4x4)): Left hand side argument of the matrix multiply.**** (\[int4x2]\(/engine/7000.0/script-reference/unity/mathematics/int4x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [int4x2](/engine/7000.0/script-reference/unity/mathematics/int4x2.md) | The computed matrix multiplication. |

## mul(int4x4, int4x3)

Returns the int4x3 matrix result of a matrix multiplication between an int4x4 matrix and an int4x3 matrix.

```csharp
public static int4x3 mul(int4x4 a, int4x3 b)
```

### Parameters

**** (\[int4x4]\(/engine/7000.0/script-reference/unity/mathematics/int4x4)): Left hand side argument of the matrix multiply.**** (\[int4x3]\(/engine/7000.0/script-reference/unity/mathematics/int4x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [int4x3](/engine/7000.0/script-reference/unity/mathematics/int4x3.md) | The computed matrix multiplication. |

## mul(int4x4, int4x4)

Returns the int4x4 matrix result of a matrix multiplication between an int4x4 matrix and an int4x4 matrix.

```csharp
public static int4x4 mul(int4x4 a, int4x4 b)
```

### Parameters

**** (\[int4x4]\(/engine/7000.0/script-reference/unity/mathematics/int4x4)): Left hand side argument of the matrix multiply.**** (\[int4x4]\(/engine/7000.0/script-reference/unity/mathematics/int4x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                  | Description                         |
| --------------------------------------------------------------------- | ----------------------------------- |
| [int4x4](/engine/7000.0/script-reference/unity/mathematics/int4x4.md) | The computed matrix multiplication. |

## mul(uint, uint)

Returns the uint value result of a matrix multiplication between a uint value and a uint value.

```csharp
public static uint mul(uint a, uint b)
```

### Parameters

**** (\[uint]\(https\://learn.microsoft.com/dotnet/api/system.uint32)): Left hand side argument of the matrix multiply.**** (\[uint]\(https\://learn.microsoft.com/dotnet/api/system.uint32)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                         | Description                         |
| ------------------------------------------------------------ | ----------------------------------- |
| [uint](https://learn.microsoft.com/dotnet/api/system.uint32) | The computed matrix multiplication. |

## mul(uint2, uint2)

Returns the uint value result of a matrix multiplication between a uint2 row vector and a uint2 column vector.

```csharp
public static uint mul(uint2 a, uint2 b)
```

### Parameters

**** (\[uint2]\(/engine/7000.0/script-reference/unity/mathematics/uint2)): Left hand side argument of the matrix multiply.**** (\[uint2]\(/engine/7000.0/script-reference/unity/mathematics/uint2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                         | Description                         |
| ------------------------------------------------------------ | ----------------------------------- |
| [uint](https://learn.microsoft.com/dotnet/api/system.uint32) | The computed matrix multiplication. |

## mul(uint2, uint2x2)

Returns the uint2 row vector result of a matrix multiplication between a uint2 row vector and a uint2x2 matrix.

```csharp
public static uint2 mul(uint2 a, uint2x2 b)
```

### Parameters

**** (\[uint2]\(/engine/7000.0/script-reference/unity/mathematics/uint2)): Left hand side argument of the matrix multiply.**** (\[uint2x2]\(/engine/7000.0/script-reference/unity/mathematics/uint2x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                | Description                         |
| ------------------------------------------------------------------- | ----------------------------------- |
| [uint2](/engine/7000.0/script-reference/unity/mathematics/uint2.md) | The computed matrix multiplication. |

## mul(uint2, uint2x3)

Returns the uint3 row vector result of a matrix multiplication between a uint2 row vector and a uint2x3 matrix.

```csharp
public static uint3 mul(uint2 a, uint2x3 b)
```

### Parameters

**** (\[uint2]\(/engine/7000.0/script-reference/unity/mathematics/uint2)): Left hand side argument of the matrix multiply.**** (\[uint2x3]\(/engine/7000.0/script-reference/unity/mathematics/uint2x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                | Description                         |
| ------------------------------------------------------------------- | ----------------------------------- |
| [uint3](/engine/7000.0/script-reference/unity/mathematics/uint3.md) | The computed matrix multiplication. |

## mul(uint2, uint2x4)

Returns the uint4 row vector result of a matrix multiplication between a uint2 row vector and a uint2x4 matrix.

```csharp
public static uint4 mul(uint2 a, uint2x4 b)
```

### Parameters

**** (\[uint2]\(/engine/7000.0/script-reference/unity/mathematics/uint2)): Left hand side argument of the matrix multiply.**** (\[uint2x4]\(/engine/7000.0/script-reference/unity/mathematics/uint2x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                | Description                         |
| ------------------------------------------------------------------- | ----------------------------------- |
| [uint4](/engine/7000.0/script-reference/unity/mathematics/uint4.md) | The computed matrix multiplication. |

## mul(uint3, uint3)

Returns the uint value result of a matrix multiplication between a uint3 row vector and a uint3 column vector.

```csharp
public static uint mul(uint3 a, uint3 b)
```

### Parameters

**** (\[uint3]\(/engine/7000.0/script-reference/unity/mathematics/uint3)): Left hand side argument of the matrix multiply.**** (\[uint3]\(/engine/7000.0/script-reference/unity/mathematics/uint3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                         | Description                         |
| ------------------------------------------------------------ | ----------------------------------- |
| [uint](https://learn.microsoft.com/dotnet/api/system.uint32) | The computed matrix multiplication. |

## mul(uint3, uint3x2)

Returns the uint2 row vector result of a matrix multiplication between a uint3 row vector and a uint3x2 matrix.

```csharp
public static uint2 mul(uint3 a, uint3x2 b)
```

### Parameters

**** (\[uint3]\(/engine/7000.0/script-reference/unity/mathematics/uint3)): Left hand side argument of the matrix multiply.**** (\[uint3x2]\(/engine/7000.0/script-reference/unity/mathematics/uint3x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                | Description                         |
| ------------------------------------------------------------------- | ----------------------------------- |
| [uint2](/engine/7000.0/script-reference/unity/mathematics/uint2.md) | The computed matrix multiplication. |

## mul(uint3, uint3x3)

Returns the uint3 row vector result of a matrix multiplication between a uint3 row vector and a uint3x3 matrix.

```csharp
public static uint3 mul(uint3 a, uint3x3 b)
```

### Parameters

**** (\[uint3]\(/engine/7000.0/script-reference/unity/mathematics/uint3)): Left hand side argument of the matrix multiply.**** (\[uint3x3]\(/engine/7000.0/script-reference/unity/mathematics/uint3x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                | Description                         |
| ------------------------------------------------------------------- | ----------------------------------- |
| [uint3](/engine/7000.0/script-reference/unity/mathematics/uint3.md) | The computed matrix multiplication. |

## mul(uint3, uint3x4)

Returns the uint4 row vector result of a matrix multiplication between a uint3 row vector and a uint3x4 matrix.

```csharp
public static uint4 mul(uint3 a, uint3x4 b)
```

### Parameters

**** (\[uint3]\(/engine/7000.0/script-reference/unity/mathematics/uint3)): Left hand side argument of the matrix multiply.**** (\[uint3x4]\(/engine/7000.0/script-reference/unity/mathematics/uint3x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                | Description                         |
| ------------------------------------------------------------------- | ----------------------------------- |
| [uint4](/engine/7000.0/script-reference/unity/mathematics/uint4.md) | The computed matrix multiplication. |

## mul(uint4, uint4)

Returns the uint value result of a matrix multiplication between a uint4 row vector and a uint4 column vector.

```csharp
public static uint mul(uint4 a, uint4 b)
```

### Parameters

**** (\[uint4]\(/engine/7000.0/script-reference/unity/mathematics/uint4)): Left hand side argument of the matrix multiply.**** (\[uint4]\(/engine/7000.0/script-reference/unity/mathematics/uint4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                         | Description                         |
| ------------------------------------------------------------ | ----------------------------------- |
| [uint](https://learn.microsoft.com/dotnet/api/system.uint32) | The computed matrix multiplication. |

## mul(uint4, uint4x2)

Returns the uint2 row vector result of a matrix multiplication between a uint4 row vector and a uint4x2 matrix.

```csharp
public static uint2 mul(uint4 a, uint4x2 b)
```

### Parameters

**** (\[uint4]\(/engine/7000.0/script-reference/unity/mathematics/uint4)): Left hand side argument of the matrix multiply.**** (\[uint4x2]\(/engine/7000.0/script-reference/unity/mathematics/uint4x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                | Description                         |
| ------------------------------------------------------------------- | ----------------------------------- |
| [uint2](/engine/7000.0/script-reference/unity/mathematics/uint2.md) | The computed matrix multiplication. |

## mul(uint4, uint4x3)

Returns the uint3 row vector result of a matrix multiplication between a uint4 row vector and a uint4x3 matrix.

```csharp
public static uint3 mul(uint4 a, uint4x3 b)
```

### Parameters

**** (\[uint4]\(/engine/7000.0/script-reference/unity/mathematics/uint4)): Left hand side argument of the matrix multiply.**** (\[uint4x3]\(/engine/7000.0/script-reference/unity/mathematics/uint4x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                | Description                         |
| ------------------------------------------------------------------- | ----------------------------------- |
| [uint3](/engine/7000.0/script-reference/unity/mathematics/uint3.md) | The computed matrix multiplication. |

## mul(uint4, uint4x4)

Returns the uint4 row vector result of a matrix multiplication between a uint4 row vector and a uint4x4 matrix.

```csharp
public static uint4 mul(uint4 a, uint4x4 b)
```

### Parameters

**** (\[uint4]\(/engine/7000.0/script-reference/unity/mathematics/uint4)): Left hand side argument of the matrix multiply.**** (\[uint4x4]\(/engine/7000.0/script-reference/unity/mathematics/uint4x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                | Description                         |
| ------------------------------------------------------------------- | ----------------------------------- |
| [uint4](/engine/7000.0/script-reference/unity/mathematics/uint4.md) | The computed matrix multiplication. |

## mul(uint2x2, uint2)

Returns the uint2 column vector result of a matrix multiplication between a uint2x2 matrix and a uint2 column vector.

```csharp
public static uint2 mul(uint2x2 a, uint2 b)
```

### Parameters

**** (\[uint2x2]\(/engine/7000.0/script-reference/unity/mathematics/uint2x2)): Left hand side argument of the matrix multiply.**** (\[uint2]\(/engine/7000.0/script-reference/unity/mathematics/uint2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                | Description                         |
| ------------------------------------------------------------------- | ----------------------------------- |
| [uint2](/engine/7000.0/script-reference/unity/mathematics/uint2.md) | The computed matrix multiplication. |

## mul(uint2x2, uint2x2)

Returns the uint2x2 matrix result of a matrix multiplication between a uint2x2 matrix and a uint2x2 matrix.

```csharp
public static uint2x2 mul(uint2x2 a, uint2x2 b)
```

### Parameters

**** (\[uint2x2]\(/engine/7000.0/script-reference/unity/mathematics/uint2x2)): Left hand side argument of the matrix multiply.**** (\[uint2x2]\(/engine/7000.0/script-reference/unity/mathematics/uint2x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [uint2x2](/engine/7000.0/script-reference/unity/mathematics/uint2x2.md) | The computed matrix multiplication. |

## mul(uint2x2, uint2x3)

Returns the uint2x3 matrix result of a matrix multiplication between a uint2x2 matrix and a uint2x3 matrix.

```csharp
public static uint2x3 mul(uint2x2 a, uint2x3 b)
```

### Parameters

**** (\[uint2x2]\(/engine/7000.0/script-reference/unity/mathematics/uint2x2)): Left hand side argument of the matrix multiply.**** (\[uint2x3]\(/engine/7000.0/script-reference/unity/mathematics/uint2x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [uint2x3](/engine/7000.0/script-reference/unity/mathematics/uint2x3.md) | The computed matrix multiplication. |

## mul(uint2x2, uint2x4)

Returns the uint2x4 matrix result of a matrix multiplication between a uint2x2 matrix and a uint2x4 matrix.

```csharp
public static uint2x4 mul(uint2x2 a, uint2x4 b)
```

### Parameters

**** (\[uint2x2]\(/engine/7000.0/script-reference/unity/mathematics/uint2x2)): Left hand side argument of the matrix multiply.**** (\[uint2x4]\(/engine/7000.0/script-reference/unity/mathematics/uint2x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [uint2x4](/engine/7000.0/script-reference/unity/mathematics/uint2x4.md) | The computed matrix multiplication. |

## mul(uint2x3, uint3)

Returns the uint2 column vector result of a matrix multiplication between a uint2x3 matrix and a uint3 column vector.

```csharp
public static uint2 mul(uint2x3 a, uint3 b)
```

### Parameters

**** (\[uint2x3]\(/engine/7000.0/script-reference/unity/mathematics/uint2x3)): Left hand side argument of the matrix multiply.**** (\[uint3]\(/engine/7000.0/script-reference/unity/mathematics/uint3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                | Description                         |
| ------------------------------------------------------------------- | ----------------------------------- |
| [uint2](/engine/7000.0/script-reference/unity/mathematics/uint2.md) | The computed matrix multiplication. |

## mul(uint2x3, uint3x2)

Returns the uint2x2 matrix result of a matrix multiplication between a uint2x3 matrix and a uint3x2 matrix.

```csharp
public static uint2x2 mul(uint2x3 a, uint3x2 b)
```

### Parameters

**** (\[uint2x3]\(/engine/7000.0/script-reference/unity/mathematics/uint2x3)): Left hand side argument of the matrix multiply.**** (\[uint3x2]\(/engine/7000.0/script-reference/unity/mathematics/uint3x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [uint2x2](/engine/7000.0/script-reference/unity/mathematics/uint2x2.md) | The computed matrix multiplication. |

## mul(uint2x3, uint3x3)

Returns the uint2x3 matrix result of a matrix multiplication between a uint2x3 matrix and a uint3x3 matrix.

```csharp
public static uint2x3 mul(uint2x3 a, uint3x3 b)
```

### Parameters

**** (\[uint2x3]\(/engine/7000.0/script-reference/unity/mathematics/uint2x3)): Left hand side argument of the matrix multiply.**** (\[uint3x3]\(/engine/7000.0/script-reference/unity/mathematics/uint3x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [uint2x3](/engine/7000.0/script-reference/unity/mathematics/uint2x3.md) | The computed matrix multiplication. |

## mul(uint2x3, uint3x4)

Returns the uint2x4 matrix result of a matrix multiplication between a uint2x3 matrix and a uint3x4 matrix.

```csharp
public static uint2x4 mul(uint2x3 a, uint3x4 b)
```

### Parameters

**** (\[uint2x3]\(/engine/7000.0/script-reference/unity/mathematics/uint2x3)): Left hand side argument of the matrix multiply.**** (\[uint3x4]\(/engine/7000.0/script-reference/unity/mathematics/uint3x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [uint2x4](/engine/7000.0/script-reference/unity/mathematics/uint2x4.md) | The computed matrix multiplication. |

## mul(uint2x4, uint4)

Returns the uint2 column vector result of a matrix multiplication between a uint2x4 matrix and a uint4 column vector.

```csharp
public static uint2 mul(uint2x4 a, uint4 b)
```

### Parameters

**** (\[uint2x4]\(/engine/7000.0/script-reference/unity/mathematics/uint2x4)): Left hand side argument of the matrix multiply.**** (\[uint4]\(/engine/7000.0/script-reference/unity/mathematics/uint4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                | Description                         |
| ------------------------------------------------------------------- | ----------------------------------- |
| [uint2](/engine/7000.0/script-reference/unity/mathematics/uint2.md) | The computed matrix multiplication. |

## mul(uint2x4, uint4x2)

Returns the uint2x2 matrix result of a matrix multiplication between a uint2x4 matrix and a uint4x2 matrix.

```csharp
public static uint2x2 mul(uint2x4 a, uint4x2 b)
```

### Parameters

**** (\[uint2x4]\(/engine/7000.0/script-reference/unity/mathematics/uint2x4)): Left hand side argument of the matrix multiply.**** (\[uint4x2]\(/engine/7000.0/script-reference/unity/mathematics/uint4x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [uint2x2](/engine/7000.0/script-reference/unity/mathematics/uint2x2.md) | The computed matrix multiplication. |

## mul(uint2x4, uint4x3)

Returns the uint2x3 matrix result of a matrix multiplication between a uint2x4 matrix and a uint4x3 matrix.

```csharp
public static uint2x3 mul(uint2x4 a, uint4x3 b)
```

### Parameters

**** (\[uint2x4]\(/engine/7000.0/script-reference/unity/mathematics/uint2x4)): Left hand side argument of the matrix multiply.**** (\[uint4x3]\(/engine/7000.0/script-reference/unity/mathematics/uint4x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [uint2x3](/engine/7000.0/script-reference/unity/mathematics/uint2x3.md) | The computed matrix multiplication. |

## mul(uint2x4, uint4x4)

Returns the uint2x4 matrix result of a matrix multiplication between a uint2x4 matrix and a uint4x4 matrix.

```csharp
public static uint2x4 mul(uint2x4 a, uint4x4 b)
```

### Parameters

**** (\[uint2x4]\(/engine/7000.0/script-reference/unity/mathematics/uint2x4)): Left hand side argument of the matrix multiply.**** (\[uint4x4]\(/engine/7000.0/script-reference/unity/mathematics/uint4x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [uint2x4](/engine/7000.0/script-reference/unity/mathematics/uint2x4.md) | The computed matrix multiplication. |

## mul(uint3x2, uint2)

Returns the uint3 column vector result of a matrix multiplication between a uint3x2 matrix and a uint2 column vector.

```csharp
public static uint3 mul(uint3x2 a, uint2 b)
```

### Parameters

**** (\[uint3x2]\(/engine/7000.0/script-reference/unity/mathematics/uint3x2)): Left hand side argument of the matrix multiply.**** (\[uint2]\(/engine/7000.0/script-reference/unity/mathematics/uint2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                | Description                         |
| ------------------------------------------------------------------- | ----------------------------------- |
| [uint3](/engine/7000.0/script-reference/unity/mathematics/uint3.md) | The computed matrix multiplication. |

## mul(uint3x2, uint2x2)

Returns the uint3x2 matrix result of a matrix multiplication between a uint3x2 matrix and a uint2x2 matrix.

```csharp
public static uint3x2 mul(uint3x2 a, uint2x2 b)
```

### Parameters

**** (\[uint3x2]\(/engine/7000.0/script-reference/unity/mathematics/uint3x2)): Left hand side argument of the matrix multiply.**** (\[uint2x2]\(/engine/7000.0/script-reference/unity/mathematics/uint2x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [uint3x2](/engine/7000.0/script-reference/unity/mathematics/uint3x2.md) | The computed matrix multiplication. |

## mul(uint3x2, uint2x3)

Returns the uint3x3 matrix result of a matrix multiplication between a uint3x2 matrix and a uint2x3 matrix.

```csharp
public static uint3x3 mul(uint3x2 a, uint2x3 b)
```

### Parameters

**** (\[uint3x2]\(/engine/7000.0/script-reference/unity/mathematics/uint3x2)): Left hand side argument of the matrix multiply.**** (\[uint2x3]\(/engine/7000.0/script-reference/unity/mathematics/uint2x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [uint3x3](/engine/7000.0/script-reference/unity/mathematics/uint3x3.md) | The computed matrix multiplication. |

## mul(uint3x2, uint2x4)

Returns the uint3x4 matrix result of a matrix multiplication between a uint3x2 matrix and a uint2x4 matrix.

```csharp
public static uint3x4 mul(uint3x2 a, uint2x4 b)
```

### Parameters

**** (\[uint3x2]\(/engine/7000.0/script-reference/unity/mathematics/uint3x2)): Left hand side argument of the matrix multiply.**** (\[uint2x4]\(/engine/7000.0/script-reference/unity/mathematics/uint2x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [uint3x4](/engine/7000.0/script-reference/unity/mathematics/uint3x4.md) | The computed matrix multiplication. |

## mul(uint3x3, uint3)

Returns the uint3 column vector result of a matrix multiplication between a uint3x3 matrix and a uint3 column vector.

```csharp
public static uint3 mul(uint3x3 a, uint3 b)
```

### Parameters

**** (\[uint3x3]\(/engine/7000.0/script-reference/unity/mathematics/uint3x3)): Left hand side argument of the matrix multiply.**** (\[uint3]\(/engine/7000.0/script-reference/unity/mathematics/uint3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                | Description                         |
| ------------------------------------------------------------------- | ----------------------------------- |
| [uint3](/engine/7000.0/script-reference/unity/mathematics/uint3.md) | The computed matrix multiplication. |

## mul(uint3x3, uint3x2)

Returns the uint3x2 matrix result of a matrix multiplication between a uint3x3 matrix and a uint3x2 matrix.

```csharp
public static uint3x2 mul(uint3x3 a, uint3x2 b)
```

### Parameters

**** (\[uint3x3]\(/engine/7000.0/script-reference/unity/mathematics/uint3x3)): Left hand side argument of the matrix multiply.**** (\[uint3x2]\(/engine/7000.0/script-reference/unity/mathematics/uint3x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [uint3x2](/engine/7000.0/script-reference/unity/mathematics/uint3x2.md) | The computed matrix multiplication. |

## mul(uint3x3, uint3x3)

Returns the uint3x3 matrix result of a matrix multiplication between a uint3x3 matrix and a uint3x3 matrix.

```csharp
public static uint3x3 mul(uint3x3 a, uint3x3 b)
```

### Parameters

**** (\[uint3x3]\(/engine/7000.0/script-reference/unity/mathematics/uint3x3)): Left hand side argument of the matrix multiply.**** (\[uint3x3]\(/engine/7000.0/script-reference/unity/mathematics/uint3x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [uint3x3](/engine/7000.0/script-reference/unity/mathematics/uint3x3.md) | The computed matrix multiplication. |

## mul(uint3x3, uint3x4)

Returns the uint3x4 matrix result of a matrix multiplication between a uint3x3 matrix and a uint3x4 matrix.

```csharp
public static uint3x4 mul(uint3x3 a, uint3x4 b)
```

### Parameters

**** (\[uint3x3]\(/engine/7000.0/script-reference/unity/mathematics/uint3x3)): Left hand side argument of the matrix multiply.**** (\[uint3x4]\(/engine/7000.0/script-reference/unity/mathematics/uint3x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [uint3x4](/engine/7000.0/script-reference/unity/mathematics/uint3x4.md) | The computed matrix multiplication. |

## mul(uint3x4, uint4)

Returns the uint3 column vector result of a matrix multiplication between a uint3x4 matrix and a uint4 column vector.

```csharp
public static uint3 mul(uint3x4 a, uint4 b)
```

### Parameters

**** (\[uint3x4]\(/engine/7000.0/script-reference/unity/mathematics/uint3x4)): Left hand side argument of the matrix multiply.**** (\[uint4]\(/engine/7000.0/script-reference/unity/mathematics/uint4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                | Description                         |
| ------------------------------------------------------------------- | ----------------------------------- |
| [uint3](/engine/7000.0/script-reference/unity/mathematics/uint3.md) | The computed matrix multiplication. |

## mul(uint3x4, uint4x2)

Returns the uint3x2 matrix result of a matrix multiplication between a uint3x4 matrix and a uint4x2 matrix.

```csharp
public static uint3x2 mul(uint3x4 a, uint4x2 b)
```

### Parameters

**** (\[uint3x4]\(/engine/7000.0/script-reference/unity/mathematics/uint3x4)): Left hand side argument of the matrix multiply.**** (\[uint4x2]\(/engine/7000.0/script-reference/unity/mathematics/uint4x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [uint3x2](/engine/7000.0/script-reference/unity/mathematics/uint3x2.md) | The computed matrix multiplication. |

## mul(uint3x4, uint4x3)

Returns the uint3x3 matrix result of a matrix multiplication between a uint3x4 matrix and a uint4x3 matrix.

```csharp
public static uint3x3 mul(uint3x4 a, uint4x3 b)
```

### Parameters

**** (\[uint3x4]\(/engine/7000.0/script-reference/unity/mathematics/uint3x4)): Left hand side argument of the matrix multiply.**** (\[uint4x3]\(/engine/7000.0/script-reference/unity/mathematics/uint4x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [uint3x3](/engine/7000.0/script-reference/unity/mathematics/uint3x3.md) | The computed matrix multiplication. |

## mul(uint3x4, uint4x4)

Returns the uint3x4 matrix result of a matrix multiplication between a uint3x4 matrix and a uint4x4 matrix.

```csharp
public static uint3x4 mul(uint3x4 a, uint4x4 b)
```

### Parameters

**** (\[uint3x4]\(/engine/7000.0/script-reference/unity/mathematics/uint3x4)): Left hand side argument of the matrix multiply.**** (\[uint4x4]\(/engine/7000.0/script-reference/unity/mathematics/uint4x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [uint3x4](/engine/7000.0/script-reference/unity/mathematics/uint3x4.md) | The computed matrix multiplication. |

## mul(uint4x2, uint2)

Returns the uint4 column vector result of a matrix multiplication between a uint4x2 matrix and a uint2 column vector.

```csharp
public static uint4 mul(uint4x2 a, uint2 b)
```

### Parameters

**** (\[uint4x2]\(/engine/7000.0/script-reference/unity/mathematics/uint4x2)): Left hand side argument of the matrix multiply.**** (\[uint2]\(/engine/7000.0/script-reference/unity/mathematics/uint2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                | Description                         |
| ------------------------------------------------------------------- | ----------------------------------- |
| [uint4](/engine/7000.0/script-reference/unity/mathematics/uint4.md) | The computed matrix multiplication. |

## mul(uint4x2, uint2x2)

Returns the uint4x2 matrix result of a matrix multiplication between a uint4x2 matrix and a uint2x2 matrix.

```csharp
public static uint4x2 mul(uint4x2 a, uint2x2 b)
```

### Parameters

**** (\[uint4x2]\(/engine/7000.0/script-reference/unity/mathematics/uint4x2)): Left hand side argument of the matrix multiply.**** (\[uint2x2]\(/engine/7000.0/script-reference/unity/mathematics/uint2x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [uint4x2](/engine/7000.0/script-reference/unity/mathematics/uint4x2.md) | The computed matrix multiplication. |

## mul(uint4x2, uint2x3)

Returns the uint4x3 matrix result of a matrix multiplication between a uint4x2 matrix and a uint2x3 matrix.

```csharp
public static uint4x3 mul(uint4x2 a, uint2x3 b)
```

### Parameters

**** (\[uint4x2]\(/engine/7000.0/script-reference/unity/mathematics/uint4x2)): Left hand side argument of the matrix multiply.**** (\[uint2x3]\(/engine/7000.0/script-reference/unity/mathematics/uint2x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [uint4x3](/engine/7000.0/script-reference/unity/mathematics/uint4x3.md) | The computed matrix multiplication. |

## mul(uint4x2, uint2x4)

Returns the uint4x4 matrix result of a matrix multiplication between a uint4x2 matrix and a uint2x4 matrix.

```csharp
public static uint4x4 mul(uint4x2 a, uint2x4 b)
```

### Parameters

**** (\[uint4x2]\(/engine/7000.0/script-reference/unity/mathematics/uint4x2)): Left hand side argument of the matrix multiply.**** (\[uint2x4]\(/engine/7000.0/script-reference/unity/mathematics/uint2x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [uint4x4](/engine/7000.0/script-reference/unity/mathematics/uint4x4.md) | The computed matrix multiplication. |

## mul(uint4x3, uint3)

Returns the uint4 column vector result of a matrix multiplication between a uint4x3 matrix and a uint3 column vector.

```csharp
public static uint4 mul(uint4x3 a, uint3 b)
```

### Parameters

**** (\[uint4x3]\(/engine/7000.0/script-reference/unity/mathematics/uint4x3)): Left hand side argument of the matrix multiply.**** (\[uint3]\(/engine/7000.0/script-reference/unity/mathematics/uint3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                | Description                         |
| ------------------------------------------------------------------- | ----------------------------------- |
| [uint4](/engine/7000.0/script-reference/unity/mathematics/uint4.md) | The computed matrix multiplication. |

## mul(uint4x3, uint3x2)

Returns the uint4x2 matrix result of a matrix multiplication between a uint4x3 matrix and a uint3x2 matrix.

```csharp
public static uint4x2 mul(uint4x3 a, uint3x2 b)
```

### Parameters

**** (\[uint4x3]\(/engine/7000.0/script-reference/unity/mathematics/uint4x3)): Left hand side argument of the matrix multiply.**** (\[uint3x2]\(/engine/7000.0/script-reference/unity/mathematics/uint3x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [uint4x2](/engine/7000.0/script-reference/unity/mathematics/uint4x2.md) | The computed matrix multiplication. |

## mul(uint4x3, uint3x3)

Returns the uint4x3 matrix result of a matrix multiplication between a uint4x3 matrix and a uint3x3 matrix.

```csharp
public static uint4x3 mul(uint4x3 a, uint3x3 b)
```

### Parameters

**** (\[uint4x3]\(/engine/7000.0/script-reference/unity/mathematics/uint4x3)): Left hand side argument of the matrix multiply.**** (\[uint3x3]\(/engine/7000.0/script-reference/unity/mathematics/uint3x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [uint4x3](/engine/7000.0/script-reference/unity/mathematics/uint4x3.md) | The computed matrix multiplication. |

## mul(uint4x3, uint3x4)

Returns the uint4x4 matrix result of a matrix multiplication between a uint4x3 matrix and a uint3x4 matrix.

```csharp
public static uint4x4 mul(uint4x3 a, uint3x4 b)
```

### Parameters

**** (\[uint4x3]\(/engine/7000.0/script-reference/unity/mathematics/uint4x3)): Left hand side argument of the matrix multiply.**** (\[uint3x4]\(/engine/7000.0/script-reference/unity/mathematics/uint3x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [uint4x4](/engine/7000.0/script-reference/unity/mathematics/uint4x4.md) | The computed matrix multiplication. |

## mul(uint4x4, uint4)

Returns the uint4 column vector result of a matrix multiplication between a uint4x4 matrix and a uint4 column vector.

```csharp
public static uint4 mul(uint4x4 a, uint4 b)
```

### Parameters

**** (\[uint4x4]\(/engine/7000.0/script-reference/unity/mathematics/uint4x4)): Left hand side argument of the matrix multiply.**** (\[uint4]\(/engine/7000.0/script-reference/unity/mathematics/uint4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                | Description                         |
| ------------------------------------------------------------------- | ----------------------------------- |
| [uint4](/engine/7000.0/script-reference/unity/mathematics/uint4.md) | The computed matrix multiplication. |

## mul(uint4x4, uint4x2)

Returns the uint4x2 matrix result of a matrix multiplication between a uint4x4 matrix and a uint4x2 matrix.

```csharp
public static uint4x2 mul(uint4x4 a, uint4x2 b)
```

### Parameters

**** (\[uint4x4]\(/engine/7000.0/script-reference/unity/mathematics/uint4x4)): Left hand side argument of the matrix multiply.**** (\[uint4x2]\(/engine/7000.0/script-reference/unity/mathematics/uint4x2)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [uint4x2](/engine/7000.0/script-reference/unity/mathematics/uint4x2.md) | The computed matrix multiplication. |

## mul(uint4x4, uint4x3)

Returns the uint4x3 matrix result of a matrix multiplication between a uint4x4 matrix and a uint4x3 matrix.

```csharp
public static uint4x3 mul(uint4x4 a, uint4x3 b)
```

### Parameters

**** (\[uint4x4]\(/engine/7000.0/script-reference/unity/mathematics/uint4x4)): Left hand side argument of the matrix multiply.**** (\[uint4x3]\(/engine/7000.0/script-reference/unity/mathematics/uint4x3)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [uint4x3](/engine/7000.0/script-reference/unity/mathematics/uint4x3.md) | The computed matrix multiplication. |

## mul(uint4x4, uint4x4)

Returns the uint4x4 matrix result of a matrix multiplication between a uint4x4 matrix and a uint4x4 matrix.

```csharp
public static uint4x4 mul(uint4x4 a, uint4x4 b)
```

### Parameters

**** (\[uint4x4]\(/engine/7000.0/script-reference/unity/mathematics/uint4x4)): Left hand side argument of the matrix multiply.**** (\[uint4x4]\(/engine/7000.0/script-reference/unity/mathematics/uint4x4)): Right hand side argument of the matrix multiply.

### Returns

| Type                                                                    | Description                         |
| ----------------------------------------------------------------------- | ----------------------------------- |
| [uint4x4](/engine/7000.0/script-reference/unity/mathematics/uint4x4.md) | The computed matrix multiplication. |

## mul(quaternion, quaternion)

Returns the result of transforming the quaternion b by the quaternion a.

```csharp
public static quaternion mul(quaternion a, quaternion b)
```

### Parameters

**** (\[quaternion]\(/engine/7000.0/script-reference/unity/mathematics/quaternion)): The quaternion on the left.**** (\[quaternion]\(/engine/7000.0/script-reference/unity/mathematics/quaternion)): The quaternion on the right.

### Returns

| Type                                                                          | Description                                                  |
| ----------------------------------------------------------------------------- | ------------------------------------------------------------ |
| [quaternion](/engine/7000.0/script-reference/unity/mathematics/quaternion.md) | The result of transforming quaternion b by the quaternion a. |

## mul(quaternion, float3)

Returns the result of transforming a vector by a quaternion.

```csharp
public static float3 mul(quaternion q, float3 v)
```

### Parameters

**** (\[quaternion]\(/engine/7000.0/script-reference/unity/mathematics/quaternion)): The quaternion transformation.**** (\[float3]\(/engine/7000.0/script-reference/unity/mathematics/float3)): The vector to transform.

### Returns

| Type                                                                  | Description                                     |
| --------------------------------------------------------------------- | ----------------------------------------------- |
| [float3](/engine/7000.0/script-reference/unity/mathematics/float3.md) | The transformation of vector v by quaternion q. |

## mul(RigidTransform, RigidTransform)

Returns the result of transforming the RigidTransform b by the RigidTransform a.

```csharp
public static RigidTransform mul(RigidTransform a, RigidTransform b)
```

### Parameters

**** (\[RigidTransform]\(/engine/7000.0/script-reference/unity/mathematics/rigidtransform)): The RigidTransform on the left.**** (\[RigidTransform]\(/engine/7000.0/script-reference/unity/mathematics/rigidtransform)): The RigidTransform on the right.

### Returns

| Type                                                                                  | Description                             |
| ------------------------------------------------------------------------------------- | --------------------------------------- |
| [RigidTransform](/engine/7000.0/script-reference/unity/mathematics/rigidtransform.md) | The RigidTransform of a transforming b. |

## mul(RigidTransform, float4)

Returns the result of transforming a float4 homogeneous coordinate by a RigidTransform.

```csharp
public static float4 mul(RigidTransform a, float4 pos)
```

### Parameters

**** (\[RigidTransform]\(/engine/7000.0/script-reference/unity/mathematics/rigidtransform)): The RigidTransform.**** (\[float4]\(/engine/7000.0/script-reference/unity/mathematics/float4)): The position to be transformed.

### Returns

| Type                                                                  | Description               |
| --------------------------------------------------------------------- | ------------------------- |
| [float4](/engine/7000.0/script-reference/unity/mathematics/float4.md) | The transformed position. |