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
*
*
* c * a + s * b = +/- (a^2 + b^2) c * b - s * a = 0
*
*
* 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: `rS[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
*
*
* A + u * [1,...,1] = Q' R'.
*
* @private
*/
private special_rank_1_update;
/**
*
* @param {number} index
*/
remove(index: number): void;
}
import { BitSet } from "../../../binary/BitSet.js";
//# sourceMappingURL=Subspan.d.ts.map