fastmob-core 0.2.0

Rust compute kernels for fastmob mobility analysis.
Documentation
use rayon::prelude::*;

pub fn rog_for_presorted_slices(
    latitudes: &[f64],
    longitudes: &[f64],
    start: usize,
    end: usize,
) -> f64 {
    let n = end - start;
    if n == 0 {
        return 0.0;
    }

    let (lat_sum, lng_sum) = (start..end).fold((0.0f64, 0.0f64), |(ls, ns), idx| {
        (ls + latitudes[idx], ns + longitudes[idx])
    });
    let cm_lat = lat_sum / n as f64;
    let cm_lng = lng_sum / n as f64;

    let cm_lat_rad = cm_lat.to_radians();
    let cm_lng_rad = cm_lng.to_radians();
    let cos_cm_lat = cm_lat_rad.cos();

    let sum_sq: f64 = (start..end)
        .map(|idx| {
            let lat_rad = latitudes[idx].to_radians();
            let dlat = lat_rad - cm_lat_rad;
            let dlng = longitudes[idx].to_radians() - cm_lng_rad;
            let a = (dlat / 2.0).sin().powi(2)
                + cos_cm_lat * lat_rad.cos() * (dlng / 2.0).sin().powi(2);
            let d = 2.0 * a.sqrt().asin() * 6371.0088;
            d * d
        })
        .sum();

    (sum_sq / n as f64).sqrt()
}

pub fn rog_for_indexed_slice(
    latitudes: &[f64],
    longitudes: &[f64],
    indices: &[usize],
    start: usize,
    end: usize,
) -> f64 {
    let n = end - start;
    if n == 0 {
        return 0.0;
    }

    let (lat_sum, lng_sum) = indices[start..end]
        .iter()
        .fold((0.0f64, 0.0f64), |(ls, ns), &idx| {
            (ls + latitudes[idx], ns + longitudes[idx])
        });
    let cm_lat = lat_sum / n as f64;
    let cm_lng = lng_sum / n as f64;

    let cm_lat_rad = cm_lat.to_radians();
    let cm_lng_rad = cm_lng.to_radians();
    let cos_cm_lat = cm_lat_rad.cos();

    let sum_sq: f64 = indices[start..end]
        .iter()
        .map(|&idx| {
            let lat_rad = latitudes[idx].to_radians();
            let dlat = lat_rad - cm_lat_rad;
            let dlng = longitudes[idx].to_radians() - cm_lng_rad;
            let a = (dlat / 2.0).sin().powi(2)
                + cos_cm_lat * lat_rad.cos() * (dlng / 2.0).sin().powi(2);
            let d = 2.0 * a.sqrt().asin() * 6371.0088;
            d * d
        })
        .sum();

    (sum_sq / n as f64).sqrt()
}

pub fn radius_of_gyration_presorted_impl(
    latitudes: &[f64],
    longitudes: &[f64],
    ends: &[usize],
) -> (Vec<f64>, Vec<bool>) {
    let results: Vec<f64> = (0..ends.len())
        .into_par_iter()
        .map(|i| {
            let start = if i == 0 { 0 } else { ends[i - 1] };
            rog_for_presorted_slices(latitudes, longitudes, start, ends[i])
        })
        .collect();
    let validity = (0..ends.len())
        .map(|i| {
            let start = if i == 0 { 0 } else { ends[i - 1] };
            ends[i] > start
        })
        .collect();

    (results, validity)
}

fn is_valid_indexed_row(
    latitudes: &[f64],
    longitudes: &[f64],
    valid_rows: Option<&[bool]>,
    idx: usize,
) -> bool {
    valid_rows.is_none_or(|rows| rows[idx])
        && latitudes[idx].is_finite()
        && longitudes[idx].is_finite()
}

pub fn radius_of_gyration_indexed_impl(
    latitudes: &[f64],
    longitudes: &[f64],
    indices: &[usize],
    ends: &[usize],
    valid_rows: Option<&[bool]>,
) -> (Vec<f64>, Vec<bool>) {
    let mut valid_indices = Vec::new();
    let mut valid_ranges = Vec::with_capacity(ends.len());
    let mut validity = Vec::with_capacity(ends.len());
    for i in 0..ends.len() {
        let start = if i == 0 { 0 } else { ends[i - 1] };
        let end = ends[i];
        let valid_start = valid_indices.len();
        for &idx in &indices[start..end] {
            if is_valid_indexed_row(latitudes, longitudes, valid_rows, idx) {
                valid_indices.push(idx);
            }
        }
        let valid_end = valid_indices.len();
        valid_ranges.push((valid_start, valid_end));
        validity.push(valid_end > valid_start);
    }

    let results: Vec<f64> = valid_ranges
        .par_iter()
        .map(|&(start, end)| {
            rog_for_indexed_slice(latitudes, longitudes, &valid_indices, start, end)
        })
        .collect();

    (results, validity)
}