Check that an argument is a vector of type double

```
checkDouble(
x,
lower = -Inf,
upper = Inf,
finite = FALSE,
any.missing = TRUE,
all.missing = TRUE,
len = NULL,
min.len = NULL,
max.len = NULL,
unique = FALSE,
sorted = FALSE,
names = NULL,
typed.missing = FALSE,
null.ok = FALSE
)
check_double(
x,
lower = -Inf,
upper = Inf,
finite = FALSE,
any.missing = TRUE,
all.missing = TRUE,
len = NULL,
min.len = NULL,
max.len = NULL,
unique = FALSE,
sorted = FALSE,
names = NULL,
typed.missing = FALSE,
null.ok = FALSE
)
assertDouble(
x,
lower = -Inf,
upper = Inf,
finite = FALSE,
any.missing = TRUE,
all.missing = TRUE,
len = NULL,
min.len = NULL,
max.len = NULL,
unique = FALSE,
sorted = FALSE,
names = NULL,
typed.missing = FALSE,
null.ok = FALSE,
.var.name = vname(x),
add = NULL
)
assert_double(
x,
lower = -Inf,
upper = Inf,
finite = FALSE,
any.missing = TRUE,
all.missing = TRUE,
len = NULL,
min.len = NULL,
max.len = NULL,
unique = FALSE,
sorted = FALSE,
names = NULL,
typed.missing = FALSE,
null.ok = FALSE,
.var.name = vname(x),
add = NULL
)
testDouble(
x,
lower = -Inf,
upper = Inf,
finite = FALSE,
any.missing = TRUE,
all.missing = TRUE,
len = NULL,
min.len = NULL,
max.len = NULL,
unique = FALSE,
sorted = FALSE,
names = NULL,
typed.missing = FALSE,
null.ok = FALSE
)
test_double(
x,
lower = -Inf,
upper = Inf,
finite = FALSE,
any.missing = TRUE,
all.missing = TRUE,
len = NULL,
min.len = NULL,
max.len = NULL,
unique = FALSE,
sorted = FALSE,
names = NULL,
typed.missing = FALSE,
null.ok = FALSE
)
expect_double(
x,
lower = -Inf,
upper = Inf,
finite = FALSE,
any.missing = TRUE,
all.missing = TRUE,
len = NULL,
min.len = NULL,
max.len = NULL,
unique = FALSE,
sorted = FALSE,
names = NULL,
typed.missing = FALSE,
null.ok = FALSE,
info = NULL,
label = vname(x)
)
```

- x
[any]

Object to check.- lower
[

`numeric(1)`

]

Lower value all elements of`x`

must be greater than or equal to.- upper
[

`numeric(1)`

]

Upper value all elements of`x`

must be lower than or equal to.- finite
[

`logical(1)`

]

Check for only finite values? Default is`FALSE`

.- any.missing
[

`logical(1)`

]

Are vectors with missing values allowed? Default is`TRUE`

.- all.missing
[

`logical(1)`

]

Are vectors with no non-missing values allowed? Default is`TRUE`

. Note that empty vectors do not have non-missing values.- len
[

`integer(1)`

]

Exact expected length of`x`

.- min.len
[

`integer(1)`

]

Minimal length of`x`

.- max.len
[

`integer(1)`

]

Maximal length of`x`

.- unique
[

`logical(1)`

]

Must all values be unique? Default is`FALSE`

.- sorted
[

`logical(1)`

]

Elements must be sorted in ascending order. Missing values are ignored.- names
[

`character(1)`

]

Check for names. See`checkNamed`

for possible values. Default is “any” which performs no check at all. Note that you can use`checkSubset`

to check for a specific set of names.- typed.missing
[

`logical(1)`

]

If set to`FALSE`

(default), all types of missing values (`NA`

,`NA_integer_`

,`NA_real_`

,`NA_character_`

or`NA_character_`

) as well as empty vectors are allowed while type-checking atomic input. Set to`TRUE`

to enable strict type checking.- null.ok
[

`logical(1)`

]

If set to`TRUE`

,`x`

may also be`NULL`

. In this case only a type check of`x`

is performed, all additional checks are disabled.- .var.name
[

`character(1)`

]

Name of the checked object to print in assertions. Defaults to the heuristic implemented in`vname`

.- add
[

`AssertCollection`

]

Collection to store assertion messages. See`AssertCollection`

.- info
[

`character(1)`

]

Extra information to be included in the message for the testthat reporter. See`expect_that`

.- label
[

`character(1)`

]

Name of the checked object to print in messages. Defaults to the heuristic implemented in`vname`

.

Depending on the function prefix: If the check is successful, the functions

`assertDouble`

/`assert_double`

return

`x`

invisibly, whereas

`checkDouble`

/`check_double`

and

`testDouble`

/`test_double`

return

`TRUE`

.
If the check is not successful,

`assertDouble`

/`assert_double`

throws an error message,

`testDouble`

/`test_double`

returns `FALSE`

,
and `checkDouble`

/`check_double`

return a string with the error message.
The function `expect_double`

always returns an

This function does not distinguish between
`NA`

, `NA_integer_`

, `NA_real_`

, `NA_complex_`

`NA_character_`

and `NaN`

.

Other basetypes:
`checkArray()`

,
`checkAtomicVector()`

,
`checkAtomic()`

,
`checkCharacter()`

,
`checkComplex()`

,
`checkDataFrame()`

,
`checkDate()`

,
`checkEnvironment()`

,
`checkFactor()`

,
`checkFormula()`

,
`checkFunction()`

,
`checkIntegerish()`

,
`checkInteger()`

,
`checkList()`

,
`checkLogical()`

,
`checkMatrix()`

,
`checkNull()`

,
`checkNumeric()`

,
`checkPOSIXct()`

,
`checkRaw()`

,
`checkVector()`

```
testDouble(1)
#> [1] TRUE
testDouble(1L)
#> [1] FALSE
testDouble(1, min.len = 1, lower = 0)
#> [1] TRUE
```