Mein MATLAB Forum - goMatlab.de

Mein MATLAB Forum

 
Gast > Registrieren       Autologin?   
Bücher:

Fachkräfte:
Softwareentwickler (m/w) für automatische Codegenerierung
Softwareentwicklung mit MATLAB/Simulink und dSPACE TargetLink im Bereich Fahrwerkregelsysteme
Elektronische Fahrwerksysteme GmbH - Ingolstadt

Entwicklungsingenieur (m/w) für modellbasierte Softwareentwicklung
Modellbasierte Softwareentwicklung mit MATLAB/Simulink und dSPACE TargetLink
Elektronische Fahrwerksysteme GmbH - Ingolstadt

Test-Ingenieur (m/w) für Resimulation
Implementierung, Integration und Anpassung von sogenannten ADTF-Filtern
Automotive Safety Technologies GmbH - Ingolstadt

Entwicklungsingenieur (m/w) für Fahrdynamikregelsysteme
Entwicklung der für die Fahrdynamik relevanten Funktionen
Elektronische Fahrwerksysteme GmbH - Ingolstadt

Elektromobilität: Entwicklungsingenieur Applikation Hybridfahrzeuge (m/w)
Erstellung von Modellen in Zusammenarbeit mit den Software-Entwicklern
MBtech Group GmbH & Co. KGaA - Sindelfingen

weitere Angebote

Partner:


Vermarktungspartner


Forum
      Option
[Erweitert]
  • Diese Seite per Mail weiterempfehlen
     


Gehe zu:  
Neues Thema eröffnen Neue Antwort erstellen

Verschiedene Ergebnisse einer m-file

 

FreshFlow
Forum-Newbie

Forum-Newbie


Beiträge: 3
Anmeldedatum: 22.06.16
Wohnort: ---
Version: ---
     Beitrag Verfasst am: 07.12.2016, 23:11     Titel: Verschiedene Ergebnisse einer m-file
  Antworten mit Zitat      
Hallo zusammen,

ich bin im Rahmen meiner Bachelorarbeit auf ein dringendes Problem gestoßen.
Ich habe eine m-file entwickelt, welche auf meinem PC ein unterschiedliches Ergebnis bringt wie auf anderen Rechnern. Grundlegend befasse ich mich mit Strukturdynamik und arbeite an einer Methode zur Modellreduktion. Dabei werden Eigenwerte approximiert. Auf meinem PC (Matlab Version R2016a, 64bit Windows 7 Professional 2009) läuft das super ab und ich erhalte eine gute Approximation. Führe ich nun dieselbe m-file auf einem anderen PC aus, so erhalte ich eine deutlich schlechtere Approximation, also ein anderes Ergebnis. Die Version kann nicht das Problem sein, da auf einem anderen Rechner mit R2016a ebenfalls die schlechtere Approximation raus kommt.
Die Struktur beinhaltet Starrkörpermoden, welche u.a. durch den Befehl eig(...) berechnet werden. Ich habe festgestellt, dass bereits bei der Ausführung dieses Befehls eig(...) für die 3 Starrkörpermoden im unten genannten Code leicht abweichende Werte raus kommen, welche meiner Meinung nach durch das weitere Handwerken mit diesen zu dem abweichenden Ergebnis führt. Ich habe diese im Anhang abgelegt.
Ich kann mir die unterschiedlichen Ergebnisse durch verschiedene Rechner nicht wirklich erklären. Vielleicht hätte jemand von euch einen Ansatzpunkt?
Vielen Dank im Voraus für die Hilfe!

hier zur Vollständigkeit die m-file:

Code:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% define all the geometric quantities and material properties

l=1;
E=2.1e11;
A=9e-4;
rho=7.8e3;
I=7e-8;
b=1e4;
m=rho*A;


[K1,K2,C1,C2,M1,M2,K,C,M,lambda_exakt,eigvec_exakt] = SystemKraker( l,E,A,rho,I,b,m );
%Berechnung der Systemmatrizen einer Balkenstruktur

%% Definition des Zustandsraumes
% y = [u; v]

A1 = [C1 ,   M1               ;
      M1   , zeros(size(C1,1))] ;
             
A2 = [ C2   , M2                 ;
       M2   , zeros(size(C2,1))  ] ;
             
B1 = [K1                , zeros(size(K1,1));
      zeros(size(K1,1))   ,   -M1          ] ;
                 

B2 = [K2               ,  zeros(size(K2,1));
      zeros(size(K2,1)) ,     -M2          ] ;


%% Berechnung der free interface normal modes - homogenes Eigenwertproblem

n1=20; %Anzahl der berücksichtigten Eigenmoden in dynamischer Lösung von Struktur 1
n2=15; %Anzahl der berücksichtigten Eigenmoden in dynamischer Lösung von Struktur 2
 
[Theta_1,lambda_1diag] = eigs(full(B1),-full(A1),n1,'sm');
[lambda_1,k1_EW] = sort(diag(lambda_1diag));
%Zuordnen der Eigenvektoren zu den richtigen Eigenwerten
Theta_1 = Theta_1(:,k1_EW);

[Theta_2ganz,lambda_2diag] = eig(full(B2),-full(A2)); %eigs Befehl aufgrund von Singularität nicht möglich
[lambda_2,k2_EW] = sort(diag(lambda_2diag));
%Zuordnen der Eigenvektoren zu den richtigen Eigenwerten
Theta_2ganz = Theta_2ganz(:,k2_EW);

%% Normalisieren der Eigenvektoren bezüglich A
% für komplette Eigenvektoren Struktur 1
[ Theta_1orth ] = Orthonormalize( Theta_1, A1, B1, lambda_1 );

% für komplette Eigenvektoren Struktur 2
[ Theta_2orthganz ] = Orthonormalize( Theta_2ganz, A2, B2, lambda_2 );

%% Entwicklung der regulären und generalisierten Starrkörperformen (Substruktur 2)
% Struktur 2 besitzt 3 Starrkörpermoden:
% der Verschiebungsvektor besitzt eine reguläre(u)
% jedoch keine generalisierte(v) rbm, während der Rotationsvektor für die
% eine reguläre und eine generalisierte rbm ausführt.
% Somit besitzt das System insgesamt r=3 reguläre und generalisierte rbm

r=3; % Gesamtanzahl der Starrkörpermoden
Theta_2orth = Theta_2orthganz(:,r+1:r+n2); % Abspeichern der normalisierten Eigenvektoren zu EW ungleich 0
Theta_2 = Theta_2ganz (:,r+1:r+n2); % Abspeichern der nicht normalisierten Eigenvektoren zu EW ungleich 0


% nachstehend erfolgt die Manipulation des generalisierten Starrkörpermode
% damit eine Menge linear unabhängiger Eigenmoden vorliegt

Theta_R2 = Theta_2ganz(:,1:r); % nicht normalisierte Starrkörpermoden
x_r2 = Theta_R2(1:18, : );
Theta_R2(:,2) = [zeros(18,1);x_r2(:,1)];
% Theta_R2(:,2) = [x_r2(:,1);x_r2(:,1)]; % beide Wahlen möglich

     
Theta_R2orth = Theta_2orthganz(:,1:r); % normalisierte Starrkörpermoden
x_r2orth = Theta_R2orth(1:18 , : );
Theta_R2orth(:,2) = [zeros(18,1);x_r2orth(:,1)];
% Theta_R2orth(:,2) = [x_r2orth(:,1);x_r2orth(:,1)]; % beide Wahlen möglich


%% Bool'sche Matrix für Substruktur 1 und Substruktur 2
% Die Geschwindigkeiten der Schnittflächenkoordinaten werden aufgrund der allgemeinen Form der Zustandsraumdarstellung
% nicht berücksichtigt (siehe Ausführung)

L1 =  zeros(2,size(full(B1),1));
L1(1:2,19:20)=eye(2);

L2 =  zeros(2,size(full(B2),1));
L2(1:2,1:2)=(-1)*eye(2);



%% statische Teillösung von Struktur 1 durch Aufprägen von Einheitskräften an den Schnittflächen

%Struktur 1 enthält keine Starrkörpermoden, da keine Eigenwerte = 0
%auftreten. Somit kann die Nachgiebigkeitsmatrix über die Inverse von D gebildet werden

Ge1 = B1\(-L1'); % elastic flexibility modes
G_res1 = Ge1 - (Theta_1orth/(diag(lambda_1(1:n1)))*Theta_1orth.')*(-L1'); %residual flexibility modes


%% statische Teillösung von Struktur 2 durch Aufprägen von Einheitskräften an den Schnittflächen

% Wichtig bei der Wahl der fixierten dofs ist, dass diese zum gleichen
% Knoten gehören.
% Hier 2 rbm für Rotation und 1 rbm für Durchsenkung.
% Es wurde der vorletzte Knoten der 2ten Struktur fixiert. Grundsätzlich
% egal welcher innere Knoten fixiert wird (nur kein Knoten, der an einem
% Dämpfer befestigt ist)

B_EE2 = B2;
B_EE2([15,16,34], : )=[];
B_EE2(:,[15,16,34])=[];

G2 = zeros(36,36);
G2([1:14,17:33,35,36],[1:14,17:33,35,36]) = inv(B_EE2); % ausgenommen dof 15,16,34 (fixiert)
 
A_RR2 = Theta_R2.'*A2*Theta_R2; % Starrkörperanteil der Systemmatrix A2

P2 = eye(36)-A2*(Theta_R2/A_RR2)*Theta_R2.'; %inertia relief projection matrix

Ge2 = P2.'*G2*P2; % elastic flexibility matrix

G_res2 = (Ge2 - Theta_2orth/(diag(lambda_2(r+1:r+n2)))*Theta_2orth.')* (-L2'); %residual flexibility modes
% G_res22 = (Theta_2orthganz(:,r+n2+1:end)/(diag(lambda_2(r+n2+1:end)))*Theta_2orthganz(:,r+n2+1:end).')* (-L2');

%% Erstellung der Transformationsmatrix und duale Kopplung
%G_res schon auf boundaries bezogen (s.o.)

T = [Theta_1orth, zeros(40,r+n2), G_res1;
    zeros(36,n1), Theta_R2 ,Theta_2orth,  G_res2;
    zeros(2, n1+n2+r) ,     eye(2)];

L = [L1,  L2];

A_sum = zeros(76,76);
B_sum = zeros(76,76);

A_sum(1:40,1:40) = A1;
A_sum(41:end,41:end) = A2;

B_sum(1:40,1:40) = B1;
B_sum(41:end,41:end) = B2;


A = [A_sum,  zeros(76,2);
    zeros(2,76), zeros(2,2)];

B = [B_sum, L';
    L, zeros(2,2)];


A_red = T.'*A*T;
B_red = T.'*B*T;

[eigvec_red, lambda_red] = eig(B_red, -A_red);
lambda_red = sort(diag(lambda_red));
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%


[EDITED, Jan, Bitte Code-Umgebung verwenden - Danke!]

Theta_R2_richtig.mat
 Beschreibung:
Starrkörpermoden der gut approximierten Lösung

Download
 Dateiname:  Theta_R2_richtig.mat
 Dateigröße:  687 Bytes
 Heruntergeladen:  47 mal
Theta_R2_falsch.mat
 Beschreibung:
Starrkörpermoden der schlecht approximierten Lösung

Download
 Dateiname:  Theta_R2_falsch.mat
 Dateigröße:  705 Bytes
 Heruntergeladen:  49 mal
Private Nachricht senden Benutzer-Profile anzeigen


Andreas Goser
Forum-Meister

Forum-Meister


Beiträge: 3.466
Anmeldedatum: 04.12.08
Wohnort: Ismaning
Version: 1.0
     Beitrag Verfasst am: 08.12.2016, 09:35     Titel:
  Antworten mit Zitat      
Wenn es dringend ist bitte an den MathWorks Support wenden.

Andreas
Private Nachricht senden Benutzer-Profile anzeigen E-Mail senden
 
Andreas Goser
Forum-Meister

Forum-Meister


Beiträge: 3.466
Anmeldedatum: 04.12.08
Wohnort: Ismaning
Version: 1.0
     Beitrag Verfasst am: 08.12.2016, 10:29     Titel:
  Antworten mit Zitat      
Ich habe mal reingeschaut. Es fehlen mindestens SystemKraker und Orthonormalize um den Code auszuführen. Der Technische Support würde diesen Code auch benötigen.

Es ist wichtig den Code bezgl. der Unterschiede zu debuggen. Grosse numerische Unterschiede entstehen oftmals durch díe ansteigende Auswirkung von vielen kleinen Unterschieden. Das scheint hier schon teilweise getan zu sein, also wäre z.B. nureine MAT Datei mit den Werten die in "eig" verwendet werden sowie der exakte Aufruf des "eig" Befehls nötig.

Zusätzlich wird des Support bestimmt nach der Ausgabe von
Code:

ver
version -blas
version  -lapack
 


fragen. Weitere Tests:

1.
Code:

feature(‘accel‘,‘off‘)
feature(‘jit,‘off‘)
 


Direkt nach einem Neustart und danach den Code ausführen.

2.
MATLAB mit der "-singleCompThread" Startup Flag starten und dann testen.
https://www.mathworks.com/help/matl....._env/startup-options.html

Andreas
Private Nachricht senden Benutzer-Profile anzeigen E-Mail senden
 
Jan S
Moderator

Moderator


Beiträge: 10.481
Anmeldedatum: 08.07.10
Wohnort: Heidelberg
Version: 2009a, 2016b
     Beitrag Verfasst am: 08.12.2016, 15:41     Titel: Re: Verschiedene Ergebnisse einer m-file
  Antworten mit Zitat      
Hallo FreshFlow,

Im Grunde sind alle Probleme "dringend", die hier gepostet werden.

Die Ausgabe von eig kann sich je nach Prozessor, Anzahl der Thread und der verwendeten Bibliothek unterscheiden. Vielleicht benutzt ein Rechner die MKL und der andere nicht?
Wenn die Ergebnisse Deines Programms aber von diesen Rundungsfehlern abhängen, ist der Rechenprozess an sich instabil. In wie weit Du das Resultat dann überhaupt als "Lösung" akzeptierst, ist die Frage. Auf jeden Fall ist es wichtig, die Input-Werte zu variieren im Rahmen der Messgenauigkeit des physikalischen Systems, um dann die Änderung der Outputs zu kontrollieren.
Es ist wie bei der Simulation eines Bleistifts, der auf der Spitze steht: Würdest Du hier dem Ergebnis trauen, dass besagt, dass der Stift für immer gerade stehen bleiben wird?

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

Forum-Newbie

Forum-Newbie


Beiträge: 3
Anmeldedatum: 22.06.16
Wohnort: ---
Version: ---
     Beitrag Verfasst am: 08.12.2016, 17:08     Titel:
  Antworten mit Zitat      
Hallo an Andreas und Jan,

danke für die schnelle Antwort ich versuche das gleich zu testen.

Bei der Eingabe von ver erscheint das:

----------------------------------------------------------------------------------------------------
MATLAB Version: 9.0.0.341360 (R2016a)
MATLAB License Number: *******
Operating System: Microsoft Windows 7 Professional Version 6.1 (Build 7601: Service Pack 1)
Java Version: Java 1.7.0_60-b19 with Oracle Corporation Java HotSpot(TM) 64-Bit Server VM mixed mode
----------------------------------------------------------------------------------------------------
MATLAB Version 9.0 (R2016a)
Simulink Version 8.7 (R2016a)
Control System Toolbox Version 10.0 (R2016a)
Optimization Toolbox Version 7.4 (R2016a)
Stateflow Version 8.7 (R2016a)
Symbolic Math Toolbox Version 7.0 (R2016a)

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
version -blas


ans =

Intel(R) Math Kernel Library Version 11.2.3 Product Build 20150413 for Intel(R) 64 architecture applications, CNR branch AVX

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
>> version -lapack

ans =

Intel(R) Math Kernel Library Version 11.2.3 Product Build 20150413 for Intel(R) 64 architecture applications, CNR branch AVX
Linear Algebra PACKage Version 3.5.0

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

Der Code für SystemKraker ist folgender:
Code:

function [ K1,K2,B1,B2,M1,M2,K,B,M,lambda_exakt, eigvec_exakt] = SystemKraker( l,E,A,rho,I,b,m )


% Create here the 'Nodes' matrix. It contains the nodal coordinates x,y.

Nodes(1,: )  = [ 0                  0 ];  
Nodes(2, : )  = [ l/10               0 ];  
Nodes(3,: )  = [ 2*l/10             0 ];
Nodes(4,: )  = [ 3*l/10             0 ];      
Nodes(5,: )  = [ 4*l/10             0 ];
Nodes(6,: )  = [ 5*l/10             0 ];
Nodes(7,: )  = [ 6*l/10             0 ];
Nodes(8,: )  = [ 7*l/10             0 ];      
Nodes(9,: )  = [ 8*l/10             0 ];
Nodes(10,: ) = [ 9*l/10             0 ];
Nodes(11,: ) = [10*l/10             0 ];

Nodes(12,: )  = [11*l/10             0 ];  
Nodes(13,: )  = [12*l/10             0 ];
Nodes(14,: )  = [13*l/10             0 ];      
Nodes(15,: )  = [14*l/10             0 ];
Nodes(16,: )  = [15*l/10             0 ];
Nodes(17,: )  = [16*l/10             0 ];
Nodes(18,: )  = [17*l/10             0 ];      
Nodes(19,: )  = [18*l/10             0 ];



%% Define all Elements
% E    ,   G   , rho ,   A   ,  I

Mat(1,1:5)=  [ E   0   rho   A  I];

%Define the Elements
%type(1=bar,2=beam), mat, node 1 , node 2
%substructur 1

Elements(1,: )  = [2   1       1  2  ];  
Elements(2,: )  = [2   1       2  3  ];
Elements(3,: )  = [2   1       3  4  ];
Elements(4,: )  = [2   1       4  5  ];  
Elements(5,: )  = [2   1       5  6  ];
Elements(6,: )  = [2   1       6  7  ];
Elements(7,: )  = [2   1       7  8  ];
Elements(8,: )  = [2   1       8  9  ];  
Elements(9,: )  = [2   1       9  10 ];
Elements(10,: ) = [2   1       10 11 ];  

%substructur 2

Elements(11,: )  = [2   1       11  12  ];  
Elements(12,: )  = [2   1       12  13  ];
Elements(13,: )  = [2   1       13  14  ];
Elements(14,: )  = [2   1       14  15  ];  
Elements(15,: )  = [2   1       15  16  ];
Elements(16,: )  = [2   1       16  17  ];
Elements(17,: )  = [2   1       17  18  ];
Elements(18,: )  = [2   1       18  19  ];  



%% Begin with first substructure


Nodes_active1 = unique(Elements(1:10,3:4));   % find which nodes really are used in elements
                                          % the degrees of freedom fixed on the ground will
                                          % be removed later.-->zählt wie
                                          % viele Knoten insgesamt (ohne
                                          % z.B.Knoten 1 doppelt zu zählen)
Ndof1 = size(Nodes_active1,1)*2;            % 2 dof per node
locnod(Nodes_active1,1:2) = reshape([1:Ndof1],2,Ndof1/2)'; %erstellt ene Matrix in der Zeilenweise die dof der einzelnen Knoten stehen  
Nele   = size(Elements(1:10,: ),1); %Anzahl der Elemente
K1 = sparse(Ndof1,Ndof1);
M1 = sparse(Ndof1,Ndof1);

for el = 1:Nele,

   type   = Elements(el,1);
   matel  = Mat(Elements(el,2),: );
   node1  = Nodes(Elements(el,3),: );  % coordinates of node 1
   node2  = Nodes(Elements(el,4),: );  % coordinates of node 2

   % Build element matrices
   if type==1,
     
      [Kel,Mel] = bar_2D(node1,node2,matel);
         dof=[locnod(Elements(el,3),[1 2]) ...
              locnod(Elements(el,4),[1 2]) ] ; % only the translational
         
   elseif type==2,
      [Kel,Mel] = beam_2D(node1,node2,matel);  
         dof=[locnod(Elements(el,3),: ) ...
              locnod(Elements(el,4),: ) ] ; %bestimmt den Ort, wo Kel bzw Mel in K bzw M eingebaut werden müssen
   end
   
   %% Assemble
   K1(dof,dof) = K1(dof,dof)+Kel;
   M1(dof,dof) = M1(dof,dof)+Mel;
     
   clear matel type Kel Mel dof
end



%% second substructure


Nodes_active2 = (unique(Elements(11:18,3:4)));   % find which nodes really are used in element
                                          % the degrees of freedom fixed on the ground will
                                          % be removed later.-->zählt wie
                                          % viele Knoten insgesamt (ohne
                                          % z.B.Knoten 1 doppelt zu zählen)
Ndof2 = size(Nodes_active2,1)*2;            % 2 dof per node
locnod(Nodes_active2,1:2) = reshape([1:Ndof2],2,Ndof2/2)'; %erstellt ene Matrix in der Zeilenweise die dof der einzelnen Knoten stehen  
Nele   = size(Elements(11:18,: ),1); %Anzahl der Elemente
K2 = sparse(Ndof2,Ndof2);
M2 = sparse(Ndof2,Ndof2);

for el = 1:Nele,

   type   = Elements(el,1);
   matel  = Mat(Elements(el,2),: );
   node1  = Nodes(Elements(el,3),: );  % coordinates of node 1
   node2  = Nodes(Elements(el,4),: );  % coordinates of node 2

   % Build element matrices
   if type==1,
     
      [Kel,Mel] = bar_2D(node1,node2,matel);
         dof=[locnod(Elements(el,3),[1 2]) ...
              locnod(Elements(el,4),[1 2]) ] ; % only the translational
         
   elseif type==2,
      [Kel,Mel] = beam_2D(node1,node2,matel);  
         dof=[locnod(Elements(el,3),: ) ...
              locnod(Elements(el,4),: ) ] ; %bestimmt den Ort, wo Kel bzw Mel in K bzw M eingebaut werden müssen
   end
   
   %% Assemble
   K2(dof,dof) = K2(dof,dof)+Kel;
   M2(dof,dof) = M2(dof,dof)+Mel;
     
   clear matel type Kel Mel dof
end


%% Apply boundary conditions

% fix dofs of nodes 1
%a. find the degrees of freedom that are fixed
dof_fix1 = [];
for n=[1],
    dof_fix1 =   [dof_fix1  locnod(n,: ) ];
end
Ndof_fix1 = size(dof_fix1,2);
%b. remove these fixed dof from the list of dof and eliminate them in the matrices
dof_rem1 = setdiff([1:Ndof1],dof_fix1);% remaining degrees of freedom
Ndof_rem1=Ndof1-Ndof_fix1;
K1=K1(dof_rem1,dof_rem1);   % from here on, K and M are related to the dof_remaining
M1=M1(dof_rem1,dof_rem1);


% Define Damping Matrices

B = sparse(36,36);
B(13,13) = b;
B(29,29) = b;

B1= B(1:20,1:20);
B2= B(19:36,19:36);

B = zeros(36,36);
M = zeros(36,36);
K = zeros(36,36);

%primale Assemblierung und Eigenlösung zur Überprüfung der Approximationsgüte

B(1:20,1:20)  = B(1:20, 1:20) +B1;
B(19:36,19:36)= B(19:36,19:36)+B2;

K(1:20,1:20)  = K(1:20, 1:20) +K1;
K(19:36,19:36)= K(19:36,19:36)+K2;

M(1:20,1:20)  = M(1:20, 1:20) +M1;
M(19:36,19:36)= M(19:36,19:36)+M2;

% Auswertung der exakten Eigenwerte
[eigvec_exakt,lambda_exakt] = polyeig(full(K),full(B),full(M));
[lambda_exakt] = sort(lambda_exakt);



end
 


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

Und die Funktion für Orthonormalize ist folgende:
Code:

function [ Theta_orth ] = Orthonormalize( Theta, A, B, lambda )

P=angle(Theta); % Berechnung des Winkels im Imaginären Raum
Pr1=P(1,: );
R=diag(exp(-1i*Pr1));
Tr=Theta*R; % drehen des komplexen Zeigers auf die reale Achse( wir wollen Einheitsmatrix ohne Im-Teil)
AA=Tr.'*A*Tr;  % =0
Ad=diag(AA);
Ard=diag(sqrt(Ad));
Theta_orth=Tr/(Ard);
%
%   XA=Theta_1orthganz.'*A*Theta_1orthganz;    %Zum Beweis der A1-Orthogonalität
%   XB=Theta_1orthganz.'*B*Theta_1orthganz;


end
 

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

Bei der Eingabe von feature erhalte ich leider einen Fehlercode:

feature(‘accel‘,‘off‘)
feature(‘accel‘,‘off‘)

Error: The input character is not valid in MATLAB statements or expressions.

K>> feature(‘jit,‘off‘)
feature(‘jit,‘off‘)

Error: The input character is not valid in MATLAB statements or expressions.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

Das mit dem Startup probiere ich gleich, Danke!
Private Nachricht senden Benutzer-Profile anzeigen
 
Jan S
Moderator

Moderator


Beiträge: 10.481
Anmeldedatum: 08.07.10
Wohnort: Heidelberg
Version: 2009a, 2016b
     Beitrag Verfasst am: 08.12.2016, 18:03     Titel:
  Antworten mit Zitat      
Hallo FreshFlow,

Die Lizenz-Nummer ist nicht von allgemeinem Interesse :-)

Wichtig wäre der Unterschied zwischen den beiden Rechnern.

Code:
feature(‘accel‘,‘off‘)

% Besser:
feature('accel', 'off')

Es geht also um die Quotes. Du brauchst ' statt ‘

Gruß, Jan

Zuletzt bearbeitet von Jan S am 20.12.2016, 17:07, insgesamt einmal bearbeitet
Private Nachricht senden Benutzer-Profile anzeigen
 
FreshFlow
Themenstarter

Forum-Newbie

Forum-Newbie


Beiträge: 3
Anmeldedatum: 22.06.16
Wohnort: ---
Version: ---
     Beitrag Verfasst am: 20.12.2016, 14:15     Titel:
  Antworten mit Zitat      
Vielen Dank für die Hilfe. Ich konnte letztendlich den Code so abändern, dass er robuster wird. Dazu habe ich die numerischen Nullen der Starrkörpermoden auf exakt 0 gesetzt. So habe ich nun auf allen Rechnern dasselbe Ergebnis.
Vielen Dank aber nochmals für die Unterstützung!
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
.


goMatlab ist ein Teil des goForen-Labels
goForen.de goMATLAB.de goLaTeX.de goPCB.de


 Impressum  | Nutzungsbedingungen  | Datenschutz  | Werbung/Mediadaten | Studentenversion | FAQ | goMatlab RSS Button RSS


Copyright © 2007 - 2017 goMatlab.de | Dies ist keine offizielle Website der Firma The Mathworks
Partner: LabVIEWforum.de

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.