---
title: 'Matematika'
description: "Fungsi matematika tingkat lanjut dan operasi pembulatan."
navigation:
  icon: 'i-ph-code-block'
seo:
  title: 'Matematika'
  description: "Fungsi matematika tingkat lanjut dan operasi pembulatan."
---

## Tinjauan

Fungsi matematika menyediakan operasi numerik tingkat lanjut melampaui aritmatika dasar, termasuk pembulatan, nilai absolut, perbandingan min/max, dan perhitungan pangkat. Fungsi-fungsi ini penting untuk perhitungan finansial, operasi statistik, dan manipulasi numerik yang presisi.

### Kasus Penggunaan Umum

- **Kalkulasi Finansial**: Pembulatan mata uang yang presisi dengan `round`, `roundup`, `rounddown`
- **Operasi Rentang**: Menemukan nilai minimum/maksimum dengan `min`, `max`
- **Analisis Statistik**: Menghitung deviasi absolut dengan `abs`
- **Komputasi Ilmiah**: Perhitungan pangkat dan eksponensial dengan `pow`
- **Pengelompokan Data**: Pembulatan ke kelipatan tertentu dengan `mround`, `ceiling`, `floor`
- **Pemotongan**: Menghapus tempat desimal tanpa pembulatan menggunakan `trunc`

### Kategori Fungsi Matematika

1. **Pembulatan**: `round`, `roundup`, `rounddown`, `trunc` - Mengontrol presisi desimal
2. **Berbasis Kelipatan**: `ceiling`, `floor`, `mround` - Membulatkan ke kelipatan tertentu
3. **Perbandingan**: `min`, `max` - Menemukan nilai ekstrem
4. **Transformasi**: `abs`, `pow` - Nilai absolut dan eksponensiasi

### Penjelasan Mode Pembulatan

Mode pembulatan yang berbeda melayani tujuan yang berbeda:

- **`round`**: Pembulatan standar (banker's rounding) - paling umum digunakan
- **`roundup`**: Selalu membulatkan menjauhi nol - untuk estimasi konservatif, jumlah halaman
- **`rounddown`**: Selalu membulatkan ke arah nol - untuk diskon, harga dasar
- **`ceiling`**: Membulatkan ke atas ke kelipatan berikutnya - untuk tingkatan harga
- **`floor`**: Membulatkan ke bawah ke kelipatan sebelumnya - untuk diskon kuantitas
- **`trunc`**: Menghapus desimal tanpa pembulatan - untuk pengambilan integer
- **`mround`**: Membulatkan ke kelipatan terdekat - untuk interval waktu, kuantitas unit

### Kompatibilitas Excel

Semua nama fungsi huruf besar (`ROUND`, `CEILING`, `FLOOR`, dll.) mempertahankan kompatibilitas Excel untuk mempermudah migrasi formula.

## `abs` - Nilai Absolut

Mengembalikan nilai absolut dari sebuah angka.

### Sintaks
```json
{"abs": value}
```

### Parameter
- **value** (number): Angka untuk mendapatkan nilai absolutnya

### Tipe Kembalian
Number - Nilai absolut (selalu non-negatif)

### Contoh

**Absolut dasar:**
```json
{"abs": -5}                // → 5
{"abs": 10}                // → 10
{"abs": 0}                 // → 0
```

**Dengan variabel:**
```json
// Data: {"temperature": -15}
{"abs": {"var": "temperature"}}  // → 15
```

**Perhitungan jarak:**
```json
{"abs": {"-": [{"var": "x1"}, {"var": "x2"}]}}
```

---

## `max` - Nilai Maksimum

Mengembalikan nilai terbesar dari sebuah daftar.

### Sintaks
```json
{"max": [value1, value2, ...]}
```

### Parameter
- **values** (array): Angka-angka untuk dibandingkan

### Tipe Kembalian
Number - Nilai terbesar, atau `null` jika array kosong

### Contoh

**Max dasar:**
```json
{"max": [1, 5, 3, 9, 2]}         // → 9
{"max": [-10, -5, -20]}          // → -5
```

**Dua nilai:**
```json
{"max": [{"var": "a"}, {"var": "b"}]}
```

**Array kosong:**
```json
{"max": []}                      // → null
```

**Cari skor tertinggi:**
```json
// Data: {"scores": [85, 92, 78, 95, 88]}
{"reduce": [
  {"var": "scores"},
  {"max": [{"var": "accumulator"}, {"var": "current"}]},
  0
]}
```

---

## `min` - Nilai Minimum

Mengembalikan nilai terkecil dari sebuah daftar.

### Sintaks
```json
{"min": [value1, value2, ...]}
```

### Parameter
- **values** (array): Angka-angka untuk dibandingkan

### Tipe Kembalian
Number - Nilai terkecil, atau `null` jika array kosong

### Contoh

**Min dasar:**
```json
{"min": [1, 5, 3, 9, 2]}         // → 1
{"min": [-10, -5, -20]}          // → -20
```

**Membatasi nilai (clamp):**
```json
{"min": [{"var": "input"}, 100]}  // Nilai maksimal 100
```

---

## `pow` / `**` - Pangkat

Menaikkan angka ke pangkat tertentu. Alternatif untuk operator `^`.

### Sintaks
```json
{"pow": [base, exponent]}
{"**": [base, exponent]}
```

### Parameter
- **base** (number): Angka dasar
- **exponent** (number): Pangkat

### Tipe Kembalian
Number - base^exponent

### Contoh

**Pangkat dasar:**
```json
{"pow": [2, 3]}                  // → 8
{"pow": [10, 2]}                 // → 100
```

**Akar kuadrat:**
```json
{"pow": [16, 0.5]}               // → 4
```

**Kubik:**
```json
{"pow": [3, 3]}                  // → 27
```

---

## `round` / `ROUND` - Pembulatan Angka

Membulatkan angka ke tempat desimal yang ditentukan.

### Sintaks
```json
{"round": [value, decimals]}
{"ROUND": [value]}
```

### Parameter
- **value** (number): Angka untuk dibulatkan
- **decimals** (number, opsional): Tempat desimal (default: 0)
  - Positif: tempat desimal
  - Nol: bulatkan ke integer
  - Negatif: bulatkan ke kiri desimal

### Tipe Kembalian
Number - Nilai yang dibulatkan

### Contoh

**Bulatkan ke integer:**
```json
{"round": [3.7]}                 // → 4
{"ROUND": [3.2]}                 // → 3
{"round": [3.5]}                 // → 4
```

**Bulatkan ke desimal:**
```json
{"ROUND": [3.14159, 2]}          // → 3.14
{"round": [2.71828, 3]}          // → 2.718
```

**Bulatkan ke puluhan:**
```json
{"ROUND": [1234, -1]}            // → 1230
{"round": [1567, -2]}            // → 1600
```

**Pembulatan finansial:**
```json
{"ROUND": [
  {"*": [{"var": "price"}, {"var": "quantity"}]},
  2
]}
```

### Catatan
Menggunakan "round half to even" (pembulatan bankir) secara default.

---

## `roundup` / `ROUNDUP` - Bulatkan ke Atas

Selalu membulatkan menjauhi nol.

### Sintaks
```json
{"roundup": [value, decimals]}
{"ROUNDUP": [value, decimals]}
```

### Parameter
- **value** (number): Angka untuk dibulatkan ke atas
- **decimals** (number, opsional): Tempat desimal (default: 0)

### Tipe Kembalian
Number - Nilai hasil pembulatan ke atas

### Contoh

**Bulatkan ke atas ke integer:**
```json
{"roundup": [3.1]}               // → 4
{"ROUNDUP": [3.9]}               // → 4
{"roundup": [-3.1]}              // → -4 (menjauhi nol)
```

**Bulatkan ke atas ke desimal:**
```json
{"ROUNDUP": [3.14159, 2]}        // → 3.15
{"roundup": [2.001, 2]}          // → 2.01
```

**Bulatkan ke atas ke puluhan:**
```json
{"ROUNDUP": [1234, -1]}          // → 1240
{"roundup": [1001, -2]}          // → 1100
```

**Hitung halaman:**
```json
// Total halaman yang dibutuhkan
{"ROUNDUP": [
  {"/": [{"var": "items"}, {"var": "perPage"}]},
  0
]}
```

---

## `rounddown` / `ROUNDDOWN` - Bulatkan ke Bawah

Selalu membulatkan ke arah nol.

### Sintaks
```json
{"rounddown": [value, decimals]}
{"ROUNDDOWN": [value, decimals]}
```

### Parameter
- **value** (number): Angka untuk dibulatkan ke bawah
- **decimals** (number, opsional): Tempat desimal (default: 0)

### Tipe Kembalian
Number - Nilai hasil pembulatan ke bawah

### Contoh

**Bulatkan ke bawah ke integer:**
```json
{"rounddown": [3.9]}             // → 3
{"ROUNDDOWN": [3.1]}             // → 3
{"rounddown": [-3.9]}            // → -3 (ke arah nol)
```

**Bulatkan ke bawah ke desimal:**
```json
{"ROUNDDOWN": [3.14159, 2]}      // → 3.14
{"rounddown": [2.999, 2]}        // → 2.99
```

---

## `ceiling` / `CEILING` - Ceiling

Membulatkan ke atas ke kelipatan signifikansi terdekat.

### Sintaks
```json
{"ceiling": [value, significance]}
{"CEILING": [value]}
```

### Parameter
- **value** (number): Angka untuk dibulatkan
- **significance** (number, opsional): Kelipatan pembulatan (default: 1)

### Tipe Kembalian
Number - Hasil pembulatan ke atas ke kelipatan terdekat

### Contoh

**Bulatkan ke atas ke integer:**
```json
{"ceiling": [4.3]}               // → 5
{"CEILING": [4.1]}               // → 5
```

**Bulatkan ke kelipatan tertentu:**
```json
{"CEILING": [4.3, 0.5]}          // → 4.5
{"ceiling": [123, 10]}           // → 130
{"ceiling": [7, 3]}              // → 9 (kelipatan 3 berikutnya)
```

**Pembulatan harga:**
```json
{"CEILING": [{"var": "price"}, 0.99]}  // Bulatkan ke .99
```

---

## `floor` / `FLOOR` - Floor

Membulatkan ke bawah ke kelipatan signifikansi terdekat.

### Sintaks
```json
{"floor": [value, significance]}
{"FLOOR": [value]}
```

### Parameter
- **value** (number): Angka untuk dibulatkan
- **significance** (number, opsional): Kelipatan pembulatan (default: 1)

### Tipe Kembalian
Number - Hasil pembulatan ke bawah ke kelipatan terdekat

### Contoh

**Bulatkan ke bawah ke integer:**
```json
{"floor": [4.9]}                 // → 4
{"FLOOR": [4.1]}                 // → 4
```

**Bulatkan ke kelipatan tertentu:**
```json
{"FLOOR": [4.7, 0.5]}            // → 4.5
{"floor": [123, 10]}             // → 120
{"floor": [8, 3]}                // → 6 (kelipatan 3 sebelumnya)
```

---

## `trunc` / `TRUNC` - Truncate

Memotong angka ke tempat desimal yang ditentukan (menghapus bagian pecahan).

### Sintaks
```json
{"trunc": [value, decimals]}
{"TRUNC": [value]}
```

### Parameter
- **value** (number): Angka untuk dipotong
- **decimals** (number, opsional): Tempat desimal (default: 0)

### Tipe Kembalian
Number - Nilai yang dipotong

### Contoh

**Potong ke integer:**
```json
{"trunc": [8.9]}                 // → 8
{"TRUNC": [-8.9]}                // → -8
```

**Potong ke desimal:**
```json
{"TRUNC": [8.9876, 2]}           // → 8.98
{"trunc": [-3.789, 1]}           // → -3.7
```

**Potong ke puluhan:**
```json
{"TRUNC": [123.456, -1]}         // → 120
```

**Ambil bagian integer:**
```json
{"trunc": [{"var": "decimal"}]}  // Hapus bagian pecahan
```

---

## `mround` / `MROUND` - Bulatkan ke Kelipatan

Membulatkan ke kelipatan terdekat dari nilai yang ditentukan.

### Sintaks
```json
{"mround": [value, multiple]}
{"MROUND": [value, multiple]}
```

### Parameter
- **value** (number): Angka untuk dibulatkan
- **multiple** (number): Kelipatan pembulatan

### Tipe Kembalian
Number - Kelipatan terdekat

### Contoh

**Bulatkan ke kelipatan terdekat:**
```json
{"mround": [10, 3]}              // → 9
{"MROUND": [11, 3]}              // → 12
{"mround": [7.5, 2]}             // → 8
```

**Bulatkan ke kelipatan 5:**
```json
{"MROUND": [13, 5]}              // → 15
{"mround": [12, 5]}              // → 10
```

**Bulatkan ke kelipatan desimal:**
```json
{"mround": [1.23, 0.1]}          // → 1.2
{"MROUND": [0.567, 0.05]}        // → 0.55
```

**Pembulatan waktu (15 menit):**
```json
{"MROUND": [{"var": "minutes"}, 15]}
```

---

## Contoh Kompleks

### Perhitungan Persentase
```json
{"round": [
  {"*": [
    {"/": [{"var": "part"}, {"var": "total"}]},
    100
  ]},
  1
]}
// Hasil: persentase dengan 1 tempat desimal
```

### Hitung Pajak
```json
{"round": [
  {"*": [{"var": "amount"}, {"var": "taxRate"}]},
  2
]}
```

### Membatasi Nilai ke Dalam Rentang (Clamp)
```json
{"max": [
  {"min": [{"var": "value"}, {"var": "max"}]},
  {"var": "min"}
]}
// Memastikan nilai berada di antara min dan max
```

### Konversi ke Unit Tampilan
```json
{
  "if": [
    {">": [{"var": "bytes"}, 1073741824]},
    {"cat": [
      {"round": [{"/": [{"var": "bytes"}, 1073741824]}, 2]},
      " GB"
    ]},
    {"cat": [
      {"round": [{"/": [{"var": "bytes"}, 1048576]}, 2]},
      " MB"
    ]}
  ]
}
```

---

## Praktik Terbaik

1. **Selalu bulatkan perhitungan finansial**
   ```json
   {"round": [amount, 2]}  // 2 desimal untuk mata uang
   ```

2. **Gunakan metode pembulatan yang tepat**
   - `round` - Tujuan umum
   - `roundup` - Selalu bulatkan ke atas (halaman, inventaris)
   - `rounddown` - Selalu bulatkan ke bawah (diskon)
   - `trunc` - Hapus desimal tanpa pembulatan

3. **Bulatkan lebih awal dan sering** dalam perhitungan multi-langkah
   ```json
   {"round": [
     {"+": [
       {"round": [step1, 2]},
       {"round": [step2, 2]}
     ]},
     2
   ]}
   ```

4. **Gunakan ceiling/floor untuk diskretisasi**
   ```json
   {"ceiling": [value, binSize]}
   ```

5. **Gabungkan min/max untuk membatasi (clamping)**
   ```json
   {"max": [minValue, {"min": [value, maxValue]}]}
   ```

---

## Troubleshooting

### Masalah: Kesalahan presisi floating point

**Masalah:** Perhitungan desimal menunjukkan hasil yang tidak terduga seperti `0.30000000000000004`.

**Penyebab umum:**
1. **Representasi floating point biner** - 0.1 + 0.2 tidak tepat sama dengan 0.3
2. **Kesalahan pembulatan yang terakumulasi** - Beberapa operasi menggabungkan kesalahan

**Solusi:**
```json
// ❌ Masalah presisi
{"+": [0.1, 0.2]}  // → 0.30000000000000004

// ✅ Bulatkan ke presisi yang diharapkan
{"round": [{"+": [0.1, 0.2]}, 2]}  // → 0.3

// ✅ Selalu bulatkan perhitungan finansial
{"round": [
  {"*": [{"var": "price"}, {"var": "quantity"}]},
  2
]}
```

### Masalah: Round/roundup/rounddown memberikan hasil yang sama

**Masalah:** Fungsi pembulatan yang berbeda menghasilkan output yang identik.

**Penyebab umum:**
1. **Sudah berada pada presisi yang diinginkan** - Angka memiliki desimal lebih sedikit dari yang diminta
2. **Hasil kebetulan sama** - Nilai di titik tengah mungkin dibulatkan dengan cara yang sama

---

## Kompatibilitas Excel

Semua operator yang ditandai dengan nama huruf besar (ROUND, CEILING, dll.) kompatibel dengan Excel:

- **ROUND** - Pembulatan bankir (round half to even)
- **ROUNDUP** - Selalu menjauhi nol
- **ROUNDDOWN** - Selalu ke arah nol
- **CEILING** - Bulatkan ke atas ke kelipatan
- **FLOOR** - Bulatkan ke bawah ke kelipatan
- **TRUNC** - Potong desimal
- **MROUND** - Bulatkan ke kelipatan terdekat
