Here are a few questions to help you clarify your understanding of bool and its operations.
When comparing discrete types such as short, long, or char, we can use any of the six comparison operators ( == , != , > , >= , < , and <= ). When comparing floating point types such as double, we cannot effectively use the in/equality comparisons ( == and != ) but can freely use the other four relational operators ( > , >= , < , and <= ). The reason here is that floating point numbers which are not an exact power of 2 are stored imprecisely — with roundoff error — most of the time. Finally, when examining the truth of a logical type (bool), we typically don't use the relational/comparison operators at all. Instead we use the operators for logical 'combination': && , ¦¦ , and ! .
Fill in the truth table for logical and (&&):
| X | Y | X && Y |
|---|---|---|
| true | true | true |
| true | false | false |
| false | true | false |
| false | false | false |
Fill in the truth table for logical or (¦¦):
| X | Y | X ¦¦ Y |
|---|---|---|
| true | true | true |
| true | false | true |
| false | true | true |
| false | false | false |
Fill in the truth table for logical not (!):
| X | ! X |
|---|---|
| true | false |
| false | true |
Another common logical operation which is not provided by a standard operator is exclusive or (aka XOR — pronounced zor). Here is its truth table:
| X | Y | X xor Y |
|---|---|---|
| true | true | false |
| true | false | true |
| false | true | true |
| false | false | false |
As you can see, it results in true when only one of its operands is true and false otherwise. (Hence its exclusivity...) Show a single bool expression to produce an XOR effect by using &&, ¦¦, and/or ! in combination.
(C) (D)
A | B | A ¦¦ B | !(A && B) | C && D
-------+-------+----------+-------------+----------
true | true | true | false | false
true | false | true | true | true
false | true | true | true | true
false | false | false | true | false
Given these declarations and initializations:
short x = 4, y = 9;
double a = 4.0, b = 10.0;
char m = '*', n = '8';
Evaluate the following expressions:
x <= 5 && a == 4 b == 10 ¦¦ n == 8
true && true ???? ¦¦ false
true ????
a > 3 && b < 20 m == '*' && n <= '9'
true && true true && true
true true
(x+1)%10 == 0 b > y && a < x
5 %10 == 0 true && false
5 == 0 false
false
y%2 != 0 b > n ¦¦ y == 9
1 != 0 false ¦¦ true
true true
Given these declarations and initializations:
bool x = true, y = false;
Evaluate the following expressions:
x && y x ¦¦ y
false true
x y
true false
!x && y x ¦¦ !y
false true
!x !y
false true
Describe DeMorgan's laws.
These laws explain the properties of AND and OR operations when a
logical negation is applied:
!(A && B) = !A ¦¦ !B
!(A ¦¦ B) = !A && !B
How do these laws apply in programming in general?
When you take the opposite of a logical AND or OR operation, you
reduce the number of actions by one:
Test | Actions to Evaluate
| Normal | Short-Circuit
------------------+------------+----------------
!(x < a ¦¦ x > b) | 4 | 2
x >= a && x <= b | 3 | 1
How do these laws differ from the distribution of negation in numerical algebra?
In numerical algebra, the addends are negated, but the operation
totaling them is not altered:
-(x + y) = -x + -y
-(x - y) = -x - -y
Show code to produce true when a virtual coin toss comes up heads and false when the toss turns up tails.
(bool)(rand() % 2)
Show code to produce true when a generic event which probabilistically occurs does so and false when the event does not happen. Assume that the likelihood of this event happening is given in the variable prob. Be sure to test with the probability not only as 50%, but also as off-center things like 60% or 25%.
rand() % RAND_MAX / (RAND_MAX - 1.0) <= prob
Re-write your coin tossing code to (re)use your generic event happening code.
prob = .5;
// repeat <= code above