Métodos de Tomada de Decisão

# Dados simulados de 5 pacientes
febre      <- c(TRUE, TRUE, FALSE, TRUE, FALSE)
taquicardia <- c(TRUE, FALSE, TRUE, TRUE, FALSE)
dispneia   <- c(FALSE, TRUE, FALSE, TRUE, FALSE)

# Conjunção vetorizada: & (opera em todos os pacientes)
alerta_sirs <- febre & taquicardia
cat("Alerta SIRS (febre E taquicardia):\n")

print(alerta_sirs)

# Disjunção: qualquer um dos critérios respiratórios
alerta_resp <- taquicardia | dispneia
cat("\nAlerta respiratório (taquicardia OU dispneia):\n")

print(alerta_resp)

# Negação: pacientes SEM febre
sem_febre <- !febre
cat("\nSem febre:\n")

print(sem_febre)

# Combinação: febre E (taquicardia OU dispneia)
alerta_combinado <- febre & (taquicardia | dispneia)
cat("\nAlerta combinado:\n")

print(alerta_combinado)

# Gerar todas as combinações de dois valores lógicos
p <- c(TRUE, TRUE, FALSE, FALSE)
q <- c(TRUE, FALSE, TRUE, FALSE)

tabela <- data.frame(p            = p,
                     q            = q,
                     `!p`         = !p,
                     `p & q`      = p & q,
                     `p | q`      = p | q,
                     `xor(p,q)`   = xor(p, q),
                     `p→q (!p|q)` = !p | q,
                     `p↔q`        = p == q,
                     check.names  = FALSE)

nomes <- names(tabela)
tabela_fmt <- as.data.frame(lapply(tabela, function(x) ifelse(x, "V", "F")),
                            check.names = FALSE)
names(tabela_fmt) <- nomes
print(tabela_fmt)

# Argumento clínico:
# P1: SE febre E tosse ENTÃO suspeitar de gripe
# P2: O paciente tem febre
# P3: O paciente tem tosse
# Conclusão: suspeitar de gripe

verificar_argumento <- function(febre, tosse) {
  P1 <- (febre & tosse)  # antecedente da regra
  gripe <- P1            # conclusão pela regra
  
  # O argumento é válido se P1→gripe é sempre V quando P1 é V
  valido <- all(!P1 | gripe)  # tautologia do modus ponens
  
  data.frame(febre = febre, tosse = tosse,
             `P1 (f∧t)` = P1,
             gripe = gripe,
             `Regra válida` = valido,
             check.names = FALSE)
}

casos <- expand.grid(febre = c(T,F), tosse = c(T,F))
resultado <- verificar_argumento(casos$febre, casos$tosse)
print(resultado)

# Exemplo: diagnóstico diferencial simplificado
# Hipótese A: infecção bacteriana | Hipótese B: infecção viral
# Normalmente são mutuamente exclusivas no mesmo episódio

bacteriana <- c(TRUE,  FALSE, TRUE,  FALSE)
viral      <- c(FALSE, TRUE,  FALSE, FALSE)

cat("Diagnóstico exclusivo (xor — um OU outro, não ambos):\n")

print(xor(bacteriana, viral))

cat("\nDiagnóstico inclusivo (| — ao menos um):\n")

print(bacteriana | viral)

cat("\nAmbas as infecções simultaneamente (& — coinfecção):\n")

print(bacteriana & viral)

cat("\nNenhuma das hipóteses confirmadas (!a & !b):\n")

print(!bacteriana & !viral)

# Protocolo de alta hospitalar (simplificado):
# Alta SE (afebril E SpO2_ok) E (exame_ok OU melhora_clinica)
# Equivalente em FNC: verificar cada cláusula separadamente

verificar_alta <- function(afebril, spo2_ok, exame_ok, melhora) {
  clausula1 <- afebril & spo2_ok          # condição vital obrigatória
  clausula2 <- exame_ok | melhora         # ao menos um critério de melhora
  alta_indicada <- clausula1 & clausula2  # FNC: ambas as cláusulas
  
  data.frame(
    afebril = afebril, spo2_ok = spo2_ok,
    exame_ok = exame_ok, melhora = melhora,
    `Cláusula 1` = clausula1,
    `Cláusula 2` = clausula2,
    `Alta indicada` = alta_indicada,
    check.names = FALSE
  )
}

# Testar quatro cenários de pacientes
res <- verificar_alta(
  afebril  = c(TRUE,  TRUE,  FALSE, TRUE),
  spo2_ok  = c(TRUE,  TRUE,  TRUE,  FALSE),
  exame_ok = c(TRUE,  FALSE, TRUE,  TRUE),
  melhora  = c(FALSE, TRUE,  FALSE, TRUE)
)
print(res)

# Simulação de banco de dados de pacientes
pacientes <- data.frame(
  id       = 1:6,
  nome     = c("Ana", "Bruno", "Carla", "Diego", "Eva", "Fábio"),
  diabetico = c(TRUE, FALSE, TRUE, FALSE, TRUE, FALSE),
  internado = c(TRUE, TRUE, FALSE, TRUE, FALSE, TRUE),
  glicemia  = c(280, 95, 195, 88, 310, 102)
)

# ∀x [Diabético(x) → MonitorarGlicemia(x)]
# Implementação: todos os diabéticos com glicemia alterada
cat("Diabéticos com glicemia > 200 (∀x: Diabético→Monitorar):\n")

print(pacientes[pacientes$diabetico & pacientes$glicemia > 200, 
                c("nome", "diabetico", "glicemia")])

# ∃x [Internado(x) ∧ Diabético(x)]  — existe ao menos um
existe_diabetico_internado <- any(pacientes$diabetico & pacientes$internado)
cat(sprintf("\n∃x [Internado(x) ∧ Diabético(x)]: %s\n",
            ifelse(existe_diabetico_internado, "VERDADEIRO", "FALSO")))

# Quantos satisfazem a condição?
n <- sum(pacientes$diabetico & pacientes$internado)
cat(sprintf("Pacientes diabéticos internados: %d\n", n))

# Regras com fatores de certeza para diagnóstico de pneumonia
# CF ∈ [-1, 1]: -1=certamente falso, 0=neutro, +1=certamente verdadeiro

combinar_cf <- function(cf1, cf2) {
  # Combinação de evidências favoráveis independentes
  if (cf1 >= 0 & cf2 >= 0) {
    return(cf1 + cf2 * (1 - cf1))       # ambas favoráveis
  } else if (cf1 < 0 & cf2 < 0) {
    return(cf1 + cf2 * (1 + cf1))       # ambas desfavoráveis
  } else {
    return((cf1 + cf2) / (1 - min(abs(cf1), abs(cf2))))  # mistas
  }
}

# Evidências para pneumonia
cf_febre_tosse   <- 0.6   # febre + tosse → pneumonia (CF = 0.6)
cf_raio_x        <- 0.8   # infiltrado no raio-X → pneumonia (CF = 0.8)
cf_sem_antibiot  <- -0.3  # ausência de melhora com antibiótico (CF = -0.3)

cf_combinado_1 <- combinar_cf(cf_febre_tosse, cf_raio_x)
cf_final       <- combinar_cf(cf_combinado_1, cf_sem_antibiot)

cat(sprintf("CF (febre+tosse):          %.2f\n", cf_febre_tosse))

cat(sprintf("CF (raio-X alterado):      %.2f\n", cf_raio_x))

cat(sprintf("CF combinado (1+2):        %.2f\n", cf_combinado_1))

cat(sprintf("CF após evidência negativa:%.2f\n", cf_final))

cat(sprintf("\nDiagnóstico de pneumonia: %s\n",
    ifelse(cf_final > 0.5, "PROVÁVEL", 
    ifelse(cf_final > 0.2, "possível", "improvável"))))

# Fatos do paciente (V/F)
febre     <- TRUE   # temperatura > 38°C
tosse     <- TRUE   # tosse seca
mialgia   <- FALSE  # dor muscular
dispneia  <- FALSE  # falta de ar

# Regras
gripal     <- febre & tosse & mialgia
alerta_uci <- febre & dispneia   # UTI: Unidade de Terapia Intensiva
isolamento <- febre & (tosse | dispneia)

# Resultados
cat("=== Triagem por Regras Lógicas ===\n")

cat(sprintf("Síndrome Gripal:    %s\n", ifelse(gripal, "POSITIVO", "negativo")))

cat(sprintf("Alerta UTI:         %s\n", ifelse(alerta_uci, "POSITIVO", "negativo")))

cat(sprintf("Indicar Isolamento: %s\n", ifelse(isolamento, "POSITIVO", "negativo")))

p <- c(TRUE, TRUE, FALSE, FALSE)
q <- c(TRUE, FALSE, TRUE, FALSE)

resultado <- !p | (p & q) | (!p)
# Equivalente a: ¬p ∨ (p → q) = ¬p ∨ (¬p ∨ q) = ¬p ∨ q
resultado_simples <- !p | (!p | q)

data.frame(
  p = p, q = q,
  `neg_p` = !p,
  `p→q` = !p | q,
  `neg_p ∨ (p→q)` = !p | (!p | q),
  check.names = FALSE
)

classificar_desidratacao <- function(turgor_reduzido, olhos_fundos, mucosas_secas) {
  # Regras da OMS (simplificadas)
  # Grave: todos os 3 sinais presentes
  # Leve: 1 ou 2 sinais presentes
  # Sem: nenhum sinal

  n_sinais <- as.integer(turgor_reduzido) +
              as.integer(olhos_fundos) +
              as.integer(mucosas_secas)

  ifelse(n_sinais == 3, "GRAVE",
  ifelse(n_sinais >= 1, "Leve",
                        "Sem desidratação"))
}

# Cenários clínicos
dados <- data.frame(
  turgor   = c(TRUE,  TRUE,  FALSE, FALSE),
  olhos    = c(TRUE,  TRUE,  FALSE, TRUE),
  mucosas  = c(TRUE,  FALSE, FALSE, FALSE)
)
dados$classificacao <- classificar_desidratacao(
  dados$turgor, dados$olhos, dados$mucosas
)
print(dados)

# Simulação de atualização diagnóstica à medida que chegam novos dados
# (raciocínio não monotônico: hipóteses podem ser revistas)

atualizar_diagnostico <- function(historico_evidencias) {
  # Hipóteses iniciais com pesos
  hipoteses <- c(gripe = 0.6, pneumonia = 0.2, COVID = 0.1, outro = 0.1)
  
  cat("=== Processo de Atualização Diagnóstica ===\n\n")
  
  for (evidencia in historico_evidencias) {
    cat(sprintf("Nova evidência: %s\n", evidencia))
    
    if (evidencia == "febre+tosse") {
      hipoteses["gripe"]     <- hipoteses["gripe"]     * 1.5
      hipoteses["pneumonia"] <- hipoteses["pneumonia"] * 1.3
    } else if (evidencia == "contato_COVID") {
      hipoteses["COVID"]     <- hipoteses["COVID"]     * 4.0
      hipoteses["gripe"]     <- hipoteses["gripe"]     * 0.6
    } else if (evidencia == "raio_x_normal") {
      hipoteses["pneumonia"] <- hipoteses["pneumonia"] * 0.1
    }
    
    # Normalizar para somar 1
    hipoteses <- hipoteses / sum(hipoteses)
    mais_provavel <- names(which.max(hipoteses))
    cat(sprintf("  Diagnóstico mais provável: %s (%.1f%%)\n\n",
                mais_provavel, max(hipoteses) * 100))
  }
  hipoteses
}

evidencias <- c("febre+tosse", "contato_COVID", "raio_x_normal")
final <- atualizar_diagnostico(evidencias)

# Funções auxiliares para operações fuzzy
fuzzy_e   <- function(a, b) pmin(a, b)      # interseção (mínimo)
fuzzy_ou  <- function(a, b) pmax(a, b)      # união (máximo)
fuzzy_nao <- function(a)    1 - a           # complemento
fuzzy_prod <- function(a, b) a * b          # produto (t-norma alternativa)

# Cenário clínico: paciente com múltiplos parâmetros avaliados
mu_febre_alta  <- 0.75   # temperatura = 39.5°C
mu_taquicardia <- 0.60   # FC = 108 bpm (Frequência Cardíaca)
mu_hipoxemia   <- 0.40   # SpO2 = 93%

cat("=== Operações Fuzzy para Triagem de Sepse ===\n\n")

cat(sprintf("μ(febre alta):   %.2f\n", mu_febre_alta))

cat(sprintf("μ(taquicardia):  %.2f\n", mu_taquicardia))

cat(sprintf("μ(hipoxemia):    %.2f\n\n", mu_hipoxemia))

cat(sprintf("Febre E Taquicardia (min):    %.2f\n",
            fuzzy_e(mu_febre_alta, mu_taquicardia)))

cat(sprintf("Febre E Taquicardia (prod):   %.2f\n",
            fuzzy_prod(mu_febre_alta, mu_taquicardia)))

cat(sprintf("Febre OU Hipoxemia (max):     %.2f\n",
            fuzzy_ou(mu_febre_alta, mu_hipoxemia)))

cat(sprintf("SEM febre alta (compl.):      %.2f\n",
            fuzzy_nao(mu_febre_alta)))

cat(sprintf("Febre E Taquic. E Hipox.(min):%.2f\n",
            fuzzy_e(fuzzy_e(mu_febre_alta, mu_taquicardia), mu_hipoxemia)))

# Base de regras para classificação de risco cardiovascular
# Variáveis: pressão (mmHg), colesterol (mg/dL)
# Saída: risco (0-10)

# Funções de pertinência
mu_pas_normal  <- function(x) pmax(0, pmin((x-100)/20, (130-x)/10))
mu_pas_limit   <- function(x) pmax(0, pmin((x-120)/10, (150-x)/10))
mu_pas_alta    <- function(x) pmax(0, pmin((x-140)/10, 1))

mu_col_normal  <- function(x) pmax(0, pmin((x-100)/50, (200-x)/20))
mu_col_limit   <- function(x) pmax(0, pmin((x-180)/20, (240-x)/20))
mu_col_alto    <- function(x) pmax(0, pmin((x-220)/20, 1))

# Centros das categorias de saída (risco 0-10)
centros_risco <- c(baixo=1.5, moderado=5.0, alto=8.5)

avaliar_risco_cv <- function(pas, col) {
  # Fuzzificação
  mpa_n <- mu_pas_normal(pas); mpa_l <- mu_pas_limit(pas); mpa_a <- mu_pas_alta(pas)
  mco_n <- mu_col_normal(col); mco_l <- mu_col_limit(col); mco_a <- mu_col_alto(col)

  # Regras (min para conjunção)
  R1 <- min(mpa_n, mco_n)  # normal + normal → baixo
  R2 <- min(mpa_l, mco_n)  # limítrofe + normal → moderado
  R3 <- min(mpa_n, mco_l)  # normal + limítrofe → moderado
  R4 <- min(mpa_l, mco_l)  # limítrofe + limítrofe → alto
  R5 <- min(mpa_a, mco_l)  # alto + limítrofe → alto
  R6 <- min(mpa_a, mco_a)  # alto + alto → alto

  # Defuzzificação: média ponderada dos centros
  pesos  <- c(R1, R2+R3, R4+R5+R6)
  escore <- sum(centros_risco * pesos) / sum(pesos)
  escore
}

# Testar três perfis de pacientes
perfis <- data.frame(
  paciente = c("A", "B", "C"),
  PAS      = c(120, 138, 160),
  Col      = c(180, 215, 260)
)
perfis$risco_cv <- round(mapply(avaliar_risco_cv, perfis$PAS, perfis$Col), 2)
print(perfis)

temp_val <- 39.2

# Funções de pertinência para temperatura
mu_normal   <- pmax(0, pmin((temp_val - 36.0)/0.8, (37.4 - temp_val)/0.6))
mu_subfebril <- pmax(0, pmin((temp_val - 37.0)/0.5, (38.5 - temp_val)/0.5))
mu_febre_mod <- pmax(0, pmin((temp_val - 38.0)/0.7, (40.0 - temp_val)/0.8))
mu_febre_alt <- pmax(0, pmin((temp_val - 39.0)/0.5, 1))

cat(sprintf("Temperatura: %.1f°C\n\n", temp_val))

cat(sprintf("μ(Normal):       %.3f\n", mu_normal))

cat(sprintf("μ(Subfebril):    %.3f\n", mu_subfebril))

cat(sprintf("μ(Febre Mod.):   %.3f\n", mu_febre_mod))

cat(sprintf("μ(Febre Alta):   %.3f\n", mu_febre_alt))

urgencia <- seq(0, 10, by = 0.05)
mu_mod   <- pmax(0, pmin((urgencia - 3)/2, (8 - urgencia)/2))
mu_alta  <- pmax(0, pmin((urgencia - 6)/1.5, 1))
tronc_mod  <- pmin(mu_mod,  0.25)
tronc_alta <- pmin(mu_alta, 0.40)
agregado   <- pmax(tronc_mod, tronc_alta)

# Centroide
centroide <- sum(urgencia * agregado) / sum(agregado)
cat(sprintf("Valor defuzzificado (centroide): %.2f / 10\n", centroide))

cat(sprintf("Interpretação: urgência %.0f%%\n", centroide * 10))

spo2 <- 93

# Funções de pertinência para SpO2
mu_normal    <- pmax(0, pmin((spo2 - 94)/2, 1))
mu_hip_leve  <- pmax(0, pmin((spo2 - 89)/2, (96 - spo2)/2))
mu_hip_grave <- pmax(0, pmin((92 - spo2)/2, 1))

cat(sprintf("SpO2: %d%%\n\n", spo2))

cat(sprintf("μ(Normal):         %.3f\n", mu_normal))

cat(sprintf("μ(Hipoxemia Leve): %.3f\n", mu_hip_leve))

cat(sprintf("μ(Hipoxemia Grave):%.3f\n", mu_hip_grave))

cat("\nInterpretação: o paciente está predominantemente em hipoxemia leve,\n")

cat("com componente crescente de hipoxemia grave. Monitoramento intensivo indicado.\n")

# Entradas
temp_val <- 39.0
spo2_val <- 93.0

# Fuzzificação — Temperatura
mu_t_normal <- pmax(0, pmin((38 - temp_val)/1, 1))
mu_t_febre  <- pmax(0, pmin((temp_val - 37.5)/1, (40.5 - temp_val)/1))
mu_t_alta   <- pmax(0, pmin((temp_val - 39.0)/0.8, 1))

# Fuzzificação — SpO2
mu_s_normal    <- pmax(0, pmin((spo2_val - 94)/2, 1))
mu_s_hip_leve  <- pmax(0, pmin((spo2_val - 89)/2, (96 - spo2_val)/2))
mu_s_hip_grave <- pmax(0, pmin((92 - spo2_val)/2, 1))

# Regras (min para conjunção)
R1_urgencia_baixa   <- min(mu_t_normal, mu_s_normal)
R2_urgencia_mod     <- min(mu_t_febre,  mu_s_hip_leve)
R3_urgencia_alta    <- min(mu_t_alta,   mu_s_hip_leve)
R4_urgencia_critica <- min(mu_t_febre,  mu_s_hip_grave)

cat("=== Graus de ativação das regras ===\n")

cat(sprintf("R1 (urgência baixa):   %.3f\n", R1_urgencia_baixa))

cat(sprintf("R2 (urgência mod.):    %.3f\n", R2_urgencia_mod))

cat(sprintf("R3 (urgência alta):    %.3f\n", R3_urgencia_alta))

cat(sprintf("R4 (urgência crítica): %.3f\n", R4_urgencia_critica))

# Defuzzificação simplificada: média ponderada dos centros
centros  <- c(1.5, 4.0, 7.0, 9.5)   # centros das categorias (0-10)
pesos    <- c(R1_urgencia_baixa, R2_urgencia_mod,
              R3_urgencia_alta, R4_urgencia_critica)
escore   <- sum(centros * pesos) / sum(pesos)

cat(sprintf("\nEscore de urgência: %.2f / 10\n", escore))

cat(sprintf("Classificação: %s\n",
    ifelse(escore < 3, "Verde (não urgente)",
    ifelse(escore < 5, "Amarelo (pouco urgente)",
    ifelse(escore < 7, "Laranja (urgente)",
                       "Vermelho (emergência)")))))

# Dados do paciente
idade   <- 68; fe <- 36; intern <- 2

# Sistema A (lógica clássica — binário)
risco_a <- (idade > 70) & (fe < 35) & (intern > 2)
cat(sprintf("Sistema A (clássico): %s\n\n",
            ifelse(risco_a, "RISCO ALTO", "risco baixo")))

# Sistema B (lógica fuzzy)
mu_idoso <- pmax(0, pmin((idade - 60)/15, 1))
mu_fe    <- pmax(0, pmin((40 - fe)/10, 1))
mu_int   <- pmax(0, pmin((intern - 1)/3, 1))

cat("Sistema B (fuzzy):\n")

cat(sprintf("  μ(idoso):              %.3f\n", mu_idoso))

cat(sprintf("  μ(FE muito reduzida):  %.3f\n", mu_fe))

cat(sprintf("  μ(múltiplas intern.):  %.3f\n", mu_int))

cat(sprintf("  Grau de risco (min):   %.3f\n", min(mu_idoso, mu_fe, mu_int)))

cat(sprintf("  Grau de risco (prod.): %.3f\n", mu_idoso * mu_fe * mu_int))

cat("\nConclusão: Sistema A não detecta risco; Sistema B indica risco moderado.\n")