"""
Knuth's TPK program in Cobra

From http://en.wikipedia.org/wiki/Trabb_Pardo-Knuth_algorithm

"In their 1977 work "The Early Development of Programming Languages", Trabb Pardo
 and Knuth introduced a trivial program which 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."

While this is useful for demonstrating a few basic things about a language, it
does not demonstrate well the features surrounding larger issues such as
organizing large code bases, working on a team, documenting your code, etc.
Also, the standard TPK code mixes input, computations and output all together.
It also directly references stdin and hard codes constants rather than taking
parameters for those things.

But some people still like to see this code to compare it to other languages.
So here it is, including a better version that addresses some of the above issues.
"""

class TPK

	shared

		def f(x as number) as number
			return x.abs.sqrt + 5.0 * x.pow(3.0)
		
		def basicTPK1
			a = number[](11)
			
			# read in the values for the array, one per line
			for i in a.length
				a[i] = number.parse(Console.readLine)
			
			# in reverse order, apply "f" to each element of the array and
			# print the result, including index
			for i in a.length-1 : 0 : -1
				y = .f(a[i])
				print '[i] ', if(y>400, 'TOO LARGE', y)

		def basicTPK2
			# some versions in other languages print the input number
			# rather than its index
			a = number[](11)
			for i in a.length
				a[i] = number.parse(Console.readLine)
			Array.reverse(a)
			for x in a
				y = .f(x)
				print '[x] ', if(y>400, 'TOO LARGE', y)

		def betterTPK
			"""
			Invokec .betterTPK with default arguments: Console.in, 11 and 400.
			"""
			.betterTPK(Console.in to !, 11, 400)

		def betterTPK(tr as TextReader, count as int, limit as number)
			require
				count > 0
			ensure
				# Well there's not much to ensure for a method that dumps its
				# results as textual output. An even better approach is to
				# separate computation from I/O so that computations can be
				# more easily tested, contracted and reused.
				true
			test
				# Now that we're using parameters, we can make a proper test.
				sw = StringWriter()
				print to sw
					.betterTPK(StringReader('1\r\n1\r\n'), 2, 400)
				r = sw.toString.replace('\r','').replace('\n','; ')
				assert r == '1  6.0; 1  6.0; '
			body
				a = number[](count)
				for i in a.length
					a[i] = number.parse(tr.readLine)
				Array.reverse(a)
				for x in a
					y = .f(x)
					print '[x] ', if(y>limit, 'TOO LARGE', y)

		def main
			if false
				print
				print 'Basic TPK - Enter numbers:'
				.basicTPK1
			if true
				print
				print 'Better TPK - Enter numbers:'
				.betterTPK