Trabb Pardo–Knuth algorithm: Difference between revisions

{{trans|Python}}

R sqrt(abs(x)) + 5 * x ^ 3

E

print(‘#.: #.’.format(x, result))

{{out}}

=={{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>

=={{header|APL}}==

{{works with|Dyalog APL}}

f←{(0.5*⍨|⍵)+5×⍵*3} ⍝ define a function f

S←,⍎{⍞←⍵ ⋄ (≢⍵)↓⍞}'Please, enter 11 numbers: '

:EndIf

:EndFor

=={{header|Arturo}}==

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

result: proc n

print [n ":" (result > 400)? -> "TOO LARGE!" -> result]

{{out}}

* ASIC does not have the fuction that calculates a square root. Thus, the program uses the added subprogram <code>CALCSQRT:</code>.

* ASIC does not scroll a text screen, but it wraps the text. Thus, the program clears the screen after the user enters numbers.

REM Trabb Pardo-Knuth algorithm

REM Used "magic numbers" because of strict specification of the algorithm.

SQRT@ = MIDDLE@

RETURN

{{out}}

Enter the data.

=={{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"

=={{header|AutoHotkey}}==

MsgBox % result := TPK(seq, 400)

return

f(x){

return Sqrt(x) + 5* (x**3)

{{out}}

<pre>11 : OVERFLOW

=={{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>

==={{header|Minimal BASIC}}===

{{works with|QBasic}}

10 REM Trabb Pardo-Knuth algorithm

20 REM Used "magic numbers" because of strict specification

260 NEXT I

270 END

==={{header|QBasic}}===

{{works with|QBasic|1.1}}

f = SQR(ABS(n)) + 5 * n ^ 3

END FUNCTION

i = i - 1

LOOP UNTIL i < 1

==={{header|True BASIC}}===

{{works with|QBasic}}

LET f = SQR(ABS(n)) + 5 * n ^ 3

END FUNCTION

LET i = i - 1

LOOP UNTIL i < 1

==={{header|Yabasic}}===

return sqr(abs(n)) + 5.0 * n ^ 3.0

end sub

endif

next i

=={{header|BASIC256}}==

print 'enter 11 numbers'

for i = 0 to 10

function f(n)

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

{{out}}

<pre>enter 11 numbers

=={{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!

{{trans|XBasic}}

{{works with|Commodore BASIC|4.5}}

10 REM TRABB PARDO-KNUTH ALGORITHM

20 REM USED "MAGIC NUMBERS" BECAUSE OF STRICT SPECIFICATION OF THE ALGORITHM.

220 NEXT I

230 END

{{out}}

<pre>

=={{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

=={{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}}

{{trans|C}}

ELENA 5.0 :

import extensions'math;

}

}

{{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|FreeBASIC}}==

' compile with: fbc -s console

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>1 => -5

===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|Julia}}==

for i in reverse(split(readline()))

v = f(parse(Int, i))

println("$(i): ", v > 400 ? "TOO LARGE" : v)

{{out}}

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

=={{header|Kotlin}}==

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

println(v)

}

{{out}}

=={{header|Ksh}}==

#!/bin/ksh

printf "%s\n" "${result}"

fi

{{out}}<pre>

Please input 11 numbers...

{{trans|XBasic}}

{{works with|Just BASIC|any}}

' Trabb Pardo-Knuth algorithm

' Used "magic numbers" because of strict specification of the algorithm.

f = sqr(abs(n)) + 5 * n * n * n

end function

{{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

=={{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

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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

revNumbers=Reverse[numbers];

]

]

{{out}}

<pre>

=={{header|min}}==

{{works with|min|0.19.3}}

(((abs 0.5 pow) (3 pow 5 * +)) cleave) :fn

"Enter 11 numbers:" puts!

(gets float) 11 times

{{out}}

<pre>

{{trans|Commodore BASIC}}

{{works with|Nascom ROM BASIC|4.7}}

10 REM Trabb Pardo-Knuth algorithm

20 REM Used "magic numbers" because of strict

240 NEXT I

250 END

{{out}}

<pre>

=={{header|Nim}}==

{{trans|Python}}

proc f(x: float): float = x.abs.pow(0.5) + 5 * x.pow(3)

for x in s:

let result = f(x)

{{out}}

{{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>

=={{header|Phix}}==

<span style="color: #008080;">function</span> <span style="color: #000000;">f</span><span style="color: #0000FF;">(</span><span style="color: #004080;">atom</span> <span style="color: #000000;">x</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">return</span> <span style="color: #7060A8;">sqrt</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">abs</span><span style="color: #0000FF;">(</span><span style="color: #000000;">x</span><span style="color: #0000FF;">))+</span><span style="color: #000000;">5</span><span style="color: #0000FF;">*</span><span style="color: #7060A8;">power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">x</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">)</span>

<span style="color: #008000;">"0.470145,1.18367,2.36984,4.86759,2.40274,5.48793,3.30256,5.34393,4.21944,2.23501,-0.0200707"</span><span style="color: #0000FF;">}</span>

<span style="color: #7060A8;">papply</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tests</span><span style="color: #0000FF;">,</span><span style="color: #000000;">test</span><span style="color: #0000FF;">)</span>

{{Out}}

<pre>

=={{header|Picat}}==

go =>

nl.

Example run:

=={{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>

=={{header|PureBasic}}==

ProcedureReturn Pow(Abs(x), 0.5) + 5 * x * x * x

EndProcedure

Print(#crlf$ + #crlf$ + "Press ENTER to exit"): Input()

CloseConsole()

{{out}}

<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===

{{Works with|Python|3.10}}

def f(x):

print(f'f({x}): overflow')

else:

{{out}}

<pre>Enter 11 numbers:

=={{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}}

=={{header|Raku}}==

(formerly Perl 6)

until @nums == 11;

for @nums.reverse -> $n {

my $r = $n.abs.sqrt + 5 * $n ** 3;

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

{{out}}

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

<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>

=={{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}}==

{{trans|Raku}}

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>

=={{header|Sinclair ZX81 BASIC}}==

Works with the unexpanded (1k RAM) ZX81

20 PRINT "ENTER ELEVEN NUMBERS:"

30 FOR I=1 TO 11

100 GOTO 120

110 PRINT A(I),Y

{{out}}

<pre>ENTER ELEVEN NUMBERS:

=={{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>

=={{header|VBScript}}==

Function tpk(s)

arr = Split(s," ")

list = WScript.StdIn.ReadLine

tpk(list)

{{Out}}

=={{header|Wren}}==

{{libheader|Wren-fmt}}

import "/fmt" for Fmt

Fmt.print(" f($6.3f) = overflow", item)

}

{{out}}

=={{header|XBasic}}==

{{works with|Windows XBasic}}

' Trabb Pardo-Knuth algorithm

PROGRAM "tpkalgorithm"

END FUNCTION

END PROGRAM

{{out}}

<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>