prednes7.html

Chyby a výhody Maple 9.52

7. přednáška                Mirko Navara & Aleš Němeček a další              26. dubna 2006

[Inserted Image]

Autorská práva:

Uživatel, tj. čtenář, může tento text používat pro svoje potřeby bez omezení. Distribuce a převod do tištěnné podoby pouze se svolením autorů. Text může mít více verzí, které vznikají tím, že autoři mohou text průběžně měnit a doplňovat.

Kontaktní adresy: navara@cmp.felk.cvut.cz     nemecek@math.feld.cvut.cz

Chyby

Než si budeme stěžovat...

Informaci o používané verzi získáme příkazem ...

> kernelopts(version);

`Maple 9.52, IBM INTEL NT, Dec 17 2004 Build ID 175529`

... resp. trochu "skrytou" formou výstupu.

> version();

User Interface: 163892
Kernel:         175529

Library:        163356

175529

Příkaz ...

> interface(version);

... se vztahuje pouze k instalaci (nezahrnuje upgrade). Podobně i údaj v Help -> About Maple ..., který ovšem poskytne i další informace o licenci ap.

`Standard Worksheet Interface, Maple 9.51, Windows XP, August 17 2004 Build ID 163892`

Na odstranění problémů jsou k jednotlivým verzím Maplu dodávány "záplaty" (patch); nakolik jsou uplatněny v použité instalaci se dozvíme příkazem

> interface(patchlevel);

0

Jinak se můžete obrátit na diskusní fórum http://www.maplesoft.com/support/discussion.html nebo vynadat přímo výrobci na http://maple.bug-list.org/. Zároveň nás informujte o chybách, abychom byli "v obraze".

>

Staronové "nepříjemnosti"

(v Maple 9.*, v jehož jádře nahradila Java původní C)

Velmi pomalý start programu oproti předchozím verzím.

Obrovský nárůst nároku na využití paměti. Nyní je např. téměř vyloučeno využít jednu instalaci Maple na serveru s terminálovým přístupem (typická učebna).

Na starších "počítadlech" problematická práce, pomalé výpočty.

Nestabilní interface - v předchzích verzích (Maple 6 - 8) se "zakousl" resp. "klekl" pouze výjimečně (nebo nikdy).

Příkaz display zobrazuje legendu i v případě, že je to potlačeno v Tools -> Options... -> Plotting - Display Legends a ani není uvedena v parametrech použitých příkazů plot (viz.4. přednáška, Grafika - Třídimenzionální).

Příkaz plot zobrazuje chybně českou diakritiku v popisu obrázků ( title, legend , ...).

Nezobrazují se správně hyperlinky po konverzi stylů - pomůže jejich editace volbou Edit -> Hyperlinks ..., stačí zvolený hyperlink otevřít pro editaci a pouze potvrdit OK bez jakékoliv úpravy.  Navíc se kolem hyperlinků chybně vkládají mezery při zobrazení a v tiskovém výstupu (zvláště před tečkou a čárkou).

Není možno (na rozdíl od předchozích verzí) definovat styl jedním základním řezem (fontem) písma a z něj pomocí nastavení velikostí, řezů ap. odvodit další pro titulek, nadpisy, ...

Vyhodnocování podmínek

Maple nevyhodnotí podmínky typu ...

> if 1 < Pi then true else false end if

> if sin(1) < ln(Float(29, -1)) then true else false end if

Error, cannot determine if this expression is true or false: 1 < Pi

Error, cannot determine if this expression is true or false: sin(1) < 1.064710737

... rychlou pomoc poskytne jedině evalf ...

> if evalf(1 < Pi) then true else false end if

> if evalf(sin(1) < ln(Float(29, -1))) then true else false end if

true

true

.. a pomalou, zato solidnější, is .

> if is(1 < Pi) then true else false end if

> if is(sin(1) < ln(Float(29, -1))) then true else false end if

true

true

>

Nevyhodnotitelné podmínky

O proměnné nic nic nevíme

> about(nic)

nic:
 nothing known about this object

> is(nic < 1000000)

false

Podmínka se vyhodnotila jako nesplněná, ačkoli měla zůstat nerozhodnutá (FAIL ). V Maple 6 to tak bylo! Nepomůže ani deklarace nic jako reálné proměnné.

> assume(nic, real)

> about(nic)

Originally nic, renamed nic~:
 is assumed to be: real

> is(nic < 1000000)

false

Co je menší než nic?

> is(-infinity <= nic)

true

> min(nic, -infinity)

-infinity

Co je menší než -infinity ? Viděli jsme, že nic to není, ale něco takového přece existuje.

> min(undefined, 0)

> min(undefined, -infinity)

undefined

undefined

Důvodem je, že jakýkoli výraz obsahující undefined výsledek undefined.

> max(undefined, infinity)

undefined

>

Po částech definované funkce (opraveno ve verzi 10.2)

Udělaly značný pokrok, přesto některé problémy zůstávají.

> ff:= x-> piecewise(x<0, -x, x):

Nepozná, že je to absolutní hodnota, a chová se k ní odlišně.

> is(ff(x)=abs(x));

FAIL

Jako výraz ji zderivuje správně, včetně nedefinované hodnoty v nule.

> diff(ff(x),x);

PIECEWISE([-1, x < 0], [undefined, x = 0], [1, 0 < x])

Pro srovnání derivace absolutní hodnoty.

> diff(abs(x),x);

abs(1, x)

To není moc názorné, je třeba vysvětlení, že to znamená poněkud speciální signum.

> ?abs

Zderivuje to i jako funkci.

> df:=D(ff);

df := proc (x) options operator, arrow; piecewise(x < 0, -1, x = 0, undefined, 0 < x, 1) end proc

> df(2), df(0);

1, undefined

Absolutní hodnotu zderivovat umí, opět po svém.

> D(abs);

proc (z) options operator, arrow; abs(1, z) end proc

Až potud vše správně.

Nyní definujeme tutéž funkci pomocí další funkce (identity).

> f1:= x-> x:

> ff:= x-> piecewise(x<0, -f1(x), f1(x)):

Jako výraz ji zderivuje správně.

> diff(ff(x),x);

PIECEWISE([-1, x < 0], [undefined, x = 0], [1, 0 < x])

Jako funkci ji zderivuje zcela špatně.

> df:=D(ff);

df := proc (x) options operator, arrow; FAIL end proc

Výsledkem je funkce, která dává vždy výsledek FAIL .

> df(2);

FAIL

>

Substituce ve funkcích

Substituce funguje pro výrazy, ale ne pro funkce:

> assume(b>=0);

> assume(0<p, p<1);

> f:=p->(p*ln(p)+(1-p)*ln(1-p))/(p+b);

f := proc (p) options operator, arrow; (p*ln(p)+(1-p)*ln(1-p))/(p+b) end proc

Zajímá nás speciální případ b = 0

> spec:=subs(b=0,D(f));

spec := proc (p) options operator, arrow; (ln(p)-ln(1-p))/(p+b)-(p*ln(p)+(1-p)*ln(1-p))/(p+b)^2 end proc

> spec:=eval(D(f),b=0);

spec := proc (p) options operator, arrow; (ln(p)-ln(1-p))/(p+b)-(p*ln(p)+(1-p)*ln(1-p))/(p+b)^2 end proc

Funguje jen pro výrazy:

> spec:=subs(b=0,D(f)(p));

spec := (ln(p)-ln(1-p))/p-(p*ln(p)+(1-p)*ln(1-p))/p^2

> spec:=eval(D(f)(p),b=0);

spec := (ln(p)-ln(1-p))/p-(p*ln(p)+(1-p)*ln(1-p))/p^2

Neurčité výrazy

Ačkoli argument nuly není definován, Maple jej uvádí.

> argument(0);

0

Mnohé nedostatky v neurčitých výrazech byly odstraněny, např. ...

> infinity-infinity

undefined

> infinity+infinity

infinity

> 0/infinity

0

... ale vyskytují se chybová hlášení i u výrazů, které jsou definovány.

> infinity/0

Error, numeric exception: division by zero

I nadále jsou uplatňována některá problematická pravidla.

> 0^0;

1

To se projeví v polynomu.

> pol := proc (t) options operator, arrow; sum(a[i]*t^i, i = 0 .. 3) end proc

pol := proc (t) options operator, arrow; sum(a[i]*t^i, i = 0 .. 3) end proc

Zdá se být vše v pořádku, ...

> expand(pol(t));

a[0]+a[1]*t+a[2]*t^2+a[3]*t^3

> pol(1);

a[0]+a[1]+a[2]+a[3]

... ale není.

> pol(0);

0

Správný výsledek.

> eval(pol(t),t=0);

a[0]

>

Předpoklady pro konvergenci řad

> sum(z^n, n = 0 .. infinity)

-1/(z-1)

Zde ignoruje podmínky konvergence. Výsledek je správný pouze pro abs(z) < 1 .

Ignoruje i některé podmínky, které konvergenci vylučují.

> assume(abs(z)>1);

> sum(z^n, n = 0 .. infinity)

-1/(z-1)

> assume(z>2);

> sum(z^n, n = 0 .. infinity)

infinity

To je správně, ale ...

> assume(z<-2);

> sum(z^n, n = 0 .. infinity)

-1/(z-1)

... už je horší.

Pro konkrétní hodnoty pracuje správně, ...

> z:=5:

> sum(z^n, n = 0 .. infinity)

infinity

... ale co si myslet o této alibistické odpovědi (novinka v Maple 9):

> z:=-5:

> sum(z^n, n = 0 .. infinity)

sum((-5)^n, n = 0 .. infinity)

> z:='z':

Neupravitelné výrazy

Známý vzorec umí za spolupráce s uživatelem uplatnit pro konkrétní hodnotu exponentu, ...

> (cosh(x)+sinh(x))^12

> simplify(%);

-5120*sinh(x)*cosh(x)^9+2048*cosh(x)^11*sinh(x)+280*sinh(x)*cosh(x)^3-12*sinh(x)*cosh(x)+4608*sinh(x)*cosh(x)^7-1792*sinh(x)*cosh(x)^5+6912*cosh(x)^8+2048*cosh(x)^12+840*cosh(x)^4-6144*cosh(x)^10+1-35...-5120*sinh(x)*cosh(x)^9+2048*cosh(x)^11*sinh(x)+280*sinh(x)*cosh(x)^3-12*sinh(x)*cosh(x)+4608*sinh(x)*cosh(x)^7-1792*sinh(x)*cosh(x)^5+6912*cosh(x)^8+2048*cosh(x)^12+840*cosh(x)^4-6144*cosh(x)^10+1-35...

> combine(%);

sinh(12*x)+cosh(12*x)

... nezvládne to však obecně ani s příslušnými předpoklady.

> assume(n, posint);

> about(n);

Originally n, renamed n~:
 is assumed to be: AndProp(integer,RealRange(1,infinity))

> (cosh(x)+sinh(x))^n

> simplify(%);

(cosh(x)+sinh(x))^n

> combine(%);

(cosh(x)+sinh(x))^n

> n:='n':

Neprovede úpravy některých výrazů s jednoduchým výsledkem (nepomůžou ani jiné příkazy).

> vyr := sin(Pi/7)^2/(sin(2*Pi/7)^4)+sin(3*Pi/7)^2/(sin(Pi/7)^4)+sin(2*Pi/7)^2/(sin(3*Pi/7)^4)

> simplify(vyr, sqrt)

(sin(1/7*Pi)^6*sin(3/7*Pi)^4+sin(3/7*Pi)^6*sin(2/7*Pi)^4+sin(2/7*Pi)^6*sin(1/7*Pi)^4)/(sin(2/7*Pi)^4*sin(1/7*Pi)^4*sin(3/7*Pi)^4)

Přitom z funkce evalf  je zřejmý výsledek.

> evalf(vyr, 50);

28.000000000000000000000000000000000000000000000002

Pro ověrení lze použít výkonnější nástroje, ale to musíme znát výsledek.

> is(vyr=28), verify(vyr,28,equal);

true, true

>

Problém s komplexními čísly

> vyr:=ln(exp(10*I));

vyr := ln(exp(10*I))

Vyhodnotíme v komplexním oboru.

> evalc(vyr);

I*(10-4*Pi)

Nečekané, ale vzhledem k periodě 2*Pi*I  přijatelné.

> convert(vyr, trig);

ln(cos(10)+I*sin(10))

> evalc(%);

1/2*ln(cos(10)^2+sin(10)^2)+I*(10-4*Pi)

To je pravda, ale hodně maskovaná! Argument logaritmu je 1, reálná část je nulová.

> simplify(%);

-2*I*(-5+2*Pi)

>

Chyby funkce plot

>

Jsou stálým zdrojem problémů.

Nezpracuje velké hodnoty y (všimněte si měřítek os), ...

> plot(1e400*sin, -5..5, axes=FRAMED);

[Plot]

...ač s takovými čísly (i většími) umí počítat.

> 1e400*sin(-5.),

> exp(110000.);

0.9589242747e400, 0.2471777404e47773

Ne vždy však pomocí hardwarové aritmetiky.

> evalhf(1e400*sin(-5.));

Float(infinity)

> evalhf(exp(110.)), evalhf(exp(1100.));

0.592097202766467075e48, Float(infinity)

Nevyhovující měřítko na ose  y (lze samozřejmě odstranit přidáním dalšího parametru y = -10 .. 10 ).

> plot(tan(x), x=-5..5, discont=true);

Trable s nekonečnem, ...

> f := proc (x) options operator, arrow; x-exp(x/1000) end proc

> g := proc (x) options operator, arrow; 2*x-exp(x/1000) end proc

> plot(f, -infinity..infinity);

[Plot]

> plot(g, -infinity..infinity);

[Plot]

... přestože limitu zvládne.

> limit(g(x), x=infinity);

-infinity

> vyr := (x+2)/(3*x-1)

> plot(vyr, x=-infinity..-2, 0..1);

[Plot]

Nezobrazuje některé meze (někdy pomůže zvětšení obrázku). Nelze definovat rozměr obrázků prametrem ani společným nastavením v Tools -> Options..., přetrvávají problémy se zobrazením popisů a legendy při tisku (vlivem nastavování velikosti obrázků).

Ukázka jednoho zajímavého vykreslení funkce cosinus.

> plot(cos(x^(3/2)), x=-2..8);

[Plot]

To je ale překvapení, neomezený cosinus v reálném oboru!

Při umocňování nezáleží na pořadí, ...

> plot(cos((x^3)^(1/2)), x=-2..8);

[Plot]

> plot(cos((x^(1/2))^3), x=-2..8);

[Plot]

... ani na zadání odmocniny pomocí funkce surd, protože číselné mocniny a odmocniny se stejně automaticky zjednodušší.

> plot(cos(surd(x,2)^3), x=-2..8);

[Plot]

Pro sudé hodnoty čitatele je samozřejmě v pohodě, ...

> plot([cos(x^(4/2)), cos(x^(6/2))], x=-2..3);

[Plot]

... stejně jako pro libovolnou změnu jmenovatele (omezí se x >= 0).

> plot([cos(x^(4/3)), cos(x^(2/5))], x=-2..8);

[Plot]

> plot(sin(z), z= 10^20..infinity);

[Plot]

> #plot(Int(signum(sinh(ln(1 - 1/z^a))), z= 0..1), a= 0..1);

Warning,  computation interrupted

Víceznačné funkce

> solve(x = I^(1/3))

(-1)^(1/6)

> allvalues(%);

(-1)^(1/6)

> simplify(%);

1/2*3^(1/2)+1/2*I

Správně má být:

> solve(x^3 = I)

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

Nepomůže ani definování obecné odmocniny příkazem surd , pouze se změní zápis výsledku.

> solve(x=surd(I, 3));

-1/2*(-1)^(1/6)+1/2*(-1)^(2/3)*3^(1/2)

> allvalues(%);

-1/2*(-1)^(1/6)+1/2*(-1)^(2/3)*3^(1/2)

> simplify(%);

1/2*I-1/2*3^(1/2)

>

Chybějící řešení rovnic

Nenachází některá řešení.

> solve(sin^3(x)*ln(x) = 0)

1

Chybí řešení rovnice sin(x) = 0 .

> solve(sin(x)^3/x = 0)

Nenachází žádné řešení.

> solve(sin(3*x)*cos(x) = 0)

1/2*Pi, Pi, 0, 1/3*Pi, -1/3*Pi, 2/3*Pi, -2/3*Pi

Chybí -Pi/2 .

Náprava: Změnou proměnné prostředí dostaneme všechna řešení (lze najít v nápovědě příkazu solve - popis a příklady použití).

> _EnvAllSolutions := true:

Takže ještě jednou.

> solve(sin^3(x)*ln(x) = 0)

1, Pi*(2*_Z2+_B1)

Druhý výsledek obsahuje "tajemné" proměnné,

> indets(%[2]);

{_B1, _Z2}

... teď se konečně dovíme, co jsme dostali.

> about(%);

{_B1, _Z2}:
 is used in the following assumed objects

 [_B1] assumed OrProp(0,1)

 [_Z2] assumed integer

To je skoro pravda, ale zakuklená: jednička a všechny násobky pi ; navíc 0 není řešením.

> solve(sin(x)^3/x = 0)

Pi*(2*_Z3+_B2)

(totéž)

> solve(sin(3*x)*cos(x) = 0)

1/2*Pi+Pi*_Z4, Pi+2*Pi*_Z5, 2*Pi*_Z6, 1/3*Pi+2*Pi*_Z7, -1/3*Pi+2*Pi*_Z7, 2/3*Pi+2*Pi*_Z8, -2/3*Pi+2*Pi*_Z8

Z posloupnosti musíme vytvořit seznam, a ten zpracovat po složkách.

> about(indets([%]));

{_Z6, _Z4, _Z8, _Z5, _Z7}:
 is used in the following assumed objects

 [_Z4] assumed integer

 [_Z6] assumed integer

 [_Z8] assumed integer

 [_Z5] assumed integer

 [_Z7] assumed integer

Konečně kompletní řešení, i když se dá zjednodušit.

> _EnvAllSolutions := false:

Fiktivní řešení rovnic

Kvůli krácení nalézá neexistující řešení.

> solve((x-2)^2/(x^2-4) = 0)

2

V tomto případě pomůže kontrola (všimněte si, jak se zobrazuje funkce eval v grafickém vstupu - Standard Math notation).

> eval((x-2)^2/(x^2-4), x = 2)

Error, numeric exception: division by zero

Někdy ani kontrola nepomůže, ...

> verify(solve((x-2)^2/(x^2-4) = 0), 2, equal)

> verify(solve((x-2)*(x+3)/((x-2)*(x+1)) = 5/3), 2, equal)

true

true

... jindy ignoruje předpoklady.

> assume(e>0);

> about(e);

Originally e, renamed e~:
 is assumed to be: RealRange(Open(0),infinity)

> solve({18 < 2*e^2})

{e < -3}, {3 < e}

Ignoruje také pozitivitu e.

> solve(18 < 2*e^2)

RealRange(-infinity, Open(-3)), RealRange(Open(3), infinity)

To je stejně chybný výsledek v méně srozumitelném tvaru.

Správný výsledek dostaneme, až když podmínku výslovně zopakujeme přímo v příkazu.

> solve({18 < 2*e^2, 0 < e})

{3 < e}

>

Řešení soustav rovnic

Tuto soustavu řeší Maple zdánlivě velmi efektivně.

> eq1 := x^2*y+3*y*z-4 = 0

> eq2 := -3*x^2*z+2*y^2+1 = 0

> eq3 := 2*y*z^2-z^2-1 = 0

Symbolická řešení ...

> symb := [solve({eq || (1 .. 3)}, {x, y, z})]

symb := [{z = 1, x = 1, y = 1}, {z = 1, y = 1, x = -1}, {z = RootOf(3*_Z^2-2*_Z+1), x = RootOf(_Z^2+2-3*RootOf(3*_Z^2-2*_Z+1)), y = 1-3*RootOf(3*_Z^2-2*_Z+1)}, {z = RootOf(6*_Z^5-6*_Z^4-9*_Z^3-7*_Z^2-...symb := [{z = 1, x = 1, y = 1}, {z = 1, y = 1, x = -1}, {z = RootOf(3*_Z^2-2*_Z+1), x = RootOf(_Z^2+2-3*RootOf(3*_Z^2-2*_Z+1)), y = 1-3*RootOf(3*_Z^2-2*_Z+1)}, {z = RootOf(6*_Z^5-6*_Z^4-9*_Z^3-7*_Z^2-...symb := [{z = 1, x = 1, y = 1}, {z = 1, y = 1, x = -1}, {z = RootOf(3*_Z^2-2*_Z+1), x = RootOf(_Z^2+2-3*RootOf(3*_Z^2-2*_Z+1)), y = 1-3*RootOf(3*_Z^2-2*_Z+1)}, {z = RootOf(6*_Z^5-6*_Z^4-9*_Z^3-7*_Z^2-...symb := [{z = 1, x = 1, y = 1}, {z = 1, y = 1, x = -1}, {z = RootOf(3*_Z^2-2*_Z+1), x = RootOf(_Z^2+2-3*RootOf(3*_Z^2-2*_Z+1)), y = 1-3*RootOf(3*_Z^2-2*_Z+1)}, {z = RootOf(6*_Z^5-6*_Z^4-9*_Z^3-7*_Z^2-...

... jsou správná.

> simplify(map(subs, symb, {eq || (1 .. 3)}));

[{0 = 0}, {0 = 0}, {0 = 0}, {0 = 0}]

Jejich číselné hodnoty.

> num := evalf(symb)

num := [{z = 1., x = 1., y = 1.}, {z = 1., y = 1., x = -1.}, {y = 0.1e-9-1.414213562*I, z = .3333333333+.4714045208*I, x = .6050003336+1.168770894*I}, {z = 2.065544037, x = .5332208267, y = .61719292}...

(Samozřejmě, že výsledek je zatížen numerickými chybami.)
Nicméně změnou znaménka u  
x (které se vyskytuje pouze ve druhé mocnině) v posledních dvou řešeních dostáváme další dvě řešení, která nebyla nalezena!
Ještě pozoruhodnější je, že až do
Maple V Release 3 tato řešení našel!!!

>

Řešení diferenciálních rovnic

Za předpokladu ...

> assume(coef <> 0)

... má diferenciální rovnice harmonického pohybu ...

> eq := {(diff(y(x), x, x))+coef^2*y(x) = 0, y(0) = 0, D(y)(1) = 0}

... řešení  y(x) = A*sin([pi/2+n*pi]*x) , kde  n  je libovolné celé číslo. Maple nachází pouze triviální řešení.

> dsolve(eq, y(x))

y(x) = 0

>

Co se stane, když zapomeneme vyznačit násobení

Zapomeneme-li vyznačit násobení `*`, může vzniknout syntakticky správný výraz, jehož první část se chápe jako funkce (např. konstantní).

> 7p;

Error, missing operator or `;`

V předchozím nás syntaktický analyzátor upozornil, ale pozor.

> v1:=7(p-1);     # chyba při zápisu

v1 := 7

U složitého výrazu snadno přehlédneme, že v čitateli něco chybí.

> v2:=5(p-1)/(p^2-2*p+2);      # chyba při zápisu

v2 := 5/(p^2-2*p+2)

> v3:=p(p-1);

v3 := p(p-1)

Aspoň pro v1, v2 to krásně počítá, by nesmysly (v prvním případě náhodou správné).

> subs(p=2,[v1,v2,v3]),
subs(p=4,[v1,v2,v3]);

[7, 5/2, 2(1)], [7, 1/2, 4(3)]

Mělo to být, ...

> w1:=7*(p-1);

> w2:=5*(p-1)/(p^2-2*p+2);

w1 := 7*p-7

w2 := 5*(p-1)/(p^2-2*p+2)

... to ale počítá trochu jinak.

> subs(p=2,[w1,w2]),
subs(p=4,[w1,w2]);

[7, 5/2], [21, 3/2]

Jak to dopadlo, je vidět z obrázku.

> plot([v1, v2, w1, w2], p=-2..2, color=[red, blue, green, yellow], legend=["v1", "v2", "w1", "w2"]);

[Plot]

>

Pracuje Maple deterministicky?

Následující příklad produkuje různé výsledky, proto napřed "uklidíme".

> restart;

> with(linalg):

Warning, the protected names norm and trace have been redefined and unprotected

Definujme Hilbertovu matici řádu n := 9 .

> H:=hilbert(n):

> eval(H);

matrix([[1, 1/2, 1/3, 1/4, 1/5, 1/6, 1/7, 1/8, 1/9], [1/2, 1/3, 1/4, 1/5, 1/6, 1/7, 1/8, 1/9, 1/10], [1/3, 1/4, 1/5, 1/6, 1/7, 1/8, 1/9, 1/10, 1/11], [1/4, 1/5, 1/6, 1/7, 1/8, 1/9, 1/10, 1/11, 1/12], ...

Převedeme ji na matici čísel typu real.

> G:=map(evalf, H):

> evalm(G);

matrix([[1., .5000000000, .3333333333, .2500000000, .2000000000, .1666666667, .1428571429, .1250000000, .1111111111], [.5000000000, .3333333333, .2500000000, .2000000000, .1666666667, .1428571429, .12...

Definujeme vektor pravých stran.

> s:=vector(n):

> for i to n do s[i]:=1 od: i:='i': n:='n':

> eval(s);

vector([1, 1, 1, 1, 1, 1, 1, 1, 1])

Řešení soustavy Gx = s standardním způsobem vychází pokaždé jinak.

> x1:=linsolve(G, s);

x1 := vector([-41.17310, 2749.9235, -45013.0942, 310374.4945, -1097946.054, 2158517.403, -2382608.186, 1380565.037, -326553.9192])

> x1:=linsolve(G, s);

x1 := vector([-3.98032, 180.71433, -1454.34872, -1150.86075, 46747.38280, -182629.2194, 310171.8702, -248157.3262, 76367.2187])

> x1:=linsolve(G, s);

x1 := vector([-33.35597, 2167.1222, -34668.0694, 234127.0509, -811848.1613, 1564422.080, -1691440.582, 958821.5511, -221495.8575])

> x1:=linsolve(G, s);

x1 := vector([-97.1812, 6558.4409, -108977.2014, 765064.244, -2761822.108, 5551638.708, -6277154.331, 3732491.610, -907696.628])

Kontrola.

> multiply(G, x1);

vector([1.0000, 1.00000, 1.00003, 1.00014, 1.00006, 1.00007, 1.00006, 1.00015, .99991])

Je to způsobené mj. tím, že se počítá na hranici deseti platných cifer; projeví se zaokrouhlovací chyby a špatná podmíněnost. Pokud zvětšíme Digits , problém se posune na Hilbertovy matice vyšších řádů.

>

Nový balíček (od verze Maple 6) pro lineární algebru to zvládne lépe.

> with(LinearAlgebra, LinearSolve, Transpose):

Nejprve musíme konvertovat do požadovaných typů.

> MG:=convert(G, Matrix):
MH:=convert(H, Matrix):

Vs:= convert(s, Vector):

Vychází pokaždé stejně, ...

> res:=LinearSolve(MG, Vs);

res := Vector[row]([11.2147171530147034, -866.823795874404140, 16274.3280791656525, -127748.942986787588, 511310.233908490394, -1131659.90110594640, 1400636.04390630149, -907132.085831661476, 239258.1...res := Vector[row]([11.2147171530147034, -866.823795874404140, 16274.3280791656525, -127748.942986787588, 511310.233908490394, -1131659.90110594640, 1400636.04390630149, -907132.085831661476, 239258.1...

> res:=LinearSolve(MG, Vs);

res := Vector[row]([11.2147171530147034, -866.823795874404140, 16274.3280791656525, -127748.942986787588, 511310.233908490394, -1131659.90110594640, 1400636.04390630149, -907132.085831661476, 239258.1...res := Vector[row]([11.2147171530147034, -866.823795874404140, 16274.3280791656525, -127748.942986787588, 511310.233908490394, -1131659.90110594640, 1400636.04390630149, -907132.085831661476, 239258.1...

... ale stejně ne přesně; správně mělo vyjít ...

> pres:=LinearSolve(MH, Vs):
Transpose(pres);

Vector[row]([9, -720, 13860, -110880, 450450, -1009008, 1261260, -823680, 218790])

... ovšem je to v rámci dané přesnosti.

> resT:=LinearAlgebra[Transpose](res):

> Transpose(MG . resT);

Vector[row]([1.00000000000363798, .99999999999636202, .99999999998908606, .99999999999272404, .99999999998544808, .99999999999272404, 1.00000000000363798, 1.00000000000727596, 1.00000000000545696])Vector[row]([1.00000000000363798, .99999999999636202, .99999999998908606, .99999999999272404, .99999999998544808, .99999999999272404, 1.00000000000363798, 1.00000000000727596, 1.00000000000545696])

Přesně znamená přesně.

> Transpose(MH . pres);

Vector[row]([1, 1, 1, 1, 1, 1, 1, 1, 1])

>

Chyby v derivaci

Fiktivní derivace

Funkce definovaná v jediném bodě nemá derivaci.

Maple ji přesto vypočítá.

> assume(x = 0)

> diff(abs(x), x)

0

> x:='x':

>

Chybná derivace (opraveno ve verzi 10.2)

Motivation: The derivative of the diagonal of the 3rd Schweizer t-norm.

> assume(lambda>1);

> dg := proc (x) options operator, arrow; -exp(-(-ln(-1+1/((1-(1-x)^lambda)^2))-2*ln(1-(1-x)^lambda))/lambda)+1 end proc

> limit(D(dg)(x), x = 1, left)

0

Správný výsledek je   2^(1/lambda) .

Původní funkci lze zjednodušit, ...

> diag2 := unapply(1-(2*(1-x)^lambda-(1-x)^(2*lambda))^(1/lambda), x)

> limit(D(diag2)(x), x = 1, left)

exp(ln(2)/lambda)

... což je správně, ...

> simplify(%-2^(1/lambda))

0

... is nám to potvrdí.

> is(%%=2^(1/lambda));

true

>

Tutor nezná nekonečno

V Mapletu pro výpočet limity nelze zadat bod nekonečno, ...

> with(Student[Calculus1],[LimitTutor]);

[LimitTutor]

> LimitTutor(sin(x), infinity);

Error, (in Student:-Calculus1:-LimitTutor) expecting a variable and/or a point as the second argument

... přestože s ním jinak Maple samozřejmě běžně počítá.

> Limit(sin(1/x), x=infinity): %=value(%);

Limit(sin(1/x), x = infinity) = 0

> Limit(sin(x), x=infinity): %=value(%);

Limit(sin(x), x = infinity) = -1 .. 1

> Limit(1/sin(x), x=infinity): %=value(%);

Limit(1/sin(x), x = infinity) = undefined

>

Překvapivá zaokrouhlovací chyba

Binomické rozdělení binomiald[5,1/2] vyhodnotíme v 0.

> p1 := binomial(5, 0)/(2^5)

p1 := 1/32

Nebo s použitím statistické knihovny.

> p2 := stats[statevalf, pf, binomiald[5, 1/2]](0)

p2 := 0.3125000000e-1

Číselné vyhodnocení dá ...

> evalf(2^5*p1, 3)

1.

> evalf(2^5*p2, 3)

.998

... ačkoli vstupy byly přesné a správný výsledek je 1.

>

Ukázky efektivnosti Maplu

Hledání extrémů funkcí

... umožňují funkce maximize a minimize , které si od verze Maple 6 konečně poradí i s výrazy, ve kterých je absolutní hodnota.

> maximize(abs(sin(x)), x=-1..0.5);      # od Maple 6 má novou notaci a funguje

sin(1)

V Maple 8 se navíc objevují další příkazy ( CriticalPoints , ExtremePoints , InflectionPoints ) v balíčku Calculus1 .

>

Faktorizace

... probíhá velmi efektivně.

> fs := proc (k) options operator, arrow; sort(factor(sum(i^k, i = 1 .. n))) end proc

Tyto vzorečky máte znát, ...

> fs(1); fs(2); fs(3)

1/2*(n+1)*n

1/6*(n+1)*(2*n+1)*n

1/4*(n+1)^2*n^2

... tyto si již pamatovat nemusíte.

> fs(30)

1/14322*(n+1)*(2*n+1)*(231*n^28+3234*n^27+12936*n^26-21021*n^25-217217*n^24+336336*n^23+3653650*n^22-5648643*n^21-54097043*n^20+83969886*n^19+677256580*n^18-1057869813*n^17-7003032113*n^16+11033483076...1/14322*(n+1)*(2*n+1)*(231*n^28+3234*n^27+12936*n^26-21021*n^25-217217*n^24+336336*n^23+3653650*n^22-5648643*n^21-54097043*n^20+83969886*n^19+677256580*n^18-1057869813*n^17-7003032113*n^16+11033483076...1/14322*(n+1)*(2*n+1)*(231*n^28+3234*n^27+12936*n^26-21021*n^25-217217*n^24+336336*n^23+3653650*n^22-5648643*n^21-54097043*n^20+83969886*n^19+677256580*n^18-1057869813*n^17-7003032113*n^16+11033483076...

> fs(50)

(výsledek pro úsporu papíru vynechán)

Polynomy bez reálných kořenů, ...

> pol := x^4-3*x^2+1; pol = factor(pol)

x^4-3*x^2+1 = (x^2-x-1)*(x^2+x-1)

... lze symbolicky rozložit i na součin prvočinitelů odpovídajících komplexním kořenům. Napřed si je pojmenujeme, ...

> alias(koren = RootOf(z^2-z-1))

... pak použijeme.

> pol = factor(pol, koren)

x^4-3*x^2+1 = (-x+koren)*(x-1+koren)*(-x-1+koren)*(x+koren)

>

Zjednodušování výrazů s odmocninami

Dokonce i automatické zjednodušování provádí netriviální úpravy.

> sqrt(14+3*sqrt(3+2*sqrt(5-12*sqrt(3-2*sqrt(2)))))

3+2^(1/2)

Knihovní funkce radnormal upravuje ještě složitější výrazy.

> expr := sqrt(6-2*sqrt(2)-2*sqrt(3)+2*sqrt(6))

> radnormal(expr)

-1+2^(1/2)+3^(1/2)

>

Po částech definované funkce

> f:=spline([$-3..1], [0$3,1,0], x, 3);

f := PIECEWISE([-18/7-39/14*x-27/28*x^2-3/28*x^3, x < -2], [18/7+69/14*x+81/28*x^2+15/28*x^3, x < -1], [1+3/14*x-51/28*x^2-29/28*x^3, x < 0], [1+3/14*x-51/28*x^2+17/28*x^3, otherwise])

> diff(f, x);

PIECEWISE([-39/14-27/14*x-9/28*x^2, x <= -2], [69/14+81/14*x+45/28*x^2, x <= -1], [3/14-51/14*x-87/28*x^2, x <= 0], [3/14-51/14*x+51/28*x^2, 0 < x])

Zvládne i jako funkci.

> D(unapply(f, x));

proc (x) options operator, arrow; piecewise(x <= -2, -39/14-27/14*x-9/28*x^2, x <= -1, 69/14+81/14*x+45/28*x^2, x <= 0, 3/14-51/14*x-87/28*x^2, 0 < x, 3/14-51/14*x+51/28*x^2) end proc

>

Nekonečné součty, derivace, integrály

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

1/90*Pi^4

Funkce ...

> f := proc (x) options operator, arrow; x^10*cos(x^5*ln(x)) end proc

... je reálná pouze za následujícího předpokladu.

> assume(x>0);

Její derivace pak je

> diff(f(x), x);

10*x^9*cos(x^5*ln(x))-x^10*sin(x^5*ln(x))*(5*x^4*ln(x)+x^4)

Integrací výsledku bychom měli dostat totéž, ...

> int(%, x);

1/2*x^10*x^(I*x^5)+1/2*x^10/x^(I*x^5)

... což však vyžaduje úpravu.

> evalc(%);

1/2*x^10*cos(x^5*ln(x))+1/2*x^10*cos(x^5*ln(x))/(cos(x^5*ln(x))^2+sin(x^5*ln(x))^2)+I*(1/2*x^10*sin(x^5*ln(x))-1/2*x^10*sin(x^5*ln(x))/(cos(x^5*ln(x))^2+sin(x^5*ln(x))^2))

> simplify(%);

x^10*cos(x^5*ln(x))

Odstraníme předpoklad pro x.

> x:='x':

Maple dovede symbolicky vypočítat i značně složité integrály, např. následující cvičení na integraci per partes.

> start:=time():

> int((sin(x))^2000, x):

> (time()-start)*sekund;

98.441*sekund

(výsledek pro úsporu papíru vynechán)

Můžeme také využít, že procedura obsahuje options=remember a mocninu postupně zvyšovat s využitím znalosti předchozích výsledků.

Přesto před další prací raději uvolníme pamě.

> restart;

Integrál závislý na parametrech

Předpoklad ...

> assume(a < b)

... je nutný pro korektnost definice následujícího integrálu.

> func := proc (x) options operator, arrow; 1/(a+b*cos(x)) end proc

> int(func(x), x)

2*arctanh((-a+b)*tan(1/2*x)/((a+b)*(-a+b))^(1/2))/((a+b)*(-a+b))^(1/2)

Výsledek lze ověřit zderivováním ...

> zpet:=diff(%,x);

zpet := 2*(1/2+1/2*tan(1/2*x)^2)/((a+b)*(1-(-a+b)*tan(1/2*x)^2/(a+b)))

... a zjednodušením.

> simplify(func(x)-zpet);

0

Zde nikoli funkcí verify .

> verify(func(x),zpet,equal);

FAIL

>

Nevlastní integrály

> int(1/(x^2), x = -1 .. 1)

infinity

> int(1/sqrt(x), x = 0 .. 1)

2

> int(1/x, x = -1 .. 2)

undefined

Poslední integral zůstává nedefinovaný, nebo nekonverguje. Nicméně konverguje ve smyslu Cauchyho hlavní hodnoty, a tu můžeme vypočítat.

> int(1/x, x=-1..2, CauchyPrincipalValue);

ln(2)

>

Diferenciální rovnice

... a to i nelineární a včetně integračních konstant.

> (diff(y(x), x, x))+y(x)*(diff(y(x), x))^3 = 0

> dsolve(%, y(x));

y(x) = _C1, y(x) = (3*x+3*_C2+(8*_C1^3+9*x^2+18*x*_C2+9*_C2^2)^(1/2))^(1/3)-2*_C1/(3*x+3*_C2+(8*_C1^3+9*x^2+18*x*_C2+9*_C2^2)^(1/2))^(1/3), y(x) = -1/2*(3*x+3*_C2+(8*_C1^3+9*x^2+18*x*_C2+9*_C2^2)^(1/2...y(x) = _C1, y(x) = (3*x+3*_C2+(8*_C1^3+9*x^2+18*x*_C2+9*_C2^2)^(1/2))^(1/3)-2*_C1/(3*x+3*_C2+(8*_C1^3+9*x^2+18*x*_C2+9*_C2^2)^(1/2))^(1/3), y(x) = -1/2*(3*x+3*_C2+(8*_C1^3+9*x^2+18*x*_C2+9*_C2^2)^(1/2...y(x) = _C1, y(x) = (3*x+3*_C2+(8*_C1^3+9*x^2+18*x*_C2+9*_C2^2)^(1/2))^(1/3)-2*_C1/(3*x+3*_C2+(8*_C1^3+9*x^2+18*x*_C2+9*_C2^2)^(1/2))^(1/3), y(x) = -1/2*(3*x+3*_C2+(8*_C1^3+9*x^2+18*x*_C2+9*_C2^2)^(1/2...y(x) = _C1, y(x) = (3*x+3*_C2+(8*_C1^3+9*x^2+18*x*_C2+9*_C2^2)^(1/2))^(1/3)-2*_C1/(3*x+3*_C2+(8*_C1^3+9*x^2+18*x*_C2+9*_C2^2)^(1/2))^(1/3), y(x) = -1/2*(3*x+3*_C2+(8*_C1^3+9*x^2+18*x*_C2+9*_C2^2)^(1/2...

Ještě příklad s funkcí definovanou po částech - tlumený oscilátor buzený harmonickým signálem.

> c:=1/20;

> buzeni:=t->piecewise(t<6*Pi,c*sin(t),0);

c := 1/20

buzeni := proc (t) options operator, arrow; piecewise(t < 6*Pi, c*sin(t), 0) end proc

> plot(buzeni, 0..30, axes=boxed);

[Plot]

> rovnice:=diff(y(x),x,x)+c*diff(y(x),x)+y(x)=buzeni(x);

rovnice := (diff(y(x), `$`(x, 2)))+1/20*(diff(y(x), x))+y(x) = PIECEWISE([1/20*sin(x), x < 6*Pi], [0, otherwise])

> dsolve({rovnice, y(0)=0, D(y)(0)=0}, y(x));

y(x) = PIECEWISE([1/1599*exp(-1/40*x)*sin(1/40*1599^(1/2)*x)*1599^(1/2)+exp(-1/40*x)*cos(1/40*1599^(1/2)*x)-cos(x), x < 6*Pi], [1/1599*exp(-1/40*x)*sin(1/40*1599^(1/2)*x)*1599^(1/2)+exp(-1/40*x)*cos(1...y(x) = PIECEWISE([1/1599*exp(-1/40*x)*sin(1/40*1599^(1/2)*x)*1599^(1/2)+exp(-1/40*x)*cos(1/40*1599^(1/2)*x)-cos(x), x < 6*Pi], [1/1599*exp(-1/40*x)*sin(1/40*1599^(1/2)*x)*1599^(1/2)+exp(-1/40*x)*cos(1...

Výsledek.

> res:=op(2,%);

res := PIECEWISE([1/1599*exp(-1/40*x)*sin(1/40*1599^(1/2)*x)*1599^(1/2)+exp(-1/40*x)*cos(1/40*1599^(1/2)*x)-cos(x), x < 6*Pi], [1/1599*exp(-1/40*x)*sin(1/40*1599^(1/2)*x)*1599^(1/2)+exp(-1/40*x)*cos(1...res := PIECEWISE([1/1599*exp(-1/40*x)*sin(1/40*1599^(1/2)*x)*1599^(1/2)+exp(-1/40*x)*cos(1/40*1599^(1/2)*x)-cos(x), x < 6*Pi], [1/1599*exp(-1/40*x)*sin(1/40*1599^(1/2)*x)*1599^(1/2)+exp(-1/40*x)*cos(1...

> plot(res, x=0..50);

[Plot]

>

Soustavy diferenciálních rovnic

> System := [diff(x(t),t) = x(t)-y(t), diff(y(t),t) = x(t)+y(t)]:

> Solution:=dsolve(System, {x(t), y(t)});

Solution := {x(t) = exp(t)*(_C1*sin(t)+_C2*cos(t)), y(t) = exp(t)*(-_C1*cos(t)+_C2*sin(t))}

Řešení dosadíme do původní soustavy.

> over:=eval(subs(Solution, System)); map(evalb,%);

over := [exp(t)*(_C1*sin(t)+_C2*cos(t))+exp(t)*(_C1*cos(t)-_C2*sin(t)) = exp(t)*(_C1*sin(t)+_C2*cos(t))-exp(t)*(-_C1*cos(t)+_C2*sin(t)), exp(t)*(_C1*sin(t)+_C2*cos(t))+exp(t)*(-_C1*cos(t)+_C2*sin(t)) ...over := [exp(t)*(_C1*sin(t)+_C2*cos(t))+exp(t)*(_C1*cos(t)-_C2*sin(t)) = exp(t)*(_C1*sin(t)+_C2*cos(t))-exp(t)*(-_C1*cos(t)+_C2*sin(t)), exp(t)*(_C1*sin(t)+_C2*cos(t))+exp(t)*(-_C1*cos(t)+_C2*sin(t)) ...

[false, true]

Neuspěli jsme, nebo výrazy v první rovnosti nejsou syntakticky shodné (znaménko vytknuto před závorku). Správnější (ale obtížné) je použití nové funkce verify . Zde je navíc doplněno o rozklad prvků seznamu na dvojice výrazů, které jsou testovány na shodnost.

> analyze:=proc(obj) verify(op(obj),equal) end:

> map(analyze, over, equal);

[true, true]

Nejvhodnějším prostředkem pro kontrolu je však v tomto případě specializovaná funkce odetest .

> odetest(Solution, System);

[0, 0]

>

Operátory

Můžeme zavést symbolické operátory, např. Laplaceův.

> Delta := D[1, 1]+D[2, 2]+D[3, 3]

Definujeme-li potenciál pole např. ...,

> field := proc (x, y, z) options operator, arrow; 1/sqrt(x^2+y^2+z^2) end proc

... pak aplikací Laplaceova operátoru bychom měli dostat nulu, ...

> Delta(field)(x, y, z)

3*x^2/(x^2+y^2+z^2)^(5/2)-3/(x^2+y^2+z^2)^(3/2)+3*y^2/(x^2+y^2+z^2)^(5/2)+3*z^2/(x^2+y^2+z^2)^(5/2)

... což také dostaneme, ale až po zjednodušení.

> simplify(%)

0

>

Kombinatorické úlohy

Maple dovoluje řešit i kombinatoricky náročné úlohy při minimálním úsilí uživatele.

Problém batohu: K danému seznamu čísel najděte podseznam s daným součtem.

Řešení Petra Savického:

Funkce choose ...

> with(combinat, choose)

... generuje všechny podseznamy daného seznamu, z nich stačí vybrat ty, které vyhovují.

> knapsack := proc (List, TheSum) local [p]; for p in choose(List) do if convert(p, `+`) = TheSum then print(p) end if end do end proc

Zvolme seznam o 15 položkách (má  2^15 = 32768  podseznamů) ...

> s := [`$`(binomial(14, i), i = 0 .. 14)]

s := [1, 14, 91, 364, 1001, 2002, 3003, 3432, 3003, 2002, 1001, 364, 91, 14, 1]

... a najděme všechny podseznamy se součtem 8192.

> knapsack(s, 8192)

[14, 14, 364, 364, 1001, 3003, 3432]

[14, 14, 364, 364, 2002, 2002, 3432]

[14, 14, 364, 364, 1001, 1001, 2002, 3432]

[1, 1, 91, 91, 2002, 3003, 3003]

[1, 1, 91, 91, 1001, 2002, 2002, 3003]

[1, 1, 91, 91, 1001, 1001, 3003, 3003]

Řešení "metodou kanadských dřevorubců" vedlo k cíli!

>

Geometrické konstrukce

Balíček geom3d dovoluje definovat body, přímky, roviny, sféry, trojúhelníky atd.

Např. přímku lze určit:

dvěma body,

bodem a vektorem,

bodem a kolmou rovinou,

jako průsečnice dvou rovin,

parametrickou rovnicí.

Tyto objekty lze zobrazovat rotacemi, translacemi, symetriemi, počítat jejich průniky, testovat vzájemnou polohu atd.

Formulace úlohy

Všechny směry v 3-rozměrném prostoru (neboli body na sféře) máme obarvit modře a červeně tak, aby v každé trojici navzájem kolmých směrů (tj. ortogonální bázi) byl právě jeden červený.
To nejde, viz Bell, J.S.:
On the Einstein-Podolsky-Rosen paradox. Physics 1 (1964), 195-200.

Inicializace 1. lemmatu

> restart;

> with(geom3d): with(plots, display):

> BCOLOR:= navy: # color of beams

Warning, the assigned name polar now has a global binding

> mytickmarks:=3: myview:=1.35:

> plots[setoptions3d](axes=NONE,
shading=ZGREYSCALE, contours=7, font=[TIMES,BOLD,12], labelfont=[COURIER,BOLD,12], scaling=CONSTRAINED, orientation=[5,80], projection=0.8, style=PATCHNOGRID, thickness=2, tickmarks=[mytickmarks,mytickmarks,mytickmarks], titlefont=[TIMES,BOLD,18], view=[-myview..myview,-myview..myview,-myview..myview]):

> magnification:=myview: # relative length of beams

> normalize:= proc(xyz) local len;
len:=sqrt(op(1,xyz)^2+op(2,xyz)^2+op(3,xyz)^2);

[op(1,xyz)/len, op(2,xyz)/len, op(3,xyz)/len]

end:

> beam:= proc(bname,bpoint) local dummy;
dsegment('bname', [O,

point('dummy', magnification*normalize(coordinates(bpoint)))])

end:

> BigCircle:= proc(cpoint) local locq, locPq, loclq, locSq, locCq;
global Pe;

beam('locq', cpoint): # beam through cpoint

plane('locPq', [O,locq]): # Plane orthogonal to locq

line('loclq', [Pe,locPq]): # line orthogonal to locq in equatorial plane

rotation('locSq', SNord, FindAngle(Pe,locPq)+Pi/2, loclq);

intersection('locCq', S,locSq):

draw(locCq(colour=BLUE, thickness=2))

end:

> point('O', [0,0,0]): # Origin

> point('X', [1,0,0]): # point at the x-axis

> point('Y', [0,1,0]): # point at the y-axis

> point('NPole', [0,0,1]): # North Pole

> beam('n', NPole): # Earth's axis

> plane('Pe', [O,n]): # equatorial plane

> sphere('S', [O, 1]): # Earth's surface

> sphere('SNord', [NPole, sqrt(2)]): # Sphere around the north pole

> intersection(Equator, S,SNord): # Equator

> plotBasic:= draw([S, n(color=RED, thickness=2), Equator(color=BLUE, thickness=2), beam('Bx',X)(color=BCOLOR), beam('By',Y)(color=BCOLOR)]):

areinterls:, "two points of intersection"

> height:=0.9:

> point('Q', [0,sqrt(1-height^2),height]):

> beam('BQ2', point('Q2', [0,-height,sqrt(1-height^2)])):

> plotCq:= BigCircle(Q): plotBq:= draw(beam('Bq',Q),color=BCOLOR):

areinterls:, "two points of intersection"

> point('T1', normalize([1,1,2])):

> point('T2', normalize([-1,1,2])):

> beam('bell1', point('Bell1',[1,0,1])):

> beam('bell2', point('Bell2',[-1,0,1])):

> plotBell2:= draw([bell1,bell2], color=GREEN, thickness=3):

> BGL1:=display([plotBasic, plotCq, plotBq,
draw(BQ2,color=RED)]):

> BGL2:=display([plotBasic, plotCq, plotBq,
draw(beam('BT1',T1),color=BCOLOR),

draw(BQ2,color=RED), BigCircle(T1)]):

> BGL3:=display([plotBasic, plotCq, plotBq, plotBell2, draw(beam('BT1',T1),color=BCOLOR),
draw(beam('BT2',T2),color=BCOLOR),

draw(BQ2,color=RED), BigCircle(T1), BigCircle(T2)]):

areinterls:, "two points of intersection"

areinterls:, "two points of intersection"

areinterls:, "two points of intersection"

Obrázek důkazu 1. lemmatu

> display([BGL1,BGL2,BGL3], insequence=true, orientation=[77,28]);

[Plot]

Inicializace 2. lemmatu

> MGL3:=display([plotBasic, plotCq, plotBq, draw(BQ2,color=RED), BigCircle(T1), BigCircle(Bell1),
draw(BT1,color=BCOLOR),

draw(bell1,color=BCOLOR)]):

areinterls:, "two points of intersection"

areinterls:, "two points of intersection"

> MGL4:=display([plotBasic, plotCq, plotBq, draw(BQ2,color=RED), BigCircle(T1), BigCircle(Bell1),
draw(BT1,color=BCOLOR),

draw(bell1,color=BCOLOR),

draw(beam('BN3',point('N3',normalize([1,-1,1]))),color=BCOLOR), BigCircle(N3)]):

areinterls:, "two points of intersection"

areinterls:, "two points of intersection"

areinterls:, "two points of intersection"

Obrázek důkazu 2. lemmatu

> display([BGL1,BGL2,MGL3,MGL4], insequence=true, orientation=[26,31]);

[Plot]

>

Použity animace důkazů Bellova lemmatu dle

Navara, M.: Computer algebraic systems in proofs and visualization of results related to Gleason's Theorem. In: E.P. Klement, R. Mesiar, E. Drobná, F. Chovanec (eds.) Abstr. 6th Int. Conf. Fuzzy Sets Theory Appl., Military Academy, Liptovský Mikuláš, Slovakia, 2002, 95-96.

Použitá literatura

[1] Buchar, J, & all: Introduction to Maple V Programming Tool (Czech), University of Agriculture, Brno, 1994.

[2] Garey,  M.R. , Johnson, D.S.: Computers and Intractability: A Guide to the Theory of NP-Completeness, Freeman, San Francisco, 1979.

[3] Heal, K.M., Hansen, M.L., Rickard, K.M.,: Maple V Learning Guide, Springer, 1996, 1998.

[4] Monagan, , M.B., Geddes, K.O., Heal, K.M., Labahn, G. and Vorkoetter,S.M.: Maple V Programming Guide, Springer, 1996, 1998.

[5] Monagan, M.B., Geddes, K.O., a další: Maple 8 Inroductory Programming Guide, Waterloo Maple Inc., 2002

[6] Monagan, M.B., Geddes, K.O., a další: Maple 8 Advanced Programming Guide, Waterloo Maple Inc., 2002

[7] Char, B.W.: Maple 9 Learning Guide, Maplesoft, Waterloo Maple Inc., 2003.

[8] Monagan, M.B., Geddes, K.O., a další: Maple 9 Inroductory Programming Guide, Maplesoft, Waterloo Maple Inc., 2003.

[9] Monagan, M.B., Geddes, K.O., a další: Maple 9 Advanced Programming Guide, Maplesoft, Waterloo Maple Inc., 2003.

[10] Vrba, L.: Comparison of Complex Arithmetics in Computer Algebra Systems (Czech), Bac. Thesis, Czech Technical University, Praha, 1997.

[11] Wester, M.:A Review of CAS Mathematical Capabilities, preprint,  University of New Mexico, Albuquerque, 1994.