WICHTIG: Der Betrieb von goMatlab.de wird privat finanziert fortgesetzt. - Mehr Infos...

Mein MATLAB Forum - goMatlab.de

Mein MATLAB Forum

 
Gast > Registrieren       Autologin?   

Partner:




Forum
      Option
[Erweitert]
  • Diese Seite per Mail weiterempfehlen
     


Gehe zu:  
Neues Thema eröffnen Neue Antwort erstellen

begrenzte Eingangsparameter

 

Legrand
Forum-Anfänger

Forum-Anfänger


Beiträge: 24
Anmeldedatum: 18.12.12
Wohnort: ---
Version: ---
     Beitrag Verfasst am: 02.04.2013, 15:09     Titel: begrenzte Eingangsparameter
  Antworten mit Zitat      
Hallo zusammen,


ich möchte aus einer Reihe von Vorgabewerten beliebig viele Zustände ausrechnen. Nach einigen Überlegungen habe ich angefangen das mit mehreren Schleifen zu konstruieren, was aber den Rahmen sprengt. Ich bin davon überzeugt, dass es eine bessere Herangehensweise an dieses Problem gibt.

Das Problem:
Als Eingangsparameter habe ich verschiedene physikalische Größen (alle als von...bis -Angaben). Daraus kann ich weitere, für das System relevante, Größen ausrechnen (die dann wieder mit von...bis -Angaben eingegrenzt sind). So geht das ein paar mal weiter, bis letztenendes alle Werte aus den Eingangwerten berechnet sind und ich alle Punkte/Zustände, die gültig sind (in jedem Intervall für jede Größe liegt) habe.

Im Anhang habe ich das Schema einmal aufgemalt. Dabei muss man sich noch vorstellen, dass a,b,c Laufvariablen von...bis sind und die errechneten Werte x und y wieder nur in einem bestimmten Intervall liegen dürfen.
Die Punkte/Zustände, die durch die Berechnung und Intervalleingrenzung von x und y rausfallen, müssen also ebenfalls in den Matrizen für a,b,c wegfallen. (So das nachher nur noch Punkte bestehen, die über das ganze System im richtigen Intervall liegen)

Ich hoffe wirklich, dass ich das Problem einigermaßen geschildert habe Confused
Rätzel jetzt schon etwas länger an der Geschichte.

Meine Frage dazu lautet, wie ich an diese Problemstellung bestmöglich herangehen kann. Vielleicht sogar mit Simulink??


Ich bedanke mich im Vorfeld für die Antworten!!


Gruß Sebastian

problem.pdf
 Beschreibung:

Download
 Dateiname:  problem.pdf
 Dateigröße:  173.8 KB
 Heruntergeladen:  337 mal
Private Nachricht senden Benutzer-Profile anzeigen


Jan S
Moderator

Moderator


Beiträge: 11.057
Anmeldedatum: 08.07.10
Wohnort: Heidelberg
Version: 2009a, 2016b
     Beitrag Verfasst am: 02.04.2013, 16:02     Titel: Re: begrenzte Eingangsparameter
  Antworten mit Zitat      
Hallo Legrand,

Sowohl die Skizze als auch die Text-Beschreibung sind sehr abstrakt.
Zitat:
ich möchte aus einer Reihe von Vorgabewerten beliebig viele Zustände ausrechnen.

Das sagt mir bereits nichts, so dass es als Einführungssatz einer Frage nicht geeignet ist. Die Bedeutung der Skizze und der Zusammenhang mit der Frage erschließt sich mir auch nicht direkt.

Die Inputs sind wahrscheinlich nicht "physikalische Größen", da in Matlab zunächstmal alles nur Zahlen sind. Dann wäre es hilfreich, wenn Du dafür ein konkretes Beispiel gibts. Verstehe ich es richtig, dass Deine Inputs etwas wie: "x = [10, 23]" sind?

Was genau sind "Laufvariablen"?
Wie können "Punkte/Zustände" in einer Matrix "wegfallen"?

Gruß, Jan
Private Nachricht senden Benutzer-Profile anzeigen
 
Legrand
Themenstarter

Forum-Anfänger

Forum-Anfänger


Beiträge: 24
Anmeldedatum: 18.12.12
Wohnort: ---
Version: ---
     Beitrag Verfasst am: 04.04.2013, 10:07     Titel:
  Antworten mit Zitat      
So ich habe jetzt mal ein Schleifenkonstrukt als Beispiel gebaut und hoffe es wird somit verständlich was ich vorhabe:

Code:

dim = 5;

% "Laufvariablen":
a = linspace(1,5,dim);
b = linspace(1,20,dim);
c = linspace(5,7,dim);

% Felder inistialisieren:
a_e = zeros(dim,dim,dim);
b_e = zeros(dim,dim,dim);
c_e = zeros(dim,dim,dim);
x   = zeros(dim,dim,dim);
y   = zeros(dim,dim,dim);

% Werte füllen und eingrenzen:
for i=1:1:dim
    for j=1:1:dim
        for k=1:1:dim
            x(i,j,k) = a(i)*b(j);
            y(i,j,k) = x(i,j,k)*c(k);
           
            % Eingangsvariablen umformen:
            a_e(i,j,k) = a(i);
            b_e(i,j,k) = b(j);
            c_e(i,j,k) = c(k);
           
            % Grenzen/Schranken:
            if x(i,j,k) > 60 || y(i,j,k) > 120
                a_e(i,j,k) = NaN;
                b_e(i,j,k) = NaN;
                c_e(i,j,k) = NaN;
                x(i,j,k) = NaN;
                y(i,j,k) = NaN;
            end
        end
    end
end

 


Nun kann ich auf die einzelnen Elemente (bei mir steht ein Element für einen Zustand) zugreifen und weiß ob dieses Element in den Grenzen liegt (wenns eben einen Wert gibt) oder außerhalb liegt (bei NaN):

Code:

>> x(1,2,3)
ans =
    5.7500

>> x(4,4,3)
ans =
   NaN
 


und wenn ich wissen will welcher a-Wert zu dem x gehört:
Code:

>> a_e(1,2,3)
ans =
    1

>> a_e(4,4,3)
ans =
   NaN
 


Bei meinem eigentlichen Problem habe ich als Ergebnisse jeweils 6-D Matrizen ( x(i,j,k,l,m,n) ) und somit auch 6 for - Schleifen ineinander. Klappen tut es zwar aber die Geschwindigkeit lässt zu Wünschen übrig.. ist klar wegen den FOR-Schleifen. Außderdem denke ich ist diese Art das zu programmieren eh nicht die Tollste!!

Ist das jetzt verständlich geworden was ich meine?


Gruß Sebastian
Private Nachricht senden Benutzer-Profile anzeigen
 
Jan S
Moderator

Moderator


Beiträge: 11.057
Anmeldedatum: 08.07.10
Wohnort: Heidelberg
Version: 2009a, 2016b
     Beitrag Verfasst am: 04.04.2013, 11:53     Titel:
  Antworten mit Zitat      
Hallo Legrand,

Ich verstehe den Zusammenhang zwischen dem Code und der Beschreibung und der Skizze in Deiner ersten Mail nicht. Darum nur ein paar Vereinfachungen am Code: Ziehe alle wiederholten Berechnungen so weit wie möglich aus den Schleifen heraus.
Code:

dim = 5;

% "Laufvariablen":
a = linspace(1,5,dim);
b = linspace(1,20,dim);
c = linspace(5,7,dim);

% Felder inistialisieren:
a_e = zeros(dim,dim,dim);
b_e = zeros(dim,dim,dim);
c_e = zeros(dim,dim,dim);
x   = zeros(dim,dim,dim);
y   = zeros(dim,dim,dim);

% Werte füllen und eingrenzen:
for i=1:dim
    a_e(i, :, :) = a(i);  % Hängt nicht von j und k ab!
       
    for j=1:dim
        x(i, j, :) = a(i)*b(j);  % Hängt nicht von k ab!
        y(i, j, :) = x(i, j, :) .* c;  % Schneller ohne Schleife, braucht man ein RESHAPE?!

        % Eingangsvariablen umformen:
        b_e(i,j,:) = b(j);
        c_e(i,j,:) = c;   % RESHAPE nötig?
    end
end

match = (x > 60 || y > 120);
a_e(match) = NaN;
b_e(match) = NaN;
c_e(match) = NaN;
x(match) = NaN;
y(match) = NaN;

Dieser Code liesse sich nun noch mit ein paar BSXFUN beschleunigen, aber erstmal bliebe zu testen, ob noch die gleichen Werte herauskommen und ob es bereits schnell genug ist. Es bringt nämlich nichts, Stunden in die Optimierung zu stelcen um Sekunden Rechenzeit zu sparen. Im Endeffekt zählt ja nur die Zeit, bis das Problem gelöst ist.

Gruß, Jan
Private Nachricht senden Benutzer-Profile anzeigen
 
Legrand
Themenstarter

Forum-Anfänger

Forum-Anfänger


Beiträge: 24
Anmeldedatum: 18.12.12
Wohnort: ---
Version: ---
     Beitrag Verfasst am: 04.04.2013, 13:19     Titel:
  Antworten mit Zitat      
Danke für die Antwort, aber das klappt irgendwie überhaupt nicht.

Bei der punktweisen Multiplikation von c sagt er:

Code:
Error using  .*
Matrix dimensions must agree.

Error in grenzen2 (line 21)
        y(i,j,:) = x(i,j,:) .* c;  % Schneller ohne Schleife, braucht man ein RESHAPE?!


und bei der logischen Abfrage (match):

Code:
Operands to the || and && operators must be convertible to logical scalar values.

Error in grenzen2 (line 29)
match = (x > 60 || y > 120);



Um das mit dem c zu beheben, fällt mir nur wieder die Einführung einer weiteren FOR-Schleife ein, womit wir wieder bei 3Stück wären :-/

Vielleicht lasse ich es wirklich einfach so, obwohl es schon sehr sehr lange dauert wenn ich die Variable dim erhöhe und das durch 6 FOR's läuft


Gruß Sebastian
Private Nachricht senden Benutzer-Profile anzeigen
 
Jan S
Moderator

Moderator


Beiträge: 11.057
Anmeldedatum: 08.07.10
Wohnort: Heidelberg
Version: 2009a, 2016b
     Beitrag Verfasst am: 04.04.2013, 16:43     Titel:
  Antworten mit Zitat      
Hallo Legrand,

Bitte schaue Dir den Kommentar an, den ich mit Absicht eingefügt habe:
Code:
y(i,j,:) = x(i,j,:) .* c;  % Schneller ohne Schleife, braucht man ein RESHAPE?!

Der Hinweis auf RESHAPE bedeutet:
Code:
y(i,j,:) = x(i,j,:) .* reshape(c, 1, 1, []);

Man benötigt für die elementweise Multiplikation keine Schleife, wie du siehst.

Bei der Verknüpfung mit || müssen beide Argumente skalar sein. Wie die Dokumentation erklärt, benötigt man für Arrays den | Operator. Also hatte ich da einen Tippfehler:
Code:
match = (x > 60 | y > 120);

Nur nicht zu schnell aufgeben. Da ich kein Matlab zur Verfügung habe, können solche Tippfehler schon mal passieren, obwohl sie beim Laufenlassen sofort hilfreiche Fehlermeldungen produzieren würden.

Gruß, Jan
Private Nachricht senden Benutzer-Profile anzeigen
 
Legrand
Themenstarter

Forum-Anfänger

Forum-Anfänger


Beiträge: 24
Anmeldedatum: 18.12.12
Wohnort: ---
Version: ---
     Beitrag Verfasst am: 05.04.2013, 13:02     Titel:
  Antworten mit Zitat      
Danke für die Motivation Smile

werde schauen ob ich das am Wochenende noch ausprobiert bekomme. Ansonsten werd ich nach meinem Urlaub in 2 Woche nochmal weiter probieren.

Gruß Sebastian
Private Nachricht senden Benutzer-Profile anzeigen
 
Neues Thema eröffnen Neue Antwort erstellen



Einstellungen und Berechtigungen
Beiträge der letzten Zeit anzeigen:

Du kannst Beiträge in dieses Forum schreiben.
Du kannst auf Beiträge in diesem Forum antworten.
Du kannst deine Beiträge in diesem Forum nicht bearbeiten.
Du kannst deine Beiträge in diesem Forum nicht löschen.
Du kannst an Umfragen in diesem Forum nicht mitmachen.
Du kannst Dateien in diesem Forum posten
Du kannst Dateien in diesem Forum herunterladen
.





 Impressum  | Nutzungsbedingungen  | Datenschutz | FAQ | goMatlab RSS Button RSS

Hosted by:


Copyright © 2007 - 2025 goMatlab.de | Dies ist keine offizielle Website der Firma The Mathworks

MATLAB, Simulink, Stateflow, Handle Graphics, Real-Time Workshop, SimBiology, SimHydraulics, SimEvents, and xPC TargetBox are registered trademarks and The MathWorks, the L-shaped membrane logo, and Embedded MATLAB are trademarks of The MathWorks, Inc.