/// <summary> /// PUBLIC API /// Find objects in space that are similar to the current object. /// Similar means that the properties listed in parameter must be the same. /// </summary> /// <param name="propertyIds">List of properties that must match</param> /// <returns>A list of objects that are similar, excluding this object. Empty list if none.</returns> public ICollection <ClassificationObject> FindSimilar(IEnumerable <byte> propertyIds) { COHashTable <ClassificationObject> ret = this._FindSimilar(propertyIds); if (ret == null) { return(EmptyCOArray); } else if (ret.Contains(this)) { ret.Remove(this); } return(ret.Objects); }
/// <summary> /// Opposite to FindSimilar(). Different means an object that has the listed properties different /// than the current object. The rest of the properties must be the same /// </summary> /// <param name="propertyIds">List of properties that must differ.</param> /// <returns>A list of different objects.</returns> public ICollection <ClassificationObject> FindDifferent(IEnumerable <byte> propertyIds) { // Algorithm: // 1. Create a list of properties that must be equal. // 2. Find objects that have those properties equal. (Set A) // 3. From setA remove objects that have diff properties equal to this // 4. Return SetA // Step 1. var propertiesEqual = this.EnabledProperties.Except(propertyIds).ToArray(); // Step 2. COHashTable <ClassificationObject> setA = this._FindSimilar(propertiesEqual); // Step 3. foreach (var prop in propertyIds) { setA.ExceptAndRemove(this.ObjectSpace.GetObjectsAt(this.Properties[prop])); } return(setA.Objects); }
/// <summary> /// Gets an intersection of multiple dimensions at coordinates specified by /// properties listed in params. /// </summary> /// <param name="properties"></param> /// <returns></returns> public COHashTable <ClassificationObject> GetDimensionIntersection(ICollection <Property> properties) { if (properties == null || properties.Count == 0) { return(COHashTable <ClassificationObject> .Empty); } if (properties.Count == 1) { return(GetObjectsAt(properties.First())); } // the order of properties does not matter for the result // sorting them will make sure that different calls to the method, with a different sequence of properties, // will result in a cache hit. var sortedProperties = properties.OrderBy(p => p.Id).ToArray(); COHashTable <ClassificationObject> ret; ///Collect all sets of matching objects var resultSets = new COHashTable <ClassificationObject> [(sortedProperties.Length)]; int i = 0; foreach (Property prop in sortedProperties) { resultSets[i++] = this.GetObjectsAt(prop); } ///Sort sets from smallest to largest. This significantly improves performance of intersect in most cases. Array.Sort <COHashTable <ClassificationObject> >(resultSets, COHashTable <ClassificationObject> .COHashTableCountComparer); ///create return set ret = resultSets[0].Clone(); ///intersect all sets with the initial return set i = 1; while (i < resultSets.Length && ret.Count > 0) { ret.IntersectAndRemove(resultSets[i++]); } return(ret); }
public PropertyEntry(COHashTable <T> coSet, LinkedListNode <Property> indexEntry) { COSet = coSet; IndexEntry = indexEntry; }