Início / coding / Perguntas / 77739178
Accepted
Quantumania
Asked: 2023-12-31 20:44:28 +0800 CST

Use a redução do Rust para executar o produto kronecker sequencial em vários arrays

  • 772

Sou novo no Rust e estou tentando usar o Rust para executar produtos kronecker sequenciais para múltiplas matrizes, ou seja, quero fazer

insira a descrição da imagem aqui

Em python, eu sei que posso fazer

import numpy as np
from functools import reduce

X = np.array([[0, 1], [1, 0])
matrices = [X for _ in range(8)]
product = reduce(np.kron, matrices)

e obtenha o resultado desejado. Como fazer o mesmo no Rust?

Meu código Rust está parecido com o seguinte por enquanto:

use ndarray::{array, ArrayBase, OwnedRepr, Dim};
use ndarray::linalg::kron;
use num::complex::Complex64 as Complex;



fn X() -> ArrayBase<OwnedRepr<Complex>, Dim<[usize; 2]>> {
    array![
        [Complex::new(0.0, 0.0), Complex::new(1.0, 0.0)],
        [Complex::new(1.0, 0.0), Complex::new(0.0, 0.0)]
    ]
}

fn main() {    
    let mut matrices = Vec::new();
    for _ in 0..8 {
        matrices.push(X());
    }
    let product = matrices
        .iter()
        .reduce(|g1, g2| kron(g1, g2));

}

Aqui está a matriz de erro que obtive:

erro

Aqui estão as coisas que não entendo:

  • OwnedRepr: Não tenho certeza para que serve exatamente, mas foi isso que o analisador de ferrugem me sugeriu fazer
  • Tentei modificar meu código de acordo com a sugestão da mensagem de erro, mas nova mensagem de erro não obtive mais sugestões de como processar.

Gostaria de saber como consertar isso e agradeceria se houvesse alguma sugestão de arquivos de exemplo de nível iniciante sobre como usar o Rust para fazer cálculos científicos.

math

1 respostas

  1. Best Answer

    Ao contrário do Python, no Rust você deve pensar na propriedade.

    ndarrayinclui várias versões de matrizes : Array, ArrayView, e . Eles são análogos às muitas maneiras pelas quais podemos visualizar dados no Rust: propriedade ( ou ) - isto é , que é um alias de , referência compartilhada ( ) - , referência mutável ( ) - , propriedade compartilhada ( e ) - e cópia- na gravação ( ) - .ArrayViewMutArcArrayCowArrayTBox<T>ArrayArrayBase<OwnedRepr>&TArrayView&mut TArrayViewMutRc<T>Arc<T>ArcArrayCow<T>CowArray

    iter()fornece um iterador sobre referências aos elementos, ou seja, &Array, enquanto kron()retorna matrizes próprias - Array. Mas reduce()exige que as entradas e a saída sejam do mesmo tipo, porque a saída se torna a entrada do próximo item. Então você precisa unificá-los.

    Existem várias maneiras de fazer isso. Por exemplo, usando into_iter()em vez de iter():

    let product = matrices.into_iter().reduce(|g1, g2| kron(&g1, &g2));

    Ou clonando a primeira matriz e usando fold():

    fn kron_many(matrices: &[Array2<Complex>]) -> Option<Array2<Complex>> {
    let (first, rest) = matrices.split_first()?;
    let first = first.clone();
    Some(rest.iter().fold(first, |g1, g2| kron(&g1, g2)))
}

fn main() {
    let mut matrices = Vec::new();
    for _ in 0..8 {
        matrices.push(X());
    }
    let product = kron_many(&matrices);
}

    Ou sem clonagem, usando CowArraypara representar um array talvez de propriedade:

    let product = matrices
    .iter()
    .map(|matrix| CowArray::from(matrix))
    .reduce(|g1, g2| kron(&g1, &g2).into());
    • 2

relate perguntas