ADT garis

Latihan membuat instruksi pembelajaran ADT garis yang disusun dari ADT point, dengan implementasi bahasa pemrograman Rust.

ADT garis

Pembaca akan belajar membuat Abstract Data Type (ADT) garis dengan memanfaatkan modul point yang sudah ada, mengimplementasikan operasi-operasi dasar pada garis, dan menguji program melalui sebuah driver sederhana.

Tujuan Pembelajaran

Setelah mempelajari materi ini, pembaca mampu:

• Menjelaskan konsep ADT garis dan hubungannya dengan ADT point.

• Mengimplementasikan modul garis.rs yang mendefinisikan tipe data garis dan operasinya.

• Menggunakan modul garis di dalam main.rs untuk membuat dan mengelola garis.

• Menguji kasus tepi (edge cases) seperti garis dengan titik awal dan akhir yang sama.

Prasyarat

• Telah memahami konsep ADT point (tipe data point, pembuatan titik, perhitungan jarak).

• Dasar pemrograman Rust: struct, impl, pemanggilan fungsi, mod, dan use.

• Pemahaman dasar tentang slope (kemiringan) garis.

Langkah-Langkah Tugas

1. Definisikan Modul garis.rs

Kita buat struct Garis yang terdiri dari dua Point (titik awal dan titik akhir).

// garis.rs
use crate::point::Point; // memanfaatkan ADT Point

#[derive(Debug)]
pub struct Garis {
    pub p1: Point, // titik awal
    pub p2: Point, // titik akhir
}

impl Garis {
    // Membuat garis baru
    pub fn new(p1: Point, p2: Point) -> Garis {
        Garis { p1, p2 }
    }

    // Menghitung panjang garis (jarak antara p1 dan p2)
    pub fn panjang(&self) -> f64 {
        self.p1.jarak(&self.p2)
    }

    // Menghitung kemiringan garis (slope)
    pub fn kemiringan(&self) -> Option<f64> {
        let dx = self.p2.x - self.p1.x;
        let dy = self.p2.y - self.p1.y;

        if dx == 0.0 {
            None // slope tak terdefinisi (garis vertikal)
        } else {
            Some(dy / dx)
        }
    }

    // Mengecek apakah garis ini degenerate (p1 == p2)
    pub fn is_degenerate(&self) -> bool {
        self.p1.x == self.p2.x && self.p1.y == self.p2.y
    }
}

2. Buat Driver main.rs untuk Menguji

// main.rs
mod point;
mod garis;

use point::Point;
use garis::Garis;

fn main() {
    // Membuat dua titik
    let p1 = Point::new(0.0, 0.0);
    let p2 = Point::new(3.0, 4.0);

    // Membuat garis dari p1 ke p2
    let g = Garis::new(p1, p2);

    println!("Garis: {:?}", g);
    println!("Panjang garis: {}", g.panjang());

    match g.kemiringan() {
        Some(m) => println!("Kemiringan: {}", m),
        None => println!("Kemiringan tidak terdefinisi (garis vertikal)"),
    }

    println!("Apakah garis degenerate? {}", g.is_degenerate());
}

Komentar:

• Option<f64> digunakan agar kita bisa mengembalikan None jika slope tidak terdefinisi.

• Driver mencetak panjang, kemiringan, dan apakah garis tersebut degenerate.

Edge Cases yang Harus Diperhatikan

• Titik awal dan akhir sama → Panjang = 0, slope tak terdefinisi.

• Garis vertikal → slope = None.

• Garis horizontal → slope = 0.0.

• Koordinat negatif → tetap bekerja karena jarak dihitung menggunakan selisih kuadrat.

Pertanyaan Refleksi

1. Bagaimana jika kita ingin menambahkan operasi baru seperti membagi garis menjadi dua (midpoint)?
   Clue: Anda dapat membuat fungsi baru titik_tengah() yang mengembalikan Point baru di tengah p1 dan p2.

2. Mengapa kita menggunakan Option<f64> untuk kemiringan?
   Clue: Karena tidak semua garis memiliki kemiringan yang valid, misalnya garis vertikal.

3. Bagaimana jika garis dipindahkan (translasi) ke posisi baru?
   Clue: Kita dapat membuat fungsi geser(dx, dy) yang menggeser kedua titik dengan nilai tersebut.

Referensi

Materi mengenai ADT, struktur data, dan pemrograman modular diadaptasi dari:
Sekolah Teknik Elektro dan Informatika, Institut Teknologi Bandung. Materi Kuliah Struktur Data – ADT Garis.