private Set<LogicalVariable> getNormalizedColumnsAccordingToEqClasses(Set<LogicalVariable> columns, Map<LogicalVariable, EquivalenceClass> equivalenceClasses) { Set<LogicalVariable> normalizedColumns = new ListSet<>(); if (equivalenceClasses == null || equivalenceClasses.isEmpty()) { normalizedColumns.addAll(columns); return normalizedColumns; } for (LogicalVariable v : columns) { EquivalenceClass ec = equivalenceClasses.get(v); if (ec == null) { normalizedColumns.add(v); } else { if (ec.representativeIsConst()) { // trivially satisfied, so the var. can be removed } else { normalizedColumns.add(ec.getVariableRepresentative()); } } } return normalizedColumns; }
/** * Normalizes or reduces the order columns argument based on the equivalenceClasses argument. The caller is * responsible for taking caution as to how to handle the returned object since this method either returns the same * object that is passed or returns a new object. * @param orderColumns the order columns that are to be normalized * @param equivalenceClasses {@link EquivalenceClass} * @return a new normalized object if normalization is applied. Otherwise, the same argument object is returned. */ public static List<OrderColumn> replaceOrderColumnsByEqClasses(List<OrderColumn> orderColumns, Map<LogicalVariable, EquivalenceClass> equivalenceClasses) { if (equivalenceClasses == null || equivalenceClasses.isEmpty()) { return orderColumns; } List<OrderColumn> norm = new ArrayList<>(); for (OrderColumn orderColumn : orderColumns) { EquivalenceClass columnEQClass = equivalenceClasses.get(orderColumn.getColumn()); if (columnEQClass == null) { norm.add(orderColumn); } else if (!columnEQClass.representativeIsConst()) { norm.add(new OrderColumn(columnEQClass.getVariableRepresentative(), orderColumn.getOrder())); } // else columnEQClass rep. is constant, i.e. trivially satisfied, so the var. can be removed } return norm; }
private List<OrderColumn> normalizeOrderingColumns(List<OrderColumn> inputOrderColumns, Map<LogicalVariable, EquivalenceClass> equivalenceClasses) { List<OrderColumn> newOrderColumns = new ArrayList<>(); if (equivalenceClasses == null || equivalenceClasses.isEmpty()) { newOrderColumns.addAll(inputOrderColumns); return newOrderColumns; } for (OrderColumn oc : inputOrderColumns) { LogicalVariable v = oc.getColumn(); EquivalenceClass ec = equivalenceClasses.get(v); if (ec == null) { newOrderColumns.add(new OrderColumn(v, oc.getOrder())); } else { if (ec.representativeIsConst()) { // trivially satisfied, so the var. can be removed } else { newOrderColumns.add(new OrderColumn(ec.getVariableRepresentative(), oc.getOrder())); } } } return newOrderColumns; }
@Override public boolean equals(Object obj) { if (!(obj instanceof EquivalenceClass)) { return false; } else { EquivalenceClass ec = (EquivalenceClass) obj; if (!members.equals(ec.getMembers())) { return false; } if (!expressionMembers.equals(ec.getExpressionMembers())) { return false; } if (representativeIsConst) { return ec.representativeIsConst() && (constRepresentative.equals(ec.getConstRepresentative())); } else { return !ec.representativeIsConst() && (variableRepresentative.equals(ec.getVariableRepresentative())); } } } }
if (oc.representativeIsConst()) { nc = new EquivalenceClass(m, oc.getConstRepresentative()); } else if (m.contains(oc.getVariableRepresentative())) { nc = new EquivalenceClass(m, oc.getVariableRepresentative()); } else { nc = new EquivalenceClass(m, v);
LogicalVariable v3; if (ec2 != null && !ec2.representativeIsConst()) { v3 = ec2.getVariableRepresentative(); } else { v3 = v2;