Benutzer:DerMathekernel

Aus Wikiversity

Staff[Bearbeiten]

Mathe I[Bearbeiten]

Einst bestand der Mathekernel damals noch aus:

  • Sascha Ludwig
  • Alexander Blum

Assoziiert waren damals noch mit dem Mathekernel einst:

  • Sandra Fenzlaff (Moses)

Mathe II[Bearbeiten]

Der Mathekernel besteht nun aus:

  • Alexander Blum

Weiterhin assoziiert bleiben:

  • Sandra Fenzlaff (Moses)

Alumni (in Gedenken an):

  • Sascha Ludwig

Mathe I[Bearbeiten]

Intervallschachtelung zur Bestimmung der eulerschen Zahl e[Bearbeiten]

(siehe Aufgabe 9.18)

Gif-Datei[Bearbeiten]

Matlab-Code[Bearbeiten]

% Diese Funktion fuehrt die Intervalschachtelung aus Lemma 9.1 aus,
% bestimmt damit die Eulersche Zahl und erstellt daraus eine Animation.
% 
% Als Argument wird die Schrittanzahl uebergeben, wie oft die 
% Intervalschachtelung ausgefuehrt werden soll.
% Zurueckgegeben werden die zuletzt (und damit die am genauesten) berechnete
% obere sowie untere Grenze des Intervals.
%
% Beispielaufruf: 
%		[u_g, o_g, M] = ivs_e(10)

function [ untere_grenze, obere_grenze, M ] = ivs_e( num_iterations )

% Initialisierung
frame = 1;

% Parameter
steps = 10;                  % Frames zwischen den Grenzlinien
pause = 5;                   % Frames während einer Grenzlinie
scaleon = false;             % Skalierung für Grenzlinien an-/ausschalten
scale = 0.7;                 % Skalierungsfaktor für die Grenzlinien
framerect = [30 20 460 340]; % Rechteck aus der Figur für die Animation

% Berechnung der Grenzen
for i = 1:1:num_iterations
	untere_grenze = (1 + 1/i)^i;	
	obere_grenze = (1 + 1/i)^(i+1);	
	m_unten(i) = untere_grenze;
	m_oben(i) = obere_grenze;
end

% Länge der Grenzlinien relativ zu dem Abstand von e berechnen
Escale = ones(1,num_iterations);
if scaleon
    Escale = scale:((1-scale)/(num_iterations-1)):1;
end
Eunten = (m_unten / exp(1)) .* Escale;
Eoben = ((m_oben - 2*exp(1)) / exp(1)) .* Escale;

% Initialisierung der Figur
figure('color','w');
hold on
axis([1.9 , 4.1, -1.1, 1.1]);
line([1.9,4.1],[0,0],[0,0],'color','k');                    % x-achse
line([exp(1),exp(1)],[-1,1],'color','b','LineWidth', 2);    % e
for m = 1:pause
    M(frame) = getframe(gcf,framerect); frame = frame + 1;
end

% Zeichnen der einzelnen Frames
for k = 1:num_iterations
    % Grenzlinien
    line([m_unten(k),m_unten(k)],[Eunten(k),(-1)*Eunten(k)],'color','r')
    line([m_oben(k),m_oben(k)],[Eoben(k),(-1)*Eoben(k)],'color','r')
    for m = 1:pause
        M(frame) = getframe(gcf,framerect); frame = frame + 1;
    end
    if k ~= num_iterations
        % Berechnung der Schrittgröße für die Verbindungslinien zwischen Grenzlinien
        step_unten = ( m_unten(k+1) - m_unten(k) ) / steps;
        step_oben = ( m_oben(k+1) - m_oben(k) ) / steps;
        for l = 1:steps
            % Verbindungslinien zwischen Grenzlinien
            line([m_unten(k),m_unten(k)+l*step_unten],[0,0],'color','r','LineWidth',2);
            line([m_oben(k),m_oben(k)+l*step_oben],[0,0],'color','r','LineWidth',2);
            M(frame) = getframe(gcf,framerect); frame = frame + 1;
        end
    end
end

% Erstellen der Animation
movie2avi(M,'ivse.avi','quality',100,'compression','none')


Lineare Abbildungen im R^2[Bearbeiten]

(siehe Aufgabe 16.28)

Gif-Dateien[Bearbeiten]

Identität[Bearbeiten]

Scherung (x-Achse)[Bearbeiten]

Scherung (y-Achse)[Bearbeiten]

Rotation[Bearbeiten]

Translation[Bearbeiten]

Spiegelung (x-Achse)[Bearbeiten]

Skalierung (x-Achse)[Bearbeiten]

Skalierung (x-Achse ~ y-Achse)[Bearbeiten]

Matlab-Code[Bearbeiten]

  • wird gerade überarbeitet


Aufgabe 21.20 "Billardtisch-Aufgabe"[Bearbeiten]

Bilder[Bearbeiten]

Matlab-Code[Bearbeiten]

billard.m[Bearbeiten]

%% Mathe 1, Aufgabe 21.21
% von (Alexander Blum und Sascha Ludwig) (= DerMathekernel)
% auchso in dieser Mathegruppe: Sandra Fenzlaff (= Moses) und Jens Keuter
% E-Mail:
%  -  Alexander Blum: ablum@uos.de
%  -  Sascha Ludwig:  sasludwi@uos.de


%% Start Up
% saubere Umgebug
clear all
close all


%% zeichne den Billardtisch

% als symbolische Variablen, um Genauigkeit zu erhoehen und um spaeter
% Gleichungsysteme loesen zu koennen
syms Breite Laenge r_Loch r_Kugel;

Breite  = 127;
Laenge  = 254;
r_Loch  = 5;
r_Kugel = 3;

% evtl. besseren Check einbauen, ob die Angaben richtig/realistisch sind
if	(r_Kugel > r_Loch) || (2*r_Loch > Breite) || (4*r_Loch > Laenge) || ...
	(Breite > Laenge)
	% Angaben sind falsch
else

% neue Figure
figure
hold on
bbb = 6;
Farben = ['r','y','g','k'];

% blauer Hintergrund
rectangle('Position', [-Laenge, -Breite, Laenge*3, Breite*3], 'LineStyle','-',  ...
	'FaceColor', [0.4, 0.6, 0.9], 'EdgeColor', 'k')

% braune Umrandung
rectangle('Position', [-r_Loch-bbb, -r_Loch-bbb, ...
	2*r_Loch+2*bbb+Laenge, 2*r_Loch+2*bbb+Breite], ...
	'Curvature',[0.05, 0.11], 'LineStyle','-', 'LineWidth', 1 ,  ...
	'FaceColor', [0.4, 0.2, 0.0], 'EdgeColor', 'k')

% gruener Tisch
rectangle('Position', [0, 0, Laenge, Breite], 'LineStyle','-', 'LineWidth', 3, ...
	'FaceColor', [0.1, 0.6, 0.1], 'EdgeColor', 'k')


% Die Ecken zeichnen
rectangle('Position', [0-r_Loch,0-r_Loch, r_Loch*2,r_Loch*2], ...
	'Curvature',[1,1], 'FaceColor','k')

rectangle('Position', [Laenge/2-r_Loch,0-r_Loch, r_Loch*2,r_Loch*2], ...
	'Curvature',[1,1], 'FaceColor','k')

rectangle('Position', [Laenge-r_Loch,0-r_Loch, r_Loch*2,r_Loch*2], ...
	'Curvature',[1,1], 'FaceColor','k')


rectangle('Position', [Laenge-r_Loch,Breite-r_Loch, r_Loch*2,r_Loch*2], ...
	'Curvature',[1,1], 'FaceColor','k')

rectangle('Position', [Laenge/2-r_Loch,Breite-r_Loch, r_Loch*2,r_Loch*2], ...
	'Curvature',[1,1], 'FaceColor','k')

rectangle('Position', [0-r_Loch,Breite-r_Loch, r_Loch*2,r_Loch*2], ...
	'Curvature',[1,1], 'FaceColor','k')


% Billardtisch ganz im Plot anzeigen
axis([-10-r_Loch-bbb,Laenge+10+r_Loch+bbb,-10-r_Loch-bbb,Breite+10+r_Loch+bbb]);
% und gleiche Seitenverhaeltnisse, damit Kreise auch schoen rund sind
axis equal;


% Kugeln einzeichnen
pos(1, 1:2) = [63.5; 63.5];
pos(2, 1:2) = [100; 100];
pos(3, 1:2) = [192.5; 63.5];
pos(4, 1:2) = [10; 63.5];

for i = 1:size(pos, 1)
	rectangle('Position', [pos(i,1)-r_Kugel,pos(i,2)-r_Kugel, ...
		r_Kugel*2,r_Kugel*2], 'Curvature',[1,1], 'FaceColor', Farben(i), ...
		'EdgeColor', Farben(i))
end


%% berechne Koordinaten, Abstaende, die Winkeltoleranzen usw.
%% berechnet die beiden Koordinaten, durch die der Mittelpunkt der Kugel
% hindurchmuss, um ins Loch zu gelangen

% Mittelpunt des unteren linken Lochs, und den Schnittpunkt mit den Banden
% (waagerecht und senkrecht), temporaere Variablen
syms y_m_loch x_m_loch y_m_bande_w x_m_bande_w y_m_bande_s x_m_bande_s ...
	x y_loch y_bande_w y_bande_s Koordinate1 Koordinate2 x_w x_s y_w y_s;

y_m_loch = 0;
x_m_loch = 0;
y_m_bande_w = 0;
x_m_bande_w = r_Loch;
y_m_bande_s = r_Loch;
x_m_bande_s = 0;

% Man berechnet die beiden Koordinaten, in dem man ein Kreisbogen mit dem Radius
% der Kugel um die beiden Schnittpunkte des Loches mit den Banden schlaegt. Die
% Schnittpunkte dieser beiden Kreisboegen mit dem Kreis des Loches sind die
% beiden gesuchten Koordinaten (bzw. nur die beiden Schnittpunkte, die auf dem 
% Billardtisch liegen)

% betrachte nur den oberen Kreisbogen des Loches, da dieser auf dem Billardtisch
% liegt. Daher nur das "+ sqrt ..."
y_loch = y_m_loch + sqrt(r_Loch^2 - (x - x_m_loch)^2);

% Kreisbogen um die waagerechte Bande, nur den oberen Teil betrachten
y_bande_w = y_m_bande_w + sqrt(r_Kugel^2 - (x - x_m_bande_w)^2);

% Kreisbogen um die senkrechte Band, nur den unteren Teil betrachten
y_bande_s = y_m_bande_s - sqrt(r_Kugel^2 - (x - x_m_bande_s)^2);

% Gleichungen loesen, in dem man von der 1. Gleichung die 2. subtrahiert, da 
% Matlab automatisch "= 0" zum Loesen annimmt
x_w = solve(y_loch - y_bande_w);				x_w = simple(x_w);
x_s = solve(y_loch - y_bande_s);x_s = x_s(2);	x_s = simple(x_s);

y_w = subs(y_loch, x, x_w);						y_w = simple(y_w);
y_s = subs(y_loch, x, x_s);						y_s = simple(y_s);

Koordinate1 = [x_w , y_w]
Koordinate2 = [x_s , y_s]

%TODO diesen Kreisbogen farbig auf dem Billardtisch anzeigen


%% als naechsten den Abstand zwischen diesen beiden Punkten berechnen
syms abstand_punkte kreisbogen_winkel laenge_kreisbogen;

Abstand_punkte = sqrt(	( Koordinate1(1) - Koordinate2(1) )^2 + ...
						( Koordinate1(2) - Koordinate2(2) )^2      );
Abstand_punkte = double(Abstand_punkte)


%% nun die Laenge des Kreisbogens
kreisbogen_winkel = winkel([x_m_loch, y_m_loch], Koordinate1, Koordinate2);
kreisbogen_winkel = kreisbogen_winkel(2);

% Verhaeltnis vom Umfang zum Ausschnitt des Kreises = der Kreisbogen
Laenge_kreisbogen_loch = 2*pi*r_Loch * (kreisbogen_winkel / (2*pi))


%% Winkeltoleranzen
% 2-Punkte Geradengleichung
Laenge = [0 1 0.1];
Winkeltoleranzen = zeros([1, size(pos(:,1))]);

for i = 1:size(pos(:,1))
	% TODO Line-Befehl benutzen!!!!!!!!
    Gerade1 = gerade(pos(i,:), double(Koordinate1), Laenge); % berechnet Punkte
    Gerade2 = gerade(pos(i,:), double(Koordinate2), Laenge); % berechnet Punkte
    plot(Gerade1(1,:), Gerade1(2,:),Farben(i)); % zeichnet Gerade
    plot(Gerade2(1,:), Gerade2(2,:),Farben(i)); % zeichnet Gerade
    winkeltmp = winkel(pos(i,:), double(Koordinate1), double(Koordinate2));
	Winkeltoleranzen(i) = winkeltmp(1);
end

% Ausgabe
Winkeltoleranzen

% Kreissegment auf den Kugeln
% Verhaeltnis vom Umfang zum Ausschnitt des Kreises = der Kreisbogen
Kreissegmente_Kugeln = 2*pi*r_Loch * (Winkeltoleranzen / (360))


%% jetzt mit Banden

% symbolische Variablen anlegen
syms A_x A_y B_x B_y alpha beta lambda v_x v_y w_x w_y s_x s_y x y;

% Punkte, durch die die Kugel durch muss, um ins Loch zu gelangen
B_x = Koordinate2(1);	% senkrechte Bande, X
B_y = Koordinate2(2);	% senkrechte Bande, Y
C_x = Koordinate1(1);	% waagerechte Bande, X
C_y = Koordinate1(2);	% waagerechte Bande, Y

% fuer alle Kugeln berechnen
Koordinaten_Banden = zeros([4, size(pos(:,1))]);
Banden_Winkel = zeros([1, size(pos(:,1))]);
for i = 1:size(pos(:,1))
	
	% Lage der aktuellen Kugel
	A_x = pos(i,1);			% pos(1, 1:2) = [63.5; 63.5];
	A_y = pos(i,2);			% pos(1, 1:2) = [63.5; 63.5];

	% Gleichungssystem fuer waagerechte Bande
	g1 = (A_x + v_x) - (x);
	g2 = (A_y + v_y) - (r_Kugel);		% Von der Kugel zur Bande
	g3 = (B_x + w_x) - (x);
	g4 = (B_y + w_y) - (r_Kugel);		% von der Bande zum Loch
	g5 = (1 * lambda * w_x) - (v_x);	
	g6 = (-1 * lambda * w_y) - (v_y);	%Abprall an der Bande im gleichen Winkel
	
	% Gleichungssystem loesen fuer waagerechte Bande
	solution_w = solve(g1, g2, g3, g4, g5, g6);
	Toleranz_w = double([solution_w.x, r_Kugel]);


	% Gleichungssystem fuer senkrechte Bande
	g7 = (A_x + v_x) - (r_Kugel);
	g8 = (A_y + v_y) - (y);				% Von der Kugel zur Bande
	g9 = (C_x + s_x) - (r_Kugel);
	g10 = (C_y + s_y) - (y);			% von der Bande zum Loch
	g11 = (1 * lambda * s_x) - (v_x);
	g12 = (-1 * lambda * s_y) - (v_y);	%Abprall an der Bande im gleichen Winkel
	
	% Gleichungssystem loesen fuer senkrechte Bande
	solution_s = solve(g7, g8, g9, g10, g11, g12);
	Toleranz_s = double([r_Kugel, solution_s.y]);
	
	% Koordinaten merken
	Koordinaten_Banden(1:2, i) = Toleranz_w';
	Koordinaten_Banden(3:4, i) = Toleranz_s';
	
	% Winkel fuer Banden merken
	tmp = winkel(pos(i,:), double(Toleranz_w), double(Toleranz_s));
	Banden_Winkel(i) = tmp(1);
end

Banden_Winkel
Koordinaten_Banden

hold off
end % if pruefen ob Angaben korrekt


% nun den maximalen Winkel ausrechnen
max_Koord = zeros([4, size(pos(:,1))]);
for i = 1:size(pos(:,1))
	% normaler Winkel
	normal_w = winkel(pos(i,:), double(Koordinate1), double(Koordinate2));
	% mit waagerechter Bande
	waag_w = winkel(pos(i,:), double(Koordinate2), Koordinaten_Banden(1:2,i)');
	% mit senkrechter Bande
	senk_w = winkel(pos(i,:), double(Koordinate1), Koordinaten_Banden(3:4,i)');
	
	if waag_w(1) > normal_w(1)
		max_Koord(1:2, i) = Koordinaten_Banden(1:2, i);
	else
		max_Koord(1:2, i) = Koordinate1';
	end
	
	if senk_w(1) > normal_w(1)
		max_Koord(3:4, i) = Koordinaten_Banden(3:4, i);
	else
		max_Koord(3:4, i) = Koordinate2';
	end
	
	
	line([pos(i,1),Koordinaten_Banden(1,i)], [ pos(i,2), Koordinaten_Banden(2,i)], ...
	'Color', 'c')

	line([pos(i,1),Koordinaten_Banden(3,i)], [ pos(i,2), Koordinaten_Banden(4,i)], ...
		'Color', 'y')
end

max_Koord

% maximale Winkeltoleranzen ausrechnen
for i = 1:size(pos(:,1))
    winkeltmp = winkel(pos(i,:), double(max_Koord(1:2, i)'), double(max_Koord(3:4, i)'));
	Max_Toleranzen(i) = winkeltmp(1);
end

Winkeltoleranzen
Max_Toleranzen

gerade.m[Bearbeiten]

function [endgerade] = gerade(P1, P2, L)
% zeichnet Gerade in der Ebene
% P1 & P2 sind Vektoren mit den x,y-Koordinaten
% L ist der Geradenparameter 0, 1, 0.1 zeichnet die
% Strecke P1P2

% Für den Plot
l = (L(1):L(3):L(2));
plot_x = P1(1) + l*(P2(1) - P1(1));
plot_y = P1(2) + l*(P2(2) - P1(2));

endgerade = [plot_x; plot_y];

% Aufruf: gerade([x1, y1], [x2, y2], [lmin, lmax, dl])

winkel.m[Bearbeiten]

function [ Winkel ] = winkel( pos, Koordinate1, Koordinate2 )
%WINKEL Summary of this function goes here
%   Detailed explanation goes here

a1 = (Koordinate1 - pos);
a2 = (Koordinate2 - pos);
a = (a1*a2') / (norm(a1)*norm(a2));
Winkel = acos( a ) * 180 / pi;

Mathe II[Bearbeiten]

33.21: Illustration des Mittelwertsatzes der Integralrechnung[Bearbeiten]

(siehe Aufgabe 33.21)

Bilder[Bearbeiten]

Funktion 1.Grades[Bearbeiten]

Funktion 2.Grades[Bearbeiten]

Funktion 5.Grades[Bearbeiten]

Matlab-Code[Bearbeiten]

(siehe Matlab-Code 33.22)

33.22: Illustration des Hauptsatzes der Infinitesimalrechnung[Bearbeiten]

(siehe Aufgabe 33.22)

Animationen[Bearbeiten]

Funktion 1.Grades[Bearbeiten]

Funktion 2.Grades[Bearbeiten]

Funktion 5.Grades[Bearbeiten]

Matlab-Code[Bearbeiten]

function [ M ] = dasintegral(graph, mode)
%dasintegral Veranschaulichung des MDI / HDI
%   MDI: Mittelwertsatz der Integtalrechnung
%   HDI: Hauptsatz der Infinitesimalrechnung
%   Liefert 
%       1. eine veranschaulichende Skizze für den MDI
%       2. eine veranschaulichende Animation für den HDI
%
%   Funktionalität:
%   dasintegral(GRAPH, MODE)
%       GRAPH = '1'/'2'/'3' (wählt verschiedene Graphen)
%       MODE = 'mdi'/'hdi' (wählt das zu veranschaulichende)
%
%   Beispiel:
%       >>dasintegral('1','mdi');
%       >>M=dasintegral('2','hdi');
%       Abspielen des Videos: >>movie(M);
%       Speichern des Videos: >>movie2avi(M,'name.avi');

syms x y; % Symbolische Variablen
transparency = 0.3; % Transparenz

switch graph
    case '1'
        f = x - y;                                          % Funktion
        x_min = 0.9; x_max = 4.1; y_min = 0; y_max = 5;     % Plotgrenzen
        unteregrenze = 1; oberegrenze  = 4;                 % Int.Intervall
    case '2'
        f = 4*x*(1-x) - y;                                  % Funktion
        x_min = -0.05; x_max = 1.05; y_min = 0; y_max = 1.3;% Plotgrenzen
        unteregrenze = 0.05; oberegrenze  = 0.95;           % Int.Intervall
    case '3'
        f = (((x-5)*(x-5)*(x-3)*(x-1)*(x-2))/3+2) - y;      % Funktion
        x_min = 1.4; x_max = 5.1; y_min = 0; y_max = 5.5;   % Plotgrenzen
        unteregrenze = 1.5; oberegrenze  = 5;               % Int.Intervall
end

switch mode
    case 'mdi'
        steps = 1; % 1 Schritt = 1 Bild
        text1='$$\int_a^b\!\!{f(x)dx}=f(z)(b $$ - $$ a)$$';
    case 'hdi'
        steps = 100; % Schritte für die Animation
        steplength = ((oberegrenze-unteregrenze)/steps); % Schrittlänge
        startstoplength = steps/5; % Dauer für Standbild Anfang / Ende
        text1='$${ F(x) - F(x_0) \over {x - x_0}} = f(z)$$';
        text2='$$x \rightarrow x_0$$';
        text3='$$F\prime(x_0) = f(x_0)$$';
        text4='-';
end

%% Graph

figure('color','w');
frame = 1;
for frames = 1:steps;
    
    % Plotte den Graphen (blau)
    ezplot(f);
    hold on; axis([x_min x_max y_min y_max]);

    % Berechne die Integrationskonstante über das Integral
    h = (int(f,unteregrenze,oberegrenze))/(oberegrenze-unteregrenze);
    const = solve(h,y);

    % Plotte konstante Funktion und fülle eingeschlossene Rechteck (blau)
    fill([unteregrenze unteregrenze oberegrenze oberegrenze],...
         [0 subs(const) subs(const) 0],'b','LineStyle','none');
    alpha(transparency); % Setze Transparenz

    % Berechne Punkte auf Graph, die Wert der Konstante annehmen (schwarz)
    g = y - const;
    solution = solve(f,g);
    allPoints.x = subs(solution.x);
    allPoints.y = subs(solution.y);
    % Schließe Punkte außerhalb der Intervallgrenzen aus
    pointsInIntervall.x = allPoints.x(allPoints.x>unteregrenze &...
        allPoints.x<oberegrenze);
    pointsInIntervall.y = allPoints.y(allPoints.x>unteregrenze &...
        allPoints.x<oberegrenze);
    % Plotte diese Punkte
    plot(pointsInIntervall.x,pointsInIntervall.y,'--o','LineStyle','none',...
        'MarkerEdgeColor','b', 'MarkerFaceColor','b', 'MarkerSize',5);

    % Plotte die Integrationsgrenzen (rot)
    ax = axis;
    line([unteregrenze unteregrenze],[0 ax(4)],'Color','r',...
        'LineWidth',1,'LineStyle','--');
    line([oberegrenze oberegrenze],[0 ax(4)],'Color','r',...
        'LineWidth',1,'LineStyle','--');

    % Plotte Hilfslinien
    line([ax(1) pointsInIntervall.x(1)],[subs(const) subs(const)],...
        'Color','k','LineWidth',1,'LineStyle',':');
    line([pointsInIntervall.x(1) pointsInIntervall.x(1)],[subs(const) 0],...
        'Color','k','LineWidth',1,'LineStyle',':');

    % Beschriftung
    switch graph
        case '1'
            title('Funktion 1.Grades [f(x)=y]');
        case '2'
            title('Funktion 2.Grades [f(x)=4x(1-x)]');
        case '3'
            title('Funktion 5.Grades [f(x)=(x-5)*(x-5)*(x-3)*(x-1)*(x-2)/3+2)]');
    end
    switch mode
        case 'mdi'
            set(gca,'XTick',[unteregrenze pointsInIntervall.x(1) oberegrenze]);
            set(gca,'XTickLabel',{'a';'z';'b'});
            set(gca,'YTick',[subs(const)]);
            set(gca,'YTickLabel',{'f(z)'});
            text(0.15,0.91,text1,'FontSize',13,'Units','normalized',...
                'BackgroundColor','white','interpreter','latex');
        case 'hdi'
            set(gca,'XTick',[unteregrenze pointsInIntervall.x(1) oberegrenze]);
            set(gca,'XTickLabel',{'x0';'z';'x'});
            set(gca,'YTick',[subs(const)]);
            set(gca,'YTickLabel',{'f(z)'});

            if frames == 1
                for j = 0:startstoplength 
                    text(0.15,0.91,text1,'FontSize',13,'Units','normalized',...
                        'BackgroundColor','white','interpreter','latex');
                    % fixes bug in linux (minus missing):
                    text(0.25,0.935,text4,'FontSize',13,'Units','normalized'); 
                    text(0.25,0.865,text4,'FontSize',13,'Units','normalized');
                    % Standbildaufnahme am Anfang
                    M(frame) = getframe(gcf); frame = frame + 1;
                end
            end
            text(0.15,0.91,text1,'FontSize',13,'Units','normalized',...
                'BackgroundColor','white','interpreter','latex');
            text(0.15,0.81,text2,'FontSize',13,'Units','normalized',...
                'BackgroundColor','white','interpreter','latex');
            % fixes bug in linux (minus missing):
            text(0.25,0.935,text4,'FontSize',13,'Units','normalized');
            text(0.25,0.865,text4,'FontSize',13,'Units','normalized');
            % Aufnahme
            M(frame) = getframe(gcf); frame = frame + 1;
            % Obergrenze um eine Schrittlänge herabsetzen
            oberegrenze = oberegrenze - steplength;
    end
    hold off;
    
end

% Endbild
if strcmp(mode,'hdi')
    % Plotte den Graphen
    ezplot(f);
    hold on; axis([x_min x_max y_min y_max]);

    % Berechne Funktionswert für Untergrenze
    g = x - unteregrenze;
    endpoint = solve(f,g)

    % Plotte Funktionswert und Hilfslinien
    plot(subs(endpoint.x),subs(endpoint.y),'--o','LineStyle','none',...
        'MarkerEdgeColor','b', 'MarkerFaceColor','b', 'MarkerSize',5);
    line([unteregrenze unteregrenze],[0 ax(4)],'Color','r','LineWidth',1,...
        'LineStyle','--');
    line([ax(1) subs(endpoint.x)],[subs(endpoint.y) subs(endpoint.y)],...
        'Color','k','LineWidth',1,'LineStyle',':');
    line([subs(endpoint.x) subs(endpoint.x)],[subs(endpoint.y) 0],...
        'Color','k','LineWidth',1,'LineStyle',':');

    % Beschriftung
    switch graph
        case '1'
            title('Funktion 1.Grades [f(x)=y]');
        case '2'
            title('Funktion 2.Grades [f(x)=4x(1-x)]');
        case '3'
            title('Funktion 5.Grades [f(x)=(x-5)*(x-5)*(x-3)*(x-1)*(x-2)/3+2)]');
    end
    set(gca,'XTick',[unteregrenze]);
    set(gca,'XTickLabel',{'x_0'});
    set(gca,'YTick',[subs(endpoint.y)]);
    set(gca,'YTickLabel',{'f(x_0)'});
    text(0.15,0.91,text1,'FontSize',13,'Units','normalized',...
        'BackgroundColor','white','interpreter','latex');
    text(0.15,0.81,text2,'FontSize',13,'Units','normalized',...
        'BackgroundColor','white','interpreter','latex');           
    text(0.15,0.73,text3,'FontSize',13,'Units','normalized',...
        'BackgroundColor','white','interpreter','latex');
    % fixes bug in linux (minus missing):
    text(0.25,0.935,text4,'FontSize',13,'Units','normalized'); 
    text(0.25,0.865,text4,'FontSize',13,'Units','normalized');

    for j=1:startstoplength
        % Standbildaufnahme am Ende
        M(frame) = getframe(gcf); frame = frame + 1;
    end
end
Abgerufen von „https://de.wikiversity.org/w/index.php?title=Benutzer:DerMathekernel&oldid=286219“