Phương Pháp Khoảng Cách trong Giao Dịch Cặp: Triển Khai và Phân Tích với Rust

Phương Pháp Khoảng Cách trong giao dịch cặp đã trở nên phổ biến đáng kể nhờ tính đơn giản thanh lịch và hiệu quả của nó. Kỹ thuật này xác định các cặp tài sản thông qua các phép đo thống kê và giao dịch dựa trên sự phân kỳ và hội tụ của mối quan hệ giá giữa chúng. Bài viết này cung cấp phân tích toàn diện về cả hai phương pháp Tiếp Cận Khoảng Cách cơ bản và nâng cao, cùng với các triển khai thực tế bằng Rust được tối ưu hóa cho các nhà giao dịch tần số cao, nhà phát triển thuật toán, nhà toán học và lập trình viên đang tìm kiếm các giải pháp mạnh mẽ.

Trực quan hóa Phương Pháp Khoảng Cách: Tài sản A và B theo dõi lẫn nhau, với các tín hiệu giao dịch được tạo ra dựa trên sự phân kỳ của chênh lệch (Long/Short)

Cơ Sở Lý Thuyết của Phương Pháp Khoảng Cách

Phương Pháp Khoảng Cách thiết lập một khung làm việc cho giao dịch cặp dựa trên các chuyển động giá được chuẩn hóa giữa các tài sản. Về bản chất, phương pháp này sử dụng các phép đo khoảng cách bình phương Euclidean để xác định các tài sản có xu hướng di chuyển cùng nhau trong lịch sử và tạo ra các tín hiệu giao dịch khi sự phân kỳ giá chuẩn hóa của chúng vượt quá các ngưỡng có ý nghĩa thống kê[2].

Phương pháp này bao gồm hai giai đoạn chính:

1. Hình thành cặp - xác định các cặp tài sản có liên quan về mặt thống kê
2. Tạo tín hiệu giao dịch - tạo ra các quy tắc vào và ra dựa trên sự phân kỳ

Cơ Sở Toán Học

Triển khai cơ bản sử dụng khoảng cách Euclidean giữa các chuỗi giá được chuẩn hóa. Với hai tài sản có chuỗi thời gian giá chuẩn hóa X và Y, chúng ta tính:

fn euclidean_squared_distance(x: &[f64], y: &[f64]) -> f64 {
    assert_eq!(x.len(), y.len(), "Time series must have equal length");
    
    x.iter()
        .zip(y.iter())
        .map(|(xi, yi)| (xi - yi).powi(2))
        .sum()
}

Phép đo khoảng cách này giúp xác định các tài sản có xu hướng di chuyển cùng nhau trong lịch sử, tạo nền tảng cho các cơ hội chênh lệch giá thống kê[2].

Triển Khai Phương Pháp Khoảng Cách Cơ Bản

Chuẩn Hóa Dữ Liệu

Trước khi tính khoảng cách, chúng ta phải chuẩn hóa dữ liệu giá để thiết lập các thang đo có thể so sánh được. Chuẩn hóa min-max thường được áp dụng:

fn min_max_normalize(prices: &[f64]) -> Vec<f64> {
    if prices.is_empty() {
        return Vec::new();
    }
    
    let min_price = prices.iter().fold(f64::INFINITY, |a, &b| a.min(b));
    let max_price = prices.iter().fold(f64::NEG_INFINITY, |a, &b| a.max(b));
    let range = max_price - min_price;
    
    if range.abs() < f64::EPSILON {
        return vec![0.5; prices.len()];
    }
    
    prices.iter()
        .map(|&price| (price - min_price) / range)
        .collect()
}

Tìm Các Cặp Gần Nhất

Chúng ta xác định các cặp tiềm năng bằng cách tính khoảng cách Euclidean giữa tất cả các tổ hợp tài sản và chọn những cặp có khoảng cách nhỏ nhất:

#[derive(Debug, Clone)]
struct StockPair {
    stock1_idx: usize,
    stock2_idx: usize,
    distance: f64,
}

impl PartialEq for StockPair {
    fn eq(&self, other: &Self) -> bool {
        self.distance.eq(&other.distance)
    }
}

impl Eq for StockPair {}

impl PartialOrd for StockPair {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        self.distance.partial_cmp(&other.distance)
    }
}

impl Ord for StockPair {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        self.partial_cmp(other).unwrap_or(std::cmp::Ordering::Equal)
    }
}

fn find_closest_pairs(normalized_prices: &[Vec<f64>], top_n: usize) -> Vec<StockPair> {
    let stock_count = normalized_prices.len();
    let mut pairs = BinaryHeap::new();
    
    for i in 0..stock_count {
        for j in (i+1)..stock_count {
            let distance = euclidean_squared_distance(&normalized_prices[i], &normalized_prices[j]);
            
            pairs.push(Reverse(StockPair {
                stock1_idx: i,
                stock2_idx: j,
                distance,
            }));
            
            // Keep only top N pairs
            if pairs.len() > top_n {
                pairs.pop();
            }
        }
    }
    
    // Convert from heap to vector and reverse to get ascending order
    pairs.into_iter().map(|Reverse(pair)| pair).collect()
}

Tính Biến Động Lịch Sử

Tính toán biến động lịch sử là rất quan trọng để thiết lập các ngưỡng giao dịch phù hợp:

fn calculate_spread_volatility(normalized_price1: &[f64], normalized_price2: &[f64]) -> f64 {
    assert_eq!(normalized_price1.len(), normalized_price2.len());
    
    // Calculate price spread
    let spread: Vec<f64> = normalized_price1.iter()
        .zip(normalized_price2.iter())
        .map(|(p1, p2)| p1 - p2)
        .collect();
    
    // Calculate mean of spread
    let mean = spread.iter().sum::<f64>() / spread.len() as f64;
    
    // Calculate standard deviation
    let variance = spread.iter()
        .map(|&x| (x - mean).powi(2))
        .sum::<f64>() / spread.len() as f64;
    
    variance.sqrt()
}

Các Phương Pháp Lựa Chọn Nâng Cao

Lọc Theo Nhóm Ngành

Giới hạn lựa chọn cặp trong cùng một ngành có thể nâng cao hiệu suất bằng cách chọn các tài sản có liên quan về mặt kinh tế:

fn find_industry_pairs(
    normalized_prices: &[Vec<f64>], 
    industry_codes: &[usize], 
    top_n_per_industry: usize
) -> Vec<StockPair> {
    // Group stocks by industry
    let mut industry_groups: std::collections::HashMap<usize, Vec<usize>> = std::collections::HashMap::new();
    
    for (idx, &code) in industry_codes.iter().enumerate() {
        industry_groups.entry(code).or_default().push(idx);
    }
    
    // Find closest pairs within each industry
    let mut all_pairs = Vec::new();
    
    for (_industry_code, stock_indices) in industry_groups {
        let mut industry_pairs = Vec::new();
        
        for i in 0..stock_indices.len() {
            for j in (i+1)..stock_indices.len() {
                let stock1_idx = stock_indices[i];
                let stock2_idx = stock_indices[j];
                let distance = euclidean_squared_distance(
                    &normalized_prices[stock1_idx], 
                    &normalized_prices[stock2_idx]
                );
                
                industry_pairs.push(StockPair {
                    stock1_idx,
                    stock2_idx,
                    distance,
                });
            }
        }
        
        // Sort pairs by distance
        industry_pairs.sort_by(|a, b| a.distance.partial_cmp(&b.distance).unwrap());
        
        // Take top N from each industry
        let top_pairs: Vec<StockPair> = industry_pairs.into_iter()
            .take(top_n_per_industry)
            .collect();
            
        all_pairs.extend(top_pairs);
    }
    
    all_pairs
}

Phương pháp giao cắt không (zero-crossings) xác định các cặp có sự hội tụ và phân kỳ thường xuyên, có khả năng chỉ ra các cơ hội giao dịch sinh lời hơn:

Khái niệm Zero-Crossings: xác định các cặp thường xuyên hồi quy về giá trị trung bình, được chỉ ra bởi chênh lệch cắt qua đường không

fn count_zero_crossings(spread: &[f64]) -> usize {
    if spread.len() < 2 {
        return 0;
    }
    
    let mut count = 0;
    for i in 1..spread.len() {
        if (spread[i-1] < 0.0 && spread[i] >= 0.0) || 
           (spread[i-1] >= 0.0 && spread[i] < 0.0) {
            count += 1;
        }
    }
    
    count
}

fn find_zero_crossing_pairs(
    normalized_prices: &[Vec<f64>],
    top_distance_threshold: f64,
    min_crossings: usize
) -> Vec<StockPair> {
    let stock_count = normalized_prices.len();
    let mut qualifying_pairs = Vec::new();
    
    for i in 0..stock_count {
        for j in (i+1)..stock_count {
            let distance = euclidean_squared_distance(&normalized_prices[i], &normalized_prices[j]);
            
            // Only consider pairs with distance below threshold
            if distance < top_distance_threshold {
                // Calculate spread
                let spread: Vec<f64> = normalized_prices[i].iter()
                    .zip(normalized_prices[j].iter())
                    .map(|(p1, p2)| p1 - p2)
                    .collect();
                
                let crossings = count_zero_crossings(&spread);
                
                if crossings >= min_crossings {
                    qualifying_pairs.push(StockPair {
                        stock1_idx: i,
                        stock2_idx: j,
                        distance,
                    });
                }
            }
        }
    }
    
    // Sort by number of crossings (could extend StockPair to include this)
    qualifying_pairs.sort_by(|a, b| a.distance.partial_cmp(&b.distance).unwrap());
    qualifying_pairs
}

Xem Xét Độ Lệch Chuẩn Lịch Sử

Phương pháp này giải quyết một hạn chế của phương pháp cơ bản bằng cách ưu tiên các cặp có biến động chênh lệch cao hơn, điều này có thể tăng tiềm năng lợi nhuận:

fn find_highsd_pairs(
    normalized_prices: &[Vec<f64>],
    top_distance_count: usize,
    min_volatility: f64
) -> Vec<StockPair> {
    let stock_count = normalized_prices.len();
    let mut all_pairs = Vec::new();
    
    for i in 0..stock_count {
        for j in (i+1)..stock_count {
            let distance = euclidean_squared_distance(&normalized_prices[i], &normalized_prices[j]);
            
            // Calculate spread volatility
            let spread: Vec<f64> = normalized_prices[i].iter()
                .zip(normalized_prices[j].iter())
                .map(|(p1, p2)| p1 - p2)
                .collect();
            
            let volatility = calculate_spread_volatility(&normalized_prices[i], &normalized_prices[j]);
            
            if volatility >= min_volatility {
                all_pairs.push(StockPair {
                    stock1_idx: i,
                    stock2_idx: j,
                    distance,
                });
            }
        }
    }
    
    // Sort by distance
    all_pairs.sort_by(|a, b| a.distance.partial_cmp(&b.distance).unwrap());
    
    // Take top N pairs with highest volatility that meet distance criteria
    all_pairs.into_iter().take(top_distance_count).collect()
}

Phương Pháp Nâng Cao: Tương Quan Pearson

Phương pháp Tương Quan Pearson mang lại nhiều ưu điểm so với Phương Pháp Khoảng Cách cơ bản, tập trung vào tương quan lợi nhuận thay vì khoảng cách giá[1].

Triển Khai trong Rust

fn pearson_correlation(x: &[f64], y: &[f64]) -> f64 {
    assert_eq!(x.len(), y.len(), "Arrays must have the same length");
    
    let n = x.len() as f64;
    let sum_x: f64 = x.iter().sum();
    let sum_y: f64 = y.iter().sum();
    let sum_xx: f64 = x.iter().map(|&val| val * val).sum();
    let sum_yy: f64 = y.iter().map(|&val| val * val).sum();
    let sum_xy: f64 = x.iter().zip(y.iter()).map(|(&xi, &yi)| xi * yi).sum();
    
    let numerator = n * sum_xy - sum_x * sum_y;
    let denominator = ((n * sum_xx - sum_x * sum_x) * (n * sum_yy - sum_y * sum_y)).sqrt();
    
    if denominator.abs() < f64::EPSILON {
        return 0.0;
    }
    
    numerator / denominator
}

struct PearsonPair {
    stock_idx: usize,
    comover_indices: Vec<usize>,
    correlations: Vec<f64>,
}

fn find_pearson_pairs(returns: &[Vec<f64>], top_n_comovers: usize) -> Vec<PearsonPair> {
    let stock_count = returns.len();
    let mut all_pairs = Vec::new();
    
    for i in 0..stock_count {
        let mut correlations = Vec::with_capacity(stock_count - 1);
        
        for j in 0..stock_count {
            if i == j {
                continue;
            }
            
            let correlation = pearson_correlation(&returns[i], &returns[j]).abs();
            correlations.push((j, correlation));
        }
        
        // Sort by correlation (highest first)
        correlations.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
        
        // Take top N comovers
        let top_comovers: Vec<(usize, f64)> = correlations.into_iter()
            .take(top_n_comovers)
            .collect();
            
        let (comover_indices, correlation_values): (Vec<usize>, Vec<f64>) = 
            top_comovers.into_iter().unzip();
            
        all_pairs.push(PearsonPair {
            stock_idx: i,
            comover_indices,
            correlations: correlation_values,
        });
    }
    
    all_pairs
}

Hình Thành Danh Mục và Tính Beta

Phương pháp Pearson tạo ra các danh mục đầu tư từ các cổ phiếu đồng biến động cho mỗi cổ phiếu, sau đó tính các hệ số hồi quy:

fn calculate_beta(stock_returns: &[f64], portfolio_returns: &[f64]) -> f64 {
    let cov_xy = covariance(stock_returns, portfolio_returns);
    let var_x = variance(portfolio_returns);
    
    if var_x.abs() < f64::EPSILON {
        return 0.0;
    }
    
    cov_xy / var_x
}

fn covariance(x: &[f64], y: &[f64]) -> f64 {
    assert_eq!(x.len(), y.len());
    
    let n = x.len() as f64;
    let mean_x: f64 = x.iter().sum::<f64>() / n;
    let mean_y: f64 = y.iter().sum::<f64>() / n;
    
    let sum_cov: f64 = x.iter()
        .zip(y.iter())
        .map(|(&xi, &yi)| (xi - mean_x) * (yi - mean_y))
        .sum();
    
    sum_cov / n
}

fn variance(x: &[f64]) -> f64 {
    let n = x.len() as f64;
    let mean: f64 = x.iter().sum::<f64>() / n;
    
    let sum_var: f64 = x.iter()
        .map(|&xi| (xi - mean).powi(2))
        .sum();
    
    sum_var / n
}

Tạo Tín Hiệu Giao Dịch

Bước cuối cùng trong cả hai phương pháp là tạo các tín hiệu giao dịch dựa trên các ngưỡng phân kỳ:

enum TradingSignal {
    Long,
    Short,
    Neutral
}

struct TradePosition {
    stock1_idx: usize,
    stock2_idx: usize,
    signal: TradingSignal,
    entry_spread: f64,
    timestamp: usize,
}

fn generate_trading_signals(
    normalized_prices: &[Vec<f64>],
    pairs: &[StockPair], 
    threshold_multiplier: f64,
    volatilities: &[f64],
    current_time: usize
) -> Vec<TradePosition> {
    let mut positions = Vec::new();
    
    for (pair_idx, pair) in pairs.iter().enumerate() {
        let stock1_idx = pair.stock1_idx;
        let stock2_idx = pair.stock2_idx;
        
        // Calculate current spread
        let current_spread = normalized_prices[stock1_idx][current_time] - 
                             normalized_prices[stock2_idx][current_time];
                             
        let threshold = threshold_multiplier * volatilities[pair_idx];
        
        let signal = if current_spread > threshold {
            // Stock1 is overvalued relative to Stock2
            TradingSignal::Short
        } else if current_spread < -threshold {
            // Stock1 is undervalued relative to Stock2
            TradingSignal::Long
        } else {
            TradingSignal::Neutral
        };
        
        if signal != TradingSignal::Neutral {
            positions.push(TradePosition {
                stock1_idx,
                stock2_idx,
                signal,
                entry_spread: current_spread,
                timestamp: current_time,
            });
        }
    }
    
    positions
}

Tối Ưu Hóa Hiệu Suất

Đối với các hệ thống giao dịch tần số cao, hiệu suất là yếu tố then chốt. Các lệnh SIMD (Single Instruction, Multiple Data) có thể tăng tốc đáng kể các phép tính khoảng cách:

Tăng tốc SIMD: tận dụng tính song song ở cấp độ dữ liệu trong Rust để xử lý đồng thời nhiều điểm giá, giảm đáng kể độ trễ

#[cfg(target_arch = "x86_64")]
use std::arch::x86_64::*;

#[cfg(target_arch = "x86_64")]
#[inline]
unsafe fn euclidean_distance_simd(x: &[f32], y: &[f32]) -> f32 {
    assert_eq!(x.len(), y.len());
    
    let mut sum = _mm256_setzero_ps();
    let chunks = x.len() / 8;
    
    for i in 0..chunks {
        let xi = _mm256_loadu_ps(&x[i * 8]);
        let yi = _mm256_loadu_ps(&y[i * 8]);
        
        let diff = _mm256_sub_ps(xi, yi);
        let squared = _mm256_mul_ps(diff, diff);
        sum = _mm256_add_ps(sum, squared);
    }
    
    // Handle the remaining elements
    let mut result = _mm256_reduce_add_ps(sum);
    
    for i in (chunks * 8)..x.len() {
        result += (x[i] - y[i]).powi(2);
    }
    
    result.sqrt()
}

// Helper function to sum SIMD vector
#[cfg(target_arch = "x86_64")]
#[inline(always)]
unsafe fn _mm256_reduce_add_ps(v: __m256) -> f32 {
    let hilow = _mm256_extractf128_ps(v, 1);
    let low = _mm256_castps256_ps128(v);
    let sum128 = _mm_add_ps(hilow, low);
    
    let hi64 = _mm_extractf128_si128(_mm_castps_si128(sum128), 1);
    let low64 = _mm_castps_si128(sum128);
    let sum64 = _mm_add_ps(_mm_castsi128_ps(hi64), _mm_castsi128_ps(low64));
    
    _mm_cvtss_f32(_mm_hadd_ps(sum64, sum64))
}

Xử lý bất đồng bộ có thể cải thiện thêm thông lượng, đặc biệt khi xử lý nhiều cặp cổ phiếu:

use tokio::task;
use futures::future::join_all;

async fn process_pairs_async(
    normalized_prices: &[Vec<f64>],
    stock_count: usize,
    chunk_size: usize
) -> Vec<StockPair> {
    let mut tasks = Vec::new();
    
    // Split work into chunks
    let chunks = (stock_count + chunk_size - 1) / chunk_size;
    
    for chunk in 0..chunks {
        let start = chunk * chunk_size;
        let end = std::cmp::min((chunk + 1) * chunk_size, stock_count);
        
        let prices_clone = normalized_prices.to_vec();
        
        let task = task::spawn(async move {
            let mut pairs = Vec::new();
            
            for i in start..end {
                for j in (i+1)..stock_count {
                    let distance = euclidean_squared_distance(&prices_clone[i], &prices_clone[j]);
                    
                    pairs.push(StockPair {
                        stock1_idx: i,
                        stock2_idx: j,
                        distance,
                    });
                }
            }
            
            pairs
        });
        
        tasks.push(task);
    }
    
    // Await all tasks and combine results
    let results = join_all(tasks).await;
    
    let mut all_pairs = Vec::new();
    for result in results {
        if let Ok(pairs) = result {
            all_pairs.extend(pairs);
        }
    }
    
    // Sort by distance
    all_pairs.sort_by(|a, b| a.distance.partial_cmp(&b.distance).unwrap_or(std::cmp::Ordering::Equal));
    all_pairs
}

Kiểm Tra Triển Khai Chiến Lược

Để đánh giá triển khai của chúng ta, chúng ta cần cơ sở hạ tầng kiểm tra phù hợp:

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_normalization() {
        let prices = vec![10.0, 15.0, 12.0, 18.0, 20.0];
        let normalized = min_max_normalize(&prices);
        
        let expected = vec![0.0, 0.5, 0.2, 0.8, 1.0];
        
        for (a, b) in normalized.iter().zip(expected.iter()) {
            assert!((a - b).abs() < 0.001);
        }
    }
    
    #[test]
    fn test_euclidean_distance() {
        let x = vec![0.1, 0.2, 0.3, 0.4, 0.5];
        let y = vec![0.15, 0.22, 0.35, 0.38, 0.53];
        
        let distance = euclidean_squared_distance(&x, &y);
        let expected = 0.0049; // Calculated manually
        
        assert!((distance - expected).abs() < 0.0001);
    }
    
    #[test]
    fn test_pearson_correlation() {
        let x = vec![1.0, 2.0, 3.0, 4.0, 5.0];
        let y = vec![5.0, 4.0, 3.0, 2.0, 1.0];
        
        let corr = pearson_correlation(&x, &y);
        let expected = -1.0; // Perfect negative correlation
        
        assert!((corr - expected).abs() < 0.0001);
    }
    
    // Integration tests would be implemented in tests/ directory
}

Đối với kiểm tra tích hợp, chúng ta sẽ tuân theo quy ước Rust về việc đặt các bài kiểm tra trong thư mục tests riêng biệt ở gốc dự án[15][18].

Kết Luận

Phương Pháp Khoảng Cách cung cấp một khung làm việc mạnh mẽ cho giao dịch cặp, với cả hai phương pháp cơ bản và nâng cao đều mang lại các cơ hội chênh lệch giá thống kê có giá trị. Phương pháp cơ bản, với trọng tâm là khoảng cách Euclidean, mang lại sự đơn giản và hiệu quả, trong khi phương pháp Tương Quan Pearson cung cấp sự linh hoạt bổ sung và các đặc điểm hồi quy phân kỳ tiềm năng tốt hơn.

Các đặc điểm hiệu suất của Rust khiến nó trở thành ngôn ngữ lý tưởng để triển khai các chiến lược đòi hỏi tính toán cao này, đặc biệt với các tối ưu hóa như SIMD và xử lý đồng thời. Sự kết hợp giữa tính nghiêm ngặt về mặt thống kê và triển khai hiệu quả tạo ra một bộ công cụ mạnh mẽ cho các nhà giao dịch thuật toán.

Khi triển khai hệ thống giao dịch cặp, cần xem xét một số yếu tố:

1. Sự đánh đổi giữa tính đơn giản (phương pháp cơ bản) và sức mạnh thống kê nâng cao (phương pháp Pearson)
2. Tài nguyên tính toán cần thiết cho phân tích cặp quy mô lớn
3. Chi phí giao dịch, có thể ảnh hưởng đáng kể đến lợi nhuận[3]
4. Nhu cầu giám sát liên tục và hiệu chỉnh lại các cặp

Bằng cách kết hợp Phương Pháp Khoảng Cách với các khả năng hiệu suất của Rust, các nhà giao dịch có thể phát triển các hệ thống chênh lệch giá thống kê hiệu quả và hiệu suất cao, có khả năng hoạt động với tốc độ và quy mô cần thiết cho các thị trường hiện đại.

Trích Dẫn

@software{soloviov2025distanceapproach,
  author = {Soloviov, Eugen},
  title = {Distance Approach in Pairs Trading: Implementation and Analysis with Rust},
  year = {2025},
  url = {https://marketmaker.cc/vi/blog/post/distance-approach-pairs-trading},
  version = {0.1.0},
  description = {Phân tích toàn diện các phương pháp Tiếp Cận Khoảng Cách cơ bản và nâng cao trong giao dịch cặp, cùng các triển khai thực tế bằng Rust được tối ưu hóa cho các nhà giao dịch tần số cao và nhà phát triển thuật toán.}
}

Tài Liệu Tham Khảo

1. Hudson Thames - Giới Thiệu về Phương Pháp Khoảng Cách trong Giao Dịch Cặp Phần II
2. Hudson Thames - Phương Pháp Khoảng Cách trong Giao Dịch Cặp Phần I
3. Reddit - Giao Dịch Cặp Có Quá Tốt Để Là Sự Thật?
4. GitHub - Kucoin Arbitrage
5. docs.rs - Khoảng Cách Euclidean trong crate geo
6. Hồi Quy Tuyến Tính Đơn Giản trong Rust
7. GitHub - correlation_rust
8. docs.rs - Đồng Tích Hợp trong algolotl-ta
9. GitHub - trading_engine_rust
10. docs.rs - crate distances
11. Reddit - Tìm crate thống kê cho Dickey-Fuller
12. crates.io - crypto-pair-trader
13. w3resource - Bài Tập Structs và Enums trong Rust
14. Sách Rust - Tổ Chức Kiểm Tra
15. Mẫu Thiết Kế trong Rust
16. GitHub - simd-euclidean
17. Rust by Example - Kiểm Tra Tích Hợp
18. YouTube - Kiểm Tra Tích Hợp trong Rust
19. Stack Overflow - Tính Tổng Khoảng Cách Giữa Nhiều Điểm
20. Databento - Ví Dụ Giao Dịch Cặp
21. Rust std - f64 Primitive
22. Hudson & Thames - Tài Liệu Phương Pháp Khoảng Cách
23. GitHub - trading-algorithms-rust
24. docs.rs - crate linreg
25. Sách Rust - Tham Chiếu và Mượn
26. Stack Overflow - Cách Diễn Giải Kết Quả Kiểm Tra adfuller
27. lib.rs - crate arima
28. Kinh Tế Lượng với R - Đồng Tích Hợp
29. DolphinDB - Hàm adfuller
30. docs.rs - crate arima (mới nhất)
31. Wikipedia - Đồng Tích Hợp