Associates the features together.
963336
public void associate()
	{
		// initialize data structures
		matches.reset();
		unassociatedSrc.reset();

		if( srcPositive.size == 0 && srcNegative.size == 0 )
			return;
		if( dstPositive.size == 0 && dstNegative.size == 0 )
			return;

		// find and add the matches
		assoc.setSource((FastQueue)srcPositive);
		assoc.setDestination((FastQueue) dstPositive);
		assoc.associate();
		FastQueue<AssociatedIndex> m = assoc.getMatches();
		for( int i = 0; i < m.size; i++ ) {
			AssociatedIndex a = m.data[i];
			int globalSrcIndex = srcPositive.data[a.src].index;
			int globalDstIndex = dstPositive.data[a.dst].index;
			matches.grow().setAssociation(globalSrcIndex,globalDstIndex,a.fitScore);
		}
		GrowQueue_I32 un = assoc.getUnassociatedSource();
		for( int i = 0; i < un.size; i++ ) {
			unassociatedSrc.add(srcPositive.data[un.get(i)].index);
		}
		assoc.setSource((FastQueue)srcNegative);
		assoc.setDestination((FastQueue) dstNegative);
		assoc.associate();
		m = assoc.getMatches();
		for( int i = 0; i < m.size; i++ ) {
			AssociatedIndex a = m.data[i];
			int globalSrcIndex = srcNegative.data[a.src].index;
			int globalDstIndex = dstNegative.data[a.dst].index;
			matches.grow().setAssociation(globalSrcIndex,globalDstIndex,a.fitScore);
		}
		un = assoc.getUnassociatedSource();
		for( int i = 0; i < un.size; i++ ) {
			unassociatedSrc.add(srcNegative.data[un.get(i)].index);
		}
	}
571445
public void addFeatures(Collection<String> featuresToAdd) {
        if (featuresToAdd == null) return;
        for (String feature : featuresToAdd) {
            addFeature(feature);
        }
    }
1363982
def mergeStyles(self, styles):
        "  "
        for k, v in six.iteritems(styles):
            if k in self and self[k]:
                self[k] = copy.copy(self[k])
                self[k].update(v)
            else:
                self[k] = v
100014
private void _addFeatureOnce(Object name, Feature feature) {
        String _name = String.valueOf(name);
        if (!this.feature().containsKey(_name)) {
            this.feature().put(_name, feature);
        }
    }
402331
def attach(self, gui):
        """"""
        super(FeatureView, self).attach(gui)
        self.actions.add(self.increase)
        self.actions.add(self.decrease)
        self.actions.separator()
        self.actions.add(self.clear_channels)
        self.actions.add(self.toggle_automatic_channel_selection)

        gui.connect_(self.on_channel_click)
        gui.connect_(self.on_request_split)
582333
def include_feature(self, name):
        """'"""

        if self.feature_is_included(name) == 0:
            descr = self.features[name].description
            raise DistutilsOptionError(
                descr + " is required, but was excluded or is not available"
            )
        self.features[name].include_in(self)
        self._set_feature(name, 1)
857050
def combine(specs):
        
        new_specs = {}
        for spec in specs:
            if new_specs.get(spec, None) is None:
                new_specs[spec] = spec
            else:
                new_specs[spec].add(spec)
        return list(new_specs.values())
570709
function (properties, featureCollection, mergeKey) {
		var features = featureCollection.features;
		var featureIndex = L.GeometryUtils.indexFeatureCollection(features, mergeKey);
		var property;
		var mergeValue;
		var newFeatureCollection = {
			type: 'FeatureCollection',
			features: []
		};

		for (var key in properties) {
			if (properties.hasOwnProperty(key)) {
				property = properties[key];

				mergeValue = property[mergeKey];

				if (mergeValue) {
					var feature = featureIndex[mergeValue];

					for (var prop in property) {
						feature.properties[prop] = property[prop];
					}

					newFeatureCollection.features.push(feature);
				}
			}
		}

		return newFeatureCollection;
	}
830086
def combining_goal(state):
        
        ((corner, edge), (L, U, F, D, R, B)) = state
        if "U" not in corner or "U" not in edge: return False
        if set(edge).issubset(set(corner)): return True
        elif set(edge.facings.keys()).issubset(set(corner.facings.keys())): return False
        opposite = {"L":"R", "R":"L", "F":"B", "B":"F"}
        edge_facings = list(edge)
        for i, (face, square) in enumerate(edge_facings):
            if face == "U":
                if square != corner[opposite[edge_facings[(i+1)%2][0]]]:
                    return False
            else:
                if square != corner["U"]:
                    return False
        return True
1262575
def combine_data(self, command2):
        """"""
        if command2 is None:
            return
        self._data = self._merge(command2._data, self._data)
1286793
private List<PeriodAssociative<T>> _Combine( List<PeriodAssociative<T>> periods1, List<PeriodAssociative<T>> periods2 )
	{
		List<PeriodAssociative<T>> result = new ArrayList<PeriodAssociative<T>>();

		int count1 = periods1.size();
		int count2 = periods2.size();

		int i = 0;
		int j = 0;
		while( i < count1 && j < count2 )
		{
			if( periods1.get( i ).getFrom().compareTo( periods2.get( j ).getFrom() ) <= 0 )
			{
				result.add( periods1.get( i ) );
				i++;
			}
			else
			{
				result.add( periods2.get( j ) );
				j++;
			}
		}
		while( i < count1 )
		{
			result.add( periods1.get( i ) );
			i++;
		}
		while( j < count2 )
		{
			result.add( periods2.get( j ) );
			j++;
		}

		return result;
	}
734462
private Map<Feature, Feature> diffFeatures(List<Feature> pcm1Features, List<Feature> pcm2Features, PCMElementComparator comparator, DiffResult result) {
        List<Feature> commonFeatures = new ArrayList<Feature>();
        List<Feature> featuresOnlyInPCM1 = new ArrayList<Feature>();
        List<Feature> featuresOnlyInPCM2 = new ArrayList<Feature>(pcm2Features);

        Map<Feature, Feature> equivalentFeatures = new HashMap<Feature, Feature>();

        for (Feature f1 : pcm1Features) {
            boolean similarFeature = false;
            for (Feature f2 : pcm2Features) {
                similarFeature = comparator.similarFeature(f1, f2);
                if (similarFeature) {
                    commonFeatures.add(f1);
                    featuresOnlyInPCM2.remove(f2);
                    equivalentFeatures.put(f1, f2);
                    break;
                }
            }

            if (!similarFeature) {
                featuresOnlyInPCM1.add(f1);
            }
        }

        result.setCommonFeatures(commonFeatures);
        result.setFeaturesOnlyInPCM1(featuresOnlyInPCM1);
        result.setFeaturesOnlyInPCM2(featuresOnlyInPCM2);

        return equivalentFeatures;
    }
287783
def merge_visual(self, mujoco_objects):
        """"""
        self.visual_obj_mjcf = []
        for obj_name, obj_mjcf in mujoco_objects.items():
            self.merge_asset(obj_mjcf)
            # Load object
            obj = obj_mjcf.get_visual(name=obj_name, site=False)
            self.visual_obj_mjcf.append(obj)
            self.worldbody.append(obj)
1062164
public void addFeatures(List<Feature> features) {
		numFeatures += features.size();
		for (Feature feature : features) {
			featureListGrid.addFeature(feature);
		}
		if (sortFeatures) {
			featureListGrid.sort(sortFieldName, sortDirGWT);
		}
		
		if (exportCsvHandler instanceof ExportFeatureListToCsvHandler) {
			((ExportFeatureListToCsvHandler) exportCsvHandler).setFeatures(features);
		}
	}
1080395
def combine(self, a, b):
        """"""

        for l in (a, b):
            for x in l:
                yield x
288114
def add_bond(self, key1, key2, bond):
        """"""
        self.graph.add_edge(key1, key2, bond=bond)
1008693
def add_features(self, **features):
        
        for fname, fvalue in six.iteritems(features):
            setattr(self, fname, fvalue)
            self.features.add(fname)