Aplicaciones de la lgica difusa

La lgica difusa es aplicable en situaciones y/o campos como:

Donde hallan procesos muy complejos, en los cuales los modelos

matemticos simples no son capaces de dar solucin a determinados problemas.
Por ejemplo, un sistema de riego el cual funciona a partir del clima del medio
ambiente. Este sistema no puede basarse en clima frio o caliente como lo hara un
sistema lgico binario, el cual toma dos estados. Ac necesitamos tomar en cuenta
diferentes estados para dar modelos matemticos automatizados que den salidas
y/o decisiones factibles.

Para procesos altamente no lineales, ejemplos de estos son:

- La meteorologa
- La combustin
- La evolucin biolgica

En el campo de las empresas este tipo de teora se ha extendido en general

a todas las reas de decisin, en las que se manejan estimaciones subjetivas
basadas en la informacin disponible y en su propia experiencia. Por ejemplo:
- Modelos de decisin utilizados con criterios de optimizacin
- Modelo de produccin
- Inventarios
- Seguros de vida
- Localizacin de plantas industriales
- Seleccin de carteras
- Estrategia de entrada a mercados extranjeros
- Valoracin de intangibles en empresas de Internet
Cuando los sistemas funcionan generalmente bien o los modelos matemticos se
pueden disear fcilmente, no hay necesidad de emplear la lgica difusa, puesto
que la solucin no es tan compleja como para hacer deducciones del tipo que
hacen los seres humanos.
Que es la logica borrosa o difusa?
La lgica borrosa o difusa se basa en lo relativo de lo observado as. Este tipo de lgica toma dos valores
aleatorios, pero contextualizados y referidos entre s. As, por ejemplo, una persona que mida 2 metros es
claramente una persona alta, si previamente se ha tomado el valor de persona baja y se ha establecido

en 1 metro. Ambos valores estn contextualizados a personas y referidos a una medida mtrica lineal.
[http://es.wikipedia.org/wiki/Lgica_difusa]
Las lgicas difusas tratan de crear aproximaciones matemticas en la resolucin de ciertos tipos de
problemas. Pretenden producir resultados exactos a partir de datos imprecisos, por lo cual son
particularmente tiles en aplicaciones electrnicas o computacionales.
un buen link de logica difusa es: http://delta.cs.cinvestav.mx/~gmorales/ldifl/ldifl.html
Un ejemplo tipico en python
En esta oportunita quera mostrar una implementacin simple de lgica difusa. Para eso acud al tpico
ejemplo del ventilador y la pelota.
#!/usr/bin/env python
#Archivo: ventiladorBorroso.py
import logicaBorrosa
import random
def borroso(objY,posY):
distancia = objY-posY
centrado =logicaBorrosa.fxTriangulo
(distancia,-10.0,0.0,10.0)
cercaA
=logicaBorrosa.fxTrapezoide
(distancia,10.0,80.0,120.0,180.0)
normalA
=logicaBorrosa.fxTrapezoide
(distancia,120.0,160.0,240.0,280.0)
lejosA
=logicaBorrosa.fxGrado
(distancia,240.0,300.0)
cercaB
=logicaBorrosa.fxTrapezoide (distancia,-180.0,120.0,-80.0,-10.0)
normalB
=logicaBorrosa.fxTrapezoide (distancia,-280.0,240.0,-160.0,-120.0)
lejosB
=logicaBorrosa.fxGradoInversa(distancia,-300,-240)
tmp
=(centrado*9.8+cercaA*4.0+normalA*2.0+lejosA*1.0+cercaB*14.0+normalB*15.5+lejo
sB*18.0)
div = (centrado+cercaA+normalA+lejosA+cercaB+normalB+lejosB)
try:
tmp /= div
except:
pass
return tmp
gravedad = 9.81
velY = 0.0
posY= random.randrange(150.0,450.0)
ventilador = random.randrange(1.0,120.0)/10.0
objY=300
while True:
caos = 0.0
ventilador = borroso(objY,posY) # Llevamos a cabo el calculo borroso
caos = (random.randrange(-50,50))/10.0
velY = ((gravedad-ventilador+caos)*0.01)
posY +=velY
print posY
el modulo que contiene a todas las funciones de membresia es

#Archivo: logicaBorrosa.py
#
#Funciones de Membresia
#
def fxBool(x,y):
"""
Funcion de membresia boleana.
Solo retorna dos valores 1,0
"""
if x<=y:
return 0
else:
return 1
def fxBoolInversa(x,y):
"""
Funcion inverda de la funcion de membresia boleana.
Solo retorna dos valores 1,0
"""
return 1-fxBool(x,y)
def fxGrado(x,y,z):
"""
Funcion de membresia de grado.
"""
if x<=y:
return 0.0
elif x>y and x<z:
return (x/(z-y))-(y/(z-y))
else:
return 1.0
def fxGradoInversa(x,y,z):
"""
Funcion de membresia de grado.
"""
if x<=y:
return 1.0
elif x>y and x<z:
return -(x/(z-y))+(z/(z-y))
else:
return 0.0
def fxTriangulo(x,x0,x1,x2):
"""
funcion de membresia Triangulo
"""
if x<=x0:
return 0.0
elif x>x0 and x<=x1:
return (x/(x1-x0))-(x0/(x1-x0))
elif x>x1 and x<=x2:
return -(x/(x2-x1))+(x2/(x2-x1))
else:
return 0.0
def fxTrapezoide(x,x0,x1,x2,x3):
"""
funcion de membresia Trapezoide
"""
if x<=x0:
return 0.0
elif x>x0 and x<=x1:
return (x/(x1-x0))-(x0/(x1-x0))
elif x>x1 and x<=x2:
return 1.0
elif x>x2 and x<=x3:
return -(x/(x3-x2))+(x3/(x3-x2))

else:
return 0.0
#
# Operadores Borroso
#
def OperadorAnd(x,y):
return min(x,y)
def OperadorOR(x,y):
return max(x,y)
def OperadorNOT(x):
return 1-x