Coverage RemoveSubsets(Coverage groups)
{
var not_subsets = new Coverage();
foreach (var candidate_subset in groups)
{
if (!groups.Any(candidate_superset => candidate_subset.IsProperSubsetOf(candidate_superset)))
{
not_subsets.Add(candidate_subset);
}
}
return(not_subsets);
}
public static string ToSOPExpression(this Coverage coverage)
{
var result = new StringBuilder();
var groups = coverage.OrderBy(g => g.Count).ToList();
for (int g = 0; g < groups.Count; g++)
{
result.Append(groups[g].ToMintermExpression());
if (g != (groups.Count - 1))
{
result.Append(" + ");
}
}
return(result.ToString());
}
public HashSet <Coverage> Minimize()
{
Coverage groups = new Coverage();
// Generar grupos iniciales (de cardinalidad 1)
foreach (var one in on_set_binary)
{
groups.Add(new Group()
{
one
});
}
// Considere el no importa como 'unos', pero no los considere esenciales
foreach (var dc in dc_set_binary)
{
groups.Add(new Group()
{
dc
});
}
Coverage previous_groups = null;
// Continuar fusionando y optimizando hasta que sea posible
while (previous_groups == null || !groups.Equals(previous_groups))
{
previous_groups = groups; // Guarde el estado antes de fusionar y optimizar
// Fusionar grupos de cardinalidad 'n' para crear grupos de doble cardinalidad.
groups = MergeGroups(groups);
// Limpiar grupos que sean subconjuntos estrictos de otros grupos.
groups = RemoveSubsets(groups);
}
// Detectar grupos esenciales.
groups = MarkEssential(groups);
// Eliminar los grupos completamente redundantes, es decir, los grupos que cubren 'unos' (de la función) ya cubiertos por otros grupos ESENCIALES
groups = RemoveRedundant(groups);
return(GetCoverages(groups));
}
Coverage MergeGroups(Coverage groups)
{
var merged = new Coverage();
foreach (var g1 in groups)
{
foreach (var g2 in groups)
{
// Dos grupos solo pueden fusionarse si son adyacentes y separados
if (g1.Intersect(g2).Count() == 0 && AreGroupsAdjacent(g1, g2))
{
var new_group = new Group(g1.Union(g2));
merged.Add(new_group);
}
}
}
return(new Coverage(groups.Union(merged)));
}
bool IsValidCoverage(Coverage selected_groups, out Coverage coverage)
{
coverage = null;
var on_set = new SortedSet <string>(on_set_binary);
foreach (var g in selected_groups)
{
on_set.ExceptWith(g);
}
// Una cobertura es válida si y solo si cubre todos los "unos" de la función
if (on_set.Any())
{
return(false);
}
else
{
coverage = new Coverage(selected_groups)
{
Cost = CoverageCost(selected_groups)
};
return(true);
}
}
