Diversity prediction theorem: Difference between revisions

=={{header|11l}}==

{{trans|C++}}

R sum(predictions.map(x -> (x - @a) ^ 2)) / predictions.len

 

 

diversity_theorem(49.0, [Float(48), 47, 51])

{{out}}

<pre>

diversity: 10.5

</pre>

 

=={{header|C}}==

Accepts inputs from command line, prints out usage on incorrect invocation.

 

#include<string.h>

return 0;

}

Invocation and Output :

<pre>

 

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

using System;

using System.Linq;

DiversityTheorem(49, new []{48d,47,51,42});

}

{{out}}

<pre>

 

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

#include <iostream>

#include <vector>

return 0;

}

{{out}}

<pre>

=={{header|Clojure}}==

John Lawrence Aspden's code posted on [http://www.learningclojure.com/2013/08/diversity-prediction-theorem.html Diversity Prediction Theorem].

(defn diversity-theorem [truth predictions]

(let [square (fn[x] (* x x))

(println (diversity-theorem 49 '(48 47 51)))

(println (diversity-theorem 49 '(48 47 51 42)))

{{out}}

<pre>

{:average-error 29/2, :crowd-error 4, :diversity 21/2}

</pre>

 

=={{header|D}}==

{{trans|C#}}

import std.stdio;

 

diversityTheorem(49.0, [48.0, 47.0, 51.0]);

diversityTheorem(49.0, [48.0, 47.0, 51.0, 42.0]);

{{out}}

<pre>average-error: 3

crowd-error: 4

diversity: 10.5</pre>

 

=={{header|Factor}}==

{{works with|Factor|0.99 2020-01-23}}

 

TUPLE: div avg-err crowd-err diversity ;

 

49 { 48 47 51 } diversity .

{{out}}

 

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Go}}==

 

import "fmt"

fmt.Printf("Diversity : %6.3f\n\n", div)

}

 

{{out}}

=={{header|Groovy}}==

{{trans|Java}}

private static double square(double d) {

return d * d

println(diversityTheorem(49.0, [48.0, 47.0, 51.0, 42.0] as double[]))

}

{{out}}

<pre>average-error : 3.000

=={{header|Haskell}}==

 

mean lst = sum lst / fromIntegral (length lst)

 

putStrLn $ "CrowdError:\t" ++ show crowderr

let diversity = meanSq avg estimates

 

<pre>λ> diversityPrediction 49 [48,47,51]

Accepts inputs from command line, prints out usage on incorrect invocation.

Were this compressed adaptation from C the content of file <tt>d.ijs</tt>

echo 'Use: ' , (;:inv 2 {. ARGV) , ' <reference value> <observations>'

 

 

exit 0

example uses follow

<pre>

=={{header|Java}}==

{{trans|Kotlin}}

 

public class DiversityPredictionTheorem {

System.out.println(diversityTheorem(49.0, new double[]{48.0, 47.0, 51.0, 42.0}));

}

{{out}}

<pre>average-error : 3.000

=={{header|JavaScript}}==

===ES5===

 

function sum(array) {

console.log(diversityTheorem(49, [48,47,51]))

console.log(diversityTheorem(49, [48,47,51,42]))

{{out}}

<pre>

 

===ES6===

'use strict';

 

// MAIN ---

return main()

{{Out}}

<pre>[

=={{header|Jsish}}==

From Typescript entry.

"use strict";

 

diversityTheorem(49, [48,47,51,42]) ==> { "average-error":14.5, "crowd-error":4, diversity:10.5 }

=!EXPECTEND!=

 

{{out}}

 

'''Works with gojq, the Go implementation of jq'''

def mean: add/length;

 

| { avgerr: ($predicted | map(. - $actual) | map(pow(.; 2)) | mean),

crderr: pow($mean - $actual; 2),

([49, [48, 47, 51]],

[49, [48, 47, 51, 42]

])

| . as [$actual, $predicted]

 

{{out}}

=={{header|Julia}}==

{{works with|Julia|1.2}}

 

function diversitytheorem(truth::T, pred::Vector{T}) where T<:Number

diversity : $divers

""")

 

{{out}}

=={{header|Kotlin}}==

{{trans|TypeScript}}

 

fun square(d: Double) = d * d

println(diversityTheorem(49.0, doubleArrayOf(48.0, 47.0, 51.0)))

println(diversityTheorem(49.0, doubleArrayOf(48.0, 47.0, 51.0, 42.0)))

 

{{out}}

=={{header|Lua}}==

{{trans|C++}}

return x * x

end

end

 

{{out}}

<pre>average-error: 3

 

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

DiversityPredictionTheorem[trueval_?NumericQ, estimates_List] :=

Module[{avg, avgerr, crowderr, diversity},

]

DiversityPredictionTheorem[49, {48, 47, 51}] // Dataset

{{out}}

<pre>TrueValue 49

 

=={{header|Nim}}==

 

func meanSquareDiff(refValue: float; estimates: seq[float]): float =

echo "Crowd error: ", (m - trueValue)^2

echo "Prediction diversity: ", meanSquareDiff(m, estimates)

 

{{out}}

 

=={{header|Perl}}==

my($truth, @pred) = @_;

my($ae,$ce,$cp,$pd,$stats);

 

print diversity(49, qw<48 47 51>) . "\n";

{{out}}

<pre>average-error: 3.000

 

=={{header|Phix}}==

{{out}}

<pre>

diversity : 10.5

</pre>

 

=={{header|Python}}==

By composition of pure functions:

{{Works with|Python|3.7}}

 

from itertools import chain

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>

=={{header|R}}==

R's vectorisation shines here. The hardest part of this task was giving each estimate its own numbered column, which is little more than a printing luxury. The actual mathematics was trivial, with each part done in essentially one line.

{

data.frame("True Value" = trueValue,

as.list(setNames(estimates, paste("Guess", seq_along(estimates)))), #Guesses, each with a title and column.

}

diversityStats(49, c(48, 47, 51))

{{out}}

<pre>> diversityStats(49, c(48, 47, 51))

True.Value Guess.1 Guess.2 Guess.3 Guess.4 Average.Error Crowd.Error Prediction.Diversity

1 49 48 47 51 42 14.5 4 10.5</pre>

 

=={{header|Raku}}==

(formerly Perl 6)

my $ae = avg-error($truth, @pred); # average individual error

my $cp = ([+] @pred)/+@pred; # collective prediction

 

.say for diversity-format diversity-calc(49, <48 47 51>);

 

{{out}}

=={{header|REXX}}==

===version 1===

Numeric Digits 20

Call diversityTheorem 49,'48 47 51'

res=res+(x-a)**2 /* accumulate square of differences */

End

{{out}}

<pre>average-error=3

Uses greater precision, but rounds the output to six decimal digits past the decimal

point &nbsp; (see the last comment in the program).

numeric digits 50 /*use precision of fifty decimal digits*/

call diversity 49, 48 47 51 /*true value and the crowd predictions.*/

say ' the crowd error: ' format( (true-a) **2, , 6) / 1

say 'prediction diversity: ' format( avgSD(a) , , 6) / 1; say; say

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

<pre>

the crowd error: 4

prediction diversity: 10.5

</pre>

 

=={{header|Ruby}}==

{{trans|D}}

def mean_square_diff(a, predictions) = mean(predictions.map { |x| square(x - a)**2 })

diversity_theorem(49.0, [48.0, 47.0, 51.0])

{{out}}

<pre>truth: 49.0, predictions [48.0, 47.0, 51.0]

=={{header|Scala}}==

{{trans|Kotlin}}

def square(d: Double): Double

= d * d

println(diversityTheorem(49.0, Array(48.0, 47.0, 51.0, 42.0)))

}

{{out}}

<pre>average-error : 3.000

=={{header|Sidef}}==

{{trans|Raku}}

v.map { (_ - m)**2 }.sum / v.len

}

 

diversity_format(diversity_calc(49, [48, 47, 51])).each{.say}

{{out}}

<pre>

 

=={{header|TypeScript}}==

function sum(array: Array<number>): number {

return array.reduce((a, b) => a + b)

console.log(diversityTheorem(49, [48,47,51]))

console.log(diversityTheorem(49, [48,47,51,42]))

{{out}}

<pre>

{ 'average-error': 14.5, 'crowd-error': 4, diversity: 10.5 }

</pre>

 

=={{header|Wren}}==

{{trans|Go}}

 

var averageSquareDiff = Fn.new { |f, preds|

Fmt.print("Crowd-error : $6.3f", res[1])

Fmt.print("Diversity : $6.3f\n", res[2])

 

{{out}}

Crowd-error : 4.000

Diversity : 10.500

</pre>

 

=={{header|zkl}}==

{{trans|Sidef}}

fcn diversityCalc(truth,pred){ //(Float,List of Float)

T("average-error","crowd-error","diversity").zip(stats)

.pump(String,Void.Xplode,"%13s :%7.3f\n".fmt)

{{out}}

<pre>