37 |
37 |
*/
|
38 |
38 |
public List<ContingencyTableRow> convertTableColumnsToContingencyTableRows() {
|
39 |
39 |
long startTime = System.nanoTime();
|
|
40 |
|
|
41 |
columnNodes = new ArrayList<>();
|
|
42 |
List<List<String>> values = new ArrayList<>();
|
|
43 |
for(NameUserName nameUserName : columnNames) {
|
|
44 |
TableColumn column = tableColumns.get(nameUserName.getName());
|
|
45 |
values.add(getOriginalValuesFromList(column.getValues()));
|
|
46 |
}
|
|
47 |
|
|
48 |
Node startNode = new Node();
|
|
49 |
generateColumns(0, values, columnNodes, startNode);
|
|
50 |
|
40 |
51 |
List<ContingencyTableRow> contingencyTableRows = new ArrayList<>();
|
41 |
52 |
|
42 |
53 |
long startTime2 = System.nanoTime();
|
43 |
|
List<ContingencyTableRow> headerRows = createHeaderOnlyRows();
|
|
54 |
List<ContingencyTableRow> dataRows = createDataRows();
|
44 |
55 |
long stopTime2 = System.nanoTime();
|
45 |
|
System.out.println("Headers:" + TimeUnit.MILLISECONDS.convert((stopTime2 - startTime2), TimeUnit.NANOSECONDS));
|
|
56 |
System.out.println("Rows:" + TimeUnit.MILLISECONDS.convert((stopTime2 - startTime2), TimeUnit.NANOSECONDS));
|
46 |
57 |
|
47 |
58 |
long startTime3 = System.nanoTime();
|
48 |
|
List<ContingencyTableRow> dataRows = createDataRows();
|
|
59 |
for (ContingencyTableRow dataRow : dataRows) {
|
|
60 |
for (int i = 0; i < columnNodes.size(); i++) {
|
|
61 |
if (!columnNodes.get(i).isUsable()) {
|
|
62 |
dataRow.getCells().remove(i + 1);
|
|
63 |
}
|
|
64 |
}
|
|
65 |
}
|
|
66 |
|
|
67 |
columnNodes.removeIf(node -> !node.isUsable());
|
49 |
68 |
long stopTime3 = System.nanoTime();
|
50 |
|
System.out.println("Rows:" + TimeUnit.MILLISECONDS.convert((stopTime3 - startTime3), TimeUnit.NANOSECONDS));
|
|
69 |
System.out.println("Columns remove:" + TimeUnit.MILLISECONDS.convert((stopTime3 - startTime3), TimeUnit.NANOSECONDS));
|
|
70 |
|
|
71 |
long startTime4 = System.nanoTime();
|
|
72 |
List<ContingencyTableRow> headerRows = createHeaderOnlyRows();
|
|
73 |
long stopTime4 = System.nanoTime();
|
|
74 |
System.out.println("Headers:" + TimeUnit.MILLISECONDS.convert((stopTime4 - startTime4), TimeUnit.NANOSECONDS));
|
51 |
75 |
|
52 |
76 |
contingencyTableRows.addAll(headerRows);
|
53 |
77 |
contingencyTableRows.addAll(dataRows);
|
... | ... | |
63 |
87 |
* @return list of contingency table rows
|
64 |
88 |
*/
|
65 |
89 |
private List<ContingencyTableRow> createHeaderOnlyRows() {
|
66 |
|
List<List<String>> values = new ArrayList<>();
|
67 |
|
columnNodes = new ArrayList<>();
|
|
90 |
//columnNodes = new ArrayList<>();
|
68 |
91 |
List<ContingencyTableRow> headerRows = new ArrayList<>();
|
69 |
92 |
|
70 |
|
List<String> valueOptions = new ArrayList<>();
|
71 |
|
for (ValueFunction valueFunction : valueFunctions) {
|
72 |
|
valueOptions.add(valueFunction.getFunction() + " z " + valueFunction.getName());
|
73 |
|
}
|
74 |
|
values.add(valueOptions);
|
|
93 |
// List<String> valueOptions = new ArrayList<>();
|
|
94 |
//
|
|
95 |
// for (ValueFunction valueFunction : valueFunctions) {
|
|
96 |
// if (!valueFunctions.get(0).getType().equals("Seznam")) {
|
|
97 |
// valueOptions.add(valueFunction.getFunction() + " z " + valueFunction.getName());
|
|
98 |
// }
|
|
99 |
// else if (valueFunctions.get(0).getType().equals("Seznam") && columnNames.size() > 0) {
|
|
100 |
// valueOptions.add("NIC z nic");
|
|
101 |
// }
|
|
102 |
// }
|
|
103 |
|
|
104 |
//values.add(valueOptions);
|
75 |
105 |
headerRows.add(new ContingencyTableRow(true, 0));
|
76 |
106 |
|
77 |
|
for(NameUserName nameUserName : columnNames) {
|
78 |
|
TableColumn column = tableColumns.get(nameUserName.getName());
|
79 |
|
values.add(getOriginalValuesFromList(column.getValues()));
|
|
107 |
for (int i = 0; i < columnNames.size(); i++) {
|
|
108 |
//NameUserName ignored = columnNames.get(i);
|
|
109 |
//TableColumn column = tableColumns.get(nameUserName.getName());
|
80 |
110 |
headerRows.add(new ContingencyTableRow(true, 0));
|
81 |
111 |
}
|
82 |
112 |
|
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 |
|
}
|
|
113 |
if (valueFunctions.get(0).getType().equals("Seznam")) {
|
|
114 |
headerRows.get(0).addTableRowCell(new ContingencyTableRowCell("Seznam", 1));
|
|
115 |
return headerRows;
|
|
116 |
}
|
|
117 |
|
|
118 |
for (int i = 0; i < headerRows.size(); i++) {
|
|
119 |
ContingencyTableRow headerRow = headerRows.get(i);
|
|
120 |
|
|
121 |
if (i == 0) {
|
|
122 |
headerRow.addTableRowCell(new ContingencyTableRowCell("Tabulka", 1));
|
92 |
123 |
}
|
93 |
|
int loopCount = 1;
|
94 |
|
for (int k = 0; k < i; k++) {
|
95 |
|
loopCount = loopCount * values.get(k).size();
|
|
124 |
else {
|
|
125 |
headerRow.addTableRowCell(new ContingencyTableRowCell("", 1));
|
96 |
126 |
}
|
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));
|
|
127 |
}
|
|
128 |
|
|
129 |
|
|
130 |
List<String> prevValues = new ArrayList<>();
|
|
131 |
int prevSize = 0;
|
|
132 |
for (ValueFunction valueFunction : valueFunctions) {
|
|
133 |
headerRows.get(0).addTableRowCell(new ContingencyTableRowCell(valueFunction.getFunction() + " z " + valueFunction.getName(), 0));
|
|
134 |
for (Node columnNode : columnNodes) {
|
|
135 |
for (int i = 0; i < columnNode.getValues().size(); i++) {
|
|
136 |
String value = columnNode.getValues().get(i);
|
|
137 |
if (!prevValues.contains(value)) {
|
|
138 |
prevValues.add(value);
|
|
139 |
headerRows.get(i + 1).addTableRowCell(new ContingencyTableRowCell(value, 1));
|
|
140 |
headerRows.get(0).getCells().get(headerRows.get(0).getCells().size() - 1).setColSpan(headerRows.get(0).getCells().get(headerRows.get(0).getCells().size() - 1).getColSpan() + 1);
|
|
141 |
} else if (columnNode.getValues().size() >= prevSize) {
|
|
142 |
headerRows.get(i + 1).getCells().get(headerRows.get(i + 1).getCells().size() - 1).setColSpan(headerRows.get(i + 1).getCells().get(headerRows.get(i + 1).getCells().size() - 1).getColSpan() + 1);
|
103 |
143 |
}
|
104 |
144 |
}
|
105 |
145 |
|
106 |
|
for (int l = 0; l < i - 1; l++) {
|
107 |
|
headerRows.get(i).addTableRowCell(new ContingencyTableRowCell("", 1));
|
|
146 |
if (columnNode.getValues().size() < prevSize) {
|
|
147 |
for (int s = prevSize; s < headerRows.size(); s++) {
|
|
148 |
headerRows.get(s).addTableRowCell(new ContingencyTableRowCell("", 1));
|
|
149 |
}
|
|
150 |
for (int s = 1; s < columnNode.getValues().size(); s++) {
|
|
151 |
headerRows.get(s).getCells().get(headerRows.get(s).getCells().size() - 1).setColSpan(headerRows.get(s).getCells().get(headerRows.get(s).getCells().size() - 1).getColSpan() + 1);
|
|
152 |
}
|
|
153 |
headerRows.get(columnNode.getValues().size()).addTableRowCell(new ContingencyTableRowCell(columnNode.getValues().get(columnNode.getValues().size() - 1) + " Celkem", 1));
|
108 |
154 |
}
|
|
155 |
|
|
156 |
prevSize = columnNode.getValues().size();
|
|
157 |
prevValues.remove(prevValues.size() - 1);
|
109 |
158 |
}
|
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 |
|
}
|
|
159 |
}
|
|
160 |
|
|
161 |
for (ValueFunction valueFunction : valueFunctions) {
|
|
162 |
for (int i = 1; i < headerRows.size(); i++) {
|
|
163 |
headerRows.get(i).addTableRowCell(new ContingencyTableRowCell("", 1));
|
117 |
164 |
}
|
|
165 |
headerRows.get(0).addTableRowCell(new ContingencyTableRowCell("Celkový " + valueFunction.getFunction() +
|
|
166 |
" z " + valueFunction.getName(), 1));
|
118 |
167 |
}
|
119 |
168 |
|
|
169 |
|
|
170 |
|
120 |
171 |
long startTime = System.nanoTime();
|
121 |
|
values.remove(0);
|
122 |
|
Node node = new Node();
|
123 |
|
generateColumns(0, values, columnNodes, node);
|
124 |
172 |
long stopTime = System.nanoTime();
|
125 |
173 |
System.out.println("Colums list:" + TimeUnit.MILLISECONDS.convert((stopTime - startTime), TimeUnit.NANOSECONDS));
|
126 |
174 |
|
... | ... | |
163 |
211 |
long stopTime = System.nanoTime();
|
164 |
212 |
System.out.println("Rows List:" + TimeUnit.MILLISECONDS.convert((stopTime - startTime), TimeUnit.NANOSECONDS));
|
165 |
213 |
|
166 |
|
boolean[] usableColumns = new boolean[(valueFunctions.size() * columnNodes.size())];
|
167 |
|
|
168 |
214 |
List<ContingencyTableRow> rowsToBeRemoved = new ArrayList<>();
|
169 |
215 |
for (int i = 0; i < dataRows.size(); i++) {
|
170 |
|
if (!fillRowWithData(dataRows.get(i), rowNodes.get(i), usableColumns)) {
|
|
216 |
if (!fillRowWithData(dataRows.get(i), rowNodes.get(i))) {
|
171 |
217 |
rowsToBeRemoved.add(dataRows.get(i));
|
172 |
218 |
}
|
173 |
219 |
}
|
174 |
220 |
|
175 |
221 |
dataRows.removeAll(rowsToBeRemoved);
|
176 |
222 |
|
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()));
|
|
223 |
if (!valueFunctions.get(0).getType().equals("Seznam") ||
|
|
224 |
(valueFunctions.get(0).getType().equals("Seznam") && columnNames.size() > 0)) {
|
|
225 |
dataRows.add(createFinalRow());
|
205 |
226 |
}
|
206 |
227 |
|
207 |
|
finalRow.addTableRowCells(valueCells);
|
208 |
|
|
209 |
|
dataRows.add(finalRow);
|
210 |
|
|
211 |
228 |
return dataRows;
|
212 |
229 |
}
|
213 |
230 |
|
... | ... | |
226 |
243 |
for (String s : list) {
|
227 |
244 |
StringBuilder levelString = new StringBuilder();
|
228 |
245 |
for (int i = 0; i < index; i++) {
|
229 |
|
levelString.append("----");
|
|
246 |
levelString.append(" ");
|
230 |
247 |
}
|
231 |
248 |
levelString.append(s);
|
232 |
249 |
ContingencyTableRow row = new ContingencyTableRow(false, index);
|
... | ... | |
254 |
271 |
for (String s : list) {
|
255 |
272 |
Node node = new Node(prevNode);
|
256 |
273 |
node.getValues().add(s);
|
257 |
|
int newIndex = index + 1;
|
258 |
|
generateColumns(newIndex, values, columnNodes, node);
|
259 |
|
columnNodes.add(node);
|
|
274 |
if (checkIfColumnIsUsable(node.getValues())) {
|
|
275 |
int newIndex = index + 1;
|
|
276 |
generateColumns(newIndex, values, columnNodes, node);
|
|
277 |
columnNodes.add(node);
|
|
278 |
}
|
260 |
279 |
}
|
261 |
280 |
}
|
262 |
281 |
}
|
... | ... | |
266 |
285 |
* @param row row to ne filled with data
|
267 |
286 |
* @param node node of the row
|
268 |
287 |
*/
|
269 |
|
private boolean fillRowWithData(ContingencyTableRow row, Node node, boolean[] usableColumns) {
|
|
288 |
private boolean fillRowWithData(ContingencyTableRow row, Node node) {
|
270 |
289 |
if (valueFunctions.size() == 0) {
|
271 |
290 |
return true;
|
272 |
291 |
}
|
... | ... | |
284 |
303 |
|
285 |
304 |
List<Integer> usableIDs = getUsableIDs(node);
|
286 |
305 |
|
|
306 |
if (valueFunctions.get(0).getType().equals("Seznam") && !usableIDs.isEmpty()) {
|
|
307 |
return true;
|
|
308 |
}
|
|
309 |
|
287 |
310 |
DoubleWrapper[] totals = new DoubleWrapper[valueFunctions.size()];
|
288 |
311 |
initializeWrapperField(totals);
|
289 |
312 |
|
... | ... | |
315 |
338 |
break;
|
316 |
339 |
}
|
317 |
340 |
}
|
|
341 |
|
318 |
342 |
// zvoleny sloupec z hodnot
|
319 |
343 |
if (tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID) == null) {
|
320 |
344 |
isUsable = false;
|
321 |
345 |
}
|
322 |
346 |
|
323 |
|
usableColumns[columnIndex] = isUsable;
|
324 |
|
|
325 |
347 |
if (isUsable) { // pokud lze hodnotu pouzit, prunik vsech hodnot sedi (ma nejakou hodnotu)
|
|
348 |
columnNode.setUsable(true);
|
326 |
349 |
isRowUsable = true;
|
327 |
350 |
isFilledCell = true;
|
328 |
351 |
computeValues(valueFunction, result, resultAvgSum, columnNode, isFirstMinMax,
|
... | ... | |
345 |
368 |
}
|
346 |
369 |
}
|
347 |
370 |
for (int i = 0; i < valueFunctions.size(); i++) {
|
|
371 |
if (valueFunctions.get(i).getType().equals("Seznam")) {
|
|
372 |
break;
|
|
373 |
}
|
348 |
374 |
if (!isFilledValueCells[i]) {
|
349 |
375 |
row.addTableRowCell(new ContingencyTableRowCell("", 0));
|
350 |
376 |
}
|
... | ... | |
381 |
407 |
return ids;
|
382 |
408 |
}
|
383 |
409 |
|
|
410 |
private boolean checkIfColumnIsUsable(List<String> columnNodeValues) {
|
|
411 |
for (int i = 0; i < tableColumns.get(columnNames.get(0).getName()).getValues().size(); i++) {
|
|
412 |
boolean isUsable = true;
|
|
413 |
for (int j = 0; j < columnNodeValues.size(); j++) {
|
|
414 |
if (!tableColumns.get(columnNames.get(j).getName()).getValues().get(i).equals(columnNodeValues.get(j))) {
|
|
415 |
isUsable = false;
|
|
416 |
break;
|
|
417 |
}
|
|
418 |
}
|
|
419 |
|
|
420 |
if (isUsable) {
|
|
421 |
return true;
|
|
422 |
}
|
|
423 |
}
|
|
424 |
|
|
425 |
return false;
|
|
426 |
}
|
|
427 |
|
384 |
428 |
private void computeValues(ValueFunction valueFunction, DoubleWrapper result, DoubleWrapper resultAvgSum, Node columnNode,
|
385 |
429 |
BooleanWrapper isFirstMinMax, int usableID, boolean isValueTotal, boolean isSingleValueRow) {
|
386 |
430 |
switch (valueFunction.getFunction()) {
|
... | ... | |
534 |
578 |
}
|
535 |
579 |
}
|
536 |
580 |
}
|
|
581 |
|
|
582 |
private ContingencyTableRow createFinalRow() {
|
|
583 |
ContingencyTableRow finalRow = new ContingencyTableRow(false, 0);
|
|
584 |
finalRow.addTableRowCell(new ContingencyTableRowCell("Celkem", 1));
|
|
585 |
|
|
586 |
List<ContingencyTableRowCell> valueCells = new ArrayList<>();
|
|
587 |
for (ValueFunction valueFunction : valueFunctions) {
|
|
588 |
for (Node columnNode : columnNodes) {
|
|
589 |
finalRow.addTableRowCell(generateFilledCell(valueFunction.getFunction(), columnNode.getTotalResult(), columnNode.getTotalResultSum(),
|
|
590 |
columnNode.getTotalMin(), columnNode.getTotalMax(), columnNode.getTotalResultAvgSum(),
|
|
591 |
columnNode.getTotalResultAvg()));
|
|
592 |
}
|
|
593 |
valueCells.add(generateFilledCell(valueFunction.getFunction(), valueFunction.getTotalResult(), valueFunction.getTotalResultSum(),
|
|
594 |
valueFunction.getTotalMin(), valueFunction.getTotalMax(), valueFunction.getTotalResultAvgSum(),
|
|
595 |
valueFunction.getTotalResultAvg()));
|
|
596 |
}
|
|
597 |
|
|
598 |
finalRow.addTableRowCells(valueCells);
|
|
599 |
|
|
600 |
return finalRow;
|
|
601 |
}
|
537 |
602 |
}
|
re #8113 re #7885 changed header column generation and row indentations; re #8154 nothing; no comments