This commit is contained in:
commit
568474d52f
1591 files changed
+528213
No files matched your search
@@ -0,0 +1,26 @@
|
||||
// Numbers: every arithmetic operator, both numeric types, and the conversions between them.
|
||||
// EXPECT: 3.5
|
||||
// EXPECT: 3
|
||||
// EXPECT: 1
|
||||
// EXPECT: -4
|
||||
// EXPECT: 512
|
||||
// EXPECT: 2.0
|
||||
// EXPECT: 27
|
||||
// EXPECT: 28
|
||||
// EXPECT: 5
|
||||
// EXPECT: 7 -7 -7
|
||||
DECLARE A, B : INTEGER
|
||||
DECLARE X : FLOAT
|
||||
A <- 7
|
||||
B <- 2
|
||||
OUTPUT A / B
|
||||
OUTPUT A DIV B
|
||||
OUTPUT A MOD B
|
||||
OUTPUT -2 ^ 2
|
||||
OUTPUT 2 ^ 3 ^ 2
|
||||
OUTPUT 4 / 2
|
||||
X <- 27.54
|
||||
OUTPUT INT(X)
|
||||
OUTPUT ROUND(X)
|
||||
OUTPUT ABS(-5)
|
||||
OUTPUT 7 DIV 1, " ", -7 DIV 1, " ", (-7) DIV 1
|
||||
@@ -0,0 +1,11 @@
|
||||
// A FLOAT formula with a FUNCTION; classic first program in any language.
|
||||
// EXPECT: 212.0
|
||||
// EXPECT: 37.0
|
||||
FUNCTION TO_FAHRENHEIT(C : FLOAT) RETURNS FLOAT
|
||||
RETURN C * 9 / 5 + 32
|
||||
ENDFUNCTION
|
||||
FUNCTION TO_CELSIUS(F : FLOAT) RETURNS FLOAT
|
||||
RETURN (F - 32) * 5 / 9
|
||||
ENDFUNCTION
|
||||
OUTPUT TO_FAHRENHEIT(100.0)
|
||||
OUTPUT TO_CELSIUS(98.6)
|
||||
@@ -0,0 +1,11 @@
|
||||
// Finance flavor: a loop that updates a FLOAT, with ROUND for reporting.
|
||||
// EXPECT: 1628.89
|
||||
FUNCTION BALANCE_AFTER(Principal : FLOAT, Rate : FLOAT, Years : INTEGER) RETURNS FLOAT
|
||||
DECLARE B : FLOAT
|
||||
B <- Principal
|
||||
FOR Y <- 0 TO Years
|
||||
B <- B * (1 + Rate)
|
||||
NEXT Y
|
||||
RETURN B
|
||||
ENDFUNCTION
|
||||
OUTPUT ROUND(BALANCE_AFTER(1000.0, 0.05, 10) * 100) / 100
|
||||
@@ -0,0 +1,13 @@
|
||||
// Recursion with a DECREASES measure and a REQUIRE.
|
||||
// EXPECT: 6
|
||||
// EXPECT: 1
|
||||
FUNCTION GCD(A : INTEGER, B : INTEGER) RETURNS INTEGER
|
||||
REQUIRE A >= 0 AND B >= 0
|
||||
DECREASES B
|
||||
IF B == 0 THEN
|
||||
RETURN A
|
||||
ENDIF
|
||||
RETURN GCD(B, A MOD B)
|
||||
ENDFUNCTION
|
||||
OUTPUT GCD(48, 18)
|
||||
OUTPUT GCD(17, 5)
|
||||
@@ -0,0 +1,19 @@
|
||||
// An ARRAY of BOOL, nested loops with STEP, and a LIST answer.
|
||||
// EXPECT: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
|
||||
FUNCTION PRIMES_UP_TO(N : INTEGER) RETURNS LIST OF INTEGER
|
||||
DECLARE IsPrime : ARRAY[N + 1] OF BOOL
|
||||
DECLARE Found : LIST OF INTEGER
|
||||
FOR I <- 0 TO N + 1
|
||||
IsPrime[I] <- I >= 2
|
||||
NEXT I
|
||||
FOR I <- 2 TO N + 1
|
||||
IF IsPrime[I] THEN
|
||||
APPEND(Found, I)
|
||||
FOR J <- I * I TO N + 1 STEP I
|
||||
IsPrime[J] <- FALSE
|
||||
NEXT J
|
||||
ENDIF
|
||||
NEXT I
|
||||
RETURN Found
|
||||
ENDFUNCTION
|
||||
OUTPUT PRIMES_UP_TO(30)
|
||||
@@ -0,0 +1,25 @@
|
||||
// Memoized recursion. A FUNCTION cannot take BYREF, so the memo table has to travel through a PROCEDURE
|
||||
// with the answer coming back BYREF too. Finding: this is the idiom; it reads heavier than in most languages.
|
||||
// EXPECT: 6765
|
||||
// EXPECT: 12586269025
|
||||
PROCEDURE FIB(N : INTEGER, BYREF Memo : HASHMAP OF INTEGER : INTEGER, BYREF Result : INTEGER)
|
||||
IF N < 2 THEN
|
||||
Result <- N
|
||||
RETURN
|
||||
ENDIF
|
||||
IF N IN Memo THEN
|
||||
Result <- Memo[N]
|
||||
RETURN
|
||||
ENDIF
|
||||
DECLARE A, B : INTEGER
|
||||
CALL FIB(N - 1, Memo, A)
|
||||
CALL FIB(N - 2, Memo, B)
|
||||
Memo[N] <- A + B
|
||||
Result <- A + B
|
||||
ENDPROCEDURE
|
||||
DECLARE M : HASHMAP OF INTEGER : INTEGER
|
||||
DECLARE R : INTEGER
|
||||
CALL FIB(20, M, R)
|
||||
OUTPUT R
|
||||
CALL FIB(50, M, R)
|
||||
OUTPUT R
|
||||
@@ -0,0 +1,34 @@
|
||||
// Text flavor: splitting a sentence into words by hand, since the notation has no SPLIT, then tallying.
|
||||
// EXPECT: {"a": 2, "is": 2, "rose": 3}
|
||||
// A HASHMAP prints its keys smallest first, whatever order they were added in.
|
||||
FUNCTION WORDS(S : STRING) RETURNS LIST OF STRING
|
||||
DECLARE Out : LIST OF STRING
|
||||
DECLARE W : STRING
|
||||
W <- ""
|
||||
FOR EACH C IN S
|
||||
IF C == ' ' THEN
|
||||
IF LENGTH(W) > 0 THEN
|
||||
APPEND(Out, W)
|
||||
ENDIF
|
||||
W <- ""
|
||||
ELSE
|
||||
W <- W & C
|
||||
ENDIF
|
||||
NEXT C
|
||||
IF LENGTH(W) > 0 THEN
|
||||
APPEND(Out, W)
|
||||
ENDIF
|
||||
RETURN Out
|
||||
ENDFUNCTION
|
||||
FUNCTION TALLY(Ws : LIST OF STRING) RETURNS HASHMAP OF STRING : INTEGER
|
||||
DECLARE T : HASHMAP OF STRING : INTEGER
|
||||
FOR EACH W IN Ws
|
||||
IF W IN T THEN
|
||||
T[W] <- T[W] + 1
|
||||
ELSE
|
||||
T[W] <- 1
|
||||
ENDIF
|
||||
NEXT W
|
||||
RETURN T
|
||||
ENDFUNCTION
|
||||
OUTPUT TALLY(WORDS("a rose is a rose is rose"))
|
||||
@@ -0,0 +1,17 @@
|
||||
// Cryptography flavor: CHAR arithmetic with ORD and CHR, MOD to wrap.
|
||||
// EXPECT: KHOOR, ZRUOG!
|
||||
// EXPECT: HELLO, WORLD!
|
||||
FUNCTION SHIFT(S : STRING, K : INTEGER) RETURNS STRING
|
||||
DECLARE Out : STRING
|
||||
Out <- ""
|
||||
FOR EACH C IN S
|
||||
IF C >= 'A' AND C <= 'Z' THEN
|
||||
Out <- Out & CHR((ORD(C) - ORD('A') + K) MOD 26 + ORD('A'))
|
||||
ELSE
|
||||
Out <- Out & C
|
||||
ENDIF
|
||||
NEXT C
|
||||
RETURN Out
|
||||
ENDFUNCTION
|
||||
OUTPUT SHIFT("HELLO, WORLD!", 3)
|
||||
OUTPUT SHIFT(SHIFT("HELLO, WORLD!", 3), 23)
|
||||
@@ -0,0 +1,17 @@
|
||||
// Two positions moving toward each other; a WHILE with a compound guard.
|
||||
// EXPECT: TRUE
|
||||
// EXPECT: FALSE
|
||||
// EXPECT: TRUE
|
||||
FUNCTION IS_PALINDROME(S : STRING) RETURNS BOOL
|
||||
DECLARE Lo, Hi : INTEGER
|
||||
Lo <- 0
|
||||
Hi <- LENGTH(S) - 1
|
||||
WHILE Lo < Hi AND S[Lo] == S[Hi]
|
||||
Lo <- Lo + 1
|
||||
Hi <- Hi - 1
|
||||
ENDWHILE
|
||||
RETURN Lo >= Hi
|
||||
ENDFUNCTION
|
||||
OUTPUT IS_PALINDROME("racecar")
|
||||
OUTPUT IS_PALINDROME("rose")
|
||||
OUTPUT IS_PALINDROME("")
|
||||
@@ -0,0 +1,19 @@
|
||||
// An in-place sort with a PROCEDURE and BYREF, plus a loop invariant.
|
||||
// EXPECT: [1, 2, 3, 5, 8, 9]
|
||||
PROCEDURE INSERTION_SORT(BYREF L : LIST OF INTEGER)
|
||||
FOR I <- 1 TO LENGTH(L)
|
||||
INVARIANT FORALL K IN [1, I) : L[K - 1] <= L[K]
|
||||
DECLARE Key, J : INTEGER
|
||||
Key <- L[I]
|
||||
J <- I - 1
|
||||
WHILE J >= 0 AND L[J] > Key
|
||||
L[J + 1] <- L[J]
|
||||
J <- J - 1
|
||||
ENDWHILE
|
||||
L[J + 1] <- Key
|
||||
NEXT I
|
||||
ENDPROCEDURE
|
||||
DECLARE Xs : LIST OF INTEGER
|
||||
Xs <- [5, 2, 9, 1, 8, 3]
|
||||
CALL INSERTION_SORT(Xs)
|
||||
OUTPUT Xs
|
||||
@@ -0,0 +1,27 @@
|
||||
// Two-dimensional ARRAYs, triple nested loops, ROWS and COLUMNS.
|
||||
// EXPECT: 19 22
|
||||
// EXPECT: 43 50
|
||||
FUNCTION MATMUL(A : ARRAY[2, 2] OF INTEGER, B : ARRAY[2, 2] OF INTEGER) RETURNS ARRAY[2, 2] OF INTEGER
|
||||
DECLARE C : ARRAY[ROWS(A), COLUMNS(B)] OF INTEGER
|
||||
FOR I <- 0 TO ROWS(A)
|
||||
FOR J <- 0 TO COLUMNS(B)
|
||||
C[I, J] <- 0
|
||||
FOR K <- 0 TO COLUMNS(A)
|
||||
C[I, J] <- C[I, J] + A[I, K] * B[K, J]
|
||||
NEXT K
|
||||
NEXT J
|
||||
NEXT I
|
||||
RETURN C
|
||||
ENDFUNCTION
|
||||
DECLARE A, B, C : ARRAY[2, 2] OF INTEGER
|
||||
A[0, 0] <- 1
|
||||
A[0, 1] <- 2
|
||||
A[1, 0] <- 3
|
||||
A[1, 1] <- 4
|
||||
B[0, 0] <- 5
|
||||
B[0, 1] <- 6
|
||||
B[1, 0] <- 7
|
||||
B[1, 1] <- 8
|
||||
C <- MATMUL(A, B)
|
||||
OUTPUT C[0, 0], " ", C[0, 1]
|
||||
OUTPUT C[1, 0], " ", C[1, 1]
|
||||
@@ -0,0 +1,37 @@
|
||||
// Records in a LIST, a FUNCTION over them, and "find the best".
|
||||
// EXPECT: Bob
|
||||
// EXPECT: 86.5
|
||||
TYPE Student
|
||||
DECLARE Name : STRING
|
||||
DECLARE Marks : LIST OF INTEGER
|
||||
ENDTYPE
|
||||
FUNCTION MEAN(Xs : LIST OF INTEGER) RETURNS FLOAT
|
||||
REQUIRE LENGTH(Xs) >= 1
|
||||
DECLARE Total : INTEGER
|
||||
Total <- 0
|
||||
FOR EACH X IN Xs
|
||||
Total <- Total + X
|
||||
NEXT X
|
||||
RETURN Total / LENGTH(Xs)
|
||||
ENDFUNCTION
|
||||
FUNCTION TOP(Ss : LIST OF Student) RETURNS Student
|
||||
REQUIRE LENGTH(Ss) >= 1
|
||||
DECLARE Best : Student
|
||||
Best <- Ss[0]
|
||||
FOR EACH S IN Ss
|
||||
IF MEAN(S.Marks) > MEAN(Best.Marks) THEN
|
||||
Best <- S
|
||||
ENDIF
|
||||
NEXT S
|
||||
RETURN Best
|
||||
ENDFUNCTION
|
||||
DECLARE A, B : Student
|
||||
DECLARE Class : LIST OF Student
|
||||
A.Name <- "Ann"
|
||||
A.Marks <- [70, 80, 90]
|
||||
B.Name <- "Bob"
|
||||
B.Marks <- [88, 85]
|
||||
APPEND(Class, A)
|
||||
APPEND(Class, B)
|
||||
OUTPUT TOP(Class).Name
|
||||
OUTPUT MEAN(TOP(Class).Marks)
|
||||
@@ -0,0 +1,25 @@
|
||||
// A LIST used as a stack: APPEND to push, REMOVE the last to pop. Balanced brackets.
|
||||
// EXPECT: TRUE
|
||||
// EXPECT: FALSE
|
||||
// EXPECT: FALSE
|
||||
FUNCTION BALANCED(S : STRING) RETURNS BOOL
|
||||
DECLARE Stack : LIST OF CHAR
|
||||
DECLARE Pairs : HASHMAP OF CHAR : CHAR
|
||||
Pairs[')'] <- '('
|
||||
Pairs[']'] <- '['
|
||||
Pairs['}'] <- '{'
|
||||
FOR EACH C IN S
|
||||
IF C == '(' OR C == '[' OR C == '{' THEN
|
||||
APPEND(Stack, C)
|
||||
ELSEIF C IN Pairs THEN
|
||||
IF LENGTH(Stack) == 0 OR Stack[LENGTH(Stack) - 1] != Pairs[C] THEN
|
||||
RETURN FALSE
|
||||
ENDIF
|
||||
REMOVE(Stack, LENGTH(Stack) - 1)
|
||||
ENDIF
|
||||
NEXT C
|
||||
RETURN LENGTH(Stack) == 0
|
||||
ENDFUNCTION
|
||||
OUTPUT BALANCED("{[()()]}")
|
||||
OUTPUT BALANCED("([)]")
|
||||
OUTPUT BALANCED("((")
|
||||
@@ -0,0 +1,30 @@
|
||||
// Graph flavor: breadth-first search with a LIST as a queue (REMOVE at 0) and a SET of seen nodes.
|
||||
// Finding: a neighbor cannot be called Next, because names ignore case and NEXT is a keyword.
|
||||
// EXPECT: [0, 1, 2, 3, 4]
|
||||
FUNCTION BFS(Adj : HASHMAP OF INTEGER : LIST OF INTEGER, Start : INTEGER) RETURNS LIST OF INTEGER
|
||||
DECLARE Queue, Order : LIST OF INTEGER
|
||||
DECLARE Seen : SET OF INTEGER
|
||||
APPEND(Queue, Start)
|
||||
ADD(Seen, Start)
|
||||
WHILE LENGTH(Queue) > 0
|
||||
DECLARE Node : INTEGER
|
||||
Node <- Queue[0]
|
||||
REMOVE(Queue, 0)
|
||||
APPEND(Order, Node)
|
||||
IF Node IN Adj THEN
|
||||
FOR EACH Nb IN Adj[Node]
|
||||
IF NOT (Nb IN Seen) THEN
|
||||
ADD(Seen, Nb)
|
||||
APPEND(Queue, Nb)
|
||||
ENDIF
|
||||
NEXT Nb
|
||||
ENDIF
|
||||
ENDWHILE
|
||||
RETURN Order
|
||||
ENDFUNCTION
|
||||
DECLARE G : HASHMAP OF INTEGER : LIST OF INTEGER
|
||||
G[0] <- [1, 2]
|
||||
G[1] <- [3]
|
||||
G[2] <- [3, 4]
|
||||
G[3] <- [4]
|
||||
OUTPUT BFS(G, 0)
|
||||
@@ -0,0 +1,49 @@
|
||||
// Simulation flavor: one step of Conway's Life on a small two-dimensional ARRAY; a blinker turns.
|
||||
// Finding: the function cannot be called STEP, nor the new grid Next: both are keywords, whatever their case.
|
||||
// EXPECT: 0 1 0
|
||||
// EXPECT: 0 1 0
|
||||
// EXPECT: 0 1 0
|
||||
FUNCTION NEIGHBORS(G : ARRAY[3, 3] OF INTEGER, R : INTEGER, C : INTEGER) RETURNS INTEGER
|
||||
DECLARE N : INTEGER
|
||||
N <- 0
|
||||
FOR DR <- -1 TO 2
|
||||
FOR DC <- -1 TO 2
|
||||
IF NOT (DR == 0 AND DC == 0) THEN
|
||||
IF R + DR >= 0 AND R + DR < ROWS(G) AND C + DC >= 0 AND C + DC < COLUMNS(G) THEN
|
||||
N <- N + G[R + DR, C + DC]
|
||||
ENDIF
|
||||
ENDIF
|
||||
NEXT DC
|
||||
NEXT DR
|
||||
RETURN N
|
||||
ENDFUNCTION
|
||||
FUNCTION LIFE_STEP(G : ARRAY[3, 3] OF INTEGER) RETURNS ARRAY[3, 3] OF INTEGER
|
||||
DECLARE After : ARRAY[3, 3] OF INTEGER
|
||||
FOR R <- 0 TO 3
|
||||
FOR C <- 0 TO 3
|
||||
DECLARE N : INTEGER
|
||||
N <- NEIGHBORS(G, R, C)
|
||||
IF G[R, C] == 1 AND (N == 2 OR N == 3) THEN
|
||||
After[R, C] <- 1
|
||||
ELSEIF G[R, C] == 0 AND N == 3 THEN
|
||||
After[R, C] <- 1
|
||||
ELSE
|
||||
After[R, C] <- 0
|
||||
ENDIF
|
||||
NEXT C
|
||||
NEXT R
|
||||
RETURN After
|
||||
ENDFUNCTION
|
||||
DECLARE G : ARRAY[3, 3] OF INTEGER
|
||||
FOR R <- 0 TO 3
|
||||
FOR C <- 0 TO 3
|
||||
G[R, C] <- 0
|
||||
NEXT C
|
||||
NEXT R
|
||||
G[1, 0] <- 1
|
||||
G[1, 1] <- 1
|
||||
G[1, 2] <- 1
|
||||
G <- LIFE_STEP(G)
|
||||
FOR R <- 0 TO 3
|
||||
OUTPUT G[R, 0], " ", G[R, 1], " ", G[R, 2]
|
||||
NEXT R
|
||||
@@ -0,0 +1,29 @@
|
||||
// Statistics flavor: mean and variance in one pass (Welford), returning two values through a record.
|
||||
// EXPECT: 5.0
|
||||
// EXPECT: 4.0
|
||||
TYPE Stats
|
||||
DECLARE Mean : FLOAT
|
||||
DECLARE Variance : FLOAT
|
||||
ENDTYPE
|
||||
FUNCTION RUNNING(Xs : LIST OF FLOAT) RETURNS Stats
|
||||
REQUIRE LENGTH(Xs) >= 2
|
||||
DECLARE N : INTEGER
|
||||
DECLARE Mean, M2, Delta : FLOAT
|
||||
DECLARE Out : Stats
|
||||
N <- 0
|
||||
Mean <- 0.0
|
||||
M2 <- 0.0
|
||||
FOR EACH X IN Xs
|
||||
N <- N + 1
|
||||
Delta <- X - Mean
|
||||
Mean <- Mean + Delta / N
|
||||
M2 <- M2 + Delta * (X - Mean)
|
||||
NEXT X
|
||||
Out.Mean <- Mean
|
||||
Out.Variance <- M2 / N
|
||||
RETURN Out
|
||||
ENDFUNCTION
|
||||
DECLARE S : Stats
|
||||
S <- RUNNING([2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0])
|
||||
OUTPUT S.Mean
|
||||
OUTPUT S.Variance
|
||||
@@ -0,0 +1,17 @@
|
||||
// CASE with half-open ranges on a FLOAT, and OTHERWISE.
|
||||
// EXPECT: A
|
||||
// EXPECT: B
|
||||
// EXPECT: F
|
||||
FUNCTION GRADE(Score : FLOAT) RETURNS STRING
|
||||
DECLARE G : STRING
|
||||
CASE OF Score
|
||||
90 TO 101 : G <- "A"
|
||||
80 TO 90 : G <- "B"
|
||||
70 TO 80 : G <- "C"
|
||||
OTHERWISE : G <- "F"
|
||||
ENDCASE
|
||||
RETURN G
|
||||
ENDFUNCTION
|
||||
OUTPUT GRADE(95.5)
|
||||
OUTPUT GRADE(80.0)
|
||||
OUTPUT GRADE(12.0)
|
||||
@@ -0,0 +1,10 @@
|
||||
// REPEAT ... UNTIL with INPUT, validating until a legal value arrives.
|
||||
// INPUT: 55
|
||||
// INPUT: -3
|
||||
// INPUT: 20
|
||||
// EXPECT: 20
|
||||
DECLARE Threshold : INTEGER
|
||||
REPEAT
|
||||
INPUT Threshold
|
||||
UNTIL Threshold >= 0 AND Threshold <= 40
|
||||
OUTPUT Threshold
|
||||
@@ -0,0 +1,16 @@
|
||||
// Kadane: find the best, with an early return for the empty case.
|
||||
// EXPECT: 6
|
||||
// EXPECT: -1
|
||||
FUNCTION MAX_SUBARRAY(Xs : LIST OF INTEGER) RETURNS INTEGER
|
||||
REQUIRE LENGTH(Xs) >= 1
|
||||
DECLARE Best, Here : INTEGER
|
||||
Best <- Xs[0]
|
||||
Here <- Xs[0]
|
||||
FOR I <- 1 TO LENGTH(Xs)
|
||||
Here <- MAX(Xs[I], Here + Xs[I])
|
||||
Best <- MAX(Best, Here)
|
||||
NEXT I
|
||||
RETURN Best
|
||||
ENDFUNCTION
|
||||
OUTPUT MAX_SUBARRAY([-2, 1, -3, 4, -1, 2, 1, -5, 4])
|
||||
OUTPUT MAX_SUBARRAY([-1])
|
||||
@@ -0,0 +1,18 @@
|
||||
// A HASHMAP from value to position: the lookup pattern every interview asks for.
|
||||
// EXPECT: [0, 2]
|
||||
// EXPECT: []
|
||||
FUNCTION TWO_SUM(Xs : LIST OF INTEGER, Target : INTEGER) RETURNS LIST OF INTEGER
|
||||
DECLARE Seen : HASHMAP OF INTEGER : INTEGER
|
||||
DECLARE Answer : LIST OF INTEGER
|
||||
FOR I <- 0 TO LENGTH(Xs)
|
||||
IF Target - Xs[I] IN Seen THEN
|
||||
APPEND(Answer, Seen[Target - Xs[I]])
|
||||
APPEND(Answer, I)
|
||||
RETURN Answer
|
||||
ENDIF
|
||||
Seen[Xs[I]] <- I
|
||||
NEXT I
|
||||
RETURN Answer
|
||||
ENDFUNCTION
|
||||
OUTPUT TWO_SUM([3, 5, 7, 9], 10)
|
||||
OUTPUT TWO_SUM([1, 2], 10)
|
||||
@@ -0,0 +1,17 @@
|
||||
// SETs: fixed with DEFINE, growing with ADD, membership, LENGTH, SORTED.
|
||||
// EXPECT: TRUE
|
||||
// EXPECT: FALSE
|
||||
// EXPECT: 4
|
||||
// EXPECT: ["ACG", "CGT", "GTA", "TAC"]
|
||||
TYPE BaseSet = SET OF CHAR
|
||||
DEFINE Purines ('A', 'G') : BaseSet
|
||||
OUTPUT 'A' IN Purines
|
||||
OUTPUT 'C' IN Purines
|
||||
DECLARE Seen : SET OF STRING
|
||||
DECLARE T : STRING
|
||||
T <- "ACGTACG"
|
||||
FOR I <- 0 TO LENGTH(T) - 3 + 1
|
||||
ADD(Seen, SLICE(T, I, I + 3))
|
||||
NEXT I
|
||||
OUTPUT LENGTH(Seen)
|
||||
OUTPUT SORTED(Seen)
|
||||
@@ -0,0 +1,25 @@
|
||||
// Number bases: a STRING of digits read left to right, and the reverse with DIV and MOD.
|
||||
// EXPECT: 13
|
||||
// EXPECT: 1101
|
||||
FUNCTION FROM_BINARY(S : STRING) RETURNS INTEGER
|
||||
DECLARE V : INTEGER
|
||||
V <- 0
|
||||
FOR EACH C IN S
|
||||
V <- V * 2 + TO_INTEGER(C)
|
||||
NEXT C
|
||||
RETURN V
|
||||
ENDFUNCTION
|
||||
FUNCTION TO_BINARY(N : INTEGER) RETURNS STRING
|
||||
REQUIRE N >= 1
|
||||
DECLARE S : STRING
|
||||
DECLARE M : INTEGER
|
||||
S <- ""
|
||||
M <- N
|
||||
WHILE M > 0
|
||||
S <- TO_STRING(M MOD 2) & S
|
||||
M <- M DIV 2
|
||||
ENDWHILE
|
||||
RETURN S
|
||||
ENDFUNCTION
|
||||
OUTPUT FROM_BINARY("1101")
|
||||
OUTPUT TO_BINARY(13)
|
||||
@@ -0,0 +1,17 @@
|
||||
// Randomness: RANDINT in a loop and a tally; the lab seeds its random numbers so a run repeats.
|
||||
// EXPECT: 100
|
||||
DECLARE Tally : ARRAY[7] OF INTEGER
|
||||
DECLARE Total : INTEGER
|
||||
FOR F <- 0 TO 7
|
||||
Tally[F] <- 0
|
||||
NEXT F
|
||||
FOR Roll <- 0 TO 100
|
||||
DECLARE Face : INTEGER
|
||||
Face <- RANDINT(1, 7)
|
||||
Tally[Face] <- Tally[Face] + 1
|
||||
NEXT Roll
|
||||
Total <- 0
|
||||
FOR F <- 1 TO 7
|
||||
Total <- Total + Tally[F]
|
||||
NEXT F
|
||||
OUTPUT Total
|
||||
@@ -0,0 +1,17 @@
|
||||
// What the notation offers for text: SLICE, &, UPPER, LOWER, ORD, CHR, TO_STRING, TO_INTEGER.
|
||||
// EXPECT: ATT
|
||||
// EXPECT: GATTACA!
|
||||
// EXPECT: hello
|
||||
// EXPECT: DNA
|
||||
// EXPECT: 65
|
||||
// EXPECT: B
|
||||
// EXPECT: 42 apples
|
||||
// EXPECT: 43
|
||||
OUTPUT SLICE("GATTACA", 1, 4)
|
||||
OUTPUT "GATTACA" & "!"
|
||||
OUTPUT LOWER("HeLLo")
|
||||
OUTPUT UPPER("dna")
|
||||
OUTPUT ORD('A')
|
||||
OUTPUT CHR(66)
|
||||
OUTPUT TO_STRING(42) & " apples"
|
||||
OUTPUT TO_INTEGER("42") + 1
|
||||
@@ -0,0 +1,20 @@
|
||||
// A HASHMAP of LISTs built up, then printed in sorted key order with KEYS.
|
||||
// Finding: the list cannot be called Keys, because built-in names are reserved whatever their case.
|
||||
// EXPECT: a: [1, 3]
|
||||
// EXPECT: b: [2]
|
||||
DECLARE Groups : HASHMAP OF STRING : LIST OF INTEGER
|
||||
DECLARE Ks : LIST OF STRING
|
||||
DECLARE Names : LIST OF STRING
|
||||
DECLARE Values : LIST OF INTEGER
|
||||
Names <- ["a", "b", "a"]
|
||||
Values <- [1, 2, 3]
|
||||
FOR I <- 0 TO LENGTH(Names)
|
||||
IF NOT (Names[I] IN Groups) THEN
|
||||
Groups[Names[I]] <- []
|
||||
ENDIF
|
||||
APPEND(Groups[Names[I]], Values[I])
|
||||
NEXT I
|
||||
Ks <- KEYS(Groups)
|
||||
FOR EACH K IN Ks
|
||||
OUTPUT K & ": " & TO_STRING(Groups[K])
|
||||
NEXT K
|
||||
@@ -0,0 +1,22 @@
|
||||
// BYREF versus by value, side by side.
|
||||
// EXPECT: 2 1
|
||||
// EXPECT: 2 1
|
||||
PROCEDURE SWAP(BYREF X : INTEGER, BYREF Y : INTEGER)
|
||||
DECLARE Temp : INTEGER
|
||||
Temp <- X
|
||||
X <- Y
|
||||
Y <- Temp
|
||||
ENDPROCEDURE
|
||||
PROCEDURE TRY_SWAP(X : INTEGER, Y : INTEGER)
|
||||
DECLARE Temp : INTEGER
|
||||
Temp <- X
|
||||
X <- Y
|
||||
Y <- Temp
|
||||
ENDPROCEDURE
|
||||
DECLARE A, B : INTEGER
|
||||
A <- 1
|
||||
B <- 2
|
||||
CALL SWAP(A, B)
|
||||
OUTPUT A, " ", B
|
||||
CALL TRY_SWAP(A, B)
|
||||
OUTPUT A, " ", B
|
||||
@@ -0,0 +1,11 @@
|
||||
// The reasoning sublanguage used as values: FORALL, EXISTS, SUM, and a set written by rule.
|
||||
// EXPECT: TRUE
|
||||
// EXPECT: FALSE
|
||||
// EXPECT: 15
|
||||
// EXPECT: 3
|
||||
DECLARE L : LIST OF INTEGER
|
||||
L <- [1, 2, 3, 4, 5]
|
||||
OUTPUT FORALL K IN [0, LENGTH(L)) : L[K] > 0
|
||||
OUTPUT EXISTS K IN [0, LENGTH(L)) : L[K] > 10
|
||||
OUTPUT SUM K IN [0, LENGTH(L)) : L[K]
|
||||
OUTPUT LENGTH({ K IN [0, LENGTH(L)) : L[K] MOD 2 == 1 })
|
||||
@@ -0,0 +1,7 @@
|
||||
// What FLOAT does and does not promise.
|
||||
// EXPECT: FALSE
|
||||
// EXPECT: TRUE
|
||||
// EXPECT: 0.30000000000000004
|
||||
OUTPUT 0.1 + 0.2 == 0.3
|
||||
OUTPUT ABS((0.1 + 0.2) - 0.3) < 0.000001
|
||||
OUTPUT 0.1 + 0.2
|
||||
@@ -0,0 +1,38 @@
|
||||
// Linear search three ways: with a flag, with BREAK, with RETURN; all three agree.
|
||||
// EXPECT: 2 2 2
|
||||
// EXPECT: -1 -1 -1
|
||||
FUNCTION FIND_FLAG(Xs : LIST OF INTEGER, X : INTEGER) RETURNS INTEGER
|
||||
DECLARE Found, I : INTEGER
|
||||
Found <- -1
|
||||
I <- 0
|
||||
WHILE I < LENGTH(Xs) AND Found == -1
|
||||
IF Xs[I] == X THEN
|
||||
Found <- I
|
||||
ENDIF
|
||||
I <- I + 1
|
||||
ENDWHILE
|
||||
RETURN Found
|
||||
ENDFUNCTION
|
||||
FUNCTION FIND_BREAK(Xs : LIST OF INTEGER, X : INTEGER) RETURNS INTEGER
|
||||
DECLARE Found : INTEGER
|
||||
Found <- -1
|
||||
FOR I <- 0 TO LENGTH(Xs)
|
||||
IF Xs[I] == X THEN
|
||||
Found <- I
|
||||
BREAK
|
||||
ENDIF
|
||||
NEXT I
|
||||
RETURN Found
|
||||
ENDFUNCTION
|
||||
FUNCTION FIND_RETURN(Xs : LIST OF INTEGER, X : INTEGER) RETURNS INTEGER
|
||||
FOR I <- 0 TO LENGTH(Xs)
|
||||
IF Xs[I] == X THEN
|
||||
RETURN I
|
||||
ENDIF
|
||||
NEXT I
|
||||
RETURN -1
|
||||
ENDFUNCTION
|
||||
DECLARE L : LIST OF INTEGER
|
||||
L <- [4, 8, 15, 16]
|
||||
OUTPUT FIND_FLAG(L, 15), " ", FIND_BREAK(L, 15), " ", FIND_RETURN(L, 15)
|
||||
OUTPUT FIND_FLAG(L, 7), " ", FIND_BREAK(L, 7), " ", FIND_RETURN(L, 7)
|
||||
@@ -0,0 +1,37 @@
|
||||
// A state machine over a STRING: does a token look like a decimal number? CASE on a STRING state.
|
||||
// EXPECT: TRUE
|
||||
// EXPECT: TRUE
|
||||
// EXPECT: FALSE
|
||||
// EXPECT: FALSE
|
||||
FUNCTION IS_NUMBER(S : STRING) RETURNS BOOL
|
||||
DECLARE State : STRING
|
||||
State <- "start"
|
||||
FOR EACH C IN S
|
||||
CASE OF State
|
||||
"start" : IF C >= '0' AND C <= '9' THEN
|
||||
State <- "int"
|
||||
ELSE
|
||||
State <- "bad"
|
||||
ENDIF
|
||||
"int" : IF C == '.' THEN
|
||||
State <- "dot"
|
||||
ELSEIF NOT (C >= '0' AND C <= '9') THEN
|
||||
State <- "bad"
|
||||
ENDIF
|
||||
"dot" : IF C >= '0' AND C <= '9' THEN
|
||||
State <- "frac"
|
||||
ELSE
|
||||
State <- "bad"
|
||||
ENDIF
|
||||
"frac" : IF NOT (C >= '0' AND C <= '9') THEN
|
||||
State <- "bad"
|
||||
ENDIF
|
||||
OTHERWISE : State <- "bad"
|
||||
ENDCASE
|
||||
NEXT C
|
||||
RETURN State == "int" OR State == "frac"
|
||||
ENDFUNCTION
|
||||
OUTPUT IS_NUMBER("42")
|
||||
OUTPUT IS_NUMBER("3.14")
|
||||
OUTPUT IS_NUMBER("3.")
|
||||
OUTPUT IS_NUMBER("x1")
|
||||
@@ -0,0 +1,20 @@
|
||||
// Edge semantics every reader should know: chained comparisons, string order, MIN of a list, SORT of text, nested lists.
|
||||
// EXPECT: TRUE
|
||||
// EXPECT: TRUE
|
||||
// EXPECT: 1
|
||||
// EXPECT: ["apple", "fig", "pear"]
|
||||
// EXPECT: 6
|
||||
// EXPECT: FALSE
|
||||
DECLARE I : INTEGER
|
||||
I <- 3
|
||||
OUTPUT 0 <= I < 5
|
||||
OUTPUT "apple" < "banana"
|
||||
OUTPUT MIN([4, 1, 9])
|
||||
DECLARE Fruit : LIST OF STRING
|
||||
Fruit <- ["pear", "apple", "fig"]
|
||||
SORT(Fruit)
|
||||
OUTPUT Fruit
|
||||
DECLARE Grid : LIST OF LIST OF INTEGER
|
||||
Grid <- [[1, 2, 3], [4, 5, 6]]
|
||||
OUTPUT Grid[1][2]
|
||||
OUTPUT "" IN Fruit
|
||||
@@ -0,0 +1,7 @@
|
||||
// A run that stops: reading one past the end. The lab names the position and the length.
|
||||
// STOPS: index
|
||||
DECLARE T : STRING
|
||||
T <- "GATTACA"
|
||||
FOR I <- 0 TO LENGTH(T) + 1
|
||||
OUTPUT T[I]
|
||||
NEXT I
|
||||
@@ -0,0 +1,11 @@
|
||||
// A run that stops: dividing by zero inside a function; the lab blames the line and shows the values.
|
||||
// STOPS: divide
|
||||
FUNCTION MEAN(Xs : LIST OF INTEGER) RETURNS FLOAT
|
||||
DECLARE Total : INTEGER
|
||||
Total <- 0
|
||||
FOR EACH X IN Xs
|
||||
Total <- Total + X
|
||||
NEXT X
|
||||
RETURN Total / LENGTH(Xs)
|
||||
ENDFUNCTION
|
||||
OUTPUT MEAN([])
|
||||
@@ -0,0 +1,6 @@
|
||||
// A run that stops: recursion with no base case.
|
||||
// STOPS: depth
|
||||
FUNCTION DOWN(N : INTEGER) RETURNS INTEGER
|
||||
RETURN DOWN(N - 1)
|
||||
ENDFUNCTION
|
||||
OUTPUT DOWN(10)
|
||||
@@ -0,0 +1,4 @@
|
||||
// A run that stops: a declared name read before anything is stored in it.
|
||||
// STOPS: unset
|
||||
DECLARE Total : INTEGER
|
||||
OUTPUT Total + 1
|
||||
@@ -0,0 +1,6 @@
|
||||
// A run that stops: a FOR counter read after its loop.
|
||||
// STOPS: unset
|
||||
DECLARE I : INTEGER
|
||||
FOR I <- 0 TO 3
|
||||
NEXT I
|
||||
OUTPUT I
|
||||
@@ -0,0 +1,14 @@
|
||||
// What the checker refuses before anything runs. Each line below is one mistake the guide names.
|
||||
// ERRORS: 5
|
||||
DECLARE T : STRING
|
||||
DECLARE N : INTEGER
|
||||
T <- "GATTACA"
|
||||
N <- 7 / 2
|
||||
T[0] <- 'C'
|
||||
IF T[0] == "G" THEN
|
||||
OUTPUT "g"
|
||||
ENDIF
|
||||
FOR I <- 0 TO 3
|
||||
I <- I + 1
|
||||
NEXT I
|
||||
N = 5
|
||||
@@ -0,0 +1,11 @@
|
||||
// CONTINUE skips a pass; here, unknown bases are not evidence.
|
||||
// EXPECT: 6
|
||||
DECLARE Total : INTEGER
|
||||
Total <- 0
|
||||
FOR EACH B IN "GATNACA"
|
||||
IF B == 'N' THEN
|
||||
CONTINUE
|
||||
ENDIF
|
||||
Total <- Total + 1
|
||||
NEXT B
|
||||
OUTPUT Total
|
||||
@@ -0,0 +1,29 @@
|
||||
// CONSTANT names a number once; STEP walks codon starts; a HASHMAP codon table; a SET of stops.
|
||||
// EXPECT: MAK
|
||||
CONSTANT BasesPerCodon = 3
|
||||
FUNCTION TRANSLATE(T : STRING) RETURNS STRING
|
||||
DECLARE Table : HASHMAP OF STRING : CHAR
|
||||
DECLARE Stops : SET OF STRING
|
||||
DECLARE Out : STRING
|
||||
Table["ATG"] <- 'M'
|
||||
Table["GCC"] <- 'A'
|
||||
Table["AAA"] <- 'K'
|
||||
ADD(Stops, "TAG")
|
||||
ADD(Stops, "TAA")
|
||||
ADD(Stops, "TGA")
|
||||
Out <- ""
|
||||
FOR I <- 0 TO LENGTH(T) - BasesPerCodon + 1 STEP BasesPerCodon
|
||||
DECLARE Codon : STRING
|
||||
Codon <- SLICE(T, I, I + BasesPerCodon)
|
||||
IF Codon IN Stops THEN
|
||||
BREAK
|
||||
ENDIF
|
||||
IF Codon IN Table THEN
|
||||
Out <- Out & Table[Codon]
|
||||
ELSE
|
||||
Out <- Out & '?'
|
||||
ENDIF
|
||||
NEXT I
|
||||
RETURN Out
|
||||
ENDFUNCTION
|
||||
OUTPUT TRANSLATE("ATGGCCAAATAGTTT")
|
||||
@@ -0,0 +1,24 @@
|
||||
// The four text built-ins added after the stress test: SPLIT, JOIN, INDEX_OF, REPLACE.
|
||||
// EXPECT: ["the", "quick", "", "brown", "fox"]
|
||||
// EXPECT: the quick brown fox
|
||||
// EXPECT: 3 -1 2
|
||||
// EXPECT: GAUUACA
|
||||
// EXPECT: read_1:GAT
|
||||
FUNCTION WORDS(S : STRING) RETURNS LIST OF STRING
|
||||
DECLARE Out : LIST OF STRING
|
||||
FOR EACH W IN SPLIT(S, " ")
|
||||
IF LENGTH(W) > 0 THEN
|
||||
APPEND(Out, W)
|
||||
ENDIF
|
||||
NEXT W
|
||||
RETURN Out
|
||||
ENDFUNCTION
|
||||
DECLARE S : STRING
|
||||
S <- "the quick brown fox"
|
||||
OUTPUT SPLIT(S, " ")
|
||||
OUTPUT JOIN(WORDS(S), " ")
|
||||
OUTPUT INDEX_OF("GATTACA", "TAC"), " ", INDEX_OF("GATTACA", 'N'), " ", INDEX_OF([4, 8, 15], 15)
|
||||
OUTPUT REPLACE("GATTACA", "T", "U")
|
||||
DECLARE Fields : LIST OF STRING
|
||||
Fields <- SPLIT("read_1\tGAT\t30", "\t")
|
||||
OUTPUT Fields[0], ":", Fields[1]
|
||||
@@ -0,0 +1,7 @@
|
||||
// A keyword used as a name is one error per name, not a cascade: the rest of the program still parses.
|
||||
// ERRORS: 2
|
||||
DECLARE Step : INTEGER
|
||||
Step <- 1
|
||||
FOR EACH Next IN [1, 2]
|
||||
OUTPUT Next + Step
|
||||
NEXT Next
|
||||
@@ -0,0 +1,17 @@
|
||||
// The numeric built-ins added for mathematics, physics, chemistry and statistics.
|
||||
// EXPECT: 2 3 -3
|
||||
// EXPECT: 1.0 1.0
|
||||
// EXPECT: 10 120
|
||||
// EXPECT: 6 2.5 2.0 2.5
|
||||
// EXPECT: 4.571428571428571 2.138089935299395
|
||||
// EXPECT: 32 5.0
|
||||
// EXPECT: [0.0, 0.0, 0.0] 4
|
||||
// EXPECT: 3.0 3.142
|
||||
OUTPUT FLOOR(2.7), " ", CEIL(2.1), " ", FLOOR(-2.3)
|
||||
OUTPUT ROUND(SIN(PI() / 2) * 1000) / 1000, " ", ROUND(COS(0.0) * 1000) / 1000
|
||||
OUTPUT CHOOSE(5, 2), " ", CHOOSE(10, 3)
|
||||
OUTPUT SUM_OF([1, 2, 3]), " ", MEAN_OF([1, 2, 3, 4]), " ", MEDIAN_OF([3, 1, 2]), " ", MEDIAN_OF([4, 1, 3, 2])
|
||||
OUTPUT VARIANCE_OF([2, 4, 4, 4, 5, 5, 7, 9]), " ", STDEV_OF([2, 4, 4, 4, 5, 5, 7, 9])
|
||||
OUTPUT DOT([1, 2, 3], [4, 5, 6]), " ", NORM_OF([3.0, 4.0])
|
||||
OUTPUT FILL(3, 0.0), " ", LENGTH(FILL(4, 'A'))
|
||||
OUTPUT LOG10(1000.0), " ", ROUND(ATAN2(1.0, 1.0) * 4 * 1000) / 1000
|
||||
@@ -0,0 +1,30 @@
|
||||
// GPU thinking: a PARALLEL FOR whose passes each own one slot (a map), then a sequential reduce.
|
||||
// EXPECT: [1.0, 4.0, 9.0, 16.0]
|
||||
// EXPECT: 30.0
|
||||
// EXPECT: [5, 7, 9]
|
||||
FUNCTION SQUARES(Xs : LIST OF FLOAT) RETURNS LIST OF FLOAT
|
||||
DECLARE Out : LIST OF FLOAT
|
||||
Out <- FILL(LENGTH(Xs), 0.0)
|
||||
PARALLEL FOR I <- 0 TO LENGTH(Xs)
|
||||
DECLARE X : FLOAT
|
||||
X <- Xs[I]
|
||||
Out[I] <- X * X
|
||||
NEXT I
|
||||
RETURN Out
|
||||
ENDFUNCTION
|
||||
|
||||
FUNCTION ADD_VECTORS(A : LIST OF INTEGER, B : LIST OF INTEGER) RETURNS LIST OF INTEGER
|
||||
REQUIRE LENGTH(A) == LENGTH(B)
|
||||
DECLARE C : LIST OF INTEGER
|
||||
C <- FILL(LENGTH(A), 0)
|
||||
PARALLEL FOR I <- 0 TO LENGTH(A)
|
||||
C[I] <- A[I] + B[I]
|
||||
NEXT I
|
||||
RETURN C
|
||||
ENDFUNCTION
|
||||
|
||||
DECLARE Sq : LIST OF FLOAT
|
||||
Sq <- SQUARES([1.0, 2.0, 3.0, 4.0])
|
||||
OUTPUT Sq
|
||||
OUTPUT SUM_OF(Sq)
|
||||
OUTPUT ADD_VECTORS([1, 2, 3], [4, 5, 6])
|
||||
@@ -0,0 +1,10 @@
|
||||
// A shared running total inside a PARALLEL FOR is a data race, and the lab says so.
|
||||
// STOPS: race
|
||||
DECLARE Xs : LIST OF FLOAT
|
||||
DECLARE Acc : FLOAT
|
||||
Xs <- [1.0, 2.0, 3.0]
|
||||
Acc <- 0.0
|
||||
PARALLEL FOR I <- 0 TO LENGTH(Xs)
|
||||
Acc <- Acc + Xs[I]
|
||||
NEXT I
|
||||
OUTPUT Acc
|
||||
@@ -0,0 +1,8 @@
|
||||
// Reading a neighbor that another pass writes is also a race, even with no shared scalar.
|
||||
// STOPS: race
|
||||
DECLARE A : LIST OF INTEGER
|
||||
A <- [5, 6, 7, 8]
|
||||
PARALLEL FOR I <- 0 TO 3
|
||||
A[I] <- A[I + 1]
|
||||
NEXT I
|
||||
OUTPUT A
|
||||
@@ -0,0 +1,25 @@
|
||||
// Physics: where a projectile lands, by stepping Newton's laws, against the closed form.
|
||||
// EXPECT: 10.2 10.2
|
||||
FUNCTION RANGE_BY_STEPS(Speed : FLOAT, Angle : FLOAT, Dt : FLOAT) RETURNS FLOAT
|
||||
DECLARE X, Y, Vx, Vy, G : FLOAT
|
||||
G <- 9.81
|
||||
X <- 0.0
|
||||
Y <- 0.0
|
||||
Vx <- Speed * COS(Angle)
|
||||
Vy <- Speed * SIN(Angle)
|
||||
REPEAT
|
||||
X <- X + Vx * Dt
|
||||
Y <- Y + Vy * Dt
|
||||
Vy <- Vy - G * Dt
|
||||
UNTIL Y <= 0.0
|
||||
RETURN X
|
||||
ENDFUNCTION
|
||||
|
||||
FUNCTION RANGE_EXACT(Speed : FLOAT, Angle : FLOAT) RETURNS FLOAT
|
||||
RETURN Speed * Speed * SIN(2.0 * Angle) / 9.81
|
||||
ENDFUNCTION
|
||||
|
||||
DECLARE Angle : FLOAT
|
||||
Angle <- PI() / 4
|
||||
// Stepping forward overshoots a little, so compare to one decimal place.
|
||||
OUTPUT ROUND(RANGE_BY_STEPS(10.0, Angle, 0.0001) * 10) / 10, " ", ROUND(RANGE_EXACT(10.0, Angle) * 10) / 10
|
||||
@@ -0,0 +1,22 @@
|
||||
// Probability and chemistry: a binomial probability from CHOOSE, and pH from LOG10.
|
||||
// EXPECT: 0.2461
|
||||
// EXPECT: 1.0
|
||||
// EXPECT: 3.0 7.0
|
||||
FUNCTION BINOMIAL(N : INTEGER, K : INTEGER, P : FLOAT) RETURNS FLOAT
|
||||
REQUIRE 0 <= K AND K <= N
|
||||
RETURN CHOOSE(N, K) * P ^ K * (1.0 - P) ^ (N - K)
|
||||
ENDFUNCTION
|
||||
|
||||
FUNCTION PH(Concentration : FLOAT) RETURNS FLOAT
|
||||
REQUIRE Concentration > 0.0
|
||||
RETURN -LOG10(Concentration)
|
||||
ENDFUNCTION
|
||||
|
||||
DECLARE Sum : FLOAT
|
||||
Sum <- 0.0
|
||||
FOR K <- 0 TO 11
|
||||
Sum <- Sum + BINOMIAL(10, K, 0.5)
|
||||
NEXT K
|
||||
OUTPUT ROUND(BINOMIAL(10, 5, 0.5) * 10000) / 10000
|
||||
OUTPUT ROUND(Sum * 1000) / 1000
|
||||
OUTPUT PH(0.001), " ", PH(0.0000001)
|
||||
@@ -0,0 +1,32 @@
|
||||
// Declaring with a starting value on one line, beside the two-line form, at the top, in a routine, and in a loop.
|
||||
// EXPECT: 3
|
||||
// EXPECT: 7 3
|
||||
// EXPECT: a <- b
|
||||
// EXPECT: 6
|
||||
// EXPECT: 2
|
||||
FUNCTION COUNT_BASE(B : CHAR, T : STRING) RETURNS INTEGER
|
||||
DECLARE N : INTEGER <- LENGTH(T)
|
||||
DECLARE Total : INTEGER <- 0 // the running total
|
||||
FOR I <- 0 TO N
|
||||
IF T[I] == B THEN
|
||||
Total <- Total + 1
|
||||
ENDIF
|
||||
NEXT I
|
||||
RETURN Total
|
||||
ENDFUNCTION
|
||||
DECLARE Seq : STRING <- "GATTACA"
|
||||
DECLARE Count : INTEGER
|
||||
Count <- COUNT_BASE('A', Seq)
|
||||
OUTPUT Count
|
||||
DECLARE Len : INTEGER <- LENGTH(Seq)
|
||||
OUTPUT Len, " ", Count
|
||||
DECLARE Arrow : STRING <- "a <- b"
|
||||
OUTPUT Arrow
|
||||
DECLARE Sum : INTEGER <- 0
|
||||
FOR K <- 0 TO 3
|
||||
DECLARE Twice : INTEGER <- 2 * K
|
||||
Sum <- Sum + Twice
|
||||
NEXT K
|
||||
OUTPUT Sum
|
||||
DECLARE Xs : LIST OF INTEGER <- [4, 9]
|
||||
OUTPUT LENGTH(Xs)
|
||||
@@ -0,0 +1,14 @@
|
||||
// Sized whole numbers: arithmetic that stays inside its type, wrapping only when asked, and conversions that check.
|
||||
// EXPECT: 255 0 255
|
||||
// EXPECT: 1500000000 -2 256
|
||||
// EXPECT: 8 14 6 255 1024 -4
|
||||
// EXPECT: 12 12 -128 2147483647
|
||||
DECLARE Count : UINT8 <- 250
|
||||
Count <- Count + 5
|
||||
OUTPUT Count, " ", WRAP(Count + 1, UINT8), " ", MAX_VALUE(UINT8)
|
||||
DECLARE Big : INT64 <- 3_000_000_000
|
||||
DECLARE Small : INT32
|
||||
Small <- INT32(Big DIV 2)
|
||||
OUTPUT Small, " ", INT16(-2.9), " ", 0xFF + 0b1
|
||||
OUTPUT BIT_AND(0b1100, 0b1010), " ", BIT_OR(12, 10), " ", BIT_XOR(12, 10), " ", BIT_NOT(UINT8(0)), " ", SHIFT_LEFT(1, 10), " ", SHIFT_RIGHT(-8, 1)
|
||||
OUTPUT GCD(84, 36), " ", LCM(4, 6), " ", MIN_VALUE(INT8), " ", MAX_VALUE(INT32)
|
||||
@@ -0,0 +1,20 @@
|
||||
// Single precision: every FLOAT32 result is rounded to 24 bits, and a literal next to a FLOAT32 is a FLOAT32.
|
||||
// EXPECT: 1.0000001 0.9999999999999999
|
||||
// EXPECT: TRUE FALSE
|
||||
// EXPECT: 0.100000001490116119384765625
|
||||
// EXPECT: 16777216.0 1.1920929e-7 1.1920929e-7
|
||||
// EXPECT: 5.551115123125783e-17 0.0
|
||||
// EXPECT: TRUE TRUE
|
||||
DECLARE X : FLOAT32 <- 0.1
|
||||
DECLARE Total32 : FLOAT32 <- 0.0
|
||||
DECLARE Total64 : FLOAT <- 0.0
|
||||
FOR I <- 0 TO 10
|
||||
Total32 <- Total32 + X
|
||||
Total64 <- Total64 + 0.1
|
||||
NEXT I
|
||||
OUTPUT Total32, " ", Total64
|
||||
OUTPUT X == 0.1, " ", FLOAT64(X) == 0.1
|
||||
OUTPUT EXACT(X)
|
||||
OUTPUT FLOAT32(16777217), " ", ULP(FLOAT32(1.0)), " ", EPSILON(FLOAT32)
|
||||
OUTPUT FMA(0.1, 10.0, -1.0), " ", 0.1 * 10.0 - 1.0
|
||||
OUTPUT IS_CLOSE(Total32, 1.0, 1e-6, 0.0), " ", IS_CLOSE(Total64, 1.0, 1e-15, 0.0)
|
||||
@@ -0,0 +1,12 @@
|
||||
// USE IEEE: NaN and the infinities flow through a calculation as IEEE 754 says, instead of stopping the run.
|
||||
// EXPECT: infinity -infinity not a number
|
||||
// EXPECT: TRUE TRUE FALSE TRUE
|
||||
// EXPECT: not a number -infinity FALSE
|
||||
USE IEEE
|
||||
DECLARE Zero : FLOAT <- 0.0
|
||||
DECLARE Inf : FLOAT
|
||||
Inf <- 1.0 / Zero
|
||||
DECLARE NotANumber : FLOAT <- Inf - Inf
|
||||
OUTPUT Inf, " ", -Inf, " ", NotANumber
|
||||
OUTPUT IS_INF(Inf), " ", IS_NAN(NotANumber), " ", NotANumber == NotANumber, " ", NotANumber != NotANumber
|
||||
OUTPUT SQRT(-1.0), " ", LOG(0.0), " ", IS_FINITE(MAX_VALUE(FLOAT64) * 2.0)
|
||||
@@ -0,0 +1,11 @@
|
||||
// Elementary functions for numerical work, and the accurate forms near 0.
|
||||
// EXPECT: 5.0 TRUE -3.0 1024.0
|
||||
// EXPECT: 1.00000000005e-10 1.000000082740371e-10 9.999999999500001e-11
|
||||
// EXPECT: -2.0 -1 -2.0 10 0.0
|
||||
// EXPECT: 3.142 3.142 0.0 0.0 2.718
|
||||
// EXPECT: TRUE 2.220446049250313e-16
|
||||
OUTPUT HYPOT(3.0, 4.0), " ", HYPOT(1e200, 1e200) > 1e200, " ", CBRT(-27.0), " ", POW(2.0, 10.0)
|
||||
OUTPUT EXPM1(1e-10), " ", EXP(1e-10) - 1.0, " ", LOG1P(1e-10)
|
||||
OUTPUT TRUNC(-2.7), " ", SIGN(-3), " ", COPYSIGN(2.0, -0.0), " ", CLAMP(15, 0, 10), " ", CLAMP(-0.5, 0.0, 1.0)
|
||||
OUTPUT ROUND(ASIN(1.0) * 2 * 1000) / 1000, " ", ROUND(ACOS(-1.0) * 1000) / 1000, " ", ATAN(0.0), " ", TANH(0.0), " ", ROUND(E() * 1000) / 1000
|
||||
OUTPUT NEXT_AFTER(1.0, 2.0) - 1.0 == EPSILON(FLOAT64), " ", ULP(1.0)
|
||||
@@ -0,0 +1,12 @@
|
||||
// Routines from the library, called like the program's own: a run steps over each one, and the
|
||||
// prover uses each one's REQUIRE and ENSURE at the call.
|
||||
// EXPECT: 5.0 4.571428571428571
|
||||
// EXPECT: 0.0 -0.0615234375
|
||||
// EXPECT: 0
|
||||
USE stats
|
||||
USE md.LennardJones
|
||||
USE align.NeedlemanWunschScore
|
||||
DECLARE Samples : LIST OF FLOAT <- [2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0]
|
||||
OUTPUT Mean(Samples), " ", Variance(Samples)
|
||||
OUTPUT LennardJones(1.0, 1.0, 1.0), " ", LennardJones(2.0, 1.0, 1.0)
|
||||
OUTPUT NeedlemanWunschScore("GATTACA", "GCATGCU", 1, -1, -1)
|
||||
@@ -0,0 +1,30 @@
|
||||
// Rules the interpreter audit pinned: MOD past 2^53, a LIST OF FLOAT from whole-number literals,
|
||||
// a function that leaves a WHILE TRUE only by RETURN, an ARRAY filled from a LIST of its length, minus zero.
|
||||
// EXPECT: -2 2
|
||||
// EXPECT: [1.0, 2.0] 3.0
|
||||
// EXPECT: 5
|
||||
// EXPECT: [1, 2, 9] 3
|
||||
// EXPECT: 0 -0.0
|
||||
FUNCTION FIRST_ABOVE(Xs : LIST OF INTEGER, Floor : INTEGER) RETURNS INTEGER
|
||||
DECLARE I : INTEGER <- 0
|
||||
WHILE TRUE
|
||||
IF I >= LENGTH(Xs) THEN
|
||||
RETURN -1
|
||||
ENDIF
|
||||
IF Xs[I] > Floor THEN
|
||||
RETURN Xs[I]
|
||||
ENDIF
|
||||
I <- I + 1
|
||||
ENDWHILE
|
||||
ENDFUNCTION
|
||||
OUTPUT 9007199254740991 MOD -3, " ", (-9007199254740991) MOD 3
|
||||
DECLARE L : LIST OF FLOAT
|
||||
L <- [1, 2]
|
||||
OUTPUT L, " ", SUM_OF(L)
|
||||
OUTPUT FIRST_ABOVE([1, 5, 9], 3)
|
||||
DECLARE A : ARRAY[3] OF INTEGER
|
||||
A <- [3, 1, 2]
|
||||
SORT(A)
|
||||
A[2] <- 9
|
||||
OUTPUT A, " ", LENGTH(A)
|
||||
OUTPUT 0 * (-1), " ", 0.0 * -1.0
|
||||
@@ -0,0 +1,58 @@
|
||||
// Statements whose Mojo the compiler asked for (pixi run mojo-fuzz --statements): a CONTINUE in a REPEAT, a name
|
||||
// declared in a block and used after it, a value given on one path only, two names that make one Mojo name, a FOR
|
||||
// EACH over text the body changes, a by-value parameter handed on BYREF, and FILL of a call.
|
||||
// EXPECT: 2
|
||||
// EXPECT: 5 2
|
||||
// EXPECT: 1 0
|
||||
// EXPECT: 1 2
|
||||
// EXPECT: abc zzzabc
|
||||
// EXPECT: 11 [1, 2, 3]
|
||||
// EXPECT: twice
|
||||
// EXPECT: [6, 6]
|
||||
PROCEDURE AddTen(BYREF V : INTEGER)
|
||||
V <- V + 10
|
||||
ENDPROCEDURE
|
||||
PROCEDURE Show(N : INTEGER, L : LIST OF INTEGER)
|
||||
CALL AddTen(N)
|
||||
OUTPUT N, " ", L
|
||||
ENDPROCEDURE
|
||||
FUNCTION Twice(N : INTEGER) RETURNS INTEGER
|
||||
OUTPUT "twice"
|
||||
RETURN N * 2
|
||||
ENDFUNCTION
|
||||
DECLARE K : INTEGER <- 0
|
||||
REPEAT
|
||||
K <- K + 1
|
||||
IF K < 3 THEN
|
||||
CONTINUE
|
||||
ENDIF
|
||||
OUTPUT "never ", K
|
||||
UNTIL K >= 2
|
||||
OUTPUT K
|
||||
IF K > 0 THEN
|
||||
DECLARE Inner : INTEGER <- 5
|
||||
ENDIF
|
||||
FOR I <- 0 TO 3
|
||||
DECLARE Last : INTEGER <- I
|
||||
NEXT I
|
||||
OUTPUT Inner, " ", Last
|
||||
DECLARE W, Z : INTEGER
|
||||
Z <- 0
|
||||
IF K > 1 THEN
|
||||
W <- 1
|
||||
ENDIF
|
||||
OUTPUT W, " ", Z
|
||||
DECLARE RunTotal : INTEGER <- 1
|
||||
DECLARE RUN_TOTAL : INTEGER <- 2
|
||||
OUTPUT RunTotal, " ", RUN_TOTAL
|
||||
DECLARE S : STRING <- "abc"
|
||||
DECLARE Seen : STRING <- ""
|
||||
FOR EACH Ch IN S
|
||||
S <- "z" & S
|
||||
Seen <- Seen & Ch
|
||||
NEXT Ch
|
||||
OUTPUT Seen, " ", S
|
||||
DECLARE L : LIST OF INTEGER <- [1, 2, 3]
|
||||
CALL Show(1, L)
|
||||
DECLARE F : LIST OF INTEGER <- FILL(2, Twice(3))
|
||||
OUTPUT F
|
||||
@@ -0,0 +1,10 @@
|
||||
// APPEND puts the INTEGER into a LIST OF FLOAT32 without rounding it; reading
|
||||
// it back into a FLOAT32 rounds.
|
||||
// MUST-NOT-PROVE: assert@10
|
||||
DECLARE L : LIST OF FLOAT32
|
||||
DECLARE Y : FLOAT32
|
||||
DECLARE N : INTEGER
|
||||
N <- 16777217
|
||||
APPEND(L, N)
|
||||
Y <- L[0]
|
||||
ASSERT Y == N
|
||||
@@ -0,0 +1,17 @@
|
||||
// The first label matches every X, so ISqrt(X) in the second label is never
|
||||
// called. The checker kept its ENSURE (0 <= RESULT <= X) as a fact anyway.
|
||||
// CALL: P(-1)
|
||||
// MUST-NOT-PROVE: assert@16
|
||||
FUNCTION ISqrt(N : INTEGER) RETURNS INTEGER
|
||||
REQUIRE N >= 0
|
||||
ENSURE RESULT >= 0 AND RESULT <= N
|
||||
RETURN 0
|
||||
ENDFUNCTION
|
||||
|
||||
PROCEDURE P(X : INTEGER)
|
||||
CASE OF X
|
||||
X, ISqrt(X) : OUTPUT "a"
|
||||
OTHERWISE : OUTPUT "b"
|
||||
ENDCASE
|
||||
ASSERT X >= 0
|
||||
ENDPROCEDURE
|
||||
@@ -0,0 +1,5 @@
|
||||
// CHR accepts the two halves of a surrogate pair; joined they are one character.
|
||||
// RUN-STOPS: value@4
|
||||
DECLARE S : STRING
|
||||
S <- CHR(55357) & CHR(56832)
|
||||
ASSERT LENGTH(S) == 2
|
||||
@@ -0,0 +1,6 @@
|
||||
// The same for constants: X + A + 2 - A is X + 2, and the checker gets X + 1.
|
||||
// INPUT: -5
|
||||
// MUST-NOT-PROVE: assert@6
|
||||
DECLARE X : INTEGER
|
||||
INPUT X
|
||||
ASSERT X + 9007199254740991 + 2 - 9007199254740991 == X + 1
|
||||
@@ -0,0 +1,12 @@
|
||||
// The run checks DECREASES >= 0 on every call, the first one too. No
|
||||
// obligation covers that check, so a unit with everything proved still stops.
|
||||
// MUST-NOT-PROVE: decreases-bound@5
|
||||
FUNCTION F(N : INTEGER) RETURNS INTEGER
|
||||
DECREASES N
|
||||
IF N <= 0 THEN
|
||||
RETURN 0
|
||||
ENDIF
|
||||
RETURN F(N - 1)
|
||||
ENDFUNCTION
|
||||
|
||||
OUTPUT F(-5)
|
||||
@@ -0,0 +1,15 @@
|
||||
// The recursive call's measure is compared with N as it is at the call
|
||||
// (N + 2), not with N as it was on entry. The run compares with entry.
|
||||
// MUST-NOT-PROVE: decreases-step@12
|
||||
// RUN-STOPS: decreases@7
|
||||
FUNCTION F(N : INTEGER) RETURNS INTEGER
|
||||
REQUIRE N >= 0
|
||||
DECREASES N
|
||||
IF N == 0 THEN
|
||||
RETURN 0
|
||||
ENDIF
|
||||
N <- N + 2
|
||||
RETURN F(N - 1)
|
||||
ENDFUNCTION
|
||||
|
||||
OUTPUT F(3)
|
||||
@@ -0,0 +1,9 @@
|
||||
// FILL stops the program on a negative count, so the call is an
|
||||
// obligation, not a fact the checker may assume.
|
||||
// MUST-NOT-PROVE: argument@6
|
||||
FUNCTION F(N : INTEGER) RETURNS INTEGER
|
||||
DECLARE Xs : LIST OF INTEGER
|
||||
Xs <- FILL(N, 0)
|
||||
RETURN LENGTH(Xs)
|
||||
ENDFUNCTION
|
||||
OUTPUT F(-1)
|
||||
@@ -0,0 +1,4 @@
|
||||
// In a run only a whole number is IN a range. The checker reads
|
||||
// X IN [0, 5) as 0 <= X < 5 for a FLOAT as well.
|
||||
// MUST-NOT-PROVE: assert@4
|
||||
ASSERT 2.5 IN [0, 5)
|
||||
@@ -0,0 +1,10 @@
|
||||
// The prover treats a FLOAT as a number: Y == Y, and X < X + 1.0 or not.
|
||||
// Infinity and NaN are not numbers in that sense. A run that let 1.0E308 *
|
||||
// 10.0 become infinity, and X - X become NaN, broke both claims while the
|
||||
// checker proved them. Such a run now stops at the overflow instead.
|
||||
// RUN-STOPS: overflow@7
|
||||
DECLARE X, Y : FLOAT
|
||||
X <- 1.0E308 * 10.0
|
||||
Y <- X - X
|
||||
ASSERT Y == Y
|
||||
OUTPUT Y
|
||||
@@ -0,0 +1,8 @@
|
||||
// A whole number stored in a FLOAT32 is rounded to the nearest single:
|
||||
// 16777217 becomes 16777216. A rule that kept the INTEGER's value for the
|
||||
// FLOAT32 would prove this ASSERT, and the run breaks it.
|
||||
// MUST-NOT-PROVE: assert@8
|
||||
DECLARE N : INTEGER <- 16777217
|
||||
DECLARE X : FLOAT32
|
||||
X <- N
|
||||
ASSERT X == N
|
||||
@@ -0,0 +1,9 @@
|
||||
// The checker's bound for the counter is stop + STEP, folded as a double:
|
||||
// 9007199254740991 + 2 rounds down. The way out of the loop then holds a
|
||||
// contradiction, and anything after the loop is proved.
|
||||
// MUST-NOT-PROVE: assert@9
|
||||
// RUN-STOPS: overflow@6
|
||||
FOR I <- 9007199254740990 TO 9007199254740991 STEP 2
|
||||
OUTPUT I
|
||||
NEXT I
|
||||
ASSERT 1 == 2
|
||||
@@ -0,0 +1,10 @@
|
||||
// A FOR counter declared INT8 holds only what INT8 holds: the run checks it at
|
||||
// the top of each pass and stops here when NEXT takes it to 128. No obligation
|
||||
// covered that check, so a unit with everything proved still stopped.
|
||||
// MUST-NOT-PROVE: overflow@7
|
||||
DECLARE I : INT8
|
||||
DECLARE N : INTEGER <- 0
|
||||
FOR I <- 120 TO 130
|
||||
N <- N + 1
|
||||
NEXT I
|
||||
OUTPUT N
|
||||
@@ -0,0 +1,13 @@
|
||||
// The way out of a FOR EACH loop includes the case of no pass at all. A
|
||||
// checker that kept "X is in Xs" on the way out held FALSE after looping over
|
||||
// an empty list, and proved anything, even 1 == 2.
|
||||
// MUST-NOT-PROVE: assert@12
|
||||
DECLARE Xs : LIST OF INTEGER
|
||||
DECLARE S : INTEGER
|
||||
Xs <- []
|
||||
S <- 0
|
||||
FOR EACH X IN Xs
|
||||
S <- S + X
|
||||
NEXT X
|
||||
ASSERT 1 == 2
|
||||
OUTPUT S
|
||||
@@ -0,0 +1,10 @@
|
||||
// M is empty, so the loop makes no pass. Its INVARIANT was never checked in
|
||||
// a run, and the checker assumed it on the way out all the same.
|
||||
// The run now checks it once more when the loop ends, and stops.
|
||||
// RUN-STOPS: invariant@7
|
||||
DECLARE M : LIST OF INTEGER
|
||||
FOR EACH E IN M
|
||||
INVARIANT 1 == 2
|
||||
OUTPUT E
|
||||
NEXT E
|
||||
ASSERT 1 == 2
|
||||
@@ -0,0 +1,13 @@
|
||||
// The INVARIANT is proved kept for the value just visited; the run checks it
|
||||
// with the next value, and it is FALSE there (Seen is 1, X is -1).
|
||||
// MUST-NOT-PROVE: invariant-keep@9
|
||||
DECLARE L : LIST OF INTEGER
|
||||
DECLARE Seen : INTEGER
|
||||
L <- [1, -1]
|
||||
Seen <- 0
|
||||
FOR EACH X IN L
|
||||
INVARIANT Seen == 0 OR X >= 0
|
||||
IF X >= 0 THEN
|
||||
Seen <- 1
|
||||
ENDIF
|
||||
NEXT X
|
||||
@@ -0,0 +1,13 @@
|
||||
// "An ARRAY keeps its dimensions through a loop" was assumed for every ARRAY
|
||||
// the body changes, while A <- B gave A the length of B. The language now holds
|
||||
// an ARRAY to its declared length: the store of another length stops the run.
|
||||
// (When both lengths are plain numbers the checker refuses the store; B's
|
||||
// length here is known only to the run.)
|
||||
// RUN-STOPS: value@11
|
||||
DECLARE A : ARRAY[3] OF INTEGER
|
||||
DECLARE N : INTEGER <- 5
|
||||
DECLARE B : ARRAY[N] OF INTEGER
|
||||
FOR I <- 0 TO 1
|
||||
A <- B
|
||||
NEXT I
|
||||
ASSERT LENGTH(A) == 3
|
||||
@@ -0,0 +1,10 @@
|
||||
// X is a FLOAT that starts at the whole number 1. At the top of the loop the
|
||||
// checker makes X an unknown of the sort its value had (a whole number), and
|
||||
// X is 0.5 on the second pass.
|
||||
// MUST-NOT-PROVE: assert@8
|
||||
DECLARE X : FLOAT
|
||||
X <- 1
|
||||
FOR I <- 0 TO 2
|
||||
ASSERT X <= 0.0 OR X >= 1.0
|
||||
X <- X / 2
|
||||
NEXT I
|
||||
@@ -0,0 +1,23 @@
|
||||
// The checker's own invariant guesses must be checked to a fixed point.
|
||||
// Each pass shifts a value one variable further down a chain, so "F <= 0"
|
||||
// survives the first four rounds of guessing and fails on the fifth. A
|
||||
// checker that stopped guessing after four rounds assumed it, and proved
|
||||
// the false ASSERT below.
|
||||
// MUST-NOT-PROVE: assert@22
|
||||
DECLARE A, B, C, D, E, F : INTEGER
|
||||
A <- 0
|
||||
B <- 0
|
||||
C <- 0
|
||||
D <- 0
|
||||
E <- 0
|
||||
F <- 0
|
||||
FOR I <- 0 TO 10
|
||||
F <- E
|
||||
E <- D
|
||||
D <- C
|
||||
C <- B
|
||||
B <- A
|
||||
A <- A + 1
|
||||
NEXT I
|
||||
ASSERT F <= 0
|
||||
OUTPUT F
|
||||
@@ -0,0 +1,7 @@
|
||||
// With USE IEEE a FLOAT can be NaN, and NaN == NaN is FALSE. The prover's
|
||||
// rule that every number equals itself does not hold for NaN, so nothing in
|
||||
// a program that says USE IEEE may be marked proved.
|
||||
// MUST-NOT-PROVE: assert@7
|
||||
USE IEEE
|
||||
DECLARE X : FLOAT <- NAN()
|
||||
ASSERT X == X
|
||||
@@ -0,0 +1,12 @@
|
||||
// Roll() gives a different number on each call. The checker treats a
|
||||
// FUNCTION as a function of its arguments only, so Roll() == Roll().
|
||||
// MUST-NOT-PROVE: assert@12
|
||||
FUNCTION Roll() RETURNS INTEGER
|
||||
RETURN RANDINT(1, 7)
|
||||
ENDFUNCTION
|
||||
|
||||
DECLARE A : INTEGER
|
||||
DECLARE B : INTEGER
|
||||
A <- Roll()
|
||||
B <- Roll()
|
||||
ASSERT A == B
|
||||
@@ -0,0 +1,5 @@
|
||||
// INDEX_OF("", "") is 0, and the checker assumes -1 <= result < LENGTH("").
|
||||
// MUST-NOT-PROVE: assert@5
|
||||
DECLARE I : INTEGER
|
||||
I <- INDEX_OF("", "")
|
||||
ASSERT I == -1
|
||||
@@ -0,0 +1,15 @@
|
||||
// The same, with INPUT inside the FUNCTION.
|
||||
// INPUT: 1
|
||||
// INPUT: 2
|
||||
// MUST-NOT-PROVE: assert@15
|
||||
FUNCTION ReadOne() RETURNS INTEGER
|
||||
DECLARE V : INTEGER
|
||||
INPUT V
|
||||
RETURN V
|
||||
ENDFUNCTION
|
||||
|
||||
DECLARE A : INTEGER
|
||||
DECLARE B : INTEGER
|
||||
A <- ReadOne()
|
||||
B <- ReadOne()
|
||||
ASSERT A == B
|
||||
@@ -0,0 +1,7 @@
|
||||
// INPUT accepts a whole number past 2^53 - 1 (so do TO_INTEGER, FLOOR, CEIL,
|
||||
// ROUND and INT), and MOD on it is computed in doubles: here N MOD 11 is 64.
|
||||
// INPUT: -516719406483505152
|
||||
// RUN-STOPS: overflow@6
|
||||
DECLARE N : INTEGER
|
||||
INPUT N
|
||||
ASSERT N MOD 11 < 11
|
||||
@@ -0,0 +1,7 @@
|
||||
// INT8 holds -128 to 127. X + 1 for X = 127 is 128, which does not fit, so
|
||||
// the run stops there. A rule that treated the sum as an exact whole number
|
||||
// with no range would prove it fits without a REQUIRE to guarantee it.
|
||||
// MUST-NOT-PROVE: overflow@6
|
||||
FUNCTION Inc(X : INT8) RETURNS INT8
|
||||
RETURN X + 1
|
||||
ENDFUNCTION
|
||||
@@ -0,0 +1,8 @@
|
||||
// X * A + (X * 2 - X * A) is 2 * X. The checker adds the coefficients as
|
||||
// doubles: A + 2 rounds to 2^53, minus A leaves 1, so it proves the sum is X.
|
||||
// Every value in the run is below 2^53.
|
||||
// INPUT: 1
|
||||
// MUST-NOT-PROVE: assert@8
|
||||
DECLARE X : INTEGER
|
||||
INPUT X
|
||||
ASSERT X * 9007199254740991 + (X * 2 - X * 9007199254740991) == X
|
||||
@@ -0,0 +1,11 @@
|
||||
// MAX(X, I) is typed FLOAT32 and holds the INTEGER 16777217, which no FLOAT32
|
||||
// holds. The store into Y rounds it; the checker sees a FLOAT32 going into a
|
||||
// FLOAT32 and keeps the value.
|
||||
// MUST-NOT-PROVE: assert@11
|
||||
DECLARE X : FLOAT32
|
||||
DECLARE Y : FLOAT32
|
||||
DECLARE I : INTEGER
|
||||
X <- 1.0
|
||||
I <- 16777217
|
||||
Y <- MAX(X, I)
|
||||
ASSERT Y == I
|
||||
@@ -0,0 +1,19 @@
|
||||
// Both ASSERTs with FORALL hold in a run. The ENSUREs of ISqrt(K) and Neg(K)
|
||||
// are kept as facts about one free "K" (K >= 0 from the first, K < 0 from
|
||||
// the second): a contradiction, so everything after is proved.
|
||||
// MUST-NOT-PROVE: assert@19
|
||||
FUNCTION ISqrt(N : INTEGER) RETURNS INTEGER
|
||||
REQUIRE N >= 0
|
||||
ENSURE RESULT >= 0 AND RESULT <= N
|
||||
RETURN 0
|
||||
ENDFUNCTION
|
||||
|
||||
FUNCTION Neg(N : INTEGER) RETURNS INTEGER
|
||||
REQUIRE N < 0
|
||||
ENSURE RESULT == 0 - N AND RESULT > 0
|
||||
RETURN 0 - N
|
||||
ENDFUNCTION
|
||||
|
||||
ASSERT FORALL K IN [0, 3) : ISqrt(K) >= 0
|
||||
ASSERT FORALL K IN [-3, 0) : Neg(K) > 0
|
||||
ASSERT 1 == 2
|
||||
@@ -0,0 +1,6 @@
|
||||
// RANDINT is drawn again for each K; the checker uses one unknown for every K,
|
||||
// so 0 and 1 are both in S or both out.
|
||||
// MUST-NOT-PROVE: assert@6
|
||||
DECLARE S : SET OF INTEGER
|
||||
S <- { K IN [0, 2) : RANDINT(0, 2) == 0 }
|
||||
ASSERT (0 IN S) == (1 IN S)
|
||||
@@ -0,0 +1,6 @@
|
||||
// RAND(X) for a negative X gives a value in (X, 0], not [0, X).
|
||||
// MUST-NOT-PROVE: assert@5
|
||||
DECLARE R : FLOAT
|
||||
R <- RAND(-1.0)
|
||||
ASSERT R >= 0.0
|
||||
OUTPUT R
|
||||
@@ -0,0 +1,7 @@
|
||||
// RAND(0.0) gives 0.0. A checker that assumed 0 <= R < 0.0 held a
|
||||
// contradiction from here on, and proved anything, even 1 == 2.
|
||||
// MUST-NOT-PROVE: assert@6
|
||||
DECLARE R : FLOAT
|
||||
R <- RAND(0.0)
|
||||
ASSERT 1 == 2
|
||||
OUTPUT R
|
||||
@@ -0,0 +1,8 @@
|
||||
// RANDINT(A, B) stops the program when [A, B) is empty.
|
||||
// MUST-NOT-PROVE: argument@5
|
||||
FUNCTION G(A : INTEGER) RETURNS INTEGER
|
||||
DECLARE R : INTEGER
|
||||
R <- RANDINT(A, 3)
|
||||
RETURN R
|
||||
ENDFUNCTION
|
||||
OUTPUT G(5)
|
||||
@@ -0,0 +1,7 @@
|
||||
// RANDN() is a new random number on each call; the checker makes both the same term.
|
||||
// MUST-NOT-PROVE: assert@7
|
||||
DECLARE A : FLOAT
|
||||
DECLARE B : FLOAT
|
||||
A <- RANDN()
|
||||
B <- RANDN()
|
||||
ASSERT A == B
|
||||
@@ -0,0 +1,10 @@
|
||||
// A REPEAT loop's INVARIANT is checked once more after the last pass. The
|
||||
// checker has no obligation for that check: "kept" covers only passes that repeat.
|
||||
// MUST-NOT-PROVE: invariant-keep@7
|
||||
DECLARE X : INTEGER
|
||||
X <- 0
|
||||
REPEAT
|
||||
INVARIANT X == 0
|
||||
X <- 1
|
||||
UNTIL X == 1
|
||||
OUTPUT X
|
||||
@@ -0,0 +1,6 @@
|
||||
// {1, 2.5} is typed SET OF INTEGER (the type of its first member), so X is
|
||||
// an INTEGER that holds 2.5.
|
||||
// MUST-NOT-PROVE: assert@5
|
||||
FOR EACH X IN {1, 2.5}
|
||||
ASSERT X <= 2 OR X >= 3
|
||||
NEXT X
|
||||
@@ -0,0 +1,16 @@
|
||||
// X >= 0 is FALSE, so ISqrt is never called. The checker keeps ISqrt's
|
||||
// ENSURE (0 <= RESULT <= X) as a fact anyway, and X >= 0 follows from it.
|
||||
// INPUT: -1
|
||||
// MUST-NOT-PROVE: assert@16
|
||||
FUNCTION ISqrt(N : INTEGER) RETURNS INTEGER
|
||||
REQUIRE N >= 0
|
||||
ENSURE RESULT >= 0 AND RESULT <= N
|
||||
RETURN 0
|
||||
ENDFUNCTION
|
||||
|
||||
DECLARE X : INTEGER
|
||||
INPUT X
|
||||
IF X >= 0 AND ISqrt(X) > 2 THEN
|
||||
OUTPUT "big"
|
||||
ENDIF
|
||||
ASSERT X >= 0
|
||||
@@ -0,0 +1,13 @@
|
||||
// B is FALSE, so X + 1 is never computed and X may be 127. The checker
|
||||
// keeps "X + 1 fits INT8" as a fact anyway, and proves X <= 126 from it.
|
||||
// INPUT: 127
|
||||
// INPUT: FALSE
|
||||
// MUST-NOT-PROVE: assert@13
|
||||
DECLARE X : INT8
|
||||
DECLARE B : BOOL
|
||||
INPUT X
|
||||
INPUT B
|
||||
IF B AND X + 1 > 0 THEN
|
||||
OUTPUT "positive"
|
||||
ENDIF
|
||||
ASSERT X <= 126
|
||||
@@ -0,0 +1,10 @@
|
||||
// SORTED of a two-dimensional ARRAY gives every value (6 here); the checker
|
||||
// gives SORTED(A) the first length of A.
|
||||
// MUST-NOT-PROVE: assert@10
|
||||
DECLARE A : ARRAY[2, 3] OF INTEGER
|
||||
FOR R <- 0 TO 2
|
||||
FOR C <- 0 TO 3
|
||||
A[R, C] <- R + C
|
||||
NEXT C
|
||||
NEXT R
|
||||
ASSERT LENGTH(SORTED(A)) == 2
|
||||
@@ -0,0 +1,10 @@
|
||||
// STEP 1 + 1 moves I by 2. The checker advances a counter whose STEP is not
|
||||
// a plain number by 1, and proves N == I kept.
|
||||
// MUST-NOT-PROVE: invariant-keep@7
|
||||
DECLARE N : INTEGER
|
||||
N <- 0
|
||||
FOR I <- 0 TO 10 STEP 1 + 1
|
||||
INVARIANT N == I
|
||||
N <- N + 1
|
||||
NEXT I
|
||||
OUTPUT N
|
||||
@@ -0,0 +1,6 @@
|
||||
// A FLOAT sum rounds at every step: 1E16 + 1.0 is 1E16. The checker extends
|
||||
// SUM over [0, 3) from SUM over [0, 2) by exact addition.
|
||||
// MUST-NOT-PROVE: assert@6
|
||||
DECLARE L : LIST OF FLOAT
|
||||
L <- [1E16, 0.0, 1.0]
|
||||
ASSERT (SUM K IN [0, 3) : L[K]) > (SUM K IN [0, 2) : L[K])
|
||||
@@ -0,0 +1,13 @@
|
||||
// SUM is not checked for infinity either: two sums overflow to +inf and -inf,
|
||||
// their SUM is NaN, and the run goes on with it. T == T is then FALSE.
|
||||
// RUN-STOPS: overflow@10
|
||||
DECLARE A : LIST OF FLOAT
|
||||
DECLARE B : LIST OF FLOAT
|
||||
DECLARE M : LIST OF FLOAT
|
||||
DECLARE T : FLOAT
|
||||
A <- [1E308, 1E308]
|
||||
B <- [-1E308, -1E308]
|
||||
APPEND(M, SUM K IN [0, 2) : A[K])
|
||||
APPEND(M, SUM K IN [0, 2) : B[K])
|
||||
T <- SUM K IN [0, 2) : M[K]
|
||||
ASSERT T == T
|
||||
@@ -0,0 +1,6 @@
|
||||
// SUM adds whole numbers without the check + has: past 2^53 - 1 the total is
|
||||
// no longer exact and the run goes on.
|
||||
// RUN-STOPS: overflow@6
|
||||
DECLARE L : LIST OF INTEGER
|
||||
L <- [9007199254740991, 1, 1]
|
||||
ASSERT (SUM K IN [0, 3) : L[K]) > (SUM K IN [0, 2) : L[K])
|
||||
Reference in new issue
Block a user