fastmob-core 0.2.0

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

use crate::utils::haversine::{adjacent_haversine_distances_into_km, haversine_km};
use crate::utils::{ranges_from_ends, validate_coord_ranges, validate_indexed_coord_ends_u64};

type JumpLengthsPresortedResult = Result<(Vec<usize>, Vec<usize>, Vec<f64>), String>;

pub fn write_jump_lengths_presorted_range(
    latitudes: &[f64],
    longitudes: &[f64],
    start: usize,
    end: usize,
    out: &mut [f64],
) {
    if end - start < 2 {
        return;
    }

    adjacent_haversine_distances_into_km(latitudes, longitudes, start, end, out);
}

pub fn jump_lengths_for_indexed_range(
    latitudes: &[f64],
    longitudes: &[f64],
    indices: &[u64],
    start: u64,
    end: u64,
    valid_rows: Option<&[bool]>,
) -> Vec<f64> {
    let start = usize::try_from(start).expect("jump range start must fit usize");
    let end = usize::try_from(end).expect("jump range end must fit usize");
    let mut valid = Vec::with_capacity(end.saturating_sub(start));
    for &idx in &indices[start..end] {
        let row = usize::try_from(idx).expect("row index must fit usize");
        if valid_rows.is_none_or(|v| v[row])
            && latitudes[row].is_finite()
            && longitudes[row].is_finite()
        {
            valid.push((latitudes[row], longitudes[row]));
        }
    }

    if valid.len() < 2 {
        return Vec::new();
    }

    valid
        .windows(2)
        .map(|pair| haversine_km(pair[0].0, pair[0].1, pair[1].0, pair[1].1))
        .collect()
}

fn jump_offsets_for_ranges(ranges: &[(usize, usize)]) -> (Vec<usize>, Vec<usize>) {
    let mut starts = Vec::with_capacity(ranges.len());
    let mut ends = Vec::with_capacity(ranges.len());
    let mut offset = 0usize;
    for &(start, end) in ranges {
        starts.push(offset);
        offset += end.saturating_sub(start).saturating_sub(1);
        ends.push(offset);
    }
    (starts, ends)
}

pub fn jump_lengths_presorted_impl(
    latitudes: &[f64],
    longitudes: &[f64],
    ends: &[usize],
) -> JumpLengthsPresortedResult {
    let ranges = ranges_from_ends(ends)?;
    validate_coord_ranges(latitudes, longitudes, &ranges)?;
    let (value_starts, value_ends) = jump_offsets_for_ranges(&ranges);
    let mut values = vec![0.0; value_ends.last().copied().unwrap_or(0)];
    let mut rest = values.as_mut_slice();
    let mut chunks = Vec::with_capacity(ranges.len());
    for (&start, &end) in value_starts.iter().zip(&value_ends) {
        let len = end - start;
        let (chunk, next) = rest.split_at_mut(len);
        chunks.push(chunk);
        rest = next;
    }

    chunks
        .into_par_iter()
        .zip(ranges.par_iter())
        .for_each(|(chunk, &(start, end))| {
            write_jump_lengths_presorted_range(latitudes, longitudes, start, end, chunk);
        });
    Ok((value_starts, value_ends, values))
}

pub fn jump_lengths_indexed_impl(
    latitudes: &[f64],
    longitudes: &[f64],
    indices: &[u64],
    ends: &[u64],
    valid_rows: Option<&[bool]>,
) -> JumpLengthsPresortedResult {
    let profile = std::env::var_os("FASTMOB_PROFILE_JUMP_LENGTHS").is_some();
    let total_started = Instant::now();
    let validation_started = Instant::now();
    validate_indexed_coord_ends_u64(latitudes, longitudes, indices, ends)?;
    if let Some(valid_rows) = valid_rows
        && valid_rows.len() != latitudes.len()
    {
        return Err("valid_rows and coordinates must have the same length".to_string());
    }
    if profile {
        eprintln!(
            "[jump_lengths::rust] validation: {:.6}s",
            validation_started.elapsed().as_secs_f64()
        );
    }

    let kernel_started = Instant::now();
    let grouped_values: Vec<Vec<f64>> = (0..ends.len())
        .into_par_iter()
        .map(|i| {
            let start = if i == 0 { 0 } else { ends[i - 1] };
            let end = ends[i];
            jump_lengths_for_indexed_range(latitudes, longitudes, indices, start, end, valid_rows)
        })
        .collect();
    if profile {
        eprintln!(
            "[jump_lengths::rust] indexed kernel and per-user result allocation: {:.6}s",
            kernel_started.elapsed().as_secs_f64()
        );
    }

    let flatten_started = Instant::now();
    let mut value_starts = Vec::with_capacity(grouped_values.len());
    let mut value_ends = Vec::with_capacity(grouped_values.len());
    let total_len: usize = grouped_values.iter().map(Vec::len).sum();
    let mut values = Vec::with_capacity(total_len);
    for mut group in grouped_values {
        value_starts.push(values.len());
        values.append(&mut group);
        value_ends.push(values.len());
    }

    if profile {
        eprintln!(
            "[jump_lengths::rust] flattening: {:.6}s; total: {:.6}s",
            flatten_started.elapsed().as_secs_f64(),
            total_started.elapsed().as_secs_f64()
        );
    }
    Ok((value_starts, value_ends, values))
}

pub fn jump_lengths_km(latitudes: Vec<f64>, longitudes: Vec<f64>) -> Result<Vec<f64>, String> {
    if latitudes.len() != longitudes.len() {
        return Err("latitudes and longitudes must have the same length".to_string());
    }

    if latitudes.is_empty() {
        return Ok(Vec::new());
    }

    let coords: Vec<(f64, f64)> = latitudes.into_iter().zip(longitudes).collect();

    let lengths: Vec<f64> = (0..coords.len().saturating_sub(1))
        .into_par_iter()
        .map(|idx| {
            let (lat1, lon1) = coords[idx];
            let (lat2, lon2) = coords[idx + 1];
            haversine_km(lat1, lon1, lat2, lon2)
        })
        .collect();

    Ok(lengths)
}