INTERFACE RealPoint;

Basic definitions for geometric points.

Index: points; geometry, points

IMPORT Axis, Point;

TYPE T = RECORD h, v: REAL END;

CONST Origin = T { 0.0, 0.0 };

PROCEDURE FromCoords (h, v: REAL): T RAISES {};

Build a point out of REALs

PROCEDURE FromAxes (axis: Axis.T; n, m: REAL): T RAISES {};

If axis=Hor then FromCoords (n,m), else FromCoords (m,n)

PROCEDURE Float(p: Point.T): T;

Same as FromCoords(FLOAT(p.h),FLOAT(p.v))

PROCEDURE Trunc(p: T): Point.T;

Same as Point.FromCoords(TRUNC(p.h),TRUNC(p.v))

PROCEDURE Floor(p: T): Point.T;

Same as Trunc, but rounds down (instead of towards zero)

PROCEDURE Round(p: T): Point.T;

Same as Trunc, but rounds to nearest integer (instead of towards zero)

PROCEDURE DistSquare (READONLY p, q: T): REAL RAISES {};

square of the distance between p and q

PROCEDURE Minus (READONLY p: T): T RAISES {};

-p.h,-p.v

PROCEDURE Add (READONLY p, q: T): T RAISES {};

Coordinate-wise addition

PROCEDURE Sub (READONLY p, q: T): T RAISES {};

Coordinate-wise subtraction

PROCEDURE Mul (READONLY p: T; n: REAL): T RAISES {};

Multiply both coordinates of p by n

PROCEDURE Div (READONLY p: T; n: REAL): T RAISES {};

Divide both coordinates of p by n

PROCEDURE Mod (READONLY p: T; n: REAL): T RAISES {};

Mod both coordinates of p by n

PROCEDURE Scale (READONLY p: T; num, den: REAL): T RAISES {};

Div (Mul (p, num), den)

PROCEDURE Min (READONLY p, q: T): T RAISES {};

Coordinate-wise min

PROCEDURE Max (READONLY p, q: T): T RAISES {};

Coordinate-wise max

PROCEDURE Move (READONLY p, dp: T): T RAISES {};

Increment p.h by dp.h and p.v by dp.v; same as Add

PROCEDURE MoveH (READONLY p: T; dh: REAL): T RAISES {};

Increment p.h by dh

PROCEDURE MoveV (READONLY p: T; dv: REAL): T RAISES {};

Increment p.v by dv

PROCEDURE MoveHV (READONLY p: T; dh, dv: REAL): T RAISES {};

Increment p.h by dh and p.v by dv

PROCEDURE Equal (READONLY p, q: T): BOOLEAN RAISES {};

Point equality

PROCEDURE Less (READONLY p, q: T): BOOLEAN RAISES {};

Whether p.h < q.h and p.v < q.v

PROCEDURE LessEq (READONLY p, q: T): BOOLEAN RAISES {};

Whether p.h <= q.h and p.v <= q.v

PROCEDURE New (READONLY value: T): REF T;

Allocates and initializes a new heap value

PROCEDURE NewArray (size: CARDINAL;  READONLY value := Origin): REF ARRAY OF T;

Allocates a new array from the heap and initializes all its elements with the given value

PROCEDURE UntracedNew (READONLY value: T): UNTRACED REF T;

Allocates and initializes a new untraced value

PROCEDURE UntracedNewArray (size: CARDINAL; READONLY value := Origin):
                                                       UNTRACED REF ARRAY OF T;

Allocates a new untraced array from the heap and initializes all its elements with the given value

PROCEDURE Compare (READONLY a, b: T): INTEGER;

== RETURN (-1 if Lt (a, b), 0 if Eq (a, b), +1 o. w.)

PROCEDURE Lt (READONLY a, b: T): BOOLEAN;

== RETURN (a.h < b.h) OR ((a.h = b.h) AND (a.v < b.v))

PROCEDURE Eq (READONLY a, b: T): BOOLEAN;

== RETURN (a = b)

PROCEDURE Hash (READONLY a: T): INTEGER;

== RETURN a suitable hash value

END RealPoint.