Booleans

true and false are their own type: what a comparison yields, what if and while take, and a value you can store, pass and return. Run a cell to see its output beside the expected one.

A comparison is a Bool

It prints as true or false, in every engine. It is not the number 1: there is no arithmetic on it.

Viv [1]

show 2.0 > 1.0
show 2.0 == 3.0

Store one in a variable

A flag is a Bool: a comparison gives one, and and, or and not combine them.

Viv [2]

found = false
n = 7.0
small = n < 10.0
show small
both = small and not found
show both

while not done

not flips a boolean, so while not done keeps looping until done becomes true.

Viv [3]

done = false
count = 0.0
while not done {
    count = count + 1.0
    done = count >= 4.0
}
show count

Functions can return one

Bool is an annotation like Num and Arr. A predicate is an ordinary function.

Viv [4]

def on_boundary(x: Num, y: Num, tol: Num) -> Bool {
    return x < tol or x > 1.0 - tol or y < tol or y > 1.0 - tol
}
show on_boundary(0.0, 0.5, 1.0e-9)
show on_boundary(0.5, 0.5, 1.0e-9)

Bools compare with == and !=

Two Bools can be compared with == and !=, and combined with and, or and not; no other operator accepts them.

Viv [5]

a = 1.0 < 2.0
b = 3.0 < 2.0
show a == b
show a != b
show not b

assert_true takes one

A test can check a condition directly.

Viv [6]

done = 3.0 > 2.0
test "three exceeds two" {
    assert_true(done)
}

and and or stop early

The right side of and runs only when the left side is true, and the right side of or only when the left side is false, so a bounds test can guard the index beside it.

Viv [7]

a = [1.0, 2.0]
j = 0.0
while j < 2.0 and a[j] > 0.0 {
    j = j + 1.0
}
show j

Comparing arrays gives a mask

A comparison with an array on either side is elementwise and gives 1.0 where the comparison is true and 0.0 where it is false. all and any turn a mask into one Bool, and where picks from two values with it.

Viv [8]

x = [-1.0, 2.0, 0.5]
show x > 0.0
show x * (x > 0.0)
show all(x > -2.0)
show any(x > 1.0)
show where(x > 0.0, x, 0.0)

← Numbers & arithmetic Control flow →