private static void patchHiDPI(UIDefaults defaults) {
if (!JBUI.isHiDPI()) return;
List<String> myIntKeys = Arrays.asList("Tree.leftChildIndent", "Tree.rightChildIndent");
List<String> patched = new ArrayList<String>();
for (Map.Entry<Object, Object> entry : defaults.entrySet()) {
Object value = entry.getValue();
String key = entry.getKey().toString();
if (value instanceof DimensionUIResource) {
entry.setValue(JBUI.size((DimensionUIResource) value).asUIResource());
} else if (value instanceof InsetsUIResource) {
entry.setValue(JBUI.insets(((InsetsUIResource) value)).asUIResource());
} else if (value instanceof Integer) {
if (key.endsWith(".maxGutterIconWidth") || myIntKeys.contains(key)) {
if (!"true".equals(defaults.get(key + ".hidpi.patched"))) {
entry.setValue(Integer.valueOf(JBUI.scale((Integer) value)));
patched.add(key);
}
}
}
}
for (String key : patched) {
defaults.put(key + ".hidpi.patched", "true");
}
}
/**
* Utility method that replaces the values of a {@link Map}, which must be instances of {@link
* List}, with unmodifiable equivalents.
*
* @param map The map whose values are to be made unmodifiable.
*/
protected static void makeMappedListsUnmodifiable(Map map) {
for (Iterator it = map.entrySet().iterator(); it.hasNext(); ) {
Map.Entry entry = (Map.Entry) it.next();
List value = (List) entry.getValue();
if (value.size() == 0) {
entry.setValue(Collections.EMPTY_LIST);
} else {
entry.setValue(Collections.unmodifiableList(value));
}
}
}
/*
* (non-Javadoc)
*
* @see jaskell.compiler.JaskellVisitor#visit(jaskell.compiler.core.Module)
*/
public Object visit(Namespace a) {
/* set current namespace */
ns = a;
/*
* visit definitions We set an infinite loop to cope with modifications
* introduced by visiting sub expressions. When something is modified -
* through lift - we restart the whole process. TODO : change this to defer
* registering new bindings at end
*/
while (true) {
try {
Iterator it = a.getAllBindings().entrySet().iterator();
while (it.hasNext()) {
Map.Entry entry = (Map.Entry) it.next();
String functionName = (String) entry.getKey();
Expression def = (Expression) entry.getValue();
if (def instanceof Abstraction)
((Abstraction) def).setClassName(ns.getName() + "." + functionName);
log.finest("Analyzing lifting for " + functionName);
lift = false;
entry.setValue((Expression) def.visit(this));
}
break;
} catch (ConcurrentModificationException cmex) {
/* restart the process */
}
}
return a;
}
private void resolveVariables(Context ctx, Properties initProps) {
for (Map.Entry<Object, Object> entry : initProps.entrySet()) {
if (entry.getValue() != null) {
entry.setValue(ctx.replaceTokens((String) entry.getValue()));
}
}
}
public void testSimple() throws Exception {
File tmp = new File("tmp");
PersistentMap<String> pm = new PersistentMap<String>(new File(tmp, "simple"), String.class);
try {
assertNull(pm.put("abc", "def"));
assertEquals("def", pm.get("abc"));
pm.close();
PersistentMap<String> pm2 = new PersistentMap<String>(new File(tmp, "simple"), String.class);
assertEquals("def", pm2.get("abc"));
assertEquals(Arrays.asList("abc"), new ArrayList<String>(pm2.keySet()));
for (Map.Entry<String, String> e : pm2.entrySet()) {
e.setValue("XXX");
}
assertEquals("XXX", pm2.get("abc"));
pm2.close();
} finally {
pm.close();
IO.delete(tmp);
}
}
public static HashMap<Character, Integer> Count(
ArrayList<String> inputList, ArrayList<Character> inputCharList) {
ArrayList<String> tempList = inputList;
ArrayList<Character> tempCharList = inputCharList;
HashMap<Character, Integer> result = new HashMap<Character, Integer>();
for (int i = 0; i < 33; i++) {
result.put(tempCharList.get(i), 0);
}
for (int i = 0; i < 10; i++) {
char[] listItemToCharArray = tempList.get(i).toCharArray();
for (Map.Entry<Character, Integer> pair : result.entrySet()) {
for (int j = 0; j < listItemToCharArray.length; j++) {
if (listItemToCharArray[j] == pair.getKey()) {
int charCount = pair.getValue();
charCount++;
pair.setValue(charCount);
}
}
}
}
return result;
}
private void makePriorInfluence(Map<String, Double> probabilites) {
if (probabilites != null) {
model.priorDenominator++;
for (Map.Entry<String, Double> e : model.categoryPriors.entrySet()) {
e.setValue(e.getValue() + probabilites.get(e.getKey()));
}
}
}
private void undoPriorInfluence(Map<String, Double> probabilites) {
if (probabilites != null && probabilites.size() > 0) {
model.priorDenominator--;
for (Map.Entry<String, Double> e : model.categoryPriors.entrySet()) {
e.setValue(e.getValue() - probabilites.get(e.getKey()));
}
}
}
// Called with lock held
protected void flushAccumulatedCredits() {
if (accumulated_credits > 0) {
for (Map.Entry<Address, Long> entry : this.credits.entrySet()) {
entry.setValue(Math.max(0, entry.getValue().longValue() - accumulated_credits));
}
accumulated_credits = 0;
}
}
/*
* (non-Javadoc)
*
* @see jaskell.compiler.JaskellVisitor#visit(jaskell.compiler.core.Alternative)
*/
public Object visit(Alternative a) {
Iterator it = a.getChoices();
while (it.hasNext()) {
Map.Entry entry = (Map.Entry) it.next();
Expression body = (Expression) entry.getValue();
entry.setValue(body.visit(this));
}
return a;
}
@Test
public void main() {
Map m = new AHTMap();
m.put(key, oldValue);
Map.Entry e = (Map.Entry) m.entrySet().iterator().next();
Object returnVal = e.setValue(newValue);
assertTrue(returnVal.equals(oldValue));
assertEquals(m.get(key), newValue);
}
protected void initAuFeatureMap() {
if (definitionMap.containsKey(DefinableArchivalUnit.KEY_AU_FEATURE_URL_MAP)) {
Map<String, ?> featMap = definitionMap.getMap(DefinableArchivalUnit.KEY_AU_FEATURE_URL_MAP);
for (Map.Entry ent : featMap.entrySet()) {
Object val = ent.getValue();
if (val instanceof Map) {
ent.setValue(MapUtil.expandAlternativeKeyLists((Map) val));
}
}
}
}
public void replenishAll() {
lock.lock();
try {
flushAccumulatedCredits();
for (Map.Entry<Address, Long> entry : credits.entrySet()) entry.setValue(max_credits);
min_credits = computeLowestCredit();
credits_available.signalAll();
} finally {
lock.unlock();
}
}
/**
* Decrements credits bytes from all elements and add new_credits to member (if non null). The
* lowest credit needs to be greater than min_credits. Needs to be called with lock held
*
* @param member The member to which new_credits are added. NOP if null
* @param new_credits Number of bytes to add to member. NOP if 0.
*/
protected void decrementAndAdd(Address member, long new_credits) {
boolean replenish = member != null && new_credits > 0;
if (accumulated_credits > 0) {
for (Map.Entry<Address, Long> entry : this.credits.entrySet()) {
entry.setValue(Math.max(0, entry.getValue().longValue() - accumulated_credits));
if (replenish) {
Address tmp = entry.getKey();
if (tmp.equals(member))
entry.setValue(Math.min(max_credits, entry.getValue().longValue() + new_credits));
}
}
accumulated_credits = 0;
} else {
if (replenish) {
Long val = this.credits.get(member);
if (val != null)
this.credits.put(member, Math.min(max_credits, val.longValue() + new_credits));
}
}
}
/**
* Assumes the input map always has String keys and the values are of types: String, Version,
* Long, Double or List of the previous types. Lists are copied and Version objects are converted
* to String objects.
*/
private static Map<String, Object> newAttributesMapDTO(Map<String, Object> map) {
Map<String, Object> dto = new HashMap<String, Object>(map);
/* Lists are copied and Version objects are converted to String objects. */
for (Map.Entry<String, Object> entry : dto.entrySet()) {
Object value = entry.getValue();
if (value instanceof Version) {
entry.setValue(String.valueOf(value));
continue;
}
if (value instanceof List) {
List<Object> newList = new ArrayList<Object>((List<?>) value);
for (ListIterator<Object> iter = newList.listIterator(); iter.hasNext(); ) {
Object element = iter.next();
if (element instanceof Version) {
iter.set(String.valueOf(element));
}
}
entry.setValue(newList);
continue;
}
}
return dto;
}
public static void main(String[] args) {
long start = System.currentTimeMillis();
Scanner input = new Scanner(System.in);
int numberOfTestCases = input.nextInt();
ArrayList<Integer> order = new ArrayList<Integer>(numberOfTestCases);
int previousKey = -1;
int previousValue = 0;
int cycleNumber = 0;
Map<Integer, Integer> testCases = new TreeMap<Integer, Integer>();
for (int i = 0; i < numberOfTestCases; i++) {
int numberOfCycles = input.nextInt();
testCases.put(numberOfCycles, 1);
order.add(numberOfCycles);
}
for (Map.Entry<Integer, Integer> entry : testCases.entrySet()) {
int numberOfCycles;
int initialHeight;
if (previousKey == -1) {
numberOfCycles = entry.getKey();
initialHeight = entry.getValue();
} else {
numberOfCycles = entry.getKey() - previousKey;
initialHeight = previousValue;
}
for (int i = 0; i < numberOfCycles; i++) {
if (cycleNumber % 2 == 0) {
initialHeight *= 2;
} else {
initialHeight += 1;
}
cycleNumber++;
}
entry.setValue(initialHeight);
previousKey = entry.getKey();
previousValue = initialHeight;
}
for (Integer element : order) {
System.out.println(testCases.get(element));
}
long elapsed = System.currentTimeMillis() - start;
System.out.println("time: " + elapsed);
}
public Expression transform(Expression exp) {
if (exp == null) return null;
if (exp.getClass() == VariableExpression.class) {
return transformVariableExpression((VariableExpression) exp);
}
if (exp.getClass() == BinaryExpression.class) {
return transformBinaryExpression((BinaryExpression) exp);
}
if (exp.getClass() == PropertyExpression.class) {
return transformPropertyExpression((PropertyExpression) exp);
}
if (exp.getClass() == MethodCallExpression.class) {
return transformMethodCallExpression((MethodCallExpression) exp);
}
if (exp.getClass() == ClosureExpression.class) {
return transformClosureExpression((ClosureExpression) exp);
}
if (exp.getClass() == ConstructorCallExpression.class) {
return transformConstructorCallExpression((ConstructorCallExpression) exp);
}
if (exp.getClass() == ArgumentListExpression.class) {
Expression result = exp.transformExpression(this);
if (inPropertyExpression) {
foundArgs = result;
}
return result;
}
if (exp instanceof ConstantExpression) {
Expression result = exp.transformExpression(this);
if (inPropertyExpression) {
foundConstant = result;
}
if (inAnnotation && exp instanceof AnnotationConstantExpression) {
ConstantExpression ce = (ConstantExpression) result;
if (ce.getValue() instanceof AnnotationNode) {
// replicate a little bit of AnnotationVisitor here
// because we can't wait until later to do this
AnnotationNode an = (AnnotationNode) ce.getValue();
Map<String, Expression> attributes = an.getMembers();
for (Map.Entry<String, Expression> entry : attributes.entrySet()) {
Expression attrExpr = transform(entry.getValue());
entry.setValue(attrExpr);
}
}
}
return result;
}
return exp.transformExpression(this);
}
@Test
public void canUseEntrySet() {
Map<String, String> map = new HashMap<>();
map.put("key1", "value1");
map.put("key2", "value2");
map.put("key3", "value3");
Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String, String> entry : entries) {
entry.setValue("bob");
}
assertEquals("bob", map.get("key1"));
assertEquals("bob", map.get("key2"));
assertEquals("bob", map.get("key3"));
}
// This function will add elements in timeoutTargets
boolean timeout() {
timeoutTargets.clear();
for (Map.Entry<ActorRef, Boolean> probeEntry : probes.entrySet()) {
if (!probeEntry.getValue()) {
int timeoutTime = timeoutTimes.get(probeEntry.getKey());
++timeoutTime;
System.out.println("Timeout!!!!!!!!!!!!!!!!!!TimeoutTime: " + timeoutTime);
if (timeoutTime >= reactionFactor) {
timeoutTargets.offer(probeEntry.getKey());
timeoutTimes.put(probeEntry.getKey(), 0);
// It's time to do split, we don't want the history
} else timeoutTimes.put(probeEntry.getKey(), timeoutTime);
}
probeEntry.setValue(false);
}
++currentId; // Probes with old id will be treated as timeout probe
return !timeoutTargets.isEmpty();
}
private void refreshLineMarkers() {
for (Map.Entry<RangeMarker, LineMarkerInfo> entry : myLineMarkerInfos.entrySet()) {
RangeMarker rangeMarker = entry.getKey();
int startOffset = rangeMarker.getStartOffset();
int endOffset = rangeMarker.getEndOffset();
LineMarkerInfo value = entry.getValue();
PsiElement element = value.getElement();
assert element != null : value;
TextRange range = new TextRange(startOffset, endOffset);
final String tooltip = value.getLineMarkerTooltip();
LineMarkerInfo markerInfo =
new LineMarkerInfo<>(
element,
range,
null,
value.updatePass,
e -> tooltip,
null,
GutterIconRenderer.Alignment.RIGHT);
entry.setValue(markerInfo);
}
}
void bar(List<String> list, HashMap<String, Integer> map) {
char c = "a".charAt(0);
byte b = new Integer(10).byteValue();
int i = new Double(10.1).intValue();
float f = new Double(10.1).floatValue();
long l = new Double(10.1).longValue();
short s = new Double(10.1).shortValue();
try {
String removed = list.remove(10);
Boolean isRemoved = list.remove("a");
} catch (Exception e) {
System.err.println(e.getMessage());
throw new RuntimeException(e.getCause());
}
for (Map.Entry<String, Integer> entry : map.entrySet()) {
String key = entry.getKey();
Integer value = entry.getValue();
entry.setValue(value + 1);
}
}
/**
* Removes all members from a given view which don't have us in their view
* (https://jira.jboss.org/browse/JGRP-1061). Example:
*
* <pre>
* A: AB
* B: AB
* C: ABC
* </pre>
*
* becomes
*
* <pre>
* A: AB
* B: AB
* C: C // A and B don't have C in their views
* </pre>
*
* @param map A map of members and their associated views
*/
public static void sanitizeViews(Map<Address, View> map) {
if (map == null) return;
for (Map.Entry<Address, View> entry : map.entrySet()) {
Address key = entry.getKey();
Collection<Address> members = new ArrayList<Address>(entry.getValue().getMembers());
boolean modified = false;
for (Iterator<Address> it = members.iterator(); it.hasNext(); ) {
Address val = it.next();
if (val.equals(key)) // we can always talk to ourself !
continue;
View view = map.get(val);
final Collection<Address> tmp_mbrs = view != null ? view.getMembers() : null;
if (tmp_mbrs != null && !tmp_mbrs.contains(key)) {
it.remove();
modified = true;
}
}
if (modified) {
View old_view = entry.getValue();
entry.setValue(new View(old_view.getVid(), members));
}
}
}
private void refreshLineMarkers() {
for (Map.Entry<RangeMarker, LineMarkerInfo> entry : lineMarkerInfos.entrySet()) {
RangeMarker rangeMarker = entry.getKey();
int startOffset = rangeMarker.getStartOffset();
int endOffset = rangeMarker.getEndOffset();
final LineMarkerInfo value = entry.getValue();
LineMarkerInfo markerInfo =
new LineMarkerInfo<PsiElement>(
value.getElement(),
new TextRange(startOffset, endOffset),
null,
value.updatePass,
new Function<PsiElement, String>() {
@Override
public String fun(PsiElement psiElement) {
return value.getLineMarkerTooltip();
}
},
null,
GutterIconRenderer.Alignment.RIGHT);
entry.setValue(markerInfo);
}
}
/** pollLastEntry returns entries in order */
public void testDescendingPollLastEntry() {
ConcurrentNavigableMap map = dmap5();
Map.Entry e = map.pollLastEntry();
assertEquals(m5, e.getKey());
assertEquals("E", e.getValue());
e = map.pollLastEntry();
assertEquals(m4, e.getKey());
map.put(m5, "E");
e = map.pollLastEntry();
assertEquals(m5, e.getKey());
assertEquals("E", e.getValue());
e = map.pollLastEntry();
assertEquals(m3, e.getKey());
map.remove(m2);
e = map.pollLastEntry();
assertEquals(m1, e.getKey());
try {
e.setValue("E");
shouldThrow();
} catch (UnsupportedOperationException success) {
}
e = map.pollLastEntry();
assertNull(e);
}
/** pollLastEntry returns entries in order */
public void testPollLastEntry() {
ConcurrentNavigableMap map = map5();
Map.Entry e = map.pollLastEntry();
assertEquals(five, e.getKey());
assertEquals("E", e.getValue());
e = map.pollLastEntry();
assertEquals(four, e.getKey());
map.put(five, "E");
e = map.pollLastEntry();
assertEquals(five, e.getKey());
assertEquals("E", e.getValue());
e = map.pollLastEntry();
assertEquals(three, e.getKey());
map.remove(two);
e = map.pollLastEntry();
assertEquals(one, e.getKey());
try {
e.setValue("E");
shouldThrow();
} catch (UnsupportedOperationException success) {
}
e = map.pollLastEntry();
assertNull(e);
}
public Object setValue(Object o) {
if (!predicate.evaluate(o)) {
throw new IllegalArgumentException("Cannot set value - Predicate rejected it");
}
return entry.setValue(o);
}
private void recalculateWalkMap() {
for (Map.Entry<Point, Integer> entry : walkAt.entrySet()) {
entry.setValue(getMinesNear(entry.getKey()));
}
}
public V setValue(V value) {
V old = internalEntry.getValue();
Checker.checkType(value);
internalEntry.setValue(value);
return old;
}
static void twoMapTest2(Map s, Object[] key, Object[] absent) {
int size = key.length;
Map s2 = newMap();
putAllTest("Add Absent ", size, s, s2);
putAllTest("Modify Present ", size, s, s2);
Object lastkey = kitTest(s2, size);
Object hold = s2.get(lastkey);
int sum = 0;
timer.start("Traverse entry ", size * 12); // 12 until finish
int sh1 = s.hashCode() - s2.hashCode();
reallyAssert(sh1 == 0);
boolean eq1 = s2.equals(s);
boolean eq2 = s.equals(s2);
reallyAssert(eq1 && eq2);
Set es2 = s2.entrySet();
for (Iterator it = s.entrySet().iterator(); it.hasNext(); ) {
Object entry = it.next();
if (es2.contains(entry)) ++sum;
}
reallyAssert(sum == size);
s2.put(lastkey, MISSING);
int sh2 = s.hashCode() - s2.hashCode();
reallyAssert(sh2 != 0);
eq1 = s2.equals(s);
eq2 = s.equals(s2);
reallyAssert(!eq1 && !eq2);
sum = 0;
for (Iterator it = s.entrySet().iterator(); it.hasNext(); ) {
Map.Entry e = (Map.Entry) it.next();
e.setValue(absent[sum++]);
}
reallyAssert(sum == size);
for (Iterator it = s2.entrySet().iterator(); it.hasNext(); ) {
Map.Entry e = (Map.Entry) it.next();
e.setValue(s.get(e.getKey()));
}
timer.finish();
int rmiss = 0;
timer.start("Remove Present ", size * 2);
Iterator s2i = s2.entrySet().iterator();
Set es = s.entrySet();
while (s2i.hasNext()) {
if (!es.remove(s2i.next())) ++rmiss;
}
timer.finish();
reallyAssert(rmiss == 0);
clrTest(size, s2);
reallyAssert(s2.isEmpty() && s.isEmpty());
}
public static void main(String[] args) {
MovesReader reader = new MovesReader();
// reader.setNewFomat(true);
// reader.setFilterDays("0,1,2,3,4,5");
reader.load("/Users/emilio/Desktop/GraphStreamTest/files/export_lunesCOPY.txt");
Graph g = reader.getG();
Iterator<Node> it = reader.getG().iterator();
ArrayList<ClusterWert> services = new ArrayList<ClusterWert>();
Date date = new Date();
try {
BufferedWriter writer =
new BufferedWriter(new FileWriter("resultado" + date.toString() + ".csv"));
// Transforming data stored into GraphStream into ClusterWert data structure
while (it.hasNext()) {
Node next = it.next();
Service s = new Service(next.getId());
if (s.fillIn(next)) {
ClusterWert cluster = new ClusterWert(s);
services.add(cluster);
} else System.out.println("Error al procesar " + s.toString());
}
CachedDistance cache = CachedDistance.getInstance();
double lastBestdistance = Double.MAX_VALUE;
long startTime = System.nanoTime();
if (true) {
// HashSet<ClusterWertDistance> distances = new HashSet<ClusterWertDistance>();
TreeMap<ClusterWertDistance, Double> distances = new TreeMap<ClusterWertDistance, Double>();
do {
if (services.size() == 497) System.out.println("a");
int bestPosI = 0;
int bestPosJ = 0;
double bestDistance = Double.MAX_VALUE;
ClusterWertDistance best = new ClusterWertDistance();
int skiped = 0;
for (int j = 0; j < services.size(); j++) {
ClusterWert cIni = services.get(j);
ClusterWertDistance distance = new ClusterWertDistance(cIni);
// Distance measured in milliseconds.
double lowerBoundDistance =
(cIni.getDistance() == -1)
? cIni.getServices().get(0).getDuration() * 60 * 1000
: cIni.getDistance();
double lowerDistance =
(distances.firstEntry() != null)
? distances.firstEntry().getValue()
: Double.MAX_VALUE;
if (!distances.containsKey(distance) && lowerBoundDistance < lowerDistance) {
for (int i = j + 1; i < services.size(); i++) {
// lowerBoundDistance += (services.get(j).getDistance()==-1) ?
// services.get(j).getServices().get(0).getDuration()*60*1000 :
// services.get(j).getDistance();
// if(lowerBoundDistance < lowerDistance){
ClusterWert aux = cache.getMinimumDistanceOther(cIni, services.get(i));
double auxDistance = aux.getDistance();
if (auxDistance != -1) {
distance.addElement(auxDistance, aux, services.get(i));
}
// }
}
if (distance.getBest_distance() != -1)
distances.put(distance, distance.getBest_distance());
} else skiped++;
}
Iterator<Map.Entry<ClusterWertDistance, Double>> iter = distances.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry<ClusterWertDistance, Double> pair = iter.next();
ClusterWertDistance aux = pair.getKey();
double auxDistance = aux.getBest_distance();
if (auxDistance != -1 && auxDistance < bestDistance) {
if (services.contains(aux.getOrigin())) {
bestDistance = auxDistance;
best = pair.getKey();
} else distances.remove(pair.getKey());
}
}
if (bestDistance < lastBestdistance) System.out.println("ERRROR ");
ArrayList<ClusterWert> toDelete = new ArrayList<ClusterWert>();
if (bestDistance != Double.MAX_VALUE) {
Double firstKey = best.getDistances().firstKey();
ClusterWert original = best.getOriginal().get(best.getDistances().get(firstKey));
System.out.println(
"MIx "
+ services.indexOf(best.getOrigin())
+ " con "
+ services.indexOf(original)
+ " currentSize "
+ services.size()
+ " distance: "
+ bestDistance
+ " skipped: "
+ skiped);
System.out.println(
"Cache Size "
+ cache.getCache1().size()
+ " A: "
+ cache.getAciertos()
+ " F: "
+ cache.getFallos());
services.remove(best.getOrigin());
toDelete.add(best.getOrigin());
services.remove(original);
toDelete.add(original);
Double bestKey = best.getDistances().firstKey();
services.add(0, best.getDistances().get(bestKey));
distances.remove(best);
lastBestdistance = bestDistance;
} else {
System.out.println("TODOS LEJOS");
break;
}
iter = distances.entrySet().iterator();
/*
while(iter.hasNext())
{
Map.Entry<ClusterWertDistance,Double> pair = iter.next();
ClusterWertDistance aux = pair.getKey();
double auxDistance = aux.getBest_distance();
if(auxDistance!=-1 && auxDistance < bestDistance){
if(services.contains(aux.getOrigin())){
bestDistance = auxDistance;
best = pair.getKey();
}else
distances.remove(pair);
}
} */
while (iter.hasNext()) {
Map.Entry<ClusterWertDistance, Double> pair = iter.next();
double auxDistance = pair.getValue();
ClusterWertDistance aux = pair.getKey();
for (ClusterWert w : toDelete) aux.removeOriginalCluster(w);
if (!services.contains(aux.getOrigin()) || aux.getDistances().size() == 0)
iter.remove();
pair.setValue(pair.getKey().getBest_distance());
}
// equals.remove(i);
// TODO iterate over equals in order to mix all other elements up.
} while (services.size() > 1);
}
String strLine;
int i = 1;
writer.write(
"ID\tIDServices\tNum Services\tH first \tH last\tLast Service Time (includes duration)\tDistance\tService Time\tTravel Time\tWaiting time");
writer.newLine();
for (ClusterWert c : services) {
writer.write(i + "\t" + c.toCSV());
writer.newLine();
i++;
}
long elapsedTime = System.nanoTime() - startTime;
writer.write(String.valueOf(elapsedTime / 1000000));
writer.flush();
writer.close();
GoogleMaps google = new GoogleMaps(false);
date = new Date();
google.generateHtml(services, "prueba" + date.toString() + ".html");
System.out.print("ASDASD");
} catch (IOException e) {
e.printStackTrace();
}
}
