Gewusst wie: ausführen mehrerer Anweisungen in einer MATLAB-anonym-Funktion?

Ich würde gerne etwas wie das hier tun:

>> foo = @() functionCall1() functionCall2()

So, dass wenn ich gesagt habe:

>> foo()

Es würde ausführen functionCall1() und führen Sie dann functionCall2(). (Ich fühle, dass ich brauche so etwas wie die C , operator)

EDIT:

functionCall1 und functionCall2 sind nicht unbedingt die Funktionen, die Werte zurückgeben.

Tun functionCall1 und functionCall2 jemals akzeptiert input-Werte? Wenn nicht, die Lösung gab ich unten sollte funktionieren. Wenn Sie akzeptieren Werte, meine Lösung könnte immer noch funktionieren, aber brauchen würde, einige änderungen.
Ich aktualisiert meine Antwort mit einem Beispiel für die übergabe von input-Argumente, nur für den Fall Sie es brauchen.

InformationsquelleAutor Daniel LeCheminant | 2009-02-17

45

Versuchen, alles zu tun, über die Kommandozeile ohne speichern der Funktionen in m-Dateien kann eine komplizierte und unübersichtliche Unterfangen, aber hier ist ein Weg, ich kam mit...

Erstes anonyme Funktionen und setzen Ihre Griffe in einem cell array:
```
fcn1 = @() ...;
fcn2 = @() ...;
fcn3 = @() ...;
fcnArray = {fcn1 fcn2 fcn3};
```
...oder, wenn Sie Funktionen, die bereits definiert (wie in m-Dateien), Stelle die Funktion verarbeitet in einem cell-array in etwa so:
```
fcnArray = {@fcn1 @fcn2 @fcn3};
```
Dann können Sie eine neue anonyme Funktion, die ruft jede Funktion im array mit Hilfe des built-in-Funktionen cellfun und feval:
```
foo = @() cellfun(@feval,fcnArray);
```
Zwar witzig aussieht, es funktioniert.

EDIT:, Wenn die Funktionen in fcnArray aufgerufen werden müssen mit der Eingabe-Argumente, würden Sie zunächst sicherstellen, dass ALLE Funktionen im array benötigen DIE GLEICHE Anzahl von Eingängen. In diesem Fall wird das folgende Beispiel zeigt, wie der Aufruf der array-Funktionen mit einem input-argument jeder:
```
foo = @(x) cellfun(@feval,fcnArray,x);
inArgs = {1 'a' [1 2 3]};
foo(inArgs);  %# Passes 1 to fcn1, 'a' to fcn2, and [1 2 3] to fcn3
```
WORT DER WARNUNG: Die Dokumentation für cellfun besagt, dass die um, in dem die Ausgabe-Elemente berechnet werden, ist nicht angegeben und sollten nicht als verlässlich angesehen werden. Dies bedeutet, dass es gibt keine Garantien, dass fcn1 wird ausgewertet, bevor fcn2 oder fcn3. Wenn die Bestellung ankommt, ist die obige Lösung nicht verwendet werden sollte.

süß! ich habe versucht, herauszufinden, etwas ähnliches.
Interessant! Und natürlich könnte man nur erklären, fcnArray direkt ab, anstatt als separate variable, also so etwas wie: myfun = @() cellfun(@feval,{@() xlim([1 5]), @() xlabel('seconds')}); Jetzt, ruft myfun setzt sowohl xlim und xlabel in der Abbildung.

InformationsquelleAutor gnovice
11

Der anonymen Funktion syntax in Matlab (wie einige andere Sprachen) erlaubt nur einen einzigen Ausdruck. Darüber hinaus hat es verschiedene variable Bindung Semantik (Variablen, die nicht in der argument-Liste haben Ihre Werte lexikalisch gebunden an die Erstellung einer Funktion der Zeit, anstatt von Referenzen gebunden werden). Diese Einfachheit erlaubt es Mathworks, um einige Optimierungen hinter den kulissen und vermeiden Sie eine Menge von unordentlichen scoping und Lebensdauer von Objekten Probleme, wenn Sie Sie in Skripts.

Wenn Sie die Definition der anonymen Funktion innerhalb einer Funktion (kein Skript), können Sie benannte innere Funktionen. Innere Funktionen haben normale lexikalische Referenz verbindlich und erlauben eine beliebige Anzahl von Anweisungen.
```
function F = createfcn(a,...)
  F = @myfunc;
  function b = myfunc(...)
    a = a+1; 
    b = a; 
  end
end
```
Manchmal kann man sich mit tricks wie gnovice Vorschlag.

Vorsichtig sein, über die Verwendung von eval,... es ist sehr ineffizient (es umgeht die JIT) und Matlab s-Optimierer verwirrt zwischen den Variablen und Funktionen, die aus dem äußeren Rahmen, die verwendet werden, innerhalb der eval-Ausdruck. Es ist auch schwer zu Debuggen und/oder das Ausmaß code mit eval.

InformationsquelleAutor Mr Fooz
6

Hier ist eine Methode, mit der Garantie für die Ausführungsreihenfolge und das, (mit den erwähnten änderungen am Ende) erlaubt die übergabe unterschiedliche Argumente für unterschiedliche Funktionen.
```
call1 = @(a,b) a();
call12 = @(a,b) call1(b,call1(a,b));
```
Den Schlüssel call1 fordert ein erstes argument und ignoriert Ihr zweites. call12 fordert sein erstes argument und dann die zweite, die Rückgabe der Wert aus der zweiten. Es funktioniert, weil eine Funktion nicht ausgewertet werden kann, bevor Ihre Argumente. Erstellen Sie Ihr Beispiel, würden Sie schreiben:
```
foo = @() call12(functionCall1, functionCall2);
```
Test-Code

Hier ist der test-code, den ich verwendet:
```
>> print1=@()fprintf('1\n');
>> print2=@()fprintf('2\n');
>> call12(print1,print2)
1
2
```
Aufrufen weitere Funktionen

Nennen Sie 3 Funktionen, könnten Sie schreiben,
```
call1(print3, call1(print2, call1(print1,print2)));
```
4 Funktionen:
```
call1(print4, call1(print3, call1(print2, call1(print1,print2))));
```
Weitere Funktionen, weiterhin die Verschachtelung Muster.

Argumente Übergeben

Wenn Sie müssen Argumente übergeben werden, Sie können schreiben, eine version von call1 nimmt Argumente und dann machen die offensichtliche änderung call12.
```
call1arg1 = @(a,arg_a,b) a(arg_a);
call12arg1 = @(a, arg_a, b, arg_b) call1arg1(b, arg_b, call1arg1(a, arg_a, b))
```
Können Sie auch Versionen von Ruf 1, die mehrere Argumente und mischen Sie und passen Sie diese entsprechend.

InformationsquelleAutor Eponymous
1

Wenn functionCall1() und functionCall2() etwas zurückgeben und denen irgendwas verkettet werden kann, dann können Sie dies tun:

>> foo = @() [functionCall1(), functionCall2()]

oder

>> foo = @() [functionCall1(); functionCall2()]

Ein Nebeneffekt dabei ist, dass foo() zurückkehren wird, die Verkettung von was auch immer functionCall1() und functionCall2() zurück.

Ich weiß nicht, ob die Reihenfolge der Ausführung von functionCall1() und functionCall2() gewährleistet ist.

Ja, leider bin ich den Umgang mit Funktionen, die keine Werte zurückgeben.

InformationsquelleAutor ManWithSleeve
1

Es ist möglich, mit dem curly - Funktion, die verwendet wird, um erstellen Sie eine durch Trennzeichen getrennte Liste.
```
curly = @(x, varargin) x{varargin{:}};
f=@(x)curly({exp(x),log(x)})
[a,b]=f(2)
```
InformationsquelleAutor Daniel
0

Vielleicht bin ich fehlen, somethign, nur eine Funktion combinationCall aufruft, beide Funktionen für Sie.

nun, ich bin der Hoffnung, in der Lage sein, es zu tun alle aus dem Kommando-Fenster... wäre das möglich?
Sie könnte wahrscheinlich, aber warum die Mühe? Verwenden Sie ein Skript und eine Funktion, Datei. Es macht es leichter zu Durchlaufen und Ihre Arbeit ausführen der Treiber-Skript.

InformationsquelleAutor MatlabDoug

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.