fixed tests

Author: amogorkon

src/fuzzylogic/estimate.py

@@ -18,11 +18,23 @@
 from itertools import permutations
 from random import choice, randint
 from statistics import median
-from typing import Callable
 
 import numpy as np
 
-from .functions import R, S, constant, gauss, rectangular, sigmoid, singleton, step, trapezoid, triangular
+from .classes import Array
+from .functions import (
+    Membership,
+    R,
+    S,
+    constant,
+    gauss,
+    rectangular,
+    sigmoid,
+    singleton,
+    step,
+    trapezoid,
+    triangular,
+)
 
 np.seterr(all="raise")
 functions = [step, rectangular]
@@ -33,13 +45,13 @@
 argument4_functions = [trapezoid]
 
 
-def normalize(target: np.ndarray, output_length: int = 16) -> np.ndarray:
+def normalize(target: Array, output_length: int = 16) -> Array:
     """Normalize and interpolate a numpy array.
 
     Return an array of output_length and normalized values.
     """
-    min_val = np.min(target)
-    max_val = np.max(target)
+    min_val = float(np.min(target))
+    max_val = float(np.max(target))
     if min_val == max_val:
         return np.ones(output_length)
     normalized_array = (target - min_val) / (max_val - min_val)
@@ -49,13 +61,12 @@ def normalize(target: np.ndarray, output_length: int = 16) -> np.ndarray:
     return normalized_array
 
 
-def guess_function(target: np.ndarray) -> Callable:
+def guess_function(target: Array) -> Membership:
     normalized = normalize(target)
-    # trivial case
     return constant if np.all(normalized == 1) else singleton
 
 
-def fitness(func: Callable, target: np.ndarray, certainty: int | None = None) -> float:
+def fitness(func: Membership, target: Array, certainty: int | None = None) -> float:
     """Compute the difference between the array and the function evaluated at the parameters.
 
     if the error is 0, we have a perfect match: fitness -> 1
@@ -66,7 +77,7 @@ def fitness(func: Callable, target: np.ndarray, certainty: int | None = None) ->
     return result if certainty is None else round(result, certainty)
 
 
-def seed_population(func: Callable, target: np.ndarray) -> dict[tuple, float]:
+def seed_population(func: Membership, target: Array) -> dict[tuple, float]:
     # create a random population of parameters
     params = [p for p in inspect.signature(func).parameters.values() if p.kind == p.POSITIONAL_OR_KEYWORD]
     seed_population = {}
@@ -106,7 +117,7 @@ def reproduce(parent1: tuple, parent2: tuple) -> tuple:
 
 
 def guess_parameters(
-    func: Callable, target: np.ndarray, precision: int | None = None, certainty: int | None = None
+    func: Membership, target: Array, precision: int | None = None, certainty: int | None = None
 ) -> tuple:
     """Find the best fitting parameters for a function, targetting an array.
 
@@ -188,7 +199,7 @@ def best() -> tuple:
     return best()
 
 
-def shave(target: np.ndarray, components: dict[Callable, tuple]) -> np.ndarray:
+def shave(target: Array, components: dict[Membership, tuple]) -> Array:
     """Remove the membership functions from the target array."""
     result = np.zeros_like(target)
     for func, params in components.items():

src/fuzzylogic/neural_network.py

@@ -2,6 +2,7 @@
 
 import numpy as np
 
+from .classes import Array
 from .functions import R, S, constant, gauss, rectangular, sigmoid, singleton, step, trapezoid, triangular
 
 functions = [step, rectangular]
@@ -12,7 +13,7 @@
 argument4_functions = [trapezoid]
 
 
-def generate_examples() -> dict[str, list[np.ndarray]]:
+def generate_examples() -> dict[str, list[Array]]:
     examples = defaultdict(lambda: [])
     examples["constant"] = [np.ones(16)]
     for x in range(16):

tests/test_caro.py

@@ -1,5 +1,6 @@
 import numpy as np
-from fuzzylogic.classes import Domain, Rule
+
+from fuzzylogic.classes import Domain, Rule, rule_from_table
 from fuzzylogic.functions import R, S, trapezoid
 
 temp = Domain("Temperatur", -30, 100, res=0.0001)  # ,res=0.1)
@@ -38,7 +39,6 @@
 temp.heiß	gef.klein	gef.groß	gef.groß
 """
 
-from fuzzylogic.classes import rule_from_table
 
 table_rules = rule_from_table(table, globals())
 
@@ -47,4 +47,4 @@
 value = {temp: 20, tan: 0.55}
 result = rules(value)
 assert isinstance(result, float)
-assert np.isclose(result, 0.45, atol=0.0001)
+assert np.isclose(result, -0.5, atol=0.0001)

tests/test_functionality.py

@@ -13,7 +13,7 @@
 
 
 @fixture
-def temp():
+def temp() -> Domain:
     d = Domain("temperature", -100, 100, res=0.1)  # in Celsius
     d.cold = S(0, 15)  # sic
     d.hot = Set(R(10, 30))  # sic
@@ -22,24 +22,24 @@ def temp():
 
 
 @fixture
-def simple():
+def simple() -> Domain:
     d = Domain("simple", 0, 10)
     d.low = S(0, 1)
     d.high = R(8, 10)
     return d
 
 
-def test_array(simple):
+def test_array(simple: Domain) -> None:
     assert array_equal(simple.low.array(), [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
     assert array_equal(simple.high.array(), [0, 0, 0, 0, 0, 0, 0, 0, 0, 0.5, 1.0])
     assert len(simple.low.array()) == 11  # unlike arrays and lists, upper boundary is INCLUDED
 
 
-def test_value(temp):
+def test_value(temp: Domain) -> None:
     assert temp(6) == {temp.cold: 0.6, temp.hot: 0, temp.warm: 0.4}
 
 
-def test_rating():
+def test_rating() -> None:
     """Tom is surveying restaurants.
     He doesn't need fancy logic but rather uses a simple approach
     with weights.
@@ -61,7 +61,7 @@ def test_rating():
     weights = {"beverage": 0.3, "atmosphere": 0.2, "looks": 0.2, "taste": 0.3}
     w_func = weighted_sum(weights=weights, target_d=R)
 
-    ratings = {
+    ratings: dict[str, float] = {
         "beverage": R.min(9),
         "atmosphere": R.min(5),
         "looks": R.min(4),