aggregationslib 0.0.0__py3-none-any.whl

aggregationslib/aggregation.py

@@ -0,0 +1,186 @@
+import math
+import warnings
+from decimal import Decimal
+
+import numpy as np
+from pynverse.inverse import inversefunc
+
+
+# 1 Arithmetic aggregation
+def arithmetic(y):
+    """
+    Arithmetic aggregation
+    :param y: 1 dimensional array
+    :return: aggregation value
+    """
+    if np.ndim(y) != 1:
+        raise ValueError("y must be 1 dimensional array")
+    return np.mean(y)
+
+
+# 2
+def quadratic(y):
+    if np.ndim(y) != 1:
+        raise ValueError("y must be 1 dimensional array")
+    y = np.array(y)
+    size = len(y)
+    with np.errstate(divide='ignore'):
+        return np.sqrt(np.sum(y ** 2) / size)
+
+
+# 3
+def geometric(y):
+    if np.ndim(y) != 1:
+        raise ValueError("y must be 1 dimensional array")
+
+    size = len(y)
+    wk = 1 / size
+    with np.errstate(divide='ignore'):
+        return np.prod(y ** wk)
+
+
+# 4
+def harmonic(y):
+    if np.ndim(y) != 1:
+        raise ValueError("y must be 1 dimensional array")
+    if type(y).__module__ != np.__name__:
+        y = np.array(y)
+    size = len(y)
+    return size / (np.sum(1 / y))
+
+
+# 5
+def power(y, r=1):
+    if np.ndim(y) != 1:
+        raise ValueError("y must be 1 dimensional array")
+    if r == 0:
+        raise ValueError("parameter r cannot be equal to 0 ")
+    # If one 0 occur in array then mean is 0
+    if 0 in y and r < 0:
+        return 0
+    else:
+        result = (np.sum(y ** r) / y.shape[0]) ** (1 / r)
+        return result
+
+
+# 6
+def exponential(y, r=1):
+    if np.ndim(y) != 1:
+        raise ValueError("y must be 1 dimensional array")
+    if r == 0:
+        raise ValueError("parameter r should be != 0 ")
+    size = len(y)
+    y = np.array(y)
+    with np.errstate(divide='ignore'):
+        return (1 / r) * np.lib.scimath.log(np.sum(np.exp(y * r)) / size)
+
+
+# 7
+def lehmer(y, r=0):
+    if np.ndim(y) != 1:
+        raise ValueError("y must be 1 dimensional array")
+    # if  array and r below 0 return 0. 0 to power of 0.
+    if 0 in y and r - 1 <= 0:
+        return 0
+    else:
+        r2 = (r - 1)
+        nominator = np.sum(y ** r)
+        with np.errstate(divide='ignore'):  #
+            denominator = np.sum(y ** r2)
+        if denominator == 0:
+            return 0
+        else:
+            return nominator / denominator
+
+
+# 8
+def arithmetic_min(y, p=0):
+    if np.ndim(y) != 1:
+        raise ValueError("y must be 1 dimensional array")
+    min = np.min(y)
+    return p * np.mean(y) + (1 - p) * min
+
+
+# 9
+def arithmetic_max(y, p=0):
+    if np.ndim(y) != 1:
+        raise ValueError("y must be 1 dimensional array")
+    max = np.max(y)
+    return p * np.mean(y) + (1 - p) * max
+
+
+# 10
+def median(y):
+    if np.ndim(y) != 1:
+        raise ValueError("y must be 1 dimensional array")
+    return np.median(y)
+
+
+# 11
+def olimpic(y):
+    if np.ndim(y) != 1:
+        raise ValueError("y must be 1 dimensional array")
+    # b = np.max(a, 0)  # max
+    # c = np.min(a, 0)  # min
+    if len(y) < 3:
+        return np.mean(y)
+    else:
+        d = np.sort(y)[1:-1]
+        return np.mean(d)
+
+
+def exponential2(y, p=0, q=0):
+    if np.ndim(y) != 1:
+        raise ValueError("y must be 1 dimensional array")
+    y = np.array(y)
+    mean = np.mean(p ** (q ** y))
+    firstlog = math.log(mean, p)
+    result = math.log(firstlog, q)
+    return result
+
+
+def exponential3(y, p=0, q=0):
+    if np.ndim(y) != 1:
+        raise ValueError("y must be 1 dimensional array")
+    y = np.array(y)
+    result = (1 / q) * math.log(np.mean(p ** (q * y)), p)
+    return result
+
+
+def sin_aggregation(y):
+    '''
+
+    :param y:
+    :return:
+    '''
+    # Check if 1 dimensional array
+    if np.ndim(y) != 1:
+        raise ValueError("y must be 1 dimensional array")
+    n = len(y)
+    return math.asin(np.sum(np.sin(y)) / n)
+
+
+def quasi_arithmeric(y, function):
+    """
+    Quasi arithmetic mean.
+
+    If function f(x)=x to then quasi-arithmetic mean is aritmetic mean.
+    If function f(x)=x^p (p != 0) then quasi-arithmetic mean is power mean to p power.
+    If function f(x)=log x then quasi-arithmetic mean is geometric mean.
+
+    :param y: 1 dimmensional array
+    :param function: function which maps an interval I of the real line to the real numbers, and is both continuous and injective
+    :return: aggregation value
+    """
+    # Check if 1 dimensional array
+    if np.ndim(y) != 1:
+        raise ValueError("y must be 1 dimensional array")
+    n = len(y)
+    apply_func = np.array([function(x) for x in y])
+    value = np.sum(apply_func) / n
+    return inversefunc(function, value)
+
+
+if __name__ == "__main__":
+    print(quasi_arithmeric.__str__())
+    print(arithmetic_min([0.2, 0.4, 0.6], 0))

aggregationslib/aggregations.py

@@ -0,0 +1,638 @@
+import itertools
+import math
+
+import numpy as np
+import re
+
+
+class A_mn:
+    """
+    Minimum
+    """
+
+    name = 'mn'
+
+    def __init__(self):
+        pass
+
+    def __call__(self, array):
+        if np.ndim(array) != 1:
+            raise ValueError("y must be 1 dimensional array")
+        return np.min(array)
+
+    def __repr__(self):
+        return f"A_mn()"
+
+    def __str__(self):
+        return f"A_mn"
+
+    def toLatex(self, params: str):
+        return f"A_{{mn}}({params})"
+
+
+class A_mx:
+    """
+    Maximum
+    """
+
+    name = 'mx'
+
+    def __init__(self):
+        pass
+
+    def __call__(self, array):
+        if np.ndim(array) != 1:
+            raise ValueError("y must be 1 dimensional array")
+        return np.max(array)
+
+    def __repr__(self):
+        return f"A_mx()"
+
+    def __str__(self):
+        return f"A_mx"
+
+    def toLatex(self, params: str):
+        return f"A_{{mx}}({params})"
+
+class A_pr:
+    """
+    Product
+    """
+
+    name = 'pr'
+
+    def __init__(self):
+        pass
+
+    def __call__(self, array):
+        return np.prod(array, axis=0)
+
+    def __repr__(self):
+        return f"A_pr()"
+
+    def __str__(self):
+        return f"A_pr"
+
+    def toLatex(self, params: str):
+        return f"A_{{pr}}({params})"
+
+class A_ar:
+    """
+    Arithmetic mean
+    """
+
+    name = 'ar'
+
+    def __init__(self):
+        pass
+
+    def __call__(self, array):
+        """
+        Arithmetic aggregation
+        :param y: 1 dimensional array
+        :return: aggregation value
+        """
+        if np.ndim(array) != 1:
+            raise ValueError("y must be 1 dimensional array")
+        return np.mean(array)
+
+    def __repr__(self):
+        return f"A_ar()"
+
+    def __str__(self):
+        return f"A_ar"
+
+    def toLatex(self, params: str):
+        return f"A_{{ar}}({params})"
+
+
+class A_qd:
+    """
+    Quadratic mean
+    """
+
+    name = 'qd'
+
+    def __init__(self):
+        pass
+
+    def __call__(self, array):
+        if np.ndim(array) != 1:
+            raise ValueError("y must be 1 dimensional array")
+        y = np.array(array)
+        size = len(y)
+        with np.errstate(divide='ignore'):
+            return np.sqrt(np.sum(y ** 2) / size)
+
+    def __repr__(self):
+        return f"A_qd()"
+
+    def __str__(self):
+        return f"A_qd"
+
+    def toLatex(self, params: str):
+        return f"A_{{qd}}({params})"
+
+
+class A_gm:
+    """
+    Geometric mean
+    """
+
+    name = 'gm'
+
+    def __init__(self):
+        pass
+
+    def __call__(self, array):
+        if np.ndim(array) != 1:
+            raise ValueError("y must be 1 dimensional array")
+        size = len(array)
+        wk = 1 / size
+        with np.errstate(divide='ignore'):
+            return np.prod(array ** wk)
+
+    def __repr__(self):
+        return f"A_gm()"
+
+    def __str__(self):
+        return f"A_gm"
+
+    def toLatex(self, params: str):
+        return f"A_{{gm}}({params})"
+
+
+
+class A_hm:
+    """
+    Harmonic mean
+    """
+
+    name = 'hm'
+
+    def __init__(self):
+        pass
+
+    def __call__(self, array):
+        if np.ndim(array) != 1:
+            raise ValueError("y must be 1 dimensional array")
+        y = np.array(array)
+        size = len(y)
+        return size / (np.sum(1 / y))
+
+    def __repr__(self):
+        return f"A_hm()"
+
+    def __str__(self):
+        return f"A_hm"
+
+    def toLatex(self, params: str):
+        return f"A_{{hm}}({params})"
+
+
+class A_pw:
+    """
+    Power mean
+    """
+
+    name = 'pw'
+
+    valid_params = ["r"]
+
+    def __init__(self, r):
+        self.__r = r
+
+    def __call__(self, array):
+        if np.ndim(array) != 1:
+            raise ValueError("y must be 1 dimensional array")
+        if self.__r == 0:
+            raise ValueError("parameter r cannot be equal to 0 ")
+        # If one 0 occur in array then mean is 0
+        if 0 in array and self.__r < 0:
+            return 0
+        else:
+            result = (np.sum(array ** self.__r) / array.shape[0]) ** (1 / self.__r)
+            return result
+
+    def __repr__(self):
+        return f"A_pw(r={self.__r})"
+
+    def __str__(self):
+        return f"A_pw({self.__r})"
+
+    def toLatex(self, params: str):
+        return f"A_{{pw}}^{{{self.__r}}}({params})"
+
+
+class A_ex:
+    """
+     Exponential mean
+     """
+
+    name = 'ex'
+
+    valid_params = ["r"]
+
+    def __init__(self, r):
+        self.__r = r
+
+    def __call__(self, array):
+        if np.ndim(array) != 1:
+            raise ValueError("y must be 1 dimensional array")
+        if self.__r == 0:
+            raise ValueError("parameter r should be != 0 ")
+        size = len(array)
+        y = np.array(array)
+        with np.errstate(divide='ignore'):
+            return (1 / self.__r) * np.lib.scimath.log(np.sum(np.exp(y * self.__r)) / size)
+
+    def __repr__(self):
+        return f"A_ex(r={self.__r})"
+
+    def __str__(self):
+        return f"A_ex({self.__r})"
+
+    def toLatex(self, params: str):
+        return f"A_{{ex}}^{{{self.__r}}}({params})"
+
+
+
+class A_ex2:
+    """
+    Exponential2 mean
+    """
+
+    name = 'ex2'
+    valid_params = ["p", "q"]
+
+    def __init__(self, p, q):
+        self.__p = p
+        self.__q = q
+
+    def __call__(self, array):
+        if np.ndim(array) != 1:
+            raise ValueError("y must be 1 dimensional array")
+        y = np.array(array)
+        mean = np.mean(self.__p ** (self.__q ** y))
+        firstlog = math.log(mean, self.__p)
+        result = math.log(firstlog, self.__q)
+        return result
+
+    def __repr__(self):
+        return f"A_ex2(p={self.__p}, q={self.__q})"
+
+    def __str__(self):
+        return f"A_ex2({self.__p}, {self.__q})"
+
+    def toLatex(self, params: str):
+        return f"A_{{ex2}}^{{p={self.__p}, q={self.__q}}}({params})"
+
+
+class A_ex3:
+    """
+    Exponential3 mean
+    """
+
+    name = 'ex3'
+    valid_params = ["p", "q"]
+
+    def __init__(self, p, q):
+        self.__p = p
+        self.__q = q
+
+    def __call__(self, array):
+        if np.ndim(array) != 1:
+            raise ValueError("y must be 1 dimensional array")
+        y = np.array(array)
+        result = (1 / self.__q) * math.log(np.mean(self.__p ** (self.__q * y)), self.__p)
+        return result
+
+    def __repr__(self):
+        return f"A_ex3(p={self.__p}, q={self.__q})"
+
+    def __str__(self):
+        return f"A_ex3({self.__p}, {self.__q})"
+
+    def toLatex(self, params: str):
+        return f"A_{{ex3}}^{{p={self.__p}, q={self.__q}}}({params})"
+
+
+class A_lm:
+    """
+    Lehmer mean
+    """
+
+    name = 'lm'
+    valid_params = ["r"]
+
+    def __init__(self, r):
+        self.__r = r
+
+    def __call__(self, array):
+        if np.ndim(array) != 1:
+            raise ValueError("y must be 1 dimensional array")
+        # if  array and r below 0 return 0. 0 to power of 0.
+        if 0 in array and self.__r - 1 <= 0:
+            return 0
+        else:
+            r2 = (self.__r - 1)
+            nominator = np.sum(array ** self.__r)
+            with np.errstate(divide='ignore'):  #
+                denominator = np.sum(array ** r2)
+            if denominator == 0:
+                return 0
+            else:
+                return nominator / denominator
+
+    def __repr__(self):
+        return f"A_lm(r={self.__r})"
+
+    def __str__(self):
+        return f"A_lm({self.__r})"
+
+    def toLatex(self, params: str):
+        return f"A_{{lm}}^{{r={self.__r}}}({params})"
+
+
+class A_amn:
+    """
+    Arithmetic minimum mean
+    """
+
+    name = 'amn'
+    valid_params = ["p"]
+
+    def __init__(self, p):
+        self.__p = p
+
+    def __call__(self, array):
+        if np.ndim(array) != 1:
+            raise ValueError("y must be 1 dimensional array")
+        min_val = np.min(array)
+        return self.__p * np.mean(array) + (1 - self.__p) * min_val
+
+    def __repr__(self):
+        return f"A_amn(p={self.__p})"
+
+    def __str__(self):
+        return f"A_amn({self.__p})"
+
+    def toLatex(self, params: str):
+        return f"A_{{amn}}^{{p={self.__p}}}({params})"
+
+
+class A_amx:
+    """
+    Arithmetic maximum mean
+    """
+
+    name = 'amx'
+    valid_params = ["p"]
+
+    def __init__(self, p):
+        self.__p = p
+
+    def __call__(self, array):
+        if np.ndim(array) != 1:
+            raise ValueError("y must be 1 dimensional array")
+        max_val = np.max(array)
+        return self.__p * np.mean(array) + (1 - self.__p) * max_val
+
+    def __repr__(self):
+        return f"A_amx(p={self.__p})"
+
+    def __str__(self):
+        return f"A_amx({self.__p})"
+
+    def toLatex(self, params: str):
+        return f"A_{{amx}}^{{p={self.__p}}}({params})"
+
+
+class A_md:
+    """
+    Median (Ordered weighted aggregation)
+    """
+
+    name = 'md'
+
+    def __init__(self):
+        pass
+
+    def __call__(self, array):
+        if np.ndim(array) != 1:
+            raise ValueError("y must be 1 dimensional array")
+        return np.median(array)
+
+    def __repr__(self):
+        return f"A_md()"
+
+    def __str__(self):
+        return f"A_md"
+
+    def toLatex(self, params: str):
+        return f"A_{{md}}({params})"
+
+
+class A_ol:
+    """
+    Olimpic mean
+    """
+
+    name = 'ol'
+
+    def __init__(self):
+        pass
+
+    def __call__(self, array):
+        if np.ndim(array) != 1:
+            raise ValueError("y must be 1 dimensional array")
+        if len(array) < 3:
+            return np.mean(array)
+        else:
+            d = np.sort(array)[1:-1]
+            return np.mean(d)
+
+    def __repr__(self):
+        return f"A_ol()"
+
+    def __str__(self):
+        return f"A_ol"
+
+    def toLatex(self, params: str):
+        return f"A_{{ol}}({params})"
+
+
+class A_oln:
+    """
+    Generalized olimpic mean
+    """
+
+    name = 'oln'
+    valid_params = ['n']
+
+    def __init__(self, n):
+        self.__n = n
+
+    def __call__(self, array):
+        if np.ndim(array) != 1:
+            raise ValueError("y must be 1 dimensional array")
+        if len(array) <= self.__n * 2:
+            return np.mean(array)
+        else:
+            d = np.sort(array)[self.__n:-self.__n]
+            return np.mean(d)
+
+    def __repr__(self):
+        return f"A_oln(n={self.__n})"
+
+    def __str__(self):
+        return f"A_oln({self.__n})"
+
+    def toLatex(self, params: str):
+        return f"A_{{oln}}^{{n={self.__n}}}({params})"
+
+
+# TODO test this aggregation
+class A_lo:
+    """
+    Generalized logarithmic mean
+    If large number of arguments its numerically unstable
+    """
+
+    name = 'lo'
+
+    def __init__(self):
+        pass
+
+    def __call__(self, array):
+        if np.ndim(array) != 1:
+            raise ValueError("y must be 1 dimensional array")
+        fact = math.factorial(len(array) - 1)
+        sum_ = 0
+        for i in range(len(array)):
+            prod_ = 1
+            for j in range(len(array)):
+                if i != j:
+                    if array[j] == 0: return 0
+                    prod_ *= math.log(array[i] / array[j])
+            sum_ += array[i] / prod_
+        return fact * sum_
+
+    def __repr__(self):
+        return f"A_lo()"
+
+    def __str__(self):
+        return f"A_lo"
+
+    def toLatex(self, params: str):
+        return f"A_{{lo}}({params})"
+
+
+class Combine2Aggregations:
+    def __init__(self, aggregation_function1, aggregation_function2, p=0.5):
+        self.__agg1 = aggregation_function1
+        self.__agg2 = aggregation_function2
+        self.__p = p
+
+    def __call__(self, array):
+        if np.ndim(array) != 1:
+            raise ValueError("y must be 1 dimensional array")
+        return self.__p * self.__agg1(array) + (1 - self.__p) * self.__agg2(array)
+
+    def __str__(self):
+        pattern = r'A_(.*?)\('
+        params_pattern = r'\((.*?)\)'
+
+        agg1 = re.search(pattern, self.__agg1.__repr__()).group(1)
+        agg2 = re.search(pattern, self.__agg2.__repr__()).group(1)
+        result = f"A_{agg1}{agg2}({self.__p}"
+
+        agg1_param = re.search(params_pattern, self.__agg1.__str__())
+        if agg1_param is not None:
+            agg1_param = agg1_param.group(1)
+            result += f", {agg1_param}"
+
+        agg2_param = re.search(params_pattern, self.__agg2.__str__())
+        if agg2_param is not None:
+            agg2_param = agg2_param.group(1)
+            result += f", {agg2_param}"
+        result += ")"
+        return result
+
+    def __repr__(self):
+        pattern = r'A_(.*?)\('
+        params_pattern = r'\((.*?)\)'
+
+        agg1 = re.search(pattern, self.__agg1.__repr__()).group(1)
+        agg2 = re.search(pattern, self.__agg2.__repr__()).group(1)
+        result = f"A_{agg1}{agg2}(p={self.__p}"
+
+        agg1_param = re.search(params_pattern, self.__agg1.__repr__()).group(1)
+        if agg1_param != "":
+            result += f", {agg1_param}"
+
+        agg2_param = re.search(params_pattern, self.__agg2.__repr__()).group(1)
+        if agg2_param != "":
+            result += f", {agg2_param}"
+        result += ")"
+        return result
+
+    def toLatex(self, params: str):
+        pqrn = f"{self.__p}"
+
+        # Inicjalizacja słownika dla wartości p, q, r, n
+        values = {'p': [], 'q': [], 'r': [], 'n': []}
+
+        # Iteracja po agregatorach
+        for agg in [self.__agg1, self.__agg2]:
+            for attr in values.keys():
+                # Pobranie wartości atrybutu dla danego agregatora, jeśli istnieje
+                value = getattr(agg, f'__{attr}', None)
+                if value is not None:
+                    values[attr].append(str(value))
+
+        # Dodanie wartości do pqrn
+        for attr, val_list in values.items():
+            if val_list:
+                pqrn += f" {attr}= {', '.join(val_list)}"
+
+        return f"A_{{{self.__agg1.name},{self.__agg2.name}}}^{{{pqrn}}}({params})"
+
+
+if __name__ == "__main__":
+    # example data
+    data = [0.2, 0.6, 0.7]
+    # configure function parameters
+    func1 = A_amn(p=0.5)
+    # use aggregation funciton
+    print(func1(data))
+
+    # Combine two aggregations - arithmetic mean and minimum
+    func2 = Combine2Aggregations(A_ar(), min)
+    # use combination of aggregation funciton
+    print(func2(data))
+
+    func1 = A_amn(p=0.5)
+    print(func1)
+
+    func2 = Combine2Aggregations(A_ar(), A_md())
+    print(func2)
+
+    func3 = Combine2Aggregations(A_ar(), A_pw(r=3))
+    print(func3.__repr__())  # function parameters are printed in order: func1, func2
+
+    aggregation_functions = []
+    ex_params = [0.2, 0.5, 1, 2, 3, 5]
+    for param in ex_params:
+        aggregation_functions.append(A_ex(param))
+
+    aggregation_functions += [A_mn(), A_mx(), A_ar(), A_md(),
+                              A_ol()]
+
+    combinations = []
+    for func1, func2 in itertools.combinations(aggregation_functions, 2):
+        for p in range(1, 10):
+            combinations.append(Combine2Aggregations(func1, func2, p=p / 10))
+
+    for x in combinations:
+        print(x.__repr__())

aggregationslib/conjuctive/purepython.py

@@ -0,0 +1,5 @@
+def product(y):
+    _prod = 1
+    for x in y:
+        _prod *= x
+    return _prod

aggregationslib/decimalaggregations.py

@@ -0,0 +1,256 @@
+import logging
+import numbers
+import warnings
+
+from decimal import Decimal
+
+# 1 Arithmetic aggregation
+import numpy as np
+
+
+def arithmetic(y):
+    """
+    Arithmetic aggregation
+    :param y: 1 dimensional array
+    :return: aggregation value
+    """
+    _sum = Decimal('0')
+    n_elems = len(y)
+    for num in y:
+        try:
+            _sum += num
+        except:
+            _sum += Decimal(str(num))
+            warnings.warn("Numbers in iterable are converted to Decimal automatically.")
+    return _sum / n_elems
+
+
+# 2
+def quadratic(y):
+    n = len(y)
+    _sum = Decimal('0')
+    for num in y:
+        try:
+            _sum += num ** 2
+        except:
+            _sum += Decimal(str(num)) ** 2
+            warnings.warn("Numbers in iterable are converted to Decimal automatically.")
+    return Decimal.sqrt(_sum / n)
+
+
+# 3
+def geometric(y):
+    """
+    y should contain only positive numbers [0, inf]
+    :param y:
+    :return:
+    """
+    _prod = Decimal('1')
+    n = Decimal(len(y))
+
+    for num in y:
+        try:
+            _prod *= num ** (1 / n)
+        except:
+            _prod *= Decimal(str(num)) ** (1 / n)
+            warnings.warn("Numbers in iterable are converted to Decimal automatically.")
+    return _prod
+
+
+# 4
+def harmonic(y):
+    """
+    WARNING if sum of denominator is  0 eg. [-10, 0 ,10] then function return 0.
+    WARNING if y cointains 0 then return 0.
+    :param y:
+    :return:
+    """
+    n = Decimal(len(y))
+
+    y_dec = []
+    for x in y:
+        if isinstance(x, numbers.Number):
+            val = Decimal(str(x))
+            y_dec.append(val)
+        else:
+            raise ValueError("y should contain numbers in 1D iterable object.")
+
+    _sum = Decimal('0')
+    for num in y_dec:
+        if num == 0:
+            warnings.warn("y contains 0 for hearmonic(" + str(y) + ")")
+            return Decimal('0')
+        _sum += Decimal('1') / num
+
+
+    if _sum == 0:
+        warnings.warn("sum of denominator is equal to 0 for hearmonic(" + str(y) + ")")
+        return Decimal('0')
+    return n / _sum
+
+
+# 5
+def power(y, r=1):
+    if r == 0:
+        raise ValueError("parameter r cannot be equal to 0 ")
+    # If one 0 occur in array then mean is 0
+    if 0 in y and r < 0:
+        return 0
+    else:
+        n = Decimal(len(y))
+
+        _sum = Decimal('0')
+        for num in y:
+            try:
+                _sum += num ** r
+            except:
+                _sum += Decimal(str(num)) ** r
+                warnings.warn("Numbers in iterable are converted to Decimal automatically.")
+
+        return (_sum / n) ** (1 / Decimal(r))
+
+
+# 6
+def exponential(y, r=1):
+    """
+    Mean is given by equation:
+    $A_6^{(r)}(x_1,...,x_n)= \frac{1}{r}\ln
+    \Big(\frac{1}{n} \sum \limits_{k=1}^{n} e^{rx_k}\Big)$, where
+    $r \in \mathbb{R}$, $r \neq 0$
+
+    :param y: array of values
+    :param r: r != 0
+    :return: value of exponential mean
+    """
+    size = Decimal(str(len(y)))
+    r = Decimal(r)
+    if r == 0:
+        raise ValueError("parameter r should be != 0 ")
+
+    # Convert y to Decimal
+    y_dec = []
+    for x in y:
+        if isinstance(x, numbers.Number):
+            val = Decimal(str(x))
+            y_dec.append(val)
+        else:
+            raise ValueError("y should contain numbers in 1D iterable object.")
+
+    _sum = Decimal('0')
+    for idx, num in enumerate(y_dec):
+        _sum += (num * r).exp()
+
+    # # Comparasion to numpy
+    #     # np_sum = np.sum(np.exp(y * int(r)))
+    #     # np_sum_log = np.lib.scimath.log(np_sum / len(y))
+
+    return (1 / r) * (_sum / size).ln()
+
+
+# 7
+def lehmer(y, r=0):
+    r = Decimal(r)
+    if 0 in y and r - 1 <= 0:
+        return 0
+    else:
+        r2 = (r - 1)
+        _nominator = Decimal('0')
+        _denominator = Decimal('0')
+        for num in y:
+            try:
+                _nominator += num ** r
+                _denominator += num ** r2
+            except:
+                _nominator += Decimal(str(num)) ** r
+                _denominator += Decimal(str(num)) ** r2
+                warnings.warn("Numbers in iterable are converted to Decimal automatically.")
+
+        if _denominator == 0:
+            return 0
+        else:
+            return _nominator / _denominator
+
+
+# 8
+def arithmetic_min(y, p=0):
+    p = Decimal(p)
+    _min = Decimal(min(y))
+    return p * arithmetic(y) + (1 - p) * _min
+
+
+# 9
+def arithmetic_max(y, p=0):
+    p = Decimal(p)
+    _max = Decimal(max(y))
+    return p * arithmetic(y) + (1 - p) * _max
+
+
+# 10
+def median(y):
+    n = len(y)
+    if n % 2 == 0:
+        return arithmetic([y[(n / 2) - 1], y[n / 2]])
+    else:
+        return y[n // 2]
+
+
+# 11
+def olimpic(y):
+    if len(y) < 3:
+        return arithmetic(y)
+    else:
+        d = sorted(y)
+        d = d[1:-1]
+        return arithmetic(d)
+
+
+def exponential2(y, p=0, q=0):
+    pass
+
+
+def exponential3(y, p=0, q=0):
+    pass
+
+
+def sin_aggregation(y):
+    pass
+
+
+def quasi_arithmeric(y, function):
+    pass
+
+
+if __name__ == "__main__":
+    y = [-10, -22, 10]
+    # 1
+    print(arithmetic(y))
+
+    # 2
+    print(quadratic(y))
+
+    # 3
+    print(geometric(y))
+
+    # # 4
+    print(harmonic(y))
+
+    # 5
+    print(power(y, r=1))
+
+    # 6
+    print(exponential(y, r=1))
+
+    # 7
+    print(lehmer(y, r=0))
+
+    # 8
+    print(arithmetic_min(y, p=0))
+
+    # 9
+    print(arithmetic_max(y, p=0))
+
+    # 10
+    print(median(y))
+
+    # 11
+    print(olimpic(y))

aggregationslib/example.py

@@ -0,0 +1,8 @@
+import math
+
+import aggregation
+
+array = [1, 2, 3, 4]
+print(aggregation.sin_aggregation(array))
+print(aggregation.quasi_arithmeric(array,math.sin))
+

aggregationslib/purepython.py

@@ -0,0 +1,25 @@
+import math
+
+import numpy as np
+
+
+def exponential(y, r=1):
+    """
+    Mean is given by equation:
+    $A_6^{(r)}(x_1,...,x_n)= \frac{1}{r}\ln
+    \Big(\frac{1}{n} \sum \limits_{k=1}^{n} e^{rx_k}\Big)$, where
+    $r \in \mathbb{R}$, $r \neq 0$
+
+    :param y: array of values
+    :param r: r != 0
+    :return: value of exponential mean
+    """
+    size = len(y)
+    if r == 0:
+        raise ValueError("parameter r should be != 0 ")
+
+    _sum = 0
+    for idx, num in enumerate(y):
+        _sum += math.exp(num * r)
+
+    return (1 / r) * math.log(_sum / size)

aggregationslib-0.0.0.dist-info/METADATA

@@ -0,0 +1,124 @@
+Metadata-Version: 2.2
+Name: aggregationslib
+Version: 0.0.0
+Summary: Python implementation of Arithmetic, quasi arithmetic and other aggregating functions
+Home-page: https://github.com/wgalka/Means
+Download-URL: https://github.com/wgalka/Means/archive/refs/tags/v0.0.3.tar.gz
+Author: wgalka
+License: TO DOO
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=2.2.2
+Requires-Dist: pynverse
+Provides-Extra: test
+Requires-Dist: pytest>=8.3.4; extra == "test"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: license
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Means
+Means, Aggregation functions...
+
+Aggregations functions are:
+- Conjuctive - the final aggregated value will always be influenced by the smallest value among the inputs.
+- Disjnuctive - the aggregated value will always be influenced by the largest value among the inputs.
+
+#### Example 1:
+
+```pycon
+# example data
+data = [0.2, 0.6, 0.7]
+# configure function parameters
+func1 = A_amn(p=0.5)
+# use aggregation funciton
+print(func1(data))
+
+# Combine two aggregations - arithmetic mean and minimum
+func2 = Combine2Aggregations(A_ar(), min)
+# use combination of aggregation funciton
+print(func2(data))
+```
+
+#### Example2:
+To get information about aggregation function you can use `__str__()` or '__repr__()' methods.
+
+```pycon
+func1 = A_amn(p=0.5)
+print(func1)
+>>>A_amn(0.5)
+
+func2 = Combine2Aggregations(A_ar(), A_md())
+print(func2)
+>>>A_armd
+
+func3 = Combine2Aggregations(A_ar(), A_pw(r=3))
+print(func3.__repr__()) # function parameters are printed in order: func1, func2
+>>>A_arpw(r=3)
+```
+
+`exponential(y, r=1)` is given by equation 
+
+$$
+A_6^{(r)}(x_1,...,x_n)= \frac{1}{r}\ln
+    \Big(\frac{1}{n} \sum \limits_{k=1}^{n} e^{rx_k}\Big), where
+    r \in \mathbb{R}, r \neq 0
+$$
+
+
+# A_ar - Arithmetic mean
+
+
+# A_qd - Quadratic mean
+
+
+# A_gm - Geometric mean
+
+
+# A_hm - Harmonic mean
+
+
+# A_pw - Power mean
+
+
+# A_ex, A_ex2, A_ex3 - Exponential mean
+
+
+# A_lm - Lehmer mean
+
+
+# A_amn - Arithmetic minimum mean
+
+
+# A_amx - Arithmetic maximum mean
+
+
+# A_md - Median - ordered weighted aggregation
+
+
+# A_ol - Olimpic aggregation
+
+# A_oln - Olimpic aggregation
+We can specify how many greatest and smallest records remove
+
+# A_ln - Logaritmic aggregation
+
+https://www.researchgate.net/publication/228886844_Logarithmic_mean_for_several_arguments
+
+$$
+L\left(x_1, x_2, \ldots, x_n\right)=(n-1) ! \sum_{i=1}^n \frac{x_i}{\prod_{\substack{j=1 \\ j \neq i}}^n \log \left(x_i / x_j\right)}
+$$
+
+# Combine2Aggregations - Combine aggregation functions
+Amn, Amx, Aar , Aex , Amd,
+Aow1, Aow1

aggregationslib-0.0.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+aggregationslib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aggregationslib/aggregation.py,sha256=xByHAEHVtu3PdnK21dJz9bayKqEO9_8xPjDGQytMpSY,4565
+aggregationslib/aggregations.py,sha256=CPkielX2iM_wVXN3z0SfNE4Dxs1HMeX3R5h9kx2la0U,14644
+aggregationslib/decimalaggregations.py,sha256=FYwro4KcojPH7ZMAEcKoE7MHN_1ojaTDY0UkEAzJN0M,5351
+aggregationslib/example.py,sha256=4y3caiSBq4jkqz88Qan1m0LB389TXvlf7VSOPC_1Cj4,149
+aggregationslib/purepython.py,sha256=Ov7AuBHLzoebS7HwTsDo8Ceed5pMzn3i71uevHnHbno,557
+aggregationslib/conjuctive/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aggregationslib/conjuctive/purepython.py,sha256=f7YOyrEvaTiBhWDyJrKPbWrym2PGFYIkTqfE2u1lOvk,82
+aggregationslib/disjunctive/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aggregationslib-0.0.0.dist-info/METADATA,sha256=VMvpYwwRkLWSCFfusZVJK_SlVcrEO7SnWrWfAY9_mec,2977
+aggregationslib-0.0.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+aggregationslib-0.0.0.dist-info/top_level.txt,sha256=aAqYX4rNyBs40QOh2hc-jTE08IsMq0haGyyy7-GSdUQ,16
+aggregationslib-0.0.0.dist-info/RECORD,,

aggregationslib-0.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

aggregationslib-0.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+aggregationslib