afmaths 2.0.3__tar.gz → 2.1.0__tar.gz

{afmaths-2.0.3 → afmaths-2.1.0}/PKG-INFO

@@ -1,19 +1,21 @@
 Metadata-Version: 2.4
 Name: afmaths
-Version: 2.0.3
-Summary: A simple package of math functions.
+Version: 2.1.0
+Summary: A suite of mathematical functions
 Home-page: https://github.com/Arturius771/afmaths
 Author: Artur Foden
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: astronomy_types>=2.1.0
 Dynamic: author
 Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license-file
+Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
@@ -23,20 +25,11 @@ A simple package of math functions. Originally this was written to enable loggin
 
 # Todo
 
-- Add tests
 - Create output functionality, which prints (in a user friendly way) the steps required
-- Doc comments
-- Document how to build/run
-- Document how to upgrade the npm package
 - Document and implement semantic versioning
 - Use currying for functions
-- Adapt hohmann transfer style to be closer to the repo's
 
-## 1. Install or Activate the Virtual Environment
-
-It's recommended to use a virtual environment for isolation. If you don't already have a virtual environment, create and activate one:
-
-### Create and start virtual environment:
+# Create and start virtual environment:
 
 ```bash
 python3 -m venv venv
@@ -46,15 +39,28 @@ python3 -m venv venv
 source venv/bin/activate
 ```
 
-## 2. Install Required Dependencies
+# Install Required Dependencies
 
 Ensure that setuptools and wheel are installed in your environment:
 
 ```bash
 pip install -r requirements.txt
+pip install -e .
+```
+
+# Run files
+
+```bash
+python -m afmaths.space.astrodynamics
+```
+
+# Run tests
+
+```bash
+python -m unittest
 ```
 
-## 3. Update version number
+# Update version number
 
 ```bash
 setup(
@@ -64,13 +70,13 @@ setup(
 )
 ```
 
-## 4. Build the dist
+# Build the dist
 
 ```bash
 python setup.py sdist bdist_wheel
 ```
 
-## 5. Upload with `twine`
+# Upload with `twine`
 
 ```bash
 twine upload dist/*

afmaths-2.0.3/lib/cs.py → afmaths-2.1.0/lib/afmaths/computer_science.py

@@ -1,190 +1,191 @@
-import math
-from geometry import pythagoras
-from operation import (
-    HALF,
-    add,
-    divide,
-    exponentiate,
-    factorial,
-    multiply,
-    subtract,
-)
-from list import sum
-
-
-def file_compression_ratio(uncompressed_size: float):
-    return lambda compressed_size: divide(compressed_size)(uncompressed_size)
-
-
-def compressed_file_size(uncompressed_size):
-    return lambda compression_ratio: divide(compression_ratio)(uncompressed_size)
-
-
-def diagonal_pixel_length(length_in_pixels):
-    return lambda width_in_pixels: math.floor(
-        pythagoras(length_in_pixels)(width_in_pixels)
-    )
-
-
-def travelling_salesman_problem_total_routes(number_of_cities) -> float:
-    ##(n - 1)!/2
-    subtract1 = subtract(1)
-    total_routes = HALF(factorial(subtract1(number_of_cities)))
-
-    return total_routes
-
-
-def check_drive_clusters(
-    sectors_per_cluster, sector_size_bytes, physical_file_size_bytes
-) -> tuple[int, float]:
-    ## TM255
-    if (
-        physical_file_size_bytes % (multiply(sectors_per_cluster)(sector_size_bytes))
-        == 0
-    ):
-        number_of_clusters = physical_file_size_bytes // multiply(sectors_per_cluster)(
-            sector_size_bytes
-        )
-    else:
-        number_of_clusters = (
-            physical_file_size_bytes // (sectors_per_cluster * sector_size_bytes)
-        ) + 1
-
-    multiply_number_of_clusters = multiply(number_of_clusters)
-    multiply_number_of_clusters_by_sectors_per_cluster = multiply(
-        multiply_number_of_clusters(sectors_per_cluster)
-    )
-    slack_space_bytes = subtract(physical_file_size_bytes)(
-        multiply_number_of_clusters_by_sectors_per_cluster(sector_size_bytes)
-    )
-
-    return (number_of_clusters, slack_space_bytes)
-
-
-def ml_f1_score(precision: float, recall: float) -> float:
-    """F1 score: related to the harmonic mean of precision and recall. Calculated as F1 = 2/[(1/Precision) + (1/Recall)] = 2/[(TP + FP)/TP + (TP + FN)/TP] = 2/[(2TP + FP + FN)/TP] = 2TP/[2TP + FP + FN] . A high F1 score implies the system has low numbers of false positives and false negatives. - TM358"""
-    f1 = divide(add(divide(precision)(1))(divide(recall)(1)))(2)
-
-    return f1
-
-
-def ml_precesion(true_positives):
-    return lambda false_positives: divide(add(true_positives)(false_positives))(
-        true_positives
-    )
-
-
-def ml_recall(true_positives):
-    """Fraction of total positives out of both true and false positives - also known as the true positive rate."""
-    return lambda false_negatives: divide(add(true_positives)(false_negatives))(
-        true_positives
-    )  # TM358
-
-
-def ml_false_positive_rate(false_positives):
-    return lambda true_negatives: divide(add(false_positives)(true_negatives))(
-        false_positives
-    )
-
-
-def ml_weighted_inputs(inputs: list[float], weights: list[float]) -> list[float] | None:
-    "Multiply the inputs by the weights - TM358 Block 1"
-    weighted_inputs = []
-    loop_count = 0
-    if len(inputs) != len(weights):
-        return None
-    for x in inputs:
-        weighted_inputs.append(multiply(x)(weights[inputs.index(x, loop_count)]))
-        loop_count += 1
-
-    return weighted_inputs
-
-
-def ml_perceptron(inputs: list[float], weights: list[float], bias: float = 0) -> float:
-    x = ml_weighted_inputs(inputs, weights)
-    if x == None:
-        return 0  # TODO: this is dangerous
-    return ml_activation_function(add(sum(x))(bias))
-
-
-def ml_activation_function(input: float, threshold: float = 0):
-    if input > threshold:
-        return 1
-    else:
-        return 0
-
-
-def byte_to_ascii_text(input: int) -> str:
-    # https://www.rapidtables.com/convert/number/binary-to-ascii.html
-    value = byte_to_decimal(input)
-
-    return chr(value)
-
-
-def byte_to_decimal(input: int) -> int:
-    """Takes an 8 bit value and returns its value in decimal form."""
-    value = 0
-    tracker = len(str(input)) - 1
-
-    for bit in str(input):
-        if int(bit) != 0:
-            exponentiateByTracker = exponentiate(tracker)
-            value += exponentiateByTracker(2)
-        tracker -= 1
-    return value
-
-
-def byte_to_hex(input: int) -> str:
-    str_input = str(input)
-    length = len(str_input)
-
-    if length == 8:
-        return f"{bit_to_hex(str_input[:4])}{bit_to_hex(str_input[4:])}"
-    if length == 7:
-        return f"{bit_to_hex(str_input[:3])}{bit_to_hex(str_input[3:])}"
-    if length == 6:
-        return f"{bit_to_hex(str_input[:2])}{bit_to_hex(str_input[2:])}"
-    if length == 5:
-        return f"{bit_to_hex(str_input[:1])}{bit_to_hex(str_input[1:])}"
-    if length <= 4:
-        return f"{bit_to_hex(str_input)}"
-
-    return str_input
-
-
-def bit_to_hex(bit_string: str) -> str:
-    bit_string = bit_string
-    if bit_string == "0":
-        return "0"
-    if bit_string == "1":
-        return "1"
-    if bit_string == "10":
-        return "2"
-    if bit_string == "11":
-        return "3"
-    if bit_string == "100":
-        return "4"
-    if bit_string == "101":
-        return "5"
-    if bit_string == "110":
-        return "6"
-    if bit_string == "111":
-        return "7"
-    if bit_string == "1000":
-        return "8"
-    if bit_string == "1001":
-        return "9"
-    if bit_string == "1010":
-        return "A"
-    if bit_string == "1011":
-        return "B"
-    if bit_string == "1100":
-        return "C"
-    if bit_string == "1101":
-        return "D"
-    if bit_string == "1110":
-        return "E"
-    if bit_string == "1111":
-        return "F"
-
-    return bit_string
+import math
+
+from afmaths.geometry.geometry import pythagoras_theorem
+
+from .operation import (
+    HALF,
+    add,
+    divide_by,
+    exponentiate,
+    factorial,
+    multiply,
+    subtract,
+)
+from .list import list_sum
+
+
+def file_compression_ratio(uncompressed_size: float):
+    return lambda compressed_size: divide_by(compressed_size)(uncompressed_size)
+
+
+def compressed_file_size(uncompressed_size):
+    return lambda compression_ratio: divide_by(compression_ratio)(uncompressed_size)
+
+
+def diagonal_pixel_length(length_in_pixels):
+    return lambda width_in_pixels: math.floor(
+        pythagoras_theorem(length_in_pixels)(width_in_pixels)
+    )
+
+
+def travelling_salesman_problem_total_routes(number_of_cities) -> float:
+    ##(n - 1)!/2
+    subtract1 = subtract(1)
+    total_routes = HALF(factorial(subtract1(number_of_cities)))
+
+    return total_routes
+
+
+def check_drive_clusters(
+    sectors_per_cluster, sector_size_bytes, physical_file_size_bytes
+) -> tuple[int, float]:
+    ## TM255
+    if (
+        physical_file_size_bytes % (multiply(sectors_per_cluster)(sector_size_bytes))
+        == 0
+    ):
+        number_of_clusters = physical_file_size_bytes // multiply(sectors_per_cluster)(
+            sector_size_bytes
+        )
+    else:
+        number_of_clusters = (
+            physical_file_size_bytes // (sectors_per_cluster * sector_size_bytes)
+        ) + 1
+
+    multiply_number_of_clusters = multiply(number_of_clusters)
+    multiply_number_of_clusters_by_sectors_per_cluster = multiply(
+        multiply_number_of_clusters(sectors_per_cluster)
+    )
+    slack_space_bytes = subtract(physical_file_size_bytes)(
+        multiply_number_of_clusters_by_sectors_per_cluster(sector_size_bytes)
+    )
+
+    return (number_of_clusters, slack_space_bytes)
+
+
+def ml_f1_score(precision: float, recall: float) -> float:
+    """F1 score: related to the harmonic mean of precision and recall. Calculated as F1 = 2/[(1/Precision) + (1/Recall)] = 2/[(TP + FP)/TP + (TP + FN)/TP] = 2/[(2TP + FP + FN)/TP] = 2TP/[2TP + FP + FN] . A high F1 score implies the system has low numbers of false positives and false negatives. - TM358"""
+    f1 = divide_by(add(divide_by(precision)(1))(divide_by(recall)(1)))(2)
+
+    return f1
+
+
+def ml_precesion(true_positives):
+    return lambda false_positives: divide_by(add(true_positives)(false_positives))(
+        true_positives
+    )
+
+
+def ml_recall(true_positives):
+    """Fraction of total positives out of both true and false positives - also known as the true positive rate."""
+    return lambda false_negatives: divide_by(add(true_positives)(false_negatives))(
+        true_positives
+    )  # TM358
+
+
+def ml_false_positive_rate(false_positives):
+    return lambda true_negatives: divide_by(add(false_positives)(true_negatives))(
+        false_positives
+    )
+
+
+def ml_weighted_inputs(inputs: list[float], weights: list[float]) -> list[float] | None:
+    "Multiply the inputs by the weights - TM358 Block 1"
+    weighted_inputs = []
+    loop_count = 0
+    if len(inputs) != len(weights):
+        return None
+    for x in inputs:
+        weighted_inputs.append(multiply(x)(weights[inputs.index(x, loop_count)]))
+        loop_count += 1
+
+    return weighted_inputs
+
+
+def ml_perceptron(inputs: list[float], weights: list[float], bias: float = 0) -> float:
+    x = ml_weighted_inputs(inputs, weights)
+    if x == None:
+        return 0  # TODO: this is dangerous
+    return ml_activation_function(add(list_sum(x))(bias))
+
+
+def ml_activation_function(input: float, threshold: float = 0):
+    if input > threshold:
+        return 1
+    else:
+        return 0
+
+
+def ascii_text_from_byte(input: int) -> str:
+    # https://www.rapidtables.com/convert/number/binary-to-ascii.html
+
+    return chr(decimal_from_byte(input))
+
+
+def decimal_from_byte(input: int) -> int:
+    """Takes an 8 bit value and returns its value in decimal form."""
+    value = 0
+    tracker = len(str(input)) - 1
+
+    for bit in str(input):
+        if int(bit) != 0:
+            exponentiateByTracker = exponentiate(tracker)
+            value += exponentiateByTracker(2)
+        tracker -= 1
+    return value
+
+
+def hex_from_byte(input: int) -> str:
+    str_input = str(input)
+    length = len(str_input)
+
+    if length == 8:
+        return f"{hex_from_bit(str_input[:4])}{hex_from_bit(str_input[4:])}"
+    if length == 7:
+        return f"{hex_from_bit(str_input[:3])}{hex_from_bit(str_input[3:])}"
+    if length == 6:
+        return f"{hex_from_bit(str_input[:2])}{hex_from_bit(str_input[2:])}"
+    if length == 5:
+        return f"{hex_from_bit(str_input[:1])}{hex_from_bit(str_input[1:])}"
+    if length <= 4:
+        return f"{hex_from_bit(str_input)}"
+
+    return str_input
+
+
+def hex_from_bit(bit_string: str) -> str:
+    bit_string = bit_string
+    if bit_string == "0":
+        return "0"
+    if bit_string == "1":
+        return "1"
+    if bit_string == "10":
+        return "2"
+    if bit_string == "11":
+        return "3"
+    if bit_string == "100":
+        return "4"
+    if bit_string == "101":
+        return "5"
+    if bit_string == "110":
+        return "6"
+    if bit_string == "111":
+        return "7"
+    if bit_string == "1000":
+        return "8"
+    if bit_string == "1001":
+        return "9"
+    if bit_string == "1010":
+        return "A"
+    if bit_string == "1011":
+        return "B"
+    if bit_string == "1100":
+        return "C"
+    if bit_string == "1101":
+        return "D"
+    if bit_string == "1110":
+        return "E"
+    if bit_string == "1111":
+        return "F"
+
+    return bit_string

afmaths-2.1.0/lib/afmaths/constants.py

@@ -0,0 +1,97 @@
+import math
+from typing import Generic, NewType
+
+from astronomy_types import (
+    T,
+    Acceleration,
+    Anomaly,
+    ArgumentOfPeriapsis,
+    Coordinate3D,
+    Eccentricity,
+    Enum,
+    GravitationalParameter,
+    Distance,
+    Hour,
+    Inclination,
+    Minute,
+    OrbitalElements,
+    Radians,
+    Ratio,
+    RightAscension,
+    Scalar,
+    Second,
+    SemiMajorAxis,
+    TrueAnomaly,
+    Vector2D,
+    Vector3D,
+    Velocity,
+)
+
+from afmaths.operation import exponentiate, multiply, negate
+
+EARTH_MU_KM_CUBED = GravitationalParameter(Scalar(398_600.4418))  # km^3 / s^2
+EARTH_MU = GravitationalParameter(Scalar(3.986004418e14))  # m^3 / s^2
+EARTH_RADIUS = Distance(Scalar(6_378_137.0))  # m
+EARTH_RADIUS_KM = Distance(Scalar(6378.0))  # km
+EARTH_ANGULAR_VELOCITY = Radians(
+    Scalar((multiply(exponentiate(negate(5))(10))(7.29115)))
+)
+MOON_ELEMENTS = OrbitalElements(
+    Inclination(Radians(Scalar(0.08956146531375098))),
+    RightAscension(Radians(Scalar(5.765000161307142))),
+    ArgumentOfPeriapsis(Radians(Scalar(1.9751206723485106))),
+    SemiMajorAxis(Distance(Scalar(388470793.3846703))),
+    Eccentricity(Ratio(Scalar(0.04483641146974054))),
+    TrueAnomaly(Anomaly(Radians(Scalar(4.171189773145077)))),
+)
+EXAMPLE_ELEMENTS = OrbitalElements(
+    Inclination(Radians(Scalar(math.radians(1.145)))),
+    RightAscension(Radians(Scalar(3.024483909022929))),
+    ArgumentOfPeriapsis(Radians(Scalar(1.5))),
+    SemiMajorAxis(Distance(Scalar(384448))),
+    Eccentricity(Ratio(Scalar(0.549006))),
+    TrueAnomaly(Anomaly(Radians(Scalar(4.1)))),
+)
+SATELLITE_EXAMPLE_ELEMENTS = OrbitalElements(
+    Inclination(Radians(Scalar(math.radians(75)))),
+    RightAscension(Radians(Scalar(1.2))),
+    ArgumentOfPeriapsis(Radians(Scalar(0.5))),
+    SemiMajorAxis(Distance(Scalar(368470793.3846703))),
+    Eccentricity(Ratio(Scalar(0.05449006))),
+    TrueAnomaly(Anomaly(Radians(Scalar(1)))),
+)
+SPEED_OF_LIGHT_METRES_PER_SECONDS = 299792458
+PLANCK_CONSTANT = multiply(6.62607004)(exponentiate(negate(34))(10))
+GRAVITATIONAL_CONSTANT = multiply(6.67430)(exponentiate(negate(11))(10))  # 6.67430e-11
+STANDARD_GRAVITY = Acceleration(Scalar(9.80665))  # m/s
+STEFAN_BOLTZMANN_CONSTANT = multiply(5.670367)(exponentiate(negate(8))(10))
+UNIT_VECTOR_XY_PLANE = Vector3D[Scalar](Scalar(0), Scalar(0), Scalar(1))
+ITRS_EXAMPLE_POSITION: list[Coordinate3D[Scalar]] = [
+    Coordinate3D(x=Scalar(6790.0), y=Scalar(0.0), z=Scalar(0.0)),
+    Coordinate3D(x=Scalar(0.0), y=Scalar(6790.0), z=Scalar(0.0)),
+    Coordinate3D(x=Scalar(-6790.0), y=Scalar(0.0), z=Scalar(0.0)),
+    Coordinate3D(x=Scalar(0.0), y=Scalar(-6790.0), z=Scalar(0.0)),
+    Coordinate3D(x=Scalar(4153.518707), y=Scalar(732.377413), z=Scalar(5321.278575)),
+    Coordinate3D(x=Scalar(1091.593504), y=Scalar(-4073.882417), z=Scalar(5321.278575)),
+    Coordinate3D(
+        x=Scalar(-3230.864009), y=Scalar(-2711.016798), z=Scalar(-5321.278575)
+    ),
+    Coordinate3D(x=Scalar(2982.288913), y=Scalar(2982.288913), z=Scalar(-5321.278575)),
+]
+ISS_TLE_EXAMPLE = (
+    "1 25544U 98067A   26191.34711344  .00005681  00000-0  11131-3 0  9996"
+    "2 25544  51.6302 185.4700 0006688 278.6359  81.3872 15.48968037575346"
+)
+ISS_NORAD_ID = 25544
+GALILEO_7_NORAD_ID = 40544
+MOLNIYA_3_50_NORAD_ID = 25847
+EUTELSAT_EUTE_117_NORAD_ID = 39122
+BEIDOU_IGSO_6 = 41434
+ARIANE_6_FM1_UPPER = 60235
+TERRA_SAR = 31698
+JAMES_WEBB = 50463
+SECONDS_PER_DAY = Second(Scalar(86400))
+MINUTES_PER_DAY = Minute(1440)
+HOURS_PER_DAY = Hour(24)
+SECONDS_PER_MINUTE = Second(Scalar(60))
+SECONDS_PER_HOUR = Second(Scalar(3600))