fastmob-core 0.2.0

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

use crate::utils::{validate_coord_ends, validate_indexed_coord_ends};

type MobilityNetworkData = (Vec<f64>, Vec<f64>, Vec<f64>, Vec<f64>, Vec<u64>, Vec<usize>);

#[derive(Clone, Copy, Eq, Hash, PartialEq)]
struct EdgeKey {
    lat_origin: u64,
    lng_origin: u64,
    lat_dest: u64,
    lng_dest: u64,
}

struct Edge {
    lat_origin: f64,
    lng_origin: f64,
    lat_dest: f64,
    lng_dest: f64,
    count: u64,
}

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

fn push_transition(
    latitudes: &[f64],
    longitudes: &[f64],
    self_loops: bool,
    origin_idx: usize,
    dest_idx: usize,
    edges: &mut Vec<Edge>,
    positions: &mut FxHashMap<EdgeKey, usize>,
) {
    let key = EdgeKey {
        lat_origin: latitudes[origin_idx].to_bits(),
        lng_origin: longitudes[origin_idx].to_bits(),
        lat_dest: latitudes[dest_idx].to_bits(),
        lng_dest: longitudes[dest_idx].to_bits(),
    };
    if !self_loops && key.lat_origin == key.lat_dest && key.lng_origin == key.lng_dest {
        return;
    }

    if let Some(&pos) = positions.get(&key) {
        edges[pos].count += 1;
        return;
    }

    let pos = edges.len();
    positions.insert(key, pos);
    edges.push(Edge {
        lat_origin: latitudes[origin_idx],
        lng_origin: longitudes[origin_idx],
        lat_dest: latitudes[dest_idx],
        lng_dest: longitudes[dest_idx],
        count: 1,
    });
}

fn network_for_indexed_range(
    latitudes: &[f64],
    longitudes: &[f64],
    indices: &[usize],
    start: usize,
    end: usize,
    self_loops: bool,
    valid_rows: Option<&[bool]>,
) -> Vec<Edge> {
    let mut edges = Vec::new();
    let mut positions: FxHashMap<EdgeKey, usize> =
        FxHashMap::with_capacity_and_hasher(end.saturating_sub(start), Default::default());
    let mut previous_valid: Option<usize> = None;

    for &idx in &indices[start..end] {
        if !is_valid_row(latitudes, longitudes, valid_rows, idx) {
            continue;
        }
        if let Some(prev_idx) = previous_valid {
            push_transition(
                latitudes,
                longitudes,
                self_loops,
                prev_idx,
                idx,
                &mut edges,
                &mut positions,
            );
        }
        previous_valid = Some(idx);
    }

    edges
}

fn network_for_presorted_range(
    latitudes: &[f64],
    longitudes: &[f64],
    start: usize,
    end: usize,
    self_loops: bool,
    valid_rows: Option<&[bool]>,
) -> Vec<Edge> {
    let mut edges = Vec::new();
    let mut positions: FxHashMap<EdgeKey, usize> =
        FxHashMap::with_capacity_and_hasher(end.saturating_sub(start), Default::default());
    let mut previous_valid: Option<usize> = None;

    for idx in start..end {
        if !is_valid_row(latitudes, longitudes, valid_rows, idx) {
            continue;
        }
        if let Some(prev_idx) = previous_valid {
            push_transition(
                latitudes,
                longitudes,
                self_loops,
                prev_idx,
                idx,
                &mut edges,
                &mut positions,
            );
        }
        previous_valid = Some(idx);
    }

    edges
}

fn flatten_user_edges(per_user: Vec<Vec<Edge>>) -> MobilityNetworkData {
    let total_edges: usize = per_user.iter().map(Vec::len).sum();
    let mut lat_origins = Vec::with_capacity(total_edges);
    let mut lng_origins = Vec::with_capacity(total_edges);
    let mut lat_dests = Vec::with_capacity(total_edges);
    let mut lng_dests = Vec::with_capacity(total_edges);
    let mut n_trips = Vec::with_capacity(total_edges);
    let mut user_indices = Vec::with_capacity(total_edges);

    for (user_idx, edges) in per_user.into_iter().enumerate() {
        for edge in edges {
            lat_origins.push(edge.lat_origin);
            lng_origins.push(edge.lng_origin);
            lat_dests.push(edge.lat_dest);
            lng_dests.push(edge.lng_dest);
            n_trips.push(edge.count);
            user_indices.push(user_idx);
        }
    }

    (
        lat_origins,
        lng_origins,
        lat_dests,
        lng_dests,
        n_trips,
        user_indices,
    )
}

pub fn individual_mobility_network_indexed_impl(
    latitudes: &[f64],
    longitudes: &[f64],
    indices: &[usize],
    ends: &[usize],
    self_loops: bool,
    valid_rows: Option<&[bool]>,
) -> Result<MobilityNetworkData, String> {
    validate_indexed_coord_ends(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());
    }

    let per_user = (0..ends.len())
        .into_par_iter()
        .map(|i| {
            let start = if i == 0 { 0 } else { ends[i - 1] };
            let end = ends[i];
            network_for_indexed_range(
                latitudes, longitudes, indices, start, end, self_loops, valid_rows,
            )
        })
        .collect();

    Ok(flatten_user_edges(per_user))
}

pub fn individual_mobility_network_presorted_impl(
    latitudes: &[f64],
    longitudes: &[f64],
    ends: &[usize],
    self_loops: bool,
    valid_rows: Option<&[bool]>,
) -> Result<MobilityNetworkData, String> {
    validate_coord_ends(latitudes, longitudes, 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());
    }

    let per_user = (0..ends.len())
        .into_par_iter()
        .map(|i| {
            let start = if i == 0 { 0 } else { ends[i - 1] };
            let end = ends[i];
            network_for_presorted_range(latitudes, longitudes, start, end, self_loops, valid_rows)
        })
        .collect();

    Ok(flatten_user_edges(per_user))
}