Struct Table 

pub(crate) struct Table {

    pub tokenizer: u32,
    pub features: u32,
    pub dim: u32,
    pub minn: u32,
    pub maxn: u32,
    pub bucket: u32,
    pub words: Vec<(u64, f32)>,
    pub buckets: Vec<f32>,
    pub weights: Vec<f32>,
    pub means: Vec<f32>,
    pub bias: f32,
    pub text_mean: f32,
    pub platt_a: f32,
    pub platt_b: f32,
    pub meta: Meta,
}

The spam filter, folded (see the module’s documentation).

Fields

tokenizer: u32

The tokenizer’s version it was trained with (tokenize::TOKENIZER).

features: u32

The header features’ version (features::FEATURES).

dim: u32

The language model’s dimension, for the record.

minn: u32

fastText’s character n-grams: shortest, longest, and how many buckets they hash into.

maxn: u32

bucket: u32

words: Vec<(u64, f32)>

Each vocabulary word’s score, under its hash (word_hash), ascending: scoring looks words up by halves. A table read from its file is so; one made in memory is once sorted (writing sorts it too).

buckets: Vec<f32>

Each n-gram bucket’s score, bucket of them.

weights: Vec<f32>

Each header feature’s weight, over its deviation, and its mean (features::NAMES’ order); none in the classifier’s table, which reads the header facts as words: that is how its kind is told (kind).

means: Vec<f32>

bias: f32

The SVM’s intercept; the classifier’s: the end of the line’s scalar.

text_mean: f32

The score of the mean message’s text (u · μ); the classifier’s: 0.

platt_a: f32

Platt’s A and B.

platt_b: f32

meta: Meta

Implementations

impl Table

pub fn lexicon(&self) -> Arc<Lexicon>

The words it reads every message with (tokenize::tokens_with): its own, or the packs built in when it keeps none (made before 8 October 2026).

pub fn kind(&self) -> Kind

Its kind: no header weights, the classifier’s, which reads the header facts as words; else the centroid’s.

pub fn sort(&mut self)

Sorts the words by their hash, as scoring needs them (words).

pub fn word_score(&self, word: &str) -> f32

A word’s score in the centroid’s table: its own, else the mean of its n-grams’ buckets; 0 when it has none.

pub fn score(&self, words: &[String], features: &[f32]) -> Score

A message’s score from its words (tokenize::tokens) and its header features (features::features), with what made it. The table’s words must be sorted (sort): one read from its file is. A header feature that is missing (f32::NAN) weighs nothing: the classifier reads no word for it; the centroid stands it at the training’s mean, which is over the messages that had it.

pub fn to_bytes(&self) -> Vec<u8>

The table as its file holds it, words sorted (sort), checksummed.

pub fn from_bytes(bytes: &[u8]) -> Result<Table, String>

Reads a table, refusing one that is damaged, made by another tokenizer or with other header features than this Sioul’s: its scores would mean nothing.

pub fn read(path: &Path) -> Result<Table, String>

Reads the table’s file.

pub fn write(&self, path: &Path) -> Result<(), String>

Writes the table where it goes, whole or not at all (written beside, flushed, then moved); the one it replaces, when this Sioul can use it, is kept as table.prev.bin (keep_previous).

pub fn cached(path: &Path) -> Option<Arc<Table>>

The table at path, read once per process and again only when its file changes (its size and time); none when there is none. One this Sioul refuses (read says why: made by a newer Sioul, damaged) leaves the one before it in use (table.prev.bin), when there is one it reads. The phone’s background process reads it once, then keeps it.

Trait Implementations

impl Clone for Table

fn clone(&self) -> Table

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Table

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl PartialEq for Table

fn eq(&self, other: &Table) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Table