\chapter{Akar - Akar Persamaan Berderajat Tinggi}

Persamaan - persamaan berderajat tinggi dapat berupa persamaan suku banyak atau persamaan yang memuat fungsi - fungsi radikal dan/atau transendental (fungsi - fungsi trigonometrik dan logaritmik). Salah satu contoh sederhana dari persamaan berderajat tinggi adalah persamaan kuadrat yang sudah kalian pelajari semenjak SMP dahulu, sebagai berikut ini,

\begin{equation}
    ax^{2} + bx + c = 0
    \label{eq21}
\end{equation}

Akar - akar dari persamaan \ref{eq21} dapat dengan mudah diselesaikan secara analitik melalui persamaan sebagai berikut,

\begin{equation}
    x = \frac{-b \pm \sqrt{b^{2}-4ac}}{2a}
    \label{eq22}
\end{equation}

Namun dalam banyak kasus pada persamaan suku banyak dan persamaan yang memuat fungsi transendental, metode penyelesaian analitik terkadang sulit untuk dilakukan, sehingga kita memerlukan metode penyelesaian numerik.

\section{Metode Iterasi Sederhana}
Metode iterasi sederhana merupakan metode numerik termudah untuk mencari akar - akar persamaan berderajat tinggi. Langkah awal yang dilakukan oleh metode iterasi sederhana adalah menyusun ulang persamaan ke dalam bentuk, di mana variabel yang tidak diketahui berada di sebelah kiri dari persamaan. Nilai awal (tebakan awal) disubstitusikan di sebelah kanan persamaan, kemudian didapatkanlah nilai baru untuk variabel tersebut. Iterasi ini akan terus berlanjut sampai nilai lama dan nilai baru variabel tersebut menjadi setara. Nilai ini merupakan salah satu akar dari persamaan, nilai akar lainnya didapatkan dengan mengikuti prosedur yang sama namun dengan nilai tebakan awal yang berbeda.

Berikut adalah langkah - langkah pengerjaannya:
\begin{enumerate}
    \item Susun ulang persamaan, sehingga seluruh variabel berada di sisi kiri persamaan.
    \item Tebak nilai awal dari variabel guna mengeksekusi iterasi pertama.
    \item Substitusikan variabel di sisi kanan persamaan dan hitung nilai baru untuk variable ini.
    \item Jika nilai baru variabel ini tidak sesuai dengan nilai sebelumnya, maka gunakan nilai baru sebagai nilai variabel ini.
    \item Ulangi langkah 3 dan 4, hingga nilai baru sama dengan nilai variabel yang lama.
    \item Jika nilai baru tidak mendekati nilai lama (dengan selisih meningkat pada setiap iterasi), hentikan penghitungan dan pertimbangkan untuk mencoba nilai awal lain atau melakukan penataan ulang terhadap persamaan yang diberikan.
\end{enumerate}

Contoh pengerjaannya secara praktis dapat diilustrasikan dalam kasus berikut ini:

Misalkan kita mempunyai persamaan sebagai berikut:

\begin{equation}
    2x^2 - 5x + 3 = 0
    \label{eq23}
\end{equation}

Melalui pelajaran di bangku SMA, kita dengan mudah menebak solusi analitik-nya, yakni $x = 1$ dan $x = 1,5$, namun tidak ada salahnya untuk menggunakan contoh ini sebagai langkah awal untuk memahami penyelsaian numeriknya melalui metode iterasi sederhana. Langkah awal algoritma ini dilakukan dengan memindahkan ruas persamaan sebagai berikut:

\begin{equation}
    x = \frac{2x^2 + 3}{5}
    \label{eq24}
\end{equation}

, atau:

\begin{equation}
x = \sqrt{\frac{5x - 3}{2}}
    \label{eq25}
\end{equation}

Untuk lebih memahaminya secara praktis, jalankan kode berikut ini:

\nolinenumbers
\lstinputlisting[language=Python]{./kode/contoh_021.py}
\linenumbers

Perhatikan jika, kita menambahkan angka 1 pada akhir iterasi, hal ini patut diingat karena jika tidak Python hanya akan melakukan perhitungan dari 0 hingga 99. 

\section{Akurasi Solusi Numerik}

Kedua Baris akhir pada luaran program menunjukkan hasil perhitungan, masing - masing untuk \verb|x| dan \verb|x_baru|:

\nolinenumbers
\begin{verbatim}
    100 0.9999999999394882
    100 0.9999999999515905
\end{verbatim}
\linenumbers

Karena solusi diperoleh secara numerik dengan menggunakan komputer, nilai-nilai tersebut secara langsung dipengaruhi oleh ketepatan tipe data variabel. Sebagai contoh, ketik penjumlahan sederhana ini di Python Shell dan tampilan hasilnya:

\nolinenumbers
\begin{verbatim}
    >>> x = 1.2 + 3.45678910111213141516
    >>> print(x)
    4.656789101112131
    >>> type(x)
    <class 'float'>
\end{verbatim}
\linenumbers

Ini menunjukkan bahwa tipe data \textit{float}, yang setara dengan \textit{double} dalam beberapa bahasa pemrograman lain, akurat hingga digit desimal ke-16 dalam konteks ini. Dengan demikian berarti bahwa syarat guna memenuhi kondisi kesetaraan secara eksak sangat sulit dicapai, bahkan tidak mungkin dalam beberapa kasus dengan jumlah digit desimal yang sangat besar, seperti konstanta $\pi$. Oleh karena itu, menjadi suatu kelaziman dalam metode numerik untuk menentukan \textbf{derajat ketelitian} (\textit{degree of accuracy}) yang diperlukan dalam menentukan keakuratan solusi. Sebagai contoh, akurasi hingga digit desimal ketiga dapat diterima bagi seorang oseanografer ketika nilai-nilai tersebut dalam satuan meter, tapi tidak pada komunitas fisika partikel yang membutuhkan keakuratan hingga 20 digit.

Oleh karenanya, algoritma iterasi sederhana harus dimodifikasi sedemikian rupa sehingga dapat mempertimbangkan tingkat ketelitian yang diperlukan untuk permasalahan tersebut. Dalam banyak referensi, hal ini disebut sebagai \textbf{toleransi numerik} (\textit{numerical tolerance}), yang mewakili \textbf{perbedaan maksimum mutlak} (\textit{absolute maximum difference}) yang dapat diterima antara nilai-nilai variabel persamaan yang dihasilkan dari dua iterasi berturut-turut. Dengan kata lain, ini adalah perbedaan antara nilai lama dan nilai baru. Penerapannya dapat dilihat pada contoh sebagai berikut:

\nolinenumbers
\lstinputlisting[language=Python]{./kode/contoh_022.py}
\linenumbers

Luarannya adalah sebagai berikut:

\nolinenumbers
\begin{verbatim}
    Akar: 1.00000
    Jumlah iterasi: 50
\end{verbatim}
\linenumbers

Permasalahan tersebut, selain dapat dikerjakan dengan metode pengulangan \verb|for|, juga dapat dikerjakan dengan metode pengulangan \verb|while| sebagai berikut sebagai alternatifnya:

\nolinenumbers
\lstinputlisting[language=Python]{./kode/contoh_023.py}
\linenumbers

Untuk menemukan nilai akar kedua, dapat diuji dengan nilai tebakan awal yang berbeda. Jika solusinya tidak juga ditemukan, perlu dilakukan penataan ulang dari persamaan yang diberikan, dalam konteks ini menggunakan persamaan \ref{eq25}.

\section{Konvergensi dan Divergensi Numerik}
Solusi yang diperoleh untuk persamaan kuadrat yang kita bahas sebelumnya (persamaan \ref{eq23}) menunjukkan bahwa kedua nilai variabel semakin mendekat pada setiap iterasi, dan pada iterasi ke-50, kedua nilai tersebut dianggap sama ketika kondisi akurasi yang dipersyaratkan terpenuhi. Perilaku ini dikenal sebagai konvergensi nilai ke suatu solusi yang spesifik (Gambar \ref{fig21}). Berikut adalah contoh kode yang digunakan untuk menampilkan konvergensi pada persamaan \ref{eq23}:

\nolinenumbers
\lstinputlisting[language=Python]{./kode/contoh_024.py}
\linenumbers

\begin{figure}[H]
    \centering
    \includegraphics[width=0.85\textwidth]{gambar/gambar021.png}
    \caption{Grafik berikut menunjukkan konvergensi ke nilai satu.}
    \label{fig21}
\end{figure}

Sebaliknya, divergensi terjadi ketika selisih nilai variabel semakin besar pada setiap iterasi hingga nilai akhir iterasi tercapai. Perbedaan tersebut dapat disebabkan oleh banyak faktor, tergantung pada jenis persamaan, tebakan awal, dan/atau metode penataan ulang persamaan. Gambar \ref{fig22} menunjukkan perilaku variabel jika terjadi divergensi untuk persamaan $x \cos{(x)} - 1 = 0$ yang dihasilkan  melalui kode sebagai berikut:

\nolinenumbers
\lstinputlisting[language=Python]{./kode/contoh_025.py}
\linenumbers

\begin{figure}[H]
    \centering
    \includegraphics[width=0.85\textwidth]{gambar/gambar022.png}
    \caption{Grafik berikut menunjukkan divergensi pada fungsi $x \cos{(x)} -1 = 0$.}
    \label{fig22}
\end{figure}

\section{Metode Newton-Raphson}
Metode Newton-Raphson memiliki prosedur yang sama dengan metode iterasi sederhana, namun perbedaan utama adalah pada langkah pertama pengerjaannya. Ketimbang menyusun ulang persamaan yang diberikan secara sederhana, persamaan baru harus dirumuskan dengan menggunakan persamaan yang diberikan dan turunan pertama terhadap variabel persamaan tersebut sebagai berikut:

\begin{equation}
x_{\text{baru}} = x - \frac{f(x)}{f'(x)}
    \label{eq26}
\end{equation}

Langkah pertama yang harus dilakukan guna menerapkan algoritma Newton pada persamaan \ref{eq23} adalah dengan mencari turunan pertamanya terhadap $x$:

\begin{equation}
f'(x) = \frac{d f(x)}{dx} = \frac{d [2x^2 - 5x + 3]}{dx} = 4x - 5
    \label{eq27}
\end{equation}

Kemudian dilakukan substitusi persamaan \ref{eq27} ke persamaan \ref{eq26}:

\begin{equation}
x_{\text{baru}} = x - \frac{2x^2 - 5x + 3}{4x - 5}
    \label{eq28}
\end{equation}

Penerapan dari persamaan \ref{eq28} dalam Python adalah sebagai berikut:

\nolinenumbers
\lstinputlisting[language=Python]{./kode/contoh_026.py}
\linenumbers

Luarannya adalah sebagai berikut:

\nolinenumbers
\begin{verbatim}
    Akar: 1.00000
    Jumlah iterasi: 7
\end{verbatim}
\linenumbers

Luar biasa, bukan?! Kita dapat menemukan akar persamaan \ref{eq23} hanya dalam tujuh kali iterasi. Hal ini menunjukkan efisiensi metode Newton-Raphson, karena dapat mencapai konvergensi sekitar delapan kali lebih cepat dibandingkan metode iterasi sederhana yang telah kita lakukan sebelumnya.

Keunggulan lainnya adalah hanya dengan sedikit mengubah nilai tebakan awal, kita dapat memperoleh solusi akar lainnya. Misalkan dengan mengubah nilai \verb|x = 2|, maka kita dapat memperoleh nilai $x = 1,5$ sesuai dengan solusi analitik-nya:

\nolinenumbers
\begin{verbatim}
    Akar: 1.50000
    Jumlah iterasi: 6
\end{verbatim}
\linenumbers

\section{Metode Biseksi}
Metode ini didasarkan pada fakta bahwa akar - akar suatu persamaan merupakan titik - titik, di mana kurva persamaan tersebut memotong sumbu $x$. Contohnya dapat dilihat dari representasi grafik persamaan \ref{eq23} di Gambar \ref{fig23}.

\begin{figure}[H]
    \centering
    \includegraphics[width=\textwidth]{gambar/gambar023.png}
    \caption{Representasi grafis persamaan \ref{eq23}.}
    \label{fig23}
\end{figure}

Kurva memotong sumbu $x$ pada nilai 1 dan 1,5 (ketika $y = 0$), yang merupakan akar-akar persamaan. Oleh karena itu, kita dapat membayangkan metode biseksi sebagai algoritma pencarian titik-titik ini di sepanjang sumbu $x$. Metode ini sebenarnya bertujuan untuk mencari titik di mana dua nilai $x$ memiliki nilai $y$ yang saling berkorespondensi, namun mempunyai tanda yang berbeda. Kemudian, interval antara nilai $x$ dibagi menjadi dua bagian, yang kemudian juga separuhnya dibagi dua lagi, dan seterusnya. Dengan operasi pembagian dua yang berurutan, intervalnya menjadi lebih kecil, yang mana diharapkan nilai $x_1$ dan $x_2$ mendekati akar yang sesungguhnya. Pada titik ini, $y_1$ dan $y_2$ mendekati nol. Dengan mengubah titik pencarian awal, akar-akar lainnya dapat ditentukan dengan cara yang sama (Gambar \ref{fig24}). 


\begin{figure}[H]
    \centering
    \includegraphics[width=\textwidth]{gambar/gambar024.png}
    \caption{Representasi grafis metode biseksi.}
    \label{fig24}
\end{figure}

Berikut adalah algoritma pencarian akar dari metode biseksi:
\begin{enumerate}
    \item Masukkan nilai $x$ yang berada dalam interval tebakan nilai akar.
    \item Hitung nilai $y$ sebagai korespondensinya.
    \item Periksa perbedaan tanda antara nilai - nilai $y$.
    \item Jika tanda-nya sama, maka hentikan langkah pencarian.
    \item Hitung nilai $x$ pada setengah interval.
    \item Periksa perbedaan tanda antara nilai $y$ pada separuh interval pertama.
    \item Jika tandanya berlawanan, maka $x_1$ dan $x_2$ adalah batas pada interval pertama.
    \item Jika tandanya sama, maka $x_1$ dan $x_2$ adalah batas interval kedua.
    \item Jika nilai $y$ mendekati nol, tampilkan nilai $x$ dan hentikan proses pencarian.
    \item Jika tidak, ulangi langkah 5 hingga 10.
\end{enumerate}

Untuk lebih memahami algoritma ini, ada baiknya kita langsung menerapkannya untuk menyelesaikan persamaan \ref{eq23} ke dalam bentuk kode Python sebagai berikut:

\nolinenumbers
\lstinputlisting[language=Python]{./kode/contoh_027.py}
\linenumbers

Hasilnya adalah:

\nolinenumbers
\begin{verbatim}
    Akar: 1.00000
    Jumlah biseksi: 21
\end{verbatim}
\linenumbers

Dengan mengubah interval awal menjadi $x_1 = 1,1$ dan $x_2 = 2$, kita akan mendapatkan nilai dari akar kedua:

\nolinenumbers
\begin{verbatim}
    Akar: 1.50000
    Jumlah biseksi: 21
\end{verbatim}
\linenumbers

Kode Python di atas merupakan penerapan algoritma metode biseksi yang paling sederhana, terdapat beberapa modifikasi yang perlu dilakukan untuk meningkatkan efektivitas kode tersebut. Pertama, kita dapat melakukan pendefinisian fungsi $y$ dengan menggunakan fungsi anonim \verb|lambda|:

\nolinenumbers
\begin{verbatim}
    y = lambda x: 2*x**2 - 5*x + 3     
\end{verbatim}
\linenumbers

Kedua, jika kita ingin membuat kode yang lebih fleksibel dengan fungsi input \textit{run-time}, kita dapat mengubah kode-nya agar menerima input dari pengguna. Berikut adalah modifikasi dari kode sebelumnya:

\nolinenumbers
\lstinputlisting[language=Python]{./kode/contoh_028.py}
\linenumbers

Berikut adalah contoh tampilan Python Shell, jika kita memasukkan nilai $x_1 = 1$ dan $x_2 = 1.1$ ketika menjalankan kode tersebut:

\nolinenumbers
\begin{verbatim}
    Masukkan nilai x1: 1
    Masukkan nilai x2: 1.1
    Akar: 1.00000
    Jumlah biseksi: 1
\end{verbatim}
\linenumbers

\section{Metode \textit{Regula Falsi}}
Langkah pengerjaan metode ini sangat mirip dengan metode biseksi karena memerlukan dua nilai awal $x$ yang harus mencakup lokasi akar yang diharapkan, dan memiliki tanda $y(x)$ yang berbeda. Perbedaannya terletak pada cara menghitung nilai $x$ selanjutnya. Pada metode \textit{regula falsi} ini, posisi $x_h$ merupakan titik potong sumbu $x$ dan garis yang menghubungkan dua titik palsu $(x_1, y_1)$ dan $(x_2, y_2)$, seperti terlihat pada Gambar \ref{fig25}.

\begin{figure}[H]
    \centering
    \includegraphics[width=\textwidth]{gambar/gambar025.png}
    \caption{Representasi grafis metode \textit{regula falsi}.}
    \label{fig25}
\end{figure}

Dengan menggunakan persamaan kemiringan garis lurus yang telah kita pahami semenjak SMP, hubungan antara ketiga titik dapat ditentukan sebagai berikut:

\begin{equation}
    \frac{y_2 - y_1}{x_2 - x_1} = \frac{y_2 - 0}{x_2 - x_h}
    \label{eq29}
\end{equation}

Sehingga didapatkan persamaan sebagai berikut:

\begin{equation}
    x_h = x_2 - \frac{x_2 - x_1}{y_2 - y_1} y_2
    \label{eq210}
\end{equation}

Bergantung pada tanda $y_h$, $x_h$ dalam konteks ini akan diubah menjadi $x_1$ atau $x_2$ sehingga dapat menyimpan akar yang teletak diantara interval $x_1$ dan $x_2$. Hal ini dapat dicapai dengan menjaga $x_1$ dan $x_2$ pada sisi berlawanan dari sumbu $x$. Prosedur ini berlanjut hingga nilai $y_h$ mendekati nol.

Untuk dapat lebih memahaminya secara praktis maka kita dapat mengimplementasikan kode Python untuk menyelesaikan persamaan \ref{eq23}, sebagai berikut:

\nolinenumbers
\lstinputlisting[language=Python]{./kode/contoh_029.py}
\linenumbers

Berikut adalah salah satu contoh eksekusi-nya:

\nolinenumbers
\begin{verbatim}
    Masukkan x1: 0
    Masukkan x2: 1.2
    Akar: 1.000760
    Jumlah posisi keliru selama perhitungan: 15
    Masukkan x1: .5
    Masukkan x2: 1.1
    Akar: 1.00097
    Jumlah posisi keliru selama perhitungan: 7
\end{verbatim}
\linenumbers

Kita juga dapat mengujinya dengan membalikan urutan awal masukan (\textit{input}):

\nolinenumbers
\begin{verbatim}
    Masukkan x1: 1.2
    Masukkan x2: 0
    Akar: 1.000760
    Jumlah posisi keliru selama perhitungan: 15
    Masukkan x1: 1.2
    Masukkan x2: 3
    Akar: 1.49900
    Jumlah posisi keliru selama perhitungan: 23
\end{verbatim}
\linenumbers

\section{Metode Garis Potong}
Metode garis potong (\textit{secant method}) mungkin terlihat mirip dengan metode \textit{regula falsi}, namun alih-alih mencari dua titik interval di mana akar - akar tersebut dapat ditemukan, metode ini menggunakan garis potong untuk menemukan akar - akar secara berurutan hingga mendekati aproksimasi akar - akar dari fungsi yang diberikan. Akibatnya, dua nilai awal $x$ tidak harus berada di kedua sisi dari akar yang hendak diaproksimasikan. Gambar \ref{fig26} menunjukkan cara kerja metode ini di dalam mengaproksimasi tiga dugaan akar secara berturut -turut, yakni $x_3$, $x_4$, dan $x_5$ melalui garis $AB$, $BC$, dan $DE$. 

\begin{figure}[H]
    \centering
    \includegraphics[width=\textwidth]{gambar/gambar026.png}
    \caption{Ilustrasi pencarian akar menggunakan metode garis potong.}
    \label{fig26}
\end{figure}

Berikut ini persamaan - persamaan pada tiga langkah iterasi pertama:
\begin{subequations}
    \begin{equation}
        x_3 = x_2 - \frac{x_2 - x_1}{y_2 - y_1} y_2
    \end{equation}
    \begin{equation}
        x_4 = x_3 - \frac{x_3 - x_2}{y_3 - y_2} y_3
    \end{equation}
    \begin{equation}
        x_5 = x_4 - \frac{x_4 - x_3}{y_4 - y_3}y_4
    \end{equation}
\end{subequations}

Atau secara umum dapat dinyatakan sebagai:

\begin{equation}
    x_i = x_{i-1} - \frac{x_{i-1} - x_{i-2}}{y_{i-1} - y_{i-2}}y_{i-1}
\end{equation}

Berikut contoh implementasi kode Python-nya guna menyelesaikan persamaan \ref{eq23}:

\nolinenumbers
\lstinputlisting[language=Python]{./kode/contoh_0210.py}
\linenumbers

Hasilnya:

\nolinenumbers
\begin{verbatim}
    Akar: 1.000000 
    Jumlah iterasi: 10 
\end{verbatim}
\linenumbers

Akar kedua-nya dapat kita temukan dengan memasukkan kondisi awal \verb|[2, 3]|:

\nolinenumbers
\begin{verbatim}
    Akar: 1.500000 
    Jumlah iterasi: 7
\end{verbatim}
\linenumbers

Pada contoh ini, nilai $x_1$ dan $x_2$ dibentuk menjadi tipe data \textit{list} terlebih dahulu sebelum dimasukkan ke dalam fungsi \verb|gar_tong()|. Hal ini akan banyak kalian jumpai pada bab - bab selanjutnya, dan di metode numerik secara umum. Kita akan banyak menjumpai objek - objek \textit{list} dan NumPy \textit{array} yang dilibatkan dalam proses I/O.

\section{Pencarian Akar - Akar Menggunakan SciPy}
Nampak pada bagian - bagian terdahulu, jika proses pencarian akar - akar kuadrat saja tampak sangat rumit. Pertanyaannya, bagaimana nanti dengan pencarian akar - akar fungsi yang lebih rumit lagi? Apa kita akan menghabiskan seumur hidup hanya untuk menuliskan kode untuk mencari, misalkan akar polinomial berderajat tujuh? 

Untungnya saat ini telah terdapat berbagai fungsi untuk penyesaian akar yang telah dioptimasi dan dikurasi di pustaka SciPy yang tersedia secara gratis! Jadi kita yang bukan seorang matematikawan terapan ataupun ahli komputasi numerik yang memang pekerjaannya adalah mengoptimasikan lebih lanjut algoritma - algoritma di belakang layar SciPy, dapat tinggal memanggil fungsi - fungsi pencarian akar dengan satu baris kode saja dari SciPy (mengagumkan, bukan?!)

SciPy menyediakan berbagai macam fungsi pencarian akar dalam modul pengoptimalan dan pencarian akar, yakni  \verb|scipy.optimize| untuk menyelesaikan berbagai jenis persamaan melalui metode numerik tingkat lanjut yang tidak akan kita bahas di sini (karena penyusunnya sendiri tidak mengerti sama sekali tentang itu!). Di bagian ini, mari kita selesaikan contoh yang diberikan di bagian - bagian terdahulu dengan menggunakan fungsi: \verb|newton()|, \verb|bisect()|, \verb|fsolve()| dan \verb|root()| melalui beberapa baris perintah di Python Shell sebagai berikut:

\nolinenumbers
\begin{verbatim}
    >>> from scipy.optimize import newton, bisect, fsolve, root
    >>> f = lambda x: 2*x**2-5*x + 3
    
    >>> print(newton(f, 0)) # memasukkan nilai tebakan 0 
        0.9999999999999999
    >>> print(newton(f, 3)) # memasukkan nilai tebakan 3 
        1.5000000000000004
    
    >>> print(bisect(f, 0, 1.2)) # memasukkan interval awal 0 - 1.2
        0.9999999999996361
    >>> print(bisect(f, 1.2, 4)) # memasukkan interval awal 1.2 - 4
        1.4999999999994542
    
    >>> print(fsolve(f, 2))# memasukkan tebakan awal 2
        [1.5]
    >>> print(fsolve(f, 0))# memasukkan tebakan awal 0
        [1.]
    >>> print(fsolve(f,[0, 1, 2])) # 3 tebakan awal bos!
        [1.  1.  1.5]
\end{verbatim}
\linenumbers

Pada baris terakhir, terdapat tiga tebakan awal dalam objek \textit{list}, sehingga luarannya adalah tiga elemen dalam \textit{array} yang mana merupakan akar yang diaproksimasi dari masing - masing nilai tebakan yang kita berikan.

\nolinenumbers
\begin{verbatim}
    >>> print(root(f, 0)) # tebakan 0
        message: The solution converged.
        success: True
        status: 1
        fun: [ 0.000e+00]
        x: [ 1.000e+00]
        nfev: 11
        fjac: [[-1.000e+00]]
        r: [ 1.000e+00]
        qtf: [-1.033e-10]
\end{verbatim}
\linenumbers

Fungsi \verb|root()| memberikan beberapa atribut terkait dengan proses komputasi numeriknya yang tidak begitu menarik dalam sudut pandang praktisi seperti kita. Oleh karena itu, untuk mendapatkan akar-nya saja, kita hanya perlu mengakses \textit{array} \verb|x| dari luaran tersebut:

\nolinenumbers
\begin{verbatim}
    >>> print(root(f, 0).x) # tebakan 0
        [1.]
    >>> print(root(f, 2).x) # tebakan 2
        [1.5]
    >>> print(root(f, [0,1,2]).x) # 3 nilai tebakan
        [1.  1.  1.5]
\end{verbatim}
\linenumbers

Untuk mengetahui tentang pengunaan modul optimasi dan pencarian akar di SciPy, kalian dapat berkunjung ke tautan berikut ini: \url{https://docs.scipy.org/doc/scipy/reference/optimize.html#module-scipy.optimize}.