public static double NumericDistance(CombinatorialSemantics desired, Semantics candidate, IEnumerable <Semantics> allCandidates) { double distance = 0.0; for (int i = 0; i < Math.Min(desired.Length, candidate.Length); i++) { var desiredSemantics = desired[i]; foreach (var value in desiredSemantics) { if (candidate[i] == null) { // if candidate has no semantic value, take the worst distance of the other candidates // if no other candidate has a semantic value, ignore i'th value /*bool distanceFound; * double worstDistance = GetWorstDistance((int) value, allCandidates, i, out distanceFound); * if (distanceFound) { * distance += worstDistance; * }*/ } else { var dist = Math.Abs((int)value - (int)candidate[i]); distance += dist; } } } return(distance); }
public static double HammingDistance(CombinatorialSemantics desired, Semantics candidate, IEnumerable <Semantics> allCandidates) { double distance = 0.0; for (int i = 0; i < Math.Min(desired.Length, candidate.Length); i++) { var semantics = desired[i]; foreach (var value in semantics) { if (candidate == null || !value.Equals(candidate[i])) { distance++; } } } return(distance); }
public TreeNode GetBySemantics(Type type, CombinatorialSemantics semantics) { var items = GetItemsByType(type); if (items.Count > 0) { PoolItem bestItem; if (type == typeof(bool)) { bestItem = GetBestItem(items, semantics, CombinatorialSemantics.HammingDistance); } else { bestItem = GetBestItem(items, semantics, CombinatorialSemantics.NumericDistance); } return(bestItem.Node); } return(null); }
// Pawlak et al. Algorithm 1 in paper Semantic Backpropagation for Designing Search Operators in GP: // Naming: n ... node, p ... root, t ... target // semantic types may be mixed up in expression: e.g. bool ret = (a + b) == (c - a) // => have to use object type instead of one generic type public CombinatorialSemantics Propagate(TreeNode root, TreeNode node, Semantics target) { CombinatorialSemantics semantics = new CombinatorialSemantics(target.Length); var path = root.GetPathTo(node); for (int i = 0; i < target.Length; i++) // for all ti element of t do: { ISet <object> currentValueSet = new HashSet <object>(); // Di currentValueSet.Add(target[i]); // Di <- { ti } var currentNode = root; // a <- p bool ambiguityFound = false; // * not element of Di int pathIndex = 0; // index of path element while (currentNode != node && currentValueSet.Count > 0 && !ambiguityFound) { int k = currentNode.Children.IndexOf(path[pathIndex]); ISet <object> valueSet = new HashSet <object>(); // D' <- {} var invertibleExpr = currentNode as IInvertible; // if not invertible, loop will end if (invertibleExpr != null && invertibleExpr.IsInvertible) { foreach (var desiredValue in currentValueSet) { bool ambiguous; var complementValue = invertibleExpr.GetComplementValue(k, i); if (complementValue != null) // complement value can be null if semantics not evaluated { valueSet.UnionWith(invertibleExpr.Invert(desiredValue, k, complementValue, out ambiguous)); if (ambiguous) { ambiguityFound = true; } } } } // valueSet is empty in case of ambiguity (* element of D') currentValueSet = valueSet; // Di <- D' currentNode = path[pathIndex++]; // a <- Child(a, n) } semantics[i] = currentValueSet; } return(semantics); }
private PoolItem GetBestItem(IList <PoolItem> items, CombinatorialSemantics semantics, DistanceMeasure distanceMeasure) { double bestDistance = Double.MaxValue; PoolItem bestItem = null; var allSemantics = items.Where(item => item is ISemanticsHolder && ((ISemanticsHolder)item.Node).SemanticsEvaluated) .Select(item => ((ISemanticsHolder)item.Node).Semantics); foreach (var item in items) { var semanticsNode = item.Node as ISemanticsHolder; if (semanticsNode != null && semanticsNode.SemanticsEvaluated) { var distance = distanceMeasure(semantics, semanticsNode.Semantics, allSemantics); if (distance < bestDistance) { bestDistance = distance; bestItem = item; } } } return(bestItem); }
protected virtual TreeNode DoLibrarySearch(Individual individual, ISemanticSubTreePool subTreePool, Type nodeType, CombinatorialSemantics desiredSemantics) { return(subTreePool.GetBySemantics(nodeType, desiredSemantics)); }