Kelompok9_PrakPBF_Modul1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# 1. Fungsi Komposisi"
      ],
      "metadata": {
        "id": "hK_Wy3po2KJ1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Pemrograman Prosedural**"
      ],
      "metadata": {
        "id": "GaZx4-nA2b51"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "64i1vozhcFVl"
      },
      "outputs": [],
      "source": [
        "def f(x):\n",
        "    return 4 ** x\n",
        "\n",
        "def g(x):\n",
        "    return x ** x\n",
        "\n",
        "def h(x):\n",
        "    return 3 + x\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "dalam kodingan di atas kita bisa memastikan fungsi prosedural atau (Procedural Programming) yang di mana terdapat def yang menggambarkan f(x), g(x), h(x), dana 4**x sebagai 4^x, x**x sebagi x^x dan 3 + x."
      ],
      "metadata": {
        "id": "Zyj45QG5ccjU"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Pemrograman Fungsional**"
      ],
      "metadata": {
        "id": "0Rrbuihv2ocp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "f = lambda x: 4 ** x\n",
        "g = lambda x: x ** x\n",
        "h = lambda x: 3 + x\n"
      ],
      "metadata": {
        "id": "kZ50R1ZodHmD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**functional programing** (lambda fuctions):\n",
        "yang dimana menggunakan fungsi lamda untuk mempersikat suatu fungsi, dalam hal ini kita tidak perlulag menngunakan return dan dalam pengisiannya juga tergolong singkat hanya membutuhkan beberapa bari kode saja di bandinkan dengan procedural programing"
      ],
      "metadata": {
        "id": "mgufXb0ydMPm"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 2. Pemrograman Berbasis Objek"
      ],
      "metadata": {
        "id": "dI2Xf4OveAw_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class FungsiKomposisi:\n",
        "    def __init__(self):\n",
        "        pass\n",
        "\n",
        "    def f(self, x):\n",
        "        return 4 ** x\n",
        "\n",
        "    def g(self, x):\n",
        "        return x ** x\n",
        "\n",
        "    def h(self, x):\n",
        "        return 3 + x\n",
        "\n",
        "\n",
        "fungsi = FungsiKomposisi()\n",
        "print(fungsi.f(2))\n"
      ],
      "metadata": {
        "id": "LKhzkb4Qd2WQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "44a86a7b-cf9f-474c-d73c-c87b1c982225"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "16\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Kode di atas adalah implementasi dari sebuah kelas Python bernama CompositionFunctions yang memiliki tiga fungsi, yaitu f, g, dan h. Setiap fungsi tersebut memiliki parameter\n",
        "x dan mengembalikan nilai berdasarkan rumus tertentu.\n",
        "\n",
        "Deklarasi Kelas (CompositionFunctions):\n",
        "Kelas ini memiliki tiga fungsi, yaitu f, g, dan h.\n",
        "Fungsi __init__ adalah konstruktor yang\n",
        "tidak melakukan apa-apa dalam contoh ini.\n",
        "\n",
        "Fungsi f(x):\n",
        "Merupakan fungsi eksponensial, 4^x.\n",
        "Parameter x adalah input, dan fungsi mengembalikan hasil dari\n",
        "4^x.\n",
        "\n",
        "Fungsi g(x):\n",
        "Merupakan fungsi pangkat, x^x.\n",
        "Parameter x adalah input, dan fungsi mengembalikan hasil dari x^x.\n",
        "\n",
        "Fungsi h(x):\n",
        "Merupakan fungsi penjumlahan, 3+x.\n",
        "Parameter x adalah input, dan fungsi mengembalikan hasil dari 3+x.\n"
      ],
      "metadata": {
        "id": "gonMoynSegir"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 3.Analisis Komparasi soal 1 dan 2"
      ],
      "metadata": {
        "id": "7-7X-IFLfwE9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Dari permasalan soal no 1 dan 2 di dapatkan bahwasannya pada pemograman berbasis objek itu memberiakan stuktur yang lebih terorganisir dan modular, tetapi jika kita membandingkannya dengan pemograman berbasis fungsi yang lebih efisen soal penggunaan memory, maupun juga waktu yang di perlukan sedangkan perbedaan pemrograman prosedural dan fungsional adalah pemrograman prosedural cenderung lebih mudah dipahami tetapi memiliki kode yang panjang. Pemgrograman fungsional sendiri memiliki kode yang lebih ringkas tetapi cenderung lebih susah dipahami."
      ],
      "metadata": {
        "id": "YvLLsu8of9AT"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 4. Penyelesaian Luas Segitiga"
      ],
      "metadata": {
        "id": "geO-UwhhitYg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class FungsiKomposisi:\n",
        "    def __init__(self):\n",
        "        pass\n",
        "\n",
        "    def f(self, x):\n",
        "        return 4 ** x\n",
        "\n",
        "    def g(self, x):\n",
        "        return x ** x\n",
        "\n",
        "    def h(self, x):\n",
        "        return 3 + x\n",
        "\n",
        "fungsi = FungsiKomposisi()\n",
        "print(fungsi.f(2))\n"
      ],
      "metadata": {
        "id": "Dr9dTrsOfnaz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "63abfe20-46a0-490e-9cd2-7f1fb4327ace"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "16\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Deklarasi Kelas (Segitiga):\n",
        "\n",
        "Kelas ini memiliki dua atribut, yaitu alas dan tinggi.\n",
        "Fungsi __init__ adalah konstruktor yang digunakan untuk menginisialisasi objek. Dalam contoh ini, objek Segitiga akan memiliki atribut alas dan tinggi saat dibuat.\n",
        "\n",
        "Metode luas(self):\n",
        "Merupakan metode (fungsi) yang menghitung luas segitiga berdasarkan rumus\n",
        "luas =1/2 alas . tinggi.\n",
        "Metode ini menggunakan atribut alas dan tinggi yang telah diinisialisasi sebelumnya.\n",
        "\n"
      ],
      "metadata": {
        "id": "PcUPMorljIEp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "luas_segitiga = lambda alas, tinggi: 0.5 * alas * tinggi\n",
        "\n",
        "\n",
        "print(luas_segitiga(5, 8))\n"
      ],
      "metadata": {
        "id": "B8samojxjuo4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "sama seperti di atas perbedaanya adalah di pemograman berbasis fungsi yang dimana kodenya bisa lebih sedikit dan dari efisiensinya lebih cepat."
      ],
      "metadata": {
        "id": "RRjfXiVjkDSx"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 5. Penyelesaian Algoritma Metode Bisection"
      ],
      "metadata": {
        "id": "NX-TnxaFjL6D"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Pemrograman Prosedural:**"
      ],
      "metadata": {
        "id": "OKtsbMk-kTCC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def bisection(f, a, b, tol=1e-5):\n",
        "    while (b - a) / 2 > tol:\n",
        "        c = (a + b) / 2\n",
        "        if f(c) == 0:\n",
        "            return c\n",
        "        elif f(c) * f(a) < 0:\n",
        "            b = c\n",
        "        else:\n",
        "            a = c\n",
        "    return (a + b) / 2\n"
      ],
      "metadata": {
        "id": "fLKAw3MtjoLF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "B3q2uHf9lbRG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Pemrograman Fungsional:**"
      ],
      "metadata": {
        "id": "9m2P9cszkitI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def bisection_functional(f, a, b, tol=1e-5):\n",
        "    def iterate(a, b):\n",
        "        c = (a + b) / 2\n",
        "        return c if abs(f(c)) <= tol else (iterate(a, c) if f(c) * f(a) < 0 else iterate(c, b))\n",
        "\n",
        "    return iterate(a, b)\n"
      ],
      "metadata": {
        "id": "auPJN9_rkoGM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from math import log2\n",
        "def metode_bisection(f, a, b, tol):\n",
        "  x0 = a\n",
        "  x1 = b\n",
        "  while abs(x1 - x0) > tol:\n",
        "    x2 = (x0 + x1) / 2\n",
        "    if f(x0) * f(x2) < 0:\n",
        "      x0 = x2\n",
        "    else:\n",
        "      x1 = x2\n",
        "  return (x0 + x1) / 2\n",
        "\n",
        "def f(x):\n",
        "  return x - 2**x\n",
        "\n",
        "a = 0.1\n",
        "b = 0.9\n",
        "tol = 1e-5\n",
        "\n",
        "akar = metode_bisection(f, a, b, tol)\n",
        "\n",
        "print(akar)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JxU4Ovq2zrki",
        "outputId": "62df82cd-b636-4762-e171-d928fae68742"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.1000030517578125\n"
          ]
        }
      ]
    }
  ]
}