@woosh/meep-engine

export class Subspan { /** * * @param {number} dim dimension count * @param {PointSet} s * @param {number} k */ constructor(dim: number, s: PointSet, k: number); /** * @type {PointSet} */ S: PointSet; /** * reserve bit-field size * @type {BitSet} */ membership: BitSet; /** * * @type {number} */ dim: number; /** * * @type {Int32Array} */ members: Int32Array; /** * DxD square matrix, where D is number of dimensions * @type {number[][]} */ Q: number[][]; /** * DxD square matrix, where D is number of dimensions * @type {number[][]} */ R: number[][]; /** * D sized vector * @type {number[]} */ u: number[]; /** * D sized vector * @type {number[]} */ w: number[]; r: number; /** * Givens C coefficient * @type {number} */ c: number; /** * Givens S coefficient * @type {number} */ s: number; dimension(): number; /** * The size of the instance's set M, a number between 0 and `dim+1`. * * Complexity: O(1). * * @returns {int} |M| */ size(): int; /** * Whether S[i] is a member of M. * * Complexity: O(1) * * @param {int} i * the "global" index into S * @returns {boolean} true iff S[i] is a member of M */ isMember(i: int): boolean; /** * The global index (into S) of an arbitrary element of M. * * Precondition: `size()>0` * * Postcondition: `isMember(anyMember())` * @returns {number} */ anyMember(): number; /** * The index (into S) of the ith point in M. The points in M are * internally ordered (in an arbitrary way) and this order only changes when {@link add()} or * {@link remove()} is called. * * Complexity: O(1) * * @param {number} i * the "local" index, 0 ≤ i < `size()` * @return {number} j such that S[j] equals the ith point of M */ globalIndex(i: number): number; /** * Short-hand for code readability to access element (i,j) of a matrix that is stored in a * one-dimensional array. * * @param {number} i * zero-based row number * @param {number} j * zero-based column number * @return {number} the index into the one-dimensional array to get the element at position (i,j) in * the matrix * @private */ private ind; /** * The point `members[r]` is called the origin. * * @return {number} index into S of the origin. * @private */ private origin; /** * Determine the Givens coefficients (c,s) satisfying * * <pre> * c * a + s * b = +/- (a^2 + b^2) c * b - s * a = 0 * </pre> * * We don't care about the signs here, for efficiency, so make sure not to rely on them anywhere. * * Source: "Matrix Computations" (2nd edition) by Gene H. B. Golub & Charles F. B. Van Loan * (Johns Hopkins University Press, 1989), p. 216. * * Note that the code of this class sometimes does not call this method but only mentions it in a * comment. The reason for this is performance; Java does not allow an efficient way of returning * a pair of doubles, so we sometimes manually "inline" `givens()` for the sake of * performance. * @param {number} a * @param {number} b * @private */ private givens; /** * Appends the new column u (which is a member field of this instance) to the right of A * = QR, updating Q and R. It assumes r to still be the old value, i.e., * the index of the column used now for insertion; r is not altered by this routine and * should be changed by the caller afterwards. * * Precondition: `r<dim` * @private */ private appendColumn; /** * Adds the point S[index] to the instance's set M. * * Precondition: `!isMember(index)` * * Complexity: O(dim^2). * * @param {number} index index into S of the point to add */ add(index: number): void; /** * Computes the vector w directed from point p to v, where v is the * point in aff(M) that lies nearest to p. * * Precondition: `size()>0` * * Complexity: O(dim^2) * * @param {number[]} p * @param {number[]} w Euclidean coordinates of point p * @return {number} the squared length of w */ shortestVectorToSpan(p: number[], w: number[]): number; /** * Use this for testing only; the method allocates additional storage and copies point * coordinates. * @return {number} */ representationError(): number; /** * Calculates the `size()`-many coefficients in the representation of p as an affine * combination of the points M. * * The ith computed coefficient `lambdas[i] `corresponds to the ith point in * M, or, in other words, to the point in S with index `globalIndex(i)`. * * Complexity: O(dim^2) * * Preconditions: c lies in the affine hull aff(M) and size() > 0. * @param {number[]|Float64Array} p * @param {number[]|Float64Array} lambdas */ findAffineCoefficients(p: number[] | Float64Array, lambdas: number[] | Float64Array): void; /** * Given R in lower Hessenberg form with subdiagonal entries 0 to `pos-1` already all * zero, clears the remaining subdiagonal entries via Givens rotations. * @param {number} pos * @private */ private hessenberg_clear; /** * Update current QR-decomposition A = QR to * * <pre> * A + u * [1,...,1] = Q' R'. * </pre> * @private */ private special_rank_1_update; /** * * @param {number} index */ remove(index: number): void; } import { BitSet } from "../../../binary/BitSet.js"; //# sourceMappingURL=Subspan.d.ts.map