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 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 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 test_set_get_pyfuzzy_for_polygon_type(self): " shoud return the correct corresponding pyfuzzy object for the Polygon type " new_set = self._mock_setModel('fuzzy.set.Polygon.Polygon') points = [(0.,0.),(30.,1.),(60.,0.)] points_value = str(points) self.parameters_mock = [ self._parameters_mock(name="points", value=points_value) ] # mocking parameters (queryset) parameters_queryset = mock.Mock() parameters_queryset.all = lambda : self.parameters_mock self.set_pre_mock(SetModel,'parameters') SetModel.parameters = parameters_queryset new_pyfuzzy_set = new_set.get_pyfuzzy() # the expected pyfuzzy system pyfuzzy_set_expected = Polygon(points=points) # are from the same class self.assertEquals(type(pyfuzzy_set_expected), type(new_pyfuzzy_set)) # have the same points self.assertEquals(pyfuzzy_set_expected.points, new_pyfuzzy_set.points)
def test_output_variable_changing_one_set_and_rule(self): " should return the correct output when changing all the sets to the new instance of same value, and changing the corresponding rule " from fuzzy_modeling.models import OutputVariableModel from fuzzy.norm.AlgebraicSum import AlgebraicSum from fuzzy.norm.AlgebraicProduct import AlgebraicProduct from fuzzy.Adjective import Adjective from fuzzy.set.Polygon import Polygon from fuzzy.defuzzify.COG import COG pyfuzzy_system_expected = self._createSystem() new_pyfuzzy_system = self._createSystem() INF = AlgebraicProduct() ACC = AlgebraicSum() COM = AlgebraicSum() COG = COG(INF=INF, ACC=ACC, failsafe=0., segment_size=0.5) acceleration = new_pyfuzzy_system.variables['a'] acceleration.adjectives['right_fast'] = a_right_fast = Adjective( Polygon([(10., 0.), (20., 1.), (50., 0.)]), COM=COM) new_pyfuzzy_system.rules['far right'].adjective = a_right_fast import math input_dict = {} input_dict["X"] = 0.0 #: position [m] input_dict["dX_dT"] = 0.0 #: velocity [m/s] input_dict["Phi"] = math.radians(45.0) #: angle [rad] input_dict["dPhi_dT"] = math.radians(0.0) #: angle velocity [rad/s] i_dict1 = input_dict.copy() i_dict2 = input_dict.copy() output_dict1 = { 'a': 0.0 #: acceleration [m/s²] } output_dict2 = { 'a': 0.0 #: acceleration [m/s²] } pyfuzzy_system_expected.fuzzify(i_dict1) pyfuzzy_system_expected.inference() pyfuzzy_system_expected.defuzzify(output_dict1) new_pyfuzzy_system.fuzzify(i_dict2) new_pyfuzzy_system.inference() new_pyfuzzy_system.defuzzify(output_dict2) pyfuzzy_system_expected.calculate(i_dict1, output_dict1) new_pyfuzzy_system.calculate(i_dict2, output_dict2) self.assertEquals(output_dict1['a'], output_dict2['a']) self._test_rules_adj_in_out_adjs(new_pyfuzzy_system)
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 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 test_set_from_pyfuzzy_for_polygon_type(self): " shoud return the correct corresponding SetModel for the Polygon pyfuzzy object " points = [(0.,0.),(30.,1.),(60.,0.)] pyfuzzy_set = Polygon(points=points) new_set = SetModel.from_pyfuzzy(pyfuzzy_set) pyfuzzy_set_full_namespace = pyfuzzy_set.__module__ + "." + pyfuzzy_set.__class__.__name__ # are from the same class self.assertEquals(pyfuzzy_set_full_namespace, new_set.set) # have the same args self.assertEquals(1,new_set.parameters.all().count()) points_param = new_set.parameters.all()[0] self.assertEquals("points",points_param.name) self.assertEquals(str(points),points_param.get_value())
def test_set_only(self): " should return the correct outout when only changing the set to a SetModel in th System " from fuzzy_modeling.models import AdjectiveModel pyfuzzy_system_expected = self._createSystem() new_pyfuzzy_system = self._createSystem() SystemModel.from_pyfuzzy(pyfuzzy_system_expected).get_pyfuzzy() from fuzzy.norm.AlgebraicSum import AlgebraicSum from fuzzy.Adjective import Adjective from fuzzy.set.Polygon import Polygon COM = AlgebraicSum() a_stop = Adjective(Polygon([(-10., 0.), (0., 1.), (10., 0.)]), COM=COM) a_stop.name = 'stop' new_a_stop = AdjectiveModel.from_pyfuzzy(a_stop).get_pyfuzzy() new_pyfuzzy_system.variables['a'].adjectives['stop'] = new_a_stop self._test_new_vs_expected_fuzzy_sysem(new_pyfuzzy_system, pyfuzzy_system_expected)
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 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(): 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 _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(): import fuzzy.System system = fuzzy.System.System( description= """This fuzzy system is to control the inverted pendulum into an upright position as well as at the position X=0. It also is used to demonstrate some features of pyfuzzy. This is the reason, it uses different fuzzy norm in normally symmetrical rules.""") from fuzzy.norm.AlgebraicProduct import AlgebraicProduct from fuzzy.norm.AlgebraicSum import AlgebraicSum from fuzzy.fuzzify.Plain import Plain from fuzzy.defuzzify.COG import COG # set defuzzification method and default norms INF = AlgebraicProduct() ACC = AlgebraicSum() COM = AlgebraicSum() CER = AlgebraicProduct() COG = COG(INF=INF, ACC=ACC, failsafe=0., segment_size=0.5) from fuzzy.InputVariable import InputVariable from fuzzy.OutputVariable import OutputVariable from fuzzy.Adjective import Adjective from fuzzy.set.Polygon import Polygon angle = InputVariable(fuzzify=Plain(), description='angle', min=0., max=360., unit='degrees') system.variables['Phi'] = angle angle.adjectives['up_more_right'] = Adjective( Polygon([(0., 0.), (30., 1.), (60., 0.)])) angle.adjectives['up_right'] = Adjective( Polygon([(30., 0.), (60., 1.), (90., 0.)])) angle.adjectives['up'] = Adjective( Polygon([(60., 0.), (90., 1.), (120., 0.)])) angle.adjectives['up_left'] = Adjective( Polygon([(90., 0.), (120., 1.), (150., 0.)])) angle.adjectives['up_more_left'] = Adjective( Polygon([(120., 0.), (150., 1.), (180., 0.)])) angle.adjectives['down_more_left'] = Adjective( Polygon([(180., 0.), (210., 1.), (240., 0.)])) angle.adjectives['down_left'] = Adjective( Polygon([(210., 0.), (240., 1.), (270., 0.)])) angle.adjectives['down'] = Adjective( Polygon([(240., 0.), (270., 1.), (300., 0.)])) angle.adjectives['down_right'] = Adjective( Polygon([(270., 0.), (300., 1.), (330., 0.)])) angle.adjectives['down_more_right'] = Adjective( Polygon([(300., 0.), (330., 1.), (360., 0.)])) angle_velocity = InputVariable(fuzzify=Plain(), description='angle velocity', min=-600., max=600., unit='degrees per second') system.variables['dPhi_dT'] = angle_velocity angle_velocity.adjectives['cw_fast'] = Adjective( Polygon([(-600., 1.), (-300., 0.)])) angle_velocity.adjectives['cw_slow'] = Adjective( Polygon([(-600., 0.), (-300., 1.), (0., 0.)])) angle_velocity.adjectives['stop'] = Adjective( Polygon([(-300., 0.), (0., 1.), (300., 0.)])) angle_velocity.adjectives['ccw_slow'] = Adjective( Polygon([(0., 0.), (300., 1.), (600., 0.)])) angle_velocity.adjectives['ccw_fast'] = Adjective( Polygon([(300., 0.), (600., 1.)])) position = InputVariable(fuzzify=Plain(), description='position', min=-20., max=20., unit='meter') system.variables['X'] = position position.adjectives['left_far'] = Adjective( Polygon([(-20., 1.), (-10., 0.)])) position.adjectives['left_near'] = Adjective( Polygon([(-20., 0.), (-5., 1.), (0., 0.)])) position.adjectives['stop'] = Adjective( Polygon([(-5., 0.), (0., 1.), (5., 0.)])) position.adjectives['right_near'] = Adjective( Polygon([(0., 0.), (5., 1.), (20., 0.)])) position.adjectives['right_far'] = Adjective( Polygon([(10., 0.), (20., 1.)])) velocity = InputVariable(fuzzify=Plain(), description='velocity', min=-10., max=10., unit='meter per second') system.variables['dX_dT'] = velocity velocity.adjectives['left_fast'] = Adjective( Polygon([(-10., 1.), (-5., 0.)])) velocity.adjectives['left_slow'] = Adjective( Polygon([(-10., 0.), (-2., 1.), (0., 0.)])) velocity.adjectives['stop'] = Adjective( Polygon([(-2., 0.), (0., 1.), (2., 0.)])) velocity.adjectives['right_slow'] = Adjective( Polygon([(0., 0.), (2., 1.), (10., 0.)])) velocity.adjectives['right_fast'] = Adjective( Polygon([(5., 0.), (10., 1.)])) acceleration = OutputVariable(defuzzify=COG, description='acceleration', min=-50., max=50., unit='meter per second^2') system.variables['a'] = acceleration acceleration.adjectives['left_fast'] = a_left_fast = Adjective(Polygon([ (-50., 0.), (-20., 1.), (-10., 0.) ]), COM=COM) acceleration.adjectives['left_slow'] = a_left_slow = Adjective(Polygon([ (-20., 0.), (-10., 1.), (0., 0.) ]), COM=COM) acceleration.adjectives['stop'] = a_stop = Adjective(Polygon([(-10., 0.), (0., 1.), (10., 0.)]), COM=COM) acceleration.adjectives['right_slow'] = a_right_slow = Adjective(Polygon([ (0., 0.), (10., 1.), (20., 0.) ]), COM=COM) acceleration.adjectives['right_fast'] = a_right_fast = Adjective(Polygon([ (10., 0.), (20., 1.), (50., 0.) ]), COM=COM) from fuzzy.Rule import Rule from fuzzy.norm.Max import Max #from fuzzy.norm.Min import Min #from fuzzy.norm.BoundedDifference import BoundedDifference #from fuzzy.norm.DrasticSum import DrasticSum from fuzzy.norm.EinsteinSum import EinsteinSum from fuzzy.norm.DombiUnion import DombiUnion from fuzzy.operator.Compound import Compound from fuzzy.operator.Input import Input from fuzzy.operator.Not import Not system.rules['stop'] = Rule( adjective=a_stop, # it gets its value from here operator=Compound( Max(), Compound(AlgebraicProduct(), Input(system.variables["Phi"].adjectives["up"]), Input(system.variables["dPhi_dT"].adjectives["stop"])), Compound(AlgebraicProduct(), Input(system.variables["Phi"].adjectives["up_right"]), Input( system.variables["dPhi_dT"].adjectives["ccw_slow"])), Compound(AlgebraicProduct(), Input(system.variables["Phi"].adjectives["up_left"]), Input( system.variables["dPhi_dT"].adjectives["cw_slow"]))), CER=CER) system.rules['tilts right'] = Rule( adjective=a_right_slow, # it gets its value from here operator=Compound( AlgebraicProduct(), Not( Compound( AlgebraicProduct(), Compound( AlgebraicSum(), Input(system.variables["X"].adjectives["left_near"]), Input(system.variables["X"].adjectives["left_far"])), Compound( EinsteinSum(), Input( system.variables["dX_dT"].adjectives["left_slow"]), Input(system.variables["dX_dT"].adjectives["left_fast"] ))), ), Input(system.variables["Phi"].adjectives["up_right"])), CER=CER) system.rules['tilts left'] = Rule( adjective=a_left_slow, # it gets its value from here operator=Compound( AlgebraicProduct(), Not( Compound( AlgebraicProduct(), Compound( AlgebraicSum(), Input(system.variables["X"].adjectives["right_near"]), Input(system.variables["X"].adjectives["right_far"])), Compound( DombiUnion(0.25), Input(system.variables["dX_dT"]. adjectives["right_slow"]), Input(system.variables["dX_dT"]. adjectives["right_fast"]))), ), Input(system.variables["Phi"].adjectives["up_left"])), CER=CER) system.rules['far right'] = Rule( adjective=a_right_fast, # it gets its value from here operator=Input(system.variables["Phi"].adjectives["up_more_right"]), CER=CER) system.rules['far left'] = Rule( adjective=a_left_fast, # it gets its value from here operator=Input(system.variables["Phi"].adjectives["up_more_left"]), CER=CER) system.rules['accelerate cw if down'] = Rule( adjective=a_right_slow, # it gets its value from here operator=Compound( AlgebraicProduct(), Input(system.variables["Phi"].adjectives["down"]), Compound( AlgebraicProduct(), Input(system.variables["dPhi_dT"].adjectives["cw_slow"]), Input(system.variables["dPhi_dT"].adjectives["cw_slow"]), )), CER=CER) system.rules['accelerate ccw if down'] = Rule( adjective=a_left_slow, # it gets its value from here operator=Compound( AlgebraicProduct(), Input(system.variables["Phi"].adjectives["down"]), Compound( AlgebraicProduct(), Input(system.variables["dPhi_dT"].adjectives["ccw_slow"]), Input(system.variables["dPhi_dT"].adjectives["ccw_slow"]), )), CER=CER) return system
def template(self, i, o, c): r = complement(c, Polygon(i)) self.assertEqual(o, r.points)
def template(self, s1, s2, z): r = [a for a in _merge_generator1(Polygon(s1), Polygon(s2))] self.assertEqual(z, r)
def template(self, x1, x2, y, n): r = merge(n, Polygon(x1), Polygon(x2)) self.assertEqual(y, r.points)
def test2_(self): s1 = Polygon([(0.0, 0.25), (1.0, 0.75)]) z = [(0.0, 0.25), (1.0, 0.75)] #r = list(_merge_generator1(s1,s2)) r = [(x, y) for (x, y) in s1.getValuesXY()] self.assertEqual(z, r)
def test_output_variable_only(self): " should return the correct outout when only changing the outputvar to a OutputVariableModel in th System " from fuzzy_modeling.models import OutputVariableModel from fuzzy.norm.AlgebraicSum import AlgebraicSum from fuzzy.norm.AlgebraicProduct import AlgebraicProduct from fuzzy.Adjective import Adjective from fuzzy.set.Polygon import Polygon from fuzzy.defuzzify.COG import COG from fuzzy.OutputVariable import OutputVariable pyfuzzy_system_expected = self._createSystem() new_pyfuzzy_system = self._createSystem() INF = AlgebraicProduct() ACC = AlgebraicSum() COM = AlgebraicSum() COG = COG(INF=INF, ACC=ACC, failsafe=0., segment_size=0.5) acceleration = OutputVariable(defuzzify=COG, description='acceleration', min=-50., max=50., unit='meter per second^2') acceleration.adjectives['left_fast'] = a_left_fast = Adjective(Polygon( [(-50., 0.), (-20., 1.), (-10., 0.)]), COM=COM) acceleration.adjectives['left_slow'] = a_left_slow = Adjective(Polygon( [(-20., 0.), (-10., 1.), (0., 0.)]), COM=COM) acceleration.adjectives['stop'] = a_stop = Adjective(Polygon([ (-10., 0.), (0., 1.), (10., 0.) ]), COM=COM) acceleration.adjectives['right_slow'] = a_right_slow = Adjective( Polygon([(0., 0.), (10., 1.), (20., 0.)]), COM=COM) acceleration.adjectives['right_fast'] = a_right_fast = Adjective( Polygon([(10., 0.), (20., 1.), (50., 0.)]), COM=COM) acceleration.name = 'a' new_acceleration = OutputVariableModel.from_pyfuzzy( acceleration).get_pyfuzzy() new_pyfuzzy_system.variables['a'] = acceleration import math input_dict = {} input_dict["X"] = 0.0 #: position [m] input_dict["dX_dT"] = 0.0 #: velocity [m/s] input_dict["Phi"] = math.radians(45.0) #: angle [rad] input_dict["dPhi_dT"] = math.radians(0.0) #: angle velocity [rad/s] i_dict1 = input_dict.copy() i_dict2 = input_dict.copy() output_dict1 = { 'a': 0.0 #: acceleration [m/s²] } output_dict2 = { 'a': 0.0 #: acceleration [m/s²] } pyfuzzy_system_expected.fuzzify(i_dict1) pyfuzzy_system_expected.inference() pyfuzzy_system_expected.defuzzify(output_dict1) new_pyfuzzy_system.fuzzify(i_dict2) new_pyfuzzy_system.inference() new_pyfuzzy_system.defuzzify(output_dict2) pyfuzzy_system_expected.calculate(i_dict1, output_dict1) new_pyfuzzy_system.calculate(i_dict2, output_dict2) self.assertNotEquals(output_dict1['a'], output_dict2['a'])
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(): """ \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(): ''' 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 template(self, i, o, n, p): r = norm(n, Polygon(i), p) self.assertEqual(o, r.points)
def test2__(self): s1 = Polygon([(0.0, 0.25), (1.0, 0.75)]) z = [0.0, 1.0] #r = list(_merge_generator1(s1,s2)) r = [x for x in s1.getValuesX()] self.assertEqual(z, r)