MAPLE 16 

(stručný manuál) 

Algebraické úpravy 

Symbolické výpočty - algebraické úpravy 

expand - roznásobí mnohočleny  a vrátí součet jednotlivých členů
factor - napíše výraz jako násobení nejmenších faktorů
simplify - zkusí najít nejjednodušší formu výrazu pomocí standardních alg. transformací  

> v:=(x-2)^2*(1+x+2*y);
 

`*`(`^`(`+`(x, `-`(2)), 2), `*`(`+`(1, x, `*`(2, `*`(y))))) (1.1.1)
 

> v1:=expand(v);
 

`+`(`-`(`*`(3, `*`(`^`(x, 2)))), `*`(`^`(x, 3)), `*`(2, `*`(`^`(x, 2), `*`(y))), `-`(`*`(8, `*`(x, `*`(y)))), 4, `*`(8, `*`(y))) (1.1.2)
 

> v2:=factor(v1);
 

`*`(`^`(`+`(x, `-`(2)), 2), `*`(`+`(1, x, `*`(2, `*`(y))))) (1.1.3)
 

> factor(x^3+3*x^2+3*x+1);
 

`*`(`^`(`+`(x, 1), 3)) (1.1.4)
 

> simplify(sin(x)^2+cos(x)^2);
 

1 (1.1.5)
 

> simplify(x^2-1);
 

`+`(`*`(`^`(x, 2)), `-`(1)) (1.1.6)
 

> factor(x^2-1);
 

`*`(`+`(x, `-`(1)), `*`(`+`(x, 1))) (1.1.7)
 

> v3:=expand(tan(x)*cos(2*x));
 

`+`(`*`(2, `*`(tan(x), `*`(`^`(cos(x), 2)))), `-`(tan(x))) (1.1.8)
 

> expand(cos(2*x));
 

`+`(`*`(2, `*`(`^`(cos(x), 2))), `-`(1)) (1.1.9)
 

> v4:=factor(v3);
 

`*`(tan(x), `*`(`+`(`*`(2, `*`(`^`(cos(x), 2))), `-`(1)))) (1.1.10)
 

> expand(sin(x+I*y));
 

`+`(`*`(sin(x), `*`(cosh(y))), `*`(I, `*`(cos(x), `*`(sinh(y))))) (1.1.11)
 

 

Krácení zlomků 

 

> normal((x + 1)/(x^2 - 1));
 

`/`(1, `*`(`+`(x, `-`(1)))) (1.2.1)
 

> simplify((x + 1)/(x^2 - 1));
 

`/`(1, `*`(`+`(x, `-`(1)))) (1.2.2)
 

> normal((x + 1)/(x^2 - 1) + x/(x*(x - 2)));
 

`/`(`*`(`+`(`*`(2, `*`(x)), `-`(3))), `*`(`+`(x, `-`(2)), `*`(`+`(x, `-`(1))))) (1.2.3)
 

> simplify((x + 1)/(x^2 - 1) + x/(x*(x - 2)));
 

`/`(`*`(`+`(`*`(2, `*`(x)), `-`(3))), `*`(`+`(x, `-`(2)), `*`(`+`(x, `-`(1))))) (1.2.4)
 

Rozklad na parciální zlomky 

 

> convert(2*(x^2 - 4)/(x^2 - 1),parfrac);
 

`+`(2, `/`(`*`(3), `*`(`+`(x, 1))), `-`(`/`(`*`(3), `*`(`+`(x, `-`(1)))))) (1.3.1)
 

> v:=(x^2 + y^2)/(x + x*y);
 

`/`(`*`(`+`(`*`(`^`(x, 2)), `*`(`^`(y, 2)))), `*`(`+`(x, `*`(x, `*`(y))))) (1.3.2)
 

Nyní řekneme Maplu, že x je proměnná a ostatní symboly jsou parametry 

> convert(v,parfrac,x);
 

`+`(`/`(`*`(x), `*`(`+`(1, y))), `/`(`*`(`^`(y, 2)), `*`(x, `*`(`+`(1, y))))) (1.3.3)
 

y je proměnná a ostatní symboly jsou parametry 

> convert(v,parfrac,y);
 

`+`(`/`(`*`(`+`(y, `-`(1))), `*`(x)), `/`(`*`(`+`(`*`(`^`(x, 2)), 1)), `*`(x, `*`(`+`(1, y))))) (1.3.4)
 

Symbolicka matematika 

Funkce 

Tabulka elementárních finkcí:
`*`(`^`(x, 2))        `^`(x, a)        sqrt(x)       `^`(x, `/`(1, `*`(n)))       `^`(e, x)      ln(x)        log(x)      log a (x)    
 

x^2      x^a    sqrt(x)   x^(1/n)    exp(x)    ln(x)      log10 (x)    log[a](x)    

 

sin(x)     cos(x)     tg(x)      cotg(x)      arcsin(x)     arccos(x)      arctg(x)        arccotg(x) 

sin(x)     cos(x)     tan(x)    cot(x)        arcsin(x)     arccos(x)      arctan(x)      arccot(x)

sinh(x)    cos h(x)     tgh(x)      cotgh(x)         |x|         sgn(x)     1/x
sinh(x)    cos h(x)    tanh(x)     coth(x)         abs(x)     sgn(x)     1/x
 

 

Vlastní definice funkce f(x) 

> f:=x->x^2+5*x-3;
 

proc (x) options operator, arrow; `+`(`*`(`^`(x, 2)), `*`(5, `*`(x)), `-`(3)) end proc (2.1.1)
 

> f(1);
 

3 (2.1.2)
 

> f(-5);
 

-3 (2.1.3)
 

Vlastní definice funkce f(x)=x^2 je-li x<0 a x je-li x>=0 

> v:=piecewise(x < 0,x^2,x>=0,x);
 

v := piecewise(`<`(x, 0), `*`(`^`(x, 2)), `<=`(0, x), x) (2.1.4)
 

> f:=x->piecewise(x < 0,x^2,x>=0,x);
 

proc (x) options operator, arrow; piecewise(`<`(x, 0), `*`(`^`(x, 2)), `<=`(0, x), x) end proc (2.1.5)
 

> f(-2);
 

4 (2.1.6)
 

> f(0);
 

0 (2.1.7)
 

> f(2);
 

2 (2.1.8)
 

Derivace 

první derivace f '(x) 

> diff(x^n,x);
 

`/`(`*`(`^`(x, n), `*`(n)), `*`(x)) (2.2.1)
 

třetí derivace f '''(x) 

> diff(x^n,x$3);
 

`+`(`/`(`*`(`^`(x, n), `*`(`^`(n, 3))), `*`(`^`(x, 3))), `-`(`/`(`*`(3, `*`(`^`(x, n), `*`(`^`(n, 2)))), `*`(`^`(x, 3)))), `/`(`*`(2, `*`(`^`(x, n), `*`(n))), `*`(`^`(x, 3)))) (2.2.2)
 

Parciální derivace funkce f(x,y) podle x 

> diff(x^2+y^2,x);
 

`+`(`*`(2, `*`(x))) (2.2.3)
 

Parciální derivace funkce f(x,y) podle y 

> diff(x^2+y^2,y);
 

`+`(`*`(2, `*`(y))) (2.2.4)
 

Jiná možnost derivace (máme-li definovanou funkci) 

> f:=(x,y)->x^2+y^2;
 

proc (x, y) options operator, arrow; `+`(`*`(`^`(x, 2)), `*`(`^`(y, 2))) end proc (2.2.5)
 

Derivace podle první proměnné 

> fx:=D[1](f);
 

proc (x, y) options operator, arrow; `+`(`*`(2, `*`(x))) end proc (2.2.6)
 

Derivace podle druhé proměnné 

> fz:=D[2](f);
 

proc (x, y) options operator, arrow; `+`(`*`(2, `*`(y))) end proc (2.2.7)
 

Integrace 

Primitivní funkce 

> int(x^n,x);
 

`/`(`*`(`^`(x, `+`(n, 1))), `*`(`+`(n, 1))) (2.3.1)
 

Příkaz s velkým začátečním písmenem vypíše pouze symbol integrálu (můžeme ho používat pro přehlednější zápis) 

> Int(x^n,x)=int(x^n,x);
 

Int(`^`(x, n), x) = `/`(`*`(`^`(x, `+`(n, 1))), `*`(`+`(n, 1))) (2.3.2)
 

> int(1/(x^4-a^4),x);
 

`+`(`-`(`/`(`*`(`/`(1, 4), `*`(ln(`+`(x, a)))), `*`(`^`(a, 3)))), `-`(`/`(`*`(`/`(1, 2), `*`(arctan(`/`(`*`(x), `*`(a))))), `*`(`^`(a, 3)))), `/`(`*`(`/`(1, 4), `*`(ln(`+`(x, `-`(a))))), `*`(`^`(a, 3)... (2.3.3)
 

> Int(1/(x^4-a^4),x)=int(1ralu/(x^4-a^4),x);
 

Int(`/`(1, `*`(`+`(`*`(`^`(x, 4)), `-`(`*`(`^`(a, 4)))))), x) = `+`(`-`(`/`(`*`(`/`(1, 4), `*`(ln(`+`(x, a)))), `*`(`^`(a, 3)))), `-`(`/`(`*`(`/`(1, 2), `*`(arctan(`/`(`*`(x), `*`(a))))), `*`(`^`(a, 3... (2.3.4)
 

F je primitivní funkce zapsaná v Maple jako funkce 

> F:=x->int(1/x,x);
 

proc (x) options operator, arrow; int(`/`(1, `*`(x)), x) end proc (2.3.5)
 

> F(x);
 

ln(x) (2.3.6)
 

Pozor !!! Maple obecně počítá v komplexním obor, kde je definovaný logaritmus ze záporného čísla. Proto také předchozí výsledek není ln(|x|) 

> ln(-1);
 

`*`(I, `*`(Pi)) (2.3.7)
 

Určitý integrál z funkce  f(x) od a do b  

> int(x^5,x=0..1);
 

`/`(1, 6) (2.3.8)
 

> Int(x^5,x=0..1)=int(x^5,x=0..1);
 

Int(`*`(`^`(x, 5)), x = 0 .. 1) = `/`(1, 6) (2.3.9)
 

Nevlastní integrály 

1. integrál diverguje 

> Int(1/x,x=0..1)=int(1/x,x=0..1);
 

Int(`/`(1, `*`(x)), x = 0 .. 1) = infinity (2.3.10)
 

> Int(1/x,x=1..infinity)=int(1/x,x=1..infinity);
 

Int(`/`(1, `*`(x)), x = 1 .. infinity) = infinity (2.3.11)
 

2. integrál konverguje 

> Int(1/x^2,x=0..infinity)=int(1/x^2,x=1..infinity);
 

Int(`/`(1, `*`(`^`(x, 2))), x = 0 .. infinity) = 1 (2.3.12)
 

> Int(x^n,x=0..1)=int(x^n,x=0..1);
 

Int(`^`(x, n), x = 0 .. 1) = `/`(`*`(`+`(`-`(limit(`^`(x, `+`(n, 1)), x = 0, right)), 1)), `*`(`+`(n, 1))) (2.3.13)
 

> assume(n>-1);
 

> Int(x^n,x=0..1)=int(x^n,x=0..1);
 

Int(`^`(x, n), x = 0 .. 1) = `/`(1, `*`(`+`(n, 1))) (2.3.14)
 

> assume(n<=-1);
 

> Int(x^n,x=0..1)=int(x^n,x=0..1);
 

Int(`^`(x, n), x = 0 .. 1) = infinity (2.3.15)
 

> n:='n';
 

n (2.3.16)
 

Někdy promitivní funkci Maple nevypočte (neznamená to, že neexistuje): 

> int(x^x,x);
 

int(`^`(x, x), x) (2.3.17)
 

Suma 

Součet nekonečné řady: 

> sum(1/2^n,n=1..infinity);
 

1 (2.4.1)
 

> Sum(1/2^n,n=1..infinity)=sum(1/2^n,n=1..infinity);
 

Sum(`/`(1, `*`(`^`(2, n))), n = 1 .. infinity) = 1 (2.4.2)
 

> Sum(1/n!,n=1..infinity)=sum(1/n!,n=1..infinity);
 

Sum(`/`(1, `*`(factorial(n))), n = 1 .. infinity) = `+`(exp(1), `-`(1)) (2.4.3)
 

> Sum(1/x^n,n=1..infinity)=sum(1/x^n,n=1..infinity);
 

Sum(`/`(1, `*`(`^`(x, n))), n = 1 .. infinity) = `/`(1, `*`(`+`(`-`(1), x))) (2.4.4)
 

Pozor !!!! Maple nám neřekne pro která x  součet platí. V tomto případě to plati pro |x|>1. Například si můžeme ukázat, že pro x=1/2 nebo  x = -1 řada diverguje. 

> Sum(1/(1/2)^n,n=1..infinity)=sum(1/(1/2)^n,n=1..infinity);
 

Sum(`/`(1, `*`(`^`(`/`(1, 2), n))), n = 1 .. infinity) = infinity (2.4.5)
 

> Sum(1/(-1)^n,n=1..infinity)=sum(1/(-1)^n,n=1..infinity);
 

Sum(`/`(1, `*`(`^`(-1, n))), n = 1 .. infinity) = sum(`/`(1, `*`(`^`(-1, n))), n = 1 .. infinity) (2.4.6)
 

Maple nám neřekne, že diverguje, ale jednoduchou úvahou (sudé a liché částečné součty) zjistíme, že součet řady neexistuje. 

Limity 

 limita  f(x) když x se blíží k a 

> limit(sin(x),x=0);
 

0 (2.5.1)
 

> Limit(sin(x),x=0)=limit(sin(x),x=0);
 

Limit(sin(x), x = 0) = 0 (2.5.2)
 

> Limit(1/x,x=0)=limit(1/x,x=0);
 

Limit(`/`(1, `*`(x)), x = 0) = undefined (2.5.3)
 

 limita  f(x) když x se blíží k a zprava 

> Limit(1/x,x=0,right)=limit(1/x,x=0,right);
 

Limit(`/`(1, `*`(x)), x = 0, right) = infinity (2.5.4)
 

limita  f(x) když x se blíží k a zleva 

> Limit(1/x,x=0,left)=limit(1/x,x=0,left);
 

Limit(`/`(1, `*`(x)), x = 0, left) = `+`(`-`(infinity)) (2.5.5)
 

Řešení rovnic 

Řešení alg. rovnic 

> v:=solve(x^2+2*x-7=0,x);
 

`+`(`-`(1), `*`(2, `*`(`^`(2, `/`(1, 2))))), `+`(`-`(1), `-`(`*`(2, `*`(`^`(2, `/`(1, 2)))))) (3.1.1)
 

> evalf(v);
 

1.828427124, -3.828427124 (3.1.2)
 

> v1:=solve(x^2+a*x+b=0,x);
 

`+`(`-`(`*`(`/`(1, 2), `*`(a))), `*`(`/`(1, 2), `*`(`^`(`+`(`*`(`^`(a, 2)), `-`(`*`(4, `*`(b)))), `/`(1, 2))))), `+`(`-`(`*`(`/`(1, 2), `*`(a))), `-`(`*`(`/`(1, 2), `*`(`^`(`+`(`*`(`^`(a, 2)), `-`(`*`... (3.1.3)
 

> v2:=solve(x^6+1=0,x);
 

I, `+`(`-`(I)), `+`(`*`(`/`(1, 2), `*`(`^`(`+`(2, `-`(`*`(`+`(`*`(2, `*`(I))), `*`(`^`(3, `/`(1, 2)))))), `/`(1, 2))))), `+`(`-`(`*`(`/`(1, 2), `*`(`^`(`+`(2, `-`(`*`(`+`(`*`(2, `*`(I))), `*`(`^`(3, `... (3.1.4)
 

> v3:=solve(x^5-2*x^3+x^2+3*x-1=0,x);
 

RootOf(`+`(`*`(`^`(_Z, 5)), `-`(`*`(2, `*`(`^`(_Z, 3)))), `*`(`^`(_Z, 2)), `*`(3, `*`(_Z)), `-`(1)), index = 1), RootOf(`+`(`*`(`^`(_Z, 5)), `-`(`*`(2, `*`(`^`(_Z, 3)))), `*`(`^`(_Z, 2)), `*`(3, `*`(_...
RootOf(`+`(`*`(`^`(_Z, 5)), `-`(`*`(2, `*`(`^`(_Z, 3)))), `*`(`^`(_Z, 2)), `*`(3, `*`(_Z)), `-`(1)), index = 1), RootOf(`+`(`*`(`^`(_Z, 5)), `-`(`*`(2, `*`(`^`(_Z, 3)))), `*`(`^`(_Z, 2)), `*`(3, `*`(_...
RootOf(`+`(`*`(`^`(_Z, 5)), `-`(`*`(2, `*`(`^`(_Z, 3)))), `*`(`^`(_Z, 2)), `*`(3, `*`(_Z)), `-`(1)), index = 1), RootOf(`+`(`*`(`^`(_Z, 5)), `-`(`*`(2, `*`(`^`(_Z, 3)))), `*`(`^`(_Z, 2)), `*`(3, `*`(_...
(3.1.5)
 

> v4:=solve(Cos(x)=x,x);
 

RootOf(`+`(`-`(Cos(_Z)), _Z)) (3.1.6)
 

V případě, že nelze najit řešení rovnice analiticky, je třeba použít numerické řešení (viz Numerická matematika) 

Řešení diferenciálních rovnic  

Obecné řešení 

> dsolve(diff(y(x),x)=1+y(x),y(x));
 

y(x) = `+`(`-`(1), `*`(exp(x), `*`(_C1))) (3.2.1)
 

Partikulární  řešení splňující počáteční podmínku 

> dsolve({diff(y(x),x)=1+y(x),y(0)=1},y(x));
 

y(x) = `+`(`-`(1), `*`(2, `*`(exp(x)))) (3.2.2)
 

Obecné řešení 

> dsolve(diff(y(x),x)=1/y(x),y(x));
 

y(x) = `*`(`^`(`+`(`*`(2, `*`(x)), _C1), `/`(1, 2))), y(x) = `+`(`-`(`*`(`^`(`+`(`*`(2, `*`(x)), _C1), `/`(1, 2))))) (3.2.3)
 

Partikulární  řešení splňující počáteční podmínku 

> res:=dsolve({diff(y(x),x)=1/y(x),y(0)=1},y(x));
 

y(x) = `*`(`^`(`+`(`*`(2, `*`(x)), 1), `/`(1, 2))) (3.2.4)
 

> plot(rhs(res),x=-0.5..1);
 

Plot_2d
 

Pozor Maple nás neupozorní, že řešení není definované v bodě x=0.5 

Obecné řešení soustavy rovnic 

> dsolve({diff(x(t),t)=-y(t),diff(y(t),t)=x(t)},{x(t),y(t)});
 

{x(t) = `+`(`*`(_C1, `*`(sin(t))), `*`(_C2, `*`(cos(t)))), y(t) = `+`(`-`(`*`(_C1, `*`(cos(t)))), `*`(_C2, `*`(sin(t))))} (3.2.5)
 

Partikulární  řešení splňující počáteční podmínku 

> res1:=dsolve({diff(x(t),t)=-y(t),diff(y(t),t)=x(t),x(0)=1,y(0)=0},{x(t),y(t)});
 

{x(t) = cos(t), y(t) = sin(t)} (3.2.6)
 

Nakreslení integrální křivky (graf partikulárního řešení  x(t)) 

> assign(res1);
 

> plot(x(t),t=0..2*Pi);
 

Plot_2d
 

Nakreslení integrální křivky (graf partikulárního řešení  y(t)) 

> plot(y(t),t=0..2*Pi);
 

Plot_2d
 

Nakreslení integrálních křivek do jednoho obrázku 

> plot([x(t),y(t)],t=0..2*Pi);
 

Plot_2d
 

Nakreslení trajektorie řešení (graf parametricky zadané křivky) 

> plot([x(t),y(t),t=0..2*Pi]);
 

Plot_2d
 

Grafy 

Grafy 2D 

Nejjednodušší vykreslení grafu. 

> plot(sin(x),x=-2*Pi..2*Pi);
 

Plot_2d
 

Teď použijeme různé volby (options). 

1. Rozsah osy y 

> plot(sin(x),x=-2*Pi..2*Pi,y=-1.5..1.5);
 

Plot_2d
 

2. Číselný popis osy x a y 

> plot(sin(x),x=-2*Pi..2*Pi,y=-1.5..1.5,tickmarks=[[-6.28,0,6.28], [-1, 1]]);
 

Plot_2d
 

3. Tloušťka čáry a titulek. 

> plot(sin(x),x=-2*Pi..2*Pi,y=-1.5..1.5,thickness=3,title=`sin(x)`);
 

Plot_2d
 

4. Grafy více funkcí do jednoho obrázku a barva grafu. 

> plot([sin(x),cos(x)],x=-2*Pi..2*Pi,y=-1.5..1.5,thickness=3,color=[red,green]);
 

Plot_2d
 

5. Pozor při kreslení grafu některých funkcí (nakreslí čáry navíc) 

> plot(tan(x),x=-2*Pi..2*Pi);
 

Plot_2d
 

> plot(tan(x),x=-2*Pi..2*Pi,discont=true);
 

Plot_2d
 

Parametrické grafy 2D 

> plot([cos(x),sin(2*x),x=0..2*Pi]);
 

Plot_2d
 

Zobrazení dat do grafu 

> data:=[[0,1],[0.5,1.4],[1.0,2.0],[1.5,1.9],[2.0,1.5],[2.5,1.6],[3.0,2.0]];
 

[[0, 1], [.5, 1.4], [1.0, 2.0], [1.5, 1.9], [2.0, 1.5], [2.5, 1.6], [3.0, 2.0]] (4.3.1)
 

> plot(data);
 

Plot_2d
 

> plot(data,style=point);
 

Plot_2d
 

Vrstevnice  funkce z=f(x,y) 

Pozor tento prikaz je součáetí balíku programů plots 

> with(plots);
 

[animate, animate3d, animatecurve, arrow, changecoords, complexplot, complexplot3d, conformal, conformal3d, contourplot, contourplot3d, coordplot, coordplot3d, densityplot, display, dualaxisplot, fiel...
[animate, animate3d, animatecurve, arrow, changecoords, complexplot, complexplot3d, conformal, conformal3d, contourplot, contourplot3d, coordplot, coordplot3d, densityplot, display, dualaxisplot, fiel...
[animate, animate3d, animatecurve, arrow, changecoords, complexplot, complexplot3d, conformal, conformal3d, contourplot, contourplot3d, coordplot, coordplot3d, densityplot, display, dualaxisplot, fiel...
[animate, animate3d, animatecurve, arrow, changecoords, complexplot, complexplot3d, conformal, conformal3d, contourplot, contourplot3d, coordplot, coordplot3d, densityplot, display, dualaxisplot, fiel...
[animate, animate3d, animatecurve, arrow, changecoords, complexplot, complexplot3d, conformal, conformal3d, contourplot, contourplot3d, coordplot, coordplot3d, densityplot, display, dualaxisplot, fiel...
[animate, animate3d, animatecurve, arrow, changecoords, complexplot, complexplot3d, conformal, conformal3d, contourplot, contourplot3d, coordplot, coordplot3d, densityplot, display, dualaxisplot, fiel...
[animate, animate3d, animatecurve, arrow, changecoords, complexplot, complexplot3d, conformal, conformal3d, contourplot, contourplot3d, coordplot, coordplot3d, densityplot, display, dualaxisplot, fiel...
[animate, animate3d, animatecurve, arrow, changecoords, complexplot, complexplot3d, conformal, conformal3d, contourplot, contourplot3d, coordplot, coordplot3d, densityplot, display, dualaxisplot, fiel...
(4.4.1)
 

> contourplot(sin(x)*sin(y),x=-2..2,y=-2..2);
 

Plot_2d
 

Volba vrstevnic. 

> contourplot(sin(x)*sin(y),x=-2..2,y=-2..2,contours=[-0.75,-0.5,-0.25,0,0.25,0.5,0.75]);
 

Plot_2d
 

Grafy 3D 

Nejjednodušší vykreslení grafu. 

> plot3d(sin(x)*sin(y),x=-2..2,y=-2..2);
 

Plot_2d
 

Teď použijeme různé volby (options). 

1. Přidáme box 

> plot3d(sin(x)*sin(y),x=-2..2,y=-2..2,axes=boxed);
 

Plot_2d
 

2. Přidáme osy 

> plot3d(sin(x)*sin(y),x=-2..2,y=-2..2,axes=normal);
 

Plot_2d
 

> plot3d(sin(x)*sin(y),x=-2..2,y=-2..2,axes=frame);
 

Plot_2d
 

3. změna sítě 

> plot3d(sin(x)*sin(y),x=-2..2,y=-2..2,axes=boxed,grid=[10,10]);
 

Plot_2d
 

Parametrické grafy 3D 

Parametricky zadaná křivka v R3 

> with(plots):
 

> spacecurve([cos(t),sin(t),t/3],t=0..6*Pi,axes=boxed);
 

Plot_2d
 

Parametricky zadaná plocha 

> plot3d([cos(t)*sin(u),sin(t)*sin(u),cos(u)],t=0..2*Pi,u=0..Pi,axes=boxed);
 

Plot_2d
 

Lineární algebra 

Práce s vektory a maticemi 

Ukážeme si jednu z možností zadání vektoru a matice (existuje více možností) 

Vektor sloupcový 

> v:=<1, 2 ,-1, 3>;
 

v := Vector[column](%id = 4678011650) (5.1.1)
 

Vektor řádkový 

> v1:=<1|2|-1|3>;
 

v1 := Vector[row](%id = 4678011714) (5.1.2)
 

Matice zadaná po sloupcích 

> A:=<<1,-1,2,1>|<-1,2,-1,1>|<1,5,0,-1>|<3,-4,4,0>>;
 

A := Matrix(%id = 4678011778) (5.1.3)
 

Matice zadaná po řádcích 

> A:=<<1|-1|1|3>,<-1|2|5|-4>,<2|-1|0|4>,<1|1|-1|0>>;
 

A := Matrix(%id = 4678011842) (5.1.4)
 

Násobení  matice  vektorem 

> A.v;
 

Vector[column](%id = 4678011906) (5.1.5)
 

Násobení  matice maticí 

> A.A;
 

Matrix(%id = 4678011970) (5.1.6)
 

Napojování matic 

> a:=<<1,2>|<2,3>>;
 

a := Matrix(%id = 4678012034) (5.1.7)
 

> b:=<<1,1>|<-1,0>>;
 

b := Matrix(%id = 4678012098) (5.1.8)
 

> c:=<<1,3>|<3,1>>;
 

c := Matrix(%id = 4678012162) (5.1.9)
 

 

> M:=<a,b,c>;
 

M := Matrix(%id = 4678012226) (5.1.10)
 

> N:=<a|b|c>;
 

N := Matrix(%id = 4678012290) (5.1.11)
 

Vyrobení matice pomocí předpisu 

> f:= (i,j) -> i/j:
 

> T:=Matrix(4,4,f);
 

T := Matrix(%id = 4678012354) (5.1.12)
 

i-tý řádek matice 

> T[1];
 

>
 

Vector[row](%id = 4678012418) (5.1.13)
 

Prvek i,j matice 

> T[1,3];
 

`/`(1, 3) (5.1.14)
 

Následující příkazy jsou součásti balíku LinearAlgebra 

Transponovaná matice  

> with(LinearAlgebra):
 

> TT:=Transpose(T);
 

TT := Matrix(%id = 4678012482) (5.1.15)
 

Inverzní matice 

> A:=<<1, -1, 2>|<-1, 1, 0>|<1, 0, 1>>;
 

A := Matrix(%id = 4678012546) (5.1.16)
 

> MatrixInverse(A);
 

Matrix(%id = 4678012610) (5.1.17)
 

> MatrixInverse(T);
 

Error, (in MatrixInverse) singular matrix
 

Maple nás upozornil, že matice T je singulární 

Vlastní čísla matice A 

> Eigenvalues(A);
 

Vector[column](%id = 4678012674) (5.1.18)
 

Vlastní vektory matice A 

> Eigenvectors(A);
 

Vector[column](%id = 4678004866), Matrix(%id = 4678004930) (5.1.19)
 

Maple nám vrátí vlastní čísla (první složka) a vlastní vektory (druhá složka) 

Determinant matica A 

> Determinant(A);
 

-2 (5.1.20)
 

> Determinant(T);
 

0 (5.1.21)
 

Jakobiho matice 

Jakobiho matice k zobrazení (r cos(t),r sin(t)) 

> restart; 1
 

> with(VectorCalculus):
 

> Jacobian( [r*cos(t),r*sin(t)], [r,t] );
 

Matrix(%id = 4678004994) (5.2.1)
 

Rozklady matic 

Singulární rozklad (příkaz je součástí baliku LinearAlgebra) 

> with(LinearAlgebra); -1
 

> A:=<<1,1,3,2>|<2,0,-3,-3>|<-1,-1,0,-2>|<1,3,2,1>>;
 

A := Matrix(%id = 4678005058) (5.3.1)
 

> U,S,Vt:=SingularValues(A,output=['U','S','Vt']):
 

> U;
 

Matrix(%id = 4678005122) (5.3.2)
 

> S;
 

Vector[column](%id = 4678005186) (5.3.3)
 

> Vt;
 

Matrix(%id = 4678005250)
Matrix(%id = 4678005250)
Matrix(%id = 4678005250)
Matrix(%id = 4678005250)
Matrix(%id = 4678005250)
(5.3.4)
 

QR rozklad 

> A:=<<1,1,1>|<2,6,0>|<-1,-1,1>>;
 

A := Matrix(%id = 4678005314) (5.3.5)
 

> Q,R:=QRDecomposition(A):
 

> Q;
 

Matrix(%id = 4678005378) (5.3.6)
 

> R;
 

Matrix(%id = 4678005442) (5.3.7)
 

Numerická matematika 

Vyčíslení výrazů, přesnost 

> (Pi^2-4)/(Pi-2);
 

`/`(`*`(`+`(`*`(`^`(Pi, 2)), `-`(4))), `*`(`+`(Pi, `-`(2)))) (6.1.1)
 

> simplify(%);
 

`+`(Pi, 2) (6.1.2)
 

> evalf(%);
 

5.141592654 (6.1.3)
 

> a:=sin(Pi/7);
 

sin(`+`(`*`(`/`(1, 7), `*`(Pi)))) (6.1.4)
 

> evalf(a);
 

.4338837393 (6.1.5)
 

implicitně je přesnost 10 platných míst, nastavíme ji na 16. 

> Digits:=16;
 

16 (6.1.6)
 

> evalf(a);
 

.4338837391175582 (6.1.7)
 

vrátíme zase přesnost na 10 platných míst 

> Digit:=10;
 

10 (6.1.8)
 

Metoda nejmenších čtverců 

> restart;
 

> data:=[[0,1],[1,2],[2,2.3],[3,2.8],[4,2.9],[5,3.5]];
 

[[0, 1], [1, 2], [2, 2.3], [3, 2.8], [4, 2.9], [5, 3.5]] (6.2.1)
 

> plot(data,style=POINT);
 

Plot_2d
 

> data1:=convert(linalg[col](data,1),list);
 

[0, 1, 2, 3, 4, 5] (6.2.2)
 

> data2:=convert(linalg[col](data,2),list);
 

[1, 2, 2.3, 2.8, 2.9, 3.5] (6.2.3)
 

Proložení přímkou 

> with(stats):
 

> r:=fit[leastsquare[[x,y]]]([data1,data2]);
 

y = `+`(1.295238095, `*`(.4485714286, `*`(x))) (6.2.4)
 

> fit[leastsquare[[x,y],y=a*x+b,{a,b}]]([data1,data2]);
 

y = `+`(1.295238095, `*`(.4485714286, `*`(x))) (6.2.5)
 

> plot(rhs(r),x=0..5);
 

Plot_2d
 

Proložení parabolou 

> r2:=fit[leastsquare[[x,y],y=a*x^2+b*x+c,{a,b,c}]]([data1,data2]);
 

y = `+`(`-`(`*`(0.5000000000e-1, `*`(`^`(x, 2)))), `*`(.6985714286, `*`(x)), 1.128571429) (6.2.6)
 

> plot(rhs(r2),x=0..5);
 

Plot_2d
 

Vykreslení do jednoho obrazku 

> g1:=plot(data,style=POINT):
 

> g2:=plot(rhs(r),x=0..5):
 

> g3:=plot(rhs(r2),x=0..5):
 

> with(plots):
 

> display(g1,g2,g3);
 

Plot_2d
 

Interpolace 

> data1;
 

[0, 1, 2, 3, 4, 5] (6.3.1)
 

> data2;
 

[1, 2, 2.3, 2.8, 2.9, 3.5] (6.3.2)
 

> y:=interp(data1,data2,x);
 

`+`(`*`(0.2500000000e-1, `*`(`^`(x, 5))), `-`(`*`(.3125000000, `*`(`^`(x, 4)))), `*`(1.400000000, `*`(`^`(x, 3))), `-`(`*`(2.737500000, `*`(`^`(x, 2)))), `*`(2.625000000, `*`(x)), 1)
`+`(`*`(0.2500000000e-1, `*`(`^`(x, 5))), `-`(`*`(.3125000000, `*`(`^`(x, 4)))), `*`(1.400000000, `*`(`^`(x, 3))), `-`(`*`(2.737500000, `*`(`^`(x, 2)))), `*`(2.625000000, `*`(x)), 1)
(6.3.3)
 

> plot(y,x=0..5);
 

Plot_2d
 

> g4:=plot(y,x=0..5):
 

> display(g1,g4);
 

Plot_2d
 

Rychlá Fourierova transformace 

Musíme zavolat balík programů DiskreteTransforms 

> with(DiscreteTransforms);
 

[DiscreteWaveletTransform, FourierTransform, InverseDiscreteWaveletTransform, InverseFourierTransform, WaveletCoefficients, WaveletPlot]
[DiscreteWaveletTransform, FourierTransform, InverseDiscreteWaveletTransform, InverseFourierTransform, WaveletCoefficients, WaveletPlot]
(6.4.1)
 

Vytvoření diskrétních dat 

> f:=i->sin(36*Pi*i/256);
 

proc (i) options operator, arrow; sin(`+`(`*`(`/`(9, 64), `*`(Pi, `*`(i))))) end proc (6.4.2)
 

> dt:=1./256;
 

0.3906250000e-2 (6.4.3)
 

> T:=1.0;
 

1.0 (6.4.4)
 

> data:=evalf(Vector(256,f));
 

data := Vector[column](%id = 4678005506) (6.4.5)
 

Vykraslení diskrétních dat 

> pdata:=[seq([(i-1)*dt,evalf(f(i))],i=1..256)]:
 

> plot(pdata);
 

Plot_2d
 

Rychlá Fourierova transformace 

> fdata:=FourierTransform(data);
 

fdata := Vector[column](%id = 4678005570) (6.4.6)
 

> dv:=1/T;
 

1.000000000 (6.4.7)
 

Vykreslení dat diskrétní Fourierovy transformace 

> pfdata:=[seq([dv*(i-1),abs(fdata[i])],i=1..256)]:
 

> plot(pfdata);
 

Plot_2d
 

> plot(pfdata,10..30);
 

Plot_2d
 

Puvodní data mají frekvenci 18 Hz. 

Numerická integrace 

> Int(x^x,x=0..1)=int(x^x,x=0..1);
 

Int(`^`(x, x), x = 0 .. 1) = int(`^`(x, x), x = 0 .. 1) (6.5.1)
 

Maple neumí vypočítat integrál analyticky, vypočteme ho pomocí numerické integrace 

> Int(x^x,x=0..1)=evalf(Int(x^x,x=0..1));
 

Int(`^`(x, x), x = 0 .. 1) = .7834305107 (6.5.2)
 

Použití různých metod. 

Počítáme s přesností 14 platných míst. 14 míst je přesnost počítače ne numerické metody 

> Int(x^x,x=0..1)=evalf[14](Int(x^x,x=0..1,method = _Gquad));
 

Int(`^`(x, x), x = 0 .. 1) = .78343051071213 (6.5.3)
 

> Int(x^x,x=0..1)=evalf[14](Int(x^x,x=0..1,method = _NCrule));
 

Int(`^`(x, x), x = 0 .. 1) = .78343051071214 (6.5.4)
 

> Int(x^x,x=0..1)=evalf[14](Int(x^x,x=0..1,method = _d01ajc));
 

Int(`^`(x, x), x = 0 .. 1) = .78343051071213 (6.5.5)
 

Zkusíme teď příklad, pro který umíme určit přesné řešení. 

Přesné řešení 

> Int(x^4,x=0..1)=int(x^4,x=0..2);
 

Int(`*`(`^`(x, 4)), x = 0 .. 1) = `/`(32, 5) (6.5.6)
 

> vp:=evalf[30](32/5);
 

6.40000000000000000000000000000 (6.5.7)
 

Numerické řešení 

> vn:=evalf[30](Int(x^4,x=0..2,method = _Gquad));
 

6.40000000000000000000000000000 (6.5.8)
 

> vn:=evalf[30](Int(x^4,x=0..2,method = _NCrule));
 

6.40000000000000000000000000000 (6.5.9)
 

Pokud Maple umí vypočítat přesné řešení, nikdy nepočíta numerické řešení (ať zvolíte jakoukoliv metodu) vždy vypočte přesné řešení a numericky ho vyjádří. 

> chyba:=vp-vn;
 

0. (6.5.10)
 

Numerická suma, součin 

Přesný výpočet sumy. 

> Sum(1/n^2,n=1..infinity)=sum(1/n^2,n=1..infinity);
 

Sum(`/`(1, `*`(`^`(n, 2))), n = 1 .. infinity) = `+`(`*`(`/`(1, 6), `*`(`^`(Pi, 2)))) (6.6.1)
 

Někdy  Maple neumí  přesný součet vypočítat. 

> Sum(1/(n^3+n!),n=1..infinity)=sum(1/(n^3+n!),n=1..infinity);
 

Sum(`/`(1, `*`(`+`(`*`(`^`(n, 3)), factorial(n)))), n = 1 .. infinity) = sum(`/`(1, `*`(`+`(`*`(`^`(n, 3)), factorial(n)))), n = 1 .. infinity) (6.6.2)
 

Přibližný výpočet sumy. 

> Sum(1/(n^3+n!),n=1..infinity)=evalf(sum(1/(n^3+n!),n=1..infinity));
 

Sum(`/`(1, `*`(`+`(`*`(`^`(n, 3)), factorial(n)))), n = 1 .. infinity) = .6470299890 (6.6.3)
 

Přesný výpočet součinu. 

> Product(1/n,n=1..10)=product(1/n,n=1..10);
 

Product(`/`(1, `*`(n)), n = 1 .. 10) = `/`(1, 3628800) (6.6.4)
 

Přibližné vvjádření výsledku. 

> Product(1/n,n=1..10)=evalf[30](product(1/n,n=1..10));
 

Product(`/`(1, `*`(n)), n = 1 .. 10) = 0.275573192239858906525573192240e-6 (6.6.5)
 

Numerické řešení polynomiálních rovnic 

> solve(x^7+x+1=0,x);
 

RootOf(`+`(`*`(`^`(_Z, 7)), _Z, 1), index = 1), RootOf(`+`(`*`(`^`(_Z, 7)), _Z, 1), index = 2), RootOf(`+`(`*`(`^`(_Z, 7)), _Z, 1), index = 3), RootOf(`+`(`*`(`^`(_Z, 7)), _Z, 1), index = 4), RootOf(`...
RootOf(`+`(`*`(`^`(_Z, 7)), _Z, 1), index = 1), RootOf(`+`(`*`(`^`(_Z, 7)), _Z, 1), index = 2), RootOf(`+`(`*`(`^`(_Z, 7)), _Z, 1), index = 3), RootOf(`+`(`*`(`^`(_Z, 7)), _Z, 1), index = 4), RootOf(`...
RootOf(`+`(`*`(`^`(_Z, 7)), _Z, 1), index = 1), RootOf(`+`(`*`(`^`(_Z, 7)), _Z, 1), index = 2), RootOf(`+`(`*`(`^`(_Z, 7)), _Z, 1), index = 3), RootOf(`+`(`*`(`^`(_Z, 7)), _Z, 1), index = 4), RootOf(`...
(6.7.1)
 

> evalf(solve(x^7+x+1=0,x));
 

`+`(HFloat(0.9798083844899015), `*`(HFloat(0.5166768838399122), `*`(I))), `+`(HFloat(0.12376188051147738), `*`(HFloat(1.0566500111970738), `*`(I))), `+`(`-`(HFloat(0.7052980879371503)), `*`(HFloat(0.6...
`+`(HFloat(0.9798083844899015), `*`(HFloat(0.5166768838399122), `*`(I))), `+`(HFloat(0.12376188051147738), `*`(HFloat(1.0566500111970738), `*`(I))), `+`(`-`(HFloat(0.7052980879371503)), `*`(HFloat(0.6...
`+`(HFloat(0.9798083844899015), `*`(HFloat(0.5166768838399122), `*`(I))), `+`(HFloat(0.12376188051147738), `*`(HFloat(1.0566500111970738), `*`(I))), `+`(`-`(HFloat(0.7052980879371503)), `*`(HFloat(0.6...
`+`(HFloat(0.9798083844899015), `*`(HFloat(0.5166768838399122), `*`(I))), `+`(HFloat(0.12376188051147738), `*`(HFloat(1.0566500111970738), `*`(I))), `+`(`-`(HFloat(0.7052980879371503)), `*`(HFloat(0.6...
(6.7.2)
 

Numerické řešení  rovnic iterační metodou 

Nutno zadat počáteční iteraci 

> fsolve(cos(x)=x,x=0);
 

.7390851332 (6.8.1)
 

Někdy má rovnice víc řešení 

> fsolve(3*sin(x)=x,x=0);
 

0. (6.8.2)
 

> fsolve(3*sin(x)=x,x=3);
 

2.278862660 (6.8.3)
 

> fsolve(3*sin(x)=x,x=-3);
 

-2.278862660 (6.8.4)
 

Numerické řešení  differenciálních rovnic  

Numericky řešíme pouze partikulární řešení 

Nejdříve analytické řešení a jeho graf 

> restart; 1
 

> r:=dsolve({diff(y(x),x)=y(x),y(0)=1},y(x));
 

y(x) = exp(x) (6.9.1)
 

> plot(rhs(r),x=0..2);
 

Plot_2d
 

Teď numerické řešení a jeho graf 

> rn:=dsolve({diff(y(x),x)=y(x),y(0)=1},y(x),numeric);
 

proc (x_rkf45) local _res, _dat, _vars, _solnproc, _xout, _ndsol, _pars, _n, _i; option `Copyright (c) 2000 by Waterloo Maple Inc. All rights reserved.`; if `<`(1, nargs) then error (6.9.2)
 

> with(plots); -1
 

> odeplot(rn, [x, y(x)], x = 0 .. 2); 1
 

Plot_2d
 

>
 

Příkaz odeplot nelze použít v Maple classic (při ukládání souboru Maple skončí chybou) 

Ukázka použití některých voleb (options). Volba rozsahu pro nezávisle proměnnou 

> rn := dsolve({y(0) = 1, diff(y(x), x) = y(x)}, y(x), numeric, range = 0 .. 10); 1
rn := dsolve({y(0) = 1, diff(y(x), x) = y(x)}, y(x), numeric, range = 0 .. 10); 1
 

proc (x_rkf45) local _res, _dat, _vars, _solnproc, _xout, _ndsol, _pars, _n, _i; option `Copyright (c) 2000 by Waterloo Maple Inc. All rights reserved.`; if `<`(1, nargs) then error (6.9.3)
 

> rn(9.5); 1
 

[x = 9.5, y(x) = HFloat(13359.704400562758)] (6.9.4)
 

Volba metody 

> rn := dsolve({y(0) = 1, diff(y(x), x) = `+`(`*`(160, `*`(y(x))))}, y(x), numeric, method = dverk78); 1
rn := dsolve({y(0) = 1, diff(y(x), x) = `+`(`*`(160, `*`(y(x))))}, y(x), numeric, method = dverk78); 1
 

proc (x_dverk78) local _res, _dat, _vars, _solnproc, _xout, _ndsol, _pars, _n, _i; option `Copyright (c) 2000 by Waterloo Maple Inc. All rights reserved.`; if `<`(1, nargs) then error (6.9.5)
 

> rn(0.2e-1); 1
 

[x = HFloat(0.02), y(x) = HFloat(24.532530196774943)] (6.9.6)
 

> rn(2.5); 1
 

Error, (in rn) cannot evaluate the solution past 0.72952958e-1, step size < hmin, problem may be singular or error tolerance may be too small
 

Změna minimálního kroku (lze jen u některých metod) 

> rn := dsolve({y(0) = 1, diff(y(x), x) = `+`(`*`(160, `*`(y(x))))}, y(x), numeric, method = dverk78, minstep = 0.1e-2); 1
rn := dsolve({y(0) = 1, diff(y(x), x) = `+`(`*`(160, `*`(y(x))))}, y(x), numeric, method = dverk78, minstep = 0.1e-2); 1
 

proc (x_dverk78) local _res, _dat, _vars, _solnproc, _xout, _ndsol, _pars, _n, _i; option `Copyright (c) 2000 by Waterloo Maple Inc. All rights reserved.`; if `<`(1, nargs) then error (6.9.7)
 

> rn(2.5); 1
 

[x = HFloat(2.5), y(x) = HFloat(5.221469679155235e173)] (6.9.8)
 

Porovnání numerické hodnoty a přesné hodnoty 

> r := dsolve({y(0) = 1, diff(y(x), x) = y(x)}, y(x)); 1
 

y(x) = exp(x) (6.9.9)
 

> v := evalf(subs(x = 4.5, rhs(r))); 1
 

90.01713130 (6.9.10)
 

> rn := dsolve({y(0) = 1, diff(y(x), x) = y(x)}, y(x), numeric); 1
 

proc (x_rkf45) local _res, _dat, _vars, _solnproc, _xout, _ndsol, _pars, _n, _i; option `Copyright (c) 2000 by Waterloo Maple Inc. All rights reserved.`; if `<`(1, nargs) then error (6.9.11)
 

> vn := rhs(rn(4.5)[2]); 1
 

HFloat(90.0170607315041) (6.9.12)
 

> chyba := `+`(v, `-`(vn)); 1
 

HFloat(7.056849590014735e-5) (6.9.13)
 

Numerické řešení soustavy diferenciálních rovnic, graf jednotlivých řešení 

> res := dsolve({x(0) = 1, y(0) = 1, diff(x(t), t) = `+`(x(t), `-`(`*`(`^`(y(t), 2)))), diff(y(t), t) = `*`(`^`(x(t), 2))}, {x(t), y(t)}, numeric); 1
res := dsolve({x(0) = 1, y(0) = 1, diff(x(t), t) = `+`(x(t), `-`(`*`(`^`(y(t), 2)))), diff(y(t), t) = `*`(`^`(x(t), 2))}, {x(t), y(t)}, numeric); 1
 

proc (x_rkf45) local _res, _dat, _vars, _solnproc, _xout, _ndsol, _pars, _n, _i; option `Copyright (c) 2000 by Waterloo Maple Inc. All rights reserved.`; if `<`(1, nargs) then error (6.9.14)
 

> odeplot(res, [t, x(t)], 0 .. 1); 1
 

Plot_2d
 

> odeplot(res, [t, y(t)], 0 .. 1); 1
 

Plot_2d
 

Graf jednotlivých řešení do jednoho grafu 

> odeplot(res, [[t, x(t)], [t, y(t)]], 0 .. 1); 1
 

Plot_2d
 

Zobrazení trajektorie 

> odeplot(res, [x(t), y(t)], 0 .. 1); 1
 

Plot_2d
 

Optimalizace, lineární programování 

> with(Optimization);
 

[ImportMPS, Interactive, LPSolve, LSSolve, Maximize, Minimize, NLPSolve, QPSolve] (6.10.1)
 

> Maximize(`+`(x, y), {`>=`(x, 0), `>=`(y, 0), `<=`(`+`(`*`(`^`(x, 2)), `*`(`^`(y, 2))), 1)}); 1
 

[1.41421356237468987, [x = HFloat(0.7071067811873449), y = HFloat(0.7071067811873449)]] (6.10.2)
 

> Minimize(`+`(x, y), {`>=`(x, 0), `>=`(y, 0), `<=`(`+`(`*`(`^`(x, 2)), `*`(`^`(y, 2))), 1)}); 1
 

[-0.444089209850062616e-15, [x = HFloat(-2.220446049250313e-16), y = HFloat(-2.220446049250313e-16)]] (6.10.3)
 

LPSolve minimizuje lineární finkci za určitých lineárních podmínek 

> LPSolve(`+`(`-`(`*`(4, `*`(x))), `-`(`*`(5, `*`(y)))), {`>=`(x, 0), `>=`(y, 0), `<=`(`+`(x, `*`(2, `*`(y))), 6), `<=`(`+`(`*`(5, `*`(x)), `*`(4, `*`(y))), 20)}); 1
 

[-19., [x = HFloat(2.6666666666666674), y = HFloat(1.6666666666666663)]] (6.10.4)
 

>