Modified random distribution: Difference between revisions

{{trans|Python}}

 

R I x < 0.5 {2 * (.5 - x)} E 2 * (x - .5)

 

V delta = I last == N {‘N/A’} E String(count - last)

print(‘ #2.2, #4, #4: ’.format(Float(b) / bins, count, delta)‘’(‘#’ * Int(40 * count / mx)))

 

{{out}}

 

=={{header|Ada}}==

with Ada.Numerics.Float_Random;

with Ada.Strings.Fixed;

New_Line;

end loop;

{{out}}

<pre>Range Observations: 20000 Buckets: 25

=={{header|Factor}}==

{{works with|Factor|0.99 2021-02-05}}

math.functions math.statistics random sequences

tools.memory.private ;

 

"Modified random distribution of values in [0, 1):" print nl

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

#define NBINS 20

 

for b = 0 to NBINS-1

print using "Bin ## (#.## to #.##): & ####";b;b*db;(b+1)*db;histo(bins(b));bins(b)

{{out}}

<pre>

=={{header|Go}}==

{{trans|Wren}}

 

import (

fmt.Printf("%4.2f ..< %4.2f %s %s\n", binSize*fi, binSize*(fi+1), hist, commatize(bins[i]))

}

 

{{out}}

The modifier is a pure function which consumes a sequence of numbers (probably, random) and applies a modification rule to it.

 

import Data.List

import Text.Printf

showHist h = foldMap mkLine h

where

 

<pre>λ> showHist $ hist 0.05 $ take 50000 $ modify vShape $ randoms $ mkStdGen 1234

Implementation:

 

while.do.r=.?0 0

if. (<u)/r do. {:r return.end.

}}

 

 

Task example:

 

 

bins=: 17%~i.18 NB. upper bounds (0 does not appear in result)

0.882353 854 ###################################################

0.941176 996 ###########################################################

 

 

=={{header|Julia}}==

 

 

modifier(x) = (y = 2x - 1; y < 0 ? -y : y)

modrands(rands1, rands2) = [x for (i, x) in enumerate(rands1) if rands2[i] < modifier(x)]

histogram(modrands(rand(50000), rand(50000)), nbins = 20)

<pre>

 

 

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

Modifier[x_] := If[x < 0.5, 2 (0.5 - x), 2 (x - 0.5)]

CreateRandomNumber[] := Module[{r1, r2, done = True},

numbers = Table[CreateRandomNumber[], 100000];

{bins, counts} = HistogramList[numbers, {0, 1, 0.05}, "PDF"];

{{out}}

<pre>{0.,0.05} - XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

=={{header|Nim}}==

{{trans|Wren}}

 

type ValRange = range[0.0..1.0]

for i in 0..<NumBins:

let hist = repeat(HistChar, (bins[i] / HistCharSize).toInt)

 

{{out}}

{{trans|Raku}}

Uses any supplied distribution function, but defaults to uniform otherwise.

use warnings;

use List::Util 'max';

 

my @samples = distribution( function => \&modifier_notch, sample_size => 50_000);

{{out}}

<pre>Bin Counts Histogram

 

=={{header|Phix}}==

while true do

atom r1 := rnd()

sequence hist := repeat('#', round(bins[i]/HIST_CHAR_SIZE))

printf(1,"%s %s %,d\n", {LBLS[i], hist, bins[i]})

{{out}}

<pre>

{{libheader|Phix/pGUI}}

A simple graphical plot. Note the labels are on the X-axis, so it's <code>v</code>-shaped, not <code><</code>-shaped: IupPlot does not support putting user-supplied labels on the Y-axis.

IupOpen()

Ihandle plot = IupPlot("GRID=YES, AXS_YAUTOMIN=NO")

IupShow(IupDialog(plot, `TITLE=Histogram, RASTERSIZE=1300x850`))

IupMainLoop()

 

=={{header|Python}}==

from typing import List, Callable, Optional

 

print(f" {b / bins:5.2f}, {count:4}, {delta:>4}: "

f"{'#' * int(40 * count / mx)}")

 

{{out}}

=={{header|R}}==

Although it may not be immediately obvious, both modifier and gen are equivalent to the corresponding functions in the task.

modifier <- function(x) 2*abs(x - 0.5)

gen <- function()

}

data <- replicate(100000, gen())

{{out}}

<pre>> NostalgiR::nos.hist(data, breaks = 20, pch = "#")

=={{header|REXX}}==

If a vertical histograph &nbsp; (instead of a &nbsp; <big><big><big>&lt;</big></big></big> &nbsp; shaped horizontal histograph) &nbsp; were to be used, &nbsp; it would be a &nbsp; <big><big>V</big></big> &nbsp; shaped.

parse arg randn bins seed . /*obtain optional argument from the CL.*/

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

#= # + 1; @.#= r /*bump counter; assign the MRD to array*/

end /*until*/

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

<pre>

 

=={{header|Raku}}==

return lazy gather loop {

my ( $r1, $r2 ) = rand, rand;

my @d = modified_random_distribution( &modifier );

 

{{out}}

<pre>

=={{header|Wren}}==

{{libheader|Wren-fmt}}

import "/fmt" for Fmt

 

var hist = HIST_CHAR * (bins[i] / HIST_CHAR_SIZE).round

Fmt.print("$4.2f ..< $4.2f $s $,d", binSize * i, binSize * (i + 1), hist, bins[i])

 

{{out}}