package jcircus.parallelism;
import java.util.*;
public class FriendshipSets {
HashSet <HashSet <Integer>> friendshipSets = new HashSet <HashSet <Integer>> ();
public FriendshipSets () {
friendshipSets = new HashSet <HashSet <Integer>> ();
}
public FriendshipSets (HashSet <HashSet <Integer>> x) {
this.friendshipSets = x;
}
public HashSet <HashSet <Integer>> getFriendshipSets () {
return this.friendshipSets;
}
public void setFriendshipSets (HashSet <HashSet <Integer>> x) {
this.friendshipSets = x;
}
public static Vector <String> intersection (Vector <String> str1, Vector <String> str2) {
Vector <String> intersec = new Vector <String> ();
for (int i = 0; i < str1.size(); i++) {
if (str2.contains(str1.elementAt(i))) {
intersec.addElement(str1.elementAt(i));
}
}
return intersec;
}
public static Vector <String> forcedInter (Vector <String> str1, Vector <String> str2, Vector <String> channelSet) {
Vector <String> intersec = intersection (str1, str2);
Vector <String> forced = new Vector <String> ();
for (int i = 0; i < intersec.size(); i++) {
if (!channelSet.contains(intersec.elementAt(i))) {
forced.addElement(intersec.elementAt(i));
}
}
return forced;
}
private static HashSet <Integer> union (HashSet <Integer> x, HashSet <Integer> y) {
HashSet <Integer> z = new HashSet <Integer> ();
z.addAll(x);
z.addAll(y);
return z;
}
public static HashSet <HashSet <Integer>> interleave (HashSet <HashSet <Integer>> x, HashSet <HashSet <Integer>> y) {
HashSet <HashSet <Integer>> z = new HashSet <HashSet <Integer>> ();
z.addAll(x);
z.addAll(y);
return z;
}
public static HashSet <HashSet <Integer>> cartesianProduct (HashSet <HashSet <Integer>> x, HashSet <HashSet <Integer>> y) {
HashSet <HashSet <Integer>> setset = new HashSet <HashSet <Integer>> ();
for (int i = 0; i < x.size(); i++) {
for (int j = 0; j < y.size(); j++) {
HashSet <HashSet <Integer>> z = new HashSet <HashSet <Integer>> ();
setset.add(union ((HashSet <Integer>)x.toArray() [i], (HashSet <Integer>)y.toArray() [j]));
}
}
return setset;
}
public static Vector <Integer> allIndexes (String chan, HashMap <String, FriendshipSets> map) {
FriendshipSets fs = map.get(chan);
Vector <Integer> all = new Vector <Integer> ();
HashSet <HashSet <Integer>> fs2 = fs.getFriendshipSets();
Object [] fs2Array = fs2.toArray();
for (int i = 0; i < fs2Array.length; i++) {
Object [] fs2ArrayArray = ((HashSet <Integer>) fs2Array [i]).toArray();
for (int j = 0; j < fs2ArrayArray.length; j++) {
//if (!all.contains(fs2ArrayArray [j]))
//all.add((Integer) fs2ArrayArray [j]);
}
all.add(i);
}
return all;
}
public void interleave (HashSet <HashSet <Integer>> y) {
this.friendshipSets = interleave (this.friendshipSets, y);
}
public void cartesianProductSync (HashSet <HashSet <Integer>> y) {
this.friendshipSets = cartesianProduct (this.friendshipSets, y);
}
public static Integer [] renamingIndexes (HashSet <HashSet <Integer>> friendsSet, int index) {
int counter = 0, aux = 0;
Object/*HashSet <Integer>*/ [] friendsSetArray = /*(HashSet <Integer> [])*/ friendsSet.toArray();
for (int i = 0; i < friendsSet.size(); i++) {
if (((HashSet <Integer>)friendsSetArray [i]).contains(index)) {
counter++;
}
}
Integer [] indexes = new Integer [counter];
for (int i = 0; i < friendsSet.size(); i++) {
if (((HashSet <Integer>)friendsSetArray [i]).contains(index)) {
indexes[aux] = i;
aux++;
}
}
/*if (indexes.length == 0) {
return new Integer [] {0};
}*/
return indexes;
}
public static HashMap <String, Integer []> renamingIndexes (HashMap <String, FriendshipSets> spfemap, int index) { //Mapeia nomes de canais a indices de renomeacao.
HashMap <String, Integer []> mapstrint = new HashMap <String, Integer []> (); //sera usado para construir acoes renomeadas
Object [] keys = spfemap.keySet().toArray();
for (int i = 0; i < spfemap.size(); i++) {
mapstrint.put((String) keys [i], ((Integer []) renamingIndexes (spfemap.get(keys[i]).getFriendshipSets(), index)));
}
return mapstrint;
}
public static void printSetOfSets (FriendshipSets pfe) {
if (pfe != null)
printSetOfSets (pfe.getFriendshipSets());
}
public static String printMap (HashMap <String, FriendshipSets> map) {
String str = "";
Object [] keys = map.keySet().toArray();
for (int i = 0; i < keys.length; i++) {
str = str + (String)keys [i] + " -> " + printSetOfSets (map.get((String)keys [i]).getFriendshipSets());
str = str + "\n";
}
return str;
}
public static String printSetOfSets (HashSet <HashSet <Integer>> setofsets) {
String str = "";
str = str + "{";
for (int i = 0; i < setofsets.size(); i++) {
if (i != 0) {
str = str + ", ";
}
str = str + "{";
Set <Integer> set = (Set <Integer>) setofsets.toArray()[i];
for (int j = 0; j < set.size(); j++) {
if (j != 0) {
str = str + ", ";
}
Integer x = (Integer) set.toArray() [j];
str = str + x;
}
str = str + "}";
}
str = str + "}";
return str;
}
public static void main (String args []) {
/**ABAIXO TRECHO DE C�DIGO USADO PARA TESTAR OS M�TODOS DE PRODUTO CARTESIANO E INTERLEAVE**/
HashSet <HashSet <Integer>> h0;
HashSet <HashSet <Integer>> h1;
HashSet <HashSet <Integer>> h2;
HashSet <HashSet <Integer>> h3;
HashSet <HashSet <Integer>> h4;
HashSet <HashSet <Integer>> h5;
HashSet <HashSet <Integer>> h6;
HashSet <HashSet <Integer>> h7;
HashSet <HashSet <Integer>> h8;
HashSet <HashSet <Integer>> h9;
HashSet <Integer> zero = new HashSet <Integer> ();
zero.add(0);
HashSet <HashSet <Integer>> zeroset = new HashSet <HashSet <Integer>> ();
zeroset.add(zero);
HashSet <Integer> um = new HashSet <Integer> ();
um.add(1);
HashSet <HashSet <Integer>> umset = new HashSet <HashSet <Integer>> ();
umset.add(um);
HashSet <Integer> dois = new HashSet <Integer> ();
dois.add(2);
HashSet <HashSet <Integer>> doisset = new HashSet <HashSet <Integer>> ();
doisset.add(dois);
HashSet <Integer> tres = new HashSet <Integer> ();
tres.add(3);
HashSet <HashSet <Integer>> tresset = new HashSet <HashSet <Integer>> ();
tresset.add(tres);
HashSet <Integer> quatro = new HashSet <Integer> ();
quatro.add(4);
HashSet <HashSet <Integer>> quatroset = new HashSet <HashSet <Integer>> ();
quatroset.add(quatro);
HashSet <Integer> cinco = new HashSet <Integer> ();
cinco.add(5);
HashSet <HashSet <Integer>> cincoset = new HashSet <HashSet <Integer>> ();
cincoset.add(cinco);
HashSet <HashSet <Integer>> seisset = interleave (doisset, tresset);
HashSet <HashSet <Integer>> seteset = interleave (quatroset, cincoset);
HashSet <HashSet <Integer>> oitoset = cartesianProduct (seisset, seteset);
HashSet <HashSet <Integer>> noveset = interleave (oitoset, umset);
HashSet <HashSet <Integer>> dezset = cartesianProduct (zeroset, noveset);
printSetOfSets (dezset);
/**ACIMA TRECHO DE C�DIGO USADO PARA TESTAR OS M�TODOS DE PRODUTO CARTESIANO E INTERLEAVE**/
}
/*public static HashSet <HashSet <Integer>> miniDispute (HashSet <Integer> set1, HashSet <Integer> set2) throws Exception {
HashSet <Integer> set = new HashSet ();
HashSet <HashSet <Integer>> setofsets = new HashSet <HashSet <Integer>> ();
if (set1.size() == 1 && set2.size () == 1) {
Integer x = (Integer) set1.toArray()[0];
Integer y = (Integer) set2.toArray()[0];
set.add(x);
set.add(y);
setofsets.add(set);
return setofsets;
}
else if (set1.size () == 1 && set2.size() == 2) {
Integer x = (Integer) set1.toArray()[0];
Integer y = (Integer) set2.toArray()[0];
Integer z = (Integer) set2.toArray()[1];
HashSet <Integer> s1 = new HashSet <Integer> ();
HashSet <Integer> s2 = new HashSet <Integer> ();
HashSet <Integer> s3 = new HashSet <Integer> ();
s1.add(x); s1.add(y);
s2.add(x); s2.add(z);
s3.add(y); s3.add(z);
setofsets.add(s1);
setofsets.add(s2);
setofsets.add(s3);
return setofsets;
}
else if (set1.size () == 2 && set2.size() == 1) {
Integer x = (Integer) set1.toArray()[0];
Integer y = (Integer) set1.toArray()[1];
Integer z = (Integer) set2.toArray()[0];
HashSet <Integer> s1 = new HashSet <Integer> ();
HashSet <Integer> s2 = new HashSet <Integer> ();
HashSet <Integer> s3 = new HashSet <Integer> ();
s1.add(x); s1.add(y);
s2.add(x); s2.add(z);
s3.add(y); s3.add(z);
setofsets.add(s1);
setofsets.add(s2);
setofsets.add(s3);
return setofsets;
}
else if (set1.size () == 2 && set2.size() == 2) {
Integer x = (Integer) set1.toArray()[0];
Integer y = (Integer) set1.toArray()[1];
Integer z = (Integer) set2.toArray()[0];
Integer w = (Integer) set2.toArray()[1];
System.out.println ("Dispute: " + x + ", " + y + ", " + z + ", " + w);
HashSet <Integer> s1 = new HashSet <Integer> ();
HashSet <Integer> s2 = new HashSet <Integer> ();
HashSet <Integer> s3 = new HashSet <Integer> ();
HashSet <Integer> s4 = new HashSet <Integer> ();
HashSet <Integer> s5 = new HashSet <Integer> ();
HashSet <Integer> s6 = new HashSet <Integer> ();
s1.add(x); s1.add(z);
s2.add(x); s2.add(w);
s3.add(y); s3.add(z);
s4.add(y); s4.add(w);
s5.add(x); s5.add(y);
s6.add(z); s6.add(w);
setofsets.add(s1);
setofsets.add(s2);
setofsets.add(s3);
setofsets.add(s4);
setofsets.add(s5);
setofsets.add(s6);
return setofsets;
}
else {
throw new Exception ("Wrong combination of sets");
}
}
public static HashSet <HashSet <Integer>> disputeMerge (HashSet <HashSet <Integer>> set1, HashSet <HashSet <Integer>> set2) throws Exception { //N�O TESTADA AINDA
HashSet <HashSet <Integer>> set = new HashSet <HashSet <Integer>> ();
for (int i = 0; i < set1.size(); i++) {
for (int j = 0; j < set2.size(); j++) {
set.addAll(miniDispute((HashSet <Integer>) set1.toArray()[i], (HashSet <Integer>) set2.toArray()[i]));
}
}
return set;
}
public static void printMiniDispute (HashSet <HashSet <Integer>> setofsets) {
System.out.print ("{");
for (int i = 0; i < setofsets.size(); i++) {
if (i != 0) {
System.out.print (", ");
}
System.out.print ("{");
Set <Integer> set = (Set <Integer>) setofsets.toArray()[i];
for (int j = 0; j < set.size(); j++) {
if (j != 0) {
System.out.print (", ");
}
Integer x = (Integer) set.toArray()[j];
System.out.print (x);
}
System.out.print ("}");
}
System.out.print ("}");
}
public static void main (String args []) {
HashSet <Integer> set1 = new HashSet <Integer> ();
HashSet <Integer> set2 = new HashSet <Integer> ();
set1.add(1);
set1.add(2);
set2.add(3);
set2.add(4);
try {
printMiniDispute (miniDispute (set1, set2));
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}*/
}