# Documentation

### This is machine translation

Translated by
Mouse over text to see original. Click the button below to return to the English verison of the page.

# prod

Product of array elements

## Syntax

• ``B = prod(A)``
example
• ``B = prod(A,dim)``
example
• ``B = prod(___,type)``
example

## Description

example

````B = prod(A)` returns the product of the array elements of `A`.If `A` is a vector, then `prod(A)` returns the product of the elements.If `A` is a nonempty matrix, then `prod(A)` treats the columns of `A` as vectors and returns a row vector of the products of each column. If `A` is an empty 0-by-0 matrix, `prod(A)` returns `1`.If `A` is a multidimensional array, then `prod(A)` acts along the first nonsingleton dimension and returns an array of products. The size of this dimension reduces to `1` while the sizes of all other dimensions remain the same.`prod` computes and returns `B` as `single` when the input, `A`, is `single`. For all other numeric and logical data types, `prod` computes and returns `B` as `double`.```

example

````B = prod(A,dim)` returns the products along dimension `dim`. For example, if `A` is a matrix, `prod(A,2)` is a column vector containing the products of each row.```

example

````B = prod(___,type)` returns an array in the class specified by `type`, using any of the input arguments in the previous syntaxes. `type` can be `'double'`, `'native'`, or `'default'`.```

## Examples

collapse all

Create a 3-by-3 array whose elements correspond to their linear indices.

```A=[1:3:7;2:3:8;3:3:9] ```
```A = 1 4 7 2 5 8 3 6 9 ```

Find the product of the elements in each column. The length of the first dimension is 1, and the length of the second dimension matches `size(A,2)`.

```B = prod(A) ```
```B = 6 120 504 ```

Create an array of logical values.

```A = [true false; true true] ```
```A = 2×2 logical array 1 0 1 1 ```

Find the product of the elements in each column.

```B = prod(A) ```
```B = 1 0 ```

The output has type `double`.

```class(B) ```
```ans = double ```

Create a 3-by-3 array whose elements correspond to their linear indices.

```A=[1:3:7;2:3:8;3:3:9] ```
```A = 1 4 7 2 5 8 3 6 9 ```

Find the product of the elements in each row and reduce the length of the second dimension to 1. The length of the first dimension matches `size(A,1)`, and the length of the second dimension is 1.

```dim = 2; B = prod(A,dim) ```
```B = 28 80 162 ```

Create a 3-by-3-by-2 array whose elements correspond to their linear indices.

```A=[1:3:7;2:3:8;3:3:9]; A(:,:,2)=[10:3:16;11:3:17;12:3:18] ```
```A(:,:,1) = 1 4 7 2 5 8 3 6 9 A(:,:,2) = 10 13 16 11 14 17 12 15 18 ```

Find the product of each element in the first plane with its corresponding element in the second plane. The length of the first dimension matches `size(A,1)`, the length of the second dimension matches `size(A,2)`, and the length of the third dimension is 1.

```dim = 3; B = prod(A,dim) ```
```B = 10 52 112 22 70 136 36 90 162 ```

Create a 3-by-3 array of single-precision values.

```A = single([1200 1500 1800; 1300 1600 1900; 1400 1700 2000]) ```
```A = 3×3 single matrix 1200 1500 1800 1300 1600 1900 1400 1700 2000 ```

Find the product of the elements in each row by multiplying in double precision.

```B = prod(A,2,'double') ```
```B = 1.0e+09 * 3.2400 3.9520 4.7600 ```

The output is double precision.

```class(B) ```
```ans = double ```

Create a 3-by-3 array of 8-bit unsigned integers.

```A = uint8([1:3:7;2:3:8;3:3:9]) ```
```A = 3×3 uint8 matrix 1 4 7 2 5 8 3 6 9 ```

Find the product of the elements in each column natively in `uint8`.

```B = prod(A,'native') ```
```B = 1×3 uint8 row vector 6 120 255 ```

The result is an array of 8-bit unsigned integers.

```class(B) ```
```ans = uint8 ```

## Input Arguments

collapse all

Input array, specified as a vector, matrix, or multidimensional array.

Data Types: `double` | `single` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64` | `logical`
Complex Number Support: Yes

Dimension to operate along, specified as a positive integer scalar. If no value is specified, then the default is the first array dimension whose size does not equal 1.

Dimension `dim` indicates the dimension whose length reduces to `1`. The `size(B,dim)` is `1`, while the sizes of all other dimensions remain the same.

Consider a two-dimensional input array, `A`.

• If `dim = 1`, then `prod(A,1)` returns a row vector containing the product of the elements in each column.

• If `dim = 2`, then `prod(A,2)` returns a column vector containing the product of the elements in each row.

`prod` returns `A` when `dim` is greater than `ndims(A)`.

Data Types: `double` | `single` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64`

Output class, specified as `'default'`, `'double'`, or `'native'`, and which defines the data type of the output, `B`.

`type`Output data type
`'default'``double`, unless the input data type is `single`. In which case, the output data type is `single`.
`'double'``double`
`'native'`same data type as the input array, `A`

Data Types: `char`

## Output Arguments

collapse all

Product array, returned as a scalar, vector, matrix, or multidimensional array.

The class of `B` is as follows:

• If the `type` argument specifies `'default'` or is not used

• and the input is not `single`, then the output is `double`.

• and the input is `single`, then the output is `single`.

• If the `type` argument specifies `'double'`, then the output is `double` regardless of the input data type.

• If the `type` argument specifies `'native'`, then the output is the same data type as the input.

collapse all

### First Nonsingleton Dimension

The first nonsingleton dimension is the first dimension of an array whose size is not equal to `1`.

For example:

• If `X` is a 1-by-n row vector, then the second dimension is the first nonsingleton dimension of `X`.

• If `X` is a 1-by-0-by-n empty array, then the second dimension is the first nonsingleton dimension of `X`.

• If `X` is a 1-by-1-by-3 array, then the third dimension is the first nonsingleton dimension of `X`.

### Tall Array Support

This function fully supports tall arrays. For more information, see Tall Arrays.