Struct ErrorModel 

pub struct ErrorModel {
    pub p_deletion: f64,
    pub p_insertion: f64,
    pub p_substitution: f64,
    pub p_transposition: f64,
    /* private fields */
}

Error model for the noisy channel model

Fields

p_deletion: f64

Probability of deletion errors

p_insertion: f64

Probability of insertion errors

p_substitution: f64

Probability of substitution errors

p_transposition: f64

Probability of transposition errors

Implementations

impl ErrorModel

pub fn new( p_deletion: f64, p_insertion: f64, p_substitution: f64, p_transposition: f64, ) -> Self

Create a new error model with custom error probabilities

Examples found in repository

examples/statistical_spelling_demo.rs (line 393)

fn noise_model_demo() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n=== Error Model Demo ===\n");

    // Create different error models with varying error type probabilities
    let models = [
        ("Default", ErrorModel::default()),
        ("Deletion-heavy", ErrorModel::new(0.7, 0.1, 0.1, 0.1)),
        ("Insertion-heavy", ErrorModel::new(0.1, 0.7, 0.1, 0.1)),
        ("Substitution-heavy", ErrorModel::new(0.1, 0.1, 0.7, 0.1)),
        ("Transposition-heavy", ErrorModel::new(0.1, 0.1, 0.1, 0.7)),
    ];

    // Test cases for different error types
    let test_pairs = [
        ("recieve", "receive"),        // Transposition (i and e)
        ("acheive", "achieve"),        // Transposition (i and e)
        ("languge", "language"),       // Deletion (missing 'a')
        ("programing", "programming"), // Deletion (missing 'm')
        ("probblem", "problem"),       // Insertion (extra 'b')
        ("committe", "committee"),     // Insertion (missing 'e')
        ("definately", "definitely"),  // Substitution ('a' instead of 'i')
        ("seperate", "separate"),      // Substitution ('e' instead of 'a')
    ];

    // Test each error model
    println!(
        "{:<20} {:<12} {:<12} {:<12} {:<12} {:<12}",
        "Model", "Delete Prob", "Insert Prob", "Subst Prob", "Transp Prob", "Example"
    );
    println!("{:-<80}", "");

    for (name, model) in &models {
        // Pick one example to show
        let (typo, correct) = test_pairs[0];
        let probability = model.error_probability(typo, correct);

        println!(
            "{:<20} {:<12.2} {:<12.2} {:<12.2} {:<12.2} {:<12.4}",
            name,
            model.p_deletion,
            model.p_insertion,
            model.p_substitution,
            model.p_transposition,
            probability
        );
    }

    println!("\nError probabilities for different error types (using default model):");

    let default_model = ErrorModel::default();

    for (typo, correct) in &test_pairs {
        let prob = default_model.error_probability(typo, correct);
        println!("{typo:<12} -> {correct:<12}: {prob:.6}");
    }

    println!("\nImpact on correction with custom error model:");

    // Create a statistical corrector with a custom error model
    let custom_config = StatisticalCorrectorConfig {
        language_model_weight: 0.3,
        edit_distance_weight: 0.7,
        ..Default::default()
    };

    let mut custom_corrector = StatisticalCorrector::new(custom_config);
    train_language_model(&mut custom_corrector);
    add_example_words(&mut custom_corrector);

    // Create a transposition-heavy error model (good for common spelling errors)
    let transposition_model = ErrorModel::new(0.1, 0.1, 0.1, 0.7);
    custom_corrector.set_error_model(transposition_model);

    // Test some examples
    println!("\nCorrecting text with transposition-heavy error model:");
    let testtext = "I recieved a mesage about thier acheivements.";
    let corrected = custom_corrector.correcttext(testtext)?;

    println!("Before: {testtext}");
    println!("After:  {corrected}");

    Ok(())
}

pub fn with_max_distance(self, maxdistance: usize) -> Self

Set the maximum edit distance to consider

pub fn error_probability(&self, typo: &str, correct: &str) -> f64

Calculate the error probability P(typo | correct)

Examples found in repository

examples/statistical_spelling_demo.rs (line 421)

fn noise_model_demo() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n=== Error Model Demo ===\n");

    // Create different error models with varying error type probabilities
    let models = [
        ("Default", ErrorModel::default()),
        ("Deletion-heavy", ErrorModel::new(0.7, 0.1, 0.1, 0.1)),
        ("Insertion-heavy", ErrorModel::new(0.1, 0.7, 0.1, 0.1)),
        ("Substitution-heavy", ErrorModel::new(0.1, 0.1, 0.7, 0.1)),
        ("Transposition-heavy", ErrorModel::new(0.1, 0.1, 0.1, 0.7)),
    ];

    // Test cases for different error types
    let test_pairs = [
        ("recieve", "receive"),        // Transposition (i and e)
        ("acheive", "achieve"),        // Transposition (i and e)
        ("languge", "language"),       // Deletion (missing 'a')
        ("programing", "programming"), // Deletion (missing 'm')
        ("probblem", "problem"),       // Insertion (extra 'b')
        ("committe", "committee"),     // Insertion (missing 'e')
        ("definately", "definitely"),  // Substitution ('a' instead of 'i')
        ("seperate", "separate"),      // Substitution ('e' instead of 'a')
    ];

    // Test each error model
    println!(
        "{:<20} {:<12} {:<12} {:<12} {:<12} {:<12}",
        "Model", "Delete Prob", "Insert Prob", "Subst Prob", "Transp Prob", "Example"
    );
    println!("{:-<80}", "");

    for (name, model) in &models {
        // Pick one example to show
        let (typo, correct) = test_pairs[0];
        let probability = model.error_probability(typo, correct);

        println!(
            "{:<20} {:<12.2} {:<12.2} {:<12.2} {:<12.2} {:<12.4}",
            name,
            model.p_deletion,
            model.p_insertion,
            model.p_substitution,
            model.p_transposition,
            probability
        );
    }

    println!("\nError probabilities for different error types (using default model):");

    let default_model = ErrorModel::default();

    for (typo, correct) in &test_pairs {
        let prob = default_model.error_probability(typo, correct);
        println!("{typo:<12} -> {correct:<12}: {prob:.6}");
    }

    println!("\nImpact on correction with custom error model:");

    // Create a statistical corrector with a custom error model
    let custom_config = StatisticalCorrectorConfig {
        language_model_weight: 0.3,
        edit_distance_weight: 0.7,
        ..Default::default()
    };

    let mut custom_corrector = StatisticalCorrector::new(custom_config);
    train_language_model(&mut custom_corrector);
    add_example_words(&mut custom_corrector);

    // Create a transposition-heavy error model (good for common spelling errors)
    let transposition_model = ErrorModel::new(0.1, 0.1, 0.1, 0.7);
    custom_corrector.set_error_model(transposition_model);

    // Test some examples
    println!("\nCorrecting text with transposition-heavy error model:");
    let testtext = "I recieved a mesage about thier acheivements.";
    let corrected = custom_corrector.correcttext(testtext)?;

    println!("Before: {testtext}");
    println!("After:  {corrected}");

    Ok(())
}

pub fn min_edit_operations(&self, typo: &str, correct: &str) -> Vec<EditOp>

Find the minimum edit operations to transform correct into typo

pub fn levenshtein_with_ops( &self, s1: &str, s2: &str, operations: &mut Vec<EditOp>, ) -> usize

Legacy implementation of Levenshtein distance with operations tracking

Trait Implementations

impl Clone for ErrorModel

fn clone(&self) -> ErrorModel

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ErrorModel

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

Formats the value using the given formatter.

impl Default for ErrorModel

fn default() -> Self

Returns the “default value” for a type.