/** {@inheritDoc} */ @Override public double incrementCount(E key, double count) { if (tempMDouble == null) { tempMDouble = new MutableDouble(); } MutableDouble oldMDouble = map.put(key, tempMDouble); totalCount += count; if (oldMDouble != null) { count += oldMDouble.doubleValue(); } tempMDouble.set(count); tempMDouble = oldMDouble; return count; }
continue; MutableDouble deltaI = new MutableDouble(); boolean fl = iterate(i, eps, deltaI); if (fl) { flag = true; updateConds(i, deltaI.doubleValue());
/** This is used internally to the class for getting back a * MutableDouble in a remove operation. Not for public use. * * @param key The key to remove * @return Its value as a MutableDouble */ private MutableDouble mutableRemove(E key) { MutableDouble md = map.remove(key); if (md != null) { totalCount -= md.doubleValue(); } return md; }
@Override public double valueAt(double[] x) { Counter<String> xC = arrayToCounter(keys, x); double penalty = 0.0; for (Map.Entry<String, Double> el : xC.entrySet()) if (el.getValue() < 0 && MERT.generativeFeatures.contains(el.getKey())) penalty += BAD_WEIGHT_PENALTY; double curEval = MERT.evalAtPoint(nbest, xC, emetric) - penalty; if (curEval > bestEval.doubleValue()) bestEval.set(curEval); it.set(it.intValue() + 1); System.err.printf("current eval(%d): %.5f - best eval: %.5f\n", it.intValue(), curEval, bestEval.doubleValue()); return -curEval; }
@Override public boolean contains(Object v) { return v instanceof Double && map.values().contains(new MutableDouble((Double) v)); }
/** * Iteration for lambda[index]. * Returns true if this lambda hasn't converged. A lambda is deemed * converged if the change found for it is smaller then the parameter eps. */ boolean iterate(int index, double err, MutableDouble ret) { double deltaL = 0.0; deltaL = newton(deltaL, index, err); //log.info("delta is "+deltaL+" feature "+index+" expectation "+ftildeArr[index]); if (Math.abs(deltaL + lambda[index]) > 200) { if ((deltaL + lambda[index]) > 200) { deltaL = 200 - lambda[index]; } else { deltaL = -lambda[index] - 200; } log.info("set delta to smth " + deltaL); } lambda[index] = lambda[index] + deltaL; if (Double.isNaN(deltaL)) { log.info(" NaN " + index + ' ' + deltaL); } ret.set(deltaL); return (Math.abs(deltaL) >= eps); }
continue; MutableDouble deltaI = new MutableDouble(); boolean fl = iterate(i, eps, deltaI); if (fl) { updateConds(i, deltaI.doubleValue());
/** {@inheritDoc} */ @Override public double remove(E key) { MutableDouble d = mutableRemove(key); // this also updates totalCount if(d != null) { return d.doubleValue(); } return defaultValue; }
@Override public boolean contains(Object v) { return v instanceof Double && map.values().contains(new MutableDouble((Double) v)); }
/** * Iteration for lambda[index]. * * @return true if this lambda hasn't converged. */ @SuppressWarnings({"UnusedDeclaration"}) boolean iterate(int index, double err, MutableDouble ret) { double deltaL = 0.0; deltaL = newton(deltaL, index, err); lambda[index] = lambda[index] + deltaL; if (!(deltaL == deltaL)) { System.err.println(" NaN " + index + ' ' + deltaL); } ret.set(deltaL); return (Math.abs(deltaL) >= eps); }
/** {@inheritDoc} */ @Override public void setCount(E key, double count) { if (tempMDouble == null) { //System.out.println("creating mdouble"); tempMDouble = new MutableDouble(); } //System.out.println("setting mdouble"); tempMDouble.set(count); //System.out.println("putting mdouble in map"); tempMDouble = map.put(key, tempMDouble); //System.out.println("placed mDouble in map"); totalCount += count; if (tempMDouble != null) { totalCount -= tempMDouble.doubleValue(); } }
continue; MutableDouble deltaI = new MutableDouble(); boolean fl = iterate(i, eps, deltaI); if (fl) { flag = true; updateConds(i, deltaI.doubleValue());
Double value1 = new Double(value.doubleValue()); if (useLists) { s.add(new Entry<>(Arrays.asList(newKey), value1));
@Override public boolean contains(Object v) { return v instanceof Double && map.values().contains(new MutableDouble((Double) v)); }
/** * Iteration for lambda[index]. * Returns true if this lambda hasn't converged. A lambda is deemed * converged if the change found for it is smaller then the parameter eps. */ boolean iterate(int index, double err, MutableDouble ret) { double deltaL = 0.0; deltaL = newton(deltaL, index, err); //System.err.println("delta is "+deltaL+" feature "+index+" expectation "+ftildeArr[index]); if (Math.abs(deltaL + lambda[index]) > 200) { if ((deltaL + lambda[index]) > 200) { deltaL = 200 - lambda[index]; } else { deltaL = -lambda[index] - 200; } System.err.println("set delta to smth " + deltaL); } lambda[index] = lambda[index] + deltaL; if (Double.isNaN(deltaL)) { System.err.println(" NaN " + index + ' ' + deltaL); } ret.set(deltaL); return (Math.abs(deltaL) >= eps); }
/** {@inheritDoc} */ @Override public double logIncrementCount(E key, double count) { if (tempMDouble == null) { tempMDouble = new MutableDouble(); } MutableDouble oldMDouble = map.put(key, tempMDouble); if (oldMDouble != null) { count = SloppyMath.logAdd(count, oldMDouble.doubleValue()); totalCount += count - oldMDouble.doubleValue(); } else { totalCount += count; } tempMDouble.set(count); tempMDouble = oldMDouble; return count; }
continue; MutableDouble deltaI = new MutableDouble(); boolean fl = iterate(i, eps, deltaI); if (fl) { flag = true; updateConds(i, deltaI.doubleValue());
/** This is used internally to the class for getting back a * MutableDouble in a remove operation. Not for public use. * * @param key The key to remove * @return Its value as a MutableDouble */ private MutableDouble mutableRemove(E key) { MutableDouble md = map.remove(key); if (md != null) { totalCount -= md.doubleValue(); } return md; }
@Override public boolean contains(Object v) { return v instanceof Double && map.values().contains(new MutableDouble((Double) v)); }
/** * Iteration for lambda[index]. * Returns true if this lambda hasn't converged. A lambda is deemed * converged if the change found for it is smaller then the parameter eps. */ boolean iterate(int index, double err, MutableDouble ret) { double deltaL = 0.0; deltaL = newton(deltaL, index, err); //System.out.println("delta is "+deltaL+" feature "+index+" expectation "+ftildeArr[index]); if (Math.abs(deltaL + lambda[index]) > 200) { if ((deltaL + lambda[index]) > 200) { deltaL = 200 - lambda[index]; } else { deltaL = -lambda[index] - 200; } System.err.println("set delta to smth " + deltaL); } lambda[index] = lambda[index] + deltaL; if (Double.isNaN(deltaL)) { System.err.println(" NaN " + index + ' ' + deltaL); } ret.set(deltaL); return (Math.abs(deltaL) >= eps); }