100) {\\r\\n\\t\\t\\t\\t\\tSystem.out.println(\\\"map generation failed! restarting\\\");\\r\\n\\t\\t\\t\\t\\tbreak;\\r\\n\\t\\t\\t\\t}\\r\\n\\t\\t\\t}while(!conorePass || !kannaitePass || !fuelPass || !forestPass);\\r\\n\\t\\t\\t//END OF LOOP 3\\r\\n\\r\\n\\t\\t\\t//LOOP 4: THE MOUNTAIN & OIL LOOP\\r\\n\\t\\t\\tfor (int i = 0; i < tileMap.length; i++) {\\r\\n\\t\\t\\t\\tfor (int j = 0; j < tileMap[i].length; j++) {\\r\\n\\t\\t\\t\\t\\tbuildMountain(i,j);\\r\\n\\t\\t\\t\\t\\tbuildOil(i,j);\\r\\n\\t\\t\\t\\t}\\r\\n\\t\\t\\t}//End of THE Mountain & OIL LOOP\\r\\n\\r\\n\\t\\t\\t//ADD MINIMUM AMOUNT OF ORES\\r\\n\\r\\n\\t\\t\\t//Generation Loop 5 *FINAL SETUP*\\r\\n\\t\\t\\tfor (int i = 0; i < tileMap.length; i++) {\\r\\n\\t\\t\\t\\tfor (int j = 0; j < tileMap[i].length; j++) {\\r\\n\\r\\n\\t\\t\\t\\t\\tif(i == 1 || j == 1 || i == tileMap.length-2 || j == tileMap[i].length-2) {\\r\\n\\t\\t\\t\\t\\t\\ttileMap[i][j] = new DesertTile(desert);\\r\\n\\t\\t\\t\\t\\t}\\r\\n\\r\\n\\t\\t\\t\\t\\tif (i == 0 || j == 0 || i == tileMap.length-1 || j == tileMap[i].length-1) {\\r\\n\\t\\t\\t\\t\\t\\ttileMap[i][j] = new WaterTile(water);\\r\\n\\t\\t\\t\\t\\t}\\r\\n\\r\\n\\t\\t\\t\\t}//End of for loop\\r\\n\\t\\t\\t}//End of for loop\\r\\n\\t\\t\\t//End of generation loop 5\\r\\n\\t\\t\\t//mapToString();//TEST RUN\\r\\n\\t\\t} while(!conorePass || !kannaitePass || !fuelPass || !forestPass); // End createWorldMap method\\r\\n\\t}\",\n \"public boolean tileReachable(float tx, float ty, AgentModel selectedAgent)\\r\\n/* 243: */ {\\r\\n/* 244:271 */ float x = selectedAgent.getX() - 0.5F;\\r\\n/* 245:272 */ float y = selectedAgent.getY() - 0.5F;\\r\\n/* 246:274 */ switch ((int)selectedAgent.getAngle())\\r\\n/* 247: */ {\\r\\n/* 248: */ case 0: \\r\\n/* 249:277 */ if ((y - 1.0F == ty) && (tx >= x - 1.0F) && (tx <= x + 1.0F)) {\\r\\n/* 250:279 */ return true;\\r\\n/* 251: */ }\\r\\n/* 252: */ break;\\r\\n/* 253: */ case 90: \\r\\n/* 254:283 */ if ((x + 1.0F == tx) && (ty >= y - 1.0F) && (ty <= y + 1.0F)) {\\r\\n/* 255:285 */ return true;\\r\\n/* 256: */ }\\r\\n/* 257: */ break;\\r\\n/* 258: */ case 180: \\r\\n/* 259:289 */ if ((y + 1.0F == ty) && (tx >= x - 1.0F) && (tx <= x + 1.0F)) {\\r\\n/* 260:291 */ return true;\\r\\n/* 261: */ }\\r\\n/* 262: */ break;\\r\\n/* 263: */ case 270: \\r\\n/* 264:295 */ if ((x - 1.0F == tx) && (ty >= y - 1.0F) && (ty <= y + 1.0F)) {\\r\\n/* 265:298 */ return true;\\r\\n/* 266: */ }\\r\\n/* 267: */ break;\\r\\n/* 268: */ }\\r\\n/* 269:303 */ return false;\\r\\n/* 270: */ }\",\n \"public LinkedList<GameState> successor(GameState a)\\n\\t{\\n\\t\\t//temperary gamestates that will be used for the legal moves\\n\\t\\tGameState w = new GameState();\\n\\t\\tGameState x = new GameState();\\n\\t\\tGameState y = new GameState();\\n\\t\\tGameState z = new GameState();\\n\\t\\t//System.out.println(\\\"THIS IS THE CURR NODE\\\");\\n\\t\\t//a.printGameState();\\n\\t\\t//System.out.println(a);\\n\\t\\t//create a linked list to return all of the legal moves as game states\\n\\t\\tLinkedList<GameState> ans = new LinkedList<GameState>();\\n\\t\\t//these are arrays that will be used to populate gamestates above\\n\\t\\tint[] d = a.moveDown();\\n\\t\\tint[] r = a.moveRight();\\n\\t\\tint[] u = a.moveUp();\\n\\t\\tint[] l = a.moveLeft();\\n\\t\\t//System.out.println(\\\"hello\\\");\\n\\t\\t//this is for the down move\\n\\t\\t//System.out.println(\\\"DOWN\\\");\\n\\t\\tif(!same1(d,check)) //make sure that moving down is a legall move\\n\\t\\t{\\n\\t\\t\\t//System.out.println(\\\"hello\\\");\\n\\t\\t\\t//if it is a legal move poplate the fieds with \\n\\t\\t\\tw.setBoard(d);\\n\\t\\t\\tw.setStateID(count);//giving unique id\\n\\t\\t\\tw.setG();\\n\\t\\t\\tw.setH(this.h(goalS.getBoard(), w));//passing in the empty space index of the goal node\\n\\t\\t\\tw.setF();\\n\\t\\t\\tw.setVisited(false);\\n\\t\\t\\tw.setParentStateID(a.getStateID());//set the parent id to that of the current game state\\n\\t\\t\\t//System.out.println(a.getStateID());\\n\\t\\t\\t//w.printGameState();\\n\\t\\t\\tw.setPriority(w.getF());//the priority is the f(n)\\n\\t\\t\\t \\n\\t\\t\\tans.add(w);//add new gamestate to the linked list of legal moves\\n\\t\\t}\\n\\t\\tcount++;//increment count so all the games states have unique ids\\n\\t\\t//this is for the up move\\n\\t\\t//System.out.println(\\\"UP\\\");\\n\\t\\tif(!same1(u,check)) //make sure that moving up is a legall move\\n\\t\\t{\\n\\t\\t\\tx.setBoard(u);\\n\\t\\t\\tx.setStateID(count);//giving unique id\\n\\t\\t\\tx.setG();\\n\\t\\t\\tx.setH(this.h(goalS.getBoard(), x));//passing in the empty space index of the goal node\\n\\t\\t\\tx.setF();\\n\\t\\t\\tx.setParentStateID(a.getStateID());//set the parent id to that of the current game state\\n\\t\\t\\tx.setVisited(false);\\n\\t\\t\\t//x.printGameState();\\n\\t\\t\\tx.setPriority(x.getF());//the priority is the f(n)\\n\\t\\t\\tans.add(x);//add new gamestate to the linked list of legal moves\\n\\t\\t}\\n\\t\\tcount++;//increment count so all the games states have unique ids\\n\\t\\t//\\tSystem.out.println(\\\"RIGHT\\\");\\n\\t\\t//this is for the right move\\n\\t\\tif(!same1(r,check)) //make sure that moving right is a legall move\\n\\t\\t{\\n\\t\\t\\t//System.out.println(\\\"hello\\\");\\n\\t\\t\\ty.setBoard(r);\\n\\t\\t\\ty.setStateID(count);//giving unique id\\n\\t\\t\\ty.setG();\\n\\t\\t\\ty.setH(this.h(goalS.getBoard(), y));//passing in the empty space index of the goal node\\n\\t\\t\\ty.setF();\\n\\t\\t\\ty.setParentStateID(a.stateID);//set the parent id to that of the current game state\\n\\t\\t\\ty.setVisited(false);\\n\\t\\t\\t//y.printGameState();\\n\\t\\t\\ty.setPriority(y.getF());//the priority is the f(n)\\n\\t\\t\\tans.add(y);//add new gamestate to the linked list of legal moves\\n\\t\\t}\\n\\t\\tcount++;//increment count so all the games states have unique ids\\n\\t\\t//this is for the left move\\n\\t\\t//System.out.println(\\\"LEFT\\\");\\n\\t\\tif(!same1(l,check)) //make sure that moving left is a legall move\\n\\t\\t{\\n\\t\\t\\tz.setBoard(l);\\n\\t\\t\\tz.setStateID(count);//giving unique id\\n\\t\\t\\tz.setG();\\n\\t\\t\\tz.setH(this.h(goalS.getBoard(), z));//passing in the empty space index of the goal node\\n\\t\\t\\tz.setF();\\n\\t\\t\\tz.setVisited(false);\\n\\t\\t\\tz.setParentStateID(a.getStateID());//set the parent id to that of the current game state\\n\\t\\t\\t//z.printGameState();\\n\\t\\t\\tz.setPriority(z.getF());//the priority is the f(n)r\\n\\t\\t\\t//count++;\\n\\t\\t\\tans.add(z);//add new gamestate to the linked list of legal moves\\n\\t\\t}\\n\\t\\tcount++;//increment count so all the games states have unique ids\\n\\t\\treturn ans;\\n\\t}\",\n \"@SuppressWarnings(\\\"ConstantConditions\\\")\\n private void moveToNest() throws AntArtException {\\n AntArea.Cell forward = getCellInDirection(directionVector);\\n AntArea.Cell left = getCellInDirection(AntDirections.moveCounterClockwise(directionVector));\\n AntArea.Cell right = getCellInDirection(AntDirections.moveClockWise(directionVector));\\n\\n //Try to move to a nest cell\\n List<AntArea.Cell> cellList = Arrays.asList(forward, left, right);\\n if (moveToNestCell(cellList)) {\\n return;\\n }\\n\\n //Sort according to home pheremone levels\\n cellList.sort((o1, o2) -> {\\n float hp1 = o1.getHomePheromone();\\n float hp2 = o2.getHomePheromone();\\n if (hp1 == hp2) {\\n return 0;\\n }\\n return hp1 > hp2 ? -1 : 1;\\n });\\n //Do a random action based on a probability\\n if (random.nextInt(Configuration.ANT_SELECTION_SEED) == 0) {\\n Collections.shuffle(cellList);\\n }\\n //Try to move to a cell\\n for (AntArea.Cell cell : cellList) {\\n if (moveTo(cell)) {\\n break;\\n }\\n }\\n }\",\n \"@Override\\n\\tpublic boolean startSearch() {\\n\\t\\tString str = \\\"\\\";\\n\\t\\t\\n\\t\\tDimension d = view.getInit();\\n\\t\\tif (d == null) {\\n\\t\\t\\tstr = str + \\\"Falta la posicion de inicio.\\\\n\\\";\\n\\t\\t} else {\\n\\t\\t\\ty0 = (int) d.getHeight();\\n\\t\\t\\tx0 = (int) d.getWidth();\\n\\t\\t}\\n\\t\\t\\n\\t\\td = view.getGoal();\\n\\t\\tif (d == null) {\\n\\t\\t\\tstr = str + \\\"Falta la posicion de meta.\\\\n\\\";\\n\\t\\t} else {\\n\\t\\t\\tyf = (int) d.getHeight();\\n\\t\\t\\txf = (int) d.getWidth();\\n\\t\\t}\\n\\t\\t\\n\\t\\tif (view.isBreadth()) {\\n\\t\\t\\tstrategy = new Breadth();\\n\\t\\t} else if (view.isDepth()) {\\n\\t\\t\\tstrategy = new Depth();\\n\\t\\t} else if (view.isAStar()) {\\n\\t\\t\\tstrategy = new AStar();\\n\\t\\t\\tif (view.isH0()) {\\n\\t\\t\\t\\theuristic = Horse.H0;\\n\\t\\t\\t} else if (view.isH1()) {\\n\\t\\t\\t\\theuristic = Horse.H1;\\n\\t\\t\\t} else if (view.isH2()) {\\n\\t\\t\\t\\theuristic = Horse.H2;\\n\\t\\t\\t} else\\n\\t\\t\\t\\tstr = str + \\\"Falta por escoger el tipo de heurstica.\\\\n\\\";\\n\\t\\t} else\\n\\t\\t\\tstr = str + \\\"Falta la estrategia de bsqueda.\\\\n\\\";\\n\\t\\t\\n\\t\\tboard = view.getBoard();\\n\\t\\t\\n\\t\\tif (str.equals(\\\"\\\")) {\\n\\t\\t\\trootNode = new Node(new Horse(x0,y0,xf,yf, board, heuristic));\\n\\t\\t}\\n\\t\\t\\n\\t\\tif (view.isTree()) {\\n\\t\\t\\tif (str.equals(\\\"\\\"))\\n\\t\\t\\t\\tsearch = new Tree(rootNode, strategy);\\n\\t\\t} else if (view.isGraph()) {\\n\\t\\t\\tif (str.equals(\\\"\\\"))\\n\\t\\t\\t\\tsearch = new Graph(rootNode, strategy);\\n\\t\\t} else \\n\\t\\t\\tstr = str + \\\"Falta el algoritmo de bsqueda.\\\\n\\\";\\n\\t\\t\\n\\t\\tif (!str.equals(\\\"\\\")) {\\n\\t\\t\\tview.showError(str);\\n\\t\\t\\treturn false;\\n\\t\\t}\\n\\t\\t\\n\\t\\tgoSearch();\\n\\t\\treturn true;\\n\\t}\",\n \"public void hunt() {\\n\\t\\tfor(int i = 0; i < N; i++) {\\n\\t\\t\\tif(cells[i].visited == false) {\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tint currentIndex = i;\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tArrayList<Integer> neighbors = setVisitedNeighbors(i);\\n\\t\\t\\t\\tint nextIndex = getRandomVisitedNeighborIndex(neighbors);\\n\\t\\t\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\tif(neighbors.size() != 0 ) {\\n\\t\\t\\t\\t\\tcells[currentIndex].visited = true;\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tif(nextIndex == NOT_EXIST) {\\n\\t\\t\\t\\t\\t\\tbreak; \\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t//if there is NO not visited neighbors \\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\telse if(currentIndex - nextIndex == -1) {\\n\\t\\t\\t\\t\\t\\tcells[currentIndex].border[EAST] = NO_WALL; \\t\\t\\t\\t\\t\\t\\t//neighbor is right \\n\\t\\t\\t\\t\\t\\tcells[nextIndex].border[WEST] = NO_WALL;\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\telse if(currentIndex - nextIndex == width) {\\n\\t\\t\\t\\t\\t\\tcells[currentIndex].border[NORTH] = NO_WALL;\\t\\t\\t\\t\\t\\t\\t//neighbor is up\\n\\t\\t\\t\\t\\t\\tcells[nextIndex].border[SOUTH] = NO_WALL;\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\telse if(currentIndex - nextIndex == -width) {\\t\\t\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\tcells[currentIndex].border[SOUTH] = NO_WALL;\\t\\t\\t\\t\\t\\t\\t//neighbor is down\\n\\t\\t\\t\\t\\t\\tcells[nextIndex].border[NORTH] = NO_WALL;\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\telse if(currentIndex - nextIndex == 1) {\\t\\t\\t\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\tcells[currentIndex].border[WEST] = NO_WALL;\\t\\t\\t\\t\\t\\t\\t\\t//neighbor is left\\n\\t\\t\\t\\t\\t\\tcells[nextIndex].border[EAST] = NO_WALL;\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\tkill(nextIndex);\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t}\\n\\t}\",\n \"@Override\\n\\tpublic boolean step(Tile newTile) {\\n\\t\\tif(newTile==null) return false;\\n\\t\\tTile temp=tile;\\n\\n\\t\\tboolean success = newTile.receiveAnimal(this); //NULLPTR\\n\\t\\tif(success) {\\n\\t\\t\\ttile.removePandaFromNeighborSubbedPandas(this); //Panda eltavolitasa a szomszedokrol.\\n\\t\\t\\tsubbedTiles.clear(); //Panda feliratkozasainak torlese\\n\\t\\t\\tfor(Tile newTileNeighbor:newTile.getNeighbors()) {\\n\\t\\t\\t\\tif(map.getSpecificTiles(hatesEntity).contains(newTileNeighbor)) {\\n\\t\\t\\t\\t\\taddSubbedTile(newTileNeighbor); //Az uj helyen szomszedok felirasa pandara\\n\\t\\t\\t\\t\\tnewTileNeighbor.addSubbedPanda(this); //Az uj helyen szomszedokra feliratkozasok\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\t//animate(temp,newTile);\\n\\t\\t\\tif(isFollowedBy())\\n\\t\\t\\t\\tfollowedBy.step(temp);\\n\\t\\t}\\n\\n\\t\\treturn success;\\n\\t}\",\n \"Pair<String,LeafNode> chooseNode(T i){\\n Set<Map.Entry<String, Identifier>> s= leafInfos.entrySet();\\n Identifier page=null;\\n LeafNode ln = null;\\n for(Map.Entry<String,Identifier> p: s){\\n TriangleShape t = triangleEncoder.parse(p.getKey());\\n if(Geom2DSuits.contains(t,i.getLowerBound(),i.getUpperBound())){\\n ln = readNode(p.getValue());\\n return new Pair<String,LeafNode>(p.getKey(),ln);\\n }\\n\\n// int r = test(t,(Interval)i);\\n// if(r==0)\\n// continue;\\n// else{\\n// page = p.getValue();\\n// if(page.longValue()!=-1)\\n// ln = readNode(page);\\n// else{\\n// ln = new LeafNode();\\n// }\\n// return new Pair<String,LeafNode>(p.getKey(),ln);\\n// }\\n }\\n\\n //2. there is no leaf node that contains i, scan the emptyNodes only when the insertion is running\\n int k=0;\\n for(String str: emptyNodes){\\n TriangleShape t = triangleEncoder.parse(str);\\n if(Geom2DSuits.contains(t,i.getLowerBound(),i.getUpperBound())){\\n String sss = emptyNodes.remove(k);\\n ln = new LeafNode();\\n ln.triangle = t;\\n return new Pair<String,LeafNode>(sss,ln);\\n }\\n ++k;\\n }\\n\\n //3. error\\n assert false;\\n return new Pair<String,LeafNode>(null,null);\\n }\",\n \"public void findShortestPath() {\\r\\n\\t\\t\\r\\n\\t\\t//Create a circular array that will store the possible next tiles in the different paths.\\r\\n\\t\\tOrderedCircularArray<MapCell> path = new OrderedCircularArray<MapCell>();\\r\\n\\t\\t\\r\\n\\t\\t//Acquire the starting cell.\\r\\n\\t\\tMapCell starting = cityMap.getStart();\\r\\n\\t\\t\\r\\n\\t\\t//This variable is to be updated continuously with the cell with the shortest distance value in the circular array.\\r\\n\\t\\tMapCell current=null;\\r\\n\\t\\t\\r\\n\\t\\t//This variable is to check if the destination has been reached, which is initially false.\\r\\n\\t\\tboolean destination = false;\\r\\n\\t\\t\\r\\n\\t\\t//Add the starting cell into the circular array, and mark it in the list.\\r\\n\\t\\tpath.insert(starting, 0);\\r\\n\\t\\t\\r\\n\\t\\tstarting.markInList(); \\r\\n\\t\\t\\r\\n\\t\\ttry {\\r\\n\\t\\t\\t\\r\\n\\t\\t\\t//As long as the circular array isn't empty, and the destination hasn't been reached, run this loop.\\r\\n\\t\\t\\twhile(!path.isEmpty()&&!destination) {\\r\\n\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t//Take the cell with the shortest distance out of the circular array, and mark it accordingly.\\r\\n\\t\\t\\t\\tcurrent = path.getSmallest();\\r\\n\\t\\t\\t\\tcurrent.markOutList();\\r\\n\\t\\t\\t\\t\\r\\n\\t\\t\\t\\tMapCell next;\\r\\n\\t\\t\\t\\tint distance;\\r\\n\\t\\t\\t\\t\\r\\n\\t\\t\\t\\tif(current.isDestination()) {\\r\\n\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\tdestination = true; //If the current cell is the destination, end the loop.\\r\\n\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t} else {\\r\\n\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\tnext = nextCell(current); //Acquire the next possible neighbour of the current cell.\\r\\n\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\t//Don't run if next is null, meaning there is no other possible neighbour in the path for the current cell.\\r\\n\\t\\t\\t\\t\\twhile(next!=null) {\\r\\n\\t\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\t\\tdistance = current.getDistanceToStart() + 1;\\r\\n\\t\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\t\\t//If the distance of the selected neighbouring cell is currently more than 1 more than the current cell's \\r\\n\\t\\t\\t\\t\\t\\t//distance, update the distance of the neighbouring cell. Then, set the current cell as its predecessor.\\r\\n\\t\\t\\t\\t\\t\\tif(next.getDistanceToStart()>distance) {\\r\\n\\t\\t\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\t\\t\\tnext.setDistanceToStart(distance);\\r\\n\\t\\t\\t\\t\\t\\t\\tnext.setPredecessor(current);\\r\\n\\t\\t\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\t\\tdistance = next.getDistanceToStart(); \\r\\n\\t\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\t\\tif(next.isMarkedInList() && distance<path.getValue(next)) {\\r\\n\\t\\t\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\t\\t\\tpath.changeValue(next, distance); //If the neighbouring cell is in the circular array, but with a \\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t //larger distance value than the new updated distance, change its value.\\r\\n\\t\\t\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\t\\t} else if(!next.isMarkedInList()){\\r\\n\\t\\t\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\t\\t\\tpath.insert(next, distance); //If the neighbouring cell isn't in the circular array, add it in.\\r\\n\\t\\t\\t\\t\\t\\t\\tnext.markInList();\\r\\n\\t\\t\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\t\\tnext = nextCell(current); //Look for the next possible neighbour, if any.\\r\\n\\t\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\t\\r\\n\\t\\t\\t}\\r\\n\\t\\t\\t\\r\\n\\t\\t\\t//Catch all the possible exceptions that might be thrown by the method calls. Print the appropriate messages.\\r\\n\\t\\t} catch (EmptyListException e) {\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tSystem.out.println(e.getMessage());\\r\\n\\t\\t\\tSystem.out.println(\\\"Path finding execution stopped.\\\");\\r\\n\\t\\t\\t\\r\\n\\t\\t} catch (InvalidNeighbourIndexException e) {\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tSystem.out.println(\\\"The program tried to access an invalid neighbour of a tile.\\\");\\r\\n\\t\\t\\tSystem.out.println(\\\"Path finding execution stopped.\\\");\\r\\n\\t\\t\\t\\r\\n\\t\\t} catch (InvalidDataItemException e) {\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tSystem.out.println(e.getMessage());\\r\\n\\t\\t\\tSystem.out.println(\\\"Path finding execution stopped.\\\");\\r\\n\\t\\t\\t\\r\\n\\t\\t} catch (Exception e) {\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tSystem.out.println(e.getMessage()+\\\" Path finding execution has stopped.\\\");\\r\\n\\t\\t\\t\\r\\n\\t\\t}\\r\\n\\t\\t\\r\\n\\t\\t//If a path was found, print the number of tiles in the path.\\r\\n\\t\\tif(destination) {\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tSystem.out.println(\\\"Number of tiles in path: \\\" + (current.getDistanceToStart()+1));\\r\\n\\t\\t\\t\\r\\n\\t\\t} else {\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tSystem.out.println(\\\"No path found.\\\"); //Otherwise, indicate that a path wasn't found.\\r\\n\\t\\t\\t\\r\\n\\t\\t}\\r\\n\\t\\t\\r\\n\\t}\",\n \"private boolean searchBoardForTarget(BoardSquareInfo start, BoardSquareInfo target, int state, boolean backwards, ArrayList<BoardSquareInfo> path) {\\n\\t\\tLog.d(LOG_TAG, \\\"Search board for target\\\");\\n\\t\\tLog.d(LOG_TAG, String.format(\\\"*****start: %s\\\",start));\\n\\t\\tLog.d(LOG_TAG, String.format(\\\"*****target: %s\\\",target));\\n\\t\\tLog.d(LOG_TAG, String.format(\\\"*****state: %s\\\",state));\\n\\t\\tLog.d(LOG_TAG, String.format(\\\"*****backwards: %s\\\",backwards));\\n\\t\\t\\n\\t\\t// NOTE: Revisit code to ensure logic correct, especially if \\n\\t\\t// I continue to add checks for cases not handled\\n\\t\\t\\n\\t\\t// See note at class level\\n\\t\\tint row = (state == PLAYER1_STATE) ? -1 : +1;\\n\\t\\tint col = (backwards)? -1: +1;\\n\\t\\t\\n\\t\\t// Check side\\n\\t\\tBoardSquareInfo square = getData(start.row + row, start.column + col);\\n\\t\\tif (square == null) {\\n\\t\\t\\tLog.d(LOG_TAG, \\\"*****square evaluate to null\\\");\\n\\t\\t\\treturn false;\\n\\t\\t}\\n\\n\\t\\tLog.d(LOG_TAG, String.format(\\\"*****square evaluated: %s\\\", square));\\n\\t\\t\\n\\t\\t// Found it\\n\\t\\tif (target.equals(square)) {\\n\\t\\t\\tLog.d(LOG_TAG, \\\"*****target found\\\");\\n\\t\\t\\treturn true;\\n\\t\\t} // end if\\n\\n\\t\\t// STOP, square states are the same\\n\\t\\tif(square.state == activeState)\\n\\t\\t\\treturn false;\\n\\t\\t\\n\\t\\t// Peek at next square. \\n\\t\\tBoardSquareInfo peek = getData(square.row + row, square.column + col);\\n\\t\\tif(peek == null) {\\n\\t\\t\\tLog.d(LOG_TAG, \\\"*****peek is null\\\");\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\treturn false;\\n\\t\\t} // end if\\n\\t\\t\\n\\t\\t// We know now that we can't jump move to peek\\n\\t\\t// STOP, we can never find target on this path\\n\\t\\tif(peek.state == activeState) {\\n\\t\\t\\tLog.d(LOG_TAG, \\\"*****stop, we can never move pass a square with same state\\\");\\n\\t\\t\\treturn false;\\n\\t\\t}\\n\\t\\t\\n\\t\\t// King allow to move over two consecutive empty squares\\n \\t\\tif(activeSquare.isKing \\n\\t\\t\\t\\t&& peek.state == EMPTY_STATE \\n\\t\\t\\t\\t&& peek.state == square.state \\n\\t\\t\\t\\t&& moveActiveSquare(square,target,state,path)) {\\n \\t\\t\\tLog.d(LOG_TAG, \\\"*****king moved over two or more consecutive emtpy squares complete\\\");\\n \\t\\t\\tpath.add(square);\\n\\t\\t\\treturn true;\\n \\t\\t}\\n\\t\\t\\n\\t\\t// We know peek isn't an empty square\\n\\t\\t// STOP, never jump over two square with same state \\n\\t\\tif(peek.state == square.state) {\\n\\t\\t\\tLog.d(LOG_TAG, \\\"*****stop, never jump over two squares with same state\\\");\\n\\t\\t\\treturn false;\\n\\t\\t}\\n\\t\\t\\n\\t\\t// Remove opponent\\n\\t\\tif (square.state != EMPTY_STATE && moveActiveSquare(square, target, state,path)) {\\n\\t\\t\\tLog.d(LOG_TAG, String.format(\\\"*****removing opponent square: %s\\\", square));\\n\\t\\t\\tpath.add(square);\\n\\t\\t\\treturn true;\\n\\t\\t}\\n\\n\\t\\t// Continue moving\\n\\t\\tif(square.state == EMPTY_STATE && moveActiveSquare(square,target,state,path)) {\\n\\t\\t\\tLog.d(LOG_TAG, \\\"*****continue moving done\\\");\\n\\t\\t\\tpath.add(square);\\n\\t\\t\\treturn true;\\n\\t\\t}\\n\\t\\t\\n\\t\\tLog.d(LOG_TAG, \\\"*****target not found on this path\\\");\\n\\t\\treturn false;\\n\\t}\",\n \"private void generateFirstMap(Node parent, int[] board, int player){\\n\\t\\tint qCount = 0, i = -1;\\n\\t\\ttry{\\n\\t\\t\\tint[][] queenPos = new int[4][2];\\n\\t\\t\\tfor(i = 0; i < board.length; i++){\\n\\t\\t\\t\\tif(board[i] == player){\\n\\t\\t\\t\\t\\tqueenPos[qCount][0] = i%10; // X\\n\\t\\t\\t\\t\\tqueenPos[qCount][1] = i/10; // Y\\n\\t\\t\\t\\t\\tgenQueenMovesMap(generateFirstMapList[qCount++], board, i);\\n\\t\\t\\t\\t\\tif(qCount > 3){break;}\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\tint count = 0;\\n\\t\\t\\tfor(int[] movemap : generateFirstMapList){\\n\\t\\t\\t\\tboard[queenPos[count][1]*GRID+queenPos[count][0]] = 0;\\n\\t\\t\\t\\tfor(int x = 0; x <= 9; x++){\\n\\t\\t\\t\\t\\tfor(int y = 0; y <= 9; y++){\\n\\t\\t\\t\\t\\t\\tif(movemap[y*GRID+x] != 0){\\n\\t\\t\\t\\t\\t\\t\\tgenShotMap(shotMapGlob, board, x, y);\\n\\t\\t\\t\\t\\t\\t\\tmultiply_shotmap(parent,movemap[y*GRID+x],shotMapGlob);\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\tboard[queenPos[count][1]*GRID+queenPos[count][0]] = player;\\n\\t\\t\\t\\tcount++;\\n\\t\\t\\t}\\n\\t\\t} catch (Exception e){\\n\\t\\t\\tSystem.out.println(\\\"q \\\"+qCount+\\\" i\\\"+i);\\n\\t\\t\\t//System.out.println(printMap(board));\\n\\t\\t}\\n\\t}\",\n \"public void explore() {\\n\\t\\t\\tif(getSpeed() < CAR_MAX_SPEED){ // Need speed to turn and progress toward the exit\\n\\t\\t\\t\\tapplyForwardAcceleration(); // Tough luck if there's a wall in the way\\n\\t\\t\\t}\\n\\t\\t\\tif (isFollowingWall) {\\n\\t\\t\\t\\t// if already been to this tile, stop following the wall\\n\\t\\t\\t\\tif (travelled.contains(new Coordinate(getPosition()))) {\\n\\t\\t\\t\\t\\tisFollowingWall = false;\\n\\t\\t\\t\\t} else {\\n\\t\\t\\t\\t\\tif(!checkFollowingWall(getOrientation(), map)) {\\n\\t\\t\\t\\t\\t\\tturnLeft();\\n\\t\\t\\t\\t\\t} else {\\n\\t\\t\\t\\t\\t\\t// If wall on left and wall straight ahead, turn right\\n\\t\\t\\t\\t\\t\\tif(checkWallAhead(getOrientation(), map)) {\\n\\t\\t\\t\\t\\t\\t\\tif (!checkWallRight(getOrientation(), map))\\t{\\n\\t\\t\\t\\t\\t\\t\\t\\tturnRight();\\n\\t\\t\\t\\t\\t\\t\\t\\tisFollowingWall = true;\\n\\t\\t\\t\\t\\t\\t\\t} else if (!checkWallLeft(getOrientation(), map)){\\n\\t\\t\\t\\t\\t\\t\\t\\tturnLeft();\\n\\t\\t\\t\\t\\t\\t\\t} else {\\n\\t\\t\\t\\t\\t\\t\\t\\tapplyReverseAcceleration();\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t}\\n\\t\\t\\t} else {\\n\\t\\t\\t\\t// Start wall-following (with wall on left) as soon as we see a wall straight ahead\\n\\t\\t\\t\\tif(checkWallAhead(getOrientation(), map)) {\\n\\t\\t\\t\\t\\tif (!checkWallRight(getOrientation(), map) && !checkWallLeft(getOrientation(), map)) {\\n\\t\\t\\t\\t\\t\\t// implementing some randomness so doesn't get stuck in loop\\n\\t\\t\\t\\t\\t\\tRandom rand = new Random();\\n\\t\\t\\t\\t\\t\\tint n = rand.nextInt(2);\\n\\t\\t\\t\\t\\t\\tif (n==0) {\\n\\t\\t\\t\\t\\t\\t\\tturnLeft();\\n\\t\\t\\t\\t\\t\\t} else {\\n\\t\\t\\t\\t\\t\\t\\tturnRight();\\n\\t\\t\\t\\t\\t\\t\\tisFollowingWall = true;\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t} else if (!checkWallRight(getOrientation(), map))\\t{\\n\\t\\t\\t\\t\\t\\tturnRight();\\n\\t\\t\\t\\t\\t\\tisFollowingWall = true;\\n\\t\\t\\t\\t\\t} else if (!checkWallLeft(getOrientation(), map)){\\n\\t\\t\\t\\t\\t\\tturnLeft();\\n\\t\\t\\t\\t\\t} else {\\n\\t\\t\\t\\t\\t\\tapplyReverseAcceleration();\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t}\",\n \"private void performInsideCheck() {\\n if (checkInsideDone) {\\n return;\\n }\\n \\n checkInsideDone = true;\\n \\n final Location playerLoc = World.getPlayer().getLocation();\\n final int currX = playerLoc.getScX();\\n final int currY = playerLoc.getScY();\\n int currZ = playerLoc.getScZ();\\n boolean nowOutside = false;\\n boolean isInside = false;\\n \\n for (int i = 0; i < 2; ++i) {\\n currZ++;\\n if (isInside || parent.isMapAt(currX, currY, currZ)) {\\n if (!insideStates[i]) {\\n insideStates[i] = true;\\n synchronized (unchecked) {\\n unchecked.add(Location.getKey(currX, currY, currZ));\\n }\\n }\\n isInside = true;\\n } else {\\n if (insideStates[i]) {\\n insideStates[i] = false;\\n nowOutside = true;\\n }\\n }\\n }\\n \\n /*\\n * If one of the values turned from inside to outside, all tiles are added to the list to be checked again.\\n */\\n if (nowOutside) {\\n synchronized (unchecked) {\\n unchecked.clear();\\n parent.processTiles(this);\\n }\\n }\\n \\n World.getWeather().setOutside(!isInside);\\n }\",\n \"private void setAvailableFromLastMove(int large, int smallx) {\\n clearAvailable();\\n // Make all the tiles at the destination available\\n if (large != -1) {\\n\\n\\n for (int i = 0; i < 9; i++) {\\n for (int dest = 0; dest < 9; dest++) {\\n if (!phaseTwo) {\\n if (!done) {\\n if (i == large) {\\n TileAssignment5 tile = mSmallTiles[large][dest];\\n if ((tile.getOwner() == TileAssignment5.Owner.NOTCLICKED))\\n addAvailable(tile);\\n\\n switch (smallx) {\\n case 0:\\n int a[] = adjacencyList.get(0);\\n\\n for (int x : a) {\\n TileAssignment5 tile1 = mSmallTiles[large][x];\\n //if(mAvailable.contains(tile1)) {\\n mAvailable.remove(tile1);\\n //}\\n }\\n break;\\n case 1:\\n int a1[] = adjacencyList.get(1);\\n\\n for (int x : a1) {\\n TileAssignment5 tile2 = mSmallTiles[large][x];\\n // if(mAvailable.contains(tile2)) {\\n mAvailable.remove(tile2);\\n //}\\n }\\n break;\\n case 2:\\n int a2[] = adjacencyList.get(2);\\n for (int x : a2) {\\n TileAssignment5 tile3 = mSmallTiles[large][x];\\n // if(mAvailable.contains(tile3)) {\\n mAvailable.remove(tile3);\\n // }\\n }\\n break;\\n case 3:\\n int a3[] = adjacencyList.get(3);\\n for (int x : a3) {\\n TileAssignment5 tile4 = mSmallTiles[large][x];\\n //if(mAvailable.contains(tile4)) {\\n mAvailable.remove(tile4);\\n // }\\n }\\n break;\\n case 4:\\n int a4[] = adjacencyList.get(4);\\n for (int x : a4) {\\n TileAssignment5 tile5 = mSmallTiles[large][x];\\n //if(mAvailable.contains(tile5)) {\\n mAvailable.remove(tile5);//}\\n\\n }\\n break;\\n case 5:\\n int a5[] = adjacencyList.get(5);\\n for (int x : a5) {\\n TileAssignment5 tile6 = mSmallTiles[large][x];\\n //if(mAvailable.contains(tile6)) {\\n mAvailable.remove(tile6);//}\\n\\n }\\n break;\\n case 6:\\n int a6[] = adjacencyList.get(6);\\n for (int x : a6) {\\n TileAssignment5 tile7 = mSmallTiles[large][x];\\n //if(mAvailable.contains(tile7)) {\\n mAvailable.remove(tile7);//}\\n\\n }\\n break;\\n case 7:\\n int a7[] = adjacencyList.get(7);\\n for (int x : a7) {\\n TileAssignment5 tile8 = mSmallTiles[large][x];\\n // if(mAvailable.contains(tile8)) {\\n mAvailable.remove(tile8);//}\\n\\n }\\n break;\\n case 8:\\n int a8[] = adjacencyList.get(8);\\n for (int x : a8) {\\n TileAssignment5 tile9 = mSmallTiles[large][x];\\n //if(mAvailable.contains(tile9)) {\\n mAvailable.remove(tile9);//}\\n\\n }\\n break;\\n }\\n\\n } else {\\n if (DoneTiles.contains(i)) {\\n continue;\\n }\\n TileAssignment5 tile = mSmallTiles[i][dest];\\n tile.setOwner(TileAssignment5.Owner.FREEZED);\\n tile.updateDrawableState('a', 0);\\n }\\n } else { //OnDOnePressed\\n if (DoneTiles.contains(i)) {\\n continue;\\n }\\n\\n // Log.d(\\\"Comes \\\", \\\"Hereeee\\\");\\n if (i != large) {//Correct answer\\n TileAssignment5 tile = mSmallTiles[i][dest];\\n tile.setOwner(TileAssignment5.Owner.NOTCLICKED);\\n addAvailable(tile);\\n tile.updateDrawableState('a', 0);\\n //done =false;\\n }\\n }\\n\\n\\n }else {\\n/*\\n ileAssignment5 thistile = mSmallTiles[i][dest];\\n if(((Button)thistile.getView()).getText().charAt(0)==' '){\\n mAvailable.remove(thistile);\\n thistile.updateDrawableState('a', 0);\\n }\\n*/\\n\\n\\n if (i == large) {\\n if (dest == smallx) {\\n TileAssignment5 tile1 = mSmallTiles[large][dest];\\n tile1.setOwner(TileAssignment5.Owner.CLICKED);\\n if (mAvailable.contains(tile1)) {\\n mAvailable.remove(tile1);\\n }\\n tile1.updateDrawableState('a', 0);\\n\\n } else {\\n TileAssignment5 tile2 = mSmallTiles[large][dest];\\n if (!(tile2.getOwner() == TileAssignment5.Owner.CLICKED)) {\\n\\n tile2.setOwner(TileAssignment5.Owner.FREEZED);\\n }\\n if (mAvailable.contains(tile2)) {\\n mAvailable.remove(tile2);\\n }\\n tile2.updateDrawableState('a', 0);\\n }\\n\\n\\n } else {\\n\\n\\n TileAssignment5 tile3 = mSmallTiles[i][dest];\\n if (!(tile3.getOwner() == TileAssignment5.Owner.CLICKED)) {\\n tile3.setOwner(TileAssignment5.Owner.NOTCLICKED);\\n }\\n // if(((((Button)mSmallTiles[i][dest].getView()).getText().toString().equals(null))||((Button)mSmallTiles[i][dest].getView()).getText().toString().charAt(0)==' ')||(((Button)mSmallTiles[i][dest].getView()).getText().toString().equals(\\\"\\\"))){\\n\\n if ((!mAvailable.contains(tile3))&&(tile3.getView().toString().charAt(0)!=' ')){\\n mAvailable.add(tile3);\\n }\\n\\n\\n tile3.updateDrawableState('a', 0);\\n\\n\\n\\n TileAssignment5 tile = mSmallTiles[i][dest];\\n if(((Button)mSmallTiles[i][dest].getView()).getText().toString().charAt(0)==' '){\\n // Log.d(\\\"Yes \\\", \\\"it came\\\");\\n if(mAvailable.contains(tile)){\\n mAvailable.remove(tile);\\n }\\n\\n }\\n else{\\n if(!mAvailable.contains(tile)){\\n addAvailable(tile);}\\n }\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n /*\\n\\n\\n\\n\\n\\n\\n ileAssignment5 tile = mSmallTiles[i][dest];\\n ileAssignment5 tile = mSmallTiles[i][dest];\\n try{\\n if(((((Button)mSmallTiles[i][dest].getView()).getText().toString().equals(null))||((Button)mSmallTiles[i][dest].getView()).getText().toString().charAt(0)==' ')||(((Button)mSmallTiles[i][dest].getView()).getText().toString().equals(\\\"\\\"))){\\n // Log.d(\\\"Yes \\\", \\\"it came\\\");\\n if(mAvailable.contains(tile)){\\n mAvailable.remove(tile);\\n }\\n }\\n else{\\n if(!mAvailable.contains(tile)){\\n addAvailable(tile);}\\n }}catch (ArrayIndexOutOfBoundsException e){\\n\\n\\n }catch ( StringIndexOutOfBoundsException e){\\n\\n }\\n\\n*/\\n }\\n\\n }\\n }\\n }\\n }\\n // If there were none available, make all squares available\\n if (mAvailable.isEmpty()&&large==-1) {\\n setAllAvailable();\\n }\\n }\",\n \"public final Tile selectComputerMove() {\\r\\n Tile tile = null;\\r\\n int count = 0;\\r\\n String tileName = null;\\r\\n boolean continueLoop = true;\\r\\n \\r\\n // First try to find a winning move\\r\\n for (Rail rail : rails) {\\r\\n for (Tile t : rail.getTiles()) {\\r\\n if (t.getText().equals(\\\"0\\\")) count++;\\r\\n }\\r\\n if (count == 2) {\\r\\n for (Tile t : rail.getTiles()) {\\r\\n if (t.getText().equals(\\\"\\\")) {\\r\\n tileName = t.getName();\\r\\n return t;\\r\\n }\\r\\n }\\r\\n }\\r\\n count = 0; \\r\\n }\\r\\n \\r\\n // If none found, try to block \\\"X\\\"\\r\\n for (Rail rail : rails) {\\r\\n for (Tile t : rail.getTiles()) {\\r\\n if (t.getText().equals(\\\"X\\\")) count++;\\r\\n }\\r\\n if (count == 2) {\\r\\n for (Tile t : rail.getTiles()) {\\r\\n if (t.getText().equals(\\\"\\\")) {\\r\\n tileName = t.getName();\\r\\n return t;\\r\\n }\\r\\n }\\r\\n }\\r\\n count = 0;\\r\\n }\\r\\n \\r\\n // If no blocking move, try to play the center which gives \\\"O\\\"\\r\\n // a statistical advantage\\r\\n if (!tiles[R2C2].isSelected()) {\\r\\n return tiles[R2C2];\\r\\n }\\r\\n \\r\\n \\r\\n // If center move is not available, try to find an open corner tile, \\r\\n // which might set up an winning combination\\r\\n if (!tiles[R1C1].isSelected()) {\\r\\n return tiles[R1C1];\\r\\n } else if (!tiles[R3C3].isSelected()) {\\r\\n return tiles[R3C3];\\r\\n } else if (!tiles[R3C1].isSelected()) {\\r\\n return tiles[R3C1];\\r\\n } else if (!tiles[R1C3].isSelected()) {\\r\\n return tiles[R1C3];\\r\\n }\\r\\n \\r\\n // If none found just pick an empty tile at random\\r\\n if(tileName == null) {\\r\\n int row = rand.nextInt(3) + 1;\\r\\n int col = rand.nextInt(3) + 1;\\r\\n tileName = \\\"r\\\" + row + \\\"c\\\" + col;\\r\\n for (Tile btn: tiles) {\\r\\n if (btn.getName().equals(tileName)) {\\r\\n tile = btn;\\r\\n break;\\r\\n }\\r\\n }\\r\\n }\\r\\n \\r\\n return tile;\\r\\n }\",\n \"private void bfs(Dungeon d, Site s) {\\n\\t\\t\\n\\t\\t// use a queue to do BFS, and initialize instance variables\\n\\t\\tQueue<Site> q = new LinkedList<Site>();\\n\\t\\tfor (int x = 0; x < d.size(); x++)\\n\\t\\t\\tfor (int y = 0; y < d.size(); y++)\\n\\t\\t\\t\\tdistTo[x][y] = INFINITY; \\n\\t\\tdistTo[s.getX()][s.getY()] = 0;\\n\\t\\tmarked[s.getX()][s.getY()] = true;\\n\\t\\t\\n\\t\\t// pop site from queue until it's empty\\n\\t\\tq.offer(s);\\n\\t\\twhile (!q.isEmpty()) {\\n\\t\\t\\t\\n\\t\\t\\t// pop the next site in the queue\\n\\t\\t\\tSite v = q.poll(); \\t \\n\\t\\t\\tint x = v.getX();\\n\\t\\t\\tint y = v.getY();\\n\\n\\t\\t\\t// 4 adjacent sites\\n\\t\\t\\tSite east = new Site(x + 1, y);\\n\\t\\t\\tSite west = new Site(x - 1, y);\\n\\t\\t\\tSite north = new Site(x, y - 1);\\n\\t\\t\\tSite south = new Site(x, y + 1);\\n\\n\\t\\t\\t// BFS the rest of the dungeon\\n\\t\\t\\tif (d.isLegalMove(v, east) && !marked[east.getX()][east.getY()]) {\\n\\t\\t\\t\\tedgeTo[east.getX()][east.getY()] = v;\\n\\t\\t\\t\\tdistTo[east.getX()][east.getY()] = distTo[x][y] + 1;\\n\\t\\t\\t\\tmarked[east.getX()][east.getY()] = true;\\n\\t\\t\\t\\tq.offer(east);\\n\\t\\t\\t}\\n\\t\\t\\tif (d.isLegalMove(v, west) && !marked[west.getX()][west.getY()]) {\\n\\t\\t\\t\\tedgeTo[west.getX()][west.getY()] = v;\\n\\t\\t\\t\\tdistTo[west.getX()][west.getY()] = distTo[x][y] + 1;\\n\\t\\t\\t\\tmarked[west.getX()][west.getY()] = true;\\n\\t\\t\\t\\tq.offer(west);\\n\\t\\t\\t}\\n\\t\\t\\tif (d.isLegalMove(v, north) && !marked[north.getX()][north.getY()]) {\\n\\t\\t\\t\\tedgeTo[north.getX()][north.getY()] = v;\\n\\t\\t\\t\\tdistTo[north.getX()][north.getY()] = distTo[x][y] + 1;\\n\\t\\t\\t\\tmarked[north.getX()][north.getY()] = true;\\n\\t\\t\\t\\tq.offer(north);\\n\\t\\t\\t}\\n\\t\\t\\tif (d.isLegalMove(v, south) && !marked[south.getX()][south.getY()]) {\\n\\t\\t\\t\\tedgeTo[south.getX()][south.getY()] = v;\\n\\t\\t\\t\\tdistTo[south.getX()][south.getY()] = distTo[x][y] + 1;\\n\\t\\t\\t\\tmarked[south.getX()][south.getY()] = true;\\n\\t\\t\\t\\tq.offer(south);\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t}\",\n \"public List<Move> validMoves(){\\n List<Move> results = new LinkedList<>();\\n int kingVal = turn == WHITE ? WHITE_KING : BLACK_KING;\\n int kingX = 0, kingY = 0;\\n List<Piece> checks = null;\\n kingSearch:\\n for (int y = 0; y < 8; y++){\\n for (int x = 0; x < 8; x++){\\n if (board[y][x] == kingVal){\\n kingX = x;\\n kingY = y;\\n checks = inCheck(x,y);\\n break kingSearch;\\n }\\n }\\n }\\n if (checks.size() > 1){ // must move king\\n for (int x = -1; x < 2; x++){\\n for (int y = -1; y < 2; y++){\\n if (kingX+x >= 0 && kingX + x < 8 && kingY+y >= 0 && kingY+y < 8){\\n int val = board[kingY+y][kingX+x];\\n if (val == 0 || turn == WHITE && val > WHITE_KING || turn == BLACK && val < BLACK_PAWN){\\n // may still be a move into check, must test at end\\n results.add(new Move(kingVal, kingX, kingY, kingX+x, kingY+y, val, 0, this));\\n }\\n }\\n }\\n }\\n } else { // could be in check TODO: split into case of single check and none, identify pin/capture lines\\n int queen = turn == WHITE ? WHITE_QUEEN : BLACK_QUEEN;\\n int knight = turn == WHITE ? WHITE_KNIGHT : BLACK_KNIGHT;\\n int rook = turn == WHITE ? WHITE_ROOK : BLACK_ROOK;\\n int bishop = turn == WHITE ? WHITE_BISHOP : BLACK_BISHOP;\\n for (int y = 0; y < 8; y++) {\\n for (int x = 0; x < 8; x++) {\\n int piece = board[y][x];\\n if (piece == (turn == WHITE ? WHITE_PAWN : BLACK_PAWN)) { // pawns\\n // regular | 2 move\\n if (board[y+turn][x] == 0){\\n if (y+turn == 0 || y + turn == 7){ // promotion\\n results.add(new Move(piece, x, y, x, y + turn, 0, queen, this));\\n results.add(new Move(piece, x, y, x, y + turn, 0, knight, this));\\n results.add(new Move(piece, x, y, x, y + turn, 0, rook, this));\\n results.add(new Move(piece, x, y, x, y + turn, 0, bishop, this));\\n }\\n else {\\n results.add(new Move(piece, x, y, x, y + turn, 0, 0, this));\\n if ((y == (turn == WHITE ? 1 : 6)) && board[y + 2 * turn][x] == 0) { // initial 2 move\\n results.add(new Move(piece, x, y, x, y + 2*turn, 0, 0, this));\\n }\\n }\\n }\\n // capture\\n for (int dx = -1; dx <= 1; dx += 2){\\n if (x + dx >= 0 && x + dx < 8) {\\n int val = board[y+turn][x+dx];\\n if (val > 0 && (turn == WHITE ? val > WHITE_KING : val < BLACK_PAWN)){\\n if (y + turn == 0 || y + turn == 7){ // promotion\\n results.add(new Move(piece, x, y, x+dx, y + turn, val, queen, this));\\n results.add(new Move(piece, x, y, x+dx, y + turn, val, knight, this));\\n results.add(new Move(piece, x, y, x+dx, y + turn, val, rook, this));\\n results.add(new Move(piece, x, y, x+dx, y + turn, val, bishop, this));\\n } else {\\n results.add(new Move(piece, x, y, x+dx, y + turn, val, 0, this));\\n }\\n }\\n if (val == 0 && y == (turn == WHITE ? 4 : 3) && x+dx == enPassant){ // en passant\\n results.add(new Move(piece, x, y, x+dx, y + turn, 0, 0, this));\\n }\\n }\\n }\\n\\n } else if (piece == knight) { // knights TODO: lookup table\\n for (int dx = -1; dx <= 1; dx += 2){\\n for (int dy = -2; dy <= 2; dy += 4){\\n if (x+dx >= 0 && x + dx < 8 && y + dy >= 0 && y + dy < 8){\\n int val = board[y+dy][x+dx];\\n if (val == 0 || (turn == WHITE ? val > WHITE_KING : val < BLACK_PAWN)){\\n results.add(new Move(piece,x,y,x+dx,y+dy,val,0,this));\\n }\\n }\\n if (x+dy >= 0 && x + dy < 8 && y + dx >= 0 && y + dx < 8){\\n int val = board[y+dx][x+dy];\\n if (val == 0 || (turn == WHITE ? val > WHITE_KING : val < BLACK_PAWN)){\\n results.add(new Move(piece,x,y,x+dy,y+dx,val,0,this));\\n }\\n }\\n }\\n }\\n } else if (piece == bishop) { // bishops\\n for (int dx = -1; dx <= 1; dx += 2){\\n for (int dy = -1; dy <= 1; dy += 2){\\n int i = 1;\\n while (x + dx*i >= 0 && x + dx*i < 8 && y + dy*i >= 0 && y + dy*i < 8){\\n int val = board[y+dy*i][x+dx*i];\\n if (val == 0){\\n results.add(new Move(piece,x,y,x+dx*i,y+dy*i,val,0,this));\\n } else {\\n if (turn == WHITE ? val > WHITE_KING : val < BLACK_PAWN){\\n results.add(new Move(piece,x,y,x+dx*i,y+dy*i,val,0,this));\\n }\\n break;\\n }\\n i++;\\n }\\n }\\n }\\n } else if (piece == rook) { // rooks\\n for (int dx = -1; dx <= 1; dx+= 2){\\n for (int ax = 0; ax < 2; ax++){\\n int i = 1;\\n while (ax==0 ? y+dx*i >= 0 && y+dx*i < 8 : x+dx*i >= 0 && x+dx*i < 8){\\n int val = board[y+dx*i*(1-ax)][x+dx*i*ax];\\n if (val == 0){\\n results.add(new Move(piece,x,y,x+dx*i*ax,y+dx*i*(1-ax),val,0,this));\\n } else {\\n if (turn == WHITE ? val > WHITE_KING : val < BLACK_PAWN){\\n results.add(new Move(piece,x,y,x+dx*i*ax,y+dx*i*(1-ax),val,0,this));\\n }\\n break;\\n }\\n i++;\\n }\\n }\\n }\\n } else if (piece == (turn == WHITE ? WHITE_QUEEN : BLACK_QUEEN)) { // queens\\n // Diagonals - same as bishops\\n for (int dx = -1; dx <= 1; dx += 2){\\n for (int dy = -1; dy <= 1; dy += 2){\\n int i = 1;\\n while (x + dx*i >= 0 && x + dx*i < 8 && y + dy*i >= 0 && y + dy*i < 8){\\n int val = board[y+dy*i][x+dx*i];\\n if (val == 0){\\n results.add(new Move(piece,x,y,x+dx*i,y+dy*i,val,0,this));\\n } else {\\n if (turn == WHITE ? val > WHITE_KING : val < BLACK_PAWN){\\n results.add(new Move(piece,x,y,x+dx*i,y+dy*i,val,0,this));\\n }\\n break;\\n }\\n i++;\\n }\\n }\\n }\\n for (int dx = -1; dx <= 1; dx+= 2){\\n for (int ax = 0; ax < 2; ax++){\\n int i = 1;\\n while (ax==0 ? y+dx*i >= 0 && y+dx*i < 8 : x+dx*i >= 0 && x+dx*i < 8){\\n int val = board[y+dx*i*(1-ax)][x+dx*i*ax];\\n if (val == 0){\\n results.add(new Move(piece,x,y,x+dx*i*ax,y+dx*i*(1-ax),val,0,this));\\n } else {\\n if (turn == WHITE ? val > WHITE_KING : val < BLACK_PAWN){\\n results.add(new Move(piece,x,y,x+dx*i*ax,y+dx*i*(1-ax),val,0,this));\\n }\\n break;\\n }\\n i++;\\n }\\n }\\n }\\n } else if (piece == (turn == WHITE ? WHITE_KING : BLACK_KING)) { // king\\n for (int dx = -1; dx < 2; dx++){\\n for (int dy = -1; dy < 2; dy++){\\n if ((dx != 0 || dy != 0) && x+dx >= 0 && x + dx < 8 && y + dy >= 0 && y + dy < 8){\\n int val = board[y+dy][x+dx];\\n if (val == 0 || (turn == WHITE ? val > WHITE_KING : val < BLACK_PAWN)){\\n results.add(new Move(piece,x,y,x+dx,y+dy,val,0,this));\\n }\\n }\\n }\\n }\\n }\\n }\\n }\\n // castle\\n if (checks.size() == 0){\\n if (turn == WHITE && (castles & 0b11) != 0){//(castles[0] || castles[1])){\\n board[0][4] = 0; // remove king to avoid check test collisions with extra king\\n if ((castles & WHITE_SHORT) != 0 && board[0][5] == 0 && board[0][6] == 0 && inCheck(5,0).size() == 0){\\n //if (castles[0] && board[0][5] == 0 && board[0][6] == 0 && inCheck(5,0).size() == 0){\\n results.add(new Move(WHITE_KING, 4, 0, 6, 0, 0, 0, this));\\n }\\n if ((castles & WHITE_LONG) != 0 && board[0][1] == 0 && board[0][2] == 0 && board[0][3] == 0 &&\\n inCheck(3,0).size() == 0){\\n //if (castles[1] && board[0][1] == 0 && board[0][2] == 0 && board[0][3] == 0 && inCheck(3,0).size() == 0){\\n results.add(new Move(WHITE_KING, 4, 0, 2, 0, 0, 0, this));\\n }\\n board[0][4] = WHITE_KING;\\n }else if (turn == BLACK && (castles & 0b1100) != 0){//(castles[2] || castles[3])) {\\n board[7][4] = 0; // remove king to avoid check test collisions with extra king\\n //if (castles[2] && board[7][5] == 0 && board[7][6] == 0 && inCheck(5, 7).size() == 0) {\\n if ((castles & BLACK_SHORT) != 0 && board[7][5] == 0 && board[7][6] == 0 && inCheck(5, 7).size() == 0) {\\n results.add(new Move(BLACK_KING, 4, 7, 6, 7, 0, 0, this));\\n }\\n //if (castles[3] && board[7][1] == 0 && board[7][2] == 0 && board[7][3] == 0 && inCheck(3, 7).size() == 0) {\\n if ((castles & BLACK_LONG) != 0 && board[7][1] == 0 && board[7][2] == 0 && board[7][3] == 0 &&\\n inCheck(3, 7).size() == 0) {\\n results.add(new Move(BLACK_KING, 4, 7, 2, 7, 0, 0, this));\\n }\\n board[7][4] = BLACK_KING;\\n }\\n }\\n }\\n List<Move> fullLegal = new LinkedList<>();\\n for (Move m : results){\\n makeMove(m);\\n turn = -turn;\\n if (m.piece == WHITE_KING || m.piece == BLACK_KING){\\n if (inCheck(m.toX,m.toY).size() == 0){\\n fullLegal.add(m);\\n }\\n }else if (inCheck(kingX,kingY).size() == 0){\\n fullLegal.add(m);\\n }\\n turn = -turn;\\n undoMove(m);\\n }\\n Collections.sort(fullLegal, (o1, o2) -> o2.score - o1.score); // greatest score treated as least so appears first\\n return fullLegal;\\n }\",\n \"public void addRandoms() {\\n //Add random boulders on tiles that aren't Lava\\n int tileNumber;\\n int selector;\\n Tile t;\\n String tileTexture;\\n Random random = new Random();\\n SquareVector playerPos = getPlayerEntity().getPosition();\\n int tileCount = GameManager.get().getWorld().getTiles().size();\\n AbstractWorld world = GameManager.get().getWorld();\\n int randIndex;\\n\\n for (int i = 0; i < 20; i++) {\\n //Get respective volcano tile (5 <= Lava tiles Index <= 8\\n do {\\n randIndex = random.nextInt(tileCount);\\n t = world.getTile(randIndex);\\n } while (t.getCoordinates().isCloseEnoughToBeTheSame(playerPos));\\n\\n tileTexture = t.getTextureName();\\n tileNumber = Integer.parseInt(tileTexture.split(\\\"_\\\")[1]);\\n\\n selector = random.nextInt(2);\\n if (tileNumber < 5 && tileNumber > 1 && selector == 1 && !t.hasParent()) {\\n entities.add(new Rock(t, true));\\n } else if (t != null && (tileNumber == 3 || tileNumber == 4) &&\\n selector == 0 && !t.hasParent()) {\\n entities.add(new VolcanoBurningTree(t, true));\\n } else {\\n i--;\\n }\\n }\\n }\",\n \"public Queen[] lowestHeuristic(Queen[] state){\\n Queen[] min = new Queen[n];\\n int minHeuristic = general.getHeuristic(state);\\n Queen[] curr = new Queen[n];\\n\\n //Copy the state in min and curr\\n for(int i = 0; i < n; i++){\\n min[i] = new Queen(state[i].getRow(), state[i].getColumn());\\n curr[i] = new Queen(state[i].getRow(), state[i].getColumn());\\n }\\n\\n //Iterate all columns\\n for(int i = 0; i < n; i++){\\n if (i>0)\\n curr[i-1] = new Queen (state[i-1].getRow(), state[i-1].getColumn());\\n curr[i] = new Queen (0, curr[i].getColumn());\\n //Iterate rows\\n for(int j = 0; j < n; j++){\\n\\n //Check if a minimum is found\\n if(general.getHeuristic(curr) < minHeuristic){\\n minHeuristic = general.getHeuristic(curr);\\n\\n for(int k = 0; k < n; k++)\\n min[k] = new Queen(curr[k].getRow(), curr[k].getColumn());\\n }\\n\\n //Move the queen\\n if(curr[i].getRow() != n-1)\\n curr[i].move();\\n }\\n }\\n return min;\\n }\",\n \"public List<Tile> findTargets() {\\n List<Tile> targets = new ArrayList<>(); // our return value\\n int fearDistance = 2; // Ideally we're 2 spots away from their head, increases when we can't do that.\\n int foodDistance = 3; // We look at a distance 3 for food.\\n\\n // If fearDistance gets this big, then its just GG i guess\\n while (targets.size() == 0 && fearDistance < 15) {\\n // Get the tiles around the Enemy's head\\n targets = this.gb.nearByTiles(this.enemy_head_x, this.enemy_head_y, fearDistance);\\n fearDistance += 1;\\n }\\n\\n // Get the food tiles near us\\n for (int i=0; i < foodDistance; i++) {\\n List<Tile> nearBy = this.gb.nearByTiles(this.us_head_x, this.us_head_y, i);\\n for (Tile t : nearBy) {\\n if (t.isFood() && !targets.contains(t)) targets.add(t);\\n }\\n }\\n return targets;\\n }\",\n \"private void prepare()\\n {\\n treespawn treespawn2 = new treespawn();\\n addObject(treespawn2,30,486);\\n\\n hantu hantu = new hantu();\\n addObject(hantu,779,359);\\n \\n hantu hantu2 = new hantu();\\n addObject(hantu2,88,84);\\n \\n bergerak bergerak2 = new bergerak();\\n addObject(bergerak2,745,423);\\n\\n bergerak bergerak3 = new bergerak();\\n addObject(bergerak3,266,566);\\n \\n bergerak bergerak4 = new bergerak();\\n addObject(bergerak4,564,566);\\n\\n hantu hantu3 = new hantu();\\n addObject(hantu3,671,490);\\n \\n hantu hantu4 = new hantu();\\n addObject(hantu4,371,499);\\n\\n bergerak bergerak = new bergerak();\\n addObject(bergerak,150,148);\\n\\n lantai lantai = new lantai();\\n addObject(lantai,561,577); \\n addObject(lantai,419,579); \\n\\n player player = new player();\\n addObject(player,882,498);\\n\\n lantai3 lantai3 = new lantai3();\\n addObject(lantai3,120,148);\\n\\n flyinglantai flyinglantai = new flyinglantai();\\n addObject(flyinglantai,292,148);\\n\\n treespawn treespawn = new treespawn();\\n addObject(treespawn,30,291);\\n\\n lantai4 lantai4 = new lantai4();\\n addObject(lantai4,235,536);\\n \\n lantai4 lantai42 = new lantai4();\\n addObject(lantai42,275,508);\\n \\n lantai4 lantai43 = new lantai4();\\n addObject(lantai43,323,480);\\n \\n lantai4 lantai44 = new lantai4();\\n addObject(lantai44,369,454);\\n\\n lantai2 lantai2 = new lantai2();\\n addObject(lantai2,680,424);\\n\\n \\n lantai3 lantai32 = new lantai3();\\n addObject(lantai32,938,146);\\n \\n lantai4 lantai45 = new lantai4();\\n addObject(lantai45,21,370);\\n\\n lantai4 lantai46 = new lantai4();\\n addObject(lantai46,210,180);\\n \\n lantai4 lantai47 = new lantai4();\\n addObject(lantai47,257,201);\\n \\n lantai4 lantai48 = new lantai4();\\n addObject(lantai48,302,229);\\n \\n lantai4 lantai49 = new lantai4();\\n addObject(lantai49,354,255);\\n \\n lantai4 lantai410 = new lantai4();\\n addObject(lantai410,402,281);\\n \\n lantai4 lantai411 = new lantai4();\\n addObject(lantai411,444,302);\\n \\n lantai4 lantai412 = new lantai4();\\n addObject(lantai412,491,334);\\n \\n lantai4 lantai413 = new lantai4();\\n addObject(lantai413,546,364);\\n \\n lantai4 lantai414 = new lantai4();\\n addObject(lantai414,582,397);\\n \\n doorlv3 doorlv3 = new doorlv3();\\n addObject(doorlv3,910,45);\\n\\n \\n }\",\n \"private void analyzeForObstacles() {\\n \\t\\n \\t\\n \\tStack<Rect> bestFound = new Stack<Rect>();//This is a stack as the algorithm moves along x linearly\\n \\tboolean[][] blackWhiteGrid = getBlackWhiteGrid();\\n \\tint[] cache = new int[grid.length];\\n \\t\\n \\twhile (true) {\\n\\t\\t\\tboolean noneFound = true;\\n\\t\\t\\t\\n\\t\\t\\tfor (int i = 0; i<cache.length; i++)\\n\\t\\t\\t\\tcache[i] = 0;\\n\\t\\t\\tfor (int llx = grid.length -1; llx >= 0; llx--) {\\n\\t\\t\\t\\tupdate_cache(blackWhiteGrid,cache, llx);\\n\\t\\t\\t\\tfor (int lly = 0; lly < grid.length; lly++) {\\n\\t\\t\\t\\t\\tRect bestOfRound = new Rect(llx,lly,llx,lly);\\n\\t\\t\\t\\t\\tint y = lly;\\n\\t\\t\\t\\t\\tint x_max = 9999;\\n\\t\\t\\t\\t\\tint x = llx;\\n\\t\\t\\t\\t\\twhile (y+1<grid.length && blackWhiteGrid[llx][y]) {\\n\\t\\t\\t\\t\\t\\ty++;\\n\\t\\t\\t\\t\\t\\tx = Math.min(llx+cache[y]-1, x_max);\\n\\t\\t\\t\\t\\t\\tx_max = x;\\n\\t\\t\\t\\t\\t\\tRect tryRect = new Rect(llx,lly-1,x,y);\\n\\t\\t\\t\\t\\t\\tif (tryRect.area() > bestOfRound.area()) {\\n\\t\\t\\t\\t\\t\\t\\tbestOfRound = tryRect;\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\tif (bestOfRound.area() > 40) {\\n\\t\\t\\t\\t\\t\\tif (noneFound) {\\n\\t\\t\\t\\t\\t\\t\\tbestFound.push(bestOfRound);\\n\\t\\t\\t\\t\\t\\t\\tnoneFound = false;\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t\\telse {\\n\\t\\t\\t\\t\\t\\t\\tRect lastRect = bestFound.peek();\\n\\t\\t\\t\\t\\t\\t\\tif (lastRect.area() < bestOfRound.area()) {\\n\\t\\t\\t\\t\\t\\t\\t\\tbestFound.pop();\\n\\t\\t\\t\\t\\t\\t\\t\\tbestFound.push(bestOfRound);\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t\\tif (noneFound)\\n\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\n\\t\\t\\tclearFoundRectangle(blackWhiteGrid, bestFound.peek());\\n \\t}\\n \\t\\n \\t//add found rectanlges\\n \\tobstacles.clear();\\n \\tobstacles.addAll(bestFound);\\n \\tSystem.out.println(\\\"Sweep done:\\\");\\n \\tfor (Rect r : bestFound){\\n \\t\\tSystem.out.println(\\\"Rect: llx=\\\" + (r.llx-400) + \\\"\\\\tlly=\\\" + (r.lly-400) + \\\"\\\\turx=\\\" + (r.urx-400) + \\\"\\\\tury=\\\" + (r.ury-400));\\n \\t\\tList<Point2D.Double> corners = new ArrayList<Point2D.Double>();\\n \\t\\tcorners.add(new Point2D.Double((r.llx-400),(r.lly-400)));\\n \\t\\tcorners.add(new Point2D.Double((r.llx-400),(r.ury-400)));\\n \\t\\tcorners.add(new Point2D.Double((r.urx-400),(r.lly-400)));\\n \\t\\tcorners.add(new Point2D.Double((r.urx-400),(r.ury-400)));\\n \\t\\tobstaclesF.add(new Obstacle(corners));\\n \\t}\\n \\t\\n \\ttoExplore.clear();\\n \\tint i = 0;\\n \\tRandom rand = new Random();\\n \\twhile (toExplore.size() < 10 && i < 1000) {\\n \\t\\tint x = rand.nextInt(grid.length);\\n \\t\\tint y = rand.nextInt(grid.length);\\n \\t\\tif (grid[x][y] == .5) {\\n \\t\\t\\ttoExplore.add(new Flag(\\\"blue\\\",x,y));\\n \\t\\t}\\n \\t}\\n }\",\n \"@Override\\n public void runMovingTest() {\\n long now;\\n int count, search;\\n elapsedTime.clear();\\n expandedCells.clear();\\n GraphPath<Integer,DefaultWeightedEdge> agentPath=null;\\n GraphPath<Integer,DefaultWeightedEdge> targetPath=null;\\n //Integer agentNode, targetNode;\\n List<Integer> pathToFollow = null;\\n for(Point[] p : points){\\n pathfinder = new LazyMovingTargetAdaptiveAStarShortestPath<Integer, DefaultWeightedEdge>(map);\\n count=0;\\n search=0;\\n agentNode = p[0].toNode();\\n targetNode = p[1].toNode();\\n LinkedList<Integer> movingExpCell = new LinkedList<>();\\n LinkedList<Long> movingElapsTime = new LinkedList<>();\\n targetThread r = new targetThread();\\n evadeThread = new Thread(r);\\n evadeThread.start();\\n while(!agentNode.equals(targetNode)){\\n if(pathToFollow==null || !agentPath.getEndVertex().equals(targetNode)) {\\n agentPath = pathfinder.getShortestPath(agentNode, targetNode, new OctileDistance());\\n if(pathfinder.getElapsedTime() > Long.valueOf(1900))\\n continue;\\n movingElapsTime.add(pathfinder.getElapsedTime());\\n movingExpCell.add(pathfinder.getNumberOfExpandedNodes());\\n search++;\\n }\\n Integer targetNext = null;\\n Integer agentNext = null;\\n if(count%2==0) {\\n /*targetPath = new Trailmax<Integer,DefaultWeightedEdge>(map).getShortestPath(agentNode,targetNode,null);\\n pathToFollow = Graphs.getPathVertexList(targetPath);\\n if (!pathToFollow.isEmpty()) targetNext = pathToFollow.remove(0);\\n if (targetNext.equals(targetNode) && !pathToFollow.isEmpty()) targetNext = pathToFollow.remove(0);\\n targetNode = targetNext;*/\\n synchronized(moveTarget) {\\n moveTarget = new Boolean(true);\\n }\\n\\n try {\\n Thread.sleep(12);\\n } catch (InterruptedException e) {\\n e.printStackTrace();\\n }\\n }\\n pathToFollow=Graphs.getPathVertexList(agentPath);\\n if(!pathToFollow.isEmpty()){\\n int i = pathToFollow.lastIndexOf(agentNode);\\n agentNext=pathToFollow.remove(i+1);\\n }\\n agentNode = agentNext;\\n count++;\\n //System.out.println(agentNode+\\\",\\\"+targetNode);\\n\\n }\\n\\n r.terminate();\\n try {\\n evadeThread.join();\\n } catch (InterruptedException e) {\\n e.printStackTrace();\\n }\\n pathToFollow=null;\\n movingElapsedTime.put(p, movingElapsTime);\\n movingExpandedCells.put(p, movingExpCell);\\n movesMap.put(p, count);\\n searchesMap.put(p, search);\\n if(verbose) {\\n Long totElaps = Long.valueOf(0);\\n Integer totExp = 0;\\n for (Long l : movingElapsTime) totElaps += l;\\n for (Integer i : movingExpCell) totExp += i;\\n System.out.println(\\\"total elapsed: \\\" + totElaps + \\\" total expanded \\\" + totExp);\\n }\\n }\\n }\",\n \"private Location generateRandomStartLocation() {\\n\\t\\tif (!atLeastOneNonWallLocation()) {\\n\\t\\t\\tthrow new IllegalStateException(\\n\\t\\t\\t\\t\\t\\\"There is no free tile available for the player to be placed\\\");\\n\\t\\t}\\n\\n\\t\\twhile (true) {\\n\\t\\t\\t// Generate a random location\\n\\t\\t\\tfinal Random random = new Random();\\n\\t\\t\\tfinal int randomRow = random.nextInt(this.map.getMapHeight());\\n\\t\\t\\tfinal int randomCol = random.nextInt(this.map.getMapWidth());\\n\\n\\t\\t\\tfinal Location location = new Location(randomCol, randomRow);\\n\\n\\t\\t\\tif (this.map.getMapCell(location).isWalkable()\\n\\t\\t\\t\\t\\t&& !otherPlayerOnTile(location, -1)) {\\n\\t\\t\\t\\t// If it's not a wall then we can put them there\\n\\t\\t\\t\\treturn location;\\n\\t\\t\\t}\\n\\t\\t}\\n\\t}\",\n \"public boolean compute() {\\n\\t\\tif(this.startNode.equals(goalNode)) {\\r\\n\\t\\t\\tSystem.out.println(\\\"Goal Node Found :)\\\");\\r\\n\\t\\t\\tSystem.out.println(startNode);\\r\\n\\t\\t}\\r\\n\\t\\r\\n\\t\\tQueue<Node> queue = new LinkedList<>();\\r\\n\\t\\tArrayList<Node> explored = new ArrayList<>();\\r\\n\\t\\tqueue.add(this.startNode);\\r\\n\\t\\texplored.add(startNode);\\r\\n\\t\\t\\r\\n\\t\\t//while queue is not empty\\r\\n\\t\\twhile(!queue.isEmpty()) {\\r\\n\\t\\t\\t//remove and return the first node in the queue\\r\\n\\t\\t\\tNode current = queue.remove();\\r\\n\\t\\t\\tif(current.equals(this.goalNode)) {\\r\\n\\t\\t\\t\\tSystem.out.println(\\\"Explored: \\\" + explored + \\\"\\\\nQueue: \\\" + queue);\\r\\n\\t\\t\\t\\treturn true;\\r\\n\\t\\t\\t}\\r\\n\\t\\t\\telse {\\r\\n\\t\\t\\t\\t//dead end\\r\\n\\t\\t\\t\\tif(current.getChildren().isEmpty()){\\r\\n\\t\\t\\t\\t\\treturn false;\\r\\n\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\t//add to queue the children of the current node\\r\\n\\t\\t\\t\\telse {\\r\\n\\t\\t\\t\\t\\tqueue.addAll(current.getChildren());\\r\\n\\t\\t\\t\\t}\\r\\n\\t\\t\\t}\\r\\n\\t\\t\\texplored.add(current);\\r\\n\\t\\t}\\r\\n\\t\\treturn false;\\r\\n\\t}\",\n \"public Iterable<Board> solution() {\\n\\t\\tif (goal == null)\\n\\t\\t\\treturn null;\\n\\t\\telse {\\n\\t\\t\\tfinal Stack<Board> trace = new Stack<Board>();\\n\\t\\t\\tSearchNode iter = goal;\\n\\t\\t\\twhile (iter != null) {\\n\\t\\t\\t\\ttrace.push(iter.getBoard());\\n\\t\\t\\t\\titer = iter.getParent();\\n\\t\\t\\t}\\n\\t\\t\\treturn trace;\\n\\t\\t}\\n\\t}\",\n \"public void specialMove() {\\n\\t\\tChessSquare initial = getSquare();\\n\\t\\tChessSquare next;\\n\\t\\t\\n\\t\\tif(initial.getNorth() != null){\\n\\t\\t\\tnext = initial.getNorth();\\n\\t\\t\\t\\n\\t\\t\\tif((next.getOccupant() == null) || (!next.getOccupant().getColor().equals(this.getColor())))\\n\\t\\t\\t\\tnext.removeOccupant();\\n\\t\\t\\tif(next.getEast() != null)\\n\\t\\t\\t\\tif((next.getEast().getOccupant() == null) || (!next.getEast().getOccupant().getColor().equals(this.getColor())))\\n\\t\\t\\t\\t\\tnext.removeOccupant();\\n\\t\\t\\tif(next.getWest() != null && next.getWest().getOccupant() == null)\\n\\t\\t\\t\\tif((next.getWest().getOccupant() == null) || (!next.getWest().getOccupant().getColor().equals(this.getColor())))\\n\\t\\t\\t\\t\\tnext.removeOccupant();\\n\\t\\t}\\n\\t\\t\\n\\t\\tif(initial.getSouth() != null){\\n\\t\\t\\tnext = initial.getSouth();\\n\\t\\t\\t\\n\\t\\t\\tif((next.getOccupant() == null) || (!next.getOccupant().getColor().equals(this.getColor())))\\n\\t\\t\\t\\tnext.removeOccupant();\\n\\t\\t\\tif(next.getEast() != null)\\n\\t\\t\\t\\tif((next.getEast().getOccupant() == null) || (!next.getEast().getOccupant().getColor().equals(this.getColor())))\\n\\t\\t\\t\\t\\tnext.removeOccupant();\\n\\t\\t\\tif(next.getWest() != null)\\n\\t\\t\\t\\tif((next.getWest().getOccupant() == null) || (!next.getWest().getOccupant().getColor().equals(this.getColor())))\\n\\t\\t\\t\\t\\tnext.removeOccupant();\\n\\t\\t\\t\\n\\t\\t}\\n\\t\\t\\n\\t\\tnext = initial.getEast();\\n\\t\\tif(next != null)\\n\\t\\t\\tif((next.getOccupant() == null) || (!next.getOccupant().getColor().equals(this.getColor())))\\n\\t\\t\\t\\tnext.removeOccupant();\\n\\t\\tnext = initial.getWest();\\n\\t\\tif(next != null)\\n\\t\\t\\tif((next.getOccupant() == null) || (!next.getOccupant().getColor().equals(this.getColor())))\\n\\t\\t\\t\\tnext.removeOccupant();\\n\\t\\tsetCountdown(9);\\n\\t}\",\n \"private void findPath(int current){\\r\\n // remove current from OPEN\\r\\n int index = insideArray(_openSet,current);\\r\\n if(index == -1){\\r\\n System.out.println(\\\"findPath method returns -1.\\\");\\r\\n }\\r\\n _openSet.remove(index);\\r\\n\\r\\n // add current to CLOSED\\r\\n _closedSet.add(current);\\r\\n\\r\\n // if current is the target node\\r\\n if(current == _endIndex){\\r\\n return;\\r\\n }\\r\\n\\r\\n int neighborNum = _map.get_grid(current).get_neighborNum();\\r\\n int[] neighbors = _map.get_grid(current).get_neighbors();\\r\\n\\r\\n //for each neighbor of the current node\\r\\n for(int i=0;i<neighborNum;i++){\\r\\n Grid neighborGrid = _map.get_grid(neighbors[i]);\\r\\n // if neighbor is not traversable or neighbor is in CLOSED\\r\\n // SKIP THIS NEIGHBOR\\r\\n if(!neighborGrid.get_type().equals(\\\"|\\\") && insideArray(_closedSet,neighbors[i]) == -1){\\r\\n int currentNeighborF = neighborGrid.get_Fnum();\\r\\n int neighborF = findF(neighbors[i]);\\r\\n if(neighborF < currentNeighborF || insideArray(_closedSet,neighbors[i]) == -1){\\r\\n neighborGrid.set_Fnum(neighborF);\\r\\n neighborGrid.set_parent(current);\\r\\n if(insideArray(_closedSet,neighbors[i]) == -1){\\r\\n _openSet.add(neighbors[i]);\\r\\n }\\r\\n }\\r\\n }\\r\\n }\\r\\n int currentIndex = smallestF();\\r\\n // RECURSIVE CALL\\r\\n findPath(_map.get_grid(_openSet.get(currentIndex)).get_index());\\r\\n }\",\n \"private static BoardNode startGreedyDepthFirst(int steps, BoardNode node){\\n count = 1;\\n return greedyDepthFirst(steps, node);\\n }\",\n \"public LinkedList<State> getNextAvailableStates() {\\n LinkedList<Integer> currentSide = new LinkedList<>();\\n LinkedList<Integer> otherSide = new LinkedList<>();\\n LinkedList<State> newStates = new LinkedList<>();\\n if(isLeft) {\\n if(leftSide != null) currentSide = new LinkedList<>(leftSide);\\n if(rightSide != null) otherSide = new LinkedList<>(rightSide);\\n } else {\\n if (rightSide != null) currentSide = new LinkedList<>(rightSide);\\n if (leftSide != null) otherSide = new LinkedList<>(leftSide);\\n }\\n\\n // add one people to the other side of the bridge\\n for (int index=0; index< currentSide.size(); index++) {\\n LinkedList<Integer> newCurrentSide = new LinkedList<>(currentSide);\\n LinkedList<Integer> newOtherSide = new LinkedList<>(otherSide);\\n int firstPeopleMoved = newCurrentSide.remove(index);\\n newOtherSide.add(firstPeopleMoved);\\n State state = (isLeft) ? new State(newCurrentSide, newOtherSide, !isLeft,timeTaken+firstPeopleMoved, depth+1, highestSpeed) :\\n new State(newOtherSide, newCurrentSide, !isLeft, timeTaken+firstPeopleMoved, depth+1, highestSpeed);\\n state.setReward(state.calculateReward(firstPeopleMoved));\\n // add this as parent to the child\\n state.parents = new LinkedList<>(this.parents);\\n state.addParent(this);\\n // set the action that get to this state\\n String currentAction = \\\"move \\\" + firstPeopleMoved;\\n currentAction += (isLeft) ? \\\" across\\\" : \\\" back\\\";\\n state.copyActions(this); // copy all the previous actions from the parent\\n state.addActions(currentAction); // add new action to state generated by parent\\n // add to the new states of list\\n newStates.add(state);\\n // add two people to the other side of the bridge\\n for (int second=0; second < newCurrentSide.size(); second++) {\\n LinkedList<Integer> newSecondCurrentSide = new LinkedList<>(newCurrentSide);\\n LinkedList<Integer> newSecondOtherSide = new LinkedList<>(newOtherSide);\\n int secondPeopleMoved = newSecondCurrentSide.remove(second);\\n newSecondOtherSide.add(secondPeopleMoved);\\n int slowerSpeed = (firstPeopleMoved > secondPeopleMoved) ? firstPeopleMoved : secondPeopleMoved;\\n state = (isLeft) ? new State(newSecondCurrentSide, newSecondOtherSide, !isLeft, timeTaken+slowerSpeed, depth+1, highestSpeed) :\\n new State(newSecondOtherSide, newSecondCurrentSide, !isLeft, timeTaken+slowerSpeed, depth+1, highestSpeed);\\n state.setReward(state.calculateReward(firstPeopleMoved, secondPeopleMoved));\\n // add this as parent to the child\\n state.parents = new LinkedList<>(this.parents);\\n state.addParent(this);\\n // set the action that get to this state\\n currentAction = \\\"move \\\"+ firstPeopleMoved + \\\" \\\" + secondPeopleMoved;\\n currentAction += (isLeft) ? \\\" across\\\" : \\\" back\\\";\\n state.copyActions(this);\\n state.addActions(currentAction);\\n // add to the new states of list\\n newStates.add(state);\\n }\\n\\n }\\n return newStates;\\n }\",\n \"private void generateRandomPosition() {\\r\\n int indexX, indexY;\\r\\n boolean collidesWithPlayers;\\r\\n playerState.position.x = Integer.MIN_VALUE; // While we trying...\\r\\n playerState.position.y = Integer.MIN_VALUE;\\r\\n final ExtensiveMovingObject testObject = new ExtensiveMovingObject( 0.0f, 0.0f, 0.0f, 0.0f, GeneralConsts.WORM_WIDTH, GeneralConsts.WORM_HEIGHT );\\r\\n int positionGenerationTrialFailureCounter = 0;\\r\\n do {\\r\\n do {\\r\\n indexX = 1 + (int) ( Math.random() * ( map.getWidth () - 1 ) );\\r\\n indexY = 1 + (int) ( Math.random() * ( map.getHeight() - 1 ) );\\r\\n if ( positionGenerationTrialFailureCounter++ == MAX_POSITION_GENERATION_TRIAL_FAILURE_COUNT )\\r\\n if ( map.getWall( indexX, indexY ) == Map.WALL_STONE )\\r\\n map.setWall( indexX, indexY, Map.WALL_BRICK ); // Not to empty: it can be under water!!\\r\\n } while( map.getWall( indexX, indexY ) == Map.WALL_STONE ); // Stone can't be cleared: it can be part of swimming pool boundaries. (But if there isn't other places where to start, we clear it!)\\r\\n testObject.position.x = ( indexX << GeneralConsts.WALL_WIDTH_SHIFT ) + GeneralConsts.WALL_WIDTH / 2;\\r\\n testObject.position.y = ( indexY << GeneralConsts.WALL_HEIGHT_SHIFT ) + GeneralConsts.WALL_HEIGHT / 2;\\r\\n collidesWithPlayers = false;\\r\\n for ( int playerIndex = 0; playerIndex < players.length && !collidesWithPlayers; playerIndex++ )\\r\\n if ( playerIndex != ownIndex && players[ playerIndex ] != null && testObject.hitsExtensiveObject( players[ playerIndex ].playerState ) )\\r\\n collidesWithPlayers = true;\\r\\n try {\\r\\n Thread.sleep( 0, 100 );\\r\\n }\\r\\n catch( InterruptedException ie ) {\\r\\n }\\r\\n } while ( collidesWithPlayers );\\r\\n playerState.position.x = testObject.position.x;\\r\\n playerState.position.y = testObject.position.y;\\r\\n map.clearMapForEnteringPlayer( indexX, indexY );\\r\\n }\",\n \"private void createChamber() {\\n\\n // Give all tiles coordinates for map and temp map\\n int CurrentY = 0;\\n for (Tile[] tiles : map) {\\n int CurrentX = 0;\\n for (Tile tile : tiles) {\\n tile.setPosition(new Coordinates(CurrentX, CurrentY));\\n tile.setTerrain(Terrain.WALL);\\n CurrentX++;\\n }\\n CurrentY++;\\n }\\n\\n for (int y = 0; y < CAST_HEIGHT; y++) {\\n for (int x = 0; x < CAST_WIDTH; x++) {\\n tempMap[y][x].setPosition(new Coordinates(x, y));\\n }\\n }\\n\\n // Initialize algorithm at starting position (0, 0)\\n tempMap[0][0].setVisited(true);\\n numberOfCellsVisited = 1; //setting number of cells visited to 1 because I have visited one now!\\n mapStack.push(tempMap[0][0]); //Chamber start position\\n createMaze(tempMap[0][0]); //Chamber start position\\n\\n // Reveal top edge, sides, and bottom edge\\n for (Tile tile : map[0]) {\\n tile.setVisible(true);\\n }\\n for (Tile[] tiles : map) {\\n tiles[0].setVisible(true);\\n tiles[CHAMBER_WIDTH].setTerrain(Terrain.WALL);\\n tiles[CHAMBER_WIDTH].setVisible(true);\\n }\\n for (Tile tile : map[CHAMBER_HEIGHT]) {\\n tile.setVisible(true);\\n }\\n\\n // Clear bugged walls\\n for (int i = 1; i < MAP_HEIGHT - 2; i += 2)\\n map[i][MAP_WIDTH - 2].setTerrain(Terrain.EMPTY);\\n\\n // Randomly make regulated holes in walls to create cycles\\n Random rand = new Random(); // Preset rng for performance purposes\\n for (int i = 1; i < MAP_HEIGHT - 1; i++) {\\n for (int j = 1; j < MAP_WIDTH - 1; j++) {\\n Tile tile = map[i][j];\\n if (tile.getTerrain().equals(Terrain.WALL)) {\\n\\n // Neighbourhood Check\\n int neighbourCount = 0, index = 0;\\n boolean[] neighbourhood = new boolean[]{false, false, false, false}; // validity flags\\n\\n for (Direction direction : Direction.cardinals) {\\n Coordinates targetCoordinates = Utility.locateDirection(tile.getPosition(), direction);\\n Tile neighbour = getTileAtCoordinates(targetCoordinates);\\n if (neighbour.getTerrain().equals(Terrain.WALL)) {\\n neighbourCount++;\\n neighbourhood[index] = true;\\n }\\n index++;\\n }\\n\\n // Corner exclusion test, tests vertical NS and horizontal EW\\n boolean isStraight = false;\\n if (neighbourhood[0] && neighbourhood[1]) isStraight = true;\\n if (neighbourhood[2] && neighbourhood[3]) isStraight = true;\\n\\n if (neighbourCount == 2 && isStraight) {\\n if (rand.nextInt(5) == 4) tile.setTerrain(Terrain.EMPTY);\\n }\\n }\\n }\\n }\\n\\n // Check for enclosed spaces and create openings\\n for (int i = 1; i < MAP_HEIGHT - 2; i++) probe(map[i][MAP_WIDTH - 2], Direction.EAST);\\n }\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.64466894","0.6435464","0.624812","0.6224093","0.62071353","0.6206119","0.6199273","0.6140004","0.611651","0.6085592","0.60560733","0.5996624","0.59746987","0.59703857","0.59506994","0.5943485","0.593737","0.59371996","0.5934632","0.59196156","0.587561","0.5867826","0.5860473","0.5858605","0.5856158","0.5847096","0.5835391","0.582351","0.5818701","0.5800376","0.5780284","0.5761437","0.5746185","0.57461566","0.57359475","0.57148284","0.5712157","0.5711979","0.5675132","0.56603926","0.56527543","0.56487644","0.5634218","0.56273437","0.5614815","0.56122494","0.56003624","0.5598151","0.55905306","0.55623245","0.5556317","0.5554222","0.5545351","0.55234903","0.54878575","0.5487278","0.548664","0.54774183","0.5473282","0.54715306","0.5464327","0.54617774","0.545928","0.5458805","0.5456067","0.54479766","0.5446893","0.5434348","0.5428942","0.5416381","0.5415984","0.5412329","0.5412304","0.5410516","0.540423","0.5399851","0.53954107","0.5394259","0.5389406","0.53875285","0.53821874","0.53755283","0.5367072","0.5361874","0.53572446","0.5352091","0.53478587","0.5338672","0.5331678","0.5330482","0.53266525","0.5325869","0.5323545","0.53221476","0.5321111","0.5318962","0.5318085","0.5316218","0.53143495","0.53141403"],"string":"[\n \"0.64466894\",\n \"0.6435464\",\n \"0.624812\",\n \"0.6224093\",\n \"0.62071353\",\n \"0.6206119\",\n \"0.6199273\",\n \"0.6140004\",\n \"0.611651\",\n \"0.6085592\",\n \"0.60560733\",\n \"0.5996624\",\n \"0.59746987\",\n \"0.59703857\",\n \"0.59506994\",\n \"0.5943485\",\n \"0.593737\",\n \"0.59371996\",\n \"0.5934632\",\n \"0.59196156\",\n \"0.587561\",\n \"0.5867826\",\n \"0.5860473\",\n \"0.5858605\",\n \"0.5856158\",\n \"0.5847096\",\n \"0.5835391\",\n \"0.582351\",\n \"0.5818701\",\n \"0.5800376\",\n \"0.5780284\",\n \"0.5761437\",\n \"0.5746185\",\n \"0.57461566\",\n \"0.57359475\",\n \"0.57148284\",\n \"0.5712157\",\n \"0.5711979\",\n \"0.5675132\",\n \"0.56603926\",\n \"0.56527543\",\n \"0.56487644\",\n \"0.5634218\",\n \"0.56273437\",\n \"0.5614815\",\n \"0.56122494\",\n \"0.56003624\",\n \"0.5598151\",\n \"0.55905306\",\n \"0.55623245\",\n \"0.5556317\",\n \"0.5554222\",\n \"0.5545351\",\n \"0.55234903\",\n \"0.54878575\",\n \"0.5487278\",\n \"0.548664\",\n \"0.54774183\",\n \"0.5473282\",\n \"0.54715306\",\n \"0.5464327\",\n \"0.54617774\",\n \"0.545928\",\n \"0.5458805\",\n \"0.5456067\",\n \"0.54479766\",\n \"0.5446893\",\n \"0.5434348\",\n \"0.5428942\",\n \"0.5416381\",\n \"0.5415984\",\n \"0.5412329\",\n \"0.5412304\",\n \"0.5410516\",\n \"0.540423\",\n \"0.5399851\",\n \"0.53954107\",\n \"0.5394259\",\n \"0.5389406\",\n \"0.53875285\",\n \"0.53821874\",\n \"0.53755283\",\n \"0.5367072\",\n \"0.5361874\",\n \"0.53572446\",\n \"0.5352091\",\n \"0.53478587\",\n \"0.5338672\",\n \"0.5331678\",\n \"0.5330482\",\n \"0.53266525\",\n \"0.5325869\",\n \"0.5323545\",\n \"0.53221476\",\n \"0.5321111\",\n \"0.5318962\",\n \"0.5318085\",\n \"0.5316218\",\n \"0.53143495\",\n \"0.53141403\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6100195"},"document_rank":{"kind":"string","value":"9"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":65,"numItemsPerPage":100,"numTotalItems":136513,"offset":6500,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3Mzk0NTgzMywic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1qYXZhLXYxIiwiZXhwIjoxNzczOTQ5NDMzLCJpc3MiOiJodHRwczovL2h1Z2dpbmdmYWNlLmNvIn0.odw30-By2lNiB295GxnOUX76TenUmFFQ8EC0QqYIwzdQ6RcYhfTUF_Ma5cXyAlBp9kq-DqDnhmjr-3KW3hUdBA","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":136513,"numBytesParquet":1558040430}]},"discussionsStats":{"closed":0,"open":1,"total":1},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 7 33.1k | document stringlengths 7 335k | metadata dict | negatives listlengths 3 101 | negative_scores listlengths 3 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
bracketsOpt [ '=' variableIntitializer ] | private void variableDeclaratorRest(VariableType x, Scope scope, Vector queue)
{
x.type.dim += bracketsOpt();
if (nextSymbol == Keyword.ASSIGNSY)
{
Operation node, root = new Operation();
root.operator = (x.modify & Keyword.FINALSY.value) == 0?Keyword.ASSIGNSY:Keyword.FINALASSIGNSY;
node = root.left = new Operation();
node.operator = Keyword.LEAFSY;
node = node.left = new Operation();
node = node.left = new Operation();
node = node.left = new Operation();
node.name = x.name;
node.type = x.type;
lookAhead();
root.right = variableIntitializer(x.type, x.type.dim, scope, queue);
queue.add(root);
root = new Operation();
root.operator = Keyword.CLEARSY;
queue.add(root);
}
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public void setBracket(String val)\r\n\t{\r\n\t\t_bracket = val;\r\n\t}",
"public Variable(int power, char notation){\n\t\tthis.power = power;\n\t\tthis.notation = notation;\n\t}",
"public String getBracket()\r\n\t{\r\n\t\treturn _bracket;\r\n\t}",
"OPTION createOPTION();",
"private String processShorthand... | [
"0.60432357",
"0.5108466",
"0.5074971",
"0.5022312",
"0.49492884",
"0.49155238",
"0.48643288",
"0.4858962",
"0.48210385",
"0.48027745",
"0.47747746",
"0.47712",
"0.47253755",
"0.46971428",
"0.4620098",
"0.4598972",
"0.45611584",
"0.4553007",
"0.45362785",
"0.45211178",
"0.449... | 0.4189154 | 77 |
"class" ident [ "extend" type ] [ "implement" typeList ] classBody | private void classDeclaration(Modifier modifier, Scope scope, String basename)
{
Vector queue = new Vector();
HashSet dummy = unresolved;
ClassType x = new ClassType();
unresolved = x.unresolved;
if (comment != null && comment.length() > 0)
{
x.comment = comment + '\n';
resetComment();
}
matchKeyword(Keyword.CLASSSY);
if (!scopeStack.contains(scope))
scopeStack.add(scope);
x.name = nextToken;
//if (basename.compareTo(nextToken.string) != 0 && basename.length() > 0)
// modifier.access &= ~Keyword.PUBLICSY.value;
modifier.check(modifier.classes | modifier.access & (basename.compareToIgnoreCase(nextToken.string) != 0 && basename.length() > 0?~Keyword.PUBLICSY.value:-1));
if ((modifier.cur & Keyword.ABSTRACTSY.value) == 0)
modifier.methods &= ~Keyword.ABSTRACTSY.value;
else
modifier.methods |= Keyword.ABSTRACTSY.value;
x.modify |= modifier.cur;
matchKeyword(Keyword.IDENTSY);
declMember(scope, x);
x.scope = new Scope(scope, Scope.classed, x.name.string);
if (nextSymbol == Keyword.EXTENDSSY)
{
lookAhead();
Type t = type();
x.extend = new ClassType(t.ident.string.substring(t.ident.string.lastIndexOf('.') + 1));
}
else if (((x.modify & Keyword.STATICSY.value) != 0 || (Scope)scopeStack.get(0) == scope) && x.name.string.compareTo("Object") != 0)
{
x.extend = new ClassType("Object");
unresolved.add(x.extend.name.string);
}
else
x.extend = new ClassType();
if (nextSymbol == Keyword.IMPLEMENTSSY)
{
lookAhead();
x.implement = typeList();
}
else
x.implement = new ClassType[0];
if ((modifier.cur & Keyword.ABSTRACTSY.value) != 0 && (modifier.cur & modifier.constructors) == 0)
modifier.cur |= Keyword.PUBLICSY.value ;
modifier.cur &= modifier.constructors;
classBody(x, new Modifier(), "", queue);
Iterator iter = x.scope.iterator();
while(iter.hasNext())
{
Basic b = (Basic)iter.next();
if (b instanceof MethodType)
if ((b.modify & Keyword.STATICSY.value) != 0)
{ // remove this from static method
MethodType m = (MethodType)b;
m.scope.remove("§this");
if (m.parameter.length > 0 && m.parameter[0].name.string.compareTo("§this") == 0)
{
Parameter [] p = new Parameter[m.parameter.length - 1];
for(int i = 0; i < p.length; i++)
p[i] = m.parameter[i + 1];
m.parameter = p;
}
}
}
// add queue to constructors
addToConstructor(x, queue);
unresolved = dummy;
writeList(x);
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"@Override\n\tpublic void inAClassBody(AClassBody node) {\n // Determine the start and end line numbers.\n int begin = findBeginLine(node);\n int end = node.getRBrace().getLine();\n String cname = null;\n Node parentNode = node.parent();\n if (parentNode instanceof AClassDe... | [
"0.678461",
"0.6756421",
"0.66587484",
"0.6647105",
"0.65516627",
"0.65516627",
"0.63856184",
"0.6340203",
"0.6275696",
"0.62755233",
"0.6154287",
"0.6125933",
"0.61142445",
"0.606991",
"0.6004471",
"0.60039735",
"0.59692943",
"0.5952569",
"0.5952352",
"0.5945607",
"0.5922005... | 0.6610336 | 4 |
';' | [ STATICSY ] ( block | [ modifiers ] memberDecl ) | private void classBodyDeclaration(ClassType object, Modifier modifier, Vector queue)
{
Modifier x = new Modifier(modifier);
x.cur = 0;
if (nextSymbol == Keyword.SEMICOLONSY)
{
lookAhead();
return;
}
if (nextSymbol == Keyword.STATICSY)
{
x.add(modifier());
queue = object.statics;
}
if (nextSymbol == Keyword.LBRACESY)
{
Vector label = new Vector();
//label.add("" + Operation.newLabel());
block(null, null, object.scope, label, Scope.MAIN, null, queue);
}
else
{
for(int y = modifier1(); y != 0; y = modifier())
x.add(y);
if ((x.cur & Keyword.NATIVESY.value) != 0)
Errors.warning(nextToken.source, nextToken.line, nextToken.col, "native detected!", false);
if ((x.cur & x.constructors) == 0)
x.cur |= modifier.cur & modifier.constructors;
if ((x.cur & Keyword.STATICSY.value) != 0)
queue = object.statics;
memberDecl(x, object, queue);
}
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"private void memberDecl(Modifier modify, ClassType object, Vector queue)\r\n {\r\n Type dummy = returns;\r\n\r\n if (identAndLPar())\r\n {\r\n if ((modify.cur & modify.constructors) == 0)\r\n modify.cur |= Keyword.PUBLICSY.value ;\r\n\r\n modify.check(modify.constructors | modify.method... | [
"0.58545095",
"0.5813793",
"0.55439675",
"0.54482913",
"0.5428254",
"0.5399601",
"0.5341742",
"0.5340609",
"0.5314068",
"0.529766",
"0.52619797",
"0.5233506",
"0.52189875",
"0.52033615",
"0.5181773",
"0.51719254",
"0.5166159",
"0.51636165",
"0.51569986",
"0.51545876",
"0.5123... | 0.5989149 | 0 |
constructorDeclaratorRest | "void" voidMethodDeclaratorRest | classDeclaration | interfaceDeclaration | methodOrFieldDeclaration | private void memberDecl(Modifier modify, ClassType object, Vector queue)
{
Type dummy = returns;
if (identAndLPar())
{
if ((modify.cur & modify.constructors) == 0)
modify.cur |= Keyword.PUBLICSY.value ;
modify.check(modify.constructors | modify.methods);
MethodType x = member = new MethodType(modify.cur | Keyword.CONSTRUCTORSY.value);
x.comment = comment + '\n';
resetComment();
x.type = new Type();
x.type.type = Keyword.NONESY;
x.type.ident = object.name;
x.type.version = object.version;
returns = x.type;
x.name = nextToken;
matchKeyword(Keyword.IDENTSY);
if (x.name.string.compareTo(object.name.string) != 0)
error("missing type of method");
constructorDeclaratorRest(x, object);
member = null;
}
else if (nextSymbol == Keyword.VOIDSY)
{
modify.check(modify.methods | modify.access);
MethodType x = member = new MethodType(modify.cur);
x.comment = comment + '\n';
resetComment();
x.type = new Type();
x.type.type = Keyword.VOIDSY;
returns = x.type;
lookAhead();
if (nextSymbol == Keyword.INVERTSY)
{ // allow prefix ~ for destructor method
lookAhead();
nextToken.string = '~' + nextToken.string;
}
x.name = nextToken;
matchKeyword(Keyword.IDENTSY);
voidMethodDeclaratorRest(modify, x, object);
member = null;
}
else if (nextSymbol == Keyword.CLASSSY)
{
modify.check(modify.classes | modify.access);
classDeclaration(modify, object.scope, "");
}
else if (nextSymbol == Keyword.INTERFACESY)
{
modify.check(modify.interfaces | modify.access);
interfaceDeclaration(modify, object.scope, "");
}
else
methodOrFieldDeclaration(modify, object, queue);
returns = dummy;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"private void constructorDeclaratorRest(MethodType x, ClassType object)\r\n {\r\n Scope scope = object.scope;\r\n\r\n x.parameter = formalParameters();\r\n if (nextSymbol == Keyword.THROWSSY)\r\n {\r\n lookAhead();\r\n x.throwing = qualidentList();\r\n }\r\n else\r\n x.throwing =... | [
"0.65380704",
"0.5930811",
"0.58458734",
"0.5827123",
"0.5815849",
"0.57605064",
"0.5726339",
"0.5661342",
"0.5634226",
"0.56117094",
"0.55589527",
"0.5535946",
"0.5476149",
"0.5463186",
"0.5443858",
"0.54358107",
"0.54241204",
"0.5392496",
"0.5357239",
"0.535134",
"0.532802"... | 0.5753441 | 6 |
formalParameters bracketsOpt [ "throws" qualidentList ] ( ';' | block ) | private void methodDeclaratorRest(Modifier modify, Type t, Token name, ClassType object)
{
modify.check(modify.methods | modify.access);
MethodType x = member = new MethodType(modify.cur);
x.comment = comment + '\n';
resetComment();
x.type = t;
returns = x.type;
x.name = name;
x.parameter = formalParameters();
x.type.dim += bracketsOpt();
if (nextSymbol == Keyword.THROWSSY)
{
lookAhead();
x.throwing = qualidentList();
}
else
x.throwing = new String[0];
if (nextSymbol == Keyword.SEMICOLONSY)
{
if ((modify.cur & Keyword.NATIVESY.value) == 0)
{
if ( (object.modify & Keyword.ABSTRACTSY.value) == 0)
error("missing modifier abstract");
if ( (modify.cur & modify.access) == 0)
modify.add(Keyword.PUBLICSY.value);
}
x.scope = new Scope(object.scope, Scope.automatic, "");
insertThis(object, x);
lookAhead();
}
else
{
if ((object.modify & Keyword.ABSTRACTSY.value) == 0)
{
if ((x.modify & new Modifier().constructors) == 0)
x.modify |= Keyword.PUBLICSY.value ;
}
Vector label = new Vector();
label.add(Operation.newLabel() + "");
x.scope = block(x, null, object.scope, label, Scope.MAIN, null, x.operation);
}
object.scope.declInsertOverload(x);
member = null;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public final void constructorDeclaratorRest() throws RecognitionException {\n int constructorDeclaratorRest_StartIndex = input.index();\n try { dbg.enterRule(getGrammarFileName(), \"constructorDeclaratorRest\");\n if ( getRuleLevel()==0 ) {dbg.commence();}\n incRuleLevel();\n dbg... | [
"0.5582835",
"0.5518597",
"0.53196144",
"0.5308051",
"0.52623224",
"0.52158636",
"0.52029866",
"0.5109213",
"0.5022285",
"0.50017995",
"0.4991166",
"0.4977902",
"0.4819611",
"0.4809581",
"0.4746177",
"0.47194052",
"0.46785572",
"0.4657945",
"0.46429813",
"0.46164808",
"0.4531... | 0.414764 | 82 |
formalParameters [ "throws" qualidentList ] ( ';' | block ) | private void voidMethodDeclaratorRest(Modifier modify, MethodType x, ClassType object)
{
Scope scope = object.scope;
x.parameter = formalParameters();
if (nextSymbol == Keyword.THROWSSY)
{
lookAhead();
x.throwing = qualidentList();
}
else
x.throwing = new String[0];
if (nextSymbol == Keyword.SEMICOLONSY)
{
if ((modify.cur & Keyword.NATIVESY.value) == 0)
{
if ( (x.modify & Keyword.ABSTRACTSY.value) == 0)
error("missing modifier abstract");
if ( (modify.cur & modify.access) == 0)
modify.add(Keyword.PUBLICSY.value);
}
x.scope = new Scope(scope, Scope.automatic, "");
insertThis(object, x);
lookAhead();
}
else
{
if ((x.modify & Keyword.ABSTRACTSY.value) == 0)
{
if ((x.modify & new Modifier().constructors) == 0)
x.modify |= Keyword.PUBLICSY.value ;
}
Vector label = new Vector();
label.add(Operation.newLabel() + "");
x.scope = block(x, null, scope, label, Scope.MAIN, null, x.operation);
}
scope.declInsertOverload(x);
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public final void constructorDeclaratorRest() throws RecognitionException {\n int constructorDeclaratorRest_StartIndex = input.index();\n try { dbg.enterRule(getGrammarFileName(), \"constructorDeclaratorRest\");\n if ( getRuleLevel()==0 ) {dbg.commence();}\n incRuleLevel();\n dbg... | [
"0.6022047",
"0.5889035",
"0.58654875",
"0.5741068",
"0.56518847",
"0.552263",
"0.5518971",
"0.5516577",
"0.55143106",
"0.54530853",
"0.53635925",
"0.529346",
"0.5281323",
"0.5250102",
"0.52481943",
"0.52456445",
"0.5231472",
"0.52019167",
"0.5168371",
"0.5161505",
"0.5160669... | 0.0 | -1 |
formalParameters [ "throws" qualidentList ] block | private void constructorDeclaratorRest(MethodType x, ClassType object)
{
Scope scope = object.scope;
x.parameter = formalParameters();
if (nextSymbol == Keyword.THROWSSY)
{
lookAhead();
x.throwing = qualidentList();
}
else
x.throwing = new String[0];
Vector label = new Vector();
label.add(Operation.newLabel() + "");
x.scope = block(x, null, scope, label, Scope.MAIN, null, x.operation);
scope.declInsertOverload(x);
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public void mo1944a() throws cf {\r\n }",
"public void mo1964g() throws cf {\r\n }",
"public void mo1963f() throws cf {\r\n }",
"public interface RoutineException {}",
"public final void constructorDeclaratorRest() throws RecognitionException {\n int constructorDeclaratorRest_StartIndex = i... | [
"0.59776527",
"0.5817696",
"0.56087744",
"0.55717355",
"0.550463",
"0.5455715",
"0.5450077",
"0.54421854",
"0.5347757",
"0.5346857",
"0.53236604",
"0.5304839",
"0.528192",
"0.5281427",
"0.5273408",
"0.52686864",
"0.524245",
"0.5241067",
"0.5233728",
"0.5223661",
"0.52206886",... | 0.5021055 | 34 |
"interface" ident [ "extends" typeList ] interfaceBody | private void interfaceDeclaration(Modifier modify, Scope scope, String basename)
{
HashSet dummy = unresolved;
ClassType x = new ClassType();
x.modify = (x.modify & ~Keyword.CLASSSY.value) | Keyword.INTERFACESY.value;
unresolved = x.unresolved;
if (comment != null && comment.length() > 0)
{
x.comment = comment + '\n';
resetComment();
}
if (!scopeStack.contains(scope))
scopeStack.add(scope);
matchKeyword(Keyword.INTERFACESY);
x.name = nextToken;
//if (basename.compareTo(nextToken.string) != 0 && basename.length() > 0)
// modify.access &= ~Keyword.PUBLICSY.value;
modify.check(modify.interfaces | modify.access & (basename.compareToIgnoreCase(nextToken.string) != 0 && basename.length() > 0?~Keyword.PUBLICSY.value:-1));
matchKeyword(Keyword.IDENTSY);
declMember(scope, x);
if (nextSymbol == Keyword.EXTENDSSY)
{
lookAhead();
x.implement = typeList();
}
else
x.implement = new ClassType[0];
x.extend = new ClassType("Object");//!!!!!!!!!!!!!!!!!!!
x.scope = new Scope(scope, Scope.heap, x.name.string);
if ((modify.cur & modify.constructors) == 0)
modify.cur |= Keyword.PUBLICSY.value & modify.access;
interfaceBody(modify, x);
unresolved = dummy;
writeList(x);
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public interface IInventoryObject extends IID\n{\n}",
"public interface SimpleFlow extends Serializable {\n\n public Pipe getPipe();\n\n public @interface IrSimpleFlow {\n\n String name();\n\n }\n\n}",
"public interface IHead extends IDetail {\n}",
"public interface a extends IInterface {\n}"... | [
"0.6823568",
"0.6755996",
"0.6638447",
"0.6621569",
"0.6531366",
"0.6342286",
"0.632408",
"0.62977946",
"0.6254782",
"0.62399477",
"0.62284577",
"0.6197219",
"0.61939406",
"0.61918813",
"0.6146035",
"0.6145063",
"0.61429983",
"0.6115285",
"0.61090475",
"0.61057144",
"0.610214... | 0.6559343 | 4 |
';' | [ modifiers ] interfaceMemberDecl | private void interfaceBodyDeclaration(Modifier modify, ClassType object)
{
if (nextSymbol == Keyword.SEMICOLONSY)
{
lookAhead();
return;
}
Modifier m = new Modifier(modify);
m.cur = 0;
for(int x; (x = modifier()) != 0; m.add(x));
if ((m.cur & m.constructors) == 0)
m.cur |= modify.cur & modify.constructors;
if ((m.cur & Keyword.NATIVESY.value) != 0)
Errors.warning(nextToken.source, nextToken.line, nextToken.col, "native detected!", false);
interfaceMemberDecl(m, object);
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"private void interfaceMemberDecl(Modifier modify, ClassType object)\r\n {\r\n if (comment != null && comment.length() > 0)\r\n {\r\n Operation op = new Operation();\r\n op.code = comment + '\\n';\r\n op.operator = Keyword.COMMENTSY;\r\n object.statics.add(op);\r\n resetComment();\... | [
"0.7100405",
"0.69286126",
"0.6441975",
"0.642301",
"0.62751365",
"0.6169609",
"0.6142762",
"0.6138974",
"0.6067786",
"0.60591555",
"0.6049081",
"0.6034443",
"0.6027791",
"0.601127",
"0.6006412",
"0.60026073",
"0.59838605",
"0.59091794",
"0.5906611",
"0.58963907",
"0.5889478"... | 0.6504393 | 2 |
"void" voidInterfaceMethodDeclaratorRest | classDeclaration | interfaceDeclaration | interfaceMethodOrFieldDeclaration | private void interfaceMemberDecl(Modifier modify, ClassType object)
{
if (comment != null && comment.length() > 0)
{
Operation op = new Operation();
op.code = comment + '\n';
op.operator = Keyword.COMMENTSY;
object.statics.add(op);
resetComment();
}
if (nextSymbol == Keyword.VOIDSY)
{
modify.check(modify.methods | modify.access);
MethodType x = new MethodType(modify.cur);
x.type = new Type();
x.type.type = Keyword.VOIDSY;
x.scope = new Scope(object.scope, Scope.automatic, "");
lookAhead();
if (nextSymbol == Keyword.INVERTSY)
{ // allow prefix ~ for destructor method
lookAhead();
nextToken.string = '~' + nextToken.string;
}
x.name = nextToken;
matchKeyword(Keyword.IDENTSY);
voidInterfaceMethodDeclaratorRest(x);
insertThis(object, x);
object.scope.declInsertOverload(x);
}
else if (nextSymbol == Keyword.CLASSSY)
{
modify.check(modify.classes | modify.access);
Modifier m = new Modifier(modify);
m.cur = modify.cur | Keyword.STATICSY.value;
classDeclaration(m, object.scope, "");
}
else if (nextSymbol == Keyword.INTERFACESY)
{
modify.check(modify.interfaces | modify.access);
interfaceDeclaration(modify, object.scope, "");
}
else
interfaceMethodOrFieldDeclaration(modify, object);
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"private void voidInterfaceMethodDeclaratorRest(MethodType x)\r\n {\r\n x.parameter = formalParameters();\r\n if (nextSymbol == Keyword.THROWSSY)\r\n {\r\n lookAhead();\r\n x.throwing = qualidentList();\r\n }\r\n else\r\n x.throwing = new String[0];\r\n\r\n matchKeyword(Keyword.S... | [
"0.6292477",
"0.6255203",
"0.604128",
"0.60360175",
"0.6018279",
"0.5997857",
"0.59426165",
"0.5882851",
"0.58643514",
"0.5849005",
"0.5842872",
"0.58292204",
"0.5764565",
"0.56892055",
"0.56879693",
"0.56365913",
"0.5629413",
"0.56078064",
"0.5586258",
"0.55662674",
"0.55464... | 0.64322364 | 0 |
formalParameters bracketsOpt [ "throws" qualidentList ] ';' | private void interfaceMethodDeclaratorRest(Modifier modify, Type t, Token ident, ClassType object)
{
modify.check(modify.methods | modify.access);
MethodType x = new MethodType(modify.cur);
x.name = ident;
x.type = t;
x.scope = new Scope(object.scope, Scope.automatic, "");
x.parameter = formalParameters();
x.type.dim += bracketsOpt();
object.scope.declInsertOverload(x);
if (nextSymbol == Keyword.THROWSSY)
{
lookAhead();
x.throwing = qualidentList();
}
else
x.throwing = new String[0];
insertThis(object, x);
matchKeyword(Keyword.SEMICOLONSY);
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public final void constructorDeclaratorRest() throws RecognitionException {\n int constructorDeclaratorRest_StartIndex = input.index();\n try { dbg.enterRule(getGrammarFileName(), \"constructorDeclaratorRest\");\n if ( getRuleLevel()==0 ) {dbg.commence();}\n incRuleLevel();\n dbg... | [
"0.56731623",
"0.5657288",
"0.55284274",
"0.5419108",
"0.539637",
"0.5359709",
"0.5132225",
"0.51083505",
"0.5012298",
"0.49388194",
"0.4934133",
"0.492999",
"0.49245542",
"0.49208656",
"0.48668775",
"0.4834796",
"0.48188698",
"0.48131976",
"0.47991717",
"0.47882873",
"0.4776... | 0.0 | -1 |
[ "throws" qualidentList ] ';' | private void voidInterfaceMethodDeclaratorRest(MethodType x)
{
x.parameter = formalParameters();
if (nextSymbol == Keyword.THROWSSY)
{
lookAhead();
x.throwing = qualidentList();
}
else
x.throwing = new String[0];
matchKeyword(Keyword.SEMICOLONSY);
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public void mo1944a() throws cf {\r\n }",
"Rule Throws() {\n // Push 1 ThrowsNode onto the value stack\n return Sequence(\n \"throws \",\n \"( \",\n actions.pushInterrupt(),\n ZeroOrMore(Field()),\n \") \",\n ... | [
"0.6348713",
"0.6192659",
"0.6090675",
"0.5994965",
"0.5969116",
"0.5965288",
"0.5943733",
"0.59254694",
"0.58441037",
"0.5802001",
"0.57715344",
"0.57104",
"0.5679942",
"0.56751424",
"0.56115705",
"0.5593998",
"0.55728877",
"0.5562642",
"0.5550828",
"0.55396634",
"0.5499715"... | 0.5527715 | 20 |
insert leading parameter this in parameter list | private void insertThis(ClassType object, MethodType x)
{
if ((x.modify & Keyword.STATICSY.value) == 0)
{
Parameter p = new Parameter();
p.name = new Token();
p.name.string = "§this";
p.type = new Type();
p.type.version = object.version;
p.type.ident.string = object.name.string;
p.type.type = Keyword.NONESY;
Parameter [] q = new Parameter[x.parameter.length + 1];
q[0] = p;
for(int i = 1; i < q.length; i++)
q[i] = x.parameter[i - 1];
x.parameter = q;
}
if (x.throwing.length > 0)
{
Parameter p = new Parameter();
p.name = new Token();
p.name.string = "§exception";
p.name.kind = Keyword.IDENTSY;
p.type = new Type();
p.type.type = Keyword.VOIDSY;
Parameter[] q = new Parameter[x.parameter.length + 1];
for (int i = 0; i < x.parameter.length; i++)
q[i] = x.parameter[i];
q[q.length - 1] = p;
x.parameter = q;
}
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public void addParameter(ParmInfoEntry p){\n\t}",
"public void addParam(JParameter x) {\n params = Lists.add(params, x);\n }",
"public void addToParameterNameValuePairs(entity.LoadParameter element);",
"public void addParameter(ParameterExtendedImpl param) {\n \tParameterExtendedImpl paramExt = parame... | [
"0.6714579",
"0.6358333",
"0.61905134",
"0.61623913",
"0.6119906",
"0.60475785",
"0.59595466",
"0.5793748",
"0.5761136",
"0.57383794",
"0.5737107",
"0.57151383",
"0.5711862",
"0.56905144",
"0.56868523",
"0.56864184",
"0.56808937",
"0.56801444",
"0.5656486",
"0.56478184",
"0.5... | 0.6021013 | 6 |
localVariableDeclaration ';' | classOrInterfaceDeclaration | statement | private void blockStatement(Scope scope, Vector queue)
{
Modifier modify = new Modifier();
modify.access = 0;
modify.classes &= Keyword.FINALSY.value | Keyword.STRICTFPSY.value;
modify.fields &= Keyword.FINALSY.value | Keyword.TRANSIENTSY.value | Keyword.VOLATILESY.value;
modify.methods &= Keyword.FINALSY.value | Keyword.SYNCHRONIZEDSY.value | Keyword.NATIVESY.value | Keyword.STRICTFPSY.value;
modify.constants &= Keyword.FINALSY.value;
Token t;
if (comment != null && comment.length() > 0)
{
Operation op = new Operation();
op.code = comment + '\n';
op.operator = Keyword.COMMENTSY;
queue.add(op);
resetComment();
}
if (isLocalVarDecl(false))
{
localVariableDeclaration(modify, scope, queue);
matchKeyword(Keyword.SEMICOLONSY);
}
else
{
peekReset();
t = nextToken;
while(t.kind == Keyword.PUBLICSY || t.kind == Keyword.PROTECTEDSY ||
t.kind == Keyword.PRIVATESY || t.kind == Keyword.ABSTRACTSY ||
t.kind == Keyword.STATICSY || t.kind == Keyword.FINALSY ||
t.kind == Keyword.STRICTFPSY)
t = peek();
if (t.kind == Keyword.CLASSSY || t.kind == Keyword.INTERFACESY)
classOrInterfaceDeclaration(modify, scope, "");
else
statement(modify, scope, Scope.SEQUENCE, null, queue, true);
}
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public final void localVariableDeclarationStatement() throws RecognitionException {\n int localVariableDeclarationStatement_StartIndex = input.index();\n try { dbg.enterRule(getGrammarFileName(), \"localVariableDeclarationStatement\");\n if ( getRuleLevel()==0 ) {dbg.commence();}\n incR... | [
"0.672178",
"0.638141",
"0.63175726",
"0.62892234",
"0.60996777",
"0.60664386",
"0.6008117",
"0.59839016",
"0.59805435",
"0.5964828",
"0.5962328",
"0.5920267",
"0.59073114",
"0.58600324",
"0.58498937",
"0.58460176",
"0.5736271",
"0.56092036",
"0.55943024",
"0.5589317",
"0.556... | 0.48200887 | 84 |
generate administrative code at the end of a block | private Operation blockEnd(Scope scope)
{
Operation root = new Operation();
root.operator = Keyword.BLOCKENDSY;
root.code = (String)scope.label.get(0);
return root;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"@Override\n public void endBlock() {\n }",
"public void endBlockOut () {\n addLine (getBlockEnd());\n // writer.close();\n }",
"public abstract void appendBlock();",
"public String generateBlock(){\n return null;\n }",
"public abstract void generateNextBlock();",
"public St... | [
"0.7231743",
"0.67107016",
"0.6548194",
"0.6522214",
"0.6425628",
"0.6217614",
"0.6074418",
"0.60680604",
"0.59706414",
"0.57040924",
"0.56859106",
"0.564769",
"0.5637197",
"0.56210405",
"0.5598711",
"0.5595582",
"0.55890787",
"0.55840814",
"0.5579296",
"0.5577703",
"0.550026... | 0.6441743 | 4 |
[ FINALSY ] type variableDeclarators | private void localVariableDeclaration(Modifier modify, Scope scope, Vector queue)
{
if (nextSymbol == Keyword.FINALSY)
{
modify.add(nextSymbol.value);
lookAhead();
}
modify.check(modify.fields | modify.access);
Type t = type();
variableDeclarators(modify, t, scope, queue);
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public List<Ref<? extends Type>> typeVariables();",
"public TypeVarElements getTypeVarAccess() {\r\n\t\treturn pTypeVar;\r\n\t}",
"public final Declaration var_type() throws RecognitionException {\n Declaration decl = null;\n\n\n Declaration d = null;\n\n\n try {\n // parser/fla... | [
"0.6854329",
"0.6484034",
"0.6378472",
"0.63247406",
"0.6305271",
"0.62879175",
"0.6255005",
"0.6207978",
"0.60585976",
"0.605845",
"0.6008981",
"0.59969664",
"0.5996945",
"0.59650904",
"0.59559405",
"0.5950304",
"0.5917259",
"0.58856744",
"0.58816177",
"0.5866395",
"0.584836... | 0.58827466 | 18 |
localVariableDeclaration | statementExpression moreStatementExpression | private void forInit(Modifier x, Scope scope, Vector queue)
{
if (isLocalVarDecl(true))
localVariableDeclaration(new Modifier(x), scope, queue);
else
{
Operation ret = moreStatementExpression(statementExpression(scope, queue), scope, queue);
while(ret != null)
{
if (ret.left != null)
queue.add(ret.left);
ret = ret.right;
Operation ptr = new Operation();
ptr.operator = Keyword.CLEARSY;
queue.add(ptr);
}
}
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public void visit(LocalVariableDeclaration n) {\n n.f0.accept(this);\n n.f1.accept(this);\n n.f2.accept(this);\n n.f3.accept(this);\n }",
"public final EObject ruleLocalVariableDeclarationStatement() throws RecognitionException {\n EObject current = null;\n int ruleLocalVariab... | [
"0.6412602",
"0.6179717",
"0.6003966",
"0.59375614",
"0.588699",
"0.58497304",
"0.58376664",
"0.58011067",
"0.5758302",
"0.57551175",
"0.5754447",
"0.55781686",
"0.5514493",
"0.5511671",
"0.5508053",
"0.55015236",
"0.549228",
"0.5474876",
"0.5463197",
"0.5440684",
"0.5425552"... | 0.0 | -1 |
"catch" '(' formalParameter ')' block | private void catchClause(String label, Scope scope, Vector queue)
{
matchKeyword(Keyword.CATCHSY);
matchKeyword(Keyword.LPARSY);
Parameter parameter = formalParameter();
Operation root = new Operation();
root.code = "DUP \" " + parameter.type.ident.string.substring(parameter.type.ident.string.lastIndexOf('.') + 1) + " \" INSTANCEOF\n IF\n";
queue.add(root);
matchKeyword(Keyword.RPARSY);
VariableType a = new VariableType(parameter.type, 0);
a.name = parameter.name;
Vector v = new Vector();
v.add("" + Operation.newLabel());
block(null, a, scope, v, Scope.CATCH, null, queue);
root = new Operation();
root.code = "DUP " + label + " BRANCH\nENDIF\n";
queue.add(root);
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public static CatchBlock catch_(ParameterExpression expression0, Expression expression1) { throw Extensions.todo(); }",
"public static CatchBlock catch_(ParameterExpression expression0, Expression expression1, Expression expression2) { throw Extensions.todo(); }",
"public static CatchBlock catch_(Class clazz, ... | [
"0.78254026",
"0.7520823",
"0.6623258",
"0.6388202",
"0.6337667",
"0.62771845",
"0.61811453",
"0.6134547",
"0.6109649",
"0.6108349",
"0.59787786",
"0.5977756",
"0.5932014",
"0.5931313",
"0.58750486",
"0.5793527",
"0.57790893",
"0.57766896",
"0.5774026",
"0.5756763",
"0.575074... | 0.6227714 | 6 |
( "default" | "case" type ) ':' | private boolean switchLabel(Scope scope, Vector queue)
{
boolean x;
if (x = nextSymbol == Keyword.DEFAULTSY)
{
lookAhead();
}
else
{
matchKeyword(Keyword.CASESY);
Type t = new Type();
t.type = Keyword.INTSY;
follower.add(Keyword.COLONSY);
castExpression(scope, t, true, queue);
follower.remove(follower.size() - 1);
}
matchKeyword(Keyword.COLONSY);
return x;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public final void rule__TypeCaseClause__Group__1__Impl() throws RecognitionException {\r\n\r\n \t\tint stackSize = keepStackSize();\r\n \t\r\n try {\r\n // InternalGo.g:11033:1: ( ( ':' ) )\r\n // InternalGo.g:11034:1: ( ':' )\r\n {\r\n // InternalGo... | [
"0.60315603",
"0.5666418",
"0.55431753",
"0.54653233",
"0.54369104",
"0.5296547",
"0.5296115",
"0.5245778",
"0.52315444",
"0.52239233",
"0.5222001",
"0.5209033",
"0.51777434",
"0.5176324",
"0.5148611",
"0.51386464",
"0.51378435",
"0.5110892",
"0.50620615",
"0.5049201",
"0.503... | 0.4785547 | 45 |
expression1 [ assign expression ] | private Operation expression(Scope scope, Vector queue)
{
Operation root = expression1(scope, queue);
if (assign.contains(nextSymbol))
{
Operation op = new Operation();
op.left = root;
op.operator = assignmentOperator();
op.right = expression(scope, queue);
root = op;
}
return root;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public static BinaryExpression addAssign(Expression expression0, Expression expression1) { throw Extensions.todo(); }",
"public static BinaryExpression addAssign(Expression expression0, Expression expression1, Method method) { throw Extensions.todo(); }",
"private static AssignExpr retrieveAssignExpression(Exp... | [
"0.8057695",
"0.76524186",
"0.7237177",
"0.7232695",
"0.7214998",
"0.7162806",
"0.71588033",
"0.70275915",
"0.70017743",
"0.69440114",
"0.6915929",
"0.69068205",
"0.68872577",
"0.6855224",
"0.68438435",
"0.6806313",
"0.67563474",
"0.67459285",
"0.6649631",
"0.66354823",
"0.66... | 0.61721015 | 53 |
expression2 [ conditionalExpr ] | private Operation expression1(Scope scope, Vector queue)
{
follower.add(Keyword.QUESTIONMARKSY);
Operation op = expression2(scope, queue);
follower.remove(follower.size() - 1);
if (nextSymbol == Keyword.QUESTIONMARKSY)
{
Operation a = new Operation();
a.operator = nextSymbol;
a.right = conditionalExpr(scope, queue);
a.left = op;
op = a;
}
return op;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"ConditionalExpression createConditionalExpression();",
"public static ConditionalExpression condition(Expression expression0, Expression expression1, Expression expression2) { throw Extensions.todo(); }",
"String getIfFunction(String condition, String exprtrue, String exprfalse);",
"public static Conditional... | [
"0.77976996",
"0.73492837",
"0.6872344",
"0.66864616",
"0.6670527",
"0.66375184",
"0.66106826",
"0.65334576",
"0.6344973",
"0.6306212",
"0.6295149",
"0.629398",
"0.6113412",
"0.60834706",
"0.59616464",
"0.5939651",
"0.5937162",
"0.5912977",
"0.5909564",
"0.5891631",
"0.587886... | 0.5394963 | 71 |
'?' expression ':' expression1 | private Operation conditionalExpr(Scope scope, Vector queue)
{
Operation root = new Operation();
matchKeyword(Keyword.QUESTIONMARKSY);
follower.add(Keyword.COLONSY);
root.left = expression(scope, queue);
follower.remove(follower.size() - 1);
matchKeyword(Keyword.COLONSY);
root.right = expression1(scope, queue);
return root;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"private String bindNull() {\n String op;\n \n if (operator == null) {\n op = null;\n } else if (operator.equals(\"=\")) {\n op = \"IS\";\n } else if (operator.equals(\"!=\")) {\n op = \"IS NOT\";\n } else {... | [
"0.62908936",
"0.59015656",
"0.57753634",
"0.56565255",
"0.56375515",
"0.5615637",
"0.5604816",
"0.5518981",
"0.5435942",
"0.5426964",
"0.5414378",
"0.54013515",
"0.5304313",
"0.52987695",
"0.5296063",
"0.5278303",
"0.524338",
"0.5243097",
"0.5241887",
"0.52236706",
"0.521562... | 0.5535028 | 7 |
expression3 [ expression2Rest ] | private Operation expression2(Scope scope, Vector queue)
{
Operation root = expression3(scope, queue);
if (infix.contains(nextSymbol))
root = expression2Rest(root, scope, queue);
return root;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"private static String[] getTwoExpr(String expr, String op) {\n\t\t\n\t\tString[] exprArr = new String[2]; \n\t\t\n\t\tint commaPos = SyntaxChecker.checkMatchedParansAndReturnNextDelim(expr, op.length() + 1, ',');\n\t\tString expr1 = expr.substring(op.length() + 1, commaPos);\n\t\texprArr[0] = expr1;\n\t\t\n\t\tint... | [
"0.574101",
"0.5719535",
"0.5641727",
"0.56271416",
"0.55587834",
"0.5546606",
"0.54591465",
"0.5433889",
"0.5413436",
"0.53979915",
"0.5388574",
"0.53555775",
"0.5354336",
"0.5351162",
"0.53447264",
"0.53229666",
"0.532202",
"0.5295287",
"0.52539134",
"0.52471685",
"0.524715... | 0.6631491 | 0 |
arguments | '.' ident argumentsOpt | private void superSuffix(Operation base, Scope scope, Vector queue)
{
if (nextSymbol == Keyword.LPARSY)
base.left.left = arguments(scope, null, queue);
else
{
matchKeyword(Keyword.DOTSY);
base = base.right = new Operation();
base.left = new Operation();
base.left.name = nextToken;
matchKeyword(Keyword.IDENTSY);
base.left.left = argumentsOpt(scope, null, queue);
}
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"Optional<String[]> arguments();",
"void setArguments(String arguments);",
"String getArguments();",
"public Code visitArgumentsNode(ExpNode.ArgumentsNode node) {\n beginGen(\"Arguments\");\n Code code = new Code();\n for(ExpNode exp : node.getArgs()) {\n code.append(exp.genCod... | [
"0.6526618",
"0.62188",
"0.617067",
"0.6165467",
"0.6068398",
"0.5925369",
"0.59005386",
"0.577267",
"0.57644427",
"0.57426924",
"0.573043",
"0.57293475",
"0.57293475",
"0.57142687",
"0.57071096",
"0.57071096",
"0.56829256",
"0.56778187",
"0.5620054",
"0.5617508",
"0.559691",... | 0.0 | -1 |
basicType arrayCreatorRest | qualident ( arrayCreatorRest | classCreatorRest ) | private Operation creator(Scope scope, Vector queue)
{
Operation root = null;
Type t = new Type();
if ((t.type = basicType()) != Keyword.NONESY)
{
root = arrayCreatorRest(t, scope, queue);
}
else
{
Token x = nextToken;
t.ident = new Token(nextToken);
t.ident.string = x.string = qualident();
unresolved.add(x.string);
if (nextSymbol == Keyword.LBRACKETSY)
{
root = arrayCreatorRest(t, scope, queue);
}
else
{
root = classCreatorRest(x, scope, queue);
}
}
return root;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public final void creator() throws RecognitionException {\n int creator_StartIndex = input.index();\n try { dbg.enterRule(getGrammarFileName(), \"creator\");\n if ( getRuleLevel()==0 ) {dbg.commence();}\n incRuleLevel();\n dbg.location(857, 1);\n\n try {\n if ( ... | [
"0.66494364",
"0.64283484",
"0.5847988",
"0.54470474",
"0.529542",
"0.5128437",
"0.50747585",
"0.50178605",
"0.4921848",
"0.491676",
"0.48715144",
"0.48598677",
"0.48397464",
"0.48310965",
"0.48256198",
"0.4824616",
"0.4815745",
"0.48038927",
"0.48016745",
"0.4762685",
"0.476... | 0.55396366 | 3 |
arguments [ classBody ] | private Operation classCreatorRest(Token t, Scope scope, Vector queue)
{
Vector v = new Vector();
String s = "super";
Operation root = new Operation();
root.type.type = Keyword.NONESY;
root.type.ident = t;
traceOn(v);
root.left = arguments(scope, v, queue);
traceOff(v);
for(int i = 0; i < v.size(); i++)
{
Token pt = (Token)v.get(i);
if (pt.kind == Keyword.NUMBERSY)
s += pt.val;
else if (pt.kind == Keyword.LNUMBERSY)
s += pt.val + "L";
else if (pt.kind == Keyword.DNUMBERSY)
s += pt.fval;
else if (pt.kind == Keyword.IDENTSY)
s += pt.string;
else
s += pt.kind.string;
}
if (s.endsWith("()"))
s = "";
else
s += ';';
if (nextSymbol == Keyword.LBRACESY)
{
ClassType x = new ClassType();
x.name = new Token();
x.name.kind = Keyword.IDENTSY;
x.name.string = "Anonymous" + anonymous++;
x.scope = new Scope(scope, Scope.classed, x.name.string);
x.extend = new ClassType(t.string.substring(t.string.lastIndexOf('.') + 1));
x.implement = new ClassType[1];
x.implement[0] = x.extend;
declMember(scope, x);
if (!scopeStack.contains(scope))
scopeStack.add(scope);
root.type.ident = x.name;
root.type.type = Keyword.NONESY;
root.left.left = null;
Vector old = queue;
queue = new Vector();
HashSet dummy = unresolved;
unresolved = x.unresolved;
unresolved.add(t.string);
classBody(x, new Modifier(), s, queue);
addToConstructor(x, queue);
queue = old;
unresolved = dummy;
writeList(x);
}
return root;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"@Override\n\tpublic void inAClassBody(AClassBody node) {\n // Determine the start and end line numbers.\n int begin = findBeginLine(node);\n int end = node.getRBrace().getLine();\n String cname = null;\n Node parentNode = node.parent();\n if (parentNode instanceof AClassDe... | [
"0.6212795",
"0.6094653",
"0.602533",
"0.601708",
"0.5859332",
"0.5856543",
"0.5824258",
"0.5799439",
"0.57859117",
"0.5752963",
"0.5740551",
"0.57384706",
"0.57365674",
"0.57365674",
"0.57009906",
"0.5649859",
"0.5627211",
"0.56025904",
"0.55918074",
"0.5585633",
"0.5581739"... | 0.0 | -1 |
'[' ']' BracketsOpt '.' "class" | ArgumentsOpt | '.' ("class" | "this") | private Operation identifierSuffix(Operation root, Operation next, Scope scope, Vector queue)
{
if (nextSymbol == Keyword.LBRACKETSY)
{
lookAhead();
lookAhead();
unresolved.add("JavaArray");
bracketsOpt();
matchKeyword(Keyword.DOTSY);
matchKeyword(Keyword.CLASSSY);
next.left.operator = Keyword.CLASSSY;
}
else if (nextSymbol == Keyword.DOTSY)
{
lookAhead();
if (nextSymbol == Keyword.CLASSSY)
{
lookAhead();
next.left.operator = Keyword.CLASSSY;
}
else
{
next = (next.right = new Operation());
next.left = new Operation();
next.left.operator = nextSymbol;
matchKeyword(Keyword.THISSY);
}
}
else
{
next.left.left = argumentsOpt(scope, null, queue);
}
return root;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public Snippet visit(MethodCallInConstructor n, Snippet argu) {\n\t Snippet _ret= new Snippet(\"\",\"\",null,false);\n\t String className = \"NEED TO PUT CLASS NAME\";\n\t n.nodeToken.accept(this, argu);\n\t String methodName = n.identifier.accept(this, argu).expType.getTypeName();\n\t this... | [
"0.5584652",
"0.5063738",
"0.5030421",
"0.49930885",
"0.4976345",
"0.49393883",
"0.48815188",
"0.48562983",
"0.48518264",
"0.48267272",
"0.48143008",
"0.47946846",
"0.478832",
"0.47635964",
"0.47463697",
"0.47378266",
"0.47152674",
"0.47152674",
"0.47139385",
"0.47137874",
"0... | 0.44142374 | 79 |
'.' ( ident ArgumentsOpt | "super" Arguments | "new" InnerCreator ) | '[' Expression ']' | private Operation selector(Scope scope, Vector queue)
{
Operation root;
root = new Operation();
if (nextSymbol == Keyword.DOTSY)
{
lookAhead();
root.operator = nextSymbol;
if (nextSymbol == Keyword.IDENTSY)
{
root.name = nextToken;
lookAhead();
root.left = argumentsOpt(scope, null, queue);
}
else if (nextSymbol == Keyword.SUPERSY)
{
matchKeyword(Keyword.SUPERSY);
root.left = arguments(scope, null, queue);
}
else
{
matchKeyword(Keyword.NEWSY);
root.left = innerCreator(scope, queue);
}
}
else
{
root.operator = nextSymbol;
matchKeyword(Keyword.LBRACKETSY);
follower.add(Keyword.RBRACKETSY);
unresolved.add("JavaArray");
root.left = expression(scope, queue);
follower.remove(follower.size() - 1);
matchKeyword(Keyword.RBRACKETSY);
}
return root;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"private static Expr newSuperCstrCall(String superClassName) {\n MethodSignature.Builder msb = MethodSignature.newBuilder();\n msb.setName(\"new\");\n msb.setOwner(toGlobalName(superClassName));\n msb.setReturnType(voidType());\n MethodCall.Builder mb = MethodCall.newBuilder();\n mb.setSignature(m... | [
"0.5825867",
"0.5810994",
"0.5793749",
"0.5586077",
"0.55407876",
"0.54051656",
"0.5376658",
"0.5358889",
"0.528302",
"0.51446134",
"0.51443315",
"0.51125747",
"0.5093253",
"0.5073238",
"0.5068527",
"0.50632143",
"0.5060805",
"0.50061786",
"0.49289072",
"0.49260837",
"0.49247... | 0.5367224 | 7 |
Construcctor del Objeto Signo. | public Signo(String nombreSigno) {
this.nombreSigno = nombreSigno;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public Signo() {\n\n }",
"public SignBean() {\n }",
"SPX(Object obj) {\n super();\n\n this.obj = obj;\n\n }",
"public BoletoPaymentRequest() {\n\n }",
"public CuentaDeposito() {\n super();\n }",
"public EnvioPersonaPK() {\r\n }",
"public SignaturEater(... | [
"0.76215166",
"0.62421006",
"0.57751954",
"0.5760748",
"0.5740004",
"0.57356066",
"0.5718838",
"0.5676105",
"0.5670853",
"0.56630903",
"0.56623036",
"0.5651707",
"0.56443065",
"0.5635455",
"0.5631608",
"0.5621887",
"0.5615272",
"0.55905503",
"0.55825984",
"0.5556664",
"0.5551... | 0.66347754 | 1 |
Construcctor del Objeto Signo. | public Signo() {
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public Signo(String nombreSigno) {\n this.nombreSigno = nombreSigno;\n }",
"public SignBean() {\n }",
"SPX(Object obj) {\n super();\n\n this.obj = obj;\n\n }",
"public BoletoPaymentRequest() {\n\n }",
"public CuentaDeposito() {\n super();\n }",
"publ... | [
"0.66347754",
"0.62421006",
"0.57751954",
"0.5760748",
"0.5740004",
"0.57356066",
"0.5718838",
"0.5676105",
"0.5670853",
"0.56630903",
"0.56623036",
"0.5651707",
"0.56443065",
"0.5635455",
"0.5631608",
"0.5621887",
"0.5615272",
"0.55905503",
"0.55825984",
"0.5556664",
"0.5551... | 0.76215166 | 0 |
Callback used when this service component is activating | @Activate
protected synchronized void activate(final ComponentContext componentContext,
final Map<String, Object> properties) {
LOGGER.info("Activating MongoDB Component...");
super.setCloudService(this.m_cloudService);
super.activate(componentContext);
this.m_context = componentContext;
this.doRegister(componentContext, properties);
LOGGER.info("Activating MongoDB Component... Done.");
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"@Override\n public void onActivate() {\n }",
"@Override\n public void activate() {\n \n }",
"@Override\n public void activate() {\n\n }",
"@Override\n\t\t\tpublic void onServiceConnected(ComponentName name, IBinder service) {\n\t\t\t}",
"public void onActivation() { }",... | [
"0.70359695",
"0.69655627",
"0.67814636",
"0.6762563",
"0.6703154",
"0.6655462",
"0.6655462",
"0.66006845",
"0.6597546",
"0.65952057",
"0.65696985",
"0.6555636",
"0.65208477",
"0.6519615",
"0.65171266",
"0.6514596",
"0.6436742",
"0.6425872",
"0.63952243",
"0.63898",
"0.635497... | 0.0 | -1 |
Callback used when this service component is deactivating | @Override
@Deactivate
protected void deactivate(final ComponentContext context) {
LOGGER.debug("Deactivating MongoDB Component...");
LOGGER.info("Releasing CloudApplicationClient for {}...", APP_ID);
super.deactivate(context);
LOGGER.debug("Deactivating MongoDB Component... Done.");
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"@Override\n public void onDeactivate() {\n }",
"public void onDeactivation() { }",
"@Override\n\tpublic void onDeactivated() {\n\t\t\n\t}",
"@Override\n\tpublic void onDeactivate() {\n\t}",
"public void deActivated() \r\n\t{\r\n\t\t\r\n\t}",
"@Override\n\tpublic void onDestroy() {\n\t\tunbindServic... | [
"0.76919997",
"0.7530798",
"0.75143176",
"0.74980015",
"0.7164491",
"0.71528757",
"0.71251726",
"0.71150094",
"0.71035653",
"0.7002748",
"0.69868314",
"0.69779134",
"0.69779134",
"0.6974324",
"0.6942236",
"0.6942002",
"0.6941421",
"0.6935349",
"0.6935349",
"0.6933779",
"0.692... | 0.65193874 | 81 |
Used to be called when configurations will get updated | public void updated(final Map<String, Object> properties) {
LOGGER.info("Updating MongoDB Component...");
this.m_properties = properties;
properties.keySet().forEach(s -> LOGGER.info("Update - " + s + ": " + properties.get(s)));
this.doRegister(this.m_context, properties);
LOGGER.info("Updating MongoDB Component... Done.");
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"void configurationUpdated();",
"@Override\n\tpublic void onConfigurationUpdate() {\n\t}",
"public void notifyConfigChange() {\n }",
"void onConfigChanged(ConfigUpdate update);",
"public abstract void updatePendingConfiguration(Configuration config);",
"private void config() {\n\t}",
"private void fi... | [
"0.8578289",
"0.80986",
"0.77703315",
"0.7487825",
"0.7440951",
"0.72692937",
"0.72169024",
"0.71941584",
"0.71539813",
"0.71333915",
"0.70943147",
"0.7086141",
"0.7034697",
"0.69955367",
"0.69955367",
"0.69955367",
"0.69955367",
"0.69955367",
"0.69955367",
"0.698126",
"0.696... | 0.0 | -1 |
Initialize the editor by specifying the attribute to edit and the editor type to use. | public void init(final EAttribute eAttribute, final String javaClassTypeName) {
this.eAttribute = eAttribute;
this.propsEditor = EAttrPropsEditorPlugin.getStructuralFeatureEditor(eAttribute, javaClassTypeName, this,
getStyle());
if (this.currentComponent != null) {
this.currentComponent.dispose();
}
if (this.propsEditor != null) {
this.currentComponent = this.propsEditor.getEditor();
this.currentComponent.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));
this.layout();
}
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public ConfmlEditor() {\r\n\t\tsuper();\r\n\t\tinitializeEditingDomain();\r\n\t}",
"protected void initializeEditors() {\n\t}",
"public void setEditor(Editor editor)\n {\n this.editor = editor;\n }",
"public void configureEditor() {\n\t\tsuper.configureEditor();\n\t}",
"public StringEditor() {... | [
"0.6051455",
"0.5918607",
"0.58683497",
"0.57546645",
"0.5721572",
"0.5697665",
"0.56835777",
"0.5668366",
"0.55596834",
"0.5548008",
"0.5548008",
"0.5474536",
"0.54548836",
"0.5454007",
"0.5441319",
"0.54326487",
"0.5429812",
"0.54006827",
"0.539092",
"0.53588724",
"0.535628... | 0.6126361 | 0 |
Default constructor that will generate a default loan. | public Loan() {
this(2.5, 1, 1000);
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public Loan(){\n\t\tthis(\"\", 0, 0, 0, 0);\n\t\tstart_date = null;\n\t}",
"public Loan(int s) {\r\n\t\tstockId = s;\r\n\t\tloanId = nextLoanId;\r\n\t\tnextLoanId++;\r\n\t\tloanFine = new Fine();\t\t\r\n\t\tloanDate = LocalDate.now();\r\n\t}",
"public Lanceur() {\n\t}",
"public Loan(int loanId, book book, me... | [
"0.8042531",
"0.7103456",
"0.70114994",
"0.6977064",
"0.6858182",
"0.6770535",
"0.66889286",
"0.6589517",
"0.64766026",
"0.6460452",
"0.6453653",
"0.6425949",
"0.641147",
"0.64051586",
"0.63499165",
"0.63404876",
"0.6311535",
"0.6256017",
"0.6251142",
"0.6232726",
"0.62145257... | 0.8163442 | 0 |
Construct a loan with specified annual interest rate, number of years, and loan amount. | public Loan(double annualInterestRate, int numberOfYears, double loanAmount) {
this.annualInterestRate = annualInterestRate;
this.numberOfYears = numberOfYears;
this.loanAmount = loanAmount;
loanDate = new java.util.Date();
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public Loan(double annualInterestRate, int numberOfYears, double loanAmount)\n {\n setAnnualInterestRate(annualInterestRate);\n setNumberOfYears(numberOfYears);\n setLoanAmount(loanAmount);\n loanDate = new Date();\n }",
"public Loan(String cId, double pA, double iR, int nY, int... | [
"0.83322054",
"0.68652654",
"0.67955536",
"0.6713729",
"0.66644216",
"0.64895993",
"0.6460563",
"0.614797",
"0.6016528",
"0.58425885",
"0.5812335",
"0.5800136",
"0.579399",
"0.5749996",
"0.559929",
"0.55849487",
"0.5573042",
"0.55505896",
"0.5542063",
"0.5538756",
"0.5480698"... | 0.8419995 | 0 |
Provides the annual interest rate. | public double getAnnualInterestRate() {
return annualInterestRate;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public double getAnnualInterestRate() {\n\t\treturn annualInterestRate;\n\t}",
"public double getInterestRate(){\n return annualInterestRate;\n }",
"public static double getInterestRate(){\n\t\t return interest_rate;\r\n\t }",
"public double getMonthlyInterestRate() {\n return (annualInteres... | [
"0.827151",
"0.8058885",
"0.7826095",
"0.7743423",
"0.7721606",
"0.7680758",
"0.7631817",
"0.7590641",
"0.7493326",
"0.7460857",
"0.7443071",
"0.73960066",
"0.73174304",
"0.72795504",
"0.7242775",
"0.7225746",
"0.7205338",
"0.70692825",
"0.69836116",
"0.69655776",
"0.6886179"... | 0.84106857 | 1 |
Sets the annual interest rate. | public void setAnnualInterestRate(double annualInterestRate) {
this.annualInterestRate = annualInterestRate;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public static void modifyInterestRate(double interestRate){\n annualInterestRate = interestRate;\n }",
"public void setInterest(double rate)\n {\n interestRate = rate;\n }",
"public void setAnnualInterestRate(double annualInterestRate) {\n\t\tthis.annualInterestRate = annualInterestRate;... | [
"0.7652004",
"0.7614111",
"0.7332631",
"0.7179029",
"0.70576936",
"0.6760844",
"0.6619691",
"0.63155144",
"0.628289",
"0.628289",
"0.6276923",
"0.6217384",
"0.61651635",
"0.60440266",
"0.59668154",
"0.5896842",
"0.58729935",
"0.5846255",
"0.57928956",
"0.5772212",
"0.5747549"... | 0.75483996 | 3 |
Provides the number of years a loan is active for. | public int getNumberOfYears() {
return numberOfYears;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"int getYears();",
"public int getYearsUntilTenure(){\n return m_yearsUntilTenure;\n }",
"private int calculateAge() {\n\t\treturn LocalDate.now().getYear() - this.birthYear;\n\t}",
"public int getYears() {\n return this.years;\n }",
"public int getYears() {\r\n\t\treturn years;\r\n\t}",
"pu... | [
"0.71602774",
"0.70549023",
"0.7027702",
"0.7015681",
"0.6903264",
"0.6845713",
"0.6702648",
"0.6653057",
"0.6636656",
"0.6621055",
"0.662064",
"0.66160345",
"0.65606123",
"0.6560458",
"0.64637136",
"0.64496326",
"0.644379",
"0.6441581",
"0.6404241",
"0.6396017",
"0.6380072",... | 0.74527234 | 0 |
Sets the number of years a loan is active for. | public void setNumberOfYears(int numberOfYears) {
this.numberOfYears = numberOfYears;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public void setYears(int years) {\n this.years = years;\n }",
"public void setYear(int value) {\n\tthis.year = value;\n }",
"public void setYear(int _year) { year = _year; }",
"public void setYear(int value) {\r\n this.year = value;\r\n }",
"public void setYear (int yr) {\n ... | [
"0.7002271",
"0.66871",
"0.6657304",
"0.66516453",
"0.66091126",
"0.65313977",
"0.65059614",
"0.6505056",
"0.64795744",
"0.6416219",
"0.63810617",
"0.6305222",
"0.6293492",
"0.6287165",
"0.6285803",
"0.6258377",
"0.6258377",
"0.6228325",
"0.62260705",
"0.6208222",
"0.62081724... | 0.70768213 | 0 |
Provides size of loan. | public double getLoanAmount() {
return loanAmount;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public final long getSize() { return size; }",
"public long getSize()\n {\n return getLong(\"Size\");\n }",
"public long getSize() {\n return size;\n }",
"public long getSize() {\r\n return size;\r\n }",
"public long getSize() {\n return size;\n }",
"public long getSi... | [
"0.7315282",
"0.7248679",
"0.7218554",
"0.71969384",
"0.71827996",
"0.71827996",
"0.71827996",
"0.71827996",
"0.71806216",
"0.7150316",
"0.71306187",
"0.70788294",
"0.70519936",
"0.70395875",
"0.7029868",
"0.7029868",
"0.7024958",
"0.7010591",
"0.69981295",
"0.69937277",
"0.6... | 0.0 | -1 |
Sets the size of loan. | public void setLoanAmount(double loanAmount) {
this.loanAmount = loanAmount;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public void setSize(long size) {\r\n\t\tthis.size = size;\r\n\t}",
"private void set_size(int size)\r\n\t{\r\n\t\tthis.size = size;\r\n\t}",
"public void setSize(long value) {\n this.size = value;\n }",
"public void setSize(int size) {\r\n _size = size;\r\n }",
"public void setSize(int ... | [
"0.7289109",
"0.7223777",
"0.7137515",
"0.7036867",
"0.70244354",
"0.69549847",
"0.69265205",
"0.69090414",
"0.6883894",
"0.6883894",
"0.68453664",
"0.6806442",
"0.6806442",
"0.6806442",
"0.6806442",
"0.6728248",
"0.66165984",
"0.66056836",
"0.65963274",
"0.65949184",
"0.6579... | 0.0 | -1 |
Provides the required monthly payment amount. | public double getMonthlyPayment() {
double monthlyInterestRate = annualInterestRate / 1200;
double monthlyPayment = loanAmount * monthlyInterestRate / (1 - (1 / Math.pow(1 + monthlyInterestRate, numberOfYears * 12)));
return monthlyPayment;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public LoanMonthlyPayment calculateMonthlyPayment() {\n double monthlyInterest = loanRequest.getApr() / MONTHLY_INTEREST_DIVISOR;\n double tmp = Math.pow(1d + monthlyInterest, -1);\n tmp = Math.pow(tmp, loanRequest.getTermInMonths());\n tmp = Math.pow(1d - tmp, -1);\n return new ... | [
"0.7260527",
"0.72044027",
"0.718239",
"0.7122574",
"0.69955546",
"0.6949449",
"0.6706348",
"0.6580219",
"0.6577091",
"0.6561213",
"0.6501366",
"0.6499962",
"0.6475233",
"0.6465791",
"0.6456828",
"0.6443561",
"0.64252883",
"0.6418953",
"0.64074343",
"0.63946676",
"0.6382841",... | 0.79301673 | 0 |
Provides the total number of payments required. | public double getTotalPayment() {
double totalPayment = getMonthlyPayment() * numberOfYears * 12;
return totalPayment;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public static int minimumNumberOfPayments() {\n return 0;\n }",
"public double getTotalPayments(){return this.total;}",
"public double getTotalAmountPaid(){\n\t\tdouble amount = getAmountOfFixedPayments()*no_years*no_payments_yearly;\n\t\tdouble result = Math.round(amount*100.0) / 100.0;\n\t\treturn ... | [
"0.7211168",
"0.6893038",
"0.680522",
"0.6715126",
"0.6615078",
"0.65967166",
"0.6554185",
"0.6462327",
"0.64481187",
"0.64388967",
"0.6391857",
"0.63698834",
"0.63521385",
"0.63335925",
"0.6323459",
"0.6323459",
"0.6315897",
"0.63061726",
"0.63061726",
"0.62925786",
"0.62897... | 0.69496214 | 1 |
Provides the date of loan. | public java.util.Date getLoanDate() {
return loanDate;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public LocalDate getDate() {\r\n\t\treturn loanDate;\r\n\t}",
"public String Get_date() \n {\n \n return date;\n }",
"public String getLeavingDate();",
"public Date getDate_of_admission() {\r\n return date_of_admission;\r\n }",
"java.lang.String getDate();",
"public long getDate()... | [
"0.80278045",
"0.7148208",
"0.69566554",
"0.6690323",
"0.666629",
"0.661017",
"0.66068244",
"0.6591761",
"0.6571702",
"0.65464973",
"0.65464973",
"0.6542482",
"0.6539978",
"0.6535568",
"0.6522169",
"0.65185493",
"0.65082425",
"0.64739645",
"0.64739645",
"0.64739645",
"0.64739... | 0.8096227 | 0 |
Created by chan on 2/10/18. | public interface DetailContract {
interface DetailView{
void openBrowserIntent(String url);
void openShareIntent();
}
interface DetailMvpPresenter{
void onMenuBrowserOpenClick(String url);
void onMenuShareClick();
}
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"@Override\n public void perish() {\n \n }",
"@Override\n\tpublic void grabar() {\n\t\t\n\t}",
"@Override\n\tpublic void comer() {\n\t\t\n\t}",
"private stendhal() {\n\t}",
"@Override\n public void func_104112_b() {\n \n }",
"@Override\n\tprotected void interr() {\n\t}",
"publi... | [
"0.589098",
"0.58720195",
"0.5835741",
"0.57920796",
"0.57533365",
"0.5734152",
"0.5733649",
"0.5700252",
"0.5674923",
"0.5674923",
"0.5674923",
"0.5674923",
"0.5674923",
"0.5674454",
"0.5633371",
"0.5632893",
"0.5627495",
"0.5627495",
"0.5624418",
"0.56141835",
"0.5607625",
... | 0.0 | -1 |
Set a new course for this student. | public void changecourse(String replacementcourse, String id1)
{
course = replacementcourse;
courseid = id1;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public void setCourse(String course);",
"public void assignCourse(Course course) {\n assignedCourse = course;\n }",
"public void setcourse(String course) {\n\t\tthis.course = course;\n\t}",
"public void assignCourse(Course course) {\r\n this.course.add(course);\r\n }",
"public void setEventCo... | [
"0.7170034",
"0.70155954",
"0.67550135",
"0.66669047",
"0.6576238",
"0.6555568",
"0.65456015",
"0.6453327",
"0.6306509",
"0.63023466",
"0.62776065",
"0.6205937",
"0.61827826",
"0.61738306",
"0.6157881",
"0.6106482",
"0.6082726",
"0.60044",
"0.5885722",
"0.58840066",
"0.581138... | 0.6094863 | 16 |
String pattern = ",."; | public static String formatNumber(double number) {
String pattern = "###,###";
DecimalFormat myFormatter = new DecimalFormat(pattern);
String output = myFormatter.format(number);
return output;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"private boolean isValidPattern(String pattern) {\n return !pattern.startsWith(\"-\") && !pattern.contains(\",\");\n }",
"private void replaceCommaToDot(String contentString)\n {\n char[] charArray = contentString.toCharArray();\n \n for(int i = 0; i < charArray.length; i++)\n ... | [
"0.60660654",
"0.5590494",
"0.5509168",
"0.5488579",
"0.5449958",
"0.53112024",
"0.527919",
"0.5214272",
"0.51839405",
"0.51621026",
"0.5157084",
"0.5153784",
"0.51366234",
"0.51056427",
"0.50686616",
"0.50637674",
"0.5051741",
"0.5043206",
"0.5026043",
"0.50193626",
"0.49853... | 0.0 | -1 |
mashing it all into one function of methods | public static long doubleToLong(double d) {
return new Long(String.format("%.0f", d)).longValue();
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"private void setMethods(Class<?> token) {\n List<Method> newMethods = new ArrayList<>();\n for (Method method : token.getDeclaredMethods()) {\n if (methods.add(new MethodWithHash(method)) && !method.isDefault()) {\n newMethods.add(method);\n }\n }\n ... | [
"0.5966792",
"0.5933956",
"0.5698374",
"0.56169844",
"0.55956304",
"0.5549709",
"0.5485362",
"0.54074925",
"0.538804",
"0.5362182",
"0.5361501",
"0.5361501",
"0.53313553",
"0.53275615",
"0.5310093",
"0.5306132",
"0.53046024",
"0.5282257",
"0.5278007",
"0.52459455",
"0.5234636... | 0.0 | -1 |
mashing it all into one function of methods | public static double longToDouble(long l) {
return (double) l;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"private void setMethods(Class<?> token) {\n List<Method> newMethods = new ArrayList<>();\n for (Method method : token.getDeclaredMethods()) {\n if (methods.add(new MethodWithHash(method)) && !method.isDefault()) {\n newMethods.add(method);\n }\n }\n ... | [
"0.5966792",
"0.5933956",
"0.5698374",
"0.56169844",
"0.55956304",
"0.5549709",
"0.5485362",
"0.54074925",
"0.538804",
"0.5362182",
"0.5361501",
"0.5361501",
"0.53313553",
"0.53275615",
"0.5310093",
"0.5306132",
"0.53046024",
"0.5282257",
"0.5278007",
"0.52459455",
"0.5234636... | 0.0 | -1 |
We use DSL here to try invoke the step implementation, if there is Step implementation found it's handled or it's an error. sandbox security execution relies on the assumption that CpsScript.invokeMethod() is safe for sandboxed code. That means we cannot let userwritten script override this method, hence the final. | @Override
public final Object invokeMethod(String name, Object args) {
DSL dsl = (DSL) getBinding().getVariable(STEPS_VAR);
return dsl.invokeMethod(name,args);
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"@Override\r\n\tprotected void doExecute(StepExecution stepExecution) throws Exception {\n\t\t\r\n\t}",
"protected abstract R runStep();",
"public interface IAutomationStep {\n\n void executeStep();\n}",
"private Object invokeStep(MethodInvocation invocation) throws Throwable {\n\t\tprinter().onStepBegins(... | [
"0.6157857",
"0.61558944",
"0.5930179",
"0.5908954",
"0.58547926",
"0.58203876",
"0.5559398",
"0.55302256",
"0.5482509",
"0.5472053",
"0.5468591",
"0.53335416",
"0.5262466",
"0.52398247",
"0.52250826",
"0.5222291",
"0.522215",
"0.52130604",
"0.5203503",
"0.518782",
"0.5181737... | 0.5166901 | 21 |
this might throw the magic CpsCallableInvocation to execute the script asynchronously | @Override
public Object evaluate(String script) throws CompilationFailedException {
return getShell().evaluate(script);
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"@Override\r\n public void asyncExecute(String script)\r\n {\n\r\n }",
"private static Object executeAsyncJavascript(WebDriver driver, String script) {\n System.out.println(\"Executing Async javascript: \" + script);\n return ((JavascriptExecutor) driver).executeAsyncScript(script);\n }"... | [
"0.757757",
"0.65191174",
"0.6447996",
"0.6241113",
"0.61415005",
"0.6032064",
"0.5891763",
"0.5882295",
"0.58384997",
"0.58029366",
"0.57619566",
"0.5755553",
"0.5746768",
"0.5740441",
"0.57321906",
"0.57050854",
"0.5703898",
"0.57031",
"0.56879973",
"0.56841975",
"0.5684197... | 0.0 | -1 |
Obtains the Groovy compiler to be used for compiling user script in the CPStransformed and sandboxed manner. | private GroovyShell getShell() {
return CpsThreadGroup.current().getExecution().getShell();
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public String getCompiler();",
"public Compiler getCompiler() {\n\t\treturn this.compiler;\n\t}",
"public String getCompilerSourceVM();",
"public String getCompilerClassName();",
"public PyCode compile(String script) {\n return null;\n }",
"public T execute() {\n return GraalCompiler... | [
"0.7087824",
"0.6494653",
"0.60767746",
"0.5958724",
"0.5936324",
"0.5928866",
"0.5802162",
"0.57071745",
"0.56498486",
"0.5627082",
"0.5612963",
"0.55880183",
"0.555377",
"0.5541758",
"0.5421811",
"0.54092026",
"0.52320236",
"0.5230801",
"0.5148512",
"0.51443297",
"0.5133404... | 0.46303353 | 60 |
/ Test hook, disable the LocalCBVLSN updates. | public void setAllowUpdate(boolean allowUpdate) {
this.allowUpdate = allowUpdate;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"@Override\r\n\tpublic void setDontSendLocalSecurityUpdates(boolean arg0)\r\n\t\t\tthrows NotesApiException {\n\r\n\t}",
"public void onNotEnabled() {\n Timber.d(\"onNotEnabled\");\n // keep the callback in case they turn it on manually\n setTorPref(Status.DISABLED);\n createClearnetCl... | [
"0.6171968",
"0.60608035",
"0.58863413",
"0.5865614",
"0.5767688",
"0.5760496",
"0.573063",
"0.5718143",
"0.571538",
"0.571538",
"0.5711072",
"0.570262",
"0.570262",
"0.570262",
"0.570262",
"0.570262",
"0.570262",
"0.570262",
"0.570262",
"0.570262",
"0.570262",
"0.570262",
... | 0.0 | -1 |
If GlobalCBVLSN is defunct, does nothing. If GlobalCBVLSN is defunct, tracks barrier VLSNs, updating the local CBVLSN if the associated log file has changed. When tracking is done on a replica, the currentLocalCBVLSN value is ultimately sent via heartbeat response to the master, which updates the RepGroupDb. When tracking is done on a master, the update is done on this node. The update is only done once per file in order to decrease the cost of tracking. Since we want the local cbvlsn to be durable, we use the last vlsn in the penultimate log file as the local cbvlsn value. We know the penultimate log file has been fsynced, and therefore the last vlsn within that file has also been fsynced. Tracking can be called quite often, and should be lightweight. | public void track(VLSN newVLSN, long lsn) {
if (defunct || !allowUpdate) {
return;
}
synchronized (this) {
if (newVLSN.compareTo(lastSyncableVLSN) > 0) {
VLSN old = lastSyncableVLSN;
lastSyncableVLSN = newVLSN;
if (DbLsn.getFileNumber(lsn) != currentFile) {
currentFile = DbLsn.getFileNumber(lsn);
currentLocalCBVLSN = old;
}
}
}
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"void updateLocalCallLogs() {\n setIncludePairedCallLogs();\n buildCallLogsList();\n\n notifyCallDataChanged();\n }",
"synchronized void updateCheckpointOnReplica(final long checkpoint) {\n /*\n * The global checkpoint here is a local knowledge which is updated under the man... | [
"0.50709635",
"0.49265188",
"0.48355",
"0.48273814",
"0.46700633",
"0.46698782",
"0.46591732",
"0.46091968",
"0.4603446",
"0.4599396",
"0.45433962",
"0.4500395",
"0.4497717",
"0.4463186",
"0.44577447",
"0.44379023",
"0.44276705",
"0.44233802",
"0.44171703",
"0.440049",
"0.438... | 0.6968448 | 0 |
If the GlobalVLSN is not defunct, initialize the local CBVLSN with the syncup matchpoint, so that the heartbeat responses sent before the node has replayed any log entries are still valid for saving a place in the replication stream. If the GlobalVLSN is defunct, do nothing. | public void registerMatchpoint(VLSN matchpoint) {
if (defunct) {
return;
}
this.currentLocalCBVLSN = matchpoint;
this.lastSyncableVLSN = matchpoint;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"@Override\n\tpublic ServerServices duplexstreamGlobalVarsInit() throws Exception {\n\t\treturn null;\n\t}",
"public static void initialize()\n {\n localPeerIDCount = 0;\n\n }",
"private void sendGroupInit() {\n \t\ttry {\n \t\t\tmyEndpt=new Endpt(serverName+\"@\"+vsAddress.toString());\n \n \t\t\t... | [
"0.54224545",
"0.53833354",
"0.5316355",
"0.52565396",
"0.5251307",
"0.52152073",
"0.5175884",
"0.50674057",
"0.5061739",
"0.50227034",
"0.50213045",
"0.50066525",
"0.49351722",
"0.49214247",
"0.49078634",
"0.4905479",
"0.49002984",
"0.4878639",
"0.48574308",
"0.48041338",
"0... | 0.5564671 | 0 |
Author: DaoTQ1 Description: This function testing Paging ShowDate Movie Result: The test is pass. This function return ResponseEntity with status 200 and Date Movies List, totalPages,totalElement and current Page | @Test
public void testFindAll_multiRecord() throws Exception {
// Setup
// Configure MovieService.findAll(...).
final List<MovieDTO> movieDTOS = Arrays.asList(
new MovieDTO(0, "Kiendo", "justice league", "zack snyder", 0.0f,
LocalDate.of(2020, 1, 1), LocalDate.of(2020, 1, 1), "movieCompany",
"version", "justice league", "nameVN", "avatar", "image"),
new MovieDTO(1, "actor", "content", "director", 0.0f,
LocalDate.of(2020, 1, 1), LocalDate.of(2020, 1, 1), "movieCompany",
"version", "nameEng", "nameVN", "avatar", "image")
);
when(mockMovieService.findAll()).thenReturn(movieDTOS);
// Run the test
final MockHttpServletResponse response = mockMvc.perform(get("/api/movies")
.accept(MediaType.APPLICATION_JSON))
.andReturn().getResponse();
// Verify the results
String jsonExpected =
"[{\"cinemaRoom\":null,\"id\":0,\"actor\":\"Kiendo\",\"content\":\"justice league\",\"director\":\"zack snyder\",\"duration\":0.0,\"fromDate\":\"2020-01-01\",\"toDate\":\"2020-01-01\",\"movieCompany\":\"movieCompany\",\"version\":\"version\",\"nameEng\":\"justice league\",\"nameVN\":\"nameVN\",\"avatar\":\"avatar\",\"image\":\"image\",\"scheduleMovies\":null,\"typeMovies\":null,\"tickets\":null,\"scheduleSeats\":null},{\"cinemaRoom\":null,\"id\":1,\"actor\":\"actor\",\"content\":\"content\",\"director\":\"director\",\"duration\":0.0,\"fromDate\":\"2020-01-01\",\"toDate\":\"2020-01-01\",\"movieCompany\":\"movieCompany\",\"version\":\"version\",\"nameEng\":\"nameEng\",\"nameVN\":\"nameVN\",\"avatar\":\"avatar\",\"image\":\"image\",\"scheduleMovies\":null,\"typeMovies\":null,\"tickets\":null,\"scheduleSeats\":null}]";
assertEquals(HttpStatus.OK.value(), response.getStatus());
assertEquals(jsonExpected, response.getContentAsString());
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"@Test\n void getAllMoviesByTitle_Test() throws Exception {\n\n //Set up\n List<Movie> movies = new ArrayList<>();\n Movie movie = new Movie();\n movie.getTitle();\n movies.add(movie);\n\n //Exercise\n when(movieService.getAllMoviesByTitle(movie.getTitle())).thenReturn(... | [
"0.6423744",
"0.63635504",
"0.6256357",
"0.62498415",
"0.62265176",
"0.621253",
"0.6076213",
"0.6027989",
"0.60205376",
"0.5981488",
"0.59711915",
"0.5939453",
"0.5894045",
"0.5887469",
"0.587942",
"0.585426",
"0.58125997",
"0.5763112",
"0.5748663",
"0.5716427",
"0.57120854",... | 0.54566073 | 47 |
TODO Autogenerated method stub | @Override
public int af() {
System.out.println("ddddd");
return 0;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"@Override\r\n\tpublic void comer() \r\n\t{\n\t\t\r\n\t}",
"@Override\n\tpublic void comer() {\n\t\t\n\t}",
"@Override\n public void perish() {\n \n }",
"@Override\r\n\t\t\tpublic void annadir() {\n\r\n\t\t\t}",
"@Override\n\tpublic void anular() {\n\n\t}",
"@Override\n\tprotected void getExr... | [
"0.6671074",
"0.6567672",
"0.6523024",
"0.6481211",
"0.6477082",
"0.64591026",
"0.64127725",
"0.63762105",
"0.6276059",
"0.6254286",
"0.623686",
"0.6223679",
"0.6201336",
"0.61950207",
"0.61950207",
"0.61922914",
"0.6186996",
"0.6173591",
"0.61327106",
"0.61285484",
"0.608016... | 0.0 | -1 |
TODO Autogenerated method stub | @Override
public int af() {
System.out.println("dsdfdghbd");
return 0;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"@Override\r\n\tpublic void comer() \r\n\t{\n\t\t\r\n\t}",
"@Override\n\tpublic void comer() {\n\t\t\n\t}",
"@Override\n public void perish() {\n \n }",
"@Override\r\n\t\t\tpublic void annadir() {\n\r\n\t\t\t}",
"@Override\n\tpublic void anular() {\n\n\t}",
"@Override\n\tprotected void getExr... | [
"0.6671074",
"0.6567672",
"0.6523024",
"0.6481211",
"0.6477082",
"0.64591026",
"0.64127725",
"0.63762105",
"0.6276059",
"0.6254286",
"0.623686",
"0.6223679",
"0.6201336",
"0.61950207",
"0.61950207",
"0.61922914",
"0.6186996",
"0.6173591",
"0.61327106",
"0.61285484",
"0.608016... | 0.0 | -1 |
TODO Autogenerated method stub | private void info3(int i) {
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"@Override\r\n\tpublic void comer() \r\n\t{\n\t\t\r\n\t}",
"@Override\n\tpublic void comer() {\n\t\t\n\t}",
"@Override\n public void perish() {\n \n }",
"@Override\r\n\t\t\tpublic void annadir() {\n\r\n\t\t\t}",
"@Override\n\tpublic void anular() {\n\n\t}",
"@Override\n\tprotected void getExr... | [
"0.66708666",
"0.65675074",
"0.65229905",
"0.6481001",
"0.64770633",
"0.64584893",
"0.6413091",
"0.63764185",
"0.6275735",
"0.62541914",
"0.6236919",
"0.6223816",
"0.62017626",
"0.61944294",
"0.61944294",
"0.61920846",
"0.61867654",
"0.6173323",
"0.61328775",
"0.61276996",
"0... | 0.0 | -1 |
Invoked when an action occurs. | @Override
public void actionPerformed(ActionEvent e) {
if (e.getActionCommand() == "button1"){
JOptionPane.showMessageDialog(null,"Button1 hit");
}else {
JOptionPane.showMessageDialog(null,"Button2 hit");
}
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"@Override\n\tpublic void action() {\n\t\tSystem.out.println(\"action now!\");\n\t}",
"public abstract void onAction();",
"public void action() {\n action.action();\n }",
"@Override\n public void action() {\n }",
"@Override\n public void action() {\n }",... | [
"0.7907701",
"0.7775921",
"0.7644247",
"0.76119846",
"0.76119846",
"0.76119846",
"0.751699",
"0.74891174",
"0.74193674",
"0.7412826",
"0.7402896",
"0.738321",
"0.7359403",
"0.7359403",
"0.73438245",
"0.73412704",
"0.73412704",
"0.73412704",
"0.73412704",
"0.73412704",
"0.7341... | 0.0 | -1 |
Created by balaji on 1/1/18. | public interface Calculator {
long add(int number1, int number2);
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"@Override\n public void perish() {\n \n }",
"@Override\n\tpublic void grabar() {\n\t\t\n\t}",
"@Override\n\tpublic void comer() {\n\t\t\n\t}",
"@Override\n public void func_104112_b() {\n \n }",
"@Override\r\n\tpublic void bicar() {\n\t\t\r\n\t}",
"@Override\r\n\tpublic void bic... | [
"0.5928732",
"0.58210576",
"0.5817531",
"0.5801082",
"0.57672226",
"0.57672226",
"0.5766683",
"0.5732634",
"0.5708449",
"0.5680293",
"0.5671327",
"0.56616294",
"0.56525534",
"0.5635601",
"0.5601708",
"0.55991346",
"0.55955267",
"0.5586667",
"0.55818415",
"0.5581494",
"0.55716... | 0.0 | -1 |
Use MuleClient to test Remote Server by RemoteDispatcher tcp://ip:port on vm://vmQueueObjectArray | public final void testCall() throws Exception
{
Logger.getLogger(this.getClass()).info("waiting for Remote message...");
Logger.getLogger(this.getClass()).info("press enter to shutdown server");
//TODO raffaele.picardi: report this class out of this test and remain only Monitor.onWait for itnegration test
// Monitor.waitOn(WAIT);
//Init section to transfer in External system
UMOMessage result=null;
MuleClient client;
while (true) {
try {
client = new MuleClient();
RemoteDispatcher rd = client.getRemoteDispatcher(MessagesTest.getString("EHelloServiceObjectArrayTest.10")); //$NON-NLS-1$
/* SoapMethod method = new SoapMethod(new QName("", Messages.getString("SOAP_METHOD_NAME")));
method.addNamedParameter(new QName( Messages.getString("NAMED_PARAMETER")), new javax.xml.namespace.QName( Messages.getString("SERVICE_NAMESPACE_URI"), Messages.getString("RETURN_QNAME")), "in");
method.setReturnType( new javax.xml.namespace.QName(Messages.getString("SERVICE_NAMESPACE_URI"), Messages.getString("RETURN_QTYPE_NAME")));
method.setReturnClass(Class.forName(Messages.getString("RETURN_CLASSNAME")));
*/
Map props = new HashMap();
props.put("style", "wrapped");
props.put("use", "literal");
//props.put(MuleProperties.MULE_SOAP_METHOD, method);
props.put("resourceKey", MessagesTest.getString("RESOURCE_KEY"));
props.put(WSRFParameter.SERVICE_NAMESPACE , MessagesTest.getString("SERVICE_NAMESPACE_URI"));
props.put(WSRFParameter.RESOURCE_KEY_NAME , MessagesTest.getString("RESOURCE_KEY_NAME"));
props.put(WSRFParameter.RETURN_QNAME, MessagesTest.getString("RETURN_QNAME"));
/* props.put(WSRFParameter.RETURN_QTYPE, new javax.xml.namespace.QName(Messages.getString("SERVICE_NAMESPACE_URI"), Messages.getString("RETURN_QTYPE_NAME")));
props.put(WSRFParameter.RETURN_QTYPE, new javax.xml.namespace.QName(Messages.getString("SERVICE_NAMESPACE_URI"), Messages.getString("RETURN_QTYPE_NAME")));
props.put(WSRFParameter.RETURN_QTYPE, new javax.xml.namespace.QName(Messages.getString("SERVICE_NAMESPACE_URI"), Messages.getString("RETURN_QTYPE_NAME")));
*/
props.put(WSRFParameter.RETURN_CLASS, Class.forName(MessagesTest.getString("RETURN_CLASSNAME")));
props.put(WSRFParameter.SOAP_ACTION_URI, MessagesTest.getString("SOAP_ACTION_URI"));
result = rd.sendRemote("vm://vmQueue", new Integer(2), props);
//result = rd.sendRemote(Messages.getString("EHelloServiceObjectArrayTest.11"),"", null); //$NON-NLS-1$
//logger.info(this, "invoke done.",""); //$NON-NLS-1$
System.out.println("invoke done.");
Thread.sleep(5000);
}
catch (UMOException e)
{
e.printStackTrace();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
finally
{
if (result != null)
{
System.out.println(result.getPayload().toString()); //$NON-NLS-1$
}
else
{
System.out.println("result is null");
}
}
//end section to transfer in External system
}
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public static void testIBMMQSendData(){\n\n MQParam param = new MQParam();\n param.setHost(\"10.86.92.194\");\n param.setPort(30099);\n param.setCcsid(1208);\n param.setChannel(\"SVRCONN_GW_OUT\");\n param.setQueueManager(\"ESB_OUT\");\n param.setQueueName(\"EIS.QUE... | [
"0.5561779",
"0.5441916",
"0.5382026",
"0.5346336",
"0.53033227",
"0.51517385",
"0.509908",
"0.5078192",
"0.5058452",
"0.5036253",
"0.49921036",
"0.49840853",
"0.497542",
"0.49642807",
"0.49260762",
"0.48742917",
"0.48723045",
"0.4872036",
"0.48556796",
"0.484779",
"0.4835328... | 0.71026 | 0 |
Test to make sure the "direct" raster path and the "nondirect" raster path produce matching results. This test was originally created after fixes to GEOS7270 where there were issues with images generated during the direct raster path but not in the normal path, stemming from not setting the background color the same way | @Test
public void testDirectVsNonDirectRasterRender() throws Exception {
Catalog catalog = getCatalog();
CoverageInfo ci = catalog.getCoverageByName(MULTIBAND.getPrefix(), MULTIBAND.getLocalPart());
final Envelope env = ci.boundingBox();
RenderedImageMapOutputFormatTest.LOGGER.info(("about to create map ctx for BasicPolygons with bounds " + env));
GetMapRequest request = new GetMapRequest();
CoordinateReferenceSystem crs = DefaultGeographicCRS.WGS84;
ReferencedEnvelope bbox = new ReferencedEnvelope(new Envelope((-116.90673461649858), (-114.30988665660261), 32.070937282184026, 33.8903284734844), crs);
request.setBbox(bbox);
request.setSRS("urn:x-ogc:def:crs:EPSG:4326");
request.setFormat("image/png");
final WMSMapContent map = new WMSMapContent(request);
map.setMapWidth(300);
map.setMapHeight(300);
map.setBgColor(Color.red);
map.setTransparent(false);
map.getViewport().setBounds(bbox);
StyleBuilder builder = new StyleBuilder();
GridCoverage2DReader reader = ((GridCoverage2DReader) (ci.getGridCoverageReader(null, null)));
reader.getCoordinateReferenceSystem();
Layer l = new org.geoserver.wms.CachedGridReaderLayer(reader, builder.createStyle(builder.createRasterSymbolizer()));
map.addLayer(l);
RenderedImageMap imageMap = this.rasterMapProducer.produceMap(map);
ImageAssert.assertEquals(new File("src/test/resources/org/geoserver/wms/map/direct-raster-expected.tif"), imageMap.getImage(), 0);
imageMap.dispose();
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public static void assertRasterEquals(final GridCoverage expected, final GridCoverage actual) {\n assertNotNull(\"Expected coverage\", expected);\n assertNotNull(\"Actual coverage\", actual);\n Assert.assertRasterEquals(expected.render(null),\n actual.render(null));... | [
"0.56471324",
"0.555498",
"0.54241383",
"0.5369739",
"0.5354094",
"0.5311355",
"0.5302043",
"0.51695925",
"0.5134436",
"0.51311237",
"0.51260793",
"0.51177794",
"0.5109101",
"0.5098306",
"0.50854325",
"0.50820696",
"0.50605255",
"0.5050033",
"0.5044693",
"0.5036499",
"0.50338... | 0.692601 | 0 |
Test to check if we can successfully create a direct rendered image by using a coverage view as a source, and a symbolizer defining which three bands of the input coverage view can be used for RGB coloring, and with what order. | @Test
public void testStyleUsingChannelsFromCoverageView() throws Exception {
GetMapRequest request = new GetMapRequest();
CoordinateReferenceSystem crs = DefaultGeographicCRS.WGS84;
ReferencedEnvelope bbox = new ReferencedEnvelope(new Envelope((-116.90673461649858), (-114.30988665660261), 32.070937282184026, 33.8903284734844), crs);
request.setBbox(bbox);
request.setSRS("urn:x-ogc:def:crs:EPSG:4326");
request.setFormat("image/png");
final WMSMapContent map = new WMSMapContent(request);
map.setMapWidth(300);
map.setMapHeight(300);
map.setTransparent(false);
map.getViewport().setBounds(bbox);
StyleBuilder styleBuilder = new StyleBuilder();
Catalog catalog = getCatalog();
// Source image
CoverageInfo ci = catalog.getCoverageByName(MULTIBAND.getPrefix(), MULTIBAND.getLocalPart());
GridCoverage2DReader reader = ((GridCoverage2DReader) (ci.getGridCoverageReader(null, null)));
reader.getCoordinateReferenceSystem();
Layer sl = new org.geoserver.wms.CachedGridReaderLayer(reader, styleBuilder.createStyle(styleBuilder.createRasterSymbolizer()));
map.addLayer(sl);
RenderedImageMap srcImageMap = this.rasterMapProducer.produceMap(map);
RenderedImage srcImage = srcImageMap.getImage();
// CoverageView band creation. We create a coverage view with 6 bands, using
// the original bands from the multiband coverage
// Note that first three bands are int reverse order of the bands of the source coverage
final InputCoverageBand ib0 = new InputCoverageBand("multiband", "2");
final CoverageBand b0 = new CoverageBand(Collections.singletonList(ib0), "multiband@2", 0, CompositionType.BAND_SELECT);
final InputCoverageBand ib1 = new InputCoverageBand("multiband", "1");
final CoverageBand b1 = new CoverageBand(Collections.singletonList(ib1), "multiband@1", 1, CompositionType.BAND_SELECT);
final InputCoverageBand ib2 = new InputCoverageBand("multiband", "0");
final CoverageBand b2 = new CoverageBand(Collections.singletonList(ib2), "multiband@0", 2, CompositionType.BAND_SELECT);
final InputCoverageBand ib3 = new InputCoverageBand("multiband", "0");
final CoverageBand b3 = new CoverageBand(Collections.singletonList(ib3), "multiband@0", 0, CompositionType.BAND_SELECT);
final InputCoverageBand ib4 = new InputCoverageBand("multiband", "1");
final CoverageBand b4 = new CoverageBand(Collections.singletonList(ib4), "multiband@1", 1, CompositionType.BAND_SELECT);
final InputCoverageBand ib5 = new InputCoverageBand("multiband", "2");
final CoverageBand b5 = new CoverageBand(Collections.singletonList(ib5), "multiband@2", 2, CompositionType.BAND_SELECT);
final List<CoverageBand> coverageBands = new ArrayList<CoverageBand>(1);
coverageBands.add(b0);
coverageBands.add(b1);
coverageBands.add(b2);
coverageBands.add(b3);
coverageBands.add(b4);
coverageBands.add(b5);
CoverageView multiBandCoverageView = new CoverageView("multiband_select", coverageBands);
CoverageStoreInfo storeInfo = catalog.getCoverageStoreByName("multiband");
CatalogBuilder builder = new CatalogBuilder(catalog);
// Reordered bands coverage
CoverageInfo coverageInfo = multiBandCoverageView.createCoverageInfo("multiband_select", storeInfo, builder);
coverageInfo.getParameters().put("USE_JAI_IMAGEREAD", "false");
catalog.add(coverageInfo);
final LayerInfo layerInfoView = builder.buildLayer(coverageInfo);
catalog.add(layerInfoView);
final Envelope env = ci.boundingBox();
RenderedImageMapOutputFormatTest.LOGGER.info(("about to create map ctx for BasicPolygons with bounds " + env));
RasterSymbolizer symbolizer = styleBuilder.createRasterSymbolizer();
ChannelSelection cs = new ChannelSelectionImpl();
SelectedChannelType red = new SelectedChannelTypeImpl();
SelectedChannelType green = new SelectedChannelTypeImpl();
SelectedChannelType blue = new SelectedChannelTypeImpl();
// We want to create an image where the RGB channels are in reverse order
// regarding the band order of the input coverage view
// Note that channel names start with index "1"
red.setChannelName("3");
green.setChannelName("2");
blue.setChannelName("1");
cs.setRGBChannels(new SelectedChannelType[]{ red, green, blue });
symbolizer.setChannelSelection(cs);
reader = ((GridCoverage2DReader) (coverageInfo.getGridCoverageReader(null, null)));
reader.getCoordinateReferenceSystem();
Layer dl = new org.geoserver.wms.CachedGridReaderLayer(reader, styleBuilder.createStyle(symbolizer));
map.removeLayer(sl);
map.addLayer(dl);
RenderedImageMap dstImageMap = this.rasterMapProducer.produceMap(map);
RenderedImage destImage = dstImageMap.getImage();
int dWidth = destImage.getWidth();
int dHeight = destImage.getHeight();
int[] destImageRowBand0 = new int[dWidth * dHeight];
int[] destImageRowBand1 = new int[destImageRowBand0.length];
int[] destImageRowBand2 = new int[destImageRowBand0.length];
destImage.getData().getSamples(0, 0, dWidth, dHeight, 0, destImageRowBand0);
destImage.getData().getSamples(0, 0, dWidth, dHeight, 1, destImageRowBand1);
destImage.getData().getSamples(0, 0, dWidth, dHeight, 2, destImageRowBand2);
int sWidth = srcImage.getWidth();
int sHeight = srcImage.getHeight();
int[] srcImageRowBand0 = new int[sWidth * sHeight];
int[] srcImageRowBand2 = new int[srcImageRowBand0.length];
srcImage.getData().getSamples(0, 0, sWidth, sHeight, 0, srcImageRowBand0);
// Source and result image first bands should be the same. We have reversed the order
// of the three first bands of the source coverage and then we re-reversed the three
// first bands using channel selection on the raster symbolizer used for rendering.
Assert.assertTrue(Arrays.equals(destImageRowBand0, srcImageRowBand0));
// Result band 0 should not be equal to source image band 2
Assert.assertFalse(Arrays.equals(destImageRowBand0, srcImageRowBand2));
srcImageMap.dispose();
dstImageMap.dispose();
map.dispose();
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"@Test\n public void testTwoIndexedSameNoData() {\n IndexColorModel icm = buildIndexColorModel(Color.BLUE, Color.RED);\n BufferedImage splitVertical = new BufferedImage(100, 100, BufferedImage.TYPE_BYTE_INDEXED,\n icm);\n Graphics2D gr = splitVertical.createGraphics();\n ... | [
"0.5562243",
"0.5547472",
"0.551372",
"0.54642",
"0.5460175",
"0.5442115",
"0.5434388",
"0.5411617",
"0.5402052",
"0.5377077",
"0.5373975",
"0.53683376",
"0.52822053",
"0.52795583",
"0.52642673",
"0.5242987",
"0.521453",
"0.52132744",
"0.5174643",
"0.5167812",
"0.5143336",
... | 0.6738903 | 0 |
Test to make sure the rendering does not skip on unmatched original envelope and tries anyways to render an output | @Test
public void testMosaicExpansion() throws Exception {
File red1 = URLs.urlToFile(this.getClass().getResource("red_footprint_test/red1.tif"));
File source = red1.getParentFile();
File testDataDir = getResourceLoader().getBaseDirectory();
File directory1 = new File(testDataDir, "redHarvest1");
File directory2 = new File(testDataDir, "redHarvest2");
if (directory1.exists()) {
FileUtils.deleteDirectory(directory1);
}
FileUtils.copyDirectory(source, directory1);
// move all files except red3 to the second dir
directory2.mkdirs();
for (File file : FileUtils.listFiles(directory1, new RegexFileFilter("red[^3].*"), null)) {
Assert.assertTrue(file.renameTo(new File(directory2, file.getName())));
}
// create the first reader
URL harvestSingleURL = URLs.fileToUrl(directory1);
ImageMosaicReader reader = new ImageMosaicReader(directory1, null);
// now create a second reader that won't be informed of the harvesting changes
// (simulating changes over a cluster, where the bbox information won't be updated from one
// node to the other)
ImageMosaicReader reader2 = new ImageMosaicReader(directory1, null);
try {
// harvest the other files with the first reader
for (File file : directory2.listFiles()) {
Assert.assertTrue(file.renameTo(new File(directory1, file.getName())));
}
reader.harvest(null, directory1, null);
// now use the render to paint a map not hitting the original envelope of reader2
ReferencedEnvelope renderEnvelope = new ReferencedEnvelope(991000, 992000, 216000, 217000, reader2.getCoordinateReferenceSystem());
Rectangle rasterArea = new Rectangle(0, 0, 10, 10);
GetMapRequest request = new GetMapRequest();
request.setBbox(renderEnvelope);
request.setSRS("EPSG:6539");
request.setFormat("image/png");
final WMSMapContent map = new WMSMapContent(request);
map.setMapWidth(10);
map.setMapHeight(10);
map.setBgColor(Color.BLACK);
map.setTransparent(false);
map.getViewport().setBounds(renderEnvelope);
StyleBuilder builder = new StyleBuilder();
Style style = builder.createStyle(builder.createRasterSymbolizer());
Layer l = new org.geoserver.wms.CachedGridReaderLayer(reader2, style);
map.addLayer(l);
RenderedImageMap imageMap = this.rasterMapProducer.produceMap(map);
File reference = new File("src/test/resources/org/geoserver/wms/map/red10.png");
ImageAssert.assertEquals(reference, imageMap.getImage(), 0);
// now again, but with a rendering transformation, different code path
style.featureTypeStyles().get(0).setTransformation(new IdentityCoverageFunction());
RenderedImageMap imageMap2 = this.rasterMapProducer.produceMap(map);
ImageAssert.assertEquals(reference, imageMap2.getImage(), 0);
imageMap.dispose();
} finally {
reader.dispose();
reader2.dispose();
}
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"@Test(expected = java.io.IOException.class)\n\tpublic void testRenderMergedOutputModel_4()\n\t\tthrows Exception {\n\t\tRedirectView fixture = new RedirectView(\"\", true, true);\n\t\tfixture.setUrl(\"/\");\n\t\tfixture.setEncodingScheme(\"\");\n\t\tMap model = new LinkedHashMap();\n\t\tHttpServletRequest request ... | [
"0.572113",
"0.56976545",
"0.56803936",
"0.56707436",
"0.55988324",
"0.5449863",
"0.5433896",
"0.53644454",
"0.5352272",
"0.53061235",
"0.52097064",
"0.5192597",
"0.5132681",
"0.5126943",
"0.5119177",
"0.5094052",
"0.5069992",
"0.5063462",
"0.5063462",
"0.5063462",
"0.5063462... | 0.0 | -1 |
Set is a list of unique items... no duplication. I can have a product with an id but I can't have the same product with another id, I can change the quantity of the product, or some of its attributes | public long getCustomerId() {
return customerId;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"@Override\n public int hashCode() {\n return Objects.hash(product, quantity);\n }",
"private Set<Product> getProductSet(Product product) {\n\t\treturn get(product.getType(), product.getState(), product.getItemId());\n\t}",
"public static void main(String[] args) {\n Set<Integer> S1 = new TreeSet<>(... | [
"0.6531059",
"0.62906134",
"0.61590517",
"0.6105416",
"0.6045634",
"0.60320777",
"0.5944286",
"0.5903926",
"0.59013516",
"0.5886527",
"0.5881008",
"0.5841194",
"0.57838494",
"0.57817155",
"0.5759256",
"0.57381845",
"0.5732497",
"0.57072246",
"0.56951624",
"0.56630945",
"0.565... | 0.0 | -1 |
/ renamed from: tm reason: default package / compiled from: GoRoutePageListener | public interface tm<T, V> {
void a(V v);
void a(boolean z);
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public interface RouterListener {\n /**\n * Notification method to be invoked from CLI if a router changes\n * his states (becomes available/unavailable).\n *\n * @param routerName router name\n * @param available true/false\n */\n public void onRouterEvent(String routerName, boolean... | [
"0.57247174",
"0.54991394",
"0.5497859",
"0.5497859",
"0.5440424",
"0.5362493",
"0.53451025",
"0.5277411",
"0.5256582",
"0.5255934",
"0.5228819",
"0.51849365",
"0.51835316",
"0.51561385",
"0.51403165",
"0.5119282",
"0.50910187",
"0.5073891",
"0.5066348",
"0.5064031",
"0.50618... | 0.0 | -1 |
/ public javaart.create_class_instance_by_5_methods.Book(); Code: 0: aload_0 1: invokespecial 1 // Method java/lang/Object."":()V 4: return | public Book(String name, int pages, int date, String type) {
this.name = name;
this.pages = pages;
this.date = date;
this.type = type;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public static void main(String[] arguments){\n Book AtlasShrugged = new Book(\"Atlas Shrugged\");\n// Book HungerGames = new Book(\"Hunger Games\");\n// CatinHat.WhatBook();\n AtlasShrugged.WhatBook();\n AtlasShrugged.CheckAvailable();\n// CatinHat.CheckAvailable();\n// HungerGames.CheckAvaila... | [
"0.6247805",
"0.620454",
"0.58636916",
"0.584826",
"0.578653",
"0.57515764",
"0.5712413",
"0.56226736",
"0.56154644",
"0.5605853",
"0.56054133",
"0.55918604",
"0.5571666",
"0.5558799",
"0.555388",
"0.555388",
"0.55409706",
"0.55239636",
"0.5510034",
"0.54874283",
"0.54851186"... | 0.0 | -1 |
/ public javaart.create_class_instance_by_5_methods.Book(java.lang.String, int, int, java.lang.String); Code: 0: aload_0 1: invokespecial 1 // Method java/lang/Object."":()V 4: aload_0 5: aload_1 6: putfield 2 // Field name:Ljava/lang/String; 9: aload_0 10: iload_2 11: putfield 3 // Field pages:I 14: aload_0 15: iload_3 16: putfield 4 // Field date:I 19: aload_0 20: aload 4 22: putfield 5 // Field type:Ljava/lang/String; 25: return | public String getName() {
return name;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public Method(String name, String desc) {\n/* 82 */ this.name = name;\n/* 83 */ this.desc = desc;\n/* */ }",
"Book createBook();",
"public Book() {\n this.bookName = \"Five Point Someone\";\n this.bookAuthorName = \"Chetan Bhagat\";\n this.bookIsbnNumber = \"9788129104595\"... | [
"0.5974858",
"0.5948454",
"0.5841124",
"0.579659",
"0.5746668",
"0.57299656",
"0.5559946",
"0.5557512",
"0.55316275",
"0.551686",
"0.54956055",
"0.54548967",
"0.5421942",
"0.5417119",
"0.5380808",
"0.5344206",
"0.53383315",
"0.53360856",
"0.5316877",
"0.5310093",
"0.53081304"... | 0.0 | -1 |
/ public java.lang.String getSignalName(); Code: 0: aload_0 1: getfield 2 // Field name:Ljava/lang/String; 4: areturn | public void setName(String name) {
this.name = name;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"java.lang.String getSignal();",
"public String getSignalName(int index);",
"public java.lang.String getSignal() {\n java.lang.Object ref = signal_;\n if (ref instanceof java.lang.String) {\n return (java.lang.String) ref;\n } else {\n com.google.protobuf.ByteString bs = \n ... | [
"0.724697",
"0.71326935",
"0.6898097",
"0.6854777",
"0.6652825",
"0.65187097",
"0.65113944",
"0.6460522",
"0.64352506",
"0.62606317",
"0.6256554",
"0.6217995",
"0.61880726",
"0.6180401",
"0.61642873",
"0.6131155",
"0.6130617",
"0.611745",
"0.6116642",
"0.6097398",
"0.6095963"... | 0.0 | -1 |
/ public void setSignalName(java.lang.String); Code: 0: aload_0 1: aload_1 2: putfield 2 // Field name:Ljava/lang/String; 5: return | public int getPages() {
return pages;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public Builder setSignal(\n java.lang.String value) {\n if (value == null) {\n throw new NullPointerException();\n }\n bitField0_ |= 0x00020000;\n signal_ = value;\n onChanged();\n return this;\n }",
"public void setName(String name)\n/* */ {\n/* 84 */ th... | [
"0.6774108",
"0.6447041",
"0.64104307",
"0.63821834",
"0.637256",
"0.6250107",
"0.62300503",
"0.6192945",
"0.6178019",
"0.6158047",
"0.61237305",
"0.61237305",
"0.61237305",
"0.61138695",
"0.61075383",
"0.6084698",
"0.60731345",
"0.60718",
"0.60645026",
"0.6045492",
"0.604403... | 0.0 | -1 |
/ public int getPages(); Code: 0: aload_0 1: getfield 3 // Field pages:I 4: ireturn | public void setPages(int pages) {
this.pages = pages;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public int getPages()\n {\n return pages;\n }",
"public int getPages() {\n return pages;\n }",
"public int getPages(){\n return pages;\n }",
"Pages getPages();",
"int getPagesAmount();",
"public int getPages() {\n return pages;\n }",
"public int getPages() {\n ... | [
"0.7723648",
"0.76646066",
"0.7660696",
"0.76224303",
"0.7499715",
"0.7496874",
"0.7496874",
"0.7305816",
"0.7287281",
"0.7230891",
"0.68642634",
"0.6842185",
"0.682082",
"0.67524797",
"0.6727606",
"0.65794617",
"0.654052",
"0.654052",
"0.654052",
"0.654052",
"0.6509123",
"... | 0.6042988 | 48 |
/ public void setPages(int); Code: 0: aload_0 1: iload_1 2: putfield 3 // Field pages:I 5: return | public int getDate() {
return date;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public void setPages(int pages) {\n this.pages = pages;\n }",
"public void setPages(int pages) {\n this.pages = pages;\n }",
"public void setPage(int value) {\n this.page = value;\n }",
"public Set getPages () {\n return pages;\n }",
"public void setPage(Page page)... | [
"0.77441",
"0.7642619",
"0.6956056",
"0.6827284",
"0.6748042",
"0.67463595",
"0.6685768",
"0.6580491",
"0.6578234",
"0.64792717",
"0.6396742",
"0.6314143",
"0.6314143",
"0.6301009",
"0.62095314",
"0.6176032",
"0.6176032",
"0.61533946",
"0.6062585",
"0.6045681",
"0.5996458",
... | 0.0 | -1 |
Gets the list of average fitness scores for each generation. The index of each entry corresponds to the generation number minus one. | public ArrayList<Double> getAverageFitnesses() { return avgFitnesses; } | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public double getAvgPopulationFitness() {\n\t\tdouble sum=0;\n\t\tfor (int i = 0; i < individuals.length; i++) {\n\t\t\tsum+=individuals[i].getFitness();\n\t\t}\n\t\treturn sum/(double)individuals.length;\n\t}",
"public double getGradeAverage() {\n int gradesTotal = 0;\n for (int grade : grades) {\... | [
"0.65770787",
"0.6502318",
"0.6312537",
"0.62453073",
"0.6213012",
"0.6203028",
"0.61342007",
"0.6119096",
"0.6113729",
"0.6092723",
"0.6010432",
"0.5892354",
"0.58863103",
"0.58806336",
"0.5876923",
"0.585288",
"0.5843406",
"0.58305204",
"0.5747856",
"0.5732025",
"0.57287425... | 0.55541503 | 36 |
Gets the list of highest fitness scores found for each generation. The index of each entry corresponds to the generation number minus one. | public ArrayList<Double> getHighestFitnesses() { return highFitnesses; } | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public float getHighestFitness() {\r\n\t\treturn highestScore;\r\n\t}",
"private static void getFitness() {\n\t\tint popSize = population.size();\n\t\tChromosome thisChromo = null;\n\t\tdouble bestScore = 0;\n\t\tdouble worstScore = 0;\n\n\t\t// The worst score would be the one with the highest energy, best woul... | [
"0.6641527",
"0.66082925",
"0.65484333",
"0.6459164",
"0.6425596",
"0.6356277",
"0.62394387",
"0.60545844",
"0.60004616",
"0.59384745",
"0.593594",
"0.59330046",
"0.59100413",
"0.5883253",
"0.58789784",
"0.58717155",
"0.5853535",
"0.58200884",
"0.5819476",
"0.5809736",
"0.574... | 0.5852693 | 17 |
Gets the probability of crossover. | public static double getCrossoverProbability() { return crossoverProbability; } | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public float getProbCross () {\r\n return cross_prob;\r\n }",
"public static void setCrossoverProbability(double value) { crossoverProbability = value; }",
"public int getCrossoverPoints() {\n\t\treturn 1;\r\n\t}",
"public int nPercentileCrossover(){\n if(!this.monteCarloDone)this.monteCarlo... | [
"0.7559638",
"0.72415245",
"0.6996236",
"0.6798722",
"0.6459056",
"0.6237282",
"0.61431944",
"0.59189993",
"0.5798485",
"0.5791319",
"0.56945807",
"0.56478596",
"0.56339604",
"0.55289036",
"0.55258083",
"0.54963726",
"0.5478085",
"0.54295754",
"0.5429299",
"0.54200816",
"0.54... | 0.87063354 | 0 |
Sets the crossover probability. | public static void setCrossoverProbability(double value) { crossoverProbability = value; } | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public void setProbCross (float value) {\r\n cross_prob = value;\r\n }",
"public static double getCrossoverProbability() { return crossoverProbability; }",
"public void origCrossover() {\n\n ArrayList<Integer> crossPoints;\n\n // Perform crossover with probability Defines.PROB_CROSSOVER... | [
"0.75608313",
"0.68994445",
"0.6577615",
"0.6538651",
"0.6507472",
"0.60021603",
"0.5968832",
"0.5930447",
"0.59264904",
"0.59002817",
"0.5892742",
"0.5839167",
"0.5821907",
"0.567351",
"0.5620685",
"0.5582957",
"0.5480596",
"0.53762776",
"0.52503663",
"0.52398133",
"0.523398... | 0.88332653 | 0 |
Gets the probability of mutation. | public static double getMutationProbability() { return mutationProbability; } | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public float getProbMut () {\r\n return mut_prob;\r\n }",
"public double getProbability() {\n return probability;\n }",
"public double getProbability() {\r\n\t\treturn Probability;\r\n\t}",
"public static void setMutationProbability(double value) { mutationProbability = value; }",
"publ... | [
"0.76699305",
"0.7411026",
"0.7081902",
"0.69713616",
"0.68518466",
"0.67429256",
"0.6634567",
"0.6627757",
"0.6548154",
"0.6487983",
"0.64162487",
"0.63524365",
"0.6213081",
"0.61739993",
"0.61709726",
"0.615252",
"0.6120002",
"0.6112103",
"0.60881066",
"0.6078831",
"0.60582... | 0.8259988 | 0 |
Sets the mutation probability. | public static void setMutationProbability(double value) { mutationProbability = value; } | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public void setProbMut (float value) {\r\n mut_prob= value;\r\n }",
"public void setProbMut(double d){\n if ((d < 0) || (d > 1)){\n throw new IllegalArgumentException(\"Mutation probability cannot be less than 0 or greater than 1.\");\n }\n mutationProb = d;\n }",
"@Override\r\n\tpubli... | [
"0.76518136",
"0.7650244",
"0.72454077",
"0.6950708",
"0.6488851",
"0.6453925",
"0.64409536",
"0.6440413",
"0.63980436",
"0.6242966",
"0.6134654",
"0.6130618",
"0.60675067",
"0.6067467",
"0.6037516",
"0.5971806",
"0.59320116",
"0.5895231",
"0.5778212",
"0.5762223",
"0.5749305... | 0.8574286 | 0 |
Gets the number of maximum generations in each run. | public int getMaxGenerations() { return maxGenerations; } | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"int getMaximalIterationCount();",
"protected int get_max_iter() {\n\t\treturn iterationsMaximum;\n\t}",
"public final int getMaxIterations()\r\n\t{\r\n\t\treturn maxIterations;\r\n\t}",
"public void setMaxGenerations(int value) { maxGenerations = value; }",
"@Override\n\tpublic int getMaxIterations() {\n\t... | [
"0.73700464",
"0.71817327",
"0.71733254",
"0.70247704",
"0.7023468",
"0.6996975",
"0.6996975",
"0.694638",
"0.6904866",
"0.6904866",
"0.6898421",
"0.6884361",
"0.68691814",
"0.6849113",
"0.6663361",
"0.66512376",
"0.6617891",
"0.6593703",
"0.6588903",
"0.65854985",
"0.6554912... | 0.8200335 | 0 |
Sets the maximum number of generations per run. | public void setMaxGenerations(int value) { maxGenerations = value; } | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public void setMaxIterations(int number) {\r\n if (number < CurrentIteration) {\r\n throw new Error(\"Cannot be lower than the current iteration.\");\r\n }\r\n MaxIteration = number;\r\n Candidates.ensureCapacity(MaxIteration);\r\n }",
"public int getMaxGenerations() { r... | [
"0.7271038",
"0.7204827",
"0.7177446",
"0.7148762",
"0.7148762",
"0.7061572",
"0.68838185",
"0.6744752",
"0.6739151",
"0.67387456",
"0.67143035",
"0.6659836",
"0.66490644",
"0.65603876",
"0.6544072",
"0.6543032",
"0.65364367",
"0.6484324",
"0.6450201",
"0.6424511",
"0.6423679... | 0.88064414 | 0 |
Creates a new genetic engine with default values and no population. | public GeneticEngine() {
avgFitnesses = new ArrayList<Double>();
highFitnesses = new ArrayList<Double>();
population = null;
crossoverProbability = 0.07;
mutationProbability = 0.001;
maxGenerations = Integer.MAX_VALUE;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public Genetic() {\r\n }",
"public Guppy() {\n this(DEFAULT_GENUS, DEFAULT_SPECIES, 0, true, 0,\n DEFAULT_HEALTH_COEFFICIENT);\n }",
"public GeneticEngine(int popSize, int maxGen, int chromosomeLength) {\n avgFitnesses = new ArrayList<Double>();\n highFitnesses = new A... | [
"0.70761263",
"0.64537066",
"0.6396623",
"0.62220645",
"0.6169256",
"0.5935765",
"0.5914046",
"0.5851614",
"0.58377075",
"0.5737698",
"0.5723978",
"0.5675133",
"0.56557554",
"0.5649991",
"0.5629246",
"0.5623635",
"0.5579655",
"0.5530974",
"0.5521417",
"0.54981244",
"0.5488102... | 0.7719474 | 0 |
Creates a new genetic engine. | public GeneticEngine(int popSize, double crossoverRate,
double mutationRate, int maxGen, int chromosomeLength) {
avgFitnesses = new ArrayList<Double>();
highFitnesses = new ArrayList<Double>();
populationSize = popSize;
crossoverProbability = crossoverRate;
mutationProbability = mutationRate;
maxGenerations = maxGen;
chromosomeSize = chromosomeLength;
initializePopulation();
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public GeneticEngine() {\n avgFitnesses = new ArrayList<Double>();\n highFitnesses = new ArrayList<Double>();\n population = null;\n crossoverProbability = 0.07;\n mutationProbability = 0.001;\n maxGenerations = Integer.MAX_VALUE;\n }",
"public Genetic() {\r\n }",
... | [
"0.6503695",
"0.61801684",
"0.61295015",
"0.5604171",
"0.5595854",
"0.5568758",
"0.55376774",
"0.5529963",
"0.55271775",
"0.5515152",
"0.55031335",
"0.54652244",
"0.5461561",
"0.54511535",
"0.5402805",
"0.5398136",
"0.5352323",
"0.5313883",
"0.5308805",
"0.52984333",
"0.52734... | 0.5460583 | 13 |
Creates a new genetic engine. | public GeneticEngine(int popSize, int maxGen, int chromosomeLength) {
avgFitnesses = new ArrayList<Double>();
highFitnesses = new ArrayList<Double>();
populationSize = popSize;
maxGenerations = maxGen;
chromosomeSize = chromosomeLength;
initializePopulation();
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public GeneticEngine() {\n avgFitnesses = new ArrayList<Double>();\n highFitnesses = new ArrayList<Double>();\n population = null;\n crossoverProbability = 0.07;\n mutationProbability = 0.001;\n maxGenerations = Integer.MAX_VALUE;\n }",
"public Genetic() {\r\n }",
... | [
"0.65042233",
"0.61813843",
"0.61318886",
"0.5606636",
"0.5590519",
"0.55648935",
"0.5535998",
"0.55309504",
"0.5529874",
"0.5501122",
"0.5463428",
"0.54625285",
"0.546244",
"0.54519033",
"0.5398963",
"0.53975314",
"0.534858",
"0.53160053",
"0.53058183",
"0.5297734",
"0.52748... | 0.5516438 | 9 |
Sets a random, starting population. | private void initializePopulation() {
// reset the population
population = new ArrayList<Genotype>();
// set the population to an array of random genotypes
for (int i = 0; i < populationSize; i++) {
population.add(new Genotype(chromosomeSize));
}
// evaluate the population
// evaluatePopulation();
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"private void setRand(){\n rand = generator.nextInt(9) + 1;\n }",
"public void setNextGeneration() {\n // create a temporary population\n ArrayList<Genotype> tempPopulation = new ArrayList<Genotype>();\n\n // select mates\n while (tempPopulation.size() < populationSize) {\n ... | [
"0.7183215",
"0.6926208",
"0.6869688",
"0.6695815",
"0.66498756",
"0.662256",
"0.65996337",
"0.6548817",
"0.6515252",
"0.6507657",
"0.64752716",
"0.64133734",
"0.6387521",
"0.63846576",
"0.6371994",
"0.6364717",
"0.63109666",
"0.62786084",
"0.626346",
"0.6240623",
"0.622396",... | 0.6585972 | 7 |
Sets the fitness scores for each member of the population. | public void evaluatePopulation() {
// reset the total fitness score
totalFitness = 0;
for (int i = 0; i < populationSize; i++) {
population.get(i).setRawFitness(
FeederCollection.getFeeders().get(i).GetFitness());
totalFitness += population.get(i).getRawFitness();
}
// set the normalized fitness for each population member
for (Genotype g : population) {
// normalized fitness = raw fitness / total fitness
g.setNormalizedFitness((g.getRawFitness() / totalFitness));
}
// sort the popoulation
Collections.sort(population, Genotype.FitnessOrder);
highFitnesses.add(population.get(0).getRawFitness());
avgFitnesses.add(totalFitness / population.size());
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"void setFitnessScore(double score){\n fitnessScore = score;\n }",
"public void setFitness(float fitness)\r\n\t{\r\n\t\tthis.fitness = fitness;\r\n\t}",
"public void modifyFitness(Population population) {\n // prepare the calculation\n double[][] data = new double[population.size()][];\... | [
"0.7092305",
"0.666054",
"0.64500993",
"0.6299279",
"0.6261554",
"0.6248128",
"0.62275803",
"0.61609584",
"0.6124505",
"0.6107644",
"0.61004734",
"0.6077427",
"0.5988335",
"0.5954946",
"0.5951134",
"0.59190774",
"0.5869766",
"0.5820241",
"0.58129084",
"0.5808236",
"0.57885313... | 0.67514426 | 1 |
Creates the next generation. | public void setNextGeneration() {
// create a temporary population
ArrayList<Genotype> tempPopulation = new ArrayList<Genotype>();
// select mates
while (tempPopulation.size() < populationSize) {
tempPopulation.add(Genotype.Mate(rouletteSelection(),
rouletteSelection(), crossoverProbability));
}
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public void generate() {\n\t}",
"protected abstract void generate();",
"public Order generateNext();",
"public abstract void generate();",
"public int getNextModuleGeneration() {\n return moduleGeneration.incrementAndGet();\n }",
"public NextGeneration(){\n this.born[3] = true;\n ... | [
"0.69206154",
"0.6782394",
"0.66955495",
"0.6597136",
"0.6565528",
"0.65440905",
"0.6535309",
"0.65127957",
"0.63766426",
"0.6239581",
"0.6130879",
"0.6084129",
"0.6075995",
"0.6032806",
"0.6015553",
"0.6011456",
"0.5991895",
"0.5989571",
"0.59842587",
"0.59420556",
"0.589816... | 0.603555 | 13 |
Selects a genotype to mate. | public Genotype rouletteSelection() {
// get a number between 0 and 1 to compare against
double slice = rnd.nextDouble();
// keep track of the cumulative fitness
double cumulativeFitness = 0;
// loop through the population to pick a mate
for (Genotype g : population) {
// increment the cumulative fitness with the member's normalized fitness
cumulativeFitness += g.getNormalizedFitness();
// if the cumulative fitness is greater than the random number,
if (cumulativeFitness > slice) {
// select the member for mating
return g;
}
}
// if no members are chosen, pick the one with the highest fitness score
return population.get(0);
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"private void selectPhenotype(String option) {\r\n if (option.equals(\"null\") || option.equals(currentPhenotype)){\r\n return;\r\n } \r\n \r\n setDatasets((VerifiedSNP) getController().getActiveSNP(), option);\r\n currentPhenotype = option; \r\n }",
... | [
"0.68243843",
"0.5895837",
"0.5697615",
"0.55700105",
"0.5540435",
"0.550514",
"0.5503683",
"0.54929125",
"0.54801005",
"0.54653317",
"0.5415859",
"0.5387952",
"0.5383143",
"0.537406",
"0.5346014",
"0.53310883",
"0.53112626",
"0.53087187",
"0.53047043",
"0.5269277",
"0.523600... | 0.55594605 | 4 |
The interface Sql queries. | public interface SqlQueries {
/**
* The constant QUOTATION.
*/
String QUOTATION = "'";
/**
* The constant SELECT_ALL_CARS.
*/
String SELECT_ALL_CARS = "SELECT * FROM Car";
/**
* The constant SELECT_ALL_USERS.
*/
String SELECT_ALL_USERS = "SELECT * FROM Users";
/**
* The constant FIND_CAR_BY_ID.
*/
String FIND_CAR_BY_ID = "Select * from Car Where id = ";
/**
* The constant CREATE_A_CAR.
*/
String CREATE_A_CAR = "insert into car values({0},{1}, {2}, {3}, {4})";
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"Query query();",
"void runQueries();",
"public List sqlQuery(String sql,Object... params);",
"public abstract ResultList executeSQL(RawQuery rawQuery);",
"private void executeQuery() {\n }",
"public void Query() {\n }",
"public abstract Statement queryToRetrieveData();",
"Query queryOn(Connecti... | [
"0.76181334",
"0.71907836",
"0.7180062",
"0.7147358",
"0.7109294",
"0.7107983",
"0.70573175",
"0.6997007",
"0.69606423",
"0.68606055",
"0.68287224",
"0.6691504",
"0.66481113",
"0.66283643",
"0.6589777",
"0.65719414",
"0.6494637",
"0.6458231",
"0.64520985",
"0.64445895",
"0.64... | 0.7014334 | 7 |
Get button id (service number and price) | @Override
public void onClick(View v) {
int baseId = service1Btn.getId();
switch (v.getId() - baseId){
case 0:
serviceName = service1.getServiceName();
servicePrice = service1.getServicePrice();
break;
case 1:
serviceName = service2.getServiceName();
servicePrice = service2.getServicePrice();
break;
case 2:
serviceName = service3.getServiceName();
servicePrice = service3.getServicePrice();
break;
case 3:
serviceName = service4.getServiceName();
servicePrice = service4.getServicePrice();
break;
case 4:
serviceName = service5.getServiceName();
servicePrice = service5.getServicePrice();
break;
case 5:
serviceName = service6.getServiceName();
servicePrice = service6.getServicePrice();
break;
}
// Send data (service number, professional name, price) to MainActivity
TransferDataToMainActivity();
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public String findButtonId(ActionEvent event) {\n Button buttonObj = (Button) event.getSource();\n return buttonObj.getId();\n }",
"public int getButtonID(){return i_ButtonID;}",
"String getService_id();",
"public String getServiceID();",
"Button getBtn();",
"String getServiceId();",
"... | [
"0.66194326",
"0.6586924",
"0.6322098",
"0.60256505",
"0.59863615",
"0.59298056",
"0.5904654",
"0.5899057",
"0.5816182",
"0.5808063",
"0.5780378",
"0.57650185",
"0.5682425",
"0.56343967",
"0.56262755",
"0.5621849",
"0.5614542",
"0.560797",
"0.55894274",
"0.55873805",
"0.55313... | 0.5992501 | 4 |
Get all service quantity from services list and store into arrayList to transfer data to new activity with intent.putIntegerArrayListExtra() | private ArrayList<Integer> GetAllServiceQuantity(List<Services> services){
// Create new empty arrayList of service quantity
ArrayList<Integer> tmp = new ArrayList<Integer>();
// Loop though services list and add service quantity to tmp arraylist
for(Services service : services){
tmp.add(service.getServiceQuantity());
}
return tmp;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public void fetchServices() {\n serviciosTotales.clear();\n for (String serviceId : serviceList) {\n databaseServiceReference.child(serviceId).addListenerForSingleValueEvent(new ValueEventListener() {\n @Override\n public void onDataChange(@NonNull DataSnapsho... | [
"0.6723477",
"0.57516706",
"0.5735899",
"0.56968135",
"0.56694865",
"0.5653477",
"0.5628693",
"0.561062",
"0.55898273",
"0.55354804",
"0.5533767",
"0.5533234",
"0.55190754",
"0.54920053",
"0.54844683",
"0.54710597",
"0.5446598",
"0.5444467",
"0.54030883",
"0.535256",
"0.53515... | 0.7352492 | 0 |
Transfer data to Choose Professional activity | private void TransferDataToMainActivity(){
Intent intent = new Intent(ChooseService.this, MainActivity.class);
intent.putExtra("Professional", professionalName);
intent.putExtra("Service", serviceName);
intent.putExtra("Price", servicePrice);
startActivity(intent);
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"@Override\n public void onClick(View v) {\n if (!TextUtils.isEmpty(typecode.getSelectId())) {\n Intent intent = null;\n if (toothType != null)\n intent = new Intent(getActivity(), VisitDrugDentalActivity.clas... | [
"0.6145682",
"0.6131977",
"0.609299",
"0.6057293",
"0.59831864",
"0.59470767",
"0.5940597",
"0.59235036",
"0.59235036",
"0.59056413",
"0.58479506",
"0.58390725",
"0.581895",
"0.57597584",
"0.5732908",
"0.57241064",
"0.57238287",
"0.5651309",
"0.56431395",
"0.56399584",
"0.560... | 0.6297704 | 0 |
Check empty services, return true if no service has been selected | private boolean CheckEmptyServices(List<Services> services){
for(Services service : services){
if(service.getServiceQuantity() > 0){
return false;
}
}
return true;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"boolean hasService();",
"boolean hasService();",
"boolean hasService();",
"boolean hasService();",
"boolean hasService();",
"boolean hasServiceList();",
"boolean isSetListOfServiceElements();",
"public boolean hasService() {\n return serviceBuilder_ != null || service_ != null;\n }",
"p... | [
"0.7031156",
"0.7031156",
"0.7031156",
"0.7031156",
"0.7031156",
"0.7016881",
"0.69657934",
"0.68230337",
"0.68230337",
"0.68230337",
"0.67917717",
"0.67917717",
"0.67917717",
"0.6766815",
"0.6766815",
"0.6660843",
"0.6331738",
"0.6311997",
"0.6277263",
"0.62264895",
"0.60825... | 0.81688744 | 0 |
Update selection choice for Spinners | private void UpdateDataForSpinner(Spinner spinner){
// Create an ArrayAdapter using the string array and a default spinner layout
ArrayAdapter<CharSequence> adapter = ArrayAdapter.createFromResource(this,
R.array.serviceQuantity, android.R.layout.simple_spinner_item);
// Specify the layout to use when the list of choices appears
adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
// Apply the adapter to the spinner
spinner.setAdapter(adapter);
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"public void updateSelection() {\n\t\t\n\t}",
"@Override\n public void onItemSelected(AdapterView<?> parent, View view,\n int pos, long id) {\n choice=pos;\n }",
"private void updateSubModeSpinnerTexts() {\n\n }",
"public void setSelection(T t) {\n\t\tspinner.setS... | [
"0.6842235",
"0.6743116",
"0.66415656",
"0.6548555",
"0.6470084",
"0.64010483",
"0.64008725",
"0.6331629",
"0.6308279",
"0.6289834",
"0.6282853",
"0.6270557",
"0.6249893",
"0.62477845",
"0.62340343",
"0.62334204",
"0.62017",
"0.6191909",
"0.61845577",
"0.6179369",
"0.6114589"... | 0.5927834 | 49 |
Hide Action bar for this particular activity | private void HideActionBar(){
if(getSupportActionBar() != null){
getSupportActionBar().hide();
}
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"private void hideActionBar() {\n View decorView = getWindow().getDecorView();\n // Hide the status bar.\n int uiOptions = View.SYSTEM_UI_FLAG_FULLSCREEN;\n decorView.setSystemUiVisibility(uiOptions);\n // Hide the action bar\n getSupportActionBar().hide();\n }",
"publ... | [
"0.8559517",
"0.8557274",
"0.8081309",
"0.73196864",
"0.7141178",
"0.68589115",
"0.6786436",
"0.6743239",
"0.67242104",
"0.662644",
"0.6607407",
"0.65983176",
"0.65734226",
"0.6564925",
"0.6560437",
"0.6465811",
"0.6408134",
"0.6408134",
"0.6401923",
"0.6382474",
"0.6376077",... | 0.83560413 | 2 |
Retrieve Google Sign In profile | private String RetrieveGoogleSignInProfile(){
String personName;
acct = GoogleSignIn.getLastSignedInAccount(ChooseService.this);
if (acct != null) {
personName = acct.getDisplayName();
/*String personGivenName = acct.getGivenName();
String personFamilyName = acct.getFamilyName();
String personEmail = acct.getEmail();
String personId = acct.getId();
Uri personPhoto = acct.getPhotoUrl();*/
}else{
personName = null;
}
return personName;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"private void getProfileInformation() {\n try {\n if (Plus.PeopleApi.getCurrentPerson(mGoogleApiClient) != null) {\n Person currentPerson = Plus.PeopleApi\n .getCurrentPerson(mGoogleApiClient);\n String personName = currentPerson.getDisplayName(... | [
"0.6969862",
"0.67185396",
"0.64642006",
"0.62573594",
"0.6185595",
"0.617921",
"0.614174",
"0.60776407",
"0.60764146",
"0.6051935",
"0.6022234",
"0.6017609",
"0.5985996",
"0.5983912",
"0.5937732",
"0.5903281",
"0.5898916",
"0.5898879",
"0.5857925",
"0.58249474",
"0.5813772",... | 0.79646206 | 0 |
probably won't have to use this function either | public static void findWumpus(GameTile[][] visibleMap) {
//method to find the position of the Wumpus
//this will be used to determine where the beast is and to kill it
for(int i=0; i<visibleMap.length; i++) {
for(int j=0; j<visibleMap[i].length; j++) {
if(visibleMap[i][j].hasWumpus()) {
wumpusX = i;
wumpusY = j;
}
}
}
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"protected boolean func_70814_o() { return true; }",
"@Override\n\tpublic void sacrifier() {\n\t\t\n\t}",
"private void poetries() {\n\n\t}",
"private void strin() {\n\n\t}",
"public void method_4270() {}",
"@Override\n\tprotected void interr() {\n\t}",
"@Override\n public void func_104112_b() {\n ... | [
"0.56414336",
"0.5529691",
"0.5417027",
"0.53309745",
"0.5330721",
"0.53233266",
"0.53216803",
"0.53207964",
"0.52877545",
"0.5282024",
"0.5252832",
"0.5214639",
"0.52093947",
"0.51916283",
"0.5173966",
"0.51706296",
"0.5164613",
"0.5164613",
"0.51577944",
"0.5144722",
"0.514... | 0.0 | -1 |
probably won't have to use this function. Need to change what arguments go into the wumpus state class | public void setStartingPosition(GameTile [][] visibleMap) {
//method to set the starting position of our player.
for(int i=0; i<visibleMap.length; i++) {
for(int j=0; j<visibleMap[i].length; j++) {
if(visibleMap[i][j] != null && visibleMap[i][j].hasPlayer()) {
playerX = i;
playerY = j;
}
}
}
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"void mo15871a(StateT statet);",
"@Override\n protected void incrementStates() {\n\n }",
"void setState(Object sender, ConditionT condition, Params params, StateT state);",
"private StateUtils() {}",
"@Override public void setTime(UpodWorld w)\n{\n StateRepr sr = getState(w);\n sr.checkAgain(0);\n}",
... | [
"0.68462044",
"0.6534638",
"0.65336394",
"0.6532271",
"0.6417674",
"0.6390407",
"0.63666296",
"0.6270003",
"0.61970556",
"0.61748666",
"0.6148404",
"0.61260915",
"0.60913646",
"0.6083229",
"0.6082864",
"0.603202",
"0.6021356",
"0.60175514",
"0.6001062",
"0.5996934",
"0.598074... | 0.0 | -1 |
new search function for its in here our goal state would be getting the closest unknown state before this, need to probably check if the the tile were standing on is safe. If it is safe, then generate children. Our first state tile will be known(starting position) lets see what we can do. | public WumpusState wellItsDarkNow(GameTile[][] visibleMap) {
Queue<WumpusState> queue = new LinkedList<WumpusState>();
HashMap<String, Boolean> visitedStates = new HashMap<String, Boolean>();
WumpusState state = new WumpusState(visibleMap, playerX, playerY);
long nodesExpanded = 0;
queue.add(state);
if(state.getParent()!=null) {
queue.add(state.getParent());
}
while(!queue.isEmpty()) {
WumpusState currentState = queue.remove();
System.out.println(currentState.toString());
if(currentState.getGoldCollected()) {
ArrayList<AgentAction> actions = currentState.getAllActions();
for(int i=1;i<actions.size(); i++) {
System.out.println("gold");
System.out.println(actions.get(i));
nextMoves.add(actions.get(i));
}
goldCollected = true;
return currentState;
}
if(currentState.spaceNotVisited()) {
ArrayList<AgentAction> actions = currentState.getAllActions();
for(int i=1;i<actions.size(); i++) {
System.out.println("null");
System.out.println(actions.get(i));
nextMoves.add(actions.get(i));
}
return currentState;
}
if(visitedStates.containsKey(currentState.toString())) {
continue;
}
else {
visitedStates.put(currentState.toString(), true);
WumpusState[] childrenOfCurrentChild = currentState.generateChildrenStates();
for(int j=0; j<childrenOfCurrentChild.length; j++) {
if(childrenOfCurrentChild[j]!=null) {
queue.add(childrenOfCurrentChild[j]);
}
}
}
}
goldCollected = true;
return state;
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"private Array<Tile>[] walk() {\n float targetY = currentTile.y + 1;\n Vector2 previousTile = new Vector2(currentTile.x, currentTile.y);\n\n Array<Vector2> tiles = new Array<Vector2>();\n tiles.add(new Vector2(currentTile.x, currentTile.y));\n\n while(currentTile.y < targetY) {\n ... | [
"0.64466894",
"0.6435464",
"0.624812",
"0.6224093",
"0.62071353",
"0.6206119",
"0.6199273",
"0.6140004",
"0.611651",
"0.6085592",
"0.60560733",
"0.5996624",
"0.59746987",
"0.59703857",
"0.59506994",
"0.5943485",
"0.593737",
"0.59371996",
"0.5934632",
"0.59196156",
"0.587561",... | 0.6100195 | 9 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.