feat: vendor midstream and sublinear-time-solver libraries

Add ruvnet/midstream (AIMDS real-time inference) and
ruvnet/sublinear-time-solver (sublinear optimization algorithms)
as vendored dependencies under vendor/.

Co-Authored-By: claude-flow <ruv@ruv.net>

vendor/midstream/examples/pattern_detection_demo.rs

@@ -0,0 +1,150 @@
+/// Example demonstrating the pattern detection APIs in temporal-compare
+///
+/// This example shows how to use:
+/// 1. find_similar() - Find similar patterns in time series
+/// 2. detect_pattern() - Detect if a pattern exists
+/// 3. Advanced APIs for recurring and fuzzy pattern detection
+
+use midstreamer_temporal_compare::{TemporalComparator, Pattern};
+
+fn main() {
+    println!("=== Temporal-Compare Pattern Detection Demo ===\n");
+
+    // Create a comparator with cache size 100 and max sequence length 1000
+    let comparator: TemporalComparator<f64> = TemporalComparator::new(100, 1000);
+
+    // Example 1: find_similar() - Find exact matches
+    println!("Example 1: Finding similar patterns with find_similar()");
+    println!("---------------------------------------------------");
+    let series1 = vec![1.0, 2.0, 3.0, 4.0, 5.0, 3.0, 4.0, 5.0, 6.0];
+    let pattern1 = vec![3.0, 4.0, 5.0];
+
+    println!("Series: {:?}", series1);
+    println!("Pattern: {:?}", pattern1);
+
+    let matches = comparator.find_similar(&series1, &pattern1, 0.5);
+    println!("Found {} matches:", matches.len());
+    for (idx, distance) in &matches {
+        println!("  - Index {}: distance = {:.4}", idx, distance);
+    }
+    println!();
+
+    // Example 2: detect_pattern() - Simple boolean detection
+    println!("Example 2: Detecting pattern existence with detect_pattern()");
+    println!("-------------------------------------------------------------");
+    let series2 = vec![10.0, 20.0, 30.0, 40.0, 50.0];
+    let pattern2a = vec![30.0, 40.0, 50.0];
+    let pattern2b = vec![100.0, 200.0, 300.0];
+
+    println!("Series: {:?}", series2);
+    println!("Pattern A: {:?}", pattern2a);
+    let found_a = comparator.detect_pattern(&series2, &pattern2a, 1.0);
+    println!("Pattern A detected: {}", found_a);
+
+    println!("Pattern B: {:?}", pattern2b);
+    let found_b = comparator.detect_pattern(&series2, &pattern2b, 1.0);
+    println!("Pattern B detected: {}", found_b);
+    println!();
+
+    // Example 3: Approximate matching with threshold
+    println!("Example 3: Approximate matching with different thresholds");
+    println!("----------------------------------------------------------");
+    let series3 = vec![1.0, 2.0, 3.1, 4.2, 4.9, 6.0];
+    let pattern3 = vec![3.0, 4.0, 5.0];
+
+    println!("Series: {:?}", series3);
+    println!("Pattern: {:?}", pattern3);
+
+    // Strict threshold
+    let strict_matches = comparator.find_similar(&series3, &pattern3, 0.5);
+    println!("Strict threshold (0.5): {} matches", strict_matches.len());
+
+    // Loose threshold
+    let loose_matches = comparator.find_similar(&series3, &pattern3, 2.0);
+    println!("Loose threshold (2.0): {} matches", loose_matches.len());
+    for (idx, distance) in &loose_matches {
+        println!("  - Index {}: distance = {:.4}", idx, distance);
+    }
+    println!();
+
+    // Example 4: Generic API with integers
+    println!("Example 4: Generic API with integer sequences");
+    println!("----------------------------------------------");
+    let comparator_int: TemporalComparator<i32> = TemporalComparator::new(100, 1000);
+
+    let haystack = vec![1, 2, 3, 4, 5, 3, 4, 5, 6, 7];
+    let needle = vec![3, 4, 5];
+
+    println!("Haystack: {:?}", haystack);
+    println!("Needle: {:?}", needle);
+
+    let matches = comparator_int.find_similar_generic(&haystack, &needle, 0.1).unwrap();
+    println!("Found {} matches:", matches.len());
+    for m in &matches {
+        println!("  - Index {}: similarity = {:.4}, distance = {:.4}",
+                 m.start_index, m.similarity, m.distance);
+    }
+    println!();
+
+    // Example 5: Detect recurring patterns
+    println!("Example 5: Automatic recurring pattern detection");
+    println!("------------------------------------------------");
+    let comparator_char: TemporalComparator<char> = TemporalComparator::new(100, 1000);
+
+    let sequence = vec!['a', 'b', 'c', 'a', 'b', 'c', 'd', 'e', 'd', 'e'];
+
+    println!("Sequence: {:?}", sequence);
+
+    let patterns = comparator_char.detect_recurring_patterns(&sequence, 2, 3).unwrap();
+    println!("Found {} recurring patterns:", patterns.len());
+    for (i, pattern) in patterns.iter().enumerate() {
+        println!("  Pattern {}: {:?}", i + 1, pattern.sequence);
+        println!("    Frequency: {}", pattern.frequency());
+        println!("    Confidence: {:.4}", pattern.confidence);
+        println!("    Occurrences at: {:?}", pattern.occurrences);
+    }
+    println!();
+
+    // Example 6: Fuzzy pattern detection
+    println!("Example 6: Fuzzy pattern detection (groups similar patterns)");
+    println!("-------------------------------------------------------------");
+    let comparator_fuzzy: TemporalComparator<i32> = TemporalComparator::new(100, 1000);
+
+    let sequence = vec![1, 2, 3, 1, 2, 4, 1, 2, 3, 5, 6, 7, 5, 6, 8];
+
+    println!("Sequence: {:?}", sequence);
+
+    let fuzzy_patterns = comparator_fuzzy.detect_fuzzy_patterns(&sequence, 3, 3, 0.7).unwrap();
+    println!("Found {} fuzzy pattern groups:", fuzzy_patterns.len());
+    for (i, pattern) in fuzzy_patterns.iter().enumerate() {
+        println!("  Pattern Group {}: {:?}", i + 1, pattern.sequence);
+        println!("    Frequency: {} (includes variations)", pattern.frequency());
+        println!("    Confidence: {:.4}", pattern.confidence);
+    }
+    println!();
+
+    // Example 7: Cache performance
+    println!("Example 7: Cache performance demonstration");
+    println!("------------------------------------------");
+
+    // Clear cache first
+    comparator.clear_cache();
+
+    // Run same query multiple times
+    for i in 1..=5 {
+        let _ = comparator.find_similar(&series1, &pattern1, 0.5);
+        let stats = comparator.cache_stats();
+        println!("  Iteration {}: hits = {}, misses = {}, hit rate = {:.2}%",
+                 i, stats.hits, stats.misses, stats.hit_rate() * 100.0);
+    }
+    println!();
+
+    println!("=== Demo Complete ===");
+    println!("\nKey Takeaways:");
+    println!("1. find_similar() uses DTW to find pattern matches with configurable threshold");
+    println!("2. detect_pattern() provides simple boolean detection");
+    println!("3. Generic APIs work with any comparable type (f64, i32, char, etc.)");
+    println!("4. Automatic pattern discovery finds recurring patterns");
+    println!("5. Fuzzy matching groups similar pattern variations");
+    println!("6. Built-in caching improves performance for repeated queries");
+}