name-engine 0.1.0

A Rust library for computing Markov chains to generate random names based on pronunciation
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

use name_engine::{Name, NameGenerator, NameGeneratorBuilder, SyllableInfo};
use rand::{rngs::StdRng, Rng, SeedableRng};

fn format(name: &String) -> String {
    let name = name.replace('+', " ").replace('*', "");
    name
}

fn normal_distribution(x: f64, mean: f64, std_dev: f64) -> f64 {
    let a = 1.0 / (std_dev * (2.0 * std::f64::consts::PI).sqrt());
    let b = -((x - mean).powi(2) / (2.0 * std_dev.powi(2)));
    a * b.exp()
}

fn evaluate(
    place_names: &Vec<Name>,
    name: &String,
    _: &String,
    syllable_info: &Vec<SyllableInfo>,
) -> Option<f64> {
    // check if the same name is in the place_names
    let first_syllable_place_name = place_names[syllable_info[0].name_index].content();
    if first_syllable_place_name == *name {
        return None;
    }

    // check if the dulicate syllables are in the name, like 'Woodwood'
    let mut has_duplicate_syllables = false;
    syllable_info.iter().enumerate().for_each(|(i, _)| {
        if i == 0 {
            return;
        }
        let place_name_current =
            &place_names[syllable_info[i].name_index].syllables()[syllable_info[i].syllable_index];
        let place_name_previous = &place_names[syllable_info[i - 1].name_index].syllables()
            [syllable_info[i - 1].syllable_index];

        if place_name_current.0.to_uppercase() == place_name_previous.0.to_uppercase() {
            has_duplicate_syllables = true;
        }
    });
    if has_duplicate_syllables {
        return None;
    }

    // split syllables by '+'
    let syllables_splitted = syllable_info
        .iter()
        .fold(vec![vec![]], |mut acc, syllable_info| {
            let place_name: &Name = &place_names[syllable_info.name_index];
            let syllable = &place_name.syllables()[syllable_info.syllable_index];
            if syllable.0 == "+" {
                acc.push(vec![]);
            } else {
                acc.last_mut().unwrap().push(syllable_info);
            }
            acc
        });

    let max_syllable_count = syllables_splitted.iter().map(|s| s.len()).max().unwrap();
    let score_for_syllable_count = normal_distribution(max_syllable_count as f64, 2.25, 2.0);

    let block_count = syllables_splitted.len();
    let score_for_block_count = normal_distribution(block_count as f64, 1.5, 1.0);

    Some(score_for_syllable_count * score_for_block_count)
}

fn create_place_name_generator(csv_file: &str) -> NameGenerator {
    let place_names = csv_file
        .lines()
        .filter_map(|line| {
            let split = line.split(',');
            let phrases = split
                .last()
                .unwrap()
                .split(':')
                .map(|phrase| {
                    let mut split = phrase.split('_');
                    let name = split.next().unwrap();
                    let pronunciation = split.next().unwrap();
                    (name, pronunciation)
                })
                .collect::<Vec<(&str, &str)>>();
            if let Ok(name) = Name::new(phrases) {
                Some(name)
            } else {
                None
            }
        })
        .collect::<Vec<Name>>();

    let generator = NameGeneratorBuilder::new()
        .bulk_add_names(place_names)
        .build();

    generator
}

fn main() {
    let us_csv_file = include_str!("assets/us.csv");
    let california_csv_file = include_str!("assets/california.csv");

    let us_generator = create_place_name_generator(us_csv_file);
    let california_generator = create_place_name_generator(california_csv_file);

    let mut rng: StdRng = SeedableRng::seed_from_u64(0);
    (0..100).for_each(|_| {
        let generator = if rng.gen::<f64>() < 0.7 {
            &us_generator
        } else {
            &california_generator
        };
        let evaluated = (0..3)
            .filter_map(|_| {
                let (name, pronunciation, syllable_info) = generator.generate_verbose(|| rng.gen());
                let score = evaluate(generator.names(), &name, &pronunciation, &syllable_info);
                if let Some(score) = score {
                    Some((name, pronunciation, score))
                } else {
                    None
                }
            })
            .max_by(|(_, _, score1), (_, _, score2)| score1.partial_cmp(score2).unwrap());

        if let Some((name, pronunciation, _)) = evaluated {
            println!("{} /{}/", format(&name), format(&pronunciation));
        }
    });
}