# Kedvenc Matematikai Kísérleteim

## Alapok

## Halmazok és függvények

## Számok

## Határérték

## Differenciálszámítás

## Integrálszámítás

## Lineáris algrebra

## Többváltozós függvények

### Metrikus terek

### Differeciálszámítás

### Lineáris operátorok normája

### Feladat

### Feladat

### Feladat

### Feladat

kill(all);

F:cos(t)^2+(3*sin(t)+2*cos(t))^2;

ratsimp(%);

Ft:diff(F,t);

solve(Ft);

%/cos(t);

trigsimp(%);

trigreduce(%);

ee:float(%), numer;

solve(ee[1]);

float(%), numer;

subst(%,F);

solve(ee[2]);

float(%), numer;

subst(%,F);

sqrt(%);

### Feladat

### Feladat

### Feladat

### Definíció

### Példa

### Példa

### Sima görbék

### Összegszabály

### Láncszabály

### Koordinátafüggvények differenciálhatósága

### Parciális deriváltak

### Középérték-egyenlőtlenség

### Következmény

### Következmény

### Tétel

### Megjegyzés

### Példák

### Feladat

### Feladat

### Feladat

### Feladat

### Feladat

### Feladat

### Feladat

### Feladat

### Feladat

### Feladat

### Bevezető példa

### Függvénysorozat tagonkénti differenciálása

### Feladat

### Magasabbrendű deriváltak

### Magasabbrendű deriváltak és parciális deriváltak kapcsolata

### A második derivált, mint bilineáris leképezés

### A magasabbrendű deriváltak, mint multilineáris leképezések

### Young tétele

### Példa

### Feladat

### Feladat

### C^m-leképezések

### Feladat

### Taylor-formula maradéktag nélkül

### Taylor-formula valós értékű függvényekre

### Megjegyzés

### Implicit függvény tétel

### Feladat

kill(all);

e1:x1*exp(x3+x4)-2*x3*x4-1;

sublis([x1=1,x2=2,x3=0,x4=0],e1);

e2:x2*exp(x3-x4)+x3/(1+x4)-2*x1;

sublis([x1=1,x2=2,x3=0,x4=0],e2);

e13:diff(e1,x3); e14:diff(e1,x4); e23:diff(e2,x3); e24:diff(e2,x4);

sublis([x1=2,x2=1,x3=0,x4=0],[[e13,e14],[e23,e24]]);

### Feladat

kill(all);

e:x^2-x*y+2*y^2+x-y-1=0;

sublis([x=0,y=1],e);

ey:diff(lhs(e),y);

sublis([x=0,y=1],ey);

depends(y,x);

ep:diff(e,x);

epp:diff(ep,x);

### Feladat

kill(all);

e:x^2+2*y^2+3*z^2+x*y-z-9=0;

sublis([x=1,y=-2,z=1],e);

depends(z,[x,y]);

ex:diff(e,x);

exx:diff(%,x);

ey:diff(e,y);

eyx:diff(%,x);

eyy:diff(ey,y);

### Feladat

etc.

### Feladat

### Feladat

### Inverz függvény tétel

### Megjegyzés

### Feladat

### Feladat

### Szélsőérték szükséges
feltétele

### Lokális szélsőérték másodrendű elégséges
feltétele

### Lokális szélsőérték magasabbrendű elégséges
feltétele

### Feladat

kill(all);

e:2*x^3-3*x^2+2*y^3+3*y^2;

ex:diff(e,x);

ey:diff(e,y);

s:solve([ex,ey],[x,y]);

exx:diff(ex,x);

exy:diff(ex,y);

eyy:diff(ey,y);

sublis(s[1],[[exx,exy],[exy,eyy]]);

sublis(s[2],[[exx,exy],[exy,eyy]]);

sublis(s[3],[[exx,exy],[exy,eyy]]);

sublis(s[4],[[exx,exy],[exy,eyy]]);

### Feladat

etc.

### Feladat

### Feladat

### Lagrange-elv: feltételes szélsőérték keresése

### Feltételes szélsőérték másodrendű elégséges
feltétele

### Szélsőérték-számítás

### Példa

### Példa

### Feladat

kill(all);

F:(x^2-6*x)*(y^2-4*y);

Fx:diff(F,x);

Fy:diff(F,y);

solve([Fx,Fy],[x,y]);

subst(3,x,F);

subst(2,y,%);

subst(2*t,y,F);

f:subst(t,x,%);

subst(0,t,f);

subst(4,t,f);

plot2d(f,[t,0,4]);

ft:diff(f,t);

solve(ft,t);

etc.

### Feladat

(1)

kill(all);

f:5*x-2*y-1;

F:f+λ*(25*x^2+4*y^2-50);

Fx:diff(F,x);

Fy:diff(F,y);

solve(Fx,λ);

e1:subst(%,Fy);

e2:diff(F,λ);

sol:algsys([e1,e2],[x,y]);

subst(sol[1],f);

subst(sol[2],f);

(2) etc.

### Feladat

kill(all);

F:x*y+λ*(x^2+y^2-1);

Fx:diff(F,x);

Fy:diff(F,y);

solve(Fx,λ);

e1:subst(%,Fy);

e2:diff(F,λ);

sol:algsys([e1,e2],[x,y]);

1/2;

### Feladat

etc.

### Feladat

etc.

### Feladat

F:x*y*z+λ*(x+y+z-5)+μ*(x*y+y*z+z*x-8);

Fx:diff(F,x);

Fy:diff(F,y);

Fz:diff(F,z);

Fl:diff(F,λ);

Fm:diff(F,μ);

e1:solve(Fx,λ);

e2:subst(e1,Fy);

e3:subst(e1,Fz);

e4:solve(e2,μ);

e5:subst(e4,e3);

ratsimp(%);

algsys([e5,Fl,Fm],[x,y,z]);

### Feladat

etc.

### Feladat

etc.

### Feladat

etc.

### Feladat

Parametrizáljuk a határt!

### Feladat

Parametrizáljuk a határt!

### Feladat

f:x+y^2/(4*x)+z^2/y+2/z;

fx:diff(f,x);

fy:diff(f,y);

fz:diff(f,z);

algsys([fx,fy,fz],[x,y,z]);

### Feladat

etc.

### Feladat

etc.

### Feladat

Parametrizáljuk a határt!

### Feladat

etc.

### Feladat

etc.

### Feladat

etc.

### Feladat

Ha a vektor hossza r, akkor a bal oldal r^4, a jobb legfeljebb a^2*r^2,
így a megoldásokra r korlátos.

etc.

### Feladat

(1)

f:x/y;

fx:diff(f,x);

fxx:diff(fx,x);

fy:diff(f,y);

fyy:diff(fy,y);

fyyy:diff(fyy,y);

t:1+(x-1)-(x-1)*(y-x)/2+(x-1)*(y-1)^2/3-(y-1)+(y-1)^2-(y-1)^3;

(2) etc.

### Feladat

(1)

f:x^3+x*y+y^2-3*x-3*y;

fx:diff(f,x);

fy:diff(f,y);

s:algsys([fx,fy],[x,y]);

subst(s[1],f);

float(%), numer;

subst(s[2],f);

float(%), numer;

(2) etc.

### Lagrange-szorzók

### Lagrange-elv: feltételes szélsőérték keresése,
egyenlőtlenségeket is tartalmazó feltételrendszer

### Következmény

### Elválasztási tétel

### Farkas-lemma

### Következmény

### Primál-duál feladatpár

### Feladat

### Nyeregpont tétel

### A lineáris programozás
főtétele

### Approximáció

### A Newton-módszer

### Kvázi Newton-módszer

### Feladat

kill(all);

Pontos:

algsys([x^2+y^2,x^2-y^2],[x,y]);

Lásd a következő feladatot.

### Feladat

kill(all);

Pontos:

algsys([x+y-3,x^2+y^2-9],[x,y]);

Newton:

f(x):=matrix([x[1]+x[2]-3],[x[1]^2+x[2]^2-9]);

m(x):=matrix([1,1],[2*x[1],2*x[2]]);

x:[2,4];

mm:m(x);

mmi:invert_by_lu(mm);

d:-mmi.f(x);

x:x+args(transpose(d))[1];

mm:m(x);

mmi:invert_by_lu(mm);

d:-mmi.f(x);

x:x+args(transpose(d))[1];

mm:m(x);

mmi:invert_by_lu(mm);

d:-mmi.f(x);

x:x+args(transpose(d))[1];

float(%), numer;

Módosított Newton:

x:[2,4];

m0:m(x);

m0i:invert_by_lu(m0);

d:-m0i.f(x);

x:x+args(transpose(d))[1];

d:-m0i.f(x);

x:x+args(transpose(d))[1];

d:-m0i.f(x);

x:x+args(transpose(d))[1];

d:-m0i.f(x);

x:x+args(transpose(d))[1];

float(%), numer;

Fékezett Newton:

σ:0.01;

1-σ;

ρ:0.5;

x:[2,4];

mm:m(x);

mmi:invert_by_lu(mm);

ff:f(x);

ffnn:ff[1][1]^2+ff[2][1]^2;

α:1.0;

d:args(transpose(-mmi.ff))[1];

xx:x+α*d;

fff:f(xx);

fffnn:fff[1][1]^2+fff[2][1];

(fffnn-ffnn)/α/ffnn;

x:x+α*d;

etc.

Broyden:

x:[2,4];

A:m(x);

Ai:invert_by_lu(A);

ff:f(x);

d:args(transpose(-Ai.ff))[1];

fff:f(x+d);

dnn:d[1]^2+d[2]^2;

A:(fff-ff-A.transpose(matrix(d))).matrix(d)/dnn;

Ai:invert_by_lu(A);

### Kapcsolat
minimumfeladatokkal

### Nelder-Mead-módszer minimumfeladatokra

### Az irány menti csökkentés módszere

### Kvázi Newton-módszerek minimalizálásra

### Feladat

Lásd a következő feladatot.

### Feladat

Pontos:

kill(all);

F:(x^2+y-11)^2+(y^2+x-7)^2;

Fx:diff(F,x);

Fy:diff(F,y);

algsys([Fx,Fy],[x,y]);

Nelder-Mead:

kill(all);

α:1.0;

β:2.0;

γ:0.5;

δ:0.5;

ε:0.1;

F(x):=(x[1]^2+x[2]-11)^2+(x[2]^2+x[1]-7)^2;

x0:[4,2]; x1:[2,2]; x2:[2,4];

F0:F(x0); F1:F(x1); F2:F(x2);

xa:(x0+x1+x2)/3.0;

Fa:(F0+F1+F2)/3.0;

((F0-Fa)^2+(F1-Fa)^2+(F2-Fa)^2)/3;

y:xa+α*(xa-x2);

F(y);

z:xa+β*(xa-x2);

F(z);

x2:y;

F2:F(x2);

x0; x1; x2;

F0; F1; F2;

xa:(x0+x1+x2)/3.0;

Fa:(F0+F1+F2)/3.0;

((F0-Fa)^2+(F1-Fa)^2+(F2-Fa)^2)/3;

y:xa+α*(xa-x0);

F(y);

x0:y;

F0:F(x0);

x0; x1; x2;

F0; F1; F2;

xa:(x0+x1+x2)/3.0;

Fa:(F0+F1+F2)/3.0;

xa:(x0+x1+x2)/3.0;

((F0-Fa)^2+(F1-Fa)^2+(F2-Fa)^2)/3;

y:xa+α*(xa-x1);

F(y);

x1:y;

F1:F(y);

x0; x1; x2;

F0; F1; F2;

xa:(x0+x1+x2)/3.0;

Fa:(F0+F1+F2)/3.0;

y:xa+α*(xa-x0);

F(y);

w:xa+γ*(xa-x0);

F(w);

x0:w;

F0:F(w);

etc.

### Feladat

etc.

### Belső pont módszerek