Struct SimdStringOps 

pub struct SimdStringOps;

SIMD-accelerated string comparison operations

Implementations

impl SimdStringOps

pub fn is_available() -> bool

Check if SIMD acceleration is available

Examples found in repository

examples/complete_integration.rs (line 245)

    fn demo_performance_monitored_simd(&self) -> Result<()> {
        println!("⚡ Demo 2: Performance-Monitored SIMD Operations");
        println!("===============================================");

        let testtexts = [
            "The quick brown fox jumps over the lazy dog".to_string(),
            "Pack my box with five dozen liquor jugs".to_string(),
            "How vexingly quick daft zebras jump!".to_string(),
            "Bright vixens jump; dozy fowl quack".to_string(),
        ];

        println!("Running SIMD-accelerated operations with performance monitoring...");

        // Start monitoring
        let operation_monitor = self
            .performance_monitor
            .start_operation("simd_operations")?;

        let start_time = Instant::now();

        // Optimized text processing
        let testtext_refs: Vec<&str> = testtexts.iter().map(|s| s.as_str()).collect();
        let processed_results = AdvancedSIMDTextProcessor::advanced_batch_process(&testtext_refs);

        // SIMD string operations
        let char_counts: Vec<usize> = testtexts
            .iter()
            .map(|text| SimdStringOps::count_chars(text, 'o'))
            .collect();

        // Optimized similarity matrix
        let similarity_matrix =
            AdvancedSIMDTextProcessor::advanced_similarity_matrix(&testtext_refs);

        let processing_time = start_time.elapsed();

        // Complete monitoring
        operation_monitor.complete(testtexts.len())?;

        println!("\n📊 SIMD Operation Results:");
        println!("  • Processing Time: {processing_time:?}");
        println!("  • Documents Processed: {}", processed_results.len());
        println!("  • Character Counts (letter 'o'): {char_counts:?}");
        println!(
            "  • Similarity Matrix Size: {}x{}",
            similarity_matrix.len(),
            similarity_matrix[0].len()
        );

        // Display similarity matrix
        println!("\n🔗 Text Similarity Matrix:");
        for (i, row) in similarity_matrix.iter().enumerate() {
            print!("  Row {i}: [");
            for (j, &similarity) in row.iter().enumerate() {
                if j > 0 {
                    print!(", ");
                }
                print!("{similarity:.3}");
            }
            println!("]");
        }

        // Show SIMD capabilities
        println!("\n⚙️  SIMD Capabilities:");
        println!("  • SIMD Available: {}", SimdStringOps::is_available());
        println!("  • String Processing: Optimized");
        println!("  • Pattern Matching: Optimized");
        println!("  • Similarity Computation: Vectorized");

        println!();
        Ok(())
    }

pub fn count_chars(text: &str, target: char) -> usize

Fast character counting using SIMD

Examples found in repository

examples/complete_integration.rs (line 208)

    fn demo_performance_monitored_simd(&self) -> Result<()> {
        println!("⚡ Demo 2: Performance-Monitored SIMD Operations");
        println!("===============================================");

        let testtexts = [
            "The quick brown fox jumps over the lazy dog".to_string(),
            "Pack my box with five dozen liquor jugs".to_string(),
            "How vexingly quick daft zebras jump!".to_string(),
            "Bright vixens jump; dozy fowl quack".to_string(),
        ];

        println!("Running SIMD-accelerated operations with performance monitoring...");

        // Start monitoring
        let operation_monitor = self
            .performance_monitor
            .start_operation("simd_operations")?;

        let start_time = Instant::now();

        // Optimized text processing
        let testtext_refs: Vec<&str> = testtexts.iter().map(|s| s.as_str()).collect();
        let processed_results = AdvancedSIMDTextProcessor::advanced_batch_process(&testtext_refs);

        // SIMD string operations
        let char_counts: Vec<usize> = testtexts
            .iter()
            .map(|text| SimdStringOps::count_chars(text, 'o'))
            .collect();

        // Optimized similarity matrix
        let similarity_matrix =
            AdvancedSIMDTextProcessor::advanced_similarity_matrix(&testtext_refs);

        let processing_time = start_time.elapsed();

        // Complete monitoring
        operation_monitor.complete(testtexts.len())?;

        println!("\n📊 SIMD Operation Results:");
        println!("  • Processing Time: {processing_time:?}");
        println!("  • Documents Processed: {}", processed_results.len());
        println!("  • Character Counts (letter 'o'): {char_counts:?}");
        println!(
            "  • Similarity Matrix Size: {}x{}",
            similarity_matrix.len(),
            similarity_matrix[0].len()
        );

        // Display similarity matrix
        println!("\n🔗 Text Similarity Matrix:");
        for (i, row) in similarity_matrix.iter().enumerate() {
            print!("  Row {i}: [");
            for (j, &similarity) in row.iter().enumerate() {
                if j > 0 {
                    print!(", ");
                }
                print!("{similarity:.3}");
            }
            println!("]");
        }

        // Show SIMD capabilities
        println!("\n⚙️  SIMD Capabilities:");
        println!("  • SIMD Available: {}", SimdStringOps::is_available());
        println!("  • String Processing: Optimized");
        println!("  • Pattern Matching: Optimized");
        println!("  • Similarity Computation: Vectorized");

        println!();
        Ok(())
    }

pub fn find_whitespace_positions(text: &str) -> Vec<usize>

Fast whitespace detection using SIMD

pub fn to_lowercase_ascii(text: &str) -> String

SIMD-accelerated case conversion for ASCII text

pub fn find_substring(haystack: &str, needle: &str) -> Option<usize>

SIMD-accelerated substring search using byte comparison

pub fn is_alphanumeric_ascii(text: &str) -> bool

SIMD-accelerated character validation

pub fn hamming_distance(s1: &str, s2: &str) -> Option<usize>

SIMD-accelerated Hamming distance calculation