/*
* Se asume que una transaccion no tiene items repetidos
*/
public void addTransaction(List <String> transaction)
{
FPNode location = root;
foreach (String item in transaction)
{
if (location.Hijos.ContainsKey(item))
{
location = location.Hijos[item];
location.Conteo++;
}
else
{
FPNode temp = null;
if (headersTable.ContainsKey(item))
{
temp = new FPNode(item, headersTable[item], location);
}
else
{
temp = new FPNode(item, null, location);
}
location.Hijos[item] = temp;
headersTable[item] = temp;
location = temp;
location.Conteo++;
}
}
}
private void AgregarSoporte(List <String> lista, ItemsSet <String> set, Dictionary <ItemsSet <String>, int> soportes)
{
String start = "";
foreach (String s in lista)
{
if (set.Contains(s))
{
start = s;
break;
}
}
FPNode nodo = headersTable[start];
int soporteSet = 0;
while (nodo != null)
{
FPNode temp = nodo;
ItemsSet <String> copy = new ItemsSet <string>();
copy.Union(set);
while (temp.Contenido != null)
{
copy.Remove(temp.Contenido);
temp = temp.Padre;
}
if (!copy.Any())
{
soporteSet += nodo.Conteo;
}
nodo = nodo.Siguiente;
}
soportes.Add(set, soporteSet);
}
public FPNode(String contenido, FPNode siguiente, FPNode padre)
{
this.conteo = 0;
this.contenido = contenido;
this.siguiente = siguiente;
this.padre = padre;
hijos = new Dictionary <string, FPNode>();
}
private FPTree Podar(FPTree conditional, FPNode node, int epsilon)
{
HashSet <String> conteo = new HashSet <String>();;
foreach (KeyValuePair <String, FPNode> entry in conditional.headersTable)
{
Int32 i = 0;
FPNode n = entry.Value;
while (n != null)
{
i += n.Conteo;
n = n.Siguiente;
}
if (i >= epsilon)
{
conteo.Add(entry.Key);
}
}
//instancia un nuevo arbol
FPTree respuesta = new FPTree();
//optiene el nodo adecuado
node = conditional.headersTable[node.Contenido];
//va a recorrer sus caminos y meterlos al arbol
while (node != null)
{
//optiene el padre
FPNode temp = node.Padre;
//instancia la transaccion
LinkedList <String> transaccion = new LinkedList <string>();
//mete los valores previos al nodo en la transaccion, si es adecuado
while (temp.Contenido != null)
{
if (conteo.Contains <String>(temp.Contenido))
{
transaccion.AddFirst(temp.Contenido);
}
temp = temp.Padre;
}
//si la transaccion no esta vacia
if (transaccion.First != null)
{
//mete la transaccion con su conteo respectivo
respuesta.addTransaction(transaccion, node.Conteo);
}
//pasa al siguiente camino
node = node.Siguiente;
}
return(respuesta);
}
public int getN()
{
int count = 0;
foreach (FPNode node in headersTable.Values)
{
FPNode temp = node;
while (temp != null)
{
count += temp.Conteo;
temp = temp.Siguiente;
}
}
return(count);
}
private void sumar(FPNode fPNode, Dictionary <string, FPNode> dictionary)
{
foreach (KeyValuePair <string, FPNode> entrada in dictionary)
{
if (fPNode.Hijos.ContainsKey(entrada.Key))
{
fPNode.Hijos[entrada.Key].Conteo += entrada.Value.Conteo;
sumar(fPNode.Hijos[entrada.Key], entrada.Value.Hijos);
}
else
{
fPNode.Hijos.Add(entrada.Key, entrada.Value);
entrada.Value.Padre = fPNode;
}
}
}
//optiene el subarbol con los caminos respectivos sin filtrar
private FPTree getCaminos(FPNode node)
{
//instancia un nuevo arbol
FPTree caminos = new FPTree();
//va a recorrer sus caminos y meterlos al arbol
while (node != null)
{
//optiene el padre
//OJO: se cambio
//OJO: se cambio
//OJO: se cambio
//OJO: se cambio
//OJO: se cambio
//OJO: se cambio
//OJO: se cambio
//OJO: se cambio
FPNode temp = node;
//OJO: se cambio
//OJO: se cambio
//OJO: se cambio
//OJO: se cambio
//OJO: se cambio
//OJO: se cambio
//OJO: se cambio
//OJO: se cambio
//utiliza una linkedList ya que el metodo addFirst es O(1)
//instancia la transaccion
LinkedList <String> transaccion = new LinkedList <string>();
//mete los valores previos al nodo en la transaccion
while (temp.Contenido != null)
{
transaccion.AddFirst(temp.Contenido);
temp = temp.Padre;
}
//si la transaccion no esta vacia
if (transaccion.First != null)
{
//mete la transaccion con su conteo respectivo
caminos.addTransaction(transaccion, node.Conteo);
}
//pasa al siguiente camino
node = node.Siguiente;
}
return(caminos);
}
public HashSet <Dependencia> TestDependencias(HashSet <Dependencia> posiblesDependencias, double confianza = 0.2)
{
HashSet <Dependencia> respuesta = new HashSet <Dependencia>();
Dictionary <String, Int32> conteo = new Dictionary <string, int>();
foreach (FPNode node in headersTable.Values)
{
FPNode n = node;
int i = 0;
while (n != null)
{
i += node.Conteo;
n = n.Siguiente;
}
conteo.Add(node.Contenido, i);
}
List <String> lista = conteo.ToList().OrderBy(c => c.Value).Select(c => c.Key).ToList();
int total = conteo.Sum(c => c.Value);
conteo = null;
Dictionary <ItemsSet <String>, int> soportes = new Dictionary <ItemsSet <string>, int>();
foreach (Dependencia dependencia in posiblesDependencias)
{
ItemsSet <String> dividendo = new ItemsSet <string>();
dividendo.UnionWith(dependencia.Implicante.Union(dependencia.Implicados));
if (!soportes.ContainsKey(dividendo))
{
AgregarSoporte(lista, dividendo, soportes);
}
ItemsSet <String> divisor = new ItemsSet <string>();
divisor.UnionWith(dependencia.Implicante);
if (!soportes.ContainsKey(divisor))
{
AgregarSoporte(lista, divisor, soportes);
}
if ((soportes[dividendo] + 0.0) / (soportes[divisor] + 0.0) >= confianza)
{
respuesta.Add(dependencia);
}
}
return(respuesta);
}
private int GetConteo(HashSet <string> itemsSet, FPNode node)
{
HashSet <string> copy = new HashSet <string>(itemsSet);
copy.Remove(node.Contenido);
if (copy.Any())
{
int conteo = 0;
foreach (FPNode n in node.Hijos.Values)
{
conteo += GetConteo(copy, n);
}
return(conteo);
}
else
{
return(node.Conteo);
}
}
private FPTree GetConditional(FPNode node, int epsilon)
{
//inicia el arbol con todos los caminos
FPTree conditional = getCaminos(node);
//inicia una variable que cuenta todo
return(Podar(conditional, node, epsilon));
/*
* //empieza a filtrar
* //hace una copia de la headersTable ya que no se puede modificar y recorrer al mismo tiempo
* //para cada item en el subArbol
* foreach (FPNode entrada in Extenciones.CloneNode<FPNode>(conditional.headersTable.Values.ToList()))
* {
* //cuenta cuantos items hay
* int suma = 0;
* FPNode n = entrada;
* while (n != null)
* {
* suma += n.Conteo;
* n = n.Siguiente;
* }
*
*
* //si es menor que el epsilon
* if (suma < epsilon)
* {
* //lo remueve
* conditional.headersTable.Remove(entrada.Contenido);
* n = entrada;
* while (n != null)
* {
* n.Padre.Hijos.Remove(entrada.Contenido);
* sumar(n.Padre, n.Hijos);
* n = n.Siguiente;
* }
* }
* }
* */
}
public HashSet <ItemsSet <String> > FPGrow(int epsilon, List <String> previos = null)
{
//si previos es default
if (previos == null)
{
//instancia a previos
previos = new List <string>();
}
//crea el conjuto de respuesta
HashSet <ItemsSet <String> > respuesta = new HashSet <ItemsSet <string> >();
//para cada item en el arbol
foreach (KeyValuePair <string, FPNode> entry in headersTable)
{
//obtiene su nodo inicial
FPNode node = entry.Value;
//crea un nuevo set de items
ItemsSet <String> items = new ItemsSet <string>();
//agrega los los items previos que se han hecho y an llevado a esta instancia de arbol
items.UnionWith(previos);
//agrega el nodo que se esta evaluando
items.Add(node.Contenido);
//agrega a la respueta el set de items
respuesta.Add(items);
//crea una copia de los previos
List <String> nueva = Extenciones.Clone <String>(previos);
//agrega el actual
nueva.Add(node.Contenido);
//genera el arbol condicional para el item actual
FPTree conditional = GetConditional(node, epsilon);
//llama recursivamente sobre el arbol condicional y une las respuestas
respuesta.UnionWith(conditional.FPGrow(epsilon, nueva));
}
return(respuesta);
}
public FPTree()
{
headersTable = new Dictionary <string, FPNode>();
root = new FPNode(null, null, null);
}
