Add files via upload

Author: DDDKnightmare

.gitignore

@@ -0,0 +1,4 @@
+*.pyc
+*cache__/*
+*_cache
+.vscode/*

fuzzyRule.py

@@ -0,0 +1,49 @@
+from typing import List, Callable, Any, Tuple
+
+'''
+examples of rules: 
+- from left to right
+- no precedence
+
+rule:A and B or C
+variables: [A,B,C]
+operators: [and,or]
+
+rule: A or B and C
+variables: [A,[B,C]]
+operators: [or, and]
+
+rule: A and B or (B and C)
+variables: [A,B,[B,C]]
+operators: [and,or,and]
+
+rule: A and (B or C and A) or C and D
+variables: [A,[B,[C,A]],[C,D]]
+operators: [and, or, and, or, and]
+
+'''
+
+def compute_rule(variables:List[any], operators:List[Callable[[float, float], float]]) -> float:
+    val = compute_parenthesis(variables, operators, 0)[1]
+    # print(len(operators), op_idx)
+    return val
+
+def compute_parenthesis(variables:List[Any], operators:List[Callable[[float, float], float]], curr_idx: int) -> Tuple[int, float]:
+    tmp = variables[0]
+    if tmp is list:
+        curr_idx, tmp = compute_parenthesis(tmp, operators, curr_idx)
+    for var in variables[1:]:
+        if type(var) is list:
+            tmp_idx = curr_idx
+            curr_idx += 1
+            curr_idx, aux = compute_parenthesis(var, operators, curr_idx)
+        else:
+            aux = var
+            tmp_idx = None
+        if tmp_idx is not None:
+            tmp = operators[tmp_idx](tmp, aux)
+            tmp_idx = None
+        else:
+            tmp = operators[curr_idx](tmp, aux)
+            curr_idx += 1
+    return curr_idx, tmp

fuzzyVar.py

@@ -0,0 +1,20 @@
+from typing import Tuple, Dict, List, Callable, NoReturn
+
+class FuzzyVar:
+    # X, T, U, M
+    # X = base_value -> accessed using its index
+    # T = values -> list of different linguistic values for the variable
+    # U = universe -> meaning range -> using [0.,1.]
+    # M = meaning -> meaning of var with base_value x, for value t in T
+    def __init__(self, values: List[float], meaning:Dict[str, Callable[[float], float]]) -> NoReturn:
+        self.values:List[float] = values
+        self.meaning:Dict[str, Callable[[float], float]] = meaning
+    
+    def get_meaning(self, value:float, base_value:float) -> float:
+        meaning = self.meaning[value](base_value)
+        if meaning < 0.:
+            return 0.
+        elif meaning > 1.:
+            return 1.
+        else:
+            return meaning

operators.py

@@ -0,0 +1,82 @@
+from typing import Callable
+from math import pow
+from random import random
+
+class Operators:
+    def __init__(self, gama:float, p:float, alpha: float):
+        if p is None:
+            p = 1. + random()
+        elif p < 1.:
+            p = 1.
+        if gama is None:
+            gama = random()
+        elif gama < 0.:
+            gama = 0.
+        elif gama > 1.:
+            gama = 1.
+        if alpha is None:
+            alpha = random()
+        elif alpha < 0.:
+            alpha = 0.
+        elif alpha > 1.:
+            alpha = 1.
+        
+        self.p = p
+        self.alpha = alpha
+        self.gama = gama
+
+
+    def minimum(self, x: float, y: float) -> float:
+        return min(x,y)
+
+    def maximum(self, x: float, y: float) -> float:
+        return max(x,y)
+
+    def drastic_product(self, x:float, y:float) -> float:
+        if(max(x,y) == 1.):
+            return min(x,y)
+        else:
+            return 0.
+
+    def drastic_sum(self, x:float, y:float) -> float:
+        if(min(x,y) == 0.):
+            return max(x,y)
+        else:
+            return 1.
+
+    def bounded_difference(self, x:float, y:float) -> float:
+        return max(0., x + y - 1.)
+
+    def bounded_sum(self, x:float, y:float) -> float:
+        return min(1., x + y)
+
+    def einstein_product(self, x:float, y:float) -> float:
+        aux = x * y
+        return aux/(2. - x + y - aux)
+
+    def einstein_sum(self, x:float, y:float) -> float:
+        return (x + y)/(1. - x * y)
+
+    def hamacher_product(self, x:float, y:float) -> float:
+        aux = x * y
+        return aux / (x + y - aux)
+
+    def hamacher_sum(self, x:float, y:float) -> float:
+        aux = x * y
+        return (x + y - 2. * aux)/(1. - aux)
+    
+    def hamacher_union(self, x:float, y:float) -> float:
+        return ((self.gama - 1.) * y + x + y) / (1. + self.gama * x * y)
+    
+    def yaeger_intersection(self, x:float, y:float) -> float:
+        return 1 - min(1, pow(pow(1. - x, self.p) + pow(1. - y, self.p), self.p))
+    
+    def yaeger_union(self, x:float, y:float) -> float:
+        return min(1., pow((x ** self.p + y ** self.p), 1./self.p))
+    
+    def dubois_prade_intersection(self, x:float, y:float) -> float:
+        return (x * y)/(max(x, y, self.alpha))
+    
+    def union(self, x:float, y:float) -> float:
+        return x + y - x * y - min(x, y, 1. - self.alpha)/max(1. - x, 1. - y, self.alpha)
+    

readme.md

@@ -0,0 +1,53 @@
+
+# Mini Fuzzy Solver
+
+This package implements a simple normalized fuzzy solver
+
+## Classes
+
+---
+
+### FuzzyVar
+
+- Retains info about the fuzzy variables
+  - List of linguistic values
+  - Meaning function for each linguistic value
+
+---
+
+### Operators
+
+- Define the operators and parameters used in each operator(minimum, maximum, union, intersect, etc)
+
+### How to use
+
+1. Define your fuzzy variables
+
+   __a)__ Base variables
+   __b)__ Linguistic values
+   __c)__ Meaning functions
+
+2. Decide on wich operators to use for each operator(and, or, union, intersection, etc) in your logic
+
+3. Use __fuzzyRule.py__ computeRules function
+
+---
+
+### How to define rules
+
+The rules are executed from left to right.
+> A and B or C -> [ [A, B, C], [and, or] ]
+> A or B and C -> [ [ [A, B], C], [or, and] ]
+> A and B or C and D -> [ [ [A, B], [C, D]], [and, or, and] ]
+> A and (B or C) -> [ [A, [B, C] ], [and, or]]
+> A and (B or C or D) and D -> [ [A, [B, C, D], D], [and, or, or, and] ]
+---
+
+### Example
+
+```python
+BASE_VARIABLES = List[float]
+MEANING = List[Dict[str,float]]
+FUZZY_VARS = List[FuzzyVar]
+FUZZY_RULES = List[Tuple[List[Any '''float or list'''],]]
+```

test.py

@@ -0,0 +1,71 @@
+from fuzzyVar import FuzzyVar
+from math import pi, sin, cos
+from typing import Dict, List, Tuple, Any, Callable, NoReturn
+from fuzzyRule import compute_rule 
+from operators import Operators
+
+
+
+# type definitions
+BASE_VALUES = List[float] # variable base values 
+MEANING = List[Dict[str, float]] # variable meaning values
+FUZZY_VARS = List[FuzzyVar] # FuzzyVarObjects
+FUZZY_RULES = List[Tuple[List[Any],List[Callable[[float, float], float]]]] # list [([var1,[var2_1,var2_2], var3], [op1_2, op2, op2_3])]
+VAR_DICT = Dict[str,int] # dictionary of fuzzy variable names to meaning/fuzzyVar/baseValue index
+OP = Operators
+
+VAR_DICT = {
+    "A": 0.,
+    "B": 1.
+}        
+
+BASE_VALUES = [4,56]
+
+MEANING = [
+    {
+        "low":0.,
+        "high":0.
+    },{
+        "none":0.,
+        "some":0.,
+        "every":0.
+    }
+]
+
+FUZZY_VARS = [
+    FuzzyVar(["low", "high"], {
+        "low": lambda x: 20 - x**3/2, 
+        "high": lambda x: x**3/5. 
+        }
+    ),
+    FuzzyVar(["none", "some", "every"], {
+        "none": lambda x: 1. if x <= 0. else 0.,
+        "some": lambda x: cos(x * pi) * sin(x * pi),
+        "every": lambda x: 1. if x == 1. else 0.
+    })
+]
+
+OP = Operators(0.5,0.5,0.5)
+
+def calculate_base_meaning(meaning_list:List[Dict[str,float]]) -> NoReturn:
+    for idx, var in enumerate(FUZZY_VARS):
+        for name in var.values:
+            meaning_list[idx][name] = var.get_meaning(name, BASE_VALUES[idx])
+
+calculate_base_meaning(MEANING)
+# print(MEANING)
+
+A = VAR_DICT["A"]
+B = VAR_DICT["B"]
+
+FUZZY_RULES = [
+    ([A,B,[B,A]], [OP.bounded_difference, OP.bounded_sum, OP.drastic_product]),
+    ([A,B,[B,A]], [OP.drastic_sum, OP.dubois_prade_intersection, OP.einstein_product]),
+    ([A,B,[B,A]], [OP.einstein_sum, OP.hamacher_product, OP.hamacher_sum]),
+    ([A,B,[B,A]], [OP.hamacher_union, OP.maximum, OP.minimum]),
+    ([A,B,[B,A]], [OP.union, OP.yaeger_intersection, OP.yaeger_union])
+]
+
+for x, y in FUZZY_RULES:
+    # print(x, y)
+    compute_rule(x, y)