[Základní matematické funkce]
Sin(x: Real): Real;
//Funkce sinus
  Číslo: Edit = 0;
Cos(x: Real): Real;
//Funkce kosinus
  Číslo: Edit = 0;
Tan(x: Real): Real;
//Funkce tangens
  Číslo: Edit = 0;
Cotg(x: Real): Real;
//Funkce kotangens
  Číslo: Edit = 0;
Sec(x: Real): Real;
//Funkce sekans
  Číslo: Edit = 0;
Cosec(x: Real): Real;
//Funkce kosekans
  Číslo: Edit = 0;

ArcSin(x: Real): Real;
//Funkce arkussinus
  Číslo: Edit = 0;
ArcCos(x: Real): Real;
//Funkce arkuskosinus
  Číslo: Edit = 0;
ArcTan(x: Real): Real;
//Funkce arkustangens
  Číslo: Edit = 0;
ArcCotg(x: Real): Real;
//Funkce arkuskotangens
  Číslo: Edit = 0;
ArcSec(x: Real): Real;
//Funkce arkussekans
  Číslo: Edit = 0;
ArcCosec(x: Real): Real;
//Funkce arkuskosekans
  Číslo: Edit = 0;

Sinh(x: Real): Real;
//Hyperbolický sinus
  Číslo: Edit = 0;  
Cosh(x: Real): Real;
//Hyperbolický kosinus
  Číslo: Edit = 0;  
Tanh(x: Real): Real;
//Hyperbolický tangens
  Číslo: Edit = 0;  
Cotgh(x: Real): Real;
//Hyperbolický kotangens
  Číslo: Edit = 0;  
Sech(x: Real): Real;
//Hyperbolický sekans
  Číslo: Edit = 0;  
Cosech(x: Real): Real;
//Hyperbolický kosekans
  Číslo: Edit = 0;  

ArcSinh(x: Real): Real;
//Hyperbolický arkussinus
  Číslo: Edit = 0;  
ArcCosh(x: Real): Real;
//Hyperbolický arkuskosinus
  Číslo: Edit = 0;  
ArcTanh(x: Real): Real;
//Hyperbolický arkustangens
  Číslo: Edit = 0;
ArcCotgh(x: Real): Real;
//Hyperbolický arkuskotangens
  Číslo: Edit = 0;  
ArcSech(x: Real): Real;
//Hyperbolický arkussekans
  Číslo: Edit = 0;  
ArcCosech(x: Real): Real;
//Hyperbolický arkuskosekans
  Číslo: Edit = 0;  

Power(Základ, Exponent: Real): Real;
//Mocnina reálného čísla
  Základ: Edit = 1;
  Exponent: Edit = 1;
Sqrt(x: Real): Real;
//Druhá odmocnina
  Nezáporné číslo: Edit=0;
Sqr(x: Real): Real;
//Druhá mocnina
  Číslo: Edit=0;
Exp(x: Real): Real;
//Exponenciála
  Číslo: Edit=0;
Ln(x: Real): Real;
//Přirozený logaritmus
  Číslo: Edit=1;
Log10(x: Real): Real;
//Dekadický logaritmus
  Číslo: Edit=1;
LogN(n: Integer; x: Real): Real;
//Logaritmus x o základu n
  Základ logaritmu: Edit=2;
  Číslo: Edit = 1;
Abs(x: Real): Real;
//Absolutní hodnota
  Číslo: Edit=0;

[Celá čísla]
FactorialR(x: Integer): Real;
//Zaokrouhlený faktoriál
  Celé číslo: Edit=0;
FactorialI(x: Integer): Integer;
//Nezaokrouhlený faktoriál
  Celé číslo: Edit=0;
InitPrvočísla(Pocet: Integer);
//vytvoří Eratosthenovo síto->zrychlení práce s prvočísly
  Počet čísel v sítu: Edit=1000;
JePrvočíslo(i: Integer): Boolean;
//Vrací True, pokud je dané číslo prvočíslem
  Celé číslo: Edit=0;
ItéPrvočíslo(Poradi: Integer): Integer;
//i-té prvočíslo
  Pořadí: Edit=0;
PočetPrvočísel(Od, Do: Integer): Integer;
//Počet prvočísel na daném intervalu
  Od: Edit=0;
  Do: Edit=0;
ČísloNaZlomek(x: Integer): string;
//Zapíše racionální číslo jako zlomek
  Číslo: Edit=0;
RozkladVSoučin(Číslo: Integer; Mocniny: Boolean): string;
//Rozklad čísla na součin prvočísel
  Číslo: Edit=1;
  Zapisovat pomocí mocnin: List(True, False)=False;
MinNásobek([c1, c2, c3, ...: Integer]): Integer;
//Nejmenší společný násobek
  Množina celých čísel: Mnozina = [1];
MaxDělitel([c1, c2, c3, ...: Integer]): Integer;
//Největší společný dělitel
  Množina celých čísel: Mnozina = [1];
Dělitelé(x: Integer): Množina;
//Celočíselní dělitelé celého čísla
  Číslo: Edit=1;
Int(x: Real): Integer;
//Zaokrouhlení k nule
  Číslo: Edit=0;
Ceil(x: Real): Integer;
//Zaokrouhlení k plus nekonečnu
  Číslo: Edit=0;
Floor(x: Real): Integer;
//Zaokrouhlení k mínus nekonečnu
  Číslo: Edit=0;
Modulus(a, b: Integer): Integer;
//Zbytek po dělení ćísla a číslem b
  Celé číslo a: Edit=0;
  Celé číslo b: Edit=0;
Frac(x: Real): Real;
//Desetinný zbytek
  Číslo: Edit=0;

[Numerická metematika]
Rovnice(f(x); x=MinX..MaxX step k): Množina;
//Numerické řešení rovnice f(x)=0
  f(x): Edit=x;
  Interval, na kterém se rovnice řeší: Interval(1, Pokud nezadáte krok, určí se automaticky)=x=-10..10;
Derivace(f(x); x=a; |Řád: Integer; Směr:Levá/Pravá/Oboustranná|);
//Numerická derivace funkce v daném bodě
  f(x): Edit=x;
  Bod funkce: Edit=x=0;
  %Řád derivace: Edit=1;
  %Směr derivace: Edit=Oboustranná;
Integrál(f(x); x=MinX..MaxX step k);
//Určitý integrál
  f(x): Edit=x;
  Interval integrování: Interval(1, Pokud nezadáte krok, nastaví se automaticky)=x=-10..10;
LinSoustava([L1=P1, L2=P2, ...], [x1, x2, ...]): Vektor;
//Řešení soustavy lineárních rovnic
  Rovnice soustavy: Množina=[x=0];
  Názvy kořenů: Množina=[x];
StacBody(f(x); x=MinX..MaxX step k): Vektor;
//Stacionární body funkce
  f(x): Edit=x;
  Interval hledání: Interval(1, Pokud nezadáte krok, nastaví se automaticky)=x=-10..10;
InflexBody(f(x); x=MinX..MaxX step k): Vektor;
//Inflexní body funkce
  f(x): Edit=x;
  Interval hledání: Interval(1, Pokud nezadáte krok, nastaví se automaticky)=x=-10..10;
LMaxima(f(x); x=MinX..MaxX step k): Vektor;
//Lokální maxima
  f(x): Edit=x;
  Interval hledání: Interval(1, Pokud nezadáte krok, nastaví se automaticky)=x=-10..10;
LMinima(f(x); x=MinX..MaxX step k): Vektor;
//Lokální minima
  f(x): Edit=x;
  Interval hledání: Interval(1, Pokud nezadáte krok, nastaví se automaticky)=x=-10..10;
GMaximum(f(x); x=MinX..MaxX step k): Vektor;
//Globální maximum
  f(x): Edit=x;
  Interval hledání: Interval(1, Pokud nezadáte krok, nastaví se automaticky)=x=-10..10;
GMinimum(f(x); x=MinX..MaxX step k): Vektor;
//Globální minimum
  f(x): Edit=x;
  Interval hledání: Interval(1, Pokud nezadáte krok, nastaví se automaticky)=x=-10..10;

[Ostatní matematické funkce]
Random: Real;
//Náhodné číslo s rovnoměrným rozložením z intervalu (0; 1)
GRandom(Prumer, SmdOdchylka: Real): Real;
//Náhodné číslo s Gaussovým rozložením
  Průměr: Edit=0;
  Směrodatná odchylka: Edit=1;
IRandom(Max: Integer): Integer; //náhodné celé číslo od 0 do Max
//Náhodné celé číslo od 0 do Max
  Nejvyšší hodnota: Edit=1;
NRandom(n: Integer): Integer;
//průměr N náhodných čísel 0..1 s rovnoměrným rozdělením
  Počet čísel do průměru: Edit=0;
StrToAngle(s: Text): Real;
//Převod formátovaného textu na úhel v radiánech
  Text: Edit=0° 0' 0'';
AngleToStr(Uhel: Real; Maska: Text): Text;
//Převod úhlu v radiánech na formátovaný text
  Úhel v radiánech: Edit=0;
  Maska řetězce: Edit=dms;
Polynom(x: Real; [k0, k1, k2, ...]): Real;
//Hodnota polynomu v daném bodě
  Číslo: Edit=0;
  Koeficienty polynomu: Množina=[0];
DiffPolynom([k0, k1, k2, ...]): Vektor;
//Derivace polynomu
  Koeficienty polynomu: Množina=[0];
IntPolynom([k0, k1, k2, ...]): Vektor;
//Integrál polynomu
  Koeficienty polynomu: Množina=[0];
MinFce([f1(x), f2(x), ...], x=a): Real;
//Nejmenší z hodnot daných funkcí v daném bodě
  Funkce: Množina = [x];
  Bod: Edit = x=0;
MaxFce([f1(x), f2(x), ...], x=a): Real;
//Největší z hodnot daných funkcí v daném bodě
  Funkce: Množina=[x];
  Bod: Edit = x=0;
Vzoreček(Vzorec, [Velicina1=Hodnota1, Velicina2=Hodnota2, ...]);
//Dosadí do vzorce dané hodnoty
  Vzorec: Edit=;
  Hodnoty veličin ve vzorci: Množina=[];
Suma(x(i); i=MinI..MaxI): Real;
//Suma hodnot výrazu pro různá i
  x(i): Edit=i;
  Rozsah proměnné, přes kterou se sčítá: Interval(0, Krok je vždy 1)=i=0..10;
Součin(x(i); i=MinI..MaxI): Real;
//Součin hodnot výrazu pro různá i
  x(i): Edit=i;
  Rozsah proměnné, přes kterou se násobí: Interval(0, Krok je vždy 1)=i=0..10;
SumIS(s: Integer): string;
//Vzorec pro Suma(i^s, i=1..n);
  Mocnina: Edit=0;

[Statistické funkce]
PočetDat(Data: TData): Integer;
//Počet dat
  Data: Data=;
PočetBodů(Body: TBody): Integer;
//Počet bodů
  Data: Data=;
MinHodnota(Data: TData): Real;
//Nejmenší hodnota ze souboru
  Data: Data=;
MaxHodnota(Data: TData): Real;
//Největší hodnota ze souboru
  Data: Data=;
Součet(Data: TData): Real;
//Součet hodnot
  Data: Data=;
SoučetČtverců(Data: TData): Real;
//Součet druhých mocnin
  Data: Data=;

Modus(Data: TData): Real;
//Modus
  Data: Data=;
Median(Data: TData): Real;
//Medián
  Data: Data=;
Průměr(Data: TData): Real;
//Aritmetický průměr
  Data: Data=;
GeomPrůměr(Data: TData): Real;
//Geometrický průměr
  Data: Data=;
HarmonPrůměr(Data: TData): Real;
//Harmonický průměr
  Data: Data=;
PrůmOdchylka(Data: TData): Real;
//Průměrná absolutní odchylka
  Data: Data=;
SmdOdchylka(Data: TData): Real;
//Směrodatná odchylka
  Data: Data=;
StdOdchylka(Data: TData): Real;
//Standardní odchylka
  Data: Data=;

[Datum a čas]
JD(JD: TJD): Real;
//převádí datum a čas z libovolného formátu na JD
  Juliánské datum: Edit=0;
Datum(Datum: TDatum): Integer;
//převádí datum z libovolného formátu na celé číslo
  Datum: Edit=0;
DZD(Čas: TČas): Real;
//převádí čas z libovolného formátu na desetinné číslo
  Čas: Edit=0;
JDToDmyHms(JD: TJD): string;
//z juliánského data počítá světový datum a čas v obč. formátu
  JD: Edit=0;
DatumToDmy(Datum: TDatum): string;
//převádí datum z vnitřního formátu na občanský
  Datum: Edit=0;
DzdToHms(Čas: TČas): string;
//převádí čas z vnitřního formátu na občanský
  Čas: Edit=0;

PrávěTeďJD: Real;
//současné Juliánské datum - světový čas
DnesDatum: Integer;
//dnešní zkrácené Juliánské datum
NyníČas: Real;
//současný čas

SlKruh(Rok: Integer): Integer;
//sluneční kruh
  Rok: Edit=2000;
ZlČíslo(Rok: Integer): Integer;
//zlaté číslo
  Rok: Edit=2000;
ŘímskýPočet(Rok: Integer): Integer;
//římský počet
  Rok: Edit=2000;
Přestupný(Rok: Integer): Boolean;
//True, pokud je daný rok přestupný
  Rok: Edit=2000;
Epakta(Rok: Integer): Integer;
//novoroční epakta
  Rok: Edit=2000;
Velikonoce(Rok: Integer): TZJD;
//datum Velikonoční neděle
  Rok: Edit=2000;

DenVTýdnu(Datum: TDatum): Integer;
//Číslo dne v týdnu (1=Pondělí...)
  Datum: Edit=0;
StMěsíce(JD: TJD): Real;
//Střední stáří měsíce - doba uplynulá od posledního novu
  JD: Edit=0;
PořadíDne(Den, Mesic: Integer): Integer;
//Pořadí dne v roce (počítá se od 1.III.);
  Den: Edit=0;
  Mesic: Edit=0;

HvězdnýČas(JD: TJD): Real;
//Hvězdný čas
  JD: Edit=0;
TerestrickýČas(JD: TJD): Real;
//Terestrický čas
  JD: Edit=0;
Atomový čas(JD: TJD): Real;
//Atomový čas
  JD: Edit=0;
MístníČas(Světový: TDZD; Poledník: Real): Real;
//Místní čas
  Světový: Edit=0;
  Poledník: Edit=0;
PásmovýČas(Světový: TDZD; Pásmo: Integer);
//Pásmový čas
  Světocý: Edit=0;
  Pásmo: Edit=1;
UTDleHČ(ZJD: TZJD; Poledník: Real; MístníHČ: TDZD): Real;
//Světový čas podle hvězdného času
  ZJD: Edit=0;
  Poledník: Edit=0;
  Místní hvězdný čas: Edit=0;
DeltaT(JD: Real): Real;
//DletaT
  JD: Edit=0;

[Konstanty]
Pi=3.14159265358979;
//Ludolfovo číslo
e=2.71828182845905;
//Eulerovo číslo
AU=1.4959787E+11;
//Astronomická jednotka v metrech
Ly=9.4605300E+15;
//Světelný rok v metrech
Pc=3.0856775E+16;
//Parsec v metrech
SynMesic=29.53059;
//Synodický měsíc ve dnech
SolKonst=1360;
//Solární konstanta ve W/m2
MSl=1.99E30;
//Hmotnost Slunce v kg
RSl=6.95997E+8;
//Poloměr Slunce v metrech
LSl=3.8268E+26;
//Zářivý výkon SLunce ve wattech

[Kreslení]
KresliBody(Body: TBody; |Barva: TBarva; Šířka: Integer; Styl: Úsečky/Tečky/Křížky/Kolečka)|);
//Vykreslí do grafu zadané body
  Body, které se mají kresli: Body=Body;
  %Barva@Barva bodů: Barva = Červená;
  %Styl@Styl značky: List(Úsečky, Tečky, Křížky, Kolečka) = Úsečky;
  %Šířka@Šířka a velikost značky: Edit = 1;
KresliFci(y(x); x=Min..Max step k; |Nespojita: Boolean; Barva; Styl; Šířka|);
//Nakreslí graf funkce
  Kreslená funkce: Edit = x;
  Rozsah proměnné: Interval(1, Pokud nezadáte krok, nastaví se automaticky) = x;
  %Nespojitá@Obsahuje funkce nespojitosti: List(True, False) = False;
  %Barva@Barva grafu: Barva = Červená;
  %Styl@Styl: List(Úsečky, Tečky, Křížky, Kolečka) = Úsečky;
  %Šířka@Šířka: Edit = 1;
KresliKrivku(x(t); y(t); t=MinT..MaxT step k; |Barva; Styl; Šířka|);
//Nakreslí 2D parametrickou křivku
  x(t): Edit=t;
  y(t): Edit=t;
  Rozsah parametru t: Interval(1, Pokud nezadáte krok, nastaví se automaticky)=t=-1..1;
  %Barva@Barva křivky: Barva = Červená;
  %Styl@Styl: List(Úsečky, Tečky, Křížky, Kolečka) = Úsečky;
  %Šířka@Šířka: Edit = 1;
KresliRovnici(LHS(x, y); x=MinX..MaxX; y=MinY..MaxY; |Kroky, Vnoreni: Integer; Barva; Styl; Šířka|);
//Nakreslí body, které vyvhovují dané algebraické rovnici (body nelze spojit)
  LHS(x, y): Edit=x^2+y^2-1;
  Rozsah souřadnice X: Interval(0, Krok se volí vlastností Kroky)=x=-1..1;
  Rozsah souřadnice Y: Interval(0, Krok se volí vlastností Kroky)=y=-1..1;
  %Kroky@Počet kroků při výpočtu bodu: Edit=50;
  %Vnoření@Počet vnoření při výpočtu bodu: Edit=2;
Popisek(Text: MatText; X, Y: Real; |Font: TFont; ZarovnaniX: Vlevo/Vpravo/Střed; ZarovnaniY: Nahoru/Dolů/Střed|);
//Do grafu umístí popisek
  Text popisku: RichText=Nadpis;
  X souřadnice popisku: Edit=0;
  Y souřadnice popisku: Edit=0;
  %Font@Font popisku: Font=[Arial, 8, 0, Černá];
  %ZarovnáníX@Vodorovné zarovnání: List(Vlevo, Vpravo, Střed)=Vlevo;
  %ZarovnáníY@Svislé zarovnání: List(Nahoru, Dolu, Střed)=Střed;
Histogram(Data: TData; Krok: Real; |Start: Real; Obdélníky: Boolean; Hodnoty: Normal/Podil/Počet); Barva; Styl; Šířka|);
//Nakreslí histogram dat
  Data: Data=Data;
  Šířka kanálu: Edit=1;
  %Start@Začátek jednoho z kanálů: Edit=0;
  %Obdélníky@Vzhled jako schody: List(True, False)=True;
  %Výšky@Určování výšky sloupce: List(Normal, Podíl, Počet)=Normal;
  %Barva: Barva = Červená;
  %Styl: List(Úsečky, Tečky, Křížky, Kolečka) = Úsečky;
  %Šířka: Edit = 1;
Úsečka(X1, Y1, X2, Y2: Real; |Barva;Styl;Šířka|);
//Nakreslí úsečku
  X souřadnice 1. krajního bodu: Edit=0;
  X souřadnice 1. krajního bodu: Edit=0;
  Y souřadnice 2. krajního bodu: Edit=1;
  Y souřadnice 2. krajního bodu: Edit=1;
  %Barva: Barva = Červená;
  %Styl: List(Úsečky, Tečky, Křížky, Kolečka) = Úsečky;
  %Šířka: Edit = 1;
SkupinaÚseček(X1(i), Y1(i), X2(i), Y2(i): Real; i=MinI..MaxI step k; |Barva;Styl;Šířka|);
//Nakreslí skupinu úseček
  X souřadnice 1. krajního bodu: Edit=0;
  X souřadnice 1. krajního bodu: Edit=0;
  Y souřadnice 2. krajního bodu: Edit=1;
  Y souřadnice 2. krajního bodu: Edit=i;
  Rozsah proměnné i: Interval(1,) = i=0..10;
  %Barva: Barva = Červená;
  %Styl: List(Úsečky, Tečky, Křížky, Kolečka) = Úsečky;
  %Šířka: Edit = 1;
SmažGarf;
//Smaže všechny útvary a popisky z grafu

[Práce s body a daty]
VytvořBody(Body: TBody; y(x); x=MinX..MaxX step k; |Přidat: Boolean|);
//Vytvoří body podél zadané funkce
  Název bodů: Edit=Body;
  Vzorec y(x): Edit=x;
  Rozsah proměnné x: Interval(1, ) = x=1..10;
  %Přidat@Přidat vytvořené ke stávajícím: List(True, False)=False;
VytvořBodyParam(Body: TBody; x(t); y(t); t=MinT..MaxT step k; |Přidat: Boolean|);
//Vytvoří body podél parametricky zadané křivky
  Název bodů: Edit=Body;
  x(t): Edit=t;
  y(t): Edit=t;
  Rozsah parametru t: Interval(1, ) = t=0..1 step 0.1;
  %Přidat@Vytvořenéke stávajícím: List(True, False)=False;
PythČísla(Body: TBody; Max: Integer; Nasobky: Boolean);
//Vypočítá Pyth. čísla a uloží je jako body
  Název bodů: Body=;
  Nejvyšší číslo: Edit=100;
  Přidávat násobky jiných čísel: List(True, False)=False;
VytvořData(Data: TData; x(i); i=MinI..MaxI step k; |Přidat: Boolean|);
//Vytvoří data podle zadaného vzorce
  Název dat: Data=Data;
  Vzorec: Edit = i;
  Rozsah proměnné: Interval(1, ) = i=0..10;
  %Přidat@Přidat vytvořené ke stávajícím: List(True, False)=False;
VypoctiRegFci(RegFce: TRegFce; Body: TBody; Typ: PrimaU/NeprimaU/Polynom/Rac/Irac/Exp/Log/Power/Fourier; |Stupeň: Integer; Perioda: Real; Přesně: Boolean|);
//Vypočte koeficienty regresní funkce
  Název regresní funkce: RegFce=RegFce;
  Body, kterými se funkce prokládá: Body=Body;
  Typ regrese: List(Polynom, Rac, Irac, Exp, Log, Power, Fourier)=Polynom;
  %Stupeň: Edit=2;
  %Peroda@Perioda (jen pro Fourierovu řadu): Edit=1;
  %Přesně@: List(True, False)=False;
Regrese(RegFce: TrgeFce; Body: TBody; Typ: PrimaU/NeprimaU/Polynom/Rac/Irac/Exp/Log/Power/Fourier; |Stupeň: Integer; Perioda: Real; Přesně: Boolean|);
//Vypočte regrení funkci, nakreslí ji a nakrelí body
  Název regresní funkce: RegFce=RegFce;
  Body, kterými se funkce prokládá: Body=Body;
  Typ regrese: List(Polynom, Rac, Irac, Exp, Log, Power, Fourier)=Polynom;
  %Stupeň: Edit=2;
  %Perioda (jen pro Fourierovu řadu): Edit=1;
  %Přesně: List(True, False)=False;

[Ostatní]
Clen(Index: Integer, Množina);
//Vrací i-tý prvek množiny
  Index prvku: Edit=1;
  Množina: Mnozina=[0];
Výstup(DesMísta: Integer; Formát: Normal/Fixed/Sci);
//Formát výstupu čísel v kalkulačce
  Počet desetinných míst: Edit=0;
  Formát zobrazení: List(Normal, Fixed, Sci)=Normal;
Exit;
//Ukončí aplikaci