# sum

Sum of array elements

## Syntax

``S = sum(A)``
``S = sum(A,'all')``
``S = sum(A,dim)``
``S = sum(A,vecdim)``
``S = sum(___,outtype)``
``S = sum(___,nanflag)``

## Description

example

````S = sum(A)` returns the sum of the elements of A along the first array dimension whose size does not equal 1.If `A` is a vector, then `sum(A)` returns the sum of the elements.If `A` is a matrix, then `sum(A)` returns a row vector containing the sum of each column.If `A` is a multidimensional array, then `sum(A)` operates along the first array dimension whose size does not equal 1, treating the elements as vectors. This dimension becomes `1` while the sizes of all other dimensions remain the same.```

example

````S = sum(A,'all')` computes the sum of all elements of `A`. This syntax is valid for MATLAB® versions R2018b and later.```

example

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

example

````S = sum(A,vecdim)` sums the elements of `A` based on the dimensions specified in the vector `vecdim`. For example, if `A` is a matrix, then `sum(A,[1 2])` is the sum of all elements in `A`, since every element of a matrix is contained in the array slice defined by dimensions 1 and 2.```

example

````S = sum(___,outtype)` returns the sum with a specified data type, using any of the input arguments in the previous syntaxes. `outtype` can be `'default'`, `'double'`, or `'native'`.```

example

````S = sum(___,nanflag)` specifies whether to include or omit `NaN` values from the calculation for any of the previous syntaxes. `sum(A,'includenan')` includes all `NaN` values in the calculation while `sum(A,'omitnan')` ignores them.```

## Examples

collapse all

Create a vector and compute the sum of its elements.

```A = 1:10; S = sum(A)```
```S = 55 ```

Create a matrix and compute the sum of the elements in each column.

`A = [1 3 2; 4 2 5; 6 1 4]`
```A = 3×3 1 3 2 4 2 5 6 1 4 ```
`S = sum(A)`
```S = 1×3 11 6 11 ```

Create a matrix and compute the sum of the elements in each row.

`A = [1 3 2; 4 2 5; 6 1 4]`
```A = 3×3 1 3 2 4 2 5 6 1 4 ```
`S = sum(A,2)`
```S = 3×1 6 11 11 ```

Use a vector dimension argument to operate on specific slices of an array.

Create a 3-D array whose elements are 1.

`A = ones(4,3,2);`

To sum all elements in each page of `A`, specify the dimensions in which to sum (row and column) using a vector dimension argument. Since both pages are a 4-by-3 matrix of ones, the sum of each page is 12.

`S1 = sum(A,[1 2])`
```S1 = S1(:,:,1) = 12 S1(:,:,2) = 12 ```

If you slice `A` along the first dimension, you can sum the elements of the resulting 4 pages, which are each 3-by-2 matrices.

`S2 = sum(A,[2 3])`
```S2 = 4×1 6 6 6 6 ```

Slicing along the second dimension, each page sum is over a 4-by-2 matrix.

`S3 = sum(A,[1 3])`
```S3 = 1×3 8 8 8 ```

Starting in R2018b, to sum over all dimensions of an array, you can either specify each dimension in the vector dimension argument, or use the `'all'` option.

`S4 = sum(A,[1 2 3])`
```S4 = 24 ```
`Sall = sum(A,'all')`
```Sall = 24 ```

Create a 4-by-2-by-3 array of ones and compute the sum along the third dimension.

```A = ones(4,2,3); S = sum(A,3)```
```S = 4×2 3 3 3 3 3 3 3 3 ```

Create a vector of 32-bit integers and compute the `int32` sum of its elements by specifying the output type as `native`.

```A = int32(1:10); S = sum(A,'native')```
```S = int32 55 ```

Create a vector and compute its sum, excluding `NaN` values.

```A = [1.77 -0.005 3.98 -2.95 NaN 0.34 NaN 0.19]; S = sum(A,'omitnan')```
```S = 3.3250 ```

If you do not specify `'omitnan'`, then `sum(A)` returns `NaN`.

## Input Arguments

collapse all

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

• If `A` is a scalar, then `sum(A)` returns `A`.

• If `A` is an empty 0-by-0 matrix, then `sum(A)` returns `0`.

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

Dimension to operate along, specified as a positive integer scalar. If you do not specify the dimension, then the default is the first array dimension of size greater than 1.

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

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

• `sum(A,1)` operates on successive elements in the columns of `A` and returns a row vector of the sums of each column. • `sum(A,2)` operates on successive elements in the rows of `A` and returns a column vector of the sums of each row. `sum` returns `A` when `dim` is greater than `ndims(A)` or when `size(A,dim)` is `1`.

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

Vector of dimensions, specified as a vector of positive integers. Each element represents a dimension of the input array. The lengths of the output in the specified operating dimensions are 1, while the others remain the same.

Consider a 2-by-3-by-3 input array, `A`. Then `sum(A,[1 2])` returns a 1-by-1-by-3 array whose elements are the sums of each page of `A`. Data Types: `double` | `single` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64`

Output data type, specified as `'default'`, `'double'`, or `'native'`. These options also specify the data type in which the operation is performed.

`outtype`Output data type
`'default'``double`, unless the input data type is `single` or `duration`, in which case, the output is `'native'`
`'double'``double`, unless the data type is `duration`, in which case, `'double'` is not supported
`'native'`same data type as the input, unless the input data type is `char`, in which case, `'native'` is not supported

Data Types: `char`

`NaN` condition, specified as one of these values:

• `'includenan'` — Include `NaN` values when computing the sum, resulting in `NaN`.

• `'omitnan'` — Ignore all `NaN` values in the input.

Data Types: `char`

## Version History

Introduced before R2006a