cargo add p3-interpolation

p3-interpolation = “0.3.0”

use p3_interpolation::lagrange::LagrangeInterpolation;

fn main() {
    // 定义已知数据点
    let points = vec![
        (0.0, 1.0),
        (1.0, 2.0),
        (2.0, 4.0),
        (3.0, 8.0),
    ];
    
    // 创建拉格朗日插值器
    let interpolator = LagrangeInterpolation::new(&points);
    
    // 在x=1.5处进行插值计算
    let x = 1.5;
    let y = interpolator.evaluate(x);
    
    println!("在 x = {} 处的插值结果为: {}", x, y);
    
    // 验证插值结果
    println!("验证: 2^1.5 = {}", 2.0f64.powf(1.5));
}

use p3_interpolation::lagrange::LagrangeInterpolation;
use p3_interpolation::newton::NewtonInterpolation;

fn main() {
    println!("=== 多项式插值计算示例 ===");
    
    // 示例数据点：指数函数 y = 2^x
    let data_points = vec![
        (0.0, 1.0),   // 2^0 = 1
        (1.0, 2.0),   // 2^1 = 2
        (2.0, 4.0),   // 2^2 = 4
        (3.0, 8.0),   // 2^3 = 8
    ];
    
    // 使用拉格朗日插值法
    println!("\n1. 拉格朗日插值法:");
    let lagrange = LagrangeInterpolation::new(&data_points);
    
    // 在多个点进行插值计算
    for &x in &[0.5, 1.5, 2.5] {
        let y_interpolated = lagrange.evaluate(x);
        let y_actual = 2.0f64.powf(x);
        let error = (y_interpolated - y_actual).abs();
        
        println!("x = {:.1}: 插值 = {:.6}, 实际 = {:.6}, 误差 = {:.6}", 
                x, y_interpolated, y_actual, error);
    }
    
    // 使用牛顿插值法
    println!("\n2. 牛顿插值法:");
    let newton = NewtonInterpolation::new(&data_points);
    
    // 在相同点进行插值计算
    for &x in &[0.5, 1.5, 2.5] {
        let y_interpolated = newton.evaluate(x);
        let y_actual = 2.0f64.powf(x);
        let error = (y_interpolated - y_actual).abs();
        
        println!("x = {:.1}: 插值 = {:.6}, 实际 = {:.6}, 误差 = {:.6}", 
                x, y_interpolated, y_actual, error);
    }
    
    // 数值逼近计算示例
    println!("\n3. 数值逼近计算:");
    
    // 生成更多的数据点用于逼近
    let mut more_points = data_points.clone();
    more_points.extend(vec![
        (0.5, 2.0f64.powf(0.5)),
        (1.5, 2.0f64.powf(1.5)),
        (2.5, 2.0f64.powf(2.5)),
    ]);
    
    // 使用更多点进行拉格朗日插值
    let better_interpolator = LagrangeInterpolation::new(&more_points);
    
    // 测试逼近效果
    let test_x = 1.8;
    let y_approx = better_interpolator.evaluate(test_x);
    let y_exact = 2.0f64.powf(test_x);
    
    println!("在 x = {} 处:", test_x);
    println!("  逼近值: {:.6}", y_approx);
    println!("  精确值: {:.6}", y_exact);
    println!("  相对误差: {:.4}%", (y_approx - y_exact).abs() / y_exact * 100.0);
}

h691938207 1楼

p3-interpolation：Rust多项式插值与数值逼近计算库

介绍

p3-interpolation是一个高效的Rust库，专注于多项式插值和数值逼近计算。该库提供了多种插值方法，包括拉格朗日插值、牛顿插值和样条插值等，适用于科学计算、工程分析和数据处理等领域。

主要特性

支持多种插值算法
高性能计算实现
内存安全保证
易于使用的API设计
完善的错误处理

安装方法

在Cargo.toml中添加依赖：

[dependencies]
p3-interpolation = "0.1.0"

基本使用方法

拉格朗日插值示例

use p3_interpolation::lagrange_interpolation;

fn main() {
    // 已知数据点
    let x_data = vec![0.0, 1.0, 2.0, 3.0];
    let y_data = vec![1.0, 2.0, 4.0, 8.0];
    
    // 创建插值器
    let interpolator = lagrange_interpolation::LagrangeInterpolator::new(&x_data, &y_data)
        .expect("数据点无效");
    
    // 在x=1.5处进行插值
    let result = interpolator.interpolate(1.5);
    println!("在x=1.5处的插值结果: {}", result);
}

牛顿插值示例

use p3_interpolation::newton_interpolation;

fn main() {
    let x_data = vec![0.0, 1.0, 2.0, 4.0];
    let y_data = vec![2.0, 3.0, 6.0, 18.0];
    
    let interpolator = newton_interpolation::NewtonInterpolator::new(&x_data, &y_data)
        .expect("数据点无效");
    
    // 批量插值计算
    let test_points = vec![0.5, 1.5, 3.0];
    for &x in &test_points {
        let y = interpolator.interpolate(x);
        println!("在x={}处的插值结果: {}", x, y);
    }
}

三次样条插值示例

use p3_interpolation::spline_interpolation;

fn main() {
    let x_data = vec![0.0, 1.0, 2.0, 3.0, 4.0];
    let y_data = vec![0.0, 1.0, 4.0, 9.0, 16.0];
    
    let spline = spline_interpolation::CubicSpline::new(&x_data, &y_data)
        .expect("数据点无效");
    
    // 获取插值函数
    let interpolated_value = spline.interpolate(2.5);
    println!("在x=2.5处的样条插值结果: {}", interpolated_value);
}

高级功能

误差分析

use p3_interpolation::{lagrange_interpolation, error_analysis};

fn main() {
    let x_data = vec![0.0, 1.0, 2.0, 3.0];
    let y_data = vec![1.0, 2.0, 4.0, 8.0];
    
    let interpolator = lagrange_interpolation::LagrangeInterpolator::new(&x_data, &y_data)
        .unwrap();
    
    // 计算在多个点的误差
    let test_points = vec![0.5, 1.5, 2.5];
    let errors = error_analysis::calculate_errors(
        &interpolator, 
        |x| x.exp(), // 真实函数
        &test_points
    );
    
    for (i, error) in errors.iter().enumerate() {
        println!("在x={}处的误差: {}", test_points[i], error);
    }
}

性能优化设置

use p3_interpolation::{lagrange_interpolation, PerformanceConfig};

fn main() {
    let config = PerformanceConfig {
        use_parallel: true,    // 启用并行计算
        cache_size: 1000,      // 设置缓存大小
        precision: 1e-12,      // 设置计算精度
    };
    
    let x_data = (0..1000).map(|x| x as f64).collect::<Vec<_>>();
    let y_data = x_data.iter().map(|x| x.sin()).collect::<Vec<_>>();
    
    let interpolator = lagrange_interpolation::LagrangeInterpolator::with_config(
        &x_data, 
        &y_data, 
        config
    ).unwrap();
}

完整示例demo

// 完整的多项式插值示例程序
use p3_interpolation::{lagrange_interpolation, newton_interpolation, spline_interpolation, error_analysis, PerformanceConfig};
use std::f64::consts::PI;

fn main() {
    println!("=== p3-interpolation 完整示例演示 ===");
    
    // 示例1: 拉格朗日插值
    println!("\n1. 拉格朗日插值示例:");
    let x_data_lagrange = vec![0.0, 1.0, 2.0, 3.0];
    let y_data_lagrange = vec![1.0, 2.0, 4.0, 8.0];
    
    let lagrange_interpolator = lagrange_interpolation::LagrangeInterpolator::new(
        &x_data_lagrange, 
        &y_data_lagrange
    ).expect("拉格朗日插值数据点无效");
    
    let test_point = 1.5;
    let lagrange_result = lagrange_interpolator.interpolate(test_point);
    println!("在x={}处的拉格朗日插值结果: {}", test_point, lagrange_result);
    
    // 示例2: 牛顿插值
    println!("\n2. 牛顿插值示例:");
    let x_data_newton = vec![0.0, 1.0, 2.0, 4.0];
    let y_data_newton = vec![2.0, 3.0, 6.0, 18.0];
    
    let newton_interpolator = newton_interpolation::NewtonInterpolator::new(
        &x_data_newton, 
        &y_data_newton
    ).expect("牛顿插值数据点无效");
    
    let test_points = vec![0.5, 1.5, 3.0];
    for &x in &test_points {
        let y = newton_interpolator.interpolate(x);
        println!("在x={}处的牛顿插值结果: {}", x, y);
    }
    
    // 示例3: 三次样条插值
    println!("\n3. 三次样条插值示例:");
    let x_data_spline = vec![0.0, 1.0, 2.0, 3.0, 4.0];
    let y_data_spline = vec![0.0, 1.0, 4.0, 9.0, 16.0];
    
    let spline = spline_interpolation::CubicSpline::new(
        &x_data_spline, 
        &y_data_spline
    ).expect("样条插值数据点无效");
    
    let spline_point = 2.5;
    let spline_result = spline.interpolate(spline_point);
    println!("在x={}处的样条插值结果: {}", spline_point, spline_result);
    
    // 示例4: 误差分析
    println!("\n4. 误差分析示例:");
    let errors = error_analysis::calculate_errors(
        &lagrange_interpolator, 
        |x| 2.0_f64.powf(x), // 真实函数：2的x次方
        &vec![0.5, 1.5, 2.5]
    );
    
    for (i, error) in errors.iter().enumerate() {
        println!("在x={}处的绝对误差: {:.6}", vec![0.5, 1.5, 2.5][i], error);
    }
    
    // 示例5: 性能优化
    println!("\n5. 性能优化示例:");
    let config = PerformanceConfig {
        use_parallel: true,
        cache_size: 2000,
        precision: 1e-10,
    };
    
    // 生成大量数据点
    let large_x_data: Vec<f64> = (0..500).map(|x| x as f64 * 0.1).collect();
    let large_y_data: Vec<f64> = large_x_data.iter().map(|x| (x * PI / 180.0).sin()).collect();
    
    let optimized_interpolator = lagrange_interpolation::LagrangeInterpolator::with_config(
        &large_x_data,
        &large_y_data,
        config
    ).expect("性能优化插值器创建失败");
    
    // 测试优化后的插值器
    let optimized_result = optimized_interpolator.interpolate(25.5);
    println!("优化后在x=25.5处的插值结果: {:.6}", optimized_result);
    println!("真实sin(25.5°)值: {:.6}", (25.5 * PI / 180.0).sin());
    
    println!("\n=== 示例演示完成 ===");
}

注意事项

确保输入的数据点x值是严格递增的
数据点数量至少为2个
对于大量数据点，建议使用样条插值以获得更好的性能
插值点应在数据点的范围内，外推结果可能不准确

错误处理

库提供了详细的错误信息，包括：

数据点数量不足
x值不是严格递增
输入数据长度不匹配
数值计算错误

通过合理使用p3-interpolation库，您可以在Rust项目中高效地实现各种插值计算需求。

Rust插值计算库p3-interpolation的使用，高效实现多项式插值与数值逼近计算