syd-format 0.1.1

binary format for chess game tree
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

#[cfg(feature = "hll")]
use crate::hyperloglog::HyperLogLog;

#[cfg(feature = "positionstats")]
use crate::position::Position;

#[cfg(feature = "positionstats")]
pub struct Stats{
    #[cfg(feature = "hll")]
    pub hll: HyperLogLog,
    pub cntpos: u64,
    pub bounds: [u64; 3],
    pub depth: [u64; 256/3+1],
}

#[cfg(feature = "positionstats")]
impl Stats {
    pub fn new() -> Self {
        Self {
            #[cfg(feature = "hll")]
            hll: HyperLogLog::new(),
            cntpos: 0,
            bounds: [0; 3],
            depth: [0; 256/3+1],
        }
    }
    pub fn update(&mut self, pos: &Position) {
        #[cfg(feature = "hll")]
        {
            self.hll.add(pos.hash);
        }
        self.cntpos += 1;
        self.bounds[pos.bound as usize] += 1;
        self.depth[pos.depth as usize] += 1;
    }
    pub fn print(&self) {
        println!("nbpos = {}", self.cntpos);
        #[cfg(feature = "hll")]
        {
            let cnt = self.hll.count();
            println!("unique pos = {} ({:.2}%)", cnt, 100.0 * cnt as f64 / self.cntpos as f64);
        }
        println!("exact      = {} ({:.2}%)", self.bounds[0], self.bounds[0] as f64 * 100.0 / self.cntpos as f64);
        println!("lowerbound = {} ({:.2}%)", self.bounds[1], self.bounds[1] as f64 * 100.0 / self.cntpos as f64);
        println!("upperbound = {} ({:.2}%)", self.bounds[2], self.bounds[2] as f64 * 100.0 / self.cntpos as f64);
        print!("depth distrib = [");
        for dcnt in self.depth {
            print!("{} ", dcnt);
        }
        print!("]\ndepth distrib = [");
        for dcnt in self.depth {
            print!("{:.2}% ", dcnt as f64 * 100.0 / self.cntpos as f64);
        }
        println!("]");
    }
}

#[cfg(feature = "readerstats")]
pub struct ReaderStat {
    degrees: [u64; 256],
    nodes: u64,
    bm_continued: u64,
    compressed_size: u64,
}

#[cfg(feature = "readerstats")]
impl ReaderStat {
    pub fn new() -> Self {
        Self {
            degrees: [0; 256],
            nodes: 0,
            bm_continued: 0,
            compressed_size: 0,
        }
    }
    pub fn update(&mut self, deg: usize, is_bm_continued: bool, size_move: u64) {
        self.degrees[deg] += 1;
        self.nodes += 1;
        self.bm_continued += is_bm_continued as u64;
        self.compressed_size += size_move;
    }
    pub fn print(&self) {
        println!("degrees: [");
        print!("\t");
        for cnt in self.degrees {
            print!("{} ", cnt);
        }
        println!("\n]");
        println!("degrees%: [");
        print!("\t");
        for cnt in self.degrees {
            print!("{:.2} ", cnt as f64 * 100.0 / self.nodes as f64);
        }
        println!("\n]");
        println!("{} / {} ({:.2}%)", self.bm_continued, self.nodes, self.bm_continued as f64 * 100.0 / self.nodes as f64);
        println!("{} / {} ({:.2}%)", self.bm_continued, self.nodes-self.degrees[0], self.bm_continued as f64 * 100.0 / (self.nodes-self.degrees[0]) as f64);
        println!("{:.2} B/pos (compressed)", self.compressed_size as f64 / (self.nodes as f64 * 8.0));
    }
}