aparler/RosettaCodeData
1
0
Fork 0
Code Issues 12 Pull requests 3 Projects Releases Packages Wiki Activity Actions

Data commit

Browse source
This commit is contained in:
Ingy döt Net 2023-07-01 11:58:00 -04:00
parent 7387c8f97b
commit cb5bb5e222
199093 changed files with 3378972 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Task/Diversity-prediction-theorem/00-META.yaml Normal file
View file

@ -0,0 +1,2 @@
---
from: http://rosettacode.org/wiki/Diversity_prediction_theorem

40
Task/Diversity-prediction-theorem/00-TASK.txt Normal file
View file

@ -0,0 +1,40 @@
The   ''wisdom of the crowd''   is the collective opinion of a group of individuals rather than that of a single expert.
Wisdom-of-the-crowds research routinely attributes the superiority of crowd averages over individual judgments to the elimination of individual noise,   an explanation that assumes independence of the individual judgments from each other.
Thus the crowd tends to make its best decisions if it is made up of diverse opinions and ideologies.
Scott E. Page introduced the diversity prediction theorem:
: <big>''The squared error of the collective prediction equals the average squared error minus the predictive diversity''.</big>
Therefore, &nbsp; when the diversity in a group is large, &nbsp; the error of the crowd is small.
;Definitions:
::* &nbsp; Average Individual Error: &nbsp; Average of the individual squared errors
::* &nbsp; Collective Error: &nbsp; Squared error of the collective prediction
::* &nbsp; Prediction Diversity: &nbsp; Average squared distance from the individual predictions to the collective prediction
::* &nbsp; Diversity Prediction Theorem: &nbsp; ''Given a crowd of predictive models'', &nbsp; &nbsp; then
:::::: &nbsp; Collective Error &nbsp; = &nbsp; Average Individual Error &nbsp; ─ &nbsp; Prediction Diversity
;Task:
For a given &nbsp; true &nbsp; value and a number of number of estimates (from a crowd), &nbsp; show &nbsp; (here on this page):
:::* &nbsp; the true value &nbsp; and &nbsp; the crowd estimates
:::* &nbsp; the average error
:::* &nbsp; the crowd error
:::* &nbsp; the prediction diversity
Use &nbsp; (at least) &nbsp; these two examples:
:::* &nbsp; a true value of &nbsp; '''49''' &nbsp; with crowd estimates of: &nbsp; ''' 48 &nbsp; 47 &nbsp; 51'''
:::* &nbsp; a true value of &nbsp; '''49''' &nbsp; with crowd estimates of: &nbsp; ''' 48 &nbsp; 47 &nbsp; 51 &nbsp; 42'''
;Also see:
:* &nbsp; Wikipedia entry: &nbsp; [https://en.wikipedia.org/wiki/Wisdom_of_the_crowd Wisdom of the crowd]
:* &nbsp; University of Michigan: [https://web.archive.org/web/20060830201235/http://www.cscs.umich.edu/~spage/teaching_files/modeling_lectures/MODEL5/M18predictnotes.pdf PDF paper] &nbsp; &nbsp; &nbsp; &nbsp; (exists on a web archive, &nbsp; the ''Wayback Machine'').
<br><br>

11
Task/Diversity-prediction-theorem/11l/diversity-prediction-theorem.11l Normal file
View file

@ -0,0 +1,11 @@
F average_square_diff(a, predictions)
R sum(predictions.map(x -> (x - @a) ^ 2)) / predictions.len
F diversity_theorem(truth, predictions)
V average = sum(predictions) / predictions.len
print(‘average-error: ’average_square_diff(truth, predictions)"\n"‘’
‘crowd-error: ’((truth - average) ^ 2)"\n"‘’
‘diversity: ’average_square_diff(average, predictions))
diversity_theorem(49.0, [Float(48), 47, 51])
diversity_theorem(49.0, [Float(48), 47, 51, 42])

36
Task/Diversity-prediction-theorem/ANSI-BASIC/diversity-prediction-theorem.basic Normal file
View file

@ -0,0 +1,36 @@
100 PROGRAM DiversityPredictionTheorem
110 OPTION BASE 0
120 DIM Estimates(1, 4)
130 FOR I = 0 TO 1
140 LET J = 0
150 READ Estimates(I, J)
160 DO WHILE Estimates(I, J) <> 0
170 LET J = J + 1
180 READ Estimates(I, J)
190 LOOP
200 NEXT I
210 DATA 48.0, 47.0, 51.0, 0.0
220 DATA 48.0, 47.0, 51.0, 42.0, 0.0
230 LET TrueVal = 49
240 FOR I = 0 TO 1
250 LET Sum = 0
260 LET J = 0
270 DO WHILE Estimates(I, J) <> 0
280 LET Sum = Sum + (Estimates(I, J) - TrueVal) ^ 2
290 LET J = J + 1
300 LOOP
310 LET AvgErr = Sum / J
320 PRINT USING "Average error : ##.###": AvgErr
330 LET Sum = 0
340 LET J = 0
350 DO WHILE Estimates(I, J) <> 0
360 LET Sum = Sum + Estimates(I, J)
370 LET J = J + 1
380 LOOP
390 LET Avg = Sum / J
400 LET CrowdErr = (TrueVal - Avg) ^ 2
410 PRINT USING "Crowd error : ##.###": CrowdErr
420 PRINT USING "Diversity : ##.###": AvgErr - CrowdErr
430 PRINT
440 NEXT I
450 END

60
Task/Diversity-prediction-theorem/Ada/diversity-prediction-theorem.ada Normal file
View file

@ -0,0 +1,60 @@
with Ada.Text_IO;
with Ada.Command_Line;
procedure Diversity_Prediction is
type Real is new Float;
type Real_Array is array (Positive range <>) of Real;
package Real_IO is new Ada.Text_Io.Float_IO (Real);
use Ada.Text_IO, Ada.Command_Line, Real_IO;
function Mean (Data : Real_Array) return Real is
Sum : Real := 0.0;
begin
for V of Data loop
Sum := Sum + V;
end loop;
return Sum / Real (Data'Length);
end Mean;
function Variance (Reference : Real; Data : Real_Array) return Real is
Res : Real_Array (Data'Range);
begin
for A in Data'Range loop
Res (A) := (Reference - Data (A)) ** 2;
end loop;
return Mean (Res);
end Variance;
procedure Diversity (Truth : Real; Estimates : Real_Array)
is
Average : constant Real := Mean (Estimates);
Average_Error : constant Real := Variance (Truth, Estimates);
Crowd_Error : constant Real := (Truth - Average) ** 2;
Diversity : constant Real := Variance (Average, Estimates);
begin
Real_IO.Default_Exp := 0;
Real_IO.Default_Aft := 5;
Put ("average-error : "); Put (Average_Error); New_Line;
Put ("crowd-error : "); Put (Crowd_Error); New_Line;
Put ("diversity : "); Put (Diversity); New_Line;
end Diversity;
begin
if Argument_Count <= 1 then
Put_Line ("Usage: diversity_prediction <truth> <data_1> <data_2> ...");
return;
end if;
declare
Truth : constant Real := Real'Value (Argument (1));
Estimates : Real_Array (2 .. Argument_Count);
begin
for A in 2 .. Argument_Count loop
Estimates (A) := Real'Value (Argument (A));
end loop;
Diversity (Truth, Estimates);
end;
end Diversity_Prediction;

21
Task/Diversity-prediction-theorem/BASIC256/diversity-prediction-theorem.basic Normal file
View file

@ -0,0 +1,21 @@
dim test = {{48.0, 47.0, 51.0, 0.0}, {48.0, 47.0, 51.0, 42.0, 0.0}}
TrueVal = 49.0
for i = 0 to 1
Vari = 0.0
Sum = 0.0
c = 0
while test[i,c] <> 0
Vari += (test[i,c] - TrueVal) ^2
Sum += test[i,c]
c += 1
end while
AvgErr = Vari / c
RefAvg = Sum / c
CrowdErr = (TrueVal - RefAvg) ^2
print "Average error : "; AvgErr
print " Crowd error : "; CrowdErr
print " Diversity : "; AvgErr - CrowdErr
print
next i

41
Task/Diversity-prediction-theorem/C++/diversity-prediction-theorem.cpp Normal file
View file

@ -0,0 +1,41 @@
#include <iostream>
#include <vector>
#include <numeric>
float sum(const std::vector<float> &array)
{
return std::accumulate(array.begin(), array.end(), 0.0);
}
float square(float x)
{
return x * x;
}
float mean(const std::vector<float> &array)
{
return sum(array) / array.size();
}
float averageSquareDiff(float a, const std::vector<float> &predictions)
{
std::vector<float> results;
for (float x : predictions)
results.push_back(square(x - a));
return mean(results);
}
void diversityTheorem(float truth, const std::vector<float> &predictions)
{
float average = mean(predictions);
std::cout
<< "average-error: " << averageSquareDiff(truth, predictions) << "\n"
<< "crowd-error: " << square(truth - average) << "\n"
<< "diversity: " << averageSquareDiff(average, predictions) << std::endl;
}
int main() {
diversityTheorem(49, {48,47,51});
diversityTheorem(49, {48,47,51,42});
return 0;
}

23
Task/Diversity-prediction-theorem/C-sharp/diversity-prediction-theorem.cs Normal file
View file

@ -0,0 +1,23 @@
using System;
using System.Linq;
using System.Collections.Generic;
public class MainClass {
static double Square(double x) => x * x;
static double AverageSquareDiff(double a, IEnumerable<double> predictions)
=> predictions.Select(x => Square(x - a)).Average();
static void DiversityTheorem(double truth, IEnumerable<double> predictions)
{
var average = predictions.Average();
Console.WriteLine($@"average-error: {AverageSquareDiff(truth, predictions)}
crowd-error: {Square(truth - average)}
diversity: {AverageSquareDiff(average, predictions)}");
}
public static void Main() {
DiversityTheorem(49, new []{48d,47,51});
DiversityTheorem(49, new []{48d,47,51,42});
}
}

69
Task/Diversity-prediction-theorem/C/diversity-prediction-theorem.c Normal file
View file

@ -0,0 +1,69 @@
#include<string.h>
#include<stdlib.h>
#include<stdio.h>
float mean(float* arr,int size){
int i = 0;
float sum = 0;
while(i != size)
sum += arr[i++];
return sum/size;
}
float variance(float reference,float* arr, int size){
int i=0;
float* newArr = (float*)malloc(size*sizeof(float));
for(;i<size;i++)
newArr[i] = (reference - arr[i])*(reference - arr[i]);
return mean(newArr,size);
}
float* extractData(char* str, int *len){
float* arr;
int i=0,count = 1;
char* token;
while(str[i]!=00){
if(str[i++]==',')
count++;
}
arr = (float*)malloc(count*sizeof(float));
*len = count;
token = strtok(str,",");
i = 0;
while(token!=NULL){
arr[i++] = atof(token);
token = strtok(NULL,",");
}
return arr;
}
int main(int argC,char* argV[])
{
float* arr,reference,meanVal;
int len;
if(argC!=3)
printf("Usage : %s <reference value> <observations separated by commas>");
else{
arr = extractData(argV[2],&len);
reference = atof(argV[1]);
meanVal = mean(arr,len);
printf("Average Error : %.9f\n",variance(reference,arr,len));
printf("Crowd Error : %.9f\n",(reference - meanVal)*(reference - meanVal));
printf("Diversity : %.9f",variance(meanVal,arr,len));
}
return 0;
}

10
Task/Diversity-prediction-theorem/Clojure/diversity-prediction-theorem.clj Normal file
View file

@ -0,0 +1,10 @@
(defn diversity-theorem [truth predictions]
(let [square (fn[x] (* x x))
mean (/ (reduce + predictions) (count predictions))
avg-sq-diff (fn[a] (/ (reduce + (for [x predictions] (square (- x a)))) (count predictions)))]
{:average-error (avg-sq-diff truth)
:crowd-error (square (- truth mean))
:diversity (avg-sq-diff mean)}))
(println (diversity-theorem 49 '(48 47 51)))
(println (diversity-theorem 49 '(48 47 51 42)))

21
Task/Diversity-prediction-theorem/D/diversity-prediction-theorem.d Normal file
View file

@ -0,0 +1,21 @@
import std.algorithm;
import std.stdio;
auto square = (real x) => x * x;
auto meanSquareDiff(R)(real a, R predictions) {
return predictions.map!(x => square(x - a)).mean;
}
void diversityTheorem(R)(real truth, R predictions) {
auto average = predictions.mean;
writeln("average-error: ", meanSquareDiff(truth, predictions));
writeln("crowd-error: ", square(truth - average));
writeln("diversity: ", meanSquareDiff(average, predictions));
writeln;
}
void main() {
diversityTheorem(49.0, [48.0, 47.0, 51.0]);
diversityTheorem(49.0, [48.0, 47.0, 51.0, 42.0]);
}

26
Task/Diversity-prediction-theorem/Delphi/diversity-prediction-theorem.delphi Normal file
View file

@ -0,0 +1,26 @@
function AveSqrDiff(TrueVal: double; Data: array of double): double;
var I: integer;
begin
Result:=0;
for I:=0 to High(Data) do Result:=Result+Sqr(Data[I]-TrueVal);
Result:=Result/Length(Data);
end;
procedure DoDiversityPrediction(Memo: TMemo; TrueValue: double; Crowd: array of double);
var AveError,AvePredict,Diversity: double;
var S: string;
begin
AveError:=AveSqrDiff(Truevalue,Crowd);
AvePredict:=Mean(Crowd);
Diversity:=AveSqrDiff(AvePredict,Crowd);
S:='Ave Error: '+FloatToStrF(AveError,ffFixed,18,2)+#$0D#$0A;
S:=S+'Crowd Error: '+FloatToStrF(Sqr(TrueValue - AvePredict),ffFixed,18,2)+#$0D#$0A;
S:=S+'Diversity: '+FloatToStrF(Diversity,ffFixed,18,2)+#$0D#$0A;
Memo.Lines.Add(S);
end;
procedure ShowDiversityPrediction(Memo: TMemo);
begin
DoDiversityPrediction(Memo,49,[48,47,51]);
DoDiversityPrediction(Memo,49,[48,47,51,42]);
end;

10
Task/Diversity-prediction-theorem/Factor/diversity-prediction-theorem.factor Normal file
View file

@ -0,0 +1,10 @@
USING: kernel math math.statistics math.vectors prettyprint ;
TUPLE: div avg-err crowd-err diversity ;
: diversity ( x seq -- obj )
[ n-v dup v* mean ] [ mean swap - sq ]
[ nip dup mean v-n dup v* mean ] 2tri div boa ;
49 { 48 47 51 } diversity .
49 { 48 47 51 42 } diversity .

26
Task/Diversity-prediction-theorem/FreeBASIC/diversity-prediction-theorem.basic Normal file
View file

@ -0,0 +1,26 @@
Dim As Double test(0 To 1, 0 To 4) => {_
{48.0, 47.0, 51.0}, _
{48.0, 47.0, 51.0, 42.0}}
Dim As Double TrueVal = 49
Dim As Double AvgErr, CrowdErr, RefAvg, Vari, Sum
Dim As Integer i, c
For i = 0 To 1
Vari = 0
Sum = 0
c = 0
While test(i,c) <> 0
Vari += (test(i,c) - TrueVal) ^2
Sum += test(i,c)
c += 1
Wend
AvgErr = Vari / c
RefAvg = Sum / c
CrowdErr = (TrueVal - RefAvg) ^2
Print Using "Average error : ###.###"; AvgErr
Print Using " Crowd error : ###.###"; CrowdErr
Print Using " Diversity : ###.###"; AvgErr - CrowdErr
Print
Sleep

34
Task/Diversity-prediction-theorem/Go/diversity-prediction-theorem.go Normal file
View file

@ -0,0 +1,34 @@
package main
import "fmt"
func averageSquareDiff(f float64, preds []float64) (av float64) {
for _, pred := range preds {
av += (pred - f) * (pred - f)
}
av /= float64(len(preds))
return
}
func diversityTheorem(truth float64, preds []float64) (float64, float64, float64) {
av := 0.0
for _, pred := range preds {
av += pred
}
av /= float64(len(preds))
avErr := averageSquareDiff(truth, preds)
crowdErr := (truth - av) * (truth - av)
div := averageSquareDiff(av, preds)
return avErr, crowdErr, div
}
func main() {
predsArray := [2][]float64{{48, 47, 51}, {48, 47, 51, 42}}
truth := 49.0
for _, preds := range predsArray {
avErr, crowdErr, div := diversityTheorem(truth, preds)
fmt.Printf("Average-error : %6.3f\n", avErr)
fmt.Printf("Crowd-error : %6.3f\n", crowdErr)
fmt.Printf("Diversity : %6.3f\n\n", div)
}
}

24
Task/Diversity-prediction-theorem/Groovy/diversity-prediction-theorem.groovy Normal file
View file

@ -0,0 +1,24 @@
class DiversityPredictionTheorem {
private static double square(double d) {
return d * d
}
private static double averageSquareDiff(double d, double[] predictions) {
return Arrays.stream(predictions)
.map({ it -> square(it - d) })
.average()
.orElseThrow()
}
private static String diversityTheorem(double truth, double[] predictions) {
double average = Arrays.stream(predictions)
.average()
.orElseThrow()
return String.format("average-error : %6.3f%n", averageSquareDiff(truth, predictions)) + String.format("crowd-error : %6.3f%n", square(truth - average)) + String.format("diversity : %6.3f%n", averageSquareDiff(average, predictions))
}
static void main(String[] args) {
println(diversityTheorem(49.0, [48.0, 47.0, 51.0] as double[]))
println(diversityTheorem(49.0, [48.0, 47.0, 51.0, 42.0] as double[]))
}
}

16
Task/Diversity-prediction-theorem/Haskell/diversity-prediction-theorem.hs Normal file
View file

@ -0,0 +1,16 @@
mean :: (Fractional a, Foldable t) => t a -> a
mean lst = sum lst / fromIntegral (length lst)
meanSq :: Fractional c => c -> [c] -> c
meanSq x = mean . map (\y -> (x-y)^^2)
diversityPrediction x estimates = do
putStrLn $ "TrueValue:\t" ++ show x
putStrLn $ "CrowdEstimates:\t" ++ show estimates
let avg = mean estimates
let avgerr = meanSq x estimates
putStrLn $ "AverageError:\t" ++ show avgerr
let crowderr = (x - avg)^^2
putStrLn $ "CrowdError:\t" ++ show crowderr
let diversity = meanSq avg estimates
putStrLn $ "Diversity:\t" ++ show diversity

16
Task/Diversity-prediction-theorem/J/diversity-prediction-theorem.j Normal file
View file

@ -0,0 +1,16 @@
echo 'Use: ' , (;:inv 2 {. ARGV) , ' <reference value> <observations>'
data=: ([: ". [: ;:inv 2&}.) ::([: exit 1:) ARGV
([: exit (1: echo@('insufficient data'"_)))^:(2 > #) data
mean=: +/ % #
variance=: [: mean [: *: -
averageError=: ({. variance }.)@:]
crowdError=: variance {.
diversity=: variance }.
echo (<;._2'average error;crowd error;diversity;') ,: ;/ (averageError`crowdError`diversity`:0~ mean@:}.) data
exit 0

28
Task/Diversity-prediction-theorem/Java/diversity-prediction-theorem.java Normal file
View file

@ -0,0 +1,28 @@
import java.util.Arrays;
public class DiversityPredictionTheorem {
private static double square(double d) {
return d * d;
}
private static double averageSquareDiff(double d, double[] predictions) {
return Arrays.stream(predictions)
.map(it -> square(it - d))
.average()
.orElseThrow();
}
private static String diversityTheorem(double truth, double[] predictions) {
double average = Arrays.stream(predictions)
.average()
.orElseThrow();
return String.format("average-error : %6.3f%n", averageSquareDiff(truth, predictions))
+ String.format("crowd-error : %6.3f%n", square(truth - average))
+ String.format("diversity : %6.3f%n", averageSquareDiff(average, predictions));
}
public static void main(String[] args) {
System.out.println(diversityTheorem(49.0, new double[]{48.0, 47.0, 51.0}));
System.out.println(diversityTheorem(49.0, new double[]{48.0, 47.0, 51.0, 42.0}));
}
}

33
Task/Diversity-prediction-theorem/JavaScript/diversity-prediction-theorem-1.js Normal file
View file

@ -0,0 +1,33 @@
'use strict';
function sum(array) {
return array.reduce(function (a, b) {
return a + b;
});
}
function square(x) {
return x * x;
}
function mean(array) {
return sum(array) / array.length;
}
function averageSquareDiff(a, predictions) {
return mean(predictions.map(function (x) {
return square(x - a);
}));
}
function diversityTheorem(truth, predictions) {
var average = mean(predictions);
return {
'average-error': averageSquareDiff(truth, predictions),
'crowd-error': square(truth - average),
'diversity': averageSquareDiff(average, predictions)
};
}
console.log(diversityTheorem(49, [48,47,51]))
console.log(diversityTheorem(49, [48,47,51,42]))

72
Task/Diversity-prediction-theorem/JavaScript/diversity-prediction-theorem-2.js Normal file
View file

@ -0,0 +1,72 @@
(() => {
'use strict';
// diversityValues :: [Num] -> {
// mean-error :: Float,
// crowd-error :: Float,
// diversity :: Float
// }
const diversityValues = observed =>
predictions => {
const predictionMean = mean(predictions);
return {
'mean-error': meanErrorSquared(observed)(
predictions
),
'crowd-error': Math.pow(
observed - predictionMean,
2
),
'diversity': meanErrorSquared(predictionMean)(
predictions
)
};
};
// meanErrorSquared :: Num a => a -> [a] -> b
const meanErrorSquared = observed =>
predictions => mean(
predictions.map(x => Math.pow(x - observed, 2))
);
// mean :: Num a => [a] -> b
const mean = xs => {
const lng = xs.length;
return lng > 0 ? (
xs.reduce((a, b) => a + b, 0) / lng
) : undefined;
};
// ----------------------- TEST ------------------------
const main = () =>
JSON.stringify([{
observed: 49,
predictions: [48, 47, 51]
}, {
observed: 49,
predictions: [48, 47, 51, 42]
}].map(x => dictionaryAtPrecision(3)(
diversityValues(x.observed)(
x.predictions
)
)), null, 2);
// ---------------------- GENERIC ----------------------
// dictionaryAtPrecision :: Int -> Dict -> Dict
const dictionaryAtPrecision = n =>
// A dictionary of Float values, with
// all Floats adjusted to a given precision.
dct => Object.keys(dct).reduce(
(a, k) => Object.assign(
a, {
[k]: dct[k].toPrecision(n)
}
), {}
);
// MAIN ---
return main()
})();

7
Task/Diversity-prediction-theorem/Jq/diversity-prediction-theorem-1.jq Normal file
View file

@ -0,0 +1,7 @@
def diversitytheorem($actual; $predicted):
def mean: add/length;
($predicted | mean) as $mean
| { avgerr: ($predicted | map(. - $actual) | map(pow(.; 2)) | mean),
crderr: pow($mean - $actual; 2),
divers: ($predicted | map(. - $mean) | map(pow(.;2)) | mean) } ;

6
Task/Diversity-prediction-theorem/Jq/diversity-prediction-theorem-2.jq Normal file
View file

@ -0,0 +1,6 @@
# The task:
([49, [48, 47, 51]],
[49, [48, 47, 51, 42]
])
| . as [$actual, $predicted]
| diversitytheorem($actual; $predicted)

37
Task/Diversity-prediction-theorem/Jsish/diversity-prediction-theorem.jsish Normal file
View file

@ -0,0 +1,37 @@
/* Diverisity Prediction Theorem, in Jsish */
"use strict";
function sum(arr:array):number {
return arr.reduce(function(acc, cur, idx, arr) { return acc + cur; });
}
function square(x:number):number {
return x * x;
}
function mean(arr:array):number {
return sum(arr) / arr.length;
}
function averageSquareDiff(a:number, predictions:array):number {
return mean(predictions.map(function(x:number):number { return square(x - a); }));
}
function diversityTheorem(truth:number, predictions:array):object {
var average = mean(predictions);
return {
"average-error": averageSquareDiff(truth, predictions),
"crowd-error": square(truth - average),
"diversity": averageSquareDiff(average, predictions)
};
}
;diversityTheorem(49, [48,47,51]);
;diversityTheorem(49, [48,47,51,42]);
/*
=!EXPECTSTART!=
diversityTheorem(49, [48,47,51]) ==> { "average-error":3, "crowd-error":0.1111111111111127, diversity:2.888888888888889 }
diversityTheorem(49, [48,47,51,42]) ==> { "average-error":14.5, "crowd-error":4, diversity:10.5 }
=!EXPECTEND!=
*/

19
Task/Diversity-prediction-theorem/Julia/diversity-prediction-theorem.julia Normal file
View file

@ -0,0 +1,19 @@
import Statistics: mean
function diversitytheorem(truth::T, pred::Vector{T}) where T<:Number
μ = mean(pred)
avgerr = mean((pred .- truth) .^ 2)
crderr = (μ - truth) ^ 2
divers = mean((pred .- μ) .^ 2)
avgerr, crderr, divers
end
for (t, s) in [(49, [48, 47, 51]),
(49, [48, 47, 51, 42])]
avgerr, crderr, divers = diversitytheorem(t, s)
println("""
average-error : $avgerr
crowd-error : $crderr
diversity : $divers
""")
end

19
Task/Diversity-prediction-theorem/Kotlin/diversity-prediction-theorem.kotlin Normal file
View file

@ -0,0 +1,19 @@
// version 1.1.4-3
fun square(d: Double) = d * d
fun averageSquareDiff(d: Double, predictions: DoubleArray) =
predictions.map { square(it - d) }.average()
fun diversityTheorem(truth: Double, predictions: DoubleArray): String {
val average = predictions.average()
val f = "%6.3f"
return "average-error : ${f.format(averageSquareDiff(truth, predictions))}\n" +
"crowd-error : ${f.format(square(truth - average))}\n" +
"diversity : ${f.format(averageSquareDiff(average, predictions))}\n"
}
fun main(args: Array<String>) {
println(diversityTheorem(49.0, doubleArrayOf(48.0, 47.0, 51.0)))
println(diversityTheorem(49.0, doubleArrayOf(48.0, 47.0, 51.0, 42.0)))
}

35
Task/Diversity-prediction-theorem/Lua/diversity-prediction-theorem.lua Normal file
View file

@ -0,0 +1,35 @@
function square(x)
return x * x
end
function mean(a)
local s = 0
local c = 0
for i,v in pairs(a) do
s = s + v
c = c + 1
end
return s / c
end
function averageSquareDiff(a, predictions)
local results = {}
for i,x in pairs(predictions) do
table.insert(results, square(x - a))
end
return mean(results)
end
function diversityTheorem(truth, predictions)
local average = mean(predictions)
print("average-error: " .. averageSquareDiff(truth, predictions))
print("crowd-error: " .. square(truth - average))
print("diversity: " .. averageSquareDiff(average, predictions))
end
function main()
diversityTheorem(49, {48, 47, 51})
diversityTheorem(49, {48, 47, 51, 42})
end
main()

17
Task/Diversity-prediction-theorem/Mathematica/diversity-prediction-theorem.math Normal file
View file

@ -0,0 +1,17 @@
ClearAll[DiversityPredictionTheorem]
DiversityPredictionTheorem[trueval_?NumericQ, estimates_List] :=
Module[{avg, avgerr, crowderr, diversity},
avg = Mean[estimates];
avgerr = Mean[(estimates - trueval)^2];
crowderr = (trueval - avg)^2;
diversity = Mean[(estimates - avg)^2];
<|
"TrueValue" -> trueval,
"CrowdEstimates" -> estimates,
"AverageError" -> avgerr,
"CrowdError" -> crowderr,
"Diversity" -> diversity
|>
]
DiversityPredictionTheorem[49, {48, 47, 51}] // Dataset
DiversityPredictionTheorem[49, {48, 47, 51, 42}] // Dataset

29
Task/Diversity-prediction-theorem/Nascom-BASIC/diversity-prediction-theorem.basic Normal file
View file

@ -0,0 +1,29 @@
10 REM Diversity prediction theorem
20 DIM EST(1,4):REM Estimates
30 FOR I=0 TO 1
40 J=0:READ EST(I,J)
50 IF EST(I,J)=0 THEN 80
60 J=J+1:READ EST(I,J)
70 GOTO 50
80 NEXT I
90 DATA 48.0,47.0,51.0,0.0
100 DATA 48.0,47.0,51.0,42.0,0.0
110 TV=49:REM True value
120 FOR I=0 TO 1
130 SUM=0:J=0
140 IF EST(I,J)=0 THEN 170
150 SUM=SUM+(EST(I,J)-TV)^2:J=J+1
160 GOTO 140
170 AER=SUM/J
180 PRINT "Average error :";AER
190 SUM=0:J=0
200 IF EST(I,J)=0 THEN 230
210 SUM=SUM+EST(I,J):J=J+1
220 GOTO 200
230 AVG=SUM/J
240 CER=(TV-AVG)^2
250 PRINT "Crowd error :";CER
260 PRINT "Diversity :";AER-CER
270 PRINT
280 NEXT I
290 END

21
Task/Diversity-prediction-theorem/Nim/diversity-prediction-theorem.nim Normal file
View file

@ -0,0 +1,21 @@
import strutils, math, stats
func meanSquareDiff(refValue: float; estimates: seq[float]): float =
## Compute the mean of the squares of the differences
## between estimated values and a reference value.
for estimate in estimates:
result += (estimate - refValue)^2
result /= estimates.len.toFloat
const Samples = [(trueValue: 49.0, estimates: @[48.0, 47.0, 51.0]),
(trueValue: 49.0, estimates: @[48.0, 47.0, 51.0, 42.0])]
for (trueValue, estimates, ) in Samples:
let m = mean(estimates)
echo "True value: ", trueValue
echo "Estimates: ", estimates.join(", ")
echo "Average error: ", meanSquareDiff(trueValue, estimates)
echo "Crowd error: ", (m - trueValue)^2
echo "Prediction diversity: ", meanSquareDiff(m, estimates)
echo ""

24
Task/Diversity-prediction-theorem/Perl/diversity-prediction-theorem.pl Normal file
View file

@ -0,0 +1,24 @@
sub diversity {
my($truth, @pred) = @_;
my($ae,$ce,$cp,$pd,$stats);
$cp += $_/@pred for @pred; # collective prediction
$ae = avg_error($truth, @pred); # average individual error
$ce = ($cp - $truth)**2; # collective error
$pd = avg_error($cp, @pred); # prediction diversity
my $fmt = "%13s: %6.3f\n";
$stats = sprintf $fmt, 'average-error', $ae;
$stats .= sprintf $fmt, 'crowd-error', $ce;
$stats .= sprintf $fmt, 'diversity', $pd;
}
sub avg_error {
my($m, @v) = @_;
my($avg_err);
$avg_err += ($_ - $m)**2 for @v;
$avg_err/@v;
}
print diversity(49, qw<48 47 51>) . "\n";
print diversity(49, qw<48 47 51 42>);

29
Task/Diversity-prediction-theorem/Phix/diversity-prediction-theorem.phix Normal file
View file

@ -0,0 +1,29 @@
(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">mean</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">return</span> <span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)/</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">variance</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">atom</span> <span style="color: #000000;">d</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">mean</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sq_power</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sq_sub</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #000000;">d</span><span style="color: #0000FF;">),</span><span style="color: #000000;">2</span><span style="color: #0000FF;">))</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">diversity_theorem</span><span style="color: #0000FF;">(</span><span style="color: #004080;">atom</span> <span style="color: #000000;">reference</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">sequence</span> <span style="color: #000000;">observations</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">average_error</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">variance</span><span style="color: #0000FF;">(</span><span style="color: #000000;">observations</span><span style="color: #0000FF;">,</span><span style="color: #000000;">reference</span><span style="color: #0000FF;">),</span>
<span style="color: #000000;">average</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">mean</span><span style="color: #0000FF;">(</span><span style="color: #000000;">observations</span><span style="color: #0000FF;">),</span>
<span style="color: #000000;">crowd_error</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">reference</span><span style="color: #0000FF;">-</span><span style="color: #000000;">average</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">),</span>
<span style="color: #000000;">diversity</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">variance</span><span style="color: #0000FF;">(</span><span style="color: #000000;">observations</span><span style="color: #0000FF;">,</span><span style="color: #000000;">average</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">return</span> <span style="color: #0000FF;">{{</span><span style="color: #008000;">"average_error"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">average_error</span><span style="color: #0000FF;">},</span>
<span style="color: #0000FF;">{</span><span style="color: #008000;">"crowd_error"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">crowd_error</span><span style="color: #0000FF;">},</span>
<span style="color: #0000FF;">{</span><span style="color: #008000;">"diversity"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">diversity</span><span style="color: #0000FF;">}}</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #004080;">atom</span> <span style="color: #000000;">reference</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">sequence</span> <span style="color: #000000;">observations</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">diversity_theorem</span><span style="color: #0000FF;">(</span><span style="color: #000000;">reference</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">observations</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" %14s : %g\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">res</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">])</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #000000;">49</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">48</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">47</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">51</span><span style="color: #0000FF;">})</span>
<span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #000000;">49</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">48</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">47</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">51</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">42</span><span style="color: #0000FF;">})</span>
<!--

41
Task/Diversity-prediction-theorem/PureBasic/diversity-prediction-theorem.basic Normal file
View file

@ -0,0 +1,41 @@
Define.f ref=49.0, mea
NewList argV.f()
Macro put
Print(~"\n["+StrF(ref)+"]"+#TAB$)
ForEach argV() : Print(StrF(argV())+#TAB$) : Next
PrintN(~"\nAverage Error : "+StrF(vari(argV(),ref),5))
PrintN("Crowd Error : "+StrF((ref-mea)*(ref-mea),5))
PrintN("Diversity : "+StrF(vari(argV(),mea),5))
EndMacro
Macro LetArgV(v)
AddElement(argV()) : argV()=v
EndMacro
Procedure.f mean(List x.f())
Define.f m
ForEach x() : m+x() : Next
ProcedureReturn m/ListSize(x())
EndProcedure
Procedure.f vari(List x.f(),r.f)
NewList nx.f()
ForEach x() : AddElement(nx()) : nx()=(r-x())*(r-x()) : Next
ProcedureReturn mean(nx())
EndProcedure
If OpenConsole()=0 : End 1 : EndIf
Gosub SetA : ClearList(argV())
Gosub SetB : Input()
End
SetA:
LetArgV(48.0) : LetArgV(47.0) : LetArgV(51.0)
mea=mean(argV()) : put
Return
SetB:
LetArgV(48.0) : LetArgV(47.0) : LetArgV(51.0) : LetArgV(42.0)
mea=mean(argV()) : put
Return

259
Task/Diversity-prediction-theorem/Python/diversity-prediction-theorem.py Normal file
View file

@ -0,0 +1,259 @@
'''Diversity prediction theorem'''
from itertools import chain
from functools import reduce
# diversityValues :: Num a => a -> [a] ->
# { mean-Error :: a, crowd-error :: a, diversity :: a }
def diversityValues(x):
'''The mean error, crowd error and
diversity, for a given observation x
and a non-empty list of predictions ps.
'''
def go(ps):
mp = mean(ps)
return {
'mean-error': meanErrorSquared(x)(ps),
'crowd-error': pow(x - mp, 2),
'diversity': meanErrorSquared(mp)(ps)
}
return go
# meanErrorSquared :: Num -> [Num] -> Num
def meanErrorSquared(x):
'''The mean of the squared differences
between the observed value x and
a non-empty list of predictions ps.
'''
def go(ps):
return mean([
pow(p - x, 2) for p in ps
])
return go
# ------------------------- TEST -------------------------
# main :: IO ()
def main():
'''Observed value: 49,
prediction lists: various.
'''
print(unlines(map(
showDiversityValues(49),
[
[48, 47, 51],
[48, 47, 51, 42],
[50, '?', 50, {}, 50], # Non-numeric values.
[] # Missing predictions.
]
)))
print(unlines(map(
showDiversityValues('49'), # String in place of number.
[
[50, 50, 50],
[40, 35, 40],
]
)))
# ---------------------- FORMATTING ----------------------
# showDiversityValues :: Num -> [Num] -> Either String String
def showDiversityValues(x):
'''Formatted string representation
of diversity values for a given
observation x and a non-empty
list of predictions p.
'''
def go(ps):
def showDict(dct):
w = 4 + max(map(len, dct.keys()))
def showKV(a, kv):
k, v = kv
return a + k.rjust(w, ' ') + (
' : ' + showPrecision(3)(v) + '\n'
)
return 'Predictions: ' + showList(ps) + ' ->\n' + (
reduce(showKV, dct.items(), '')
)
def showProblem(e):
return (
unlines(map(indented(1), e)) if (
isinstance(e, list)
) else indented(1)(repr(e))
) + '\n'
return 'Observation: ' + repr(x) + '\n' + (
either(showProblem)(showDict)(
bindLR(numLR(x))(
lambda n: bindLR(numsLR(ps))(
compose(Right, diversityValues(n))
)
)
)
)
return go
# ------------------ GENERIC FUNCTIONS -------------------
# Left :: a -> Either a b
def Left(x):
'''Constructor for an empty Either (option type) value
with an associated string.
'''
return {'type': 'Either', 'Right': None, 'Left': x}
# Right :: b -> Either a b
def Right(x):
'''Constructor for a populated Either (option type) value'''
return {'type': 'Either', 'Left': None, 'Right': x}
# bindLR (>>=) :: Either a -> (a -> Either b) -> Either b
def bindLR(m):
'''Either monad injection operator.
Two computations sequentially composed,
with any value produced by the first
passed as an argument to the second.
'''
def go(mf):
return (
mf(m.get('Right')) if None is m.get('Left') else m
)
return go
# compose :: ((a -> a), ...) -> (a -> a)
def compose(*fs):
'''Composition, from right to left,
of a series of functions.
'''
def go(f, g):
def fg(x):
return f(g(x))
return fg
return reduce(go, fs, identity)
# concatMap :: (a -> [b]) -> [a] -> [b]
def concatMap(f):
'''A concatenated list over which a function has been mapped.
The list monad can be derived by using a function f which
wraps its output in a list,
(using an empty list to represent computational failure).
'''
def go(xs):
return chain.from_iterable(map(f, xs))
return go
# either :: (a -> c) -> (b -> c) -> Either a b -> c
def either(fl):
'''The application of fl to e if e is a Left value,
or the application of fr to e if e is a Right value.
'''
return lambda fr: lambda e: fl(e['Left']) if (
None is e['Right']
) else fr(e['Right'])
# identity :: a -> a
def identity(x):
'''The identity function.'''
return x
# indented :: Int -> String -> String
def indented(n):
'''String indented by n multiples
of four spaces.
'''
return lambda s: (4 * ' ' * n) + s
# mean :: [Num] -> Float
def mean(xs):
'''Arithmetic mean of a list
of numeric values.
'''
return sum(xs) / float(len(xs))
# numLR :: a -> Either String Num
def numLR(x):
'''Either Right x if x is a float or int,
or a Left explanatory message.'''
return Right(x) if (
isinstance(x, (float, int))
) else Left(
'Expected number, saw: ' + (
str(type(x)) + ' ' + repr(x)
)
)
# numsLR :: [a] -> Either String [Num]
def numsLR(xs):
'''Either Right xs if all xs are float or int,
or a Left explanatory message.'''
def go(ns):
ls, rs = partitionEithers(map(numLR, ns))
return Left(ls) if ls else Right(rs)
return bindLR(
Right(xs) if (
bool(xs) and isinstance(xs, list)
) else Left(
'Expected a non-empty list, saw: ' + (
str(type(xs)) + ' ' + repr(xs)
)
)
)(go)
# partitionEithers :: [Either a b] -> ([a],[b])
def partitionEithers(lrs):
'''A list of Either values partitioned into a tuple
of two lists, with all Left elements extracted
into the first list, and Right elements
extracted into the second list.
'''
def go(a, x):
ls, rs = a
r = x.get('Right')
return (ls + [x.get('Left')], rs) if None is r else (
ls, rs + [r]
)
return reduce(go, lrs, ([], []))
# showList :: [a] -> String
def showList(xs):
'''Compact string representation of a list'''
return '[' + ','.join(str(x) for x in xs) + ']'
# showPrecision :: Int -> Float -> String
def showPrecision(n):
'''A string showing a floating point number
at a given degree of precision.'''
def go(x):
return str(round(x, n))
return go
# unlines :: [String] -> String
def unlines(xs):
'''A single string derived by the intercalation
of a list of strings with the newline character.'''
return '\n'.join(xs)
# MAIN ---
if __name__ == '__main__':
main()

31
Task/Diversity-prediction-theorem/QuickBASIC/diversity-prediction-theorem.basic Normal file
View file

@ -0,0 +1,31 @@
REM Diversity prediction theorem
DIM Estimates(1, 4)
FOR I% = 0 TO 1
J% = 0
READ Estimates(I%, J%)
WHILE Estimates(I%, J%) <> 0!
J% = J% + 1
READ Estimates(I%, J%)
WEND
NEXT I%
DATA 48.0, 47.0, 51.0, 0.0
DATA 48.0, 47.0, 51.0, 42.0, 0.0
TrueVal = 49!
FOR I% = 0 TO 1
Sum = 0!: J% = 0
WHILE Estimates(I%, J%) <> 0!
Sum = Sum + (Estimates(I%, J%) - TrueVal) ^ 2: J% = J% + 1
WEND
AvgErr = Sum / J%
PRINT USING "Average error : ##.###"; AvgErr
Sum = 0!: J% = 0
WHILE Estimates(I%, J%) <> 0!
Sum = Sum + Estimates(I%, J%): J% = J% + 1
WEND
Avg = Sum / J%
CrowdErr = (TrueVal - Avg) ^ 2
PRINT USING "Crowd error : ##.###"; CrowdErr
PRINT USING "Diversity : ##.###"; AvgErr - CrowdErr
PRINT
NEXT I%
END

11
Task/Diversity-prediction-theorem/R/diversity-prediction-theorem.r Normal file
View file

@ -0,0 +1,11 @@
diversityStats <- function(trueValue, estimates)
{
collectivePrediction <- mean(estimates)
data.frame("True Value" = trueValue,
as.list(setNames(estimates, paste("Guess", seq_along(estimates)))), #Guesses, each with a title and column.
"Average Error" = mean((trueValue - estimates)^2),
"Crowd Error" = (trueValue - collectivePrediction)^2,
"Prediction Diversity" = mean((estimates - collectivePrediction)^2))
}
diversityStats(49, c(48, 47, 51))
diversityStats(49, c(48, 47, 51, 42))

31
Task/Diversity-prediction-theorem/REXX/diversity-prediction-theorem-1.rexx Normal file
View file

@ -0,0 +1,31 @@
/* REXX */
Numeric Digits 20
Call diversityTheorem 49,'48 47 51'
Say '--------------------------------------'
Call diversityTheorem 49,'48 47 51 42'
Exit
diversityTheorem:
Parse Arg truth,list
average=average(list)
Say 'average-error='averageSquareDiff(truth,list)
Say 'crowd-error='||(truth-average)**2
Say 'diversity='averageSquareDiff(average,list)
Return
average: Procedure
Parse Arg list
res=0
Do i=1 To words(list)
res=res+word(list,i) /* accumulate list elements */
End
Return res/words(list) /* return the average */
averageSquareDiff: Procedure
Parse Arg a,list
res=0
Do i=1 To words(list)
x=word(list,i)
res=res+(x-a)**2 /* accumulate square of differences */
End
Return res/words(list) /* return the average */

15
Task/Diversity-prediction-theorem/REXX/diversity-prediction-theorem-2.rexx Normal file
View file

@ -0,0 +1,15 @@
/*REXX program calculates the average error, crowd error, and prediction diversity. */
numeric digits 50 /*use precision of fifty decimal digits*/
call diversity 49, 48 47 51 /*true value and the crowd predictions.*/
call diversity 49, 48 47 51 42 /* " " " " " " */
exit 0 /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
avg: $= 0; do j=1 for #; $= $ + word(x, j) ; end; return $ / #
avgSD: $= 0; arg y; do j=1 for #; $= $ + (word(x, j) - y)**2; end; return $ / #
/*──────────────────────────────────────────────────────────────────────────────────────*/
diversity: parse arg true, x; #= words(x); a= avg() /*get args; count #est; avg*/
say ' the true value: ' true copies("═", 20) "crowd estimates: " x
say ' the average error: ' format( avgSD(true) , , 6) / 1
say ' the crowd error: ' format( (true-a) **2, , 6) / 1
say 'prediction diversity: ' format( avgSD(a) , , 6) / 1; say; say
return /* └─── show 6 dec. digs.*/

15
Task/Diversity-prediction-theorem/Racket/diversity-prediction-theorem.rkt Normal file
View file

@ -0,0 +1,15 @@
#lang racket
(define (mean l)
(/ (apply + l) (length l)))
(define (diversity-theorem truth predictions)
(define μ (mean predictions))
(define (avg-sq-diff a)
(mean (map (λ (p) (sqr (- p a))) predictions)))
(hash 'average-error (avg-sq-diff truth)
'crowd-error (sqr (- truth μ))
'diversity (avg-sq-diff μ)))
(println (diversity-theorem 49 '(48 47 51)))
(println (diversity-theorem 49 '(48 47 51 42)))

20
Task/Diversity-prediction-theorem/Raku/diversity-prediction-theorem.raku Normal file
View file

@ -0,0 +1,20 @@
sub diversity-calc($truth, @pred) {
my $ae = avg-error($truth, @pred); # average individual error
my $cp = ([+] @pred)/+@pred; # collective prediction
my $ce = ($cp - $truth)**2; # collective error
my $pd = avg-error($cp, @pred); # prediction diversity
return $ae, $ce, $pd;
}
sub avg-error ($m, @v) { ([+] (@v X- $m) X**2) / +@v }
sub diversity-format (@stats) {
gather {
for <average-error crowd-error diversity> Z @stats -> ($label,$value) {
take $label.fmt("%13s") ~ ':' ~ $value.fmt("%7.3f");
}
}
}
.say for diversity-format diversity-calc(49, <48 47 51>);
.say for diversity-format diversity-calc(49, <48 47 51 42>);

13
Task/Diversity-prediction-theorem/Ruby/diversity-prediction-theorem.rb Normal file
View file

@ -0,0 +1,13 @@
def mean(a) = a.sum(0.0) / a.size
def mean_square_diff(a, predictions) = mean(predictions.map { |x| square(x - a)**2 })
def diversity_theorem(truth, predictions)
average = mean(predictions)
puts "truth: #{truth}, predictions #{predictions}",
"average-error: #{mean_square_diff(truth, predictions)}",
"crowd-error: #{(truth - average)**2}",
"diversity: #{mean_square_diff(average, predictions)}",""
end
diversity_theorem(49.0, [48.0, 47.0, 51.0])
diversity_theorem(49.0, [48.0, 47.0, 51.0, 42.0])

22
Task/Diversity-prediction-theorem/Scala/diversity-prediction-theorem.scala Normal file
View file

@ -0,0 +1,22 @@
object DiversityPredictionTheorem {
def square(d: Double): Double
= d * d
def average(a: Array[Double]): Double
= a.sum / a.length
def averageSquareDiff(d: Double, predictions: Array[Double]): Double
= average(predictions.map(it => square(it - d)))
def diversityTheorem(truth: Double, predictions: Array[Double]): String = {
val avg = average(predictions)
f"average-error : ${averageSquareDiff(truth, predictions)}%6.3f\n" +
f"crowd-error : ${square(truth - avg)}%6.3f\n"+
f"diversity : ${averageSquareDiff(avg, predictions)}%6.3f\n"
}
def main(args: Array[String]): Unit = {
println(diversityTheorem(49.0, Array(48.0, 47.0, 51.0)))
println(diversityTheorem(49.0, Array(48.0, 47.0, 51.0, 42.0)))
}
}

22
Task/Diversity-prediction-theorem/Sidef/diversity-prediction-theorem.sidef Normal file
View file

@ -0,0 +1,22 @@
func avg_error(m, v) {
v.map { (_ - m)**2 }.sum / v.len
}
func diversity_calc(truth, pred) {
var ae = avg_error(truth, pred)
var cp = pred.sum/pred.len
var ce = (cp - truth)**2
var pd = avg_error(cp, pred)
return [ae, ce, pd]
}
func diversity_format(stats) {
gather {
for t,v in (%w(average-error crowd-error diversity) ~Z stats) {
take(("%13s" % t) + ':' + ('%7.3f' % v))
}
}
}
diversity_format(diversity_calc(49, [48, 47, 51])).each{.say}
diversity_format(diversity_calc(49, [48, 47, 51, 42])).each{.say}

27
Task/Diversity-prediction-theorem/TypeScript/diversity-prediction-theorem.ts Normal file
View file

@ -0,0 +1,27 @@
function sum(array: Array<number>): number {
return array.reduce((a, b) => a + b)
}
function square(x : number) :number {
return x * x
}
function mean(array: Array<number>): number {
return sum(array) / array.length
}
function averageSquareDiff(a: number, predictions: Array<number>): number {
return mean(predictions.map(x => square(x - a)))
}
function diversityTheorem(truth: number, predictions: Array<number>): Object {
const average: number = mean(predictions)
return {
"average-error": averageSquareDiff(truth, predictions),
"crowd-error": square(truth - average),
"diversity": averageSquareDiff(average, predictions)
}
}
console.log(diversityTheorem(49, [48,47,51]))
console.log(diversityTheorem(49, [48,47,51,42]))

23
Task/Diversity-prediction-theorem/Visual-Basic-.NET/diversity-prediction-theorem.vb Normal file
View file

@ -0,0 +1,23 @@
Module Module1
Function Square(x As Double) As Double
Return x * x
End Function
Function AverageSquareDiff(a As Double, predictions As IEnumerable(Of Double)) As Double
Return predictions.Select(Function(x) Square(x - a)).Average()
End Function
Sub DiversityTheorem(truth As Double, predictions As IEnumerable(Of Double))
Dim average = predictions.Average()
Console.WriteLine("average-error: {0}", AverageSquareDiff(truth, predictions))
Console.WriteLine("crowd-error: {0}", Square(truth - average))
Console.WriteLine("diversity: {0}", AverageSquareDiff(average, predictions))
End Sub
Sub Main()
DiversityTheorem(49.0, {48.0, 47.0, 51.0})
DiversityTheorem(49.0, {48.0, 47.0, 51.0, 42.0})
End Sub
End Module

24
Task/Diversity-prediction-theorem/Wren/diversity-prediction-theorem.wren Normal file
View file

@ -0,0 +1,24 @@
import "/fmt" for Fmt
var averageSquareDiff = Fn.new { |f, preds|
var av = 0
for (pred in preds) av = av + (pred-f)*(pred-f)
return av/preds.count
}
var diversityTheorem = Fn.new { |truth, preds|
var av = (preds.reduce { |sum, pred| sum + pred }) / preds.count
var avErr = averageSquareDiff.call(truth, preds)
var crowdErr = (truth-av) * (truth-av)
var div = averageSquareDiff.call(av, preds)
return [avErr, crowdErr, div]
}
var predsList = [ [48, 47, 51], [48, 47, 51, 42] ]
var truth = 49
for (preds in predsList) {
var res = diversityTheorem.call(truth, preds)
Fmt.print("Average-error : $6.3f", res[0])
Fmt.print("Crowd-error : $6.3f", res[1])
Fmt.print("Diversity : $6.3f\n", res[2])
}

23
Task/Diversity-prediction-theorem/XPL0/diversity-prediction-theorem.xpl0 Normal file
View file

@ -0,0 +1,23 @@
real Estimates, TrueVal, AvgErr, CrowdErr, Sum, Avg;
int I, J;
[Estimates:= [ [48., 47., 51., 0.], [48., 47., 51., 42., 0.] ];
TrueVal:= 49.;
Format(2, 3);
for I:= 0 to 1 do
[Sum:= 0.; J:= 0;
while Estimates(I,J) # 0. do
[Sum:= Sum + sq(Estimates(I,J) - TrueVal); J:= J+1];
AvgErr:= Sum/float(J);
Text(0, "Average error : "); RlOut(0, AvgErr); CrLf(0);
Sum:= 0.; J:= 0;
while Estimates(I,J) # 0. do
[Sum:= Sum + Estimates(I,J); J:= J+1];
Avg:= Sum/float(J);
CrowdErr:= sq(TrueVal-Avg);
Text(0, "Crowd error : "); RlOut(0, CrowdErr); CrLf(0);
Text(0, "Diversity : "); RlOut(0, AvgErr-CrowdErr); CrLf(0);
CrLf(0);
];
]

12
Task/Diversity-prediction-theorem/Zkl/diversity-prediction-theorem-1.zkl Normal file
View file

@ -0,0 +1,12 @@
fcn avgError(m,v){ v.apply('wrap(n){ (n - m).pow(2) }).sum(0.0)/v.len() }
fcn diversityCalc(truth,pred){ //(Float,List of Float)
ae,cp := avgError(truth,pred), pred.sum(0.0)/pred.len();
ce,pd := (cp - truth).pow(2), avgError(cp, pred);
return(ae,ce,pd)
}
fcn diversityFormat(stats){ // ( (averageError,crowdError,diversity) )
T("average-error","crowd-error","diversity").zip(stats)
.pump(String,Void.Xplode,"%13s :%7.3f\n".fmt)
}

2
Task/Diversity-prediction-theorem/Zkl/diversity-prediction-theorem-2.zkl Normal file
View file

@ -0,0 +1,2 @@
diversityCalc(49.0, T(48.0,47.0,51.0)) : diversityFormat(_).println();
diversityCalc(49.0, T(48.0,47.0,51.0,42.0)) : diversityFormat(_).println();