Struct IndexChunked 

pub struct IndexChunked<'a, IX: IndexValue> {
    pub chunked_array: &'a UInt64Chunked,
    /* private fields */
}

Fields

chunked_array: &'a UInt64Chunked

Implementations

impl<'a, IX: IndexValue> IndexChunked<'a, IX>

pub fn iter_indexes_validated(&self) -> ValidatedIndexIter<'_, IX>

iterate over the Index values in this array.

The contained u64 values are validated and returned as Results

pub fn iter_indexes_nonvalidated(&self) -> NonValidatedIndexIter<'_, IX>

iterate over the Index values in this array.

The contained u64 values are not validated, so there may be invalid Index values.

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn validity_bitmap(&self) -> Bitmap

pub fn to_collection<C>(&self) -> Result<C, Error>

where C: FromIterator<IX>,

Trait Implementations

impl<'a, IX> BoundingRect for IndexChunked<'a, IX>

where IX: BoundingRect + IndexValue,

fn bounding_rect(&self) -> Result<Option<Rect>, Error>

impl<'a, IX> BuildKDTreeIndex<'a, IX> for IndexChunked<'a, IX>

where IX: CoordinateIndexable + IndexValue,

fn kdtree_index_with_node_size(&self, node_size: u8) -> KDTreeIndex<IX>

Build a KDTreeIndex using custom parameters.

fn kdtree_index(&self) -> KDTreeIndex<IX>

Build a KDTreeIndex using the default parameters.

impl<'a, IX> BuildPackedHilbertRTreeIndex<IX> for IndexChunked<'a, IX>

where IX: RectIndexable + IndexValue,

fn packed_hilbert_rtree_index( &self, ) -> Result<PackedHilbertRTreeIndex<IX>, Error>

Build a spatial index using the packed Hilbert R-tree algorithm

impl<'a, IX> BuildRTreeIndex<'a, IX> for IndexChunked<'a, IX>

where IX: RectIndexable + IndexValue,

fn rtree_index(&self) -> RTreeIndex<IX>

Build a R-Tree spatial index

Example

use geo_types::Rect;
use polars::prelude::UInt64Chunked;
use polars_core::prelude::TakeRandom;
use h3ron::{H3Cell, Index};
use h3ron_polars::{AsH3CellChunked, NamedFromIndexes};
use h3ron_polars::spatial_index::{BuildRTreeIndex, SpatialIndex, SpatialIndexGeomOp};

let ca = UInt64Chunked::new_from_indexes(
    "",
    vec![
        H3Cell::from_coordinate((45.5, 45.5).into(), 7).unwrap(),
        H3Cell::from_coordinate((-60.5, -60.5).into(), 7).unwrap(),
        H3Cell::from_coordinate((120.5, 70.5).into(), 7).unwrap(),
    ],
);

let rtree = ca.h3cell().rtree_index();
let mask = rtree.geometries_intersect(&Rect::new((40.0, 40.0), (50.0, 50.0)));

assert_eq!(mask.len(), 3);
assert_eq!(mask.get(0), Some(true));
assert_eq!(mask.get(1), Some(false));
assert_eq!(mask.get(2), Some(false));

impl<'a, IX: Clone + IndexValue> Clone for IndexChunked<'a, IX>

fn clone(&self) -> IndexChunked<'a, IX>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> H3CellClusters for IndexChunked<'a, H3Cell>

fn h3_cell_clusters(&self) -> Result<DataFrame, Error>

find clusters of neighboring cells

fn h3_cell_clusters_eq_value(&self, values: &Series) -> Result<DataFrame, Error>

find clusters of neighboring cells where the same value is associated with the cells.

impl<'a> H3ChangeResolution for IndexChunked<'a, H3Cell>

fn h3_change_resolution( &self, target_resolution: u8, ) -> Result<ListChunked, Error>

Changes the resolution of the contained H3Cell values

impl<'a> H3CompactCells for IndexChunked<'a, H3Cell>

fn h3_compact_cells(&self) -> Result<UInt64Chunked, Error>

Compacts H3Cell using the H3 resolution hierarchy.

impl<'a> H3GridDisk for IndexChunked<'a, H3Cell>

fn h3_grid_disk(&self, k: u32) -> Result<ListChunked, Error>

Produces all cells within k distance of the origin cell.

impl<'a, IX: IndexValue> H3IsValid for IndexChunked<'a, IX>

fn h3_is_valid(&self) -> BooleanChunked

Example

fn h3_all_valid(&self) -> bool

Returns true when all contained h3indexes are valid.

impl<'a, IX: IndexValue> H3Resolution for IndexChunked<'a, IX>

fn h3_resolution(&self) -> UInt8Chunked

Obtain the H3 Resolutions at the array positions where the contained Index values are valid.

impl<'a, IX: IndexValue> TakeRandom for IndexChunked<'a, IX>

fn get(&self, index: usize) -> Option<Self::Item>

get a nullable value by index. The returned Index is not validated.

type Item = IX

fn last(&self) -> Option<Self::Item>

This is much faster if we have many chunks as we don’t have to compute the index

unsafe fn get_unchecked(&self, index: usize) -> Option<Self::Item>

where Self: Sized,

Get a value by index and ignore the null bit.