Trabb Pardo–Knuth algorithm: Difference between revisions

# ''Print and show the program in action from a typical run here''. (If the output is graphical rather than text then either add a screendump or describe textually what is displayed).

<br><br>

 

=={{header|Ada}}==

 

 

procedure Trabb_Pardo_Knuth is

end loop;

 

 

{{out}}

Tested with Agena 2.9.5 Win32

{{Trans|ALGOL W}}

local y;

local a := [];

fi

od

{{out}}

<pre>

This is as close as possible to Pardo and Knuth's original but works with the [http://www.gnu.org/software/marst/marst.html GNU MARST] ALGOL-to-C compiler. Note Pardo and Knuth did not insist on prompts or textual I/O as their report mostly concerned systems that predated even the idea of keyboard interaction.

 

integer i; real y; real array a[0:10];

real procedure f(t); value t; real t;

outchar(1, "\n", 1)

end

 

Compilation and sample run:

=={{header|ALGOL 68}}==

{{Trans|ALGOL W}} which was itself a Translation of ALGOL 60.

PROC f = ( REAL t )REAL:

sqrt(ABS t)+5*t*t*t;

ELSE print( ( fixed( y, -9, 4 ), newline ) )

FI

{{out}}

<pre>

=={{header|ALGOL W}}==

{{Trans|ALGOL 60}}

real y; real array a( 0 :: 10 );

real procedure f( real value t );

else write( y );

end

{{out}}

<pre>

6.0000

</pre>

 

=={{header|AutoIt}}==

; by James1337 (autoit.de)

; AutoIt Version: 3.3.8.1

Func f($x)

Return Sqrt(Abs($x)) + 5*$x^3

{{out}}

<pre>Input: "1 2 3 4 5 6 7 8 9 10 11"

f(2) = 41.4142135623731

f(1) = 6</pre>

 

=={{header|AWK}}==

# syntax: GAWK -f TRABB_PARDO-KNUTH_ALGORITHM.AWK

BEGIN {

function abs(x) { if (x >= 0) { return x } else { return -x } }

function f(x) { return sqrt(abs(x)) + 5 * x ^ 3 }

{{out}}

<pre>

</pre>

 

print 'enter 11 numbers'

for i = 0 to 10

x = f(s[i])

if x > 400 then

else

print x

function f(n)

return sqrt(abs(n))+5*n^3

{{out}}

<pre>enter 11 numbers

f(-3)=-133.2679492

f(-4)=-318</pre>

 

=={{header|C}}==

#include<math.h>

#include<stdio.h>

return 0;

}

{{out}}

<pre>Please enter 11 numbers :10 -1 1 2 3 4 4.3 4.305 4.303 4.302 4.301

 

=={{header|C++}}==

#include <iostream>

#include <cmath>

}

return 0 ;

{{out}}

<pre>Please enter 11 numbers!

 

=={{header|Common Lisp}}==

(princ "Enter 11 numbers (space-separated): ")

(let ((numbers '()))

(trabb-pardo-knuth (lambda (x) (+ (expt (abs x) 0.5) (* 5 (expt x 3))))

 

{{Out}}

 

=={{header|D}}==

 

double f(in double x) pure nothrow {

writefln("f(%0.3f) = %s", x, y > 400 ? "Too large" : y.text);

}

{{out}}

<pre>Please enter eleven numbers on a line: 1 2 3 -4.55 5.1111 6 -7 8 9 10

f(2.000) = 41.4142

f(1.000) = 6</pre>

 

=={{header|EchoLisp}}==

(define (trabb-fun n)

(+ (* 5 n n n) (sqrt(abs n))))

(error 'incomplete-list numlist))))) ;; users cancel

(for-each check-trabb (reverse (take numlist 11))))

{{out}}

(trabb)

;; input : (0 4 1 8 5 9 10 3 6 7 2)

(root g 0 10)

→ 4.301409367213084

 

=={{header|Ela}}==

Translation of OCaml version:

 

 

:::IO

do

putStrLn "Please enter 11 numbers:"

 

{{out}}

f(2) = 41.4142135623731

f(1) = 6</pre>

=={{header|Elena}}==

{{trans|C}}

if (result > 400)

{{out}}

<pre>

=={{header|Elixir}}==

{{trans|Erlang}}

def task do

Enum.reverse( get_11_numbers )

end

 

 

{{out}}

 

=={{header|Erlang}}==

-module( trabb_pardo_knuth ).

 

perform_operation_check_overflow( N, Result, Overflow ) when Result > Overflow -> alert( N );

perform_operation_check_overflow( N, Result, _Overflow ) -> io:fwrite( "f(~p) => ~p~n", [N, Result] ).

{{out}}

<pre>

 

=={{header|ERRE}}==

!Trabb Pardo-Knuth algorithm

PROGRAM TPK

END FOR

END PROGRAM

Numbers to be elaborated is included in the program with a DATA statement. You can substitute

this with an input keyboard like this

 

=={{header|F Sharp|F#}}==

module ``Trabb Pardo - Knuth``

open System

| n when n <= 400.0 -> Console.WriteLine(n)

| _ -> Console.WriteLine("Overflow"))

{{out}}

<pre>fsharpi Program.fsx

 

=={{header|Factor}}==

prettyprint sequences splitting ;

IN: rosetta-code.trabb-pardo-knuth

[ string>number [ fn ] ?result print ] each ;

 

{{out}}

<pre>

 

=={{header|Forth}}==

 

4e2 fconstant f-too-big

 

: tpk ( -- )

{{out}}

<pre>

===Fortran 95===

{{works with|Fortran|95 and later}}

implicit none

 

end function

{{out}}

<pre> Input eleven numbers:

===Fortran I===

Written in FORTRAN I (1957), the original language quoted in the 1976 Donald Knuth & Luis Trabb Pardo’s study. Let’ note: no type declarations (INTEGER, REAL), no subprogram FUNCTION (only statement function), no logical IF, no END statement, and only Hollerith strings. The input data are on 2 80-column punched cards, only 1 to 72 columns are used so 6 values are read on the first card and 5 on the second card, so even input data could be numbered in the 73-80 area.

FTPKF(X)=SQRTF(ABSF(X))+5.0*X**3 TPK00020

DIMENSION A(11) TPK00030

3 CONTINUE TPK00150

STOP 0 TPK00160

 

=={{header|Go}}==

===Task/Wikipedia===

This solution follows the task description by reversing the sequence. It also rejects non-numeric input until 11 numbers are entered.

 

import (

result := math.Sqrt(math.Abs(x)) + 5*x*x*x

return result, result > 400

{{out}}

The input is chosen to show some interesting boundary cases.

===TPK paper===

The original paper had no requirement to reverse the sequence in place, but instead processed the sequence in reverse order.

 

import (

}

}

 

=={{header|Haskell}}==

 

f :: Floating a => a -> a

else print x) .

f) $

{{out}}

<pre>Enter 11 numbers for evaluation

<tt>reverse(S)</tt> with <tt>S[*S to 1 by -1]</tt>.

 

S := []

writes("Enter 11 numbers: ")

procedure f(x)

return abs(x)^0.5 + 5*x^3

 

Sample run:

=={{header|Io}}==

 

// Initialize objects to be used

in_num := File standardInput()

)

)

 

{{out}}

No checks are done if the input is actually numbers and if there are actually eleven of them. This doesn't affect the algorithm.

Additional checks can be done separately.

smoutput 'Enter 11 numbers: '

t1=: ((5 * ^&3) + (^&0.5@* *))"0 |. _999&".;._1 ' ' , 1!:1 [ 1

smoutput 'Values of functions of reversed input: ' , ": t1

; <@(,&' ')@": ` ((<'user alert ')&[) @. (>&400)"0 t1

A possible use scenario:

Enter 11 numbers:

1 2 3 4 5 6 7 8.8 _9 10.123 0

Values of functions of reversed input: 0 5189.96 _3642 3410.33 1717.65 1082.45 627.236 322 136.732 41.4142 6

0 user alert _3642 user alert user alert user alert user alert 322 136.732 41.4142 6

 

Note that the result of tpk is persisted in t1 and is also its explicit result rather than being an explicit output.

Here's an alternative approach:

 

smoutput 'Enter 11 numbers: '

_&". 1!:1]1

overflow400=: 'user alert'"_`":@.(<:&400)"0

 

 

And, here's this alternative in action:

 

Enter 11 numbers:

1 2 3 4 5 6 7 8.8 _9 10.123 0

136.732

41.4142

 

(clearly, other alternatives are also possible).

=={{header|Java}}==

 

* Alexander Alvonellos

*/

}

}

 

{{out}}

 

=== Spidermonkey ===

 

function main() {

 

main();

 

Results:

jq does not currently have an interactive mode allowing a prompt to be issued first,

and so the initial prompt is implemented here using "echo", in keeping with the jq approach of dovetailing with other command-line tools.

def abs: if . < 0 then -. else . end;

def power(x): (x * log) | exp;

else error("The number of numbers was not 11.")

end

{{out}}

jq -M -s -R -f Trabb_Pardo-Knuth_algorithm.jq

> Enter 11 numbers on one line; when done, enter the end-of-file character:

136.73205080756887

41.41421356237309

 

=={{header|Kotlin}}==

 

fun f(x: Double) = Math.sqrt(Math.abs(x)) + 5.0 * x * x * x

println(v)

}

 

{{out}}

</pre>

 

 

=={{header|Lua}}==

===Implementation of task description===

 

function reverse (t)

result = f(x)

if result > 400 then print("Overflow!") else print(result) end

{{out}}

<pre>Enter 11 numbers...

 

===Line-for-line from TPK paper===

function f (t)

return math.sqrt(math.abs(t)) + 5*t^3

if y > 400 then print(i, "TOO LARGE")

else print(i, y) end

{{out}}

<pre>1

1 41.414213562373

0 6</pre>

 

=={{header|M2000 Interpreter}}==

Module Input11 {

Flush ' empty stack

Input11

Run

 

To collect the output in clipboard. Global variables need <= to assign values, and document append values using = or <= (for globals)

Output with "," for decimals (Locale 1032). We can change this using statement Locale 1033

 

Global a$

Document a$ ' make a$ as a document - string with paragraphs

Run 1, 2, 3, -4.55,5.1111, 6, -7, 8, 9, 10, 11

Clipboard a$

 

{{out}}

 

=={{header|Maple}}==

f:= x -> abs(x)^0.5 + 5*x^3:

for item in seqn do

print(result):

end if:

{{Out|Usage}}

Input:1,2,3,4,5,6,7,8,9,10,11

6.</pre>

 

tpk[numbers_,overflowVal_]:=Module[{revNumbers},

revNumbers=Reverse[numbers];

]

]

{{out}}

<pre>

f[1.18367]= 9.38004

f[0.470145]= 1.20527

</pre>

 

=={{header|Nim}}==

{{trans|Python}}

 

 

proc ask: seq[float] =

 

var s = ask()

reverse s

for x in s:

{{out}}

<pre>11 numbers: 1 2 3 4 5 6 7 8 9 10 11

 

=={{header|Objective-C}}==

{{works with|Mac OS X|10.6+}}

 

// TPKA.m

// RosettaCode

return 0;

}

 

{{out}}

=={{header|OCaml}}==

 

let p x = x < 400.0

 

then Printf.printf "f(%g) = %g\n%!" x res

else Printf.eprintf "f(%g) :: Overflow\n%!" x

 

{{out}}

 

=={{header|PARI/GP}}==

print("11 numbers: ");

v=vector(11, n, eval(input()));

v=apply(x->x=sqrt(abs(x))+5*x^3;if(x>400,"overflow",x), v);

vector(11, i, v[12-i])

{{out}}

<pre>11 numbers:

 

=={{header|Perl}}==

for ( 1..11 ) {

$number = <STDIN>;

my $result = sqrt( abs($n) ) + 5 * $n**3;

printf "f( %6.2f ) %s\n", $n, $result > 400 ? " too large!" : sprintf "= %6.2f", $result

{{out}}

<pre>

f( 2.00 ) = 41.41</pre>

 

=={{header|Phix}}==

{{Out}}

<pre>

f(0.470145):1.20527

</pre>

 

=={{header|PicoLisp}}==

(+ (sqrt (abs X)) (* 5 X X X)) )

 

(for X (reverse (make (do 11 (link (read)))))

(when (> (f X) 400)

Test:

f : 11

f = 6658

f = 41

f : 1

 

=={{header|PL/I}}==

Trabb: Procedure options (main); /* 11 November 2013 */

 

 

end Trabb;

{{out}}

<pre>

=={{header|PL/M}}==

Assuming the existence of suitable external library routines.

/* external I/O and real mathematical routines */

WRITE$STRING: PROCEDURE( S ) EXTERNAL; DECLARE S POINTER; END;

END MAIN;

 

{{out}}

<pre>

 

=={{header|PowerShell}}==

function Get-Tpk

{

}

}

$tpk = 1..11 | Get-Tpk

$tpk

{{Out}}

<pre>

</pre>

Sort back to ascending order ignoring '''Overflow''' results:

$tpk | where result -ne overflow | sort number

{{Out}}

<pre>

4 322

</pre>

 

=={{header|Python}}==

===Functional===

Type "copyright", "credits" or "license()" for more information.

>>> def f(x): return abs(x) ** 0.5 + 5 * x**3

11 numbers: 1 2 3 4 5 6 7 8 9 10 11

11:TOO LARGE!, 10:TOO LARGE!, 9:TOO LARGE!, 8:TOO LARGE!, 7:TOO LARGE!, 6:TOO LARGE!, 5:TOO LARGE!, 4:322.0, 3:136.73205080756887, 2:41.41421356237309, 1:6.0

 

===Procedural===

 

 

if __name__ == '__main__':

else:

 

=={{header|R}}==

 

f <- function(x) sqrt(abs(x)) + 5*x^3

else

print(res)

 

{{out|Sample output}}

 

=={{header|Racket}}==

#lang racket

 

(displayln "Overflow!")

(printf "f(~a) = ~a\n" x res)))

 

{{out}}

f(1) = 6

</pre>

 

=={{header|REXX}}==

<br><br>It could be noted that almost half of this program is devoted to prompting, parsing and validating of the (input) numbers,

<br>not to mention some hefty code to support right-justified numbers such that they are aligned when displayed.

numeric digits 200 /*the number of digits precision to use*/

parse arg N .; if N=='' | N=="," then N=11 /*Not specified? Then use the default.*/

numeric digits; parse value format(x,2,1,,0) 'E0' with g 'E' _ .; g=g *.5'e'_ % 2

do j=0 while h>9; m.j=h; h=h % 2 + 1; end /*j*/

{{out|output|text=&nbsp; when prompted, using the input of: &nbsp; &nbsp; <tt> 5 &nbsp; 3.3 &nbsp; 3 &nbsp; 2e-1 &nbsp; 1 &nbsp; 0 &nbsp; -1 &nbsp; -222 &nbsp; -33 &nbsp; 4.0004 &nbsp; +5 </tt>}}

<pre>

 

=={{header|Ring}}==

# Project : Trabb Pardo–Knuth algorithm

 

func f(n)

return sqrt(fabs(n)) + 5 * pow(n, 3)

Output:

<pre>

f(-5) = -622.764

 

</pre>

 

=={{header|Ruby}}==

 

 

puts "Please enter 11 numbers:"

res = f(n)

puts res > 400 ? "Overflow!" : res

 

{{out}}

 

=={{header|Rust}}==

use std::io::{self, BufRead};

 

}

}

 

{{out}}

 

=={{header|Scala}}==

final val numbers = scala.collection.mutable.MutableList[Double]()

final val in = new java.util.Scanner(System.in)

private final val THRESHOLD = 400D

private final val CAPACITY = 11

 

=={{header|Sidef}}==

nums = Sys.readln("Please type 11 space-separated numbers: ").nums

} while(nums.len != 11)

var r = (n.abs.sqrt + (5 * n**3));

say "#{n}\t#{ r > 400 ? 'Urk!' : r }";

{{out}}

<pre>

10 Urk!

</pre>

 

=={{header|Swift}}==

{{works with|Swift 2.0}}

 

print("Enter 11 numbers for the Trabb─Pardo─Knuth algorithm:")

print("f(\($0))", result > 400.0 ? "OVERFLOW" : result, separator: "\t")

}

{{Out}}

<pre>

 

=={{header|Symsyn}}==

|Trabb Pardo–Knuth algorithm

 

+ y x

return

 

=={{header|Tcl}}==

proc f {x} {expr {abs($x)**0.5 + 5*$x**3}}

proc overflow {y} {expr {$y > 400}}

puts "${x}: $result"

}

{{out|Sample run}}

<pre>

</pre>

 

 

 

 

<pre>

</pre>

 

=={{header|XPL0}}==

 

func real F(X);

else RlOut(0, Result);

CrLf(0)];

 

{{out}}

 

=={{header|zkl}}==

reg ns; do{

ns=ask("11 numbers seperated by spaces: ");

ns.reverse().apply(fcn(x){

fx:=f(x); "f(%7.3f)-->%s".fmt(x, if(fx>400)"Overflow" else fx) })

{{out}}

<pre>