SparseSlices

Bit reported by scatterAxpyChecked when a product or updated accumulator value is not finite.

Bit reported by scatterAxpyChecked when nonzero operands produce a zero product.

Maximum absolute finite value whose row is active. Inactive entries are ignored, empty active support returns zero, and any active NaN or infinity returns NaN.

Clears the selected values and marks entries without consuming or changing touched.

The two state arrays must have the same logical dimension. The touched window, including an empty window at the array end, and every selected index are validated before mutation. Selected indices must be unique as a caller precondition; verifying uniqueness without temporary storage would require quadratic work. Values are written as positive zero and marks as zero.

Writes touched entries as gatherTouched, then clears every visited accumulator and mark entry. Clearing includes exact zeroes omitted by compaction. The caller resets its touched count to zero after the call; touched storage itself is deliberately left intact for reuse.

Writes touched accumulator entries in touched order and returns the number written. When compactExactZeros is true, both signed zeroes are omitted; NaN and infinities are retained. The accumulator and touched support are left unchanged.

Writes relative entry positions for active nonzero entries meeting both caller thresholds.

columnMaximum, absoluteTolerance, and relativeThreshold must be finite and nonnegative. The output reserves count positions before filtering. Nonfinite active entries are omitted: a maximum produced by activeColumnMaxAbs would already be NaN, so a finite maximum means they are not eligible arithmetic data.

Reduces indexed products into initial in strict input order and latches arithmetic diagnostics.

Each product is evaluated once, then added to or subtracted from the running result once according to subtractProducts. ARITHMETIC_NONFINITE reports a nonfinite initial value, operand, product, or updated result. ARITHMETIC_NONZERO_PRODUCT_UNDERFLOW reports two nonzero finite operands whose product is zero. Existing status bits are preserved, and the IEEE result is returned rather than converted to an exception. A zero updated sum is not classified as addition underflow because it may be exact cancellation.

Status and input windows and every index are validated before any arithmetic is evaluated. Repeated and unsorted indices are permitted and contribute in their supplied order. values and dense may alias.

Accumulates alpha * values(k) at indices(k) and returns the new total touched count.

A first touch initializes the accumulator entry from positive zero, writes epoch to its mark, and appends the index once in input order. Already touched entries keep their original position. Exact cancellation does not remove support. epoch must be nonzero and is caller-managed; marks must be reset before epoch reuse or wrap. The existing touched slice must contain every entry encountered here whose mark already equals epoch. This is a trusted precondition: the existing touched slice and its marks are not scanned. Capacity is required only for indices whose mark does not yet equal epoch.

Zero alpha is evaluated, not treated as a no-op. Thus finite values still become touched and 0 * infinity produces NaN according to IEEE 754 arithmetic.

Performs scatterAxpy while latching arithmetic diagnostics into arithmeticStatus at statusOffset.

ARITHMETIC_NONFINITE is set when a multiplication or updated accumulator value is nonfinite. ARITHMETIC_NONZERO_PRODUCT_UNDERFLOW is set when two nonzero operands produce a zero product. Existing bits in the status element are preserved, allowing one caller-owned element to collect diagnostics across repeated scatters. The IEEE result is always written, and each product and sum is evaluated exactly once.