Update the density estimates for each object.

@param rbod_score Density storage
@param referenceDists Distances from current reference point
421400
protected void updateDensities(WritableDoubleDataStore rbod_score, DoubleDBIDList referenceDists) {
    DoubleDBIDListIter it = referenceDists.iter();
    for(int l = 0; l < referenceDists.size(); l++) {
      double density = computeDensity(referenceDists, it, l);
      // computeDensity modified the iterator, reset:
      it.seek(l);
      // NaN indicates the first run.
      if(!(density > rbod_score.doubleValue(it))) {
        rbod_score.putDouble(it, density);
      }
    }
  }
739575
synchronized void updateCloudAnchors(Collection<Anchor> updatedAnchors) {
        for (Anchor anchor : updatedAnchors) {
            if (pendingAnchors.containsKey(anchor)) {
                Anchor.CloudAnchorState cloudState = anchor.getCloudAnchorState();
                if (isReturnableState(cloudState)) {
                    CloudAnchorCallback cb = pendingAnchors.get(anchor);
                    pendingAnchors.remove(anchor);
                    GVRAnchor newAnchor = mArCoreHelper.createAnchor(anchor, AR2VR_SCALE);
                    cb.onCloudUpdate(newAnchor);
                }
            }
        }
    }
484758
private void addShardedLinkValues(TableDefinition tableDef, DBObject dbObj) {
        for (FieldDefinition fieldDef : tableDef.getFieldDefinitions()) {
            if (fieldDef.isLinkField() && fieldDef.isSharded()) {
                TableDefinition extentTableDef = tableDef.getLinkExtentTableDef(fieldDef);
                Set<Integer> shardNums = getShards(extentTableDef).keySet();
                Set<String> values = getShardedLinkValues(dbObj.getObjectID(), fieldDef, shardNums);
                dbObj.addFieldValues(fieldDef.getName(), values);
            }
        }
    }
507899
protected void storeReference(int refId, Object newRef) {
        refMap.put(Integer.valueOf(refId), newRef);
    }
1212819
public void setRelatedFindings(java.util.Collection<RelatedFinding> relatedFindings) {
        if (relatedFindings == null) {
            this.relatedFindings = null;
            return;
        }

        this.relatedFindings = new java.util.ArrayList<RelatedFinding>(relatedFindings);
    }
959963
public void setObjectIdentifiers(java.util.Collection<String> objectIdentifiers) {
        if (objectIdentifiers == null) {
            this.objectIdentifiers = null;
            return;
        }

        this.objectIdentifiers = new java.util.ArrayList<String>(objectIdentifiers);
    }
640120
public void updateRecordMetrics() {
    for (Optional<Fork> fork : this.forks.keySet()) {
      if (fork.isPresent()) {
        fork.get().updateRecordMetrics();
      }
    }
  }
728291
@Override
    void findReferencedClassNames(final Set<String> referencedClassNames) {
        if (enumValue != null) {
            enumValue.findReferencedClassNames(referencedClassNames);
        } else if (classRef != null) {
            referencedClassNames.add(classRef.getClassName());
        } else if (annotationInfo != null) {
            annotationInfo.findReferencedClassNames(referencedClassNames);
        } else if (objectArrayValue != null) {
            for (final ObjectTypedValueWrapper item : objectArrayValue) {
                item.findReferencedClassNames(referencedClassNames);
            }
        }
    }
250597
@Override
    protected void onPersist(EntityMetadata entityMetadata, Object entity, Object id, List<RelationHolder> rlHolders)
    {
        MetamodelImpl metaModel = (MetamodelImpl) kunderaMetadata.getApplicationMetadata().getMetamodel(
                entityMetadata.getPersistenceUnit());

        AbstractManagedType managedType = (AbstractManagedType) metaModel.entity(entityMetadata.getEntityClazz());

        if (managedType.hasLobAttribute())
        {
            onPersistGFS(entity, id, entityMetadata, isUpdate);
        }

        else
        {
            Map<String, List<DBObject>> collections = new HashMap<String, List<DBObject>>();
            collections = onPersist(collections, entity, id, entityMetadata, rlHolders, isUpdate);
            onFlushCollection(collections);
        }
    }
860109
@Override
	public void updateReferencePoint(List<S> population) {
		List<Double> iterationMaxs = new ArrayList<>(maxs.size());
		
		for (int i = 0; i < this.getProblem().getNumberOfObjectives(); i++) {		
			iterationMaxs.add(Double.NEGATIVE_INFINITY);
		}
		
		for (S solution : population) {
			updateReferencePoint(solution);
			for (int i = 0; i < solution.getNumberOfObjectives(); i++) {				
				iterationMaxs.set(i, Math.max(iterationMaxs.get(i), solution.getObjective(i)));				
			}
		}
		
		history.add(iterationMaxs);
		
		List<Double> mean = history.mean();
		List<Double> var  = history.variance(mean);
			
		Double maxVariance = this.getMax(var);						
			
		if (maxVariance > alpha) {
			Double maxInNadir = this.getMax(this.maxs);
			for (int i = 0; i < this.getProblem().getNumberOfObjectives(); i++) 
				this.maxs.set(i, maxInNadir);						
		} else {						
			for (int i = 0; i < this.getProblem().getNumberOfObjectives(); i++) {
				if (Math.abs(maxs.get(i) - this.getReferencePoint().get(i)) < this.epsilon) {
					Double maxInMaxs = this.getMax(this.maxs);
					this.maxs.set(i,maxInMaxs);
					history.mark(i);
				} else if (iterationMaxs.get(i) > this.maxs.get(i)) {
					this.maxs.set(i, iterationMaxs.get(i) + Math.abs(iterationMaxs.get(i)-this.maxs.get(i)));
					history.mark(i);
				} else if ((var.get(i)==0.0) && history.isUnMarked(i)) {
					double v = history.getMaxObjective(i);
					this.maxs.set(i, (maxs.get(i)+v)/2.0);
					history.mark(i);
				}
				history.decreaseMark(i);
			}						
		}
	}
540899
public void addReference(String referenceSource, String referenceName, String referenceUrl) {
        final Reference ref = new Reference();
        ref.setSource(referenceSource);
        ref.setName(referenceName);
        ref.setUrl(referenceUrl);
        this.references.add(ref);
    }
240462
public void setDirectlyRelevantTypeQualifiers(MethodDescriptor methodDescriptor, Collection<TypeQualifierValue<?>> qualifiers) {
        methodToDirectlyRelevantQualifiersMap.put(methodDescriptor, qualifiers);
        allKnownQualifiers.addAll(qualifiers);
    }
1264242
private void updateHeap(final double distance, final int iid) {
    final double prevdist = kdist;
    final int previd = heap.peekValue();
    heap.replaceTopElement(distance, iid);
    kdist = heap.peekKey();
    // If the kdist improved, zap ties.
    if(kdist < prevdist) {
      numties = 0;
    }
    else {
      addToTies(previd);
    }
  }
1063333
public void updateDefinition_12_063(SpatialReferenceSystem srs) {
		if (srs != null) {
			String definition = srs.getDefinition_12_063();
			if (definition != null) {
				updateDefinition_12_063(srs.getSrsId(), definition);
			}
		}
	}
1081930
def update_distant_reference(self, ref):
        
        self.validate_reference_data(ref["data"])
        self._zotero_lib.update_item(ref)
753394
public void setReferenceResolver (ReferenceResolver referenceResolver) {
		if (referenceResolver == null) throw new IllegalArgumentException("referenceResolver cannot be null.");
		this.references = true;
		this.referenceResolver = referenceResolver;
		if (TRACE) trace("kryo", "Reference resolver: " + referenceResolver.getClass().getName());
	}
664623
protected void computePDists(Relation<O> relation, KNNQuery<O> knn, WritableDoubleDataStore pdists) {
    // computing PRDs
    FiniteProgress prdsProgress = LOG.isVerbose() ? new FiniteProgress("pdists", relation.size(), LOG) : null;
    for(DBIDIter iditer = relation.iterDBIDs(); iditer.valid(); iditer.advance()) {
      final KNNList neighbors = knn.getKNNForDBID(iditer, kreach + 1); // +
                                                                       // query
                                                                       // point
      // use first kref neighbors as reference set
      int ks = 0;
      double ssum = 0.;
      for(DoubleDBIDListIter neighbor = neighbors.iter(); neighbor.valid() && ks < kreach; neighbor.advance()) {
        if(DBIDUtil.equal(neighbor, iditer)) {
          continue;
        }
        final double d = neighbor.doubleValue();
        ssum += d * d;
        ks++;
      }
      double pdist = ks > 0 ? FastMath.sqrt(ssum / ks) : 0.;
      pdists.putDouble(iditer, pdist);
      LOG.incrementProcessed(prdsProgress);
    }
    LOG.ensureCompleted(prdsProgress);
  }