Jensen's Device: Difference between revisions

[[wp:Donald_Knuth|Donald Knuth]] later proposed the [[Man or boy test|Man or Boy Test]] as a more rigorous exercise.

<br><br>

 

=={{header|Ada}}==

 

procedure Jensen_Device is

begin

Put_Line (Float'Image (Sum (I'Access, 1.0, 100.0, Inv_I'Access)));

<pre>

5.18738E+00

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

{{trans|ALGOL 60}}

INT i;

PROC sum = (REF INT i, INT lo, hi, PROC REAL term)REAL:

COMMENT note the correspondence between the mathematical notation and the call to sum COMMENT

print (sum (i, 1, 100, REAL: 1/i))

Output: +5.18737751763962e +0

 

=={{header|AppleScript}}==

 

on jsum(i, lo, hi, term)

end script

 

Output: 5.18737751764

 

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

fUn: .float 1

 

 

{{works with|BBC BASIC for Windows}}

END

= temp

Output:

 

=={{header|Bracmat}}==

= I lo hi Term temp

. !arg:((=?I),?lo,?hi,(=?Term))

)

& sum$((=i),1,100,(=!i^-1))

Output:

<pre>14466636279520351160221518043104131447711/2788815009188499086581352357412492142272</pre>

 

=={{header|C}}==

 

int i;

printf("%f\n", sum(&i, 1, 100, term_func));

return 0;

Output: 5.18738

 

{{works with|gcc}}

Alternatively, C's macros provide a closer imitation of ALGOL's call-by-name semantics:

int i;

printf("%f\n", sum(i, 1, 100, 1.0 / i));

return 0;

Output: 5.187378

 

=={{header|C sharp}}==

Can be simulated via lambda expressions:

 

class JensensDevice

Console.WriteLine(Sum(ref i, 1, 100, () => 1.0 / i));

}

 

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

#include <iostream>

 

std::cout << SUM(i,1,100,1.0/i) << "\n";

return 0;

Output: 5.18738

5.18738

=={{header|Clipper}}==

With hindsight Algol60 provided this feature in a way that is terrible for program maintenance, because the calling code looks innocuous.

// A fairly direct translation of the Algol 60

// John M Skelton 11-Feb-2012

next i

return temp

 

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

Common Lisp does not have call-by-name for functions; however, it can be directly simulated by a macro wrapping selected parameters in lambdas.

 

 

(defun %sum (lo hi func)

 

(defmacro sum (i lo hi term)

 

14466636279520351160221518043104131447711/2788815009188499086581352357412492142272

CL-USER> (float (sum i 1 100 (/ 1 i)))

 

=={{header|D}}==

There are better ways to do this in D, but this is closer to the original Algol version:

pure @safe /*nothrow @nogc*/ {

double result = 0.0;

int i;

sum(i, 1, 100, 1.0/i).writeln;

{{out}}

<pre>

 

=={{header|DWScript}}==

Must use a "while" loop, as "for" loop variables are restricted to local variable for code clarity, and this indeed a case where any kind of extra clarity helps.

begin

i:=lo;

var i : Integer;

 

Output: 5.187...

 

(The definition of the outer <var>i</var> has been moved down to emphasize that it is unrelated to the <var>i</var> inside of <var>sum</var>.)

 

def sum(&i, lo, hi, &term) { # bind i and term to passed slots

var temp := 0

var i := null

sum(&i, 1, 100, def _.get() { return 1/i })

 

<tt>1/i</tt> is not a noun, so there is no slot associated with it; so we use <tt>def _.get() { return 1/i }</tt> to define a slot object which does the computation when it is read as a slot.

This emulation of the original call-by-name is of course unidiomatic; a natural version of the same computation would be:

 

var temp := 0

for i in lo..hi { temp += f(i) }

return temp

}

 

=={{header|Elixir}}==

{{trans|Erlang}}

def task, do: sum( 1, 100, fn i -> 1 / i end )

end

 

 

{{out}}

<pre>

5.1873775176396215

</pre>

 

No call by name, no macros, so I use a fun(ction). Actually, the the macro part is a lie. Somebody else, that knows how, could do a parse transform.

 

-module( jensens_device ).

 

Temp = Term( I ),

Temp + sum( I + 1, High, Term ).

 

{{out}}

4> jensens_device:task().

5.1873775176396215

</pre>

 

=={{header|F_Sharp|F#}}==

printfn "%.14f" (List.fold(fun n g->n+1.0/g) 0.0 [1.0..100.0]);;

{{out}}

<pre>

5.18737751763962

</pre>

=={{header|Factor}}==

Similar to the Java and Kotlin examples:

 

 

This version is a bit closer to the original, as it increments <code>i</code> in the caller's namespace.

 

: sum ( i lo hi term -- x )

inline

 

{{out}}

<pre>

This version passes i on the stack:

 

Output: 5.18737751763962

 

The following version passes i and 1/i as execution tokens and is thus closer to the original, but less idiomatic:

 

loop 2drop ;

 

=={{header|Fortran}}==

SUM = 0

DO I = LO,HI

END FUNCTION SUM

WRITE (6,*) SUM(I,1,100,1.0/I)

Here, type declarations have been omitted to save space because they won't help - until there appears a "BY NAME" or some such phrasing. Although variable <code>I</code> in the calling routine will have its value adjusted as the DO-loop in SUM proceeds (the parameter being passed by reference), this won't affect the evaluation of 1.0/I, which will be performed once using whatever value is in the caller's variable (it is uninitialised, indeed, undeclared also and so by default an integer) then the function is invoked with the address of the location containing that result. The function will make many references to that result, obtaining the same value each time. The fact that the caller's <code>I</code> will be changed each time doesn't matter.

 

INTEGER I !Being by reference is workable.

INTEGER LO,HI !Just as any other parameters.

 

WRITE (6,*) SUMJ(I,1,100,THIS) !No statement as to the parameters of THIS.

The result of this is 5.187378, however it does not follow the formalism of Jensen's Device. The invocation statement SUMJ(I,1,100,THIS) does not contain the form of the function but only its name, and the function itself is defined separately. This means that the convenience of different functions via the likes of SUM(I,1,100,1.0/I**2) is unavailable, a separately-defined function with its own name must be defined for each such function. Further, the SUM routine must invoke TERM(I) itself, explicitly supplying the appropriate parameter. And the fact that variable <code>I</code> is a parameter to SUM is an irrelevance, and might as well be omitted from SUMJ.

 

 

=={{header|Go}}==

 

import "fmt"

func main() {

fmt.Printf("%f\n", sum(&i, 1, 100, func() float64 { return 1.0 / float64(i) }))

 

{{out}}

{{trans|JavaScript}}

Solution:

(lo..hi).sum { i.value = it; term() }

}

def obj = [:]

 

Output:

 

=={{header|Haskell}}==

import Data.STRef

 

 

foo :: Double

foo =

runST $

 

main :: IO ()

{{Out}}

<pre>5.187377517639621</pre>

 

=={{header|Huginn}}==

temp = 0.0;

i *= 0.0;

i = 0.0;

print( "{}\n".format( harmonic_sum( i, 1.0, 100.0, @[i](){ 1.0 / i; } ) ) );

{{Output}}<pre>5.18737751764</pre>

 

Traditional call by name and reference are not features of Icon/Unicon. Procedures parameters are passed by value (immutable types) and reference (mutable types). However, a similar effect may be accomplished by means of co-expressions. The example below was selected for cleanliness of calling.

 

 

procedure main()

temp +:= @^term

return temp

 

Refreshing the co-expression above is more expensive to process but to avoid it requires unary alternation in the call.

...

 

Alternately, we can use a programmer defined control operator (PDCO) approach that passes every argument as a co-expression. Again the refresh co-expression/unary iteration trade-off can be made. The call is cleaner looking but the procedure code is less clear. Additionally all the parameters are passed as individual co-expressions.

...

procedure sum(X)

...

every @X[1] := @X[2] to @X[3] do

 

=={{header|J}}==

'''Solution:'''

'name lo hi expression'=. y

temp=. 0

temp=. temp + ".expression

end.

'''Example:'''

 

Note, however, that in J it is reasonably likely that the expression (or an obvious variation on the expression) can deal with the looping itself. And in typical use this often simplifies to entering the expression and data directly on the command line.

This is Java 8.

 

import java.util.stream.*;

 

}

}

The program prints '5.187377517639621'.

 

Java 7 is more verbose, but under the hood does essentially the same thing:

 

 

interface IntToDoubleFunction {

}

}

 

=={{header|JavaScript}}==

Uses an object ''o'' instead of integer pointer ''i'', as the C example does.

 

 

function sum(o, lo, hi, term) {

 

obj = {val: 0};

The alert shows us '5.187377517639621'.

 

=={{header|Joy}}==

Joy does not have named parameters.

Neither i nor 1/i are visible in the program.

=={{header|jq}}==

The technique used in the Javascript example can also be used in jq, but in jq it is more idiomatic to use "." to refer to the current term. For example, using sum/3 defined below, we can write: sum(1; 100; 1/.) to perform the task.

reduce range(lo; hi+1) as $i (0; . + ($i|term));

 

# The task:

{{Out}}

$ jq -n -f jensen.jq

{{trans|C}}

 

return quote

lo = $loname

 

i = 0

 

=={{header|Kotlin}}==

 

 

=={{header|Lua}}==

 

function sum(var, a, b, str)

local ret = 0

end

print(sum("i", 1, 100, "1/i"))

 

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

The definition of the lazy function has two statements. First statement is a Module with one argument, the actual name of Jensen`s_Device, which make the function to get the same scope as module Jensen`s_Device, and the second statement is =1/i which return the expression.

 

Module Jensen`s_Device {

Def double i

}

Jensen`s_Device

 

Using Decimal for better accuracy. change &i to &any to show that: when any change, change i, so f() use this i.

Module Jensen`s_Device {

Def decimal i

}

Jensen`s_Device

 

Many other examples use single float. So this is one for single.

Module Jensen`s_Device {

Def single i

}

Jensen`s_Device

 

=={{header|M4}}==

`ifelse($#,0,``$0'',

`ifelse(eval($2<=$3),1,

`pushdef(`temp',0)`'for(`$1',$2,$3,

`define(`temp',eval(temp+$4))')`'temp`'popdef(`temp')')

 

Output:

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

 

Do[temp = temp + term, {i, lo, hi}];

temp];

 

Output:

 

=={{header|Maxima}}==

 

mysum(1/n, n, 1, 10);

/* still works */

mysum(1/n, n, 1, 10);

 

=={{header|NetRexx}}==

import COM.ibm.netrexx.process.

 

return Rexx termMethod.invoke(null,[iv])

 

=={{header|Nim}}==

 

i = lo

while i <= hi:

inc i

 

 

=={{header|Objeck}}==

bundle Default {

class Jensens {

}

}

 

Output: 5.18738

 

=={{header|OCaml}}==

 

let sum' i lo hi term =

 

let () =

Output: 5.187378

 

=={{header|Oforth}}==

 

 

{{out}}

=={{header|Oz}}==

Translation using mutable references and an anonymous function:

fun {Sum I Lo Hi Term}

Temp = {NewCell 0.0}

I = {NewCell unit}

in

 

Idiomatic code:

fun {Sum Lo Hi F}

{FoldL {Map {List.number Lo Hi 1} F} Number.'+' 0.0}

end

in

 

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

 

=={{header|Pascal}}==

type

end;

 

result := 0;

i := lo;

inc(i);

 

var

Out

<pre> 5.1873775176396206E+000</pre>

 

=={{header|Perl}}==

sub sum {

my ($i, $lo, $hi, $term) = @_;

}

 

Output: 5.18737751763962

 

Or you can take advantage of the fact that elements of the @_ are aliases of the original:

sub sum {

my (undef, $lo, $hi, $term) = @_;

}

 

Output: 5.18737751763962

 

I could also have done what C and PHP are doing, though in Phix I'd have to explicitly assign the static var within the loop.<br>

I wholeheartedly agree with the comment on the Clipper example.

{{out}}

<pre>

 

=={{header|PHP}}==

function sum (&$i, $lo, $hi, $term) {

$temp = 0;

 

//Output: 5.1873775176396

 

=={{header|PicoLisp}}==

 

(de jensen (I Lo Hi Term)

(format

(jensen I 1 100 '(() (*/ 1.0 (val I))))

Output:

<pre>-> "5.187383"</pre>

 

=={{header|Python}}==

def __init__(self, value=None):

self.value = value

# note the correspondence between the mathematical notation and the

# call to sum it's almost as good as sum(1/i for i in range(1,101))

 

or

 

def harmonic_sum(i, lo, hi, term):

return sum(term() for i[0] in range(lo, hi + 1))

i = [0]

print(harmonic_sum(i, 1, 100, lambda: 1.0 / i[0]))

 

or

 

def harmonic_sum(i, lo, hi, term):

return sum(eval(term) for i[0] in range(lo, hi + 1))

i = [0]

print(harmonic_sum(i, 1, 100, "1.0 / i[0]"))

 

Output: 5.18737751764

of a function; however, ignoring conventions we can come disturbingly close to the ALGOL call-by-name semantics.

 

eval(substitute({

.temp <- 0;

##and because of enclos=parent.frame(), the term can involve variables in the caller's scope:

x <- -1

 

=={{header|Racket}}==

be written just as Jørn Jensen did at Regnecentralen.

 

#lang algol60

begin

printnln (sum (i, 1, 100, 1/i))

end

 

But of course you can also use the more boring popular alternative of first class functions:

 

#lang racket/base

(define (sum lo hi f)

(for/sum ([i (in-range lo (add1 hi))]) (f i)))

(sum 1 100 (λ(i) (/ 1.0 i)))

 

=={{header|Raku}}==

 

Rather than playing tricks like Perl&nbsp;5 does, the declarations of the formal parameters are quite straightforward in Raku:

my $temp = 0;

loop ($i = $lo; $i <= $hi; $i++) {

 

my $i;

Note that the C-style "for" loop is pronounced "loop" in Raku, and is the only loop statement that actually requires parens.

 

=={{header|Rascal}}==

temp = 0;

while (lo <= hi){

lo += 1;}

return temp;

 

With as output:

 

 

=={{header|REXX}}==

parse arg d . /*obtain optional argument from the CL.*/

if d=='' | d=="," then d= 100 /*Not specified? Then use the default.*/

/*comment lit var lit var lit var literal var literal */

 

{{out|output|text=&nbsp; when using the default input:}}

<pre>

 

=={{header|Ring}}==

# Project : Jensen's Device

 

next

return temp

Output:

<pre>

5.18737751763962

</pre>

 

=={{header|Ruby}}==

Here, setting the variable and evaluating the term are truly executed in the "outer" context:

sum = 0.0

lo.upto(hi) do |n|

sum

end

 

But here is the Ruby way to do it:

lo.upto(hi).inject(0.0) {|sum, n| sum += yield n}

end

 

Even more concise: (requires ruby >= 2.4)

def sum lo, hi, &term

(lo..hi).sum(&term)

# or using Rational:

p sum(1,100){|i| Rational(1,i)} # => 14466636279520351160221518043104131447711 / 2788815009188499086581352357412492142272

 

=={{header|Scala}}==

class, which is effectively the same as passing by reference.

 

val i = new MyInt

def sum(i: MyInt, lo: Int, hi: Int, term: => Double) = {

temp

}

 

Result:

Scheme procedures do not support call-by-name. Scheme macros, however, do:

 

(define-syntax sum

(syntax-rules ()

(loop (+ var 1)

(+ result . body)))))))

 

<pre>

Seed7 supports call-by-name with function parameters:

 

$ include "seed7_05.s7i";

include "float.s7i";

writeln(sum(i, 1, 100, 1.0/flt(i)) digits 6);

end func;

 

Output:

 

=={{header|Sidef}}==

func sum (i, lo, hi, term) {

for (*i = lo; *i <= hi; (*i)++) {

{{out}}

 

=={{header|Simula}}==

{{trans|algol60}}

{{works with|SIMULA-67}}

begin

integer i;

comment note the correspondence between the mathematical notation and the call to sum;

outreal (sum (i, 1, 100, 1/i), 7, 14)

{{out}}

<pre>

 

=={{header|Standard ML}}==

 

fun sum' (i, lo, hi, term) = let

 

val () =

Output: 5.18737751764

 

=={{header|Swift}}==

 

func sum(inout i: Int, lo: Int, hi: Int, @autoclosure term: () -> Double) -> Double {

}

 

(Prior to Swift 1.2, replace <code>@autoclosure term: () -> Double</code> with <code>term: @autoclosure () -> Double</code>.)

{{out}}

=={{header|Tcl}}==

Here, we set the value of the passed variable in the caller's frame. We then evaluate the passed term there too.

upvar 1 $var x

set sum 0.0

return $sum

}

However, the solution is expressed more simply like this

set sum 0.0

for {set n $lo} {$n < $hi} {incr n} {

return $sum

}

 

=={{header|VBA}}==

Private Function sum(i As String, ByVal lo As Integer, ByVal hi As Integer, term As String) As Double

Dim temp As Double

Debug.Print sum("j", 1, 100, "sin(j)")

End Sub

{{out}}

<pre>

=={{header|Wren}}==

As Wren doesn't support call by name, call by reference nor pointers we need to 'box' the global numeric variable 'i' and use a function for 'term' to simulate Jensen's device. This works because all user defined types are reference types and functions can capture external variables.

construct new(v) { _v = v }

v { _v }

 

var s = sum.call(i, 1, 100, Fn.new { 1/i.v })

 

{{out}}

=={{header|zkl}}==

zkl doesn't support call by name/address but does have reference objects. Using an explicit call to term:

temp:=0.0; ri.set(lo);

do{ temp+=term(ri); } while(ri.inc()<hi); // inc return previous value

return(temp);

}

Using function application/deferred(lazy) objects, we can make the function call implicit (addition forces evaluation of the LHS):

temp:=0.0; ri.set(lo);

do{ temp=term + temp; } while(ri.inc()<hi); // inc return previous value

}

ri:=Ref(0);

In this case, we can call sum or sum2 and it does the same thing (the ri parameter will be ignored).

 

Of course, as others have pointed out, this can be expressed very simply:

{{out}}

<pre>

5.187378

5.187378

</pre>