DerMathekernel
Beigetreten 24. November 2009
Staff
BearbeitenMathe I
BearbeitenEinst bestand der Mathekernel damals noch aus:
- Sascha Ludwig
- Alexander Blum
Assoziiert waren damals noch mit dem Mathekernel einst:
- Sandra Fenzlaff (Moses)
Mathe II
BearbeitenDer Mathekernel besteht nun aus:
- Alexander Blum
Weiterhin assoziiert bleiben:
- Sandra Fenzlaff (Moses)
Alumni (in Gedenken an):
- Sascha Ludwig
Mathe I
BearbeitenIntervallschachtelung zur Bestimmung der eulerschen Zahl e
Bearbeiten(siehe Aufgabe 9.18)
Gif-Datei
BearbeitenMatlab-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
BearbeitenIdentität
BearbeitenScherung (x-Achse)
BearbeitenScherung (y-Achse)
BearbeitenRotation
BearbeitenTranslation
BearbeitenSpiegelung (x-Achse)
BearbeitenSkalierung (x-Achse)
BearbeitenSkalierung (x-Achse ~ y-Achse)
BearbeitenMatlab-Code
Bearbeiten- wird gerade überarbeitet
Aufgabe 21.20 "Billardtisch-Aufgabe"
BearbeitenBilder
BearbeitenMatlab-Code
Bearbeitenbillard.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
Bearbeitenfunction [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
Bearbeitenfunction [ 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
Bearbeiten33.21: Illustration des Mittelwertsatzes der Integralrechnung
Bearbeiten(siehe Aufgabe 33.21)
Bilder
BearbeitenFunktion 1.Grades
BearbeitenFunktion 2.Grades
BearbeitenFunktion 5.Grades
BearbeitenMatlab-Code
Bearbeiten(siehe Matlab-Code 33.22)
33.22: Illustration des Hauptsatzes der Infinitesimalrechnung
Bearbeiten(siehe Aufgabe 33.22)
Animationen
BearbeitenFunktion 1.Grades
BearbeitenFunktion 2.Grades
BearbeitenFunktion 5.Grades
BearbeitenMatlab-Code
Bearbeitenfunction [ 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