def complement(COMPLEMENT, set,segment_size=None):
"""Returns a new fuzzy set which ist this complement of the given set.
(Where the membership of the result set is equal to C{COMPLEMENT(set(x))}.
For meaning of segment_size see also L{fuzzy.set.operations.merge}.
@param COMPLEMENT: fuzzy complement to use. For example Zadeh(), ...
Also possible as one param function, eg. C{lambda x: 1.-x}.
@type COMPLEMENT: L{fuzzy.complement.Base.Base}
@param set: fuzzy set
@type set: L{fuzzy.set.Set}
@param segment_size: maximum size of a segment
@type segment_size: float/None
@return: resulting fuzzy set
@rtype: L{fuzzy.set.Polygon.Polygon}
"""
from fuzzy.set.Polygon import Polygon
ret = Polygon()
prev_x,prev_y = None,None
for x,y in _complement_generator(COMPLEMENT,set):
if (segment_size is not None) and (prev_x is not None) and (abs(y-prev_y)>0.01):
diff = x-prev_x
if diff > 2.*segment_size:
n = int(diff/segment_size)
dx = diff/n
for i in range(1,n):
x_ = prev_x+i*dx
ret.add(x_,COMPLEMENT(set(x_)))
ret.add(x,y)
prev_x,prev_y = x,y
return ret
def complement(COMPLEMENT, set, segment_size=None):
"""Returns a new fuzzy set which is this complement of the given set.
(Where the membership of the result set is equal to C{COMPLEMENT(set(x))}.
For meaning of segment_size see also L{fuzzy.set.operations.merge}.
@param COMPLEMENT: fuzzy complement to use. For example Zadeh(), ...
Also possible as one param function, eg. C{lambda x: 1.-x}.
@type COMPLEMENT: L{fuzzy.complement.Base.Base}
@param set: fuzzy set
@type set: L{fuzzy.set.Set}
@param segment_size: maximum size of a segment
@type segment_size: float/None
@return: resulting fuzzy set
@rtype: L{fuzzy.set.Polygon.Polygon}
"""
from fuzzy.set.Polygon import Polygon
ret = Polygon()
prev_x, prev_y = None, None
for x, y in _complement_generator(COMPLEMENT, set):
if (segment_size
is not None) and (prev_x
is not None) and (abs(y - prev_y) > 0.01):
diff = x - prev_x
if diff > 2. * segment_size:
n = int(diff / segment_size)
dx = diff / n
for i in range(1, n):
x_ = prev_x + i * dx
ret.add(x_, COMPLEMENT(set(x_)))
ret.add(x, y)
prev_x, prev_y = x, y
return ret
def norm(NORM, set, value,segment_size=None):
"""Returns a new fuzzy set which ist this set normed with value.
where the membership of the result set is equal to C{NORM(set(x),value)}.
For meaning of segment_size see also L{fuzzy.set.operations.merge}.
@param NORM: fuzzy norm to calculate set's values with value. For example Min(), Max(), ...
Also possible as two params function, eg. C{lambda a,b: (a+b)/2.}.
@type NORM: L{fuzzy.norm.Norm.Norm}
@param set: fuzzy set
@type set: L{fuzzy.set.Set}
@param value: value
@type value: float
@param segment_size: maximum size of a segment
@type segment_size: float/None
@return: resulting fuzzy set
@rtype: L{fuzzy.set.Polygon.Polygon}
"""
from fuzzy.set.Polygon import Polygon
ret = Polygon()
prev_x,prev_y = None,None
for x,y in _norm_generator(NORM,set,value):
if (segment_size is not None) and (prev_x is not None) and (abs(y-prev_y)>0.01):
diff = x-prev_x
if diff > 2.*segment_size:
n = int(diff/segment_size)
dx = diff/n
for i in range(1,n):
x_ = prev_x+i*dx
ret.add(x_,NORM(set(x_),value))
ret.add(x,y)
prev_x,prev_y = x,y
return ret
def merge(NORM, set1, set2, segment_size=None):
"""Returns a new fuzzy set which is the merger of set1 and set2,
where the membership of the result set is equal to C{NORM(set1(x),set2(x))}.
For nonlinear operations you might want set the segment size to a value
which controls how large a linear segment of the result can be.
See also the following examples:
- U{http://pyfuzzy.sourceforge.net/demo/merge/AlgebraicProduct_d_d.png} - The algebraic product is M{x*y}, so using it on the same set, it calculates the square of it.
- U{http://pyfuzzy.sourceforge.net/demo/merge/AlgebraicSum_d_d.png} - The algebraic sum is M{x+y-x*y}.
@param NORM: fuzzy norm to calculate both sets values. For example Min(), Max(), ...
Also possible as two params function, eg. C{lambda a,b: (a+b)/2.}.
@type NORM: L{fuzzy.norm.Norm.Norm}
@param set1: fuzzy set
@type set1: L{fuzzy.set.Set}
@param set2: fuzzy set
@type set2: L{fuzzy.set.Set}
@param segment_size: maximum size of a segment
@type segment_size: float/None
@return: resulting fuzzy set
@rtype: L{fuzzy.set.Polygon.Polygon}
"""
from fuzzy.set.Polygon import Polygon
ret = Polygon()
prev_x, prev_y = None, None
for x, y in _merge_generator(NORM, set1, set2):
if (segment_size
is not None) and (prev_x
is not None) and (abs(y - prev_y) > 0.01):
diff = x - prev_x
if diff > 2. * segment_size:
n = int(diff / segment_size)
dx = diff / n
for i in range(1, n):
x_ = prev_x + i * dx
ret.add(x_, NORM(set1(x_), set2(x_)))
ret.add(x, y)
prev_x, prev_y = x, y
return ret
def saw(interval, n):
"""
Splits an ``interval`` into ``n`` triangle functions.
:Parameters:
interval
A tuple containing the start and the end of the interval, in the format
``(start, end)``;
n
The number of functions in which the interval must be split.
:Returns:
A list of triangle membership functions, in order.
"""
xo, xf = interval
dx = float(xf - xo) / float(n + 1)
mfs = []
for i in range(n):
mft = Polygon()
mft.add(x=xo, y=0.0)
mft.add(x=xo + dx, y=1.0)
mft.add(x=xo + 2 * dx, y=0.0)
mfs.append(mft)
xo += dx
return mfs
def merge(NORM, set1, set2, segment_size=None):
"""Returns a new fuzzy set which ist the merger of set1 and set2,
where the membership of the result set is equal to C{NORM(set1(x),set2(x))}.
For nonlinear operations you might want set the segment size to a value
which controls how large a linear segment of the result can be.
See also the following examples:
- U{http://pyfuzzy.sourceforge.net/test/merge/AlgebraicProduct_d_d.png} - The algebraic product is M{x*y}, so using it on the same set, it calculates the square of it.
- U{http://pyfuzzy.sourceforge.net/test/merge/AlgebraicSum_d_d.png} - The algebraic sum is M{x+y-x*y}.
@param NORM: fuzzy norm to calculate both sets values. For example Min(), Max(), ...
Also possible as two params function, eg. C{lambda a,b: (a+b)/2.}.
@type NORM: L{fuzzy.norm.Norm.Norm}
@param set1: fuzzy set
@type set1: L{fuzzy.set.Set}
@param set2: fuzzy set
@type set2: L{fuzzy.set.Set}
@param segment_size: maximum size of a segment
@type segment_size: float/None
@return: resulting fuzzy set
@rtype: L{fuzzy.set.Polygon.Polygon}
"""
from fuzzy.set.Polygon import Polygon
ret = Polygon()
prev_x,prev_y = None,None
for x,y in _merge_generator(NORM,set1,set2):
if (segment_size is not None) and (prev_x is not None) and (abs(y-prev_y)>0.01):
diff = x-prev_x
if diff > 2.*segment_size:
n = int(diff/segment_size)
dx = diff/n
for i in range(1,n):
x_ = prev_x+i*dx
ret.add(x_,NORM(set1(x_),set2(x_)))
ret.add(x,y)
prev_x,prev_y = x,y
return ret
def norm(NORM, set, value, segment_size=None):
"""Returns a new fuzzy set which ist this set normed with value.
where the membership of the result set is equal to C{NORM(set(x),value)}.
For meaning of segment_size see also L{fuzzy.set.operations.merge}.
@param NORM: fuzzy norm to calculate set's values with value. For example Min(), Max(), ...
Also possible as two params function, eg. C{lambda a,b: (a+b)/2.}.
@type NORM: L{fuzzy.norm.Norm.Norm}
@param set: fuzzy set
@type set: L{fuzzy.set.Set}
@param value: value
@type value: float
@param segment_size: maximum size of a segment
@type segment_size: float/None
@return: resulting fuzzy set
@rtype: L{fuzzy.set.Polygon.Polygon}
"""
from fuzzy.set.Polygon import Polygon
ret = Polygon()
prev_x, prev_y = None, None
for x, y in _norm_generator(NORM, set, value):
if (segment_size
is not None) and (prev_x
is not None) and (abs(y - prev_y) > 0.01):
diff = x - prev_x
if diff > 2. * segment_size:
n = int(diff / segment_size)
dx = diff / n
for i in range(1, n):
x_ = prev_x + i * dx
ret.add(x_, NORM(set(x_), value))
ret.add(x, y)
prev_x, prev_y = x, y
return ret
def _createSystem():
"""
\brief Crea el conjunto de reglas y valores para el controlador
\details Este comando no es necesario utilizarlo
"""
from fuzzy.InputVariable import InputVariable
from fuzzy.OutputVariable import OutputVariable
from fuzzy.fuzzify.Plain import Plain
from fuzzy.defuzzify.COG import COG
from fuzzy.Adjective import Adjective
from fuzzy.set.Polygon import Polygon
system = fuzzy.System.System()
#----------------------------------------------------------------------------------------------------------------
# Valores de entrada
#----------------------------------------------------------------------------------------------------------------
input_temp = InputVariable(fuzzify=Plain())
system.variables["error"] = input_temp
in1_set = Polygon()
in1_set.add(x=-6000, y=0.0) # porque debe iniciar y finalizar en cero
in1_set.add(x=-5000, y=1.0)
in1_set.add(x=-4000, y=0.5)
in1_set.add(x=-3000, y=0.0)
in1 = Adjective(in1_set)
input_temp.adjectives["MGN"] = in1
in2_set = Polygon()
in2_set.add(x=-4500, y=0.0)
in2_set.add(x=-3000, y=1.0)
in2_set.add(x=-2000, y=0.0)
in2 = Adjective(in2_set)
input_temp.adjectives["GN"] = in2
in3_set = Polygon()
in3_set.add(x=-3000, y=0.0)
in3_set.add(x=-2000, y=1.0)
in3_set.add(x=-1000, y=0.0)
in3 = Adjective(in3_set)
input_temp.adjectives["N"] = in3
in4_set = Polygon()
in4_set.add(x=-2000, y=0.0)
in4_set.add(x=-1000, y=1.0)
in4_set.add(x=0, y=0.0)
in4 = Adjective(in4_set)
input_temp.adjectives["Z"] = in4
in5_set = Polygon()
in5_set.add(x=-1000, y=0.0)
in5_set.add(x=1000, y=1.0)
in5_set.add(x=5000, y=1.0)
in5_set.add(x=6000, y=0.0) # porque debe iniciar y finalizar en cero
in5 = Adjective(in5_set)
input_temp.adjectives["P"] = in5
#----------------------------------------------------------------------------------------------------------------
# Valores de salida
#----------------------------------------------------------------------------------------------------------------
output_temp = OutputVariable(defuzzify=COG())
system.variables["vel"] = output_temp
output_temp.failsafe = 0.0 # let it output 0.0 if no COG available
out1_set = Polygon()
out1_set.add(x=-200, y=0.0) # porque debe iniciar y finalizar en cero
out1_set.add(x=-120, y=1.0)
out1_set.add(x=250, y=0.0)
out1 = Adjective(out1_set)
output_temp.adjectives["VMB"] = out1
out2_set = Polygon()
out2_set.add(x=30, y=0.0)
out2_set.add(x=355, y=1.0)
out2_set.add(x=600, y=0.0)
out2 = Adjective(out2_set)
output_temp.adjectives["VB"] = out2
out3_set = Polygon()
out3_set.add(x=255, y=0.0)
out3_set.add(x=600, y=1.0)
out3_set.add(x=950, y=0.0)
out3 = Adjective(out3_set)
output_temp.adjectives["VM"] = out3
out4_set = Polygon()
out4_set.add(x=600, y=0.0)
out4_set.add(x=875, y=1.0)
out4_set.add(x=1130, y=0.0)
out4 = Adjective(out4_set)
output_temp.adjectives["VA"] = out4
out5_set = Polygon()
out5_set.add(x=950, y=0.0)
out5_set.add(x=1300, y=1.0)
out5_set.add(x=1500, y=0.0) # porque debe iniciar y finalizar en cero
out5 = Adjective(out5_set)
output_temp.adjectives["VMA"] = out5
#----------------------------------------------------------------------------------------------------------------
# Reglas
#----------------------------------------------------------------------------------------------------------------
from fuzzy.Rule import Rule
from fuzzy.norm.Min import Min
from fuzzy.operator.Input import Input
from fuzzy.operator.Compound import Compound
rule1 = Rule(
adjective=system.variables["vel"].adjectives["VMA"],
operator=Input(system.variables["error"].adjectives["MGN"]),
)
system.rules["rule1"] = rule1
rule2 = Rule(
adjective=system.variables["vel"].adjectives["VA"],
operator=Input(system.variables["error"].adjectives["GN"], ),
)
system.rules["rule2"] = rule2
rule3 = Rule(
adjective=system.variables["vel"].adjectives["VM"],
operator=Input(system.variables["error"].adjectives["N"], ),
)
system.rules["rule3"] = rule3
rule4 = Rule(
adjective=system.variables["vel"].adjectives["VB"],
operator=Input(system.variables["error"].adjectives["Z"], ),
)
system.rules["rule4"] = rule4
rule5 = Rule(
adjective=system.variables["vel"].adjectives["VMB"],
operator=Input(system.variables["error"].adjectives["P"], ),
)
system.rules["rule5"] = rule5
return system
def _createSystem():
from fuzzy.InputVariable import InputVariable
from fuzzy.OutputVariable import OutputVariable
from fuzzy.fuzzify.Plain import Plain
from fuzzy.defuzzify.COG import COG
from fuzzy.defuzzify.LM import LM
from fuzzy.Adjective import Adjective
from fuzzy.set.Polygon import Polygon
system = fuzzy.System.System()
#----------------------------------------------------------------------------------------------------------------
# input temperature
#----------------------------------------------------------------------------------------------------------------
input_temp = InputVariable(fuzzify=Plain())
system.variables["InputTemp"] = input_temp
int1_set = Polygon()
int1_set.add(x=-80, y=0.0)
int1_set.add(x=0.0, y=1.0)
int1_set.add(x=10, y=0.0)
int1 = Adjective(int1_set)
input_temp.adjectives["z"] = int1
int2_set = Polygon()
int2_set.add(x=0, y=0.0)
int2_set.add(x=15, y=1.0)
int2_set.add(x=30, y=0.0)
int2 = Adjective(int2_set)
input_temp.adjectives["s"] = int2
int3_set = Polygon()
int3_set.add(x=15, y=0.0)
int3_set.add(x=30, y=1.0)
int3_set.add(x=80, y=0.0)
int3 = Adjective(int3_set)
input_temp.adjectives["t"] = int3
#----------------------------------------------------------------------------------------------------------------
# input wind
#----------------------------------------------------------------------------------------------------------------
input_wind = InputVariable(fuzzify=Plain())
system.variables["InputWind"] = input_wind
inw1_set = Polygon()
inw1_set.add(x=0, y=0.0)
inw1_set.add(x=10.0, y=1.0)
inw1_set.add(x=20, y=0.0)
inw1 = Adjective(inw1_set)
input_wind.adjectives["s"] = inw1
inw2_set = Polygon()
inw2_set.add(x=10, y=0.0)
inw2_set.add(x=30, y=1.0)
inw2_set.add(x=50, y=0.0)
inw2 = Adjective(inw2_set)
input_wind.adjectives["m"] = inw2
inw3_set = Polygon()
inw3_set.add(x=30, y=0.0)
inw3_set.add(x=50, y=1.0)
inw3_set.add(x=150, y=0.0)
inw3 = Adjective(inw3_set)
input_wind.adjectives["v"] = inw3
#----------------------------------------------------------------------------------------------------------------
# output => pocitova teplota
#----------------------------------------------------------------------------------------------------------------
output_clothes = OutputVariable(defuzzify=COG())
system.variables["o"] = output_clothes
output_clothes.failsafe = 0.0 # let it output 0.0 if no COG available
# out1_set = Polygon()
# out1_set.add(x = -80, y= 0.0)
# out1_set.add(x = 0, y= 1.0)
# out1_set.add(x = 10, y= 0.0)
# out1 = Adjective(out1_set)
# output_clothes.adjectives["vz"] = out1
out2_set = Polygon()
out2_set.add(x=-80, y=0.0)
out2_set.add(x=0, y=1.0)
out2_set.add(x=10, y=0.0)
out2 = Adjective(out2_set)
output_clothes.adjectives["z"] = out2
out3_set = Polygon()
out3_set.add(x=0, y=0.0)
out3_set.add(x=15, y=1.0)
out3_set.add(x=30, y=0.0)
out3 = Adjective(out3_set)
output_clothes.adjectives["s"] = out3
out4_set = Polygon()
out4_set.add(x=15, y=0.0)
out4_set.add(x=30, y=1.0)
out4_set.add(x=80, y=0.0)
out4 = Adjective(out4_set)
output_clothes.adjectives["t"] = out4
# out5_set = Polygon()
# out5_set.add(x = 30, y= 0.0)
# out5_set.add(x = 40, y= 1.0)
# out5_set.add(x = 50, y= 0.0)
# out5 = Adjective(out5_set)
# output_clothes.adjectives["vt"] = out5
#----------------------------------------------------------------------------------------------------------------
# Definition der Regeln
#----------------------------------------------------------------------------------------------------------------
from fuzzy.Rule import Rule
from fuzzy.norm.Min import Min
from fuzzy.operator.Input import Input
from fuzzy.operator.Compound import Compound
rule1 = Rule(adjective=system.variables["o"].adjectives["z"],
operator=Compound(
Min(),
Input(system.variables["InputTemp"].adjectives["z"]),
Input(system.variables["InputWind"].adjectives["v"])))
system.rules["rule1"] = rule1
rule2 = Rule(adjective=system.variables["o"].adjectives["z"],
operator=Compound(
Min(),
Input(system.variables["InputTemp"].adjectives["z"]),
Input(system.variables["InputWind"].adjectives["m"])))
system.rules["rule2"] = rule2
rule3 = Rule(adjective=system.variables["o"].adjectives["z"],
operator=Compound(
Min(),
Input(system.variables["InputTemp"].adjectives["z"]),
Input(system.variables["InputWind"].adjectives["s"])))
system.rules["rule3"] = rule3
rule4 = Rule(adjective=system.variables["o"].adjectives["z"],
operator=Compound(
Min(),
Input(system.variables["InputTemp"].adjectives["s"]),
Input(system.variables["InputWind"].adjectives["v"])))
system.rules["rule4"] = rule4
rule5 = Rule(adjective=system.variables["o"].adjectives["s"],
operator=Compound(
Min(),
Input(system.variables["InputTemp"].adjectives["s"]),
Input(system.variables["InputWind"].adjectives["m"])))
system.rules["rule5"] = rule5
rule6 = Rule(adjective=system.variables["o"].adjectives["s"],
operator=Compound(
Min(),
Input(system.variables["InputTemp"].adjectives["s"]),
Input(system.variables["InputWind"].adjectives["s"])))
system.rules["rule6"] = rule6
rule7 = Rule(adjective=system.variables["o"].adjectives["s"],
operator=Compound(
Min(),
Input(system.variables["InputTemp"].adjectives["t"]),
Input(system.variables["InputWind"].adjectives["v"])))
system.rules["rule7"] = rule7
rule8 = Rule(adjective=system.variables["o"].adjectives["t"],
operator=Compound(
Min(),
Input(system.variables["InputTemp"].adjectives["t"]),
Input(system.variables["InputWind"].adjectives["m"])))
system.rules["rule8"] = rule8
rule9 = Rule(adjective=system.variables["o"].adjectives["t"],
operator=Compound(
Min(),
Input(system.variables["InputTemp"].adjectives["t"]),
Input(system.variables["InputWind"].adjectives["s"])))
system.rules["rule9"] = rule9
return system
def flat_saw(interval, n):
"""
Splits an ``interval`` into a decreasing ramp, ``n-2`` triangle functions
and an increasing ramp.
:Parameters:
interval
A tuple containing the start and the end of the interval, in the format
``(start, end)``;
n
The number of functions in which the interval must be split.
:Returns:
A list of corresponding functions, in order.
"""
xo, xf = interval
dx = float(xf - xo) / float(n + 1)
# Decreasing ramp
mf1 = Polygon()
mf1.add(x=xo, y=1.0)
mf1.add(x=xo + dx, y=1.0)
mf1.add(x=xo + 2 * dx, y=0.0)
# ``n-2`` triangle
mfs = saw((xo + dx, xf - dx), n - 2)
# Increasing ramp
mf2 = Polygon()
mf2.add(x=xf - 2 * dx, y=0.0)
mf2.add(x=xf - dx, y=1.0)
mf2.add(x=xf, y=1.0)
return [mf1] + mfs + [mf2]
def _createSystem():
'''
Definition des Fuzzy-Systems:
1. Eingangsvariable Phi
2. Eingangsvariable dPhi_dT
3. Ausgangsvariable a
4. Definition der Regeln
'''
from fuzzy.InputVariable import InputVariable
from fuzzy.OutputVariable import OutputVariable
from fuzzy.fuzzify.Plain import Plain
from fuzzy.defuzzify.COG import COG
from fuzzy.Adjective import Adjective
from fuzzy.set.Polygon import Polygon
system = fuzzy.System.System()
#----------------------------------------------------------------------------------------------------------------
# Definition des Drehwinkels als Eingang
#----------------------------------------------------------------------------------------------------------------
input_temp = InputVariable(fuzzify=Plain())
system.variables["Phi"] = input_temp
in1_set = Polygon()
in1_set.add(x=-22.5, y=0.0)
in1_set.add(x=0.0, y=1.0)
in1_set.add(x=22.5, y=0.0)
in1 = Adjective(in1_set)
input_temp.adjectives["eN"] = in1
in2_set = Polygon()
in2_set.add(x=0.0, y=0.0)
in2_set.add(x=22.5, y=1.0)
in2_set.add(x=45.0, y=0.0)
in2 = Adjective(in2_set)
input_temp.adjectives["pk"] = in2
in3_set = Polygon()
in3_set.add(x=22.5, y=0.0)
in3_set.add(x=45.0, y=1.0)
in3_set.add(x=67.5, y=0.0)
in3 = Adjective(in3_set)
input_temp.adjectives["pm"] = in3
in4_set = Polygon()
in4_set.add(x=45.0, y=0.0)
in4_set.add(x=67.5, y=1.0)
in4_set.add(x=90.0, y=1.0)
in4_set.add(x=180.0, y=0.0)
in4 = Adjective(in4_set)
input_temp.adjectives["pg"] = in4
in5_set = Polygon()
in5_set.add(x=-45.0, y=0.0)
in5_set.add(x=-67.5, y=1.0)
in5_set.add(x=-90.0, y=1.0)
in5_set.add(x=-180.0, y=0.0)
in5 = Adjective(in5_set)
input_temp.adjectives["ng"] = in5
in6_set = Polygon()
in6_set.add(x=-22.5, y=0.0)
in6_set.add(x=-45.0, y=1.0)
in6_set.add(x=-67.5, y=0.0)
in6 = Adjective(in6_set)
input_temp.adjectives["nm"] = in6
in7_set = Polygon()
in7_set.add(x=-0.0, y=0.0)
in7_set.add(x=-22.5, y=1.0)
in7_set.add(x=-45.0, y=0.0)
in7 = Adjective(in7_set)
input_temp.adjectives["nk"] = in7
#----------------------------------------------------------------------------------------------------------------
# Definition der Winkelgeschwindigkeit als Eingang
#----------------------------------------------------------------------------------------------------------------
input_tempa = InputVariable(fuzzify=Plain())
system.variables["dPhi_dT"] = input_tempa
in1a_set = Polygon()
in1a_set.add(x=-11.25, y=0.0)
in1a_set.add(x=0.0, y=1.0)
in1a_set.add(x=11.25, y=0.0)
in1a = Adjective(in1a_set)
input_tempa.adjectives["eN"] = in1a
in2a_set = Polygon()
in2a_set.add(x=0.0, y=0.0)
in2a_set.add(x=11.25, y=1.0)
in2a_set.add(x=22.5, y=0.0)
in2a = Adjective(in2a_set)
input_tempa.adjectives["pk"] = in2a
in3a_set = Polygon()
in3a_set.add(x=11.25, y=0.0)
in3a_set.add(x=22.50, y=1.0)
in3a_set.add(x=33.75, y=0.0)
in3a = Adjective(in3a_set)
input_tempa.adjectives["pm"] = in3a
in4a_set = Polygon()
in4a_set.add(x=22.5, y=0.0)
in4a_set.add(x=33.75, y=1.0)
in4a_set.add(x=45.0, y=1.0)
in4a_set.add(x=90.0, y=0.0)
in4a = Adjective(in4a_set)
input_tempa.adjectives["pg"] = in4a
in5a_set = Polygon()
in5a_set.add(x=-0.0, y=0.0)
in5a_set.add(x=-11.25, y=1.0)
in5a_set.add(x=-22.5, y=0.0)
in5a = Adjective(in5a_set)
input_tempa.adjectives["nk"] = in5a
in6a_set = Polygon()
in6a_set.add(x=-11.25, y=0.0)
in6a_set.add(x=-22.50, y=1.0)
in6a_set.add(x=-33.75, y=0.0)
in6a = Adjective(in6a_set)
input_tempa.adjectives["nm"] = in6a
in7a_set = Polygon()
in7a_set.add(x=-22.5, y=0.0)
in7a_set.add(x=-33.75, y=1.0)
in7a_set.add(x=-45.0, y=1.0)
in7a_set.add(x=-90.0, y=0.0)
in7a = Adjective(in7a_set)
input_tempa.adjectives["ng"] = in7a
#----------------------------------------------------------------------------------------------------------------
# Definition der Horizontalbeschleunigung als Ausgang
#----------------------------------------------------------------------------------------------------------------
output_temp = OutputVariable(defuzzify=COG())
system.variables["a"] = output_temp
output_temp.failsafe = 0.0 # let it output 0.0 if no COG available
out1_set = Polygon()
out1_set.add(x=-0.25, y=0.0)
out1_set.add(x=0.0, y=1.0)
out1_set.add(x=0.25, y=0.0)
out1 = Adjective(out1_set)
output_temp.adjectives["eN"] = out1
out2_set = Polygon()
out2_set.add(x=0.00, y=0.0)
out2_set.add(x=0.25, y=1.0)
out2_set.add(x=0.50, y=0.0)
out2 = Adjective(out2_set)
output_temp.adjectives["pk"] = out2
out3_set = Polygon()
out3_set.add(x=0.25, y=0.0)
out3_set.add(x=0.50, y=1.0)
out3_set.add(x=0.75, y=0.0)
out3 = Adjective(out3_set)
output_temp.adjectives["pm"] = out3
out4_set = Polygon()
out4_set.add(x=0.50, y=0.0)
out4_set.add(x=0.75, y=1.0)
out4_set.add(x=1.0, y=1.0)
out4_set.add(x=2.0, y=0.0)
out4 = Adjective(out4_set)
output_temp.adjectives["pg"] = out4
out5_set = Polygon()
out5_set.add(x=0.00, y=0.0)
out5_set.add(x=-0.25, y=1.0)
out5_set.add(x=-0.50, y=0.0)
out5 = Adjective(out5_set)
output_temp.adjectives["nk"] = out5
out6_set = Polygon()
out6_set.add(x=-0.25, y=0.0)
out6_set.add(x=-0.50, y=1.0)
out6_set.add(x=-0.75, y=0.0)
out6 = Adjective(out6_set)
output_temp.adjectives["nm"] = out6
out7_set = Polygon()
out7_set.add(x=-0.50, y=0.0)
out7_set.add(x=-0.75, y=1.0)
out7_set.add(x=-1.0, y=1.0)
out7_set.add(x=-2.0, y=0.0)
out7 = Adjective(out7_set)
output_temp.adjectives["ng"] = out7
#----------------------------------------------------------------------------------------------------------------
# Definition der Regeln
#----------------------------------------------------------------------------------------------------------------
from fuzzy.Rule import Rule
from fuzzy.norm.Min import Min
from fuzzy.operator.Input import Input
from fuzzy.operator.Compound import Compound
rule1 = Rule(adjective=system.variables["a"].adjectives["pk"],
operator=Compound(
Min(), Input(system.variables["Phi"].adjectives["nk"]),
Input(system.variables["dPhi_dT"].adjectives["eN"])))
system.rules["rule1"] = rule1
rule2 = Rule(
adjective=system.variables["a"].adjectives["nk"],
operator=Input(system.variables["Phi"].adjectives["pk"], ),
)
system.rules["rule2"] = rule2
rule3 = Rule(
adjective=system.variables["a"].adjectives["pm"],
operator=Input(system.variables["Phi"].adjectives["nm"], ),
)
system.rules["rule3"] = rule3
rule4 = Rule(
adjective=system.variables["a"].adjectives["nm"],
operator=Input(system.variables["Phi"].adjectives["pm"], ),
)
system.rules["rule4"] = rule4
rule5 = Rule(
adjective=system.variables["a"].adjectives["pg"],
operator=Input(system.variables["Phi"].adjectives["ng"], ),
)
system.rules["rule5"] = rule5
rule6 = Rule(
adjective=system.variables["a"].adjectives["ng"],
operator=Input(system.variables["Phi"].adjectives["pg"], ),
)
system.rules["rule6"] = rule6
return system
def _createSystem():
"""
\brief Crea el conjunto de reglas y valores para el controlador
\details Este comando no es necesario utilizarlo
"""
from fuzzy.InputVariable import InputVariable
from fuzzy.OutputVariable import OutputVariable
from fuzzy.fuzzify.Plain import Plain
from fuzzy.defuzzify.COG import COG
from fuzzy.Adjective import Adjective
from fuzzy.set.Polygon import Polygon
system = fuzzy.System.System()
#----------------------------------------------------------------------------------------------------------------
# Valores de entrada
#----------------------------------------------------------------------------------------------------------------
input_temp = InputVariable(fuzzify=Plain())
system.variables["error"] = input_temp
in1_set = Polygon()
in1_set.add(x =-6000, y= 0.0) # porque debe iniciar y finalizar en cero
in1_set.add(x =-5000, y= 1.0)
in1_set.add(x =-4000, y= 0.5)
in1_set.add(x =-3000, y= 0.0)
in1 = Adjective(in1_set)
input_temp.adjectives["MGN"] = in1
in2_set = Polygon()
in2_set.add(x =-4500, y= 0.0)
in2_set.add(x =-3000, y= 1.0)
in2_set.add(x =-2000, y= 0.0)
in2 = Adjective(in2_set)
input_temp.adjectives["GN"] = in2
in3_set = Polygon()
in3_set.add(x =-3000, y= 0.0)
in3_set.add(x =-2000, y= 1.0)
in3_set.add(x =-1000, y= 0.0)
in3 = Adjective(in3_set)
input_temp.adjectives["N"] = in3
in4_set = Polygon()
in4_set.add(x = -2000, y= 0.0)
in4_set.add(x =-1000, y= 1.0)
in4_set.add(x =0, y= 0.0)
in4 = Adjective(in4_set)
input_temp.adjectives["Z"] = in4
in5_set = Polygon()
in5_set.add(x = -1000, y= 0.0)
in5_set.add(x = 1000, y= 1.0)
in5_set.add(x = 5000, y= 1.0)
in5_set.add(x =6000, y= 0.0) # porque debe iniciar y finalizar en cero
in5 = Adjective(in5_set)
input_temp.adjectives["P"] = in5
#----------------------------------------------------------------------------------------------------------------
# Valores de salida
#----------------------------------------------------------------------------------------------------------------
output_temp = OutputVariable(defuzzify=COG())
system.variables["vel"] = output_temp
output_temp.failsafe = 0.0 # let it output 0.0 if no COG available
out1_set = Polygon()
out1_set.add(x =-200, y= 0.0) # porque debe iniciar y finalizar en cero
out1_set.add(x =-120, y= 1.0)
out1_set.add(x =250, y= 0.0)
out1 = Adjective(out1_set)
output_temp.adjectives["VMB"] = out1
out2_set = Polygon()
out2_set.add(x =30, y= 0.0)
out2_set.add(x =355, y= 1.0)
out2_set.add(x =600, y= 0.0)
out2 = Adjective(out2_set)
output_temp.adjectives["VB"] = out2
out3_set = Polygon()
out3_set.add(x = 255, y= 0.0)
out3_set.add(x = 600, y= 1.0)
out3_set.add(x = 950, y= 0.0)
out3 = Adjective(out3_set)
output_temp.adjectives["VM"] = out3
out4_set = Polygon()
out4_set.add(x = 600, y= 0.0)
out4_set.add(x = 875, y= 1.0)
out4_set.add(x = 1130, y= 0.0)
out4 = Adjective(out4_set)
output_temp.adjectives["VA"] = out4
out5_set = Polygon()
out5_set.add(x = 950, y= 0.0)
out5_set.add(x = 1300, y= 1.0)
out5_set.add(x =1500, y= 0.0) # porque debe iniciar y finalizar en cero
out5 = Adjective(out5_set)
output_temp.adjectives["VMA"] = out5
#----------------------------------------------------------------------------------------------------------------
# Reglas
#----------------------------------------------------------------------------------------------------------------
from fuzzy.Rule import Rule
from fuzzy.norm.Min import Min
from fuzzy.operator.Input import Input
from fuzzy.operator.Compound import Compound
rule1 = Rule(adjective=system.variables["vel"].adjectives["VMA"],
operator=Input(system.variables["error"].adjectives["MGN"]),
)
system.rules["rule1"]=rule1
rule2 = Rule(adjective=system.variables["vel"].adjectives["VA"],
operator=Input(system.variables["error"].adjectives["GN"],),
)
system.rules["rule2"]=rule2
rule3 = Rule(adjective=system.variables["vel"].adjectives["VM"],
operator=Input(system.variables["error"].adjectives["N"],),
)
system.rules["rule3"]=rule3
rule4 = Rule(adjective=system.variables["vel"].adjectives["VB"],
operator=Input(system.variables["error"].adjectives["Z"],),
)
system.rules["rule4"]=rule4
rule5 = Rule(adjective=system.variables["vel"].adjectives["VMB"],
operator=Input(system.variables["error"].adjectives["P"],),
)
system.rules["rule5"]=rule5
return system
