Revize cc39413d

re #7885 added SUM and ability to work with multiple values and sorted parameters in configuration, optimization

src/main/java/vldc/aswi/utils/Converter.java

@@ -7 +7 @@
 import vldc.aswi.model.table.contingencyTable.ContingencyTableRow;
 import vldc.aswi.model.table.contingencyTable.ContingencyTableRowCell;
 
+import javax.persistence.criteria.CriteriaBuilder;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.TimeUnit;
 
 /**
  * Class for converting classes.
@@ -27 +29 @@
     public List<ContingencyTableRow> convertTableColumnsToContingencyTableRows(Map<String, TableColumn> tableColumns,
                                                                                       List<NameUserName> rowNames,
                                                                                       List<NameUserName> columnNames,
-                                                                                      List<ValueFunction> valueFunctions) {
-        /*
+                                                                               List<ValueFunction> valueFunctions) {
+        long startTime = System.nanoTime();
         List<ContingencyTableRow> contingencyTableRows = new ArrayList<>();
 
-        // Create header row with column names.
-        ContingencyTableRow contingencyTableRowHeader = new ContingencyTableRow(true, 0);
-        for (String columnName : tableColumns.keySet()) {
-            contingencyTableRowHeader.addTableRowCell(new ContingencyTableRowCell(columnName, 0));
-        }
-        contingencyTableRows.add(contingencyTableRowHeader);
-
-        boolean listExpanded = false;
+        long startTime2 = System.nanoTime();
+        List<ContingencyTableRow> headerRows = createHeaderOnlyRows(tableColumns, columnNames, valueFunctions);
+        long stopTime2 = System.nanoTime();
+        System.out.println("Headers:" + TimeUnit.MILLISECONDS.convert((stopTime2 - startTime2), TimeUnit.NANOSECONDS));
 
-        // Create contingency table row.
-        for (TableColumn tableColumn : tableColumns.values()) {
-            List<String> values = tableColumn.getValues();
-
-            // If list is not created, then create it.
-            if (!listExpanded) {
-                for (int j = 0; j < values.size(); j++) {
-                    ContingencyTableRow contingencyTableRow = new ContingencyTableRow(false, 0);
-                    contingencyTableRows.add(contingencyTableRow);
-                }
-                listExpanded = true;
-            }
-
-            // Iterate through all values and assign one value per one row.
-            for (int j = 0; j < values.size(); j++) {
-                ContingencyTableRowCell contingencyTableRowCell = new ContingencyTableRowCell(values.get(j), 0);
-                contingencyTableRows.get(j + 1).addTableRowCell(contingencyTableRowCell);
-            }
-        }
-
-          */
-        List<ContingencyTableRow> contingencyTableRows = new ArrayList<>();
-
-        List<ContingencyTableRow> headerRows = createHeaderOnlyRows(tableColumns, columnNames);
+        long startTime3 = System.nanoTime();
         List<ContingencyTableRow> dataRows = createDataRows(tableColumns, columnNames, rowNames, valueFunctions);
+        long stopTime3 = System.nanoTime();
+        System.out.println("Rows:" + TimeUnit.MILLISECONDS.convert((stopTime3 - startTime3), TimeUnit.NANOSECONDS));
 
         contingencyTableRows.addAll(headerRows);
         contingencyTableRows.addAll(dataRows);
 
+        long stopTime = System.nanoTime();
+        System.out.println("Converter:" + TimeUnit.SECONDS.convert((stopTime - startTime), TimeUnit.NANOSECONDS) + "s");
+
         return contingencyTableRows;
     }
 
-    private List<ContingencyTableRow> createHeaderOnlyRows(Map<String, TableColumn> tableColumns, List<NameUserName> columnNames) {
+    /**
+     * Generates header rows.
+     * @param tableColumns Map of TableColumn
+     * @param columnNames list of column and user column names
+     * @param valueFunctions list of values and their functions
+     * @return list of contingency table rows
+     */
+    private List<ContingencyTableRow> createHeaderOnlyRows(Map<String, TableColumn> tableColumns,
+                                                           List<NameUserName> columnNames, List<ValueFunction> valueFunctions) {
         List<List<String>> values = new ArrayList<>();
         columnNodes = new ArrayList<>();
         List<ContingencyTableRow> headerRows = new ArrayList<>();
+
+        List<String> valueOptions = new ArrayList<>();
+        for (ValueFunction valueFunction : valueFunctions) {
+            valueOptions.add(valueFunction.getFunction() + " z " + valueFunction.getValue());
+        }
+        values.add(valueOptions);
+        headerRows.add(new ContingencyTableRow(true, 0));
+
         for(NameUserName nameUserName : columnNames) {
             TableColumn column = tableColumns.get(nameUserName.getName());
             values.add(getOriginalValuesFromList(column.getValues()));
             headerRows.add(new ContingencyTableRow(true, 0));
         }
 
-        Node node = new Node();
-        generateColumns(0, values, columnNodes, node);
-
         for (int i = 0; i < values.size(); i++) {
             int colSpan = 1;
             for (int j = values.size() - 1; j > i; j--) {
@@ -103 +96 @@
             for (int k = 0; k < loopCount; k++) {
                 for (String value : values.get(i)) {
                     headerRows.get(i).addTableRowCell(new ContingencyTableRowCell(value, colSpan));
-                    if (i != values.size() - 1) {
+                    if (i != values.size() - 1 && i != 0) {
                         headerRows.get(i).addTableRowCell(new ContingencyTableRowCell(value + " Celkem", 1));
                     }
                 }
 
-                for (int l = 0; l < i; l++) {
+                for (int l = 0; l < i - 1; l++) {
                     headerRows.get(i).addTableRowCell(new ContingencyTableRowCell("", 1));
                 }
             }
-            if (i == 0) {
-                headerRows.get(i).addTableRowCell(new ContingencyTableRowCell("Celkový počet", 1));
-            }
-            else {
-                headerRows.get(i).addTableRowCell(new ContingencyTableRowCell("", 1));
+            for(ValueFunction valueFunction: valueFunctions) {
+                if (i == 0) {
+                    headerRows.get(i).addTableRowCell(new ContingencyTableRowCell("Celkový " + valueFunction.getFunction() +
+                            " z " + valueFunction.getValue(), 1));
+                } else {
+                    headerRows.get(i).addTableRowCell(new ContingencyTableRowCell("", 1));
+                }
             }
         }
 
+        long startTime = System.nanoTime();
+        values.remove(0);
+        Node node = new Node();
+        generateColumns(0, values, columnNodes, node);
+        long stopTime = System.nanoTime();
+        System.out.println("Colums list:" + TimeUnit.MILLISECONDS.convert((stopTime - startTime), TimeUnit.NANOSECONDS));
+
         return headerRows;
     }
 
+    /**
+     * Gets original values of a given list.
+     * @param list list from which original values should be taken
+     * @return list of original values
+     */
     private List<String> getOriginalValuesFromList(List<String> list) {
         List<String> origList = new ArrayList<>();
 
@@ -135 +142 @@
         return origList;
     }
 
+    /**
+     * Creates data rows.
+     * @param tableColumns Map of TableColumn
+     * @param columnNames list of column and user column names
+     * @param rowNames list of row and user row names
+     * @param valueFunctions list of values and their functions
+     * @return list of contingency table rows
+     */
     private List<ContingencyTableRow> createDataRows(Map<String, TableColumn> tableColumns, List<NameUserName> columnNames,
                                                      List<NameUserName> rowNames, List<ValueFunction> valueFunctions) {
         List<ContingencyTableRow> dataRows = new ArrayList<>();
@@ -145 +160 @@
             values.add(getOriginalValuesFromList(column.getValues()));
         }
 
+        long startTime = System.nanoTime();
         Node node = new Node();
         generateRows(dataRows, 0, values, rowNodes, node);
+        long stopTime = System.nanoTime();
+        System.out.println("Rows List:" + TimeUnit.MILLISECONDS.convert((stopTime - startTime), TimeUnit.NANOSECONDS));
 
         for (int i = 0; i < dataRows.size(); i++) {
-            fillRowWithCountData(dataRows.get(i), tableColumns, rowNodes.get(i), rowNames, columnNames, valueFunctions);
+            fillRowWithData(dataRows.get(i), tableColumns, rowNodes.get(i), rowNames, columnNames, valueFunctions);
         }
 
         return dataRows;
     }
 
+    /**
+     * Recursively generates all possible row combinations, sorted as in contingency table.
+     * @param rows list of sorted contingency table rows
+     * @param index index in the values list
+     * @param values list of lists of values of each query row
+     * @param rowNodes list of row nodes
+     * @param prevNode parent node of the nodes
+     */
     private void generateRows(List<ContingencyTableRow> rows, int index, List<List<String>> values, List<Node> rowNodes,
                               Node prevNode) {
         if (index < values.size()) {
@@ -177 +203 @@
         }
     }
 
+    /**
+     * Recursively generates all possible column combinations, sorted as in contingency table.
+     * @param index index in the values list
+     * @param values list of lists of values of each query row
+     * @param columnNodes list of column nodes
+     * @param prevNode parent node of the nodes
+     */
     private void generateColumns(int index, List<List<String>> values, List<Node> columnNodes, Node prevNode) {
         if (index < values.size()) {
             List<String> list = values.get(index);
@@ -190 +223 @@
         }
     }
 
-    private void fillRowWithCountData(ContingencyTableRow row, Map<String, TableColumn> tableColumns, Node node,
-                                      List<NameUserName> rowNames, List<NameUserName> columnNames, List<ValueFunction> valueFunctions) {
-        int totalCount = 0;
-        //sloupec v kont. tabulce
-        for (Node columnNode : columnNodes) {
-            int count = 0;
-            // radek v orig. tabulce
-            for (int i = 0; i < tableColumns.get(rowNames.get(0).getName()).getValues().size(); i++) {
-                boolean isUsable = true;
-                //zvoleny sloupec z radku
-                for (int j = 0; j < node.getValues().size(); j++) {
-                    if (!tableColumns.get(rowNames.get(j).getName()).getValues().get(i).equals(node.getValues().get(j))) {
-                        isUsable = false;
-                        break;
-                    }
-                }
-                int j;
-                // zvoleny sloupec ze sloupcu
-                for (j = 0; j < columnNode.getValues().size(); j++) {
-                    if (!tableColumns.get(columnNames.get(j).getName()).getValues().get(i).equals(columnNode.getValues().get(j))) {
-                        isUsable = false;
-                        break;
+    /**
+     * Fills each data row with data.
+     * @param row row to ne filled with data
+     * @param tableColumns Map of TableColumn
+     * @param node node of the row
+     * @param rowNames list of row names and user names
+     * @param columnNames list of column names and user names
+     * @param valueFunctions list of values and their functions
+     */
+    private void fillRowWithData(ContingencyTableRow row, Map<String, TableColumn> tableColumns, Node node,
+                                 List<NameUserName> rowNames, List<NameUserName> columnNames, List<ValueFunction> valueFunctions) {
+        if (columnNodes.size() == 0) {
+            columnNodes.add(new Node());
+        }
+
+        List<Integer> usableIDs = getUsableIDs(tableColumns, node, rowNames);
+
+        int[] totals = new int[valueFunctions.size()];
+        //hodnota
+        for (int v = 0; v < valueFunctions.size(); v++) {
+            ValueFunction valueFunction = valueFunctions.get(v);
+            //sloupec v kont. tabulce
+            for (Node columnNode : columnNodes) {
+                int result = 0;
+                // radek v orig. tabulce
+                for (Integer usableID : usableIDs) {
+                    boolean isUsable = true;
+                    int j;
+                    // zvoleny sloupec ze sloupcu
+                    for (j = 0; j < columnNode.getValues().size(); j++) {
+                        if (!tableColumns.get(columnNames.get(j).getName()).getValues().get(usableID).equals(columnNode.getValues().get(j))) {
+                            isUsable = false;
+                            break;
+                        }
                     }
-                }
-                // zvoleny sloupec z hodnot
-                for (ValueFunction valueFunction : valueFunctions) {
-                    if (tableColumns.get(valueFunction.getValue()).getValues().get(i) == null) {
+                    // zvoleny sloupec z hodnot
+                    if (tableColumns.get(valueFunction.getValue()).getValues().get(usableID) == null) {
                         isUsable = false;
-                        break;
                     }
-                }
 
-                if (isUsable) {
-                    count++;
-                    if (j - 1 == 0) {
-                        totalCount++;
+                    if (isUsable) {
+                        if (valueFunction.getFunction().equals("COUNT")) {
+                            result++;
+                        } else if (valueFunction.getFunction().equals("SUM")) {
+                            result += Integer.parseInt(tableColumns.get(valueFunction.getValue()).getValues().get(usableID));
+                        }
+                        if (j - 1 == 0 || j == 0) {
+                            if (valueFunction.getFunction().equals("COUNT")) {
+                                totals[v]++;
+                            } else if (valueFunction.getFunction().equals("SUM")) {
+                                totals[v] += Integer.parseInt(tableColumns.get(valueFunction.getValue()).getValues().get(usableID));
+                            }
+                        }
                     }
                 }
+                row.addTableRowCell(new ContingencyTableRowCell(Integer.toString(result), 0));
             }
+        }
+        for (int total : totals) {
+            row.addTableRowCell(new ContingencyTableRowCell(Integer.toString(total), 0));
+        }
+    }
+
+    /**
+     * Gets a list of IDs of the query rows that fit the contingency table row settings.
+     * @param tableColumns Map of TableColumn
+     * @param node node of the row
+     * @param rowNames list of row names and user names
+     * @return list of usable IDs
+     */
+    private List<Integer> getUsableIDs(Map<String, TableColumn> tableColumns, Node node, List<NameUserName> rowNames) {
+        List<Integer> ids = new ArrayList<>();
 
-            row.addTableRowCell(new ContingencyTableRowCell(Integer.toString(count), 0));
+        for (int i = 0; i < tableColumns.get(rowNames.get(0).getName()).getValues().size(); i++) {
+            for (int j = 0; j < node.getValues().size(); j++) {
+                if (tableColumns.get(rowNames.get(j).getName()).getValues().get(i).equals(node.getValues().get(j))) {
+                    ids.add(i);
+                }
+            }
         }
 
-        row.addTableRowCell(new ContingencyTableRowCell(Integer.toString(totalCount), 0));
+        return ids;
     }
 }