private void play() { if (isReload) reloadGame(); if (isEnd || isPause) return; addFeed(); doesEatFeed(); addRegime(); doesEatRegime(); crossBorder(); head = blocks.peekFirst(); Block newHead = new Block(head.getX() + dx[inputDirection], head.getY() + dy[inputDirection]); Rectangle headRect = new Rectangle(head.getX(), head.getY(), 10, 10); if (isEnd(newHead)) { isEnd = true; // Image image = new Image(this.getClass().getResourceAsStream("/gameOver.png")); // ImageView imageView = new ImageView(image); // group.getChildren().add(imageView); // scene.setOnKeyPressed(null); saveRecord(); showRecord(); return; } else { blocks.push(newHead); rectangles.push(headRect); blocks.pollLast(); updateGui(); } }
private void reloadGame() { if (!isReload) return; score = 0; isReload = false; isEnd = false; feedCounter1 = 0; feedCounter2 = 0; List<Rectangle> rectangleList = new ArrayList<>(rectangles); for (Rectangle r : rectangleList) group.getChildren().remove(r); regimeRectangle.setX(-20); Deque<Block> blocksTemp = new ArrayDeque<>(); Deque<Rectangle> rectanglesTemp = new ArrayDeque<>(); head = new Block(100, 150); tale = new Block(90, 150); if (inputDirection != 3) { blocksTemp.push(tale); blocksTemp.push(head); rectanglesTemp.push(new Rectangle(tale.getX(), tale.getY(), 10, 10)); rectanglesTemp.push(new Rectangle(head.getX(), head.getY(), 10, 10)); } else { blocksTemp.push(head); blocksTemp.push(tale); rectanglesTemp.push(new Rectangle(head.getX(), head.getY(), 10, 10)); rectanglesTemp.push(new Rectangle(tale.getX(), tale.getY(), 10, 10)); } blocks = blocksTemp; rectangles = rectanglesTemp; group.getChildren().add(rectangles.getFirst()); group.getChildren().add(rectangles.getLast()); timer.cancel(); timer = null; timer = new Timer(); timer.schedule( new TimerTask() { @Override public void run() { Platform.runLater(() -> play()); } }, 1, 100); }
@Override public void meet(FunctionCall fc) throws RuntimeException { // special optimizations for frequent cases with variables if ((XMLSchema.DOUBLE.toString().equals(fc.getURI()) || XMLSchema.FLOAT.toString().equals(fc.getURI())) && fc.getArgs().size() == 1) { optypes.push(ValueType.DOUBLE); fc.getArgs().get(0).visit(this); optypes.pop(); } else if ((XMLSchema.INTEGER.toString().equals(fc.getURI()) || XMLSchema.INT.toString().equals(fc.getURI())) && fc.getArgs().size() == 1) { optypes.push(ValueType.INT); fc.getArgs().get(0).visit(this); optypes.pop(); } else if (XMLSchema.BOOLEAN.toString().equals(fc.getURI()) && fc.getArgs().size() == 1) { optypes.push(ValueType.BOOL); fc.getArgs().get(0).visit(this); optypes.pop(); } else if (XMLSchema.DATE.toString().equals(fc.getURI()) && fc.getArgs().size() == 1) { optypes.push(ValueType.DATE); fc.getArgs().get(0).visit(this); optypes.pop(); } else { String fnUri = fc.getURI(); String[] args = new String[fc.getArgs().size()]; NativeFunction nf = functionRegistry.get(fnUri); if (nf != null && nf.isSupported(parent.getDialect())) { for (int i = 0; i < args.length; i++) { args[i] = new ValueExpressionEvaluator(fc.getArgs().get(i), parent, nf.getArgumentType(i)) .build(); } if (optypes.peek() != nf.getReturnType()) { builder.append(castExpression(nf.getNative(parent.getDialect(), args), optypes.peek())); } else { builder.append(nf.getNative(parent.getDialect(), args)); } } else { throw new IllegalArgumentException( "the function " + fnUri + " is not supported by the SQL translation"); } } }
@Override public void meet(MathExpr expr) throws RuntimeException { ValueType ot = new OPTypeFinder(expr).coerce(); if (ot == ValueType.STRING) { if (expr.getOperator() == MathExpr.MathOp.PLUS) { builder.append( functionRegistry .get(FN.CONCAT.stringValue()) .getNative( parent.getDialect(), new ValueExpressionEvaluator(expr.getLeftArg(), parent, ot).build(), new ValueExpressionEvaluator(expr.getRightArg(), parent, ot).build())); } else { throw new IllegalArgumentException( "operation " + expr.getOperator() + " is not supported on strings"); } } else { if (ot == ValueType.NODE || ot == ValueType.TERM) { ot = ValueType.DOUBLE; } optypes.push(ot); expr.getLeftArg().visit(this); builder.append(getSQLOperator(expr.getOperator())); expr.getRightArg().visit(this); optypes.pop(); } }
@Override public void meet(Count node) throws RuntimeException { builder.append("COUNT("); if (node.isDistinct()) { builder.append("DISTINCT "); } if (node.getArg() == null) { // this is a weird special case where we need to expand to all variables selected in the query // wrapped // by the group; we cannot simply use "*" because the concept of variables is a different one // in SQL, // so instead we construct an ARRAY of the bindings of all variables List<String> countVariables = new ArrayList<>(); for (SQLVariable v : parent.getVariables().values()) { if (v.getProjectionType() == ValueType.NONE) { Preconditions.checkState( v.getExpressions().size() > 0, "no expressions available for variable"); countVariables.add(v.getExpressions().get(0)); } } builder.append("ARRAY["); Joiner.on(',').appendTo(builder, countVariables); builder.append("]"); } else { optypes.push(ValueType.NODE); node.getArg().visit(this); optypes.pop(); } builder.append(")"); }
private InstructionImpl startNode(@Nullable GroovyPsiElement element, boolean checkPending) { final InstructionImpl instruction = new InstructionImpl(element); addNode(instruction); if (checkPending) checkPending(instruction); myProcessingStack.push(instruction); return instruction; }
@Override public void enterFacilityDecl(ResolveParser.FacilityDeclContext ctx) { VCAssertiveBlockBuilder block = new VCAssertiveBlockBuilder(g, moduleScope, "Facility_Inst=" + ctx.name.getText(), ctx); block.assume(g.getTrueExp()); assertiveBlocks.push(block); }
@Override public void enterProcedureDecl(ResolveParser.ProcedureDeclContext ctx) { Scope s = symtab.getScope(ctx); try { List<ProgParameterSymbol> paramSyms = s.getSymbolsOfType(ProgParameterSymbol.class); currentProcOpSym = s.queryForOne( new OperationQuery( null, ctx.name, Utils.apply(paramSyms, ProgParameterSymbol::getDeclaredType))); // This is the requires for the operation with some substutions made (see corrFnExp rule in // HH-diss) PExp corrFnExpRequires = perParameterCorrFnExpSubstitute(paramSyms, currentProcOpSym.getRequires()); List<PExp> opParamAntecedents = new ArrayList<>(); Utils.apply(paramSyms, opParamAntecedents, this::extractAssumptionsFromParameter); Set<PExp> l = getModuleLevelAssertionsOfType(ClauseType.REQUIRES); VCAssertiveBlockBuilder block = new VCAssertiveBlockBuilder(g, s, "Correct_Op_Hypo=" + ctx.name.getText(), ctx) .facilitySpecializations(facilitySpecFormalActualMappings) .assume(getModuleLevelAssertionsOfType(ClauseType.REQUIRES)) // TODO: constraints should be added on demand via NOTICE:... // .assume(getModuleLevelAssertionsOfType(ClauseType.CONSTRAINT)) .assume(opParamAntecedents) // we assume correspondence for reprs here automatically .assume(corrFnExpRequires) .remember(); assertiveBlocks.push(block); } catch (SymbolTableException e) { throw new RuntimeException(e); // this shouldn't happen now } }
@Override public void meet(If node) throws RuntimeException { builder.append("CASE WHEN "); optypes.push(ValueType.BOOL); node.getCondition().visit(this); optypes.pop(); optypes.push(new OPTypeFinder(node).coerce()); builder.append(" THEN "); node.getResult().visit(this); builder.append(" ELSE "); node.getAlternative().visit(this); builder.append(" END"); optypes.pop(); }
@Override public void meet(Sum node) throws RuntimeException { builder.append("SUM("); optypes.push(ValueType.DOUBLE); node.getArg().visit(this); optypes.pop(); builder.append(")"); }
@Override public void meet(Compare cmp) throws RuntimeException { optypes.push(new OPTypeFinder(cmp).coerce()); cmp.getLeftArg().visit(this); builder.append(getSQLOperator(cmp.getOperator())); cmp.getRightArg().visit(this); optypes.pop(); }
// returns the single move to make given a board, depth, piecelist, heuristic // whill choose the best terminal board at the max depth, // or if none exists, the best board with no children (inevitable death) public Board.Direction nextMove(Board start, List<Integer> nextPiece) { int maxDepth = Math.min(exploreDepth, nextPiece.size()); double bestLiveScore = -1; Board.Direction bestLiveDirection = null; // cus why not? // add the first round seperately so we know which move to return for (Board.Direction d : Board.Direction.values()) { Board next = start.move(d, nextPiece.get(0)); if (next != null) { PriorityQueue<Double> pq = new PriorityQueue<Double>(); Deque<StackItem> stack = new ArrayDeque<StackItem>(); stack.push(new StackItem(next, 1, d)); // DFS while (!stack.isEmpty()) { StackItem cur = stack.pop(); // add more moves if not beyond max depth if (cur.d < maxDepth) { for (Board.Direction d2 : Board.Direction.values()) { Board next2 = cur.b.move(d2, nextPiece.get(cur.d)); if (next2 != null) { stack.push(new StackItem(next2, cur.d + 1, cur.move)); } } } // update live only at the bottom of the tree if (cur.d == maxDepth) { pq.add(heuristic.useHeuristic(cur.b)); if (pq.size() > 10) pq.poll(); } } double sum = 0; int count = 0; count = pq.size(); while (!pq.isEmpty()) sum += pq.poll(); if (count > 0 && sum / count > bestLiveScore) { bestLiveScore = sum / count; bestLiveDirection = d; } } } return bestLiveDirection; }
public int execute(String input) { Deque<Integer> stack = new ArrayDeque<>(); for (String s : input.split("\\s")) { Operator operator = opetators.get(s); if (operator != null) { Integer num1 = stack.pop(); Integer num2 = stack.pop(); stack.push(operator.execute(num1, num2)); } else { stack.push(Integer.valueOf(s)); } } return stack.pop(); }
private void doesEatFeed() { if (isEnd) return; if (Math.abs(blocks.peekFirst().getX() - feedRectangle.getX()) < 10 && Math.abs(blocks.peekFirst().getY() - feedRectangle.getY()) < 10) { feedRectangle.setX(1200); isFeed = false; ++feedCounter2; ++score; scoreLabel.setText(String.valueOf(score)); head = blocks.peekFirst(); Block newHead = new Block(head.getX() + dx[inputDirection], head.getY() + dy[inputDirection]); Rectangle headRect = new Rectangle(head.getX(), head.getY(), 10, 10); blocks.push(newHead); rectangles.push(headRect); } }
@Override public void meet(SameTerm cmp) throws RuntimeException { // covered by value binding in variables optypes.push(ValueType.TERM); cmp.getLeftArg().visit(this); builder.append(" = "); cmp.getRightArg().visit(this); optypes.pop(); }
public void run() { Deque<VisitingContext> stack = new ArrayDeque<>(); stack.add(new VisitingContext(rootNode)); boolean goOn = stack.peek().hasNext(); if (goOn) { do { Map.Entry<String, JsonValue> current = stack.peek().nextElement(); if (!(current.getValue() instanceof JsonStructure)) { String key = stack.peek().getNSPrefix() + current.getKey(); String value = null; JsonValue jsonValue = current.getValue(); switch (jsonValue.getValueType()) { case NULL: value = null; break; case FALSE: value = Boolean.FALSE.toString(); break; case TRUE: Boolean.TRUE.toString(); break; case NUMBER: value = jsonValue.toString(); break; case STRING: value = ((JsonString) jsonValue).getString(); break; default: throw new ConfigException("Internal failure while processing JSON document."); } targetStore.put(key, value); } else if (current.getValue() instanceof JsonObject) { String key = stack.peek().getNSPrefix() + current.getKey(); JsonObject node = (JsonObject) current.getValue(); stack.push(new VisitingContext(node, key)); } else if (current.getValue() instanceof JsonArray) { throw new ConfigException("Arrays are not supported at the moment."); } else { throw new ConfigException("Internal failure while processing JSON document."); } goOn = stack.peek().hasNext(); while (!goOn && stack.size() > 0) { stack.remove(); goOn = (stack.size() > 0) && stack.peek().hasNext(); } } while (goOn); } }
@Override public boolean add(@NotNull final ByteIterable key, @NotNull final ByteIterable value) { final ByteIterator it = key.iterator(); NodeBase node = root; MutableNode mutableNode = null; final Deque<ChildReferenceTransient> stack = new ArrayDeque<>(); while (true) { final NodeBase.MatchResult matchResult = node.matchesKeySequence(it); final int matchingLength = matchResult.matchingLength; if (matchingLength < 0) { final MutableNode prefix = node.getMutableCopy(this).splitKey(-matchingLength - 1, matchResult.keyByte); if (matchResult.hasNext) { prefix.hang(matchResult.nextByte, it).setValue(value); } else { prefix.setValue(value); } if (stack.isEmpty()) { root = new MutableRoot(prefix, root.sourceAddress); } else { final ChildReferenceTransient parent = stack.pop(); mutableNode = parent.mutate(this); mutableNode.setChild(parent.firstByte, prefix); } break; } if (!it.hasNext()) { if (node.hasValue()) { return false; } mutableNode = node.getMutableCopy(this); mutableNode.setValue(value); break; } final byte nextByte = it.next(); final NodeBase child = node.getChild(this, nextByte); if (child == null) { mutableNode = node.getMutableCopy(this); if (mutableNode.hasChildren() || mutableNode.hasKey() || mutableNode.hasValue()) { mutableNode.hang(nextByte, it).setValue(value); } else { mutableNode.setKeySequence(new ArrayByteIterable(nextByte, it)); mutableNode.setValue(value); } break; } stack.push(new ChildReferenceTransient(nextByte, node)); node = child; } ++size; mutateUp(stack, mutableNode); TreeCursorMutable.notifyCursors(this); return true; }
public static boolean bfsIterative(TreeNode root, int val) { Deque<TreeNode> s = new LinkedList<>(); s.push(root); while (!s.isEmpty()) { TreeNode curr = s.removeFirst(); if (curr.left != null) s.addLast(curr.left); if (curr.right != null) s.addLast(curr.right); if (curr.value == val) return true; } return false; }
private void addExternalParents(EntityType entityType) { Deque<Type> superTypes = new ArrayDeque<Type>(); if (entityType.getSuperType() != null) { superTypes.push(entityType.getSuperType().getType()); } while (!superTypes.isEmpty()) { Type superType = superTypes.pop(); if (!context.allTypes.containsKey(superType.getFullName())) { TypeElement typeElement = processingEnv.getElementUtils().getTypeElement(superType.getFullName()); if (typeElement == null) { throw new IllegalStateException("Found no type for " + superType.getFullName()); } EntityType superEntityType = elementHandler.handleEntityType(typeElement); if (superEntityType.getSuperType() != null) { superTypes.push(superEntityType.getSuperType().getType()); } context.allTypes.put(superType.getFullName(), superEntityType); } } }
public ValueExpressionEvaluator(ValueExpr expr, SQLBuilder parent, ValueType optype) { this.parent = parent; optypes.push(optype); if (log.isTraceEnabled()) { long start = System.currentTimeMillis(); expr.visit(this); log.trace("expression evaluated in {} ms", (System.currentTimeMillis() - start)); } else { expr.visit(this); } }
@Override public void meet(Bound node) throws RuntimeException { ValueExpr arg = node.getArg(); if (arg instanceof ValueConstant) { builder.append(Boolean.toString(true)); } else if (arg instanceof Var) { builder.append("("); optypes.push(ValueType.NODE); arg.visit(this); optypes.pop(); builder.append(" IS NOT NULL)"); } }
private List<Element> createConnectedComponent( Map<Element, ElementStatus> elementStatusMap, Element root) { List<Element> connectedComponent = new ArrayList<>(); Deque<Element> stack = new ArrayDeque<>(); stack.push(root); while (!stack.isEmpty()) { Element element = stack.pop(); if (ElementStatus.UNREACHABLE.equals(elementStatusMap.get(element))) { connectedComponent.add(element); elementStatusMap.put(element, ElementStatus.REACHABLE); if (element instanceof RuntimeVertex) { RuntimeVertex vertex = (RuntimeVertex) element; for (RuntimeEdge edge : context.getModel().getOutEdges(vertex)) { stack.push(edge); } } else if (element instanceof RuntimeEdge) { RuntimeEdge edge = (RuntimeEdge) element; stack.push(edge.getTargetVertex()); } } } return Collections.unmodifiableList(connectedComponent); }
private void crossBorder() { if (isEnd) return; List<Block> blockTemp = new ArrayList<>(blocks); switch (inputDirection) { case 0: for (int i = 0; i < blockTemp.size(); i++) if (blockTemp.get(i).getY() >= 460) { Block temp = blockTemp.get(i); temp.setY(0); blockTemp.set(i, temp); } break; case 1: for (int i = 0; i < blockTemp.size(); i++) if (blockTemp.get(i).getX() >= 490) { Block temp = blockTemp.get(i); temp.setX(0); blockTemp.set(i, temp); } break; case 2: for (int i = 0; i < blockTemp.size(); i++) if (blockTemp.get(i).getY() <= 0) { Block temp = blockTemp.get(i); temp.setY(450); blockTemp.set(i, temp); } break; case 3: for (int i = 0; i < blockTemp.size(); i++) if (blockTemp.get(i).getX() <= 0) { Block temp = blockTemp.get(i); temp.setX(480); blockTemp.set(i, temp); } break; } Deque<Block> blocksTemp = new ArrayDeque<>(); for (int i = blockTemp.size() - 1; i >= 0; i--) blocksTemp.push(blockTemp.get(i)); blocks = blocksTemp; }
@Override public void meet(BNodeGenerator gen) throws RuntimeException { if (gen.getNodeIdExpr() != null) { // get value of argument and express it as string optypes.push(ValueType.STRING); gen.getNodeIdExpr().visit(this); optypes.pop(); } else { builder .append("'") .append( Long.toHexString(System.currentTimeMillis()) + Integer.toHexString(anonIdGenerator.nextInt(1000))) .append("'"); } }
@Override public void enterTypeImplInit(ResolveParser.TypeImplInitContext ctx) { Scope s = symtab.getScope(ctx.getParent()); PExp convention = currentTypeReprSym.getConvention(); PExp correspondence = currentTypeReprSym.getCorrespondence(); PExp typeInitEnsures = g.getTrueExp(); List<ModuleParameterSymbol> moduleParamSyms = getAllModuleParameterSyms(); VCAssertiveBlockBuilder block = new VCAssertiveBlockBuilder(g, s, "T_Init_Hypo=" + currentTypeReprSym.getName(), ctx) .assume(getModuleLevelAssertionsOfType(ClauseType.REQUIRES)) .assume( getAssertionsFromModuleFormalParameters( moduleParamSyms, this::extractAssumptionsFromParameter)); assertiveBlocks.push(block); }
@Override public void meet(Like node) throws RuntimeException { if (node.isCaseSensitive()) { optypes.push(ValueType.STRING); node.getArg().visit(this); optypes.pop(); builder.append(" LIKE "); node.getPattern(); } else { builder.append( parent .getDialect() .getILike( new ValueExpressionEvaluator(node.getArg(), parent, ValueType.STRING).build(), node.getOpPattern())); } }
public static QuantileDigest deserialize(DataInput input) { try { double maxError = input.readDouble(); double alpha = input.readDouble(); QuantileDigest result = new QuantileDigest(maxError, alpha); result.landmarkInSeconds = input.readLong(); result.min = input.readLong(); result.max = input.readLong(); result.totalNodeCount = input.readInt(); Deque<Node> stack = new ArrayDeque<>(); for (int i = 0; i < result.totalNodeCount; i++) { int flags = input.readByte(); Node node = deserializeNode(input); if ((flags & Flags.HAS_RIGHT) != 0) { node.right = stack.pop(); } if ((flags & Flags.HAS_LEFT) != 0) { node.left = stack.pop(); } stack.push(node); result.weightedCount += node.weightedCount; if (node.weightedCount >= ZERO_WEIGHT_THRESHOLD) { result.nonZeroNodeCount++; } } if (!stack.isEmpty()) { Preconditions.checkArgument( stack.size() == 1, "Tree is corrupted. Expected a single root node"); result.root = stack.pop(); } return result; } catch (IOException e) { throw Throwables.propagate(e); } }
private int findMaxArea(int[] height) { if (height == null || height.length == 0) return 0; int[] h = Arrays.copyOf(height, height.length + 1); int maxArea = 0; Deque<Integer> stack = new LinkedList(); int k = 0; while (k < h.length) { if (stack.isEmpty() || h[stack.peek()] <= h[k]) { stack.push(k++); } else { int t = stack.pop(); int leftIndex = (stack.isEmpty()) ? -1 : stack.peek(); int rightIndex = k; int tmpArea = h[t] * (rightIndex - leftIndex - 1); maxArea = Math.max(maxArea, tmpArea); } } return maxArea; }
public void request(int i, int j) { if (i < 0 || i > versions.length || j < 0 || j > versions[i].length) return; if (versions[i][j] == 0) return; synchronized (nodeSubList) { for (OnDemandData onDemandData = (OnDemandData) nodeSubList.reverseGetFirst(); onDemandData != null; onDemandData = (OnDemandData) nodeSubList.reverseGetNext()) if (onDemandData.dataType == i && onDemandData.id == j) return; OnDemandData onDemandData_1 = new OnDemandData(); onDemandData_1.dataType = i; onDemandData_1.id = j; onDemandData_1.incomplete = true; synchronized (aClass19_1370) { aClass19_1370.insertHead(onDemandData_1); } nodeSubList.push(onDemandData_1); } }
// 检测是否合法:合法 0,不合法 -1 public int checkValid(String s) { Deque<Integer> q = new ArrayDeque<>(); for (int i = 0; i < s.length(); i++) { char c = s.charAt(i); switch (c) { case '(': q.push(i); break; case ')': if (q.isEmpty()) { return -1; } else { q.pop(); } break; default: break; } } return q.isEmpty() ? 0 : -1; }