## Exercises

R has a function called

`t()`

that computes the*transpose*of a given matrix. This means that it switches around the rows and columns of the matrix, like this:`myMatrix <- matrix(1:24, nrow = 6) myMatrix`

`## [,1] [,2] [,3] [,4] ## [1,] 1 7 13 19 ## [2,] 2 8 14 20 ## [3,] 3 9 15 21 ## [4,] 4 10 16 22 ## [5,] 5 11 17 23 ## [6,] 6 12 18 24`

`t(myMatrix)`

`## [,1] [,2] [,3] [,4] [,5] [,6] ## [1,] 1 2 3 4 5 6 ## [2,] 7 8 9 10 11 12 ## [3,] 13 14 15 16 17 18 ## [4,] 19 20 21 22 23 24`

Write your own function called

`transpose()`

that will perform the same task on any given matrix. The function should take a single parameter called`mat`

, the matrix to be transposed.**Of course you may NOT use**`t()`

in the code for your function!**Hints:**Your function will have to:- break
`mat`

down into the vector of its elements, and then - build the new matrix from those elements, with a number of rows equal to the number of columns of
`mat`

.

For the first task,

`as.vector()`

will be useful.For the second task, recall (see previous Practice Exercises from this Chapter) that there is a function

`nrow()`

that returns the number of rows of a given matrix. It will also be helpful to remember the function`ncol()`

that computes the number of columns of a given matrix.- break
R has functions called

`rowSums()`

and`colSums()`

that will respectively sum the rows and the columns of a matrix. Here is an example:`myMatrix <- matrix(1:24, nrow = 6) rowSums(myMatrix)`

Your task is to write your own function called`## [1] 40 44 48 52 56 60`

`dimSum()`

that will sum either the rows or the columns of a given matrix. The function should have two parameters:`mat`

: the matrix to be summed.`dim`

: the dimension to sum along, either rows or columns. The default value should be`"rows"`

. If the user sets`dim`

to`"columns"`

then the function would compute the column-sums.

**You may NOT use**A typical example of use should look like this:`rowSums()`

or`colSums()`

in the code for your function.`myMatrix <- matrix(1:24, nrow = 6) dimSum(myMatrix)`

`## [1] 40 44 48 52 56 60`

`dimSum(myMatrix, "columns")`

`## [1] 21 57 93 129`

**Hint**: Recall that in previous Practice Exercises of this Chapter we made a function called`myRowSums()`

that sums the rows of any given matrix. Modify the idea for`myRowSums()`

to write a function called`myColSums()`

that finds the column-sums of any given matrix. You may then use the two previously-created functions to write the required function`dimsum()`

.Starting with

`m111survey`

in the**bcscr**package, write the code necessary to create a new data frame called`smaller`

that consists precisely of the male students who believe in extraterrestrial life and who are more than 68 inches tall. The new data frame should contain all of the original variables except for`sex`

and`extra_life`

.- Write a function called
`dfRandSelect()`

that randomly selects (without replacement) a specified number of rows from a given data frame. The function should have two parameters:`df`

: the data frame from which to select;`n`

: the number of rows to select.

If

`n`

is greater than the number of rows in`df`

, the function should return immediately with a message informing the user that the required task is not possible and informing him/her of the number of rows in`df`

. Typical examples of use should be as follows:`dfRandSelect(bcscr::fuel, 5)`

`## speed efficiency ## 10 100 8.27 ## 6 60 5.90 ## 9 90 7.57 ## 14 140 11.77 ## 2 20 13.00`

`dfRandSelect(bcscr::fuel, 200)`

`## No can do! The frame has only 15 rows.`

**Hint**: Use the function`nrow()`

, which gives the number of rows of a matrix or data frame. - (*) Create your own data frame, named
`myFrame`

. The frame should have 100 rows, along with the following variables:`lowerLetters`

: a character vector randomly-produced 3-letter strings, like “chj”, “bbw”, and so on. The letters should all be lowercase.`height`

: a numerical vector consisting of real numbers chosen randomly between the values of 60 and 75.`sex`

: a factor whose possible value are “female” and “male”. Again, these values should be chosen randomly.

A call to

`str(myFrame)`

would come out*like*this (although your results will vary a bit since the vectors are constructed randomly):`str(myFrame)`

`## 'data.frame': 100 obs. of 3 variables: ## $ lowerLetters: chr "hst" "stx" "knq" "bit" ... ## $ height : num 68.6 67 63.1 70.7 62 ... ## $ sex : Factor w/ 2 levels "female","male": 2 2 1 1 1 2 1 1 2 2 ...`

`summary()`

is useful when working with data frames. Here is how a call to`summary(myFrame)`

might look:`summary(myFrame)`

`## lowerLetters height sex ## Length:100 Min. :60.63 female:46 ## Class :character 1st Qu.:64.14 male :54 ## Mode :character Median :68.56 ## Mean :68.06 ## 3rd Qu.:71.91 ## Max. :74.58`

**Hint**: If you have a vector of three letters, such as`vec <- c("g", "a", "r")`

then you can paste them together as follows:

`paste0(vec, collapse = "")`

`## [1] "gar"`

(*) Study the data frame

`fuel`

in the**bcscr**package. Note that the fuel efficiency is reported as the number of liters of fuel required to travel 100 kilometers. Look up the conversion between gallons and liters and between kilometers and miles, and use this information to create a new variable called`mpg`

that gives the fuel efficiency as miles per gallon. While you are at it, create a new variable`mph`

that gives the speed in miles per hour. Finally, add these new variables to the`fuel`

data frame.- (*) Use matrices to generalize the simulation in the Appeals Court Paradox (see Section 6.5). Your goal is to write a simulation function called
`appealsSimPlus()`

that comes with all the options provided in the text, but with additional parameters so that the user can choose:- the number of judges on the court;
- the probability for each judge to make a correct decision;
- the voting pattern (how many votes each judge gets).

A typical call to the functions should look like this:

`appealsSimPlus(reps = 10000, seed = 5252, probs = c(0.95, 0.90, 0.90, 0.90, 0.80), votes = c(2, 1, 1, 1, 0))`

In the above call the court consists of five judges. The best one decides cases correctly 95% of the time, three are right 90% of the time and one is right 80%of the time. The voting arrangement is that the best judge gets two votes, the next three get one vote each, and the worst gets no vote. Any voting scheme—even a scheme involving fractional votes—should be allowed so long as the votes add up to the number of judges.

**Here is a hint.**When you write the function it may be helpful to use the fact that`rbinom()`

can take a`prob`

parameter that is a vector of any length. Here’s an example:`results <- rbinom(6, size = 100, prob = c(0.10, 0.50, 0.90)) results`

`## [1] 20 49 94 15 50 88`

The first and fourth entries simulate a person tossing a fair coin 100 times when she has only a 10% chance of heads. The second and fifth entries simulate the same, when the chance of heads is 50%. The third and sixth simulate coin-tossing when there is a 90% chance of heads.

If you would like to arrange the results more nicely—say in a matrix where each column gives the results for a different person—you can do so:

`resultsMat <- matrix(results, ncol = 3, byrow = TRUE) resultsMat`

`## [,1] [,2] [,3] ## [1,] 20 49 94 ## [2,] 15 50 88`

Of course judges don’t flip a coin 100 times, they decide one case at a time. Suppose you have five judges with probabilities as follows:

`probCorrect <- c(0.95, 0.90, 0.90, 0.90, 0.80)`

If you would like to simulate the judges deciding, say, 6 cases, try this:

`results <- rbinom(5*6, size = 1, prob= rep(probCorrect, 6)) resultsMat <- matrix(results, nrow = 6, byrow = TRUE) resultsMat`

`## [,1] [,2] [,3] [,4] [,5] ## [1,] 1 1 1 0 1 ## [2,] 0 1 1 1 1 ## [3,] 1 1 1 1 1 ## [4,] 1 1 1 1 1 ## [5,] 1 1 1 1 1 ## [6,] 1 1 1 1 0`

When it comes to applying the voting pattern to compute the decision in each case, consider matrix multiplication. For example, suppose that the pattern is:

`votes <- c(2, 1, 1, 1, 0)`

Then make

`votes`

a one-column matrix and perform matrix multiplication:`correctVotes <- resultsMat %*% matrix(votes, nrow = 5) correctVotes`

`## [,1] ## [1,] 4 ## [2,] 3 ## [3,] 5 ## [4,] 5 ## [5,] 5 ## [6,] 5`

Think about how to encapsulate all of this into a nice, general simulation function.