smarty_pants/
lib.rs

1pub mod neural_network;
2
3/// Just a testing module, only here for developers of the library itself.
4/// The functions defined in this module are in this order so that if a
5/// previous test worked then in theory the next one should work.
6#[cfg(test)]
7mod tests {
8    use crate::neural_network::NeuralNetwork;
9
10    #[test]
11    /// Test if `NeuralNetwork::new()` is working.
12    fn new() {
13        #[allow(unused_variables)]
14        let network:NeuralNetwork = NeuralNetwork::new(1.0,10,10,3);
15    }
16
17    #[test]
18    /// Test if `NeuralNetwork::new_from()` is working.
19    fn new_from() {
20        let hidden_layers:Vec<Vec<f64>> = vec![vec![1.0,1.0,1.0]];
21        let output_weights:Vec<f64> = vec![1.0,1.0];
22        #[allow(unused_variables)]
23        let network:NeuralNetwork = NeuralNetwork::new_from(hidden_layers,output_weights);
24    }
25
26    #[test]
27    /// Test if `NeuralNetwork::batch_new()` is working.
28    fn batch_new() {
29        #[allow(unused_variables)]
30        let networks: Vec<NeuralNetwork> = NeuralNetwork::batch_new(5,1.0,1,3,2);
31    }
32
33    #[test]
34    /// Test if the `set_wheight` and `get_wheight` functions are working
35    fn weights() {
36        let mut network:NeuralNetwork = NeuralNetwork::new(1.0,10,10,3);
37        assert!(network.set_wheight(42.4242424242, (5,8)) == None);
38        assert!(network.get_wheight((5,8)).unwrap() == 42.4242424242);
39    }
40
41    #[test]
42    /// Test if `NeuralNetwork::mutate()` is working.
43    fn mutate() {
44        let mut network:NeuralNetwork = NeuralNetwork::new(1.0,10,10,3);
45        network.mutate(10.0f64, true);
46        assert!(1.0 != network.get_wheight((0,0)).unwrap());
47    }
48
49    #[test]
50    /// Test if `neural_network::NeuralNetwork::batch_mutate()` is working.
51    fn batch_mutate() {
52        let networks: Vec<NeuralNetwork> = crate::neural_network::batch_mutate(5,0.25,&mut NeuralNetwork::new(1.0,1,3,2), true);
53        for network in networks.iter() {
54            assert!(1.0 != network.get_wheight((0,0)).unwrap());
55        }
56    }
57
58    #[test]
59    /// Test if `NeuralNetwork::run()` is working.
60    fn run() {
61        let mut network:NeuralNetwork = NeuralNetwork::new(1.0,10,10,3);
62        let data:Vec<f64> = network.run(&vec![1.0,1.0,1.0]);
63        assert!(data[0] == 30000000000.0);
64        assert!(data[1] == 30000000000.0);
65        assert!(data[2] == 30000000000.0);
66    }
67
68    #[test]
69    /// Test if `neural_network::NeuralNetwork::batch_run()` is working.
70    fn batch_run() {
71        let mut networks: Vec<NeuralNetwork> = NeuralNetwork::batch_new(5,1.0,10,10,3);
72        let data:Vec<Vec<f64>> = crate::neural_network::batch_run(&mut networks, &vec![1.0,1.0,1.0]);
73        for output in data.iter() {
74            assert!(output[0] == 30000000000.0);
75            assert!(output[1] == 30000000000.0);
76            assert!(output[2] == 30000000000.0);
77        }
78    }
79}