Probabilistic choice: Difference between revisions

 

=={{header|Ada}}==

with Ada.Text_IO; use Ada.Text_IO;

 

end if;

end loop;

Sample output:

<pre>

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of FORMATted transput}}

 

MODE LREAL = LONG REAL;

FOR i FROM LWB items TO UPB items DO printf(($f(real repr)" "$, prob count OF items[i]/trials)) OD;

printf($l$)

Sample output:

<pre>

Attained prob.: 0.199987 0.166917 0.142531 0.124203 0.111338 0.099702 0.091660 0.063662

</pre>

 

=={{header|AutoHotkey}}==

contributed by Laszlo on the ahk [http://www.autohotkey.com/forum/post-276279.html#276279 forum]

s2 := "beth", p2 := 1/6.0

s3 := "gimel", p3 := 1/7.0

heth 0.063456 0.063342

---------------------------

 

=={{header|AWK}}==

 

 

BEGIN {

counts[sym] = 0;

}

 

Example output:

 

Rounding off makes the results look perfect.

 

=={{header|BBC BASIC}}==

item$() = "aleph","beth","gimel","daleth","he","waw","zayin","heth"

prob() = 1/5.0, 1/6.0, 1/7.0, 1/8.0, 1/9.0, 1/10.0, 1/11.0, 1759/27720

FOR i% = 0 TO DIM(item$(),1)

PRINT item$(i%), cnt%(i%)/1E6, prob(i%)

'''Output:'''

<pre>

 

=={{header|C}}==

#include <stdlib.h>

 

 

return 0;

aleph 199928 19.9928% 20.0000%

beth 166489 16.6489% 16.6667%

waw 99935 9.9935% 10.0000%

zayin 91001 9.1001% 9.0909%

 

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

{{trans|Java}}

 

using System;

 

}

}

 

Output:

Target prob.: 0.200000 0.166667 0.142857 0.125000 0.111111 0.100000 0.090909 0.063456

Attained prob.: 0.199975 0.166460 0.142290 0.125510 0.111374 0.100018 0.090746 0.063627</pre>

 

=={{header|Clojure}}==

It uses the language built-in (frequencies) to count the number of occurrences of each distinct name. Note that while we actually generate a sequence of num-trials random samples, the sequence is lazily generated and lazily consumed. This means that the program will scale to an arbitrarily-large num-trials with no ill effects, by throwing away elements it's already processed.

 

(reduce

(fn [acc n] (conj acc (+ (or (last acc) 0) n)))

(doseq [[idx exp] expected]

(println "Expected number of" (*names* idx) "was"

 

<pre>Expected number of aleph was 200000.0 and actually got 199300

 

This is a straightforward, if a little verbose implementation based upon the Perl one.

(beth 1/6)

(gimel 1/7)

WAW 0.100068 0.1

ZAYIN 0.090458 0.09090909

 

=={{header|D}}==

===Basic Version===

import std.stdio, std.random, std.string, std.range;

 

foreach (name, p, co; zip(items, pr, counts[]))

writefln("%-7s %.8f %.8f", name, p, co / nTrials);

{{out}}

<pre>Item Target prob Attained prob

 

===A Faster Version===

import std.stdio, std.random, std.algorithm, std.range;

 

foreach (name, p, co; zip(items, pr, counts[]))

writefln("%-7s %.8f %.8f", name, p, co / nTrials);

 

=={{header|E}}==

It is rather verbose, due to using the tree rather than a linear search, and having code to print the tree (which was used to debug it).

 

 

First, the algorithm:

 

def leaf(value) {

return def leaf {

makeIntervalTree(assocs.run(midpoint)))

} else {

return leaf(value)

}

}

}

 

Then the test setup:

 

"aleph" => 1/5,

"beth" => 1/6.0,

for item in probTable.domain() {

stdout.print(item, "\t", timesFound[item] / trials, "\t", probTable[item], "\n")

 

=={{header|Elixir}}==

{{trans|Erlang}}

@tries 1000000

@probs [aleph: 1/5,

end

 

 

{{out}}

The optimized version of Java.

 

-module(probabilistic_choice).

 

get_choice(T,Ran - Prob)

end.

 

Output:

 

=={{header|ERRE}}==

 

DIM ITEM$[7],PROB[7],CNT[7]

END FOR

END IF

 

Output:

=={{header|Euphoria}}==

{{trans|PureBasic}}

constant times = 1e6

atom d,e

printf(1,"%-7s should be %f is %f | Deviatation %6.3f%%\n",

{Mapps[j][1],Mapps[j][2],d,(1-Mapps[j][2]/d)*100})

 

Output:

 

=={{header|Factor}}==

math.statistics prettyprint quotations sequences sorting formatting ;

IN: rosettacode.proba

: example ( # data -- )

[ case-probas generate-normalized ]

 

In a REPL:

outputs

heth: 0.063469 0.063456

waw: 0.100226 0.100000

he: 0.110562 0.111111

aleph: 0.199868 0.200000

 

=={{header|Forth}}==

 

\ common factors of desired probabilities (1/5 .. 1/11)

f- fabs fs. ;

 

 

<pre>

=={{header|Fortran}}==

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

IMPLICIT NONE

WRITE(*, "(A,8F10.6)") "Attained Probability:", REAL(probcount) / REAL(trials)

Sample Output:

<pre>

 

=={{header|FreeBASIC}}==

 

Dim letters (0 To 7) As String = {"aleph", "beth", "gimel", "daleth", "he", "waw", "zayin", "heth"}

Print

Print "Press any key to quit"

 

{{out}}

he 0.110772 0.111111

waw 0.100236 0.100000

heth 0.063412 0.063456

-------- --------

1.000000 1.000000

</pre>

 

=={{header|Go}}==

 

import (

}

fmt.Printf("Totals %8.6f %8.6f\n", totalTarget, totalGenerated)

Output:

<pre>

 

=={{header|Haskell}}==

dataBinCounts :: [Float] -> [Float] -> [Int]

dataBinCounts thresholds range =

main :: IO ()

main = do

g <- newStdGen

let fractions = recip <$> [5 .. 11] :: [Float]

actual =

putStrLn " expected actual"

mapM_ putStrLn $

zipWith3

expected

{{Out}}

Sample

 

=={{header|HicEst}}==

 

expected = 1 / ($ + 4)

outcome = outcome / trials

 

Exported from the spreadsheet-like DLG function:

<pre>0.2 0.199908

=={{header|Icon}} and {{header|Unicon}}==

 

record Item(value, probability)

 

left(count(sample, item.value)/*sample, 6))

end

 

Output:

 

=={{header|J}}==

main=: verb define

hdr=. ' target actual '

da (distribution of actual values among partitions)

pa (actual proportions)

Example use:

target actual

aleph 0.200000 0.200344

waw 0.100000 0.099751

zayin 0.090909 0.091121

Note that there is no rounding error in summing the proportions, as they are represented as rational numbers, not floating-point approximations.

pt

1r5 1r6 1r7 1r8 1r9 1r10 1r11 1759r27720

+/pt

 

=={{header|Java}}==

{{trans|C}}

static long TRIALS= 1000000;

 

 

}

Output:

<pre>Trials: 1000000

Attained prob.: 0.199615 0.167517 0.142612 0.125211 0.110970 0.099614 0.091002 0.063459 </pre>

{{works with|Java|1.5+}}

 

public class Prob {

return null;

}

Output:

<pre>Target probabliities: {ALEPH=0.2, BETH=0.16666666666666666, GIMEL=0.14285714285714285, DALETH=0.125, HE=0.1111111111111111, WAW=0.1, ZAYIN=0.09090909090909091, HETH=0.06345598845598846}

===ES5===

Fortunately, iterating over properties added to an object maintains the insertion order.

aleph: 1/5.0,

beth: 1/6.0,

for (var name in probabilities)

// using WSH

output:

<pre>aleph 0.2 0.200597

By functional composition:

{{Trans|Haskell}}

'use strict';

 

.map(unwords)

.join('\n');

{{Out}}

Sample:

Zayin 0.0909091 0.0909630

Chet 0.0634560 0.0632870 </pre>

 

=={{header|Julia}}==

I made the solution to this task more difficult than I had anticipated by using the Hebrew characters (rather than their anglicised names) as labels for the sampled collection of objects. In doing so, I encountered an interesting subtlety of bidirectional text in Unicode. Namely, that strong right-to-left characters, such as those of Hebrew, override the directionality of European digits, which have weak directionality. Because of this property of Unicode, my table of items and yields had its lines of data interpreted as if it were entirely Hebrew and output in reverse order (from my English speaking perspective). I was able to get the table to display as I liked on my terminal by preceding the the Hebrew characters by the Unicode RLI (right-to-left isolate) control character (<tt>U+2067</tt>). However, when I pasted this output into this Rosetta Code entry, the display reverted to the "backwards" version. Rather than continue the struggle, trying to force this entry to display as it does on my terminal, I created an alternative version of the table. This "Displayable Here" table adds "yields" to to each line, and this strong left-to-right text makes the whole line display as left-to-right (without the need for a RLI characer).

p = [1/i for i in 5:11]

plen = length(p)

plab[i], accum[i], p[i], r[i]))

end

 

{{out}}

=={{header|Kotlin}}==

{{trans|FreeBASIC}}

 

fun main(args: Array<String>) {

println("\t-------- --------")

println("\t${"%8.6f".format(sumActual)} 1.000000")

 

{{out}}

 

=={{header|Liberty BASIC}}==

names$="aleph beth gimel daleth he waw zayin heth"

dim sum(8)

print word$(names$, i), using( "#.#####", counter(i) /N), using( "#.#####", 1/(i+4))

next

 

=={{header|Lua}}==

items["aleph"] = 1/5.0

items["beth"] = 1/6.0

for item, _ in pairs( items ) do

print( item, samples[item]/num_trials, items[item] )

Output

<pre>gimel 0.142606 0.14285714285714

waw 0.100062 0.1</pre>

 

Built-in function can already do a weighted random choosing. Example for making a million random choices would be:

To compare the data we use the following code to make a table:

gives back (item, attained prob., target prob.):

<pre>aleph 0.200036 0.2

=={{header|MATLAB}}==

{{works with|MATLAB|with Statistics Toolbox}}

choices = {'aleph' 'beth' 'gimel' 'daleth' 'he' 'waw' 'zayin' 'heth'};

w = [1/5 1/6 1/7 1/8 1/9 1/10 1/11 1759/27720];

choices{k}, T(k, 2), T(k, 3), 100*w(k))

end

{{out}}

<pre>Value Count Percent Goal

heth 63171 6.32% 6.35%</pre>

{{works with|MATLAB|without toolboxes}}

choices = {'aleph' 'beth' 'gimel' 'daleth' 'he' 'waw' 'zayin' 'heth'};

w = [1/5 1/6 1/7 1/8 1/9 1/10 1/11 1759/27720];

choices{k}, results(k), 100*results(k)/nSamp, 100*w(k))

end

{{out}}

<pre>Value Count Percent Goal

 

=={{header|Nim}}==

 

var start = cpuTime()

 

 

randomize()

 

 

{{out}}

 

 

=={{header|OCaml}}==

 

"Aleph", 1.0 /. 5.0;

"Beth", 1.0 /. 6.0;

let d = Hashtbl.find h v in

Printf.printf "%s \t %f %f\n" v p (float d /. float n)

 

Output:

 

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

my(v=[5544,10164,14124,17589,20669,23441,25961,27720],u=vector(8),e);

for(i=1,1e6,

print("Diff: ",u-e);

print("StDev: ",vector(8,i,sqrt(abs(u[i]-v[i])/e[i])));

 

=={{header|Perl}}==

use constant TRIALS => 1e6;

 

$_, $results{$_}/TRIALS, $ps{$_},

abs($results{$_}/TRIALS - $ps{$_});

 

Sample output:

zayin 0.091014 0.090909 0.000105

heth 0.063731 0.063456 0.000275</pre>

 

=={{header|Phix}}==

{{out}}

<pre>

heth 0.063442 0.063456

</pre>

 

=={{header|PicoLisp}}==

(let Probs

(mapcar

(cdddr X)

(format (cadr X) 6)

Output:

<pre> Probability Result

 

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

Dcl prob(8) Dec Float(15) Init((1/5.0), /* aleph */

(1/6.0), /* beth */

Put Edit(what(i),cnt(i),pr,prob(i))(Skip,a,f(10),x(2),2(f(11,8)));

End;

{{out}}

<pre>One million trials

{{trans|Java Script}}

The guts of this script are translated from the Java Script entry. Then I stole the idea to show the actual Hebrew character from Julia.

$character = [PSCustomObject]@{

aleph = [PSCustomObject]@{Expected=1/5 ; Alpha="א"}

}

}

{{Out}}

<pre>

 

=={{header|PureBasic}}==

 

Structure Item

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

CloseConsole()

 

Output may look like

=={{header|Python}}==

Two different algorithms are coded.

 

def probchoice(items, probs):

probs[-1] = 1-sum(probs[:-1])

tester(probchoice, items, probs, 1000000)

 

Sample output:

Target probability: 0.200000,0.166667,0.142857,0.125000,0.111111,0.100000,0.090909,0.063456

Attained probability: 0.199720,0.166424,0.142474,0.124561,0.111511,0.100313,0.091316,0.063681</pre>

 

=={{header|R}}==

# Note that R doesn't actually require the weights

# vector for rmultinom to sum to 1.

Requested = prob,

Obtained = hebrew/sum(hebrew))

 

Sample output:

 

A histogram of the data is also possible using, for example,

 

=={{header|Racket}}==

as a module. Either run the program in DrRacket or run `raco test prob-choice.rkt`

 

;;; returns a probabalistic choice from the sequence choices

;;; choices generates two values -- the chosen value and a

(test-p-c-function probabalistic-choice/exact test-weightings/50:50)

(test-p-c-function probabalistic-choice test-weightings/rosetta)

Output (note that the progress counts, which go to standard error, are

interleaved with the output on standard out)

zayin 90478 1000000/11 45239/500000 -0.47%

he 111275 1000000/9 4451/40000 0.15%</pre>

 

=={{header|REXX}}==

parse arg trials digs seed . /*obtain the optional arguments from CL*/

if datatype(seed, 'W') then call random ,,seed /*allows repeatability for RANDOM nums.*/

numeric digits digs /*use a specific number of decimal digs*/

names= 'aleph beth gimel daleth he waw zayin heth ───totals───►' /*names of the cells.*/

end /*n*/

say center('name',15,_) center('count',d,_) center('target %',w,_) center('actual %',w,_)

 

do cell=1 for z /*display each of the cells and totals.*/

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

<pre>

 

=={{header|Ring}}==

# Project : Probabilistic choice

 

see "" + item[i] + " " + cnt[i]/1000000 + " " + prob[i] + nl

next

Output:

<pre>

 

=={{header|Ruby}}==

"aleph" => 1/5.0,

"beth" => 1/6.0,

val = probabilities[k]

printf "%-8s%.8f %.8f %6.3f %%\n", k, val, act, 100*(act-val)/val

 

{{out}}

 

=={{header|Rust}}==

 

use rand::distributions::{IndependentSample, Sample, Weighted, WeightedChoice};

let counts = take_samples(&mut rng, &wc);

print_mapping(&counts);

{{out}}

<pre> ~~~ U32 METHOD ~~~

=={{header|Scala}}==

This algorithm consists of a concise two-line tail-recursive loop (<tt>def weighted</tt>). The rest of the code is for API robustness, testing and display. <tt>weightedProb</tt> is for the task as stated (0 < <i>p</i> < 1), and <tt>weightedFreq</tt> is the equivalent based on integer frequencies (<i>f</i> >= 0).

import scala.collection.mutable.LinkedHashMap

 

println("Checking weighted frequencies:")

check(frequencies.map{case (a, b) => a -> b.toDouble}, for (i <- 1 to 1000000) yield weightedFreq(frequencies))

{{out}}

<pre>Checking weighted probabilities:

'heth 0.0630 0.0632 ok

1.0000 1.0000</pre>

 

=={{header|Scheme}}==

Using guile scheme 2.0.11.

 

 

(define (random-choice probs)

(he 1/9) (waw 1/10) (zayin 1/11) (heth 1759/27720)))

 

 

Example output:

zayin 0.09091 0.09096

heth 0.06346 0.06313

 

=={{header|Sidef}}==

{{trans|Perl}}

 

func prob_choice_picker(options) {

abs(v/TRIALS - ps{k})

);

 

{{out}}

heth 0.068800 0.063456 0.005344

</pre>

 

=={{header|Stata}}==

mata

letters="aleph","beth","gimel","daleth","he","waw","zayin","heth"

st_addvar("str10","a")

st_sstore(.,.,a)

 

=={{header|Tcl}}==

 

set map [dict create]

]

}

<pre>using 1000000 samples:

expected actual difference

implemented by the run time system.

 

#import nat

#import flo

#show+

 

output:

<pre>

=={{header|VBScript}}==

Derived from the BBC BASIC version

item = Array("aleph","beth","gimel","daleth","he","waw","zayin","heth")

prob = Array(1/5.0, 1/6.0, 1/7.0, 1/8.0, 1/9.0, 1/10.0, 1/11.0, 1759/27720)

WScript.StdOut.Write item(i) & vbTab & FormatNumber(cnt(i)/1000000,6) & vbTab & FormatNumber(prob(i),6)

WScript.StdOut.WriteLine

 

{{out}}

zayin 0.090745 0.090909

heth 0.063705 0.063456

</pre>

 

=={{header|XPL0}}==

def Size = 10_000_000;

int Tbl(12+1);

");

RlOut(0, S0); RlOut(0, S1);

 

Output:

1.00000 1.00000

</pre>

 

=={{header|zkl}}==

{{trans|C}}

"he", "waw", "zayin", "heth");

var ptable=T(5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0).apply('/.fp(1.0));

"%6s%7d %7.4f%% %7.4f%%".fmt(names[i], r[i], r[i]/M*100,

ptable[i]*100).println();

{{out}}

<pre>