# plus, +

Add numbers, append strings

## Syntax

## Description

`C = `

adds
arrays `A`

+ `B`

`A`

and `B`

by adding corresponding
elements. If one input is a string array, then `plus`

appends the
corresponding elements as strings.

The sizes of `A`

and `B`

must be the same or be
compatible. If the sizes of
`A`

and `B`

are compatible, then the two
arrays implicitly expand to match each other. For example, if one of
`A`

or `B`

is a scalar, then the scalar is
combined with each element of the other array. Also, vectors with different
orientations (one row vector and one column vector) implicitly expand to form a
matrix.

## Examples

### Add Scalar to Array

Create an array, `A`

, and add a scalar value to it.

A = [0 1; 1 0]; C = A + 2

`C = `*2×2*
2 3
3 2

The scalar value is added to each entry of `A`

.

### Append Strings

Create two 1-by-3 string arrays, then append similarly located strings in the arrays.

s1 = ["Red" "Blue" "Green"]

`s1 = `*1x3 string*
"Red" "Blue" "Green"

s2 = ["Truck" "Sky" "Tree"]

`s2 = `*1x3 string*
"Truck" "Sky" "Tree"

s = s1 + s2

`s = `*1x3 string*
"RedTruck" "BlueSky" "GreenTree"

### Add Two Arrays

Create two arrays, `A`

and `B`

, and add them together.

A = [1 0; 2 4]; B = [5 9; 2 1]; C = A + B

`C = `*2×2*
6 9
4 5

The elements of `A`

are added to the corresponding elements of `B`

.

### Add Row and Column Vectors

Create a 1-by-2 row vector and 3-by-1 column vector and add them.

a = 1:2; b = (1:3)'; a + b

`ans = `*3×2*
2 3
3 4
4 5

The result is a 3-by-2 matrix, where each (i,j) element in the matrix is equal to a`(j) + b(i)`

:

$$\mathit{a}=\left[{\mathit{a}}_{1}\text{\hspace{0.17em}}{\mathit{a}}_{2}\right],\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}\mathit{b}=\left[\begin{array}{c}{\mathit{b}}_{1}\\ {\mathit{b}}_{2}\\ {\mathit{b}}_{3}\end{array}\right],\text{\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}\hspace{0.17em}}\text{\hspace{0.17em}}\mathit{a}+\text{\hspace{0.17em}}\mathit{b}=\left[\begin{array}{cc}{\mathit{a}}_{1}+\text{\hspace{0.17em}}{\mathit{b}}_{1}& {\mathit{a}}_{2}+\text{\hspace{0.17em}}{\mathit{b}}_{1}\\ {\mathit{a}}_{1}+\text{\hspace{0.17em}}{\mathit{b}}_{2}& {\mathit{a}}_{2}+\text{\hspace{0.17em}}{\mathit{b}}_{2}\\ {\mathit{a}}_{1}+\text{\hspace{0.17em}}{\mathit{b}}_{3}& {\mathit{a}}_{2}+\text{\hspace{0.17em}}{\mathit{b}}_{3}\end{array}\right].$$

### Add Vector to Matrix

Create an array, `A`

, and add a column vector to it. The vector is treated as though it is a matrix of the same size as `A`

, so that each element in the vector is added to a row in `A`

.

A = [1 2 3; 4 5 6]

`A = `*2×3*
1 2 3
4 5 6

b = [10; 100]

`b = `*2×1*
10
100

A + b

`ans = `*2×3*
11 12 13
104 105 106

## Input Arguments

`A`

, `B`

— Operands

scalars | vectors | matrices | multidimensional arrays

Operands, specified as scalars, vectors, matrices, or multidimensional
arrays. Inputs `A`

and `B`

must either be
the same size or have sizes that are compatible (for example,
`A`

is an `M`

-by-`N`

matrix and `B`

is a scalar or
`1`

-by-`N`

row vector). For more
information, see Compatible Array Sizes for Basic Operations.

If one input is a string array, then the other input can be numeric, character, string, or a cell array. In this case,

`plus`

converts the non-string input into a string array and then appends corresponding elements of the inputs.Operands with an integer data type cannot be complex.

If one input is a

`datetime`

array,`duration`

array, or`calendarDuration`

array, then numeric values in the other input are treated as a number of 24-hour days.

**Data Types: **`single`

| `double`

| `int8`

| `int16`

| `int32`

| `int64`

| `uint8`

| `uint16`

| `uint32`

| `uint64`

| `logical`

| `char`

| `string`

| `datetime`

| `duration`

| `calendarDuration`

**Complex Number Support: **Yes

## Tips

For appending text,

`plus`

only operates on string arrays. Use the`append`

function to append text in character vectors or cell arrays.

## Compatibility Considerations

### Implicit expansion change affects arguments for operators

*Behavior changed in R2016b*

Starting in R2016b with the addition of implicit expansion, some combinations of arguments for basic operations that previously returned errors now produce results. For example, you previously could not add a row and a column vector, but those operands are now valid for addition. In other words, an expression like `[1 2] + [1; 2]`

previously returned a size mismatch error, but now it executes.

If your code uses element-wise operators and relies on the errors that MATLAB^{®} previously returned for mismatched sizes, particularly within a `try`

/`catch`

block, then your code might no longer catch those errors.

For more information on the required input sizes for basic array operations, see Compatible Array Sizes for Basic Operations.

### Implicit expansion change affects `calendarDuration`

,
`datetime`

, and `duration`

arrays

*Behavior changed in R2020b*

Starting in R2020b, `plus`

supports implicit expansion when the
arguments are `calendarDuration`

, `datetime`

, or
`duration`

arrays. Between R2020a and R2016b, implicit
expansion was supported only for numeric and string data types.

## Extended Capabilities

### Tall Arrays

Calculate with arrays that have more rows than fit in memory.

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

### C/C++ Code Generation

Generate C and C++ code using MATLAB® Coder™.

Usage notes and limitations:

If you use

`plus`

with single type and double type operands, the generated code might not produce the same result as MATLAB. See Binary Element-Wise Operations with Single and Double Operands (MATLAB Coder).

### GPU Code Generation

Generate CUDA® code for NVIDIA® GPUs using GPU Coder™.

### HDL Code Generation

Generate Verilog and VHDL code for FPGA and ASIC designs using HDL Coder™.

Inputs cannot be data type `logical`

.

### Thread-Based Environment

Run code in the background using MATLAB® `backgroundPool`

or accelerate code with Parallel Computing Toolbox™ `ThreadPool`

.

This function fully supports thread-based environments. For more information, see Run MATLAB Functions in Thread-Based Environment.

### GPU Arrays

Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox™.

Usage notes and limitations:

64-bit integers are not supported.

For more information, see Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

### Distributed Arrays

Partition large arrays across the combined memory of your cluster using Parallel Computing Toolbox™.

This function fully supports distributed arrays. For more information, see Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).

## See Also

**Introduced before R2006a**

## Open Example

You have a modified version of this example. Do you want to open this example with your edits?

## MATLAB Command

You clicked a link that corresponds to this MATLAB command:

Run the command by entering it in the MATLAB Command Window. Web browsers do not support MATLAB commands.

# Select a Web Site

Choose a web site to get translated content where available and see local events and offers. Based on your location, we recommend that you select: .

You can also select a web site from the following list:

## How to Get Best Site Performance

Select the China site (in Chinese or English) for best site performance. Other MathWorks country sites are not optimized for visits from your location.

### Americas

- América Latina (Español)
- Canada (English)
- United States (English)

### Europe

- Belgium (English)
- Denmark (English)
- Deutschland (Deutsch)
- España (Español)
- Finland (English)
- France (Français)
- Ireland (English)
- Italia (Italiano)
- Luxembourg (English)

- Netherlands (English)
- Norway (English)
- Österreich (Deutsch)
- Portugal (English)
- Sweden (English)
- Switzerland
- United Kingdom (English)