Core

import * as tf from "@polydera/trueform";

const pts = tf.random("float32", [100, 3]);
const offset = tf.ndarray([1, 0, -1]);   // shape [3]

const shifted = pts.add(offset);          // [100, 3] + [3] → [100, 3]
const scaled = pts.mul(2.0);              // [100, 3] * scalar → [100, 3]

pts.sum(0);          // method
tf.sum(pts, 0);      // free function — equivalent

await tf.async.sum(pts, 0);
await tf.async.sort(pts);

// From JavaScript data (number[] defaults to float64; JS numbers are doubles)
const a = tf.ndarray([1, 2, 3, 4, 5, 6], [2, 3]);    // float64, shape [2, 3]
const b = tf.ndarray(new Int32Array([0, 1, 2]));     // int32, shape [3]
const c = tf.ndarray(new Float32Array([1, 2, 3]), [1, 3]);
const d = tf.ndarray(new Float64Array([1, 2, 3]), [1, 3]);

// Filled arrays
const z = tf.zeros("float32", [100, 3]);
const z64 = tf.zeros("float64", [100, 3]);
const o = tf.ones("int32", [10]);
const f = tf.full("float32", [4, 4], 0.5);

// Identity matrix
const I = tf.eye("float32", 4);  // [4, 4]

// Sequences
const r = tf.arange("int32", 10);            // [0, 1, ..., 9]
const s = tf.arange("float32", 0, 1, 0.1);  // [0.0, 0.1, ..., 0.9]
const l = tf.linspace(0, 1, 11);             // [0.0, 0.1, ..., 1.0]

// Random
const rnd = tf.random("float32", [100, 3], -1, 1);

const pts = tf.ndarray([1,2,3, 4,5,6], [2, 3]);

pts.length;  // 6
pts.shape;   // [2, 3]
pts.ndim;    // 2
pts.dtype;   // "float64" — number[] inputs default to float64
pts.data;    // Float64Array([1, 2, 3, 4, 5, 6])

// Reshape in-place (must preserve total count)
pts.shape = [3, 2];

const vec = tf.ndarray([10, 20, 30]);
for (const v of vec) console.log(v);  // 10, 20, 30

const mat = tf.ndarray([1,2,3, 4,5,6], [2, 3]);
for (const row of mat) console.log(row.data);  // Float32Array([1,2,3]), ...

const pts = tf.ndarray([1,2,3, 4,5,6, 7,8,9], [3, 3]);

// Row view (zero-copy)
const row = pts.row(0);              // [1, 2, 3]

// Get: returns number for 1D, row view for nD
const val = pts.get(0);              // NDArray [1, 2, 3]

// Slice along axis 0 (zero-copy)
const first_two = pts.slice(0, 2);   // shape [2, 3]

const pts = tf.random("float32", [100, 3]);

// Single-axis: gather rows by index array
const ids = tf.ndarray(new Int32Array([0, 5, 10]));
const selected = pts.take(ids);          // shape [3, 3]
const same = tf.take(pts, ids);          // free function — equivalent

// Multi-axis: each argument selects along one axis
pts.take(null, 0);       // column 0 → shape [100]
pts.take(null, [0, 2]);  // columns 0 and 2 → shape [100, 2]
pts.take(5);             // row 5 squeezed → shape [3]
pts.take([0, 2]);        // rows 0 and 2 → shape [2, 3]

const indices = tf.ndarray(new Int32Array([2, 0, 1]), [3, 1]);
const gathered = pts.takeAlongAxis(indices, 1);

const mask = pts.take(null, 2).gt(0);    // z > 0
const above = pts.booleanIndex(mask);     // only rows where z > 0

const a = tf.random("float32", [100, 3]);
const b = tf.random("float32", [100, 3]);

const sum  = a.add(b);
const diff = a.sub(1.0);
const prod = a.mul(b);
const quot = a.div(2.0);
const rem  = a.mod(b);
const clmp = a.clip(0, 1);

// Matrix multiply (batch broadcast on leading dims)
const A = tf.random("float32", [4, 4]);
const B = tf.random("float32", [4, 4]);
const C = A.matMul(B);  // [4, 4]

a.add_(1.0).mul_(2.0).clip_(0, 10);

const mask = a.gt(0);       // element-wise a > 0
const eq   = a.eq(b);       // element-wise a == b

const combined = mask_a.and(mask_b);
const negated  = mask_a.not();
const either   = mask_a.or(mask_b);

const result = tf.where(mask, a, b);  // mask ? a : b, element-wise

const pts = tf.random("float32", [100, 3]);

// Scalar reductions (no axis → full reduction)
pts.sum();              // number
pts.min();              // number
pts.mean();             // number

// Per-axis reductions
pts.sum(0);             // shape [3] — sum each column
pts.norm(1);            // shape [100] — L2 norm of each row

// Free function form
tf.sum(pts, 0);         // equivalent to pts.sum(0)
tf.norm(pts, 1);        // equivalent to pts.norm(1)

// Async
await tf.async.sum(pts, 0);
await tf.async.norm(pts, 1);

pts.argmin();           // flat index of global minimum
pts.argmax(0);          // shape [3] — per-column argmax index

const mask = pts.gt(0);
mask.any();             // 1 if any true
mask.all();             // 1 if all true
mask.any(1);            // shape [100] — per-row any

const angles = tf.linspace(0, Math.PI, 100);

tf.sin(angles);    tf.sin_(angles);    // in-place
tf.cos(angles);    tf.cos_(angles);
tf.tan(angles);    tf.tan_(angles);

// Inverse
tf.asin(arr);      tf.asin_(arr);
tf.acos(arr);      tf.acos_(arr);
tf.atan(arr);      tf.atan_(arr);

// Two-argument (broadcasts). Async: tf.async.atan2
tf.atan2(y, x);

const a = tf.random("float32", [100, 3]);
const b = tf.random("float32", [100, 3]);

// Dot product along last axis. [N,3]·[N,3] → [N]. Scalar for 1D inputs.
tf.dot(a, b);

// Cross product (last axis must be 3). [N,3]×[N,3] → [N,3].
tf.cross(a, b);

// L2-normalize (copy and in-place)
tf.normalize(a, 1);      // per-row normalize → new array
tf.normalize_(a, 1);     // in-place

const arr = tf.ndarray(new Int32Array([3, 1, 4, 1, 5]));

// Method form
arr.sort();             // sorted copy: [1, 1, 3, 4, 5]
arr.sort_();            // sort in-place
arr.argsort();          // permutation indices (int32)

// Free function form
tf.sort(arr);           // equivalent to arr.sort()
tf.sort_(arr);          // equivalent to arr.sort_()
tf.argsort(arr);        // equivalent to arr.argsort()

// Async
await tf.async.sort(arr);
await tf.async.argsort(arr);

const a = tf.ndarray(new Int32Array([1, 2, 3, 4]));
const b = tf.ndarray(new Int32Array([2, 4, 5]));

tf.unique(a);              // [1, 2, 3, 4]
tf.setUnion(a, b);         // [1, 2, 3, 4, 5]
tf.setIntersection(a, b);  // [2, 4]
tf.setDifference(a, b);    // [1, 3] — elements in a not in b

const labels = tf.ndarray(new Int32Array([0, 1, 0, 2, 1, 0, 2, 2, 0]));

tf.bincount(labels);                           // int32 [4, 2, 3]
tf.bincount(labels, { minLength: 5 });         // int32 [4, 2, 3, 0, 0]

// Weighted → float32 sums per bin
const w = tf.ndarray(new Float32Array([0.5, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0]));
tf.bincount(labels, { weights: w });           // float32 weight sums

await tf.async.bincount(labels);

const x = tf.random("float32", [10000], -1, 1);

// Equal-width bins
const { counts, edges } = tf.histogram(x, { bins: 20, range: [-1, 1] });
// counts: int32 [20], edges: float32 [21]

// Auto range (min/max of x)
tf.histogram(x, { bins: 20 });

// Explicit edges
const userEdges = tf.ndarray(new Float32Array([-1, -0.5, 0, 0.5, 1]));
tf.histogram(x, { bins: userEdges });

// Probability density (PDF) — integrates to 1
const pdf = tf.histogram(x, { bins: 50, density: true });

// Weighted histogram
const weights = tf.random("float32", [10000]);
tf.histogram(x, { bins: 20, weights });        // float32 counts

await tf.async.histogram(x, { bins: 100 });

const pts = tf.zeros("float32", [100, 3]);

// Fill with scalar
pts.assign(1.0);

// Broadcast array
const row = tf.ndarray([1, 2, 3]);
pts.assign(row);                          // broadcast [3] → all rows

// Masked assignment (set where mask is true)
const mask = pts.take(null, 2).gt(0);
pts.assign(mask, 0.0);                    // zero out where z > 0

// Indexed assignment (set at given row indices)
const ids = tf.ndarray(new Int32Array([0, 5, 10]));
pts.assign(ids, row);                     // set rows 0, 5, 10

const a = tf.random("float32", [10, 3]);
const b = tf.random("float32", [10, 3]);

// Stack along new axis (all inputs must have identical shape)
tf.stack([a, b], 0);         // shape [2, 10, 3]

// Concatenate along existing axis
tf.concatenate([a, b], 0);   // shape [20, 3]

// Tile (repeat)
tf.tile(a, [2, 1]);          // shape [20, 3]

const pts = tf.random("float32", [100, 3]);

pts.flatten();              // shape [300]
pts.reshape([50, 6]);       // shape [50, 6]
pts.T;                      // shape [3, 100] — transpose shorthand
pts.transpose([1, 0]);      // explicit axis permutation

const row = pts.row(0);     // shape [3]
row.unsqueeze(0);           // shape [1, 3]
row.unsqueeze(0).squeeze(); // shape [3]

const f = tf.random("float32", [10, 3]);

f.as("int32");              // new array, truncated values
f.gt(0).as("int8");         // same-storage cast (bool → int8): zero-copy

const copy = arr.clone();  // deep copy — independent WASM buffer

// Create from offsets + data arrays
const obb = tf.offsetBlockedBuffer(
  tf.ndarray(new Int32Array([0, 3, 5]), [3]),     // offsets [N+1]
  tf.ndarray(new Int32Array([0, 1, 2, 3, 4]), [5]) // data
);
// obb.length === 2, obb.get(0).data → [0, 1, 2], obb.get(1).data → [3, 4]

// Use as paths for curves
const curves = tf.curves(obb, points);

// Returned by topology operations
const fm = mesh.faceMembership;

// Number of blocks
fm.length;

// Access individual blocks
const block = fm.get(0);    // NDArrayInt32 — faces adjacent to vertex 0

// Iterate over all blocks
for (const block of fm) {
  console.log(block.data);  // Int32Array view of this block
}

// Access underlying arrays
fm.offsets;  // NDArrayInt32 [N+1]
fm.data;     // NDArrayInt32 (flat packed data)

const p = tf.point(1, 2, 3);
p.type;    // "point"
p.shape;   // [3]
p.data;    // Float32Array([1, 2, 3])
p.sum();   // 6 — all NDArray operations work

// Single point
const p = tf.point(1, 2, 3);                      // shape [3]
p.isBatch;  // false
p.count;    // 1

// Batch of 100 points from flat data
const pts = tf.point(new Float32Array(300), 3);    // shape [100, 3]
pts.isBatch;  // true
pts.count;    // 100

// Batch from an NDArray (zero-copy)
const pts2 = tf.point(tf.random("float32", [50, 3]));

// Index into a batch
const first = pts.at(0);   // single Point, shape [3]

// ── Points and Vectors ──────────────────────────────────────────────
const p = tf.point(1, 2, 3);                                  // float32 [3]
const p64 = tf.point(1, 2, 3, { dtype: "float64" });          // float64 [3]
const v = tf.vector(0, 0, 1);                                 // float32 [3]

const pts = tf.point(new Float32Array(300), 3);               // batch [100, 3]
const pts64 = tf.point(new Float64Array(300), 3);             // batch [100, 3] float64
const pts2 = tf.point(tf.random("float32", [50, 3]));         // batch from NDArray (zero-copy)

// ── Segments, Rays, Lines ───────────────────────────────────────────
// Single — from two primitives
const seg = tf.segment(tf.point(0, 0, 0), tf.point(1, 1, 1));   // [2, 3]
const r   = tf.ray(tf.point(0, 0, 0), tf.vector(0, 0, 1));     // [2, 3]
const ln  = tf.line(tf.point(0, 0, 0), tf.vector(1, 0, 0));    // [2, 3]

// Batch — from two NDArrays with shape [N, 3]
const origins = tf.random("float32", [100, 3]);
const dirs    = tf.random("float32", [100, 3]);
const rays = tf.ray(origins, dirs);                              // [100, 2, 3]

// ── Triangles ───────────────────────────────────────────────────────
// Single — from three primitives
const tri = tf.triangle(tf.point(0,0,0), tf.point(1,0,0), tf.point(0,1,0));  // [3, 3]

// Batch — from three NDArrays with shape [N, 3]
const a = tf.random("float32", [50, 3]);
const b = tf.random("float32", [50, 3]);
const c = tf.random("float32", [50, 3]);
const tris = tf.triangle(a, b, c);                              // [50, 3, 3]

// ── Plane, AABB, Polygon ───────────────────────────────────────────
const pl  = tf.plane(tf.vector(0, 0, 1), 5.0);                  // [4]
const box = tf.aabb(tf.point(0, 0, 0), tf.point(1, 1, 1));     // [2, 3]
const meshBox = tf.aabbFrom(mesh);                              // from geometry
const ptsBox = tf.aabbFrom(points);                             // from NDArray
const poly = tf.polygon([tf.point(0,0,0), tf.point(1,0,0), tf.point(0,1,0)]);

const obb = tf.obbFrom(mesh);        // or tf.obbFrom(points)

obb.origin;   // NDArrayFloat32 [3] — corner point
obb.axes;     // NDArrayFloat32 [3, 3] — orthonormal axes (one per row)
obb.extent;   // NDArrayFloat32 [3] — full extents along each axis

const T = tf.makeTranslation(1, 0, 0);                    // three numbers
const T2 = tf.makeTranslation([1, 0, 0]);                 // or array
const T3 = tf.makeTranslation(someNDArray);                // or NDArray [3]

const R = tf.makeRotation(90, "z");                        // 90° around Z
const Rp = tf.makeRotation(45, [1, 0, 0], [0, 0, 5]);     // 45° around X, pivot at [0,0,5]

const Rr = tf.makeRandomRotation();                        // uniform random rotation
const Rr2 = tf.makeRandomRotation(centroid);               // random rotation around pivot

const Tinv = tf.inverted(T);                               // inverse of 4x4 affine
const M2dInv = tf.inverted(mat3x3);                        // inverse of 3x3 affine

// Three.js → trueform
const mat = tf.ndarray(threeMatrix4.elements, [4, 4]).T;

// trueform → Three.js
const m4 = new THREE.Matrix4().fromArray(tfMatrix.T.data);

const faces  = tf.ndarray(new Int32Array([0,1,2, 0,2,3, 0,3,1, 1,3,2]), [4, 3]);
const points = tf.ndarray(new Float32Array([0,0,0, 1,0,0, 0,1,0, 0,0,1]), [4, 3]);

const m = tf.mesh(faces, points);

m.numberOfFaces;   // 4
m.numberOfPoints;  // 4
m.faces;           // NDArrayInt32 [4, 3]
m.points;          // NDArrayFloat32 [4, 3]
m.dtype;           // "float32"

// Double-precision mesh
const points64 = tf.ndarray(new Float64Array([0,0,0, 1,0,0, 0,1,0, 0,0,1]), [4, 3]);
const m64 = tf.mesh(faces, points64);
m64.dtype;         // "float64"
m64.points;        // NDArrayFloat64 [4, 3]

// Topology is lazy — first access computes and caches
const fm = m.faceMembership;
const neighbors = fm.get(0);  // faces incident to vertex 0

const mel = m.manifoldEdgeLink;
// mel.row(0).data → Int32Array with 3 neighbor face IDs for face 0

// Precompute off the main thread (result cached on mesh)
await tf.async.computeNormals(m);
await tf.async.computeFaceMembership(m);
await tf.async.buildTree(m);

// Shallow copy — new handle sharing buffers, with own caches and cleared transformation
const view = m.shallowCopy();

// Pre-build the spatial AABB tree
m.buildTree();

// Apply a transformation
m.transformation = tf.makeRotation(90, "z");

// Free WASM memory immediately (idempotent, never required)
m.delete();

// From flat points
const pc = tf.pointCloud(tf.random("float32", [1000, 3]));

// From a Mesh (copies points, vertex link, and point normals)
const pc2 = tf.pointCloud(m);

pc.numberOfPoints;   // 1000
pc.points;           // NDArrayFloat32 [1000, 3]

pc.buildTree();                 // pre-build spatial tree
const view = pc.shallowCopy();  // new handle sharing buffers, own caches and pose
pc.delete();                    // immediate cleanup (idempotent, never required)

const c = tf.curves(paths, points);

c.length;    // number of paths
c.paths;     // OffsetBlockedBuffer — iterate or index into paths
c.points;    // NDArrayFloat32 [V, 3] — shared vertex pool

for (const path of c.paths) {
  console.log(path.data);  // Int32Array of vertex indices for this path
}

// Returned by tf.cleaned(), tf.reindexedByMask(), etc.
const { mesh, faceMap, pointMap } = tf.cleaned(m, { returnIndexMap: true });

faceMap.f;         // NDArrayInt32 — f[oldFaceId] = newFaceId
faceMap.keptIds;   // NDArrayInt32 — original face IDs that survived

const removed = faceMap.f.eq(faceMap.keptIds.length);  // boolean mask of removed elements