AlgebraGeometryLab

Library "AlgebraGeometryLab"
Algebra & 2D geometry utilities absent from Pine built-ins.
Rigorous, no-repaint, export-ready: vectors, robust roots, linear solvers, 2x2/3x3 det/inverse,
symmetric 2x2 eigensystem, orthogonal regression (TLS), affine transforms, intersections,
distances, projections, polygon metrics, point-in-polygon, convex hull (monotone chain),
Bezier/Catmull-Rom/Barycentric tools.

clamp(x, lo, hi)
  clamp to [lo, hi]
  Parameters:
    x (float)
    lo (float)
    hi (float)

near(a, b, atol, rtol)
  approximately equal with relative+absolute tolerance
  Parameters:
    a (float)
    b (float)
    atol (float)
    rtol (float)

sgn(x)
  sign as {-1,0,1}
  Parameters:
    x (float)

hypot(x, y)
  stable hypot (sqrt(x^2+y^2))
  Parameters:
    x (float)
    y (float)

method length(v)
  Namespace types: Vec2
  Parameters:
    v (Vec2)

method length2(v)
  Namespace types: Vec2
  Parameters:
    v (Vec2)

method normalized(v)
  Namespace types: Vec2
  Parameters:
    v (Vec2)

method add(a, b)
  Namespace types: Vec2
  Parameters:
    a (Vec2)
    b (Vec2)

method sub(a, b)
  Namespace types: Vec2
  Parameters:
    a (Vec2)
    b (Vec2)

method muls(v, s)
  Namespace types: Vec2
  Parameters:
    v (Vec2)
    s (float)

method dot(a, b)
  Namespace types: Vec2
  Parameters:
    a (Vec2)
    b (Vec2)

method crossz(a, b)
  Namespace types: Vec2
  Parameters:
    a (Vec2)
    b (Vec2)

method rotate(v, ang)
  Namespace types: Vec2
  Parameters:
    v (Vec2)
    ang (float)

method apply(v, T)
  Namespace types: Vec2
  Parameters:
    v (Vec2)
    T (Affine2)

affine_identity()
  identity transform

affine_translate(tx, ty)
  translation
  Parameters:
    tx (float)
    ty (float)

affine_rotate(ang)
  rotation about origin
  Parameters:
    ang (float)

affine_scale(sx, sy)
  scaling about origin
  Parameters:
    sx (float)
    sy (float)

affine_rotate_about(ang, px, py)
  rotation about pivot (px,py)
  Parameters:
    ang (float)
    px (float)
    py (float)

affine_compose(T2, T1)
  compose T2∘T1 (apply T1 then T2)
  Parameters:
    T2 (Affine2)
    T1 (Affine2)

quadratic_roots(a, b, c)
  Real roots of ax^2 + bx + c = 0 (numerically stable)
  Parameters:
    a (float)
    b (float)
    c (float)
  Returns: [int n, float r1, float r2] with n∈{0,1,2}; r1<=r2 when n=2.

cubic_roots(a, b, c, d)
  Real roots of ax^3+bx^2+cx+d=0 (Cardano; returns up to 3 real roots)
  Parameters:
    a (float)
    b (float)
    c (float)
    d (float)
  Returns: [int n, float r1, float r2, float r3] (valid r2/r3 only if n>=2/n>=3)

det2(a, b, c, d)
  det2 of [a b; c d]
  Parameters:
    a (float)
    b (float)
    c (float)
    d (float)

inv2(a, b, c, d)
  inverse of 2x2; returns [ok, ia, ib, ic, id]
  Parameters:
    a (float)
    b (float)
    c (float)
    d (float)

solve2(a, b, c, d, e, f)
  solve 2x2 * [x;y] = [e;f] via Cramer
  Parameters:
    a (float)
    b (float)
    c (float)
    d (float)
    e (float)
    f (float)

det3(a11, a12, a13, a21, a22, a23, a31, a32, a33)
  det3 of 3x3
  Parameters:
    a11 (float)
    a12 (float)
    a13 (float)
    a21 (float)
    a22 (float)
    a23 (float)
    a31 (float)
    a32 (float)
    a33 (float)

inv3(a11, a12, a13, a21, a22, a23, a31, a32, a33)
  inverse 3x3; returns [ok, i11..i33]
  Parameters:
    a11 (float)
    a12 (float)
    a13 (float)
    a21 (float)
    a22 (float)
    a23 (float)
    a31 (float)
    a32 (float)
    a33 (float)

eig2_symmetric(a, b, d)
  symmetric 2x2 eigensystem: [[a,b],[b,d]]
  Parameters:
    a (float)
    b (float)
    d (float)
  Returns: [lambda_max, v1x, v1y, lambda_min, v2x, v2y] with unit eigenvectors

tls_line(xs, ys)
  Orthogonal (total least squares) regression line through point cloud
Input arrays must be same length N>=2. Returns line in normal form n•x + c = 0
  Parameters:
    xs (array<float>)
    ys (array<float>)
  Returns: [ok, nx, ny, c, cx, cy] where (nx,ny) unit normal; (cx,cy) centroid.

orient(a, b, c)
  orientation (signed area*2): >0 CCW, <0 CW, 0 collinear
  Parameters:
    a (Vec2)
    b (Vec2)
    c (Vec2)

project_point_line(p, a, d)
  project point p onto infinite line through a with direction d
  Parameters:
    p (Vec2)
    a (Vec2)
    d (Vec2)
  Returns: [projVec2, t] where proj = a + t*d

closest_point_segment(p, a, b)
  closest point on segment [a,b] to p
  Parameters:
    p (Vec2)
    a (Vec2)
    b (Vec2)
  Returns: [closestVec2, t] where t∈[0,1] on segment

dist_point_line(p, a, d)
  distance from point to line (infinite)
  Parameters:
    p (Vec2)
    a (Vec2)
    d (Vec2)

dist_point_segment(p, a, b)
  distance from point to segment [a,b]
  Parameters:
    p (Vec2)
    a (Vec2)
    b (Vec2)

intersect_lines(p1, d1, p2, d2)
  line-line intersection: L1: p1+d1*t, L2: p2+d2*u
  Parameters:
    p1 (Vec2)
    d1 (Vec2)
    p2 (Vec2)
    d2 (Vec2)
  Returns: [ok, ix, iy, t, u]

intersect_segments(s1, s2)
  segment-segment intersection (closed segments)
  Parameters:
    s1 (Segment2)
    s2 (Segment2)
  Returns: [kind, ix, iy] where kind: 0=no, 1=proper point, 2=overlap (ix/iy=na)

circumcircle(a, b, c)
  circle through 3 non-collinear points
  Parameters:
    a (Vec2)
    b (Vec2)
    c (Vec2)

intersect_circle_line(C, p, d)
  intersections of circle and line (param p + d t)
  Parameters:
    C (Circle2)
    p (Vec2)
    d (Vec2)
  Returns: [n, x1,y1, x2,y2] with n∈{0,1,2}

intersect_circles(A, B)
  circle-circle intersection
  Parameters:
    A (Circle2)
    B (Circle2)
  Returns: [n, x1,y1, x2,y2] with n∈{0,1,2}

polygon_area(xs, ys)
  signed area (shoelace). Positive if CCW.
  Parameters:
    xs (array<float>)
    ys (array<float>)

polygon_centroid(xs, ys)
  polygon centroid (for non-self-intersecting). Fallback to vertex mean if area≈0.
  Parameters:
    xs (array<float>)
    ys (array<float>)

point_in_polygon(px, py, xs, ys)
  point-in-polygon test (ray casting). Returns true if inside; boundary counts as inside.
  Parameters:
    px (float)
    py (float)
    xs (array<float>)
    ys (array<float>)

convex_hull(xs, ys)
  convex hull (monotone chain). Returns array<int> of hull vertex indices in CCW order.
Uses array.sort_indices(xs) (ascending by x). Ties on x are handled; result is deterministic.
  Parameters:
    xs (array<float>)
    ys (array<float>)

lerp(a, b, t)
  linear interpolate between a and b
  Parameters:
    a (float)
    b (float)
    t (float)

bezier2(p0, p1, p2, t)
  quadratic Bezier B(t) for points p0,p1,p2
  Parameters:
    p0 (Vec2)
    p1 (Vec2)
    p2 (Vec2)
    t (float)

bezier3(p0, p1, p2, p3, t)
  cubic Bezier B(t) for p0,p1,p2,p3
  Parameters:
    p0 (Vec2)
    p1 (Vec2)
    p2 (Vec2)
    p3 (Vec2)
    t (float)

catmull_rom(p0, p1, p2, p3, t, alpha)
  Catmull-Rom interpolation (centripetal form when alpha=0.5)
t∈[0,1], returns point between p1 and p2
  Parameters:
    p0 (Vec2)
    p1 (Vec2)
    p2 (Vec2)
    p3 (Vec2)
    t (float)
    alpha (float)

barycentric(A, B, C, P)
  barycentric coordinates of P wrt triangle ABC
  Parameters:
    A (Vec2)
    B (Vec2)
    C (Vec2)
    P (Vec2)
  Returns: [ok, wA, wB, wC]

point_in_triangle(A, B, C, P)
  point-in-triangle using barycentric (boundary included)
  Parameters:
    A (Vec2)
    B (Vec2)
    C (Vec2)
    P (Vec2)

Vec2
  Fields:
    x (series float)
    y (series float)

Line2
  Fields:
    p (Vec2)
    d (Vec2)

Segment2
  Fields:
    a (Vec2)
    b (Vec2)

Circle2
  Fields:
    c (Vec2)
    r (series float)

Affine2
  Fields:
    a (series float)
    b (series float)
    c (series float)
    d (series float)
    tx (series float)
    ty (series float)