web-apps/apps/spreadsheeteditor/main/resources/formula-lang/lv_desc.json
2021-05-27 22:15:25 +03:00

1842 lines
66 KiB
JSON

{
"DATE": {
"a": "(gads; mēnesis; diena)",
"d": "Atgriež skaitli, kas apzīmē datumu datuma/laika kodā"
},
"DATEDIF": {
"a": "( start-date; end-date; unit )",
"d": "Date and time function used to return the difference between two date values (start date and end date), based on the interval (unit) specified"
},
"DATEVALUE": {
"a": "(datums_teksts)",
"d": "Pārveido datumu teksta formātā par skaitli, kas apzīmē datumu datuma/laika kodā"
},
"DAY": {
"a": "(seriālais_skaitlis)",
"d": "Atgriež mēneša dienu - skaitli no 1 līdz 31."
},
"DAYS": {
"a": "(beigu_datums; sākuma_datums)",
"d": "Atgriež dienu skaitu starp diviem datumiem."
},
"DAYS360": {
"a": "(sākuma_datums; beigu_datums; [metode])",
"d": "Atgriež dienu skaitu starp diviem datumiem, pieņemot, ka gadā ir 360 dienas (divpadsmit 30 dienu mēneši)"
},
"EDATE": {
"a": "(sākuma_datums; mēneši)",
"d": "Atgriež datuma sērijas numuru, kas ir norādītais mēnešu skaits pirms vai pēc sākuma datuma"
},
"EOMONTH": {
"a": "(sākuma_datums; mēneši)",
"d": "Atgriež tās mēneša pēdējās dienas sērijas numuru, kas ir pirms vai pēc noteikta mēnešu skaita"
},
"HOUR": {
"a": "(seriālais_skaitlis)",
"d": "Atgriež stundu kā skaitli no 0 (12:00 A.M.) līdz 23 (11:00 P.M.)."
},
"ISOWEEKNUM": {
"a": "(datums)",
"d": "Atgriež gada ISO nedēļas numuru noteiktam datumam"
},
"MINUTE": {
"a": "(seriālais_skaitlis)",
"d": "Atgriež minūti kā skaitli no 0 līdz 59."
},
"MONTH": {
"a": "(seriālais_skaitlis)",
"d": "Atgriež mēnesi - skaitli no 1 (janvāris) līdz 12 (decembris)."
},
"NETWORKDAYS": {
"a": "(sākuma_datums; beigu_datums; [brīvdienas])",
"d": "Atgriež pilnu darbdienu skaitu starp diviem datumiem"
},
"NETWORKDAYS.INTL": {
"a": "(sākuma_datums; beigu_datums; [nedēļas_nogale]; [brīvdienas])",
"d": "Atgriež pilnu darbdienu skaitu starp diviem datumiem ar pielāgotu nedēļas nogales parametru"
},
"NOW": {
"a": "()",
"d": "Atgriež šīsdienas datumu un laiku, kas formatēts kā datums un laiks."
},
"SECOND": {
"a": "(seriālais_skaitlis)",
"d": "Atgriež sekundi kā skaitli no 0 līdz 59."
},
"TIME": {
"a": "(stunda; minūte; sekunde)",
"d": "Konvertē stundas, minūtes un sekundes, kas norādītas kā skaitļi, par seriālo skaitli, kas formatēts laika formātā"
},
"TIMEVALUE": {
"a": "(laiks)",
"d": "Konvertē teksta laiku seriālā skaitlī, kas apzīmē laiku, - skaitlī no 0 (00:00:00) līdz 0.999988426 (23:59:59). Formatējiet skaitli laika formātā pēc formulas ievadīšanas"
},
"TODAY": {
"a": "()",
"d": "Atgriež pašreizējo datumu, kas ir formatēts kā datums."
},
"WEEKDAY": {
"a": "(seriālais_skaitlis; [atgriešanas_tips])",
"d": "Atgriež skaitli no 1 līdz 7, kas apzīmē nedēļas dienu."
},
"WEEKNUM": {
"a": "(sērijas_numurs; [atgriešanas_tips])",
"d": "Atgriež gada nedēļas numuru"
},
"WORKDAY": {
"a": "(sākuma_datums; dienas; [brīvdienas])",
"d": "Atgriež tā datuma sērijas numuru, kas ir pirms vai pēc noteiktā darbdienas numura"
},
"WORKDAY.INTL": {
"a": "(sākuma_datums; dienas; [nedēļas_nogale]; [brīvdienas])",
"d": "Atgriež tā datuma sērijas numuru, kas ir pirms vai pēc noteiktā darbdienas numura ar pielāgotiem nedēļas nogales parametriem"
},
"YEAR": {
"a": "(seriālais_skaitlis)",
"d": "Atgriež gadu - veselu skaitli robežās no 1900 līdz 9999."
},
"YEARFRAC": {
"a": "(sākuma_datums; beigu_datums; [pamats])",
"d": "Atgriež gada daļu, kas ataino veselu dienu skaitu laika posmā starp sākuma_datumu un beigu_datumu"
},
"BESSELI": {
"a": "(x; n)",
"d": "Atgriež modificēto Beseļa funkciju In(x)"
},
"BESSELJ": {
"a": "(x; n)",
"d": "Atgriež Beseļa funkciju Jn(x)"
},
"BESSELK": {
"a": "(x; n)",
"d": "Atgriež modificēto Beseļa funkciju Kn(x)"
},
"BESSELY": {
"a": "(x; n)",
"d": "Atgriež Beseļa funkciju Yn(x)"
},
"BIN2DEC": {
"a": "(skaitlis)",
"d": "Pārvērš bināru skaitli decimālā"
},
"BIN2HEX": {
"a": "(skaitlis; [vietas])",
"d": "Pārvērš bināru skaitli heksadecimālā"
},
"BIN2OCT": {
"a": "(skaitlis; [vietas])",
"d": "Pārvērš bināru skaitli oktālā"
},
"BITAND": {
"a": "(skaitlis1; skaitlis2)",
"d": "Bitu veidā atgriež divu skaitļu vērtību \"Un\""
},
"BITLSHIFT": {
"a": "(skaitlis; pārvietoš_apjoms)",
"d": "Atgriež skaitli, kas pārvietots pa kreisi pa pārvietošanas_apjoma bitiem"
},
"BITOR": {
"a": "(skaitlis1; skaitlis2)",
"d": "Bitu veidā atgriež divu skaitļu vērtību \"Vai\""
},
"BITRSHIFT": {
"a": "(skaitlis; pārvietoš_apjoms)",
"d": "Atgriež skaitli, kas pārvietots pa labi pa pārvietošanas_daudzuma bitiem"
},
"BITXOR": {
"a": "(skaitlis1; skaitlis2)",
"d": "Bitu veidā atgriež divu skaitļu vērtību \"Izņemot/Vai\""
},
"COMPLEX": {
"a": "(reāls_skaitlis; i_skaitlis; [sufikss])",
"d": "Konvertē reālus un iedomātus koeficientus saliktā skaitlī"
},
"CONVERT": {
"a": "(skaitlis; no_vienības; līdz_vienībai)",
"d": "Konvertē skaitli no vienas mērvienību sistēmas citā"
},
"DEC2BIN": {
"a": "(skaitlis; [vietas])",
"d": "Pārvērš decimālskaitli binārā"
},
"DEC2HEX": {
"a": "(skaitlis; [vietas])",
"d": "Pārvērš decimālskaitli heksadecimālā"
},
"DEC2OCT": {
"a": "(skaitlis; [vietas])",
"d": "Pārvērš decimālskaitli oktālā"
},
"DELTA": {
"a": "(skaitlis1; [skaitlis2])",
"d": "Pārbauda, vai divi skaitļi ir vienādi"
},
"ERF": {
"a": "(apakšējā_robeža; [augšējā_robeža])",
"d": "Atgriež kļūdas funkciju"
},
"ERF.PRECISE": {
"a": "(X)",
"d": "Atgriež kļūdas funkciju"
},
"ERFC": {
"a": "(x)",
"d": "Atgriež papildu kļūdas funkciju"
},
"ERFC.PRECISE": {
"a": "(x)",
"d": "Atgriež papildu kļūdas funkciju"
},
"GESTEP": {
"a": "(skaitlis; [solis])",
"d": "Pārbauda, vai skaitlis ir lielāks par sliekšņa vērtību"
},
"HEX2BIN": {
"a": "(skaitlis; [vietas])",
"d": "Pārvērš heksadecimālu skaitli binārā"
},
"HEX2DEC": {
"a": "(skaitlis)",
"d": "Pārvērš heksadecimālu skaitli decimālā"
},
"HEX2OCT": {
"a": "(skaitlis; [vietas])",
"d": "Pārvērš heksadecimālu skaitli oktālā"
},
"IMABS": {
"a": "(iskaitlis)",
"d": "Atgriež salikta skaitļa absolūto vērtību (moduli)"
},
"IMAGINARY": {
"a": "(iskaitlis)",
"d": "Atgriež salikta skaitļa iedomāto koeficientu"
},
"IMARGUMENT": {
"a": "(iskaitlis)",
"d": "Atgriež argumentu q, leņķi, kas izteikts radiānos"
},
"IMCONJUGATE": {
"a": "(iskaitlis)",
"d": "Atgriež salikta skaitļa saliktu konjugātu"
},
"IMCOS": {
"a": "(iskaitlis)",
"d": "Atgriež salikta skaitļa kosinusu"
},
"IMCOSH": {
"a": "(skaitlis)",
"d": "Atgriež salikta skaitļa hiperbolisko kosinusu"
},
"IMCOT": {
"a": "(skaitlis)",
"d": "Atgriež saliktā skaitļa kotangensu"
},
"IMCSC": {
"a": "(skaitlis)",
"d": "Atgriež saliktā skaitļa kosekansu"
},
"IMCSCH": {
"a": "(skaitlis)",
"d": "Atgriež saliktā skaitļa hiperbolisko kosekansu"
},
"IMDIV": {
"a": "(iskaitlis1; iskaitlis2)",
"d": "Atgriež divu saliktu skaitļu dalījumu"
},
"IMEXP": {
"a": "(iskaitlis)",
"d": "Atgriež salikta skaitļa eksponentu"
},
"IMLN": {
"a": "(iskaitlis)",
"d": "Atgriež salikta skaitļa naturālo logaritmu"
},
"IMLOG10": {
"a": "(iskaitlis)",
"d": "Atgriež salikta skaitļa bāzes 10 logaritmu"
},
"IMLOG2": {
"a": "(iskaitlis)",
"d": "Atgriež salikta skaitļa bāzes 2 logaritmu"
},
"IMPOWER": {
"a": "(iskaitlis; skaitlis)",
"d": "Atgriež saliktu skaitli, kas kāpināts veselā pakāpē"
},
"IMPRODUCT": {
"a": "(iskaitlis1; [iskaitlis2]; ...)",
"d": "Atgriež produktam saliktus skaitļus no 1 līdz 255"
},
"IMREAL": {
"a": "(iskaitlis)",
"d": "Atgriež salikta skaitļa reālo koeficientu"
},
"IMSEC": {
"a": "(skaitlis)",
"d": "Atgriež saliktā skaitļa sekanti"
},
"IMSECH": {
"a": "(skaitlis)",
"d": "Atgriež saliktā skaitļa hiperbolisko sekanti"
},
"IMSIN": {
"a": "(iskaitlis)",
"d": "Atgriež salikta skaitļa sinusu"
},
"IMSINH": {
"a": "(skaitlis)",
"d": "Atgriež salikta skaitļa hiperbolisko sinusu"
},
"IMSQRT": {
"a": "(skaitlis)",
"d": "Atgriež salikta skaitļa kvadrātsakni"
},
"IMSUB": {
"a": "(iskaitlis1; iskaitlis2)",
"d": "Atgriež divu saliktu skaitļu starpību"
},
"IMSUM": {
"a": "(iskaitlis1; [iskaitlis2]; ...)",
"d": "Atgriež salikta skaitļa summu"
},
"IMTAN": {
"a": "(skaitlis)",
"d": "Atgriež saliktā skaitļa tangensu"
},
"OCT2BIN": {
"a": "(skaitlis; [vietas])",
"d": "Pārvērš oktālu skaitli binārā"
},
"OCT2DEC": {
"a": "(skaitlis)",
"d": "Pārvērš oktālu skaitli decimālā"
},
"OCT2HEX": {
"a": "(skaitlis; [vietas])",
"d": "Pārvērš oktālu skaitli heksadecimālā"
},
"DAVERAGE": {
"a": "(datu_bāze; lauks; kritēriji)",
"d": "Aprēķina vidējo vērtību no vērtībām norādītajiem nosacījumiem atbilstošas datu bāzes ierakstu laukā (kolonnā)"
},
"DCOUNT": {
"a": "(datu_bāze; lauks; kritēriji)",
"d": "Saskaita šūnas, kurās ir skaitļi, norādītajiem nosacījumiem atbilstošas datu bāzes ierakstu laukā (kolonnā)"
},
"DCOUNTA": {
"a": "(datu_bāze; lauks; kritēriji)",
"d": "Saskaita netukšās šūnas ierakstu laukā (kolonnā) datu bāzē, kas atbilst norādītajiem kritērijiem"
},
"DGET": {
"a": "(datu_bāze; lauks; kritēriji)",
"d": "Izgūst no datu bāzes vienu ierakstu, kas atbilst norādītajiem nosacījumiem"
},
"DMAX": {
"a": "(datu_bāze; lauks; kritēriji)",
"d": "Atgriež vislielāko skaitli norādītajiem nosacījumiem atbilstošas datu bāzes ierakstu laukā (kolonnā)"
},
"DMIN": {
"a": "(datu_bāze; lauks; kritēriji)",
"d": "Atgriež vismazāko skaitli norādītajiem nosacījumiem atbilstošas datu bāzes ierakstu laukā (kolonnā)"
},
"DPRODUCT": {
"a": "(datu_bāze; lauks; kritēriji)",
"d": "Reizina vērtības, kuras atrodas datu bāzes ierakstu laukā (kolonnā), kas atbilst norādītajiem kritērijiem"
},
"DSTDEV": {
"a": "(datu_bāze; lauks; kritēriji)",
"d": "Aprēķina standartnovirzi, izmantojot atlasīto datu bāzes ievadņu izlasi"
},
"DSTDEVP": {
"a": "(datu_bāze; lauks; kritēriji)",
"d": "Aprēķina standartnovirzi, izmantojot atlasītu datu bāzes ievadņu visu populāciju"
},
"DSUM": {
"a": "(datu_bāze; lauks; kritēriji)",
"d": "Sasummē skaitļus norādītajiem nosacījumiem atbilstošas datu bāzes ierakstu laukā (kolonnā)"
},
"DVAR": {
"a": "(datu_bāze; lauks; kritēriji)",
"d": "Aprēķina dispersiju, izmantojot atlasīto datu bāzes ievadņu izlasi"
},
"DVARP": {
"a": "(datu_bāze; lauks; kritēriji)",
"d": "Aprēķina dispersiju, izmantojot atlasītu datu bāzes ievadņu visu populāciju"
},
"CHAR": {
"a": "(skaitlis)",
"d": "Atgriež rakstzīmi, kuru norāda koda numurs datora rakstzīmju kopā"
},
"CLEAN": {
"a": "(teksts)",
"d": "No teksta izņem visas nedrukājamās rakstzīmes"
},
"CODE": {
"a": "(teksts)",
"d": "Atgriež teksta virknes pirmās rakstzīmes skaitlisko kodu datorā izmantotajā rakstzīmju kopā"
},
"CONCATENATE": {
"a": "(teksts1; [teksts2]; ...)",
"d": "Savieno vairākas teksta virknes vienā"
},
"CONCAT": {
"a": "(teksts1; ...)",
"d": "Savieno teksta virkņu sarakstu vai diapazonu"
},
"DOLLAR": {
"a": "(skaitlis; [decimālskaitļi])",
"d": "Konvertē skaitli par tekstu, izmantojot valūtas formātu"
},
"EXACT": {
"a": "(teksts1; teksts2)",
"d": "Pārbauda, vai divas teksta virknes ir pilnīgi vienādas un atgriež TRUE vai FALSE. Funkcija EXACT ir reģistrjutīga"
},
"FIND": {
"a": "(atrast_tekstu; tekstā; [sākuma_num])",
"d": "Atgriež vienas teksta virknes sākuma pozīciju citā teksta virknē. Funkcija FIND ir reģistrjutīga"
},
"FINDB": {
"a": "( string-1; string-2; [start-pos] )",
"d": "Text and data function used to find the specified substring (string-1) within a string (string-2) and is intended for languages the double-byte character set (DBCS) like Japanese, Chinese, Korean etc."
},
"FIXED": {
"a": "(skaitlis; [decimāldaļas]; [bez_komatiem])",
"d": "Noapaļo skaitli līdz norādītajam decimāldaļu skaitam un atgriež rezultātu kā tekstu ar komatiem vai bez tiem"
},
"LEFT": {
"a": "(teksts; [skaitļu_rakstz])",
"d": "Atgriež norādīto rakstzīmju skaitu no teksta virknes sākuma"
},
"LEFTB": {
"a": "( string; [number-chars] )",
"d": "Text and data function used to extract the substring from the specified string starting from the left character and is intended for languages that use the double-byte character set (DBCS) like Japanese, Chinese, Korean etc."
},
"LEN": {
"a": "(teksts)",
"d": "Atgriež rakstzīmju skaitu teksta virknē"
},
"LENB": {
"a": "( string )",
"d": "Text and data function used to analyse the specified string and return the number of characters it contains and is intended for languages that use the double-byte character set (DBCS) like Japanese, Chinese, Korean etc."
},
"LOWER": {
"a": "(teksts)",
"d": "Visus burtus teksta virknē konvertē par mazajiem burtiem"
},
"MID": {
"a": "(teksts; sākuma_num; rakstzīmju_skaits)",
"d": "Atgriež rakstzīmes no teksta virknes vidus, norādot sākuma pozīciju un garumu"
},
"MIDB": {
"a": "( string; start-pos; number-chars )",
"d": "Text and data function used to extract the characters from the specified string starting from any position and is intended for languages that use the double-byte character set (DBCS) like Japanese, Chinese, Korean etc."
},
"NUMBERVALUE": {
"a": "(teksts; [decimālzīme]; [grupu_atdalītājs])",
"d": "Pārvērš tekstu par skaitli no lokalizācijas neatkarīgā veidā"
},
"PROPER": {
"a": "(teksts)",
"d": "Pārveido teksta virkni pareizajā burtu reģistrā; katra vārda pirmo burtu par lielo, bet pārējos - par mazajiem"
},
"REPLACE": {
"a": "(vecais_teksts; sākuma_num; rakstzīmju_skaits; jaunais_teksts)",
"d": "Aizstāj daļu teksta virknes ar citu teksta virkni"
},
"REPLACEB": {
"a": "( string-1; start-pos; number-chars; string-2 )",
"d": "Text and data function used to replace a set of characters, based on the number of characters and the start position you specify, with a new set of characters and is intended for languages that use the double-byte character set (DBCS) like Japanese, Chinese, Korean etc."
},
"REPT": {
"a": "(teksts; skaitlis_reizes)",
"d": "Atkārto tekstu norādīto reižu skaitu. Izmantojiet funkciju REPT, lai aizpildītu šūnu ar noteiktu skaitu teksta virkņu"
},
"RIGHT": {
"a": "(teksts; [skaitļu_rakstz])",
"d": "Atgriež norādīto rakstzīmju skaitu no teksta virknes beigām"
},
"RIGHTB": {
"a": "( string; [number-chars] )",
"d": "Text and data function used to extract a substring from a string starting from the right-most character, based on the specified number of characters and is intended for languages that use the double-byte character set (DBCS) like Japanese, Chinese, Korean etc."
},
"SEARCH": {
"a": "(atrast_tekstu; tekstā; [sākuma_num])",
"d": "Atgriež rakstzīmes numuru, pie kuras noteikta rakstzīme vai teksta virkne atrasta pirmo reizi, lasot virzienā no kreisās uz labo pusi (nav reģistrjutīgi)"
},
"SEARCHB": {
"a": "( string-1; string-2; [start-pos] )",
"d": "Text and data function used to return the location of the specified substring in a string and is intended for languages that use the double-byte character set (DBCS) like Japanese, Chinese, Korean etc."
},
"SUBSTITUTE": {
"a": "(teksts; vecais_teksts; jaunais_teksts; [gadījuma_numurs])",
"d": "Teksta virknē aizstāj esošu tekstu ar jaunu tekstu"
},
"T": {
"a": "(vērtība)",
"d": "Pārbauda, vai vērtība ir teksts un atgriež tekstu, ja tā ir vai dubultpēdiņas (tukšu tekstu), ja tā nav"
},
"TEXT": {
"a": "(vērtība; formāts_teksts)",
"d": "Konvertē vērtību par tekstu noteiktā skaitļu formātā"
},
"TEXTJOIN": {
"a": "(norobežotājs; ignorēt_tukšu; teksts1; ...)",
"d": "Savieno teksta virkņu sarakstu vai diapazonu, izmantojot norobežotāju"
},
"TRIM": {
"a": "(tekstst)",
"d": "Izņem visas atstarpes no teksta virknes, izņemot vienplatuma atstarpes starp vārdiem"
},
"UNICHAR": {
"a": "(skaitlis)",
"d": "Atgriež unikoda rakstzīmi, uz ko atsaucas noteiktā skaitliskā vērtība"
},
"UNICODE": {
"a": "(teksts)",
"d": "Atgriež skaitli (koda punktu), kas atbilst teksta pirmajai rakstzīmei"
},
"UPPER": {
"a": "(teksts)",
"d": "Konvertē teksta virkni uz visiem lielajiem burtiem"
},
"VALUE": {
"a": "(teksts)",
"d": "Konvertē teksta virkni, kas apzīmē skaitli, par skaitli"
},
"AVEDEV": {
"a": "(skaitlis1; [skaitlis2]; ...)",
"d": "Atgriež vidējo vērtību datu punktu absolūtajām novirzēm no vidējā. Argumenti var būt skaitļi vai nosaukumi, masīvi vai atsauces, kurās ietilpst skaitļi"
},
"AVERAGE": {
"a": "(skaitlis1; [skaitlis2]; ...)",
"d": "Atgriež savu argumentu vidējo (aritmētisko), kas var būt skaitļi vai nosaukumi, masīvi vai atsauces, kurās ir skaitļi"
},
"AVERAGEA": {
"a": "(vērtība1; [vērtība2]; ...)",
"d": "Atgriež argumentu vidējo (vidējo aritmētisko), novērtējuma tekstu un FALSE argumentos kā 0; TRUE tiek novērtēts kā 1. Argumenti var būt skaitļi, nosaukumi, masīvi vai atsauces"
},
"AVERAGEIF": {
"a": "(diapazons; kritēriji; [vidējais_diapazons])",
"d": "Atrod vidējo (vidējo aritmētisko) šūnām, ko norāda dotais nosacījums vai kritērijs"
},
"AVERAGEIFS": {
"a": "(vidējais_diapazons; kritēriju_diapazons; kritēriji; ...)",
"d": "Atrod vidējo (vidējo aritmētisko) šūnām, ko norāda dotā nosacījumu kopa vai kritēriji"
},
"BETADIST": {
"a": "(x; alfa; beta; [A]; [B])",
"d": "Atgriež kumulatīvo beta varbūtības blīvuma funkciju"
},
"BETAINV": {
"a": "(varbūtība; alfa; beta; [A]; [B])",
"d": "Atgriež apgrieztu kumulatīvo beta varbūtības blīvuma funkciju (BETADIST)"
},
"BETA.DIST": {
"a": "(x; alfa; beta; kumulatīvā; [A]; [B])",
"d": "Atgriež beta varbūtības sadalījuma funkciju"
},
"BETA.INV": {
"a": "(varbūtība; alfa; beta; [A]; [B])",
"d": "Atgriež apgrieztu kumulatīvo beta varbūtības blīvuma funkciju (BETA.DIST)"
},
"BINOMDIST": {
"a": "(labvēlizn_skaits; mēģinājumi; labvēlizn_varbūtība; kumulatīvā)",
"d": "Atgriež atsevišķas izteiksmes binomiālā sadalījuma varbūtību"
},
"BINOM.DIST": {
"a": "(labvēlizn_skaits; mēģinājumi; labvēlizn_varbūtība; kumulatīvā)",
"d": "Atgriež binomiālā sadalījuma atsevišķas vērtības varbūtību"
},
"BINOM.DIST.RANGE": {
"a": "(mēģinājumi; labvēlizn_varbūtība; izdošanās_skaits; [izdošanās_skaits2])",
"d": "Atgriež mēģinājuma rezultātu iespējamību, izmantojot binomu sadali"
},
"BINOM.INV": {
"a": "(mēģinājumi; labvēlizn_varbūtība; alfa)",
"d": "Atgriež vismazāko vērtību, kurai kumulatīvais binomiālais sadalījums ir lielāks vai vienāds ar kritērija vērtību"
},
"CHIDIST": {
"a": "(x; brīvības_pakāpe)",
"d": "Atgriež labā zara hī kvadrātā sadalījuma varbūtību"
},
"CHIINV": {
"a": "(varbūtība; brīvības_pakāpe)",
"d": "Atgriež apgrieztu hī kvadrāta sadalījuma labā zara varbūtību"
},
"CHITEST": {
"a": "(faktiskais_diapazons; sagaidāmais_diapazons)",
"d": "Atgriež neatkarības pārbaudi: statiskās un piemērotās brīvības pakāpes hī kvadrātā sadalījuma vērtību"
},
"CHISQ.DIST": {
"a": "(x; brīvības_pakāpe; kumulatīvā)",
"d": "Atgriež kreisā zara hī kvadrātā sadalījuma varbūtību"
},
"CHISQ.DIST.RT": {
"a": "(x; brīvības_pakāpe)",
"d": "Atgriež labā zara hī kvadrātā sadalījuma varbūtību"
},
"CHISQ.INV": {
"a": "(varbūtība; brīvības_pakāpe)",
"d": "Atgriež apgrieztu kreisā zara hī kvadrātā sadalījuma varbūtību"
},
"CHISQ.INV.RT": {
"a": "(varbūtība; brīvības_pakāpe)",
"d": "Atgriež apgrieztu labā zara hī kvadrātā sadalījuma varbūtību"
},
"CHISQ.TEST": {
"a": "(faktiskais_diapazons; sagaidāmais_diapazons)",
"d": "Atgriež neatkarības pārbaudi: statiskās un piemērotās brīvības pakāpes hī kvadrātā sadalījuma vērtību"
},
"CONFIDENCE": {
"a": "(alfa; standartnovirze; lielums)",
"d": "Atgriež populācijas vidējā ticamības intervālu, izmantojot normālo sadalījumu"
},
"CONFIDENCE.NORM": {
"a": "(alfa; standartnovirze; lielums)",
"d": "Atgriež populācijas vidējā ticamības intervālu, izmantojot normālo sadalījumu"
},
"CONFIDENCE.T": {
"a": "(alfa; standartnovirze; lielums)",
"d": "Atgriež populācijas vidējā ticamības intervālu, izmantojot Stjūdenta t sadalījumu"
},
"CORREL": {
"a": "(masīvs1; masīvs2)",
"d": "Atgriež divu datu kopu korelācijas koeficientu"
},
"COUNT": {
"a": "(vērtība1; [vērtība2]; ...)",
"d": "Šūnu diapazonā saskaita, cik šūnās ir skaitļi"
},
"COUNTA": {
"a": "(vērtība1; [vērtība2]; ...)",
"d": "Diapazonā saskaita, cik šūnas nav tukšas"
},
"COUNTBLANK": {
"a": "(diapazons)",
"d": "Saskaita, cik tukšu šūnu ir norādītajā šūnu diapazonā"
},
"COUNTIF": {
"a": "(diapazons; kritēriji)",
"d": "Saskaita, cik šūnu diapazonā atbilst noteiktajam nosacījumam"
},
"COUNTIFS": {
"a": "(kritēriju_diapazons; kritēriji; ...)",
"d": "Skaita šūnu skaitu, ko norāda dotā nosacījumu kopa vai kritēriji"
},
"COVAR": {
"a": "(masīvs1; masīvs2)",
"d": "Atgriež kovariāciju - katra divu kopu datu punktu pāra noviržu reizinājuma vidējo"
},
"COVARIANCE.P": {
"a": "(masīvs1; masīvs2)",
"d": "Atgriež populācijas kovariāciju - katra divu kopu datu punktu pāra noviržu reizinājuma vidējo"
},
"COVARIANCE.S": {
"a": "(masīvs1; masīvs2)",
"d": "Atgriež izlases kovariāciju - katra divu kopu datu punktu pāra noviržu reizinājuma vidējo"
},
"CRITBINOM": {
"a": "(izmēģinājumi; varbūtība_s; alfa)",
"d": "Atgriež vismazāko vērtību, kuras kumulatīvais binomu sadalījums ir lielāks vai vienāds ar kritērija vērtību"
},
"DEVSQ": {
"a": "(skaitlis1; [skaitlis2]; ...)",
"d": "Atgriež datu punktu to noviržu kvadrātu summu, kuras aprēķinātas no to izlašu vidējā"
},
"EXPONDIST": {
"a": "(x; lambda; kumulatīvā)",
"d": "Atgriež eksponenciālo sadalījumu"
},
"EXPON.DIST": {
"a": "(x; lambda; kumulatīva)",
"d": "Atgriež eksponenciālo sadalījumu"
},
"FDIST": {
"a": "(x; brīvības_pakāpe1; brīvības_pakāpe2)",
"d": "Atgriež divu datu kopu (labā zara) F varbūtības sadalījumu (atšķirības pakāpi)"
},
"FINV": {
"a": "(varbūtība; brīvības_pak1; brīvības_pak2)",
"d": "Atgriež apgrieztu (labā zara) F varbūtības sadalījumu: ja p = FDIST(x,...), FINV(p,...) = x"
},
"FTEST": {
"a": "(masīvs1; masīvs2)",
"d": "Atgriež F testa rezultātus - divu zaru varbūtību, ka dispersijas Masīvā1 un Masīvā2 nav nozīmīgi atšķirīgas"
},
"F.DIST": {
"a": "(x; brīvības_pakāpe1; brīvības_pakāpe2; kumulatīvā)",
"d": "Atgriež divu datu kopu (kreisā zara) F varbūtības sadalījumu (atšķirības pakāpi)"
},
"F.DIST.RT": {
"a": "(x; brīvības_pakāpe1; brīvības_pakāpe2)",
"d": "Atgriež divu datu kopu (labā zara) F varbūtības sadalījumu (atšķirības pakāpi)"
},
"F.INV": {
"a": "(varbūtība; brīvības_pak1; brīvības_pak2)",
"d": "Atgriež apgrieztu (kreisā zara) F varbūtības sadalījumu: ja p = F.DIST(x,...), F.INV(p,...) = x"
},
"F.INV.RT": {
"a": "(varbūtība; brīvības_pak1; brīvības_pak2)",
"d": "Atgriež apgrieztu (labā zara) F varbūtības sadalījumu: ja p = F.DIST.RT(x,...), F.INV.RT(p,...) = x"
},
"F.TEST": {
"a": "(masīvs1; masīvs2)",
"d": "Atgriež F testa rezultātus - divu zaru varbūtību, ka dispersijas Masīvā1 un Masīvā2 nav nozīmīgi atšķirīgas"
},
"FISHER": {
"a": "(x)",
"d": "Atgriež Fišera transformāciju"
},
"FISHERINV": {
"a": "(y)",
"d": "Atgriež apgrieztu Fišera transformāciju: ja y = FISHER(x), FISHERINV(y) = x"
},
"FORECAST": {
"a": "(x; zināmie_y; zināmie_x)",
"d": "Izmantojot esošās vērtības, aprēķina vai prognozē nākotnes vērtību saskaņā ar lineāru tendences līkni"
},
"FORECAST.ETS": {
"a": "(mērķa_datums; vērtības; laika_grafiks; [sezonalitāte]; [datu_pabeigšana]; [apkopojums])",
"d": "Atgriež prognozēto vērtību konkrētam nākotnes mērķa datumam, izmantojot eksponenciālo līdzināšanas metodi."
},
"FORECAST.ETS.CONFINT": {
"a": "(target_date; values; timeline; [confidence_level]; [seasonality]; [data_completion]; [aggregation])",
"d": "Atgriež ticamības intervālu prognozētajai vērtībai norādītajā mērķa datumā."
},
"FORECAST.ETS.SEASONALITY": {
"a": "(vērtības; laika_grafiks; [datu_pabeigšana]; [apkopojums])",
"d": "Atgriež tā atkārtotās modeļa garumu, ko programma noteica norādītajai laika sērijai."
},
"FORECAST.ETS.STAT": {
"a": "(vērtības; laika_grafiks; statistikas_tips; [sezonalitāte]; [datu_pabeigšana]; [apkopojums])",
"d": "Atgriež pieprasīto prognozes statistiku."
},
"FORECAST.LINEAR": {
"a": "(x; zināmie_y; zināmie_x)",
"d": "Izmantojot esošās vērtības, aprēķina vai prognozē nākotnes vērtību saskaņā ar lineāru tendences līkni"
},
"FREQUENCY": {
"a": "(datu_masīvs; intervālu_masīvs)",
"d": "Aprēķina, cik bieži vērtības sastopamas vērtību diapazonā un pēc tam atgriež vertikālu skaitļu masīvu, kurā ir par vienu elementu vairāk nekā Intervālu_masīvā"
},
"GAMMA": {
"a": "(x)",
"d": "Atgriež gamma funkcijas vērtību"
},
"GAMMADIST": {
"a": "(x; alfa; beta; kumulatīvā)",
"d": "Atgriež gamma sadalījumu"
},
"GAMMA.DIST": {
"a": "(x; alfa; beta; kumulatīvā)",
"d": "Atgriež gamma sadalījumu"
},
"GAMMAINV": {
"a": "(varbūtība; alfa; beta)",
"d": "Atgriež apgrieztu gamma kumulatīvo sadalījumu: ja p = GAMMADIST(x,...), GAMMAINV(p,...) = x"
},
"GAMMA.INV": {
"a": "(varbūtība; alfa; beta)",
"d": "Atgriež apgrieztu gamma kumulatīvo sadalījumu: ja p = GAMMA.DIST(x,...), GAMMA.INV(p,...) = x"
},
"GAMMALN": {
"a": "(x)",
"d": "Atgriež gamma funkcijas naturālo logaritmu"
},
"GAMMALN.PRECISE": {
"a": "(x)",
"d": "Atgriež gamma funkcijas naturālo logaritmu"
},
"GAUSS": {
"a": "(x)",
"d": "Atgriež par 0,5 mazāk nekā standarta parastais kumulatīvais sadalījums"
},
"GEOMEAN": {
"a": "(skaitlis1; [skaitlis2]; ...)",
"d": "Atgriež pozitīvu skaitlisku datu masīva vai diapazona vidējo ģeometrisko"
},
"GROWTH": {
"a": "(zināmie_y; [zināmie_x]; [jaunie_x]; [konst])",
"d": "Atgriež skaitļus eksponenciālā progresijā saskaņā ar zināmo datu punktiem"
},
"HARMEAN": {
"a": "(skaitlis1; [skaitlis2]; ...)",
"d": "Atgriež pozitīvu skaitļu kopas vidējo harmonisko: apgriezto skaitļu apgriezto vidējo aritmētisko"
},
"HYPGEOM.DIST": {
"a": "(izlase_labvēlizn; skaits_izlasē; populācija_labvēlizn; skaits_pop; kumulatīvā)",
"d": "Atgriež hiperģeometrisko sadalījumu"
},
"HYPGEOMDIST": {
"a": "(izlase_labvēlizn; skaitlis_izlase; populācija_labvēlizn; skaitlis_pop)",
"d": "Atgriež hiperģeometrisku sadalījumu"
},
"INTERCEPT": {
"a": "(zināmie_y; zināmie_x)",
"d": "Izmantojot regresijas taisni, kas novilkta caur zināmajām x vērtībām un y vērtībām un visvairāk tām atbilst, aprēķina punktu, kurā taisne krustosies ar y asi"
},
"KURT": {
"a": "(skaitlis1; [skaitlis2]; ...)",
"d": "Atgriež datu kopas ekscesa koeficientu"
},
"LARGE": {
"a": "(masīvs; k)",
"d": "Atgriež datu kopas k-to lielāko vērtību. Piemēram, piekto lielāko skaitli"
},
"LINEST": {
"a": "(zināmie_y; [zināmie_x]; [konst]; [statist])",
"d": "Atgriež statistiku, kas raksturo lineāru tendences līkni pa zināmo datu punktiem, novelkot taisni ar mazāko kvadrātu metodi"
},
"LOGEST": {
"a": "(zināmie_y; [zināmie_x]; [konst]; [statist])",
"d": "Atgriež statistiku, kas raksturo ar zināmajiem datu punktiem saskanošo eksponentlīkni"
},
"LOGINV": {
"a": "(varbūtība; vidējais; standartnovirze)",
"d": "Atgriež apgrieztu logaritmiski normālu kumulatīvu x sadalījuma funkciju, kur ln(x) parasti ir sadalīts ar parametriem Vidējais un Standartnovirze"
},
"LOGNORM.DIST": {
"a": "(x; vidējais; standartnovirze; kumulatīvā)",
"d": "Atgriež x logaritmiski normālo sadalījumu, kur ln(x) ir normāli sadalīts ar parametriem Vidējais un Standartnovirze"
},
"LOGNORM.INV": {
"a": "(varbūtība; vidējais; standartnovirze)",
"d": "Atgriež apgrieztu logaritmiski normālu kumulatīvu x sadalījuma funkciju, kur ln(x) ir normāli sadalīts ar parametriem Vidējais un Standartnovirze"
},
"LOGNORMDIST": {
"a": "(x; vidējais; standartnovirze)",
"d": "Atgriež kumulatīvo logaritmiski normālo x sadalījumu, kur ln(x) parasti ir sadalīts ar parametriem Vidējais un Standartnovirze"
},
"MAX": {
"a": "(skaitlis1; [skaitlis2]; ...)",
"d": "Atgriež vislielāko vērtību no vērtību kopas. Ignorē loģiskās vērtības un tekstu"
},
"MAXA": {
"a": "(vērtība1; [vērtība2]; ...)",
"d": "Atgriež lielāko vērtību kopas vērtību. Neignorē loģiskās vērtības un tekstu"
},
"MAXIFS": {
"a": "(maksimālais_diapazons; kritēriju_diapazons; kritēriji; ...)",
"d": "Atgriež maksimālo vērtību šūnās, ko norāda attiecīgā nosacījumu vai kritēriju kopa"
},
"MEDIAN": {
"a": "(skaitlis1; [skaitlis2]; ...)",
"d": "Atgriež mediānu jeb skaitli norādīto skaitļu kopas vidū"
},
"MIN": {
"a": "(skaitlis1; [skaitlis2]; ...)",
"d": "Atgriež vismazāko skaitli vērtību kopā. Ignorē loģiskās vērtības un tekstu"
},
"MINA": {
"a": "(vērtība1; [vērtība2]; ...)",
"d": "Atgriež mazāko vērtību kopas vērtību. Neignorē loģiskās vērtības un tekstu"
},
"MINIFS": {
"a": "(minimālais_diapazons; kritēriju_diapazons; kritēriji; ...)",
"d": "Atgriež minimālo vērtību šūnās, ko norāda attiecīgā nosacījumu vai kritēriju kopa"
},
"MODE": {
"a": "(skaitlis1; [skaitlis2]; ...)",
"d": "Atgriež datu masīvā vai diapazonā visbiežāk sastopamo vai atkārtoto vērtību"
},
"MODE.MULT": {
"a": "(skaitlis1; [skaitlis2]; ...)",
"d": "Atgriež vertikālu visbiežāk sastopamo vai atkārtojošos vērtību masīvu kā datu masīvu vai diapazonu. Horizontālam masīvam izmantojiet =TRANSPOSE(MODE.MULT(skaitlis1,skaitlis2,...))"
},
"MODE.SNGL": {
"a": "(skaitlis1; [skaitlis2]; ...)",
"d": "Atgriež datu masīvā vai diapazonā visbiežāk sastopamo vai atkārtoto vērtību"
},
"NEGBINOM.DIST": {
"a": "(nelabvēlizn_skaits; labvēlizn_skaits; labvēlizn_varbūtība; kumulatīvā)",
"d": "Atgriež negatīvu binomiālo sadalījumu, varbūtību, ka būs (nelabvēlizn_ skaits) nelabvēlīgi iznākumi pirms (labvēlizn_skaits). labvēlīgā iznākuma ar (labvēlizn_varbūtība) varbūtību"
},
"NEGBINOMDIST": {
"a": "(nelabvēlizn_skaits; labvēlizn_skaits; labvēlizn_varbūtība)",
"d": "Atgriež negatīvu binomiālo sadalījumu, varbūtību, ka būs (nelabvēlizn_skaits) nelabvēlīgi iznākumi pirms (labvēlizn_skaits). labvēlīgā iznākumā ar (labvēlizn_varbūtība) varbūtību"
},
"NORM.DIST": {
"a": "(x; vidējais; standartnovirze; kumulatīvā)",
"d": "Atgriež norādītā vidējā lieluma un standartnovirzes normālo sadalījumu"
},
"NORMDIST": {
"a": "(x; vidējais; standartnovirze; kumulatīvā)",
"d": "Atgriež norādītā vidējā lieluma un standartnovirzes normālo kumulatīvo sadalījumu"
},
"NORM.INV": {
"a": "(varbūtība; vidējais; standartnovirze)",
"d": "Atgriež apgrieztu norādītās vidējās vērtības un standartnovirzes normālo kumulatīvo sadalījumu"
},
"NORMINV": {
"a": "(varbūtība; vidējais; standartnovirze)",
"d": "Atgriež norādītās vidējās vērtības un standartnovirzes apgrieztu normālo kumulatīvo sadalījumu"
},
"NORM.S.DIST": {
"a": "(z; kumulatīvā)",
"d": "Atgriež standarta normālo sadalījumu (tā vidējais ir nulle, bet standartnovirze - viens)"
},
"NORMSDIST": {
"a": "(z)",
"d": "Atgriež standarta normālo kumulatīvo sadalījumu (tā vidējais ir nulle, bet standartnovirze - viens)"
},
"NORM.S.INV": {
"a": "(varbūtība)",
"d": "Atgriež apgrieztu standarta normālo kumulatīvo sadalījumu (tā vidējais ir nulle, bet standartnovirze - viens)"
},
"NORMSINV": {
"a": "(varbūtība)",
"d": "Atgriež apgrieztu standarta normālo kumulatīvo sadalījumu (tā vidējais ir nulle, bet standartnovirze - viens)"
},
"PEARSON": {
"a": "(masīvs1; masīvs2)",
"d": "Atgriež Pīrsona korelācijas koeficientu r"
},
"PERCENTILE": {
"a": "(masīvs; k)",
"d": "Atgriež diapazona vērtību k-to procentili"
},
"PERCENTILE.EXC": {
"a": "(masīvs; k)",
"d": "Atgriež diapazona vērtību k-to procentili, kur k ir diapazons no 0 līdz 1 neieskaitot"
},
"PERCENTILE.INC": {
"a": "(masīvs; k)",
"d": "Atgriež diapazona vērtību k-to procentili, kur k ir diapazons no 0 līdz 1 ieskaitot"
},
"PERCENTRANK": {
"a": "(masīvs; x; [nozīmība])",
"d": "Atgriež datu kopā ietilpstošas vērtības rangu procentuāli no datu kopas"
},
"PERCENTRANK.EXC": {
"a": "(masīvs; x; [nozīmība])",
"d": "Atgriež datu kopā ietilpstošas vērtības rangu kā procentu (no 0 līdz 1 neieskaitot) no datu kopas"
},
"PERCENTRANK.INC": {
"a": "(masīvs; x; [nozīmība])",
"d": "Atgriež datu kopā ietilpstošas vērtības rangu kā procentu (no 0 līdz 1 ieskaitot) no datu kopas"
},
"PERMUT": {
"a": "(skaitlis; izvēlētais_skaitlis)",
"d": "Atgriež no visiem objektiem izvēlēta noteikta objektu skaita permutāciju skaitu"
},
"PERMUTATIONA": {
"a": "(skaitlis; izvēlētais_skaitlis)",
"d": "Atgriež no visiem objektiem izvēlēta noteikta objektu skaita permutāciju skaitu"
},
"PHI": {
"a": "(x)",
"d": "Atgriež standarta normālā sadalījuma blīvuma funkcijas vērtību"
},
"POISSON": {
"a": "(x; vidējais; kumulatīvā)",
"d": "Atgriež Puasona sadalījumu"
},
"POISSON.DIST": {
"a": "(x; vidējais; kumulatīvā)",
"d": "Atgriež Puasona sadalījumu"
},
"PROB": {
"a": "(x_diapazons; varb_diapazons; zemākā_robeža; [augstākā_robeža])",
"d": "Atgriež varbūtību, ka vērtības diapazonā atrodas starp abām robežām vai ir vienādas ar zemāko robežu"
},
"QUARTILE": {
"a": "(masīvs; kvartile)",
"d": "Atgriež datu kopas kvartili"
},
"QUARTILE.INC": {
"a": "(masīvs; kvartile)",
"d": "Atgriež datu kopas kvartili, izmantojot procentiles vērtības no 0 līdz 1 ieskaitot"
},
"QUARTILE.EXC": {
"a": "(masīvs; kvartile)",
"d": "Atgriež datu kopas kvartili, izmantojot procentiles vērtības no 0 līdz 1 neieskaitot"
},
"RANK": {
"a": "(skaitlis; ats; [kārtība])",
"d": "Atgriež skaitļa rangu skaitļu sarakstā: tā lielumu attiecībā pret pārējām vērtībām sarakstā"
},
"RANK.AVG": {
"a": "(skaitlis; ats; [kārtība])",
"d": "Atgriež skaitļa rangu skaitļu sarakstā: tā lielumu attiecībā pret pārējām vērtībām sarakstā; ja vairākām vērtībām ir vienāds rangs, tiek atgriezts vidējais rangs"
},
"RANK.EQ": {
"a": "(skaitlis; ats; [kārtība])",
"d": "Atgriež skaitļa rangu skaitļu sarakstā: tā lielumu attiecībā pret pārējām vērtībām sarakstā; ja vairākām vērtībām ir rangs, tiek atgriezts augstākais šīs vērtību kopas rangs"
},
"RSQ": {
"a": "(zināmie_y; zināmie_x)",
"d": "Atgriež Pīrsona korelācijas koeficienta kvadrātu norādītajos datu punktos"
},
"SKEW": {
"a": "(skaitlis1; [skaitlis2]; ...)",
"d": "Atgriež sadalījuma asimetriju: sadalījuma asimetrijas pakāpi attiecībā pret vidējo"
},
"SKEW.P": {
"a": "(skaitlis1; [skaitlis2]; ...)",
"d": "Atgriež sadalījuma asimetriju, pamatojoties uz kopskaitu: sadalījuma asimetrijas pakāpi attiecībā pret vidējo"
},
"SLOPE": {
"a": "(zināmie_y; zināmie_x)",
"d": "Atgriež lineārās regresijas taisnes slīpumu caur norādītajiem datu punktiem"
},
"SMALL": {
"a": "(masīvs; k)",
"d": "Atgriež datu kopas k-to mazāko vērtību. Piemēram, piekto mazāko skaitli"
},
"STANDARDIZE": {
"a": "(x; vidējais; standartnovirze)",
"d": "Atgriež tāda sadalījuma normalizētu vērtību, kuru raksturo vidējais un standartnovirze"
},
"STDEV": {
"a": "(skaitlis1; [skaitlis2]; ...)",
"d": "Aprēķina standartnovirzi, izmantojot izlasi (izlasē ignorē loģiskās vērtības un tekstu)"
},
"STDEV.P": {
"a": "(skaitlis1; [skaitlis2]; ...)",
"d": "Aprēķina standartnovirzi, izmantojot visu populāciju kā argumentus (ignorē loģiskās vērtības un tekstu)"
},
"STDEV.S": {
"a": "(skaitlis1; [skaitlis2]; ...)",
"d": "Aprēķina standartnovirzi, izmantojot izlasi (izlasē ignorē loģiskās vērtības un tekstu)"
},
"STDEVA": {
"a": "(vērtība1; [vērtība2]; ...)",
"d": "Aplēš standartnovirzi, ņemot vērā izlasi, ieskaitot loģiskās vērtības un tekstu. Tekstam un loģiskajai vērtībai FALSE ir vērtība 0; loģiskajai vērtībai TRUE ir vērtība 1"
},
"STDEVP": {
"a": "(skaitlis1; [skaitlis2]; ...)",
"d": "Aprēķina standartnovirzi, izmantojot visu populāciju kā argumentus (ignorē loģiskās vērtības un tekstu)"
},
"STDEVPA": {
"a": "(vērtība1; [vērtība2]; ...)",
"d": "Aprēķina standartnovirzi, ņemot vērā visu populāciju, arī loģiskās vērtības un tekstu. Tekstam un loģiskajai vērtībai FALSE ir vērtība 0; loģiskajai vērtībai TRUE ir vērtība 1"
},
"STEYX": {
"a": "(zināmie_y; zināmie_x)",
"d": "Atgriež regresijas katra zināmā x prognozētās y vērtības standarta kļūdu"
},
"TDIST": {
"a": "(x; brīvības_pak; zari)",
"d": "Atgriež Stjūdenta t sadalījumu"
},
"TINV": {
"a": "(varbūtība; brīvības_pakāpe)",
"d": "Atgriež divu zaru apgriezto Stjūdenta t sadalījumu"
},
"T.DIST": {
"a": "(x; brīvības_pakāpe; kumulatīvā)",
"d": "Atgriež kreisā zara Stjūdenta t sadalījumu"
},
"T.DIST.2T": {
"a": "(x; brīvības_pakāpe)",
"d": "Atgriež divu zaru Stjūdenta t sadalījumu"
},
"T.DIST.RT": {
"a": "(x; brīvības_pakāpe)",
"d": "Atgriež labā zara Stjūdenta t sadalījumu"
},
"T.INV": {
"a": "(varbūtība; brīvības_pakāpe)",
"d": "Atgriež kreisā zara apgriezto Stjūdenta t sadalījumu"
},
"T.INV.2T": {
"a": "(varbūtība; brīvības_pakāpe)",
"d": "Atgriež divu zaru apgriezto Stjūdenta t sadalījumu"
},
"T.TEST": {
"a": "(masīvs1; masīvs2; zari; tips)",
"d": "Atgriež Stjūdenta t testam atbilstošu varbūtību"
},
"TREND": {
"a": "(zināmie_y; [zināmie_x]; [jaunie_x]; [konst])",
"d": "Izmantojot mazāko kvadrātu metodi, atgriež skaitļus lineārā līknē, kas atbilst zināmiem datu punktiem"
},
"TRIMMEAN": {
"a": "(masīvs; procents)",
"d": "Atgriež datu vērtības kopas iekšējās daļas vidējo"
},
"TTEST": {
"a": "(masīvs1; masīvs2; zari; tips)",
"d": "Atgriež Stjūdenta t testam atbilstošu varbūtību"
},
"VAR": {
"a": "(skaitlis1; [skaitlis2]; ...)",
"d": "Aprēķina dispersiju, izmantojot izlasi (izlasē ignorē loģiskās vērtības un tekstu)"
},
"VAR.P": {
"a": "(skaitlis1; [skaitlis2]; ...)",
"d": "Aprēķina dispersiju, izmantojot visu populāciju (ignorē loģiskās vērtības un tekstu populācijā)"
},
"VAR.S": {
"a": "(skaitlis1; [skaitlis2]; ...)",
"d": "Aprēķina dispersiju, izmantojot izlasi (izlasē ignorē loģiskās vērtības un tekstu)"
},
"VARA": {
"a": "(vērtība1; [vērtība2]; ...)",
"d": "Aplēš dispersiju, ņemot vērā izlasi, ieskaitot loģiskās vērtības un tekstu. Tekstam un loģiskajai vērtībai FALSE ir vērtība 0; loģiskajai vērtībai TRUE ir vērtība 1"
},
"VARP": {
"a": "(skaitlis1; [skaitlis2]; ...)",
"d": "Aprēķina dispersiju, izmantojot visu populāciju (ignorē loģiskās vērtības un tekstu populācijā)"
},
"VARPA": {
"a": "(vērtība1; [vērtība2]; ...)",
"d": "Aprēķina dispersiju, ņemot vērā visu populāciju, arī loģiskās vērtības un tekstu. Tekstam un loģiskajai vērtībai FALSE ir vērtība 0; loģiskajai vērtībai TRUE ir vērtība 1"
},
"WEIBULL": {
"a": "(x; alfa; beta; kumulatīvā)",
"d": "Atgriež Veibula sadalījumu"
},
"WEIBULL.DIST": {
"a": "(x; alfa; beta; kumulatīvā)",
"d": "Atgriež Veibula sadalījumu"
},
"Z.TEST": {
"a": "(masīvs; x; [sigma])",
"d": "Atgriež viena zara z testa P vērtību"
},
"ZTEST": {
"a": "(masīvs; x; [sigma])",
"d": "Atgriež viena zara z testa P vērtību"
},
"ACCRINT": {
"a": "(emisija; pirmie_procenti; apmaksa; likme; nom; biežums; [bāze]; [apr_metode])",
"d": "Atgriež tāda vērtspapīra uzkrātos procentus, par kuru tiek periodiski maksāti procenti."
},
"ACCRINTM": {
"a": "(emisija; apmaksa; likme; nom; [pamats])",
"d": "Atgriež tāda vērtspapīra uzkrātos procentus, kuru dzēšot, tiek maksāti procenti"
},
"AMORDEGRC": {
"a": "(cena; datums_iegādāts; pirmais_periods; likvidācija; periods; likme; [pamats])",
"d": "Atgriež katra grāmatošanas perioda proporcionāli sadalītu lineāru aktīvu amortizāciju."
},
"AMORLINC": {
"a": "(cena; datums_iegādāts; pirmais_periods; likvidācija; periods; likme; [pamats])",
"d": "Atgriež katra grāmatošanas perioda proporcionāli sadalītu lineāru aktīvu amortizāciju."
},
"COUPDAYBS": {
"a": "(apmaksa; dzēšanas_datums; biežums; [bāze])",
"d": "Atgriež dienu skaitu no kupona perioda sākuma līdz apmaksas datumam"
},
"COUPDAYS": {
"a": "(apmaksa; dzēšanas_datums; biežums; [bāze])",
"d": "Atgriež dienu skaitu kupona periodā, ietverot apmaksas datumu"
},
"COUPDAYSNC": {
"a": "(apmaksa; dzēšanas_datums; biežums; [bāze])",
"d": "Atgriež dienu skaitu no apmaksas datuma līdz nākamajam kupona datumam"
},
"COUPNCD": {
"a": "(apmaksa; dzēšanas_datums; biežums; [bāze])",
"d": "Atgriež nākamo kupona datumu pēc apmaksas dienas"
},
"COUPNUM": {
"a": "(apmaksa; dzēšanas_datums; biežums; [bāze])",
"d": "Atgriež kuponu skaitu, kas maksājami no apmaksas datuma līdz dzēšanas datumam"
},
"COUPPCD": {
"a": "(apmaksa; dzēšanas_datums; biežums; [bāze])",
"d": "Atgriež iepriekšējo kupona datumu pirms apmaksas datuma"
},
"CUMIPMT": {
"a": "(likme; skg; pv; sākuma_periods; beigu_periods; tips)",
"d": "Atgriež kumulatīvos procentus, kas maksāti par aizdevumu starp diviem periodiem"
},
"CUMPRINC": {
"a": "(likme; skg; pv; sākuma_periods; beigu_periods; tips)",
"d": "Atgriež kumulatīvo pamatsummu, kas maksāta par aizdevumu starp diviem periodiem"
},
"DB": {
"a": "(vērtība; likvidācijas_vērt; kalpošanas_laiks; periods; [mēnesis])",
"d": "Atgriež aktīvu amortizāciju noteiktā periodā, izmantojot aritmētiski degresīvo nolietojuma aprēķināšanas metodi"
},
"DDB": {
"a": "(vērtība; likvidācijas_vērt; kalpošanas_laiks; periods; [koeficients])",
"d": "Atgriež aktīvu amortizāciju norādītā periodā, izmantojot ģeometriski degresīvo nolietojuma aprēķināšanas metodi vai kādu citu norādīto metodi"
},
"DISC": {
"a": "(apmaksa; dzēšanas_datums; c; izpirkšana; [bāze])",
"d": "Atgriež vērtspapīra diskonta likmi"
},
"DOLLARDE": {
"a": "(daļa_dolārs; daļa)",
"d": "Konvertē cenu dolāros, kas izteikta kā daļa, dolāra cenā, kas izteikta kā decimālskaitlis"
},
"DOLLARFR": {
"a": "(decimāldaļskailis_dolārs; daļa)",
"d": "Konvertē cenu dolāros, kas izteikta kā decimālskaitlis, dolāra cenā, kas izteikta kā daļskaitlis"
},
"DURATION": {
"a": "(apmaksa; dzēšanas_datums; kupons; peļņa; biežums; [bāze])",
"d": "Atgriež vērtspapīra ikgadējo ilgumu ar periodiskiem procentu maksājumiem"
},
"EFFECT": {
"a": "(nomināls_likme; skg)",
"d": "Atgriež faktisko ikgadējo procentu likmi"
},
"FV": {
"a": "(likme; per_sk; maks; [nv]; [tips])",
"d": "Atgriež tādas investīcijas nākotnes vērtību, kuras pamatā ir periodiski, konstanti maksājumi un konstanta procentu likme"
},
"FVSCHEDULE": {
"a": "(pamatsumma; grafiks)",
"d": "Atgriež sākotnējās pamatsummas nākotnes vērtību pēc salikto procentu likmju sērijas lietošanas"
},
"INTRATE": {
"a": "(apmaksa; dzēšanas_datums; investīcijas; izpirkšana; [bāze])",
"d": "Atgriež pilnībā investēta vērtspapīra procentu likmi"
},
"IPMT": {
"a": "(likme; per; per_sk; pv; [nv]; [tips])",
"d": "Atgriež noteikta perioda procentu maksājumus par investīciju, ja tiek veikti periodiski, konstanti maksājumi un ir konstanta procentu likme"
},
"IRR": {
"a": "(vērtības; [minējums])",
"d": "Atgriež iekšējo ienākumu normu (internal rate of return, IRR) sērijai naudas plūsmas"
},
"ISPMT": {
"a": "(likme; per; persk; pv)",
"d": "Atgriež procentus, kas jāmaksā noteiktā investīcijas periodā"
},
"MDURATION": {
"a": "(apmaksa; dzēšanas_datums; kupons; peļņa; biežums; [pamats])",
"d": "Atgriež Makaolija modificēto vērtspapīra ilgumu ar 100 EUR pieņemtu nominālvērtību"
},
"MIRR": {
"a": "(vērtības; finansiālā_likme; pārinvest_likme)",
"d": "Atgriež iekšējo ienākumu normu (internal rate of return) sērijai periodisku naudas plūsmu, ņemot vērā gan investīcijas izmaksas, gan procentus par naudas pārinvestēšanu"
},
"NOMINAL": {
"a": "(faktiskā_likme; skg)",
"d": "Atgriež ikgadējo nominālo procentu likmi"
},
"NPER": {
"a": "(likme; maks; pv; [nv]; [tips])",
"d": "Atgriež investīcijas periodu skaitu, ja tiek veikti periodiski, konstanti maksājumi un ir konstanta procentu likme"
},
"NPV": {
"a": "(likme; vērtība1; [vērtība2]; ...)",
"d": "Atgriež investīcijas pašreizējo neto vērtību, izmantojot diskonta likmi un turpmāku maksājumu virkni (negatīvas vērtības) un ienākumus (pozitīvas vērtības)"
},
"ODDFPRICE": {
"a": "(apmaksa; dzēšanas_datums; emisija; pirmais_kupons; likme; peļņa; izpirkšana; biežums; [bāze])",
"d": "Atgriež tāda vērtspapīra cenu par 100 EUR nominālvērtību, kura pirmais periods ir nepāra"
},
"ODDFYIELD": {
"a": "(apmaksa; dzēšanas_datums; emisija; pirmais_kupons; likme; pr; izpirkšana; biežums; [bāze])",
"d": "Atgriež tāda vērtspapīra peļņu, kura pirmais periods ir nepāra"
},
"ODDLPRICE": {
"a": "(apmaksa; dzēšanas_datums; pēdējie_procenti; likme; peļņa; izpirkšana; biežums; [bāze])",
"d": "Atgriež tāda vērtspapīra cenu uz 100 EUR nominālvērtību, kura pēdējais periods ir nepāra"
},
"ODDLYIELD": {
"a": "(apmaksa; dzēšanas_datums; pēdējie_procenti; likme; pr; izpirkšana; biežums; [bāze])",
"d": "Atgriež tāda vērtspapīra cenu, kura pēdējais periods ir nepāra"
},
"PDURATION": {
"a": "(likme; pv; nv)",
"d": "Atgriež periodu skaitu, kuru laikā ieguldījums sasniedz noteiktu vērtību"
},
"PMT": {
"a": "(likme; persk; pv; [nv]; [tips])",
"d": "Aprēķina aizdevuma atmaksāšanu, ja tiek veikti konstanti maksājumi ar konstantu procentu likmi"
},
"PPMT": {
"a": "(likme; per; per_sk; pv; [nv]; [tips])",
"d": "Atgriež noteiktas investīcijas pamatsummas maksājumus, ja tiek veikti periodiski, konstanti maksājumi un ir konstanta procentu likme"
},
"PRICE": {
"a": "(apmaksa; dzēšanas_datums; likme; peļņa; izpirkšana; biežums; [bāze])",
"d": "Atgriež vērtspapīra cenu par 100 EUR nominālvērtību, maksājot periodiskus procentus"
},
"PRICEDISC": {
"a": "(apmaksa; dzēšanas_datums; diskonts; izpirkšana; [bāze])",
"d": "Atgriež diskontēta vērtspapīra cenu par 100 EUR nominālvērtību"
},
"PRICEMAT": {
"a": "(apmaksa; dzēšanas_datums; emisija; likme; peļņa; [bāze])",
"d": "Atgriež cenu vērtspapīram par 100 EUR nominālvērtību, par kuru procentus maksā dzēšot"
},
"PV": {
"a": "(likme; per_sk; maks; [nv]; [tips])",
"d": "Atgriež investīcijas pašreizējo vērtību: turpmāk veicamu maksājumu virknes vērtības kopsumma šobrīd"
},
"RATE": {
"a": "(per_sk; maks; pv; [nv]; [tips]; [minējums])",
"d": "Atgriež viena perioda procentu likmi aizdevuma vai investīcijas perioda laikā. Piemēram, izmantojiet 6%/4, ja tiek veikti ikceturkšņa maksājumi ar ikgadējo procentu likmi (APR) 6%"
},
"RECEIVED": {
"a": "(apmaksa; dzēšanas_datums; investīcijas; diskonts; [bāze])",
"d": "Atgriež pilnībā investēta vērtspapīra dzēšanas datumā saņemamo summu"
},
"RRI": {
"a": "(per_sk; pv; nv)",
"d": "Atgriež ieguldījuma pieauguma procentu likmes ekvivalentu"
},
"SLN": {
"a": "(vērtība; likvidācijas_vērt; kalpošanas_laiks)",
"d": "Atgriež aktīvu lineāro amortizāciju vienā periodā"
},
"SYD": {
"a": "(vērtība; likvidācijas_vērt; kalpošanas_laiks; per)",
"d": "Atgriež aktīvu amortizāciju noteiktā periodā, aprēķinot ar gada ciparu summas metodi"
},
"TBILLEQ": {
"a": "(apmaksa; dzēšanas_datums; diskonts)",
"d": "Atgriež valsts kases vekseļa peļņu, kas ekvivalenta obligācijām"
},
"TBILLPRICE": {
"a": "(apmaksa; dzēšanas_datums; diskonts)",
"d": "Atgriež valsts kases vekseļa cenu par 100 ASV dolāru nominālvērtību"
},
"TBILLYIELD": {
"a": "(apmaksa; dzēšanas_datums; pr)",
"d": "Atgriež valsts kases vekseļa peļņu"
},
"VDB": {
"a": "(vērtība; likvidācijas_vērt; kalpošanas_laiks; sāk_periods; beigu_periods; [koeficients]; [nav_pārslēgš])",
"d": "Atgriež aktīvu amortizāciju jebkurā norādītā periodā, arī daļējos periodos, izmantojot ģeometriski degresīvo nolietojuma aprēķināšanas metodi vai kādu citu norādītu metodi"
},
"XIRR": {
"a": "(vērtības; datumi; [minējums])",
"d": "Atgriež naudas plūsmas grafika iekšējo ienesīguma normu"
},
"XNPV": {
"a": "(likme; vērtība; datumi)",
"d": "Atgriež naudas plūsmas grafika pašreizējo neto vērtību"
},
"YIELD": {
"a": "(apmaksa; dzēšanas_datums; likme; c; izpirkšana; biežums; [bāze])",
"d": "Atgriež peļņu, ko devis vērtspapīrs ar periodisku procentu izmaksu"
},
"YIELDDISC": {
"a": "(apmaksa; dzēšanas_datums; c; izpirkšana; [bāze])",
"d": "Atgriež diskontēta vērtspapīra ikgadējo peļņu. Piemēram, valsts kases vekselis"
},
"YIELDMAT": {
"a": "(apmaksa; dzēšanas_datums; emisija; likme; c; [bāze])",
"d": "Atgriež ikgadējo vērtspapīra peļņu, par kuru procentus maksā dzēšot"
},
"ABS": {
"a": "(skaitlis)",
"d": "Atgriež skaitļa absolūto vērtību - skaitli bez zīmes"
},
"ACOS": {
"a": "(skaitlis)",
"d": "Atgriež skaitļa arkkosinusu radiānos diapazonā no 0 līdz Pi. Arkkosinuss ir leņķis, kura kosinuss ir Skaitlis"
},
"ACOSH": {
"a": "(skaitlis)",
"d": "Atgriež skaitļa apgriezto hiperbolisko kosinusu"
},
"ACOT": {
"a": "(skaitlis)",
"d": "Atgriež skaitļa arkkotangensu radiānos diapazonā no 0 līdz Pi."
},
"ACOTH": {
"a": "(skaitlis)",
"d": "Atgriež skaitļa inverso hiperbolisko kotangensu"
},
"AGGREGATE": {
"a": "(funkcijas_num; opcijas; ats1; ...)",
"d": "Atgriež apkopojumu kā sarakstu vai datu bāzi"
},
"ARABIC": {
"a": "(teksts)",
"d": "Pārvērš romiešu ciparu par arābu ciparu"
},
"ASC": {
"a": "( text )",
"d": "Text function for Double-byte character set (DBCS) languages, the function changes full-width (double-byte) characters to half-width (single-byte) characters"
},
"ASIN": {
"a": "(skaitlis)",
"d": "Atgriež skaitļa arksīnusu radiānos diapazonā no -Pi/2 līdz Pi/2"
},
"ASINH": {
"a": "(skaitlis)",
"d": "Atgriež skaitļa apgriezto hiperbolisko sinusu"
},
"ATAN": {
"a": "(skaitlis)",
"d": "Atgriež skaitļa arktangensu radiānos, diapazonā no -Pi/2 līdz Pi/2"
},
"ATAN2": {
"a": "(x_num; y_num)",
"d": "Atgriež norādīto x un y koordinātu arktangensu radiānos no -Pi un Pi, izslēdzot -Pi"
},
"ATANH": {
"a": "(skaitlis)",
"d": "Atgriež skaitļa apgriezto hiperbolisko tangensu"
},
"BASE": {
"a": "(skaitlis; bāze; [min_garums])",
"d": "Pārvērš skaitli par teksta atveidojumu ar doto bāzi"
},
"CEILING": {
"a": "(skaitlis; būtiskums)",
"d": "Noapaļo skaitli uz augšu līdz tuvākajam būtiskjama skaitlim, kas dalās bez atlikuma"
},
"CEILING.MATH": {
"a": "(skaitlis; [būtiskums]; [režīms])",
"d": "Noapaļo skaitli uz augšu līdz tuvākajam veselajam skaitlim vai līdz tuvākajam nozīmīgajam skaitlim, kas dalās bez atlikuma"
},
"CEILING.PRECISE": {
"a": "( x; [significance] )",
"d": "Math and trigonometry function used to return a number that is rounded up to the nearest integer or to the nearest multiple of significance"
},
"COMBIN": {
"a": "(skaitlis; izvēlētais_skaitlis)",
"d": "Atgriež norādītā vienumu skaita kombināciju skaitu"
},
"COMBINA": {
"a": "(skaitlis; izvēlētais_skaitlis)",
"d": "Atgriež norādītā vienumu skaita kombināciju skaitu"
},
"COS": {
"a": "(skaitlis)",
"d": "Atgriež leņķa kosinusu"
},
"COSH": {
"a": "(skaitlis)",
"d": "Atgriež skaitļa hiperbolisko kosinusu"
},
"COT": {
"a": "(skaitlis)",
"d": "atgriež leņķa kotangensu"
},
"COTH": {
"a": "(skaitlis)",
"d": "atgriež skaitļa hiperbolisko kotangensu"
},
"CSC": {
"a": "(skaitlis)",
"d": "atgriež leņķa kosekansu"
},
"CSCH": {
"a": "(skaitlis)",
"d": "atgriež leņķa hiperbolisko kosekansu"
},
"DECIMAL": {
"a": "(skaitlis; bāze)",
"d": "pārvērš skaitļa teksta atveidojumu dotā bāzē par decimālskaitli"
},
"DEGREES": {
"a": "(leņķis)",
"d": "Konvertē radiānus par grādiem"
},
"ECMA.CEILING": {
"a": "( x; significance )",
"d": "Math and trigonometry function used to round the number up to the nearest multiple of significance"
},
"EVEN": {
"a": "(skaitlis)",
"d": "Noapaļo pozitīvu skaitli uz augšu, bet negatīvu - uz leju līdz tuvākajam veselajam pārskaitlim"
},
"EXP": {
"a": "(skaitlis)",
"d": "Atgriež e, kas kāpināts norādītajā pakāpē"
},
"FACT": {
"a": "(skaitlis)",
"d": "Atgriež skaitļa faktoriālu, kas vienāds ar 1*2*3*...* Skaitlis"
},
"FACTDOUBLE": {
"a": "(skaitlis)",
"d": "Atgriež skaitļa dubulto faktoriālu"
},
"FLOOR": {
"a": "(skaitlis; būtiskums)",
"d": "Noapaļo skaitli uz leju līdz tuvākajam būtiskajam skaitlim, kas dalās bez atlikuma"
},
"FLOOR.PRECISE": {
"a": "( x; [significance] )",
"d": "Math and trigonometry function used to return a number that is rounded down to the nearest integer or to the nearest multiple of significance"
},
"FLOOR.MATH": {
"a": "(skaitlis; [būtiskums]; [režīms])",
"d": "Noapaļo skaitli uz leju līdz tuvākajam veselajam skaitlim vai līdz tuvākajam nozīmīgajam skaitlim, kas dalās bez atlikuma"
},
"GCD": {
"a": "(skaitlis1; [skaitlis2]; ...)",
"d": "Atgriež lielāko kopējo dalītāju"
},
"INT": {
"a": "(skaitlis)",
"d": "Noapaļo skaitli līdz tuvākajam veselajam skaitlim"
},
"ISO.CEILING": {
"a": "( number; [significance] )",
"d": "Math and trigonometry function used to return a number that is rounded up to the nearest integer or to the nearest multiple of significance regardless of the sign of the number. However, if the number or the significance is zero, zero is returned."
},
"LCM": {
"a": "(skaitlis1; [skaitlis2]; ...)",
"d": "Atgriež mazāko kopējo skaitli, ar kuru dalāms bez atlikuma"
},
"LN": {
"a": "(skaitlis)",
"d": "Atgriež skaitļa naturālo logaritmu"
},
"LOG": {
"a": "(skaitlis; [bāze])",
"d": "Atgriež skaitļa logaritmu norādītājai bāzei"
},
"LOG10": {
"a": "(skaitlis)",
"d": "Atgriež skaitļa bāzes 10 logaritmu"
},
"MDETERM": {
"a": "(masīvs)",
"d": "Atgriež masīva matricas determinantu"
},
"MINVERSE": {
"a": "(masīvs)",
"d": "Atgriež masīvā glabātas matricas apgriezto matricu"
},
"MMULT": {
"a": "(masīvs1; masīvs2)",
"d": "Atgriež divu masīvu reizinājumu - masīvu ar to pašu rindu skaitu kā masīvs1 un ar to pašu kolonnu skaitu kā masīvs2"
},
"MOD": {
"a": "(skaitlis; dalītājs)",
"d": "Atgriež atlikumu pēc skaitļa dalīšanas ar dalītāju"
},
"MROUND": {
"a": "(skaitlis; dalāmais_skaitlis)",
"d": "Atgriež skaitli, kas noapaļots līdz vēlamajam dalāmajam skaitlim"
},
"MULTINOMIAL": {
"a": "(skaitlis1; [skaitlis2]; ...)",
"d": "Atgriež datu kopas multinomiālu"
},
"MUNIT": {
"a": "(dimensija)",
"d": "Atgriež norādītās dimensijas vienības matricu"
},
"ODD": {
"a": "(skaitlis)",
"d": "Noapaļo pozitīvu skaitli uz augšu, bet negatīvu - uz leju līdz tuvākajam veselajam nepāra skaitlim"
},
"PI": {
"a": "()",
"d": "Atgriež vērtību Pi - 3,14159265358979 ar precizitāti līdz 15 cipariem"
},
"POWER": {
"a": "(skaitlis; pakāpe)",
"d": "Atgriež skaitļa kāpināšanas rezultātu"
},
"PRODUCT": {
"a": "(skaitlis1; [skaitlis2]; ...)",
"d": "Reizina visus skaitļus, kas sniegti kā argumenti"
},
"QUOTIENT": {
"a": "(skaitītājs; saucējs)",
"d": "Atgriež dalījuma veselo daļu"
},
"RADIANS": {
"a": "(leņķis)",
"d": "Konvertē grādus par radiāniem"
},
"RAND": {
"a": "()",
"d": "Atgriež gadījumskaitli, kas lielāks vai vienāds ar nulli un mazāks par 1 un ir vienmērīgi sadalīts (veicot pārrēķinu, mainās)"
},
"RANDARRAY": {
"a": "([rindas]; [ailes]; [min]; [max]; [vesels_skaitlis])",
"d": "Atgriež gadījumskaitļu masīvu"
},
"RANDBETWEEN": {
"a": "(mazākais; lielākais)",
"d": "Atgriež nejauši izvēlētu skaitli starp norādītajiem skaitļiem"
},
"ROMAN": {
"a": "(skaitlis; [forma])",
"d": "Konvertē arābu skaitļus uz romiešu skaitļiem kā tekstu"
},
"ROUND": {
"a": "(skaitlis; ciparu_skaits)",
"d": "Noapaļo skaitli līdz norādītajam ciparu skaitam"
},
"ROUNDDOWN": {
"a": "(skaitlis; ciparu_skaits)",
"d": "Noapaļo skaitli uz leju virzienā uz nulli"
},
"ROUNDUP": {
"a": "(skaitlis; ciparu_skaits)",
"d": "Noapaļo skaitli uz augšu virzienā no nulles"
},
"SEC": {
"a": "(skaitlis)",
"d": "atgriež leņķa sekanti"
},
"SECH": {
"a": "(skaitlis)",
"d": "atgriež leņķa hiperbolisko sekanti"
},
"SERIESSUM": {
"a": "(x; n; m; koeficienti)",
"d": "Atgriež pakāpju sērijas summu, kas balstīta formulā"
},
"SIGN": {
"a": "(skaitlis)",
"d": "Atgriež skaitļa zīmi: 1, ja skaitlis ir pozitīvs, nulli, ja skaitlis ir nulle, vai -1, ja skaitlis ir negatīvs"
},
"SIN": {
"a": "(skaitlis)",
"d": "Atgriež leņķa sinusu"
},
"SINH": {
"a": "(skaitlis)",
"d": "Atgriež skaitļa hiperbolisko sinusu"
},
"SQRT": {
"a": "(skaitlis)",
"d": "Atgriež skaitļa kvadrātsakni"
},
"SQRTPI": {
"a": "(skaitlis)",
"d": "Atgriež kvadrātsakni (skaitlis * Pi)"
},
"SUBTOTAL": {
"a": "(funkcijas_num; ats1; ...)",
"d": "Atgriež starpsummu sarakstā vai datu bāzē"
},
"SUM": {
"a": "(skaitlis1; [skaitlis2]; ...)",
"d": "Saskaita visus šūnu diapazonā esošos skaitļus"
},
"SUMIF": {
"a": "(diapazons; kritēriji; [summas_diapazons])",
"d": "Saskaita noteikta nosacījuma vai kritēriju norādītas šūnas"
},
"SUMIFS": {
"a": "(summas_diapazons; kritēriju_diapazons; kritēriji; ...)",
"d": "Pievieno šūnas, ko norāda dotā nosacījumu kopa vai kritēriji"
},
"SUMPRODUCT": {
"a": "(masīvs1; [masīvs2]; [masīvs3]; ...)",
"d": "Atgriež atbilstošo diapazonu vai masīvu reizinājumu summu"
},
"SUMSQ": {
"a": "(skaitlis1; [skaitlis2]; ...)",
"d": "Atgriež argumentu kvadrātu summu. Argumenti var būt skaitļi, masīvi, nosaukumi vai atsauces uz šūnām, kurās ir skaitļi"
},
"SUMX2MY2": {
"a": "(masīvs_x; masīvs_y)",
"d": "Sasummē divu atbilstošu diapazonu vai masīvu kvadrātu atšķirības"
},
"SUMX2PY2": {
"a": "(masīvs_x; masīvs_y)",
"d": "Atgriež divu atbilstošu diapazonu vai masīvu skaitļu kvadrātu summu kopsummu"
},
"SUMXMY2": {
"a": "(masīvs_x; masīvs_y)",
"d": "Sasummē divu atbilstošu diapazonu vai masīvu atšķirību kvadrātus"
},
"TAN": {
"a": "(skaitlis)",
"d": "Atgriež leņķa tangensu"
},
"TANH": {
"a": "(skaitlis)",
"d": "Atgriež skaitļa hiperbolisko tangensu"
},
"TRUNC": {
"a": "(skaitlis; [ciparu_skaits])",
"d": "Aprauj skaitli līdz veselam skaitlim, noņemot skaitļa decimāldaļu"
},
"ADDRESS": {
"a": "(rindas_num; kolonnas_num; [abs_num]; [a1]; [lapas])",
"d": "Izveido šūnas atsauci kā tekstu, ja norādīti rindas un kolonnas numuri"
},
"CHOOSE": {
"a": "(indeksa_num; vērtība1; [vērtība2]; ...)",
"d": "Izvēlas vērtību vai veicamo darbību no vērtību saraksta atkarībā no indeksa skaitļa"
},
"COLUMN": {
"a": "([atsauce])",
"d": "Atgriež atsauces kolonnas numuru"
},
"COLUMNS": {
"a": "(masīvs)",
"d": "Atgriež kolonnu skaitu atsaucē vai masīvā"
},
"FORMULATEXT": {
"a": "(atsauce)",
"d": "Atgriež formulu kā virkni"
},
"HLOOKUP": {
"a": "(uzmeklējamā_vērtība; tabulas_masīvs; rinda_indeksa_num; [diapazona_uzmeklēšana])",
"d": "Meklē vērtību tabulas vai vērtību masīva augšējā rindā un atgriež to tajā pašā rindas kolonnā, kuru norāda"
},
"HYPERLINK": {
"a": "(saite_uz_atraš_vietu; [pazīšanas_vārds])",
"d": "Izveido saīsni vai īsceļu, kas atver datora cietajā diskā, tīkla serverī vai internetā glabātu dokumentu"
},
"INDEX": {
"a": "(masīvs; rindas_numurs; [kolonnas_numurs]!atsauce; rindas_numurs; [kolonnas_numurs]; [apgabala_numurs])",
"d": "Atgriež vērtību vai šūnas atsauci, kas atrodas noteiktas rindas un kolonnas krustpunktā norādītajā diapazonā"
},
"INDIRECT": {
"a": "(ats_teksts; [a1])",
"d": "Atgriež atsauci, kas norādīta teksta virknē"
},
"LOOKUP": {
"a": "(uzmeklējamā_vērtība; uzmeklēšanas_vektors; [rezultāta_vektors]!uzmeklējamā_vērtība; masīvs)",
"d": "Uzmeklē vērtību vienas rindas vai vienas kolonnas diapazonā vai masīvā. Paredzēts atpakaļsaderībai"
},
"MATCH": {
"a": "(uzmeklējamā_vērtība; uzmeklēšanas_masīvs; [atbilstības_tips])",
"d": "Atgriež tāda masīva vienuma relatīvo pozīciju, kurš atbilst norādītai vērtībai norādītā kārtībā"
},
"OFFSET": {
"a": "(atsauce; rindas; kolonnas; [augstums]; [platums])",
"d": "Atgriež atsauci uz diapazonu, kas ir noteikts rindu un kolonnu skaits no noteiktas atsauces"
},
"ROW": {
"a": "([atsauce])",
"d": "Atgriež atsauces rindas numuru"
},
"ROWS": {
"a": "(masīvs)",
"d": "Atgriež rindu skaitu atsaucē vai masīvā"
},
"TRANSPOSE": {
"a": "(masīvs)",
"d": "Konvertē vertikālu šūnu diapazonu par horizontālu un pretēji"
},
"UNIQUE": {
"a": "(masīvs; [pēc_kolonnas]; [tieši_vienreiz])",
"d": "Atgriež unikālās vērtības no diapazona vai masīva."
},
"VLOOKUP": {
"a": "(uzmeklējamā_vērtība; tabulas_masīvs; kolonna_indeksa_num; [diapazona_uzmeklēšana])",
"d": "Meklē vērtību tabulas pēdējā kolonnā pa kreisi un pēc tam atgriež vērtību tajā pašā kolonnas rindā, kuru norāda. Pēc noklusējuma tabulai jābūt sakārtotai augošā secībā"
},
"XLOOKUP": {
"a": "(uzmeklējamā_vērtība; uzmeklēšanas_masīvs; atgriešanas_masīvs; [ja_nav_atrasts]; [atbilstības_režīms]; [meklēšanas_režīms])",
"d": "Meklē diapazonā vai masīvā atbilstību un atgriež atbilstošo vienumu no otra diapazona vai masīva. Pēc noklusējuma tiek izmantota precīza atbilstība"
},
"CELL": {
"a": "(info_type; [reference])",
"d": "Information function used to return information about the formatting, location, or contents of a cell"
},
"ERROR.TYPE": {
"a": "(kļūdas_vērt)",
"d": "Atgriež skaitli, kas atbilst kļūdas vērtībai."
},
"ISBLANK": {
"a": "(vērtība)",
"d": "Pārbauda, vai atsauce nav uz tukšu šūnu un atgriež TRUE vai FALSE"
},
"ISERR": {
"a": "(vērtība)",
"d": "Pārbauda, vai vērtība ir kļūda, kas nav #N/A, un atgriež TRUE vai FALSE"
},
"ISERROR": {
"a": "(vērtība)",
"d": "Pārbauda, vai vērtība ir kļūda, un atgriež TRUE vai FALSE"
},
"ISEVEN": {
"a": "(skaitlis)",
"d": "Atgriež TRUE, ja ir pārskaitlis"
},
"ISFORMULA": {
"a": "(atsauce)",
"d": "Pārbauda, vai atsauce ir uz šūnu, kurā ir formula, un atgriež TRUE vai FALSE"
},
"ISLOGICAL": {
"a": "(vērtība)",
"d": "Pārbauda, vai vērtība ir loģiskā vērtība (TRUE vai FALSE) un atgriež TRUE vai FALSE"
},
"ISNA": {
"a": "(vērtība)",
"d": "Pārbauda, vai vērtība ir #N/A un atgriež TRUE vai FALSE"
},
"ISNONTEXT": {
"a": "(vērtība)",
"d": "Pārbauda, vai vērtība nav teksts (tukšas šūnas nav teksts) un atgriež TRUE vai FALSE"
},
"ISNUMBER": {
"a": "(vērtība)",
"d": "Pārbauda, vai vērtība ir skaitlis un atgriež TRUE vai FALSE"
},
"ISODD": {
"a": "(skaitlis)",
"d": "Atgriež TRUE, ja ir nepārskaitlis"
},
"ISREF": {
"a": "(vērtība)",
"d": "Pārbauda, vai vērtība ir atsauce un atgriež TRUE vai FALSE"
},
"ISTEXT": {
"a": "(vērtība)",
"d": "Pārbauda, vai vērtība ir teksts un atgriež TRUE vai FALSE"
},
"N": {
"a": "(vērtība)",
"d": "Konvertē vērtību, kas nav skaitlis, par skaitli, datumus - par seriāliem skaitļiem, TRUE uz 1, visu citu - uz 0 (nulli)"
},
"NA": {
"a": "()",
"d": "Atgriež kļūdas vērtību #N/A (vērtība nav pieejama)"
},
"SHEET": {
"a": "([vērtība])",
"d": "Atgriež atsauces lapas numuru"
},
"SHEETS": {
"a": "([atsauce])",
"d": "Atgriež lapu skaitu atsaucē"
},
"TYPE": {
"a": "(vērtība)",
"d": "Atgriež veselu skaitli, kas apzīmē vērtības datu tipu: skaitlis = 1; teksts = 2; loģiskā vērtība = 4; kļūdas vērtība = 16; masīvs = 64; saliktie dati = 128"
},
"AND": {
"a": "(loģiskā1; [loģiskā2]; ...)",
"d": "Pārbauda, vai visi argumenti ir TRUE, un atgriež TRUE, ja visi argumenti ir TRUE"
},
"FALSE": {
"a": "()",
"d": "Atgriež loģisko vērtību FALSE"
},
"IF": {
"a": "(loģiskais_tests; [vērtība_ja_true]; [vērtība_ja_false])",
"d": "Pārbauda, vai ir ievērots nosacījums, un atgriež vienu vērtību, ja TRUE, bet citu vērtību, ja - FALSE"
},
"IFS": {
"a": "(loģiskais_tests; vērtība_ja_patiess; ...)",
"d": "Pārbauda, vai ir izpildīts viens vai vairāki nosacījumi, un atgriež vērtību, kas atbilst pirmajam PATIESAJAM nosacījumam"
},
"IFERROR": {
"a": "(vērtība; vērtība_ja_kļūda)",
"d": "Atgriež vērtība_ja_kļūda, ja izteiksme ir kļūdaina, bet pretējā gadījumā — pašas izteiksmes vērtību"
},
"IFNA": {
"a": "(vērtība; vērtība_ja_nav_pieej)",
"d": "Atgriež norādīto vērtību, ja izteiksmes atrisinājums ir #N/A; citos gadījumos atgriež izteiksmes vērtību"
},
"NOT": {
"a": "(loģiskā)",
"d": "Maina FALSE uz TRUE vai TRUE uz FALSE"
},
"OR": {
"a": "(loģiskā1; [loģiskā2]; ...)",
"d": "Pārbauda, vai kāds no argumentiem ir TRUE, un atgriež TRUE vai FALSE. Atgriež FALSE tikai tad, ja visi argumenti ir FALSE"
},
"SWITCH": {
"a": "(izteiksme; vērtība1; rezultāts1; [noklusējums_vai_vērtība2]; [rezultāts2]; ...)",
"d": "Novērtē izteiksmi pret vērtību sarakstu un atgriež rezultātu, kas atbilst pirmajai atbilstošajai vērtībai. Ja atbilstības nav, tiek atgriezta neobligāta noklusējuma vērtība"
},
"TRUE": {
"a": "()",
"d": "Atgriež loģisko vērtību TRUE"
},
"XOR": {
"a": "(loģiskā_vērtība1; [loģiskā_vērtība2]; ...)",
"d": "No visiem argumentiem atgriež loģisko vērtību \"Izņemot/Vai\""
}
}