Modellierung und Simulation - Wiederholung 1-6

Autor:	Prof. Dr.-Ing. Schneider
Termin:	11.04.2025 & 16.05.2025

Aufgabe 7.1 - Funktionen

Schreiben Sie die Funktion Celsius im m-File Celsius.m, die eine übergebene Fahrenheit-Temperatur in den zugehörigen Celsius-Wert umrechnet und diesen zurückgibt:

function c = Celsius(fahr)

Zur Umrechnung von Grad Fahrenheit in Grad Celsius dient die Formel:

c = (5.0/9.0) * (fahr − 32)

Testen Sie Ihre Funktion mit mehreren Temperaturen.

Schreiben Sie eine weitere Funktion Fahrenheit, die eine übergebene Celsius-Temperatur in den Fahrenheit-Wert umrechnet:

function f = Fahrenheit(c)

Rufen Sie die beiden Funktionen auch hintereinander auf, also beispielsweise

>> f = Fahrenheit( Celsius( fahr ) )

Musterlösung 7.1 

% Aufgabe 7.1.1: Umrechung Fahrenheit nach Celsius
%    c = Celsius( fahr )
function c = Celsius( fahr )
   c = (5.0/9.0) * ( fahr - 32 );
end

% Aufgabe 7.1.2: Umrechung Celsius nach Fahrenheit
%    f = Fahrenheit(c)
function f = Fahrenheit( c )
   f = (9.0/5.0) * c + 32;
end

Aufgabe 7.2 - Funktionen

Erstellen Sie die Funktion Pythagoras im m-File Pythagoras.m, die aus den zwei übergebenen Argumenten a und b die Zahl c nach dem Satz von Pythagoras berechnet, also $a^2+b^2=c^2$. Vor der Zuweisung des Rückgabewerts $c$ müssen Sie natürlich noch die Wurzel aus $c^2$ ziehen:

function c = Pythagoras(a, b)

Testen Sie Ihre Funktion mit mehreren Zahlenpaaren.

Musterlösung 7.2 

%% Musterlösung Aufgabe 7.2 - Ein- und Ausgaben
function c = Pythagoras( a, b )
  c_2 = a^2 + b^2;
  c = sqrt( c_2 );
end);

Aufgabe 7.3 - Ein- und Ausgabe

Schreiben Sie die Funktion function u = UmfangInput(prompt). Die Daten für den Radius sollen über input von der Tastatur abgefragt werden. Die neue Funktion mit dem Namen UmfangInput muss in dem neuen m-File UmfangInput.m abgespeichert werden.

Als Eingabe-Aufforderung für den Radius dient der an die Funktion übergebene Text, der im Parameter prompt abgelegt ist. Nach der Berechnung des Umfangs werden der Radius und der Umfang mithilfe der Funktion fprintf ausgegeben.

Musterlösung 7.3 

%% Musterlösung Aufgabe 7.3 - Ein- und Ausgaben
function u = UmfangInput( prompt )
  r = input( prompt ); % Radius von Tastatur einlesen
  u = 2 * pi * r; % u enthält berechneten Umfang
  fprintf( 'Der Umfang zum Radius %g ist: %g \n', r,u );
end

Aufgabe 7.4 - Ein- und Ausgabe

Erweitern Sie die Funktion UmfangInput, damit sie außer dem Umfang auch noch die Kreisfläche berechnet. Die beiden Ergebnisse sollen sowohl mit fprintf ausgegeben als auch von der Funktion zurückgegeben werden.

Experimentieren Sie mit unterschiedlichen Formatanweisungen bei der Ausgabe mit fprintf, beispielsweise durch eine Variation der Zahl der Nachkommastellen.

Musterlösung 7.4 

function [umf, F] = KreisInput() 
% Aufgabe 7.4: berechnet Kreisumfang und -fläche
%         [umf, F] = KreisInput()
%         Radius wird von der Tastatur eingelesen 
  % Einlesen des Radius von der Tastatur 
  r = input( 'Bitte Radius eingeben: ' ); 
  
  % Berechnung des Umfangs aus dem Eingabewert und Rückgabe 
  umf = 2 * pi * r; 
  F   = pi * r * r; 
  
  % Ausgabe des Ergebnisses auf dem Bildschirm 
  fprintf( 'Der Umfang zum Radius %g ist: %g \n', [r, umf] );
  fprintf( 'Die Fläche zum Radius %g ist: %g \n', [r, F] );
end

Aufgabe 7.5 - Ein- und Ausgabe

rstellen Sie die Funktion AdditionInput, die nacheinander zwei Zahlen über den Aufruf von input anfordert und in den Variablen a und b speichert. Diese Zahlen werden danach addiert. Ihre Summe wird in der Variablen c zurückgegeben:

function c = AdditionInput()

Verwenden Sie zur Eingabe-Aufforderung einen geeigneten Prompt und testen Sie Ihre Funktion mit unterschiedlichen Zahlenpaaren.

Schreiben Sie eine zweite Funktion zur Addition, die analog UmfangVar mit einer variablen Übergabeliste arbeitet:

function c = AdditionVar(varargin)

Musterlösung 7.4 

% Aufgabe 7.5.1: Addiert zwei Zahlen
%    c = AdditionInput() 
%    Die beiden Zahlen werden von der Tastatur eingelesen.   
function c = AdditionInput() 
  fprintf( 'Die Funktion addiert zwei Zahlen: \n' );
  % Einlesen der Zahlen von der Tastatur 
  a = input( 'Bitte 1. Zahl eingeben: ' ); 
  b = input( 'Bitte 2. Zahl eingeben: ' ); 
  
  % Berechnung der Summe
  c = a + b;
  
  % Ausgabe des Ergebnisses auf dem Bildschirm 
  fprintf( 'Die Summe von %g + %g ist %g \n', a, b, c );
end

% Aufgabe 7.5.2: Addiert zwei Zahlen, mit varargs
%    c = AdditionVar(varargin) 
%    Die beiden Zahlen werden von der Tastatur eingelesen oder übergeben. 
function c = AdditionVar(varargin) 

  fprintf( 'Die Funktion addiert zwei Zahlen: \n' );
  
  % Test der Zahl der übergebenen Werte
  if(nargin < 2)
    % Einlesen der Zahlen von der Tastatur 
    a = input( 'Bitte 1. Zahl eingeben: ' ); 
    b = input( 'Bitte 2. Zahl eingeben: ' ); 
  else
    a = varargin{1};
    b = varargin{2};
  end
  
  % Berechnung der Summe
  c = a + b;
  
  % Ausgabe des Ergebnisses auf dem Bildschirm 
  fprintf( 'Die Summe von %g + %g ist %g \n', a, b, c );
end

Aufgabe 7.6 - Verzweigung

Schreiben Sie eine Funktion QuotientInput, die zwei Zahlen a und b von der Tastatur einliest. Prüfen Sie, ob b gleich null ist. Geben Sie in diesem Fall eine Fehlermeldung aus. Berechnen Sie ansonsten den Quotienten a/b und geben Sie das Ergebnis mit fprintf aus. Testen Sie die Funktion mit mehreren Zahlenwerten.

Musterlösung 7.6 

% Aufgabe 7.6: Bildet den Quotienten zweier Zahlen
%    c = QuotientInput() 
%    Die beiden Zahlen werden von der Tastatur eingelesen. 
function c = QuotientInput()   
  fprintf( 'Die Funktion bildet den Quotienten zweier Zahlen: \n' );
  % Einlesen der Zahlen von der Tastatur 
  a = input( 'Bitte 1. Zahl eingeben: ' ); 
  b = input( 'Bitte 2. Zahl eingeben: ' ); 
  
  if( b == 0 )
    fprintf( 'Division durch Null! \n' );
    c = Inf; 
    return;
  end
  
  % Berechnung des Quotienten
  c = a / b;
  
  % Ausgabe des Ergebnisses auf dem Bildschirm 
  fprintf( '%g / %g = %g \n', a, b, c );
end

Aufgabe 7.7 - Verzweigung

Schreiben Sie die Funktion intervall, die von der Tastatur eine Zahl einliest. Liegt diese Zahl im Intervall zwischen 10 und 99, wird sie zurückgegeben. Anderenfalls erfolgt eine Fehlermeldung. Testen Sie die drei möglichen Fälle mit mehreren Zahlenwerten.

Schreiben Sie die weitere Funktion intervall2, die analog nur Eingabewerte außerhalb des Intervalls von 1 und 2 bearbeitet. Testen Sie die Funktion.

Musterlösung 7.7 

% Aufgabe 7.7.1: Testet, ob eine Zahl im Intervall [10,99] liegt
%    erg = intervall1() 
%    Die Zahl wird von der Tastatur eingelesen. 
function  erg = intervall1()
   z = input( 'Bitte Zahl eingeben: ' );
   
   if( z < 10 || z > 99 ) 
      fprintf( 'Zahl liegt außerhalb von [10,99] ! \n' );
      erg = 0;
      return;
   end
   
   % korrekte Zahl wird zurückgegeben
   erg = z;
end

% Aufgabe 7.7.2: Testet, ob eine Zahl außerhalb [1,2] liegt
%    erg = intervall2() 
%    Die Zahl wird von der Tastatur eingelesen. 
function  erg = intervall2()
   z = input( 'Bitte Zahl eingeben: ' );
   
   if( z >= 1 && z <= 2 ) 
      fprintf( 'Zahl liegt innerhalb von [1,2] ! \n' );
      erg = 0;
      return;
   end
   
   % korrekte Zahl wird zurückgegeben
   erg = z;
end

Aufgabe 7.8 - Verzweigung

Erstellen Sie die Funktion Auswahl, die als Erstes von der Tastatur ein Zeichen c einliest. Mit einer verschachtelten if-else-Abfrage soll dann in Abhängigkeit von c wie folgt verfahren werden: Ist c das Zeichen „k“, wird von der Tastatur ein Radiuswert r abgefragt und die Kreisfläche $\pi \cdot r^2$ berechnet. Ist c das Zeichen „q“, wird von der Tastatur die Kantenlänge a abgefragt und die Quadratfläche $a^2$ berechnet. Ist c das Zeichen „r“, werden von der Tastatur die Länge l und die Breite b abgefragt und die Rechteckfläche $l\cdot b$ berechnet. Kommt ein anderes Zeichen, wird eine Fehlermeldung ausgegeben. Zu jedem der regulären Fälle sollen die Lösung und der Flächentyp mit fprintf ausgegeben werden.

Schreiben Sie eine weitere Funktion Auswahl2, die anstelle der verschachtelten if-else-Abfragen eine switch-Anweisung verwendet, und testen Sie alle möglichen Fälle.

Musterlösung 7.8 

function  Auswahl()
% Aufgabe 7.8.1: je nach Zeichen wird verschieden gehandelt
%    Auswahl() 
%    Das Zeichen wird von der Tastatur eingelesen. 

   c = input( 'Zeichen (k, q oder r) eingeben: ', 's' );
   
   if( c == 'k' )
         fprintf( 'Berechnung der Kreisfläche: \n' );
         r = input( 'Bitte Radius eingeben: ');
         F = pi * r * r;
         fprintf( 'Die Kreisfläche zum Radius %g ist %g.\n', r, F );
   elseif( c == 'q' )
         fprintf( 'Berechnung der Quadratfläche: \n' );
         a = input( 'Bitte Kantenlänge eingeben: ');
         F = a * a;
         fprintf( 'Die Quadratfläche zur Kante %g ist %g.\n', a, F );
         
   elseif( c == 'r' )
         fprintf( 'Berechnung der Rechteckfläche: \n' );
         a = input( 'Bitte Länge eingeben: ');
         b = input( 'Bitte Breite eingeben: ');
         F = a * b;
         fprintf( 'Die Rechteckfläche zu %g und %g ist %g.\n', a, b, F );
         
   else
         fprintf( 'Unzulässiges Zeichen %c \n', c );
   end
end

% Aufgabe 7.8.2: je nach Zeichen wird verschieden gehandelt
%    Auswahl2() 
%    Das Zeichen wird von der Tastatur eingelesen. 
function  Auswahl2()
   c = input( 'Zeichen (k, q oder r) eingeben: ', 's' );
   
   switch( c ) 
      case 'k'
         fprintf( 'Berechnung der Kreisfläche: \n' );
         r = input( 'Bitte Radius eingeben: ');
         F = pi * r * r;
         fprintf( 'Die Kreisfläche zum Radius %g ist %g.\n', r, F );
         
      case 'q'
         fprintf( 'Berechnung der Quadratfläche: \n' );
         a = input( 'Bitte Kantenlänge eingeben: ');
         F = a * a;
         fprintf( 'Die Quadratfläche zur Kante %g ist %g.\n', a, F );
         
      case 'r'
         fprintf( 'Berechnung der Rechteckfläche: \n' );
         a = input( 'Bitte Länge eingeben: ');
         b = input( 'Bitte Breite eingeben: ');
         F = a * b;
         fprintf( 'Die Rechteckfläche zu %g und %g ist %g.\n', a, b, F );
         
      otherwise
         fprintf( 'Unzulässiges Zeichen %c \n', c );
   end
end

Aufgabe 7.9 - Verzweigung

Erstellen Sie die Funktion Umfangsprache, die wie UmfangInput aus Aufgabe 7.4 arbeitet, die jedoch einen Eingabeparameter besitzt, mit dem man für die Aufforde rung zur Radiuseingabe unterschiedliche Sprachen wählen kann, zum Beispiel mit „g“ für Deutsch: „Bitte Radius eingeben: “, mit „e“ für Englisch: „Please type in radius value: “ etc.

Musterlösung 7.9 

% function UmfangSprache( sprache ):
%   Sprachabhängige Ausgaben
%   sprache = 'g', 'e', 'f, 's', etc.
function UmfangSprache( sprache )
    switch( sprache )
       case 'g'
          prompt = 'Bitte Radius eingeben: ';
          pText  = 'Der Umfang zum Radius %g ist %g. \n';
       case 'e'
          prompt = 'Please type in radius value: ';
          pText  = 'The circumsphere for radius %g is %g. \n';
       case 'f'
          prompt = 'Le rayon, s.v.p.: ';
          pText  = 'La circonference pour le rayon %g est %g \n';
       case 's'
          prompt = 'Indique el radio, por favor: ';
          pText  = 'La circunferencia del radio %g es %g \n';
       otherwise
          prompt = 'Bitte Radius eingaben: ';
          pText  = 'Der Umfang zum Radius %g ist %g. \n';
    end
    
    r = input( prompt );
    
    u = 2 * pi * r;
    
    fprintf( pText, r, u );
end

Aufgabe 7.10 - Schleifen

Erstellen Sie eine Funktion kubik, die mit einer Zählschleife rückwärts die Kubikwerte $x^3$ für x = 5 bis x = 2 ausgibt. Formatieren Sie die Ausgabe übersichtlich und erzeugen Sie auch eine aussagekräftige Überschrift.

Musterlösung 7.10 

% Aufgabe 7.10: berechnet Kubik-Zahlen
%    kubik() 
function  kubik()
   fprintf( 'Kubik-Zahlen:  \n' );
   fprintf( '   n   |  n^3  \n' );
   fprintf( '---------------\n' );
   for( n=5:-1:2 )
      q = n * n * n;
      fprintf( '  %3d  |  %3d   \n', n, q );
   end
end

Aufgabe 7.11 - Schleifen

Erstellen Sie eine Funktion grosses_1x1, die das große Einmaleins für m = 11 bis m = 20 und n = 1 bis n = 10 ausgibt. Formatieren Sie die Tabelle übersichtlich.

Musterlösung 7.11 

% Aufgabe 2.5.2: berechnet das Große 1x1
%    grosses_1x1() 
function  grosses_1x1()
   fprintf( '\n'); 
   fprintf( ' ---------- Grosses 1x1 ---------- \n' ); 
   fprintf( '\n'); 
   
   for( m=11:20 ) 
      for( n=1:10 ) 
         erg = m*n; 
         fprintf( ' %3.0f ', erg ); 
      end
      fprintf( '\n'); 
   end
end

Aufgabe 7.12 - Schleifen

Schreiben Sie eine Funktion fakListe, die die Werte von n! für n = 1 bis n = 6 ausgibt. Zur Berechnung von n! für ein festes n können Sie die Funktion fakultaet verwenden.

Musterlösung 7.12 

% Aufgabe 7.12: berechnet Fakultäts-Liste
%    fakListe() 
function  fakListe()
   fprintf( 'Fakultäts-Liste:  \n' );
   fprintf( '   n   |  n!   \n' );
   fprintf( '---------------\n' );
   for( n=1:6 )
      % Aufruf der vorher geschriebenen Funktion fakultaet, 
      % deren M-File am besten im selben Verzeichnis liegt
      f = fakultaet( n );
      fprintf( '  %3d  |  %3d   \n', n, f );
   end
end

function erg = fakultaet( n )   % Zeile 1 
  z = 1;                        % Zeile 2 
  for( k=2:n )                  % Zeile 3 
     z = z * k;                 % Zeile 4 
  end                           % Zeile 5 
  erg = z;                      % Zeile 6
end

Aufgabe 7.13 - Schleifen

Schreiben Sie die Funktion intervall, die nur Eingabewerte im Intervall zwischen 10 und 99 akzeptiert und ansonsten eine neue Zahl anfordert. Testen Sie die Funktion für alle möglichen Fälle.

Musterlösung 7.13 

% Aufgabe 7.13: Testet, ob eine Zahl im Intervall [10,99] liegt
%    erg = intervall() 
%    Die Zahl wird von der Tastatur eingelesen. 
function  erg = intervall()
   z = 0;  % Start mit nicht akzeptabler Zahl 
   
   while( z < 10 || z > 99 ) 
      z = input( 'Bitte Zahl eingeben: ' );
   
      if( z < 10 || z > 99 )
         fprintf( 'Zahl liegt außerhalb von [10,99] ! \n' );
      end
   end
   
   % korrekte Zahl wird zurückgegeben
   fprintf( 'Zahl %g war korrekt \n', z ); 
   erg = z;
end

Aufgabe 7.14 - Schleifen

Schreiben Sie die Funktion Pytha(n), die unter den Zahlen von 1 bis n ganzzahlige Zahlen-Tripel a, b und c sucht, für die der Satz von Pythagoras gilt: a 2 + b 2 = c 2, wie beispielsweise für die Zahlen 3, 4, und 5, mit 32 + 42 = 52. Um zu testen, ob eine Zahl c ganzzahlig ist, können Sie c runden und das Ergebnis mit der ursprünglichen, nicht gerundeten Zahl c vergleichen. Das Runden erreichen Sie mit einem Cast auf int32, zum Beispiel g = int32( c ). Bei Gleichheit sollte die Differenz von g und c im Betrag kleiner sein als die MATLAB-Genauigkeit eps, also abs( g – c ) < eps.

Musterlösung 7.14 

function Pytha( nMax )
   fprintf( 'a^2 + b^2 = c^2: ganzzahlig \n' );
   fprintf( '   a   |   b   |   c  \n' );
   fprintf( '----------------------\n' );
   for( a = 1:nMax )
     bMax = sqrt( nMax^2 - a^2 );  
     for( b = a:bMax )         
        c = sqrt( a^2 + b^2 );
        % c ist ganzzahlig 
        if( (c - floor(c)) < eps )
           fprintf( ' %3d  |  %3d  |  %3d \n', a, b, int32(c) );  
        end
     end
   end
end

Aufgabe 7.15 - Schleifen

Schreiben Sie die Funktion sinus, die über folgende Taylorreihenentwicklung einen Näherungswert für den Sinus berechnet:

$y=sinus(x)=\sum _n(-1{)}^{(n-1)/2}\cdot \frac{x^n}{n!},n=1,3,5,7,...$

Die ersten Glieder der Reihe haben also die Form:

$y=\frac{x^1}{1!}-\frac{x^3}{3!}+\frac{x^5}{5!}-...=x-\frac{x^3}{6}+\frac{x^5}{120}-...$

Wählen Sie wie im Beispiel epsi eine sinnvolle Schranke für den Abbruch der Summe. Testen Sie die Funktion mit mehreren Winkelwerten und vergleichen Sie die Ergebnisse mit den Werten der MATLAB-Funktion sin.

Musterlösung 7.15 

% Aufgabe 7.15: berechnet den Sinus
%    y = sinus( x, epsi, ausgabe ) 
%    x : Winkel im Bogenmaß
%    epsi : Schranke zum Abbruch
%    ausgabe : ob Zahl der Summanden ausgegeben wird
%
%    Verwendete Rekursionsformel für Summenglieder:
%       sn = - sn * x*x / ( n*(n-1) ) 
%       mit Startwert: s1 = x
function y = sinus( x, epsi, ausgabe ) 
   n = 1;     % 1 = Startnummer des Summanden 
   sn = x;    % 1. Summand = x 
   z = sn;    % Zwischensumme = x
   
   while( abs(sn) > epsi ) % Kriterium zum Weitermachen 
      n = n + 2;        % nächste Summandennummer 
      sn = - sn * x*x / ( n *(n-1) );  % aktueller Summand 
      z = z + sn;       % Summand zu Zwischensumme addieren 
   end

   y = z; % Rückgabe der Summe 
   if( ausgabe ) % Kontrollausgabe, falls ausgabe == 1 
      fprintf( 'Zahl der Summanden: %g \n', n ); 
      fprintf( 'Wert sinus(%g) = %16.15g \n', x, y );
      fprintf( 'Differenz zu MATLAB-sin: %g \n', y - sin(x) );
   end
end

Aufgabe 7.16 - Felder

Schreiben Sie die Funktion res = vecAddition(v1,v2), die die beiden Spaltenvektoren v1 und v2 addiert und das Ergebnis in res zurückgibt. Testen Sie die Funktion, zum Beispiel mit den Vektoren v1 = [1;2;3] und v2 = [2;−1;3].

Musterlösung 7.16 

% Aufgabe 7.16: addiert zwei Vektoren
%    res = vecAddition( v1, v2 ) 
function  res = vecAddition( v1, v2 )
   res = v1 + v2;
end

Aufgabe 7.17 - Felder

Schreiben Sie die Funktion A = Drehung(w), die aus dem Drehwinkel w die zugehörige zweidimensionale Drehmatrix A berechnet. Die Drehmatrix A ist wie folgt definiert:

A = [cos(w), -sin(w); sin(w), cos(w) ]

Testen Sie die Funktion mit unterschiedlichen Winkeln. Welche Matrizen erhält man beispielsweise für die Winkel π/2 (90 Grad), π (180 Grad) und 2π (360 Grad)?

Musterlösung 7.17 

% Aufgabe 7.17: berechnet eine Drehmatrix
%    A = Drehung( w )
%    w : Drehwinkel im Bogenmaß
function A = Drehung( w )
    A(1,1) =   cos(w);
    A(1,2) = - sin(w);
    A(2,1) =   sin(w);
    A(2,2) =   cos(w);
end

Aufgabe 7.18 - Felder

Schreiben Sie die Funktion fncPlot, die analog der sin-Funktion die Funktion $f(x)=(x^3+5x)cos(3x)$ im Intervall x = [−5,+6] zeichnet.

Musterlösung 7.18 

% Aufgabe 7.18: Funktions-Plot
%    fncPlot( anfang, ende, diff )
%    anfang : Startpunkt, z.B. -5
%    ende : Endpunkt, z.B. +6
%    diff : Abstand der Stützstellen, z.B. 0.1
function  fncPlot( anfang, ende, diff )
  % 1. Berechnungspunkt: anfang
  akt = anfang;
  % 1. Element der Matrix
  n = 1;
 
  % Vektoren x und y berechnen, bis ende erreicht ist 
  while (akt <= ende)
    % x-Matrix von anfang bis ende  
    x(n) = akt;
    % y-Matrix = sin-Wert zu x
    y(n) = (x(n)*x(n)*x(n) + 5*x(n))*cos(3*x(n));
    
    % nächste Vektorkomponente wählen
    n = n +1;
    % akt. Berechnungspunkt, um diff weiter
    akt = akt + diff;
  end
 
  % Daten plotten
  plot(x,y,'r');
  % dazu Grid einschalten
  grid on; 
  
  title( 'Funktion: (x*x*x + 5*x)*cos(3*x)' );
  xlabel( 'x-Achse' );
  ylabel( 'y-Achse' );
end

Aufgabe 7.19 - Felder

Erzeugen Sie die folgenden Felder:

• a(n) = 1, 2, 3, 4, 5
• b(n) = 0, 2, 4, 6, 8
• c(n) = 1, 0.5, 0, -0.5, -1
• d(n) = 40, 41, 42, 43, 44, 45

einmal mithilfe des :-Operators und dann auch mit dem linspace-Operator.

Aufgabe 7.20 - Felder

Erstellen Sie die Funktion d = Drehung(w,v), die den übergebenen 2D-Spaltenvektor v um den Winkel w dreht und den gedrehten Vektor d zurückgibt. Die Drehung eines Vektors v kann über die Multiplikation mit der zum Winkel w gehörenden Drehmatrix A (siehe oben) realisiert werden:

d = A * v;

Testen Sie die Funktion Drehung, beispielsweise für w = pi/2 und v = [1;0].

Musterlösung 7.19 

% Aufgabe 7.20: dreht einen Vektor um Winkel
%    d = VecDrehung( w, v )
%    w : Drehwinkel im Bogenmaß
%    v : der zu drehende Vektor
function d = VecDrehung( w, v )
    A(1,1) =   cos(w);
    A(1,2) = - sin(w);
    A(2,1) =   sin(w);
    A(2,2) =   cos(w);
    
    d = A * v;
end

Aufgabe 7.21 - Felder

Schreiben Sie eine weitere Funktion [dx,dy] = linTransf(w,v,t), die nach einer Drehung noch eine Verschiebung um den Vektor t=[tx;ty] vornimmt:

d = A * v + t;

Testen Sie mit unterschiedlichen Verschiebungen, zum Beispiel für t = [0;1]. Unterscheiden sich die Ergebnisse, wenn man die Reihenfolge der Operationen vertauscht, also zuerst dreht und dann verschiebt bzw. zuerst verschiebt und dann dreht?

Musterlösung 7.21 

% Aufgabe 7.21: Lineare Transformation
%    [dx,dy] = linTransf( w, v, t )
%    w : Drehwinkel im Bogenmaß
%    v : der zu drehende Vektor
%    t : Verschiebungsvektor
function [dx,dy] = linTransf( w, v, t )
    A(1,1) =   cos(w);
    A(1,2) = - sin(w);
    A(2,1) =   sin(w);
    A(2,2) =   cos(w);
    
    d = A * v + t;
    dx = d(1);
    dy = d(2);
end

Musterlösung 7.21 - 2. Variante 

% Aufgabe 7.21: Lineare Transformation
%    [dx,dy] = linTransf2( w, v, t )
%    w : Drehwinkel im Bogenmaß
%    v : der zu drehende Vektor
%    t : Verschiebungsvektor
%    2. Variante: erst verschieben und dann drehen
function [dx,dy] = linTransf2( w, v, t )
    A(1,1) =   cos(w);
    A(1,2) = - sin(w);
    A(2,1) =   sin(w);
    A(2,2) =   cos(w);
    
    % erst verschieben und dann drehen
    d = A * (v + t);
    dx = d(1);
    dy = d(2);
end

---

→ MATLAB^® Befehlsübersicht
→ zurück zum Hauptartikel: BSE Modellierung und Simulation - SoSe25