Struct FloatDataRange 

pub struct FloatDataRange {
    pub low: f64,
    pub high: f64,
    pub scale: f64,
    pub bits_required: usize,
}

The observed range of values seen in a set of points whose coordinates are signed 64-bit floats.

From this information we can determine how to translate the coordinates so that their normalized range has a low of zero. This permits us to use the fewest number of bits to represent them when constructing a Hilbert index.

Motivation.

1. The Hilbert Curve transformation requires non-negative numbers, so all values must be translated until the lowest is zero. That means that if the lowest value is negative, we shift to the positive direction, or contrariwise to the negative direction.
2. The execution time of the Hilbert transformation is directly proportional to the number of bits used to represent each value. Thus if we can sacrifice some precision, each value can be multiplied by a scale factor and rounded to the nearest integer to compress the value (and sacrifice information).

Fields

low: f64

Lowest value of any coordinate of any point in a collection of points.

high: f64

Highest value of any coordinate of any point in a collection of points.

scale: f64

Multiplier to apply before rounding to an integer value, sacrificing some precision. For example, if you want to encode values such that you preserve precision to the hundredth place, scale should be 100.

bits_required: usize

Minimum number of bits required to represent a normalized value without loss of information for the given scale factor.

Example:

• If low is -5.02 and high is 3.13 then the range is 8.15. If scale is 100, the range becomes 815, so 10 bits are required to represent all values in that range.

Implementations

impl FloatDataRange

pub fn new(low: f64, high: f64, scale: f64) -> Self

Create a FloatDataRange without reference to particular data.

pub fn from_f64<I>(points: &[I], scale: f64) -> Self

where for<'a> &'a I: IntoIterator<Item = &'a f64>,

Study all f64 coordinates in all points to find the minimum and maximum values.

pub fn range(&self) -> f64

Range from low to high value.

pub fn normalize(&self, coordinate: f64) -> u32

Normalize an f64 coordinate value, shifting it enough so that the minimum value found in any point is shifted to zero and the maximum value is shifted to range, and using the full number of bits required for the range multiplied by the scale.

pub fn compress(&self, coordinate: f64, bits_allocated: usize) -> u32

Normalize an f64 coordinate value, shifting it enough so that the minimum value found in any point is shifted to zero and the maximum value is shifted to range, then optionally compressing the range by bit shifting such that no more than the given number of bits are required for the largest value.

Trait Implementations

impl Clone for FloatDataRange

fn clone(&self) -> FloatDataRange

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FloatDataRange

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

Formats the value using the given formatter.

impl PartialEq for FloatDataRange

fn eq(&self, other: &FloatDataRange) -> 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 StructuralPartialEq for FloatDataRange