Struct PackedIntegers 

pub struct PackedIntegers { /* private fields */ }

An array of integers packed together in blocks using a variable number of bits for each integer, along with an index to allow fast random access.

Implementations

impl PackedIntegers

pub fn len(&self) -> usize

The number of integers packed into the array.

pub fn from_vec(data: Vec<u64>) -> Self

Build a packed array of integers from a vector.

This re-uses the space the vector is allocated in while building the packed array, though it may involve a re-allocation of the space to reduce the size at the end (it should never increase this allocation, though the additional size of the separate index may mean more space is used overall in some cases).

use ::packed_integer_array::PackedIntegers;
let input_data: Vec<u64> = vec![5, 138, 10, 90, 242, 312, 541, 48];
let packed = PackedIntegers::from_vec(input_data.clone());
assert_eq!(input_data.len(), packed.len());
for i in 0..input_data.len() {
    assert_eq!(Some(input_data[i]), packed.get(i));
}

pub fn from_iter<I, T>(iter: I) -> Self

where T: Into<u64>, I: IntoIterator<Item = T>,

Build a packed array of integers from an iterator.

use ::packed_integer_array::PackedIntegers;
let input_data: Vec<u64> = vec![5, 138, 10, 90, 242, 312, 541, 48];
let packed = PackedIntegers::from_iter(input_data.iter().cloned());
assert_eq!(input_data.len(), packed.len());
for i in 0..input_data.len() {
    assert_eq!(Some(input_data[i]), packed.get(i));
}

pub fn get(&self, idx: usize) -> Option<u64>

Get the integer at a specific index.

This operation should be fast, and does not involve unpacking many others of the packed integers or using a lot of memory for the unpacking.

Returns None for out-of-bounds.

use rand::prelude::*;
use ::packed_integer_array::PackedIntegers;
let mut rng = rand::thread_rng();
let len = rng.gen_range(137, 549);
let unpacked: Vec<u64> = (0..len).map(|_| rng.gen()).collect();
let packed = PackedIntegers::from_iter(unpacked.iter().cloned());
for i in 0..len {
    assert_eq!(Some(unpacked[i]), packed.get(i));
}
assert_eq!(None, packed.get(len));
assert_eq!(None, packed.get(len + 5));

impl PackedIntegers

pub fn iter<'a>(&'a self) -> Iter<'a>

Iterate through the packed integers without consuming self.

use rand::prelude::*;
use ::packed_integer_array::PackedIntegers;
let mut rng = rand::thread_rng();
let len = rng.gen_range(0, 10000);
let data: Vec<u64> = (0..len).map(|_| rng.gen()).collect();
let packed = PackedIntegers::from_iter(data.iter().cloned());
let unpacked: Vec<_> = packed.iter().collect();
assert_eq!(data, unpacked);

Trait Implementations

impl Clone for PackedIntegers

fn clone(&self) -> PackedIntegers

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PackedIntegers

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

Formats the value using the given formatter.

impl<'a> IntoIterator for &'a PackedIntegers

type IntoIter = Iter<'a>

Which kind of iterator are we turning this into?

type Item = u64

The type of the elements being iterated over.

fn into_iter(self) -> Iter<'a>

Creates an iterator from a value.

impl IntoIterator for PackedIntegers

type IntoIter = IntoIter

Which kind of iterator are we turning this into?

type Item = u64

The type of the elements being iterated over.

fn into_iter(self) -> IntoIter

Creates an iterator from a value.

impl Ord for PackedIntegers

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for PackedIntegers

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for PackedIntegers

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for PackedIntegers