From 8ebbcf8378a1d7747f4c53f59f4bfbfe9f3972e8 Mon Sep 17 00:00:00 2001 From: arfy slowy Date: Tue, 30 Jan 2024 19:33:58 +0700 Subject: [PATCH] Develop library (#30) * Update pypi.yml * Update pypi.yml * fix: mencoba menggunakan ke branch release (#18) Signed-off-by: slowy07 * Update pypi.yml * chore: merubah branch release (#19) * fix: mencoba menggunakan ke branch release Signed-off-by: slowy07 * chore: merubah branch release merubah branch release menjadi `develop-library` dan hasil dari branch ini akan di push ke main untuk upload package ke pypi Signed-off-by: slowy07 * docs: menambahkan dokumentasi tentang branch Signed-off-by: slowy07 * docs: memperbaiki dokumentasi dari CONTRIBUTING.md Signed-off-by: slowy07 * fix: mengubah konfigurasi dari mergify Signed-off-by: slowy07 --------- Signed-off-by: slowy07 * Barometrik (#20) * fix: mencoba menggunakan ke branch release Signed-off-by: slowy07 * feat: menambahkan ketinggian barometrik menghitung ketinggian dengan menggunakan rumus barometrik, menggunakan daripada menggunakan prinsip penurunan tekanan udara dengan meningkatnya ketinggian rumus: kettingian = 44330 * [1 - (P/p0)^(1/5.255) dimana: p = tekanan yang sudah terukur p0 = tekanan udara standard pada permukaan laut (101325 Pa) Signed-off-by: slowy07 --------- Signed-off-by: slowy07 * chore: menambahakan natural language indonesia (#21) Signed-off-by: slowy07 * feat: menambahkan fungsi euler pi (#22) Signed-off-by: slowy07 * feat: upgrade dari error handling (#23) * feat: mengganti fitur dari error handling Signed-off-by: slowy07 * fix: memperbaiki dari mypy typehinting Signed-off-by: slowy07 --------- Signed-off-by: slowy07 * feat: meanambahkan fungsi fisika (#24) menambahkan beberapa fungsi dari - efek doppler - gaya sentripental Signed-off-by: slowy07 * feat: menambahkan utils.error dan fungsi sigmoid Signed-off-by: slowy07 * docs: menambahkan dokumentasi docstring (#25) Signed-off-by: slowy07 * feat: dockerize for testing OpenSeries (#28) * feat: dockerize for testing OpenSeries * [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci * fix: for named files --------- Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com> * feat: deploy to pypi (#29) Signed-off-by: slowy07 --------- Signed-off-by: slowy07 Co-authored-by: Rull <88574877+rulanugrh@users.noreply.github.com> Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com> --- .dockerignore | 8 + .github/workflows/pypi.yml | 9 +- .github/workflows/pythontesting.yml | 12 +- .mergify.yml | 1 - .pre-commit-config.yaml | 1 + CONTRIBUTING.md | 6 + Dockerfile.openseries_test | 17 ++ OpenSeries/fisika.py | 200 +++++++++++++---- OpenSeries/matematika.py | 284 +++++++++++++++++------- OpenSeries/statistika.py | 35 ++- OpenSeries/util/constant.py | 6 + OpenSeries/util/error.py | 62 ++++-- README.md | 14 +- docker.sh | 24 ++ example/fisika/efek_doppler.py | 5 + example/fisika/gaya_sentripental.py | 5 + example/fisika/tekanan_barometrik.py | 7 + example/matematika/radian_ke_derajat.py | 3 + example/matematika/sigmoid.py | 6 + pyproject.toml | 8 +- setup.py | 2 +- testing/fisika_test.py | 95 +++++++- testing/main_test.py | 10 + testing/matematika_test.py | 100 ++++++--- testing/statistika_test.py | 15 +- 25 files changed, 733 insertions(+), 202 deletions(-) create mode 100644 .dockerignore create mode 100644 Dockerfile.openseries_test create mode 100644 docker.sh create mode 100644 example/fisika/efek_doppler.py create mode 100644 example/fisika/gaya_sentripental.py create mode 100644 example/fisika/tekanan_barometrik.py create mode 100644 example/matematika/radian_ke_derajat.py create mode 100644 example/matematika/sigmoid.py diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000..47e91cb --- /dev/null +++ b/.dockerignore @@ -0,0 +1,8 @@ +.gitignore +.mergify.yml +.pre-commit-config.yaml +CONTRIBUTING.md +LICENSE +README.md +.github/* +.github \ No newline at end of file diff --git a/.github/workflows/pypi.yml b/.github/workflows/pypi.yml index 4a00bdb..acecead 100644 --- a/.github/workflows/pypi.yml +++ b/.github/workflows/pypi.yml @@ -1,8 +1,11 @@ -name: Upload Python Package +# git action yang digunakan untuk mengupload project dari github +# kemudian di upload ke pypi + +name: upload OpenSeries ke pypi on: push: - branches: [release] + branches: [main] jobs: deploy: @@ -20,6 +23,6 @@ jobs: - name: Build package run: python -m build - name: Publish package - uses: pypa/gh-action-pypi-publish@v1 + uses: pypa/gh-action-pypi-publish@release/v1 with: password: ${{ secrets.PYPI_API_TOKEN }} diff --git a/.github/workflows/pythontesting.yml b/.github/workflows/pythontesting.yml index 687ef11..8629663 100644 --- a/.github/workflows/pythontesting.yml +++ b/.github/workflows/pythontesting.yml @@ -1,10 +1,12 @@ name: openseries testing on: + # membuat unittesting untuk mengecek dari pull request dan push + # branch dari yang akan di cek adalah main dan develop-library pull_request: - branches: [main] + branches: [main, develop-library] push: - branches: [main] + branches: [main, develop-library] jobs: build: @@ -12,21 +14,27 @@ jobs: strategy: matrix: + # operasi sistem yang dijadikan sebagai environment dari testnya os: [macos-latest, windows-latest, ubuntu-latest] steps: + # check out kode dimana adalah git action + # mengecek kode daripada project - name: checkout kode uses: actions/checkout@v4 + # memanggil environment dari python - name: setting python uses: actions/setup-python@v4 + # install requirement yang sudah disedikan dari project - name: install requirement run: | python -m pip install --upgrade pip python -m pip install -r requirements.txt python -m pip install -r dev-requirements.txt + # testing kode dengan pytest - name: testing kode dengan pytest run: | pytest testing/main_test.py --verbose diff --git a/.mergify.yml b/.mergify.yml index ae398e0..96066ad 100644 --- a/.mergify.yml +++ b/.mergify.yml @@ -5,7 +5,6 @@ pull_request_rules: # ketika dikasih label 'ready-to-merge' akan dicentang - name: testing dengan label ready-to-merge conditions: - - base=main - label=ready-to-merge actions: comment: diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index f308e26..1246c29 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -35,6 +35,7 @@ repos: - --ignore-missing-imports - --non-interactive - --install-types + exclude: example additional_dependencies: [types-requests] - repo: https://github.com/pre-commit/mirrors-prettier diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index afbfd03..fa5b9fb 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -129,6 +129,12 @@ kendala atau masalah ketika melakukan pull request. Kamu juga bisa bertanya pada ``` - Lakukan _push_ ke _branch_ kamu dan kemudian _open pull request_. +> [!IMPORTANT] +> Lakukan pull request ke branch ``develop-library`` jika ingin pull request library dan ``develop`` untuk pull request ke web dari OpenSeries. + +> [!CAUTION] +> Pull request akan di close jika mengarah ke branch ``main`` atau ``web``. + **Saran pesan commit** - `feat:` untuk menambah algoritma atau tambahan lainnya; diff --git a/Dockerfile.openseries_test b/Dockerfile.openseries_test new file mode 100644 index 0000000..a0ed139 --- /dev/null +++ b/Dockerfile.openseries_test @@ -0,0 +1,17 @@ +# Import image with tag version 3.12 +FROM python:3.12.1-alpine + +# Custom workdir to save all project +WORKDIR /openseries + +# Copy all local project to inside image +COPY . . + +# Install requirement +RUN pip install -r requirements.txt + +# Install dev-requirements +RUN pip install -r dev-requirements.txt + +# Running pytest +CMD ["pytest"] diff --git a/OpenSeries/fisika.py b/OpenSeries/fisika.py index c3f3cc1..ae4c02f 100644 --- a/OpenSeries/fisika.py +++ b/OpenSeries/fisika.py @@ -2,120 +2,135 @@ from typing import Union -def kecepatan(jarak: Union[float, int], waktu: Union[float, int]) -> Union[float, str]: +def kecepatan( + jarak: Union[float, int], waktu: Union[float, int] +) -> Union[float, error.ErrorDibagiNol, error.ErrorTipeData]: """ fungsi untuk menghitung kecepatan Parameter: - jarak (float atau int): jarak tempuh - waktu (float atau int): waktu tempuh (sekon) + jarak (float atau int): jarak tempuh + waktu (float atau int): waktu tempuh (sekon) Return: - float: hasil dari jarak / waktu + float: hasil dari jarak / waktu + error.ErrorTipeData: error jika tipe data data salah + error.ErrorDibagiNol: error jika angka dibagikan dengan 0 """ # mengecek apakah variable tersebut bertipe data int atau float # jika tidak maka error - if isinstance(jarak, (float, int)) and isinstance(waktu, (float, int)): + if all(isinstance(data, (float, int)) for data in [jarak, waktu]): try: return jarak / waktu except ZeroDivisionError: # error jika hasil pembagian dibagikan dengan 0 - return error.error_dibagi_nol() + return error.ErrorDibagiNol() else: - return error.error_tipe_data(["int", "float"]) + return error.ErrorTipeData(["int", "float"]) def percepatan( kecepatan: Union[float, int], waktu: Union[float, int] -) -> Union[float, str]: +) -> Union[float, error.ErrorDibagiNol, error.ErrorTipeData]: """ fungsi untuk menghitung percepatan parameter: - kecepatan (float atau int): kecepatan (m/s) - waktu (float atau int): waktu tempuh (sekon) + kecepatan (float atau int): kecepatan (m/s) + waktu (float atau int): waktu tempuh (sekon) Return: - float: hasil dari kecepatan / waktu + float: hasil dari kecepatan / waktu + error.ErrorTipeData: error jika tipe data data salah + error.ErrorDibagiNol: jika angka dibagikan dengan 0 """ # mengecek apakah variable tersebut bertipe data int atau float # jika tidak maka error - if isinstance(kecepatan, (float, int)) and isinstance(waktu, (float, int)): + if all(isinstance(data, (float, int)) for data in [kecepatan, waktu]): try: return kecepatan / waktu except ZeroDivisionError: # error jika hasil pembagian dibagikan dengan 0 - return error.error_dibagi_nol() + return error.ErrorDibagiNol() else: - return error.error_tipe_data(["int", "float"]) + return error.ErrorTipeData(["int", "float"]) def gerak_lurus_beraturan( kecepatan_awal: float, a: float, t: float -) -> Union[float, str]: +) -> Union[float, error.ErrorTipeData]: """ fungsi untuk menghitung jarak yang ditempuh oleh benda yang bergerak lurus beraturan - parameter: + Parameter: kecepatan_awal (float): kecepatan awal (m/s) a (float): percepatan (m/s**2) t (float): waktu (s) + + Return: + float: jarak yang ditempuh oleh benda + error.ErrorTipeData: error jika tipe data salah """ # mengecek apakah variable tersebut bertipe data int atau float # jika tidak maka error - if ( - isinstance(kecepatan_awal, float) - and isinstance(a, float) - and isinstance(t, float) - ): + if all(isinstance(data, (float)) for data in [kecepatan_awal, a, t]): return kecepatan_awal * t + 0.5 * a * t**2 else: - return error.error_tipe_data(["float"]) + return error.ErrorTipeData(["float"]) def energi_kinetik( massa: Union[float, int], kecepatan: Union[int, float] -) -> Union[int, float, str]: +) -> Union[int, float, error.ErrorTipeData]: """ menghitung energi kinetik - parameter: + Parameter: massa (float): massa benda kecepatan (float atau int): kecepatan benda + + Return: + (int, float): hasil dari perhitungan energi kinetik + error.ErrorTipeData: error jika tipe data data salah """ # mengecek apakah variable tersebut bertipe data int atau float # jika tidak maka error - if isinstance(massa, (int, float)) and isinstance(kecepatan, (int, float)): + if all(isinstance(data, (float, int)) for data in [massa, kecepatan]): return 0.5 * massa * kecepatan**2 else: - return error.error_tipe_data(["int", "float"]) + return error.ErrorTipeData(["int", "float"]) def masa_jenis( massa: Union[int, float], volume: Union[int, float] -) -> Union[int, float, str]: +) -> Union[int, float, error.ErrorDibagiNol, error.ErrorTipeData]: """ menghitung masa jenis suatu benda - parameter: + Parameter: massa (float atau int): massa benda volume (float atau int): volume benda + + Return: + (int, flloat): hasil dari kalkulasi fungsi dari masa jenis + error.ErrorTipeData: error jika tipe data data salah + error.ErrorDibagiNol: error jika angka dibagikan dengan 0 """ # mengecek apakah variable tersebut bertipe data int atau float # jika tidak maka error - if isinstance(massa, (int, float)) and isinstance(volume, (int, float)): + if all(isinstance(data, (float, int)) for data in [massa, volume]): try: return massa / volume except ZeroDivisionError: # error jika hasil pembagian dibagikan dengan 0 - return error.error_dibagi_nol() + return error.ErrorDibagiNol() else: - return error.error_tipe_data(["int", "float"]) + return error.ErrorTipeData(["int", "float"]) def energi_potensial( m: Union[int, float], g: Union[int, float], h: Union[int, float] -) -> Union[float, int, str]: +) -> Union[float, int, error.ErrorTipeData]: """ menghitung energi potensial dengan rumus Ep = m * g * h @@ -123,18 +138,21 @@ def energi_potensial( m (float atau int): masa benda g (float atau int): gravitasi bumi h (float atau int): ketinggian suatu benda + + Return: + (float, int): hasil dari kalkulasi energei potensial + error.ErrorTipeData: error jika tipe data data salah """ - if ( - not isinstance(m, (float, int)) - and not isinstance(g, (float, int)) - and not isinstance(h, (float, int)) - ): - return error.error_tipe_data(["float", "int"]) + # melakukan pengecekan apakah semua parameter memiliki tipe data dari float atau int + if not all(isinstance(data, (float, int)) for data in [m, g, h]): + return error.ErrorTipeData(["float", "int"]) else: return m * g * h -def hukum_ohm(i: Union[float, int], r: Union[float, int]) -> Union[float, int, str]: +def hukum_ohm( + i: Union[float, int], r: Union[float, int] +) -> Union[float, int, error.ErrorTipeData]: """ menghitung hukum ohm dengan besar arus listrik yang mengalir melalui sebuah hantaran akan berbanding lurus dengan tengangan potensial @@ -143,10 +161,110 @@ def hukum_ohm(i: Union[float, int], r: Union[float, int]) -> Union[float, int, s Parameter: i (float atau int): kuat arus r (float atau int): hambatan (ditulis omega) + + Return: + (float, int): hasil dari kalkulasi dari hukum ohm + error.ErrorTipeData: error jika tipe data data salah """ # mengecek apakah variable tersebut bertipe data int atau float # jika tidak maka error - if not isinstance(i, (float, int)) and not isinstance(r, (float, int)): - return error.error_tipe_data(["float", "int"]) + if not all(isinstance(data, (float, int)) for data in [i, r]): + return error.ErrorTipeData(["float", "int"]) else: return i * r + + +def ketinggian_barometrik( + tekanan: float, +) -> Union[float, error.ErrorTipeData, error.Error]: + """ + fungsi untuk menghitung perkiraan ketinggian berdasarkan dari + tekanan udara yang menggunakan rumus barometrik + + Parameter: + tekanan (float): tekanan udara + + Return: + (float): hasil dari kalkulasi ketinggian barometrik + error.ErrorTipeData: error jika tipe data data salah + error.Error: jika nilai lebih tinggi dari tekanan di permukaan laut + error.Error: jika tekanan atmosfir tidak bisa negatif + """ + # mengecek apakah variable tersebut bertipe data float + # jika tidak maka error + if not isinstance(tekanan, float): + return error.ErrorTipeData(["float"]) + else: + if tekanan > 101325: + return error.Error("nilai lebih tinggi dari tekanan di permukaan laut") + if tekanan < 0: + return error.Error("tekanan atmosfir tidak bisa negatif") + else: + hasil = 44_330 * (1 - (tekanan / 101_325) ** (1 / 5.5255)) + return hasil + + +def gaya_sentripental( + massa: Union[float, int], velocity: Union[float, int], radius: Union[float, int] +) -> Union[float, int, error.Error, error.ErrorTipeData]: + """ + fungsi untuk menghitung gaya sentripental. gaya sentripental adalah gaya yang bekerja + pada benda dalam gerak lengkung arahnya menuju ke sumbu rotasi atau pusat kelengkungan + + Parameter: + massa (float): masa benda + v (float): kecepatan dari benda + radius (float): jari-jari lintasan melingkar + + Return: + (float, int): hasil dari kalkulasi nilai sentripental + error.ErrorTipeData: error jika tipe data data salah + error.Error: jika massa negatif + error.Error: jika radius negatif + """ + # mengecek apakah variable tersebut bertipe data int atau float + # jika tidak maka error + if not all(isinstance(data, (float, int)) for data in [massa, velocity, radius]): + return error.ErrorTipeData(["float", "int"]) + if massa < 0: + return error.Error("Massa tidak boleh negatif") + if radius <= 0: + return error.Error("Radius selalu angka positif") + return (massa * (velocity) ** 2) / radius + + +def efek_doppler( + org_frek: Union[float, int], + gelombang_vel: Union[float, int], + obs_vel: Union[float, int], + src_vel: Union[float, int], +) -> Union[float, error.ErrorDibagiNol, error.ErrorTipeData, error.Error]: + """ + fungsi untuk menghitung efek doppler + + Parameter: + org_frek (int atau float): frekuensi gelombang sumber diam + gelombang_vel_vel (int atau float): kecepatan gelombang dalam medium + obs_vel (int atau float): kecepatan pengamatan + src_vel (int atau float): kecepatan sumber + + Return: + (float): hasil dari kalkulasi efek doppler + error.ErrorTipeData: error jika tipe data data salah + error.Error: jika nilai doppler negatif + """ + # mengecek apakah variable tersebut bertipe data int atau float + # jika tidak maka error + if not all( + isinstance(data, (float, int)) + for data in [org_frek, gelombang_vel, obs_vel, src_vel] + ): + return error.ErrorTipeData(["int", "float"]) + if gelombang_vel == src_vel: + return error.ErrorDibagiNol() + doppler = (org_frek * (gelombang_vel + obs_vel)) / (gelombang_vel - src_vel) + if doppler <= 0: + return error.Error( + "frekuensi tidak positif, kecepatan sumber relatif lebih besar dari kecepatan gelombang dalam medium" + ) + return doppler diff --git a/OpenSeries/matematika.py b/OpenSeries/matematika.py index 2672dc3..aedec54 100644 --- a/OpenSeries/matematika.py +++ b/OpenSeries/matematika.py @@ -1,169 +1,215 @@ from OpenSeries.util import constant as constant -from OpenSeries.util import error as pesan_error +from OpenSeries.util import error as error from typing import Union, Sequence +import numpy as np import math -def radian_ke_derajat(radian: Union[float, int]) -> Union[float, str]: +def radian_ke_derajat(radian: Union[float, int]) -> Union[float, error.ErrorTipeData]: """ mengubah nilai radian ke derajat - parameter: + Parameter: radian (float atau integer): nilai radian + + Return: + (float): hasil dari kalkulasi radian ke derajat + error.ErrorTipeData: error jika tipe data salah """ + # mengecek apakah variable tersebut bertipe data int atau float + # jika tidak maka error if not isinstance(radian, (float, int)): - return pesan_error.error_tipe_data(["float", "int"]) + return error.ErrorTipeData(["float", "int"]) else: return radian * (180 / constant.pi) -def derajat_ke_radian(derajat: Union[float, int]) -> Union[float, str]: +def derajat_ke_radian(derajat: Union[float, int]) -> Union[float, error.ErrorTipeData]: """ mengubah nilai derajat ke nilai radian - parameter: + Parameter: derajat (float atau int): nilai derajat + + Return: + (float): hasil dari kalkulasi derajat ke radian + error.ErrorTipeData: error jika tipe data salah """ + # mengecek apakah variable tersebut bertipe data int atau float + # jika tidak maka error if not isinstance(derajat, (float, int)): - return pesan_error.error_tipe_data(["float", "int"]) + return error.ErrorTipeData(["float", "int"]) else: return derajat * (constant.pi / 180) -def radian_ke_gradian(radian: Union[float, int]) -> Union[float, str]: +def radian_ke_gradian(radian: Union[float, int]) -> Union[float, error.ErrorTipeData]: """ mengubah nilai radian ke gradian Parameter: radian (float atau int): nilai radian + + Return: + (float): hasil dari kalkulasi radian ke gradian + error.ErrorTipeData: error jika tipe data salah """ + # mengecek apakah variable tersebut bertipe data int atau float + # jika tidak maka error if not isinstance(radian, (float, int)): - return pesan_error.error_tipe_data(["float", "int"]) + return error.ErrorTipeData(["float", "int"]) else: return radian * (200 / constant.pi) -def gradian_ke_radian(gradian: Union[float, int]) -> Union[float, str]: +def gradian_ke_radian(gradian: Union[float, int]) -> Union[float, error.ErrorTipeData]: """ mengubah nilai gradian ke radian - parameter: + Parameter: gradian (float atau int): nilai gradian + + Return: + (float): hasil dari kalkulasi gradian ke radian + error.ErrorTipeData: error jika tipe data salah """ + # mengecek apakah variable tersebut bertipe data int atau float + # jika tidak maka error if not isinstance(gradian, (float, int)): - return pesan_error.error_tipe_data(["float", "int"]) + return error.ErrorTipeData(["float", "int"]) else: return gradian * (constant.pi / 200) -def luas_lingkaran(jari: Union[float, int]) -> Union[float, str]: +def luas_lingkaran(jari: Union[float, int]) -> Union[float, error.ErrorTipeData]: """ menghitung luas lingkaran Parameter: - jari-jari (float atau integer): jari jari yang akan dihitung + jari-jari (float atau integer): jari jari yang akan dihitung + + Return: + (float): hasil dari kalkulasi luas lingkaran + error.ErrorTipeData: error jika tipe data salah """ # mengecek apakah variable tersebut bertipe data int atau float # jika tidak maka error if isinstance(jari, (float, int)): return constant.pi * jari**2 else: - return pesan_error.error_tipe_data(["float", "int"]) + return error.ErrorTipeData(["float", "int"]) -def keliling_lingkaran(jari: Union[float, int]) -> Union[float, str]: +def keliling_lingkaran(jari: Union[float, int]) -> Union[float, error.ErrorTipeData]: """ menghitung keliling lingkaran - parameter: + Parameter: jari (float atau integer): jari-jari lingkaran + + Return: + (float): hasil dari kalkulasi keliling lingkaran """ # mengecek apakah variable tersebut bertipe data int atau float # jika tidak maka error if isinstance(jari, (float, int)): return 2 * constant.pi * jari else: - return pesan_error.error_tipe_data(["float", "int"]) + return error.ErrorTipeData(["float", "int"]) -def diameter_lingkaran(jari: Union[float, int]) -> Union[float, str]: +def diameter_lingkaran(jari: Union[float, int]) -> Union[float, error.ErrorTipeData]: """ menghitung diameter lingkaran - parameter: + Parameter: jari (float atau integer): jari-jari lingkaran + + Return: + (float): hasil dari kalkulasi diameter lingkaran + error.ErrorTipeData: error jika tipe data salah """ # mengecek apakah variable tersebut bertipe data int atau float # jika tidak maka error if isinstance(jari, (float, int)): return 2 * jari else: - return pesan_error.error_tipe_data(["float", "int"]) + return error.ErrorTipeData(["float", "int"]) def persamaan_kuadrat( a: Union[int, float], b: Union[int, float], c: Union[int, float] -) -> Union[float, int, str]: +) -> Union[float, int, error.Error, error.ErrorTipeData]: """ menghitung persamaan linear - parameter: + Parameter: a (float atau integer): nilai a b (float atau integer): nilai b c (float atau integer): nilai c - return: + Return: (float atau integer): hasil persamaan linear dari 3 bilangan a, b, dan c + error.ErrorTipeData: error jika tipe data salah + error.Error: jika memiliki nilai complex """ # mengecek apakah variable tersebut bertipe data int atau float # jika tidak maka error - if ( - isinstance(a, (int, float)) - and isinstance(b, (int, float)) - and isinstance(c, (int, float)) - ): + if all(isinstance(data, (int, float)) for data in [a, b, c]): diskriminan = b**2 - 4 * a * c if diskriminan >= 0: akar1 = (-b + math.sqrt(diskriminan)) / (2 * a) return akar1 else: - return pesan_error.error_format("Persamaan memiliki solusi complex") + return error.Error("Persamaan memiliki solusi complex") else: - return pesan_error.error_tipe_data(["float", "int"]) + return error.ErrorTipeData(["float", "int"]) -def rata_rata(nilai: Sequence[Union[int, float]]) -> Union[int, float, str]: +def rata_rata( + nilai: Sequence[Union[int, float]], +) -> Union[int, float, error.Error, error.ErrorTipeData]: """ menghitung nilai rata-rata - parameter: + Parameter: nilai (list(float atau integer)): nilai yang dihitung + + Return: + (int, float): hasil dari kalkulasi nilai rata-rata + error.ErrorTipeData: error jika tipe data error + error.Error: jika di dalam list nilai kosong """ # mengecek apakah variable tersebut bertipe data int atau float # jika tidak maka error if isinstance(nilai, list): # mengecek apakah nilai dalam list kodong if not nilai: - return pesan_error.error_format("List tidak boleh kosong") + return error.Error("List tidak boleh kosong") # membuat looping untuk memecah nilai yang terdapat pada list for cek_nilai in nilai: # mengecek nilai dalam list apakah semua tipe data berbentuk int # atau float, jika tidak error if not isinstance(cek_nilai, (int, float)): - return pesan_error.error_tipe_data(["float", "int"]) + return error.ErrorTipeData(["float", "int"]) # menghitung nilai rata-rata return sum(nilai) / len(nilai) else: - return pesan_error.error_tipe_data(["float", "int"]) + return error.ErrorTipeData(["float", "int"]) -def faktorial(nilai: int) -> Union[int, float, str]: +def faktorial(nilai: int) -> Union[int, float, error.Error, error.ErrorTipeData]: """ menghitung produk dari semua bilangan bulat positif contoh `4! = 24 = 4 x 3 x 2 x 1` - parameter: + Parameter: nilai (int): nilai yang akan di faktorial + + Return: + (int, float): hasil dari kalkulasi faktorial + error.ErrorTipeData: error jika tipe data salah + error.Error: jika nilai dimasukkan negatif """ # mengecek apakah variable tersebut bertipe data int atau float # jika tidak maka error @@ -171,42 +217,54 @@ def faktorial(nilai: int) -> Union[int, float, str]: if nilai == 0 or nilai == 1: return 1 elif nilai < 0: - return pesan_error.error_format("Tidak bisa menggunakan angka negatif") + return error.Error("Tidak bisa menggunakan angka negatif") else: - return int(nilai * faktorial(nilai - 1)) + hasil_rekursif = faktorial(nilai - 1) + if isinstance(hasil_rekursif, int): + return nilai * hasil_rekursif + else: + return hasil_rekursif else: - return pesan_error.error_tipe_data(["int"]) + return error.ErrorTipeData(["int"]) -def permutasi(nilai: int, r: int) -> Union[int, float, str]: +def permutasi(nilai: int, r: int) -> Union[int, float, error.ErrorTipeData]: """ menghitung nilai permutasi dari n objek yang diambil dari r - parameter: + Parameter: nilai (int): nilai objek r (int): jumlah objek yang diambil + + Return: + (int, float): hasil dari kalkulasi permutasi + error.ErrorTipeData: error jika tipe data salah """ # mengecek apakah variable tersebut bertipe data int atau float # jika tidak maka error if not isinstance(nilai, int) or not isinstance(r, int): - return pesan_error.error_tipe_data(["int"]) + return error.ErrorTipeData(["int"]) else: faktorial_nilai = faktorial(nilai) faktorial_nilai_r = faktorial(nilai - r) - if isinstance(faktorial_nilai, str) or isinstance(faktorial_nilai_r, str): - return pesan_error.error_tipe_data(["int"]) - else: + if isinstance(faktorial_nilai, int) and isinstance(faktorial_nilai_r, int): return faktorial_nilai / faktorial_nilai_r + else: + return error.ErrorTipeData(["int"]) -def kombinasi(nilai: int, r: int) -> Union[int, float, str]: +def kombinasi(nilai: int, r: int) -> Union[int, float, error.ErrorTipeData]: """ - menghitung nilai kombasi dari n objek yang diambil dari r + menghitung nilai kombinasi dari n objek yang diambil dari r - parameter: + Parameter: nilai (int): nilai objek r (int): jumlah objek yang diambil + + Return: + (int, float): hasil dari kalkulasi kombinasi + error.ErrorTipeData: error jika tipe data salah """ # mengecek apakah variable tersebut bertipe data int atau float # jika tidak maka error @@ -216,26 +274,31 @@ def kombinasi(nilai: int, r: int) -> Union[int, float, str]: faktorial_nilai_r = faktorial(nilai - r) if ( - isinstance(faktorial_nilai, str) - or isinstance(faktorial_r, str) - or isinstance(faktorial_nilai_r, str) + isinstance(faktorial_nilai, int) + and isinstance(faktorial_r, int) + and isinstance(faktorial_nilai_r, int) ): - return pesan_error.error_tipe_data(["int"]) - else: return faktorial_nilai / (faktorial_r * faktorial_nilai_r) + else: + return error.ErrorTipeData(["int"]) else: - return pesan_error.error_tipe_data(["int"]) + return error.ErrorTipeData(["int"]) def fpb( bilangan_pertama: Union[int, float], bilangan_kedua: Union[int, float] -) -> Union[int, float, str]: +) -> Union[int, float, error.Error, error.ErrorTipeData]: """ menghitung faktor persekutuan terbesar dari dua buah bilangan - parameter: + Parameter: bilangan_pertama (float atau integer): bilagan pertama bilangan_kedua (float atau integer): bilangan kedua + + Return: + (int, float): hasil dari kalkulasi fpb + error.ErrorTipeData: error jika tipe data salah + error.Error: jika nilai yang diberikan negatif """ # mengecek apakah variable tersebut bertipe data int atau float # jika tidak maka error @@ -243,7 +306,7 @@ def fpb( bilangan_kedua, (int, float) ): if bilangan_pertama < 0 and bilangan_kedua < 0: - return pesan_error.error_format("Angka tidak boleh negatif") + return error.Error("Angka tidak boleh negatif") else: while bilangan_kedua: bilangan_pertama, bilangan_kedua = ( @@ -252,23 +315,28 @@ def fpb( ) return abs(bilangan_pertama) else: - return pesan_error.error_tipe_data(["float", "int"]) + return error.ErrorTipeData(["float", "int"]) -def faktor_prima(n: int) -> Union[list[int], str]: +def faktor_prima(n: int) -> Union[list[int], error.Error, error.ErrorTipeData]: """ membuat fungsi untuk mengurutkan nilai faktor prima - parameter: + Parameter: n (int): rentang angka yang mau di tampilkan bilangan faktor prima + + Return: + (list[int]): hasil dari kalkulasi dari faktor prima + error.ErrorTipeData: jika tipe data yang dimasukkan salah + error.Error: jika angka diberikan nilai negatif """ # mengecek apakah variable n bertipe data integer atau float - if not isinstance(n, (int)) and not isinstance(n, (float)): + if not isinstance(n, (int)): # menampilkan pesan error jika tipe data salah - return pesan_error.error_tipe_data(["float", "int"]) + return error.ErrorTipeData(["int"]) else: if n < 0: - return pesan_error.error_format("Angka tidak boleh negatif") + return error.Error("Angka tidak boleh negatif") else: # jika desimal mengubah bilangan ke integer n = int(n) @@ -288,61 +356,117 @@ def faktor_prima(n: int) -> Union[list[int], str]: def peluang_kejadian( kejadian: Union[int, float], ukuran_sampel: Union[int, float] -) -> Union[int, float, str]: +) -> Union[int, float, error.ErrorTipeData, error.ErrorDibagiNol]: """ menghitung probabilitas dari suatu kejadian - parameter: + Parameter: kejadian (float atau integer): jumlah hasil yang menguntungkan (n(A)) ukuran sampel (float atau integer): ukurang ruang sampel (n(S)) + + Return: + (int, float): hasil dari kalkulasi peluang kejadian + error.ErrorTipeData: error jika tipe data salah + error.ErrorDibagiNol: error jika nilai dibagi dengan 0 """ # mengecek apakah variable kejadian, ukuran sampel bertipe data integer atau float if not isinstance(kejadian, (float, int)) and not isinstance( ukuran_sampel, (float, int) ): - return pesan_error.error_tipe_data(["float", "int"]) + return error.ErrorTipeData(["float", "int"]) else: try: return kejadian / ukuran_sampel except ZeroDivisionError: # menampilkan pesan error jika dibagi dengan 0 - return pesan_error.error_dibagi_nol() + return error.ErrorDibagiNol() def hitung_jumlah_deret( n: Union[float, int], a: Union[float, int], b: Union[float, int] -) -> Union[float, int, str]: +) -> Union[float, int, error.ErrorTipeData]: """ menghitung jumlah deret aritmatika - parameter: + Parameter: n (float atau integer): jumlah suku dalam deret a (float atau integer): suku pertama dalam deret b (float atau integer): selisih antara dua suku berturut-turut + + Return: + (float, int): hasil dari kalkulasi jumlah deret + error.ErrorTipeData: error jika tipe data salah """ # mengecek apakah variable n, a dan b bertipe data integer atau float - if ( - not isinstance(n, (float, int)) - and not isinstance(a, (float, int)) - and not isinstance(b, (float, int)) - ): - return pesan_error.error_tipe_data(["float", "int"]) + if all(isinstance(data, (float, int)) for data in [n, a, b]): + return error.ErrorTipeData(["float", "int"]) else: return 0.5 * n * (2 * a + (n - 1) * b) def transpose_matriks( matriks: list[list[Union[float, int]]], -) -> Union[list[list[Union[float, int]]], str]: +) -> Union[list[list[Union[float, int]]], error.ErrorTipeData]: """ fungsi untuk transpose matrix - parameter: + Parameter: matriks: list[float, int]: matriks yang akan di transpose + + Return: + (list[float atau int]): hasil dari kalkulasi transpose matriks + error.ErrorTipeData: jika error tipe data yang diberikan salah """ if not isinstance(matriks, list): - return pesan_error.error_tipe_data(["list"]) + return error.ErrorTipeData(["list"]) else: return [ [matriks[j][i] for j in range(len(matriks))] for i in range(len(matriks[0])) ] + + +def euler_pi( + n: int, +) -> Union[int, float, error.ErrorTipeData, error.Error]: + """ + menghitung fungsi dari euler pi + + Parameter: + n (int): bilangan untuk menghitung fungsi dari euler phi + + Return: + (int, float): hasil dari kalkulasi fungsi euler pi + error.ErrorTipeData: error jika tipe data salah + error.Error: jika nilai yang diberikan negatif + """ + if not isinstance(n, int): + return error.ErrorTipeData(["int"]) + elif n <= 0: + return error.Error("nilai dari bilangan tidak boleh negatif atau 0") + else: + s = float(n) + faktor_prima_n = faktor_prima(n) + if isinstance(faktor_prima_n, list): + for x in set(faktor_prima_n): + s *= (x - 1) / x + return s + else: + return faktor_prima_n + + +def sigmoid(vektor: np.ndarray) -> Union[error.ErrorTipeData, np.ndarray]: + """ + fungsi sigmoid adalah fungsi yang berbentuk huruf S. fungsi ini biasanya + digunakan untuk mengubah nilai input dari neuron menjadi nilai output yang + lebih mudah diproses oleh neuron lain + + Parameter: + vektor (np.ndarray): rentang nilai array yang ingin dimasukkan + + Return: + (np.ndarray): hasil dari kalkulasi sigmoid + error.ErrorTipeData: error jika tipe data salah + """ + if not isinstance(vektor, np.ndarray): + return error.ErrorTipeData(["numpy.narray"]) + return 1 / (1 + np.exp(-vektor)) diff --git a/OpenSeries/statistika.py b/OpenSeries/statistika.py index 38af6f7..c48fa6d 100644 --- a/OpenSeries/statistika.py +++ b/OpenSeries/statistika.py @@ -1,21 +1,29 @@ import numpy as np from typing import Union -from OpenSeries.util import error as pesan_error +from OpenSeries.util import error as error -def entropy(label: list[int], base: int) -> Union[float, int, str]: +def entropy( + label: list[int], base: int +) -> Union[float, int, error.Error, error.ErrorTipeData]: """ fungsi menghitung entropy dari suatu fitur pada suatu dataset - parameter: + Parameter: label (list (int)): label fitur yang akan di hitung entropynya + base (int): label dari entropy + + Return: + (float, int): hasil dari kalkulasi dari entropy + error.ErrorTipeData: error jika tipe data salah + error.Error: jika nilai label yang diberikan kosong """ if not isinstance(label, (list)): - return pesan_error.error_tipe_data(["list"]) + return error.ErrorTipeData(["list"]) if not label: - return pesan_error.error_format("label tidak boleh kosong") + return error.Error("label tidak boleh kosong") if not all(isinstance(cek_nilai, int) for cek_nilai in label): - return pesan_error.error_tipe_data(["int"]) + return error.ErrorTipeData(["int"]) _, count = np.unique(label, return_counts=True) probabilitas = count / len(label) probabilitas[probabilitas == 0] = 1 @@ -24,17 +32,24 @@ def entropy(label: list[int], base: int) -> Union[float, int, str]: return np.sum(abs(probabilitas * log)) -def standar_deviasi(vektor: np.ndarray) -> Union[float, str]: +def standar_deviasi( + vektor: np.ndarray, +) -> Union[float, error.Error, error.ErrorTipeData]: """ fungsi untuk mengukur penyebaran data terhadap nilai rata-ratanya - parameter: + Parameter: vektor (np.array) + + Return: + (float): hasil dari kalkulasi standar deviasi + error.ErrorTipeData: error jika tipe data salah + error.Error: jika vektor yang diberikan kosong """ if not isinstance(vektor, np.ndarray): - return pesan_error.error_tipe_data(["numpy array"]) + return error.ErrorTipeData(["numpy array"]) if len(vektor) == 0: - return pesan_error.error_format("vektor tidak boleh kosong") + return error.Error("vektor tidak boleh kosong") mean_value = np.mean(vektor) squared_diff = np.square(vektor - mean_value) diff --git a/OpenSeries/util/constant.py b/OpenSeries/util/constant.py index 6bd0760..f3e3b70 100644 --- a/OpenSeries/util/constant.py +++ b/OpenSeries/util/constant.py @@ -5,3 +5,9 @@ # bilangan euler adalah nilai konstant yang dimana nilai kira-kiranya sama dengan 2.71828 # dan dikarakterisasi dalam berbagai cara bilangan_euler: float = 2.718281828459045235360 + +# default error dari warna menggunakan kode ANSI escape +# merah +red: str = "\033[91m" +# reset kembali warna ke default +reset_warna: str = "\033[0m" diff --git a/OpenSeries/util/error.py b/OpenSeries/util/error.py index b7a6260..bb1106b 100644 --- a/OpenSeries/util/error.py +++ b/OpenSeries/util/error.py @@ -1,27 +1,61 @@ -def error_tipe_data(error_data: list[str]) -> str: +from OpenSeries.util import constant as warna + + +class ErrorTipeData(TypeError): """ - fungsi panggilan untuk menampilkan pesan error + kelas untuk mendeteksi error dari tipe data - Parameter: - error_data (list(str)): tipe data yang ingin diisi + parameter: + expected_types (list[str]): tipe data yang dimasukkan + + return: + (str): pesan error tipe data sesuai dari inputan """ - return f"Kamu memasukkan tipe data yang salah, harus {','.join(error_data)}" + + def __init__(self, expected_types: list[str]): + message = f"{warna.red}Error Tipe:{warna.reset_warna} tipe data Harus {' atau '.join(expected_types)}" + super().__init__(message) -def error_format(format_string: str) -> str: +class Error(Exception): """ - fungsi untuk menampilkan format error - sesuai keinginan dari pesan error + kelas untuk membuat kostumisasi error parameter: - format_string (str): pesan yang akan diisi + pesan (str): pesan kostum yang ingin dimasukkan """ - return "Error: " + format_string + def __init__(self, pesan: str): + message = f"{warna.red}Error:{warna.reset_warna} {pesan}" + super().__init__(message) -def error_dibagi_nol(): + +class IndeksError(IndexError): """ - fungsi panggilan untuk menampilkan pesan error - pesan error berupa `tidak bisa dibagikan dengan 0 + kelas untuk membuat error dari index jika tidak selaras dengan dimensi atau lain """ - return "Tidak bisa dibagikan dengan 0" + + def __init__(self, pesan: str): + message = f"{warna.red}Indeks Error:{warna.reset_warna} {pesan}" + super().__init__(message) + + +class ErrorValue(ValueError): + """ + kelas untuk membuat error dari index dengan throw dari ValueError + """ + + def __init__(self, pesan: str): + message = f"{warna.red}Error Value:{warna.reset_warna} {pesan}" + super().__init__(message) + + +class ErrorDibagiNol(ZeroDivisionError): + """ + kelas untuk menampilkan error yang tidak bisa dibagi dengan nol + """ + + def __init__(self): + super().__init__( + f"{warna.red}Error Dibagi Nol:{warna.reset_warna} Tidak bisa dibagi dengan nol" + ) diff --git a/README.md b/README.md index e1bf4e8..02354f7 100644 --- a/README.md +++ b/README.md @@ -5,8 +5,8 @@ ![codequality](https://img.shields.io/codacy/grade/06ba6d6d345f4c15bf8e5cc3eac19d4d?style=flat-square&logo=codacy) ![build badge](https://img.shields.io/github/actions/workflow/status/bellshade/OpenSeries/pythontesting.yml?style=flat-square&logo=github&label=Build%20(%20Linux%2C%20Windows%2C%20MacOS)) -Project Untuk Menghitung Segala Jenis Persamaan atau Rumus-Rumus yang terdapat pada bangku sekolah (SMA/SMK/Sederajat). -Project ini bertujuan untuk memudahkan siswa dalam menghitung persamaan atau problem-problem yang terdapat pada pelajaran sekolah (cheat egine untuk Sekolah). +Project Untuk Menghitung Segala Jenis Persamaan atau Rumus-Rumus yang terdapat pada bangku sekolah (SMA/SMK/Sederajat) dan jenjang yang lebih lanjut. +Project ini bertujuan untuk memudahkan siswa dalam menghitung persamaan atau problem-problem yang terdapat pada pelajaran sekolah (cheat egine untuk hitung-menghitung). **Menghitung nilai probabilitas dari suatu kejadian** @@ -33,9 +33,17 @@ Untuk Menjalankan Library ini, kamu harus Memiliki Python dengan versi: 3.11.6 h kamu bisa menginstall package `OpenSeries` via pip dengan cara ```bash -pip install git+https://github.com/bellshade/OpenSeries +pip install OpenSeriesBellshade ``` +## Docker +kamu juga bisa testing package via `docker`` dengan cara + +```bash +bash docker.sh +``` +> Note: untuk windows kalian bisa install dulu dockernya dengan panduan yang ada di [`Docker Docs`](https://docs.docker.com/desktop/install/windows-install/) + Informasi: kamu bisa melihat pada [wiki](https://github.com/bellshade/OpenSeries/wiki) atau ke [website](openseries.pages.dev/), untuk dokumentasi installasi dan pengunaan dari `OpenSeries` diff --git a/docker.sh b/docker.sh new file mode 100644 index 0000000..119e5cc --- /dev/null +++ b/docker.sh @@ -0,0 +1,24 @@ +#!/bin/bash +os_checking(){ + . /etc/os-release + case $ID in + ubuntu) sudo apt install docker docker.io + ;; + arch) sudo pacman -S docker + ;; + darwin) brew install docker + ;; + debian) sudo apt install docker docker.io + ;; + *) echo "If windows you can see the documentation" + ;; + esac +} + +running_docker() { + docker build -t openseries:1.0 -f Dockerfile.openseries_test . + docker run openseries:1.0 +} + +os_checking +running_docker \ No newline at end of file diff --git a/example/fisika/efek_doppler.py b/example/fisika/efek_doppler.py new file mode 100644 index 0000000..ebad7c3 --- /dev/null +++ b/example/fisika/efek_doppler.py @@ -0,0 +1,5 @@ +import OpenSeries.fisika as fisika + +# menghitung fungsi dari efek doppler +doppler_efek = fisika.efek_doppler(100, 330, 10) +print(doppler_efek) diff --git a/example/fisika/gaya_sentripental.py b/example/fisika/gaya_sentripental.py new file mode 100644 index 0000000..df365fa --- /dev/null +++ b/example/fisika/gaya_sentripental.py @@ -0,0 +1,5 @@ +import OpenSeries.fisika as fisika + +# menghitung gaya sentripental +hasil = round(fisika.gaya_sentripental(10, 15, 5)) +print(hasil) diff --git a/example/fisika/tekanan_barometrik.py b/example/fisika/tekanan_barometrik.py new file mode 100644 index 0000000..0d90bb2 --- /dev/null +++ b/example/fisika/tekanan_barometrik.py @@ -0,0 +1,7 @@ +import OpenSeries.fisika as fisika + +# tekanan udara +tekanan = 100_000.0 +# memanggil fungsi dari ketinggian barometrik +hasil = fisika.ketinggian_barometrik(tekanan) +print(f"tekanan: {tekanan} Pa, Ketinggian adalah: {hasil} meter") diff --git a/example/matematika/radian_ke_derajat.py b/example/matematika/radian_ke_derajat.py new file mode 100644 index 0000000..9bde155 --- /dev/null +++ b/example/matematika/radian_ke_derajat.py @@ -0,0 +1,3 @@ +import OpenSeries.matematika as matematika + +print(matematika.radian_ke_derajat(3)) diff --git a/example/matematika/sigmoid.py b/example/matematika/sigmoid.py new file mode 100644 index 0000000..1bb0592 --- /dev/null +++ b/example/matematika/sigmoid.py @@ -0,0 +1,6 @@ +import OpenSeries.matematika as matematika +import numpy as np + +# membuat fungsi sigmoid +array = np.array([-1.0, 1.0, 2.0]) +print(matematika.sigmoid(array)) diff --git a/pyproject.toml b/pyproject.toml index 2b99a7a..0e893c8 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "OpenSeriesBellshade" -version = "1.1.2" +version = "1.6.6" dynamic = [ "dependencies" ] @@ -8,8 +8,9 @@ description = "library untuk membantu temen-temen dalam perhitungan matematika" readme = "README.md" requires-python = ">=3.11.6" keywords = [ - "OpenSeries", - "openseries" + "OpenSeriesBellshade", + "openseries", + "bellshade", ] license = {text = "MIT"} authors = [ @@ -19,6 +20,7 @@ classifiers = [ "Intended Audience :: Developers", "License :: OSI Approved :: MIT License", "Natural Language :: English", + "Natural Language :: Indonesian", "Programming Language :: Python :: 3.8", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", diff --git a/setup.py b/setup.py index 381f3fd..23d76fc 100644 --- a/setup.py +++ b/setup.py @@ -21,7 +21,7 @@ # nama dari project name="OpenSeries", # versi dari project - version="1.0.0", + version="1.6.6", # deskripsi singkat dari project description="library untuk membantu temen-temen SMA/SMK/Sederajat", # deskripsi detail tentang project diff --git a/testing/fisika_test.py b/testing/fisika_test.py index 7c7a11e..5609a6a 100644 --- a/testing/fisika_test.py +++ b/testing/fisika_test.py @@ -10,17 +10,17 @@ def test_angka_valid(self): def test_dibagi_nol(self): hasil = fisika.kecepatan(150.0, 0) - self.assertEqual(hasil, error.error_dibagi_nol()) + with self.assertRaises(error.ErrorDibagiNol): + raise hasil def test_invalid_input(self): - hasil = fisika.kecepatan("12", 5.0) - self.assertIsInstance(hasil, str) - self.assertIn(error.error_tipe_data(["int", "float"]), hasil) + with self.assertRaises(error.ErrorTipeData): + raise fisika.kecepatan("12", 30) def test_kecepatan_invalid_input2(self): hasil = fisika.kecepatan("12", "50") - self.assertIsInstance(hasil, str) - self.assertIn(error.error_tipe_data(["int", "float"]), hasil) + with self.assertRaises(error.ErrorTipeData): + raise hasil class TestPercepatan(unittest.TestCase): @@ -30,12 +30,13 @@ def test_percepatan_valid(self): def test_percepatan_dibagi_nol(self): hasil = fisika.percepatan(30.0, 0) - self.assertEqual(error.error_dibagi_nol(), hasil) + with self.assertRaises(error.ErrorDibagiNol): + raise hasil def test_percepatan_nilai_tidak_valid(self): hasil = fisika.percepatan("20", 30) - self.assertIsInstance(hasil, str) - self.assertIn(error.error_tipe_data(["int", "float"]), hasil) + with self.assertRaises(error.ErrorTipeData): + raise hasil class TestGerakLurusBeraturan(unittest.TestCase): @@ -45,7 +46,8 @@ def test_valid(self): def test_invalid_int(self): hasil = fisika.gerak_lurus_beraturan(8, 1.5, 2) - self.assertEqual(hasil, error.error_tipe_data(["float"])) + with self.assertRaises(error.ErrorTipeData): + raise hasil class TestEnergiKinetik(unittest.TestCase): @@ -55,4 +57,75 @@ def test_valid_input(self): def test_invalid_input_mix_tipe_data(self): hasil = fisika.energi_kinetik("3", 4.5) - self.assertEqual(hasil, error.error_tipe_data(["int", "float"])) + with self.assertRaises(error.ErrorTipeData): + raise hasil + + +class TestKetinggianBarometrik(unittest.TestCase): + def test_valid_input_tekanan(self): + hasil = fisika.ketinggian_barometrik(101325.0) + self.assertIsInstance(hasil, float) + + def test_tekanan_lebih_besar_daripada_air(self): + hasil = fisika.ketinggian_barometrik(110000.0) + with self.assertRaises(error.Error): + raise hasil + + def test_tekanan_angka_negatif(self): + hasil = fisika.ketinggian_barometrik(-820.3) + with self.assertRaises(error.Error): + raise hasil + + def test_tekanan_tipe_data_salah(self): + hasil = fisika.ketinggian_barometrik("12") + with self.assertRaises(error.ErrorTipeData): + raise hasil + + +class TestGayaSentripental(unittest.TestCase): + def test_gaya_sentripental(self): + hasil = fisika.gaya_sentripental(10, 5, 2) + self.assertEqual(hasil, 125.0) + + def test_gaya_sentripental_error_tipe_data(self): + hasil = fisika.gaya_sentripental("12", 5, 2) + self.assertIsInstance(hasil, error.ErrorTipeData) + with self.assertRaises(error.ErrorTipeData): + raise hasil + + def test_gaya_sentripental_minus(self): + hasil = fisika.gaya_sentripental(-10, 5, 2) + self.assertIsInstance(hasil, error.Error) + with self.assertRaises(error.Error): + raise hasil + + def test_gaya_sentripental_nol(self): + hasil = fisika.gaya_sentripental(10, 5, 0) + self.assertIsInstance(hasil, error.Error) + with self.assertRaises(error.Error): + raise hasil + + +class TestEfekDoppler(unittest.TestCase): + def test_efek_doppler(self): + hasil = fisika.efek_doppler(100, 340, 20, 10) + rounding_hasil = round(hasil) + self.assertEqual(rounding_hasil, 109) + + def test_efek_doppler_invalid_tipe_data(self): + hasil = fisika.efek_doppler("12", "340", "20", 10) + self.assertIsInstance(hasil, error.ErrorTipeData) + with self.assertRaises(error.ErrorTipeData): + raise hasil + + def test_efek_doppler_dibagi_nol(self): + hasil = fisika.efek_doppler(0, 0, 0, 0) + self.assertIsInstance(hasil, error.ErrorDibagiNol) + with self.assertRaises(error.ErrorDibagiNol): + raise hasil + + def test_efek_doppler_nilai_negatif(self): + hasil = fisika.efek_doppler(-100, -340, 20, 10) + self.assertIsInstance(hasil, error.Error) + with self.assertRaises(error.Error): + raise hasil diff --git a/testing/main_test.py b/testing/main_test.py index b7fec00..8e0a59e 100644 --- a/testing/main_test.py +++ b/testing/main_test.py @@ -11,6 +11,8 @@ TestFPB, TestFaktorPrima, TestMatriksTranspose, + TestFungsiEuler, + TestSigmoid, ) from testing.fisika_test import ( @@ -18,6 +20,9 @@ TestPercepatan, TestGerakLurusBeraturan, TestEnergiKinetik, + TestKetinggianBarometrik, + TestGayaSentripental, + TestEfekDoppler, ) from testing.statistika_test import TestFungsiEntropy, TestFungiStandardDeviasi @@ -35,6 +40,8 @@ TestFPB, TestFaktorPrima, TestMatriksTranspose, + TestFungsiEuler, + TestSigmoid, ] testing_fisika: list = [ @@ -42,6 +49,9 @@ TestPercepatan, TestGerakLurusBeraturan, TestEnergiKinetik, + TestKetinggianBarometrik, + TestGayaSentripental, + TestEfekDoppler, ] testing_statistika: list = [ diff --git a/testing/matematika_test.py b/testing/matematika_test.py index faeea10..718a374 100644 --- a/testing/matematika_test.py +++ b/testing/matematika_test.py @@ -1,34 +1,31 @@ import unittest from OpenSeries import matematika as matematika from OpenSeries.util import error as error +import numpy as np class TestKonversi(unittest.TestCase): def test_radian_ke_derajat(self): self.assertAlmostEqual(matematika.radian_ke_derajat(1), 57.2957795131) self.assertAlmostEqual(matematika.radian_ke_derajat(0), 0) - self.assertEqual( - matematika.radian_ke_derajat("12"), error.error_tipe_data(["float", "int"]) - ) + with self.assertRaises(error.ErrorTipeData): + raise matematika.radian_ke_derajat("12") def test_derajat_ke_radian(self): self.assertAlmostEqual(matematika.derajat_ke_radian(180), 3.1415926535) self.assertAlmostEqual(matematika.derajat_ke_radian(0), 0) - self.assertEqual( - matematika.derajat_ke_radian("15"), error.error_tipe_data(["float", "int"]) - ) + with self.assertRaises(error.ErrorTipeData): + raise matematika.derajat_ke_radian("12") def test_radian_ke_gradian(self): self.assertAlmostEqual(matematika.radian_ke_gradian(180), 11459.1559026) - self.assertEqual( - matematika.radian_ke_gradian("128"), error.error_tipe_data(["float", "int"]) - ) + with self.assertRaises(error.ErrorTipeData): + raise matematika.radian_ke_gradian("128") def test_gradian_ke_radian(self): self.assertAlmostEqual(matematika.gradian_ke_radian(52), 0.8168140899) - self.assertEqual( - matematika.gradian_ke_radian("200"), error.error_tipe_data(["float", "int"]) - ) + with self.assertRaises(error.ErrorTipeData): + raise matematika.gradian_ke_radian("200") class TestKelilingLingkaran(unittest.TestCase): @@ -42,7 +39,8 @@ def test_tipe_data_int(self): def test_nilai_input_tidak_valid(self): hasil = matematika.keliling_lingkaran("45") - self.assertEqual(hasil, error.error_tipe_data(["float", "int"])) + with self.assertRaises(error.ErrorTipeData): + raise hasil class TestDiameterLingkaran(unittest.TestCase): @@ -56,7 +54,8 @@ def test_tipe_data_int(self): def test_nilai_input_tidak_valid(self): hasil = matematika.diameter_lingkaran("800") - self.assertEqual(hasil, error.error_tipe_data(["float", "int"])) + with self.assertRaises(error.ErrorTipeData): + raise hasil class TestPersamaanKuadrat(unittest.TestCase): @@ -70,11 +69,13 @@ def test_nilai_valid_float(self): def test_nilai_input_tidak_valid(self): hasil = matematika.persamaan_kuadrat("12", 2, 3) - self.assertEqual(hasil, error.error_tipe_data(["float", "int"])) + with self.assertRaises(error.ErrorTipeData): + raise hasil def test_nilai_complex(self): hasil = matematika.persamaan_kuadrat(1, 2, 5) - self.assertEqual(hasil, error.error_format("Persamaan memiliki solusi complex")) + with self.assertRaises(error.Error): + raise hasil class TestRataRata(unittest.TestCase): @@ -88,7 +89,8 @@ def test_nilai_valid_float(self): def test_list_kosong(self): hasil = matematika.rata_rata([]) - self.assertEqual(hasil, error.error_format("List tidak boleh kosong")) + with self.assertRaises(error.Error): + raise hasil class TestFaktorial(unittest.TestCase): @@ -102,13 +104,13 @@ def test_faktorial_nilai_int(self): def test_faktorial_nilai_float(self): hasil = matematika.faktorial(2.5) - self.assertEqual(hasil, error.error_tipe_data(["int"])) + with self.assertRaises(error.ErrorTipeData): + raise hasil def test_faktorial_nilai_negatif(self): hasil = matematika.faktorial(-20) - self.assertEqual( - hasil, error.error_format("Tidak bisa menggunakan angka negatif") - ) + with self.assertRaises(error.Error): + raise hasil class TestPermutasi(unittest.TestCase): @@ -118,11 +120,13 @@ def test_input_valid(self): def test_input_invalid_float(self): hasil = matematika.permutasi(5.2, 2.0) - self.assertEqual(hasil, error.error_tipe_data(["int"])) + with self.assertRaises(error.ErrorTipeData): + raise hasil def test_nilai_input_tidak_valid(self): hasil = matematika.permutasi("12", "14") - self.assertEqual(hasil, error.error_tipe_data(["int"])) + with self.assertRaises(error.ErrorTipeData): + raise hasil class TestKombinasi(unittest.TestCase): @@ -132,11 +136,13 @@ def test_input_valid(self): def test_input_invalid_float(self): hasil = matematika.kombinasi(5.2, 2.0) - self.assertEqual(hasil, error.error_tipe_data(["int"])) + with self.assertRaises(error.ErrorTipeData): + raise hasil def test_nilai_input_tidak_valid(self): hasil = matematika.kombinasi("12", "14") - self.assertEqual(hasil, error.error_tipe_data(["int"])) + with self.assertRaises(error.ErrorTipeData): + raise hasil class TestFPB(unittest.TestCase): @@ -150,7 +156,8 @@ def test_invalid_input(self): def test_angka_invalid(self): hasil = matematika.fpb(-36, -40) - self.assertEqual(hasil, error.error_format("Angka tidak boleh negatif")) + with self.assertRaises(error.Error): + raise hasil def test_angka_nol(self): hasil = matematika.fpb(0, 48) @@ -164,7 +171,8 @@ def test_input_valid(self): def test_input_float(self): hasil = matematika.faktor_prima(25.0) - self.assertEqual(hasil, [5, 5]) + with self.assertRaises(error.ErrorTipeData): + raise hasil def test_faktor_prima_kosong(self): hasil = matematika.faktor_prima(1) @@ -172,7 +180,8 @@ def test_faktor_prima_kosong(self): def test_input_negatif(self): hasil = matematika.faktor_prima(-30) - self.assertEqual(hasil, error.error_format("Angka tidak boleh negatif")) + with self.assertRaises(error.Error): + raise hasil class TestMatriksTranspose(unittest.TestCase): @@ -181,3 +190,38 @@ def test_valid_input(self): ekspetasi = [[1, 4, 7], [2, 5, 8], [3, 6, 9]] hasil = matematika.transpose_matriks(matriks_a) self.assertEqual(hasil, ekspetasi) + + +class TestFungsiEuler(unittest.TestCase): + def test_nilai_positif(self): + hasil = matematika.euler_pi(100) + self.assertEqual(hasil, 40.0) + + def test_nilai_tidak_integer(self): + hasil = matematika.euler_pi(3.14) + with self.assertRaises(error.ErrorTipeData): + raise hasil + + def test_nilai_negatif(self): + hasil = matematika.euler_pi(-20) + with self.assertRaises(error.Error): + raise hasil + + def test_nilai_nol(self): + hasil = matematika.euler_pi(0) + with self.assertRaises(error.Error): + raise hasil + + +class TestSigmoid(unittest.TestCase): + def test_sigmoid(self): + input_nilai_array = np.array([1, 2, 3]) + hasil = matematika.sigmoid(input_nilai_array) + nilai_ekspetasi = np.array([0.73105858, 0.88079708, 0.95257413]) + np.testing.assert_allclose(hasil, nilai_ekspetasi, rtol=1e-7) + + def test_invalid_input(self): + hasil = matematika.sigmoid(5) + self.assertIsInstance(hasil, error.ErrorTipeData) + with self.assertRaises(error.ErrorTipeData): + raise hasil diff --git a/testing/statistika_test.py b/testing/statistika_test.py index 9fba2b9..243e803 100644 --- a/testing/statistika_test.py +++ b/testing/statistika_test.py @@ -13,17 +13,20 @@ def test_entropy_dengan_none(self): def test_nilai_kosong(self): label = [] hasil = statistika.entropy(label, base=2) - self.assertEqual(hasil, pesan_error.error_format("label tidak boleh kosong")) + with self.assertRaises(pesan_error.Error): + raise hasil def test_nilai_element_dalam_label(self): label = [1, 2, "3", 4] hasil = statistika.entropy(label, base=2) - self.assertEqual(hasil, pesan_error.error_tipe_data(["int"])) + with self.assertRaises(pesan_error.ErrorTipeData): + raise hasil def test_tipe_data_tuple(self): label = (1, 2, 3) hasil = statistika.entropy(label, base=2) - self.assertEqual(hasil, pesan_error.error_tipe_data(["list"])) + with self.assertRaises(pesan_error.ErrorTipeData): + raise hasil class TestFungiStandardDeviasi(unittest.TestCase): @@ -35,9 +38,11 @@ def test_standard_deviasi_dengan_numpy_array(self): def test_standard_deviasi_dengan_list(self): vektor = [1, 2, 3, 4, 5] hasil = statistika.standar_deviasi(vektor) - self.assertEqual(hasil, pesan_error.error_tipe_data(["numpy array"])) + with self.assertRaises(pesan_error.ErrorTipeData): + raise hasil def test_standard_deviasi_dengan_numpy_kosong(self): vektor = np.array([]) hasil = statistika.standar_deviasi(vektor) - self.assertEqual(hasil, pesan_error.error_format("vektor tidak boleh kosong")) + with self.assertRaises(pesan_error.Error): + raise hasil