lace 0.9.1

A probabilistic cross-categorization engine
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

use std::convert::TryFrom;

use serde::Deserialize;
use serde::Serialize;

use crate::codebook::ColType;
use crate::data::Datum;

/// Feature type
#[derive(Serialize, Deserialize, Debug, Clone, Copy, Eq, PartialEq, Hash)]
#[serde(rename_all = "snake_case")]
pub enum FType {
    Binary,
    Continuous,
    Categorical,
    Count,
}

impl std::fmt::Display for FType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Binary => write!(f, "Binary"),
            Self::Continuous => write!(f, "Continuous"),
            Self::Categorical => write!(f, "Categorical"),
            Self::Count => write!(f, "Count"),
        }
    }
}

impl std::str::FromStr for FType {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "Binary" => Ok(FType::Binary),
            "Continuous" => Ok(FType::Continuous),
            "Categorical" => Ok(FType::Categorical),
            "Count" => Ok(FType::Count),
            invalid => Err(format!("Invalid ftype: '{invalid}'")),
        }
    }
}

impl From<FType> for String {
    fn from(ftype: FType) -> Self {
        ftype.to_string()
    }
}

/// FType compatibility information
#[derive(Debug)]
pub struct FTypeCompat {
    /// The FType of the Datum passed to this feature
    pub ftype_req: FType,
    /// The FType of this feature
    pub ftype: FType,
}

impl TryFrom<&Datum> for FType {
    type Error = ();

    fn try_from(datum: &Datum) -> Result<Self, Self::Error> {
        match datum {
            Datum::Binary(_) => Ok(FType::Binary),
            Datum::Categorical(_) => Ok(FType::Categorical),
            Datum::Continuous(_) => Ok(FType::Continuous),
            Datum::Count(_) => Ok(FType::Count),
            Datum::Missing => Err(()),
        }
    }
}

impl FType {
    pub fn from_coltype(coltype: &ColType) -> FType {
        match coltype {
            ColType::Continuous { .. } => FType::Continuous,
            ColType::Categorical { .. } => FType::Categorical,
            ColType::Count { .. } => FType::Count,
        }
    }

    pub fn is_continuous(self) -> bool {
        matches!(self, FType::Continuous)
    }

    pub fn is_categorical(self) -> bool {
        matches!(self, FType::Categorical)
    }

    pub fn is_count(self) -> bool {
        matches!(self, FType::Count)
    }

    /// Return a tuple
    pub fn datum_compatible(self, datum: &Datum) -> (bool, FTypeCompat) {
        if let Ok(ftype_req) = FType::try_from(datum) {
            let ok = ftype_req == self;
            (
                ok,
                FTypeCompat {
                    ftype_req,
                    ftype: self,
                },
            )
        } else {
            // always compatible if the datum is a missing value
            (
                true,
                FTypeCompat {
                    ftype_req: self,
                    ftype: self,
                },
            )
        }
    }
}

// TODO: tests