A Computer Randomly Puts A Point Inside The Rectangle

You're debugging a simulation at 11 PM. Which means the particles cluster in the corner. The Monte Carlo estimate is off by a factor of two. You stare at the code: x = random() * width; y = random() * height. Looks right. It is right — for a rectangle aligned to the axes, anchored at the origin.

But your rectangle isn't at the origin. Day to day, or it's rotated. Or both.

That's when the simple problem stops being simple.

What Is Random Point Generation in a Rectangle

At its core, this is the task of picking a coordinate pair (x, y) such that every point inside a given rectangle has exactly the same probability of being chosen. No gaps. No clustering. But uniform distribution. No bias toward edges or center.

You might be surprised how often this gets overlooked.

For an axis-aligned rectangle with lower-left corner at (x₀, y₀), width w, and height h, the textbook solution fits in one line:

x = x₀ + random() * w
y = y₀ + random() * h

random() returns a uniform float in [0, 1). Multiply by width and height. Shift by the corner coordinates. Done.

This works because the uniform distribution is preserved under affine transformations — scaling and translation. The probability density stays constant across the transformed region.

But rectangles in the wild aren't always axis-aligned. They're rotated. They're defined by four vertices in no particular order. They're the bounding box of a sprite sheet, the collision zone in a physics engine, the integration domain for a Monte Carlo estimator. The moment rotation enters the picture, the naive approach breaks.

The Rotated Rectangle Case

A rotated rectangle is still a parallelogram. It has a center, two orthogonal axes (the local x and y directions), and half-extents along each axis. If you generate a point in the local coordinate system — where the rectangle is axis-aligned and centered at the origin — then rotate and translate into world space, you preserve uniformity.

The math:

1. Generate u, v uniformly in [-halfWidth, halfWidth] × [-halfHeight, halfHeight]
2. Rotate by the rectangle's angle θ:

   x_world = center_x + u * cos(θ) - v * sin(θ)
   y_world = center_y + u * sin(θ) + v * cos(θ)
   

3. That's it. The Jacobian of this transformation is 1 (rotation preserves area), so uniformity holds.

This is the clean, correct way. Also, no rejection sampling. So no approximation. Two trig calls, four multiplies, a handful of adds.

The Arbitrary Quadrilateral Trap

Here's where people get burned. A "rectangle" defined by four arbitrary points might not be a rectangle at all. So naturally, it could be any convex quadrilateral. Or worse — the points might be in random order, defining a bow-tie self-intersecting polygon.

If you assume rectangle properties (right angles, parallel opposite sides) without verifying, your uniform sampling will be wrong. The generated points will cluster toward the acute corners of a parallelogram, or distribute strangely across a general quad.

For a true arbitrary convex quadrilateral, uniform sampling requires either:

• Triangulation (split into two triangles, pick triangle proportional to area, then sample uniformly in triangle)
• Bilinear parameterization with area-weighting correction (the Jacobian isn't constant)

The triangle method is simpler and strong. Compute both triangle areas. Then generate a uniform point in that triangle using the standard method: generate r1, r2 in [0,1); if r1 + r2 > 1, reflect: r1 = 1 - r1, r2 = 1 - r2. Choose triangle A with probability area_A / (area_A + area_B). Pick a diagonal. The point is v0 + r1*(v1-v0) + r2*(v2-v0).

Why It Matters

You might wonder: does the bias actually matter? The rectangle looks fine on screen. The simulation runs.

It matters when you're estimating integrals. And monte Carlo integration converges at O(1/√n) only if* samples are truly uniform over the domain. Even so, bias introduces systematic error that doesn't vanish with more samples. You can run ten million iterations and still be wrong.

It matters in graphics. And artists notice. Consider this: procedural placement of grass, debris, stars — if the distribution isn't uniform, the eye catches it. Clumping near one corner of a rotated bounding box looks artificial. Players notice.

It matters in physics. Day to day, the rectangle might be a detector surface, a boundary condition zone, a source region. Which means photon mapping. Particle-in-cell methods. Neutron transport. Non-uniform sampling skews flux calculations, dose estimates, signal-to-noise ratios.

And it matters in testing. Property-based testing. Fuzzing. If your test generator doesn't uniformly cover the input rectangle, you miss edge cases. The bug lives in the corner you never sample.

How It Works — The Complete Pipeline

Let's walk through a production-ready approach. Not a snippet. The whole thought process.

Step 1: Define Your Rectangle Representation

Don't pass around four loose floats. Define a struct or class that captures the actual* degrees of freedom:

Want to learn more? We recommend does it appear that the reaction has finished and describe how this exercise demonstrates the principle of phage typing for further reading.

struct Rectangle {
    Vec2 center;      // world position of center
    Vec2 halfExtents; // half-width, half-height (both > 0)
    float angle;      // rotation in radians, CCW from +X axis
}

This representation is minimal (5 floats), unambiguous, and numerically stable. No vertex ordering issues. No degenerate cases (zero area = halfExtents zero, which you can assert against).

Alternative: two orthogonal axis vectors axisX, axisY (not necessarily unit length). Then halfExtents are the lengths of these vectors. Now, center is the midpoint. This avoids trig at sampling time — you already have the rotated basis.

struct Rectangle {
    Vec2 center;
    Vec2 axisX;  // local X axis in world space (length = halfWidth)
    Vec2 axisY;  // local Y axis in world space (length = halfHeight)
}

Sampling becomes:

u = random() * 2 - 1  // [-1, 1]
v = random() * 2 - 1
point = center + u * axisX + v * axisY

Zero trig. This is the form graphics engines use. So naturally, four multiplies, three adds. In practice, store the rotated basis once at rectangle creation. Physics engines too. Reuse forever.

Step 2: Validate at Construction

If someone passes four vertices, verify they form a rectangle before constructing your internal representation.

Check:

• Four vertices
• Opposite sides parallel (cross product of edge vectors ≈ 0)
• Adjacent sides perpendicular (dot product ≈ 0)
• Non-zero area

If validation fails, either reject the input or fall back to quadrilateral sampling with a warning. Silent wrong behavior is the enemy.

Step 3: The Sampling Function

Vec2 sampleUniform(Rectangle rect, RNG rng) {
    float u = rng.nextFloat() * 2.0f - 1.0f;  // [-1, 1]
    float v = rng.nextFloat() * 2.0f - 

### Step 3: The Sampling Function  
```cpp
Vec2 sampleUniform(Rectangle rect, RNG rng) {
    float u = rng.nextFloat() * 2.0f - 1.0f;  // [-1, 1]
    float v = rng.nextFloat() * 2.0f - 1.0f;  // [-1, 1]
    return rect.center + u * rect.axisX + v * rect.axisY;
}

This method leverages the precomputed axisX and axisY vectors to avoid runtime trigonometry. By sampling u and v uniformly in the [-1, 1] range, the resulting point is guaranteed to lie within the axis-aligned bounding box of the rectangle. Since the rectangle is defined by its rotated basis, this approach inherently respects its orientation.

For performance-critical systems (e.g., real-time physics or ray tracing), consider caching the axisX and axisY vectors or precomputing them during rectangle construction. Avoid recomputing these values on every sample.

Step 4: Handling Edge Cases and Degeneracies

Even with validation during construction, runtime scenarios might introduce edge cases. For example:

• Near-degenerate rectangles: If halfExtents (or axisX/axisY lengths) approach zero due to floating-point errors, the sampling function could produce points outside the intended region. Add runtime checks to clamp u and v within [-1, 1] if the rectangle’s area is below a threshold.
• Dynamic rectangles: If the rectangle’s center, orientation, or size changes over time (e.g., in a physics simulation), ensure the sampling function updates its internal state correctly.

Step 5: Integration into Larger Systems

Uniform sampling of rectangles is rarely a standalone concern. It becomes critical in pipelines like:

• Physics engines: Sampling particle positions within collision shapes (e.g., rotated boxes).
• Computer graphics: Generating light paths through shadow maps or path tracing.
• Scientific computing: Modeling neutron transport through irregular detectors.

In these contexts, the rectangle’s sampling method must align with the system’s numerical stability and performance requirements. Here's one way to look at it: photon mapping might require stratified sampling instead of uniform sampling to reduce variance.

Conclusion

Uniform sampling of rectangles is a foundational yet often underestimated task. Its impact spans disciplines—from physics simulations to software testing—where non-uniform coverage can introduce silent biases or catastrophic failures. By rigorously defining rectangle representations, validating inputs, and implementing efficient sampling algorithms, developers ensure robustness across applications. The key takeaway is that geometry is not just about shapes; it’s about how we interact with them. A well-designed sampling pipeline doesn’t just generate points—it guarantees confidence in the correctness of the systems that rely on them. Whether you’re tracing photons, simulating particles, or fuzzing code, the rectangle’s uniform sampling is a quiet but critical enabler of precision.