feagi-brain-development 0.0.13

Brain Development Utilities - Synaptogenesis and Connectivity
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

// Copyright 2025 Neuraville Inc.
// SPDX-License-Identifier: Apache-2.0

/*!
Expander morphology - scales coordinates from source to destination.
*/

use crate::types::{BduResult, Position};

/// Expander mapping - scales coordinates by dimension ratios.
pub fn syn_expander(
    _src_area_id: &str,
    _dst_area_id: &str,
    neuron_location: Position,
    src_dimensions: (usize, usize, usize),
    dst_dimensions: (usize, usize, usize),
) -> BduResult<Position> {
    let (src_x, src_y, src_z) = src_dimensions;
    let (dst_x, dst_y, dst_z) = dst_dimensions;

    // Calculate expansion ratios
    let ratio_x = dst_x as f32 / src_x as f32;
    let ratio_y = dst_y as f32 / src_y as f32;
    let ratio_z = dst_z as f32 / src_z as f32;

    // Scale neuron position
    let (x, y, z) = neuron_location;
    let scaled_x = ((x as f32 * ratio_x) as usize).min(dst_x - 1) as u32;
    let scaled_y = ((y as f32 * ratio_y) as usize).min(dst_y - 1) as u32;
    let scaled_z = ((z as f32 * ratio_z) as usize).min(dst_z - 1) as u32;

    Ok((scaled_x, scaled_y, scaled_z))
}

/// Batch expander for parallel processing (sequential fallback for WASM)
pub fn syn_expander_batch(
    src_area_id: &str,
    dst_area_id: &str,
    neuron_locations: &[Position],
    src_dimensions: (usize, usize, usize),
    dst_dimensions: (usize, usize, usize),
) -> BduResult<Vec<Position>> {
    #[cfg(feature = "parallel")]
    {
        use rayon::prelude::*;
        neuron_locations
            .par_iter()
            .map(|&loc| {
                syn_expander(
                    src_area_id,
                    dst_area_id,
                    loc,
                    src_dimensions,
                    dst_dimensions,
                )
            })
            .collect::<Result<Vec<_>, _>>()
    }

    #[cfg(not(feature = "parallel"))]
    {
        neuron_locations
            .iter()
            .map(|&loc| {
                syn_expander(
                    src_area_id,
                    dst_area_id,
                    loc,
                    src_dimensions,
                    dst_dimensions,
                )
            })
            .collect::<Result<Vec<_>, _>>()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_expander_scale_up() {
        let result = syn_expander("src", "dst", (5, 5, 5), (10, 10, 10), (20, 20, 20));
        assert!(result.is_ok());
        assert_eq!(result.unwrap(), (10, 10, 10));
    }

    #[test]
    fn test_expander_scale_down() {
        let result = syn_expander("src", "dst", (10, 10, 10), (20, 20, 20), (10, 10, 10));
        assert!(result.is_ok());
        assert_eq!(result.unwrap(), (5, 5, 5));
    }
}