4-logic.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Computer Logic\n",
    "\n",
    "pengkondisian sebelumnya yang sudah kita pelajari, sangat simpel. bahkan dpat dikatakan primitif. sedangkan kondisi di kondisi nyata jauh lebih kompleks.\n",
    "maka dari itu, Python harus punya operator yang berisi conjunction(and) dan disjunction (or). biasanya mereka disebut logical operator\n",
    "\n",
    "1. and\n",
    "\n",
    "ini adalah operator binary dengan prioritas lebih rendah.\n",
    "contoh penggunaan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "counter>0 and value===10"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "hasil and dapat dilihat pada truth table\n",
    "misalkan sebuah conjunction A dan B, maka kemungkinan nilainya adalah sbb:\n",
    "\n",
    "A       B       A and B\n",
    "\n",
    "False   False   False\n",
    "False   True    False\n",
    "True    False   False\n",
    "True    True    True"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. or\n",
    "\n",
    "disjunction atau or adalah operator binary dengan priority lebih rendah dari and. Berikut truth table nya:\n",
    "A       B       A or B\n",
    "False   False   False\n",
    "False   True    True\n",
    "True    False   True\n",
    "True    True    True"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. not\n",
    "\n",
    "adalah unary operator yang melakukan negasi. not mempunya prioritas yang tinggi\n",
    "\n",
    "Argument        not Argument\n",
    "False           True\n",
    "True            False"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Logical Expression\n",
    "\n",
    "menurut hukum De Morgan:\n",
    "\" negasi dari conjunction adalah disjunction dari negasinya\"\n",
    "\"negasi dari disjunction adalah conjunction dari negasinya\"\n",
    "\n",
    "atau dalam algoritma\n",
    "\n",
    "not (A and B) == not A or not B\n",
    "\n",
    "not (A or B) == not A and not B"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bitwise Operator\n",
    "\n",
    "selain itu, ada 4 operator yang mengijinkanmu utk manipulasi single bit dari data.\n",
    "\n",
    "mereka disebut xor (exclusive or) dan dinotasikan sebagai caret (^)\n",
    "\n",
    "Empat dari mereka tsb adalah:\n",
    "- & (ampersand) - bitwise conjunction\n",
    "- | (bar) - bitwise disjunction\n",
    "- ~ (tilde) - bitwise negation\n",
    "- ^ (caret) - bitwise xor\n",
    "\n",
    "A       B       A & B       A | B       A ^ B\n",
    "0       0       0           0           0\n",
    "0       1       0           1           1\n",
    "1       0       0           1           1\n",
    "1       1       1           1           1\n",
    "\n",
    "bitwise operation (~)\n",
    "\n",
    "Argumen     ~Argumen\n",
    "0           1\n",
    "1           0\n",
    "\n",
    "nb : \n",
    "- argumen dari operator harus berbentk integers, tidak boleh float\n",
    "- logical operator tidak perlu masuk ke level bit daam argumen, mereka hanya tertarik pada nilai integer akhir\n",
    "- bitwise operator lebih ketat karena mereka berhadapan dg setiap bit secara terpisah\n",
    "\n",
    "tambahan : \n",
    "kita dapat menggunakan bitwise operator utk manipulasi single bit of data seperti\n",
    "- x=15 atau 0000 1111 dalam bentuk binary\n",
    "- y=16 atau 0001 0000 dalam bentuk binary"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Logical vs Bit Operation\n",
    "\n",
    "kita misalkan sbb:\n",
    "i=15\n",
    "j=22\n",
    "\n",
    "kita asumsikan bahwa bilangan integer tsb kita simpan dalam 32 bit, maka:\n",
    "\n",
    "i: 00000000000000000000000000001111\n",
    "j: 00000000000000000000000000010110\n",
    "\n",
    "lalu assignment diberikan:\n",
    "\n",
    "log =i and j\n",
    "\n",
    "kita akan menggunakan logical conjunction. kedua variabel i dan j tidak sama dg 0, so akan dianggap mewakili True. dengan melihat truth table dari and, kita akan melihat hasilnya adalah True.\n",
    "\n",
    "log: True\n",
    "sekarang bitwise operation nya adlah:\n",
    "\n",
    "bit = i & j\n",
    "\n",
    "operator & akan mengoperasikan tiap pasangan bit secara terpisah, menghasilkan nilai bit yang relevan sbb:\n",
    "\n",
    "i                000000000000000000000000000 01111\n",
    "j                000000000000000000000000000 10110\n",
    "bit = i & j      000000000000000000000000000 00110\n",
    "\n",
    "bit sesuai dg nilai integer dari 6\n",
    "\n",
    "lalu kita lihat negasinya:\n",
    "\n",
    "logneg = not i\n",
    "\n",
    "logneg variable akan diset ke False, \n",
    "\n",
    "negasi bitwise akan menjadi sbb:\n",
    "\n",
    "bitneg = -i\n",
    "\n",
    "nilai var. bitneg adlah -16. ini sungguh aneh tetapi belum semua.\n",
    "jika kamu berharap belajar lebih, harus cek sistem angka binary dan sistemnya akan mengatur\n",
    "2 angka komplemen\n",
    "\n",
    "i\t            00000000000000000000000000001111\n",
    "bitneg = ~i\t    11111111111111111111111111110000\n",
    "\n",
    "tiap 2 argumen ini dapat ditulis dalam bentuk singkatan. berikut contoh dari notasi yang sejenis:\n",
    "\n",
    "x = x & y   -------> x &=y\n",
    "x = x | y   -------> x |=y\n",
    "x = x^y     -------> x ^=y\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 5 -5 1 1 16\n"
     ]
    }
   ],
   "source": [
    "#kuisss\n",
    "\n",
    "x = 4\n",
    "y = 1\n",
    "\n",
    "a = x & y\n",
    "b = x | y\n",
    "c = ~x  # tricky!\n",
    "d = x ^ 5\n",
    "e = x >> 2\n",
    "f = x << 2\n",
    "\n",
    "print(a, b, c, d, e, f)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.10"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}