rlife 0.1.0

A life library written in Rust.
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

//! This module contains some methods to get informations and statistics
//! about the patterns of a grid.

use Grid;

impl Grid {
    /// Returns the coordinates of the cell at the upper left corner of
    /// the current `Grid`.
    pub fn guess_pattern_origin(&self) -> (usize, usize) {
        let grid_size = self.get_grid_size();

        if grid_size == (0, 0) {
            return (0, 0);
        }

        let mut pattern_origin = grid_size;

        for row in 0..grid_size.0 {
            for col in 0..grid_size.1 {
                if self.get_cell_state(row as i64, col as i64) {
                    if row < pattern_origin.0 {
                        pattern_origin.0 = row;
                    }
                    if col < pattern_origin.1 {
                        pattern_origin.1 = col;
                    }
                }
            }
        }

        pattern_origin
    }

    /// Returns the size of the current `Grid`'s pattern.
    pub fn guess_pattern_size(&self) -> (usize, usize) {
        let grid_size = self.get_grid_size();

        if grid_size == (0, 0) {
            return (0, 0);
        }

        let pattern_origin = self.guess_pattern_origin();
        let mut pattern_limit = pattern_origin;

        for row in 0..grid_size.0 {
            for col in 0..grid_size.1 {
                if self.get_cell_state(row as i64, col as i64) {
                    if row > pattern_limit.0 {
                        pattern_limit.0 = row;
                    }
                    if col > pattern_limit.1 {
                        pattern_limit.1 = col;
                    }
                }
            }
        }

        (
            pattern_limit.0 - pattern_origin.0 + 1,
            pattern_limit.1 - pattern_origin.1 + 1,
        )
    }
}