How do you calculate the Euclidean distance between two points?

Subtract the two points coordinate by coordinate, square each difference, add the squares, and take the square root. In symbols, for points a and b: d = √(Σ (aᵢ − bᵢ)²). For example, (1, 2) and (4, 6) give differences −3 and −4, squares 9 and 16, sum 25, so d = √25 = 5 — the hypotenuse of a 3-4-5 right triangle.

What is the difference between Euclidean and Manhattan distance?

Euclidean distance is the straight-line length between two points, √(Σ (aᵢ − bᵢ)²). Manhattan distance is the sum of the absolute coordinate differences, Σ |aᵢ − bᵢ| — the path you would walk along a city grid. Euclidean is always less than or equal to Manhattan. Use Manhattan when movement is axis-aligned or when you want a metric less sensitive to large single-dimension gaps.

What is the difference between Euclidean distance and cosine similarity?

Euclidean distance measures how far apart two vectors are in space; it grows with magnitude. Cosine similarity measures the angle between them and ignores magnitude entirely. Two embeddings pointing the same way but at different lengths have a large Euclidean distance yet a cosine similarity near 1. For length-normalised vectors the two are directly related; for raw vectors they answer different questions.

What is squared Euclidean distance and why is it used in k-means?

Squared Euclidean distance is d² = Σ (aᵢ − bᵢ)² — the distance before the square root. k-means minimises it because the square root is a monotonic step that does not change which centroid is nearest, and skipping it avoids a costly sqrt per comparison while keeping the maths differentiable. This tool shows d² alongside d so you can use whichever your algorithm expects.

How is Euclidean distance used in KNN and clustering?

k-nearest-neighbours ranks training points by their Euclidean distance to a query and votes among the closest k. k-means assigns each point to the centroid with the smallest squared Euclidean distance, then recomputes centroids. Because the metric is scale-sensitive, features are usually standardised first so that one large-range feature does not dominate the distance.

Does this match numpy.linalg.norm and scikit-learn?

Yes. The Euclidean distance here equals numpy.linalg.norm(a − b) and sklearn.metrics.pairwise.euclidean_distances, the squared output equals euclidean_distances(..., squared=True), and the comparison row matches manhattan_distances and the DistanceMetric "chebyshev". The tool also re-computes the distance a second way, with Math.hypot, and confirms the two routes agree.

Why must the two points have the same number of coordinates?

The formula pairs coordinates by position — a₁ with b₁, a₂ with b₂, and so on — so both points need the same number of coordinates for the pairing to be defined. Comparing a 2D point with a 3D point has no meaning. If the lengths differ, the calculator stops and tells you both lengths instead of returning a misleading number.

Does this calculator send my data anywhere?

No. Parsing your numbers, taking the differences, squaring, summing and rooting — all of it runs in your browser with plain JavaScript. Nothing is uploaded, logged, or stored, so you can paste real feature vectors or embedding values without concern. The page keeps working offline once it has loaded.

AI · Machine learning

Euclidean Distance Calculator

Compute the Euclidean (L2) distance between two points or two vectors of any dimension, in your browser. See the squared distance, the Manhattan and Chebyshev comparisons, and the full per-dimension working behind every result. No signup, nothing uploaded.

By Induwara Ashinsana— Executive Director, Ryzera TechnologiesUpdated Jun 10, 2026

Euclidean distance calculator

Input mode

Vector / Point A

Any length ≥ 1 — A and B must match.

Vector / Point B

Same length as A. Commas, spaces, or new lines.

Examples

Euclidean distance

0.5477

L2 · 3-D

Squared (d²)

0.3000

Used by k-means

Manhattan (L1)

0.8000

Σ |aᵢ − bᵢ|

Chebyshev (L∞)

0.5000

max |aᵢ − bᵢ|

Decimals

Cross-check. The direct form √(Σ (aᵢ − bᵢ)²) gives 0.5477; the independent overflow-safe form Math.hypot(a − b) — how numpy.linalg.norm computes it — gives 0.5477. They reconcile, as they must.

Step-by-step working

Dim	aᵢ	bᵢ	aᵢ − bᵢ	(aᵢ − bᵢ)²	\|aᵢ − bᵢ\|
#1	0.2000	0.1000	0.1000	0.0100	0.1000
#2	0.5000	0.7000	-0.2000	0.0400	0.2000
#3	0.9000	0.4000	0.5000	0.2500	0.5000
Totals				0.3000	0.8000

d = √((0.1000)² + (−0.2000)² + (0.5000)²) = √0.3000 = 0.5477

Method: d = √(Σ (aᵢ − bᵢ)²); d² = Σ (aᵢ − bᵢ)²; Manhattan = Σ |aᵢ − bᵢ|; Chebyshev = maxᵢ |aᵢ − bᵢ| — scikit-learn euclidean_distances and NumPy linalg.norm. Nothing leaves this page.

How it works

Euclidean distance is the straight-line distance between two points — the length of the segment joining them. For two equal-length vectors a = [a₁…aₙ] and b = [b₁…bₙ], it is the square root of the sum of the squared coordinate differences. It is the metric scikit-learn and NumPy use by default, and it generalises the Pythagorean theorem to any number of dimensions.

d(a, b) = √( Σ (aᵢ − bᵢ)² ) = √( (a₁ − b₁)² + … + (aₙ − bₙ)² )

The tool computes this in four steps:

Per-dimension difference. Subtract the vectors coordinate by coordinate: dᵢ = aᵢ − bᵢ.
Square and sum. Square each difference and add them up. This sum is the squared Euclidean distance d² = Σ dᵢ², which equals scikit-learn's euclidean_distances(…, squared=True).
Square root. The Euclidean distance is d = √(d²), equivalent to numpy.linalg.norm(a − b).
Comparison metrics. Over the same differences the tool also reports Manhattan Σ |dᵢ| and Chebyshev max |dᵢ|, the L1 and L∞ members of the same Minkowski family.

The 2D and 3D modes are just the n = 2 and n = 3 cases of the same sum: √((x₂ − x₁)² + (y₂ − y₁)²) and √((x₂ − x₁)² + (y₂ − y₁)² + (z₂ − z₁)²). All arithmetic is done in double-precision floating point and is rounded only for display, using the decimal places you pick. As a credibility check, the calculator computes the distance a second way — as the L2 norm of the difference vector via Math.hypot, the overflow-safe route NumPy relies on — and confirms the two agree, so even inputs around 10⁹ stay exact.

Worked examples

2D points — a = [1, 2], b = [4, 6] (the 3-4-5 triangle)

Differences: 1 − 4 = −3, 2 − 6 = −4
Squares: (−3)² = 9, (−4)² = 16, sum S = 25
Euclidean: d = √25 = 5.0000, squared d² = 25
Manhattan: |−3| + |−4| = 7, Chebyshev: max(3, 4) = 4
hypot(−3, −4) = 5.0000 → cross-check agrees

n-D vectors — a = [1, 2, 3], b = [4, 0, 3]

Differences: −3, 2, 0
Squares: 9, 4, 0, sum S = 13
Euclidean: d = √13 = 3.605551, squared d² = 13
Manhattan: 3 + 2 + 0 = 5, Chebyshev: max(3, 2, 0) = 3
numpy.linalg.norm([1,2,3] − [4,0,3]) = 3.605551 → agrees

Embedding vectors — p = [0.2, 0.5, 0.9], q = [0.1, 0.7, 0.4]

Differences: 0.1, −0.2, 0.5
Squares: 0.01, 0.04, 0.25, sum S = 0.30
Euclidean: d = √0.30 = 0.547723, squared d² = 0.30
Manhattan: 0.1 + 0.2 + 0.5 = 0.8, Chebyshev: max(0.1, 0.2, 0.5) = 0.5
scipy.spatial.distance.euclidean(p, q) = 0.547722 → agrees

Frequently asked questions

Sources & references

The formulas on this page were last cross-checked against these sources on 2026-06-10. Euclidean distance is a stable mathematical definition, so this tool needs no rate or schedule updates — only the worked examples are periodically re-reconciled.

Related tools

LiveAI

Cosine Similarity Calc

Compute the cosine similarity, cosine distance, and angle between two numeric vectors or two short texts, with the full dot-product and magnitude working. Matches scikit-learn, runs entirely in the browser.

Open tool

LiveAI

Manhattan Distance Calc

Compute the Manhattan (L1 / taxicab / city-block) distance between two points or two numeric vectors of any dimension, with the full per-dimension working. Also shows the Euclidean (L2) and Chebyshev (L∞) distances, and matches scikit-learn and SciPy — entirely in your browser.

Open tool

LiveAI

Hamming Distance Calc

Compute the Hamming distance between two equal-length binary strings, text strings, or numeric vectors — the count of positions that differ. Also shows the normalised Hamming loss, similarity, and exactly which positions mismatch, entirely in your browser.

Open tool

Rate this tool

Be the first to rate

Comments & feedback

Spotted a bug or want an improvement? Tell us — our team reviews every comment, and good ideas get built. Comments are public and anonymous.

Found a bug, edge case, or want to suggest an improvement?

Email me at [email protected] — most fixes ship within 24 hours.