private void initStack(XNContext parent) { initStack(); firstResponder = parent.firstResponder; responderStack.addAll(parent.responderStack); callStack.addAll(parent.callStack); result = parent.result; }
public GenomeLocSortedSet subtractRegions(GenomeLocSortedSet toRemoveSet) { LinkedList<GenomeLoc> good = new LinkedList<GenomeLoc>(); Stack<GenomeLoc> toProcess = new Stack<GenomeLoc>(); Stack<GenomeLoc> toExclude = new Stack<GenomeLoc>(); // initialize the stacks toProcess.addAll(mArray); Collections.reverse(toProcess); toExclude.addAll(toRemoveSet.mArray); Collections.reverse(toExclude); int i = 0; while (!toProcess.empty()) { // while there's still stuff to process if (toExclude.empty()) { good.addAll(toProcess); // no more excludes, all the processing stuff is good break; } GenomeLoc p = toProcess.peek(); GenomeLoc e = toExclude.peek(); if (p.overlapsP(e)) { toProcess.pop(); for (GenomeLoc newP : p.subtract(e)) toProcess.push(newP); } else if (p.compareContigs(e) < 0) { good.add(toProcess.pop()); // p is now good } else if (p.compareContigs(e) > 0) { toExclude.pop(); // e can't effect anything } else if (p.getStop() < e.getStart()) { good.add(toProcess.pop()); // p stops before e starts, p is good } else if (e.getStop() < p.getStart()) { toExclude.pop(); // p starts after e stops, e is done } else { throw new ReviewedStingException("BUG: unexpected condition: p=" + p + ", e=" + e); } if (i++ % 10000 == 0) logger.debug("removeRegions operation: i = " + i); } return createSetFromList(genomeLocParser, good); }
private void generateMoveForPosition(int color, int position) { Stack<Integer> flipStack = new Stack<Integer>(); // list of all flips found for position int pointer; // pointer to position that is currently being evaluated // loop through each possible line radiating from position for (int i = 0; i < ADJACENT_ADDERS.length; i++) { Stack<Integer> lineStack = new Stack<Integer>(); // list of flips found on individual radial pointer = position + ADJACENT_ADDERS[i]; boolean foundSameColor = false; // loop through each position in the line // end loop if same color, edge, or empty space found boolean loop = true; while (loop) { int stateAtPointer = this.positions[pointer]; switch (stateAtPointer) { case 0: loop = false; break; // found empty case -2: loop = false; break; // found edge default: int colorEvaluate = color * stateAtPointer; switch (colorEvaluate) { case 1: // found same color foundSameColor = true; loop = false; break; case -1: // found opposite color lineStack.push(pointer); pointer += ADJACENT_ADDERS[i]; break; } break; } } if (foundSameColor && lineStack.size() > 0) { flipStack.addAll( lineStack); // join lineStack with flipStack if flips found along current radial } } // push the move on to legalMovesList if valid flips found. otherwise do nothing. switch (flipStack.size()) { case 0: break; // do nothing default: this.legalMovesList.push(new Move(position, flipStack)); break; } }
/** * Merge list of expressions into a tree of logical/relational expressions. This is done * recursively in several passes, one per level of precedence starting at the highest precedence * level. Recursion exits when a single expression remains. * * @param listExpressions list of expressions to merge * @param precedenceLevel the precedence level that is to be merged * @return tree of expressions with a single root expression */ private List<Expression> mergeExpressions(List<Expression> listExpressions, int precedenceLevel) { if (listExpressions.size() > 1) { Stack<Expression> stack = new Stack<Expression>(); stack.push(listExpressions.remove(0)); while (!listExpressions.isEmpty()) { Expression exp = stack.pop(); Expression left = stack.empty() ? null : stack.pop(); Expression right = listExpressions.remove(0); stack.addAll(exp.merge(left, right, precedenceLevel)); } return mergeExpressions(new ArrayList<Expression>(stack), precedenceLevel - 1); } return listExpressions; }