QUESTIONS:

What the hell is the answer to:

1) Exercise 2: In the editor, three vectors are defined. Each one represents the box office numbers from the first three Star Wars movies. The first element of each vector indicates the US box office revenue, the second element refers to the Non-US box office. In this exercise, you’ll combine all these figures into a single vector with name ‘box_office’. Next construct a ‘matrix star_wars’ with 2 rows and 3 columns.

2) Exercise 1: Write code to create an array ‘l’ with 3 sheets of 2 rows and 4 columns, filled with the first 5 letters of the alphabet.

The possibility to fill a matrix by rows is possibly the only advantage of matrix() over array().

"!(2>3) + 2

[1] FALSE

!(2>3) + 0:5

[1] TRUE FALSE FALSE FALSE FALSE FALSE

z <- (1 > 2)

is.logical(z)

[1] TRUE"

Consulta realizada correctamente

These examples demonstrate how R handles "conflicts" between different types of operations and how it manages collections of data (vectors). 1. !(2>3) + 2 → FALSE

This is another result of Operator Precedence. In R, the addition operator (+) is much stronger than the negation operator (!).

What you expect: NOT (2 > 3) is NOT FALSE, which is TRUE. Then TRUE + 2 should be 3.

What R does: It groups the + 2 with the expression immediately to its left.

    First, it evaluates the comparison: (2 > 3) is FALSE.

    Now the expression is !FALSE + 2.

    Because + happens before !, R calculates FALSE + 2 first.

    FALSE is coerced to 0. So, 0 + 2 = 2.

    Finally, it applies the negation: !2.

    In R, any non-zero number is treated as TRUE for logical operations. Therefore, NOT 2 (NOT TRUE) becomes FALSE.

1. !(2>3) + 0:5 → TRUE FALSE FALSE FALSE FALSE FALSE

This uses the same precedence rule but adds Vectorization into the mix.

Step-by-Step:

    2 > 3 is FALSE.

    0:5 creates a vector: c(0, 1, 2, 3, 4, 5).

    R evaluates the addition first: FALSE + c(0, 1, 2, 3, 4, 5).

    FALSE becomes 0, and is added to every number in the vector (Recycling). Result: c(0, 1, 2, 3, 4, 5).

    Now R applies ! to that entire vector: !c(0, 1, 2, 3, 4, 5).

    The Result:

        !0 is TRUE (because 0 is the only "False" number).

        !1, !2, !3, etc., are all FALSE (because non-zero numbers are "True").

1. z <- (1 > 2) and is.logical(z) → TRUE

This is the simplest case because of the Parentheses.

The parentheses force R to finish the comparison (1 > 2) before doing anything else.

1 > 2 is strictly a logical comparison, so the result stored in z is the logical value FALSE.

Since z is a "logical" data type, is.logical(z) correctly returns TRUE.

The Golden Rule for R Logic

If you are combining a logical test (!, >, ==) with an arithmetic operation (+, *, /), always wrap your logical test in parentheses.

Bad: !x + y (Does !(x+y))

Good: (!x) + y (Does (Not x) + y)

"!(1>2) * 3

[1] TRUE

3 * !(1>2)

[1] 3"

This is a classic "trap" in the R language caused by Operator Precedence. It’s the coding equivalent of the math rule that multiplication comes before addition (BODMAS), but with a twist that is unique to R.

Here is exactly why those two lines give different results: 1. !(1>2) * 3 → TRUE

In R, the multiplication operator (*) has a higher precedence than the negation operator (!).

The Math: R doesn't see "Not (1 > 2), then times 3." Instead, it groups the * and the ! together in a way that prioritizes the multiplication first.

The Step-by-Step:

    First, it evaluates the comparison: (1 > 2) is FALSE.

    Now the expression is !FALSE * 3.

    Because * is stronger than !, R tries to do FALSE * 3 first.

    As we discussed, FALSE is converted to 0. So, 0 * 3 is 0.

    Finally, it applies the ! to that result: !0.

    In R, any number that is exactly 0 is FALSE, and anything else is TRUE. Therefore, !0 becomes TRUE.

1. 3 * !(1>2) → 3

When you flip the order, the grouping changes because the ! is now tucked inside the operation differently.

The Step-by-Step:

    First, it evaluates the comparison: (1 > 2) is FALSE.

    Now the expression is 3 * !FALSE.

    R evaluates the negation: !FALSE is TRUE.

    Now the expression is 3 * TRUE.

    R converts TRUE to 1 for the computation: 3 * 1 is 3.

How to avoid this confusion

The "Safe Way" is to always use parentheses around your logical negations if you plan to do math with them. This forces R to do exactly what you want: R

(!(1 > 2)) * 3

[1] 3

Pro Tip: In the R terminal, you can type ?Syntax to see the full list of which operators are "stronger" than others. You'll see that * and / are way up at the top, while ! is surprisingly far down!

Note that the logical data type objects are automatically converted to a ‘numeric’ type when used inside a computation: TRUE is replaced by 1 and FALSE by 0.2 2

Why isn't FALSE simply 0?

we need to go beyond ethical protocols and into active decolonization

colonial past implications for reciprocity practice

the political problem. How to go beyond academic reciprocity and into social reciprocity.

Similar to the concept of agential realism!

key term here: "ancestors". We need to think of reciprocity in a way that account for the years of exploitation of our ancestors.

Really cool resource to apply to academic work!