# ismissing

Find missing values

## Syntax

``TF = ismissing(A)``
``TF = ismissing(A,indicator)``
``TF = ismissing(___,'OutputFormat',format)``

## Description

example

````TF = ismissing(A)` returns a logical array that indicates which elements of the input data contain missing values. The size of `TF` is the same as the size of `A`.Missing values are defined according to the data type of `A`: `NaN` — `double`, `single`, `duration`, and `calendarDuration``NaT` — `datetime``<missing>` — `string``<undefined>` — `categorical``{''}` — `cell` of character vectors If `A` is a table, then the data type of each column defines the missing value for that column.For data types with no default definition of a standard missing value, `ismissing(A)` returns an array or table of logical `0` (`false`) values the same size as `A`. ```

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`.```
````TF = ismissing(___,'OutputFormat',format)` specifies for table or timetable input data the output data type for any of the previous syntaxes.```

## Examples

collapse all

Create a row vector `A` that contains `NaN` values, and identify their locations 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.

```dblVar = [NaN; 2; 3; 4; 5; 6]; singleVar = single([1; NaN; 3; 4; 5; 6]); cellstrVar = {'one'; 'two'; ''; 'four'; 'five'; 'six'}; categoryVar = categorical({'red'; 'orange'; 'yellow'; ''; 'blue'; 'indigo'}); dateVar = [datetime(2015,1:4,15) NaT datetime(2015,6,15)]'; stringVar = ["a"; "b"; "c"; "d"; "e"; missing]; A = table(dblVar,singleVar,cellstrVar,categoryVar,dateVar,stringVar)```
```A=6×6 table dblVar singleVar cellstrVar categoryVar dateVar stringVar ______ _________ __________ ___________ ___________ _________ NaN 1 {'one' } red 15-Jan-2015 "a" 2 NaN {'two' } orange 15-Feb-2015 "b" 3 3 {0x0 char} yellow 15-Mar-2015 "c" 4 4 {'four' } <undefined> 15-Apr-2015 "d" 5 5 {'five' } blue NaT "e" 6 6 {'six' } indigo 15-Jun-2015 <missing> ```

Find the elements with missing values.

`ismissing` returns an array that has a logical 1 for every corresponding element in `A` with a missing value. The size of `TF` is the same as the size of `A`.

`TF = ismissing(A)`
```TF = 6x6 logical array 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 ```

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

Specify the missing value indicators. `ismissing` returns an array that has a logical 1 for every corresponding element in `A` with 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, because 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, cell array of character vectors, table, or timetable.

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

• If `A` is a cell array or a table with cell array variables, then `ismissing` only detects missing elements when the cell array contains character vectors.

Missing value indicator, 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 and 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 `A` is a table, then `missing` is also an indicator for missing cell arrays of character vectors (`{''}`).

Indicator data types match data types in the entries of `A`. These 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.

Output data type, specified as one of these values:

• `'logical'` — For table or timetable input data, return the output `TF` as a logical array.

• `'tabular'` — For table input data, return the output `TF` as a table. For timetable input data, return the output `TF` as a timetable.

For vector, matrix, or multidimensional array input data, `OutputFormat` is not supported.

Example: `ismissing(T,'OutputFormat','tabular')`

## Tips

• Because 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.

• For input data that is a structure array or a cell array of non-character vectors, `ismissing` returns `false`. To find missing values in a structure array, apply `ismissing` to each field in the structure by using the `structfun` function. To find missing values in a cell array of non-character vectors, apply `ismissing` to each cell in the cell array by using the `cellfun` function.

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

## Version History

Introduced in R2013b

expand all