math-tompy 2024.8.13.13.26__tar.gz

math_tompy-2024.8.13.13.26/.gitignore

@@ -0,0 +1,4 @@
+.idea/
+__pycache__/
+venv*/
+dist/

math_tompy-2024.8.13.13.26/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.3
+Name: math-tompy
+Version: 2024.8.13.13.26
+Summary: Extra math for tompy projects
+Author: tompy
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+Extra math for tompy projects

math_tompy-2024.8.13.13.26/README.md

@@ -0,0 +1 @@
+Extra math for tompy projects

math_tompy-2024.8.13.13.26/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "math-tompy"
+version = "2024.08.13.13.26"
+dependencies = []
+authors = [
+    { name = "tompy" },
+]
+description = "Extra math for tompy projects"
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3.9",
+    "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
+    "Operating System :: OS Independent",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/math_tompy"]

math_tompy-2024.8.13.13.26/src/math_tompy/decimal.py

@@ -0,0 +1,27 @@
+from decimal import Decimal
+
+
+def normalize_value(value: Decimal, minimum: Decimal, maximum: Decimal) -> Decimal:
+    """Scale value position between minimum and maximum to [0:1] bound"""
+
+    # Scale value and maximum relative to zero to enable finding fractional value by straightforward division
+    zero_scaled_value: Decimal = value - minimum
+    zero_scaled_maximum: Decimal = maximum - minimum
+
+    # Divide scaled values
+    normalized_value: Decimal = zero_scaled_value / zero_scaled_maximum
+
+    return normalized_value
+
+
+def clamp_or_normalize_value(value: Decimal, minimum: Decimal, maximum: Decimal) -> Decimal:
+    new_value: Decimal
+
+    if value < minimum:
+        new_value = Decimal("0.0")
+    elif value > maximum:
+        new_value = Decimal("1.0")
+    else:
+        new_value = normalize_value(value=value, minimum=minimum, maximum=maximum)
+
+    return new_value

math_tompy-2024.8.13.13.26/src/math_tompy/float.py

@@ -0,0 +1,52 @@
+from enum import Enum, auto
+from math import inf
+from random import normalvariate
+
+Variability = float
+
+
+class Rounding(Enum):
+    ROUND = auto()
+    CEILING = auto()
+    FLOOR = auto()
+
+
+def round_to_nearest_multiple(number, round_to, rounding: Rounding = Rounding.ROUND):
+    if round_to <= 0:
+        raise ValueError(f"Rounding factor can not be 0 or negative.")
+
+    remainder = number % round_to
+
+    if rounding == Rounding.ROUND:
+        nearest = number + round_to - remainder if 2 * remainder >= round_to else number - remainder
+    elif rounding == Rounding.CEILING:
+        nearest = number + round_to - remainder
+    elif rounding == Rounding.FLOOR:
+        nearest = number - remainder
+    else:
+        raise ValueError(f"rounding is not a valid Rounding value: '{rounding}")
+
+    return nearest
+
+
+def get_variability_amount(variability: Variability,
+                           coloring_image_axis_size: int) -> float:
+    if variability == 0.0:
+        variability_amount: float = variability
+    else:
+        # TODO: get scaled or truncated value rather than retrying until value generated that fits in desired range
+        #       search term: Truncated normal distribution
+        # https://scipy.github.io/devdocs/reference/generated/scipy.stats.truncnorm.html
+        # https://github.com/jessemzhang/tn_test/blob/master/truncated_normal/truncated_normal.py
+        # package name: truncnorm
+        # package name: pydistributions
+        variation_value: float = inf
+        while variation_value < -1.0 or variation_value > 1.0:
+            variation_value: float = normalvariate(mu=0.0, sigma=0.25)
+
+        # Maximum extent of axis considered around point
+        variability_radius: float = variability * coloring_image_axis_size
+        # Specific extent selected with normal distribution value
+        variability_amount: float = variation_value * variability_radius
+
+    return variability_amount

math_tompy-2024.8.13.13.26/src/math_tompy/special.py

@@ -0,0 +1,84 @@
+from decimal import Decimal
+from fractions import Fraction
+from typing import NamedTuple
+
+# TODO: use Numeric to make parts of this more generic
+Numeric = int | float | Decimal | Fraction
+
+# TODO: Point1Df as Vector1 in Decimal
+Point1Df = float
+Point2Df = tuple[float, float]
+Point1Di = int
+Point2Di = tuple[int, int]
+
+
+class Range1Df(NamedTuple):
+    minimum: float
+    maximum: float
+
+    # TODO: implement as __len__
+    def size(self) -> float:
+        # Measuring stretch between fence posts
+        # TODO: confirm that '1.0' should not be added here, because it is measuring between, not at
+        return self.maximum - self.minimum + 1.0
+        # return self.maximum - self.minimum
+
+
+class Range1Di(NamedTuple):
+    minimum: int
+    maximum: int
+
+    # TODO: implement as __len__
+    def size(self) -> int:
+        # Measuring amount of fence posts
+        return self.maximum - self.minimum + 1
+
+
+class Range2Df(NamedTuple):
+    x_axis: Range1Df
+    y_axis: Range1Df
+
+    def area(self) -> float:
+        return self.x_axis.size() * self.y_axis.size()
+
+
+class Range2Di(NamedTuple):
+    x_axis: Range1Di
+    y_axis: Range1Di
+
+    def area(self) -> float:
+        return self.x_axis.size() * self.y_axis.size()
+
+
+# TODO: improve naming with words specific to bucketed int values and tiny-mini float values
+def clamp_svg_value_to_range(svg_image_point: Point1Df, svg_image_axis: Range1Df) -> Point1Df:
+    value: Point1Df
+    if svg_image_point < svg_image_axis.minimum:
+        value = svg_image_axis.minimum
+    elif svg_image_point > svg_image_axis.maximum:
+        value = svg_image_axis.maximum
+    else:
+        value = svg_image_point
+    return value
+
+
+# TODO: improve naming with words specific to bucketed int values and tiny-mini float values
+def clamp_image_value_to_range(coloring_image_point: Point1Di, coloring_image_axis: Range1Di) -> Point1Di:
+    value: Point1Di
+    if coloring_image_point < coloring_image_axis.minimum:
+        value = coloring_image_axis.minimum
+    elif coloring_image_point > coloring_image_axis.maximum:
+        value = coloring_image_axis.maximum
+    else:
+        value = coloring_image_point
+    return value
+
+
+# TODO: make naming generic to not focus on
+def get_coloring_image_fraction(svg_image_point: Point1Df,
+                                svg_axis_range: Range1Df) -> float:
+    clamped_svg_image_y_axis_point: Point1Df = clamp_svg_value_to_range(svg_image_point=svg_image_point,
+                                                                        svg_image_axis=svg_axis_range)
+    axis_scaler: float = 1.0 / svg_axis_range.size()
+    coloring_image_scaled_y_axis_point: float = clamped_svg_image_y_axis_point * axis_scaler
+    return coloring_image_scaled_y_axis_point