{
	"DATE": {
		"a": "(year; month; day)",
		"d": "Vrátí číslo, které představuje datum v kódu pro datum a čas."
	},
	"DATEDIF": {
		"a": "(počáteční_datum; konncové_datum; jednotka)",
		"d": "Vypočítá počet dnů, měsíců nebo roků mezi dvěma daty"
	},
	"DATEVALUE": {
		"a": "(datum)",
		"d": "Převede datum ve formátu textu na číslo, které představuje datum v kódu pro datum a čas."
	},
	"DAY": {
		"a": "(pořadové_číslo)",
		"d": "Vrátí den v měsíci, číslo od 1 do 31."
	},
	"DAYS": {
		"a": "(konec; začátek)",
		"d": "Vrátí počet dní mezi dvěma daty."
	},
	"DAYS360": {
		"a": "(start; konec; [metoda])",
		"d": "Vrátí počet dnů mezi dvěma daty na základě roku s 360 dny (dvanáct měsíců s 30 dny)."
	},
	"EDATE": {
		"a": "(začátek; měsíce)",
		"d": "Vrátí pořadové číslo data, což je určený počet měsíců před nebo po počátečním datu."
	},
	"EOMONTH": {
		"a": "(začátek; měsíce)",
		"d": "Vrátí pořadové číslo posledního dne měsíce před nebo po určeném počtu měsíců."
	},
	"HOUR": {
		"a": "(pořadové_číslo)",
		"d": "Vrátí hodiny jako číslo od 0 (12:00 dop.) do 23 (11:00 odp.)."
	},
	"ISOWEEKNUM": {
		"a": "(datum)",
		"d": "Vrátí číslo týdne ISO v roce pro dané datum."
	},
	"MINUTE": {
		"a": "(pořadové_číslo)",
		"d": "Vrátí minuty, číslo od 0 do 59."
	},
	"MONTH": {
		"a": "(pořadové_číslo)",
		"d": "Vrátí měsíc, číslo od 1 (leden) do 12 (prosinec)."
	},
	"NETWORKDAYS": {
		"a": "(začátek; konec; [svátky])",
		"d": "Vrátí počet celých pracovních dnů mezi dvěma zadanými daty."
	},
	"NETWORKDAYS.INTL": {
		"a": "(začátek; konec; [víkend]; [svátky])",
		"d": "Vrátí počet celých pracovních dní mezi dvěma daty s vlastními parametry víkendu."
	},
	"NOW": {
		"a": "()",
		"d": "Vrátí aktuální datum a čas formátované jako datum a čas."
	},
	"SECOND": {
		"a": "(pořadové_číslo)",
		"d": "Vrátí sekundy, číslo od 0 do 59."
	},
	"TIME": {
		"a": "(hodina; minuta; sekunda)",
		"d": "Převede hodiny, minuty a sekundy zadané jako čísla na pořadové číslo formátované pomocí formátu času."
	},
	"TIMEVALUE": {
		"a": "(čas)",
		"d": "Převede čas ve formě textového řetězce na pořadové číslo vyjadřující čas, číslo od 0 (12:00:00 dop.) do 0,999988426 (11:59:59 odp.). Po zadání vzorce číslo zformátujte pomocí formátu času."
	},
	"TODAY": {
		"a": "()",
		"d": "Vrátí aktuální datum formátované jako datum."
	},
	"WEEKDAY": {
		"a": "(pořadové; [typ])",
		"d": "Vrátí číslo od 1 do 7 určující den v týdnu kalendářního data."
	},
	"WEEKNUM": {
		"a": "(pořad_číslo; [typ])",
		"d": "Vrátí číslo týdne v roce."
	},
	"WORKDAY": {
		"a": "(začátek; dny; [svátky])",
		"d": "Vrátí pořadové číslo data před nebo po zadaném počtu pracovních dnů."
	},
	"WORKDAY.INTL": {
		"a": "(začátek; dny; [víkend]; [svátky])",
		"d": "Vrátí pořadové číslo data před nebo po zadaném počtu pracovních dnů s vlastními parametry víkendu."
	},
	"YEAR": {
		"a": "(pořadové_číslo)",
		"d": "Vrátí rok kalendářního data, celé číslo v rozsahu od 1900 do 9999."
	},
	"YEARFRAC": {
		"a": "(začátek; konec; [základna])",
		"d": "Vrátí část roku vyjádřenou zlomkem a představující počet celých dnů mezi počátečním a koncovým datem."
	},
	"BESSELI": {
		"a": "(x; n)",
		"d": "Vrátí modifikovanou Besselovu funkci In(x)."
	},
	"BESSELJ": {
		"a": "(x; n)",
		"d": "Vrátí Besselovu funkci Jn(x)."
	},
	"BESSELK": {
		"a": "(x; n)",
		"d": "Vrátí modifikovanou Besselovu funkci Kn(x)."
	},
	"BESSELY": {
		"a": "(x; n)",
		"d": "Vrátí Besselovu funkci Yn(x)."
	},
	"BIN2DEC": {
		"a": "(číslo)",
		"d": "Převede binární číslo na dekadické."
	},
	"BIN2HEX": {
		"a": "(číslo; [místa])",
		"d": "Převede binární číslo na hexadecimální."
	},
	"BIN2OCT": {
		"a": "(číslo; [místa])",
		"d": "Převede binární číslo na osmičkové."
	},
	"BITAND": {
		"a": "(číslo1; číslo2)",
		"d": "Vrátí bitové „A“ dvou čísel"
	},
	"BITLSHIFT": {
		"a": "(číslo; velikost_posunu)",
		"d": "Vrátí číslo posunuté doleva o hodnotu velikost_posunu v bitech"
	},
	"BITOR": {
		"a": "(číslo1; číslo2)",
		"d": "Vrátí bitové „nebo“ ze dvou čísel"
	},
	"BITRSHIFT": {
		"a": "(číslo; velikost_posunu)",
		"d": "Vrátí číslo posunuté doprava o hodnotu velikost_posunu v bitech"
	},
	"BITXOR": {
		"a": "(číslo1; číslo2)",
		"d": "Vrátí bitové „výhradní nebo“ ze dvou čísel"
	},
	"COMPLEX": {
		"a": "(reál; imag; [přípona])",
		"d": "Převede reálnou a imaginární část na komplexní číslo"
	},
	"CONVERT": {
		"a": "(číslo; z; do)",
		"d": "Převede číslo do jiného jednotkového měrného systému."
	},
	"DEC2BIN": {
		"a": "(číslo; [místa])",
		"d": "Převede dekadické číslo na binární."
	},
	"DEC2HEX": {
		"a": "(číslo; [místa])",
		"d": "Převede dekadické číslo na hexadecimální."
	},
	"DEC2OCT": {
		"a": "(číslo; [místa])",
		"d": "Převede dekadické číslo na osmičkové."
	},
	"DELTA": {
		"a": "(číslo1; [číslo2])",
		"d": "Testuje rovnost dvou čísel."
	},
	"ERF": {
		"a": "(dolní_limit; [horní_limit])",
		"d": "Vrátí chybovou funkci."
	},
	"ERF.PRECISE": {
		"a": "(x)",
		"d": "Vrátí chybovou funkci."
	},
	"ERFC": {
		"a": "(x)",
		"d": "Vrátí doplňkovou chybovou funkci."
	},
	"ERFC.PRECISE": {
		"a": "(x)",
		"d": "Vrátí doplňkovou chybovou funkci."
	},
	"GESTEP": {
		"a": "(číslo; [co])",
		"d": "Testuje, zda je číslo větší než mezní hodnota."
	},
	"HEX2BIN": {
		"a": "(číslo; [místa])",
		"d": "Převede hexadecimální číslo na binární."
	},
	"HEX2DEC": {
		"a": "(číslo)",
		"d": "Převede hexadecimální číslo na dekadické."
	},
	"HEX2OCT": {
		"a": "(číslo; [místa])",
		"d": "Převede hexadecimální číslo na osmičkové."
	},
	"IMABS": {
		"a": "(ičíslo)",
		"d": "Vrátí absolutní hodnotu komplexního čísla."
	},
	"IMAGINARY": {
		"a": "(ičíslo)",
		"d": "Vrátí imaginární část komplexního čísla."
	},
	"IMARGUMENT": {
		"a": "(ičíslo)",
		"d": "Vrátí argument q (úhel v radiánech)."
	},
	"IMCONJUGATE": {
		"a": "(ičíslo)",
		"d": "Vrátí komplexně sdružené číslo ke komplexnímu číslu."
	},
	"IMCOS": {
		"a": "(ičíslo)",
		"d": "Vrátí kosinus komplexního čísla."
	},
	"IMCOSH": {
		"a": "(Ičíslo)",
		"d": "Vrátí hyperbolický kosinus komplexního čísla"
	},
	"IMCOT": {
		"a": "(Ičíslo)",
		"d": "Vrátí kotangens komplexního čísla"
	},
	"IMCSC": {
		"a": "(Ičíslo)",
		"d": "Vrátí kosekans komplexního čísla"
	},
	"IMCSCH": {
		"a": "(Ičíslo)",
		"d": "Vrátí hyperbolický kosekans komplexního čísla"
	},
	"IMDIV": {
		"a": "(ičíslo1; ičíslo2)",
		"d": "Vrátí podíl dvou komplexních čísel."
	},
	"IMEXP": {
		"a": "(ičíslo)",
		"d": "Vrátí exponenciální tvar komplexního čísla."
	},
	"IMLN": {
		"a": "(ičíslo)",
		"d": "Vrátí přirozený logaritmus komplexního čísla."
	},
	"IMLOG10": {
		"a": "(ičíslo)",
		"d": "Vrátí dekadický logaritmus komplexního čísla."
	},
	"IMLOG2": {
		"a": "(ičíslo)",
		"d": "Vrátí logaritmus komplexního čísla při základu 2."
	},
	"IMPOWER": {
		"a": "(ičíslo; číslo)",
		"d": "Vrátí komplexní číslo umocněné na celé číslo."
	},
	"IMPRODUCT": {
		"a": "(ičíslo1; [ičíslo2]; ...)",
		"d": "Vrátí součin 1 až 255 komplexních čísel."
	},
	"IMREAL": {
		"a": "(ičíslo)",
		"d": "Vrátí reálnou část komplexního čísla."
	},
	"IMSEC": {
		"a": "(Ičíslo)",
		"d": "Vrátí sekans komplexního čísla"
	},
	"IMSECH": {
		"a": "(Ičíslo)",
		"d": "Vrátí hyperbolický sekans komplexního čísla"
	},
	"IMSIN": {
		"a": "(ičíslo)",
		"d": "Vrátí sinus komplexního čísla."
	},
	"IMSINH": {
		"a": "(Ičíslo)",
		"d": "Vrátí hyperbolický sinus komplexního čísla"
	},
	"IMSQRT": {
		"a": "(ičíslo)",
		"d": "Vrátí druhou odmocninu komplexního čísla."
	},
	"IMSUB": {
		"a": "(ičíslo1; ičíslo2)",
		"d": "Vrátí rozdíl dvou komplexních čísel."
	},
	"IMSUM": {
		"a": "(ičíslo1; [ičíslo2]; ...)",
		"d": "Vrátí součet komplexních čísel."
	},
	"IMTAN": {
		"a": "(Ičíslo)",
		"d": "Vrátí tangens komplexního čísla"
	},
	"OCT2BIN": {
		"a": "(číslo; [místa])",
		"d": "Převede osmičkové číslo na binární."
	},
	"OCT2DEC": {
		"a": "(číslo)",
		"d": "Převede osmičkové číslo na dekadické."
	},
	"OCT2HEX": {
		"a": "(číslo; [místa])",
		"d": "Převede osmičkové číslo na hexadecimální."
	},
	"DAVERAGE": {
		"a": "(databáze; pole; kritéria)",
		"d": "Vrátí průměr hodnot ve sloupci seznamu nebo databáze, které splňují zadaná kritéria."
	},
	"DCOUNT": {
		"a": "(databáze; pole; kritéria)",
		"d": "Vrátí počet buněk obsahujících čísla v poli (sloupci) záznamů databáze, které splňují zadaná kritéria."
	},
	"DCOUNTA": {
		"a": "(databáze; pole; kritéria)",
		"d": "Vrátí počet neprázdných buněk v poli (sloupci) záznamů databáze, které splňují zadaná kritéria."
	},
	"DGET": {
		"a": "(databáze; pole; kritéria)",
		"d": "Vybere z databáze jeden záznam, který splňuje zadaná kritéria."
	},
	"DMAX": {
		"a": "(databáze; pole; kritéria)",
		"d": "Vrátí maximální hodnotu v poli (sloupci) záznamů databáze, která splňuje zadaná kritéria."
	},
	"DMIN": {
		"a": "(databáze; pole; kritéria)",
		"d": "Vrátí minimální hodnotu v poli (sloupci) záznamů databáze, která splňuje zadaná kritéria."
	},
	"DPRODUCT": {
		"a": "(databáze; pole; kritéria)",
		"d": "Vynásobí hodnoty v poli (sloupci) záznamů databáze, které splňují zadaná kritéria."
	},
	"DSTDEV": {
		"a": "(databáze; pole; kritéria)",
		"d": "Odhadne směrodatnou odchylku výběru vybraných položek databáze."
	},
	"DSTDEVP": {
		"a": "(databáze; pole; kritéria)",
		"d": "Vrátí směrodatnou odchylku základního souboru vybraných položek databáze."
	},
	"DSUM": {
		"a": "(databáze; pole; kritéria)",
		"d": "Sečte čísla v poli (sloupci) záznamů databáze, které splňují zadaná kritéria."
	},
	"DVAR": {
		"a": "(databáze; pole; kritéria)",
		"d": "Odhadne rozptyl výběru vybraných položek databáze."
	},
	"DVARP": {
		"a": "(databáze; pole; kritéria)",
		"d": "Vrátí rozptyl základního souboru vybraných položek databáze."
	},
	"CHAR": {
		"a": "(kód)",
		"d": "Vrátí znak určený číslem kódu ze znakové sady definované v používaném počítači."
	},
	"CLEAN": {
		"a": "(text)",
		"d": "Odstraní z textu všechny netisknutelné znaky."
	},
	"CODE": {
		"a": "(text)",
		"d": "Vrátí číselný kód prvního znaku textového řetězce ze znakové sady definované v používaném počítači."
	},
	"CONCATENATE": {
		"a": "(text1; [text2]; ...)",
		"d": "Sloučí několik textových řetězců do jednoho."
	},
	"CONCAT": {
		"a": "(text1; ...)",
		"d": "Zřetězí seznam nebo oblast textových řetězců."
	},
	"DOLLAR": {
		"a": "(číslo; [desetiny])",
		"d": "Převede číslo na text ve formátu měny."
	},
	"EXACT": {
		"a": "(text1; text2)",
		"d": "Ověří, zda jsou dva textové řetězce stejné a vrátí hodnotu PRAVDA nebo NEPRAVDA. Tato funkce rozlišuje malá a velká písmena."
	},
	"FIND": {
		"a": "(co; kde; [start])",
		"d": "Vrátí počáteční pozici jednoho textového řetězce v jiném textovém řetězci. Tato funkce rozlišuje malá a velká písmena."
	},
	"FINDB": {
		"a": "(co; kde; [start])",
		"d": "Vyhledají jeden textový řetězec v druhém textovém řetězci a vrátí číslo počáteční pozice prvního textového řetězce od prvního znaku druhého textového řetězce, je určena pro jazyky používající dvoubajtovou znakovou sadu (DBCS) - japonština, čínština a korejština"
	},
	"FIXED": {
		"a": "(číslo; [desetiny]; [bez_čárky])",
		"d": "Zaokrouhlí číslo na zadaný počet desetinných míst a vrátí výsledek ve formátu textu s čárkami nebo bez čárek."
	},
	"LEFT": {
		"a": "(text; [znaky])",
		"d": "Vrátí zadaný počet znaků od počátku textového řetězce."
	},
	"LEFTB": {
		"a": "(text; [znaky])",
		"d": "Vrátí první znak nebo znaky v textovém řetězci na základě zadaného počtu bajtů, je určena pro jazyky používající dvoubajtovou znakovou sadu (DBCS) - japonština, čínština a korejština"
	},
	"LEN": {
		"a": "(text)",
		"d": "Vrátí počet znaků textového řetězce."
	},
	"LENB": {
		"a": "(text)",
		"d": "Vrátí počet bajtů, které představují znaky v textovém řetězci, je určena pro jazyky používající dvoubajtovou znakovou sadu (DBCS) - japonština, čínština a korejština"
	},
	"LOWER": {
		"a": "(text)",
		"d": "Převede všechna písmena textového řetězce na malá."
	},
	"MID": {
		"a": "(text; start; počet_znaků)",
		"d": "Vrátí znaky z textového řetězce, je-li zadána počáteční pozice a počet znaků."
	},
	"MIDB": {
		"a": "(text; start; počet_znaků)",
		"d": "Vrátí určitý počet znaků (na základě zadaného počtu bajtů) z textového řetězce od zadané pozice, je určena pro jazyky používající dvoubajtovou znakovou sadu (DBCS) - japonština, čínština a korejština"
	},
	"NUMBERVALUE": {
		"a": "(text; [oddělovač_desetin]; [oddělovač_skupin])",
		"d": "Převede text na číslo nezávisle na prostředí"
	},
	"PROPER": {
		"a": "(text)",
		"d": "Převede textový řetězec na formát, kdy jsou první písmena všech slov velká a ostatní písmena malá."
	},
	"REPLACE": {
		"a": "(starý; start; znaky; nový)",
		"d": "Nahradí část textového řetězce jiným textovým řetězcem."
	},
	"REPLACEB": {
		"a": "(starý; start; znaky; nový)",
		"d": "Nahradí na základě zadaného počtu bajtů část textového řetězce jiným textovým řetězcem, je určena pro jazyky používající dvoubajtovou znakovou sadu (DBCS) - japonština, čínština a korejština"
	},
	"REPT": {
		"a": "(text; počet)",
		"d": "Několikrát zopakuje zadaný text. Použijte funkci OPAKOVAT, chcete-li vyplnit buňku určitým počtem výskytů textového řetězce."
	},
	"RIGHT": {
		"a": "(text; [znaky])",
		"d": "Vrátí zadaný počet znaků od konce textového řetězce."
	},
	"RIGHTB": {
		"a": "(text; [znaky])",
		"d": "Vrátí zadaný počet bajtů od konce textového řetězce, je určena pro jazyky používající dvoubajtovou znakovou sadu (DBCS) - japonština, čínština a korejština"
	},
	"SEARCH": {
		"a": "(co; kde; [start])",
		"d": "Vrátí číslo prvního nalezeného výskytu znaku nebo textového řetězce. Směr hledání je zleva doprava. Velká a malá písmena nejsou rozlišována."
	},
	"SEARCHB": {
		"a": "(co; kde; [start])",
		"d": "Vyhledají jeden textový řetězec v rámci druhého textového řetězce a vrátí číslo počáteční pozice prvního textového řetězce od prvního znaku druhého textového řetězce, je určena pro jazyky používající dvoubajtovou znakovou sadu (DBCS) - japonština, čínština a korejština"
	},
	"SUBSTITUTE": {
		"a": "(text; starý; nový; [instance])",
		"d": "Nahradí existující text novým textem v textovém řetězci."
	},
	"T": {
		"a": "(hodnota)",
		"d": "Ověří, zda je argument Hodnota text. Jestliže ano, vrátí text, jestliže ne, vrátí uvozovky (prázdný text)."
	},
	"TEXT": {
		"a": "(hodnota; formát)",
		"d": "Převede hodnotu na text v určitém formátu."
	},
	"TEXTJOIN": {
		"a": "(oddělovač; ignorovat_prázdné; text1; ...)",
		"d": "Zřetězí seznam nebo oblast textových řetězců pomocí oddělovače."
	},
	"TRIM": {
		"a": "(text)",
		"d": "Odstraní všechny mezery z textového řetězce kromě jednotlivých mezer mezi slovy."
	},
	"UNICHAR": {
		"a": "(číslo)",
		"d": "Vrátí znak Unicode vztažený k dané číselné hodnotě"
	},
	"UNICODE": {
		"a": "(text)",
		"d": "Vrátí číslo (bod kódu) odpovídající prvnímu znaku textu"
	},
	"UPPER": {
		"a": "(text)",
		"d": "Převede všechna písmena textového řetězce na velká."
	},
	"VALUE": {
		"a": "(text)",
		"d": "Převede textový řetězec představující číslo na číslo."
	},
	"AVEDEV": {
		"a": "(číslo1; [číslo2]; ...)",
		"d": "Vrátí průměrnou hodnotu absolutních odchylek datových bodů od jejich střední hodnoty. Argumenty mohou být čísla či názvy, matice nebo odkazy obsahující čísla."
	},
	"AVERAGE": {
		"a": "(číslo1; [číslo2]; ...)",
		"d": "Vrátí průměrnou hodnotu (aritmetický průměr) argumentů. Argumenty mohou být čísla či názvy, matice nebo odkazy, které obsahují čísla."
	},
	"AVERAGEA": {
		"a": "(hodnota1; [hodnota2]; ...)",
		"d": "Vrátí průměrnou hodnotu (aritmetický průměr) argumentů. Text a logická hodnota NEPRAVDA mají hodnotu 0, logická hodnota PRAVDA má hodnotu 1. Argumenty mohou být čísla, názvy, matice nebo odkazy."
	},
	"AVERAGEIF": {
		"a": "(oblast; kritérium; [oblast_pro_průměr])",
		"d": "Zjistí průměrnou hodnotu (aritmetický průměr) buněk určených danou podmínkou nebo kritériem."
	},
	"AVERAGEIFS": {
		"a": "(oblast_pro_průměr; oblast_kritérií; kritérium; ...)",
		"d": "Zjistí průměrnou hodnotu (aritmetický průměr) buněk určených danou sadou podmínek nebo kritérií."
	},
	"BETADIST": {
		"a": "(x; alfa; beta; [A]; [B])",
		"d": "Vrátí hodnotu kumulativní funkce hustoty pravděpodobnosti beta rozdělení."
	},
	"BETAINV": {
		"a": "(pravděpodobnost; alfa; beta; [A]; [B])",
		"d": "Vrátí inverzní hodnotu kumulativní funkce hustoty pravděpodobnosti beta rozdělení (inverzní funkce k funkci BETADIST)."
	},
	"BETA.DIST": {
		"a": "(x; alfa; beta; kumulativní; [A]; [B])",
		"d": "Vrátí funkci rozdělení pravděpodobnosti beta."
	},
	"BETA.INV": {
		"a": "(pravděpodobnost; alfa; beta; [A]; [B])",
		"d": "Vrátí inverzní hodnotu kumulativní funkce hustoty pravděpodobnosti beta rozdělení (BETA.DIST)."
	},
	"BINOMDIST": {
		"a": "(počet_úspěchů; pokusy; pravděpodobnost_úspěchu; kumulativní)",
		"d": "Vrátí hodnotu binomického rozdělení pravděpodobnosti jednotlivých veličin."
	},
	"BINOM.DIST": {
		"a": "(počet_úspěchů; pokusy; pravděpodobnost_úspěchu; kumulativní)",
		"d": "Vrátí hodnotu binomického rozdělení pravděpodobnosti jednotlivých veličin."
	},
	"BINOM.DIST.RANGE": {
		"a": "(pokusy; pravděpodobnost_úspěchu; počet_úspěchů; [počet_úspěchů2])",
		"d": "Vrátí pravděpodobnost výsledku pokusu pomocí binomického rozdělení"
	},
	"BINOM.INV": {
		"a": "(pokusy; pravděpodobnost_úspěchu; alfa)",
		"d": "Vrátí nejmenší hodnotu, pro kterou má kumulativní binomické rozdělení hodnotu větší nebo rovnu hodnotě kritéria."
	},
	"CHIDIST": {
		"a": "(x; volnost)",
		"d": "Vrátí pravděpodobnost (pravý chvost) chí-kvadrát rozdělení."
	},
	"CHIINV": {
		"a": "(pravděpodobnost; volnost)",
		"d": "Vrátí inverzní hodnotu pravděpodobnosti (pravý chvost) chí-kvadrát rozdělení."
	},
	"CHITEST": {
		"a": "(aktuální; očekávané)",
		"d": "Vrátí test nezávislosti: hodnota chí-kvadrát rozdělení pro statistické jednotky a příslušné stupně volnosti."
	},
	"CHISQ.DIST": {
		"a": "(x; volnost; kumulativní)",
		"d": "Vrátí levostrannou pravděpodobnost rozdělení chí-kvadrát."
	},
	"CHISQ.DIST.RT": {
		"a": "(x; volnost)",
		"d": "Vrátí pravostrannou pravděpodobnost rozdělení chí-kvadrát."
	},
	"CHISQ.INV": {
		"a": "(pravděpodobnost; volnost)",
		"d": "Vrátí hodnotu funkce inverzní k distribuční funkci levostranné pravděpodobnosti rozdělení chí-kvadrát."
	},
	"CHISQ.INV.RT": {
		"a": "(pravděpodobnost; volnost)",
		"d": "Vrátí hodnotu funkce inverzní k distribuční funkci pravostranné pravděpodobnosti rozdělení chí-kvadrát."
	},
	"CHISQ.TEST": {
		"a": "(aktuální; očekávané)",
		"d": "Vrátí test nezávislosti: hodnota ze statistického rozdělení chí-kvadrát a příslušné stupně volnosti."
	},
	"CONFIDENCE": {
		"a": "(alfa; sm_odch; velikost)",
		"d": "Vrátí interval spolehlivosti pro střední hodnotu základního souboru pomocí normálního rozdělení."
	},
	"CONFIDENCE.NORM": {
		"a": "(alfa; sm_odch; velikost)",
		"d": "Vrátí interval spolehlivosti pro střední hodnotu základního souboru pomocí normálního rozdělení."
	},
	"CONFIDENCE.T": {
		"a": "(alfa; sm_odch; velikost)",
		"d": "Vrátí interval spolehlivosti pro střední hodnotu základního souboru pomocí Studentova t-rozdělení."
	},
	"CORREL": {
		"a": "(matice1; matice2)",
		"d": "Vrátí korelační koeficient mezi dvěma množinami dat."
	},
	"COUNT": {
		"a": "(hodnota1; [hodnota2]; ...)",
		"d": "Vrátí počet buněk v oblasti obsahujících čísla."
	},
	"COUNTA": {
		"a": "(hodnota1; [hodnota2]; ...)",
		"d": "Vrátí počet buněk v oblasti, které nejsou prázdné."
	},
	"COUNTBLANK": {
		"a": "(oblast)",
		"d": "Vrátí počet prázdných buněk v zadané oblasti buněk."
	},
	"COUNTIF": {
		"a": "(oblast; kritérium)",
		"d": "Vrátí počet buněk v zadané oblasti, které splňují požadované kritérium."
	},
	"COUNTIFS": {
		"a": "(oblast_kritérií; kritérium; ...)",
		"d": "Určí počet buněk na základě dané sady podmínek nebo kritérií."
	},
	"COVAR": {
		"a": "(matice1; matice2)",
		"d": "Vrátí hodnotu kovariance, průměrnou hodnotu součinů odchylek pro každou dvojici datových bodů ve dvou množinách dat."
	},
	"COVARIANCE.P": {
		"a": "(matice1; matice2)",
		"d": "Vrátí hodnotu kovariance základního souboru, průměrnou hodnotu součinů odchylek pro každou dvojici datových bodů ve dvou množinách dat."
	},
	"COVARIANCE.S": {
		"a": "(matice1; matice2)",
		"d": "Vrátí hodnotu kovariance výběru, průměrnou hodnotu součinů odchylek pro každou dvojici datových bodů ve dvou množinách dat."
	},
	"CRITBINOM": {
		"a": "(pokusy; pravděpodobnost_úspěchu; alfa)",
		"d": "Vrátí nejmenší hodnotu, pro kterou má kumulativní binomické rozdělení hodnotu větší nebo rovnu hodnotě kritéria."
	},
	"DEVSQ": {
		"a": "(číslo1; [číslo2]; ...)",
		"d": "Vrátí součet druhých mocnin odchylek datových bodů od jejich střední hodnoty výběru."
	},
	"EXPONDIST": {
		"a": "(x; lambda; kumulativní)",
		"d": "Vrátí hodnotu exponenciálního rozdělení."
	},
	"EXPON.DIST": {
		"a": "(x; lambda; kumulativní)",
		"d": "Vrátí hodnotu exponenciálního rozdělení."
	},
	"FDIST": {
		"a": "(x; volnost1; volnost2)",
		"d": "Vrátí hodnotu F rozdělení (stupeň nonekvivalence) pravděpodobnosti (pravý chvost) pro dvě množiny dat."
	},
	"FINV": {
		"a": "(pravděpodobnost; volnost1; volnost2)",
		"d": "Vrátí hodnotu inverzní funkce k funkci F rozdělení pravděpodobnosti (pravý chvost): Jestliže p = FDIST(x,...), pak FINV(p,...) = x."
	},
	"FTEST": {
		"a": "(matice1; matice2)",
		"d": "Vrátí výsledek F-testu, tj. pravděpodobnosti (dva chvosty), že se rozptyly v argumentech matice1 a matice2 výrazně neliší."
	},
	"F.DIST": {
		"a": "(x; volnost1; volnost2; kumulativní)",
		"d": "Vrátí hodnotu (levostranného) rozdělení pravděpodobnosti F (stupeň nonekvivalence) pro dvě množiny dat."
	},
	"F.DIST.RT": {
		"a": "(x; volnost1; volnost2)",
		"d": "Vrátí hodnotu (pravostranného) rozdělení pravděpodobnosti F (stupeň nonekvivalence) pro dvě množiny dat."
	},
	"F.INV": {
		"a": "(pravděpodobnost; volnost1; volnost2)",
		"d": "Vrátí hodnotu inverzní funkce k distribuční funkci (levostranného) rozdělení pravděpodobnosti F: jestliže p = F.DIST(x,...), F.INV(p,...) = x."
	},
	"F.INV.RT": {
		"a": "(pravděpodobnost; volnost1; volnost2)",
		"d": "Vrátí hodnotu inverzní funkce k distribuční funkci (pravostranného) rozdělení pravděpodobnosti F: jestliže p = F.DIST.RT(x,...), F.INV.RT(p,...) = x."
	},
	"F.TEST": {
		"a": "(matice1; matice2)",
		"d": "Vrátí výsledek F-testu, tj. pravděpodobnosti (dva chvosty), že se rozptyly v argumentech matice1 a matice2 výrazně neliší."
	},
	"FISHER": {
		"a": "(x)",
		"d": "Vrátí hodnotu Fisherovy transformace."
	},
	"FISHERINV": {
		"a": "(y)",
		"d": "Vrátí hodnotu inverzní funkce k Fisherově transformaci: jestliže y = FISHER(x), FISHERINV(y) = x."
	},
	"FORECAST": {
		"a": "(x; pole_y; pole_x)",
		"d": "Vypočte (předpoví) budoucí hodnotu lineárního trendu pomocí existujících hodnot."
	},
	"FORECAST.ETS": {
		"a": "(cílové_datum; hodnoty; časová_osa; [sezónnost]; [dokončení_dat]; [agregace])",
		"d": "Vrátí prognózu hodnoty k zadanému budoucímu cílovému datu pomocí metody exponenciálního vyhlazování."
	},
	"FORECAST.ETS.CONFINT": {
		"a": "(cílové_datum; hodnoty; časová_osa; [úroveň_spolehlivosti]; [sezónnost]; [dokončení_dat]; [agregace])",
		"d": "Vrátí interval spolehlivosti pro prognózu hodnoty k zadanému cílovému datu."
	},
	"FORECAST.ETS.SEASONALITY": {
		"a": "(hodnoty; časová_osa; [dokončení_dat]; [agregace])",
		"d": "Vrátí délku opakujícího se vzorku, který aplikace detekuje u zadané časové řady."
	},
	"FORECAST.ETS.STAT": {
		"a": "(hodnoty; časová_osa; typ_statistiky; [sezónnost]; [dokončení_dat]; [agregace])",
		"d": "Vrátí statistická data prognózy."
	},
	"FORECAST.LINEAR": {
		"a": "(x; pole_y; pole_x)",
		"d": "Vypočte (předpoví) budoucí hodnotu lineárního trendu pomocí existujících hodnot."
	},
	"FREQUENCY": {
		"a": "(data; hodnoty)",
		"d": "Vypočte počet výskytů hodnot v oblasti hodnot a vrátí vertikální matici čísel, která má o jeden prvek více než argument Hodnoty."
	},
	"GAMMA": {
		"a": "(x)",
		"d": "Vrátí hodnotu funkce gama"
	},
	"GAMMADIST": {
		"a": "(x; alfa; beta; kumulativní)",
		"d": "Vrátí hodnotu gama rozdělení."
	},
	"GAMMA.DIST": {
		"a": "(x; alfa; beta; kumulativní)",
		"d": "Vrátí hodnotu gama rozdělení."
	},
	"GAMMAINV": {
		"a": "(pravděpodobnost; alfa; beta)",
		"d": "Vrátí hodnotu inverzní funkce ke kumulativnímu gama rozdělení: Jestliže p = GAMMADIST(x,...), pak GAMMAINV(p,...) = x."
	},
	"GAMMA.INV": {
		"a": "(pravděpodobnost; alfa; beta)",
		"d": "Vrátí hodnotu inverzní funkce k distribuční funkci kumulativního rozdělení gama: jestliže p = GAMMA.DIST(x,...), potom GAMMA.INV(p,...) = x."
	},
	"GAMMALN": {
		"a": "(x)",
		"d": "Vrátí přirozený logaritmus funkce gama."
	},
	"GAMMALN.PRECISE": {
		"a": "(x)",
		"d": "Vrátí přirozený logaritmus funkce gama."
	},
	"GAUSS": {
		"a": "(x)",
		"d": "Vrátí hodnotu 0,5 menší než u standardního normálního součtového rozdělení"
	},
	"GEOMEAN": {
		"a": "(číslo1; [číslo2]; ...)",
		"d": "Vrátí geometrický průměr matice nebo oblasti kladných číselných dat."
	},
	"GROWTH": {
		"a": "(pole_y; [pole_x]; [nová_x]; [b])",
		"d": "Vrátí hodnoty trendu exponenciálního růstu odpovídajícího známým datovým bodům."
	},
	"HARMEAN": {
		"a": "(číslo1; [číslo2]; ...)",
		"d": "Vrátí harmonický průměr množiny kladných čísel: reciproční hodnota aritmetického průměru recipročních čísel."
	},
	"HYPGEOM.DIST": {
		"a": "(úspěch; celkem; základ_úspěch; základ_celkem; kumulativní)",
		"d": "Vrátí hodnotu hypergeometrického rozdělení."
	},
	"HYPGEOMDIST": {
		"a": "(úspěch; celkem; základ_úspěch; základ_celkem)",
		"d": "Vrátí hodnotu hypergeometrického rozdělení."
	},
	"INTERCEPT": {
		"a": "(pole_y; pole_x)",
		"d": "Vypočte souřadnice bodu, ve kterém čára protne osu y, pomocí proložení nejlepší regresní čáry známými hodnotami x a y."
	},
	"KURT": {
		"a": "(číslo1; [číslo2]; ...)",
		"d": "Vrátí hodnotu excesu množiny dat."
	},
	"LARGE": {
		"a": "(pole; k)",
		"d": "Vrátí k-tou největší hodnotu množiny dat, například páté největší číslo."
	},
	"LINEST": {
		"a": "(pole_y; [pole_x]; [b]; [stat])",
		"d": "Vrátí statistiku popisující lineární trend odpovídající známým datovým bodům proložením přímky vypočtené metodou nejmenších čtverců."
	},
	"LOGEST": {
		"a": "(pole_y; [pole_x]; [b]; [stat])",
		"d": "Vrátí statistiku, která popisuje exponenciální křivku odpovídající známým datovým bodům."
	},
	"LOGINV": {
		"a": "(pravděpodobnost; stř_hodn; sm_odch)",
		"d": "Vrátí inverzní funkci ke kumulativní distribuční funkci logaritmicko-normálního rozdělení hodnot x, kde funkce ln(x) má normální rozdělení s parametry stř_hodn a sm_odch."
	},
	"LOGNORM.DIST": {
		"a": "(x; střední; sm_odchylka; kumulativní)",
		"d": "Vrátí hodnotu logaritmicko-normálního rozdělení hodnot x, kde funkce ln(x) má normální rozdělení s parametry Střední a Sm_odch."
	},
	"LOGNORM.INV": {
		"a": "(pravděpodobnost; stř_hodn; sm_odch)",
		"d": "Vrátí inverzní funkci ke kumulativní distribuční funkci logaritmicko-normálního rozdělení hodnot x, kde funkce ln(x) má normální rozdělení s parametry Stř_hodn a Sm_odch."
	},
	"LOGNORMDIST": {
		"a": "(x; střední; sm_odch)",
		"d": "Vrátí hodnotu kumulativního logaritmicko-normálního rozdělení hodnot x, kde funkce ln(x) má normální rozdělení s parametry střední a sm_odch."
	},
	"MAX": {
		"a": "(číslo1; [číslo2]; ...)",
		"d": "Vrátí maximální hodnotu množiny hodnot. Přeskočí logické hodnoty a text."
	},
	"MAXA": {
		"a": "(hodnota1; [hodnota2]; ...)",
		"d": "Vrátí maximální hodnotu v množině hodnot. Nepřeskočí logické hodnoty a text."
	},
	"MAXIFS": {
		"a": "(max_oblast; kritéria_oblast; kritéria; ...)",
		"d": "Vrátí maximální hodnotu z buněk určených sadou podmínek nebo kritérií."
	},
	"MEDIAN": {
		"a": "(číslo1; [číslo2]; ...)",
		"d": "Vrátí medián, střední hodnotu množiny zadaných čísel."
	},
	"MIN": {
		"a": "(číslo1; [číslo2]; ...)",
		"d": "Vrátí minimální hodnotu množiny hodnot. Přeskočí logické hodnoty a text."
	},
	"MINA": {
		"a": "(hodnota1; [hodnota2]; ...)",
		"d": "Vrátí minimální hodnotu v množině hodnot. Nepřeskočí logické hodnoty a text."
	},
	"MINIFS": {
		"a": "(min_oblast; kritéria_oblast; kritéria; ...)",
		"d": "Vrátí minimální hodnotu z buněk určených sadou podmínek nebo kritérií."
	},
	"MODE": {
		"a": "(číslo1; [číslo2]; ...)",
		"d": "Vrátí hodnotu, která se v matici nebo v oblasti dat vyskytuje nejčastěji."
	},
	"MODE.MULT": {
		"a": "(číslo1; [číslo2]; ...)",
		"d": "Vrátí vertikální matici nejčastěji se vyskytujících (opakovaných) hodnot v matici nebo oblasti dat. Chcete-li získat horizontální matici, použijte vzorec =TRANSPOZICE(MODE.MULT(číslo1;číslo2;...))"
	},
	"MODE.SNGL": {
		"a": "(číslo1; [číslo2]; ...)",
		"d": "Vrátí hodnotu, která se v matici nebo v oblasti dat vyskytuje nejčastěji."
	},
	"NEGBINOM.DIST": {
		"a": "(počet_neúspěchů; počet_úspěchů; pravděpodobnost_úspěchu; kumulativní)",
		"d": "Vrátí hodnotu negativního binomického rozdělení, tj. pravděpodobnost, že neúspěchy argumentu počet_neúspěchů nastanou dříve než úspěch argumentu počet_úspěchů s pravděpodobností určenou argumentem pravděpodobnost_úspěchu."
	},
	"NEGBINOMDIST": {
		"a": "(počet_neúspěchů; počet_úspěchů; pravděpodobnost_úspěchu)",
		"d": "Vrátí hodnotu negativního binomického rozdělení, tj. pravděpodobnost, že počet neúspěchů určený argumentem počet_neúspěchů nastane dříve než počet úspěchů určených argumentem počet_úspěchů s pravděpodobností určenou argumentem pravděpodobnost_úspěchu."
	},
	"NORM.DIST": {
		"a": "(x; střed_hodn; sm_odch; kumulativní)",
		"d": "Vrátí hodnotu normálního rozdělení pro zadanou střední hodnotu a směrodatnou odchylku."
	},
	"NORMDIST": {
		"a": "(x; střed_hodn; sm_odch; kumulativní)",
		"d": "Vrátí hodnotu normálního kumulativního rozdělení pro zadanou střední hodnotu a směrodatnou odchylku."
	},
	"NORM.INV": {
		"a": "(pravděpodobnost; střední; sm_odch)",
		"d": "Vrátí inverzní funkci k distribuční funkci normálního kumulativního rozdělení pro zadanou střední hodnotu a směrodatnou odchylku."
	},
	"NORMINV": {
		"a": "(pravděpodobnost; střední; sm_odch)",
		"d": "Vrátí inverzní funkci k normálnímu kumulativnímu rozdělení pro zadanou střední hodnotu a směrodatnou odchylku."
	},
	"NORM.S.DIST": {
		"a": "(z; kumulativní)",
		"d": "Vrátí standardní normální rozdělení (má střední hodnotu nula a směrodatnou odchylku jedna)."
	},
	"NORMSDIST": {
		"a": "(z)",
		"d": "Vrátí hodnotu standardního normálního kumulativního rozdělení. (Střední hodnota daného rozdělení je rovna 0 a jeho směrodatná odchylka je rovna 1.)"
	},
	"NORM.S.INV": {
		"a": "(pravděpodobnost)",
		"d": "Vrátí inverzní funkci k distribuční funkci standardního normálního kumulativního rozdělení (které má střední hodnotu rovnou 0 a směrodatnou odchylku 1)."
	},
	"NORMSINV": {
		"a": "(pravděpodobnost)",
		"d": "Vrátí inverzní funkci ke standardnímu normálnímu kumulativnímu rozdělení. (Střední hodnota daného rozdělení je rovna 0 a jeho směrodatná odchylka je rovna 1)."
	},
	"PEARSON": {
		"a": "(pole1; pole2)",
		"d": "Vrátí Pearsonův výsledný momentový korelační koeficient r."
	},
	"PERCENTILE": {
		"a": "(matice; k)",
		"d": "Vrátí hodnotu k-tého percentilu hodnot v oblasti."
	},
	"PERCENTILE.EXC": {
		"a": "(matice; k)",
		"d": "Vrátí hodnotu k-tého percentilu hodnot v oblasti, kde hodnota k spadá do oblasti 0..1 (s vyloučením hodnot 0 a 1)."
	},
	"PERCENTILE.INC": {
		"a": "(matice; k)",
		"d": "Vrátí hodnotu k-tého percentilu hodnot v oblasti, kde hodnota k spadá do oblasti 0..1 (včetně)."
	},
	"PERCENTRANK": {
		"a": "(matice; x; [významnost])",
		"d": "Vrátí pořadí hodnoty v množině dat vyjádřené procentuální částí množiny dat."
	},
	"PERCENTRANK.EXC": {
		"a": "(matice; x; [významnost])",
		"d": "Vrátí pořadí hodnoty v množině dat vyjádřené procentuální částí (0..1, s vyloučením hodnot 0 a 1) množiny dat."
	},
	"PERCENTRANK.INC": {
		"a": "(matice; x; [významnost])",
		"d": "Vrátí pořadí hodnoty v množině dat vyjádřené procentuální částí (0..1, včetně) množiny dat."
	},
	"PERMUT": {
		"a": "(počet; permutace)",
		"d": "Vrátí počet permutací pro zadaný počet objektů, které lze vybrat z celkového počtu objektů."
	},
	"PERMUTATIONA": {
		"a": "(počet; permutace)",
		"d": "Vrátí počet permutací pro zadaný počet objektů (s opakováním) které je možné vybrat z celkového počtu objektů"
	},
	"PHI": {
		"a": "(x)",
		"d": "Vrátí hodnotu funkce hustoty pro standardní normální rozdělení"
	},
	"POISSON": {
		"a": "(x; střední; kumulativní)",
		"d": "Vrátí hodnotu Poissonova rozdělení."
	},
	"POISSON.DIST": {
		"a": "(x; střední; kumulativní)",
		"d": "Vrátí hodnotu Poissonova rozdělení."
	},
	"PROB": {
		"a": "(x_oblast; prst_oblast; dolní_limit; [horní_limit])",
		"d": "Vrátí pravděpodobnost toho, že hodnoty v oblasti leží mezi dvěma mezemi nebo jsou rovny dolní mezi."
	},
	"QUARTILE": {
		"a": "(matice; kvartil)",
		"d": "Vrátí hodnotu kvartilu množiny dat."
	},
	"QUARTILE.INC": {
		"a": "(matice; kvartil)",
		"d": "Vrátí hodnotu kvartilu množiny dat na základě hodnot percentilu z oblasti 0..1 (včetně)."
	},
	"QUARTILE.EXC": {
		"a": "(matice; kvartil)",
		"d": "Vrátí hodnotu kvartilu množiny dat na základě hodnot percentilu z oblasti 0..1 (s vyloučením hodnot 0 a 1)."
	},
	"RANK": {
		"a": "(číslo; odkaz; [pořadí])",
		"d": "Vrátí pořadí čísla v seznamu čísel: jeho relativní velikost vzhledem k hodnotám v seznamu."
	},
	"RANK.AVG": {
		"a": "(číslo; odkaz; [pořadí])",
		"d": "Vrátí pořadí čísla v seznamu čísel: jeho relativní velikost vzhledem k ostatním hodnotám v seznamu. Má-li stejné pořadí více než jedna hodnota, bude vráceno průměrné pořadí."
	},
	"RANK.EQ": {
		"a": "(číslo; odkaz; [pořadí])",
		"d": "Vrátí pořadí čísla v seznamu čísel: jeho relativní velikost vzhledem k ostatním hodnotám v seznamu. Má-li stejné pořadí více než jedna hodnota, bude vráceno nejvyšší pořadí dané množiny hodnot."
	},
	"RSQ": {
		"a": "(pole_y; pole_x)",
		"d": "Vrátí druhou mocninu Pearsonova výsledného momentového korelačního koeficientu pomocí zadaných datových bodů."
	},
	"SKEW": {
		"a": "(číslo1; [číslo2]; ...)",
		"d": "Vrátí zešikmení rozdělení: charakteristika stupně asymetrie rozdělení kolem jeho střední hodnoty."
	},
	"SKEW.P": {
		"a": "(číslo1; [číslo2]; ...)",
		"d": "Vrátí zešikmení rozdělení založené na základním souboru: charakteristika stupně asymetrie rozdělení kolem jeho střední hodnoty"
	},
	"SLOPE": {
		"a": "(pole_y; pole_x)",
		"d": "Vrátí směrnici lineární regresní čáry proložené zadanými datovými body."
	},
	"SMALL": {
		"a": "(pole; k)",
		"d": "Vrátí k-tou nejmenší hodnotu v množině dat, například páté nejmenší číslo."
	},
	"STANDARDIZE": {
		"a": "(x; střed_hodn; sm_odch)",
		"d": "Vrátí normalizovanou hodnotu z rozdělení určeného střední hodnotou a směrodatnou odchylkou."
	},
	"STDEV": {
		"a": "(číslo1; [číslo2]; ...)",
		"d": "Odhadne směrodatnou odchylku výběru (přeskočí logické hodnoty a text ve výběru)."
	},
	"STDEV.P": {
		"a": "(číslo1; [číslo2]; ...)",
		"d": "Vypočte směrodatnou odchylku základního souboru, který byl zadán jako argument (přeskočí logické hodnoty a text)."
	},
	"STDEV.S": {
		"a": "(číslo1; [číslo2]; ...)",
		"d": "Odhadne směrodatnou odchylku výběru (přeskočí logické hodnoty a text ve výběru)."
	},
	"STDEVA": {
		"a": "(hodnota1; [hodnota2]; ...)",
		"d": "Odhadne směrodatnou odchylku výběru. Nepřeskočí logické hodnoty a text. Text a logická hodnota NEPRAVDA mají hodnotu 0, logická hodnota PRAVDA má hodnotu 1."
	},
	"STDEVP": {
		"a": "(číslo1; [číslo2]; ...)",
		"d": "Vypočte směrodatnou odchylku základního souboru, který byl zadán jako argument (přeskočí logické hodnoty a text)."
	},
	"STDEVPA": {
		"a": "(hodnota1; [hodnota2]; ...)",
		"d": "Vypočte směrodatnou odchylku základního souboru. Nepřeskočí logické hodnoty a text. Text a logická hodnota NEPRAVDA mají hodnotu 0, logická hodnota PRAVDA má hodnotu 1."
	},
	"STEYX": {
		"a": "(pole_y; pole_x)",
		"d": "Vrátí standardní chybu předpovězené hodnoty y pro každou hodnotu x v regresi."
	},
	"TDIST": {
		"a": "(x; volnost; chvosty)",
		"d": "Vrátí hodnotu Studentova t-rozdělení."
	},
	"TINV": {
		"a": "(pravděpodobnost; volnost)",
		"d": "Vrátí inverzní funkci (dva chvosty) ke Studentovu t-rozdělení."
	},
	"T.DIST": {
		"a": "(x; volnost; kumulativní)",
		"d": "Vrátí hodnotu levostranného Studentova t-rozdělení."
	},
	"T.DIST.2T": {
		"a": "(x; volnost)",
		"d": "Vrátí hodnotu oboustranného Studentova t-rozdělení."
	},
	"T.DIST.RT": {
		"a": "(x; volnost)",
		"d": "Vrátí hodnotu pravostranného Studentova t-rozdělení."
	},
	"T.INV": {
		"a": "(pravděpodobnost; volnost)",
		"d": "Vrátí levostrannou inverzní funkci k distribuční funkci Studentova t-rozdělení."
	},
	"T.INV.2T": {
		"a": "(pravděpodobnost; volnost)",
		"d": "Vrátí oboustrannou inverzní funkci k distribuční funkci Studentova t-rozdělení."
	},
	"T.TEST": {
		"a": "(matice1; matice2; chvosty; typ)",
		"d": "Vrátí pravděpodobnost odpovídající Studentovu t-testu."
	},
	"TREND": {
		"a": "(pole_y; [pole_x]; [nová_x]; [b])",
		"d": "Vrátí hodnoty lineárního trendu odpovídajícího známým datovým bodům pomocí metody nejmenších čtverců."
	},
	"TRIMMEAN": {
		"a": "(pole; procenta)",
		"d": "Vrátí průměrnou hodnotu vnitřní části množiny datových hodnot."
	},
	"TTEST": {
		"a": "(matice1; matice2; chvosty; typ)",
		"d": "Vrátí pravděpodobnost odpovídající Studentovu t-testu."
	},
	"VAR": {
		"a": "(číslo1; [číslo2]; ...)",
		"d": "Odhadne rozptyl výběru (přeskočí logické hodnoty a text ve výběru)."
	},
	"VAR.P": {
		"a": "(číslo1; [číslo2]; ...)",
		"d": "Vypočte rozptyl celého základního souboru (přeskočí logické hodnoty a text v základním souboru)."
	},
	"VAR.S": {
		"a": "(číslo1; [číslo2]; ...)",
		"d": "Odhadne rozptyl výběru (přeskočí logické hodnoty a text ve výběru)."
	},
	"VARA": {
		"a": "(hodnota1; [hodnota2]; ...)",
		"d": "Odhadne rozptyl výběru. Nepřeskočí logické hodnoty a text. Text a logická hodnota NEPRAVDA mají hodnotu 0, logická hodnota PRAVDA má hodnotu 1."
	},
	"VARP": {
		"a": "(číslo1; [číslo2]; ...)",
		"d": "Vypočte rozptyl základního souboru (přeskočí logické hodnoty a text v základním souboru)."
	},
	"VARPA": {
		"a": "(hodnota1; [hodnota2]; ...)",
		"d": "Vypočte rozptyl základního souboru. Nepřeskočí logické hodnoty a text. Text a logická hodnota NEPRAVDA mají hodnotu 0, logická hodnota PRAVDA má hodnotu 1."
	},
	"WEIBULL": {
		"a": "(x; alfa; beta; kumulativní)",
		"d": "Vrátí hodnotu Weibullova rozdělení."
	},
	"WEIBULL.DIST": {
		"a": "(x; alfa; beta; kumulativní)",
		"d": "Vrátí hodnotu Weibullova rozdělení."
	},
	"Z.TEST": {
		"a": "(matice; x; [sigma])",
		"d": "Vrátí P-hodnotu (jeden chvost) z-testu."
	},
	"ZTEST": {
		"a": "(matice; x; [sigma])",
		"d": "Vrátí P-hodnotu (jeden chvost) z-testu."
	},
	"ACCRINT": {
		"a": "(emise; první_úrok; vypořádání; sazba; nom_hodnota; počet_plateb; [základna]; [metoda_výpočtu])",
		"d": "Vrátí nahromaděný úrok z cenného papíru, ze kterého je úrok placen pravidelně."
	},
	"ACCRINTM": {
		"a": "(emise; vypořádání; sazba; nom_hodnota; [základna])",
		"d": "Vrátí nahromaděný úrok z cenného papíru, ze kterého je úrok placen k datu splatnosti."
	},
	"AMORDEGRC": {
		"a": "(náklad; nákup; první_období; zůstatek; období; sazba; [základna])",
		"d": "Vrátí kalkulačně rozvržený lineární odpis aktiva pro každé účetní období."
	},
	"AMORLINC": {
		"a": "(náklad; nákup; první_období; zůstatek; období; sazba; [základna])",
		"d": "Vrátí kalkulačně rozvržený lineární odpis aktiva pro každé účetní období."
	},
	"COUPDAYBS": {
		"a": "(vypořádání; splatnost; počet_plateb; [základna])",
		"d": "Vrátí počet dnů od začátku období placení kupónů do data splatnosti."
	},
	"COUPDAYS": {
		"a": "(vypořádání; splatnost; počet_plateb; [základna])",
		"d": "Vrátí počet dnů v období placení kupónů, které obsahuje den zúčtování."
	},
	"COUPDAYSNC": {
		"a": "(vypořádání; splatnost; počet_plateb; [základna])",
		"d": "Vrátí počet dnů od data zúčtování do následujícího data placení kupónu."
	},
	"COUPNCD": {
		"a": "(vypořádání; splatnost; počet_plateb; [základna])",
		"d": "Vrátí následující datum placení kupónu po datu zúčtování."
	},
	"COUPNUM": {
		"a": "(vypořádání; splatnost; počet_plateb; [základna])",
		"d": "Vrátí počet kupónů splatných mezi datem zúčtování a datem splatnosti."
	},
	"COUPPCD": {
		"a": "(vypořádání; splatnost; počet_plateb; [základna])",
		"d": "Vrátí předchozí datum placení kupónu před datem zúčtování."
	},
	"CUMIPMT": {
		"a": "(úrok; období; půjčka; začátek; konec; typ)",
		"d": "Vrátí kumulativní úrok splacený mezi dvěma obdobími."
	},
	"CUMPRINC": {
		"a": "(úrok; období; půjčka; začátek; konec; typ)",
		"d": "Vrátí kumulativní jistinu splacenou mezi dvěma obdobími půjčky."
	},
	"DB": {
		"a": "(náklady; zůstatek; životnost; období; [měsíc])",
		"d": "Vypočítá odpis aktiva za určité období pomocí degresivní metody odpisu s pevným zůstatkem."
	},
	"DDB": {
		"a": "(náklady; zůstatek; životnost; období; [faktor])",
		"d": "Vypočítá odpis aktiva za určité období pomocí dvojité degresivní metody odpisu nebo jiné metody, kterou zadáte."
	},
	"DISC": {
		"a": "(vypořádání; splatnost; cena; zaruč_cena; [základna])",
		"d": "Vrátí diskontní sazbu cenného papíru."
	},
	"DOLLARDE": {
		"a": "(zlomková_koruna; zlomek)",
		"d": "Převede částku v korunách vyjádřenou zlomkem na částku v korunách vyjádřenou desetinným číslem."
	},
	"DOLLARFR": {
		"a": "(desetinná_koruna; zlomek)",
		"d": "Převede částku v korunách vyjádřenou desetinným číslem na částku v korunách vyjádřenou zlomkem."
	},
	"DURATION": {
		"a": "(vypořádání; splatnost; kupón; výnos; počet_plateb; [základna])",
		"d": "Vrátí roční dobu cenného papíru s pravidelnými úrokovými sazbami."
	},
	"EFFECT": {
		"a": "(úrok; období)",
		"d": "Vrátí efektivní roční úrokovou sazbu."
	},
	"FV": {
		"a": "(sazba; pper; splátka; [souč_hod]; [typ])",
		"d": "Vrátí budoucí hodnotu investice vypočtenou na základě pravidelných konstantních splátek a konstantní úrokové sazby."
	},
	"FVSCHEDULE": {
		"a": "(hodnota; sazby)",
		"d": "Vrátí budoucí hodnotu počáteční jistiny po použití série sazeb složitého úroku."
	},
	"INTRATE": {
		"a": "(vypořádání; splatnost; investice; zaruč_cena; [základna])",
		"d": "Vrátí úrokovou sazbu plně investovaného cenného papíru."
	},
	"IPMT": {
		"a": "(sazba; za; pper; souč_hod; [bud_hod]; [typ])",
		"d": "Vrátí výšku úroku v určitém úrokovém období vypočtenou na základě pravidelných konstantních splátek a konstantní úrokové sazby."
	},
	"IRR": {
		"a": "(hodnoty; [odhad])",
		"d": "Vrátí vnitřní výnosové procento série peněžních toků."
	},
	"ISPMT": {
		"a": "(sazba; za; pper; souč)",
		"d": "Vrátí výšku úroku zaplaceného za určité období investice."
	},
	"MDURATION": {
		"a": "(vypořádání; splatnost; kupón; výnos; počet_plateb; [základna])",
		"d": "Vrátí Macauleyho modifikovanou dobu cenného papíru o nominální hodnotě 100 Kč."
	},
	"MIRR": {
		"a": "(hodnoty; finance; investice)",
		"d": "Vrátí vnitřní sazbu výnosu pravidelných peněžních příjmů. Zohledňuje jak náklady na investice, tak úrok z reinvestic získaných peněžních prostředků."
	},
	"NOMINAL": {
		"a": "(úrok; období)",
		"d": "Vrátí nominální roční úrokovou sazbu."
	},
	"NPER": {
		"a": "(sazba; splátka; souč_hod; [bud_hod]; [typ])",
		"d": "Vrátí počet období pro investici vypočítaný na základě pravidelných konstantních splátek a konstantní úrokové sazby. Chcete-li například zadat čtvrtletní splátky realizované 6. dubna, použijte 6%/4."
	},
	"NPV": {
		"a": "(sazba; hodnota1; [hodnota2]; ...)",
		"d": "Vrátí čistou současnou hodnotu investice vypočítanou na základě diskontní sazby a série budoucích plateb (záporné hodnoty) a příjmů (kladné hodnoty)."
	},
	"ODDFPRICE": {
		"a": "(vypořádání; splatnost; emise; první_úrok; sazba; výnos; zaruč_cena; počet_plateb; [základna])",
		"d": "Vrátí cenu cenného papíru o nominální hodnotě 100 Kč s odlišným prvním obdobím."
	},
	"ODDFYIELD": {
		"a": "(vypořádání; splatnost; emise; první_úrok; sazba; cena; zaruč_cena; počet_plateb; [základna])",
		"d": "Vrátí výnos cenného papíru s odlišným prvním obdobím."
	},
	"ODDLPRICE": {
		"a": "(vypořádání; splatnost; poslední_úrok; sazba; výnos; zaruč_cena; počet_plateb; [základna])",
		"d": "Vrátí cenu cenného papíru o nominální hodnotě 100 Kč s odlišným posledním obdobím."
	},
	"ODDLYIELD": {
		"a": "(vypořádání; splatnost; poslední_úrok; sazba; cena; zaruč_cena; počet_plateb; [základna])",
		"d": "Vrátí výnos cenného papíru s odlišným posledním obdobím."
	},
	"PDURATION": {
		"a": "(sazba; souč_hod; bud_hod)",
		"d": "Vrátí počet období požadovaných investicí k tomu, aby dosáhla zadané hodnoty"
	},
	"PMT": {
		"a": "(sazba; pper; souč_hod; [bud_hod]; [typ])",
		"d": "Vypočte splátku půjčky na základě konstantních splátek a konstantní úrokové sazby."
	},
	"PPMT": {
		"a": "(sazba; za; pper; souč_hod; [bud_hod]; [typ])",
		"d": "Vrátí hodnotu splátky jistiny pro zadanou investici vypočtenou na základě pravidelných konstantních splátek a konstantní úrokové sazby."
	},
	"PRICE": {
		"a": "(vypořádání; splatnost; sazba; výnos; zaruč_cena; počet_plateb; [základna])",
		"d": "Vrátí cenu cenného papíru o nominální hodnotě 100 Kč, ze kterého je úrok placen v pravidelných termínech."
	},
	"PRICEDISC": {
		"a": "(vypořádání; splatnost; diskont_sazba; zaruč_cena; [základna])",
		"d": "Vrátí cenu diskontního cenného papíru o nominální hodnotě 100 Kč."
	},
	"PRICEMAT": {
		"a": "(vypořádání; splatnost; emise; sazba; výnos; [základna])",
		"d": "Vrátí cenu cenného papíru o nominální hodnotě 100 Kč, ze kterého je úrok placen k datu splatnosti."
	},
	"PV": {
		"a": "(sazba; pper; splátka; [bud_hod]; [typ])",
		"d": "Vrátí současnou hodnotu investice: celkovou hodnotu série budoucích plateb."
	},
	"RATE": {
		"a": "(pper; splátka; souč_hod; [bud_hod]; [typ]; [odhad])",
		"d": "Vrátí úrokovou sazbu vztaženou na období půjčky nebo investice. Chcete-li například zadat čtvrtletní splátky realizované 6. dubna, použijte 6%/4."
	},
	"RECEIVED": {
		"a": "(vypořádání; splatnost; investice; diskont_sazba; [základna])",
		"d": "Vrátí částku obdrženou k datu splatnosti plně investovaného cenného papíru."
	},
	"RRI": {
		"a": "(nper; souč_hod; bud_hod)",
		"d": "Vrátí odpovídající úrokovou sazbu pro růst investic"
	},
	"SLN": {
		"a": "(náklady; zůstatek; životnost)",
		"d": "Vrátí přímé odpisy aktiva pro jedno období."
	},
	"SYD": {
		"a": "(náklady; zůstatek; životnost; za)",
		"d": "Vrátí směrné číslo ročních odpisů aktiva pro zadané období."
	},
	"TBILLEQ": {
		"a": "(vypořádání; splatnost; diskont_sazba)",
		"d": "Vrátí výnos směnky státní pokladny ekvivalentní výnosu obligace."
	},
	"TBILLPRICE": {
		"a": "(vypořádání; splatnost; diskont_sazba)",
		"d": "Vrátí cenu směnky státní pokladny o nominální hodnotě 100 Kč."
	},
	"TBILLYIELD": {
		"a": "(vypořádání; splatnost; cena)",
		"d": "Vrátí výnos směnky státní pokladny."
	},
	"VDB": {
		"a": "(cena; zůstatek; životnost; začátek; konec; [faktor]; [nepřepínat])",
		"d": "Vypočte odpisy aktiva pro každé zadané období, včetně neukončených období, pomocí dvojité degresivní metody odpisu nebo jiné metody, kterou zadáte."
	},
	"XIRR": {
		"a": "(hodnoty; data; [odhad])",
		"d": "Vrátí vnitřní výnosnost pro harmonogram peněžních toků."
	},
	"XNPV": {
		"a": "(sazba; hodnoty; data)",
		"d": "Vrátí čistou současnou hodnotu pro harmonogram peněžních toků."
	},
	"YIELD": {
		"a": "(vypořádání; splatnost; sazba; cena; zaruč_cena; počet_plateb; [základna])",
		"d": "Vrátí výnos cenného papíru, ze kterého je úrok placen v pravidelných termínech."
	},
	"YIELDDISC": {
		"a": "(vypořádání; splatnost; cena; zaruč_cena; [základna])",
		"d": "Vrátí roční výnos diskontního cenného papíru, například směnky státní pokladny."
	},
	"YIELDMAT": {
		"a": "(vypořádání; splatnost; emise; sazba; cena; [základna])",
		"d": "Vrátí roční výnos cenného papíru, ze kterého je úrok placen k datu splatnosti."
	},
	"ABS": {
		"a": "(číslo)",
		"d": "Vrátí absolutní hodnotu čísla. Výsledek je číslo bez znaménka."
	},
	"ACOS": {
		"a": "(číslo)",
		"d": "Vrátí hodnotu arkuskosinu čísla. Výsledek je v radiánech v rozsahu 0 až pí. Arkuskosinus je úhel, jehož kosinus je argument Číslo."
	},
	"ACOSH": {
		"a": "(číslo)",
		"d": "Vrátí hodnotu hyperbolického arkuskosinu čísla."
	},
	"ACOT": {
		"a": "(číslo)",
		"d": "Vrátí arkuskotangens čísla. Výsledek je v radiánech v rozsahu 0 až pí."
	},
	"ACOTH": {
		"a": "(číslo)",
		"d": "Vrátí inverzní hyperbolický kotangens čísla"
	},
	"AGGREGATE": {
		"a": "(funkce; možnosti; odkaz1; ...)",
		"d": "Vrátí agregaci v seznamu nebo databázi."
	},
	"ARABIC": {
		"a": "(text)",
		"d": "Převede římskou číslici na arabskou."
	},
	"ASC": {
		"a": "(text)",
		"d": "U jazyků využívajících dvoubajtové znakové sady (DBCS) změní znaky s plnou šířkou (dvoubajtové) na znaky s poloviční šířkou (jednobajtové)"
	},
	"ASIN": {
		"a": "(číslo)",
		"d": "Vrátí arkussinus čísla. Výsledek je v radiánech v rozsahu -pí/2 až pí/2."
	},
	"ASINH": {
		"a": "(číslo)",
		"d": "Vrátí hyperbolický arkussinus čísla."
	},
	"ATAN": {
		"a": "(číslo)",
		"d": "Vrátí arkustangens čísla. Výsledek je v radiánech v rozsahu -pí/2 až pí/2."
	},
	"ATAN2": {
		"a": "(x_číslo; y_číslo)",
		"d": "Vrátí arkustangens zadané x-ové a y-ové souřadnice. Výsledek je v radiánech v rozsahu -pí až pí kromě hodnoty -pí."
	},
	"ATANH": {
		"a": "(číslo)",
		"d": "Vrátí hyperbolický arkustangens čísla."
	},
	"BASE": {
		"a": "(číslo; radix; [min_length])",
		"d": "Převede číslo na textové vyjádření s danou číselnou základnou."
	},
	"CEILING": {
		"a": "(číslo; významnost)",
		"d": "Zaokrouhlí číslo nahoru na nejbližší násobek zadané hodnoty významnosti."
	},
	"CEILING.MATH": {
		"a": "(číslo; [významnost]; [režim])",
		"d": "Zaokrouhlí číslo nahoru na nejbližší celé číslo nebo na nejbližší násobek zadané hodnoty významnosti"
	},
	"CEILING.PRECISE": {
		"a": "(číslo; [významnost])",
		"d": "Vrátí číslo zaokrouhlené nahoru na nejbližší celé číslo nebo na nejbližší násobek zadané hodnoty"
	},
	"COMBIN": {
		"a": "(počet; kombinace)",
		"d": "Vrátí počet kombinací pro zadaný počet položek."
	},
	"COMBINA": {
		"a": "(počet; kombinace)",
		"d": "Vrátí počet kombinací s opakováním pro daný počet položek"
	},
	"COS": {
		"a": "(číslo)",
		"d": "Vrátí kosinus úhlu."
	},
	"COSH": {
		"a": "(číslo)",
		"d": "Vrátí hyperbolický kosinus čísla."
	},
	"COT": {
		"a": "(číslo)",
		"d": "Vrátí kotangens úhlu"
	},
	"COTH": {
		"a": "(číslo)",
		"d": "Vrátí hyperbolický kotangens čísla"
	},
	"CSC": {
		"a": "(číslo)",
		"d": "Vrátí kosekans úhlu"
	},
	"CSCH": {
		"a": "(číslo)",
		"d": "Vrátí hyperbolický kosekans úhlu"
	},
	"DECIMAL": {
		"a": "(číslo; základ)",
		"d": "Převede textové vyjádření čísla v daném základu na desítkové číslo"
	},
	"DEGREES": {
		"a": "(úhel)",
		"d": "Převede radiány na stupně."
	},
	"ECMA.CEILING": {
		"a": "(číslo; významnost)",
		"d": "Zaokrouhlí číslo nahoru na nejbližší násobek zadané hodnoty významnosti"
	},
	"EVEN": {
		"a": "(číslo)",
		"d": "Zaokrouhlí kladné číslo nahoru a záporné číslo dolů na nejbližší sudé celé číslo."
	},
	"EXP": {
		"a": "(číslo)",
		"d": "Vrátí základ přirozeného logaritmu umocněný na zadané číslo."
	},
	"FACT": {
		"a": "(číslo)",
		"d": "Vrátí faktoriál čísla. Výsledek se rovná hodnotě 1*2*3*...*Číslo."
	},
	"FACTDOUBLE": {
		"a": "(číslo)",
		"d": "Vrátí dvojitý faktoriál čísla."
	},
	"FLOOR": {
		"a": "(číslo; významnost)",
		"d": "Zaokrouhlí číslo dolů na nejbližší násobek zadané hodnoty významnosti."
	},
	"FLOOR.PRECISE": {
		"a": "(číslo; [významnost])",
		"d": "Vrátí číslo zaokrouhlené dolů na nejbližší celé číslo nebo na nejbližší násobek zadané hodnoty"
	},
	"FLOOR.MATH": {
		"a": "(číslo; [významnost]; [režim])",
		"d": "Zaokrouhlí číslo dolů na nejbližší celé číslo nebo na nejbližší násobek zadané hodnoty významnosti"
	},
	"GCD": {
		"a": "(číslo1; [číslo2]; ...)",
		"d": "Vrátí největší společný dělitel."
	},
	"INT": {
		"a": "(číslo)",
		"d": "Zaokrouhlí číslo dolů na nejbližší celé číslo."
	},
	"ISO.CEILING": {
		"a": "(číslo; [významnost])",
		"d": "Vrátí číslo zaokrouhlené nahoru na nejbližší celé číslo nebo na nejbližší násobek zadané hodnoty. Číslo bude zaokrouhleno nahoru bez ohledu na jeho znaménko. Pokud je však zadáno číslo nula nebo násobek nuly, bude vrácena nula."
	},
	"LCM": {
		"a": "(číslo1; [číslo2]; ...)",
		"d": "Vrátí nejmenší společný násobek."
	},
	"LN": {
		"a": "(číslo)",
		"d": "Vrátí přirozený logaritmus čísla."
	},
	"LOG": {
		"a": "(číslo; [základ])",
		"d": "Vrátí logaritmus čísla při zadaném základu."
	},
	"LOG10": {
		"a": "(číslo)",
		"d": "Vrátí dekadický logaritmus čísla."
	},
	"MDETERM": {
		"a": "(pole)",
		"d": "Vrátí determinant matice."
	},
	"MINVERSE": {
		"a": "(pole)",
		"d": "Vrátí inverzní matici k matici, která je uložena v oblasti definované jako matice."
	},
	"MMULT": {
		"a": "(pole1; pole2)",
		"d": "Vrátí součin dvou matic, matici se stejným počtem řádků jako matice argumentu Pole1 a stejným počtem sloupců jako matice argumentu Pole2."
	},
	"MOD": {
		"a": "(číslo; dělitel)",
		"d": "Vrátí zbytek po dělení čísla."
	},
	"MROUND": {
		"a": "(číslo; násobek)",
		"d": "Vrátí číslo zaokrouhlené na požadovaný násobek."
	},
	"MULTINOMIAL": {
		"a": "(číslo1; [číslo2]; ...)",
		"d": "Vrátí mnohočlen sady čísel."
	},
	"MUNIT": {
		"a": "(dimenze)",
		"d": "Vrátí matici jednotek pro zadanou dimenzi"
	},
	"ODD": {
		"a": "(číslo)",
		"d": "Zaokrouhlí kladné číslo nahoru a záporné číslo dolů na nejbližší liché celé číslo."
	},
	"PI": {
		"a": "()",
		"d": "Vrátí hodnotu čísla pí s přesností na 15 číslic. Výsledek je hodnota 3.14159265358979."
	},
	"POWER": {
		"a": "(číslo; exponent)",
		"d": "Umocní číslo na zadaný exponent."
	},
	"PRODUCT": {
		"a": "(číslo1; [číslo2]; ...)",
		"d": "Vynásobí všechna čísla zadaná jako argumenty."
	},
	"QUOTIENT": {
		"a": "(numerátor; denominátor)",
		"d": "Vrátí celou část dělení."
	},
	"RADIANS": {
		"a": "(úhel)",
		"d": "Převede stupně na radiány."
	},
	"RAND": {
		"a": "()",
		"d": "Vrátí náhodné číslo větší nebo rovné 0 a menší než 1 určené na základě spojité distribuční funkce (změní se při každém přepočítání listu)."
	},
	"RANDARRAY": {
		"a": "([řádků]; [sloupců]; [min]; [max]; [celé_číslo])",
		"d": "Vrátí pole náhodných čísel"
	},
	"RANDBETWEEN": {
		"a": "(dolní; horní)",
		"d": "Vrátí náhodné číslo mezi zadanými čísly."
	},
	"ROMAN": {
		"a": "(číslo; [forma])",
		"d": "Převede číslo napsané pomocí arabských číslic na římské číslice ve formátu textu."
	},
	"ROUND": {
		"a": "(číslo; číslice)",
		"d": "Zaokrouhlí číslo na zadaný počet číslic."
	},
	"ROUNDDOWN": {
		"a": "(číslo; číslice)",
		"d": "Zaokrouhlí číslo dolů směrem k nule."
	},
	"ROUNDUP": {
		"a": "(číslo; číslice)",
		"d": "Zaokrouhlí číslo nahoru směrem od nuly."
	},
	"SEC": {
		"a": "(číslo)",
		"d": "Vrátí sekans úhlu"
	},
	"SECH": {
		"a": "(číslo)",
		"d": "Vrátí hyperbolický sekans úhlu"
	},
	"SERIESSUM": {
		"a": "(x; n; m; koeficient)",
		"d": "Vrátí součet mocninné řady určené podle vzorce."
	},
	"SIGN": {
		"a": "(číslo)",
		"d": "Vrátí znaménko čísla: číslo 1 pro kladné číslo, 0 pro nulu nebo -1 pro záporné číslo."
	},
	"SIN": {
		"a": "(číslo)",
		"d": "Vrátí sinus úhlu."
	},
	"SINH": {
		"a": "(číslo)",
		"d": "Vrátí hyperbolický sinus čísla."
	},
	"SQRT": {
		"a": "(číslo)",
		"d": "Vrátí druhou odmocninu čísla."
	},
	"SQRTPI": {
		"a": "(číslo)",
		"d": "Vrátí druhou odmocninu výrazu (číslo * pí)."
	},
	"SUBTOTAL": {
		"a": "(funkce; odkaz1; ...)",
		"d": "Vrátí souhrn na listu nebo v databázi."
	},
	"SUM": {
		"a": "(číslo1; [číslo2]; ...)",
		"d": "Sečte všechna čísla v oblasti buněk."
	},
	"SUMIF": {
		"a": "(oblast; kritéria; [součet])",
		"d": "Sečte buňky vybrané podle zadaných kritérií."
	},
	"SUMIFS": {
		"a": "(oblast_součtu; oblast_kritérií; kritérium; ...)",
		"d": "Sečte buňky určené danou sadou podmínek nebo kritérií."
	},
	"SUMPRODUCT": {
		"a": "(pole1; [pole2]; [pole3]; ...)",
		"d": "Vrátí součet součinů odpovídajících oblastí nebo matic."
	},
	"SUMSQ": {
		"a": "(číslo1; [číslo2]; ...)",
		"d": "Vrátí součet druhých mocnin argumentů. Argumenty mohou představovat čísla, matice, názvy nebo odkazy na buňky obsahující čísla."
	},
	"SUMX2MY2": {
		"a": "(pole_x; pole_y)",
		"d": "Vypočte součet rozdílů čtverců dvou odpovídajících oblastí nebo polí."
	},
	"SUMX2PY2": {
		"a": "(pole_x; pole_y)",
		"d": "Vrátí celkový součet součtů čtverců čísel ve dvou odpovídajících oblastech nebo maticích."
	},
	"SUMXMY2": {
		"a": "(pole_x; pole_y)",
		"d": "Vypočte součet čtverců rozdílů dvou odpovídajících oblastí nebo matic."
	},
	"TAN": {
		"a": "(číslo)",
		"d": "Vrátí tangens úhlu."
	},
	"TANH": {
		"a": "(číslo)",
		"d": "Vrátí hyperbolický tangens čísla."
	},
	"TRUNC": {
		"a": "(číslo; [desetiny])",
		"d": "Zkrátí číslo na celé číslo odstraněním desetinné nebo zlomkové části čísla."
	},
	"ADDRESS": {
		"a": "(řádek; sloupec; [typ]; [a1]; [list])",
		"d": "Vytvoří textový odkaz na buňku po zadání čísla řádku a sloupce."
	},
	"CHOOSE": {
		"a": "(index; hodnota1; [hodnota2]; ...)",
		"d": "Zvolí hodnotu nebo akci, která má být provedena, ze seznamu hodnot na základě zadaného argumentu Index."
	},
	"COLUMN": {
		"a": "([odkaz])",
		"d": "Vrátí číslo sloupce odkazu."
	},
	"COLUMNS": {
		"a": "(pole)",
		"d": "Vrátí počet sloupců v matici nebo odkazu."
	},
	"FORMULATEXT": {
		"a": "(odkaz)",
		"d": "Vrátí vzorec jako řetězec"
	},
	"HLOOKUP": {
		"a": "(hledat; tabulka; řádek; [typ])",
		"d": "Prohledá horní řádek tabulky nebo matice hodnot a vrátí hodnotu ze zadaného řádku obsaženou ve stejném sloupci."
	},
	"HYPERLINK": {
		"a": "(umístění; [název])",
		"d": "Vytvoří zástupce nebo odkaz, který otevře dokument uložený na pevném disku, síťovém serveru nebo na síti Internet."
	},
	"INDEX": {
		"a": "(pole; řádek; [sloupec]!odkaz; řádek; [sloupec]; [oblast])",
		"d": "Vrátí hodnotu nebo odkaz na buňku v určitém řádku a sloupci v dané oblasti."
	},
	"INDIRECT": {
		"a": "(odkaz; [a1])",
		"d": "Vrátí odkaz určený textovým řetězcem."
	},
	"LOOKUP": {
		"a": "(co; hledat; [výsledek]!co; pole)",
		"d": "Vyhledá požadovanou hodnotu v matici nebo v oblasti obsahující jeden řádek nebo jeden sloupec. Funkce je poskytnuta k zajištění zpětné kompatibility"
	},
	"MATCH": {
		"a": "(co; prohledat; [shoda])",
		"d": "Vrátí relativní polohu položky matice, která odpovídá určené hodnotě v určeném pořadí."
	},
	"OFFSET": {
		"a": "(odkaz; řádky; sloupce; [výška]; [šířka])",
		"d": "Vrátí odkaz na oblast, která představuje daný počet řádků a sloupců z daného odkazu."
	},
	"ROW": {
		"a": "([odkaz])",
		"d": "Vrátí číslo řádku odkazu."
	},
	"ROWS": {
		"a": "(pole)",
		"d": "Vrátí počet řádků v odkazu nebo matici."
	},
	"TRANSPOSE": {
		"a": "(pole)",
		"d": "Převede vodorovnou oblast buněk na svislou nebo naopak."
	},
	"UNIQUE": {
		"a": "(pole; [sloupce]; [právě_jednou])",
		"d": "Vrátí jedinečné hodnoty z rozsahu nebo pole."
	},
	"VLOOKUP": {
		"a": "(hledat; tabulka; sloupec; [typ])",
		"d": "Vyhledá hodnotu v krajním levém sloupci tabulky a vrátí hodnotu ze zadaného sloupce ve stejném řádku. Tabulka musí být standardně seřazena vzestupně."
	},
	"XLOOKUP": {
		"a": "(co; prohledat; vrátit; [pokud_nenalezeno]; [režim_shody]; [režim_vyhledávání])",
		"d": "Vyhledá požadovanou hodnotu v oblasti nebo poli a vrátí odpovídající položku z jiné oblasti nebo pole. Ve výchozím nastavení se vyžaduje přesná shoda."
	},
	"CELL": {
		"a": "(informace; [odkaz])",
		"d": "Vrátí informace o formátování, umístění nebo obsahu buňky"
	},
	"ERROR.TYPE": {
		"a": "(chyba)",
		"d": "Vrátí číslo odpovídající chybové hodnotě."
	},
	"ISBLANK": {
		"a": "(hodnota)",
		"d": "Ověří, zda odkaz v argumentu Hodnota odkazuje na prázdnou buňku a vrátí hodnotu PRAVDA nebo NEPRAVDA."
	},
	"ISERR": {
		"a": "(hodnota)",
		"d": "Ověří, jestli argument Hodnota představuje jinou chybu než #NENÍ_K_DISPOZICI, a vrátí hodnotu PRAVDA nebo NEPRAVDA."
	},
	"ISERROR": {
		"a": "(hodnota)",
		"d": "Ověří, jestli argument Hodnota představuje chybu, a vrátí hodnotu PRAVDA nebo NEPRAVDA."
	},
	"ISEVEN": {
		"a": "(číslo)",
		"d": "Vrátí logickou hodnotu PRAVDA, pokud je číslo sudé."
	},
	"ISFORMULA": {
		"a": "(odkaz)",
		"d": "Ověří, jestli odkaz odkazuje na buňku obsahující vzorec, a vrátí hodnotu PRAVDA nebo NEPRAVDA"
	},
	"ISLOGICAL": {
		"a": "(hodnota)",
		"d": "Ověří, zda argument Hodnota je logická hodnota (PRAVDA nebo NEPRAVDA) a vrátí hodnotu PRAVDA nebo NEPRAVDA."
	},
	"ISNA": {
		"a": "(hodnota)",
		"d": "Ověří, zda je argument Hodnota chybová hodnota #NENÍ_K_DISPOZICI, a vrátí hodnotu PRAVDA nebo NEPRAVDA."
	},
	"ISNONTEXT": {
		"a": "(hodnota)",
		"d": "Ověří, zda argument Hodnota není text (prázdné buňky nejsou text) a vrátí hodnotu PRAVDA nebo NEPRAVDA."
	},
	"ISNUMBER": {
		"a": "(hodnota)",
		"d": "Ověří, zda je argument Hodnota číslo a vrátí hodnotu PRAVDA nebo NEPRAVDA."
	},
	"ISODD": {
		"a": "(číslo)",
		"d": "Vrátí logickou hodnotu PRAVDA, pokud je číslo liché."
	},
	"ISREF": {
		"a": "(hodnota)",
		"d": "Ověří, zda je argument Hodnota odkaz a vrátí hodnotu PRAVDA nebo NEPRAVDA."
	},
	"ISTEXT": {
		"a": "(hodnota)",
		"d": "Ověří, zda je argument Hodnota text a vrátí hodnotu PRAVDA nebo NEPRAVDA."
	},
	"N": {
		"a": "(hodnota)",
		"d": "Převede nečíselnou hodnotu na číslo, kalendářní data na pořadová čísla, hodnotu PRAVDA na číslo 1 a všechny ostatní výrazy na číslo 0 (nula)."
	},
	"NA": {
		"a": "()",
		"d": "Vrátí chybovou hodnotu #NENÍ_K_DISPOZICI (hodnota nedostupná)."
	},
	"SHEET": {
		"a": "([hodnota])",
		"d": "Vrátí číslo listu odkazovaného listu"
	},
	"SHEETS": {
		"a": "([odkaz])",
		"d": "Vrátí počet listů v odkazu"
	},
	"TYPE": {
		"a": "(hodnota)",
		"d": "Vrátí celé číslo představující datový typ hodnoty: číslo = 1, text = 2, logická hodnota = 4, chybová hodnota = 16, matice = 64, složený datový typ = 128."
	},
	"AND": {
		"a": "(logická1; [logická2]; ...)",
		"d": "Ověří, zda mají všechny argumenty hodnotu PRAVDA, a v takovém případě vrátí hodnotu PRAVDA."
	},
	"FALSE": {
		"a": "()",
		"d": "Vrátí logickou hodnotu NEPRAVDA."
	},
	"IF": {
		"a": "(podmínka; [ano]; [ne])",
		"d": "Ověří, zda je podmínka splněna, a vrátí jednu hodnotu, jestliže je výsledkem hodnota PRAVDA, a jinou hodnotu, pokud je výsledkem hodnota NEPRAVDA."
	},
	"IFS": {
		"a": "(logický_test; podmínka; ...)",
		"d": "Zkontroluje, jestli je splněná jedna nebo víc podmínek, a vrátí hodnotu odpovídající první pravdivé podmínce."
	},
	"IFERROR": {
		"a": "(hodnota; hodnota_v_případě_chyby)",
		"d": "Pokud je výraz chybný, vrátí hodnotu hodnota_v_případě_chyby. V opačném případě vrátí vlastní hodnotu výrazu."
	},
	"IFNA": {
		"a": "(hodnota; hodnota_pokud_na)",
		"d": "Vrátí zadanou hodnotu, pokud je výsledkem výrazu hodnota #N/A, v opačném případě vrátí výsledek výrazu"
	},
	"NOT": {
		"a": "(loghod)",
		"d": "Změní hodnotu NEPRAVDA na PRAVDA nebo naopak."
	},
	"OR": {
		"a": "(logická1; [logická2]; ...)",
		"d": "Ověří, zda je nejméně jeden argument roven hodnotě PRAVDA, a vrátí hodnotu PRAVDA nebo NEPRAVDA. Vrátí hodnotu NEPRAVDA pouze v případě, že všechny argumenty jsou rovny hodnotě NEPRAVDA."
	},
	"SWITCH": {
		"a": "(výraz; hodnota1; výsledek1; [výchozí_nebo_hodnota2]; [výsledek2]; ...)",
		"d": "Vyhodnocuje výraz oproti seznamu hodnot a vrací výsledek odpovídající první shodné hodnotě. Pokud se neshoduje žádná hodnota, vrátí volitelnou výchozí hodnotu."
	},
	"TRUE": {
		"a": "()",
		"d": "Vrátí logickou hodnotu PRAVDA."
	},
	"XOR": {
		"a": "(logická1; [logická2]; ...)",
		"d": "Vrátí logickou hodnotu Výhradní nebo všech argumentů"
	},
	"TEXTBEFORE": {
		"a": "(text, delimiter, [instance_num], [match_mode], [match_end], [if_not_found])",
		"d": "Vrátí text, který je před oddělovači znaků."
	},
	"TEXTAFTER": {
		"a": "(text, delimiter, [instance_num], [match_mode], [match_end], [if_not_found])",
		"d": "Vrátí text, který je po oddělovači znaků."
	},
	"TEXTSPLIT": {
		"a": "(text, col_delimiter, [row_delimiter], [ignore_empty], [match_mode], [pad_with])",
		"d": "Rozdělí text na řádky nebo sloupce pomocí oddělovačů."
	},
	"WRAPROWS": {
		"a": "(vector, wrap_count, [pad_with])",
		"d": "Zalomí vektor řádku nebo sloupce po zadaném počtu hodnot."
	},
	"VSTACK": {
		"a": "(array1, [array2], ...)",
		"d": " Svisle skládá pole do jednoho pole."
	},
	"HSTACK": {
		"a": "(array1, [array2], ...)",
		"d": " Vodorovně skládá pole do jednoho pole."
	},
	"CHOOSEROWS": {
		"a": "(array, row_num1, [row_num2], ...)",
		"d": "Vrátí řádky z pole nebo odkazu."
	},
	"CHOOSECOLS": {
		"a": "(array, col_num1, [col_num2], ...)",
		"d": "Vrátí sloupce z pole nebo odkazu."
	},
	"TOCOL": {
		"a": "(array, [ignore], [scan_by_column])",
		"d": "Vrátí pole jako jeden sloupec."
	},
	"TOROW": {
		"a": "(pole, [ignorovat], [prohledávat_podle_sloupce])",
		"d": "Vrátí pole jako jeden řádek. "
	},
	"WRAPCOLS": {
		"a": "(vektor, wrap_count, [pad_with])",
		"d": " Zabalí vektor řádku nebo sloupce po zadaném počtu hodnot."
	},
	"TAKE": {
		"a": "(array, rows, [columns])",
		"d": "Vrátí řádky nebo sloupce ze začátku nebo konce pole."
	},
	"DROP": {
		"a": "(array, rows, [columns])",
		"d": "Přemístí řádky nebo sloupce ze začátku nebo konce pole."
	}
}