1 | import { computeMeanDistributions, computeMeanValues } from '../src/interpreter_v2';
|
2 |
|
3 | describe('Interpreter.computeMean', function() {
|
4 | it('Probability distribution', function() {
|
5 | let distributions = [
|
6 | [0.1, 0.5, 0.4],
|
7 | [0.1, 0.5, 0.4]
|
8 | ];
|
9 |
|
10 | let sizes = [1, 1];
|
11 |
|
12 | let expectedSize = 2;
|
13 | let expectedDistribution = [0.1, 0.5, 0.4];
|
14 | let expectedResult = {
|
15 | value: expectedDistribution,
|
16 | size: expectedSize
|
17 | };
|
18 | expect(computeMeanDistributions(distributions, sizes)).to.be.deep.equal(expectedResult);
|
19 |
|
20 | distributions = [
|
21 | [0.1, 0.5, 0.4],
|
22 | [0.1, 0.1, 0.8]
|
23 | ];
|
24 | sizes = [0, 1000];
|
25 |
|
26 | expectedSize = 1000;
|
27 | expectedDistribution = [0.1, 0.1, 0.8];
|
28 | expectedResult = {
|
29 | value: expectedDistribution,
|
30 | size: expectedSize
|
31 | };
|
32 | expect(computeMeanDistributions(distributions, sizes)).to.be.deep.equal(expectedResult);
|
33 |
|
34 | distributions = [
|
35 | [1.0, 0.0, 0.0, 0.0],
|
36 | [0.0, 1.0, 0.0, 0.0],
|
37 | [0.0, 0.0, 1.0, 0.0],
|
38 | [0.0, 0.0, 0.0, 1.0]
|
39 | ];
|
40 |
|
41 | sizes = [20, 40, 30, 10];
|
42 |
|
43 | expectedSize = 100;
|
44 | expectedDistribution = [0.2, 0.4, 0.3, 0.1];
|
45 | expectedResult = {
|
46 | value: expectedDistribution,
|
47 | size: expectedSize
|
48 | };
|
49 | expect(computeMeanDistributions(distributions, sizes)).to.be.deep.equal(expectedResult);
|
50 | });
|
51 |
|
52 | it('Mean distribution', function() {
|
53 | let values = [10., 10.];
|
54 | let sizes = [1, 1];
|
55 |
|
56 | let expectedSize = 2;
|
57 | let expectedValue = 10;
|
58 | let expectedResult = {
|
59 | value: expectedValue,
|
60 | size: expectedSize
|
61 | };
|
62 | expect(computeMeanValues(values, sizes)).to.be.deep.equal(expectedResult);
|
63 |
|
64 | values = [80., 70.];
|
65 | sizes = [0, 1000];
|
66 |
|
67 | expectedSize = 1000;
|
68 | expectedValue = 70;
|
69 | expectedResult = {
|
70 | value: expectedValue,
|
71 | size: expectedSize
|
72 | };
|
73 | expect(computeMeanValues(values, sizes)).to.be.deep.equal(expectedResult);
|
74 |
|
75 | values = [1., 2., 3., 4.];
|
76 | sizes = [1, 1, 1, 1];
|
77 |
|
78 | expectedSize = 4;
|
79 | expectedValue = 2.5;
|
80 | expectedResult = {
|
81 | value: expectedValue,
|
82 | size: expectedSize
|
83 | };
|
84 | expect(computeMeanValues(values, sizes)).to.be.deep.equal(expectedResult);
|
85 |
|
86 | values = [4., 5.];
|
87 | let stds = [1.0, 2.0];
|
88 | sizes = [3, 5];
|
89 |
|
90 | expectedSize = 8;
|
91 | expectedValue = 37.0 / 8.0;
|
92 | let expectedStd = Math.sqrt((18.0 + 15.0 / 8.0) / 7.0);
|
93 | expectedResult = {
|
94 | value: expectedValue,
|
95 | standard_deviation: expectedStd,
|
96 | size: expectedSize
|
97 | };
|
98 | let result = computeMeanValues(values, sizes, stds);
|
99 | expect(result.value).to.be.equal(expectedValue);
|
100 | expect(result.size).to.be.equal(expectedSize);
|
101 | expect(result.standard_deviation).to.be.closeTo(expectedStd, 0.00001);
|
102 |
|
103 | values = [0.0, 5.];
|
104 | stds = [0.0, 2.0];
|
105 | sizes = [0, 5];
|
106 |
|
107 | expectedSize = 5.0;
|
108 | expectedValue = 5.0;
|
109 | expectedStd = 2.0;
|
110 | expectedResult = {
|
111 | value: expectedValue,
|
112 | standard_deviation: expectedStd,
|
113 | size: expectedSize
|
114 | };
|
115 | result = computeMeanValues(values, sizes, stds);
|
116 | expect(result.value).to.be.equal(expectedValue);
|
117 | expect(result.size).to.be.equal(expectedSize);
|
118 | expect(result.standard_deviation).to.be.closeTo(expectedStd, 0.00001);
|
119 |
|
120 | values = [5.0, 0.0];
|
121 | stds = [2.0, 0.0];
|
122 | sizes = [5, 0];
|
123 | result = computeMeanValues(values, sizes, stds);
|
124 | expect(result.value).to.be.equal(expectedValue);
|
125 | expect(result.size).to.be.equal(expectedSize);
|
126 | expect(result.standard_deviation).to.be.closeTo(expectedStd, 0.00001);
|
127 |
|
128 | values = [1.0, 5.];
|
129 | stds = [15.0, 2.0];
|
130 | sizes = [1, 5];
|
131 |
|
132 | expectedSize = 6.0;
|
133 | expectedValue = 26.0 / 6.0;
|
134 | expectedStd = Math.sqrt((16.0 + 80.0 / 6.0) / 5.0);
|
135 | expectedResult = {
|
136 | value: expectedValue,
|
137 | standard_deviation: expectedStd,
|
138 | size: expectedSize
|
139 | };
|
140 | result = computeMeanValues(values, sizes, stds);
|
141 | expect(result.value).to.be.equal(expectedValue);
|
142 | expect(result.size).to.be.equal(expectedSize);
|
143 | expect(result.standard_deviation).to.be.closeTo(expectedStd, 0.00001);
|
144 |
|
145 | values = [0.0, 0.0, 0.0, 0.0, 1.0];
|
146 | stds = [0.0, 0.0, 0.0, 0.0, 2.0];
|
147 | sizes = [0, 0, 0, 0, 20];
|
148 |
|
149 | expectedSize = 20.0;
|
150 | expectedValue = 1.0;
|
151 | expectedStd = 2.0;
|
152 | expectedResult = {
|
153 | value: expectedValue,
|
154 | standard_deviation: expectedStd,
|
155 | size: expectedSize
|
156 | };
|
157 | result = computeMeanValues(values, sizes, stds);
|
158 | expect(result.value).to.be.equal(expectedValue);
|
159 | expect(result.size).to.be.equal(expectedSize);
|
160 | expect(result.standard_deviation).to.be.closeTo(expectedStd, 0.00001);
|
161 | });
|
162 | });
|