Deming's funnel: Difference between revisions

{{trans|Python}}

-0.231, -0.401, 0.269, 0.491, 0.951, 1.15, 0.001, -0.382, 0.161, 0.915,

2.08, -2.337, 0.034, -0.126, 0.014, 0.709, 0.129, -1.093, -0.483, -1.193,

experiment(‘Rule 2:’, (z, dz) -> -dz)

experiment(‘Rule 3:’, (z, dz) -> -(z + dz))

{{out}}

=={{header|Ada}}==

{{trans|Go}}

with Ada.Text_IO;

Experiment ("Rule 3", Rule_3'Access);

Experiment ("Rule 4", Rule_4'Access);

=={{header|D}}==

{{trans|Python}}

auto mean(T)(in T[] xs) pure nothrow @nogc {

experiment("Rule 3:", dxs, dys, (z, dz) => -(z + dz));

experiment("Rule 4:", dxs, dys, (z, dz) => z + dz);

{{out}}

<pre>Rule 1:

=={{header|Elixir}}==

{{trans|Ruby}}

def funnel(dxs, rule) do

{_, rxs} = Enum.reduce(dxs, {0, []}, fn dx,{x,rxs} ->

Deming.experiment("Rule 2:", dxs, dys, fn _z, dz -> -dz end)

Deming.experiment("Rule 3:", dxs, dys, fn z, dz -> -(z+dz) end)

{{out}}

=={{header|Factor}}==

{{works with|Factor|0.99 2019-10-06}}

kernel math math.statistics sequences ;

[ "Rule 3:" print [ 0 [ - neg ] accumulate* ] bi@ ]

[ "Rule 4:" print [ cum-sum ] bi@ ]

{{out}}

<pre>

=={{header|Go}}==

{{trans|Python}}

import (

return z + dz

})

{{out}}

=={{header|Haskell}}==

{{trans|Python}}

import Text.Printf

experiment "Rule 2:" dxs dys (\_ dz -> -dz)

experiment "Rule 3:" dxs dys (\z dz -> -(z+dz))

{{out}}

=={{header|J}}==

dx=:".0 :0-.LF

_0.533 0.270 0.859 _0.043 _0.205 _0.127 _0.071 0.275

smoutput ' Rule 4 (x,y):'

smoutput ' Mean: ',":dx ,&mean&Rule4 dy

Displayed result:

Translation of [[Deming's_Funnel#Python|Python]] via [[Deming's_Funnel#D|D]]

{{works with|Java|8}}

import java.util.Arrays;

import java.util.function.BiFunction;

return sqrt(Arrays.stream(xs).map(x -> pow((x - m), 2)).sum() / xs.length);

}

<pre>Rule 1:

=={{header|Julia}}==

using Statistics, Distributions, Plots

testfunnel(false)

display(plots)

<pre>

Using Racket data.

=={{header|Kotlin}}==

{{trans|Python}}

typealias Rule = (Double, Double) -> Double

experiment("Rule 3") { z, dz -> -(z + dz) }

experiment("Rule 4") { z, dz -> z + dz }

{{out}}

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

1.251, -0.231, -0.401, 0.269, 0.491, 0.951, 1.15, 0.001, -0.382,

0.161, 0.915, 2.08, -2.337, 0.034, -0.126, 0.014, 0.709,

];

{{out}}

<pre>Rule 1

== Stretch 1 ==

RadiusDistribution = NormalDistribution[0, 1];

AngleDistribution = UniformDistribution[{0, Pi}];

TableForm[Results[#, newData] & /@ Range[4], TableSpacing -> 5]

{{out}}

== Stretch 2 ==

ListPlot[MarblePositions[#][Transpose[{dxs,dys}]]&/@Range[4],PlotLegends->PointLegend[{1,2,3,4}],AspectRatio->Automatic,ImageSize->600]

{{out}}

=={{header|Nim}}==

{{trans|Kotlin}}

type Rule = proc(x, y: float): float

experiment("Rule 3", proc(z, dz: float): float = -(z + dz))

{{out}}

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

:''This is a work-in-progress.''

my(v=vector(drops),target=0);

v[1]=rule(target, 0);

print()

)

=={{header|Perl}}==

-0.533 0.270 0.859 -0.043 -0.205 -0.127 -0.071 0.275

1.251 -0.231 -0.401 0.269 0.491 0.951 1.150 0.001

printf "Mean x, y : %7.4f %7.4f\n", mean(@ddx), mean(@ddy);

printf "Std dev x, y : %7.4f %7.4f\n", stddev(@ddx), stddev(@ddy);

{{out}}<pre>

Rule 1

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">funnel</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">dxs</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">rule</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">experiment</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">dxs</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">dys</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre>

=={{header|Python}}==

{{trans|Racket}}

dxs = [-0.533, 0.27, 0.859, -0.043, -0.205, -0.127, -0.071, 0.275, 1.251,

experiment('Rule 2:', lambda z, dz: -dz)

experiment('Rule 3:', lambda z, dz: -(z+dz))

{{output}}

'''Alternative''': [Generates pseudo-random data and gives some interpretation.] The funnel experiment is performed in one dimension. The other dimension would act similarly.

from math import sqrt

from pprint import pprint as pp

for rule, comment in rcomments:

printit(rule)

{{out}}

=={{header|Racket}}==

The stretch solutions can be obtained by uncommenting radii etc. (delete the 4 semi-colons) to generate fresh data, and scatter-plots can be obtained by deleting the #; .

(require math/distributions math/statistics plot)

(experiment "Rule 2:" (λ (z dz) (- dz)))

(experiment "Rule 3:" (λ (z dz) (- (+ z dz))))

{{output}}

(formerly Perl 6)

{{Works with|Rakudo|2018.10}}

sub stddev {

# <(x - <x>)²> = <x²> - <x>²

printf "Mean x, y : %7.4f %7.4f\n", mean(@z».re), mean(@z».im);

printf "Std dev x, y : %7.4f %7.4f\n", stddev(@z».re), stddev(@z».im);

{{out}}

<pre>Rule 1:

=={{header|Ruby}}==

{{trans|Python}}

x, rxs = 0, []

for dx in dxs

experiment('Rule 2:', dxs, dys) {|z, dz| -dz}

experiment('Rule 3:', dxs, dys) {|z, dz| -(z+dz)}

{{out}}

=={{header|Sidef}}==

{{trans|Raku}}

a.sum / a.len

}

printf("Mean x, y : %.4f %.4f\n", x̄(z.map{.re}), x̄(z.map{.im}))

printf("Std dev x, y : %.4f %.4f\n", σ(z.map{.re}), σ(z.map{.im}))

{{out}}

<pre>

{{trans|Kotlin}}

let dxs = [

experiment(label: "Rule 2", rule: {_, dz in -dz })

experiment(label: "Rule 3", rule: {z, dz in -(z + dz) })

{{out}}

{{works with|Tcl|8.6}}

{{trans|Ruby}}

namespace path {tcl::mathop tcl::mathfunc}

experiment "Rule 2:" $dxs $dys {{z dz} {expr {-$dz}}}

experiment "Rule 3:" $dxs $dys {{z dz} {expr {-($z+$dz)}}}

The first stretch goal:

{{tcllib|math::constants}}

{{tcllib|simulation::random}}

package require simulation::random

experiment "Rule 2:" $dxs $dys {{z dz} {expr {-$dz}}}

experiment "Rule 3:" $dxs $dys {{z dz} {expr {-($z+$dz)}}}

{{out}}

<pre>

=={{header|Vlang}}==

{{trans|Go}}

type Rule = fn(f64, f64) f64

return z + dz

})

{{out}}

{{trans|Go}}{{libheader|Wren-math}}

{{libheader|Wren-fmt}}

import "/fmt" for Fmt

experiment.call("Rule 2") { |z, dz| -dz }

experiment.call("Rule 3") { |z, dz| -(z + dz) }

{{out}}

=={{header|zkl}}==

{{trans|Ruby}}

x:=0.0; rxs:=L();

foreach dx in (dxs){

"Std dev x, y : %7.4f, %7.4f".fmt(stddev(rxs),stddev(rys)).println();

println();

1.251, -0.231, -0.401, 0.269, 0.491, 0.951, 1.150, 0.001,

-0.382, 0.161, 0.915, 2.080, -2.337, 0.034, -0.126, 0.014,

experiment("Rule 2:", dxs, dys, fcn(z,dz){ -dz });

experiment("Rule 3:", dxs, dys, fcn(z,dz){ -(z+dz) });

{{out}}

<pre>