如何定义鲁斯特的功能？

Question

我决定做2D向量积在生锈。在JavaScript中，这是简单的事：

float CrossProduct( const Vec2& a, const Vec2& b ) {
    return a.x * b.y - a.y * b.x;
}

我试图把它转换为防锈系统：

// Just created two separate variables for the two different vectors

let vec1 = vec![1.15, 7.0];
let vec2 = vec![7.0, 2.0];
let cross_product(&vec1, &vec2) = vec1[0] * vec2[1] - vec1[1] * vec2[0];
println!("{}", cross_product);

// I also tried return.
let vec1 = vec![1.15, 7.0];
let vec2 = vec![7.0, 2.0];
let cross_product(&vec1, &vec2) {
    return (vec1[0] * vec2[1] - vec1[1] * vec2[0]);
}
println!("{}", cross_product);

我认为这些人会工作，但是这更多的是一个现实的支票给我锈多么的不同可以从我以前使用的任何语言。

我发现了一个非常低效的方式来解决这个问题，但是我宁愿学会正确地做到这一点。我是新来的锈，所以请把我尝试用一​​粒盐。

Answer 1

有两种可能的方式来做到这一点。

First Way

你可以声明函数，并将其传递到println!()它类似于像Java,C#等多种编程语言

//Declare the function
fn cross_product(slice1: &[i32], slice2: &[i32]) -> i32 {
    slice1[0] * slice2[1] - slice1[1] * slice2[2]
}

//Use it Like following
fn main() {
    let vec1 = vec![1, 2, 3];
    let vec2 = vec![4, 5, 6];

    println!("{}", cross_product(&vec1[..], &vec2[..]));
}

Second Way

你可以声明封闭，并将其传递到println!()，在函数式编程一个共同的方法：

// You can declare a closure and use it as function in the same code block
fn main() {
    let vec1 = vec![1, 2, 3];
    let vec2 = vec![4, 5, 6];

    let cross_product = |slice1: &[i32], slice2: &[i32]| -> i32 {
        let result = slice1[0] * slice2[1] - slice1[1] * slice2[2];
        result
    };

    println!("{}", cross_product(&vec1[..], &vec2[..]));
}

请注意，我已创建使用i32数据类型，它对应于一个整数向量和闭包。你可以用f32更改类型，或者如果你想更广泛的范围内浮动f64。

Answer 2

它看起来像你主要有锈语法问题。您可以创建一个跨产品功能或做跨产品在线。

let vec1 = vec![1.15, 7.0];
let vec2 = vec![7.0, 2.0];
let cross_product = vec1[0] * vec2[1] - vec1[1] * vec2[0];
println!("{}", cross_product);

如果你想有一个功能，您可以不断使用。

fn function_cross_product(vec1: Vec<f64>, vec2: Vec<f64>) -> f64 {
  return vec1[0] * vec2[1] - vec1[1] * vec2[0];
};
let other_product = function_cross_product(vec1, vec2);
println!("{}", other_product);

第二种解决方案可以是误导，因为它总是会产生对一个2x2向量的叉积即使你通过不同尺寸的向量。