Maple

Úvod

Maple je case sensitive (rozlišuje malé a VEĽKÉ písmená). Príkazy sú oddelené bodkočiarkou ;. Priradenie symbolického výrazu premennej. Výpis sa robí automaticky. Dvojbodka oddeľuje viac príkazov na jednom riadku. Jediný príkaz ukončený dvojbodkou potlačí výpis ako odozvu Maple-u.

> u:=x^3-1;
> v:=x-1;

Výpis

> u/v;

Zjednodušovanie výrazov

> simplify(u/v);

Faktorizácia čísel ifactor()

> ifactor(1568754568699566222565468955669);

Vyhodnotenie výrazu ako čísla v plávajúcej čiarke: Porovnaj

> 8/3;
> evalf(8/3);

Počet platných miest pri vyhodnocovaní je druhým parametrom evalf(). Znak % nahrádza výstup z predošlého kroku

> evalf(%, 15);
> evalf[15](%);

Konštanta Digits špecifikuje implicitný počet platných desatinných miest. Preddefinovaná konštanta Pi.

> Digits:=30;
> evalf(Pi)

Odmocnina sqrt(). Výsledkom je zlomok.

> sqrt(64)/3;

Odmocnina sqrt() z reálneho čísla. Výsledkom je desatinné číslo.

> sqrt(64.)/3;

Zviazanie dvoch premenných. Ak sa zmení x, zmení sa aj y

> y:=2*sin(x);
> x:=1;
> x, y;
# vypise sa 1, 2 * sin(1)

Zrušenie zviazania dvoch premenných

> x:='x': x, y;

Substitúcia do výrazu - subs(). Za x sa substituuje Pi.

> subs(x=Pi,y);

Funkcie (zobrazenia)

Vytvorenie ,,funkcionálneho" operátora. Funkcia f o jednej premennej.

> f:=x-> 2*sin(x);
> f(pi);

Alternatívne cez príkaz unapply()

> g:=unapply(4+sin(x),x);
> g(pi);

Funkcia viacerých premenných

> h:=(x,a)->a*sin(x);
> h(1,x);

> g:=unapply(a*sin(x),x,a);
> g(5,Pi);

Vykreslenie grafu plot3d()

> plot3d(g,-10..10, -5..5);

Sekvencie, zoznamy a množiny

Vytvorenie sekvencie (sequence)

> a:=0,b,3,c,4;

Prístup k prvkom sekvencie cez []

> a[1]
> a[a[4]];

Vytvorenie sekvencie podľa predpisu seq()

> a:=seq(2*i,i=1..10);

Vytvorenie sekvencie opakovaním $. Vytvorí sa zoznam troch 10tok.

10$3

Vytvorenie zoznamu cez [..]

> zoz:=[a,b,c,4];

Vytvorenie zoznamu zo sekvencie (ktorou je matematic. postupnosť)

> a:=[seq(2*i,i=1..10)];

Nahradenie operandov vo výraze novými hodnotami subsop().

> subsop(1=NULL, 2=5, 4 = 5, zoz) : zoz;
# vysledkom je zoznam [5, c, 7]

Vytvorenie sekvencie zo zoznamu

> op(zoz);

Zoznam zo zoznamu

> [op(zoz),99,100];

Prístup ku prvkom zo zoznamu.

> zoz[2];
> zoz[2..4];

Usporiadanie zoznamu

> sort(zoz);

Vytvorenie množiny (set)

> x:={a,b,4,r};

Vytvorenie poľa (array) zo zoznamu

> v:=array([-1,0,1]);

Vytvorenie dvojrozmerného poľa

> m:=array([[1,2],[3,4]]);

Vytvorenie ďalšieho rozmeru v poli

> c:=array(1..4);
> c[3]:=5:c;
# v treťom poli vytvoríme pole

Vektor (vector)

> r:=vector([1,2,3,4]);

Vektor troch 10tok.

> x:=vector(3, 10);

Matice v balíku linalg

Vytvorenie matice zo zoznamov

> M:=matrix([[1,2],[4,5]]);

Transpozícia

> M1:=transpose(M);

Normálne rozdelenie

Hustota normálneho rozdelenia

> phi:=unapply((1/sqrt(2*Pi))*e^(-(x^2)/2), x);

Distribučná funkcia

> Phi:=x->int(phi(t),t=0..x);
> Phi(3);

Distribučná funkcia vlastným vzorcom

> Phi:=unapply(phi(x)*sum(x^(2*i-1)/doublefactorial(2*i-1), i=1..n), x,n);
> Phi(3, 10);
> evalf(%,50);

Vykreslenie

> plot(phi,-10..10);
> plot(Phi, -5..5);

Procedúry a funkcie

Funkcia na výpočet polovice čísla. Na konci každého riadku pri zadávaní je potrebné dať Shift + Enter.

> polovica:=proc(x)
> evalf(x/2)
> end;

Použitie funkcie

> polovica(1);
> polovica(3/4);

Definovanie lokálnych premenných. Funkcia na výpočet štvrtiny čísla.

> stvrtina:=proc(x) local x;
> evalf(x/4)
> end;
# x je lokálna premenná. Inak sa x považuje za globálnu

Výpis definície funkcie pomocou eval()

> eval(polovica);
> eval(stvrtina);
> eval(int);

Súčet postupnosti celých čísel od zadaného čísla po zadané číslo

> sucet:=proc(iOd, iDo)
>   local i, s;
>   s:=0;
>   for i from iOd to iDo do
>     s:=s+i;
>   end;
> end;

Procedúra na zistenie párnosti čísla

> jeParne:=proc(cislo)
>   local vysledok;
>   vysledok := FALSE;
>   if(cislo mod 2 = 0) then
>     vysledok := TRUE;
>   fi;
>   vysledok;
> end;

Funkcia na výpočet absolútnej hodnoty čísla

> absolutna:=proc(cislo)
>   local vysledok;
>   vysledok := cislo;
>   if(cislo < 0) then
>     vysledok := -cislo;
>   fi;
>   vysledok;
> end;

Načítanie dát z externého súboru do zoznamu (niekedy treba potvrdiť dvojitým Enterom, force execution;-)

> dat:=readdata("H:/LONGLEY1.TXT", 7);

Konverzia načítaných dát na pole

> convert(dat, array);

Uloženie definovanej premennej do externého súboru. (Funkcia polovica() sa uloží do externého súboru)

> save polovica, "h:/polovica.m";

Štatistické znaky

Definovanie balíčkov a zoznamu dát

> with(stats);
> with(describe);
>
> marks:=[64,93,72,68,91,84,51,43,23,76];

Štatistické znaky (medián, aritmetický priemer)

> median(marks);
> mean(marks);

Rozsah štatistických dát (ako interval)

> range(marks);

Vyhodnocovanie štatistických funkcií - podbalíček `statevalf`

Načítanie podbalíčka

> with(statevalf);

Distribučná funkcia spojitého rozdelenia

> cdf[normald](4);
Kvantilová funkcia (inverzná distribučná funkcia) spojitého rozdelenia
> icdf[normald](0.95);
Hustota spojitého rozdelenia
> pdf[normald](0);

Distribučná funkcia, kvantilová funkcia a pravdepodobnostná funkcia diskrétneho rozdelenia

> dcdf[normald](4);
> idcdf[normald](0.95);
> pf[normald](0);

Generovanie náhodných čísiel - balíček `random` a histogramy

Zavedenie balíčka

> with(random);

Generovanie sto náhodných čísel z normálneho rozdelenia

> data:=[random[normald[1,2]](100)];

Definovanie intervalov pre histogram

> ranges:=[-6..-5, -5..-4, -4..-3, -3..-2, -2..-1, -1..0,0..1,1..2,2..3,3..4,4..5, 5..6];

Rozdelenie vygenerovaných náhodných čísiel (data) do intervalov (ranges)

> data_list:=transform[tallyinto](data,ranges);

Vykreslenie histogramu

> statplots[histogram](data_list);

Generovanie 100 náhodných čísiel z chí-kvadrát rozdelenia o 6 stupňoch voľnosti

> data:=[random[chisquare[6]](100)];

Aplikovanie funkcie na zoznam

Aplikovanie funkcie f(x) na každý prvok zoznamu

> map(f, [a,b,c]);

Mapovanie funkcie sin() na zoznam

> data:=[0, Pi/2, 3*Pi/2, 2*Pi];
> map(sin, data);

Aplikovanie funkcie viacerých premenných na zoznam (f(x,y) na zoznam)

> map(f, [a,b,c], x, y);

Aplikovanie parciálnej derivácie (funkcia diff()) podľa x na zoznam

> data2:=[sin(x), ln(x), x^2];
> map(diff, data2, x);

Definovanie funkcie a jej aplikovanie

> map(x->x^2, [-1, -2, 0, 3]);

Riešenie sústav rovníc - `solve()`

Riešenie rovnice o jednej neznámej x

> solve({x^2=4} , {x});

Parametrické riešenie rovnice

> solve({x+y=2});

Riešenie sústavy

> solve({x+2*y=3, y+1/x = 1}, {x,y});

Sústava môže mať viacero riešení, solve() ich vráti ako sekvenciu. Extrahovanie jednotlivých riešení sústavy.

> sustava:={x+2*y=3, y+1/x = 1};
> riesenia:=solve(sustava, {x,y});
> riesenia[1];

Kontrola správnosti riešení pomocou funkcie eval() (najprv sa overí prvé riešenie, potom druhé)

> eval(sustava, riesenia[1]);
> eval(sustava, riesenia[2]);

Práca s maticami -- balík LinearAlgebra

Zavedenie balíčka

> with(LinearAlgebra);

Dátový typ je Vector (v linalg je to vector). Zadávanie Vectora po riadkoch dvoma spôsobmi

> V := <2 | 1>);
> V := Vector([2,1])

Základným dátovým typom je Matrix (v linalg je to matrix). Zadávanie Matrixu po riadkoch

> A := Matrix(<<2 | 1>, <3 | 4>>);

Počet stĺpcov

> ColumnDimension(A);

Počet riadkov

> RowDimension(A);

Vymazanie prvého stĺpca z matice

> DeleteColumn(A, 1);

Vymazanie prvého riadku z matice

> DeleteRow(A, 1);

Diagonálna matica 4 x 4 s diagonálnymi prvkami 1,2,3 (posledný prvok diagonály je 0)

> DiagonalMatrix(<1,2,3>, 4, 4);

,,Dvojková" matica 4 x 4

> DiagonalMatrix(Vector(4, 2), 4, 4);

Vlastné vektory matice

> Eigenvectors(A);

Inverzné matice: pre neštvorcové matice MP-pseudoinverzia, pre štvorcové nesingulárne: A^-1

> MatrixInverse(A);

Násobenie matice maticou

> MatrixMatrixMultiply(A, A);

Násobenie matice vektorom

> MatrixVectorMultiply(A, V);

Transpozícia matice

> Transpose(A);

Vlastná procedúra pre normu matice

> with(LinearAlgebra):
> norma:=proc(M)
> max(seq(add(abs(M[i,j]), i=1..RowDimension(M)), j=1..ColumnDimension(M)));
> end;

Použitie normy

> A:= < < 1/2 | 12/951>, <1/27 | 1/6 > >;
> norma(A);

Zabudovaná norma matice

> MatrixNorm(A, 1);

Condition Number matice -- vlastná procedúra

Procedura pre Condition Number
> CN_1:=proc(A)
> norma(A) * norma(MatrixInverse(A));
> end;

Použitie vlastnej CN_1

> CN_1(A);

Vypocet zabudovanou funkciou

> ConditionNumber(A);

Načítanie dátového súboru do matice Matrix (opäť dvakrát Enter)

> with(stats);
> longleym := Matrix(readdata(`h:\Longley1.txt`, float, 7));

Násobenie matice longleym transponovanou maticou k longleym

> X := MatrixMatrixMultiply(Transpose(longleym),  longleym);

Výpočet CN_1

> CN_1(X);

Násobenie matice longleym inverznou maticou k longleym

> MatrixMatrixMultiply(X, MatrixInverse(X));

Pripočítanie ,,desiatkovej" matice a výpočet CN_1

> XX := MatrixAdd(X, Vector(7, 10));
> CN_1(XX);

Pripočítanie ,,1000000000-kovej" matice a výpočet CN1. Presnosť CN1 sa zväčšuje s rastúcimi prvkami na diagonále

> DiagonalMatrix(Vector(7, 100000000000));
> ZZ := MatrixAdd(X, %);
> CN_1(ZZ);
!Tabuľky -- tables

V poliach sú celočíselné, 1-based indexy; v tabuľkách možno mať ľubovoľné indexy

Definovanie tabuľky zo zoznamu

> T:=table([a,b,c]);

Priradenie prvku na druhé miesto

> T[2]:=b;

Vytvorenie tabuľky spolu s definíciou indexov pre hodnoty

> T1:=table([0=alpha, 1=beta]);

Výpis prvku s indexom 0.

> T1[0];

Roztodivné indexy

> T3:=table([(shirt, S) = 12, (shirt, M) = 8, (shirt, L) = 6]);

Prístup k prvku s indexom shirt, M

> T3[shirt, M];

T3 je len symbol, na vypísanie celej tabuľky treba eval()

> eval(T3);

Prázdna tabuľka

> T:=table();

Naplnenie hodnotami

> T[1]:=4;
> T[2]:=2;

Výpis tabuľky

> eval(T);

Zrušenie prvku

> T[1]:='T[1]';

Výpis indexov tabuľky (sekvencia zoznamov)

> indices(T3);

Výpis položiek tabuľky (sekvencia zoznamov)

> entries(T1);

Operácie so symbolmi

Zrušenie priradenia premennej -- unassign(). Parameter musí byť nevyhodnotiteľný. V príklade unassign(a) je zlý, pretože sa druhý riadok sa vyhodnotí na unassign(1).

a := 1;
unassign(a)

Správne ,,odradenie" premennej

unassign('a');

Konkatenácia reťazcov (|| -- lepidlo)

"Hello " || "World"
"Indian c." || (1..3)

Výsledkom nasledovného evaln() je sekvencia symbolov troch symbolov

> evaln(a || (1..3))

Funkcia modulo (`mod`)

Klasická syntax

> 35 mod 26;

Modulo ako funkcia

> `mod`(9, 5);

Alternatívne modulo (kladné čísla v intervale 0..4)

> modp(9, 5);

mods() využíva symetrickú reprezentáciu

> mods(9, 5);