defuzificacao

import ipdb # ipdb.set_trace()
import numpy as np

def deffuzify_cog(y, uy):
    """
    center of gravity
    """

    sum_uy = np.sum(uy)
    middle_sum_uy = sum_uy/2

    error = np.abs(np.cumsum(uy)-middle_sum_uy)
    index = np.where(error == np.min(error))
    index = index[0][0]
    y_star = y[index]

    return y_star


def deffuzify_mom(y, uy):
    """
    Middle of Maximum
    """
    indices = np.where(uy==max(uy))
    M = y[indices]
    y_star = np.sum(M)/M.shape[0]
    return y_star


def deffuzify_lom(y, uy):
    """
    Larger of Maximum
    """
    indices = np.where(uy==max(uy))
    M = y[indices]
    y_star = max(M)
    return y_star

def deffuzify_som(y, uy):
    """
    Smaller of Maximum
    """
    indices = np.where(uy==max(uy))
    M = y[indices]
    y_star = min(M)
    return y_star


def trimf(x, abc):
    a, b, c = abc
    y = np.zeros(len(x))
    left_side_eq = (1/(b-a))*(x-a)
    right_side_eq = (1/(c-b))*(-x+c)
    y = np.minimum(left_side_eq,right_side_eq)
    y = np.maximum(y,0)
    return y

def inference_mandani_nomatrix(P,ux,uy):
    """
    onde:
    - P é a premissa
    - ux é a função de pertinência do antencedente
    - uy é a função de pertinência do consequente
    - retornará Q
    """
    antecedente_max = np.max(np.minimum(P[:],ux[:]))
    #ipdb.set_trace()
    Q = np.minimum(antecedente_max,uy[:])
    return Q

def inference_mandani_2_premissas_AND(P1,ux1,P2,ux2,uy):
    """
    onde:
    - P1 é o antecedente 1
    - P2 é o antecedente 2
    - ux1 é a função de pertinência do antencedente 1
    - ux2 é a função de pertinência do antencedente 2
    - uy é a função de pertinência do consequente
    - retornará Q
    """
    antecedente1_max = np.max(np.minimum(P1[:],ux1[:]))
    antecedente2_max = np.max(np.minimum(P2[:],ux2[:]))
    antecedente_max = min(antecedente1_max,antecedente2_max)
    Q = np.minimum(antecedente_max,uy[:])
    return Q


# conjunto Universo  das variáveis base
#X = [-40, -30 ... 40]
X = np.arange(-40,41,10)

#Y = [-6, -2, ..., 6]
Y = np.arange(-6, 6.1, 2)


# Funções de Pertinência
u_x_baixo = trimf(X,[-40,0,40])  # funcao de pertinencia para variável linguística x com valor baixo
u_x_medio = trimf(X,[-10,10,60])  # funcao de pertinencia para variável linguística x1 com valor medio

u_y_medio  = trimf(Y,[-6,-2,2])     # funcao de pertinencia para variável linguística y com valor medio
u_y_alto  = trimf(Y,[-2,2,6])      # funcao de pertinencia para variável linguística y com valor alto

#ipdb.set_trace()
# Inferência Fuzzy

#Assuma que x = 20
A_l = np.zeros(X.shape[0])   # inicializa A_l
A_l[np.where(X==20)] = 1     # faz que no índice onde o conjunto universo = 20, este conjunto tenha valor 1


Y_l1 = inference_mandani_nomatrix(A_l,u_x_baixo,u_y_alto)
Y_l2 = inference_mandani_nomatrix(A_l,u_x_medio,u_y_medio)

Y_l = np.maximum(Y_l1,Y_l2)

#ipdb.set_trace()
y_defuzified = deffuzify_cog(Y,Y_l)
#y_defuzified = deffuzify_lom(Y,Y_l)

print("\n")
print("Universo de discurso: %s" %Y)
print("Grau de Pertinência da saída: %s" %Y_l)
print("Saída defuzificada: %f" %y_defuzified)