afmaths 2.0.2__tar.gz → 2.0.4__tar.gz

{afmaths-2.0.2 → afmaths-2.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: afmaths
-Version: 2.0.2
+Version: 2.0.4
 Summary: A simple package of math functions.
 Home-page: https://github.com/Arturius771/afmaths
 Author: Artur Foden
@@ -8,12 +8,14 @@ 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
 
@@ -52,6 +54,7 @@ Ensure that setuptools and wheel are installed in your environment:
 
 ```bash
 pip install -r requirements.txt
+pip install -e .
 ```
 
 ## 3. Update version number

afmaths-2.0.4/lib/afmaths/cs.py

@@ -0,0 +1,190 @@
+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

afmaths-2.0.4/lib/afmaths/formula.py

@@ -0,0 +1,66 @@
+from functools import reduce
+import math
+from .operation import (
+    SQUARE,
+    add,
+    divide,
+    exponentiate,
+    multiply,
+    factorial,
+)
+
+
+def sigmoid(input: float, bias: float = 0) -> float:
+    """Calculates the sigmoid of a value"""
+    # TM358 Section Block 1 section 5
+    add_bias = add(bias)
+    return divide(add(1)(exponentiate(add_bias(-input))(math.e)))(1)
+
+
+def inverse_square_law(source_strength: float, distance_metres: float) -> float:
+    """Calculates the inverse square law"""
+    ##TM255 block 1
+    four_times_pi = multiply(4)(math.pi)
+    denominator = multiply(SQUARE(distance_metres))(four_times_pi)
+    return divide(denominator)(source_strength)
+
+
+def taylor_series(value):
+    """Calculates the Taylor series of a value"""
+
+    # Written for sin and cos functions so may not be generic for pure Taylor Series functions.
+    def steps(
+        initial_value_in_series, increment=1, initial_denmoninator=1, steps=3, sign=-1
+    ):
+        taylor = [initial_value_in_series]
+        for _ in range(steps):
+            exponent = exponentiate(initial_denmoninator)
+            division = divide(factorial(initial_denmoninator))
+            taylor.append(division(exponent(value)))
+            initial_denmoninator += increment
+
+        for index in range(len(taylor)):
+            sign = -1 if sign == +1 else +1
+            taylor[index] = taylor[index] * sign
+
+        return reduce(lambda a, b: a + b, taylor)
+
+    return steps
+
+
+def herons_method(value: float):
+    """
+    O(log precision) method for calculating square roots. The square roots of two values (eg. 25, 2982186) will be calculated in the same number of cycles to the same precision
+    """
+    # www.youtube.com/watch?v=l2TCgS_eLwA
+    initial_estimate = value / 2
+    current_step = initial_estimate
+    epsilon = value * exponentiate(-9)(10)
+
+    while True:
+        next_step = 1 / 2 * (current_step + (value / current_step))
+        if next_step < epsilon:
+            break
+        current_step = next_step
+
+    return current_step

afmaths-2.0.4/lib/afmaths/geometry.py

@@ -0,0 +1,210 @@
+from astronomy_types import (
+    Coordinate2D,
+    Distance,
+    Eccentricity,
+    Radians,
+    Ratio,
+    Scalar,
+    SemiMajorAxis,
+    TrueAnomaly,
+)
+
+from .operation import (
+    HALF,
+    SQUARE,
+    add,
+    divide,
+    multiply,
+    subtract,
+)
+import math
+from .formula import taylor_series
+
+pythagoras = lambda a: lambda b: add(SQUARE(a))(SQUARE(b))
+
+
+def euclid(m: int, n: int) -> int:
+    """Given two positive integers, m and n, find their greatest common divisor which is the largest positive integer that divides both evenly."""
+
+    remainder = m % n
+    if remainder == 0:
+        return n
+    else:
+        m = n
+        n = remainder
+        euclid(m, n)
+    return n
+
+
+def sieve_of_eratosthenes(n: int) -> list[int]:
+    """Finds prime numbers up to n"""
+    # https://www.youtube.com/watch?v=fwxjMKBMR7s
+    numbers = [True] * n
+    primes = []
+
+    for index in range(2, n):
+        if numbers[index]:
+            primes.append(index)
+            for multiple in range(index * index, n, index):
+                numbers[multiple] = False
+
+    return primes
+
+
+def tangent(angle_degrees: float) -> float:
+    """Returns a value in radians"""
+    return divide(cosine(angle_degrees))(sine(angle_degrees))
+
+
+def arctangent(radians):
+    return math.degrees(math.atan(radians))
+
+
+def sine(angle_degrees: float) -> float:
+    """Returns a value in radians"""
+    return taylor_series(math.radians(angle_degrees))(math.radians(angle_degrees), 2, 3)
+
+
+def cosine(angle_degrees: float) -> float:
+    """Returns a value in radians"""
+    return taylor_series(math.radians(angle_degrees))(1, 2, 2)
+
+
+# TODO: Check naming, this may be valid for more than just right triangles
+def area_of_right_triangle(base_length: float, height_length: float) -> float:
+    """Area = base * height / 2"""
+    return HALF(multiply(base_length)(height_length))
+
+
+def area_of_quarter_circle(side_length: float, radius: float) -> float:
+    """Area = s^2 - ((1/4)*pi*r^2)"""
+    return subtract((1 / 4) * math.pi * SQUARE(radius))(SQUARE(side_length))
+
+
+def semi_major_axis_from_axes(a: float, b: float) -> SemiMajorAxis:
+    """Returns the semi major axis of an ellipse given the lengths of the two axes"""
+    return HALF(add(a)(b))
+
+
+def circle_bounding_box_from_coordinates(
+    coordinates: Coordinate2D, radius: float
+) -> tuple[Coordinate2D, Coordinate2D]:
+    """
+    Calculate the bounding box of a circle given its center coordinates and radius.
+
+    Parameters:
+    x (float): The x-coordinate of the circle's center.
+    y (float): The y-coordinate of the circle's center.
+    radius (float): The radius of the circle.
+
+    Returns:
+    tuple: A tuple containing the coordinates of the bounding box in the format (x0, y0, x1, y1).
+    """
+    return draw_circle_with_eccentricity(
+        coordinates, radius, Eccentricity(Ratio(Scalar(0)))
+    )
+
+
+def draw_circle_with_eccentricity(
+    coordinates: Coordinate2D, radius: float, eccentricity: Eccentricity
+) -> tuple[Coordinate2D, Coordinate2D]:
+    """
+    Calculate the bounding box of an ellipse given its center coordinates, radius, and eccentricity.
+
+    Parameters:
+    x (float): The x-coordinate of the ellipse's center.
+    y (float): The y-coordinate of the ellipse's center.
+    radius (float): The semi-major axis of the ellipse.
+    eccentricity (float): The eccentricity of the ellipse (0 <= eccentricity < 1).
+
+    Returns:
+    tuple: A tuple containing the coordinates of the bounding box in the format (x0, y0, x1, y1).
+    """
+    if eccentricity < 0 or eccentricity >= 1:
+        raise ValueError("Eccentricity must be in the range [0, 1).")
+
+    semi_minor_axis = radius * (1 - eccentricity**2) ** 0.5
+    x0 = coordinates.x - radius
+    y0 = coordinates.y - semi_minor_axis
+    x1 = coordinates.x + radius
+    y1 = coordinates.y + semi_minor_axis
+    return (Coordinate2D(x0, y0), Coordinate2D(x1, y1))
+
+
+def calculate_distance(
+    coordinates1: Coordinate2D, coordinates2: Coordinate2D
+) -> Distance:
+    """
+    Calculate the distance between two points in 2D space.
+
+    Parameters:
+    x1 (float): The x-coordinate of the first point.
+    y1 (float): The y-coordinate of the first point.
+    x2 (float): The x-coordinate of the second point.
+    y2 (float): The y-coordinate of the second point.
+
+    Returns:
+    float: The distance between the two points.
+    """
+    return (
+        (coordinates2.x - coordinates1.x) ** 2 + (coordinates2.y - coordinates1.y) ** 2
+    ) ** 0.5
+
+
+def calculate_foci(
+    semi_major_axis: SemiMajorAxis, eccentricity: Eccentricity
+) -> tuple[Coordinate2D, Coordinate2D]:
+    """
+    Calculate the coordinates of the foci of an ellipse given its semi-major axis and eccentricity.
+
+    Parameters:
+    a (float): The semi-major axis of the ellipse.
+    e (float): The eccentricity of the ellipse (0 <= eccentricity < 1).
+
+    Returns:
+    tuple: A tuple containing the coordinates of the two foci in the format ((x1, y1), (x2, y2)).
+    """
+    if eccentricity < 0 or eccentricity >= 1:
+        raise ValueError("Eccentricity must be in the range [0, 1).")
+
+    c = semi_major_axis * eccentricity
+    # [X1, Y1] = (-c, 0) and [X2, Y2] = (c, 0) for an ellipse centered at the origin
+    return (Coordinate2D(-c, 0), Coordinate2D(c, 0))
+
+
+def calculate_semi_major_axis(
+    radius: Distance, eccentricity: Eccentricity
+) -> SemiMajorAxis:
+    """
+    Calculate the semi-major axis of an ellipse given the distance from the center to a point on the ellipse and the eccentricity.
+
+    Parameters:
+    r (float): The distance from the center of the ellipse to a point on the ellipse.
+    e (float): The eccentricity of the ellipse (0 <= eccentricity < 1).
+
+    Returns:
+    float: The semi-major axis of the ellipse.
+    """
+    if eccentricity < 0 or eccentricity >= 1:
+        raise ValueError("Eccentricity must be in the range [0, 1).")
+
+    return SemiMajorAxis(Distance(Scalar(radius / (1 - eccentricity))))
+
+
+def calculate_semi_minor_axis(
+    semi_major_axis: SemiMajorAxis, eccentricity: Eccentricity
+) -> float:
+    """
+    Calculate the semi-minor axis of an ellipse given its semi-major axis and eccentricity.
+
+    Parameters:
+    a (float): The semi-major axis of the ellipse.
+    e (float): The eccentricity of the ellipse (0 <= eccentricity < 1).
+
+    Returns:
+    float: The semi-minor axis of the ellipse.
+    """
+    if eccentricity < 0 or eccentricity >= 1:
+        raise ValueError("Eccentricity must be in the range [0, 1).")
+
+    return semi_major_axis * (1 - eccentricity**2) ** 0.5

afmaths-2.0.4/lib/afmaths/graph.py

@@ -0,0 +1,38 @@
+from dataclasses import dataclass
+
+from operation import divide, multiply, subtract, termial
+
+
+@dataclass(frozen=True)
+class GraphCoordinates:
+    x: float
+    y: float
+
+
+def slope_gradiant(point1: GraphCoordinates, point2: GraphCoordinates) -> float:
+    """Calculates the slope between two points"""
+    ##https://www.bbc.co.uk/bitesize/topics/zvhs34j/articles/z4ctng8
+    return divide(subtract(point1.x)(point2.x))(subtract(point1.y)(point2.y))
+
+
+def equation_of_line(
+    point1: GraphCoordinates, point2: GraphCoordinates
+) -> tuple[float, float]:
+    """Returns the slope and y-intercept of the line passing through two points"""
+    ##m = gradient
+    m = slope_gradiant(point1, point2)
+    ##b = y intercept when x = 0
+    rhs = multiply(m)(point1.x)
+    b = subtract(rhs)(point1.y)
+    ##y = mx + b
+    return (m, b)
+
+
+def interpolations_for_bezier_curve(number_of_control_points: int) -> int:
+    """Calculates the number of interpolations needed for a bezier curve with a given number of control points
+    interpolations = n(n+1)/2
+    """
+    # if points < 2:
+    #   return 0
+    # return points - 1 + interpolations_for_bezier_curve(points - 1)
+    return termial(number_of_control_points)

afmaths-2.0.4/lib/afmaths/list.py

@@ -0,0 +1,63 @@
+import math
+import statistics
+from operation import divide, subtract
+
+
+def sort(number_list: list[float]) -> list[float]:
+    return sorted(number_list)
+
+
+def length(number_list: list[float]) -> int:
+    return len(number_list)
+
+
+def sum(number_list: list[float]) -> float:
+    return math.sum(number_list)
+
+
+def minimum(number_list: list[float]) -> float:
+    return min(number_list)
+
+
+def maximum(number_list: list[float]) -> float:
+    return max(number_list)
+
+
+def range(number_list: list[float]) -> float:
+    return subtract(minimum(number_list))(maximum(number_list))
+
+
+def mean(number_list: list[float]) -> float:
+    return divide(length(number_list))(sum(number_list))
+
+
+def median(number_list: list[float]) -> float:
+    return statistics.median(number_list)
+
+
+def quartiles(number_list: list[float]) -> tuple[float, float, float]:
+    """Calculates the quartiles of a list of numbers"""
+    number_list = sorted(number_list)
+    q1_index = int(math.ceil(length(number_list) * 0.25))
+    q1_result = number_list[q1_index - 1]
+    number_list[0 : length(number_list) // 2]
+    q3_result = median(number_list)
+    iqr_result = subtract(q1_result)(q3_result)
+
+    return q1_result, q3_result, iqr_result
+
+
+def dataplotter(number_list: list[float]) -> None:
+    ##MU123
+    """
+    Runs some useful functions on a provided list
+    """
+    sort(number_list)
+    length(number_list)
+    sum(number_list)
+    minimum(number_list)
+    maximum(number_list)
+    range(number_list)
+    mean(number_list)
+    median(number_list)
+    quartiles(number_list)