Scale a point from the origin calculator
Multiply a point's coordinates by a scale factor from the origin: (3, 4) scaled by 2 becomes (6, 8), and its distance from the origin grows from 5 to 10. Negative factors reflect it through the origin. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- X
- 3
- Y
- 4
- Scale
- 2
- Scaled x
- 6
- Scaled y
- 8
- Original distance
- 5
- Scaled distance
- 10
Scaling a point from the origin is the simplest homothety on the plane: given P equals open parenthesis x comma y close parenthesis and a real factor k, the image is P prime equals open parenthesis k times x comma k times y close parenthesis. That map multiplies every distance from the origin by the absolute value of k, keeps rays from the origin when k is positive, and reflects through the origin when k is negative.
What scaling from the origin means and why people search for it
In Euclidean plane geometry a homothety with center at the origin and factor k sends every point P to the point on the same ray from O whose distance from O is multiplied by the absolute value of k when k is positive, or to the opposite ray when k is negative. Search intent clusters around phrases such as scale a point from the origin calculator, dilate a point about the origin, multiply coordinates by a scale factor, and homothety P prime equals k P.
Students want a numeric check against a textbook answer key when they confuse scaling from the origin with translation, reflection over an axis, or scaling about a non-zero center. Teachers want a deterministic oracle that rejects non-numeric scale factors instead of silently inventing zeros. When k equals one the map is the identity; when k equals zero every point collapses to the origin; when the absolute value of k is greater than one distances grow; when it is between zero and one they shrink.
When scaling from the origin is useful
Classrooms and tutoring platforms use a scale-a-point-from-origin calculator so learners can check dilated coordinates for arbitrary points and factors without flipping sign errors when they confuse positive enlargement with reflection through the origin. Exam-prep generators need a deterministic oracle that rejects non-finite scale factors instead of silently coercing bad strings into zero and collapsing every point. Failed validation does not consume balance.
Coordinates and scale may be any finite numbers within a large absolute bound suitable for ordinary classroom and CAD figures; the response shares the same unit system you already use. Keep requests small, pin the rounded fields in tests, and you get reproducible scaled points for homework, LMS plugins, and edge workers without standing up symbolic math infrastructure of your own.
What you can do with it
Classroom and homework dilation drills
Students submit x, y, and a scale factor k and verify the image from the origin as (k·x, k·y), including rejection when the factor is missing or non-numeric.
Exam and LMS auto-grading
Mark coordinate-geometry items with a deterministic oracle that multiplies by k correctly and never invents a scaled point from invalid input.
FAQ
What formula does the calculator use?
Scaling from the origin is componentwise multiplication: (x,y) → (k·x, k·y). The formula field restates that identity. Distances from the origin scale by |k|.
What if the scale factor is negative or zero?
Negative k reflects through the origin and multiplies distances by |k|. Zero maps every point to the origin. Both are valid finite factors, not errors.
What is (3, 4) scaled by 2 from the origin?
It becomes (6, 8). Both coordinates are multiplied by the factor, and the distance from the origin doubles as well, from 5 to 10.
How does the distance from the origin change?
It is multiplied by the absolute value of the factor. A factor above 1 pushes the point away, one between 0 and 1 pulls it closer, and a positive factor keeps it on the same ray.
Is scaling a point the same as moving it?
No. Moving a point adds a fixed amount to each coordinate, while scaling from the origin multiplies them. Enlarging around some other center is also different, and this calculator does not do it.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/geom/scale-point \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"x":3,"y":4,"scale":2}'const res = await fetch("https://api.kit.forhosting.com/geom/scale-point", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"x": 3,
"y": 4,
"scale": 2
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/geom/scale-point",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"x": 3,
"y": 4,
"scale": 2
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/geom/scale-point", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"x":3,"y":4,"scale":2}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"x":3,"y":4,"scale":2}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/geom/scale-point", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"x": 3,
"y": 4,
"scale": 2
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "geom.scale_point",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
This calculator accepts three finite numbers—x, y, and scale—rejects missing or non-numeric values with invalid_input so failed validation is never charged, and returns the scaled pair together with the original and scaled Euclidean distances from the origin.
What scaling from the origin means and why people search for it
Algebraically the map is componentwise multiplication: scaled_x equals k times x and scaled_y equals k times y. Delivering scaled_x and scaled_y as JSON makes the result easy to diff in continuous integration, feed into a larger pipeline, or copy into notes. The response also reports original_distance and scaled_distance so clients can verify that the ratio of distances equals the absolute value of k without a second hypot call.
Input contract, response shape, and validation behaviour
POST a JSON body with three required finite numbers: x, the abscissa of the point to scale; y, the ordinate; and scale, the factor k of the homothety centered at the origin. Each field may arrive as a JSON number or as a numeric string; missing fields, empty strings, NaN, and infinities fail with invalid_input naming the field so those failed calls are not charged. After parsing, the scaled point is computed as scaled_x equals scale times x and scaled_y equals scale times y. Results are rounded to a stable decimal precision so the same coordinates always yield the same JSON across JavaScript engines. The response echoes the input coordinates and scale, returns scaled_x and scaled_y, returns original_distance as the Euclidean norm of the input point and scaled_distance as the Euclidean norm of the image, and includes a short formula string restating the identity for display next to the answer. Example: x equals three, y equals four, and scale equals two yields scaled_x equals six and scaled_y equals eight because each coordinate is doubled, with original_distance five and scaled_distance ten. Example with a shrink: x equals negative one point five, y equals two, and scale equals zero point five yields scaled_x equals negative zero point seven five and scaled_y equals one. There is no trigonometry, no matrix library, and no external geometry service—only two multiplications and two hypot calls on a Worker isolate. Pair the response with your own plotting code if you need a sketch of the ray from the origin through P and P prime; this endpoint returns numbers only and does not emit plots or multi-step prose beyond the formula field.
Where a scale-from-origin API earns its keep, pricing, and limits
Engineering notebooks, CAD helpers, and game editors often reduce zoom-about-origin and uniform mesh scale steps to this single map when validating that a figure grows or shrinks about O; calling a tiny parse API avoids pulling a full computer-algebra or transform stack for a three-number problem.
Integration use cases
CAD, mesh, and game zoom-about-origin
Tools that apply a uniform scale about the origin or validate zoom transforms can recover the scaled point and distance ratio as structured JSON.
Technical questions
How do I scale a point from the origin with this API?
Send a JSON body with finite numbers x, y, and scale (the factor k). The response returns scaled_x = k·x and scaled_y = k·y, the image of (x,y) under the origin-centered homothety.
What happens if the scale factor is missing or not a number?
The request fails with invalid_input because a finite number is required for every field, including scale. Those validation failures are not charged.
What does the scale-a-point-from-origin calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.