(graph.getAdjacentNodes(y));
- naYX.retainAll(graph.getAdjacentNodes(x));
-
- for (int i = naYX.size()-1; i >= 0; i--) {
- Node z = naYX.get(i);
- Edge edge = graph.getEdge(y, z);
-
- if (!Edges.isUndirectedEdge(edge)) {
- naYX.remove(z);
- }
- }
-
- return naYX;
- }
-
- public Dag getFusion(){
-
- return this.outputDag;
+/**
+ * The {@code HeuristicConsensusBES} class extends the {@code ConsensusBES} class
+ * to implement a heuristic approach for backward equivalence search in directed acyclic graphs (DAGs).
+ *
+ * This class is designed to perform a consensus structure learning algorithm
+ * by applying a heuristic method for backward equivalence search (BES) with D-separation.
+ * It allows for a more efficient search by limiting the size of the conditioning set and applying a
+ * percentage threshold for determining d-separation between nodes.
+ *
+ * The constructor initializes the class with a list of input DAGs, a maximum size for the
+ * conditioning set, and a percentage threshold for d-separation.
+ * The `fusion` method applies the consensus union to compute a consensus DAG from the input DAGs,
+ * and then applies the backward equivalence search with D-separation with the specified parameters to refine the graph.
+ */
+public class HeuristicConsensusBES extends ConsensusBES{
+
+ private final int maxSize;
+ private final double percentage;
+
+ /**
+ * Constructor for HeuristicConsensusBES.
+ * This class extends ConsensusBES to implement a heuristic approach
+ * for backward equivalence search in directed acyclic graphs (DAGs).
+ *
+ * @param dags the list of input DAGs to be fused.
+ * @param maxSize the maximum size of the conditioning set for d-separation checks.
+ * @param percentage the percentage/threshold for determining d-separation between nodes.
+ */
+ public HeuristicConsensusBES(ArrayList dags, int maxSize, double percentage) {
+ super(dags);
+ this.maxSize = maxSize;
+ this.percentage = percentage;
}
-
-
- public static void main(String args[]) {
-
-
- System.out.println("Grafos de Partida: ");
-
- // (seed, n. variables, n egdes aprox, n.dags, mutation)
- RandomBN setOfBNs = new RandomBN(0, Integer.parseInt(args[0]), Integer.parseInt(args[1]),
- Integer.parseInt(args[2]),Integer.parseInt(args[3]));
- setOfBNs.setMaxInDegree(3);
- setOfBNs.setMaxOutDegree(3);
- setOfBNs.generate();
-
- for(int i = 0; i< setOfBNs.setOfRandomBNs.size(); i++){
- System.out.println("red de partida: "+i);
- System.out.println("---------------------");
- System.out.println("Grafo: ");
- System.out.println(setOfBNs.setOfRandomDags.get(i).getDegree()+" "+ setOfBNs.setOfRandomDags.get(i).getNumEdges());
-// System.out.println("Probabilidades: ");
-// System.out.println(setOfBNs.setOfRandomBNs.get(i).toString());
-// System.out.println("_____________________");
-// System.out.println("Datos Simulados");
-// System.out.println(setOfBNs.setOfSampledBNs.get(i).toString());
-
-
- }
- //
- HeuristicConsensusBES conDag= null;
- conDag = new HeuristicConsensusBES(setOfBNs.setOfRandomDags,1.0);
- conDag.fusion();
- Dag g = conDag.getFusion();
- System.out.println("grafo de partida Union: "+conDag.union.getDegree()+" "+ conDag.union.getNumEdges());
- System.out.println("grafo consenso: "+ g.getDegree() +" Complejidad de la Fusion: "+ conDag.getNumberOfInsertedEdges()+ " "+ conDag.outputDag.getNumEdges());
+ /**
+ * Executes the heuristic consensus backward equivalence search.
+ * This method first applies the ConsensusUnion to compute a consensus DAG from the input DAGs,
+ * and then applies the Backward Equivalence Search with D-separation to refine the graph, setting the maxSize and percentage parameters for an heuristic search.
+ * The resulting output DAG is stored in the outputDag attribute.
+ */
+ @Override
+ public void fusion(){
+ // 1. Apply ConsensusUnion
+ consensusUnion();
+ // 2. Apply Heuristic BES with D-separation
+ BackwardEquivalenceSearchDSep bes = new BackwardEquivalenceSearchDSep(this.getUnion(), this.getInputDags(), this.getTransformedDags());
+ bes.setMaxSize(maxSize);
+ bes.setPercentage(percentage);
+ this.outputDag = bes.applyBackwardEliminationWithDSeparation();
+ // 3. Updating numberOfInsertedEdges
+ this.numberOfInsertedEdges -= bes.getNumberOfRemovedEdges();
}
}
diff --git a/src/main/java/es/uclm/i3a/simd/consensusBN/HeuristicConsensusMVoting.java b/src/main/java/es/uclm/i3a/simd/consensusBN/HeuristicConsensusMVoting.java
index 1abe261..f09ec62 100644
--- a/src/main/java/es/uclm/i3a/simd/consensusBN/HeuristicConsensusMVoting.java
+++ b/src/main/java/es/uclm/i3a/simd/consensusBN/HeuristicConsensusMVoting.java
@@ -6,48 +6,142 @@
import edu.cmu.tetrad.graph.Dag;
import edu.cmu.tetrad.graph.Edge;
import edu.cmu.tetrad.graph.EdgeListGraph;
+import edu.cmu.tetrad.graph.Edges;
import edu.cmu.tetrad.graph.Endpoint;
import edu.cmu.tetrad.graph.Graph;
import edu.cmu.tetrad.graph.Node;
import static es.uclm.i3a.simd.consensusBN.Utils.pdagToDag;
+/**
+ * The {@code HeuristicConsensusMVoting} class implements a consensus structure learning algorithm
+ * based on a heuristic majority voting strategy.
+ *
+ * Given a collection of Directed Acyclic Graphs (DAGs), this class aggregates the structures
+ * by counting the frequency of directed edges across all graphs and selecting those
+ * that meet or exceed a specified threshold.
+ *
+ * The heuristic helps reduce noise by filtering out weakly supported edges, and it resolves
+ * conflicts (such as bidirectional edges) by applying majority rules or tie-breaking strategies.
+ *
+ * Typical use cases include combining results from different structure learning algorithms,
+ * bootstrapping runs, or expert-curated networks.
+ *
+ * The resulting output is a new DAG that aims to reflect the most consistent edges found
+ * across the input graphs.
+ *
+ *
Note: Input DAGs must share the same set of nodes for the consensus to be meaningful.
+ *
+ * Example usage:
+ *
{@code
+ * List inputGraphs = Arrays.asList(dag1, dag2, dag3);
+ * HeuristicConsensusMVoting consensus = new HeuristicConsensusMVoting(inputGraphs, threshold);
+ * Dag consensusDag = consensus.getConsensusGraph();
+ * }
+ *
+ */
public class HeuristicConsensusMVoting {
- ArrayList variables = null;
- Dag outputDag = null;
- ArrayList setOfdags = null;
- double percentage = 1.0;
- double [][] weight = null;
+ /**
+ * List of variables (nodes) in the consensus DAG.
+ * This list is derived from the nodes of the input DAGs.
+ */
+ private ArrayList variables = null;
+
+ /**
+ * The resulting output DAG after applying the heuristic consensus voting.
+ * This DAG contains the edges that were selected based on the majority voting strategy.
+ */
+ private Dag outputDag = null;
+
+ /**
+ * List of input DAGs used to compute the consensus.
+ * These DAGs are expected to have the same set of nodes.
+ */
+ private ArrayList setOfdags = null;
+
+ /**
+ * Percentage threshold for edge inclusion in the consensus DAG.
+ * An edge is included if it appears in at least this percentage of the input DAGs.
+ */
+ private double percentage = 1.0;
+
+ /**
+ * Weight matrix representing the frequency of edges between pairs of nodes.
+ * The weight[i][j] indicates how many times the edge from node i to node j appears in the input DAGs.
+ */
+ private double [][] weight = null;
+ /**
+ * Constructor for HeuristicConsensusMVoting.
+ * Initializes the variables, output DAG, input DAGs, and weight matrix.
+ * @param setOfdags the list of input DAGs to be fused.
+ * @param percentage the percentage threshold for edge inclusion in the consensus DAG.
+ */
+ public HeuristicConsensusMVoting(ArrayList setOfdags, double percentage) {
+ this.variables = (ArrayList) setOfdags.get(0).getNodes();
+ this.outputDag = null;
+ this.setOfdags = setOfdags;
+ this.percentage = percentage;
+ this.weight = new double[this.variables.size()][this.variables.size()];
+ setup();
+ }
+ /**
+ * Sets up the HeuristicConsensusMVoting instance by validating the input DAGs
+ * and building the weight matrix based on the edges present in the input DAGs.
+ */
+ private void setup() {
+ // Ensuring that the input DAGs are not null and have the same set of nodes
+ validateInputDags();
+ buildWeightMatrix();
+ }
+
+ /**
+ * Validates the input DAGs to ensure they are not null and have the same set of nodes.
+ * Throws an IllegalArgumentException if any validation fails.
+ */
+ private void validateInputDags() {
+ if (this.setOfdags == null || this.setOfdags.isEmpty())
+ throw new IllegalArgumentException("Input DAGs cannot be null or empty.");
+ for(Dag dag : this.setOfdags) {
+ if (dag.getNodes().size() != this.variables.size()) {
+ throw new IllegalArgumentException("All input DAGs must have the same number of nodes.");
+ }
+ if (!dag.getNodes().containsAll(this.variables)) {
+ throw new IllegalArgumentException("All input DAGs must have the same set of nodes.");
+ }
+ }
+ }
-public HeuristicConsensusMVoting(ArrayList setOfdags, double percentage) {
- super();
- this.variables = (ArrayList) setOfdags.get(0).getNodes();
- this.outputDag = null;
- this.setOfdags = setOfdags;
- this.percentage = percentage;
- this.weight = new double[this.variables.size()][this.variables.size()];
- ArrayList pdags = new ArrayList();
+ /**
+ * Builds the weight matrix based on the edges present in the input DAGs.
+ * Each entry weight[i][j] is incremented for each directed edge from node i to node j
+ * across all input DAGs, normalized by the number of input DAGs
+ */
+ private void buildWeightMatrix() {
+ ArrayList pdags = new ArrayList<>();
for(Dag g: this.setOfdags){
- Graph pd = new EdgeListGraph(new LinkedList(g.getNodes()));
+ Graph graph = new EdgeListGraph(new LinkedList<>(g.getNodes()));
for(Edge e: g.getEdges()){
- pd.addEdge(e);
+ graph.addEdge(e);
}
- pdagToDag(pd);
- pdags.add(pd);
+ pdagToDag(graph);
+ pdags.add(graph);
}
-
+
for(Graph pd: pdags){
for(Edge e: pd.getEdges()){
- Node n1 = e.getNode1();
- Node n2 = e.getNode2();
if(e.isDirected()){
- if(e.getEndpoint1() == Endpoint.ARROW){
- this.weight[variables.indexOf(n2)][variables.indexOf(n1)]+= (double) (1.0/this.setOfdags.size());
- }else{
- this.weight[variables.indexOf(n1)][variables.indexOf(n2)]+= (double) (1.0/this.setOfdags.size());
- }
+ Node from = Edges.getDirectedEdgeTail(e);
+ Node to = Edges.getDirectedEdgeHead(e);
+ this.weight[variables.indexOf(from)][variables.indexOf(to)] += (double) (1.0/this.setOfdags.size());
+ // if(e.getEndpoint1() == Endpoint.ARROW){
+ // this.weight[variables.indexOf(n2)][variables.indexOf(n1)]+= (double) (1.0/this.setOfdags.size());
+ // }else{
+ // this.weight[variables.indexOf(n1)][variables.indexOf(n2)]+= (double) (1.0/this.setOfdags.size());
+ // }
}else{
+ Node n1 = e.getNode1();
+ Node n2 = e.getNode2();
this.weight[variables.indexOf(n2)][variables.indexOf(n1)]+= (double) (1.0/this.setOfdags.size());
this.weight[variables.indexOf(n1)][variables.indexOf(n2)]+= (double) (1.0/this.setOfdags.size());
}
@@ -55,36 +149,88 @@ public HeuristicConsensusMVoting(ArrayList setOfdags, double percentage) {
}
}
-public Dag fusion(){
-
- this.outputDag = new Dag(variables);
- boolean procced = true;
- int bestEdgei = 0;
- int bestEdgej = 0;
- double maxW = 0.0;
- while(procced){
- for(int i = 0; i= maxW){
- if((this.weight[i][j] > maxW) || ((this.weight[i][j]==maxW) && (Math.random()>0.5))){
- bestEdgei = i;
- bestEdgej = j;
- maxW = this.weight[i][j];
+ /**
+ * Performs the fusion of the input DAGs using a heuristic majority voting strategy.
+ * The method iteratively selects edges based on their weights and adds them to the output DAG
+ * until no more edges meet the specified percentage threshold.
+ * @return The resulting consensus DAG after applying the heuristic voting.
+ */
+ public Dag fusion(){
+ this.outputDag = new Dag(variables);
+
+ while(true){
+ int bestEdgei = -1; // Best edge head node index
+ int bestEdgej = -1; // Best edge tail node index
+ double maxW = 0.0; // Maximum weight found in the current iteration
+
+ // Find the best edge based on the weight matrix
+ for(int i = 0; i= maxW){
+ if((this.weight[i][j] > maxW) || ((this.weight[i][j]==maxW) && (Math.random()>0.5))){
+ bestEdgei = i;
+ bestEdgej = j;
+ maxW = this.weight[i][j];
+ }
}
}
- }
- if(maxW >= this.percentage){
- if(!this.outputDag.paths().existsDirectedPath(variables.get(bestEdgej), variables.get(bestEdgei))){
- this.outputDag.addEdge(new Edge(variables.get(bestEdgei),variables.get(bestEdgej),Endpoint.TAIL,Endpoint.ARROW));
- this.weight[bestEdgei][bestEdgej] = 0;
- }else this.weight[bestEdgei][bestEdgej] = 0;
- if(maxW==0) procced = false;
- maxW = 0.0;
- }else procced = false;
+ // Stop if no edge meets the threshold
+ if(bestEdgei == -1 || bestEdgej == -1 || maxW < percentage || maxW == 0.0)
+ break;
+
+ // Add edge if it doesn't introduce a cycle
+ Node from = variables.get(bestEdgei);
+ Node to = variables.get(bestEdgej);
+ if(!this.outputDag.paths().existsDirectedPath(to, from)){
+ this.outputDag.addEdge(new Edge(from,to,Endpoint.TAIL,Endpoint.ARROW));
+ }
+ // Mark the edge as used by setting its weight to zero
+ this.weight[bestEdgei][bestEdgej] = 0;
+ }
+
+ return this.outputDag;
+ }
+
+ /**
+ * Returns the nodes (variables) of the consensus DAG.
+ * @return A list of nodes representing the variables in the consensus DAG.
+ */
+ public ArrayList getVariables() {
+ return variables;
+ }
+
+ /**
+ * Returns the resulting consensus DAG after applying the heuristic voting.
+ * @return The output DAG containing the selected edges based on the majority voting strategy.
+ */
+ public Dag getOutputDag() {
+ return outputDag;
+ }
+
+ /**
+ * Returns the list of input DAGs used to compute the consensus.
+ * @return A list of DAGs that were used as input for the consensus voting.
+ */
+ public ArrayList getSetOfdags() {
+ return setOfdags;
+ }
+
+ /**
+ * Returns the percentage threshold used for edge inclusion in the consensus DAG.
+ * @return The percentage threshold for edge inclusion.
+ */
+ public double getPercentage() {
+ return percentage;
+ }
+ /**
+ * Returns the weight matrix representing the frequency of edges between pairs of nodes.
+ * Each entry weight[i][j] indicates the weight that the edge from node i to node j has in the input DAGs.
+ * @return The weight matrix used in the consensus voting process.
+ * @see #fusion()
+ */
+ public double[][] getWeight() {
+ return weight;
}
-
- return this.outputDag;
-}
}
diff --git a/src/main/java/es/uclm/i3a/simd/consensusBN/HierarchicalAgglomerativeClustererBNs.java b/src/main/java/es/uclm/i3a/simd/consensusBN/HierarchicalAgglomerativeClustererBNs.java
index 1965f28..e55c0d9 100644
--- a/src/main/java/es/uclm/i3a/simd/consensusBN/HierarchicalAgglomerativeClustererBNs.java
+++ b/src/main/java/es/uclm/i3a/simd/consensusBN/HierarchicalAgglomerativeClustererBNs.java
@@ -106,7 +106,7 @@ public int cluster() {
clustersIndexes[i][i][0] = true;
}
- dissimilarityMatrix = computeDissimilarityMatrix();
+ computeDissimilarityMatrix();
for (int a = 1; a 0 && (this.maxSize >= (this.clusterCardinalities[o1] + this.clusterCardinalities[o2]))|| level == 0){
PairWiseConsensusBES pairBNs = new PairWiseConsensusBES(this.clustersBN[o1][level],this.clustersBN[o2][level]);
PairWiseConsensusBES pairDag= (PairWiseConsensusBES) pairBNs;
- pairDag.getFusion();
+ pairDag.fusion();
return pairBNs;
}else if(this.maxSize == 0){
PairWiseConsensusBES pairBNs = new PairWiseConsensusBES(this.clustersBN[o1][level],this.clustersBN[o2][level]);
PairWiseConsensusBES pairDag= (PairWiseConsensusBES) pairBNs;
- pairDag.getFusion();
+ pairDag.fusion();
if((pairDag.getDagFusion().getNumEdges())/this.averageNEdges <= this.maxComplexityCluster|| level == 0)
return pairBNs;
else return null;
@@ -326,7 +325,7 @@ private Pair findMostSimilarClusters() {
PairWiseConsensusBES inCluster = dissimilarityMatrix[cluster][neighbor];
if(inCluster!= null){
double complexity = 0.0;
- complexity = (float) inCluster.getHammingDistance();//getNumberOfInsertedEdges();
+ complexity = (float) inCluster.calculateHammingDistance();//getNumberOfInsertedEdges();
if (indexUsed[neighbor]&&complexity hashMap=new HashMap();
-//
-// public static int[] getList(int size) {
-// Integer key=size;
-// int[] lista=hashMap.get(key);
-// if(lista==null) {
-// lista=generateList(size);
-// hashMap.put(key, lista);
-// }
-// return lista;
-// }
-
- public static int[] getList(int size) {
- return generateList(size);
- }
-
- private static int[] generateList(int size) {
+ /**
+ * MAX_SIZE is the maximum number of elements that can be included in any subset.
+ * It is set to Integer.MAX_VALUE by default, meaning no limit unless specified.
+ */
+ public static int MAX_SIZE=Integer.MAX_VALUE;
+
+ /**
+ * Generates a list of integers representing all subsets of a set of a given size.
+ * Each integer is a bitmask where the i-th bit represents the inclusion of the i-th element.
+ * @param size the size of the set for which subsets are generated
+ * @return an array of integers representing the subsets
+ */
+ public static int[] generateList(int size) {
int[] lista;
if(size==0) {
return new int[1];
}
+ // Generation of powers of numbers that are powers of 2
int[] pow2=new int[size];
pow2[0]=1;
for(int i=1;iaux[0][index]) {
aux[0][counter]=aux[0][index]+pow2[i];
@@ -50,11 +55,4 @@ private static int[] generateList(int size) {
return lista;
}
- public static void setMaxSize(int maxParents) {
- ListFabric.maxSize = maxParents;
- }
-
- public static int getMaxSize() {
- return ListFabric.maxSize;
- }
}
diff --git a/src/main/java/es/uclm/i3a/simd/consensusBN/PairWiseConsensusBES.java b/src/main/java/es/uclm/i3a/simd/consensusBN/PairWiseConsensusBES.java
index 3b053bb..f1669bb 100644
--- a/src/main/java/es/uclm/i3a/simd/consensusBN/PairWiseConsensusBES.java
+++ b/src/main/java/es/uclm/i3a/simd/consensusBN/PairWiseConsensusBES.java
@@ -2,54 +2,138 @@
import java.util.ArrayList;
-
import edu.cmu.tetrad.graph.Dag;
import edu.cmu.tetrad.graph.Edge;
import edu.cmu.tetrad.graph.Node;
-
+/**
+ * This class implements the PairWiseConsensusBES algorithm, which measures the similarity between two DAGs by fusing them with the ConsensusBES algorithm.
+ * It first fuses the two input DAGs into a consensus DAG using the ConsensusBES class.
+ * After obtaining the consensus DAG, it calculates the Hamming distance between the fused DAG and the original input DAGs.
+ * The resulting output DAG is stored in the consensusDAG attribute, and the number of inserted edges during the fusion process can be retrieved using getNumberOfInsertedEdges.
+ */
public class PairWiseConsensusBES implements Runnable{
+ /**
+ * The first input DAG to be fused.
+ */
+ private Dag firstDag = null;
+
+ /**
+ * The second input DAG to be fused.
+ */
+ private Dag secondDag = null;
+
+ /**
+ * The resulting consensus DAG after applying the fusion process.
+ */
+ private Dag consensusDAG = null;
+
+ /**
+ * Instance of ConsensusBES used to compute the consensus DAG from the input DAGs.
+ */
+ private ConsensusBES consensusBES= null;
- private Dag b1 = null;
- private Dag b2 = null;
- private Dag conDAG = null;
- private ConsensusBES conBES= null;
+ /**
+ * Number of total edges inserted during the fusion process.
+ */
private int numberOfInsertedEdges = 0;
+
+ /**
+ * Number of edges inserted during the consensus union process.
+ */
private int numberOfUnionEdges = 0;
- public PairWiseConsensusBES(Dag b1, Dag b2) {
- super();
- this.b1 = b1;
- this.b2 = b2;
+ /**
+ * Constructor for the PairWiseConsensusBES class.
+ * It initializes the instance with two input DAGs and checks if they are valid.
+ * If the input DAGs are not valid, it throws an IllegalArgumentException.
+ * @param firstDag the first input DAG for fusion similarity.
+ * @param secondDag the second input DAG for fusion similarity.
+ */
+ public PairWiseConsensusBES(Dag firstDag, Dag secondDag) {
+ checkInput(firstDag, secondDag);
+ this.firstDag = firstDag;
+ this.secondDag = secondDag;
}
-
- public void getFusion(){
- ArrayList setOfDags = new ArrayList();
- setOfDags.add(this.b1);
- setOfDags.add(this.b2);
- conBES = new ConsensusBES(setOfDags);
- conBES.fusion();
- this.numberOfInsertedEdges = conBES.getNumberOfInsertedEdges();
- this.numberOfUnionEdges = conBES.union.getNumEdges();
- this.conDAG = conBES.getFusion();
+ /**
+ * Checks if the input DAGs are valid.
+ * Validity is determined by ensuring that the DAGs are not null, contain at least one node and one edge, and have the same set of nodes.
+ * If any of these conditions are not met, an IllegalArgumentException is thrown.
+ * @param firstDag first input DAG for fusion similarity
+ * @param secondDag second input DAG for fusion similarity
+ * @throws IllegalArgumentException if the input DAGs are not valid
+ */
+ private void checkInput(Dag firstDag, Dag secondDag) {
+ if (firstDag == null || secondDag == null) {
+ throw new IllegalArgumentException("Input DAGs cannot be null.");
+ }
+ if (firstDag.getNumNodes() == 0 || secondDag.getNumNodes() == 0) {
+ throw new IllegalArgumentException("Input DAGs must contain at least one node.");
+ }
+ if (firstDag.getNumEdges() == 0 || secondDag.getNumEdges() == 0) {
+ throw new IllegalArgumentException("Input DAGs must contain at least one edge.");
+ }
+ if (firstDag.getNodes().size() != secondDag.getNodes().size()) {
+ throw new IllegalArgumentException("Input DAGs must have the same number of nodes.");
+ }
+ if (!firstDag.getNodes().containsAll(secondDag.getNodes())) {
+ throw new IllegalArgumentException("Input DAGs must have the same set of nodes.");
+ }
}
-
+
+ /**
+ * Performs the fusion process by first applying the consensus union and then applying the Backward Equivalence Search.
+ */
+ public void fusion(){
+ // Creating a list of DAGs to be fused
+ ArrayList setOfDags = new ArrayList<>();
+ setOfDags.add(this.firstDag);
+ setOfDags.add(this.secondDag);
+ // Applying the ConsensusBES algorithm to fuse the DAGs
+ consensusBES = new ConsensusBES(setOfDags);
+ consensusBES.fusion();
+ // Retrieving the resulting DAG and the number of inserted edges
+ this.numberOfInsertedEdges = consensusBES.getNumberOfInsertedEdges();
+ this.numberOfUnionEdges = consensusBES.getUnion().getNumEdges();
+ this.consensusDAG = consensusBES.getFusionDag();
+ }
+
+ /**
+ * Returns the number of edges inserted during the fusion process.
+ * This method retrieves the number of edges that were added to the consensus DAG during the fusion process.
+ * It is useful for understanding how many edges were introduced in the consensus DAG compared to the original input DAGs.
+ * @return the number of edges inserted during the fusion process.
+ */
public int getNumberOfInsertedEdges(){
return this.numberOfInsertedEdges;
}
+ /**
+ * Returns the number of edges in the union DAG after the consensus union process.
+ * This method retrieves the number of edges that were present in the union DAG after merging the transformed input DAGs.
+ * It is useful for understanding the size of the union DAG before applying the Backward Equivalence Search.
+ * This number can be used to compare with the number of edges in the final consensus DAG after the Backward Equivalence Search.
+ *
+ * @see ConsensusBES#getUnion()
+ * @see ConsensusBES#getNumberOfInsertedEdges()
+ * @return the number of edges in the union DAG after the consensus union process.
+ */
public int getNumberOfUnionEdges(){
return this.numberOfUnionEdges;
}
- public int getHammingDistance(){
- if(this.conDAG==null) this.getFusion();
+ /**
+ * Calculates the Hamming distance between the optimum fusion DAG and the original input DAGs.
+ * @return The Hamming distance between the fused DAG and the original input DAGs.
+ */
+ public int calculateHammingDistance(){
+ if(this.consensusDAG==null) this.fusion();
int distance = 0;
- for(Edge ed: this.conDAG.getEdges()){
+ for(Edge ed: this.consensusDAG.getEdges()){
Node tail = ed.getNode1();
Node head = ed.getNode2();
- for(Dag g: conBES.setOfOutDags){
+ for(Dag g: consensusBES.getTransformedDags()){
Edge edge1 = g.getEdge(tail, head);
Edge edge2 = g.getEdge(head, tail);
if(edge1 == null && edge2==null) distance++;
@@ -58,14 +142,25 @@ public int getHammingDistance(){
return distance+this.getNumberOfInsertedEdges();
}
+ /**
+ * Returns the resulting consensus DAG after applying the fusion process.
+ * This method retrieves the final fused DAG, which represents the optimal fusion of the input DAGs.
+ * It is useful for obtaining the consensus structure after the fusion process has been completed.
+ *
+ * @see ConsensusBES#getFusionDag()
+ * @return the resulting consensus DAG after applying the whole fusion process.
+ */
public Dag getDagFusion(){
- return this.conDAG;
+ return this.consensusDAG;
}
+ /**
+ * Runs the fusion process in a thread, performing the consensus union and the Backward Equivalence Search with D-separation.
+ */
@Override
public void run() {
- this.getFusion();
+ this.fusion();
}
}
diff --git a/src/main/java/es/uclm/i3a/simd/consensusBN/PowerSet.java b/src/main/java/es/uclm/i3a/simd/consensusBN/PowerSet.java
index ebfe47d..c240f46 100644
--- a/src/main/java/es/uclm/i3a/simd/consensusBN/PowerSet.java
+++ b/src/main/java/es/uclm/i3a/simd/consensusBN/PowerSet.java
@@ -3,113 +3,140 @@
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
+import java.util.HashSet;
import java.util.List;
-
+import java.util.Set;
import edu.cmu.tetrad.graph.Node;
-public class PowerSet implements Enumeration {
+/**
+ * PowerSet generates all subsets of a given set of nodes, with an optional maximum size constraint.
+ * It implements Enumeration to allow iteration over the subsets.
+ */
+public class PowerSet implements Enumeration> {
+ /**
+ * List of nodes for which the power set is generated.
+ */
List nodes;
- private List subSets;
+ /**
+ * List to store the generated subsets.
+ */
+ private final List> subSets = new ArrayList<>();
+ /**
+ * Index to track the current position in the enumeration.
+ */
private int index;
- private int[] lista;
- private HashMap