# ismissing

Find missing values

## Syntax

``TF = ismissing(A)``
``TF = ismissing(A,indicator)``

## Description

example

````TF = ismissing(A)` returns a logical array that indicates which elements of an array or table contain missing values. The size of `TF` is the same as the size of `A`.Standard missing values depend on the data type: `NaN` for `double`, `single`, `duration`, and `calendarDuration``NaT` for `datetime``<missing>` for `string``<undefined>` for `categorical``' '` for `char``{''}` for `cell` of character vectors ```

example

````TF = ismissing(A,indicator)` treats the values in `indicator` as missing value indicators, ignoring all default indicators listed in the previous syntax. `indicator` can be a single indicator or multiple indicators. For example, if `A` is an array of type `double`, then `ismissing(A,[0,-99])` treats 0 and -99 as missing `double` values instead of `NaN`.```

## Examples

collapse all

Create a row vector `A` that contains `NaN` values, and identify their location in `A`.

```A = [3 NaN 5 6 7 NaN NaN 9]; TF = ismissing(A)```
```TF = 1x8 logical array 0 1 0 0 0 1 1 0 ```

Create a table with variables of different data types and find the elements with missing values.

```dblVar = [NaN;3;5;7;9;11;13]; singleVar = single([1;NaN;5;7;9;11;13]); cellstrVar = {'one';'three';'';'seven';'nine';'eleven';'thirteen'}; charVar = ['A';'C';'E';' ';'I';'J';'L']; categoryVar = categorical({'red';'yellow';'blue';'violet';'';'ultraviolet';'orange'}); dateVar = [datetime(2015,1:2:10,15) NaT datetime(2015,11,15)]'; stringVar = ["a";"b";"c";"d";"e";"f";missing]; A = table(dblVar,singleVar,cellstrVar,charVar,categoryVar,dateVar,stringVar)```
```A=7×7 table dblVar singleVar cellstrVar charVar categoryVar dateVar stringVar ______ _________ ____________ _______ ___________ ___________ _________ NaN 1 {'one' } A red 15-Jan-2015 "a" 3 NaN {'three' } C yellow 15-Mar-2015 "b" 5 5 {0x0 char } E blue 15-May-2015 "c" 7 7 {'seven' } violet 15-Jul-2015 "d" 9 9 {'nine' } I <undefined> 15-Sep-2015 "e" 11 11 {'eleven' } J ultraviolet NaT "f" 13 13 {'thirteen'} L orange 15-Nov-2015 <missing> ```

`ismissing` returns 1 where the corresponding element in `A` has a missing value.

`TF = ismissing(A)`
```TF = 7x7 logical array 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 ```

The size of `TF` is the same as the size of `A`.

Create a table where `'NA'`, `''`, `-99`, `NaN`, and `Inf` represent missing values. Then, find the elements with missing values.

```dblVar = [NaN;3;Inf;7;9]; int8Var = int8([1;3;5;7;-99]); cellstrVar = {'one';'three';'';'NA';'nine'}; charVar = ['A';'C';'E';' ';'I']; A = table(dblVar,int8Var,cellstrVar,charVar)```
```A=5×4 table dblVar int8Var cellstrVar charVar ______ _______ __________ _______ NaN 1 {'one' } A 3 3 {'three' } C Inf 5 {0x0 char} E 7 7 {'NA' } 9 -99 {'nine' } I ```

`ismissing` returns 1 where the corresponding element in `A` has a missing value.

```id = {'NA' '' -99 NaN Inf}; TF = ismissing(A,id)```
```TF = 5x4 logical array 1 0 0 0 0 0 0 0 1 0 1 0 0 0 1 1 0 1 0 0 ```

`ismissing` ignores trailing white space in character arrays. Therefore, since the empty character vector, `''`, is specified as a missing value indicator, `ismissing` identifies the empty character vector in `A.cellstrVar` and also the blank space in `A.charVar` as missing values.

## Input Arguments

collapse all

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

If `A` is a timetable, then `ismissing` operates on the table data only and ignores `NaT` or `NaN` values in the vector of row times.

When the input argument is a cell array, it must be a cell array of character vectors. If the input is a table or timetable with a variable of type `cell`, then `ismissing` only detects missing elements when the variable is a cell array of character vectors.

Data Types: `double` | `single` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64` | `logical` | `char` | `string` | `cell` | `table` | `timetable` | `categorical` | `datetime` | `duration` | `calendarDuration`

Missing value indicators, specified as a scalar, vector, or cell array. If `A` is an array, then `indicator` must be a vector. If `A` is a table or timetable, then `indicator` can also be a cell array with entries of multiple data types.

The entries of `indicator` indicate the values that `ismissing` treats as missing. Specifying `indicator` overrides all default standard missing indicators. If you want to add indicators while maintaining the list of standard indicators, then you must include all default indicators as elements of `indicator`. For example, if `A` is a table with `categorical` and numeric values, use `ismissing(A,{-99,'<undefined>'})` to indicate `-99` as a missing numeric value, but preserve `<undefined>` as a missing `categorical` value.

You can also use the `missing` value as an indicator for any missing data represented as `NaN`, `NaT`, `missing`, or `<undefined>`. If your input is a table, then `missing` is also an indicator for missing character vectors (`' '`) and missing cell arrays of character vectors (`{''}`).

Indicator data types match data types in the entries of `A`. The following are additional data type matches between the indicator and elements of `A`:

• `double` indicators match `double`, `single`, integer, and `logical` entries of `A`.

• `string` and `char` indicators, and indicators that are cell arrays of character vectors, match `string` entries of `A`.

• `string` and `char` indicators match `categorical` entries of `A`.

Example: `TF = ismissing(A,0)` recognizes only `0` as a missing value.

Data Types: `single` | `double` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64` | `logical` | `char` | `string` | `cell` | `datetime` | `duration`

## Tips

• Since integer variables cannot store `NaN`, use a special integer value (otherwise unused) to indicate missing integer data, such as `-99`.

• For more information on finding missing strings, see Test for Empty Strings and Missing Values.

## Algorithms

`ismissing` handles leading and trailing white space differently for indicators that are cell arrays of character vectors, character arrays, or categorical arrays.

• For cell arrays of character vectors, `ismissing` does not ignore indicator white space. All character vectors must match exactly.

• For character arrays in table variables, `ismissing` ignores trailing white space in the indicator.

• For categorical arrays, `ismissing` ignores leading and trailing white space in the indicator.