Struct IntVec

pub struct IntVec<E: Endianness, W: BitWrite<E>, C: Codec<E, W>> { /* private fields */ }

A compressed vector of integers.

The IntVec stores values in a compressed bitstream along with sample offsets for fast random access. The type is generic over an endianness (E) and codec (C).

Type Parameters

• E: Endianness marker (e.g. BE or LE).
• C: The codec used for compression. Must implement Codec<E, MyBitWrite<E>, MyBitRead<E>>.

Fields

• data: The compressed bitstream data.
• samples: Offsets (in bits) into data for every k-th value, used to jump-start decoding.
• k: The sampling period.
• len: The total number of integers stored.
• codec_param: Extra parameters for C.

Examples

use compressed_intvec::intvec::BEIntVec;
use compressed_intvec::codecs::GammaCodec;

// Create a compressed vector using a codec without extra parameters.
let input = vec![1, 2, 3, 4, 5];
let intvec = BEIntVec::<GammaCodec>::from(&input, 2).unwrap();
let value = intvec.get(3);
assert_eq!(value, 4);
assert_eq!(intvec.len(), 5);

Implementations

impl<C: Codec<BE, BufBitWriter<BE, MemWordWriterVec<u64, Vec<u64>>>>> IntVec<BigEndian, BufBitWriter<BigEndian, MemWordWriterVec<u64, Vec<u64>>>, C>

where C::Params: Copy,

pub fn from_with_param( input: &[u64], k: usize, codec_param: C::Params, ) -> Result<Self, Box<dyn Error>>

Creates a new BEIntVec from a vector of unsigned 64-bit integers.

Values are encoded with the specified codec parameter.

Arguments

• input: The values to be compressed.
• k: The sampling rate (every k-th value is stored as a sample).
• codec_param: Parameters for the codec.

Examples

use compressed_intvec::intvec::BEIntVec;
use compressed_intvec::codecs::ExpGolombCodec;

let input = vec![1, 5, 3, 1991, 42];
let intvec = BEIntVec::<ExpGolombCodec>::from_with_param(&input, 2, 3).unwrap();

let value = intvec.get(3);
assert_eq!(value, 1991);

pub fn get(&self, index: usize) -> u64

Retrieves the value at the given index.

Panics if the index is out of bounds.

Examples

use compressed_intvec::intvec::BEIntVec;
use compressed_intvec::codecs::GammaCodec;

let input = vec![1, 5, 3, 12, 42];
let intvec = BEIntVec::<GammaCodec>::from(&input, 2).unwrap();
let value = intvec.get(3);
assert_eq!(value, 12);

pub fn into_vec(self) -> Vec<u64>

Returns the original vector of integers.

This operation is expensive as it requires decoding the entire bitstream.

Examples

use compressed_intvec::intvec::BEIntVec;
use compressed_intvec::codecs::GammaCodec;

let input = vec![43, 12, 5, 1991, 42];
let intvec = BEIntVec::<GammaCodec>::from(&input, 2).unwrap();
let values = intvec.into_vec();
assert_eq!(values, input);

pub fn iter(&self) -> BEIntVecIter<'_, C>

Returns an iterator over the decompressed integer values stored in this compressed vector.

The iterator decodes values on the fly and does not modify the underlying data.

Example

use compressed_intvec::intvec::BEIntVec;
use compressed_intvec::codecs::GammaCodec;

let input = vec![1, 5, 3, 12, 42];
let intvec = BEIntVec::<GammaCodec>::from(&input, 2).unwrap();

// Iterate over the vector and print each value.
for (i, value) in intvec.iter().enumerate() {
    assert_eq!(value, input[i]);
}

pub fn limbs(&self) -> Vec<u64>

Returns a clone of the internal bitstream data as a vector of 64-bit unsigned integers.

This can be used for debugging or low-level operations where access to the raw compressed limb data is required.

pub fn len(&self) -> usize

Returns the number of integers stored in the compressed vector.

This value represents the total count of decompressed integers.

pub fn get_sampling_rate(&self) -> usize

Returns the sampling rate used by the compressed vector.

pub fn get_samples(&self) -> Vec<usize>

Returns the codec parameter used by the compressed vector.

pub fn is_empty(&self) -> bool

Checks whether the compressed vector contains no elements.

Returns true if the vector is empty, and false otherwise.

impl<C: Codec<BE, BufBitWriter<BE, MemWordWriterVec<u64, Vec<u64>>>, Params = ()>> IntVec<BigEndian, BufBitWriter<BigEndian, MemWordWriterVec<u64, Vec<u64>>>, C>

Convenience constructor for codecs with no extra runtime parameter.

pub fn from(input: &[u64], k: usize) -> Result<Self, Box<dyn Error>>

impl<C> IntVec<LittleEndian, BufBitWriter<LittleEndian, MemWordWriterVec<u64, Vec<u64>>>, C>

where C: Codec<LE, BufBitWriter<LE, MemWordWriterVec<u64, Vec<u64>>>>, C::Params: Copy,

pub fn from_with_param( input: &[u64], k: usize, codec_param: C::Params, ) -> Result<Self, Box<dyn Error>>

Creates a new LEIntVec from a vector of unsigned 64-bit integers.

Values are encoded with the specified codec parameter.

Arguments

• input: The values to be compressed.
• k: The sampling rate (every k-th value is stored as a sample).
• codec_param: Parameters for the codec.

Examples

use compressed_intvec::intvec::LEIntVec;
use compressed_intvec::codecs::ExpGolombCodec;

let input = vec![1, 5, 3, 1991, 42];
let intvec = LEIntVec::<ExpGolombCodec>::from_with_param(&input, 2, 3).unwrap();

let value = intvec.get(3);
assert_eq!(value, 1991);

pub fn get(&self, index: usize) -> u64

Retrieves the value at the given index.

Returns None if the index is out of bounds.

Examples

use compressed_intvec::intvec::LEIntVec;
use compressed_intvec::codecs::GammaCodec;

let input = vec![1, 5, 3, 1991, 42];
let intvec = LEIntVec::<GammaCodec>::from(&input, 2).unwrap();
let value = intvec.get(3);
assert_eq!(value, 1991);

pub fn into_vec(self) -> Vec<u64>

Returns the original vector of integers.

This operation is expensive as it requires decoding the entire bitstream.

Examples

use compressed_intvec::intvec::LEIntVec;
use compressed_intvec::codecs::GammaCodec;

let input = vec![43, 12, 5, 1991, 42];
let intvec = LEIntVec::<GammaCodec>::from(&input, 2).unwrap();
let values = intvec.into_vec();
assert_eq!(values, input);

pub fn iter(&self) -> LEIntVecIter<'_, C>

Returns an iterator over the values stored in the vector.

pub fn limbs(&self) -> Vec<u64>

Returns a clone of the internal bitstream data as a vector of 64-bit unsigned integers.

This can be used for debugging or low-level operations where access to the raw compressed limb data is required.

pub fn len(&self) -> usize

Returns the number of integers stored in the compressed vector.

This value represents the total count of decompressed integers.

pub fn get_sampling_rate(&self) -> usize

Returns the sampling rate used by the compressed vector.

pub fn get_samples(&self) -> Vec<usize>

Returns the codec parameter used by the compressed vector.

pub fn is_empty(&self) -> bool

Checks whether the compressed vector contains no elements.

Returns true if the vector is empty, and false otherwise.

impl<C: Codec<LE, BufBitWriter<LE, MemWordWriterVec<u64, Vec<u64>>>, Params = ()>> IntVec<LittleEndian, BufBitWriter<LittleEndian, MemWordWriterVec<u64, Vec<u64>>>, C>

Convenience constructor for codecs with no extra runtime parameter.

pub fn from(input: &[u64], k: usize) -> Result<Self, Box<dyn Error>>

Trait Implementations

impl<E: Clone + Endianness, W: Clone + BitWrite<E>, C: Clone + Codec<E, W>> Clone for IntVec<E, W, C>

where C::Params: Clone,

fn clone(&self) -> IntVec<E, W, C>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<E: Endianness, W: BitWrite<E>, C: Codec<E, W>> CopyType for IntVec<E, W, C>

where Vec<u64>: MemSize, Vec<usize>: MemSize, PhantomData<C>: MemSize, usize: MemSize, C::Params: MemSize, PhantomData<E>: MemSize,

type Copy = False

impl<E: Debug + Endianness, W: Debug + BitWrite<E>, C: Debug + Codec<E, W>> Debug for IntVec<E, W, C>

where C::Params: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<E: Endianness, W: BitWrite<E>, C: Codec<E, W>> MemDbgImpl for IntVec<E, W, C>

where Vec<u64>: MemDbgImpl, Vec<usize>: MemDbgImpl, PhantomData<C>: MemDbgImpl, usize: MemDbgImpl, C::Params: MemDbgImpl, PhantomData<E>: MemDbgImpl,

fn _mem_dbg_rec_on( &self, _memdbg_writer: &mut impl Write, _memdbg_total_size: usize, _memdbg_max_depth: usize, _memdbg_prefix: &mut String, _memdbg_is_last: bool, _memdbg_flags: DbgFlags, ) -> Result

impl<E: Endianness, W: BitWrite<E>, C: Codec<E, W>> MemSize for IntVec<E, W, C>

where Vec<u64>: MemSize, Vec<usize>: MemSize, PhantomData<C>: MemSize, usize: MemSize, C::Params: MemSize, PhantomData<E>: MemSize,

fn mem_size(&self, _memsize_flags: SizeFlags) -> usize

Return the (recursively computed) overall memory size of the structure in bytes.