/**
 * Extracts the lowest set bit and turns it from one hot format
 * into a number between 0 and 31.
 *
 * @param low The 32bit unsigned binary number to extract bits from.
 * @return {number} The extracted lowest bit offset.
 */
export declare function extractOneHotLow(low: number): number;
/**
 * 32 bit pop count, count hamming weight/number of bits set in x
 *
 * @param x 32bit unsigned integer.
 * @return {number} The number of bits set high in the 32bit integer.
 */
export declare function pop32(x: number): number;
/**
 * Add a single item to the compacted elements count that would result from using the 32-bit index
 * compaction across the supplied span, but using a retained state machine so it can be done
 * incrementally.
 *
 * It is expected the elements are in ascending order.
 *
 * Use this to determine the buffer size to allocate.
 *
 * stateBuffer needs at least 2 elements at stateBufferOffset.
 *
 * @param value
 * @param stateBuffer
 * @param stateBufferOffset
 * @return {number} The current count.
 */
export declare function addCompactedElementCount32State(value: number, stateBuffer: Int32Array, stateBufferOffset?: number): number;
/**
 * Appends an item to the compacted element set in output buffer, the outputBuffer should be
 * pre-allocated using the count size obtained earlier using addCompactedElementCount32State
 * run oxer the same set to make sure there is enough room for all the set elements.
 *
 * It's expected that all xalues are added in ascending order.
 *
 * @param value
 * @param stateBuffer
 * @param outputBuffer
 * @param stateBufferOffset
 * @param outputOffset
 * @return {number} The current count.
 */
export declare function addCompactedElement32State(value: number, stateBuffer: Int32Array, outputBuffer: Uint32Array, stateBufferOffset?: number, outputOffset?: number): number;
/**
 * Get the compacted count from the state buffer.
 *
 * @param stateBuffer
 * @param stateBufferOffset
 * @return {number} The compacted element count at a particular offset.
 */
export declare function getCountCompactedElements32State(stateBuffer: Int32Array, stateBufferOffset?: number): number;
/**
 * Set-up a compacted element count state record.
 *
 * @param stateBuffer
 * @param stateBufferOffset
 */
export declare function initCountCompactedElements32State(stateBuffer: Int32Array, stateBufferOffset?: number): void;
/**
 * Count the number of compacted elements that would result from using the
 * 32-bit index compaction across the supplied span.
 *
 *  Use this to determine the buffer size to allocate
 *
 * @param buffer
 * @param offset
 * @param end
 * @return {number} The number of compacted elements in a buffer run.
 */
export declare function countCompactedElements32(buffer: Uint32Array, offset?: number, end?: number): number;
/**
 * Compact a whole set of slements, in sorted order, from the input array range into
 * the output array in a single,
 * non incremental pass.
 *
 * The output array has to contain enough elements in the range, which the count
 * should be obtained using countCompactedElements32
 *
 * @param output
 * @param outputOffset
 * @param input
 * @param inputOffset
 * @param inputEnd
 */
export declare function compactElements32(output: Uint32Array, outputOffset: number, input: Uint32Array, inputOffset?: number, inputEnd?: number): void;
//# sourceMappingURL=bit_operations.d.ts.map