# Datové typy

## Seznam (list)

s:[1,4,25,9,16,25];

Stejné objekty se mohou vyskytovat více než jednou,
zachovává se zadané uspořádání.

Ověření, že s je datového typu seznam:

listp(s);

Vytváření seznamu

makelist(i^2,i,1,5);

makelist (expr, i, i_0, i_1) vytváří seznam, kde j-tý element je roven 
ev (expr, i=j) pro j od i_0 do i_1. 

makelist(x=y,y,[a,b,c]);

makelist (expr, x, list) vytváří seznam, kde j-tý element je roven 
ev (expr, x=list[j]) pro j od 1 do počtu prvků seznamu. 

create_list(x^i,i,[1,3,7]);

Počet prvků seznamu (délka seznamu):

length(s);

Test, zda daný element patří do seznamu:

member(2,s);

member(4,s);

Výběr jednotlivých prvků seznamu:

s[1];

Nahrazení prvku seznamu jiným:

s[1]:a;

s;

first(s);second(s);third(s);fourth(s);fifth(s);

last(s);

Odstranění elementu ze seznamu:

delete (y, [w, x, y, z, z, y, x, w]);

Odstranění duplicit

seznam:[x, x, x*y, x*(x-1)];

unique(seznam);

cl : [black, red, green, yellow, blue, white, pink];

rest(cl,2);

Odstraní první dva prvky seznamu.

rest(cl,-2);

Odstraní poslední dva prvky seznamu.

rest(cl);

Odstraní první prvek seznamu.

reverse(cl);

Obrátí pořadí prvků seznamu.

cons(orange,cl);

Vytvoří nový seznam se zadaným prvkem na prvním místě.

endcons(orange,cl);

Vytvoří nový seznam se zadaným prvkem na posledním místě.

append(cl,[orange,brown]);

append(list_1,...,list_n) vytváří jeden seznam, skládající se postupně z prvků 
seznamu list_1,list_2,...,list_n.

L1:[1,2,3,4,5];

L2:[a,b,c,d,e];

join(L1,L2);

join(l,m) vytváří seznam spojením seznamů l a m, přičemž prvky obou seznamů se 
pravidelně střídají. Tj. výsledný seznam vypadá takto: [l[1], m[1], l[2], m[2],...]. 

Pokud mají oba seznamy různou délku, join ignoruje prvky delšího seznamu.

f(x):=x^2;

map(f,L1);

map(f, list) aplikuje funkční předpis na všechny prvky seznamu.

Sečtení prvků seznamu

apply("+",L1);

random(11);

random(x) vrací náhodně zvolené celé číslo od 0 do x-1.

3<5, pred;

L : makelist(random(11),i,1,10);

sublist(L, lambda([x], is(x<5)));

f(x) := is(x<5)$

f(4);

sublist(L,f);

sublist(L, evenp);

## Množina (set)

M1:set(b,a,c);

M1:{c,b,a};

Pokud množina obsahuje stejné prvky, jsou automaticky odstraněny.

Datový typ množina používá vnitřní systém uspořádání.

setp(M1);

Prázdná množina:

set();

subst(c=a, M1);

M2:set(1,2,3);

M3:[1,1,2,2,3,3];

Vytvoření množiny ze seznamu:

M4:setify(M3);

A zpětné vytvoření seznamu z množiny:

listify(M4);

full_listify ({a, b, {c, {d, e, f}, g}});

listify ({a, b, {c, {d, e, f}, g}});

fullsetify ([a, [a]]);

Základní množinové operace

Sjednocení:

union(M1,M2);

Průnik:

intersect(M1,M2);

Rozdíl:

setdifference({0,1,2,3},{0,2,4,6});

Počet prvků konečné množiny:

cardinality(M1);

s:{1,2,five,3,4};

Přidání prvku:

adjoin(x, s);

union(s,{x});

Odstranění prvku z množiny:

disjoin(x,%);

disjointp ({a, b, c}, {1, 2, 3});

disjoint vrací true, pokud jsou zadané množiny disjunktní.

disjointp ({a, b, 3}, {1, 2, 3});

Určuje, zda daný prvek patří do množiny:

elementp(1,s);

elementp(6,s);

Určuje, zad jsou zadané množiny totožné:

setequalp ({1, 2, 3}, {1, 2, 3});

setequalp ({a, b, c}, {1, 2, 3});

subset ({1, 2, 7, 8, 9, 14}, evenp);

Vytvoří podmnožinu dané množiny na základě zadaného kritéria.

evenp(1);evenp(1/2);evenp(2);

oddp(1);oddp(1/2);oddp(2);

Určuje, zda je první zadaná množina podmnožinou druhé.

subsetp ({1, 2, 3}, {a, 1, b, 2, c, 3});

subsetp ({a, 1, b, 2, c, 3}, {1, 2, 3});

Vrací množinu všech podmnožin zadané množiny:

collection:powerset({1,2,3});

cardinality(collection);

fourth(collection);

numbers:{0,%pi,%pi/3,%pi/2};

map(g,numbers);

map(sin, numbers);

## Pole (array)

array (name, dim_1, ..., dim_n) vytváří obecné pole.
n musí být menší nebo rovné pěti.

array(A,2,3);

A[1,1]:1;A[1,2]:4;A[1,3]:9;

A[2,1]:1;A[2,2]:8;A[2,3]:27;

arrayinfo(A);

listarray (A);

translate:[["jedna", 1], ["dve", 2], ["tri",3]];

assoc("jedna", translate);

cons(["ctyri",4], translate);

## Matice

K vytvoření matice použijeme příkaz matrix([],[],...), přičemž v hranatých
závorkách vypisujeme jednotlivé řádky matice.

D:matrix([1,2,3],[1,4,9],[1,8,27]);

D[1,1];

Definování indexační funkce

h[i,j]:=1/(i+j-x);

hilbert4 : genmatrix(h,4,4);

ident(3);

diagmatrix(3,0);

zeromatrix(3,3);

Operace s maticemi

A: matrix([2,a], [-1,-2*b]);

B : matrix([3*a,2], [1-b,1]);

Sečítání a odečítání matic

A+B;

A-B;

C:transpose(D);

Násobení matic

D.C;

expand(A.B);

A*B;

Při použití * se pouze vynásobí prvky na odpovídajících pozicích.

A/B;

Dělí prvky na odpovídajících pozicích.

Mocniny

B^^3;

B^3;

Operátor "^" umocní jen prvky na odpovídajícíh pozicích.

Počet řádků

length(D);

Počet sloupců

length(transpose(D));

Hodnost matice

rank(D);

Výpočet determinaru čtvercové matice:

determinant(D);

invert(D);

D.%;

kill(all);

Gaussova eliminace

A:matrix([1,1,3,-3],[5,5,13,-17],[3,1,7,-11]);

triangularize(A);

echelon(A);

load("/home_zam/plch/vyuka/maxima/rref.mac");

rref(A);

Balíček linearalgebra

load(linearalgebra);

toeplitz([1,2,3]);

toeplitz([alpha, beta]);

Pro práci s vektory slouží balíček vect

load(vect);

v1 : [1,0,1];

length(v1);

v2 : [0,1,1];

v1-v2;

Skalární součin

v1 . v2;

Vektorový součin

v1 ~ v2;

zde nedochází automaticky k vyhodnocení, to provedeme až pomocí

express(%);