Konsep Integral

Topik ini memperkenalkan integral dari dua sisi, yaitu luas di bawah kurva dan antiturunan, mulai dari penjumlahan kepingan persegi panjang hingga teorema dasar kalkulus. Setiap konsep diverifikasi secara numerik menggunakan NumPy, mulai dari jumlah Riemann, aturan trapesium, hingga nilai eksak dari rumus antiturunan. Setelah membaca, luas di bawah kurva sederhana dapat dihitung melalui dua cara yang berbeda, yaitu secara analitik dengan antiturunan dan secara numerik dengan kode, serta kedua hasilnya dapat dibandingkan langsung.

Luas di bawah kurva sebagai penjumlahan kepingan#

Luas daerah di bawah kurva $y = f(x)$ dari $x = a$ sampai $x = b$ dapat dihampiri dengan membagi daerah itu menjadi persegi panjang sempit lalu menjumlahkan luas seluruh kepingannya. Pendekatan ini disebut jumlah Riemann (Riemann sum), yaitu penjumlahan luas $f(x_i)\,\Delta x$ pada setiap kepingan berlebar $\Delta x$. Contoh yang digunakan sepanjang topik ini adalah $f(x) = x^2$ pada interval $[0, 1]$, yang nilai eksaknya akan diperoleh dari dua arah yang berbeda.

Gambar berikut memperlihatkan delapan kepingan persegi panjang di bawah kurva tersebut, lengkap dengan kurva aslinya. Tinggi setiap kepingan diambil dari ujung kirinya, sehingga setiap kepingan tampak lebih pendek daripada kurva di atasnya. Pilihan ujung kiri hanyalah satu kebiasaan, karena ujung kanan atau titik tengah setiap kepingan memberikan hampiran lain pada jumlah kepingan yang sama.

import numpy as np
import matplotlib.pyplot as plt

def f(x):
    return x**2

n = 8
a, b = 0.0, 1.0
x = np.linspace(a, b, n, endpoint=False)
lebar = (b - a) / n

xfine = np.linspace(a, b, 400)
fig, ax = plt.subplots(figsize=(6, 3))
ax.bar(x, f(x), width=lebar, align="edge", color="#a8c7e7",
       edgecolor="#1a5fb4", linewidth=0.8, label="persegi panjang")
ax.plot(xfine, f(xfine), color="#c01c28", linewidth=2, label="f(x) = x^2")
ax.set_xlabel("x")
ax.set_ylabel("f(x)")
ax.set_title("Delapan persegi panjang menghampiri luas di bawah kurva")
ax.legend(loc="upper left", fontsize=8)
fig.savefig("jumlah-riemann.svg")

Seluruh kepingan berada di bawah kurva karena $f(x) = x^2$ adalah fungsi yang naik dan tinggi kepingan diambil dari ujung kiri, sehingga jumlahnya pasti kurang dari luas sebenarnya. Kekurangan itu tidak menghalangi, karena banyaknya kepingan dapat ditambah hingga selisihnya menyusut. Pola penyusutan itulah yang diukur secara numerik pada bagian berikut.

Jumlah Riemann dan notasi integral#

Ketika banyaknya kepingan $n$ membesar dan lebar $\Delta x$ menyusut menuju nol, jumlah Riemann menuju suatu nilai tetap yang disebut integral tentu (definite integral). Nilai yang dituju itu tidak bergantung pada cara membagi interval, selama lebar terbesarnya menuju nol. Hubungan itu dituliskan sebagai limit berikut,

Program berikut menghitung jumlah Riemann kiri untuk $f(x) = x^2$ pada $[0, 1]$ dengan empat pilihan $n$, lalu membandingkannya dengan nilai eksak $1/3$ yang akan dijelaskan pada bagian berikutnya. Seluruh penjumlahannya dikerjakan oleh NumPy dalam satu perhitungan, yaitu jumlah tinggi kepingan dikalikan lebar kepingan.

import numpy as np

def f(x):
    return x**2

a, b = 0.0, 1.0
eksak = 1.0 / 3.0
for n in (10, 100, 1000, 10000):
    x = np.linspace(a, b, n, endpoint=False)
    lebar = (b - a) / n
    jumlah = np.sum(f(x)) * lebar
    print(f"n = {n:6d} : jumlah Riemann = {jumlah:.6f}, eksak = {eksak:.6f}")

n =     10 : jumlah Riemann = 0.285000, eksak = 0.333333
n =    100 : jumlah Riemann = 0.328350, eksak = 0.333333
n =   1000 : jumlah Riemann = 0.332834, eksak = 0.333333
n =  10000 : jumlah Riemann = 0.333283, eksak = 0.333333

Jumlah kepingan yang dikalikan sepuluh menyusutkan selisih terhadap nilai eksak sekitar sepuluh kali pula, sebagaimana terlihat dari $0.048333$ pada $n = 10$ yang turun menjadi $0.000050$ pada $n = 10000$. Pola penyusutan ini merupakan ciri hampiran yang konvergen, yaitu bergerak menuju satu nilai tetap. Nilai yang dituju itu dapat dituliskan dalam bentuk tertutup tanpa penjumlahan apa pun, dan rumus itulah yang menjadi isi bagian berikutnya.

Antiturunan dan teorema dasar kalkulus#

Antiturunan (antiderivative) dari fungsi $f$ adalah fungsi $F$ yang turunannya sama dengan $f$, yaitu $F'(x) = f(x)$. Satu fungsi memiliki banyak antiturunan sekaligus, karena penjumlahan konstanta tidak mengubah turunannya. Teorema dasar kalkulus (fundamental theorem of calculus) menyatakan bahwa integral tentu dapat dihitung dari antiturunan tanpa penjumlahan kepingan sama sekali,

Pada contoh yang sama, antiturunan dari $f(x) = x^2$ adalah $F(x) = x^3/3$ karena turunan $x^3/3$ mengembalikan $x^2$. Nilai integralnya menjadi $F(1) - F(0) = 1/3$, tepat nilai yang dituju oleh jumlah Riemann pada bagian sebelumnya. Program berikut menghitung nilai tersebut bersama dua hampiran numerik pada jumlah kepingan yang sama, sehingga ketelitian kedua metode dapat dibandingkan.

import numpy as np

def f(x):
    return x**2

def F(x):
    return x**3 / 3.0

a, b = 0.0, 1.0
ftc = F(b) - F(a)

x = np.linspace(a, b, 1001)
trapesium = np.trapezoid(f(x), x)

xkiri = np.linspace(a, b, 1000, endpoint=False)
riemann = np.sum(f(xkiri)) * (b - a) / 1000.0

print(f"{'F(b) - F(a) (eksak)' : <24}: {ftc:.6f}")
print(f"{'trapesium 1000 keping': <24}: {trapesium:.6f}")
print(f"{'Riemann kiri 1000 keping': <24}: {riemann:.6f}")

F(b) - F(a) (eksak)     : 0.333333
trapesium 1000 keping   : 0.333334
Riemann kiri 1000 keping: 0.332834

Pada jumlah kepingan yang sama, aturan trapesium np.trapezoid menyisakan selisih sekitar $10^{-6}$, sedangkan jumlah Riemann kiri masih menyisakan sekitar $5 \times 10^{-4}$. Ketelitian trapesium yang jauh lebih baik berasal dari cara kepingannya mengambil ketinggian rata-rata di kedua ujung, sehingga sebagian kesalahan ujung kiri dan ujung kanan saling menghapus. Nilai eksak dari teorema dasar kalkulus tetap menjadi acuan kebenaran kedua hampiran itu.

Demo interaktif: banyak kepingan yang dapat diatur#

Demo berikut menggambar kepingan persegi panjang di bawah $f(x) = x^2$ sesuai jumlah kepingan yang dipilih. Geser penggeser $n$ dari $4$ sampai $80$, lalu amati bacaan jumlah Riemann yang makin dekat ke luas eksak $1/3 \approx 0.333333$. Selisihnya paling terlihat pada kepingan yang lebar, dan menyusut setiap kali $n$ membesar.

Di mana hal ini ditemui dalam kode#

Integral numerik muncul setiap kali jumlah total dihitung dari pengukuran yang berupa sampel, bukan rumus. Catatan daya sebuah sensor yang direkam setiap detik menghasilkan energi total berupa luas di bawah kurva daya terhadap waktu, dan jumlah itu dihitung dengan np.trapezoid(daya, waktu) tanpa mencari antiturunan sama sekali. Pola yang sama digunakan untuk menghitung jarak dari catatan kecepatan, volume dari laju aliran, dan total pengunjung dari catatan jumlah per jam.

Fungsi np.trapezoid menghitung aturan trapesium pada seluruh array sekaligus, dan merupakan nama baru dari fungsi lama np.trapz yang kini tidak disarankan lagi. Apabila kebutuhannya berupa jumlah berjalan yang diperbarui setiap sampel, np.cumsum menjadi padanan diskret dari integral tak tentu, yaitu fungsi yang turunannya mengembalikan data aslinya. Metode dengan ketelitian lebih tinggi untuk fungsi yang halus tersedia pada pustaka lain, tetapi aturan trapesium sudah mencukupi untuk catatan pengukuran yang berderau.

Ringkasan#

• Integral tentu $\int_a^b f(x)\,dx$ didefinisikan sebagai limit jumlah Riemann, yaitu penjumlahan luas kepingan persegi panjang yang lebarnya menuju nol.
• Untuk $f(x) = x^2$ pada $[0, 1]$, jumlah Riemann menuju $1/3$ ketika banyaknya kepingan membesar, dengan selisih yang menyusut seiring $n$.
• Teorema dasar kalkulus menghitung nilai yang sama secara eksak melalui antiturunan, yaitu $\int_a^b f = F(b) - F(a)$ dengan $F'(x) = f(x)$.
• Aturan trapesium np.trapezoid mencapai ketelitian jauh lebih tinggi daripada jumlah Riemann kiri pada jumlah kepingan yang sama.

Referensi#

• Calculus Volume 1, 5.1 Approximating Areas — OpenStax — Penjelasan jumlah Riemann kiri, kanan, dan titik tengah beserta gambarnya.
• Calculus Volume 1, 5.3 The Fundamental Theorem of Calculus — OpenStax — Teorema dasar kalkulus yang menghubungkan integral dengan antiturunan.
• numpy.trapezoid — NumPy — Dokumentasi aturan trapesium untuk integrasi numerik array.