So far in these tutorials, we haven’t really examined what the `self$data`

data frame *actually* contains. It contains the data from the dataset which is displayed in the spreadsheet view, but exactly how these values map to the R type system is a bit nuanced.

In jamovi there are four variable types:

- Nominal Text
- Nominal
- Ordinal
- Continuous

`Nominal Text`

variables only ever have ‘text’ values, so will come through in the `self$data`

data frame simply as factors. `Continuous`

variables only ever have numeric values, so in the `self$data`

data frame, they are of type numeric. However, the `Nominal`

and `Ordinal`

variable types are a little more tricky. These can have *both* numeric *and* text values.

(**NOTE** jamovi currently doesn’t support assigning text values (labels) to Nominal and Ordinal variables. This will be added in the future.)

Further, there are situations where you want to treat a `Nominal`

or `Ordinal`

variable as a factor (i.e. when it is used as the grouping variable for a t-test), but other times where you want to use it as a number (i.e. when taking a mean of say, Likert items). (Some would argue that this should never happen – you should never be taking the mean of a categorial variable, and that’s possibly true – but some people do still find it useful).

The other advantage of the ‘dual nature’ of `Nominal`

variables, is that it means the users can ignore the variable type if they don’t want to worry about it. When working with large datasets, the process of going through and setting up all the columns, making sure they have the correct variable type, etc. can be long and tedious. So only using the variable type as a guide can make it easier for the user. This is also consistent with the way that many statistical software work, including SPSS.

So whether a `Nominal`

variable should be treated as a factor or a continuous variable should be determined by context. For example, for an ANCOVA, variables assigned to ‘factors’ should be treated as factors, and variables assigned to ‘covariates’ should be treated as numeric. Avoid *inferring* how the user wants to treat the variable based on its type, i.e. avoid an ‘independent variables’ option, where if the user assigns a nominal variable, it is treated as a factor, and if the user assigns a continuous variable, it is treated as a covariate – this is *implied* behaviour, and users make mistakes.

In jamovi, by default, `Nominal`

and `Ordinal`

variables in `self$data`

come through as factors. The numeric values for each column are attached to the column as an attribute. You don’t need to interact with this attribute directly, but there are situations where it’s good to know it’s there.

One issue to do with these attributes, is that a number of R functions in the `base`

package have no respect for attributes. Using the functions `na.omit`

, `subset`

and likely others on `self$data`

, results in the discarding of these attributes. For this reason, it is better to convert these columns to the types you want to use (so the attributes are no longer needed) *before* using these functions.

To convert a `Nominal`

or `Ordinal`

variable (which come through as factors) to a numeric, `jmvcore`

provides the `toNumeric()`

function. To convert in the other direction, from a numeric to a factor, you can use the `factor()`

or `as.factor()`

functions built into R. If `toNumeric()`

is called on a variable which is already numeric, it has no effect. Similarly, if `as.factor()`

is called on a variable which is already a factor, it has no effect. So you can call these on every column, without needing to check whether they are already the correct type.

Returning to our ANCOVA example, which requires a single numeric dependent variable, one or more factors as factors, and one or more covariates as numeric, we might begin the `.run()`

function as follows:

```
.run = function() {
# read the option values into shorter variable names
dep <- self$options$dep
facs <- self$options$factors
covs <- self$options$covs
# get the data
data <- self$data
# convert to appropriate data types
data[[dep]] <- jmvcore::toNumeric(data[[dep]])
for (fac in facs)
data[[fac]] <- as.factor(data[[fac]])
for (cov in covs)
data[[cov]] <- jmvcore::toNumeric(data[[cov]])
# data is now all of the appropriate type we can begin!
data <- na.omit(data)
...
}
```

In this way, one of the first things you will do in the `.run()`

function, is setting up all the columns from `self$data`

to be the correct types.