private void InitSheepDesireFM()
{
sheepDesireFM = new FuzzyModule();
FuzzyVariable DistToTarget = sheepDesireFM.CreateFLV("DistToOgre");
FzSet Dist_Close = DistToTarget.AddLeftShoulderSet("Dist_Close", 0, 25, 150);
FzSet Dist_Medium = DistToTarget.AddTriangleSet("Dist_Medium", 25, 50, 300);
FzSet Dist_Far = DistToTarget.AddRightShoulderSet("Dist_Far", 150, 300, 500);
FuzzyVariable AmmoStatus = sheepDesireFM.CreateFLV("Hunger");
FzSet Hunger_Low = AmmoStatus.AddLeftShoulderSet("Hunger_Low", 0, 0, 10);
FzSet Hunger_Okay = AmmoStatus.AddTriangleSet("Hunger_Okay", 0, 10, 30);
FzSet Hunger_Intense = AmmoStatus.AddRightShoulderSet("Hunger_Intense", 10, 30, 40);
FuzzyVariable Desirability = sheepDesireFM.CreateFLV("Desirability");
FzSet Undersirable = Desirability.AddLeftShoulderSet("Undesirable", 0, 25, 50);
FzSet Desirable = Desirability.AddTriangleSet("Desirable", 25, 50, 75);
FzSet VeryDesirable = Desirability.AddRightShoulderSet("VeryDesirable", 50, 75, 100);
sheepDesireFM.AddRule(new FzAND(Dist_Close, Hunger_Low), Undersirable);
sheepDesireFM.AddRule(new FzAND(Dist_Close, Hunger_Okay), Undersirable);
sheepDesireFM.AddRule(new FzAND(Dist_Close, Hunger_Intense), Undersirable);
sheepDesireFM.AddRule(new FzAND(Dist_Medium, Hunger_Low), Desirable);
sheepDesireFM.AddRule(new FzAND(Dist_Medium, Hunger_Okay), VeryDesirable);
sheepDesireFM.AddRule(new FzAND(Dist_Medium, Hunger_Intense), VeryDesirable);
sheepDesireFM.AddRule(new FzAND(Dist_Far, Hunger_Low), Undersirable);
sheepDesireFM.AddRule(new FzAND(Dist_Far, Hunger_Okay), Desirable);
sheepDesireFM.AddRule(new FzAND(Dist_Far, Hunger_Intense), Desirable);
}
private void InitPromisingRegionFM()
{
// Promising Region FuzzyModule
promisingRegionFM = new FuzzyModule();
FuzzyVariable DistToRegion = promisingRegionFM.CreateFLV("DistToRegion");
FzSet Dist_Close = DistToRegion.AddLeftShoulderSet("Dist_Close", 0, 50, 150);
FzSet Dist_Medium = DistToRegion.AddTriangleSet("Dist_Medium", 50, 150, 200);
FzSet Dist_Far = DistToRegion.AddRightShoulderSet("Dist_Far", 150, 250, 300);
FuzzyVariable RegionWealth = promisingRegionFM.CreateFLV("RegionWealth");
FzSet Region_Poor = RegionWealth.AddLeftShoulderSet("Region_Poor", 0, 300, 750);
FzSet Region_Decent = RegionWealth.AddTriangleSet("Region_Decent", 750, 1500, 2700);
FzSet Region_Rich = RegionWealth.AddRightShoulderSet("Region_Rich", 2250, 2700, Region.MAX_RESOURCE_COUNT);
FuzzyVariable Desirability = promisingRegionFM.CreateFLV("Desirability");
FzSet Undersirable = Desirability.AddLeftShoulderSet("Undesirable", 0, 25, 50);
FzSet Desirable = Desirability.AddTriangleSet("Desirable", 25, 50, 75);
FzSet Very_Desirable = Desirability.AddRightShoulderSet("VeryDesirable", 50, 75, 100);
promisingRegionFM.AddRule(new FzAND(Dist_Close, Region_Poor), Undersirable);
promisingRegionFM.AddRule(new FzAND(Dist_Close, Region_Decent), Desirable);
promisingRegionFM.AddRule(new FzAND(Dist_Close, Region_Rich), Very_Desirable);
promisingRegionFM.AddRule(new FzAND(Dist_Medium, Region_Poor), Undersirable);
promisingRegionFM.AddRule(new FzAND(Dist_Medium, Region_Decent), Undersirable);
promisingRegionFM.AddRule(new FzAND(Dist_Medium, Region_Rich), Very_Desirable);
promisingRegionFM.AddRule(new FzAND(Dist_Far, Region_Poor), Undersirable);
promisingRegionFM.AddRule(new FzAND(Dist_Far, Region_Decent), Undersirable);
promisingRegionFM.AddRule(new FzAND(Dist_Far, Region_Rich), Very_Desirable);
}
// prepare Metadata condequent for Fuzzy Logic with code
private FuzzyVariable PrepareMetadata()
{
FuzzyVariable Metadata = new FuzzyVariable()
{
Name = "Metadata"
};
FuzzyValue Few = new FuzzyValue()
{
Name = "Few"
};
FuzzyValue Medium = new FuzzyValue()
{
Name = "Medium"
};
FuzzyValue All = new FuzzyValue()
{
Name = "All"
};
Few.MF = new TrapezoidMemberShip(0, 0, 10, 30);
Medium.MF = new TrapezoidMemberShip(0, 30, 60, 90);
All.MF = new TrapezoidMemberShip(60, 90, 100, 100);
Metadata.AddValue(Few);
Metadata.AddValue(Medium);
Metadata.AddValue(All);
return(Metadata);
}
public Thirst() : base()
{
_module = new FuzzyModule();
// Antecedents
FuzzyVariable Thirst = _module.CreateFLV("Thirst");
var Thirst_Low = Thirst.AddLeftShoulderSet("Thirst_Low", 0, 10, 20);
var Thirst_Med = Thirst.AddTriangularSet("Thirst_Med", 10, 20, 30);
var Thirst_High = Thirst.AddRightShoulderSet("Thirst_High", 20, 30, _MAX_THIRST);
FuzzyVariable Distance = _module.CreateFLV("Distance");
var Distance_Close = Distance.AddLeftShoulderSet("Distance_Close", 0, 40, 80);
var Distance_Medium = Distance.AddTriangularSet("Distance_Medium", 40, 80, 400);
var Distance_Far = Distance.AddRightShoulderSet("Distance_Far", 80, 400, MAX_DISTANCE);
// Consequence
FuzzyVariable Desirability = _module.CreateFLV("Desirability");
var Undesirable = Desirability.AddLeftShoulderSet("Undesirable", 0, 25, 50);
var Desirable = Desirability.AddTriangularSet("Desirable", 25, 50, 75);
var VeryDesirable = Desirability.AddRightShoulderSet("VeryDesirable", 50, 75, 100);
// Rules
_module.AddRule(new FzAND(Thirst_Low, Distance_Close), Undesirable);
_module.AddRule(new FzAND(Thirst_Low, Distance_Medium), Undesirable);
_module.AddRule(new FzAND(Thirst_Low, Distance_Far), Undesirable);
_module.AddRule(new FzAND(Thirst_Med, Distance_Close), Desirable);
_module.AddRule(new FzAND(Thirst_Med, Distance_Medium), Undesirable);
_module.AddRule(new FzAND(Thirst_Med, Distance_Far), Undesirable);
_module.AddRule(new FzAND(Thirst_High, Distance_Close), VeryDesirable);
_module.AddRule(new FzAND(Thirst_High, Distance_Medium), VeryDesirable);
_module.AddRule(new FzAND(Thirst_High, Distance_Far), Desirable);
}
/// <summary>
/// This method reads all Fuzzy Logic configuration from SQLite database, and applies
/// this logic to all relevant fuzzy classes
/// </summary>
private void CreateFuzzyLogicFromSQLiteDB()
{
try
{
DataService db = new DataService("fuzzy.db");
var FuzzParts = db.GetFuzzyParts();
var FuzzValues = db.GetFuzzyValues();
var FuzzRules = db.GetFuzzyRules();
// all read so try to create everything from data
FuzzyRuleManager mgr = new FuzzyRuleManager();
foreach (FuzzyParts p in FuzzParts)
{
FuzzyVariable vv = new FuzzyVariable()
{
Name = p.Name
};
if (string.Compare(p.FuzzyType, "Antecedent", false) == 0)
{
mgr.Antecedents.Add(vv);
}
else
{
mgr.Consequent = vv;
}
foreach (FuzzyValues val in FuzzValues)
{
if (string.Compare(val.SetName, p.Name, true) == 0)
{
FuzzyValue fval = new FuzzyValue()
{
Name = val.Name, Parent = vv
};
double[] MFValues = ParseValues(val.MemberValues);
if (string.Compare(val.MemberType, "trapmf", true) == 0) // trapezoid MF?
{
fval.MF = new TrapezoidMemberShip(MFValues[0], MFValues[1], MFValues[2], MFValues[3]);
}
else
{
fval.MF = new TriangleMembership(MFValues[0], MFValues[1], MFValues[2]);
}
vv.AddValue(fval);
}
}
}
foreach (FuzzyRules r in FuzzRules)
{
mgr.AddNewStringRule(r.Rule);
}
// apply rule manager to member variable
mngr = mgr;
ReadFromSQLite = true;
LogManager.Instance.AddLog("Success Create Fuzzy Logic from SQLite DB");
}
catch (Exception ex)
{
Debug.LogError(ex.Message);
}
}
private void testFuzzy()
{
// Creates a working Fuzzy system via code
// Inference engine
this.system.setEngine(new FuzzyInferenceEngine());
// Variables
FuzzyVariable vHealth = new FuzzyVariable("Health",0.0f,10.0f);
vHealth.addMf("Low"); // Should also be able to specify slope and origin
vHealth.addMf("Mid");
vHealth.addMf("High");
FuzzyVariable vDistance = new FuzzyVariable("Distance",0.0f,10.0f);
vDistance.addMf("Low");
vDistance.addMf("Mid");
vDistance.addMf("High");
FuzzyVariable vFear = new FuzzyVariable("Fear",0.0f,10.0f);
vFear.addMf("Low");
vFear.addMf("Mid");
vFear.addMf("High");
// Rules
FuzzyRule rule = new FuzzyRule("Test1");
rule.addAntecedent(vHealth,"Low");
rule.addAntecedent(vDistance,"Low");
rule.addConsequent(vFear,"High");
this.system.addRule(rule);
// Inferral
this.system.infer();
}
private void Awake()
{
fm = new FuzzyModule();
FuzzyVariable DistToTarget = fm.CreateFLV("DistToTarget");
FzSet Target_Close = DistToTarget.AddLeftShoulderSet("Target_Close", 0, 25, 150);
FzSet Target_Medium = DistToTarget.AddTriangleSet("Target_Medium", 25, 50, 300);
FzSet Target_Far = DistToTarget.AddRightShoulderSet("Target_Far", 150, 300, 500);
FuzzyVariable AmmoStatus = fm.CreateFLV("AmmoStatus");
FzSet Ammo_Low = AmmoStatus.AddLeftShoulderSet("Ammo_Low", 0, 0, 10);
FzSet Ammo_Okay = AmmoStatus.AddTriangleSet("Ammo_Okay", 0, 10, 30);
FzSet Ammo_Loads = AmmoStatus.AddRightShoulderSet("Ammo_Loads", 10, 30, 40);
FuzzyVariable Desirability = fm.CreateFLV("Desirablility");
FzSet Undersirable = Desirability.AddLeftShoulderSet("Undesirable", 0, 25, 50);
FzSet Desirable = Desirability.AddTriangleSet("Desirable", 25, 50, 75);
FzSet VeryDesirable = Desirability.AddRightShoulderSet("VeryDesirable", 50, 75, 100);
fm.AddRule(new FzAND(Target_Close, Ammo_Low), Undersirable);
fm.AddRule(new FzAND(Target_Close, Ammo_Okay), Undersirable);
fm.AddRule(new FzAND(Target_Close, Ammo_Loads), Undersirable);
fm.AddRule(new FzAND(Target_Medium, Ammo_Low), Desirable);
fm.AddRule(new FzAND(Target_Medium, Ammo_Okay), VeryDesirable);
fm.AddRule(new FzAND(Target_Medium, Ammo_Loads), VeryDesirable);
fm.AddRule(new FzAND(Target_Far, Ammo_Low), Undersirable);
fm.AddRule(new FzAND(Target_Far, Ammo_Okay), Desirable);
fm.AddRule(new FzAND(Target_Far, Ammo_Loads), Desirable);
}
public void FuzzyTowerCalcSniper(FuzzyModule towerFuzzyModule)
{
// Retrieves the antecedents.
FuzzyVariable health = towerFuzzyModule.GetVar("Health");
FzSet low = new FzSet(health.GetSet("Low"));
FzSet middle = new FzSet(health.GetSet("Middle"));
FzSet high = new FzSet(health.GetSet("High"));
FuzzyVariable distanceToEnemy = towerFuzzyModule.GetVar("DistanceToEnemy");
FzSet close = new FzSet(distanceToEnemy.GetSet("Close"));
FzSet medium = new FzSet(distanceToEnemy.GetSet("Medium"));
FzSet far = new FzSet(distanceToEnemy.GetSet("Far"));
// Creates the consequent.
FuzzyVariable shootDesirability = towerFuzzyModule.CreateFLV("ShootDesirability");
FzSet undesirable = shootDesirability.AddLeftShoulderSet("Undesirable", 0, 15, 30);
FzSet desirable = shootDesirability.AddTriangularSet("Desirable", 15, 30, 75);
FzSet veryDesirable = shootDesirability.AddRightShoulderSet("VeryDesirable", 30, 75, 100);
// Add rules to complete the FAM.
towerFuzzyModule.AddRule(new FzAND(low, close), desirable);
towerFuzzyModule.AddRule(new FzAND(low, medium), desirable);
towerFuzzyModule.AddRule(new FzAND(low, far), veryDesirable);
towerFuzzyModule.AddRule(new FzAND(middle, close), undesirable);
towerFuzzyModule.AddRule(new FzAND(middle, medium), undesirable);
towerFuzzyModule.AddRule(new FzAND(middle, far), desirable);
towerFuzzyModule.AddRule(new FzAND(high, close), undesirable);
towerFuzzyModule.AddRule(new FzAND(high, medium), undesirable);
towerFuzzyModule.AddRule(new FzAND(high, far), desirable);
}
public void TestFuzzyRule()
{
IMemebershipFunction coldFx, warmFx, hotFx;
this.GetMembershipFunctions(out coldFx, out warmFx, out hotFx);
FuzzyVariable <Temperature> cold = new FuzzyVariable <Temperature>(Temperature.Cold, coldFx);
FuzzyVariable <Temperature> warm = new FuzzyVariable <Temperature>(Temperature.Warm, warmFx);
FuzzyVariable <Temperature> hot = new FuzzyVariable <Temperature>(Temperature.Hot, hotFx);
var exp = cold.AsExpression().And(warm).Or(hot.AsExpression().Not());
FuzzyRule <Command> rule = new FuzzyRule <Command>(Command.Heat, exp);
float inputTemp = 10;
FuzzyValueSet valueSet = new FuzzyValueSet();
valueSet.Set(cold.fX(inputTemp));
valueSet.Set(warm.fX(inputTemp));
valueSet.Set(hot.fX(inputTemp));
// 0.6666 AND 0.3333 OR NOT 0.0
var result = rule.Evaluate(valueSet);
Assert.AreEqual(1.0f, result.membershipDegree, 0.000005f);
}
private void button_deleteFV_Click(object sender, EventArgs e)
{
if (dataGridViewFV.SelectedRows.Count > 0)
{
if (MessageBox.Show("Вы действительно хотите удалить эту нечёткую переменную?", "Подтверждение удаления",
MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
try
{
FuzzyVariable fv = dbConnection.Get <FuzzyVariable>(dataGridViewFV.SelectedRows[0].Cells["FVId"].Value);
fv.deleted = 1;
dbConnection.Update(fv);
refreshFuzzyTable(selectedLinguisticVariable);
}
catch (Exception ex)
{
//Exception may occur when dbConnection is null
MessageBox.Show("Произошла ошибка при работе с базой данных: " + ex.Message, "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
else
{
MessageBox.Show("Необходимо выбрать нечёткую переменную", "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
public MakeDecisionGoal(AwareEntity me) : base(me)
{
fuzzyModule = new FuzzyModule();
FuzzyVariable hunger = fuzzyModule.CreateFLV("Hunger");
FzSet hungry = hunger.AddLeftShoulder("Hungry", 0.0, 0.1, 0.3);
FzSet content = hunger.AddTriangle("Content", 0.1, 0.5, 0.8);
FzSet full = hunger.AddRightShoulder("Full", 0.5, 0.8, 1.0);
FuzzyVariable fatique = fuzzyModule.CreateFLV("Fatique");
FzSet sleepy = fatique.AddLeftShoulder("Sleepy", 0.0, 0.1, 0.3);
FzSet awake = fatique.AddTriangle("Awake", 0.1, 0.3, 0.5);
FzSet alert = fatique.AddRightShoulder("Alert", 0.3, 0.5, 1.0);
FuzzyVariable desirability = fuzzyModule.CreateFLV("Desirability");
FzSet unDesirable = desirability.AddLeftShoulder("Undesirable", 0, 0.25, 0.5);
FzSet desirable = desirability.AddTriangle("Desirable", 0.25, 0.5, 0.75);
FzSet veryDesirable = desirability.AddRightShoulder("VeryDesirable", 0.5, 0.75, 1.0);
fuzzyModule.AddRule(new FzAND(hungry, sleepy), unDesirable);
fuzzyModule.AddRule(new FzAND(hungry, awake), desirable);
fuzzyModule.AddRule(new FzAND(hungry, alert), veryDesirable);
fuzzyModule.AddRule(new FzAND(content, sleepy), unDesirable);
fuzzyModule.AddRule(new FzAND(content, awake), desirable);
fuzzyModule.AddRule(new FzAND(content, alert), veryDesirable);
fuzzyModule.AddRule(new FzAND(full, sleepy), unDesirable);
fuzzyModule.AddRule(new FzAND(full, awake), desirable);
fuzzyModule.AddRule(new FzAND(full, alert), veryDesirable);
}
public ThinkGoal(ConsciousGameEntity entity) : base(entity)
{
fuzzyModule = new FuzzyModule();
FuzzyVariable hunger = fuzzyModule.CreateFLV("Hunger");
FzSet starving = hunger.AddLeftShoulder("Starving", 0.0, 0.1, 0.3);
FzSet content = hunger.AddTriangle("Content", 0.1, 0.5, 0.8);
FzSet full = hunger.AddRightShoulder("Full", 0.5, 0.8, 1.0);
FuzzyVariable sleep = fuzzyModule.CreateFLV("Sleep");
FzSet tired = sleep.AddLeftShoulder("Tired", 0.0, 0.1, 0.3);
FzSet sleepy = sleep.AddTriangle("Sleepy", 0.1, 0.3, 0.5);
FzSet awake = sleep.AddRightShoulder("Awake", 0.3, 0.5, 1.0);
FuzzyVariable desirability = fuzzyModule.CreateFLV("Desirability");
FzSet undesirable = desirability.AddLeftShoulder("Undesirable", 0, 0.25, 0.5);
FzSet desirable = desirability.AddTriangle("Desirable", 0.25, 0.5, 0.75);
FzSet veryDesirable = desirability.AddRightShoulder("VeryDesirable", 0.5, 0.75, 1.0);
fuzzyModule.AddRule(new FzOR(starving, tired), undesirable);
fuzzyModule.AddRule(new FzAND(content, sleepy), undesirable);
fuzzyModule.AddRule(new FzAND(full, sleepy), desirable);
fuzzyModule.AddRule(new FzAND(content, awake), desirable);
fuzzyModule.AddRule(new FzAND(full, awake), veryDesirable);
}
public string CreateFuzzyRuleAndReturnResult(FetchRuleDTO rules, double inputValue)
{
FuzzySystemResultDTO system = new FuzzySystemResultDTO();
system = CreateSystem(rules, inputValue);
_fsGround = system.System;
inputValue = system.InputValue;
FuzzyVariable fvInput = _fsGround.InputByName(rules.VariableList.FirstOrDefault(d => d.variableTypeID == (byte)Enums.VariableType.Input).visibleVariableName);
FuzzyVariable fvOutput = _fsGround.OutputByName(rules.VariableList.FirstOrDefault(d => d.variableTypeID == (byte)Enums.VariableType.Output).visibleVariableName);
Dictionary <FuzzyVariable, double> inputValues = new Dictionary <FuzzyVariable, double>();
inputValues.Add(fvInput, inputValue);
Dictionary <FuzzyVariable, double> result = _fsGround.Calculate(inputValues);
_fsGround.DefuzzificationMethod = DefuzzificationMethod.Centroid;
double outputValue = result[fvOutput];
string outputType = ReturnLimitNearbyResults(rules, outputValue);
return(outputType);
}
public static FGUIVariable createFGUIVariable(FuzzyVariable v)
{
GameObject go = (GameObject)Instantiate(prefabFGUIVariable);
FGUIVariable gui = go.GetComponent<FGUIVariable>();
gui.setVariable(v);
return gui;
}
public FuzzyVariable CreateFLV(string name)
{
FuzzyVariable fuzzyVariable = new FuzzyVariable();
m_Variables.Add(name, fuzzyVariable);
m_Variables.TryGetValue(name, out fuzzyVariable);
return(fuzzyVariable);
}
private void OnAddValue(MouseEventArgs e, FuzzyVariable variable)
{
Random rnd = new Random();
FuzzyValue fv = new FuzzyValue(variable, $"Value-{rnd.Next():X08}",
$"Description-{rnd.Next():X08}");
variable.AddValue(fv);
}
private void SecondNameChanged(object sender, EventArgs e)
{
this.second = (FuzzyVariable)secondName.SelectedItem;
if (second != null)
{
secondValue.DataSource = ((FuzzyVariable)secondName.SelectedItem).Labels;
}
}
private void FirstNameChanged(object sender, EventArgs e)
{
this.first = (FuzzyVariable)firstName.SelectedItem;
if (first != null)
{
firstValue.DataSource = new BindingList <string>(first.Labels);
}
}
public void CreateFuzzyFLV()
{
FuzzyModule fuzzyModule = new FuzzyModule();
FuzzyVariable distanceToTarget = fuzzyModule.CreateFLV("DistanceToTarget");
Assert.NotEqual(null, distanceToTarget);
}
private void OnDuplicateValue(MouseEventArgs e, FuzzyVariable variable, FuzzyValue value)
{
FuzzyValue copy = value.Clone();
//copy.Name += " (kopia)";
//copy.Description += " (kopia)";
variable.AddValue(copy);
}
private async Task OnRemoveVariable(MouseEventArgs e, FuzzyVariable variable)
{
if (!await MessageBox.OkCancel(this.Modal, "Pytanie", $"Czy chcesz <b>usunąć</b> zmienną lingwistyczną {variable.Name}?<br/>Usunięcie zmiennej nie spowoduje usunięcia reguł związanych z tą zmienną"))
{
return;
}
BoardProvider.Board.RemoveVariable(variable);
}
public EditFV(SQLiteConnection arg_dbConnection, int arg_linguisticVariableId, FuzzyVariable arg_fuzzyVariable) : this(arg_dbConnection, arg_linguisticVariableId)
{
if (arg_fuzzyVariable != null)
{
fuzzyVariable = arg_fuzzyVariable;
textBox_name.Text = fuzzyVariable.name;
Text = "Редактирование нечёткой переменной";
}
}
private static Term GetTerm(FuzzyVariable variable, string name)
{
var term = variable.Terms.FirstOrDefault(x => x.Name == name);
if (term == null)
{
throw new ProblemConditionsParseException("Не найдено значение " + name + " нечеткой переменной " + variable.Name);
}
return(term);
}
MamdaniFuzzySystem CreateSystem()
{
//
// Create empty fuzzy system
//
MamdaniFuzzySystem fsTips = new MamdaniFuzzySystem();
//
// Create input variables for the system
//
FuzzyVariable fvService = new FuzzyVariable("service", 0.0, 10.0);
fvService.Terms.Add(new FuzzyTerm("poor", new TriangularMembershipFunction(-5.0, 0.0, 5.0)));
fvService.Terms.Add(new FuzzyTerm("good", new TriangularMembershipFunction(0.0, 5.0, 10.0)));
fvService.Terms.Add(new FuzzyTerm("excellent", new TriangularMembershipFunction(5.0, 10.0, 15.0)));
fsTips.Input.Add(fvService);
FuzzyVariable fvFood = new FuzzyVariable("food", 0.0, 10.0);
fvFood.Terms.Add(new FuzzyTerm("rancid", new TrapezoidMembershipFunction(0.0, 0.0, 1.0, 3.0)));
fvFood.Terms.Add(new FuzzyTerm("delicious", new TrapezoidMembershipFunction(7.0, 9.0, 10.0, 10.0)));
fsTips.Input.Add(fvFood);
//
// Create output variables for the system
//
FuzzyVariable fvTips = new FuzzyVariable("tips", 0.0, 30.0);
fvTips.Terms.Add(new FuzzyTerm("cheap", new TriangularMembershipFunction(0.0, 5.0, 10.0)));
fvTips.Terms.Add(new FuzzyTerm("average", new TriangularMembershipFunction(10.0, 15.0, 20.0)));
fvTips.Terms.Add(new FuzzyTerm("generous", new TriangularMembershipFunction(20.0, 25.0, 30.0)));
fsTips.Output.Add(fvTips);
//
// Create three fuzzy rules
//
try
{
MamdaniFuzzyRule rule1 = fsTips.ParseRule("if (service is poor ) or (food is rancid) then tips is cheap");
MamdaniFuzzyRule rule2 = fsTips.ParseRule("if ((service is good)) then tips is average");
MamdaniFuzzyRule rule3 = fsTips.ParseRule("if (service is excellent) or (food is delicious) then (tips is generous)");
fsTips.Rules.Add(rule1);
fsTips.Rules.Add(rule2);
fsTips.Rules.Add(rule3);
}
catch (Exception ex)
{
MessageBox.Show(string.Format("Parsing exception: {0}", ex.Message));
return(null);
}
return(fsTips);
}
public HouseMemberFuzzyCalc([NotNull] Logging.Logger logger)
{
_logger = logger;
//
// Create empty fuzzy system
//
//
// Create input variables for the system
//
var energy = new FuzzyVariable("energy", 0.0, 10000.0);
//// finetune these parameters some more / automate the fine tuning
energy.Terms.Add(new FuzzyTerm("zeroenergy", new TriangularMembershipFunction(-5.0, 0.0, 1000)));
energy.Terms.Add(new FuzzyTerm("onethousand", new TrapezoidMembershipFunction(1000, 1200, 1300, 1800)));
energy.Terms.Add(new FuzzyTerm("twothousand", new TrapezoidMembershipFunction(1500, 2200, 2500, 3500)));
energy.Terms.Add(new FuzzyTerm("threethousand", new TrapezoidMembershipFunction(3300, 4000, 4700, 5000)));
energy.Terms.Add(new FuzzyTerm("fourthousand", new TrapezoidMembershipFunction(4500, 5000, 6000, 6500)));
energy.Terms.Add(new FuzzyTerm("fivethousand", new TriangularMembershipFunction(6500, 7500, 8000)));
energy.Terms.Add(new FuzzyTerm("sixthousand", new TriangularMembershipFunction(7000, 8000, 10000)));
_fsTips.Input.Add(energy);
/*FuzzyVariable fvFood = new FuzzyVariable("food", 0.0, 10.0);
* fvFood.Terms.Add(new FuzzyTerm("rancid", new TrapezoidMembershipFunction(0.0, 0.0, 1.0, 3.0)));
* fvFood.Terms.Add(new FuzzyTerm("delicious", new TrapezoidMembershipFunction(7.0, 9.0, 10.0, 10.0)));
* fsTips.Input.Add(fvFood);*/
//
// Create output variables for the system
//
var people = new FuzzyVariable("people", 0.0, 10);
people.Terms.Add(new FuzzyTerm("zero", new TriangularMembershipFunction(0.0, 0.2, 0.5)));
people.Terms.Add(new FuzzyTerm("oneperson", new TriangularMembershipFunction(0.0, 1, 2)));
people.Terms.Add(new FuzzyTerm("twopersons", new TriangularMembershipFunction(1, 2, 3)));
people.Terms.Add(new FuzzyTerm("threepersons", new TriangularMembershipFunction(2, 3, 4)));
people.Terms.Add(new FuzzyTerm("fourpersons", new TriangularMembershipFunction(3, 4, 5)));
people.Terms.Add(new FuzzyTerm("fivepersons", new TriangularMembershipFunction(4, 5, 6)));
people.Terms.Add(new FuzzyTerm("sixpersons", new TriangularMembershipFunction(5, 6, 7)));
_fsTips.Output.Add(people);
//
// Create three fuzzy rules
//
// try
// {// or (food is rancid)
_fsTips.Rules.Add(_fsTips.ParseRule("if (energy is zeroenergy ) then people is zero"));
_fsTips.Rules.Add(_fsTips.ParseRule("if (energy is onethousand) then people is oneperson"));
_fsTips.Rules.Add(_fsTips.ParseRule("if (energy is twothousand) then (people is twopersons)"));
_fsTips.Rules.Add(_fsTips.ParseRule("if (energy is threethousand) then (people is threepersons)"));
_fsTips.Rules.Add(_fsTips.ParseRule("if (energy is fourthousand) then (people is fourpersons)"));
_fsTips.Rules.Add(_fsTips.ParseRule("if (energy is fivethousand) then (people is fivepersons)"));
_fsTips.Rules.Add(_fsTips.ParseRule("if (energy is sixthousand) then (people is sixpersons)"));
}
private void OnAddVariable(MouseEventArgs e)
{
Random rnd = new Random();
FuzzyVariable fv = new FuzzyVariable()
{
Name = $"Variable-{rnd.Next():X08}",
Description = $"Description-{rnd.Next():X08}"
};
BoardProvider.Board.AddVariable(fv);
}
static FuzzyVariable DefineAgeVariable()
{
var age = new FuzzyVariable("age");
age.AddTerm(new FuzzyTerm("child", new TrapezoidMembershipFunction(0.0, 0.0, 10.0, 14.0)));
age.AddTerm(new FuzzyTerm("adolescent", new TrapezoidMembershipFunction(10.0, 13.0, 17.0, 20.0)));
age.AddTerm(new FuzzyTerm("adult", new TrapezoidMembershipFunction(17.0, 21.0, 36.0, 40.0)));
age.AddTerm(new FuzzyTerm("middle-aged", new TrapezoidMembershipFunction(36.0, 40.0, 48.0, 52.0)));
age.AddTerm(new FuzzyTerm("aged", new TrapezoidMembershipFunction(48.0, 60.0, 80.0, 80.0)));
return(age);
}
static FuzzyVariable DefineTemperatureVariable()
{
var temperature = new FuzzyVariable("temperature");
temperature.AddTerm(new FuzzyTerm("freezing", new TriangularMembershipFunction(5.0, 10.0, 15.0)));
temperature.AddTerm(new FuzzyTerm("cold", new TriangularMembershipFunction(10.0, 15.0, 20.0)));
temperature.AddTerm(new FuzzyTerm("chilly", new TriangularMembershipFunction(15.0, 20.0, 25.0)));
temperature.AddTerm(new FuzzyTerm("warm", new TriangularMembershipFunction(20.0, 25.0, 30.0)));
temperature.AddTerm(new FuzzyTerm("hot", new TriangularMembershipFunction(25.0, 30.0, 35.0)));
return(temperature);
}
public EditVariableForm(FuzzyVariable variable)
: this()
{
this.Text = "Редактирование нечеткой переменной";
this.variableName.Text = variable.Name;
//this.variableName.Enabled = false;
this.variableLingName.Text = variable.LingName;
this.isResult.Checked = variable.IsResult;
_terms = variable.Terms;
RefreshFormListView();
}
private void CreateFact(object sender, EventArgs e)
{
string name = Interaction.InputBox("Введите имя переменной",
"Имя переменной", "Имя переменной");
currentFact = new FuzzyVariable(name, "", currMin, currMax);
for (int i = 0; i < labels.Count; i++)
{
currentFact.AddSet(labels[i], functions[i]);
}
this.Hide();
}
/// <summary>
/// Операция "меньше" между нечетким и четким значениями.
/// Возвращает true, если конец диапазона четких значений нечеткой переменной меньше, чем четкое значение.
/// </summary>
/// <param name="fuzzyValue">Нечеткое значение</param>
/// <param name="intValue">Четкое значение</param>
public bool fuzzyLess(string fuzzyValue, int intValue)
{
FuzzyVariable fuzzyVariable = getFuzzyVariableByName(fuzzyValue);
if (fuzzyVariable != null)
{
return(fuzzyVariable.rangeEnd < intValue);
}
else
{
return(false);
}
}
/// <summary>
/// Операция "меньше либо равно" между нечетким и четким значениями.
/// Возвращает true, если конец диапазона четких значение нечеткой переменной меньше значения четкой переменной, или значение четкой переменной находится в пределах этого диапазона.
/// </summary>
/// <param name="fuzzyValue">Нечеткое значение</param>
/// <param name="intValue">Четкое значение</param>
public bool fuzzyLessOrEquals(string fuzzyValue, int intValue)
{
FuzzyVariable fuzzyVariable = getFuzzyVariableByName(fuzzyValue);
if (fuzzyVariable != null)
{
return((fuzzyVariable.rangeEnd < intValue) || ((intValue >= fuzzyVariable.rangeStart) && (intValue <= fuzzyVariable.rangeEnd)));
}
else
{
return(false);
}
}
// Use this for initialization
void Start()
{
variable = new FuzzyVariable(name,min,max);
renderer.material.color = new Color(1,0,0);
addMf("Short");
FuzzyMembershipFunction mf = addMf("Long");
mf.setOrigin(5);
mf.setSlope(2);
mf.setWidth(4);
mf = addMf("Absurd");
mf.setOrigin(8);
mf.setSlope(5);
mf.setWidth(1);
}
public FuzzyMembershipFunction(string label, FuzzyVariable fuzzy_var, float slope, float origin, float width)
{
this.label = label;
this.fuzzy_var = fuzzy_var;
// Initialisation
// The number of points for this FMF is determined by the resolution and the range of values for the variable
N = Mathf.FloorToInt((fuzzy_var.max-fuzzy_var.min)/resolution)+1;
this.x = new float[N];
this.y = new float[N];
// Default
slopeVal = new Val(slope);
originVal = new Val(origin);
widthVal = new Val(width);
recompute();
//Debug.Log(this);
//startRecomputing();
}
// If V is L ...
public void addAntecedent(FuzzyVariable v, string l)
{
this.inputs.Add(v);
this.labelsIn.Add(l);
}
// .. then V is L.
public void addConsequent(FuzzyVariable v, string l)
{
this.outputs.Add(v);
this.labelsOut.Add(l);
}
private void testRead()
{
// Read a fuzzy system from Fuzzy Tactics Data files
Dictionary<string,object> dictVariables = Json.loadJsonFromFolder("Assets/Scripts/Fuzzy/json/variables");
Dictionary<string,object> dictRules = Json.loadJsonFromFolder("Assets/Scripts/Fuzzy/json/rules");
// Inference engine
this.system.setEngine(new FuzzyInferenceEngine());
// Variables
//((List<object>) dict["array"])[0]);
List<object> listVariables = ((List<object>) dictVariables["variables"]);
foreach (Dictionary<string,object> variable in listVariables){
float min = (float)((double)variable["min"]);
float max = (float)((double)variable["max"]);
FuzzyVariable newVar = new FuzzyVariable((string)variable["name"],min,max);
List<object> mfs = ((List<object>) variable["mfs"]);
foreach (Dictionary<string,object> mf in mfs){
float origin = (float) ((double)mf["origin"]);
float slope = (float) ((double)mf["slope"]);
float width = (float) ((double)mf["width"]);
newVar.addMf((string)mf["label"],slope,origin,width);
}
this.variables[newVar.name] = newVar;
print("Added new variable " + newVar);
}
// Rules
List<object> listRules = ((List<object>) dictRules["rules"]);
foreach (Dictionary<string,object> rule in listRules){
float weight = (float)((double)rule["weight"]);
FuzzyRule newRule = new FuzzyRule((string)rule["name"], weight);
List<object> antecedents = ((List<object>) rule["antecedents"]);
foreach (Dictionary<string,object> antecedent in antecedents){
newRule.addAntecedent(this.variables[(string)antecedent["variable"]], (string)antecedent["label"]);
}
List<object> consequents = ((List<object>) rule["consequents"]);
foreach (Dictionary<string,object> consequent in consequents){
newRule.addConsequent(this.variables[(string)consequent["variable"]], (string)consequent["label"]);
}
this.system.addRule(newRule);
Debug.Log("Added new rule: " + newRule);
}
// Inferral
//this.system.infer();
}
// Constructor
// A FMF is defined for a particular Fuzzy Variable and for a specific label
public FuzzyMembershipFunction(string label, FuzzyVariable fuzzy_var)
: this(label,fuzzy_var,1,0,0)
{
}
public void setVariable(FuzzyVariable v)
{
this.v = v;
this.name = v.name;
textMesh.text = v.name;
}
// Use this for initialization
void Start()
{
variable = new FuzzyVariable(name,min,max);
renderer.material.color = new Color(0,1,0);
}
public DefuzzifiedValue(FuzzyVariable variable, MembershipFunction msf, double value)
{
Variable = variable;
MembershipFunction = msf;
Value = value;
}
