# Distinguish between Cases Specified by Logical Conditions¶

## Description¶

`cases`

allows to distinguish several cases defined logical conditions. It can be used
to code these cases into a vector. The function can be considered as a multi-condition
generalization of `ifelse`

.

## Usage¶

```
cases(...,check.xor)
```

## Arguments¶

`...`

A sequence of logical expressions or assignment expressions containing logical expressions as “right hand side”.

`check.xor`

character (either

`"warn"`

,`"stop"`

, or`"ignore"`

) or logical; if`TRUE`

or equal to`"stop"`

or`"warn"`

,`cases`

checks, whether the case conditions are mutually exclusive and exhaustive. If this is not satisfied and`check.xor`

equals`"warn"`

a warning is shown, otherwise an error exception is raised.

## Value¶

If it is called with logical expressions as … arguments, `cases`

returns a factor, if
it is called with assignment expressions the function returns a vector with the same mode
as the results of the “assigned” expressions and with the same length as the logical
conditions.

## Details¶

There are two distinct ways to use this function. Either the function can be used to
construct a factor that represents several logical cases or it can be used to
conditionally evaluate an expression in a manner similar to `ifelse`

.

For the first use, the `...`

arguments have to be a series of logical expressions.
`cases`

then returns a factor with as many levels as logical expressions given as
`...`

arguments. The resulting factor will attain its first level if the first
condition is TRUE, otherwise it will attain its second level if the second condition is
TRUE, etc. The levels will be named after the conditions or, if name tags are attached
to the logical expressions, after the tags of the expressions. Not that the logical
expressions all need to evaluate to logical vectors of the same length, otherwise an
error condition is raised.

For the second use, the `...`

arguments have to be a series of assignment expression of
the type `<expression> <- <logical expression>`

or ```
<logical expression> ->
<expression>
```

. For cases in which the first logical expression is TRUE, the result of
first expression that appears on the other side of the assignment operator become
elements of the vector returned by `cases`

, for cases in which the second logical
expression is TRUE, the result of the second expression that appears on the other side of
the assignment operator become elements of the vector returned by `cases`

, etc. Note
that the logical expressions also here all need to evaluate to logical vectors of the
same length. The expressions on the other side of the assignment operator should also be
either vectors of the same length and mode or should scalars of the same mode, otherwise
unpredictable results may occur.

## Examples¶

```
# Examples of the first kind of usage of the function
#
df <- data.frame(x = rnorm(n=20), y = rnorm(n=20))
df <- df[do.call(order,df),]
(df <- within(df,{
x1=cases(x>0,x<=0)
y1=cases(y>0,y<=0)
z1=cases(
"Condition 1"=x<0,
"Condition 2"=y<0,# only applies if x >= 0
"Condition 3"=TRUE
)
z2=cases(x<0,(x>=0 & y <0), (x>=0 & y >=0))
}))
```

```
Warning in cases(`Condition 1` = x < 0, `Condition 2` = y < 0, `Condition 3` =
TRUE) :
conditions are not mutually exclusive
x y z2 z1 y1 x1
13 -1.71980034 -0.06460691 x < 0 Condition 1 y <= 0 x <= 0
5 -1.22081309 0.37023528 x < 0 Condition 1 y > 0 x <= 0
9 -1.12897740 -0.34792961 x < 0 Condition 1 y <= 0 x <= 0
3 -1.02920881 -1.20653907 x < 0 Condition 1 y <= 0 x <= 0
4 -0.96695590 -0.60388117 x < 0 Condition 1 y <= 0 x <= 0
1 -0.72015354 3.22906950 x < 0 Condition 1 y > 0 x <= 0
8 -0.41294485 -1.12182261 x < 0 Condition 1 y <= 0 x <= 0
14 -0.35690666 -0.70523710 x < 0 Condition 1 y <= 0 x <= 0
18 -0.33358539 -0.34782808 x < 0 Condition 1 y <= 0 x <= 0
2 -0.19812433 0.92045257 x < 0 Condition 1 y > 0 x <= 0
10 -0.08793133 1.23890215 x < 0 Condition 1 y > 0 x <= 0
16 -0.03824410 -1.09651319 x < 0 Condition 1 y <= 0 x <= 0
20 0.22424124 1.60723456 (x >= 0 & y >= 0) Condition 3 y > 0 x > 0
19 0.60498592 0.53212862 (x >= 0 & y >= 0) Condition 3 y > 0 x > 0
6 0.83620770 -1.90100065 (x >= 0 & y < 0) Condition 2 y <= 0 x > 0
7 1.11497180 -1.80440994 (x >= 0 & y < 0) Condition 2 y <= 0 x > 0
15 1.53328049 1.36219727 (x >= 0 & y >= 0) Condition 3 y > 0 x > 0
17 1.59741324 -0.22843352 (x >= 0 & y < 0) Condition 2 y <= 0 x > 0
12 2.04131317 0.16238072 (x >= 0 & y >= 0) Condition 3 y > 0 x > 0
11 2.24190369 -0.27419756 (x >= 0 & y < 0) Condition 2 y <= 0 x > 0
```

```
xtabs(~x1+y1,data=df)
```

```
y1
x1 y > 0 y <= 0
x > 0 4 4
x <= 0 4 8
```

```
dd <- with(df,
try(cases(x<0,
x>=0,
x>1,
check.xor=TRUE)# let's be fussy
)
)
```

```
Error in cases(x < 0, x >= 0, x > 1, check.xor = TRUE) :
conditions are not mutually exclusive
```

```
dd <- with(df,
cases(x<0,x>=0,x>1)
)
```

```
Warning in cases(x < 0, x >= 0, x > 1) :
conditions are not mutually exclusive
```

```
genTable(range(x)~dd,data=df)
```

```
dd
x < 0 x >= 0
1 -1.7198003 0.2242412
2 -0.0382441 2.2419037
```

```
# An example of the second kind of usage of the function:
# A construction of a non-smooth function
#
fun <- function(x)
cases(
x==0 -> 1,
abs(x)> 1 -> abs(x),
abs(x)<=1 -> x^2
)
x <- seq(from=-2,to=2,length=101)
plot(fun(x)~x)
```

```
Warning in cases(1 <- x == 0, abs(x) <- abs(x) > 1, x^2 <- abs(x) <= 1) :
conditions are not mutually exclusive
Loading required package: svglite
```