@Override public int compare(Distance o1, Distance o2) { if (o1.getCosine_similarity() < o2.getCosine_similarity()) return 1; else if (o1.getCosine_similarity() > o2.getCosine_similarity()) return -1; return 0; }
/** * Identify segments of continuous walls in a vertical direction * * @param sl */ private void generateSegmentsForVerticalWalls(ArrayList<Seg> sl) { int x; int y; // we search for vertical walls, so for each row for (x = 0; x != width; x++) { y = 0; while (y < height) { // find the beginning of a segment if (cells.hasNoWallOnLeft(x, y)) { y++; continue; } int starty = y; // find the end of a segment while (cells.hasWallOnLeft(x, y)) { y++; if (y == height) break; if (cells.hasWallOnTop(x, y)) break; } // create segment with (x,starty) being being the actual start position of the segment, // y-starty being the positive length sl.add( new Seg( x * Constants.MAP_UNIT, starty * Constants.MAP_UNIT, 0, (y - starty) * Constants.MAP_UNIT, dists.getDistance(x, starty), colchange)); } y = 0; while (y < height) { // find the beginning of a segment if (cells.hasNoWallOnRight(x, y)) { y++; continue; } int starty = y; // find the end of a segment while (cells.hasWallOnRight(x, y)) { y++; if (y == height) break; if (cells.hasWallOnTop(x, y)) break; } // create segment with (x+1,y) being being one off in both directions from the last cell in // this segment, starty-y being the negative length // since we are looking at right walls, one off in the right direction (x+1) are then cells // that have this segment on its left hand side sl.add( new Seg( (x + 1) * Constants.MAP_UNIT, y * Constants.MAP_UNIT, 0, (starty - y) * Constants.MAP_UNIT, dists.getDistance(x, starty), colchange)); } } }
private void testStrategy(Strategy distanceStrategy) throws UDFArgumentException, HiveException { Distance distance = new Distance(); Object result = distance.evaluate(distanceStrategy.getName(), "hello", "hello"); Assert.assertNotNull(result); Float dist = (Float) result; Assert.assertEquals(1.0, dist, 0f); }
/** * Call back method for MazeBuilder to communicate newly generated maze as reaction to a call to * build() * * @param root node for traversals, used for the first person perspective * @param cells encodes the maze with its walls and border * @param dists encodes the solution by providing distances to the exit for each position in the * maze * @param startx current position, x coordinate * @param starty current position, y coordinate */ public void newMaze(BSPNode root, Cells c, Distance dists, int startx, int starty) { if (Cells .deepdebugWall) { // for debugging: dump the sequence of all deleted walls to a log file // This reveals how the maze was generated c.saveLogFile(Cells.deepedebugWallFileName); } // adjust internal state of maze model showMaze = showSolution = solving = false; mazecells = c; mazedists = dists; seencells = new Cells(mazew + 1, mazeh + 1); rootnode = root; setCurrentDirection(1, 0); setCurrentPosition(startx, starty); walkStep = 0; viewdx = dx << 16; viewdy = dy << 16; angle = 0; mapMode = false; cleanViews(); // Set up the robot and the robot driver. setUpRobotDriver(); // register views for the new maze // mazew and mazeh have been set in build() method before mazebuider was called to generate a // new maze. // reset map_scale in mapdrawer to a value of 18 ///// WAS 10//// addView( new FirstPersonDrawer( Constants.VIEW_WIDTH, Constants.VIEW_HEIGHT, Constants.MAP_UNIT, Constants.STEP_SIZE, mazecells, seencells, 18, mazedists.getDists(), mazew, mazeh, root, this)); // order of registration matters, code executed in order of appearance! addView( new MapDrawer( Constants.VIEW_WIDTH, Constants.VIEW_HEIGHT, Constants.MAP_UNIT, Constants.STEP_SIZE, mazecells, seencells, 18, mazedists.getDists(), mazew, mazeh, this)); }
@Test public void testEvaluateWithStrategyNotFound() throws HiveException { Distance distance = new Distance(); try { distance.evaluate("dd", "dd", "dd"); Assert.fail(); } catch (HiveException ex) { } }
@Test public void testEvaluateWithNullValues() throws HiveException { Distance distance = new Distance(); try { distance.evaluate(null, null, null); Assert.fail(); } catch (HiveException ex) { } }
public SlidePuzzle(int width, int height, String puzzle) { history = new History(); this.width = width; this.height = height; this.puzzle = puzzle; correctPuzzle = Util.createAnswerPanel(puzzle); distance = new Distance(width, height, correctPuzzle); char[][] chars = Util.createBoard(width, height, puzzle); board = new Board(width, height, puzzle); int distInt = distance.getAllDistance(chars); int maxDistInt = distance.getMaxDistance(chars); history.putHistory(puzzle, "", distInt, maxDistInt); answerBoard = new AnswerBoard(); answerBoard.put(puzzle, distInt, distance.getMaxDistance(chars)); }
public static void main(String[] args) { point newPoint = new point(); System.out.println("Please enter your starting X point."); Scanner input = new Scanner(System.in); double startInputX = input.nextDouble(); System.out.println("Please enter your starting Y point."); double startInputY = input.nextDouble(); newPoint.x = startInputX; newPoint.y = startInputY; System.out.println( "What would you like to do? \n" + "Calculate your distance to another point? \t\t\t\t\t\t\t Please Press 1 \n" + "Calculate your distance to the origin? \t\t\t\t\t\t\t\t Please Press 2 \n" + "Change the co-ordinates of your current point? \t\t\t\t\t\t\t Please Press 3 \n" + "Find out the co-ordinates of your current point? \t\t\t\t\t\t Please Press 4 \n" + "Reverse the cartesian plane of your point (negative to positive co-ordinates or vice versa)? \t Please Press 5 \n"); Distance A = new Distance(); int Choice = input.nextInt(); if (Choice == 1) { A.distanceTo(newPoint.x, newPoint.y); } if (Choice == 2) { A.distanceToOrigin(); } if (Choice == 3) { System.out.println("Please enter your move-to-X point."); double startInput2X = input.nextDouble(); System.out.println("Please enter your move-to-Y point."); double startInput2Y = input.nextDouble(); A.moveTo(startInput2X, startInput2Y); } if (Choice == 4) { point newPoint1 = new point(); newPoint1.Clone(); } if (Choice == 5) { point newPoint2 = new point(); newPoint2.opposite(newPoint.x, newPoint.y); } }
/** * Adds a new distance functor for the given attribute data type. * * @param type the attribute data type * @param d the distance functor to use on the data type */ public static final void putDistanceFunctorFor(String type, Distance d) { Map<String, Distance> fs = distanceMap.get(type); if (fs == null) { fs = new HashMap<String, Distance>(); } fs.put(d.toString(), d); distanceMap.put(type, fs); }
public String toString() { return "Distance mirror of " + source.comment() + " " + source.atom1().number() + " " + source.atom2().number() + " " + distance() + " " + dDistanceDx() + " " + dDistanceDy() + " " + dDistanceDz() + " "; }
/** * * 移動とその距離をhistoryに加える処理。 * * @param operation * @param position * @param currentDistance * @param currentMaxDistance */ private void move( String operation, MovedPosition position, int currentDistance, int currentMaxDistance) { String boardStr = board.getBoardString(); char changedChar = position.getC(); int oldX = position.getOldX(); int oldY = position.getOldY(); int newX = position.getNewX(); int newY = position.getNewY(); if (history.getOperationHistory(boardStr) == null) { char[][] c = Util.createBoard(width, height, boardStr); int newDistance = distance.getNewDistance(changedChar, oldX, oldY, newX, newY, currentDistance); int newMaxDistance = distance.getMaxDistance(c); answerBoard.put(boardStr, newDistance, newMaxDistance); history.putHistory(boardStr, operation, newDistance, newMaxDistance); } }
/** * @param P indeks analizowanego pixela * @param eps promień sąsiedztwa * @return lista sąsiadów danego pixela w zadanym promieniu eps */ private List<Integer> regionQuery(int P, double eps) { List<Integer> neighbours = new ArrayList<>(); double tmp; for (int i = 0; i < colors.length; i++) { if (P != i) { tmp = dist.compute(colors[P], colors[i]); if (tmp <= eps) neighbours.add(i); } } return neighbours; }
public void calculate(View view) { EditText flyingDistanceTextBox = (EditText) findViewById(R.id.flyingdistancecourseFlyingDistanceOutput); EditText courseTextBox = (EditText) findViewById(R.id.flyingdistancecourseCourse_2); double flyingDistance = 0; double course = 0; Distance d = new Distance(); flyingDistance = Calculation.calcFlyDis(airportOneChoice, airportTwoChoice); course = Calculation.calcCourBwAir(airportOneChoice, airportTwoChoice); if (distanceUnitChoice.equalsIgnoreCase("SM")) { flyingDistance = d.kilomToStat(flyingDistance); flyingDistanceTextBox.setText((String.format("%.2f", flyingDistance))); } else if (distanceUnitChoice.equalsIgnoreCase("NM")) { flyingDistance = d.kilomToNaut(flyingDistance); flyingDistanceTextBox.setText((String.format("%.2f", flyingDistance))); } else { flyingDistanceTextBox.setText((String.format("%.2f", flyingDistance))); } courseTextBox.setText(String.format("%.2f", course)); }
/** * Print a trip for the request on the standard input to the standard output, using the map data * in MAPFILENAME. */ private static void trip(String mapFileName) { createMap(mapFileName); Scanner requests = new Scanner(System.in); requests.useDelimiter("\\n+"); while (requests.hasNext()) { String request = requests.next().trim(); String[] locations = request.split("\\s*,\\s+"); if (locations.length > 1) { System.out.printf("From %s:%n%n", locations[0]); Graph<Location, Distance>.Vertex startV, endV, currV; String start, end, currentLocation; for (int j = 1; j < locations.length; j++) { currentLocation = start = locations[j - 1]; end = locations[j]; _destinations.add(end); currV = startV = findVertex(start); endV = findVertex(end); for (Graph<Location, Distance>.Edge road : Graphs.shortestPath(_map, startV, endV, new Length())) { Distance currentRoad = road.getLabel(); String roadName = currentRoad.toString(); String direction = currentRoad.getDirection(currentLocation); String len = String.valueOf(currentRoad.weight()); currV = road.getV(currV); currentLocation = currV.getLabel().toString(); _data.add(new String[] {roadName, len, direction, currentLocation}); } addInstruction(); } finallyPrintInstructions(); } else { System.err.printf("User must provide more than one location in" + " one line."); } } requests.close(); }
public Location[] findLocationsInRadius(String json, double radius) { JSONArray locationPool = new JSONArray(json); for (int i = 0; i <= locationPool.length() - 1; ++i) { latitude = locationPool.getJSONObject(i).getDouble("Longitude"); longitude = locationPool.getJSONObject(i).getDouble("Latitude"); boolean inRadius = Distance.isInRadius( ownLocation.buildCoordinate(), new Point2D.Double(latitude, longitude), radius); if (inRadius) { String name = locationPool.getJSONObject(i).getString("Name"); Location result = new Location(name, longitude, latitude); locationInRadius[i] = result; } } return locationInRadius; }
/** * Wyznacza reprezentanta danej grupy * * @param colors Lista kolorów należących do danej grupy * @return Kolor reprezentuący daną grupę */ public Color findRep(List<Color> colors) { double r = 0.0, g = 0.0, b = 0.0, dst = Double.POSITIVE_INFINITY, tmp; double s = (double) colors.size(); Color ret = new Color(0, 0, 0); for (Color c : colors) { r += c.vec[0]; g += c.vec[1]; b += c.vec[2]; } r /= s; g /= s; b /= s; Color crep = new Color((int) r, (int) g, (int) b); for (Color c : colors) { tmp = dist.compute(c, crep); if (tmp < dst) { dst = tmp; ret = c; } } return ret; }
public boolean isSimilar(String name1, String name2) { return distance.LD(name1, name2) <= maximumDistance; }
public PointsDouble calc(Vector[] x, Vector[] mu, Vector[] sigma2, double[][] uebergangsw) { double[][] s = new double[x.length][mu.length]; int[][] r = new int[x.length][mu.length]; // ---Erste Spalte--- s[0][0] = 1; // d.calcDistance(mu[0], x[0], sigma2[0]); for (int j = 1; j < mu.length; j++) { s[0][j] = Double.POSITIVE_INFINITY; } // ---Iteriere über Spalten--- for (int i = 1; i < x.length; i++) { for (int j = 0; j < mu.length; j++) { // k=0 // System.out.println("i-1 " + (i-1) + " j " + j); double min = s[i - 1][j] + uebergangsw[j][j]; // double distance = s[i-1][j]; int k = j; // k=1 if (j > 0) { if (s[i - 1][j - 1] + uebergangsw[j - 1][j] < min) { min = s[i - 1][j - 1] + uebergangsw[j - 1][j]; k = j - 1; } } // k=2 if (j > 1) { if (s[i - 1][j - 2] + uebergangsw[j - 2][j] < min) { min = s[i - 1][j - 2] + uebergangsw[j - 2][j]; k = j - 2; } } r[i][j] = k; s[i][j] = min + d.calcDistance(x[i], mu[j], sigma2[j]); } } /*System.out.println("\nRückwärtszeiger"); for(int i = 0; i < r.length; i++){ for(int j = 0; j < r[i].length; j++){ System.out.print(r[i][j] + " "); } System.out.println(""); } System.out.println("");*/ // ---Rückwärtszeiger verfolgen--- // TODO: hier Point[] p = new Point[x.length]; int j = mu.length - 1; // Endzustand for (int i = x.length - 1; i >= 0; i--) { p[i] = new Point(i, j); // j -= r[i][j]; j = r[i][j]; } /*System.out.println("a x"); for (Point p1 : p) { System.out.println(p1.x + " " + p1.y); } System.out.println("");*/ // todo: Überprüfung ob n-1 m-1 Knoten Minimum ist??? Vermutlich nicht, man nimmt einfach den // n-1 m-1 Knoten? /*for (j = model.length - 1; j >= 0; j--) { for (int i = 0; i < x.length; i++) { System.out.print(s[i][j] + " "); } System.out.println(""); }*/ return new PointsDouble(p, s[x.length - 1][mu.length - 1]); }
@Override public double Compute(double[] u, double[] v) { return Distance.Manhattan(u, v); }
@Override public double Compute(double[] u, double[] v) { return Distance.Canberra(u, v); }
public final double dz() { return 0 - source.dz(); }
public final double dDistanceDz() { return 0 - source.dDistanceDz(); }
public double centroidDifference() { return Distance.euclidian(oldCentroid, centroid); }
public final double distance2() { return source.distance2(); }
public final Atom atom2() { return source.atom2(); }
public final double invDistance() { return source.invDistance(); }
/** * Identify segments of continuous walls in a horizontal direction * * @param sl */ private void generateSegmentForHorizontalWalls(ArrayList<Seg> sl) { int x; int y; // we search for horizontal walls, so for each column for (y = 0; y != height; y++) { // first round through rows x = 0; while (x < width) { // find the beginning of a segment if (cells.hasNoWallOnTop(x, y)) { x++; continue; } // found one int startx = x; // find the end of a segment // follow segment with wall on top till // x is the first index of a cell that has no wall on top // stop at outer bound or when hitting a wall (cell has wall on left) // such that length of the segment is startx-x, which is a negative value btw while (cells.hasWallOnTop(x, y)) { x++; if (x == width) break; if (cells.hasWallOnLeft(x, y)) break; } // create segment with (x,y) being the end positions, startx-x being the negative length // note the (x,y) is not part of the segment sl.add( new Seg( x * Constants.MAP_UNIT, y * Constants.MAP_UNIT, (startx - x) * Constants.MAP_UNIT, 0, dists.getDistance(startx, y), colchange)); } // second round through rows, same for bottom walls x = 0; while (x < width) { // find the beginning of a segment if (cells.hasNoWallOnBottom(x, y)) { x++; continue; } int startx = x; // find the end of a segment while (cells.hasWallOnBottom(x, y)) { x++; if (x == width) break; if (cells.hasWallOnLeft(x, y)) break; } // create segment with (startx,y+1) being one below the start position, x-startx being the // positive length // so this may represent a bottom wall segment as a top wall segment one below sl.add( new Seg( startx * Constants.MAP_UNIT, (y + 1) * Constants.MAP_UNIT, (x - startx) * Constants.MAP_UNIT, 0, dists.getDistance(startx, y), colchange)); } } }