> ## Documentation Index > Fetch the complete documentation index at: https://help.dingtalk.io/llms.txt > Use this file to discover all available pages before exploring further. # Referensi fungsi formula > Referensi lengkap fungsi formula AI Table — logika, info, tanggal/waktu, teks, matematika, teknik, statistika, keuangan, dan lainnya. # **Logika** | Fungsi | Deskripsi | Contoh | Argumen | | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `AND` | Mengembalikan true jika semua argumen bernilai logika benar; mengembalikan false jika ada yang salah. | AND(\\\[expr1], \\\[expr2]) | expr1: ekspresi atau referensi sel yang menghasilkan nilai logika (TRUE / FALSE) atau dapat dikonversi menjadi nilai tersebut. expr2: ekspresi lain yang menghasilkan nilai logika. | | `FALSE` | Mengembalikan nilai logika FALSE. | FALSE() | | | `IF` | Mengembalikan satu nilai ketika ekspresi bernilai TRUE, dan nilai lain ketika FALSE. | IF(\\\[expr], \\\[value\_if\_true], \\\[value\_if\_false]) | expr: ekspresi logika atau referensi. value\_if\_true: dikembalikan ketika expr bernilai TRUE. value\_if\_false: dikembalikan ketika expr bernilai FALSE. | | `IFERROR` | Mengembalikan argumen pertama jika bukan kesalahan; jika tidak, mengembalikan argumen kedua, atau kosong jika tidak disediakan. | IFERROR(\\\[value], \\\[value\_if\_error]) | value: nilai yang dikembalikan ketika bukan kesalahan. value\_if\_error: dikembalikan ketika value merupakan kesalahan. | | `IFS` | Mengevaluasi beberapa kondisi dan mengembalikan nilai yang cocok dengan kondisi TRUE pertama. | IFS(\\\[cond1], \\\[val1], \\\[cond2], \\\[val2]) | cond1: kondisi pertama yang dievaluasi. val1: dikembalikan ketika cond1 bernilai TRUE. cond2: kondisi berikutnya jika kondisi sebelumnya FALSE. val2: dikembalikan ketika cond2 bernilai TRUE. | | `NOT` | Mengembalikan kebalikan dari suatu nilai logika — NOT(TRUE) → FALSE, NOT(FALSE) → TRUE. | NOT(\\\[expr]) | expr: ekspresi atau referensi sel yang mewakili nilai logika. | | `OR` | Mengembalikan true jika ada argumen yang bernilai logika benar; false jika semuanya salah. | OR(\\\[expr1], \\\[expr2]) | expr1: ekspresi yang menghasilkan nilai logika. expr2: ekspresi lain yang menghasilkan nilai logika. | | `SWITCH` | Menguji suatu ekspresi terhadap daftar kasus dan mengembalikan nilai yang cocok; mengembalikan nilai default ketika tidak ada yang cocok (opsional). | SWITCH(\[expr], \[case1], \[val1], \[case2\_or\_default], \[val2]) | expr: nilai yang diperiksa. case1: kasus pertama yang dibandingkan. val1: dikembalikan ketika case1 cocok. case2\_or\_default: kasus berikutnya yang dicoba, atau default jika tidak ada yang cocok. val2: dikembalikan ketika case2 cocok. | | `TRUE` | Mengembalikan nilai logika TRUE. | TRUE() | | | `XOR` | Mengembalikan true ketika jumlah argumen yang bernilai logika benar berjumlah ganjil; false ketika genap. | XOR(\\\[expr1], \\\[expr2]) | expr1: ekspresi yang menghasilkan nilai logika. expr2: ekspresi lain yang menghasilkan nilai logika. | # **Informasi** | Fungsi | Deskripsi | Contoh | Argumen | | ------------ | -------------------------------------------------------------------------- | --------------------- | ----------------------------------------------------------------------------------------------------- | | `ERROR.TYPE` | Mengembalikan angka yang sesuai dengan nilai kesalahan di sel lain. | ERROR.TYPE(\\\[ref]) | ref: sel tempat mencari nomor kesalahan — Anda juga dapat memasukkan nilai kesalahan secara langsung. | | `ISBLANK` | Memeriksa apakah sel yang direferensikan kosong. | ISBLANK(\\\[value]) | value: referensi ke sel yang akan diperiksa. | | `ISERR` | Memeriksa apakah suatu nilai adalah kesalahan selain #N/A. | ISERR(\\\[value]) | value: nilai yang akan diuji. | | `ISERROR` | Memeriksa apakah suatu nilai adalah kesalahan apa pun. | ISERROR(\\\[value]) | value: nilai yang akan diuji. | | `ISEVEN` | Memeriksa apakah suatu nilai genap. | ISEVEN(\\\[value]) | value: nilai yang akan diuji. | | `ISLOGICAL` | Memeriksa apakah suatu nilai adalah TRUE atau FALSE. | ISLOGICAL(\\\[value]) | value: nilai yang akan diuji. | | `ISNA` | Memeriksa apakah suatu nilai adalah kesalahan #N/A. | ISNA(\\\[value]) | value: nilai yang dibandingkan dengan #N/A. | | `ISNONTEXT` | Memeriksa apakah suatu nilai bukan teks. | ISNONTEXT(\\\[value]) | value: nilai yang akan diuji. | | `ISNUMBER` | Memeriksa apakah suatu nilai adalah angka. | ISNUMBER(\\\[value]) | value: nilai yang akan diuji. | | `ISODD` | Memeriksa apakah suatu nilai ganjil. | ISODD(\\\[number]) | number: nilai yang akan diuji. | | `ISTEXT` | Memeriksa apakah suatu nilai adalah teks. | ISTEXT(\\\[value]) | value: nilai yang akan diuji. | | `N` | Mengembalikan argumen sebagai angka. Teks menjadi 0; kesalahan diteruskan. | N(\\\[value]) | value: argumen yang akan dikonversi. | | `NA` | Mengembalikan kesalahan "tanpa nilai" #N/A. | NA() | | | `URL` | Mengembalikan tautan dari sel yang direferensikan. | URL(\\\[ref]) | ref: referensi sel. | # **Tanggal & waktu** | Fungsi | Deskripsi | Contoh | Argumen | | ------------------ | --------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `DATE` | Mengonversi tahun, bulan, dan hari yang diberikan menjadi tanggal. | DATE(year, month, day) | year: nomor tahun — manual atau bidang. month: nomor bulan — manual atau bidang. day: nomor hari — manual atau bidang. | | `DATEADD` | Menambah/mengurangi sejumlah waktu dari waktu dasar, dengan satuan. Mis., `DATEADD("2025-01-01", 2, "weeks")` → 2025-01-15. | DATEADD(\\\[start], \\\[amount], \\\[unit]) | start: waktu dasar, wajib. amount: jumlah yang ditambah/dikurangi, wajib. unit: satuan `amount`, wajib. Valid: "ms", "milliseconds", "s", "seconds", "m", "minutes", "h", "hours", "d", "days", "w", "weeks", "M", "months", "q", "quarters", "y", "years". | | `DATEDIF` | Menghitung selisih hari, bulan, atau tahun antara dua tanggal. | DATEDIF(start, end, unit) | start: tanggal mulai — bidang tanggal, tanggal numerik, atau formula. end: tanggal akhir — bidang tanggal, tanggal numerik, atau formula. unit: singkatan satuan, mis., Y / M / D. | | `DATEVALUE` | Mengonversi string tanggal berformat yang dikenal menjadi nilai tanggal. | DATEVALUE(\\\[date\_string]) | date\_string: string yang mewakili tanggal. | | `DAY` | Mengembalikan hari dalam sebulan untuk suatu tanggal sebagai angka. | DAY(date\_value) | date\_value: tanggal untuk mengekstrak harinya. | | `DAYS` | Mengembalikan selisih hari antara dua tanggal. | DAYS(end, start) | end: tanggal akhir — bidang tanggal, tanggal numerik, atau formula. start: tanggal mulai. | | `DAYS360` | Mengembalikan jumlah hari antara dua tanggal dengan asumsi setahun 360 hari (digunakan dalam perhitungan bunga). | DAYS360(\\\[start], \\\[end], \\\[method]) | start: tanggal mulai — referensi sel tanggal, fungsi yang menghasilkan tanggal, atau angka. end: tanggal akhir. method: metode penghitungan hari yang digunakan. | | `EDATE` | Mengembalikan tanggal yang sejumlah bulan sebelum/sesudah tanggal lain. | EDATE(start, months) | start: tanggal referensi. months: bulan sebelumnya (negatif) atau sesudahnya (positif). | | `EOMONTH` | Mengembalikan hari terakhir dalam bulan, sejumlah bulan sebelum/sesudah tanggal lain. | EOMONTH(start, months) | start: tanggal mulai. months: positif → masa depan; negatif → masa lalu. | | `HOUR` | Mengembalikan bagian jam dari suatu waktu sebagai angka. | HOUR(time) | time: waktu yang akan dihitung. | | `ISOWEEKNUM` | Mengembalikan nomor minggu ISO dalam setahun untuk suatu tanggal. | ISOWEEKNUM(\\\[date]) | date: tanggal — referensi sel, fungsi yang menghasilkan tanggal, atau angka. | | `MINUTE` | Mengembalikan bagian menit dari suatu waktu sebagai angka. | MINUTE(time) | time: waktu yang akan dihitung. | | `MONTH` | Mengembalikan bulan untuk suatu tanggal sebagai angka. | MONTH(date\_value) | date\_value: tanggal untuk mengekstrak bulannya. | | `NETWORKDAYS` | Mengembalikan jumlah hari kerja bersih antara dua tanggal. | NETWORKDAYS(start, end, \\\[holidays]) | start: tanggal mulai. end: tanggal akhir. holidays: default akhir pekan; Anda juga dapat memasukkan rentang tanggal atau bidang. | | `NETWORKDAYS.INTL` | Mengembalikan jumlah hari kerja bersih antara dua tanggal (tidak termasuk akhir pekan dan hari libur yang ditentukan). | NETWORKDAYS.INTL(\\\[start], \\\[end], \\\[weekend], \\\[holidays]) | start: awal periode. end: akhir periode. weekend: angka atau string yang menunjukkan hari mana yang merupakan akhir pekan. holidays: rentang atau array tanggal yang dianggap hari libur. | | `NOW` | Mengembalikan tanggal dan waktu saat ini sebagai nilai tanggal. | NOW() | / | | `SECOND` | Mengembalikan bagian detik dari suatu waktu sebagai angka. | SECOND(time) | time: waktu yang akan dihitung. | | `TODAY` | Mengembalikan tanggal saat ini sebagai nilai tanggal. | TODAY() | / | | `WEEKDAY` | Mengembalikan angka untuk hari dalam seminggu dari suatu tanggal. | WEEKDAY(date\_value, \\\[type]) | date\_value: tanggal target. type: hari yang mengawali minggu ke-1 — 1 = Minggu, 2 = Senin. Default 1. | | `WEEKNUM` | Mengembalikan nomor minggu dalam setahun untuk suatu tanggal. | WEEKNUM(date, \\\[type]) | date: tanggal target. type: hari yang mengawali minggu ke-1 — 1 = Minggu, 2 = Senin. Default 1. | | `WORKDAY` | Menghitung tanggal akhir berdasarkan jumlah hari kerja. | WORKDAY(start, days, \\\[holidays]) | start: tanggal mulai — fungsi tanggal atau bidang numerik. days: hari kerja dari tanggal mulai. holidays: default akhir pekan; Anda juga dapat memasukkan rentang atau array. | | `WORKDAY.INTL` | Menghitung tanggal sejumlah hari kerja kemudian (tidak termasuk akhir pekan dan hari libur yang ditentukan). | WORKDAY.INTL(\\\[start], \\\[days], \\\[weekend], \\\[holidays]) | start: tanggal mulai. days: hari kerja ke depan (negatif untuk ke belakang). weekend: angka atau string yang menunjukkan hari mana yang merupakan akhir pekan. holidays: rentang atau array tanggal yang dianggap hari libur. | | `YEAR` | Mengembalikan tahun dari suatu tanggal. | YEAR(date\_value) | date\_value: tanggal untuk mengekstrak tahunnya. | | `YEARFRAC` | Mengembalikan tahun pecahan antara dua tanggal menggunakan metode penghitungan hari yang ditentukan. | YEARFRAC(\\\[start], \\\[end], \\\[method]) | start: tanggal mulai — referensi sel, fungsi yang menghasilkan tanggal, atau angka. end: tanggal akhir. method: metode penghitungan hari yang digunakan. | # **Teks** | Fungsi | Deskripsi | Contoh | Argumen | | ------------- | ------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `CHAR` | Mengembalikan karakter Unicode untuk suatu angka. | CHAR(number) | number: angka yang akan dikonversi. | | `CLEAN` | Mengembalikan teks dengan karakter ASCII yang tidak dapat dicetak dihapus. | CLEAN(\\\[text]) | text: teks yang akan dibersihkan. | | `CODE` | Mengembalikan nilai Unicode dari karakter pertama string yang diberikan. | CODE(\\\[string]) | string: string yang akan diperiksa. | | `CONCAT` | Mengembalikan penggabungan dua nilai. Setara dengan `&`. | CONCAT(\\\[value1], \\\[value2]) | value1: nilai sebelumnya. value2: nilai yang akan ditambahkan. | | `CONCATENATE` | Menggabungkan beberapa string. | CONCATENATE(string1, \\\[string2, ...]) | string1: string awal. string2: string tambahan yang akan ditambahkan. | | `EXACT` | Membandingkan dua string untuk kesamaan. | EXACT(\\\[string1], \\\[string2]) | string1: string pertama. string2: string kedua. | | `FIND` | Mencari suatu nilai mulai dari posisi tertentu dan mengembalikan posisi kemunculan pertamanya; mengembalikan -1 jika tidak ditemukan. | FIND(search\_value, search\_range, \\\[start\_position]) | search\_value: nilai yang dicari — peka huruf besar/kecil. search\_range: tempat pencarian — nilai, array, atau bidang. start\_position: posisi awal. Default 1. | | `FINDB` | Mengembalikan posisi kemunculan pertama suatu string dalam teks (setiap karakter double-byte dihitung sebagai 2). | FINDB(\\\[search\_for], \\\[text\_to\_search], \\\[start\_position]) | search\_for: string yang dicari. text\_to\_search: tempat pencarian. start\_position: posisi karakter awal. | | `FIXED` | Memformat angka dengan jumlah tempat desimal yang tetap. | FIXED(\\\[number], \\\[decimals], \\\[no\_separator]) | number: angka yang akan diformat. decimals: jumlah desimal yang ditampilkan. no\_separator: apakah menyembunyikan pemisah ribuan (0 / false → gunakan pemisah). | | `LEFT` | Mengembalikan substring dari awal string. | LEFT(string, \\\[count]) | string: string sumber. count: jumlah karakter yang dikembalikan dari kiri. | | `LEFTB` | Mengembalikan substring dari awal string (dalam byte). | LEFTB(\[string], \[number\_of\_bytes]) | string: string sumber. number\_of\_bytes: jumlah byte dari kiri. | | `LEN` | Mengembalikan panjang string. | LEN(text) | text: string. | | `LENB` | Mengembalikan panjang string dalam byte. | LENB(\\\[text]) | text: string. | | `LOWER` | Mengonversi string menjadi huruf kecil. | LOWER(text) | text: string. | | `MID` | Mengembalikan substring dengan panjang tertentu mulai dari posisi tertentu. | MID(string, start, length) | string: string sumber. start: indeks awal berbasis 1. length: jumlah karakter yang diekstrak. | | `MIDB` | Mengembalikan substring (dalam byte). | MIDB(\[string], \[starting\_at], \[extract\_length\_bytes]) | string: string sumber. starting\_at: offset byte berbasis 1. extract\_length\_bytes: panjang substring dalam byte. | | `PROPER` | Mengapitalkan huruf pertama setiap kata dalam string. | PROPER(\\\[text]) | text: string — huruf pertama setiap kata menjadi kapital, sisanya huruf kecil. | | `REGEXTEST` | Memeriksa apakah ada bagian teks yang cocok dengan ekspresi reguler. | REGEXTEST(\\\[text], \\\[regex], \\\[case\_sensitive]) | text: teks yang diperiksa. regex: ekspresi reguler. case\_sensitive: apakah pencocokan peka huruf besar/kecil. Default true. | | `REPLACE` | Mengganti sebagian string teks dengan teks lain. | REPLACE(text, position, length, new\_text) | text: teks sumber. position: awal penggantian berbasis 1. length: jumlah karakter yang diganti. new\_text: teks pengganti. | | `REPLACEB` | Mengganti sebagian string teks dengan teks lain (dalam byte). | REPLACEB(\\\[text], \\\[position], \\\[bytes], \\\[new\_text]) | text: teks sumber. position: posisi byte berbasis 1. bytes: jumlah byte yang diganti. new\_text: teks pengganti. | | `REPT` | Mengulangi teks sejumlah kali yang ditentukan. | REPT(\\\[text], \\\[count]) | text: string yang akan diulang. count: berapa kali. | | `RIGHT` | Mengembalikan substring dari akhir string. | RIGHT(string, \\\[count]) | string: string sumber. count: jumlah karakter dari kanan. | | `RIGHTB` | Mengembalikan substring dari akhir string (dalam byte). | RIGHTB(\[string], \[number\_of\_bytes]) | string: string sumber. number\_of\_bytes: byte dari kanan. | | `SEARCH` | Mengembalikan posisi kemunculan pertama suatu string dalam teks. Mengembalikan #VALUE! jika tidak ditemukan. | SEARCH(\\\[search\_string], \\\[text\_to\_search], \\\[start\_position]) | search\_string: string yang dicari. text\_to\_search: tempat pencarian. start\_position: posisi karakter awal. | | `SEARCHB` | Mengembalikan posisi kemunculan pertama dalam teks (setiap karakter double-byte dihitung sebagai 2). | SEARCHB(\\\[search\_for], \\\[text\_to\_search], \\\[start\_position]) | search\_for: string yang dicari. text\_to\_search: tempat pencarian. start\_position: posisi karakter awal. | | `SUBSTITUTE` | Mengganti sebagian teks yang ada dengan teks baru. | SUBSTITUTE(text, old\_text, new\_text, \\\[occurrence]) | text: teks asli. old\_text: teks yang akan diganti. new\_text: pengganti. occurrence: kemunculan mana yang diganti; jika diabaikan, mengganti semua. | | `T` | Mengembalikan argumen sebagai teks; mengembalikan string kosong jika bukan teks. | T(\\\[value]) | value: argumen yang akan dikonversi menjadi teks. | | `TEXT` | Mengonversi angka menjadi teks dalam format yang ditentukan. | TEXT(value, format) | value: nilai yang akan dikonversi. format: format angka kustom — umum: "YYYY/MM/DD", "MM/DD HH:MM", "DDDD" (nama hari lengkap), "DDD" (nama hari singkat), "0.0%". | | `TEXTJOIN` | Menggabungkan string dan/atau array dengan pemisah yang dapat disesuaikan. | TEXTJOIN(\\\[delimiter], \\\[ignore\_empty], \\\[text1], \\\[text2]) | delimiter: string atau referensi (boleh kosong — menggabungkan secara langsung). ignore\_empty: boolean; TRUE melewati sel kosong. text1: teks apa pun — string atau array. text2: teks lainnya. | | `TRIM` | Menghapus spasi di awal, di akhir, dan spasi ganda dari teks. | TRIM(text) | text: string atau referensi yang akan dibersihkan. | | `UNICHAR` | Mengembalikan karakter untuk angka Unicode desimal. | UNICHAR(\\\[number]) | number: angka Unicode. | | `UNICODE` | Mengembalikan nilai Unicode desimal dari karakter pertama string. | UNICODE(\\\[text]) | text: string yang berisi karakter yang akan dievaluasi. | | `UPPER` | Mengonversi string menjadi huruf besar. | UPPER(text) | text: string. | | `VALUE` | Mengonversi string berformat tanggal, waktu, atau angka yang dikenal menjadi angka. | VALUE(\\\[text]) | text: string yang akan dikonversi. | # **Matematika & trigonometri** | Fungsi | Deskripsi | Contoh | Argumen | | ---------------- | -------------------------------------------------------------------------------------------------------- | ------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `ABS` | Mengembalikan nilai absolut suatu angka. | ABS(number) | number: nilai. | | `ACOS` | Mengembalikan kosinus invers dalam radian. | ACOS(number) | number: nilai. | | `ACOSH` | Mengembalikan kosinus hiperbolik invers. | ACOSH(number) | number: nilai. | | `ACOT` | Mengembalikan kotangen invers dalam radian. | ACOT(\\\[value]) | value: angka. | | `ACOTH` | Mengembalikan kotangen hiperbolik invers dalam radian. | ACOTH(\\\[value]) | value: angka — tidak boleh berada dalam rentang \[-1, 1]. | | `ARABIC` | Menghitung nilai angka Romawi. | ARABIC(\\\[roman]) | roman: angka Romawi — harus 1 sampai 3999. | | `ASIN` | Mengembalikan sinus invers dalam radian. | ASIN(number) | number: nilai. | | `ASINH` | Mengembalikan sinus hiperbolik invers dalam radian. | ASINH(number) | number: nilai. | | `ATAN` | Mengembalikan tangen invers dalam radian. | ATAN(number) | number: nilai. | | `ATAN2` | Mengembalikan tangen invers dari koordinat X / Y yang diberikan. | ATAN2(x, y) | x: koordinat x. y: koordinat y. | | `ATANH` | Mengembalikan tangen hiperbolik invers. | ATANH(number) | number: nilai. | | `BASE` | Mengonversi angka menjadi teks dalam basis numerik lain (mis., basis 2 untuk biner). | BASE(\\\[value], \\\[base], \\\[min\_length]) | value: angka yang akan dikonversi. base: basis target. min\_length: panjang minimum teks yang dikembalikan. | | `CEILING` | Membulatkan ke atas ke kelipatan faktor terdekat. | CEILING(\\\[value], \\\[factor]) | value: angka yang akan dibulatkan ke atas. factor: kelipatan pembulatan. | | `CELING.MATH` | Membulatkan ke atas ke kelipatan signifikansi terdekat; untuk angka negatif, arah bergantung pada mode. | CEILING.MATH(\\\[number], \\\[significance], \\\[mode]) | number: angka yang akan dibulatkan. significance: kelipatan pembulatan — tanda diabaikan. mode: untuk angka negatif, mengontrol arah. 0 / kosong → menuju nol; jika tidak, menjauhi nol. | | `CELING.PRECISE` | Membulatkan ke atas ke kelipatan signifikansi terdekat. Angka positif dan negatif dibulatkan. | CEILING.PRECISE(\\\[number], \\\[significance]) | number: angka yang akan dibulatkan. significance: kelipatan pembulatan. | | `COMBIN` | Mengembalikan jumlah cara memilih k dari n (kombinasi). | COMBIN(\\\[n], \\\[k]) | n: total objek. k: jumlah yang dipilih. | | `COMBINA` | Mengembalikan jumlah cara memilih k dari n dengan pengulangan. | COMBINA(\\\[n], \\\[k]) | n: total objek. k: jumlah yang dipilih. | | `COS` | Mengembalikan kosinus suatu sudut (dalam radian). | COS(angle) | angle: sudut dalam radian. | | `COSH` | Mengembalikan kosinus hiperbolik dari bilangan real. | COSH(number) | number: nilai. | | `COT` | Mengembalikan kotangen suatu sudut (dalam radian). | COT(\\\[angle]) | angle: sudut dalam radian. | | `COTH` | Mengembalikan kotangen hiperbolik dari bilangan real. | COTH(\\\[value]) | value: bilangan real. | | `CSC` | Mengembalikan kosekan suatu sudut (dalam radian). | CSC(\\\[angle]) | angle: sudut dalam radian. | | `CSCH` | Mengembalikan kosekan hiperbolik dari bilangan real. | CSCH(\\\[value]) | value: bilangan real. | | `DECIMAL` | Mengonversi teks-angka dalam basis lain menjadi angka basis-10. | DECIMAL(\\\[value], \\\[base]) | value: teks-angka yang akan dikonversi. base: basis sumber. | | `DEGREES` | Mengonversi sudut dari radian menjadi derajat. | DEGREES(\\\[angle]) | angle: sudut dalam radian. | | `EVEN` | Membulatkan ke atas ke bilangan bulat genap terdekat. | EVEN(\\\[number]) | number: nilai yang akan dibulatkan. | | `EXP` | Mengembalikan bilangan Euler e (\~2,718) yang dipangkatkan. | EXP(\\\[exponent]) | exponent: pangkat untuk menaikkan e. | | `FACT` | Mengembalikan faktorial suatu angka. | FACT(\\\[number]) | number: nilai. | | `FACTDOUBLE` | Mengembalikan faktorial ganda suatu angka. | FACTDOUBLE(\\\[number]) | number: nilai. | | `FLOOR` | Membulatkan ke bawah ke kelipatan faktor terdekat. | FLOOR(\\\[value], \\\[factor]) | value: angka yang akan dibulatkan ke bawah. factor: kelipatan pembulatan. | | `FLOOR.MATH` | Membulatkan ke bawah ke kelipatan signifikansi terdekat; untuk angka negatif, arah bergantung pada mode. | FLOOR.MATH(\\\[number], \\\[significance], \\\[mode]) | number: angka yang akan dibulatkan. significance: kelipatan pembulatan — tanda diabaikan. mode: untuk angka negatif, 0 / kosong → menjauhi nol; jika tidak, menuju nol. | | `FLOOR.PRECISE` | Membulatkan ke bawah ke kelipatan signifikansi terdekat. Angka positif dan negatif dibulatkan. | FLOOR.PRECISE(\\\[number], \\\[significance]) | number: angka yang akan dibulatkan. significance: kelipatan pembulatan. | | `GCD` | Mengembalikan pembagi persekutuan terbesar dari satu atau lebih bilangan bulat. | GCD(\\\[number1], \\\[number2]) | number1: angka atau rentang pertama. number2: angka atau rentang lainnya. | | `INT` | Membulatkan ke bawah ke bilangan bulat terdekat ≤ nilai. | INT(number) | number: nilai. | | `LCM` | Mengembalikan kelipatan persekutuan terkecil dari satu atau lebih bilangan bulat. | LCM(\\\[number1], \\\[number2]) | number1: angka atau rentang pertama. number2: angka atau rentang lainnya. | | `LN` | Mengembalikan logaritma natural (basis e) suatu angka. | LN(\\\[number]) | number: nilai. | | `LOG` | Mengembalikan logaritma suatu angka dalam basis yang ditentukan. | LOG(\\\[number], \\\[base]) | number: nilai. base: basis logaritma. | | `LOG10` | Mengembalikan logaritma basis-10 suatu angka. | LOG10(\\\[number]) | number: nilai. | | `MMULT` | Menghitung hasil kali matriks dari dua matriks yang diberikan sebagai array / rentang. | MMULT(\\\[matrix1], \\\[matrix2]) | matrix1: matriks pertama sebagai array atau rentang. matrix2: matriks kedua sebagai array atau rentang. | | `MOD` | Mengembalikan sisa pembagian. | MOD(dividend, divisor) | dividend: bilangan yang dibagi. divisor: pembagi. | | `MROUND` | Membulatkan ke kelipatan bilangan bulat lain terdekat. | MROUND(\\\[number], \\\[factor]) | number: nilai yang akan dibulatkan. factor: kelipatan pembulatan. | | `MULTINOMIAL` | Mengembalikan faktorial dari jumlah argumen dibagi hasil kali faktorialnya. | MULTINOMIAL(\\\[number1], \\\[number2]) | number1: angka atau rentang pertama. number2: angka atau rentang lainnya. | | `MUNIT` | Mengembalikan matriks identitas n × n di mana n adalah input. | MUNIT(\\\[size]) | size: dimensi — harus positif. | | `ODD` | Membulatkan ke atas ke bilangan bulat ganjil terdekat. | ODD(\\\[number]) | number: nilai yang akan dibulatkan. | | `PI` | Mengembalikan konstanta matematika π (3,14159265358979) hingga 15 digit. | PI() | / | | `POWER` | Mengembalikan hasil pemangkatan suatu angka. | POWER(base, exponent) | base: sembarang bilangan real. exponent: pangkat. | | `PRODUCT` | Mengembalikan hasil kali dari sekumpulan angka. | PRODUCT(\\\[number1], \\\[number2]) | number1: angka atau rentang pertama. number2: angka atau rentang lainnya. | | `QUOTIENT` | Mengembalikan bagian bilangan bulat dari suatu pembagian — mengabaikan sisa. | QUOTIENT(dividend, divisor) | dividend: bilangan yang dibagi. divisor: pembagi. | | `RADIANS` | Mengonversi sudut dari derajat menjadi radian. | RADIANS(\\\[angle]) | angle: sudut dalam derajat. | | `RAND` | | RAND() | | | `RANDBETWEEN` | Mengembalikan bilangan bulat acak antara dua bilangan bulat (inklusif). | RANDBETWEEN(\\\[low], \\\[high]) | low: batas bawah. high: batas atas. | | `ROMAN` | Memformat angka sebagai angka Romawi. | ROMAN(\\\[number], \\\[simplification]) | number: angka yang akan diformat — 1 sampai 3999. simplification: tingkat penyederhanaan — 0 sampai 4. | | `ROUND` | Membulatkan angka ke sejumlah digit yang ditentukan. | ROUND(number, digits) | number: nilai yang akan dibulatkan. digits: digit — 1 = 1 desimal, 0 = bilangan bulat, -1 = puluhan. | | `ROUNDDOWN` | Membulatkan angka menuju nol ke sejumlah digit yang ditentukan. | ROUNDDOWN(number, digits) | number: nilai yang akan dibulatkan. digits: 1 = 1 desimal, 0 = bilangan bulat, -1 = puluhan. | | `ROUNDUP` | Membulatkan angka menjauhi nol ke sejumlah digit yang ditentukan. | ROUNDUP(number, digits) | number: nilai yang akan dibulatkan. digits: 1 = 1 desimal, 0 = bilangan bulat, -1 = puluhan. | | `SEC` | Mengembalikan sekan suatu sudut (dalam radian). | SEC(\\\[angle]) | angle: sudut dalam radian. | | `SECH` | Mengembalikan sekan hiperbolik dari bilangan real. | SECH(\\\[value]) | value: bilangan real. | | `SIGN` | Mengembalikan -1 untuk negatif, 1 untuk positif, 0 untuk nol. | SIGN(\\\[number]) | number: nilai. | | `SIN` | Mengembalikan sinus suatu sudut (dalam radian). | SIN(angle) | angle: sudut dalam radian. | | `SINH` | Mengembalikan sinus hiperbolik dari bilangan real. | SINH(number) | number: nilai. | | `SQRT` | Mengembalikan akar kuadrat positif dari bilangan positif. | SQRT(\\\[number]) | number: nilai. | | `SQRTP` | Mengembalikan akar kuadrat positif dari (PI × bilangan positif). | SQRTPI(\\\[number]) | number: nilai yang akan dikalikan dengan PI. | | `SUM` | Mengembalikan jumlah dari semua nilai dalam array target. | SUM(value1, \\\[value2, ...]) | value1: angka atau referensi kolom pertama. value2: angka atau kolom lainnya. | | `SUMPRODUCT` | Mengembalikan jumlah hasil kali elemen-elemen yang bersesuaian dalam dua array / rentang berukuran sama. | SUMPRODUCT(\\\[array1], \\\[array2]) | array1: array atau rentang pertama. array2: array atau rentang kedua. | | `SUMSQ` | Mengembalikan jumlah kuadrat dari sekumpulan nilai. | SUMSQ(\\\[number1], \\\[number2]) | number1: angka atau rentang pertama. number2: angka atau rentang lainnya. | | `SUMX2MY2` | Mengembalikan jumlah selisih kuadrat dari nilai-nilai yang bersesuaian dalam dua array. | SUMX2MY2(\[array\_x], \[array\_y]) | array\_x: array atau rentang pertama. array\_y: array atau rentang kedua. | | `SUMX2PY2` | Mengembalikan jumlah penjumlahan kuadrat dari nilai-nilai yang bersesuaian dalam dua array. | SUMX2PY2(\[array\_x], \[array\_y]) | array\_x: array atau rentang pertama. array\_y: array atau rentang kedua. | | `TAN` | Mengembalikan tangen suatu sudut (dalam radian). | TAN(angle) | angle: sudut dalam radian. | | `TANH` | Mengembalikan tangen hiperbolik dari bilangan real. | TANH(number) | number: nilai. | | `TRUNC` | Memotong angka ke sejumlah digit signifikan yang ditentukan. | TRUNC(\\\[number], \\\[digits]) | number: nilai yang akan dipotong. digits: digit yang dipertahankan setelah desimal. | # **Teknik** | Fungsi | Deskripsi | Contoh | Argumen | | -------------- | ------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------- | | `BESSELI` | Mengembalikan fungsi Bessel termodifikasi — sama dengan fungsi Bessel yang dievaluasi untuk argumen imajiner murni. | BESSELI(\\\[value], \\\[order]) | value: input. order: orde fungsi Bessel — non-bilangan bulat dipotong. | | `BESSELJ` | Mengembalikan fungsi Bessel. | BESSELJ(\\\[value], \\\[order]) | value: input. order: orde fungsi Bessel — non-bilangan bulat dipotong. | | `BESSELK` | Mengembalikan fungsi Bessel termodifikasi — sama dengan fungsi Bessel yang dievaluasi untuk argumen imajiner murni. | BESSELK(\\\[value], \\\[order]) | value: input. order: orde fungsi Bessel — non-bilangan bulat dipotong. | | `BESSELY` | Mengembalikan fungsi Bessel. | BESSELY(\\\[value], \\\[order]) | value: input. order: orde fungsi Bessel — non-bilangan bulat dipotong. | | `BIN2DEC` | Mengonversi bilangan biner bertanda menjadi desimal. | BIN2DEC(\\\[signed\_binary]) | signed\_binary: bilangan biner bertanda 10-bit sebagai string. | | `BIN2HEX` | Mengonversi bilangan biner bertanda menjadi heksadesimal bertanda. | BIN2HEX(\\\[signed\_binary], \\\[significant\_digits]) | signed\_binary: bilangan biner bertanda 10-bit sebagai string. significant\_digits: digit padding. | | `BIN2OCT` | Mengonversi bilangan biner bertanda menjadi oktal bertanda. | BIN2OCT(\\\[signed\_binary], \\\[significant\_digits]) | signed\_binary: bilangan biner bertanda 10-bit sebagai string. significant\_digits: digit padding. | | `BITAND` | AND bitwise dari dua nilai. | BITAND(\\\[value1], \\\[value2]) | value1: nilai pertama. value2: nilai kedua. | | `BITLSHIFT` | Menggeser nilai ke kiri sejumlah bit. | BITLSHIFT(\\\[value], \\\[shift\_amount]) | value: nilai. shift\_amount: jumlah bit yang digeser ke kiri. | | `BITOR` | OR bitwise dari dua nilai. | BITOR(\\\[value1], \\\[value2]) | value1: nilai pertama. value2: nilai kedua. | | `BITRSHIFT` | Menggeser nilai ke kanan sejumlah bit. | BITRSHIFT(\\\[value], \\\[shift\_amount]) | value: nilai. shift\_amount: jumlah bit yang digeser ke kanan. | | `BITXOR` | XOR bitwise dari dua nilai. | BITXOR(\\\[value1], \\\[value2]) | value1: nilai pertama. value2: nilai kedua. | | `COMPLEX` | Membuat bilangan kompleks dari koefisien real dan imajiner. | COMPLEX(\\\[real], \\\[imag], \\\[suffix]) | real: koefisien real. imag: koefisien imajiner. suffix: hanya "i" atau "j"; default "i". | | `DEC2BIN` | Mengonversi bilangan desimal menjadi biner bertanda. | DEC2BIN(\\\[decimal], \\\[significant\_digits]) | decimal: bilangan desimal sebagai string. significant\_digits: digit padding. | | `DEC2HEX` | Mengonversi bilangan desimal menjadi heksadesimal bertanda. | DEC2HEX(\\\[decimal], \\\[significant\_digits]) | decimal: bilangan desimal sebagai string. significant\_digits: digit padding. | | `DEC2OCT` | Mengonversi bilangan desimal menjadi oktal bertanda. | DEC2OCT(\\\[decimal], \\\[significant\_digits]) | decimal: bilangan desimal sebagai string. significant\_digits: digit padding. | | `DELTA` | Membandingkan dua angka — mengembalikan 1 jika sama. | DELTA(\\\[number1], \\\[number2]) | number1: angka pertama yang dibandingkan. number2: angka kedua yang dibandingkan. | | `ERF` | Mengembalikan hasil fungsi kesalahan Gauss. | ERF(\\\[z1], \\\[z2]) | z1: jika digunakan sendiri, integral berjalan dari 0 hingga z1. Jika z2 diberikan, ini adalah batas bawah. z2: batas atas integral. | | `ERF.PRECISE` | Mengembalikan hasil fungsi kesalahan Gauss. | ERF.PRECISE(\\\[z1]) | z1: jika digunakan sendiri, integral berjalan dari 0 hingga z1. Jika z2 diberikan, ini adalah batas bawah. | | `ERFC` | Mengembalikan fungsi kesalahan Gauss komplementer dari suatu nilai. | ERFC(\\\[z]) | z: batas atas integral. | | `ERFC.PRECISE` | Mengembalikan fungsi kesalahan Gauss komplementer dari suatu nilai. | ERFC.PRECISE(\\\[z]) | z: batas atas integral. | | `GESTEP` | Mengembalikan 1 jika suatu angka ≥ nilai langkah, jika tidak 0. Langkah default adalah 0. | GESTEP(\\\[value], \\\[step]) | value: nilai yang akan diuji. step: langkah. Mengembalikan 0 jika kosong. | | `HEX2BIN` | Mengonversi bilangan heksadesimal bertanda menjadi biner bertanda. | HEX2BIN(\\\[signed\_hex], \\\[significant\_digits]) | signed\_hex: bilangan heksadesimal bertanda 40-bit sebagai string. significant\_digits: digit padding. | | `HEX2DEC` | Mengonversi bilangan heksadesimal bertanda menjadi desimal. | HEX2DEC(\\\[signed\_hex]) | signed\_hex: bilangan heksadesimal bertanda 40-bit sebagai string. | | `HEX2OCT` | Mengonversi bilangan heksadesimal bertanda menjadi oktal bertanda. | HEX2OCT(\\\[signed\_hex], \\\[significant\_digits]) | signed\_hex: bilangan heksadesimal bertanda 40-bit sebagai string. significant\_digits: digit padding. | | `IMABS` | Mengembalikan nilai absolut suatu bilangan kompleks. | IMABS(\\\[number]) | number: bilangan kompleks. | | `IMAGINARY` | Mengembalikan koefisien imajiner suatu bilangan kompleks. | IMAGINARY(\\\[complex]) | complex: bilangan kompleks berbentuk a+bi atau a+bj. | | `IMARGUMENT` | Mengembalikan argumen θ suatu bilangan kompleks (sudut dalam radian). | IMARGUMENT(\\\[number]) | number: bilangan kompleks. | | `IMCONJUGATE` | Mengembalikan konjugat kompleks. | IMCONJUGATE(\\\[number]) | number: bilangan kompleks. | | `IMCOS` | Mengembalikan kosinus suatu bilangan kompleks dalam bentuk x + yi atau x + yj. | IMCOS(\\\[number]) | number: bilangan kompleks. | | `IMCOSH` | Mengembalikan kosinus hiperbolik suatu bilangan kompleks dalam bentuk x + yi atau x + yj. | IMCOSH(\\\[number]) | number: bilangan kompleks. | | `IMCOT` | Mengembalikan kotangen suatu bilangan kompleks dalam bentuk x + yi atau x + yj. | IMCOT(\\\[number]) | number: bilangan kompleks. | | `IMCSC` | Mengembalikan kosekan suatu bilangan kompleks dalam bentuk x + yi atau x + yj. | IMCSC(\\\[number]) | number: bilangan kompleks. | | `IMCSCH` | Mengembalikan kosekan hiperbolik suatu bilangan kompleks dalam bentuk x + yi atau x + yj. | IMCSCH(\\\[number]) | number: bilangan kompleks. | | `IMDIV` | Mengembalikan hasil pembagian satu bilangan kompleks dengan bilangan kompleks lain. | IMDIV(\\\[dividend], \\\[divisor]) | dividend: bilangan kompleks yang dibagi. divisor: bilangan kompleks pembagi. | | `IMEXP` | Mengembalikan bilangan Euler e (\~2,718) yang dipangkatkan dengan pangkat kompleks. | IMEXP(\\\[exponent]) | exponent: eksponen kompleks. | | `IMLN` | Mengembalikan logaritma natural (basis e) suatu bilangan kompleks. | IMLN(\\\[complex]) | complex: bilangan kompleks. | | `IMLOG10` | Mengembalikan logaritma basis-10 suatu bilangan kompleks. | IMLOG10(\\\[value]) | value: bilangan kompleks. | | `IMLOG2` | Mengembalikan logaritma basis-2 suatu bilangan kompleks. | IMLOG2(\\\[value]) | value: bilangan kompleks. | | `IMPOWER` | Mengembalikan bilangan kompleks yang dipangkatkan. | IMPOWER(\\\[complex\_base], \\\[exponent]) | complex\_base: basis kompleks. exponent: pangkat. | | `IMPRODUCT` | Mengembalikan hasil kali dari sekumpulan bilangan kompleks. | IMPRODUCT(\\\[number1], \\\[number2]) | number1: bilangan kompleks atau rentang pertama. number2: bilangan kompleks atau rentang lainnya. | | `IMREAL` | Mengembalikan koefisien real suatu bilangan kompleks. | IMREAL(\\\[complex]) | complex: bilangan kompleks berbentuk a+bi atau a+bj. | | `IMSEC` | Mengembalikan sekan suatu bilangan kompleks dalam bentuk x + yi atau x + yj. | IMSEC(\\\[number]) | number: bilangan kompleks. | | `IMSECH` | Mengembalikan sekan hiperbolik suatu bilangan kompleks dalam bentuk x + yi atau x + yj. | IMSECH(\\\[number]) | number: bilangan kompleks. | | `IMSIN` | Mengembalikan sinus suatu bilangan kompleks dalam bentuk x + yi atau x + yj. | IMSIN(\\\[number]) | number: bilangan kompleks. | | `IMSINH` | Mengembalikan sinus hiperbolik suatu bilangan kompleks dalam bentuk x + yi atau x + yj. | IMSINH(\\\[number]) | number: bilangan kompleks. | | `IMSQRT` | Mengembalikan akar kuadrat suatu bilangan kompleks. | IMSQRT(\\\[complex]) | complex: bilangan kompleks berbentuk a+bi atau a+bj. | | `IMSUB` | Mengembalikan selisih dua bilangan kompleks. | IMSUB(\\\[number1], \\\[number2]) | number1: bilangan kompleks yang dikurangi. number2: bilangan kompleks pengurang. | | `IMSUM` | Mengembalikan jumlah dari sekumpulan bilangan kompleks. | IMSUM(\\\[value1], \\\[value2]) | value1: bilangan kompleks atau rentang pertama. value2: bilangan kompleks atau rentang lainnya. | | `IMTAN` | Mengembalikan tangen suatu bilangan kompleks dalam bentuk x + yi atau x + yj. | IMTAN(\\\[number]) | number: bilangan kompleks. | | `OCT2BIN` | Mengonversi bilangan oktal bertanda menjadi biner bertanda. | OCT2BIN(\\\[signed\_octal], \\\[significant\_digits]) | signed\_octal: bilangan oktal bertanda 30-bit sebagai string. significant\_digits: digit padding. | | `OCT2DEC` | Mengonversi bilangan oktal bertanda menjadi desimal. | OCT2DEC(\\\[signed\_octal]) | signed\_octal: bilangan oktal bertanda 30-bit sebagai string. | | `OCT2HEX` | Mengonversi bilangan oktal bertanda menjadi heksadesimal bertanda. | OCT2HEX(\\\[signed\_octal], \\\[significant\_digits]) | signed\_octal: bilangan oktal bertanda 30-bit sebagai string. significant\_digits: digit padding. | # **Statistika** | Fungsi | Deskripsi | Contoh | Argumen | | ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `AVEDEV` | Mengembalikan rata-rata deviasi absolut dari nilai rata-rata suatu kumpulan data. | AVEDEV(\\\[value1], \\\[value2]) | value1: nilai sampel atau rentang pertama. value2: nilai sampel atau rentang lainnya. | | `AVERAGE` | Mengembalikan rata-rata aritmetika suatu kumpulan data, mengabaikan teks. | AVERAGE(\\\[value1], \\\[value2]) | value1: angka atau rentang pertama. value2: angka atau rentang lainnya. | | `AVERAGEA` | Mengembalikan rata-rata aritmetika suatu kumpulan data. | AVERAGEA(\\\[value1], \\\[value2]) | value1: nilai atau rentang pertama. value2: nilai atau rentang lainnya. | | `BETA.DIST` | Mengembalikan probabilitas distribusi beta untuk suatu input. | BETA.DIST(\\\[value], \\\[alpha], \\\[beta], \\\[lower], \\\[upper], \\\[Arg6]) | value: input. alpha: parameter distribusi pertama. beta: parameter distribusi kedua. lower: batas bawah, default 0. upper: batas atas, default 1. | | `BETA.INV` | Mengembalikan invers dari distribusi beta untuk suatu probabilitas. | BETA.INV(\\\[probability], \\\[alpha], \\\[beta], \\\[lower], \\\[upper]) | probability: probabilitas input. alpha: parameter pertama. beta: parameter kedua. lower: batas bawah, default 0. upper: batas atas, default 1. | | `BETADIST` | Mengembalikan probabilitas distribusi beta untuk suatu input. | BINOM.DIST(\\\[successes], \\\[trials], \\\[probability], \\\[cumulative]) | value: input. alpha: parameter pertama. beta: parameter kedua. lower: batas bawah, default 0. upper: batas atas, default 1. | | `BETAINV` | Mengembalikan invers dari distribusi beta untuk suatu probabilitas. | BETAINV(\\\[probability], \\\[alpha], \\\[beta], \\\[lower], \\\[upper]) | probability: probabilitas input. alpha: parameter pertama. beta: parameter kedua. lower: batas bawah, default 0. upper: batas atas, default 1. | | `BINOM.DIST` | Berdasarkan tingkat keberhasilan uji coba dan asumsi sampel dikembalikan setelah setiap uji coba, mengembalikan probabilitas sejumlah (atau hingga sejumlah) keberhasilan dalam jumlah uji coba tetap. | BINOM.DIST(\\\[successes], \\\[trials], \\\[probability], \\\[cumulative]) | successes: jumlah keberhasilan yang probabilitasnya dihitung. trials: total jumlah uji coba berprobabilitas sama. probability: probabilitas keberhasilan per uji coba. cumulative: apakah menggunakan distribusi kumulatif. | | `BINOM.DIST.RANGE` | Berdasarkan populasi dengan jumlah keberhasilan tetap dan asumsi sampel dikembalikan, mengembalikan probabilitas sejumlah (atau hingga sejumlah) keberhasilan dalam sejumlah uji coba. | BINOM.DIST.RANGE(\\\[trials], \\\[probability], \\\[successes], \\\[max\_successes]) | trials: jumlah uji coba independen. probability: probabilitas keberhasilan per uji coba. successes: jumlah keberhasilan yang dihitung. max\_successes: jumlah keberhasilan maksimum yang dihitung. Jika diabaikan, hanya probabilitas jumlah eksak yang dikembalikan. | | `BINOM.INV` | Mengembalikan nilai terkecil sehingga distribusi binomial kumulatif ≥ probabilitas target. | BINOM.INV(\\\[trials], \\\[probability], \\\[target\_probability]) | trials: jumlah uji coba independen. probability: probabilitas keberhasilan per uji coba. target\_probability: probabilitas kritis. | | `BINOMDIST` | Berdasarkan tingkat keberhasilan uji coba dan asumsi sampel dikembalikan setelah setiap uji coba, mengembalikan probabilitas sejumlah (atau hingga sejumlah) keberhasilan dalam jumlah uji coba tetap. | BINOMDIST(\\\[successes], \\\[trials], \\\[probability], \\\[cumulative]) | successes: jumlah keberhasilan yang probabilitasnya dihitung. trials: total jumlah uji coba berprobabilitas sama. probability: probabilitas keberhasilan per uji coba. cumulative: apakah menggunakan distribusi kumulatif. | | `CHIDIST` | Menghitung distribusi chi-kuadrat ekor kanan (sering digunakan dalam pengujian hipotesis). | CHIDIST(\\\[x], \\\[degrees\_of\_freedom]) | x: nilai input. degrees\_of\_freedom: derajat kebebasan. | | `CHIINV` | Menghitung invers dari distribusi chi-kuadrat ekor kanan. | CHIINV(\\\[probability], \\\[degrees\_of\_freedom]) | probability: probabilitas chi-kuadrat ekor kanan. degrees\_of\_freedom: derajat kebebasan. | | `CHISQ.DIST` | Menghitung distribusi chi-kuadrat ekor kiri (sering digunakan dalam pengujian hipotesis). | CHISQ.DIST(\\\[x], \\\[degrees\_of\_freedom], \\\[cumulative]) | x: nilai input. degrees\_of\_freedom: derajat kebebasan. cumulative: apakah menggunakan distribusi kumulatif. | | `CHISQ.DIST.RT` | Menghitung distribusi chi-kuadrat ekor kanan (sering digunakan dalam pengujian hipotesis). | CHISQ.DIST.RT(\\\[x], \\\[degrees\_of\_freedom]) | x: nilai input. degrees\_of\_freedom: derajat kebebasan. | | `CHISQ.INV` | Menghitung invers dari distribusi chi-kuadrat ekor kiri. | CHISQ.INV(\\\[probability], \\\[degrees\_of\_freedom]) | probability: probabilitas chi-kuadrat ekor kiri. degrees\_of\_freedom: derajat kebebasan. | | `CHISQ.INV.RT` | Menghitung invers dari distribusi chi-kuadrat ekor kanan. | CHISQ.INV.RT(\\\[probability], \\\[degrees\_of\_freedom]) | probability: probabilitas chi-kuadrat ekor kanan. degrees\_of\_freedom: derajat kebebasan. | | `CHISQ.TEST` | Mengembalikan probabilitas yang terkait dengan uji chi-kuadrat Pearson pada dua rentang — digunakan untuk menilai apakah data kategorikal yang diamati dapat berasal dari distribusi yang diharapkan. | CHISQ.TEST(\\\[observed], \\\[expected]) | observed: jumlah teramati per kategori. expected: jumlah yang diharapkan per kategori di bawah hipotesis nol. | | `CHITEST` | Mengembalikan probabilitas yang terkait dengan uji chi-kuadrat Pearson pada dua rentang — digunakan untuk menilai apakah data kategorikal yang diamati dapat berasal dari distribusi yang diharapkan. | CHITEST(\\\[observed], \\\[expected]) | observed: jumlah teramati per kategori. expected: jumlah yang diharapkan per kategori di bawah hipotesis nol. | | `CONFIDENCE` | Mengembalikan setengah lebar interval kepercayaan untuk distribusi normal. | CONFIDENCE(\\\[alpha], \\\[std\_dev], \\\[size]) | alpha: 1 dikurangi tingkat kepercayaan yang diinginkan. Mis., 0,1 → kepercayaan 90%. std\_dev: deviasi standar populasi. size: ukuran sampel. | | `CONFIDENCE.NORM` | Mengembalikan setengah lebar interval kepercayaan untuk distribusi normal. | CONFIDENCE.NORM(\\\[alpha], \\\[std\_dev], \\\[size]) | alpha: 1 dikurangi tingkat kepercayaan yang diinginkan. std\_dev: deviasi standar populasi. size: ukuran sampel. | | `CONFIDENCE.T` | Mengembalikan setengah lebar interval kepercayaan untuk distribusi T Student. | CONFIDENCE.T(\\\[alpha], \\\[std\_dev], \\\[size]) | alpha: 1 dikurangi tingkat kepercayaan yang diinginkan. std\_dev: deviasi standar sampel. size: ukuran sampel. | | `CORREL` | Mengembalikan koefisien korelasi Pearson r untuk suatu kumpulan data. | CORREL(\[data\_y], \[data\_x]) | data\_y: rentang atau array data dependen. data\_x: rentang atau array data independen. | | `COUNT` | Mengembalikan jumlah nilai numerik dalam suatu kumpulan data. | COUNT(\\\[value1], \\\[value2]) | value1: nilai atau rentang pertama yang diperiksa. value2: nilai atau rentang lainnya. | | `COUNTA` | Mengembalikan jumlah semua nilai dalam suatu kumpulan data. | COUNTA(\\\[value1], \\\[value2]) | value1: nilai atau rentang pertama yang diperiksa. value2: nilai atau rentang lainnya. | | `COVAR` | Mengembalikan kovarians suatu kumpulan data. | COVAR(\[data\_y], \[data\_x]) | data\_y: rentang atau array data dependen. data\_x: rentang atau array data independen. | | `COVARIANCE.P` | Mengembalikan kovarians populasi suatu kumpulan data. | COVARIANCE.P(\[data\_y], \[data\_x]) | data\_y: rentang atau array data dependen. data\_x: rentang atau array data independen. | | `COVARIANCE.S` | Mengembalikan kovarians sampel suatu kumpulan data. | COVARIANCE.S(\[data\_y], \[data\_x]) | data\_y: rentang atau array data dependen. data\_x: rentang atau array data independen. | | `CRITBINOM` | Mengembalikan nilai terkecil sehingga distribusi binomial kumulatif ≥ probabilitas target. | CRITBINOM(\\\[trials], \\\[probability], \\\[target\_probability]) | trials: jumlah uji coba independen. probability: probabilitas keberhasilan per uji coba. target\_probability: probabilitas kritis. | | `DEVSQ` | Mengembalikan jumlah kuadrat deviasi dari rata-rata sampel. | DEVSQ(\\\[value1], \\\[value2]) | value1: nilai sampel atau rentang pertama. value2: nilai sampel atau rentang lainnya. | | `EXPON.DIST` | Mengembalikan nilai distribusi eksponensial untuk suatu lambda dan nilai. | EXPON.DIST(\\\[x], \\\[lambda], \\\[cumulative]) | x: input. lambda: parameter lambda. cumulative: apakah menggunakan distribusi kumulatif. | | `EXPONDIST` | Mengembalikan nilai distribusi eksponensial untuk suatu lambda dan nilai. | EXPONDIST(\\\[x], \\\[lambda], \\\[cumulative]) | x: input. lambda: parameter lambda. cumulative: apakah menggunakan distribusi kumulatif. | | `F.DIST` | Diberikan x, mengembalikan distribusi probabilitas F ekor kanan antara dua kumpulan data — juga dikenal sebagai distribusi Fisher-Snedecor. | F.DIST(\\\[x], \\\[df1], \\\[df2], \\\[cumulative]) | x: input. df1: derajat kebebasan pembilang. df2: derajat kebebasan penyebut. cumulative: pemilih bentuk. | | `F.DIST.RT` | Diberikan x, mengembalikan distribusi probabilitas F ekor kanan antara dua kumpulan data — juga dikenal sebagai distribusi Fisher-Snedecor. | F.DIST.RT(\\\[x], \\\[df1], \\\[df2]) | x: input. df1: derajat kebebasan pembilang. df2: derajat kebebasan penyebut. | | `F.INV` | Menghitung invers dari distribusi probabilitas F ekor kanan. | F.INV(\\\[probability], \\\[df1], \\\[df2]) | probability: probabilitas F ekor kanan. df1: derajat kebebasan pembilang. df2: derajat kebebasan penyebut. | | `F.INV.RT` | Menghitung invers dari distribusi probabilitas F ekor kanan. | F.INV.RT(\\\[probability], \\\[df1], \\\[df2]) | probability: probabilitas F ekor kanan. df1: derajat kebebasan pembilang. df2: derajat kebebasan penyebut. | | `F.TEST` | Mengembalikan probabilitas yang terkait dengan uji-F untuk kesetaraan varians. | F.TEST(\\\[range1], \\\[range2]) | range1: sampel atau rentang sel pertama. range2: sampel atau rentang sel kedua. | | `FDIST` | Diberikan x, mengembalikan distribusi probabilitas F ekor kanan antara dua kumpulan data — juga dikenal sebagai distribusi Fisher-Snedecor. | FDIST(\\\[x], \\\[df1], \\\[df2]) | x: input. df1: derajat kebebasan pembilang. df2: derajat kebebasan penyebut. | | `FINV` | Menghitung invers dari distribusi probabilitas F ekor kanan. | FINV(\\\[probability], \\\[df1], \\\[df2]) | probability: probabilitas F ekor kanan. df1: derajat kebebasan pembilang. df2: derajat kebebasan penyebut. | | `FISHER` | Mengembalikan transformasi Fisher suatu nilai. | FISHER(\\\[number]) | number: nilai yang akan ditransformasi. | | `FISHERINV` | Mengembalikan transformasi Fisher invers suatu nilai. | FISHERINV(\\\[value]) | value: nilai yang akan ditransformasi balik. | | `FORECAST` | Menghitung y prediksi untuk suatu x berdasarkan regresi linear pada kumpulan data. | FORECAST(\[x], \[data\_y], \[data\_x]) | x: nilai sumbu x yang diprediksi. data\_y: rentang atau array data dependen. data\_x: rentang atau array data independen. | | `FORECAST.LINEAR` | Menghitung y prediksi untuk suatu x berdasarkan regresi linear pada kumpulan data. | FORECAST.LINEAR(\[x], \[data\_y], \[data\_x]) | x: nilai sumbu x yang diprediksi. data\_y: rentang atau array data dependen. data\_x: rentang atau array data independen. | | `FREQUENCY` | Mengembalikan distribusi frekuensi suatu array sebagai array satu kolom, berdasarkan bin yang ditentukan. | FREQUENCY(\\\[data], \\\[bins]) | data: array atau rentang nilai. bins: array atau rentang batas bin. | | `FTEST` | Mengembalikan probabilitas yang terkait dengan uji-F untuk kesetaraan varians. | FTEST(\\\[range1], \\\[range2]) | range1: sampel atau rentang sel pertama. range2: sampel atau rentang sel kedua. | | `GAMMA` | Mengembalikan nilai fungsi gamma untuk suatu input. | GAMMA(\\\[number]) | number: input. | | `GAMMA.DIST` | Menghitung distribusi gamma (distribusi kontinu dua parameter). | GAMMA.DIST(\\\[x], \\\[alpha], \\\[beta], \\\[cumulative]) | x: input. alpha: parameter pertama. beta: parameter kedua. cumulative: TRUE → kumulatif; FALSE → densitas. | | `GAMMA.INV` | Mengembalikan invers dari distribusi kumulatif gamma berdasarkan probabilitas serta parameter alpha dan beta. | GAMMA.INV(\\\[probability], \\\[alpha], \\\[beta]) | probability: probabilitas input — harus 0 sampai 1. alpha: parameter bentuk — harus positif. beta: parameter skala — harus positif. | | `GAMMALN` | Mengembalikan logaritma natural (basis e) dari fungsi gamma. | GAMMALN(\\\[number]) | number: input — mengembalikan logaritma natural dari Gamma(number). | | `GAUSS` | Mengembalikan probabilitas bahwa variabel normal standar berada dalam z deviasi standar dari rata-rata. | GAUSS(\\\[z]) | z: jumlah deviasi standar dari rata-rata. | | `GEOMEAN` | Mengembalikan rata-rata geometrik suatu kumpulan data. | GEOMEAN(\\\[value1], \\\[value2]) | value1: nilai sampel atau rentang pertama. value2: nilai sampel atau rentang lainnya. | | `HARMEAN` | Mengembalikan rata-rata harmonik suatu kumpulan data. | HARMEAN(\\\[value1], \\\[value2]) | value1: nilai sampel atau rentang pertama. value2: nilai sampel atau rentang lainnya. | | `HYPGEOM.DIST` | Mengembalikan probabilitas sejumlah keberhasilan dalam sejumlah uji coba, berdasarkan tingkat keberhasilan populasi dan asumsi sampel tidak dikembalikan. | HYPGEOM.DIST(\\\[successes], \\\[trials], \\\[population\_successes], \\\[population\_size]) | successes: keberhasilan yang diperlukan. trials: jumlah uji coba. population\_successes: total keberhasilan dalam populasi. population\_size: ukuran populasi. | | `HYPGEOMDIST` | Mengembalikan probabilitas sejumlah keberhasilan dalam sejumlah uji coba, berdasarkan tingkat keberhasilan populasi dan asumsi sampel tidak dikembalikan. | HYPGEOMDIST(\\\[successes], \\\[trials], \\\[population\_successes], \\\[population\_size]) | successes: keberhasilan yang diperlukan. trials: jumlah uji coba. population\_successes: total keberhasilan dalam populasi. population\_size: ukuran populasi. | | `INTERCEPT` | Mengembalikan nilai y di mana garis regresi linear suatu kumpulan data memotong sumbu y (x = 0). | INTERCEPT(\[data\_y], \[data\_x]) | data\_y: rentang atau array data dependen. data\_x: rentang atau array data independen. | | `KURT` | Mengembalikan kurtosis suatu kumpulan data — menggambarkan keruncingan distribusi. | KURT(\\\[value1], \\\[value2]) | value1: nilai atau rentang pertama. value2: nilai atau rentang lainnya. | | `LARGE` | Mengembalikan elemen terbesar ke-n dalam suatu kumpulan data. | LARGE(\\\[data], \\\[n]) | data: rentang atau array. n: peringkat dari yang terbesar (1 = terbesar). | | `LOGINV` | Mengembalikan invers dari distribusi kumulatif lognormal untuk suatu nilai dengan rata-rata dan deviasi standar tertentu. | LOGINV(\\\[x], \\\[mean], \\\[std\_dev]) | x: input. mean: rata-rata distribusi (mu). std\_dev: deviasi standar distribusi (sigma). | | `LOGNORM.DIST` | Mengembalikan distribusi kumulatif lognormal untuk suatu nilai dengan rata-rata dan deviasi standar tertentu. | LOGNORM.DIST(\\\[x], \\\[mean], \\\[std\_dev], ) | x: input. mean: rata-rata distribusi (mu). std\_dev: deviasi standar distribusi (sigma). | | `LOGNORM.INV` | Mengembalikan invers dari distribusi kumulatif lognormal untuk suatu nilai dengan rata-rata dan deviasi standar tertentu. | LOGNORM.INV(\\\[x], \\\[mean], \\\[std\_dev]) | x: input. mean: rata-rata distribusi (mu). std\_dev: deviasi standar distribusi (sigma). | | `LOGNORMDIST` | Mengembalikan distribusi kumulatif lognormal untuk suatu nilai dengan rata-rata dan deviasi standar tertentu. | LOGNORMDIST(\\\[x], \\\[mean], \\\[std\_dev]) | x: input. mean: rata-rata distribusi (mu). std\_dev: deviasi standar distribusi (sigma). | | `MAX` | Mengembalikan nilai maksimum dari suatu kumpulan data numerik. | MAX(\\\[value1], \\\[value2]) | value1: nilai atau rentang pertama. value2: nilai atau rentang lainnya. | | `MAXA` | Mengembalikan nilai numerik maksimum suatu kumpulan data. | MAXA(\\\[value1], \\\[value2]) | value1: nilai atau rentang pertama. value2: nilai atau rentang lainnya. | | `MEDIAN` | Mengembalikan median dari suatu kumpulan data numerik. | MEDIAN(\\\[value1], \\\[value2]) | value1: nilai atau rentang pertama. value2: nilai atau rentang lainnya. | | `MIN` | Mengembalikan nilai minimum dari suatu kumpulan data numerik. | MIN(\\\[value1], \\\[value2]) | value1: nilai atau rentang pertama. value2: nilai atau rentang lainnya. | | `MINA` | Mengembalikan nilai numerik minimum suatu kumpulan data. | MINA(\\\[value1], \\\[value2]) | value1: nilai atau rentang pertama. value2: nilai atau rentang lainnya. | | `MODE` | Mengembalikan nilai yang paling sering muncul dalam suatu kumpulan data. | MODE(\\\[value1], \\\[value2]) | value1: nilai atau rentang pertama. value2: nilai atau rentang lainnya. | | `MODE.MULT` | Mengembalikan nilai yang paling sering muncul dalam suatu kumpulan data. | MODE.MULT(\\\[value1], \\\[value2]) | value1: nilai atau rentang pertama. value2: nilai atau rentang lainnya. | | `MODE.SNGL` | Mengembalikan nilai yang paling sering muncul dalam suatu kumpulan data. | MODE.SNGL(\\\[value1], \\\[value2]) | value1: nilai atau rentang pertama. value2: nilai atau rentang lainnya. | | `NEGBINOM.DIST` | Berdasarkan probabilitas keberhasilan tetap, mengembalikan probabilitas sejumlah kegagalan sebelum sejumlah keberhasilan. | NEGBINOM.DIST(\\\[failures], \\\[successes], \\\[probability]) | failures: jumlah kegagalan yang dimodelkan. successes: jumlah keberhasilan yang dimodelkan. probability: probabilitas keberhasilan per uji coba. | | `NEGBINOMDIST` | Berdasarkan probabilitas keberhasilan tetap, mengembalikan probabilitas sejumlah kegagalan sebelum sejumlah keberhasilan. | NEGBINOMDIST(\\\[failures], \\\[successes], \\\[probability]) | failures: jumlah kegagalan yang dimodelkan. successes: jumlah keberhasilan yang dimodelkan. probability: probabilitas keberhasilan per uji coba. | | `NORM.DIST` | Mengembalikan nilai fungsi distribusi normal (atau bentuk kumulatifnya) untuk input, rata-rata, dan deviasi standar tertentu. | NORM.S.DIST(\\\[x], \\\[Arg2]) | x: input. mean: rata-rata distribusi (mu). std\_dev: deviasi standar distribusi (sigma). cumulative: apakah menggunakan bentuk kumulatif. | | `NORM.INV` | Mengembalikan invers dari fungsi distribusi normal untuk input, rata-rata, dan deviasi standar tertentu. | NORM.INV(\\\[x], \\\[mean], \\\[std\_dev]) | x: input. mean: rata-rata distribusi (mu). std\_dev: deviasi standar distribusi (sigma). | | `NORM.S.DIST` | Mengembalikan distribusi kumulatif normal standar untuk suatu nilai. | NORM.S.DIST(\\\[x], \\\[Arg2]) | x: input. Arg2 | | `NORM.S.INV` | Mengembalikan invers dari fungsi distribusi normal standar untuk suatu nilai. | NORM.S.INV(\\\[x]) | x: input. | | `NORMDIST` | Mengembalikan nilai fungsi distribusi normal (atau bentuk kumulatifnya) untuk input, rata-rata, dan deviasi standar tertentu. | NORMDIST(\\\[x], \\\[mean], \\\[std\_dev], \\\[cumulative]) | x: input. mean: rata-rata distribusi (mu). std\_dev: deviasi standar distribusi (sigma). cumulative: apakah menggunakan bentuk kumulatif. | | `NORMINV` | Mengembalikan invers dari fungsi distribusi normal untuk input, rata-rata, dan deviasi standar tertentu. | NORMINV(\\\[x], \\\[mean], \\\[std\_dev]) | x: input. mean: rata-rata distribusi (mu). std\_dev: deviasi standar distribusi (sigma). | | `NORMSDIST` | Mengembalikan distribusi kumulatif normal standar untuk suatu nilai. | NORMSDIST(\\\[x]) | x: input. | | `NORMSINV` | Mengembalikan invers dari fungsi distribusi normal standar untuk suatu nilai. | NORMSINV(\\\[x]) | x: input. | | `PEARSON` | Mengembalikan koefisien korelasi Pearson r untuk suatu kumpulan data. | PEARSON(\[data\_y], \[data\_x]) | data\_y: rentang atau array data dependen. data\_x: rentang atau array data independen. | | `PERCENTILE` | Mengembalikan nilai pada persentil tertentu dalam suatu kumpulan data. | PERCENTILE(\\\[data], \\\[percentile]) | data: array atau rentang. percentile: persentil target. | | `PERCENTILE.EXC` | Mengembalikan nilai pada persentil tertentu (eksklusif 0 dan 1) dalam suatu kumpulan data. | PERCENTILE.EXC(\\\[data], \\\[percentile]) | data: array atau rentang. percentile: persentil target (eksklusif 0 dan 1). | | `PERCENTILE.INC` | Mengembalikan nilai pada persentil tertentu dalam suatu kumpulan data. | PERCENTILE.INC(\\\[data], \\\[percentile]) | data: array atau rentang. percentile: persentil target. | | `PERCENTRANK` | Mengembalikan peringkat persentil (sebagai persentase) suatu nilai dalam kumpulan data. | PERCENTRANK(\\\[data], \\\[value], \\\[significant\_digits]) | data: array atau rentang. value: nilai yang diperingkat. significant\_digits: digit signifikan yang digunakan. Default 3. | | `PERCENTRANK.EXC` | Mengembalikan peringkat persentil (antara 0 dan 1, eksklusif) suatu nilai dalam kumpulan data. | PERCENTRANK.EXC(\\\[data], \\\[value], \\\[significant\_digits]) | data: array atau rentang. value: nilai yang diperingkat. significant\_digits: digit signifikan yang digunakan. Default 3. | | `PERCENTRANK.INC` | Mengembalikan peringkat persentil (antara 0 dan 1, inklusif) suatu nilai dalam kumpulan data. | PERCENTRANK.INC(\\\[data], \\\[value], \\\[significant\_digits]) | data: array atau rentang. value: nilai yang diperingkat. significant\_digits: digit signifikan yang digunakan. Default 3. | | `PERMUT` | Mengembalikan jumlah pemilihan terurut yang berbeda dari k dari n. | PERMUT(\\\[n], \\\[k]) | n: total objek. k: jumlah yang dipilih. | | `PERMUTATIONA` | Mengembalikan jumlah pemilihan terurut yang berbeda dari k dari n dengan pengulangan. | PERMUTATIONA(\\\[n], \\\[k]) | n: total objek. k: jumlah yang dipilih. | | `PHI` | Mengembalikan nilai distribusi normal standar (rata-rata 0, deviasi standar 1). | PHI(\\\[x]) | x: input. | | `POISSON` | Mengembalikan nilai fungsi distribusi Poisson (atau bentuk kumulatifnya) untuk parameter tertentu. | POISSON(\\\[x], \\\[mean], \\\[cumulative]) | x: input. mean: rata-rata distribusi (mu). cumulative: apakah menggunakan bentuk kumulatif. | | `POISSON.DIST` | Mengembalikan nilai fungsi distribusi Poisson (atau bentuk kumulatifnya) untuk parameter tertentu. | POISSON.DIST(\\\[x], \\\[mean], \\\[cumulative]) | x: input. mean: rata-rata distribusi (mu). cumulative: apakah menggunakan bentuk kumulatif. | | `PROB` | Diberikan sekumpulan nilai dan probabilitas yang bersesuaian, menghitung probabilitas bahwa pemilihan acak berada di antara dua batas. | PROB(\\\[data], \\\[probability], \\\[lower], \\\[upper]) | data: array atau rentang. probability: array atau rentang probabilitas yang cocok dengan `data`. lower: batas bawah. upper: batas atas. | | `QUARTILE` | Mengembalikan nilai pada kuartil tertentu dalam suatu kumpulan data. | QUARTILE(\\\[data], \\\[quartile]) | data: array atau rentang. quartile: kuartil mana yang dikembalikan. | | `QUARTILE.EXC` | Mengembalikan nilai pada kuartil tertentu (eksklusif 0 dan 4) dalam suatu kumpulan data. | QUARTILE.EXC(\\\[data], \\\[quartile]) | data: array atau rentang. quartile: kuartil mana yang dikembalikan. | | `QUARTILE.INC` | Mengembalikan nilai pada kuartil tertentu dalam suatu kumpulan data. | QUARTILE.INC(\\\[data], \\\[quartile]) | data: array atau rentang. quartile: kuartil mana yang dikembalikan. | | `RSQ` | Mengembalikan r kuadrat, di mana r adalah koefisien korelasi Pearson. | RSQ(\[data\_y], \[data\_x]) | data\_y: rentang atau array data dependen. data\_x: rentang atau array data independen. | | `SKEW` | Mengembalikan kemiringan (skewness) suatu kumpulan data — menggambarkan asimetri di sekitar rata-rata. | SKEW(\\\[value1], \\\[value2]) | value1: nilai atau rentang pertama. value2: nilai atau rentang lainnya. | | `SKEW.P` | Mengembalikan kemiringan (skewness) suatu kumpulan data — menggambarkan asimetri di sekitar rata-rata. Memperlakukan kumpulan data sebagai seluruh populasi. | SKEW\.P(\\\[value1], \\\[value2]) | value1: nilai atau rentang pertama. value2: nilai atau rentang lainnya. | | `SLOPE` | Mengembalikan kemiringan garis regresi linear suatu kumpulan data. | SLOPE(\[data\_y], \[data\_x]) | data\_y: rentang atau array data dependen. data\_x: rentang atau array data independen. | | `SMALL` | Mengembalikan elemen terkecil ke-n dalam suatu kumpulan data. | SMALL(\\\[data], \\\[n]) | data: array atau rentang. n: peringkat dari yang terkecil (1 = terkecil). | | `STANDARDIZE` | Mengembalikan nilai ternormalisasi suatu variabel acak berdasarkan rata-rata dan deviasi standar distribusi. | STANDARDIZE(\\\[value], \\\[mean], \\\[std\_dev]) | value: variabel acak yang dinormalisasi. mean: rata-rata distribusi. std\_dev: deviasi standar distribusi. | | `STDEV` | Mengembalikan deviasi standar sampel. | STDEV(\\\[value1], \\\[value2]) | value1: nilai sampel atau rentang pertama. value2: nilai sampel atau rentang lainnya. | | `STDEV.P` | Mengembalikan deviasi standar populasi. | STDEV.P(\\\[value1], \\\[value2]) | value1: nilai sampel atau rentang pertama. value2: nilai atau rentang lainnya. | | `STDEV.S` | Mengembalikan deviasi standar sampel. | STDEV.S(\\\[value1], \\\[value2]) | value1: nilai sampel atau rentang pertama. value2: nilai sampel atau rentang lainnya. | | `STDEVA` | Mengembalikan deviasi standar sampel, memperlakukan teks sebagai 0. | STDEVA(\\\[value1], \\\[value2]) | value1: nilai sampel atau rentang pertama. value2: nilai sampel atau rentang lainnya. | | `STDEVP` | Mengembalikan deviasi standar populasi. | STDEVP(\\\[value1], \\\[value2]) | value1: nilai sampel atau rentang pertama. value2: nilai atau rentang lainnya. | | `STDEVPA` | Mengembalikan deviasi standar populasi, memperlakukan teks sebagai 0. | STDEVPA(\\\[value1], \\\[value2]) | value1: nilai sampel atau rentang pertama. value2: nilai atau rentang lainnya. | | `STEYX` | Mengembalikan kesalahan standar nilai y prediksi per x dalam analisis regresi. | STEYX(\[data\_y], \[data\_x]) | data\_y: rentang atau array data dependen. data\_x: rentang atau array data independen. | | `SUM` | Mengembalikan jumlah dari sekumpulan nilai dan/atau sel. | SUM(\\\[value1], \\\[number2]) | value1: angka atau rentang pertama yang dijumlahkan. number2: angka atau rentang lainnya. | | `T.DIST` | Diberikan input (x), mengembalikan probabilitas distribusi t Student. | T.DIST(\\\[x], \\\[degrees\_of\_freedom], \\\[tails]) | x: input. degrees\_of\_freedom: derajat kebebasan. tails: 1 = satu ekor, 2 = dua ekor. | | `T.DIST.2T` | Diberikan input (x), mengembalikan probabilitas distribusi t Student. | T.INV.2T(\\\[x], \\\[degrees\_of\_freedom]) | x: input. degrees\_of\_freedom: derajat kebebasan. tails: 1 = satu ekor, 2 = dua ekor. | | `T.DIST.RT` | Diberikan input (x), mengembalikan distribusi t Student ekor kanan. | T.DIST.RT(\\\[x], \\\[degrees\_of\_freedom]) | x: input. degrees\_of\_freedom: derajat kebebasan. | | `T.INV` | Mengembalikan invers dari fungsi TDIST dua ekor. | T.INV(\\\[probability], \\\[degrees\_of\_freedom]) | probability: probabilitas t dua ekor. degrees\_of\_freedom: derajat kebebasan. | | `T.INV.2T` | Mengembalikan invers dari fungsi TDIST dua ekor. | T.INV.2T(\\\[probability], \\\[degrees\_of\_freedom]) | probability: probabilitas t dua ekor. degrees\_of\_freedom: derajat kebebasan. | | `T.TEST` | Mengembalikan invers dari fungsi TDIST dua ekor. | T.TEST(\\\[range1], \\\[range2], \\\[tails], \\\[type]) | range1: sampel atau rentang sel pertama. range2: sampel atau rentang sel kedua. tails: ekor distribusi. type: tipe uji-t. | | `TINV` | Uji-t. Mengembalikan probabilitas yang terkait dengan uji-t Student — digunakan untuk menilai apakah dua sampel kemungkinan berasal dari populasi dengan rata-rata yang sama. | TINV(\\\[probability], \\\[degrees\_of\_freedom]) | probability: probabilitas t dua ekor. degrees\_of\_freedom: derajat kebebasan. | | `TRIMMEAN` | Mengembalikan invers dari fungsi TDIST dua ekor. | TRIMMEAN(\\\[data], \\\[exclude\_proportion]) | data: array atau rentang. exclude\_proportion: fraksi nilai ekstrem yang dikecualikan. | | `TTEST` | Mengembalikan rata-rata yang dihitung setelah mengecualikan sebagian ujung tinggi dan rendah. | TTEST(\\\[range1], \\\[range2], \\\[tails], \\\[type]) | value1: nilai sampel atau rentang pertama. value2: nilai sampel atau rentang lainnya. | | `VAR` | Uji-t. Mengembalikan probabilitas yang terkait dengan uji-t Student — digunakan untuk menilai apakah dua sampel kemungkinan berasal dari populasi dengan rata-rata yang sama. | VAR(\\\[value1], \\\[value2]) | value1: nilai sampel atau rentang pertama. value2: nilai sampel atau rentang lainnya. | | `VAR.P` | Mengembalikan varians berdasarkan sampel. | VAR.P(\\\[value1], \\\[value2]) | value1: nilai sampel atau rentang pertama. value2: nilai atau rentang lainnya. | | `VAR.S` | Mengembalikan varians berdasarkan populasi. | VAR.S(\\\[value1], \\\[value2]) | value1: nilai sampel atau rentang pertama. value2: nilai sampel atau rentang lainnya. | | `VARA` | Mengembalikan varians berdasarkan sampel. | VARA(\\\[value1], \\\[value2]) | value1: nilai sampel atau rentang pertama. value2: nilai sampel atau rentang lainnya. | | `VARP` | Mengembalikan varians berdasarkan sampel, memperlakukan teks sebagai 0. | VARP(\\\[value1], \\\[value2]) | value1: nilai sampel atau rentang pertama. value2: nilai atau rentang lainnya. | | `VARPA` | Mengembalikan varians berdasarkan populasi. | VARPA(\\\[value1], \\\[value2]) | value1: nilai sampel atau rentang pertama. value2: nilai atau rentang lainnya. | | `WEIBULL` | Mengembalikan varians berdasarkan populasi, memperlakukan teks sebagai 0. | WEIBULL(\\\[x], \\\[shape], \\\[scale], \\\[cumulative]) | x: input. shape: parameter bentuk Weibull. scale: parameter skala Weibull. cumulative: apakah menggunakan distribusi kumulatif. | | `WEIBULL.DIST` | Mengembalikan nilai distribusi Weibull (atau bentuk kumulatifnya) untuk bentuk dan skala tertentu. | WEIBULL.DIST(\\\[x], \\\[shape], \\\[scale], \\\[cumulative]) | x: input. shape: parameter bentuk Weibull. scale: parameter skala Weibull. cumulative: apakah menggunakan distribusi kumulatif. | | `Z.TEST` | Mengembalikan nilai distribusi Weibull (atau bentuk kumulatifnya) untuk bentuk dan skala tertentu. | Z.TEST(\\\[data], \\\[value], \\\[std\_dev]) | data: array atau rentang. value: nilai statistik uji untuk uji-Z. std\_dev: deviasi standar yang diasumsikan; jika diabaikan, deviasi standar data yang digunakan. | | `ZTEST` | Mengembalikan nilai P satu ekor dari uji-Z terhadap distribusi standar. | ZTEST(\\\[data], \\\[value], \\\[std\_dev]) | data: array atau rentang. value: nilai statistik uji untuk uji-Z. std\_dev: deviasi standar yang diasumsikan; jika diabaikan, deviasi standar data yang digunakan. | # **Keuangan** | Fungsi | Deskripsi | Contoh | Argumen | | ------------ | ------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `COUPDAYBS` | Mengembalikan jumlah hari dari tanggal kupon atau pembayaran bunga pertama hingga tanggal penyelesaian. | COUPDAYBS(\\\[settlement], \\\[maturity], \\\[frequency], \\\[basis]) | settlement: tanggal penyelesaian obligasi — saat obligasi diserahkan kepada pembeli. maturity: tanggal jatuh tempo obligasi — saat penebusan terjadi pada nilai nominal. frequency: pembayaran kupon per tahun (1, 2, atau 4). basis: metode penghitungan hari yang digunakan. | | `COUPDAYSNC` | Mengembalikan jumlah hari dari tanggal penyelesaian hingga tanggal kupon atau pembayaran bunga berikutnya. | COUPDAYSNC(\\\[settlement], \\\[maturity], \\\[frequency], \\\[basis]) | settlement: tanggal penyelesaian obligasi. maturity: tanggal jatuh tempo obligasi. frequency: pembayaran kupon per tahun. basis: metode penghitungan hari. | | `COUPNCD` | Mengembalikan tanggal kupon atau pembayaran bunga berikutnya setelah tanggal penyelesaian. | COUPNCD(\\\[settlement], \\\[maturity], \\\[frequency], \\\[basis]) | settlement: tanggal penyelesaian obligasi. maturity: tanggal jatuh tempo obligasi. frequency: pembayaran kupon per tahun. basis: metode penghitungan hari. | | `COUPNUM` | Mengembalikan jumlah kupon (pembayaran bunga) antara tanggal penyelesaian dan jatuh tempo. | COUPNUM(\\\[settlement], \\\[maturity], \\\[frequency], \\\[basis]) | settlement: tanggal penyelesaian obligasi. maturity: tanggal jatuh tempo obligasi. frequency: pembayaran kupon per tahun. basis: metode penghitungan hari. | | `COUPPCD` | Mengembalikan tanggal kupon atau pembayaran bunga sebelumnya sebelum tanggal penyelesaian. | COUPPCD(\\\[settlement], \\\[maturity], \\\[frequency], \\\[basis]) | settlement: tanggal penyelesaian obligasi. maturity: tanggal jatuh tempo obligasi. frequency: pembayaran kupon per tahun. basis: metode penghitungan hari. | | `CUMIPMT` | Mengembalikan bunga kumulatif yang dibayarkan atas suatu investasi selama serangkaian periode, dengan pembayaran sama dan suku bunga tetap. | CUMIPMT(\\\[rate], \\\[nper], \\\[pv], \\\[start\_period], \\\[end\_period], \\\[type]) | rate: suku bunga. nper: jumlah periode pembayaran. pv: nilai sekarang. start\_period: periode pertama yang disertakan. end\_period: periode terakhir yang disertakan. type: waktu — 0 = akhir periode, 1 = awal. | | `CUMPRINC` | Mengembalikan pokok kumulatif yang dilunasi atas suatu investasi selama serangkaian periode, dengan pembayaran sama dan suku bunga tetap. | CUMPRINC(\\\[rate], \\\[nper], \\\[pv], \\\[start\_period], \\\[end\_period], \\\[type]) | rate: suku bunga. nper: jumlah periode pembayaran. pv: nilai sekarang. start\_period: periode pertama yang disertakan. end\_period: periode terakhir yang disertakan. type: waktu — 0 = akhir periode, 1 = awal. | | `DB` | Mengembalikan penyusutan suatu aset untuk periode tertentu menggunakan metode saldo menurun tetap. | DB(\\\[cost], \\\[salvage], \\\[life], \\\[period], \\\[months]) | cost: biaya awal aset. salvage: nilai pada akhir masa manfaat. life: masa manfaat dalam periode. period: periode penyusutan. months: bulan pada tahun pertama. | | `DDB` | Mengembalikan penyusutan suatu aset untuk periode tertentu menggunakan metode saldo menurun ganda. | DDB(\\\[cost], \\\[salvage], \\\[life], \\\[period], \\\[factor]) | cost: biaya awal aset. salvage: nilai pada akhir masa manfaat. life: masa manfaat dalam periode. period: periode penyusutan. factor: laju penurunan. | | `DISC` | Mengembalikan tingkat diskonto suatu obligasi dari harganya. | DISC(\\\[settlement], \\\[maturity], \\\[price], \\\[redemption], \\\[basis]) | settlement: tanggal penyelesaian obligasi. maturity: tanggal jatuh tempo obligasi. price: per nilai nominal $100. redemption: nilai penebusan per nilai nominal $100. basis: metode penghitungan hari. | | `DOLLARDE` | Mengonversi harga yang dinyatakan sebagai pecahan menjadi angka desimal. | DOLLARDE(\\\[fractional\_price], \\\[fraction]) | fractional\_price: harga dalam bentuk pecahan yang disepakati. fraction: ukuran penyebut — mis., 8 untuk 1/8, 32 untuk 1/32. | | `DOLLARFR` | Mengonversi harga desimal menjadi representasi pecahan. | DOLLARFR(\\\[decimal\_price], \\\[fraction]) | decimal\_price: harga dalam bentuk desimal. fraction: ukuran penyebut — mis., 8 untuk 1/8, 32 untuk 1/32. | | `EFFECT` | Mengembalikan suku bunga tahunan efektif dari suku bunga nominal dan jumlah periode penggabungan per tahun. | EFFECT(\\\[nominal\_rate], \\\[periods]) | nominal\_rate: suku bunga nominal tahunan. periods: periode penggabungan per tahun. | | `FV` | Mengembalikan nilai masa depan suatu investasi anuitas dengan pembayaran sama dan suku bunga tetap. | FV(\\\[rate], \\\[nper], \\\[pmt], \\\[pv], \\\[type]) | rate: suku bunga. nper: jumlah periode pembayaran. pmt: pembayaran per periode. pv: nilai sekarang. type: waktu — 0 = akhir periode, 1 = awal. | | `IPMT` | Mengembalikan bunga yang dibayarkan dalam periode tertentu dari suatu investasi dengan pembayaran sama dan suku bunga tetap. | IPMT(\\\[rate], \\\[period], \\\[nper], \\\[pv], \\\[fv], \\\[type]) | rate: suku bunga. period: periode (dalam periode). nper: jumlah periode pembayaran. pv: nilai sekarang. fv: nilai masa depan tersisa setelah pembayaran terakhir. type: waktu — 0 = akhir periode, 1 = awal. | | `IRR` | Mengembalikan tingkat pengembalian internal untuk serangkaian arus kas periodik. | IRR(\\\[cash\_flows], \\\[rate\_guess]) | cash\_flows: array atau rentang jumlah terkait investasi. rate\_guess: perkiraan IRR. | | `ISPMT` | Mengembalikan bunga yang dibayarkan selama periode investasi tertentu. | ISPMT(\\\[rate], \\\[period], \\\[nper], \\\[pv]) | rate: suku bunga. period: periode yang ditinjau. nper: jumlah periode pembayaran. pv: nilai sekarang. | | `NOMINAL` | Mengembalikan suku bunga tahunan nominal dari suku bunga efektif dan jumlah periode penggabungan per tahun. | NOMINAL(\\\[effective\_rate], \\\[periods]) | effective\_rate: suku bunga tahunan efektif. periods: periode penggabungan per tahun. | | `NPER` | Mengembalikan jumlah periode pembayaran untuk melunasi suatu investasi dengan pembayaran sama dan suku bunga tetap. | NPER(\\\[rate], \\\[pmt], \\\[pv], \\\[fv], \\\[type]) | rate: suku bunga. pmt: pembayaran per periode. pv: nilai sekarang. fv: nilai masa depan tersisa setelah pembayaran terakhir. type: waktu — 0 = akhir periode, 1 = awal. | | `NPV` | Mengembalikan nilai sekarang bersih suatu investasi dengan serangkaian arus kas periodik dan tingkat diskonto. | NPV(\\\[discount\_rate], \\\[cash\_flow1], \\\[cash\_flow2]) | discount\_rate: tingkat diskonto per periode. cash\_flow1: arus kas masa depan pertama. cash\_flow2: arus kas masa depan lainnya. | | `PDURATION` | Mengembalikan jumlah periode yang diperlukan agar suatu investasi mencapai nilai target. | PDURATION(\\\[rate], \\\[pv], \\\[fv]) | rate: laju pertumbuhan per periode. pv: nilai sekarang. fv: nilai masa depan target. | | `PMT` | Mengembalikan pembayaran periodik untuk suatu investasi anuitas dengan pembayaran sama dan suku bunga tetap. | PMT(\\\[rate], \\\[nper], \\\[pv], \\\[fv], \\\[type]) | rate: suku bunga. nper: jumlah periode pembayaran. pv: nilai sekarang. fv: nilai masa depan tersisa setelah pembayaran terakhir. type: waktu — 0 = akhir periode, 1 = awal. | | `PPMT` | Mengembalikan pelunasan pokok dalam periode tertentu dari suatu investasi dengan pembayaran sama dan suku bunga tetap. | PPMT(\\\[rate], \\\[period], \\\[nper], \\\[pv], \\\[fv], \\\[type]) | rate: suku bunga. period: periode (dalam periode). nper: jumlah periode pembayaran. pv: nilai sekarang. fv: nilai masa depan tersisa setelah pembayaran terakhir. type: waktu — 0 = akhir periode, 1 = awal. | | `PRICEDISC` | Mengembalikan harga obligasi diskonto (tanpa kupon) berdasarkan imbal hasil yang diharapkan. | PRICEDISC(\\\[settlement], \\\[maturity], \\\[discount], \\\[redemption], \\\[basis]) | settlement: tanggal penyelesaian obligasi. maturity: tanggal jatuh tempo obligasi. discount: tingkat diskonto saat pembelian. redemption: nilai penebusan per nilai nominal \$100. basis: metode penghitungan hari. | | `PV` | Mengembalikan nilai sekarang suatu investasi anuitas dengan pembayaran sama dan suku bunga tetap. | PV(\\\[rate], \\\[nper], \\\[pmt], \\\[fv], \\\[type]) | rate: suku bunga. nper: jumlah periode pembayaran. pmt: pembayaran per periode. fv: nilai masa depan tersisa setelah pembayaran terakhir. type: waktu — 0 = akhir periode, 1 = awal. | | `RATE` | Mengembalikan suku bunga suatu investasi anuitas dengan pembayaran sama dan ketentuan tetap. | RATE(\\\[nper], \\\[pmt], \\\[pv], \\\[fv], \\\[type], \\\[rate\_guess]) | nper: jumlah periode pembayaran. pmt: pembayaran per periode. pv: nilai sekarang. fv: nilai masa depan tersisa setelah pembayaran terakhir. type: waktu — 0 = akhir periode, 1 = awal. rate\_guess: perkiraan suku bunga. | | `RECEIVED` | Mengembalikan jumlah yang diterima pada saat jatuh tempo untuk obligasi berpendapatan tetap yang dibeli pada tanggal tertentu. | RECEIVED(\\\[settlement], \\\[maturity], \\\[investment], \\\[discount], \\\[basis]) | settlement: tanggal penyelesaian obligasi. maturity: tanggal jatuh tempo obligasi. investment: jumlah yang diinvestasikan (terlepas dari nilai nominal obligasi). discount: tingkat diskonto obligasi. basis: metode penghitungan hari. | | `RRI` | Mengembalikan suku bunga yang diperlukan agar suatu investasi tumbuh menjadi nilai target selama sejumlah periode. | RRI(\\\[nper], \\\[pv], \\\[fv]) | nper: jumlah periode pertumbuhan. pv: nilai sekarang. fv: nilai masa depan target. | | `SLN` | Mengembalikan penyusutan suatu aset untuk satu periode menggunakan metode garis lurus. | SLN(\\\[cost], \\\[salvage], \\\[life]) | cost: biaya awal aset. salvage: nilai pada akhir masa manfaat. life: masa manfaat dalam periode. | | `SYD` | Mengembalikan penyusutan suatu aset untuk periode tertentu menggunakan metode jumlah angka tahun. | SYD(\\\[cost], \\\[salvage], \\\[life], \\\[period]) | cost: biaya awal aset. salvage: nilai pada akhir masa manfaat. life: masa manfaat dalam periode. period: periode penyusutan. | | `VDB` | Mengembalikan penyusutan suatu aset untuk periode tertentu (atau periode sebagian). | VDB(\\\[cost], \\\[salvage], \\\[life], \\\[start\_period], \\\[end\_period], \\\[factor], \\\[no\_switch]) | cost: biaya awal aset. salvage: nilai pada akhir masa manfaat (residu). life: masa manfaat dalam periode. start\_period: periode mulai penyusutan. end\_period: periode akhir penyusutan. factor: laju saldo menurun (default 2 — saldo menurun ganda). no\_switch: apakah beralih ke garis lurus ketika penyusutan melebihi nilai saldo menurun. | | `XIRR` | Mengembalikan tingkat pengembalian internal untuk serangkaian arus kas yang mungkin tidak periodik. | XIRR(\\\[cash\_flows], \\\[dates], \\\[rate\_guess]) | cash\_flows: array atau rentang jumlah terkait investasi. dates: array atau rentang tanggal yang bersesuaian dengan arus kas. rate\_guess: perkiraan IRR. | | `XNPV` | Mengembalikan nilai sekarang bersih arus kas yang mungkin tidak periodik, berdasarkan tingkat diskonto. | XNPV(\\\[discount\_rate], \\\[cash\_flows], \\\[dates]) | discount\_rate: tingkat diskonto per periode. cash\_flows: rentang jumlah terkait investasi. dates: rentang tanggal yang bersesuaian dengan arus kas. | | `YIELDDISC` | Mengembalikan imbal hasil tahunan obligasi diskonto (tanpa kupon) dari harganya. | YIELDDISC(\\\[settlement], \\\[maturity], \\\[price], \\\[redemption], \\\[basis]) | settlement: tanggal penyelesaian obligasi. maturity: tanggal jatuh tempo obligasi. price: per nilai nominal $100. redemption: nilai penebusan per nilai nominal $100. basis: metode penghitungan hari. | # **Khusus** | Fungsi | Deskripsi | Contoh | Argumen | | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `FILTER` | Mengembalikan versi terfilter dari rentang sumber — hanya baris / kolom yang cocok dengan kondisi yang ditentukan. Catatan: beberapa versi Excel tidak mendukung fungsi ini. Gunakan dengan hati-hati jika mengekspor ke file lokal. | FILTER(\\\[range], \\\[condition], \\\[value]) | range: data yang akan difilter. condition: baris atau kolom yang cocok dengan baris atau kolom pertama `range` — boolean atau nilai yang dapat dikonversi menjadi boolean. value: dikembalikan ketika tidak ada baris yang cocok. | | `UNIQUE` | Mengembalikan baris / kolom unik dari rentang sumber, menghapus duplikat. Baris / kolom dikembalikan dalam urutan kemunculan pertamanya. Catatan: beberapa versi Excel tidak mendukung fungsi ini. Gunakan dengan hati-hati jika mengekspor ke file lokal. | UNIQUE(\\\[source\_range], \\\[by\_column], \\\[exactly\_once]) | source\_range: rentang atau array yang akan dideduplikasi. by\_column: opsional, TRUE / FALSE. Default FALSE — mendeduplikasi berdasarkan baris. exactly\_once: opsional, TRUE / FALSE. Default FALSE — mempertahankan nilai unik mana pun (satu atau beberapa kemunculan). |