public boolean execute(K key, double value) { put(key, value); return true; } };
@Override public TObjectDoubleMap<String> getRunningMean() { TObjectDoubleMap<String> activityToMeanMap = new TObjectDoubleHashMap<>(); setExecutionTimeRunningMean.setActivityToMeanMap(activityToMeanMap); setExecutionTimeRunningMean.setFactor(1.0 / executionData.size()); runningExecutionTotals.forEachEntry(setExecutionTimeRunningMean); return activityToMeanMap; }
public void readExternal( ObjectInput in ) throws IOException, ClassNotFoundException { // VERSION in.readByte(); // SUPER super.readExternal( in ); // NO_ENTRY_VALUE no_entry_value = in.readDouble(); // NUMBER OF ENTRIES int size = in.readInt(); setUp( size ); // ENTRIES while (size-- > 0) { //noinspection unchecked K key = ( K ) in.readObject(); double val = in.readDouble(); put(key, val); } }
@Override public TObjectDoubleHashMap<MolecularFormula> recombinate(TObjectDoubleHashMap<MolecularFormula> source, double normalizationConstant) { final TObjectDoubleHashMap<MolecularFormula> recombination = new TObjectDoubleHashMap<MolecularFormula> (source.size()*losses.size()); for (MolecularFormula loss : losses) { for (MolecularFormula f : source.keySet()) { final MolecularFormula recomb = loss.add(f); final double score = source.get(f)+penalty; if (score < 0) continue; if (!source.containsKey(recomb) || source.get(recomb)<score) recombination.put(recomb, score); } } return recombination; }
private static TObjectDoubleHashMap<MolecularFormula> convertMap(Map<MolecularFormula, Double> map) { final TObjectDoubleHashMap newMap = new TObjectDoubleHashMap<MolecularFormula>(map.size()); for (Map.Entry<MolecularFormula, Double> entry : map.entrySet()) newMap.put(entry.getKey(), entry.getValue()); return newMap; }
@Override public TObjectDoubleHashMap<MolecularFormula> recombinate(TObjectDoubleHashMap<MolecularFormula> source, double normalizationConstant) { final ArrayList<MolecularFormula> losses = new ArrayList<MolecularFormula>(source.keySet().size()); source.forEachEntry(new TObjectDoubleProcedure<MolecularFormula>() { @Override public boolean execute(MolecularFormula a, double b) { if (b >= 0) losses.add(a); return true; } }); final TObjectDoubleHashMap<MolecularFormula> recs = new TObjectDoubleHashMap<MolecularFormula>(source.size() * source.size() * source.size()); List<MolecularFormula> src = new ArrayList<MolecularFormula>(losses); final double gamma = 10; for (int i = 2; i <= 3; ++i) { final double score = Math.log10(gamma / i); final ArrayList<MolecularFormula> newSrc = new ArrayList<MolecularFormula>(); for (MolecularFormula f : losses) { for (MolecularFormula g : src) { newSrc.add(f.add(g)); } } src = newSrc; for (MolecularFormula f : src) recs.put(f, score); } return recs; }
final TObjectDoubleHashMap<A> cats = new TObjectDoubleHashMap<A>(); count.increment(annotation); cats.putIfAbsent(annotation, 0); cats.increment(annotation); for (final A x : cats.keySet()) Pj.add((cats.get(x) / totalCount) * (cats.get(x) / totalCount));
public void incrementCount(T object, double increment) { if (counts.containsKey(object)) { counts.put(object, counts.get(object) + increment); } else { counts.put(object, increment); } total += increment; stats.add(increment); }
@Override public <G, D, L> void exportParameters(ParameterHelper helper, DataDocument<G, D, L> document, D dictionary) { final D radicals = document.newDictionary(); for (MolecularFormula f : freeRadicals.keySet()) { document.addToDictionary(radicals, f.toString(), freeRadicals.get(f)); } document.addDictionaryToDictionary(dictionary, "commonRadicals", radicals); document.addToDictionary(dictionary, "radicalPenalty", generalRadicalScore); document.addToDictionary(dictionary, "normalization", normalization); } }
/** {@inheritDoc} */ public double[] values() { double[] vals = new double[size()]; double[] v = _values; Object[] keys = _set; for ( int i = v.length, j = 0; i-- > 0; ) { if ( keys[i] != FREE && keys[i] != REMOVED ) { vals[j++] = v[i]; } } return vals; }
writer.newLine(); String[] keys = map.keys(new String[map.size()]); if (sortByValues) { List<Tuple<String, Double>> list = new LinkedList<>(); TObjectDoubleIterator<String> it = map.iterator(); for (int i = 0; i < map.size(); i++) { it.advance(); list.add(new Tuple<>(it.key(), it.value())); writer.write(key); writer.write(TAB); writer.write(String.valueOf(map.get(key))); writer.newLine();
/** {@inheritDoc} */ public String toString() { final StringBuilder buf = new StringBuilder("{"); forEachEntry( new TObjectDoubleProcedure<K>() { private boolean first = true; public boolean execute( K key, double value ) { if ( first ) first = false; else buf.append( "," ); buf.append( key ).append( "=" ).append( value ); return true; } }); buf.append( "}" ); return buf.toString(); } } // TObjectDoubleHashMap
private Scored<C>[][] toArray(TObjectDoubleHashMap<C>[] maps) { Scored<C>[][] array = new Scored[maps.length][]; for(int i = 0; i < maps.length; ++i) { TObjectDoubleHashMap<C> map = maps[i]; Scored<C>[] scoredCandidates = new Scored[map.size()]; int j = 0; for (C candidate : map.keySet()) { scoredCandidates[j++] = new Scored(candidate, map.get(candidate)); } Arrays.sort(scoredCandidates, Scored.<C>desc()); array[i] = scoredCandidates; } return array; }
public FreeRadicalEdgeScorer(Map<MolecularFormula, Double> freeRadicals, double generalRadicalScore, double normalization) { this.freeRadicals = new TObjectDoubleHashMap<MolecularFormula>(freeRadicals.size() * 2, 0.75f, Double.NEGATIVE_INFINITY); this.freeRadicals.putAll(freeRadicals); this.generalRadicalScore = generalRadicalScore; this.normalization = normalization; }
public double getCount(T object) { if (this.counts.containsKey(object)) return this.counts.get(object); else return 0; }
@Override public Iterator<ObjectDoubleEntry<KEY>> iterator() { return new Iterator<ObjectDoubleEntry<KEY>>() { TObjectDoubleIterator<KEY> iter = paramsMap.iterator(); ObjectDoubleEntry<KEY> entry = new ObjectDoubleEntry<KEY>(); @Override public boolean hasNext() { return iter.hasNext(); } @Override public ObjectDoubleEntry<KEY> next() { iter.advance(); entry.key = iter.key(); entry.value = iter.value(); return entry; } @Override public void remove() { throw new UnsupportedOperationException("Not supported"); } }; } }