Calculate Euclidean distance between two points.

@param anotherPoint Point to calculate distance to.
@return Euclidean distance between this point and anotherPoint points.
172877
public float DistanceTo(IntPoint anotherPoint) {
        float dx = this.x - anotherPoint.x;
        float dy = this.y - anotherPoint.y;

        return (float) Math.sqrt(dx * dx + dy * dy);
    }
769587
public static float distance(PointF p1, PointF p2){
        return (float) Math.sqrt(Math.pow((p2.x - p1.x), 2) + Math.pow(p2.y - p1.y,2));
    }
666409
private static double distance(double[] pointA, double [] pointB) {
		double distance = 0.0;
		for (int i = 0; i < pointA.length; i++) {
			double d = pointA[i] - pointB[i];
			distance += d * d;
		}
		return Math.sqrt(distance);
	}
801367
public double distance(final Coordinate c) {
        final double dx = getX() - c.getX();
        final double dy = getY() - c.getY();
        return Math.sqrt(dx * dx + dy * dy);
    }
247774
public double sqrMaxDistance(Envelope2D other) {
		if (isEmpty() || other.isEmpty())
			return NumberUtils.TheNaN;

		double dist = 0;
		Point2D[] points = new Point2D[4];
		queryCorners(points);
		Point2D[] points_o = new Point2D[4];
		other.queryCorners(points_o);
		for (int i = 0; i < 4; i++) {
			for (int j = 0; j < 4; j++) {
				double d = Point2D.sqrDistance(points[i], points_o[j]);
				if (d > dist) {
					dist = d;
				}
			}
		}

		return dist;
	}
231143
public double getHullDistance(SphereCluster other) {
		double distance = 0.0;
		//get the center through getCenter so subclass have a chance
		double[] center0 = getCenter();
		double[] center1 = other.getCenter();
		distance = distance(center0, center1);

		distance = distance - getRadius() - other.getRadius();
		return distance;
	}
436747
public static int distance (int x1, int y1, int x2, int y2) {
        return (int)Math.sqrt(distanceSq(x1, y1, x2, y2));
    }
1027148
public static double Euclidean(IntPoint p, IntPoint q) {
        return Euclidean(p.x, p.y, q.x, q.y);
    }
734420
public double distance(Instance first, Instance second) {
    return Math.sqrt(distance(first, second, Double.POSITIVE_INFINITY));
  }
128822
public static Double getDistanceBetweenCoordinates(Tuple2<Double, Double> point1, Tuple2<Double, Double> point2) {
        // sqrt( (x2-x1)^2 + (y2-y2)^2 )
        Double xDiff = point1._1() - point2._1();
        Double yDiff = point1._2() - point2._2();
        return Math.sqrt(xDiff * xDiff + yDiff * yDiff);
    }
415267
public static double distance(Point p1, Point p2)
	{
		double x = p2.x - p1.x;
		double y = p2.y - p1.y;
		double z = p2.z - p1.z;
		return Math.sqrt(x * x + y * y + z * z);
	}
1048504
def distance(self, other):
        """"""
        return math.acos(self._pos3d.dot(other.vector))
1341039
def distance_to(self, other):
        """"""
        return np.linalg.norm(self.position-other.position)
380367
public static int distance (int x1, int y1, int x2, int y2)
    {
        int dx = x1-x2, dy = y1-y2;
        return (int)Math.sqrt(dx*dx+dy*dy);
    }
72964
public double normalizedDistance(double[] point1, double[] point2) throws Exception {
    return Math.sqrt(distance2(point1, point2)) / point1.length;
  }
203373
private static double pointsDistance(Point a, Point b) {
        int dx = b.x - a.x;
        int dy = b.y - a.y;
        return Math.sqrt(dx * dx + dy * dy);
    }
1327739
@Pure
	public double distance(Point2D<?, ?> point, double width) {
		double mind = Double.MAX_VALUE;
		double dist;
		final Point2d pts1 = new Point2d();
		final Point2d pts2 = new Point2d();

		double w = width;
		w = Math.abs(w) / 2.;

		for (final PointGroup grp : groups()) {
			for (int idx = 0; idx < grp.size(); idx += 2) {
				if (grp.getMany(idx, pts1, pts2) > 1) {
					dist = Segment2afp.calculatesDistanceSegmentPoint(
							pts1.getX(), pts1.getY(), pts2.getX(), pts2.getY(),
							point.getX(), point.getY()) - w;
					if (dist < mind) {
						mind = dist;
					}
				} else {
					dist = pts1.getDistance(point);
					if (dist < mind) {
						mind = dist;
					}
				}
			}
		}

		return mind;
	}