Source code Penjumlah dan Pengurangan Matriks pada Java

Source code Penjumlah dan Pengurangan Matriks orde 3 X 3 

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package PraktikumASD;

import java.util.Scanner;

/**
 *
 * @author Nenov
 */
public class Matriks {

    private int A[][] = new int[3][3];
    private int B[][] = new int[3][3];
    private int C[][] = new int[3][3];

    public void input() {
        Scanner input = new Scanner(System.in);

        int i, j, k, m;

        System.out.println("   Matriks A");
        for (i = 0; i < 3; i++) {
            for (j = 0; j < 3; j++) {
                System.out.print("Baris " + (i + 1) + " Kolom " + (j + 1) + " : ");
                A[i][j] = input.nextInt();
            }
            System.out.println("");
        }

        System.out.println("\n    Matriks B");
        for (k = 0; k < 3; k++) {
            for (m = 0; m < 3; m++) {
                System.out.print("Baris " + (k + 1) + " Kolom " + (m + 1) + " : ");
                B[k][m] = input.nextInt();
            }
            System.out.println("");
        }
    }

    public void penjumlahan() {
        System.out.println("\nHasil Penjumlahan Matriks A dan B adalah ");

        for (int x = 0; x < 3; x++) {
            for (int y = 0; y < 3; y++) {
                C[x][y] = A[x][y] + B[x][y];
            }
        }
    }

    public void pengurangan() {
        System.out.println("\nHasil Pngurangan Matriks A dan B adalah ");

        for (int x = 0; x < 3; x++) {
            for (int y = 0; y < 3; y++) {
                C[x][y] = A[x][y] - B[x][y];
            }
        }
    }

    public void Cetak() {
        for (int x = 0; x < 3; x++) {
            for (int y = 0; y < 3; y++) {
                System.out.print(C[x][y] + "   ");
            }
            System.out.println("");
        }

    }

}
class MainMatriks{
    public static void main(String[] args) {
    Matriks a = new Matriks();
    a.input();
    a.penjumlahan();
    a.Cetak();
    a.pengurangan();
    a.Cetak();
        
    }
}

Source Code Merge Sort Pada Java

contoh source code pengurutan angka menggunakan prinsip merge sort,. kalo ada salah dalam source codenya atau komenanya,., mohon maaf ya, karena aku baru belajar,., :) :)

========================================================================


/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package PraktikumASD;

import java.util.Scanner;

/**
 *
 * @author Nenov
 */
public class MergeSort {
    
    // method untuk proses mengurutkan angka yang berada dalam array
    public void MergeSort(int angka[], int rnd, int tg) { 

        int low = rnd;
        int high = tg;
        //meriksa apakah low lebih kecil dari pada high, jika tidak maka angka telah terurut
        if (low < high) {
            int middle = (low + high) / 2;//mendapatkan indeks dari elemen yang ada di tengah 
            MergeSort(angka, low, middle);//melakukan rekrusif untuk mengurutkan sisi kiri array 
            MergeSort(angka, middle + 1, high);//melakukan rekrusif untuk  mengurutkan sisi kanan array
            int end_low = middle;
            int start_high = middle + 1;
            // proses perulangan untuk membandingkan isi array dengan isi array sebelah kananya, 
            // perulangan akan terus dilakukan selama rnd lebih kecil sama dengan end_low dan start_high kecil sama dengan dengan high
            while ((rnd <= end_low) && (start_high <= high)) { 
                if (angka[low] < angka[start_high]) {// jika isi array lebih kecil dari isi array sesudahnya atau sebelah kananya
                    low++;// maka low akan bertambah 1
                } else {  //jika isi array lebih besarkecil dari isi array sesudahnya atau sebelah kananya
                    int Temp = angka[start_high]; // temp adalah isi dari array ke start_high, start_high adalh indeks yang di peroleh dari indeks yang di tengah ditambah 1
                    for (int k = start_high - 1; k >= low; k--) {// perulangan untuk penukaran array
                        angka[k + 1] = angka[k]; //proses penukuran tempat array dari array yg sebelah kananya array saat ini menjadi array sekarang
                    }
                    angka[low] = Temp; // mengisi array dengn temp
                    low++;// low bertambah 1
                    end_low++; // end_low akan bertambah
                    start_high++;// strat_high kan bertambah 1
                }

            }
            System.out.println(" ");
            for (int i = 0; i < angka.length; i++) {//perulangan untuk menampilkan proses 
                System.out.print(angka[i] + " ");
            }
        }
    }
    // method untuk mencetak angka - angka setelah di urutkan
    public void cetak(int angka[], int pj) {
        MergeSort(angka, 0, pj - 1);//memanggil method MergeSort
        System.out.print("\n\nSetelah sorting:\n");
        for (int i = 0; i < pj; i++) {// perulangan untuk menampilkan angka yang tlah di urutkan
            System.out.print(angka[i] + "  ");
        }
        System.out.println();
    }
}


//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

class test {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("Masukan Batasan array : ");
        int max = input.nextInt();// menyimpan inputan dari user ke dalam max
        int[] angka = new int[max]; // membuat tempat array sebanyak yang di inputkan user
        System.out.println("Masukan data yang ingin di sorting : ");
        for (int i = 0; i < max; i++) { // perulangan untuk mengisi array dengan angka
            System.out.print("Data ke-" + (i + 1) + " : ");
            angka[i] = input.nextInt();// angka yang di masukan di simpan di dalam array
        }
        MergeSort sort = new MergeSort(); // membuat objek baru dari kelas MergeSort
        sort.cetak(angka, max); 

    }
}

source code avl tree di java

Alhamdulillah akhirnya selesai jga tugas ku ini, terima kasih untuk yang telah membantu aku dalam mengerjakan tugas ini.

source code di bawah ini memiliki 3 Kelas yaitu :
- Kelas AvlNode

- Kelas AvlTree

-Kelas AVLmain

maaf jika ada kesalahan komentnya atau soure codenya, karena aku baru belajar

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

/*

 * To change this template, choose Tools | Templates

 * and open the template in the editor.

 */

package PraktikumASD.AVLTree;

/**

 *

 * @author Nenov

 */

class AvlNode {

 public AvlNode left;

 public AvlNode right;

 public AvlNode parent;

 public int data;

 public int balance;

 public AvlNode(int k) {

  left = right = parent = null;

  balance = 0;

  data = k;

 }

 public String toString() {

  return "" + data;

 }

}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

/*

 * To change this template, choose Tools | Templates

 * and open the template in the editor.

 */

package PraktikumASD.AVLTree;

import java.util.ArrayList;

import java.util.Stack;

/**

 *

 * @author Nenov

 */

public class AvlTree {

    protected AvlNode root; // membuat node dari root

// method yang akan di panggil d kelas main untuk memasukan angka-angka

    public void insert(int k) { // k adalah angka yang di masukan

        // membuat node baru dari k

        AvlNode n = new AvlNode(k);

        // memanggil  method insertAVL untuk memasukan node

        insertAVL(this.root, n);

    }

    // method untuk menentukan sebuah node itu menjadi root, anak kiri, atau anak kanan

    private void insertAVL(AvlNode p, AvlNode q) {

        // Jika simpul untuk membandingkan adalah null, node adalah node yang dimasukkan. Jika akar adalah nol, node tersebut adalah adalah akar pohon.

        if (p == null) {

            this.root = q;

        } else {

            // jika perbandingan node yang dimasukan lebih kecil dari pada node yang menjadi parent maka node tersebut berada di sebelah kiri

            if (q.data < p.data) {

                if (p.left == null) { // jika node kirinya kosong 

                    p.left = q; // maka node di sebelah kiri adalah node yang di masukan

                    q.parent = p; // maka node parent dari node yang dimasukan adalah node yang sudah ada

                    // Memanggil method CheckAVL untuk mengecek kesetimbangan dari node yang di masukan sekarang

                    CheckAVL(p);

                } else { // jika node kirinya ada

                    insertAVL(p.left, q);// maka melakukan rekrusif untuk memasukan node, dengan yang bertindak sebagai parent adalah node kirinya

                }

                // jika perbandingan node yang dimasukan lebih besar dari pada node yang menjadi parent maka node tersebut berada di sebelah kanan

            } else if (q.data > p.data) {

                if (p.right == null) {// jika node kanan kosong

                    p.right = q;// maka node di sebelah kanan adalah node yang di masukan

                    q.parent = p;// maka node parent dari node yang dimasukan adalah node yang sudah ada

                    // Memanggil method CheckAVL untuk mengecek kesetimbangan dari node yang di masukan sekarang

                    CheckAVL(p);

                } else {// jika node kananya ada

                    insertAVL(p.right, q);// maka melakukan rekrusif untuk memasukan node, dengan yang bertindak sebagai parent adalah node kananya

                }

            } else { // jika node yang di masukan sudah ada di dalam pohon maka tidak dilakukan apa-apa

            }

        }

    }

    //method untuk menghitung selisih tinggi dari anak kanan dan anak kiri

    private void setBalance(AvlNode cur) {

        cur.balance = height(cur.right) - height(cur.left);

    }

    // method untuk memeriksa keseimbangan untuk setiap node dan memanggil metode yang diperlukan untuk menyeimbangkan pohon .

    private void CheckAVL(AvlNode cur) {

        setBalance(cur);// memanggil method untuk menghitung selisih tinggi antara anak kanan dan anak kiri dari node yang di berikan

        int balance = cur.balance; // pendeklarasi balance untuk menyimpan hasil dari selisih tinggi antara anak kanan dan anak kiri

        // check keseimbangan jika tinggi dari kanan dikurang tinggi dari kiri adalah -2

        if (balance == -2) {

            // jika tinggi anak kiri dari anak kiri lebih besar sama dengan dari pada  tinggi anak kanan dari anak kiri tersebut.

            if (height(cur.left.left) >= height(cur.left.right)) {

                cur = rotateRight(cur); // maka melakukan rotasi kanan berdasarkan node yang di berikan

            } else { // jika tidak

                cur = doubleRotateLeftRight(cur); // maka akan melakukan double rotasi berdasarkan node yang di berikan

            }

            // check keseimbangan jika tinggi dari kanan dikurang tinggi dari kiri adalah 2

        } else if (balance == 2) {

            // jika tinggi anak kanan dari anak kanan lebih besar sama dengan dari pada  tinggi anak kiri dari anak kanan tersebut.

            if (height(cur.right.right) >= height(cur.right.left)) {

                cur = rotateLeft(cur); // maka akan melakukan rotasi kiri berdasarkan node yang di berikan

            } else {//jika tidak

                cur = doubleRotateRightLeft(cur);// maka akan melakukan double rotasi berdasarkan node yang di berikan

            }

        }

        if (cur.parent != null) {// jika parent dari node tersebut tidak kosong

            CheckAVL(cur.parent); // maka melakukan rekrusif dengan node yang di masukan adalah parent dari node tersebut

        } else {// jika tidak

            this.root = cur; // root adalah node tersebut

        }

    }

    //method untuk rotasi kiri

    private AvlNode rotateLeft(AvlNode n) {

        AvlNode v = n.right; // membuat node baru, dan node tersebut adalah node kanan dari node yang di masukan

        v.parent = n.parent;// maka parent dari node node baru adalaha node yang di masukan

        n.right = v.left; // node kanan adalah node kiri dari node baru

        if (n.right != null) { // jika node kanan tidak kosong

            n.right.parent = n; // maka parent dari node kanan adalah node yang dimasukan

        }

        v.left = n; // node kiri dari node baru adalah node yang di masukan

        n.parent = v; // parent dari node tersebut adalah node baru

        if (v.parent != null) { // jika parent dari node baru tidak kosong

            if (v.parent.right == n) { // jika anak kanan dari parent node baru sama dengan node yang ada

                v.parent.right = v;// maka anak kanan dari parent node baru adalah node baru

            } else if (v.parent.left == n) { // jika anak kiri dari parent node baru sama dengan node yang ada

                v.parent.left = v; // maka anak kiri dari parent node baru adalah node baru

            }

        }

        return v;// mengembalikan node baru

    }

    // method untuk rotasi kanan

    private AvlNode rotateRight(AvlNode n) {

        AvlNode v = n.left;// membuat node baru, dan node tersebut adalah node kiri dari node yang di masukan

        v.parent = n.parent;// maka parent dari node node baru adalaha node yang di masukan

        n.left = v.right;// node kiri adalah node kanan dari node baru

        if (n.left != null) {// jika node kiri kosong

            n.left.parent = n; // maka parent dari node kiri adalah node yang di masukan

        }

        v.right = n;// node kanan dari node baru adalah node yang di masukan

        n.parent = v;// parent dari node tersebut adalah node baru

        if (v.parent != null) { // jika parent dari node baru tidak kosong

            if (v.parent.right == n) { // jika anak kanan dari parent node baru sama dengan node yang ada

                v.parent.right = v;// maka anak kanan dari parent node baru adalah node baru

            } else if (v.parent.left == n) { // jika anak kiri dari parent node baru sama dengan node yang ada

                v.parent.left = v; // maka anak kiri dari parent node baru adalah node baru

            }

        }

        return v;// mengembalikan node baru

    }

// method proses double rotasi

    private AvlNode doubleRotateLeftRight(AvlNode u) {

        u.left = rotateLeft(u.left);// melakukan rotasi kiri

        return rotateRight(u);// mengembalikan rotasi kanan

    }

    // method proses double rotasi

    private AvlNode doubleRotateRightLeft(AvlNode u) {

        u.right = rotateRight(u.right); // melakukan rotasi kanan

        return rotateLeft(u); // mengembalikan hasil dari rotasi kiri

    }

    // method untuk mencari tinggi atau level dari tree

    private int height(AvlNode cur) {

        if (cur == null) { // jika root tidak ad

            return -1; //maka level atau tingginya adalah -1

        }

        if (cur.left == null && cur.right == null) {// jika ada akar dan tidak mempunyai anak kanan dan kiri

            return 0; // maka level atau tingginya adalah 0

        } else if (cur.left == null) { // jika hnya memiliki anak kiri

            return 1 + height(cur.right); // maka level atau tingginya adalah 1 di tambah dengan jumlah level atau tinggi dari anak dari anak kiri tersebut

        } else if (cur.right == null) {// jika hanya memiliki anak kanan

            return 1 + height(cur.left);// maka level atau tingginya adalah 1 di tambah dengan jumlah level atau tinggi dari anak dari anak kanan tersebut

        } else {// jika punya anak kiri dan kanan

            return 1 + Math.max(height(cur.left), height(cur.right));

            // maka tingginya adalah 1 di tambah dengan nilai tertinggi antara anak kiri dan anak kanan

        }

    }

    public void displayTree() {

        Stack stack = new Stack();

        stack.push(root);

        int nBlanks = 32;

        boolean isRowEmpty = false;

        System.out.println(".............................................................");

        while (isRowEmpty == false) {

            Stack localStack = new Stack();

            isRowEmpty = true;

            for (int j = 0; j < nBlanks; j++) {

                System.out.print(' ');

            }

            while (stack.isEmpty() == false) {

                AvlNode temp = (AvlNode) stack.pop();

                if (temp != null) {

                    System.out.print(temp.data);

                    localStack.push(temp.left);

                    localStack.push(temp.right);

                    if (temp.left != null || temp.right != null) {

                        isRowEmpty = false;

                    }

                } else {

                    System.out.print("--");

                    localStack.push(null);

                    localStack.push(null);

                }

                for (int j = 0; j < (nBlanks * 2) - 2; j++) {

                    System.out.print(' ');

                }

            }

            System.out.println();

            nBlanks /= 2;

            while (localStack.isEmpty() == false) {

                stack.push(localStack.pop());

            }

        }

        System.out.println("............................................................");

    }

}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++

/*

 * To change this template, choose Tools | Templates

 * and open the template in the editor.

 */

package PraktikumASD.AVLTree;

/**

 *

 * @author Nenov

 */

public class AVLmain {

    public static void main(String[] args) {

        AvlTree Fn = new AvlTree();

        Fn.insert(35);

        Fn.insert(20);

        Fn.insert(45);

        Fn.insert(25);

        Fn.insert(18);

        Fn.insert(40);

        Fn.insert(43);

        Fn.insert(30);

        Fn.insert(10);

        Fn.insert(27);

        Fn.displayTree();

    }

}

Grafik kontinyu dan diskontinyuitas

PRINSIP KERJA PERANGKAT INPUT

PRINSIP KERJA PERANGKAT INPUT

1.    Keyboard

Keyboard merupakan unit input yang paling penting dalam suatu pengolahan data dengan komputer. Keyboard dapat berfungsi memasukkan huruf, angka, karakter khusus serta sebagai media bagi user (pengguna) untuk melakukan perintah-perintah lainnya yang diperlukan, seperti menyimpan file dan membuka file.

Sebuah keyboard seperti miniatur komputer. keyboard mempunyai prosesor sendiri dan rangkaian sirkuit yang membawa informasi menuju dan dari prosesor tersebut. Bagian terbesar dari rangkaian keyboard berupa “key matrix”

“Key matrix” adalahsebuah kisi rangkaian dibawah tombol-tombol keyboard. Di dalam keyboard, tiap rangkaiannya terputus (seperti saklar) pada titik dibawah tiap tombol. Ketika kita menekan sebuah tombol, tombol tersebut menekan sebuah saklar, menjadikan rangkaian tersambung dan mengalirkan arus listrik melaluinya. Jika kita lama pada tombol, prosesor mengenalinya sama dengan menekan tombol tersebut berulang-ulang. Ketika prosesor menemukan rangkaian tertutup (tersambung karena adanya penekanan tombol), maka prosesor akan membandingkan lokasi yang rangkaian tertutup tersebut dengan peta karakter yang tersimpan dalam ROM (read only memory) keyboard. Peta karakter pada dasar nya adalah tabel daftar karakter yaitu daftar posisi tiap-tiap tombol atau kombinasi tombol beserta karakter yang direpresentasikannya. Sebagai contoh, peta karakter memberitahu prosesor bahwa menekan tombol “a” sendirian menghasilkan huruf kecil “a”, tetapi tombol Shift bersama tombol “a” bersama-sama akan menghasilkan huruf kapital “A”

2.    Mouse optick

Salah satu perangkat input yang tidak kalah pentingnya dibanding keyboard yaitu mouse. Fungsi alat ini adalah untuk perpindahan pointer atau kursor secara cepat. Selain itu, dapat sebagai perintah praktis dan cepat dibanding dengan keyboard. Mouse adalah satu dari beberapa alat penunjuk (pointing device) yang dikembangkan untuk On Line System (NLS) milik Engelbard.  Selain mouse, yang pada mulanya disebut "bug", juga dikembangkan beberapa alat pendeteksi gerakan tubuh yang lain, misalnya alat yang diletakkan di kepala untuk mendeteksi gerakan dagu. Karena kenyamanan dan kepraktisannya, mouse-lah yang dipilih.

Mouse komputer berteknologi bola (track ball), kini sudah tergantikan dengan optik. Mouse optik  emiliki kamera beresolusi rendah yang dapat  menangkap sekitar 1500 – 6000 gambar permukaan di bawahnya. Dengan kemampuan analisanya, mouse dapat menghitung posisi, kecepatan, dan pergerakannya.Ketika mouse terhubung dengan komputer, lampu LED merah mulai bersinar. Cahayanya  fokus pada permukaan bawah mouse dengan lebih dulu melewati lensa tipe khusus (HDNS-2100).  cahaya LED terpantul kembali ke kamera  yang terintegrasi dengan Sensor Optical Mouse. Kamera mengambil gambar dari permukaan dengan frekuensi di kisaran 1500 – 6000 gambar per detik . untuk menghitung posisi mouse. Gambar-gambar ini diproses oleh Processor Digital Signal dan hasil koordinatnya dikirim ke IC A2611D melalui transmisi data serial. Kemudian, IC (A2611D) lainnya akan mengambil input serial dari sensor gambar dan tombol mouse, yang seterusnya dikonversi ke protokol USB dan mengirimkannya ke PC. Driver dari mouse yang terpasang pada computer menerima koordinat dan menghasilkan gerakan kursor yang sesuai.

3.    Joystick

program game, dalam pengoprerasian, joystick tidak memerlukan tempat yang luas. Setelah perintah mulai di terimah oleh joystick akan mengirim data yang menunjukan ID joystick (0x41 untuk joystick digital dan 0x37 untuk joystick analog red mode). Pada saat yang bersamaan dengan joystick mengirim ID mikrokontroler juga mengirim data (0x42) untuk meminta data dari joystick. Saat data (0x42) di terima maka joystick akan membalas dengan mengirim data (0x52) sebagai pemberitahuan bahwa data akan segera di kirim. Setelah itu joystick mengirim data 6X8 bit yang berisi informasi tombol mana saja yang di tekan.

4.    Scanner

Scanner   adalah  suatu  alat   elektronik  yang   fungsinya  mirip dengan mesin  fotokopi.  Mesin  fotocopy hasilnya dapat   langsung kamu  lihat  pada kertas sedangkan scanner hasilnya ditampilkan pada layar monitor komputer dahulu kemudian baru dapat  dirubah dan dimodifikasi  sehingga  tampilan dan hasilnya menjadi bagus yang kemudian dapat disimpan sebagai file text, dokumen dan gambar.

Cara Kerja Scanner

Scanner adalah alat inputan komputer dengancara kerjanya yaitu membaca gambar menggunakan sinar kemudian hasilnya dimasukkan kedalam komputer berupa gambar. Scanner merupakan perangkat yang cara kerjanya sama dengan cara kerjanya mesin fotocopy.

Ketika kamu menekan tombol mouse untuk memulai Scanning, yang terjadi adalah:

1)        Penekanan  tombol  mouse dari  komputer  menggerakkan pengendali kecepatan pada  mesin  scanner.  Mesin  yang   terletak  dalam  scanner tersebut mengendalikan proses pengiriman ke unit scanning.

2)        Kemudian unit scanning menempatkan proses pengiriman ke tempat atau jalur yang sesuai untuk langsung memulai scanning.

3)      Nyala lampu yang terlihat pada Scanner menandakan bahwa kegiatan scanning sudah mulai dilakukan.

4)        Setelah nyala lampu sudah tidak ada, berarti proses scan sudah selesai dan hasilnya dapat dilihat pada layar monitor.

5)      Apabila hasil  atau tampilan teks / gambar  ingin dirubah,  kita dapat merubahnya  dengan menggunakan   software-software   aplikasi  yan

g ada. Misalnya dengan photoshop, Adobe dan lain- lain. pot scanned.

5.    Barcode

Barcode termasuk dalam unit masukan (input device). Fungsi alat ini adalah untuk membaca suatu kode yang berbentuk kotak-kotak atau garis-garis tebal vertical yang kemudian diterjemahkan dalam bentuk angka-angka. Kode-kode ini biasanya menempel pada produk-produk makanan, minuman, alat elektronik dan buku.

Untuk memahami bagaimana barcode scanner bekerja, kita harus mengeksplorasi bagian-bagian berbeda dari perangkat itu. Pada dasarnya, ada 3 bagian fungsional dalam sebuah barcode scanner, yaitu, sistem pencahayaan, sensor / konverter, dan decoder.

Scanner barcode mulai dengan menerangi kode dengan Red Light. Sensor dari barcode scanner mendeteksi cahaya yang dipantulkan dari sistem pencahayaan dan menghasilkan sinyal analog dengan tegangan yang bervariasi yang mewakili intensitas gelombang magnetik. Konverter merubah sinyal analog ke sinyal digital yang dikirimkan ke decoder. Decoder mengimplementasikan sinyal digital, mengkoreksi dan memvalidasi dengan kalkulasi matematika, mengubahnya menjadi teks ASCII lalu mengirimkannya ke komputer.

6.    Touchpad

Touchpad atau bisa juga disebut Trackpad adalah perangkat penunjuk (pointer) yang terdiri dari permukaan khusus yang bisa menerjemahkan gerakan dan posisi jari pengguna ke posisi relatif di layar. Unit input ini adalah fitur umum dari laptop/notebook dan juga digunakan sebagai pengganti mouse komputer di space meja yang kecil.

Ada dua cara pokok bagaimana touchpad bekerja. :
a. Dalam pendekatan matriks, serangkaian konduktor diatur dalam sebuah array dari garis paralel dalam dua lapisan, dipisahkan oleh isolator dan persimpangan satu sama lain pada sudut yang tepat untuk membentuk grid. Sinyal frekuensi tinggi diberikan secara berurutan antara pasangan dalam grid array dua dimensi. Arus yang lewat di antara node sebanding dengan kapasitansi. Ketika virtual ground, seperti jari, ditempatkan di atas salah satu persimpangan antara lapisan konduktif beberapa bidang listrik dihubungsingkat ke titik ground ini, mengakibatkan perubahan kapasitansi yang besar di titik itu.

b.  Capacitive shunt method, dijelaskan dalam catatan aplikasi oleh Analog Devices, merasakan perubahan kapasitansi antara pemancar dan penerima yang ada di sisi berlawanan dari sensor. Pemancar menciptakan medan listrik yang berosilasi di 200-300 kHz. Jika titik ground, seperti jari, ditempatkan antara pemancar dan penerima,  beberapa garis medan didorong menjauh, seihingga mengurangi kapasitansi.