Rust插值计算库interpolation的使用，提供高效数值插值与平滑曲线生成功能

Rust插值计算库interpolation的使用，提供高效数值插值与平滑曲线生成功能

interpolation是一个用于插值计算的Rust库，支持多种插值方法，能够高效地进行数值插值和平滑曲线生成。

安装

在项目目录中运行以下Cargo命令：

cargo add interpolation

或者在Cargo.toml中添加：

interpolation = "0.3.0"

基础使用示例

use interpolation::{lerp, Lerp};

fn main() {
    // 线性插值示例
    let a = 0.0;
    let b = 10.0;
    let t = 0.5;
    
    // 方法1: 使用lerp函数
    let result = lerp(&a, &b, t);
    println!("lerp({}, {}, {}) = {}", a, b, t, result); // 输出5.0
    
    // 方法2: 使用Lerp trait
    let result = a.lerp(&b, t);
    println!("{}.lerp({}, {}) = {}", a, b, t, result); // 输出5.0
}

完整示例demo

下面是一个更完整的示例，展示如何使用interpolation库进行不同类型数据的插值计算：

use interpolation::{lerp, Lerp, Ease, EaseFunction};
use interpolation::Spatial;

fn main() {
    // 1. 基本数值插值
    println!("--- 基本数值插值 ---");
    let start = 0.0;
    let end = 100.0;
    
    for i in 0..=10 {
        let t = i as f32 / 10.0;
        let value = lerp(&start, &end, t);
        println!("t={:.1}: {:.1}", t, value);
    }
    
    // 2. 使用缓动函数
    println!("\n--- 使用缓动函数 ---");
    let ease_fn = EaseFunction::QuadraticInOut;
    
    for i in 0..=10 {
        let t = i as f32 / 10.0;
        let eased_t = ease_fn.ease(t);
        let value = lerp(&start, &end, eased_t);
        println!("t={:.1} -> eased={:.3} -> value={:.1}", t, eased_t, value);
    }
    
    // 3. 空间位置插值
    println!("\n--- 空间位置插值 ---");
    #[derive(Debug)]
    struct Point {
        x: f32,
        y: f32,
    }
    
    impl Spatial for Point {
        fn add(&self, other: &Self) -> Self {
            Point {
                x: self.x + other.x,
                y: self.y + other.y,
            }
        }
        
        fn scale(&self, s: f32) -> Self {
            Point {
                x: self.x * s,
                y: self.y * s,
            }
        }
    }
    
    let p1 = Point { x: 0.0, y: 0.0 };
    let p2 = Point { x: 10.0, y: 20.0 };
    
    for i in 0..=5 {
        let t = i as f32 / 5.0;
        let p = lerp(&p1, &p2, t);
        println!("t={:.1}: {:?}", t, p);
    }
}

功能特点

  1. 支持多种插值方法：

    • 线性插值 (lerp)
    • 缓动函数 (easing functions)
    • 空间插值 (Spatial trait)

  2. 类型安全：

    • 使用泛型实现，支持任何实现了适当trait的类型

  3. 高性能：

    • 零成本抽象
    • 编译时优化

interpolation库特别适合需要平滑过渡效果的场景，如动画、游戏开发、数据可视化等领域。通过使用不同的缓动函数，可以创建各种自然的运动效果。


1 回复

Rust插值计算库interpolation使用指南

interpolation是Rust中一个功能强大的数值插值库，提供了多种插值算法和曲线生成功能。下面介绍其主要功能和使用方法。

安装

在Cargo.toml中添加依赖：

[dependencies]
interpolation = "1.0"

基本用法

线性插值

use interpolation::Lerp;

fn main() {
    let a = 0.0;
    let b = 10.0;
    let t = 0.5; // 插值参数，范围[0.0, 1.0]
    
    let result = a.lerp(&b, t);
    println!("线性插值结果: {}", result); // 输出 5.0
}

样条插值

use interpolation::Spline;

fn main() {
    // 创建样条插值器
    let spline = Spline::from_vec(vec![
        (0.0, 0.0),
        (1.0, 2.0),
        (2.0, 1.0),
        (3.0, 4.0),
    ]);
    
    // 在x=1.5处插值
    let y = spline.clamped_sample(1.5);
    println!("样条插值结果: {}", y);
}

高级功能

缓动函数

use interpolation::Ease;

fn main() {
    let t = 0.5;
    
    // 使用不同的缓动函数
    let ease_in = t.ease_in_quad();
    let ease_out = t.ease_out_cubic();
    let ease_in_out = t.ease_in_out_sine();
    
    println!("缓动函数结果: {}, {}, {}", ease_in, ease_out, ease_in_out);
}

多维插值

use interpolation::{Lerp, Spline2d};

fn main() {
    // 2D样条插值
    let points = vec![
        vec![(0.0, 0.0), (1.0, 2.0)],
        vec![(0.0, 1.0), (1.0, 3.0)],
    ];
    
    let spline2d = Spline2d::from_vec(points);
    let value = spline2d.sample(0.5, 0.5);
    println!("2D样条插值结果: {}", value);
}

性能优化

对于大量数据插值，可以使用precompute方法预先计算插值参数：

use interpolation::Spline;

fn main() {
    let mut spline = Spline::from_vec(vec![
        (0.0, 0.0),
        (1.0, 2.0),
        (2.0, 1.0),
        (3.0, 4.0),
    ]);
    
    spline.precompute(); // 预先计算
    
    // 后续插值操作会更快
    for x in 0..100 {
        let y = spline.clamped_sample(x as f64 * 0.01);
        println!("x: {}, y: {}", x, y);
    }
}

注意事项

  1. 插值参数t通常应在[0.0, 1.0]范围内
  2. 样条插值需要至少4个点才能获得平滑结果
  3. 对于周期性数据，考虑使用Spline::new_periodic方法

这个库非常适合游戏开发、数据可视化和科学计算中需要平滑插值的场景。

完整示例

下面是一个完整的示例，展示了interpolation库的主要功能：

use interpolation::{Lerp, Spline, Ease, Spline2d};

fn main() {
    // 1. 线性插值示例
    println!("\n=== 线性插值 ===");
    let start = 0.0;
    let end = 100.0;
    for t in 0..=10 {
        let t = t as f64 * 0.1;
        let value = start.lerp(&end, t);
        println!("在t={:.1}时, 插值结果: {:.1}", t, value);
    }

    // 2. 样条插值示例
    println!("\n=== 样条插值 ===");
    let points = vec![
        (0.0, 0.0),
        (1.0, 2.0),
        (2.0, 1.0),
        (3.0, 4.0),
    ];
    let mut spline = Spline::from_vec(points);
    spline.precompute(); // 预计算优化性能
    
    for x in 0..=30 {
        let x = x as f64 * 0.1;
        let y = spline.clamped_sample(x);
        println!("在x={:.1}处, y={:.4}", x, y);
    }

    // 3. 缓动函数示例
    println!("\n=== 缓动函数 ===");
    for t in 0..=10 {
        let t = t as f64 * 0.1;
        println!(
            "t={:.1}: 二次缓入={:.4}, 三次缓出={:.4}, 正弦缓入缓出={:.4}",
            t,
            t.ease_in_quad(),
            t.ease_out_cubic(),
            t.ease_in_out_sine()
        );
    }

    // 4. 2D样条插值示例
    println!("\n=== 2D样条插值 ===");
    let grid = vec![
        vec![(0.0, 0.0), (1.0, 2.0)],
        vec![(0.0, 1.0), (1.0, 3.0)],
    ];
    let spline2d = Spline2d::from_vec(grid);
    
    for x in 0..=10 {
        for y in 0..=10 {
            let x = x as f64 * 0.1;
            let y = y as f64 * 0.1;
            let value = spline2d.sample(x, y);
            println!("在({:.1}, {:.1})处, 值={:.4}", x, y, value);
        }
    }
}

这个完整示例包含了：

  1. 线性插值的基础用法
  2. 样条插值及预计算优化
  3. 多种缓动函数的应用
  4. 二维样条插值的实现

运行此示例可以全面了解interpolation库的功能和用法。

回到顶部