diff --git a/OpenSeries/bilangan_istimewa.py b/OpenSeries/bilangan_istimewa.py
index 779a047..b6ba426 100644
--- a/OpenSeries/bilangan_istimewa.py
+++ b/OpenSeries/bilangan_istimewa.py
@@ -1,5 +1,6 @@
 import OpenSeries.util.error as error
 from typing import Union
+import numpy as np
 
 
 def angka_armstrong(angka: int) -> Union[str, error.ErrorTipeData]:
@@ -115,3 +116,147 @@ def angka_segitiga(angka: int) -> Union[int, error.ErrorTipeData, error.Error]:
     if angka < 0:
         return error.Error("angka tidak boleh negatif")
     return angka * (angka + 1) // 2
+
+
+def angka_polindrom(angka: int) -> Union[str, error.ErrorTipeData, error.Error]:
+    """
+    angka polindrom adalah angka yang jika di balik akan memiliki bentuk yang sama
+
+    Parameter:
+        angak(int): angka yang di masukkan
+
+    Return:
+        str : mengembalika informasi angka polindorm
+        error.ErrorTipeData : error jika tipe data salah
+        error.Error : jika angka yang dimasukkan negatif
+    """
+    benar, bukan = "angka polindrom", "bukan angka polindrom"
+    if isinstance(angka, (int)):
+        sisa = 0
+        digit_angka = abs(angka)
+        while digit_angka != 0:
+            sisa = (sisa * 10) + (digit_angka % 10)
+            digit_angka = digit_angka // 10
+        if sisa == abs(angka):
+            return benar.capitalize()
+        return bukan.capitalize()
+    if angka < 0:
+        return error.Error("angka tidak boleh negatif")
+    else:
+        return error.ErrorTipeData(["int"])
+
+
+def angka_prima(angka: int) -> Union[str, error.ErrorTipeData, error.Error]:
+    """
+    Angka Prima adalah angka yang habis di bagi oleh satu dan
+    dirinya sendiri
+
+    Parameter :
+        angka(int) = angka yang akan di cek
+
+    Return:
+        str : mengembalikan informasi angka prima
+        error.ErrorTipeData : error jika tipe data salah
+        error.Error : error jika nilai negatif
+    """
+    benar, bukan = "angka prima", "bukan angka prima"
+    if not isinstance(angka, int):
+        return error.ErrorTipeData(["int"])
+    if angka < 0:
+        return error.Error("angka tidak boleh negatif")
+    else:
+        if angka < 2:
+            return bukan.capitalize()
+
+        print_sieve = [True] * (angka + 1)
+        print_sieve[0] = print_sieve[1] = False
+        for x in range(2, int(np.sqrt(angka)) + 1):
+            if print_sieve[x]:
+                for k in range(x * x, angka + 1, x):
+                    print_sieve[k] = False
+        if print_sieve[angka]:
+            return benar.capitalize()
+        else:
+            return bukan.capitalize()
+
+
+def angka_kaprekar(angka: int) -> Union[str, error.ErrorTipeData, error.Error]:
+    """
+    angka kaprekar adalah angka yang bukan negatif,lalu di kuadratkan dan
+    angka dibagi menjadi dua bagian lalu di jumlahkan adalah bilangan asli itu
+    sendiri.
+    99 = (99)^2 = 9801 = 98+01 = 99
+    55 = (55)^2 = 3025 = 30+25 = 55
+    45 = (45)^2 = 2025 = 20+25 = 45
+    9 = 9^2 = 81 = 8+1 = 9
+    Parameter:
+        angka(int) : angka yang akan di cek
+
+    Return:
+        str : mengembalikan informasi angka kaprekar
+        error.ErrorTipeData = error jika tipe data tidak sesuai
+        error.Error = error jika angka negatif
+    """
+    benar, bukan = "angka kaprekar", "bukan angka kaprekar"
+    if not isinstance(angka, int):
+        return error.ErrorTipeData(["int"])
+    if angka < 0:
+        return error.Error("Angka tidak boleh negatif")
+    else:
+        if angka == 1:
+            return benar.capitalize()
+        sq_angka = angka * angka
+        cout_digit = 0
+        while sq_angka != 0:
+            cout_digit = cout_digit + 1
+            sq_angka = sq_angka // 10
+        sq_n = angka * angka
+        r_digits = 0
+        while r_digits < cout_digit:
+            r_digits = r_digits + 1
+            eq_parts = int(np.pow(10, r_digits))
+            sum = sq_n // eq_parts + sq_n % eq_parts
+            if sum == angka:
+                return benar.capitalize()
+        return bukan.capitalize()
+
+
+def angka_tetrahedral(angka: int) -> Union[int, error.ErrorTipeData, error.Error]:
+    """
+    Angka tetrahedral adalah angka yang dapat disusun sebagai piramid
+    dengan dasar segitiga dan tiga sisi.
+
+    Parameter :
+        angka(int) : Angka yang akan dikalkulasi
+    Return :
+        int : Hasil kalkulasi angka tetrahedral
+        error.ErrorTipeData : error jika tipe data tidak sesuai
+        error.Error : error jika nilai negatif
+    """
+    if not isinstance(angka, int):
+        return error.ErrorTipeData(["int"])
+    if angka < 0:
+        return error.Error("angka tidak boleh negatif")
+    else:
+        return (angka * (angka + 1) * (angka + 2)) // 6
+
+
+def angka_pentatope(angka: int) -> Union[int, error.Error, error.ErrorTipeData]:
+    """
+    Angka Pentatope adalah angka yang menghitung jumlah titik yang bisa
+    di bentuk piramida dalam skala 4 dimensi
+
+    Parameter :
+        angka(int) : angka yang akan dikalkulasi
+
+        Return :
+        int : Hasil kalkulasi angka pentatope
+        error.ErrorTipeData : error jika tipe data tidak sesuai
+        error.Error : error jika nilai negatif
+    """
+    if not isinstance(angka, int):
+        return error.ErrorTipeData(["int"])
+    if angka < 0:
+        return error.Error("Angka tidak boleh negatif")
+    else:
+        return (angka * (angka + 1) * (angka + 2) * (angka + 3)) // 24
diff --git a/OpenSeries/fisika.py b/OpenSeries/fisika.py
index ae4c02f..f14b121 100644
--- a/OpenSeries/fisika.py
+++ b/OpenSeries/fisika.py
@@ -112,7 +112,7 @@ def masa_jenis(
         volume (float atau int): volume benda
 
     Return:
-        (int, flloat): hasil dari kalkulasi fungsi dari masa jenis
+        (int, float): hasil dari kalkulasi fungsi dari masa jenis
         error.ErrorTipeData: error jika tipe data data salah
         error.ErrorDibagiNol: error jika angka dibagikan dengan 0
     """
@@ -128,6 +128,164 @@ def masa_jenis(
         return error.ErrorTipeData(["int", "float"])
 
 
+def kecepatan_sudut(
+    sudut: Union[int, float], time: Union[int, float]
+) -> Union[int, float, error.ErrorTipeData, error.ErrorDibagiNol]:
+    """
+    Menghitung kecepatan sudut
+
+    Parameter:
+        sudut (float atau int): sudut tempuh benda
+        time (float atau int): waktu tempuh benda
+
+    Return:
+        (int,float): hasil dari kalkulasi fungsi kecepatan sudut
+        error.ErrorTipeData : error jika tipe data salah
+        error.ErrorDibagiNol: error jika angka dibagikan dengan 0
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if all(isinstance(data, (float, int)) for data in [sudut, time]):
+        try:
+            return sudut / time
+        except ZeroDivisionError:
+            return error.ErrorDibagiNol()
+    else:
+        return error.ErrorTipeData(["int", "float"])
+
+
+def percepatan_sudut(
+    w_sudut: Union[int, float], time: Union[int, float]
+) -> Union[int, float, error.ErrorTipeData, error.ErrorDibagiNol]:
+    """
+    Menghitung percepatan sudut
+
+    Parameter:
+        w_sudut (int atau float) : kecepatan sudut
+        time    (int atau float) : waktu
+
+    Return:
+        (int,float): hasil dari kalkulasi fungsi percepatan sudut
+        error.ErrorTipeData : error jika tipe data salah
+        error.DibagiNol : error jika angka dibagikan dengan 0
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if all(isinstance(data, (float, int)) for data in [w_sudut, time]):
+        try:
+            return w_sudut / time
+        except ZeroDivisionError:
+            return error.ErrorDibagiNol()
+    else:
+        return error.ErrorTipeData(["int", "float"])
+
+
+def percepatan_sentripetal_linear(
+    kecepatan: Union[int, float], jari_jari: Union[int, float]
+) -> Union[int, float, error.ErrorTipeData, error.ErrorDibagiNol]:
+    """
+    Menghitung percepatan sentripetal linear
+
+    Parameter :
+        kecepatan (int,float) : kecepatan
+        jari_jari (int,float) : jari-jari lintasan
+    Return :
+        (int,float) : hasil kalkulasi percepatan sentripetal linear
+        error.ErrorTipeData : error jika tipe data salah
+        error.ErrorDibagiNol : error jika dibagi dengan nol
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if all(isinstance(data, (float, int)) for data in [kecepatan, jari_jari]):
+        try:
+            return kecepatan**2 / jari_jari
+        except ZeroDivisionError:
+            return error.ErrorDibagiNol()
+    else:
+        return error.ErrorTipeData(["int", "float"])
+
+
+def percepatan_sentripetal_sudut(
+    jari_jari: Union[int, float], kecepatan_sudut: Union[int, float]
+) -> Union[int, float, error.ErrorTipeData]:
+    """
+    Menghitung percepatan sentripetal sudut
+
+    Parameter :
+        kecepatan_sudut (int,float) : kecepatan sudut
+        jari_jari (int,float) : jari-jari lintasan
+    Return :
+        (int,float) : hasil kalkulasi percepatan sentripetal sudut
+        error.ErrorTipeData : error jika tipe data salah
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if all(isinstance(data, (int, float)) for data in [kecepatan_sudut, jari_jari]):
+        return jari_jari * (kecepatan_sudut**2)
+    else:
+        return error.ErrorTipeData(["int", "float"])
+
+
+def gerak_melingkar_beraturan(
+    w_awal: Union[int, float], a_sudut: Union[int, float], t: Union[int, float]
+) -> Union[int, float, error.Error, error.ErrorTipeData]:
+    """
+    menghitung hasil dari gerak melingkar beraturan
+
+    Parameter:
+        w_awal (float atau int) : kecepatan sudut awal
+        a_sudur (float atau int): percepatan sudut
+    Return:
+        (int atau float) : hasil kalkulasi dari gerak melingkar beraturan
+        error.ErrorTipeData : error jika tipe data salah
+        error.Errorvalue : error jika waktu kurang dari 0
+    """
+    if all(isinstance(data, (int, float)) for data in [w_awal, a_sudut, t]):
+        return w_awal + a_sudut * t
+    else:
+        return error.ErrorTipeData(["Tipe data tidak sesuai"])
+
+
+def inersia(
+    m: Union[float, int], r: Union[float, int]
+) -> Union[float, int, error.Error, error.ErrorTipeData]:
+    """
+    Menghitung inersia dari suatu benda
+
+    Parameter:
+        m (float atau int): massa benda
+        r (float atau int): jari-jari
+
+    Return:
+        (int atau float) : hasil dari kalkulasi fungsi inersia
+        error.ErrorValue : error jika massa kurang dari 0
+        error.ErrorTipeData : error jika tipe data salah
+    """
+    if all(isinstance(data, (float, int)) for data in [m, r]):
+        return m * (r**2)
+    else:
+        return error.ErrorTipeData(["int", "float"])
+
+
+def energi_kinetik_rotasi(
+    inersia: Union[float, int], kecepatan_sudut: Union[int, float]
+) -> Union[int, float, error.ErrorTipeData]:
+    """
+    menghitung energi kinetik rotasi
+
+    Parameter:
+        inersia (float atau int): inersia benda
+        kecepatan_sudut (float atau int): kecepatan benda
+    Return:
+        (int atau float) : hasil kalkulasi dari energi kinetik rotasi
+        error.ErrorTipeData : error jika tipe data salah
+    """
+    if all(isinstance(data, (float, int)) for data in [inersia, kecepatan_sudut]):
+        return (1 / 2) * inersia * (kecepatan_sudut**2)
+    else:
+        return error.ErrorTipeData(["int", "float"])
+
+
 def energi_potensial(
     m: Union[int, float], g: Union[int, float], h: Union[int, float]
 ) -> Union[float, int, error.ErrorTipeData]:
@@ -268,3 +426,239 @@ def efek_doppler(
             "frekuensi tidak positif, kecepatan sumber relatif lebih besar dari kecepatan gelombang dalam medium"
         )
     return doppler
+
+
+def celcius_farenheit(celcius: Union[int, float]) -> Union[float, int]:
+    """
+    mengubah nilai celcius ke farenheit
+
+    Paramieter:
+        celcius (float atau int): nilai celcius
+
+    Return:
+        (float atau int): hasil dari kalkulasi celcius ke farenheit
+        error.ErrorTipeData: error jika tipe data salah
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if not isinstance(celcius, (float, int)):
+        return error.ErrorTipeData(["float", "int"])
+    else:
+        return celcius * (9 / 5) + 32
+
+
+def farenheit_celcius(farenheit: Union[int, float]) -> Union[int, float]:
+    """
+    mengubah nilai farenheit ke celcius
+
+    Parameter:
+        farenheit(int atau float): nilai farenheit
+
+    Return:
+        (float atau int): hasil dari kalkulasi farenheit ke celcius
+        errot.ErrorTiperData: error jika data salah
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if not isinstance(farenheit, (float, int)):
+        return error.ErrorTipeData(["float", "int"])
+    else:
+        return (farenheit - 32) * (5 / 9)
+
+
+def celcius_reaumur(celcius: Union[int, float]) -> Union[int, float]:
+    """
+    mengubah nilai celcius ke reaumur
+
+    Parameter:
+        celcius(int atau float): nilai celcius
+
+    Return:
+        (float atau int): hasil dari kalkulasi celcius ke reaumur
+        errot.ErrorTiperData: error jika data salah
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if not isinstance(celcius, (float, int)):
+        return error.ErrorTipeData(["float", "int"])
+    else:
+        return celcius * (4 / 5)
+
+
+def reamur_celcius(reamur: Union[int, float]) -> Union[int, float]:
+    """
+    mengubah nilai reamur ke celcius
+
+    Parameter:
+        reamur(int atau float): nilai reamur
+
+    Return:
+        (float atau int): hasil dari kalkulasi celcius ke reamur
+        errot.ErrorTiperData: error jika data salah
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if not isinstance(reamur, (float, int)):
+        return error.ErrorTipeData(["float", "int"])
+    else:
+        return reamur * (5 / 4)
+
+
+def celcius_kelvin(celcius: Union[int, float]) -> Union[int, float]:
+    """
+    mengubah nilai celcius ke reaumur
+
+    Parameter:
+        celcius(int atau float): nilai celcius
+
+    Return:
+        (float atau int): hasil dari kalkulasi celcius ke kelvin
+        errot.ErrorTiperData: error jika data salah
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if not isinstance(celcius, (float, int)):
+        return error.ErrorTipeData(["float", "int"])
+    else:
+        return celcius + 273.15
+
+
+def kelvin_celcius(kelvin: Union[int, float]) -> Union[int, float, error.Error]:
+    """
+    mengubah celcius ke kelvin
+
+    Parameter:
+        kelvin(int atau float): nilai kelvin
+
+    Return:
+        (float atau int): hasil dari kalkulasi kelvin ke celcius
+        error.ErrorTiperData: error jika data salah
+        erro.Error: error jika nilai kelvin kurang dari nol
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if not isinstance(kelvin, (float, int)):
+        return error.ErrorTipeData(["float", "int"])
+    elif kelvin < 0:
+        return error.Error("Nilai kelvin tidak boleh kurang dari 0")
+    else:
+        return 273.15 - kelvin
+
+
+def kelvin_fahrenheit(kelvin: Union[int, float]) -> Union[int, float, error.Error]:
+    """
+    mengubah kelvin ke fahrenheit
+
+    Parameter:
+        kelvin(int atau float): nilai kelvin
+
+    Return:
+        (float atau int): hasil dari kalkulasi kelvin ke fahrenheit
+        error.ErrorTiperData: error jika data salah
+        errot.Error ; error jika nilai kelvin kurang dari nol
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if not isinstance(kelvin, (float, int)):
+        return error.ErrorTipeData(["float", "int"])
+    elif kelvin < 0:
+        return error.Error("Kelvin tidak boleh kurang dari 0")
+    else:
+        return kelvin * (9 / 5) - 459.67
+
+
+def fahrenheit_kelvin(fahrenheit: Union[int, float]) -> Union[int, float]:
+    """
+    mengubah fahrenheit ke kelvin
+
+    Parameter:
+        fahrenheit(int atau float): nilai fahrenheit
+
+    Return:
+        (float atau int): hasil dari kalkulasi fahrenheit ke kelvin
+        errot.ErrorTiperData: error jika data salah
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if not isinstance(fahrenheit, (float, int)):
+        return error.ErrorTipeData(["float", "int"])
+    else:
+        return (fahrenheit + 459.67) * (5 / 9)
+
+
+def kelvin_reamur(kelvin: Union[int, float]) -> Union[int, float, error.Error]:
+    """
+    mengubah kelvin ke reamur
+
+    Parameter:
+        kelvin(int atau float): nilai kelvin
+
+    Return:
+        (float atau int): hasil dari kalkulasi kelvin ke reamur
+        errot.ErrorTiperData: error jika data salah
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if not isinstance(kelvin, (float, int)):
+        return error.ErrorTipeData(["int", "float"])
+    elif kelvin < 0:
+        return error.Error("Kelvin tidak boleh kurang dari 0")
+    else:
+        return (kelvin - 273.15) * (4 / 5)
+
+
+def reamur_kelvin(reamur: Union[int, float]) -> Union[int, float]:
+    """
+    mengubah reamur ke kelvin
+
+    Parameter:
+        reamur(int atau float): nilai reamur
+
+    Return:
+        (float atau int): hasil dari kalkulasi reamur ke kelvin
+        errot.ErrorTiperData: error jika data salah
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if not isinstance(reamur, (float, int)):
+        return error.ErrorTipeData(["float", "int"])
+    else:
+        return (reamur * (5 / 4)) + 273.15
+
+
+def reamur_fahrenheit(reamur: Union[int, float]) -> Union[int, float]:
+    """
+    mengubah reamur ke fahrenheit
+
+    Parameter:
+        reamur(int atau float): nilai reamur
+
+    Return:
+        (float atau int): hasil dari kalkulasi reamur ke fahrenheit
+        errot.ErrorTiperData: error jika data salah
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if not isinstance(reamur, (float, int)):
+        return error.ErrorTipeData(["float", "int"])
+    else:
+        return (reamur * (9 / 4)) + 32
+
+
+def fahrenheit_reamur(fahrenheit: Union[int, float]) -> Union[int, float]:
+    """
+    mengubah fahrenheit ke reamur
+
+    Parameter:
+        fahrenheit(int atau float): nilai fahrenheit
+
+    Return:
+        (float atau int): hasil dari kalkulasi fahrenheit ke reamur
+        errot.ErrorTiperData: error jika data salah
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if not isinstance(fahrenheit, (float, int)):
+        return error.ErrorTipeData(["float", "int"])
+    else:
+        return (fahrenheit - 32) * (4 / 9)
diff --git a/example/fisika/efek_doppler.py b/example/fisika/efek_doppler.py
index ebad7c3..e3491fb 100644
--- a/example/fisika/efek_doppler.py
+++ b/example/fisika/efek_doppler.py
@@ -1,5 +1,5 @@
 import OpenSeries.fisika as fisika
 
 # menghitung fungsi dari efek doppler
-doppler_efek = fisika.efek_doppler(100, 330, 10)
+doppler_efek = fisika.efek_doppler(100, 330, 10, 10)
 print(doppler_efek)
diff --git a/testing/bilangan_istimewa_test.py b/testing/bilangan_istimewa_test.py
index 55552b1..3fb0e56 100644
--- a/testing/bilangan_istimewa_test.py
+++ b/testing/bilangan_istimewa_test.py
@@ -65,3 +65,109 @@ def test_beda_tipe_data(self):
         hasil = bilangan.angka_segitiga("12")
         with self.assertRaises(error.ErrorTipeData):
             raise hasil
+
+
+class TestAngkaPolindorm(unittest.TestCase):
+    def test_angka_polindrom(self):
+        hasil = bilangan.angka_polindrom(909)
+        hasil_1 = bilangan.angka_polindrom(505)
+        self.assertEqual(hasil, "angka polindrom".capitalize())
+        self.assertEqual(hasil_1, "angka polindrom".capitalize())
+
+    def test_salah_angka_polindorm(self):
+        hasil = bilangan.angka_polindrom(123)
+        hasil_1 = bilangan.angka_polindrom(756)
+        self.assertEqual(hasil, "bukan angka polindrom".capitalize())
+        self.assertEqual(hasil_1, "bukan angka polindrom".capitalize())
+
+    def tes_angka_negatif_polindrom(self):
+        hasil = bilangan.angka_polindrom(-909)
+        with self.assertRaises(error.Error):
+            raise hasil
+
+    def tipe_data_angka_polindrom(self):
+        hasil = bilangan.angka_polindrom("909")
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestAngkaPrima(unittest.TestCase):
+    def test_angka_prima(self):
+        hasil1 = bilangan.angka_prima(11)
+        hasil2 = bilangan.angka_prima(41)
+        self.assertEqual(hasil1, "angka prima".capitalize())
+        self.assertEqual(hasil2, "angka prima".capitalize())
+
+    def test_bukan_angka_prima(self):
+        self.assertEqual(bilangan.angka_prima(25), "bukan angka prima".capitalize())
+        self.assertEqual(bilangan.angka_prima(49), "bukan angka prima".capitalize())
+
+    def test_angka_prima_negatif(self):
+        hasil = bilangan.angka_prima(-7)
+        with self.assertRaises(error.Error):
+            raise hasil
+
+    def test_tipe_data(self):
+        hasil = bilangan.angka_prima("5")
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class angka_kaprekar(unittest.TestCase):
+    def test_angka_kaprekar(self):
+        self.assertAlmostEqual(
+            bilangan.angka_kaprekar(45), "angka kaprekar".capitalize()
+        )
+        self.assertAlmostEqual(
+            bilangan.angka_kaprekar(55), "angka kaprekar".capitalize()
+        )
+
+    def tets_bukan_angka_kaprekar(self):
+        self.assertAlmostEqual(
+            bilangan.angka_kaprekar(12), "bukan angka kaprekar".capitalize()
+        )
+        self.assertAlmostEqual(
+            bilangan.angka_kaprekar(35), "bukan angka kaprekar".capitalize()
+        )
+
+    def tets_angka_negatif(self):
+        hasil = bilangan.angka_kaprekar(-81)
+        with self.assertRaises(error.Error):
+            raise hasil
+
+    def test_tipe_data(self):
+        hasil = bilangan.angka_kaprekar("81")
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class angka_tetrahendral(unittest.TestCase):
+    def test_angka_tetrahedral(self):
+        self.assertAlmostEqual(bilangan.angka_tetrahedral(8), 120)
+        self.assertAlmostEqual(bilangan.angka_tetrahedral(5), 35)
+
+    def test_angka_negatif(self):
+        hasil = bilangan.angka_tetrahedral(-10)
+        with self.assertRaises(error.Error):
+            raise hasil
+
+    def tipe_data_salah(self):
+        hasil = bilangan.angka_tetrahedral("10")
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class angka_pentatope(unittest.TestCase):
+    def test_angka_pentatope(self):
+        self.assertAlmostEqual(bilangan.angka_pentatope(9), 495)
+        self.assertAlmostEqual(bilangan.angka_pentatope(7), 210)
+
+    def test_angka_negatif_pentatope(self):
+        hasil = bilangan.angka_pentatope(-19)
+        with self.assertRaises(error.Error):
+            raise hasil
+
+    def tets_tipe_data(self):
+        hasil = bilangan.angka_pentatope("9")
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
diff --git a/testing/fisika_test.py b/testing/fisika_test.py
index 5609a6a..02a2b3e 100644
--- a/testing/fisika_test.py
+++ b/testing/fisika_test.py
@@ -39,10 +39,69 @@ def test_percepatan_nilai_tidak_valid(self):
             raise hasil
 
 
+class TestKecepatanSudut(unittest.TestCase):
+    def test_kecepatan_sudut_valid(self):
+        hasil = fisika.kecepatan_sudut(30, 2)
+        self.assertEqual(hasil, 15)
+
+    def test_kecepatan_sudut_dibagi_nol(self):
+        hasil = fisika.kecepatan_sudut(30.0, 0)
+        with self.assertRaises(error.ErrorDibagiNol):
+            raise hasil
+
+    def test_kecepatan_sudut_tidak_valid(self):
+        hasil = fisika.kecepatan_sudut("30.0", 2)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestPercepatanSudut(unittest.TestCase):
+    def test_percepatan_sudut_valid(self):
+        hasil = fisika.percepatan_sudut(50, 2)
+        self.assertEqual(hasil, 25)
+
+    def test_percepatan_sudut_dibagi_nol(self):
+        hasil = fisika.percepatan_sudut(50.0, 0)
+        with self.assertRaises(error.ErrorDibagiNol):
+            raise hasil
+
+    def test_percepatan_sudut_tidak_valid(self):
+        hasil = fisika.percepatan_sudut("50.0", 2)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestPercepatanSentripetallinear(unittest.TestCase):
+    def test_percepatanSentripetal_linear_valid(self):
+        hasil = fisika.percepatan_sentripetal_linear(5.0, 2)
+        self.assertEqual(hasil, 12.5)
+
+    def test_percepatan_sudut_dibagi_nol(self):
+        hasil = fisika.percepatan_sudut(50.0, 0)
+        with self.assertRaises(error.ErrorDibagiNol):
+            raise hasil
+
+    def test_percepatan_sudut_tidak_valid(self):
+        hasil = fisika.percepatan_sudut("50.0", 2)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestPercepatanSentripetalSudut(unittest.TestCase):
+    def test_percepatansentripetal_sudut_valid(self):
+        hasil = fisika.percepatan_sentripetal_sudut(5, 8)
+        self.assertEqual(hasil, 320)
+
+    def test_percepatan_sudut_tidak_valid(self):
+        hasil = fisika.percepatan_sentripetal_sudut("5", 8)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
 class TestGerakLurusBeraturan(unittest.TestCase):
     def test_valid(self):
         hasil = fisika.gerak_lurus_beraturan(10.0, 2.0, 3.0)
-        self.assertAlmostEqual(hasil, 39.0, places=2)
+        self.assertAlmostEqual(hasil, 39.0)
 
     def test_invalid_int(self):
         hasil = fisika.gerak_lurus_beraturan(8, 1.5, 2)
@@ -50,6 +109,28 @@ def test_invalid_int(self):
             raise hasil
 
 
+class TesGerakMelingkarBeraturan(unittest.TestCase):
+    def test_valid(self):
+        hasil = fisika.gerak_melingkar_beraturan(5, 6, 3)
+        self.assertAlmostEqual(hasil, 23)
+
+    def test_invalid(self):
+        hasil = fisika.gerak_melingkar_beraturan("5", "6", 3)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestInersia(unittest.TestCase):
+    def test_valid(self):
+        hasil = fisika.inersia(2, 4)
+        self.assertAlmostEqual(hasil, 32)
+
+    def test_invalid(self):
+        hasil = fisika.inersia("2", 4)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
 class TestEnergiKinetik(unittest.TestCase):
     def test_valid_input(self):
         hasil = fisika.energi_kinetik(2.0, 5.0)
@@ -61,6 +142,17 @@ def test_invalid_input_mix_tipe_data(self):
             raise hasil
 
 
+class TestEnergiKinetikRotasi(unittest.TestCase):
+    def test_valid(self):
+        hasil = fisika.energi_kinetik_rotasi(2, 6)
+        self.assertAlmostEqual(hasil, 36)
+
+    def test_invalid(self):
+        hasil = fisika.energi_kinetik_rotasi("2", 6)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
 class TestKetinggianBarometrik(unittest.TestCase):
     def test_valid_input_tekanan(self):
         hasil = fisika.ketinggian_barometrik(101325.0)
@@ -129,3 +221,167 @@ def test_efek_doppler_nilai_negatif(self):
         self.assertIsInstance(hasil, error.Error)
         with self.assertRaises(error.Error):
             raise hasil
+
+
+class TestCelciusFarenheit(unittest.TestCase):
+    def test_CelciusFarenheit(self):
+        hasil = fisika.celcius_farenheit(0)
+        rounding_hasil = round(hasil)
+        self.assertEqual(rounding_hasil, 32)
+
+    def test_CelciusFarenheit_invalid_tipe_data(self):
+        hasil = fisika.celcius_farenheit("0")
+        self.assertIsInstance(hasil, error.ErrorTipeData)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestFarenheitCelcius(unittest.TestCase):
+    def test_FarenheitCelcius(self):
+        hasil = fisika.farenheit_celcius(32)
+        rounding_hasil = round(hasil)
+        self.assertEqual(rounding_hasil, 0)
+
+    def test_FarenheitCelcius_invalid_tipe_data(self):
+        hasil = fisika.farenheit_celcius("32")
+        self.assertIsInstance(hasil, error.ErrorTipeData)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestCelciusReamur(unittest.TestCase):
+    def test_CelciusReamur(self):
+        hasil = fisika.celcius_reaumur(32)
+        self.assertEqual(hasil, 25.6)
+
+    def test_CelciusReamur_invalid_tipe_data(self):
+        hasil = fisika.farenheit_celcius("32")
+        self.assertIsInstance(hasil, error.ErrorTipeData)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestReamurCelcius(unittest.TestCase):
+    def test_ReamurCelcius(self):
+        hasil = fisika.reamur_celcius(32)
+        self.assertEqual(hasil, 40)
+
+    def test_ReamurCelcius_invalid_tipe_data(self):
+        hasil = fisika.farenheit_celcius("32")
+        self.assertIsInstance(hasil, error.ErrorTipeData)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestCelciusKelvin(unittest.TestCase):
+    def test_CelciusKelvin(self):
+        hasil = fisika.celcius_kelvin(0)
+        self.assertEqual(hasil, 273.15)
+
+    def test_CelciusKelvin_invalid_tipe_data(self):
+        hasil = fisika.farenheit_celcius("0")
+        self.assertIsInstance(hasil, error.ErrorTipeData)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestKelvinCelcius(unittest.TestCase):
+    def test_KelvinCelcius(self):
+        hasil = fisika.kelvin_celcius(273.15)
+        self.assertEqual(hasil, 0)
+
+    def test_kelvin_nilai_negatif(self):
+        hasil = fisika.kelvin_celcius(-10)
+        self.assertIsInstance(hasil, error.Error)
+        with self.assertRaises(error.Error):
+            raise hasil
+
+    def test_KelvinCelcius_invalid_tipe_data(self):
+        hasil = fisika.kelvin_celcius("273.15")
+        self.assertIsInstance(hasil, error.ErrorTipeData)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestKelvinFarenheit(unittest.TestCase):
+    def test_KelvinFarenheit(self):
+        hasil = fisika.kelvin_fahrenheit(300)
+        self.assertEqual(hasil, 80.32999999999998)
+
+    def test_kelvin_nilai_negatif(self):
+        hasil = fisika.kelvin_fahrenheit(-10)
+        self.assertIsInstance(hasil, error.Error)
+        with self.assertRaises(error.Error):
+            raise hasil
+
+    def test_KelvinFarenheit_invalid_tipe_data(self):
+        hasil = fisika.kelvin_fahrenheit("0")
+        self.assertIsInstance(hasil, error.ErrorTipeData)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestFarenheitKelvin(unittest.TestCase):
+    def test_FarenheitKelvin(self):
+        hasil = fisika.fahrenheit_kelvin(-459.67)
+        self.assertEqual(hasil, 0)
+
+    def test_FarenheitKelvin_invalid_tipe_data(self):
+        hasil = fisika.fahrenheit_kelvin("-459.67")
+        self.assertIsInstance(hasil, error.ErrorTipeData)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestKelvinReamur(unittest.TestCase):
+    def test_KelvinReamur(self):
+        hasil = fisika.kelvin_reamur(300)
+        self.assertEqual(hasil, 21.480000000000018)
+
+    def test_kelvin_nilai_negatif(self):
+        hasil = fisika.kelvin_reamur(-10)
+        self.assertIsInstance(hasil, error.Error)
+        with self.assertRaises(error.Error):
+            raise hasil
+
+    def test_KelvinReamur_invalid_tipe_data(self):
+        hasil = fisika.kelvin_reamur("300")
+        self.assertIsInstance(hasil, error.ErrorTipeData)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestReamurKelvin(unittest.TestCase):
+    def test_ReamurKelvin(self):
+        hasil = fisika.reamur_kelvin(0)
+        self.assertEqual(hasil, 273.15)
+
+    def test_ReamurFahrenheit_invalid_tipe_data(self):
+        hasil = fisika.reamur_fahrenheit("-218.52")
+        self.assertIsInstance(hasil, error.ErrorTipeData)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestReamurFahrenheit(unittest.TestCase):
+    def test_ReamurFahrenheit(self):
+        hasil = fisika.reamur_fahrenheit(0)
+        self.assertEqual(hasil, 32)
+
+    def test_ReamurFahrenheit_invalid_tipe_data(self):
+        hasil = fisika.reamur_fahrenheit("0")
+        self.assertIsInstance(hasil, error.ErrorTipeData)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestFahrenheitReamur(unittest.TestCase):
+    def test_FahrenheitReamur(self):
+        hasil = fisika.fahrenheit_reamur(40)
+        self.assertEqual(hasil, 3.5555555555555554)
+
+    def test_FahrenheitReamur_invalid_tipe_data(self):
+        hasil = fisika.fahrenheit_reamur("0")
+        self.assertIsInstance(hasil, error.ErrorTipeData)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil