95767
もともとjuliaで書いていた数値計算プログラムをrustに移植しようとしています.  
rust for beginnerを読みながら実装をすすめていたのですが, トレイト境界について誤解しているらしく  
思ったような挙動になりません.  
具体的には, 添付コードのb_to_wがnot foundになってしまいます. Tで境界として, Wenoトレイトを指定しているのですが  
これではメソッド呼び出しできないのでしょうか?  
もしくは抽象化の方法がrustとして間違っているのでしょうか.  
回答お願いいたします.

```

    trait Reconstruct {}
    
    trait Scheme<const N: usize> {
        fn compute(st: &[f64; N]) -> f64;
        fn compute_l(&self, st: &[f64; N]) -> f64;
        fn compute_r(st: &[f64; N]) -> f64;
    }
    
    trait Weno {
        const D0: f64 = 2.0;
        const D1: f64 = 2.0;
        const D2: f64 = 2.0;
    
        fn b_to_w(b1: f64, b2: f64, b3: f64) -> [f64; 3];
    }
    
    impl<T: Weno> Scheme<5> for T {
        fn compute(st: &[f64; 5]) -> f64 {
            todo!()
        }
    
        fn compute_l(&self, st: &[f64; 5]) -> f64 {
            let [qmm, qm, q, qp, qpp] = st;
    
            let q0 = 1. / 3. * qmm - 7. / 6. * qm + 11. / 6. * q;
            let q1 = -1. / 6. * qm + 5. / 6. * q + 1. / 3. * qp;
            let q2 = 1. / 3. * q + 5. / 6. * qp - 1. / 6. * qpp;
    
            let b0 =
                13. / 12. * (qmm - 2. * qm + q).powf(2.) + 1. / 4. * (qmm - 4. * qm + 3. * q).powf(2.);
            let b1 = 13. / 12. * (qm - 2. * q + qp).powf(2.) + 1. / 4. * (qm - qp).powf(2.);
            let b2 =
                13. / 12. * (q - 2. * qp + qpp).powf(2.) + 1. / 4. * (3. * q - 4. * qp + qpp).powf(2.);
    
            let d0 = 0.1;
            let d1 = 0.6;
            let d2 = 0.3;
            let [w0, w1, w2] = self.b_to_w(b0, b1, b2);
            q0 * w0 + q1 * w1 + q2 * w2
        }
    
        fn compute_r(st: &[f64; 5]) -> f64 {
            todo!()
        }
    }
    
    struct WenoZ;
    
    impl Weno for WenoZ {
        fn b_to_w(b0: f64, b1: f64, b2: f64) -> [f64; 3] {
            let t = (b2 - b0).abs();
            let e = 1.0e-20;
            let bz0 = (b0 + e) / (b0 + t + e);
            let bz1 = (b1 + e) / (b1 + t + e);
            let bz2 = (b2 + e) / (b2 + t + e);
            let a0 = Self::D0 / bz0;
            let a1 = Self::D1 / bz1;
            let a2 = Self::D2 / bz2;
            let sum = a0 + a1 + a2;
            [a0 / sum, a1 / sum, a2 / sum]
        }
    }
    
    
```
CC BY-SA 4.0
2023-07-26T09:50:24.133
95764
2023-07-26T15:41:42.627
2023-07-26T15:41:42.627
19110
59265
question
rust
rustのジェネリクスを使った実装で、トレイトの関数がnot foundになってしまう
`b_to_w` は引数に `&self` を取らないので

```

            let [w0, w1, w2] = Self::b_to_w(b0, b1, b2);
    
```

とすれば呼び出せます。あるいは同じ意味になりますが `T::b_to_w` でもいけます（`Self`は今`T`のことを指している）
CC BY-SA 4.0
2023-07-26T10:50:15.620
95767
2023-07-26T10:50:15.620
9572
95764
answer