/** Show the last element in the list of adapters */
private void showList() {
if (mAdapters.isEmpty() || mAdapters.getLast().isEmpty()) {
mList.setEmptyView(mEmptyLibrary);
} else {
LibraryAdapter adapter = mAdapters.getLast();
adapter.getFilter().filter(mLastFilter);
mList.setAdapter(adapter);
if (adapter.isEmpty() || adapter.getCount() == 0) {
buildSubActionBar("", "");
} else {
MyLibraryItem item = adapter.getItem(0);
switch (item.getLevel()) {
case MyLibrary.LVL_ARTIST:
buildSubActionBar("", "");
break;
case MyLibrary.LVL_ALBUM:
buildSubActionBar(item.getArtist(), "");
break;
default:
buildSubActionBar(item.getArtist(), item.getAlbum());
break;
}
}
}
}
@Override
public String toString() {
String str = "=================================================\n";
str += "Freecells: ";
for (LinkedList<Card> freecell : freecells) {
if (freecell.isEmpty()) str += " ";
else str += freecell.getLast().toString() + " ";
}
str += "\t\tFoundations: ";
for (LinkedList<Card> foundation : foundations) {
if (foundation.isEmpty()) str += " ";
else str += foundation.getLast().toString() + "(" + foundation.size() + ") ";
}
str += "\n\n";
for (LinkedList<Card> cascade : cascades) {
if (cascade.isEmpty()) str += "\n";
else {
for (Card c : cascade) {
str += c.toString() + " ";
}
str += "\n";
}
}
str += "\nF: " + f + "\tG: " + g + "\tH: " + h + "\n";
str += "=================================================\n";
return str;
}
private void readGraph() throws IOException {
InputStream is = ProgrammingSet4.class.getResourceAsStream("SCC.txt");
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
graph = new HashMap<Integer, List<Integer>>();
rGraph = new HashMap<Integer, List<Integer>>();
String l = null;
while ((l = reader.readLine()) != null) {
LinkedList<Integer> line = readEdge(l);
List<Integer> edges = graph.get(line.getFirst());
if (edges == null) {
edges = new ArrayList<Integer>();
graph.put(line.getFirst(), edges);
}
edges.add(line.getLast());
List<Integer> rEdges = rGraph.get(line.getLast());
if (rEdges == null) {
rEdges = new ArrayList<Integer>();
rGraph.put(line.getLast(), rEdges);
}
rEdges.add(line.getFirst());
}
reader.close();
}
private void endCondition(String name) throws SAXException {
Condition cond = conditionStack.removeLast();
if (cond.isEmpty()) throw new SAXException('<' + name + "> must not be empty");
if (!values.isEmpty()) {
try {
MemberOf memberOf = (MemberOf) cond;
if (memberOf.vr.isIntType()) memberOf.setValues(parseInts(values));
else memberOf.setValues(values.toArray(new String[values.size()]));
} catch (Exception e) {
throw new SAXException("unexpected <Value> contained by <" + name + ">");
}
values.clear();
}
if (!codes.isEmpty()) {
try {
((MemberOf) cond).setValues(codes.toArray(new Code[codes.size()]));
} catch (Exception e) {
throw new SAXException("unexpected <Code> contained by <" + name + ">");
}
codes.clear();
}
if (conditionStack.isEmpty()) {
if (elementConditions) getLastDataElement().setCondition(cond.trim());
else iodStack.getLast().setCondition(cond.trim());
elementConditions = false;
itemConditions = false;
} else conditionStack.getLast().addChild(cond.trim());
}
@Override
public Object handle() throws GAIInterpreterException {
String condition = getFirstMatch(getCommand(), RH.VAL_OR_EXP);
String action = getActionName(getCommand().replace(condition, ""));
LinkedList<GAIObject> actionChain = getSession().getObjectOrAttribute(action);
if (isPathValid(action)) {
throw new GAIInterpreterException(wrongPath(actionChain));
}
Object result;
AbstractHandler handler;
if (hasMatch(condition, RH.ANY_VAL)) {
result = getValue(condition);
} else if (hasMatch(condition, RH.NUMERIC_EXP)) {
handler = new NumericExpHandler(condition, getInterpreter());
result = handler.handle();
} else if (hasMatch(condition, RH.ACT_EXE)) {
handler = new ActionExecHandler(condition, getInterpreter());
result = handler.handle();
} else {
throw new GAIInterpreterException(INVALID_FOR_CONDITION);
}
if (result == null) {
throw new GAIInterpreterException(INVALID_FOR_CONDITION);
}
if (isArray(result)) {
GAIObject arrayObject = (GAIObject) result;
for (Object e : arrayObject.getElements()) {
executeAction(actionChain.getLast(), e);
}
} else {
executeAction(actionChain.getLast(), result);
}
return null;
}
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MessageId.UPDATE_CLIENT_ID_FAIL:
{
BaseUtil.innerComm.webappclient.updateClientId(
BaseUtil.getSelfUserInfo().getUserId(), clientId);
break;
}
case MessageId.APK_DOWN_LOAD_DONE:
{
Intent intent = new Intent(Intent.ACTION_VIEW);
intent.setDataAndType(
Uri.fromFile(
new File(
FileUtil.APK_PATH + BaseUtil.getSystemInfo().getLatestClientName())),
"application/vnd.android.package-archive");
InnerCommAdapter.ct.startActivity(intent);
break;
}
default:
{
if (!innerCommQue.isEmpty()) {
Log.i(
"InnerCommAdapter",
"baseutil send msg:" + msg.what + "to->" + innerCommQue.getLast());
innerCommQue.getLast().processMessage(msg);
} else {
Log.e("BaseUtil", "UI activity innerCommQue is empty,drop msgid:!!" + msg.what);
}
break;
}
}
}
public MemorySet(
int numberOfLevels,
int[] assocs,
int[] cacheszs,
int[] blockszs,
int[] latencies,
int policy,
int mainMemoryLatency,
HashMap<Integer, int[]> initialMemory) {
if (policy == 0) {
writeThrough = true;
} else {
writeThrough = false;
}
cycles = 0;
mainMemory = new MainMemory(initialMemory, mainMemoryLatency);
caches = new LinkedList<Cache>();
// int x, y, z, cyc;
for (int i = 0; i < numberOfLevels; i++) {
caches.add(new Cache(assocs[i], cacheszs[i], blockszs[i], latencies[i]));
if (i > 0) {
caches.get(i - 1).setHigherLevel(caches.getLast());
}
}
caches.getLast().setMainMemory(mainMemory);
firstCache = caches.getFirst();
}
public static void postOrderNoIn(TreeNode root) {
if (root == null) return;
LinkedList<TreeNode> stack = new LinkedList<>();
LinkedList<Boolean> flag = new LinkedList<>();
boolean curFlag;
while (!stack.isEmpty() || root != null) {
while (root != null) {
stack.addLast(root);
flag.addLast(true);
root = root.left;
}
root = stack.getLast();
curFlag = flag.getLast();
flag.removeLast();
if (curFlag) { //
flag.addLast(false);
root = root.right;
} else {
stack.removeLast();
System.out.print(root.val + " ");
root = null; // 第一次的时候缺少这一句，陷入死循环。
}
}
}
public void addState(World x) {
double growthRate = calGrowthRate(x), deathRate = calDeathRate(x);
int population = x.getPopulation();
listPopulationChange.add(generation == 0 ? population : population - listPopulation.getLast());
listPopulation.add(population);
listGrowthRate.add(growthRate);
listDeathRate.add(deathRate);
if (generation == 1) {
minPopulation = maxPopulation = population;
maxGrowthRate = minGrowthRate = growthRate;
maxDeathRate = deathRate;
maxPopulationChange = minPopulationChange = listPopulationChange.getLast();
}
if (generation > 1) {
minPopulation = minPopulation > population ? population : minPopulation;
maxPopulation = maxPopulation < population ? population : maxPopulation;
maxGrowthRate = maxGrowthRate < growthRate ? growthRate : maxGrowthRate;
maxDeathRate = maxDeathRate < deathRate ? deathRate : maxDeathRate;
maxPopulationChange = Math.max(maxPopulationChange, listPopulationChange.getLast());
minPopulationChange = Math.min(minPopulationChange, listPopulationChange.getLast());
maxGrowthRate = Math.max(maxGrowthRate, listGrowthRate.getLast());
minGrowthRate = Math.min(minGrowthRate, listGrowthRate.getLast());
}
generation++;
listCells.add(x);
}
/**
* Removes the least recently used elements if the cache size is greater than or equal to the
* maximum allowed size until the cache is at least 10% empty.
*/
protected synchronized void cullCache() {
// Check if a max cache size is defined.
if (maxCacheSize < 0) {
return;
}
// See if the cache is too big. If so, clean out cache until it's 10% free.
if (map.size() > maxCacheSize) {
// First, delete any old entries to see how much memory that frees.
deleteExpiredEntries();
// Next, delete the least recently used elements until 10% of the cache
// has been freed.
int desiredSize = (int) (maxCacheSize * .90);
for (int i = map.size(); i > desiredSize; i--) {
// Get the key and invoke the remove method on it.
if (remove(lastAccessedList.getLast().object, true) == null) {
LOGGER.warning(
"Error attempting to cullCache with remove("
+ lastAccessedList.getLast().object.toString()
+ ") - cacheObject not found in cache!");
lastAccessedList.getLast().remove();
}
}
}
}
/* (non-Javadoc)
* @see org.apache.batik.parser.PathHandler#linetoVerticalRel(float)
*/
public void linetoVerticalRel(float y) throws ParseException {
if (verbose) System.out.println("linetoVerticalRel: " + y);
Vertex vert = new Vertex(pathPoints.getLast().getX(), pathPoints.getLast().getY() + y, 0);
pathPoints.add(vert);
currentSubPath.add(vert);
}
private void sendBatchNonTransacted() {
try {
if (qualityOfServiceMode == QualityOfServiceMode.ONCE_AND_ONLY_ONCE) {
// We client ack before sending
if (JMSBridgeImpl.trace) {
HornetQJMSServerLogger.LOGGER.trace("Client acking source session");
}
messages.getLast().acknowledge();
if (JMSBridgeImpl.trace) {
HornetQJMSServerLogger.LOGGER.trace("Client acked source session");
}
}
sendMessages();
if (maxBatchSize > 1) {
// The sending session is transacted - we need to commit it
if (JMSBridgeImpl.trace) {
HornetQJMSServerLogger.LOGGER.trace("Committing target session");
}
targetSession.commit();
if (JMSBridgeImpl.trace) {
HornetQJMSServerLogger.LOGGER.trace("Committed source session");
}
}
if (qualityOfServiceMode == QualityOfServiceMode.DUPLICATES_OK) {
// We client ack after sending
// Note we could actually use Session.DUPS_OK_ACKNOWLEDGE here
// For a slightly less strong delivery guarantee
if (JMSBridgeImpl.trace) {
HornetQJMSServerLogger.LOGGER.trace("Client acking source session");
}
messages.getLast().acknowledge();
if (JMSBridgeImpl.trace) {
HornetQJMSServerLogger.LOGGER.trace("Client acked source session");
}
}
// Clear the messages
messages.clear();
} catch (Exception e) {
HornetQJMSServerLogger.LOGGER.bridgeAckError(e);
handleFailureOnSend();
}
}
private ArrayList<String> helper(WifiMapData unknown) {
Vd2_3MapData unknownStat = new Vd2_3MapData(unknown);
// debug("here stat");
// debug(unknownStat, unknownStat.fullScan.size());
LinkedList<LocationEvaluation> possible = new LinkedList<LocationEvaluation>();
ArrayList<String> possibleLocations = new ArrayList<String>();
for (String locationID : cache.keySet()) {
LocationEvaluation eval = new LocationEvaluation(locationID);
possible.add(eval);
}
if (possible.isEmpty()) {
System.out.println("+++++++++++++++++++++++++++++++++");
return possibleLocations;
}
{
// Remove the ones that has too little low-var Aps
for (LocationEvaluation eval : possible) {
eval.score = nHavingLowVariance(cache.get(eval.name), unknownStat);
}
Collections.sort(possible);
// debug(possible);
double min = possible.getFirst().score - maxAbsenceAP;
while (!possible.isEmpty() && possible.getLast().score < min) possible.removeLast();
}
{
// Remove the ones that miss too much Low-var APs
for (LocationEvaluation eval : possible) {
eval.score = nMissingLowVariance(cache.get(eval.name), unknownStat);
}
Collections.sort(possible);
// debug(possible);
double min = possible.getFirst().score - maxAbsenceAP;
while (!possible.isEmpty() && possible.getLast().score < min) possible.removeLast();
}
{
// Sort the average this distance
for (LocationEvaluation eval : possible) {
eval.score = differenceAverage(cache.get(eval.name), unknownStat);
}
Collections.sort(possible);
while (!possible.isEmpty() && possible.getLast().score < VERY_NEGATIVE) {
possible.removeLast();
}
}
for (int i = 0; i < possible.size(); ++i) {
possibleLocations.add(possible.get(i).name);
}
return possibleLocations;
}
/**
* flashback! Throws an unsupported operation exception
*
* @param location where to flash back to
*/
public void flashBackTo(GenomeLoc location) {
if (!canFlashBackTo(location))
throw new UnsupportedOperationException("we can't flash back to " + location);
if (pastQueue.size() == 0) return; // the iterator can do it alone
while (pastQueue.size() > 0 && !pastQueue.getLast().getLocation().isBefore(location)) {
aheadQueue.addFirst(pastQueue.getLast());
pastQueue.removeLast();
}
}
public int theNthNum(int n) {
Integer[] a = {1, 2, 3, 4, 5};
if (n <= 5) return a[n - 1];
LinkedList<Integer> arrayIntegers = new LinkedList<Integer>();
for (int aa : a) arrayIntegers.add(aa);
for (int i = 6; i <= n; i++) {
int x = getNext(arrayIntegers.getLast(), arrayIntegers);
arrayIntegers.add(x);
}
return arrayIntegers.getLast();
}
private void updateEtaAndSpeed() {
long now = dates.getFirst();
long past = dates.getLast();
long loadedKbNow = loaded.getFirst();
long loadedKbPast = loaded.getLast();
long kiloBytesRemaining = max - loadedKbNow;
// speed kb/
speedKbPerSecond = (float) ((double) (loadedKbNow - loadedKbPast)) / ((now - past) / 1000);
timeleft = (long) (kiloBytesRemaining / speedKbPerSecond);
eta.setTime(now + timeleft * 1000);
}
/** Starts adding points to the mouseEvents list every 2 milliseconds */
private void collect() {
int same = 0; // The number of times that the mouse has been in same position.
pause = false; // whether or not the mouse is currently idle
while (record) {
if (!pause) {
// If the mouse is not currently idle, A new point is added to the "mouseEvents" List. point
// has x and y coordinates
mouseEvents.add(
new SimpleMouseEvent(
MouseInfo.getPointerInfo().getLocation().x,
MouseInfo.getPointerInfo().getLocation().y,
0));
}
// If the mouse is currently set as idle, but mouvement has been detected: that is, if the
// current position is different than
// where the mouse is when it was set as idle...
if (pause
&& ((MouseInfo.getPointerInfo().getLocation().x) != mouseEvents.getLast().gx()
|| MouseInfo.getPointerInfo().getLocation().y != mouseEvents.getLast().gy())) {
unpause();
}
// Detects if the current position of the mouse is the same as the last time it was checked.
if (mouseEvents.size() > 5
&& (mouseEvents
.getLast()
.toString()
.equals(mouseEvents.get(mouseEvents.size() - 2).toString()))) {
// If position is the same, the "same" count is increased.
same++;
// Once the mouse has been in the same place for 10 cycles, it is said to be idle.
if (same == 10) {
pause = true;
// The stopwatch will count how long the mouse has been idle for
stopWatch.start();
System.out.println("Pause");
}
} else {
// If the mouse has moved since last cycle, then the number of times it has been in the same
// position is set to 0.
same = 0;
}
try {
Thread.sleep(2); // Delay between cycles.
} catch (InterruptedException ex) {
Thread.currentThread().interrupt();
}
if (!record) {
gui.log("Recording Stopped.");
gui.refreshActionList();
}
}
}
public Register getDestinationRegister() {
/*
for(int i = fields.size() - 1; i >= 0; i--) {
if(fields.get(i) instanceof Register) {
return (Register)fields.get(i);
}
}
*/
if (fields.size() > 0 && fields.getLast() instanceof Register)
return (Register) fields.getLast();
return null;
}
public void removeFromStacks(UndoableGroup group) {
if (group.getAffectedDocuments().isEmpty()) return;
if (group.isGlobal()) {
assert myGlobalStack.getLast() == group;
myGlobalStack.removeLast();
}
for (DocumentReference each : group.getAffectedDocuments()) {
LinkedList<UndoableGroup> stack = getStack(each);
assert stack.getLast() == group;
stack.removeLast();
}
}
/* (non-Javadoc)
* @see org.apache.batik.parser.PathHandler#curvetoQuadraticSmoothRel(float, float)
*/
public void curvetoQuadraticSmoothRel(float x, float y) throws ParseException {
if (verbose) System.out.println("curvetoQuadraticSmoothRel: " + x + "," + y);
Vertex lastPoint = pathPoints.getLast();
if (lastPoint instanceof BezierVertex
&& cubicBezVertTOQuadricControlPoint.get(lastPoint) != null) {
Vertex lastEndPoint =
new Vertex(
pathPoints.getLast().getX(),
pathPoints.getLast().getY(),
pathPoints.getLast().getZ());
// Get control point of last QuadTo
Vertex lastQuadControlPoint = cubicBezVertTOQuadricControlPoint.get(lastPoint);
cubicBezVertTOQuadricControlPoint.remove(lastPoint);
// Rotate that controlpoint around the end point of the last QuadTo
lastQuadControlPoint.rotateZ(lastEndPoint, 180);
// Put in startPoint = last QuadTo Endpoint of this smoothQuadTo, the calculated control
// point, and the endpoint of smoothQuadTo
BezierVertex b5 =
Tools3D.getCubicFromQuadraticCurve(
lastEndPoint,
lastQuadControlPoint,
new Vertex(lastPoint.getX() + x, lastPoint.getY() + y, 0));
// Save last quad control point
cubicBezVertTOQuadricControlPoint.put(b5, lastQuadControlPoint);
pathPoints.add(b5);
currentSubPath.add(b5);
} else {
if (verbose)
System.out.println(
"couldnt get last control point at curvetoQuadraticSmoothRel - using last point as the control point");
Vertex lastEndPoint = new Vertex(lastPoint.getX(), lastPoint.getY(), 0);
Vertex quadControlPoint = new Vertex(lastPoint.getX(), lastPoint.getY(), 0);
BezierVertex b5 =
Tools3D.getCubicFromQuadraticCurve(
lastEndPoint,
quadControlPoint,
new Vertex(lastPoint.getX() + x, lastPoint.getY() + y, 0));
cubicBezVertTOQuadricControlPoint.put(b5, quadControlPoint);
pathPoints.add(b5);
currentSubPath.add(b5);
}
}
public synchronized boolean enqueue(ByteBuffer byteBuffer) {
if (byteBuffer.remaining() == 0) {
return false;
}
if (queue.size() > 0) {
ByteBuffer tail = queue.getLast();
if (tail.hasRemaining()) {
topUpBuffer(tail, byteBuffer);
}
}
while (byteBuffer.hasRemaining()) {
ByteBuffer newBuf = bufferFactory.newBuffer();
topUpBuffer(newBuf, byteBuffer);
queue.addLast(newBuf);
}
facade.modifyInterestOps(SelectionKey.OP_WRITE, 0);
return true;
}
public void actionPerformed(ActionEvent event) {
int i;
JButton aux = (JButton) event.getSource();
if (aux == closeCompra) {
try {
String[] information = {
JOptionPane.showInputDialog(null, "nombre"),
JOptionPane.showInputDialog(null, "numero de targeta")
};
ObjectOutputStream oos = new ObjectOutputStream(client.getOutputStream());
oos.writeObject(information);
oos.flush();
oos.writeObject(products);
oos.flush();
oos.writeObject(comprados);
oos.flush();
cleanTable();
comprados.clear();
} catch (Exception e) {
System.out.print("\nerror al cerrar la compra " + e.getMessage());
}
return;
}
for (i = 0; aux != mostrador.addCar[i]; i++) {;
}
if (products.get(i).getPiesas() > 0) {
products.get(i).popParts();
addCompra(products.get(i));
total.setText("total: " + comprados.getLast().getTotal());
} else {
JOptionPane.showMessageDialog(null, "no seas menso ya no hay mas piesas! :@");
}
}
/**
* @param cacheCtx Cache context.
* @param cand Cache lock candidate to add.
* @return {@code True} if added as a result of this operation, {@code false} if was previously
* added.
*/
public boolean addNext(GridCacheContext cacheCtx, GridCacheMvccCandidate cand) {
assert cand != null;
assert !cand.reentry() : "Lock reentries should not be linked: " + cand;
// Don't order near candidates by thread as they will be ordered on
// DHT node. Also, if candidate is implicit, no point to order him.
if (cacheCtx.isNear() || cand.singleImplicit()) return true;
LinkedList<GridCacheMvccCandidate> queue = pending.get();
GridCacheMvccCandidate prev = null;
if (!queue.isEmpty()) prev = queue.getLast();
queue.add(cand);
if (prev != null) {
prev.next(cand);
cand.previous(prev);
}
if (log.isDebugEnabled()) log.debug("Linked new candidate: " + cand);
return true;
}
public void handleEvents() {
for (int i = 0; i < eventQueue.size(); i++) {
Event e = eventQueue.getLast();
if (e.timestamp > ProcessingSketch.getGameTimeline().getIterations()) break;
if (e.type == EventType.NEW_OBJECT) {
ProcessingSketch.addGameObject(((NewObjectEvent) e).newObj);
} else if (e.type == EventType.SHOT_COLLISION) {
ProcessingSketch.removeObjByGUID(((ShotCollisionEvent) e).obj1GUID);
ProcessingSketch.removeObjByGUID(((ShotCollisionEvent) e).obj2GUID);
} else {
for (GameObject obj : ProcessingSketch.getObjects()) {
if (handlerMap.get(obj.getGUID()) == null) continue;
if (handlerMap.get(obj.getGUID()).contains(e.type)) {
if (e.type == EventType.COLLISION) {
if (((CollisionEvent) e).obj1.getGUID() != obj.getGUID()
&& ((CollisionEvent) e).obj2.getGUID() != obj.getGUID()) {
continue; // if obj is neither of the collided objects, don't send the collision
// event to obj
}
}
obj.onEvent(e);
}
}
}
eventQueue.removeLast();
System.out.println("Events handled: " + i);
}
}
/* (non-Javadoc)
* @see org.apache.batik.parser.PathHandler#curvetoCubicSmoothAbs(float, float, float, float)
*/
public void curvetoCubicSmoothAbs(float x2, float y2, float x, float y) throws ParseException {
if (verbose)
System.out.println("curvetoCubicSmoothAbs x2:" + x2 + " y2:" + y2 + " x:" + x + " y:" + y);
Vertex lastPoint = pathPoints.getLast();
if (lastPoint instanceof BezierVertex) {
BezierVertex lastBez = (BezierVertex) lastPoint;
Vertex lastConPointCopy = (Vertex) lastBez.getSecondCtrlPoint().getCopy();
// reflect the last controlpoint at the current point
lastConPointCopy.rotateZ(lastPoint, 180);
BezierVertex b =
new BezierVertex(lastConPointCopy.getX(), lastConPointCopy.getY(), 0, x2, y2, 0, x, y, 0);
pathPoints.add(b);
currentSubPath.add(b);
} else {
if (verbose)
System.out.println(
"Couldnt get last controlpoint at: curvetoCubicSmoothAbs - using last point as first controlpoint");
Vertex lastEndPoint = new Vertex(lastPoint.getX(), lastPoint.getY(), 0);
BezierVertex b =
new BezierVertex(lastEndPoint.getX(), lastEndPoint.getY(), 0, x2, y2, 0, x, y, 0);
pathPoints.add(b);
currentSubPath.add(b);
}
}
public static String normalizePath(String path) {
if (!path.contains("./")) {
return path;
}
boolean absolute = path.startsWith("/");
String[] elements = path.split(Repository.SEPARATOR);
LinkedList<String> list = new LinkedList<String>();
for (String e : elements) {
if ("..".equals(e)) {
if (list.isEmpty() || "..".equals(list.getLast())) {
list.add(e);
} else {
list.removeLast();
}
} else if (!".".equals(e) && e.length() > 0) {
list.add(e);
}
}
StringBuilder sb = new StringBuilder(path.length());
if (absolute) {
sb.append("/");
}
int count = 0, last = list.size() - 1;
for (String e : list) {
sb.append(e);
if (count++ < last) sb.append("/");
}
return sb.toString();
}
/**
* Calculate largest prime factor.
*
* @return the largest prime factor
*/
public int getLargestPrimeFactor() {
int divider = PrimeChecker.FIRST_PRIME;
double divideIt = this.divideIt;
this.factors.addLast(PrimeChecker.FIRST_PRIME);
while (divideIt > 1) {
if (String.valueOf(divideIt).endsWith(String.valueOf(PrimeChecker.END_PRIME))) {
divider = PrimeChecker.END_PRIME;
divideIt = divideIt / divider;
} else {
boolean hasNext = false;
for (final int prime : this.factors) {
if (divideIt % prime == 0) {
divider = prime;
hasNext = true;
break;
}
}
if (!hasNext) {
while (divideIt % divider == 0) {
this.factors.addLast(divider);
divider = PrimeChecker.getNextPrime(this.factors);
}
hasNext = false;
}
}
divideIt = divideIt / divider;
if (!factors.contains(divider)) {
factors.add(divider);
}
}
System.out.println("processed primes : " + factors.toString());
return factors.getLast();
}
/**
* Caches the path that was just found.
*
* @param smiod
* @param endNode
* @param startNode
*/
private void cachePath(StreetMobilityInfoOD smiod, SegmentNode startNode, SegmentNode endNode) {
if (hm != null && smiod.path.size() > MIN_CACHED_PATH_LENGTH) {
Location startPoint = startNode.point;
LinkedList ll = (LinkedList) hm.get(startPoint);
if (ll == null) {
ll = new LinkedList();
}
// make sure that path doesn't already exist...
// must iterate through all of them...
ListIterator li = ll.listIterator();
boolean found = false;
while (li.hasNext()) {
LinkedList existingPath = (LinkedList) li.next();
if (existingPath.getFirst().equals(startNode)
&& existingPath.getLast().equals(smiod.path.getLast())) {
found = true;
break;
}
}
if (!found) {
LinkedList newPath = (LinkedList) smiod.path.clone();
newPath.addFirst(startNode);
ll.add(newPath);
hm.put(startPoint, ll);
}
}
}
/* (non-Javadoc)
* @see org.apache.batik.parser.PathHandler#arcAbs(float, float, float, boolean, boolean, float, float)
*/
public void arcAbs(
float rx, float ry, float phi, boolean large_arc, boolean sweep, float x, float y)
throws ParseException {
if (verbose)
System.out.println(
"arcAbs: "
+ rx
+ " "
+ ry
+ " "
+ phi
+ " "
+ large_arc
+ " "
+ sweep
+ " "
+ x
+ " "
+ y);
Vertex lastPoint = pathPoints.getLast();
List<Vertex> arcVertices =
Tools3D.arcTo(lastPoint.x, lastPoint.y, rx, ry, phi, large_arc, sweep, x, y, 40);
// Prevent odd picking behavour, in which the normal is
// not correctly computed, because the 2 points are the same
if (!arcVertices.isEmpty() && lastPoint != null && arcVertices.get(0).equalsVector(lastPoint)) {
arcVertices.remove(0);
}
pathPoints.addAll(arcVertices);
currentSubPath.addAll(arcVertices);
}
/* (non-Javadoc)
* @see org.apache.batik.parser.PathHandler#linetoHorizontalAbs(float)
*/
public void linetoHorizontalAbs(float x) throws ParseException {
if (verbose) System.out.println("linetoHorizontalAbs x:" + x);
Vertex vert = new Vertex(x, pathPoints.getLast().getY(), 0);
pathPoints.add(vert);
currentSubPath.add(vert);
}