Remove all instances of CustomFeature from the active feature list.
771512
def remove_all_custom_funcs(self):
        
        custom_feats = [f for f in self.active_features if isinstance(f, CustomFeature)]
        for f in custom_feats:
            self.active_features.remove(f)
876161
private void removeMarkedObservations() {
		Point2D_F64 observation = new Point2D_F64();

		for (int viewIndex = 0; viewIndex < observations.views.length; viewIndex++) {
//			System.out.println("ViewIndex="+viewIndex);
			SceneObservations.View v = observations.views[viewIndex];
			for(int indexInView = v.point.size-1; indexInView >= 0; indexInView-- ) {
				int pointID = v.getPointId(indexInView);
				SceneStructureProjective.Point f = structure.points[pointID];
//				System.out.println("   pointIndex="+pointIndex+" pointID="+pointID+" hash="+f.hashCode());
				v.get(indexInView, observation);

				if( !Double.isNaN(v.observations.get(indexInView*2)))
					continue;

				// Tell the feature it is no longer visible in this view
				f.removeView(viewIndex);
				// Remove the observation of this feature from the view
				v.remove(indexInView);
			}
		}
	}
595408
def prune(self):
        
        self.boundprocs = [ obj for obj in self.boundprocs if obj.permission in self.display ]
        self.variables = [ obj for obj in self.variables if obj.permission in self.display ]
        for obj in self.boundprocs + self.variables:
            obj.visible = True
1291100
def _clean_props(self):
        
        remove = []
        for p in self.properties.keys():
            if not hasattr(self.ic, p) and \
              p not in self.ic.bands and p not in ['parallax','feh','age','mass_B','mass_C'] and \
              not re.search('delta_',p):
                remove.append(p)

        for p in remove:
            del self.properties[p]

        if len(remove) > 0:
            logging.warning('Properties removed from Model because ' +
                            'not present in {}: {}'.format(type(self.ic),remove))

        remove = []
        for p in self.properties.keys():
            try:
                val = self.properties[p][0]
                if not np.isfinite(val):
                    remove.append(p)
            except:
                pass

        for p in remove:
            del self.properties[p]

        if len(remove) > 0:
            logging.warning('Properties removed from Model because ' +
                            'value is nan or inf: {}'.format(remove))
        


        self._props_cleaned = True
866103
def clear(self):
        
        for sample in self.metadata:
            try:
                delattr(sample.depth, 'bases')
                delattr(sample.depth, 'coverage')
                delattr(sample.depth, 'length')
                delattr(sample.depth, 'stddev')
            except AttributeError:
                pass
539637
function() {
        if (this.layer) {
            this.layer.removeFeatures(this);
            this.layer = null;
        }
            
        this.geometry = null;
        this.modified = null;
        OpenLayers.Feature.prototype.destroy.apply(this, arguments);
    }
297834
public void uninstallFeatures(Collection<String> featureNames, Collection<String> uninstallInstallFeatures) {
        getUninstallDirector().uninstallFeatures(featureNames, uninstallInstallFeatures, false);
    }
1264154
def remove_properties(self):
        
        if self.features_layer is not None:
            self.features_layer.remove_properties()

        if self.header is not None:
            self.header.remove_lp('features')
492079
def clean(self):
        
        for prop in ('imported_from', 'use', 'plus', 'templates', 'register'):
            try:
                delattr(self, prop)
            except AttributeError:
                pass
        for prop in ('configuration_warnings', 'configuration_errors'):
            try:
                if getattr(self, prop, None) is not None and not getattr(self, prop):
                    delattr(self, prop)
            except AttributeError:
                pass
452549
public function clear()
    {
        $this->id = null;
        $this->feature_av_id = null;
        $this->feature_feature_type_id = null;
        $this->locale = null;
        $this->value = null;
        $this->created_at = null;
        $this->updated_at = null;
        $this->alreadyInSave = false;
        $this->clearAllReferences();
        $this->applyDefaultValues();
        $this->resetModified();
        $this->setNew(true);
        $this->setDeleted(false);
    }
1066955
def clear_all(self):
        """"""
        logger.info("Clearing ALL Features and FeatureKeys.")
        self.session.query(Feature).delete(synchronize_session="fetch")
        self.session.query(FeatureKey).delete(synchronize_session="fetch")
166553
def Remove(self, *descriptor_names):
    """"""
    new_descriptor_map = self.descriptor_map.copy()
    for name in descriptor_names:
      new_descriptor_map.pop(name, None)

    new_descriptors = [
        desc for desc in self.descriptors
        if desc in itervalues(new_descriptor_map)
    ]
    return TypeDescriptorSet(*new_descriptors)
1077571
def remove_selected_classification(self):
        """"""
        removed_classes = self.hazard_class_form.selectedItems()
        current_item = self.hazard_class_form.currentItem()
        removed_index = self.hazard_class_form.indexFromItem(current_item)
        del self.classification[removed_index.row()]
        for item in removed_classes:
            self.hazard_class_form.takeItem(
                self.hazard_class_form.row(item))
264984
public void removeAll()
    {
        if (m_gridList != null)
            m_gridList.removeAll();
        if (m_gridBuffer != null)
            m_gridBuffer.removeAll();
        if (m_gridNew != null)
            m_gridNew.removeAll();
        m_iEndOfFileIndex = UNKNOWN_POSITION;
        m_iPhysicalFilePosition = UNKNOWN_POSITION;
        m_iLogicalFilePosition = UNKNOWN_POSITION;
    }
418773
def prune_existing_features(project, force=False):
    """"""
    if not force and not project.on_master_after_merge():
        raise SkippedValidationTest('Not on master')

    out = project.build()
    X_df, y, features = out['X_df'], out['y'], out['features']
    proposed_feature = get_proposed_feature(project)
    accepted_features = get_accepted_features(features, proposed_feature)
    evaluator = GFSSFPruningEvaluator(
        X_df, y, accepted_features, proposed_feature)
    redundant_features = evaluator.prune()

    # propose removal
    for feature in redundant_features:
        logger.debug(PRUNER_MESSAGE + feature.source)

    return redundant_features
1262173
function() {
      var t = this,
          components = t.model.get('components');
      components.remove(components.models);
      t.showSettings();
    }
800835
public function clearFeatureData($feature)
    {
        $feature = $this->get($feature);
        if ($feature) {
            $feature->setData(array());
            $this->save($feature);
        }
    }