# TPK algorithm

The **TPK algorithm** is a program introduced by Donald Knuth and Luis Trabb Pardo to illustrate the evolution of computer programming languages. In their 1977 work "The Early Development of Programming Languages", Trabb Pardo and Knuth introduced a small program that involved arrays, indexing, mathematical functions, subroutines, I/O, conditionals and iteration. They then wrote implementations of the algorithm in several early programming languages to show how such concepts were expressed.

To explain the name "TPK", the authors referred to Grimm's law (which concerns the consonants 't', 'p', and 'k'), the sounds in the word "typical", and their own initials (Trabb Pardo and Knuth).^{[1]} In a talk based on the paper, Knuth said:^{[2]}

You can only appreciate how deep the subject is by seeing how good people struggled with it and how the ideas emerged one at a time. In order to study this—Luis I think was the main instigator of this idea—we take one program—one algorithm—and we write it in every language. And that way from one example we can quickly psych out the flavor of that particular language. We call this the TPK program, and well, the fact that it has the initials of Trabb Pardo and Knuth is just a funny coincidence.

In the paper, the authors implement this algorithm in Konrad Zuse's Plankalkül, in Goldstine and von Neumann's flow diagrams, in Haskell Curry's proposed notation, in Short Code of John Mauchly and others, in the Intermediate Program Language of Arthur Burks, in the notation of Heinz Rutishauser, in the language and compiler by Corrado Böhm in 1951–52, in Autocode of Alick Glennie, in the A-2 system of Grace Hopper, in the Laning and Zierler system, in the earliest proposed Fortran (1954) of John Backus, in the Autocode for Mark 1 by Tony Brooker, in ПП-2 of Andrey Ershov, in BACAIC of Mandalay Grems and R. E. Porter, in Kompiler 2 of A. Kenton Elsworth and others, in ADES of E. K. Blum, the Internal Translator of Alan Perlis, in Fortran of John Backus, in ARITH-MATIC and MATH-MATIC from Grace Hopper's lab, in the system of Bauer and Samelson, and (in addenda in 2003 and 2009) PACT I and TRANSCODE. They then describe what kind of arithmetic was available, and provide a subjective rating of these languages on parameters of "implementation", "readability", "control structures", "data structures", "machine independence" and "impact", besides mentioning what each was the first to do.

## The algorithm[edit]

askfor 11 numbers to be read into a sequenceSreversesequenceSfor eachiteminsequenceScalla function to do an operationifresultoverflowsalertuserelseresult

The algorithm reads eleven numbers from an input device, stores them in an array, and then processes them in reverse order, applying a user-defined function to each value and reporting either the value of the function or a message to the effect that the value has exceeded some threshold.

## ALGOL 60 implementation[edit]

```
begin integer i; real y; real array a[0:10];
real procedure f(t); real t; value t;
f := sqrt(abs(t)) + 5 * t ^ 3;
for i := 0 step 1 until 10 do read(a[i]);
for i := 10 step -1 until 0 do
begin y := f(a[i]);
if y > 400 then write(i, "TOO LARGE")
else write(i, y);
end
end.
```

The problem with the usually specified function is that the term `5 * t ^ 3`

gives overflows in almost all languages for very large negative values.

## C implementation[edit]

This shows a C implementation equivalent to the above ALGOL 60.

```
#include <math.h>
#include <stdio.h>
double f(double t)
{
return sqrt(fabs(t)) + 5 * pow(t, 3);
}
int main(void)
{
double a[11] = {0}, y;
for (int i = 0; i < 11; i++)
scanf("%lf", &a[i]);
for (int i = 10; i >= 0; i--) {
y = f(a[i]);
if (y > 400)
printf("%d TOO LARGE\n", i);
else
printf("%d %.16g\n", i, y);
}
}
```

## Python implementation[edit]

This shows a Python implementation.

```
from math import sqrt
def f(t):
return sqrt(abs(t)) + 5 * t ** 3
a = [float(input()) for _ in range(11)]
for i, t in reversed(list(enumerate(a))):
y = f(t)
if y > 400:
print(i, "TOO LARGE")
else:
print(i, y)
```

## Rust implementation[edit]

This shows a Rust implementation.

```
use std::io::{self, prelude::*};
fn f(t: f64) -> f64 {
t.abs().sqrt() + 5.0 * t.powi(3)
}
fn main() {
let mut a = [0f64; 11];
for (t, input) in a.iter_mut().zip(io::stdin().lock().lines()) {
*t = input.unwrap().parse().unwrap();
}
a.iter().enumerate().rev().for_each(|(i, &t)| match f(t) {
y if y > 400.0 => println!("{} TOO LARGE", i),
y => println!("{} {}", i, y),
});
}
```

## References[edit]

**^**Luis Trabb Pardo and Donald E. Knuth, "The Early Development of Programming Languages".- First published August 1976 in typewritten draft form, as Stanford CS Report STAN-CS-76-562
- Published in
*Encyclopedia of Computer Science and Technology*, Jack Belzer, Albert G. Holzman, and Allen Kent (eds.), Vol. 6, pp. 419-493. Dekker, New York, 1977. - Reprinted (doi:10.1016/B978-0-12-491650-0.50019-8) in
*A History of Computing in the Twentieth Century*, N. Metropolis, J. Howlett, and G.-C. Rota (eds.), New York, Academic Press, 1980. ISBN 0-12-491650-3 - Reprinted with amendments as Chapter 1 of
*Selected Papers on Computer Languages*, Donald Knuth, Stanford, CA, CSLI, 2003. ISBN 1-57586-382-0)

**^**"A Dozen Precursors of Fortran", lecture by Donald Knuth, 2003-12-03 at the Computer History Museum: Abstract, video