horizontal motion code physics

ciphers/a1z26.py

@@ -7,15 +7,18 @@
 """
 
 
-def encode(plain: str) -> list[int]:
+from typing import List
+
+
+def encode(plain: str) -> List[int]:
     """
     >>> encode("myname")
     [13, 25, 14, 1, 13, 5]
     """
     return [ord(elem) - 96 for elem in plain]
 
 
-def decode(encoded: list[int]) -> str:
+def decode(encoded: List[int]) -> str:
     """
     >>> decode([13, 25, 14, 1, 13, 5])
     'myname'

ciphers/enigma_machine2.py

@@ -14,9 +14,10 @@
 
 Created by TrapinchO
 """
+from typing import Dict, Tuple
 
-RotorPositionT = tuple[int, int, int]
-RotorSelectionT = tuple[str, str, str]
+RotorPositionT = Tuple[int, int, int]
+RotorSelectionT = Tuple[str, str, str]
 
 
 # used alphabet --------------------------
@@ -69,7 +70,7 @@
 
 def _validator(
     rotpos: RotorPositionT, rotsel: RotorSelectionT, pb: str
-) -> tuple[RotorPositionT, RotorSelectionT, dict[str, str]]:
+) -> Tuple[RotorPositionT, RotorSelectionT, Dict[str, str]]:
     """
     Checks if the values can be used for the 'enigma' function
 
@@ -110,7 +111,7 @@ def _validator(
     return rotpos, rotsel, pbdict
 
 
-def _plugboard(pbstring: str) -> dict[str, str]:
+def _plugboard(pbstring: str) -> Dict[str, str]:
     """
     https://en.wikipedia.org/wiki/Enigma_machine#Plugboard
 

ciphers/trafid_cipher.py

@@ -1,7 +1,10 @@
 # https://en.wikipedia.org/wiki/Trifid_cipher
 
 
-def __encryptPart(messagePart: str, character2Number: dict[str, str]) -> str:
+from typing import Dict, Tuple
+
+
+def __encryptPart(messagePart: str, character2Number: Dict[str, str]) -> str:
     one, two, three = "", "", ""
     tmp = []
 
@@ -17,8 +20,8 @@ def __encryptPart(messagePart: str, character2Number: dict[str, str]) -> str:
 
 
 def __decryptPart(
-    messagePart: str, character2Number: dict[str, str]
-) -> tuple[str, str, str]:
+    messagePart: str, character2Number: Dict[str, str]
+) -> Tuple[str, str, str]:
     tmp, thisPart = "", ""
     result = []
 
@@ -36,7 +39,7 @@ def __decryptPart(
 
 def __prepare(
     message: str, alphabet: str
-) -> tuple[str, str, dict[str, str], dict[str, str]]:
+) -> Tuple[str, str, Dict[str, str], Dict[str, str]]:
     # Validate message and alphabet, set to upper and remove spaces
     alphabet = alphabet.replace(" ", "").upper()
     message = message.replace(" ", "").upper()

ciphers/xor_cipher.py

@@ -18,6 +18,9 @@
 """
 
 
+from typing import List
+
+
 class XORCipher:
     def __init__(self, key: int = 0):
         """
@@ -28,7 +31,7 @@ def __init__(self, key: int = 0):
         # private field
         self.__key = key
 
-    def encrypt(self, content: str, key: int) -> list[str]:
+    def encrypt(self, content: str, key: int) -> List[str]:
         """
         input: 'content' of type string and 'key' of type int
         output: encrypted string 'content' as a list of chars
@@ -53,7 +56,7 @@ def encrypt(self, content: str, key: int) -> list[str]:
 
         return ans
 
-    def decrypt(self, content: str, key: int) -> list[str]:
+    def decrypt(self, content: str, key: int) -> List[str]:
         """
         input: 'content' of type list and 'key' of type int
         output: decrypted string 'content' as a list of chars

physics/horizontal_projectile_motion.py

@@ -0,0 +1,168 @@
+"""
+Horizontal Projectile Motion problem in physics.
+This algorithm solves a specific problem in which
+the motion starts from the ground as can be seen below:
+      (v = 0)
+        **
+       *  *
+      *    *
+     *      *
+    *        *
+   *          *
+GROUND      GROUND
+
+For more info: https://en.wikipedia.org/wiki/Projectile_motion
+"""
+
+# Importing packages
+from math import radians as angle_to_radians
+from math import sin
+
+# Acceleration Constant on hearth (unit m/s^2)
+g = 9.80665
+
+
+def check_args(init_velocity: float, angle: float) -> None:
+    """
+    Check that the arguments are valid
+    """
+
+    # Ensure valid instance
+    if not isinstance(init_velocity, (int, float)):
+        raise TypeError("Invalid velocity. Should be a positive number.")
+
+    if not isinstance(angle, (int, float)):
+        raise TypeError("Invalid angle. Range is 1-90 degrees.")
+
+    # Ensure valid angle
+    if angle > 90 or angle < 1:
+        raise ValueError("Invalid angle. Range is 1-90 degrees.")
+
+    # Ensure valid velocity
+    if init_velocity < 0:
+        raise ValueError("Invalid velocity. Should be a positive number.")
+
+
+def horizontal_distance(init_velocity: float, angle: float) -> float:
+    """
+    Returns the horizontal distance that the object cover
+
+    Formula:
+            v_0^2 * sin(2 * alpha)
+            ---------------------
+                   g
+
+    v_0 - initial velocity
+    alpha - angle
+
+    >>> horizontal_distance(30, 45)
+    91.77
+    >>> horizontal_distance(100, 78)
+    414.76
+    >>> horizontal_distance(4.5, 5.5)
+    0.39
+    >>> horizontal_distance(-1, 20)
+    Traceback (most recent call last):
+        ...
+    ValueError: Invalid velocity. Should be a positive number.
+    >>> horizontal_distance(30, -20)
+    Traceback (most recent call last):
+        ...
+    ValueError: Invalid angle. Range is 1-90 degrees.
+    """
+    check_args(init_velocity, angle)
+    radians = angle_to_radians(2 * angle)
+    return round(init_velocity ** 2 * sin(radians) / g, 2)
+
+
+def max_height(init_velocity: float, angle: float) -> float:
+    """
+    Returns the maximum height that the object reach
+
+    Formula:
+            v_0^2 * sin^2(alpha)
+            --------------------
+                   2g
+
+    v_0 - initial velocity
+    alpha - angle
+
+    >>> max_height(30, 45)
+    22.94
+    >>> max_height(100, 78)
+    487.82
+    >>> max_height(4.5, 5.5)
+    0.01
+    >>> max_height("a", 20)
+    Traceback (most recent call last):
+        ...
+    TypeError: Invalid velocity. Should be a positive number.
+    >>> horizontal_distance(30, "b")
+    Traceback (most recent call last):
+        ...
+    TypeError: Invalid angle. Range is 1-90 degrees.
+    """
+    check_args(init_velocity, angle)
+    radians = angle_to_radians(angle)
+    return round(init_velocity ** 2 * sin(radians) ** 2 / (2 * g), 2)
+
+
+def total_time(init_velocity: float, angle: float) -> float:
+    """
+    Returns total time of the motion
+
+    Formula:
+            2 * v_0 * sin(alpha)
+            --------------------
+                   g
+
+    v_0 - initial velocity
+    alpha - angle
+
+    >>> total_time(30, 45)
+    4.33
+    >>> total_time(100, 78)
+    19.95
+    >>> total_time(4.5, 5.5)
+    0.09
+    >>> total_time(-10, 40)
+    Traceback (most recent call last):
+        ...
+    ValueError: Invalid velocity. Should be a positive number.
+    >>> total_time(30, "b")
+    Traceback (most recent call last):
+        ...
+    TypeError: Invalid angle. Range is 1-90 degrees.
+    """
+    check_args(init_velocity, angle)
+    radians = angle_to_radians(angle)
+    return round(2 * init_velocity * sin(radians) / g, 2)
+
+
+def test_motion() -> None:
+    """
+    >>> test_motion()
+    """
+    v0, angle = 25, 20
+    assert horizontal_distance(v0, angle) == 40.97
+    assert max_height(v0, angle) == 3.73
+    assert total_time(v0, angle) == 1.74
+
+
+if __name__ == "__main__":
+    from doctest import testmod
+
+    testmod()
+
+    # Get input from user
+    init_vel = float(input("Initial Velocity: ").strip())
+
+    # Get input from user
+    angle = float(input("angle: ").strip())
+
+    # Print results
+    print()
+    print("Results: ")
+    print(f"Horizontal Distance: {str(horizontal_distance(init_vel, angle))} [m]")
+    print(f"Maximum Height: {str(max_height(init_vel, angle))} [m]")
+    print(f"Total Time: {str(total_time(init_vel, angle))} [s]")