Bagaimana Kama dihitung?

Jawaban langsung

Kama biasanya dihitung sebagai rata-rata bergerak variabel yang menyesuaikan diri sendiri. Dalam formulasi yang paling umum, setiap nilai baru Kama menggunakan (1) nilai Kama sebelumnya, (2) faktor penghalusan yang berubah seiring waktu, dan (3) harga saat ini. Faktor penghalusan tersebut bergantung pada seberapa “efisien” harga telah bergerak selama jendela lookback terakhir—sering diukur sebagai rasio antara perubahan harga bersih dan total perubahan absolut.

Karena ada nama dan varian yang berbeda dalam praktiknya, cara teraman untuk memverifikasi apa yang Anda gunakan adalah dengan memeriksa definisi persis di pengaturan indikator yang Anda miliki (misalnya, panjang lookback dan konstanta penghalusan). Perhitungan di bawah ini menunjukkan satu struktur yang banyak digunakan dan stabil; jika Kama di platform Anda menggunakan nama parameter yang berbeda atau rumus efisiensi yang sedikit berbeda, langkah-langkah mekanisnya serupa tetapi konstanta mungkin berbeda.

Mekanisme dan definisi

Cara praktis untuk menggambarkan mekanismenya adalah sebagai proses penghalusan rekursif.

1. Pilih rangkaian harga input Kama dihitung dari rangkaian waktu harga. “Harga” dapat didefinisikan dengan berbagai cara (misalnya, harga penutupan, harga tipikal, atau rangkaian turunan lainnya). Pilihan input Anda harus sesuai dengan implementasi yang ingin Anda reproduksi.

Misalkan P[t] adalah harga yang dipilih pada waktu t.

2. Tetapkan jendela lookback dan batas penghalusan Kama tipikal menggunakan:

• Panjang lookback: N (berapa periode yang digunakan untuk menilai efisiensi)
• Pengaturan penghalusan cepat: biasanya diwakili oleh periode atau konstanta “cepat” yang kecil
• Pengaturan penghalusan lambat: biasanya diwakili oleh periode atau konstanta “lambat” yang lebih besar

Dalam banyak implementasi, batas penghalusan diubah menjadi dua konstanta:

• SC_fast dan SC_slow yang diturunkan dari periode cepat dan lambat

Pemetaan yang tepat bergantung pada implementasi. Pendekatan umum menggunakan konstanta gaya penghalusan eksponensial dalam bentuk:

• SC_fast = 2 / (fastPeriod + 1)
• SC_slow = 2 / (slowPeriod + 1)

3. Hitung rasio efisiensi selama N periode terakhir Selama jendela lookback, dua kuantitas dibandingkan:

• Perubahan bersih: |P[t] − P[t−N]|
• Jumlah pergerakan absolut: sum_{i=0..N−1} |P[t−i] − P[t−i−1]|

Kemudian rasio efisiensi ER dihitung sebagai:

• ER = netChange / sumAbsMoves

ER ini dirancang untuk menjadi lebih tinggi ketika harga bergerak kuat dari awal ke akhir relatif terhadap jumlah pergerakan “bolak-balik” di dalam jendela. Ketika ER mendekati 0, harga tidak menentu; ketika ER mendekati 1, harga bergerak lebih langsung.

Detail yang ditangani secara eksplisit oleh implementasi: jika sumAbsMoves adalah nol (misalnya, jika harga tidak berubah di seluruh jendela), ER dapat diatur ke 0 atau ditangani untuk menghindari pembagian dengan nol. Anda harus mereplikasi aturan yang sama yang digunakan di sumber Anda.

4. Ubah ER menjadi konstanta penghalusan dinamis Konstanta penghalusan variabel SC[t] kemudian dihitung menggunakan ER dan batas penghalusan. Struktur umum adalah:

• SC[t] = (ER × (SC_fast − SC_slow) + SC_slow)^2

Eksponen (sering 2) adalah bagian dari formulasi yang umum digunakan; jika implementasi Anda menggunakan eksponen yang berbeda, Anda harus menggunakan yang sama.

5. Perbarui Kama secara rekursif Terakhir, Kama diperbarui sebagai:

• Kama[t] = Kama[t−1] + SC[t] × (P[t] − Kama[t−1])

Bentuk ini membuat Kama “tertarik menuju” harga saat ini dengan jumlah yang bergantung pada SC[t]. SC yang lebih besar berarti penyesuaian lebih cepat; SC yang lebih kecil berarti penyesuaian lebih lambat.

6. Inisialisasi Kama memerlukan nilai awal Kama[0] (atau Kama[N−1], tergantung pada pengindeksan). Banyak implementasi menginisialisasi Kama dengan harga pada titik pertama yang tersedia atau dengan rata-rata bergerak sederhana. Jika Anda ingin memverifikasi perhitungan secara independen, konfirmasikan aturan inisialisasi yang tepat dari definisi indikator yang Anda uji.

Bukti atau contoh (dengan asumsi eksplisit)

Di bawah ini adalah contoh numerik kecil menggunakan asumsi yang dinyatakan. Ini bukan data pasar langsung; ini menunjukkan struktur perhitungan yang dapat Anda ulangi dengan rangkaian Anda sendiri.

Asumsi untuk contoh:

• Harga input P adalah harga penutupan.
• Panjang lookback N = 3.
• fastPeriod = 2, slowPeriod = 30, jadi:
  • SC_fast = 2/(2+1) = 0.666666…
  • SC_slow = 2/(30+1) = 0.064516…
• Eksponen adalah 2 dalam SC[t].
• Nilai Kama sebelumnya adalah Kama[t−1] = 100.

Misalkan pada waktu t Anda memiliki:

• P[t−2] = 99
• P[t−1] = 101
• P[t] = 100

Langkah A: netChange

• netChange = |P[t] − P[t−N]| = |100 − 99| = 1

Langkah B: sumAbsMoves Untuk N = 3, kita memerlukan |P[t]−P[t−1]| + |P[t−1]−P[t−2]| + |P[t−2]−P[t−3]|. Tetapi seri mini kami hanya menunjukkan dua harga sebelumnya. Untuk menjaga demonstrasi tetap konsisten, perluas jendela untuk menyertakan P[t−3].

Misalkan P[t−3] = 98. Sekarang hitung:

• |P[t] − P[t−1]| = |100 − 101| = 1
• |P[t−1] − P[t−2]| = |101 − 99| = 2
• |P[t−2] − P[t−3]| = |99 − 98| = 1
• sumAbsMoves = 1 + 2 + 1 = 4

Langkah C: ER

• ER = netChange / sumAbsMoves = 1 / 4 = 0.25

Langkah D: konstanta penghalusan dinamis

• SC[t] = (ER × (SC_fast − SC_slow) + SC_slow)^2 Pertama hitung (SC_fast − SC_slow):
• 0.666666… − 0.064516… = 0.602150… Kemudian istilah linier:
• ER × (SC_fast − SC_slow) + SC_slow = 0.25 × 0.602150… + 0.064516… = 0.150537… + 0.064516… = 0.215053… Kuadratkan:
• SC[t] ≈ (0.215053…)^2 ≈ 0.0463

Langkah E: perbarui Kama

• Kama[t] = Kama[t−1] + SC[t] × (P[t] − Kama[t−1]) = 100 + 0.0463 × (100 − 100) = 100

Dalam contoh yang dibuat ini, harga saat ini sama dengan Kama sebelumnya, jadi pembaruannya adalah nol. Jika P[t] berbeda dari Kama[t−1], Anda akan melihat penyesuaian bukan nol yang diskalakan oleh SC[t].

Mengapa ini menggambarkan idenya: jika ER meningkat (harga menjadi lebih langsung selama N periode), SC[t] cenderung bergerak menuju SC_fast, membuat Kama merespons lebih cepat. Jika ER menurun (pergerakan lebih tidak menentu), SC[t] cenderung menuju SC_slow, membuat Kama lebih halus.

Keterbatasan dan risiko

1. Ketidakcocokan parameter Kama bergantung pada N, pengaturan cepat/lambat, dan eksponen serta aturan penanganan untuk kasus tepi (seperti pembagian dengan nol). Jika Anda menyalin rumus tetapi bukan pemetaan parameter yang tepat dari indikator Anda, Anda akan mereproduksi nilai yang berbeda.

2. Definisi harga input Platform yang berbeda mendefinisikan “harga” secara berbeda. Jika satu menggunakan penutupan dan yang lain menggunakan harga turunan (misalnya, rata-rata tinggi/rendah/penutupan), seluruh rangkaian keluaran berubah.