# 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 is greater than 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 is greater than 1, treating the elements as vectors. The size of `S` in this dimension becomes `1` while the sizes of all other dimensions remain the same as in `A`.If `A` is a table or timetable, then `sum(A)` returns a one-row table containing the sum of each variable. (since R2023a)```

example

````S = sum(A,"all")` returns the sum of all elements of `A`.```

example

````S = sum(A,dim)` returns the sum along dimension `dim`. For example, if `A` is a matrix, then `sum(A,2)` returns 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])` returns the sum of all elements in `A` because 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 the 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 in `A`. For example, `sum(A,"omitnan")` ignores `NaN` values when computing the sum. By default, `sum` includes `NaN` values.```

## 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 ```

To compute the 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 matrix containing `NaN` values.

`A = [1.77 -0.005 NaN -2.95; NaN 0.34 NaN 0.19]`
```A = 2×4 1.7700 -0.0050 NaN -2.9500 NaN 0.3400 NaN 0.1900 ```

Compute the sum of the matrix, excluding `NaN` values. For matrix columns that contain any `NaN` value, `sum` computes with the non-`NaN` elements. For matrix columns that contain all `NaN` values, the sum is 0.

`S = sum(A,"omitnan")`
```S = 1×4 1.7700 0.3350 0 -2.7600 ```

## Input Arguments

collapse all

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

• 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` | `table` | `timetable`
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`, `duration`, `table`, or `timetable`, in which case, the output is `"native"`
`"double"``double`, unless the data type is `duration`, `table`, or `timetable`, 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; or unless the input data type is `timetable`, in which case the output data type is `table`

Missing value condition, specified as one of these values:

• `"includemissing"` or `"includenan"` — Include `NaN` values in `A` when computing the sum. If any element in the operating dimension is `NaN`, then the corresponding element in `S` is `NaN`. `"includemissing"` and `"includenan"` have the same behavior.

• `"omitmissing"` or `"omitnan"` — Ignore `NaN` values in `A`, and compute the sum over fewer points. If all elements in the operating dimension are `NaN`, then the corresponding element in `S` is 0. `"omitmissing"` and `"omitnan"` have the same behavior.

## Version History

Introduced before R2006a

expand all