Executable library: Difference between revisions

{{task}}

{{omit from|GUISS}}

{{omit from|MATLAB}}

{{omit from|Maxima}}

To overcome the first obstacle, we implement a very simplistic parameter passing mechanism in a package Parameter (''parameter.ads''): The global variable Parameter.X will hold the ingoing parameter, the other global variable Parameter.Y will take the return value. To overcome the second obstacle, we ensure that Parameter.X is 0 by default.

 

X: Natural := 0;

Y: Natural;

 

Now comes our parameterless procedure Hailstone (''hailstone.adb''). Note that we are

[[Hailstone sequence#Alternative method]] to perform the real computation.

 

 

procedure Hailstone is

end;

end if;

 

If we compile this and run it, we get the following output:

that essentially repeats the parameter profile. As our procedure is actually parameterless, this specification is more than trivial.

 

 

Finally, we write another parameterless procedure (''hailstone_test.adb''), that will call the procedure Hailstone. Note that we '''must''' change the Parameter.X to a value > 0 before calling Hailstone, otherwise, Hailstone would act as if it where the main program.

 

 

procedure Hailstone_Test is

Ada.Text_IO.Put_Line("The first such sequence: Hailstone("

& Integer'Image(Sample) & " ).");

 

Compiling and running this gives the following output:

{{works with|AutoHotkey_L}}

First we create the library, hailstone.ahk:

SetBatchLines, -1

 

until n=1

return out

Running this directly gives the output:

<pre>Length of hailstone 27: 112

 

Then we can create a file (test.ahk) that uses the library (note the #Include line):

#Include %A_ScriptDir%\hailstone.ahk

SetBatchLines -1

if (count > highestCount)

highestCount := count, highestN := length

Running this '''does not''' trigger the output of the hailstone.ahk,

instead it outputs this:

This must be saved as the file HAILSTONE.BBC.

It may be used as a library (see below) or executed directly.

PRINT "Sequence length for 27 is "; seqlen%

maxlen% = 0

L% += 1

ENDWHILE

{{out}}

<pre>

===Client===

This uses the above program as a library:

DIM freq%(351)

PRINT "The most common sequence length is " ; mostcommon%

PRINT "It occurs " ; max% " times"

{{out}}

<pre>

=={{header|C}}==

Solution for Linux/GCC. First, header file hailstone.h:

#define HAILSTONE

void free_sequence(long *);

 

Then the lib source code hailstone.c (actual name doesn't matter):

#include <stdlib.h>

 

 

exit(0);

A program to use the lib (I call it test.c):

#include "hailstone.h"

 

 

return 0;

 

Building the lib: <code>gcc -Wall -W -fPIC -shared -o libhail.so hailstone.c -lc -Wl,-e,hail_main</code>

</pre>

The file <code>hailstone_sequence.clj</code> is an executable library:

 

(defn next-in-hailstone

(range 100000)))]

(printf "The number %s has the longest Hailstone sequence under 100000, of length %s.\n"

You can run it from the command line (<code>clojure.jar</code> is [https://clojure.org/community/downloads the jar that contains the Clojure language]):

<pre>$ java -cp clojure.jar clojure.main -m rosetta-code.hailstone-sequence

</pre>

You can also use its functions from other programs. The file <code>frequent_hailstone_lengths.clj</code>:

(:require [rosetta-code.hailstone-sequence

:refer [hailstone-seq]]))

(printf (str "The most frequent Hailstone sequence length for numbers under 100000 is %s,"

" with a frequency of %s.\n")

You can run it from the command line:

<pre>$ java -cp clojure.jar clojure.main -m rosetta-code.frequent-hailstone-lengths

 

The library, named <code>hailstone.deja</code>:

swap [ over ]

while < 1 dup:

!print( "number: " to-str max ", length: " to-str maxlen )

else:

 

The client:

 

local :counts {}

set :maxlen counts! k

!print( "Maximum length: " to-str maxlen )

 

=={{header|Factor}}==

This vocabulary, ''rosetta.hailstone'', exports the word ''hailstone'', but also uses ''MAIN:'' to declare a main entry point.

 

USING: arrays io kernel math math.ranges prettyprint sequences vectors ;

IN: rosetta.hailstone

PRIVATE>

 

 

There are two ways to run this program:

Any other Factor program can also use ''rosetta.hailstone'' as a regular vocabulary. This program only uses the word ''hailstone'' from that vocabulary, and never calls the main entry point of ''rosetta.hailstone''.

 

USING: assocs kernel io math math.ranges prettyprint

rosetta.hailstone sequences ;

PRIVATE>

 

 

<pre>$ ./factor -run=rosetta.hailstone.length

To complete the task, first create these two files in the 'modulino' directory:

 

package main

 

}

fmt.Printf("\n%d has the longest Hailstone sequence, its length being %d.\n", longest, length)

 

package main

 

func main() {

libMain()

 

To emulate an executable library:

Now create this file in the 'hailstone' directory:

 

package main

 

}

fmt.Printf("\nThe Hailstone length returned most is %d, which occurs %d times.\n", mk, mv)

 

and copy modulino.go to the 'hailstone' directory. The library can then be used in the 'normal' way:

 

'''HailStone.io'''

HailStone sequence := method(n,

if(n < 1, Exception raise("hailstone: expect n >= 1 not #{n}" interpolate))

writeln("For numbers < 100,000, ", maxN,

" has the longest sequence of ", maxSize, " elements.")

'''client.io'''

for(n, 1, 100000-1,

out := HailStone sequence(n)

writeln("The most frequent sequence lengths for n < 100,000 are:\n",

lengths join(",")," occurring ",maxCount," times each.")

'''Terminal Session'''

<pre>$ io HailStone.io

This is the executable library:

 

9!:29]1

9!:27'main 0'

smoutput 'less than 100000 (and finding that sequence length):'

smoutput (I.@(= >./),>./) #@hailseq i.1e5

 

Running it might look like this:

 

Hailstone sequence for the number 27

27 82 41 124 62 31 94 47 142 71 214 107 322 161 484 242 121 364 182 91 274 137 412 206 103 310 155 466 233 700 350 175 526 263 790 395 1186 593 1780 890 445 1336 668 334 167 502 251 754 377 1132 566 283 850 425 1276 638 319 958 479 1438 719 2158 1079 3238 ...

Finding number with longest hailstone sequence which is

less than 100000 (and finding that sequence length):

 

This is the program which uses the library part of that executable library:

 

9!:29]1

9!:27'main 0'

smoutput {:{.\:~ (#/.~,.~.) #@hailseq }.i.1e5

)

 

Running it might look like this:

Finding most frequent hailstone sequence length for

Hailstone sequences for whole numbers less than 100000

 

Notes: <code>9!:29]1</code> tells the interpeter to run a phrase. <code>9!:27'phrase'</code> tells the interpeter the phrase to execute. (<code>9!:</code> means, in essence: standard library number 9, and <code>9!:29</code> identifies a specific entry point in that library.)

 

===Library===

import java.util.ArrayList;

import java.util.List;

}

{{out}}

<pre>

 

===Client===

import java.util.HashMap;

import java.util.Map;

 

}

{{out}}

<pre>

=={{header|Julia}}==

A Julia module can check to see if it is also the file run from the command lime by checking the PROGRAM_NAME variable.

############### in file hailstone.jl ###############

module Hailstone

 

print("The most common hailstone sequence length for hailstone(n) for 1 <= n < 100000 is $nlen, which occurs $cnt times.")

{{output}}<pre>

Running hailstone.jl standalone:

First, <code>execlib.b</code> looks like this:

 

 

include "sys.m"; sys: Sys;

return i :: hailstone(big 3 * i + big 1);

}

 

And <code>execsexeclib.b</code> (which executes <code>execlib</code>) looks like this:

 

 

include "sys.m"; sys: Sys;

raise "fail:errors";

}

 

{{out}}

=={{header|Lua}}==

The library is called hailstone.lua:

bit32=bit32 or bit

local lib={

return lib

end

 

The executable is called hailtest.lua:

 

local lib=require"hailstone"

local longest,longest_i=0,0

end

print("Longest sequence at "..longest_i..", length "..longest)

 

{{out}}

</pre>

 

===Library===

hailstone[n_] :=

hailstone[n] = Prepend[hailstone[If[EvenQ[n], n/2, 3 n + 1]], n];

val = MaximalBy[Range[99999], Length@*hailstone][[1]];

Print[val, " has the longest hailstone sequence with length ",

{{out}}

<pre>hailstone(27) starts with {27, 82, 41, 124}, ends with {8, 4, 2, 1}, and has length 112.

===Client===

This assumes that the library is named <tt>hailstone.m</tt>.

Print["The most common hailstone length is ",

{{out}}

<pre>The most common hailstone length is 72.</pre>

=={{header|Nanoquery}}==

The global boolean value 'main' is true is the program is being executed directly and false if it is being imported as a library.

seq = list()

print "\nThe number less than 100,000 with the longest sequence is "

println maxLoc + " with a length of " + max

 

=={{header|NetRexx}}==

Using this JAR file as a library, the following program can use the <tt>hailstone(N)</tt> method to complete the task:

 

options replace format comments java crossref symbols nobinary

 

say 'The length of hailstone sequence that is most common in the range' beginNum '<= N <' endNum 'is' mostOftenNum'. It occurs' mostOftenCount 'times.'

return

 

The program can then be launched with the <tt>java</tt> command. In this sample the JAR file is included via the <tt>-cp</tt> switch:

 

=={{header|Nim}}==

result = @[n]

var n = n

m = n

mi = i

 

In Nim the value <code>isMainModule</code> is set at compiletime, and we can use it with <code>when</code> (a compiletime if).

 

'''Library Importing Example'''

 

var t = initCountTable[int]()

let (val, cnt) = t.largest()

echo "The length of hailstone sequence that is most common for"

 

{{out}}

 

Library file hailstone.c:

 

#define HAILSTONE1 "n=1;print1(%d,\": \");apply(x->while(x!=1,if(x/2==x\\2,x/=2,x=x*3+1);n++;print1(x,\", \")),%d);print(\"(\",n,\")\n\")"

 

exit(0);

Compile hailstone.c: ''gcc -O2 -Wall hailstone.c -fPIC -shared -o libhailstone.so -lpari -Wl,-e,main''

 

----

Main program linking libhailstone.so... main.c:

 

int main(void)

 

return 0;

Compile main.c: ''gcc -O2 -Wall main.c -o main -L. libhailstone.so''

 

Execute main program: ''LD_LIBRARY_PATH=. ./main'' :

<pre>27: 82, 41, 124, 62, 31, 94, 47, 142, 71, 214, 107, 322, 161, 484, 242, 121, 364, 182, 91, 274, 137, 412, 206, 103, 310, 155, 466, 233, 700, 350, 175, 526, 263, 790, 395, 1186, 593, 1780, 890, 445, 1336, 668, 334, 167, 502, 251, 754, 377, 1132, 566, 283, 850, 425, 1276, 638, 319, 958, 479, 1438, 719, 2158, 1079, 3238, 1619, 4858, 2429, 7288, 3644, 1822, 911, 2734, 1367, 4102, 2051, 6154, 3077, 9232, 4616, 2308, 1154, 577, 1732, 866, 433, 1300, 650, 325, 976, 488, 244, 122, 61, 184, 92, 46, 23, 70, 35, 106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1, (112)</pre>

 

=={{header|Perl}}==

Lib package in file <code>Hailstone.pm</code>:

 

sub seq {

}

 

use strict;

use warnings;

my ($most_frequent) = sort {$seqs{$b} <=> $seqs{$a}} keys %seqs;

Running the lib: <pre>% perl Hailstone.pm

seq of 27 - 112 elements: 27 82 41 124 62 31 94 47 142 ... 10 5 16 8 4 2 1

=={{header|Phix}}==

Simply test whether include_file() returns 1. hail.exw:

function hailstone(atom n)

sequence s = {n}

printf(1,"The longest hailstone sequence under 100,000 is %d with %d elements.\n",{imax,hmax})

{{out}}

<pre>

</pre>

test.exw:

 

sequence counts = {}

counts[l] += 1

end for

{{out}}

<pre>

by prefixing it with '-'.

Create an executable file (chmod +x) "hailstone.l":

 

(de hailstone (N)

(test 351 (length (hailstone N))) )

(println 'OK)

and an executable file (chmod +x) "test.l":

 

(load "hailstone.l")

(prinl "The hailstone length returned most often is " (car M))

(prinl "It is returned " (cdr M) " times") ) )

Test:

<pre>$ ./hailstone.l -hailtest

 

both can be used as an executable.

int next(int n)

}

write("longest sequence starting at %d has %d elements\n", longest->start, longest->length);

 

if run directly we get:

note that the . in .HailStone only signifies calling a class or module from the current directory.

the analyze function is identical in both examples:

{

.HailStone HailStone = .HailStone();

}

write("most common length %d appears %d times\n", max->length, max->count);

 

a module is already instantiated so we can use it directly.

like above the initial . in .Hailstone.hailstone only signifies the current directory, the second . is a member reference resolved at compile time.

{

mapping long = ([]);

}

write("most common length %d appears %d times\n", max->length, max->count);

 

{{out}} for both examples:

 

The entry is copied below and, for this task needs to be in a file called <code>hailstone.py</code>:

seq = [n]

while n>1:

assert len(h)==112 and h[:4]==[27, 82, 41, 124] and h[-4:]==[8, 4, 2, 1]

print("Maximum length %i was found for hailstone(%i) for numbers <100,000" %

 

In the case of the Python language the interpreter maintains a module level variable called __name__. If the file hailstone.py is ''imported'' (as <code>import hailstone</code>), then the __name__ variable is set to the import name of 'hailstone' and the <code>if __name__ == '__main__'</code> expression would then be false, and only the hailstone function is available to the importer.

 

The second executable is the file <code>common_hailstone_length.py</code> with this content:

 

def function_length_frequency(func, hrange):

print("The length of hailstone sequence that is most common for\n"

"hailstone(n) where 1<=n<%i, is %i. It occurs %i times."

 

Both files could be in the same directory. (That is the easiest way to make the library known to its importer for this example)

function is now provided, and the demonstration printout is pushed into a

<tt>main</tt> submodule:

#lang racket

 

(printf "for x<=~s, ~s has the longest sequence with ~s items\n"

N (car longest) (cdr longest)))

 

Running it directly produces the same output as [[Hailstone sequence#Racket]]:

And now this can be used from a second source file, "<tt>hsfreq.rkt</tt>" as a

library:

#lang racket

(require "hs.rkt")

(printf "Most frequent sequence length for x<=~s: ~s, appearing ~s times\n" N

(cdr best) (car best))

 

<pre>

(formerly Perl 6)

The library can be written as a module:

our sub hailstone($n) is export {

$n, { $_ %% 2 ?? $_ div 2 !! $_ * 3 + 1 } ... 1

sub MAIN {

say "hailstone(27) = {.[^4]} [...] {.[*-4 .. *-1]}" given Hailstone::hailstone 27;

 

It can be run with:

{{out}}

<pre>hailstone(27) = 27 82 41 124 [...] 8 4 2 1</pre>

 

It can then be used with a program such as:

my %score;

(1 .. 100_000).race.map: { %score{hailstone($_).elems}++ };

 

Called with a command line as:

<br>The following program (function) is named: &nbsp; '''HAILSTONE.REX''' &nbsp; (the case doesn't matter for Microsoft Windows systems).

<br>All REXX interpreters support subroutines/functions being on the current drive ('''CD'''), default disk (or MDISK in the case of CMS), or the equivalent.

numeric digits 20 /*ensure enough digits for mult. */

parse arg n 1 s /*N & S assigned to the first arg*/

s=s n /*build a sequence list (append).*/

end /*while*/

 

===task 2, 3===

The following program is named: &nbsp;: '''HAIL_PGM.REX''' &nbsp; and is stored in the current directory.

parse arg x .; if x=='' then x=27 /*get the optional first argument*/

 

 

say '(between 1──►99,999) ' bigJ 'has the longest hailstone sequence:' w

{{out}}

<pre>

===task 4===

The following program is named: &nbsp; '''HAIL_POP.REX''' &nbsp; and is stored in the current directory.

parse arg z .; if z=='' then z=99999 /*get the optional first argument*/

!.=0

say '(between 1──►'z") " p,

' is the most common hailstone sequence length (with' occ "occurrences)."

{{out}}

<pre>

{{works with|Ruby|1.8.7}}

 

module Hailstone

module_function

puts "#{n} has a hailstone sequence length of #{len}"

puts "the largest number in that sequence is #{hailstone(n).max}"

 

{{out|It runs like any Ruby program}}

This is ''hsfreq.rb'', which requires ''hailstone.rb'' as a library.

 

require 'hailstone'

 

puts "Given the hailstone sequences from 1 to #{last},"

puts "the most common sequence length is #{length},"

 

As with any library, ''hailstone.rb'' must be in <code>$:</code>, the search path for libraries.

In Scala it is possible to combine several "main"s

(mixed-in by the App trait) in one file (e.g. HailstoneSequence.scala):

object HailstoneSequence extends App { // Show it all, default number is 27.

def hailstone(n: Int): LazyList[Int] =

println(s"Longest hailstone sequence length= $len occurring with number $n.")

}

 

Steps:

=={{header|Sidef}}==

Library saved as '''Hailstone.sm'''

gather {

while (n > 1) {

take(n)

}

take(1)

}

}

if (__FILE__ == __MAIN__) { # true when not imported

var seq = hailstone(27)

var n = 0

var max = 0

}

}

say "Longest sequence is for #{n}: #{max}"

 

It can be run with:

 

It can then be used with a program such as:

 

var score = Hash()

 

var k = score.keys.max_by {|k| score{k} }

 

Called with a command line as:

 

The library is searched in the directories specified in the '''SIDEF_INC''' environment variable, which defaults to the current directory.

=={{header|Tcl}}==

The standard idiom for detecting whether a script is being loaded as a library or run directly is to compare the result of <code>info script</code> (which describes the name of the currently sourced script file) and the global <code>argv0</code> variable (which holds the name of the main script).

package provide hailstone 1.0

 

}

puts "max is $max, with length $maxlen"

 

To make the package locatable, run this Tcl script

in the same directory which builds the index file:

 

Using the above code as a library then just requires that we tell the script the location of the additional library directory by adding it to the global <code>auto_path</code> variable; it is unnecessary if the script is installed in one of the standard locations (a fairly long list that depends on the installation):

package require Tcl 8.6 ;# For [lsort -stride] option

lappend auto_path . ;# Or wherever it is located

lassign $sortedHist mostCommonLength freq

 

 

=={{header|Wren}}==

The strategy here is check whether the main module is the same as the library module and to treat is as executable if it is but as a library otherwise.

 

 

var Hailstone = Fn.new { |n|

// Check if it's being used as a library or not.

import "os" for Process

libMain_.call()

 

{{out}}

If we run this directly, we get the expected output:

<pre>

 

For the Hailstone sequence starting with n = 27:

 

If we now create a second module which imports the above and calls its Hailstone function:

 

 

var freq = {}

}

}

 

{{out}}

We can now run this to check that the executable code in hailstone.wren has been suppressed, giving us:

<pre>

 

The Hailstone length returned most is 72, which occurs 1467 times.

 

File hailstone.zkl:

if(n.isEven) return(self.fcn(n/2,z)); return(self.fcn(n*3+1,z)) }

 

fcn(c,n){ // if new longest sequence, save length/C, return longest

if(c.len()>n[0]) n.clear(c.len(),c[0]); n}.fp1(L(0,0)))

File hailstone2.zkl:

collatz:=Import("hailstone",False,False,False).collatz; // don't run constructor

d:=Dictionary();

mostFreqLen:=d.filter1('wrap([(k,v)]){ v==longest })[0];

println("Most frequent length: %d; %d sequences of that length."

{{out}}

<pre>