1
|
package vldc.aswi.utils;
|
2
|
|
3
|
import vldc.aswi.model.table.*;
|
4
|
import vldc.aswi.model.table.contingencyTable.ContingencyTableRow;
|
5
|
import vldc.aswi.model.table.contingencyTable.ContingencyTableRowCell;
|
6
|
|
7
|
import java.text.DecimalFormat;
|
8
|
import java.util.ArrayList;
|
9
|
import java.util.List;
|
10
|
import java.util.Map;
|
11
|
import java.util.concurrent.TimeUnit;
|
12
|
|
13
|
/**
|
14
|
* Class for converting classes.
|
15
|
*/
|
16
|
public class Converter {
|
17
|
|
18
|
private final Map<String, TableColumn> tableColumns;
|
19
|
private final List<NameUserName> rowNames;
|
20
|
private final List<NameUserName> columnNames;
|
21
|
private final List<ValueFunction> valueFunctions;
|
22
|
|
23
|
private List<Node> columnNodes;
|
24
|
private final DecimalFormat decimalFormat = new DecimalFormat("0.###");
|
25
|
|
26
|
public Converter(Map<String, TableColumn> tableColumns, List<NameUserName> rowNames, List<NameUserName> columnNames,
|
27
|
List<ValueFunction> valueFunctions) {
|
28
|
this.tableColumns = tableColumns;
|
29
|
this.rowNames = rowNames;
|
30
|
this.columnNames = columnNames;
|
31
|
this.valueFunctions = valueFunctions;
|
32
|
}
|
33
|
|
34
|
/**
|
35
|
* Convert Map of TableColumns into list of ContingencyTableRow.
|
36
|
* @return List of ContingencyTableRow.
|
37
|
*/
|
38
|
public List<ContingencyTableRow> convertTableColumnsToContingencyTableRows() {
|
39
|
long startTime = System.nanoTime();
|
40
|
List<ContingencyTableRow> contingencyTableRows = new ArrayList<>();
|
41
|
|
42
|
long startTime2 = System.nanoTime();
|
43
|
List<ContingencyTableRow> headerRows = createHeaderOnlyRows();
|
44
|
long stopTime2 = System.nanoTime();
|
45
|
System.out.println("Headers:" + TimeUnit.MILLISECONDS.convert((stopTime2 - startTime2), TimeUnit.NANOSECONDS));
|
46
|
|
47
|
long startTime3 = System.nanoTime();
|
48
|
List<ContingencyTableRow> dataRows = createDataRows();
|
49
|
long stopTime3 = System.nanoTime();
|
50
|
System.out.println("Rows:" + TimeUnit.MILLISECONDS.convert((stopTime3 - startTime3), TimeUnit.NANOSECONDS));
|
51
|
|
52
|
contingencyTableRows.addAll(headerRows);
|
53
|
contingencyTableRows.addAll(dataRows);
|
54
|
|
55
|
long stopTime = System.nanoTime();
|
56
|
System.out.println("Converter:" + TimeUnit.SECONDS.convert((stopTime - startTime), TimeUnit.NANOSECONDS) + "s");
|
57
|
|
58
|
return contingencyTableRows;
|
59
|
}
|
60
|
|
61
|
/**
|
62
|
* Generates header rows.
|
63
|
* @return list of contingency table rows
|
64
|
*/
|
65
|
private List<ContingencyTableRow> createHeaderOnlyRows() {
|
66
|
List<List<String>> values = new ArrayList<>();
|
67
|
columnNodes = new ArrayList<>();
|
68
|
List<ContingencyTableRow> headerRows = new ArrayList<>();
|
69
|
|
70
|
List<String> valueOptions = new ArrayList<>();
|
71
|
for (ValueFunction valueFunction : valueFunctions) {
|
72
|
valueOptions.add(valueFunction.getFunction() + " z " + valueFunction.getName());
|
73
|
}
|
74
|
values.add(valueOptions);
|
75
|
headerRows.add(new ContingencyTableRow(true, 0));
|
76
|
|
77
|
for(NameUserName nameUserName : columnNames) {
|
78
|
TableColumn column = tableColumns.get(nameUserName.getName());
|
79
|
values.add(getOriginalValuesFromList(column.getValues()));
|
80
|
headerRows.add(new ContingencyTableRow(true, 0));
|
81
|
}
|
82
|
|
83
|
for (int i = 0; i < values.size(); i++) {
|
84
|
int colSpan = 1;
|
85
|
for (int j = values.size() - 1; j > i; j--) {
|
86
|
if (values.size() - 1 == j) {
|
87
|
colSpan = values.get(j).size();
|
88
|
}
|
89
|
else {
|
90
|
colSpan = (colSpan + 1) * values.get(j).size();
|
91
|
}
|
92
|
}
|
93
|
int loopCount = 1;
|
94
|
for (int k = 0; k < i; k++) {
|
95
|
loopCount = loopCount * values.get(k).size();
|
96
|
}
|
97
|
headerRows.get(i).addTableRowCell(new ContingencyTableRowCell("", 1));
|
98
|
for (int k = 0; k < loopCount; k++) {
|
99
|
for (String value : values.get(i)) {
|
100
|
headerRows.get(i).addTableRowCell(new ContingencyTableRowCell(value, colSpan));
|
101
|
if (i != values.size() - 1 && i != 0) {
|
102
|
headerRows.get(i).addTableRowCell(new ContingencyTableRowCell(value + " Celkem", 1));
|
103
|
}
|
104
|
}
|
105
|
|
106
|
for (int l = 0; l < i - 1; l++) {
|
107
|
headerRows.get(i).addTableRowCell(new ContingencyTableRowCell("", 1));
|
108
|
}
|
109
|
}
|
110
|
for(ValueFunction valueFunction: valueFunctions) {
|
111
|
if (i == 0) {
|
112
|
headerRows.get(i).addTableRowCell(new ContingencyTableRowCell("Celkový " + valueFunction.getFunction() +
|
113
|
" z " + valueFunction.getName(), 1));
|
114
|
} else {
|
115
|
headerRows.get(i).addTableRowCell(new ContingencyTableRowCell("", 1));
|
116
|
}
|
117
|
}
|
118
|
}
|
119
|
|
120
|
long startTime = System.nanoTime();
|
121
|
values.remove(0);
|
122
|
Node node = new Node();
|
123
|
generateColumns(0, values, columnNodes, node);
|
124
|
long stopTime = System.nanoTime();
|
125
|
System.out.println("Colums list:" + TimeUnit.MILLISECONDS.convert((stopTime - startTime), TimeUnit.NANOSECONDS));
|
126
|
|
127
|
return headerRows;
|
128
|
}
|
129
|
|
130
|
/**
|
131
|
* Gets original values of a given list.
|
132
|
* @param list list from which original values should be taken
|
133
|
* @return list of original values
|
134
|
*/
|
135
|
private List<String> getOriginalValuesFromList(List<String> list) {
|
136
|
List<String> origList = new ArrayList<>();
|
137
|
|
138
|
for (String string : list) {
|
139
|
if (origList.stream().noneMatch(s -> s.equals(string))) {
|
140
|
origList.add(string);
|
141
|
}
|
142
|
}
|
143
|
|
144
|
return origList;
|
145
|
}
|
146
|
|
147
|
/**
|
148
|
* Creates data rows.
|
149
|
* @return list of contingency table rows
|
150
|
*/
|
151
|
private List<ContingencyTableRow> createDataRows() {
|
152
|
List<ContingencyTableRow> dataRows = new ArrayList<>();
|
153
|
List<Node> rowNodes = new ArrayList<>();
|
154
|
List<List<String>> values = new ArrayList<>();
|
155
|
for(NameUserName nameUserName : rowNames) {
|
156
|
TableColumn column = tableColumns.get(nameUserName.getName());
|
157
|
values.add(getOriginalValuesFromList(column.getValues()));
|
158
|
}
|
159
|
|
160
|
long startTime = System.nanoTime();
|
161
|
Node node = new Node();
|
162
|
generateRows(dataRows, 0, values, rowNodes, node);
|
163
|
long stopTime = System.nanoTime();
|
164
|
System.out.println("Rows List:" + TimeUnit.MILLISECONDS.convert((stopTime - startTime), TimeUnit.NANOSECONDS));
|
165
|
|
166
|
boolean[] usableColumns = new boolean[(valueFunctions.size() * columnNodes.size())];
|
167
|
|
168
|
List<ContingencyTableRow> rowsToBeRemoved = new ArrayList<>();
|
169
|
for (int i = 0; i < dataRows.size(); i++) {
|
170
|
if (!fillRowWithData(dataRows.get(i), rowNodes.get(i), usableColumns)) {
|
171
|
rowsToBeRemoved.add(dataRows.get(i));
|
172
|
}
|
173
|
}
|
174
|
|
175
|
dataRows.removeAll(rowsToBeRemoved);
|
176
|
|
177
|
// for (ContingencyTableRow row : dataRows) {
|
178
|
// List<ContingencyTableRowCell> cellsToRemove = new ArrayList<>();
|
179
|
// for (int i = 1; i < usableColumns.length; i++) {
|
180
|
// if (!usableColumns[i - 1]) {
|
181
|
// cellsToRemove.add(row.getCells().get(i));
|
182
|
// }
|
183
|
// }
|
184
|
// row.getCells().removeAll(cellsToRemove);
|
185
|
// cellsToRemove.clear();
|
186
|
// }
|
187
|
|
188
|
ContingencyTableRow finalRow = new ContingencyTableRow(false, 0);
|
189
|
finalRow.addTableRowCell(new ContingencyTableRowCell("Celkem", 1));
|
190
|
|
191
|
int columnIndex = 0;
|
192
|
List<ContingencyTableRowCell> valueCells = new ArrayList<>();
|
193
|
for (ValueFunction valueFunction : valueFunctions) {
|
194
|
for (Node columnNode : columnNodes) {
|
195
|
if (true) {
|
196
|
finalRow.addTableRowCell(generateFilledCell(valueFunction.getFunction(), columnNode.getTotalResult(), columnNode.getTotalResultSum(),
|
197
|
columnNode.getTotalMin(), columnNode.getTotalMax(), columnNode.getTotalResultAvgSum(),
|
198
|
columnNode.getTotalResultAvg()));
|
199
|
columnIndex++;
|
200
|
}
|
201
|
}
|
202
|
valueCells.add(generateFilledCell(valueFunction.getFunction(), valueFunction.getTotalResult(), valueFunction.getTotalResultSum(),
|
203
|
valueFunction.getTotalMin(), valueFunction.getTotalMax(), valueFunction.getTotalResultAvgSum(),
|
204
|
valueFunction.getTotalResultAvg()));
|
205
|
}
|
206
|
|
207
|
finalRow.addTableRowCells(valueCells);
|
208
|
|
209
|
dataRows.add(finalRow);
|
210
|
|
211
|
return dataRows;
|
212
|
}
|
213
|
|
214
|
/**
|
215
|
* Recursively generates all possible row combinations, sorted as in contingency table.
|
216
|
* @param rows list of sorted contingency table rows
|
217
|
* @param index index in the values list
|
218
|
* @param values list of lists of values of each query row
|
219
|
* @param rowNodes list of row nodes
|
220
|
* @param prevNode parent node of the nodes
|
221
|
*/
|
222
|
private void generateRows(List<ContingencyTableRow> rows, int index, List<List<String>> values, List<Node> rowNodes,
|
223
|
Node prevNode) {
|
224
|
if (index < values.size()) {
|
225
|
List<String> list = values.get(index);
|
226
|
for (String s : list) {
|
227
|
StringBuilder levelString = new StringBuilder();
|
228
|
for (int i = 0; i < index; i++) {
|
229
|
levelString.append("----");
|
230
|
}
|
231
|
levelString.append(s);
|
232
|
ContingencyTableRow row = new ContingencyTableRow(false, index);
|
233
|
row.addTableRowCell(new ContingencyTableRowCell(levelString.toString(), 1));
|
234
|
rows.add(row);
|
235
|
Node node = new Node(prevNode);
|
236
|
node.getValues().add(s);
|
237
|
rowNodes.add(node);
|
238
|
int newIndex = index + 1;
|
239
|
generateRows(rows, newIndex, values, rowNodes, node);
|
240
|
}
|
241
|
}
|
242
|
}
|
243
|
|
244
|
/**
|
245
|
* Recursively generates all possible column combinations, sorted as in contingency table.
|
246
|
* @param index index in the values list
|
247
|
* @param values list of lists of values of each query row
|
248
|
* @param columnNodes list of column nodes
|
249
|
* @param prevNode parent node of the nodes
|
250
|
*/
|
251
|
private void generateColumns(int index, List<List<String>> values, List<Node> columnNodes, Node prevNode) {
|
252
|
if (index < values.size()) {
|
253
|
List<String> list = values.get(index);
|
254
|
for (String s : list) {
|
255
|
Node node = new Node(prevNode);
|
256
|
node.getValues().add(s);
|
257
|
int newIndex = index + 1;
|
258
|
generateColumns(newIndex, values, columnNodes, node);
|
259
|
columnNodes.add(node);
|
260
|
}
|
261
|
}
|
262
|
}
|
263
|
|
264
|
/**
|
265
|
* Fills each data row with data.
|
266
|
* @param row row to ne filled with data
|
267
|
* @param node node of the row
|
268
|
*/
|
269
|
private boolean fillRowWithData(ContingencyTableRow row, Node node, boolean[] usableColumns) {
|
270
|
if (valueFunctions.size() == 0) {
|
271
|
return true;
|
272
|
}
|
273
|
|
274
|
boolean isSingleValueRow = false;
|
275
|
|
276
|
if (node.getValues().size() <= 1) {
|
277
|
isSingleValueRow = true;
|
278
|
}
|
279
|
|
280
|
boolean isRowUsable = false;
|
281
|
if (columnNodes.size() == 0) {
|
282
|
columnNodes.add(new Node());
|
283
|
}
|
284
|
|
285
|
List<Integer> usableIDs = getUsableIDs(node);
|
286
|
|
287
|
DoubleWrapper[] totals = new DoubleWrapper[valueFunctions.size()];
|
288
|
initializeWrapperField(totals);
|
289
|
|
290
|
DoubleWrapper[] totalsAvgSum = new DoubleWrapper[valueFunctions.size()];
|
291
|
initializeWrapperField(totalsAvgSum);
|
292
|
|
293
|
boolean[] isFilledValueCells = new boolean[valueFunctions.size()];
|
294
|
int columnIndex = 0;
|
295
|
//hodnota
|
296
|
for (int v = 0; v < valueFunctions.size(); v++) {
|
297
|
BooleanWrapper isFirstMinMaxTotal = new BooleanWrapper(true);
|
298
|
ValueFunction valueFunction = valueFunctions.get(v);
|
299
|
//sloupec v kont. tabulce
|
300
|
for (Node columnNode : columnNodes) {
|
301
|
DoubleWrapper result = new DoubleWrapper(0);
|
302
|
DoubleWrapper resultAvgSum = new DoubleWrapper(0);
|
303
|
BooleanWrapper isFirstMinMax = new BooleanWrapper(true);
|
304
|
boolean isFilledCell = false;
|
305
|
// radek v orig. tabulce
|
306
|
for (Integer usableID : usableIDs) {
|
307
|
boolean isUsable = true;
|
308
|
int j;
|
309
|
// zvoleny sloupec ze sloupcu, ziska hodnoty z pouzitelne radky danych sloupcu originalni tabulky a
|
310
|
// pokud se vsechny rovnaji hodnotam, ktere jsou ulozeny v hodnotach uzlu na pozici vybraneho
|
311
|
// sloupce, je kommbinace pouzitelna k vypoctum
|
312
|
for (j = 0; j < columnNode.getValues().size(); j++) {
|
313
|
if (!tableColumns.get(columnNames.get(j).getName()).getValues().get(usableID).equals(columnNode.getValues().get(j))) {
|
314
|
isUsable = false;
|
315
|
break;
|
316
|
}
|
317
|
}
|
318
|
// zvoleny sloupec z hodnot
|
319
|
if (tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID) == null) {
|
320
|
isUsable = false;
|
321
|
}
|
322
|
|
323
|
usableColumns[columnIndex] = isUsable;
|
324
|
|
325
|
if (isUsable) { // pokud lze hodnotu pouzit, prunik vsech hodnot sedi (ma nejakou hodnotu)
|
326
|
isRowUsable = true;
|
327
|
isFilledCell = true;
|
328
|
computeValues(valueFunction, result, resultAvgSum, columnNode, isFirstMinMax,
|
329
|
usableID, false, isSingleValueRow);
|
330
|
if (j <= 1) {
|
331
|
isFilledValueCells[v] = true;
|
332
|
computeValues(valueFunction, totals[v], totalsAvgSum[v], null, isFirstMinMaxTotal,
|
333
|
usableID, true, isSingleValueRow);
|
334
|
}
|
335
|
}
|
336
|
}
|
337
|
if (!isFilledCell) {
|
338
|
row.addTableRowCell(new ContingencyTableRowCell("", 0));
|
339
|
}
|
340
|
else {
|
341
|
row.addTableRowCell(generateFilledCell(valueFunction.getFunction(), result.getValue(), result.getValue(), result.getValue(),
|
342
|
result.getValue(), resultAvgSum.getValue(), result.getValue()));
|
343
|
}
|
344
|
columnIndex++;
|
345
|
}
|
346
|
}
|
347
|
for (int i = 0; i < valueFunctions.size(); i++) {
|
348
|
if (!isFilledValueCells[i]) {
|
349
|
row.addTableRowCell(new ContingencyTableRowCell("", 0));
|
350
|
}
|
351
|
else {
|
352
|
row.addTableRowCell(generateFilledCell(valueFunctions.get(i).getFunction(), totals[i].getValue(), totals[i].getValue(),
|
353
|
totals[i].getValue(), totals[i].getValue(), totalsAvgSum[i].getValue(), totals[i].getValue()));
|
354
|
}
|
355
|
}
|
356
|
|
357
|
return isRowUsable;
|
358
|
}
|
359
|
|
360
|
/**
|
361
|
* Gets a list of IDs of the query rows that fit the contingency table row settings.
|
362
|
* @param node node of the row
|
363
|
* @return list of usable IDs
|
364
|
*/
|
365
|
private List<Integer> getUsableIDs(Node node) {
|
366
|
List<Integer> ids = new ArrayList<>();
|
367
|
|
368
|
for (int i = 0; i < tableColumns.get(rowNames.get(0).getName()).getValues().size(); i++) {
|
369
|
boolean isUsable = true;
|
370
|
for (int j = 0; j < node.getValues().size(); j++) {
|
371
|
if (!tableColumns.get(rowNames.get(j).getName()).getValues().get(i).equals(node.getValues().get(j))) {
|
372
|
isUsable = false;
|
373
|
break;
|
374
|
}
|
375
|
}
|
376
|
if (isUsable) {
|
377
|
ids.add(i);
|
378
|
}
|
379
|
}
|
380
|
|
381
|
return ids;
|
382
|
}
|
383
|
|
384
|
private void computeValues(ValueFunction valueFunction, DoubleWrapper result, DoubleWrapper resultAvgSum, Node columnNode,
|
385
|
BooleanWrapper isFirstMinMax, int usableID, boolean isValueTotal, boolean isSingleValueRow) {
|
386
|
switch (valueFunction.getFunction()) {
|
387
|
case "COUNT":
|
388
|
count(valueFunction, result, columnNode, isValueTotal, isSingleValueRow);
|
389
|
break;
|
390
|
case "SUM":
|
391
|
sum(valueFunction, result, columnNode, usableID, isValueTotal, isSingleValueRow);
|
392
|
break;
|
393
|
case "MIN":
|
394
|
min(valueFunction, result, columnNode, isFirstMinMax, usableID, isValueTotal, isSingleValueRow);
|
395
|
break;
|
396
|
case "MAX":
|
397
|
max(valueFunction, result, columnNode, isFirstMinMax, usableID, isValueTotal, isSingleValueRow);
|
398
|
break;
|
399
|
case "AVG":
|
400
|
average(valueFunction, result, resultAvgSum, columnNode, usableID, isValueTotal, isSingleValueRow);
|
401
|
break;
|
402
|
}
|
403
|
}
|
404
|
|
405
|
private ContingencyTableRowCell generateFilledCell(String function, double totalResult, double totalResultSum,
|
406
|
double totalMin, double totalMax, double totalResultAvgSum,
|
407
|
double totalResultAvg) {
|
408
|
ContingencyTableRowCell cell = null;
|
409
|
switch (function) {
|
410
|
case "COUNT":
|
411
|
cell = new ContingencyTableRowCell(decimalFormat.format(totalResult), 1);
|
412
|
break;
|
413
|
case "SUM":
|
414
|
cell = new ContingencyTableRowCell(decimalFormat.format(totalResultSum), 1);
|
415
|
break;
|
416
|
case "MIN":
|
417
|
cell = new ContingencyTableRowCell(decimalFormat.format(totalMin), 1);
|
418
|
break;
|
419
|
case "MAX":
|
420
|
cell = new ContingencyTableRowCell(decimalFormat.format(totalMax), 1);
|
421
|
break;
|
422
|
case "AVG":
|
423
|
if (totalResultAvg == 0) {
|
424
|
cell = new ContingencyTableRowCell("!!Dělení nulou!!", 0);
|
425
|
} else {
|
426
|
cell = new ContingencyTableRowCell(decimalFormat.format(totalResultAvgSum / totalResultAvg), 0);
|
427
|
}
|
428
|
break;
|
429
|
}
|
430
|
|
431
|
return cell;
|
432
|
}
|
433
|
|
434
|
private void initializeWrapperField(DoubleWrapper[] field) {
|
435
|
for (int i = 0; i < field.length; i++) {
|
436
|
field[i] = new DoubleWrapper(0);
|
437
|
}
|
438
|
}
|
439
|
|
440
|
private void count(ValueFunction valueFunction, DoubleWrapper result, Node columnNode, boolean isValueTotal,
|
441
|
boolean isSingleValueRow) {
|
442
|
result.setValue(result.getValue() + 1);
|
443
|
if (columnNode != null && isSingleValueRow) {
|
444
|
columnNode.setTotalResult(columnNode.getTotalResult() + 1);
|
445
|
}
|
446
|
if (isValueTotal && isSingleValueRow) {
|
447
|
valueFunction.setTotalResult(valueFunction.getTotalResult() + 1);
|
448
|
}
|
449
|
}
|
450
|
|
451
|
private void sum(ValueFunction valueFunction, DoubleWrapper result, Node columnNode, int usableID, boolean isValueTotal,
|
452
|
boolean isSingleValueRow) {
|
453
|
if (valueFunction.getType().equals("Číslo")) {
|
454
|
result.setValue(result.getValue() + Double.parseDouble(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID)));
|
455
|
if (columnNode != null && isSingleValueRow) {
|
456
|
columnNode.setTotalResultSum(columnNode.getTotalResultSum() + Double.parseDouble(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID)));
|
457
|
}
|
458
|
if (isValueTotal && isSingleValueRow) {
|
459
|
valueFunction.setTotalResultSum(valueFunction.getTotalResultSum() + Double.parseDouble(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID)));
|
460
|
}
|
461
|
}
|
462
|
}
|
463
|
|
464
|
private void min(ValueFunction valueFunction, DoubleWrapper result, Node columnNode, BooleanWrapper isFirstMinMax,
|
465
|
int usableID, boolean isValueTotal, boolean isSingleValueRow) {
|
466
|
if (valueFunction.getType().equals("Číslo")) {
|
467
|
if (isFirstMinMax.isValue()) {
|
468
|
isFirstMinMax.setValue(false);
|
469
|
result.setValue(Double.parseDouble(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID)));
|
470
|
}
|
471
|
else {
|
472
|
result.setValue(Math.min(result.getValue(), Integer.parseInt(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID))));
|
473
|
}
|
474
|
if (columnNode != null && isSingleValueRow) {
|
475
|
if (columnNode.isFirstMin()) {
|
476
|
columnNode.setFirstMin(false);
|
477
|
columnNode.setTotalMin(Double.parseDouble(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID)));
|
478
|
} else {
|
479
|
columnNode.setTotalMin(Math.min(columnNode.getTotalMin(), Integer.parseInt(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID))));
|
480
|
}
|
481
|
}
|
482
|
if (isValueTotal && isSingleValueRow) {
|
483
|
if (valueFunction.isFirstMin()) {
|
484
|
valueFunction.setFirstMin(false);
|
485
|
valueFunction.setTotalMin(Double.parseDouble(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID)));
|
486
|
} else {
|
487
|
valueFunction.setTotalMin(Math.min(valueFunction.getTotalMin(), Integer.parseInt(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID))));
|
488
|
}
|
489
|
}
|
490
|
}
|
491
|
}
|
492
|
|
493
|
private void max(ValueFunction valueFunction, DoubleWrapper result, Node columnNode, BooleanWrapper isFirstMinMax,
|
494
|
int usableID, boolean isValueTotal, boolean isSingleValueRow) {
|
495
|
if (valueFunction.getType().equals("Číslo")) {
|
496
|
if (isFirstMinMax.isValue()) {
|
497
|
isFirstMinMax.setValue(false);
|
498
|
result.setValue(Double.parseDouble(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID)));
|
499
|
}
|
500
|
else {
|
501
|
result.setValue(Math.max(result.getValue(), Integer.parseInt(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID))));
|
502
|
}
|
503
|
if (columnNode != null && isSingleValueRow) {
|
504
|
if (columnNode.isFirstMax()) {
|
505
|
columnNode.setFirstMax(false);
|
506
|
columnNode.setTotalMax(Double.parseDouble(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID)));
|
507
|
} else {
|
508
|
columnNode.setTotalMax(Math.max(columnNode.getTotalMax(), Integer.parseInt(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID))));
|
509
|
}
|
510
|
}
|
511
|
if (isValueTotal && isSingleValueRow) {
|
512
|
if (valueFunction.isFirstMax()) {
|
513
|
valueFunction.setFirstMax(false);
|
514
|
valueFunction.setTotalMax(Double.parseDouble(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID)));
|
515
|
} else {
|
516
|
valueFunction.setTotalMax(Math.max(valueFunction.getTotalMax(), Integer.parseInt(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID))));
|
517
|
}
|
518
|
}
|
519
|
}
|
520
|
}
|
521
|
|
522
|
private void average(ValueFunction valueFunction, DoubleWrapper result, DoubleWrapper resultAvgSum, Node columnNode,
|
523
|
int usableID, boolean isValueTotal, boolean isSingleValueRow) {
|
524
|
if (valueFunction.getType().equals("Číslo")) {
|
525
|
result.setValue(result.getValue() + 1);
|
526
|
resultAvgSum.setValue(resultAvgSum.getValue() + Double.parseDouble(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID)));
|
527
|
if (columnNode != null && isSingleValueRow) {
|
528
|
columnNode.setTotalResultAvg(columnNode.getTotalResultAvg() + 1);
|
529
|
columnNode.setTotalResultAvgSum(columnNode.getTotalResultAvgSum() + Double.parseDouble(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID)));
|
530
|
}
|
531
|
if (isValueTotal && isSingleValueRow) {
|
532
|
valueFunction.setTotalResultAvg(valueFunction.getTotalResultAvg() + 1);
|
533
|
valueFunction.setTotalResultAvgSum(valueFunction.getTotalResultAvgSum() + Double.parseDouble(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID)));
|
534
|
}
|
535
|
}
|
536
|
}
|
537
|
}
|