neurodna 0.0.1

Evolutionary neural networks with genetic encoding and neurodivergent cognitive modeling
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

//! Neurodivergent traits and cognitive patterns

use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Neurodivergent trait profile
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NeurodivergentTrait {
    pub name: String,
    pub strength: f32,
    pub category: TraitCategory,
    pub effects: TraitEffects,
}

/// Categories of neurodivergent traits
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum TraitCategory {
    Attention,
    Sensory,
    Processing,
    Executive,
    Memory,
    Social,
    Creative,
}

/// Effects that traits have on neural behavior
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TraitEffects {
    pub learning_rate_modifier: f32,
    pub connection_strength_modifier: f32,
    pub activation_threshold_modifier: f32,
    pub specialization_tendency: f32,
}

impl Default for TraitEffects {
    fn default() -> Self {
        Self {
            learning_rate_modifier: 1.0,
            connection_strength_modifier: 1.0,
            activation_threshold_modifier: 1.0,
            specialization_tendency: 0.0,
        }
    }
}

/// Collection of traits forming a profile
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TraitProfile {
    pub traits: Vec<NeurodivergentTrait>,
    pub compatibility_scores: HashMap<String, f32>,
}

impl TraitProfile {
    pub fn new() -> Self {
        Self {
            traits: Vec::new(),
            compatibility_scores: HashMap::new(),
        }
    }
    
    pub fn add_trait(&mut self, trait_def: NeurodivergentTrait) {
        self.traits.push(trait_def);
    }
    
    pub fn get_trait(&self, name: &str) -> Option<&NeurodivergentTrait> {
        self.traits.iter().find(|t| t.name == name)
    }
    
    pub fn adhd_profile() -> Self {
        let mut profile = Self::new();
        
        profile.add_trait(NeurodivergentTrait {
            name: "hyperfocus".to_string(),
            strength: 0.8,
            category: TraitCategory::Attention,
            effects: TraitEffects {
                learning_rate_modifier: 1.5,
                connection_strength_modifier: 1.3,
                activation_threshold_modifier: 0.8,
                specialization_tendency: 0.7,
            },
        });
        
        profile.add_trait(NeurodivergentTrait {
            name: "distractibility".to_string(),
            strength: 0.6,
            category: TraitCategory::Attention,
            effects: TraitEffects {
                learning_rate_modifier: 0.8,
                connection_strength_modifier: 0.9,
                activation_threshold_modifier: 1.2,
                specialization_tendency: -0.3,
            },
        });
        
        profile
    }
    
    pub fn autism_profile() -> Self {
        let mut profile = Self::new();
        
        profile.add_trait(NeurodivergentTrait {
            name: "pattern_recognition".to_string(),
            strength: 0.9,
            category: TraitCategory::Processing,
            effects: TraitEffects {
                learning_rate_modifier: 1.2,
                connection_strength_modifier: 1.4,
                activation_threshold_modifier: 0.9,
                specialization_tendency: 0.8,
            },
        });
        
        profile.add_trait(NeurodivergentTrait {
            name: "detail_orientation".to_string(),
            strength: 0.8,
            category: TraitCategory::Processing,
            effects: TraitEffects {
                learning_rate_modifier: 1.1,
                connection_strength_modifier: 1.2,
                activation_threshold_modifier: 0.85,
                specialization_tendency: 0.6,
            },
        });
        
        profile
    }
}

impl Default for TraitProfile {
    fn default() -> Self {
        Self::new()
    }
}