Wie initialisiert man ein Array von Strukturen in MATLAB?

Wie kann ich preallocate ein array von structs in MATLAB? Ich möchte preallocate "a" in diesem Beispiel, so dass es nicht die Größe mehrmals.

a = []
for i = 1:100
  a(i).x = i;
end

InformationsquelleAutor der Frage Mohammad Moghimi | 2012-12-01

matlab

Mit repmat ist bei weitem der effizienteste Weg, um preallocate Strukturen :

N = 10000;    
b = repmat(struct('x',1), N, 1 );

Dies ist ~10x schneller mit Matlab 2011a, als preallocating über die Indizierung, wie in

N      = 10000;
b(N).x = 1

Indexing-Methode ist nur geringfügig schneller als nicht preallocating.

No preallocation:            0.075524    
Preallocate Using indexing:  0.063774
Preallocate with repmat:     0.005234

Folgenden Code in Fall, dass Sie überprüfen möchten.

        clear;
        N = 10000;

    %1) GROWING A STRUCT
        tic;
        for ii=1:N
            a(ii).x(1)=1;    
        end
        noPreAll = toc;        

    %2)PREALLOCATING A STRUCT
        tic;
        b = repmat( struct( 'x', 1 ), N, 1 );
        for ii=1:N
            b(ii).x(1)=1;    
        end;  
        repmatBased=toc;        

    %3)Index to preallocate
        c(N).x = 1;
        for ii=1:N
            c(ii).x(1)=1;    
        end;  
        preIndex=toc;

        disp(['No preallocation:        ' num2str(noPreAll)])            
        disp(['Preallocate Indexing:    ' num2str(preIndex)])
        disp(['Preallocate with repmat: ' num2str(repmatBased)])
No preallocation:        0.075524    
Preallocate Indexing:    0.063774
Preallocate with repmat: 0.0052338
>>

P. S. ich wäre daran interessiert zu wissen, warum dies wahr ist, wenn jemand kann es erklären.

InformationsquelleAutor der Antwort jerad

11

Gibt es eine nette Diskussion über diese in Loren auf die Kunst des MATLAB blog.

Wenn ich Sie richtig verstehe, ist hier eine Weise, die zum initialisieren der struct Sie wollen:
```
a(100).x = 100;
```
Mit dieser Methode können wir sehen, dass Elemente sind gefüllt mit leeren arrays.

InformationsquelleAutor der Antwort bla
10

Gibt es eine Reihe von Möglichkeiten, wie Sie können initialisieren einer Struktur. Zum Beispiel, können Sie die struct Befehl:
```
a(1:100) = struct('x',[]);
```
setzt alle Felder x zu leeren.

Können Sie auch deal zu erstellen und füllen Sie die Struktur, wenn Sie wissen, welche Daten gehen sollte es
```
xx = num2cell(1:100);
[a(1:100).x]=deal(xx{:});
a(99).x
ans =
    99
```
Oder verwenden Sie struct wieder (beachten Sie, dass, wenn ein Feld der Struktur sollte ein cell-array, die Zelle muss in geschweifte Klammern eingeschlossen werden!)
```
a = struct('x',xx)
```
InformationsquelleAutor der Antwort Jonas
1

Die Art und Weise dies gemacht werden soll, und die einfachste ist
```
a=struct('x',cell(1,N));
```
Wenn Sie beheben die fehlende "tic" und fügen Sie diese Methode, um die benchmarking-code präsentiert von jerad, die Methode, die ich vorschlagen, oben ist ein bisschen langsamer als repmat aber viel einfacher zu implementieren, hier ist die Ausgabe:
```
No preallocation:        0.10137
Preallocate Indexing:    0.07615
Preallocate with repmat: 0.01458
Preallocate with struct: 0.07588
```
Dem Grund, dass repmat schneller ist, da ein Wert zu jedem x' - Feld zugeordnet ist, während der pre-allocation, statt es leer zu lassen. Wenn die oben genannten pre-allocation-Technik geändert wird, so beginnen wir mit aller der x-Felder, die einen Wert () zugewiesen, wie folgt:
```
    a=cell(1,N);
    a(:)={1};
    d=struct('x',a);
```
Dann das benchmarking verbessert sehr, sehr nahe gewesen, oder einige Zeit schneller als repmat. Der Unterschied ist so klein, dass jedes mal, wenn ich es laufen lasse ändert es das man schneller ist. Hier ein ergebnisbeispiel:
```
No preallocation:        0.0962
Preallocate Indexing:    0.0745
Preallocate with repmat: 0.0259
Preallocate with struct: 0.0184
```
Umgekehrt, wenn die repmat pre-Zuweisung geändert wird, setzen Sie das Feld leer, wie diese
```
b = repmat( struct( 'x', {} ), N, 1 );
```
Alle speed-Vorteil verloren

InformationsquelleAutor der Antwort Camilo Rada
-1

Laut diese Antwort, es gibt auch einen anderen Weg, es zu tun:
```
[a.x] = deal(val);
```
wo val ist der Wert, den Sie zuweisen möchten jeder element der struct.

Den Effekt dieses Befehls unterscheidet sich von derjenigen der anderen, wie jeder x Feld jeder Struktur a zugewiesen werden, die val Wert.

InformationsquelleAutor der Antwort Alessandro Cuttin
-1

Anstatt von pre-Zuweisung das array von structs kann es einfacher sein, um die Rückseite der Schleife. Auf diese Weise wird das array zugewiesen, der in der ersten iteration und den rest der Iterationen verwendet werden, die zum füllen der Strukturen.
```
a = []
for i = 100:-1:1
    a(i).x = i;
end
```
InformationsquelleAutor der Antwort Jasper Uijlings

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.