Konvertieren Sie ArrayD in Array2 in Rust

1. Array in Rost
2. Initialisierung und Deklaration des Arrays in Rust
3. ND-Array in Rust
4. Reihe 2 in Rost
5. Konvertierung von ArrayD nach Array2 in Rust

In diesem Artikel geht es um die Umwandlung von ArrayD in Array2 in Rust.

Array in Rost

Ein Array ist eine Sammlung von Werten desselben Typs. Eine Gruppe der Wichtigkeit desselben Datentyps wird als Array bezeichnet.

In der Rust-Programmierung ist ein Array eine Sammlung von Elementen fester Größe, die durch [T; N], wobei T den Elementtyp darstellt und N die konstante Größe des Arrays zur Kompilierzeit bezeichnet.

Ein Array kann auf zwei verschiedene Arten erstellt werden.

1. Einfach eine Liste von [x,y,z]-Elementen.
2. Wiederholung des Ausdrucks [N, X]. Dadurch wird ein Array erstellt, das N Instanzen von X enthält.

Initialisierung und Deklaration des Arrays in Rust

Es gibt mehrere Syntaxen zum Erstellen eines Arrays in Rust. Einige von ihnen sind:

Syntaxen:

Syntax 1:
let var_name = [val_1,val_2,val_3];

Example:
let _cars = ["BMW","Toyota","Ferrari"];

Syntax 2:
let var_name:[dataType;size_of_array] = [val_1,val_2,val_3];

Example:
let _numbers:[i32;3] = [1,2,3];

Syntax 3:
let var_name:[dataType;size_of_array] = [default_value,size_of_array];

Example:
let _num_array:[i32;3] = [0;3];

1. In der 1. Syntax ist cars der Variablenname und BMW, Toyota und Ferrari sind die Werte des Arrays.
2. In der zweiten Syntax ist numbers der Variablenname, i32 der Datentyp, 3 die Array-Größe und 1, 2 und 3 die Werte des Arrays.
3. In der 3. Syntax ist num_array der Variablenname, i32 der Datentyp, 3 die Array-Größe, 0 der Standardwert für Elemente und 3 die Größe des Arrays.

ND-Array in Rust

Die N-dimensionale Array-Datenstruktur wird häufig beim wissenschaftlichen Rechnen und Verarbeiten verwendet.

Die Crate ndarray implementiert N-dimensionale Array-Unterstützung in Rust. Andere Kisten machen davon ausgiebigen Gebrauch.

Reihe 2 in Rost

Array 2 ist das zweidimensionale Array. Es kann einfach mit dem Makro arr2 erstellt werden.

Das Beispiel für die Erstellung eines 3x3 2D-Arrays ist unten angegeben.

extern crate ndarray;
use ndarray::arr2;

fn main() {
    let mut two_dimensional_array = array2(&[[4, 5, 6],
                    [10, 11, 12],
                    [20, 21, 22]]);
    array2[[2, 1]] = 10;
    println!("The two dimensional array is {:?}", array2);
}

Ausgang:

The two dimensional array is [[4, 5, 6],
 [10, 11, 12],
 [20, 21, 22]], shape=[3, 3], strides=[3, 1], layout=Cc (0x5), const ndim=2

Konvertierung von ArrayD nach Array2 in Rust

Die Konvertierung eines Arrays in ein anderes ist mit demselben Typ möglich, aber die Dimensionen sollten unterschiedlich sein. Der Fehler tritt auf, wenn die Dimensionen des Arrays nicht übereinstimmen.

Daher muss die Anzahl der Achsen bei der Konvertierung übereinstimmen.

So konvertieren Sie ein n-dimensionales Array in ein 2D-Array:

Wir können dem folgenden Code folgen, wenn der Variablentyp ArrayD<f32> ist.

let arr2d: Array2<f32> = arr2d.into_dimensionality::<Ix2>()?;

Der obige Code soll es in eine Variable vom Typ Array2<f32> konvertieren.

use ndarray::{ArrayD, Ix2, IxDyn};

let array = ArrayD::<f32>::zeros(IxDyn(&[5, 5]));
assert!(array.into_dimensionality::<Ix2>().is_ok());

Oben ist der Code zum Erstellen eines dynamischen dimensionalen Arrays und zum Konvertieren in eine I * 2-Dimension.