/// <summary> /// Creates a variable with evenly sized and spaced trapezoidal functions. /// </summary> /// <param name="varName">The name of this variable.</param> /// <param name="min">Minimum value.</param> /// <param name="max">Maxiumum value.</param> /// <param name="termNames">The terms of this variable.</param> /// <returns>Symmetric variable.</returns> public static FuzzyVariable CreateSymmetricTrapezoidalVariable(string varName, double min, double max, params string[] termNames) { FuzzyVariable fuzzyVar = new FuzzyVariable(varName, min, max); int count = 0; double spread = (max - min) / ((termNames.Count() * 2) - 1); foreach (string term in termNames) { if(count == 0) { fuzzyVar.Terms.Add(new FuzzyTerm(term, new TrapezoidMembershipFunction(spread * count, spread * count, spread * ++count, spread * ++count))); } else if(count == (termNames.Count() * 2) - 2) { fuzzyVar.Terms.Add(new FuzzyTerm(term, new TrapezoidMembershipFunction(spread * --count, spread * ++count, spread * ++count, spread * count))); } else { fuzzyVar.Terms.Add(new FuzzyTerm(term, new TrapezoidMembershipFunction(spread * --count, spread * ++count, spread * ++count, spread * ++count))); } } return fuzzyVar; }
/// <summary> /// Get coefficient by fuzzy variable /// </summary> /// <param name="var">Fuzzy variable</param> /// <returns>Coefficient's value</returns> public double GetCoefficient(FuzzyVariable var) { if (var == null) { return(_constValue); } else { return(_coeffs[var]); } }
public DecisionMakerType1( List<FuzzyVariable> inputVariables, FuzzyVariable outputVariable, RulesList ruleDefinitions, List<string> includedVariables = null) { if (includedVariables == null) { includedVariables = (from v in inputVariables select v.Name).ToList(); } this.fsWellEval = new MamdaniFuzzySystem(); this.fsWellEval.Input.AddRange(from v in inputVariables where includedVariables.Contains(v.Name) select v); this.fsWellEval.Output.Add(outputVariable); this.RulesDefinitions = new RulesList(); foreach (var rule in ruleDefinitions.Items) { string[] splitDef = rule.Definition.Split( new[] { "if", "and", "(", ")" }, StringSplitOptions.RemoveEmptyEntries); string updatedDef = string.Empty; foreach (var condition in splitDef) { if (condition == string.Empty) { continue; } var trimmedCondition = condition.Trim(); if (trimmedCondition.StartsWith("then")) { updatedDef += trimmedCondition; } else { string variable = trimmedCondition.Split(' ')[0]; if (includedVariables.Contains(variable)) { string keyword = updatedDef == string.Empty ? "if" : "and"; updatedDef += string.Format("{0} ({1}) ", keyword, trimmedCondition); } } } if (!RulesDefinitions.Items.Exists(r => r.Definition.Equals(updatedDef))) { this.RulesDefinitions.Items.Add(new RuleDef { Definition = updatedDef, Weight = rule.Weight }); MamdaniFuzzyRule newRule = this.fsWellEval.ParseRule(updatedDef); this.fsWellEval.Rules.Add(newRule); } } }
/// <summary> /// Set coefficient by fuzzy variable /// </summary> /// <param name="var">Fuzzy variable</param> /// <param name="coeff">New value of the coefficient</param> public void SetCoefficient(FuzzyVariable var, double coeff) { if (var == null) { _constValue = coeff; } else { _coeffs[var] = coeff; } }
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; }
/// <summary> /// Creates a variable with evenly sized and spaced triangular functions. /// </summary> /// <param name="varName">The name of this variable.</param> /// <param name="min">Minimum value.</param> /// <param name="max">Maxiumum value.</param> /// <param name="termNames">The terms of this variable.</param> /// <returns>Symmetric variable.</returns> public static FuzzyVariable CreateSymmetricTriangularVariable(string varName, double min, double max, params string[] termNames) { FuzzyVariable fuzzyVar = new FuzzyVariable(varName, min, max); int count = 0; double spread = (max - min) / (termNames.Count() - 1); foreach (string term in termNames) { fuzzyVar.Terms.Add(new FuzzyTerm(term, new TriangularMembershipFunction(spread * --count, spread * ++count, spread * ++count))); } return fuzzyVar; }
public static FuzzyVariable GetOutputVariable() { XmlSerializer serializer = new XmlSerializer(typeof(ParamsList)); var fs = new FileStream(VARIABLES_DATA, FileMode.Open); var parametersList = (ParamsList)serializer.Deserialize(fs); var parameters = (from item in parametersList.Items where item.Type == ParameterType.Output select item).ToList(); fs.Close(); if (parameters.Count > 0) { FuzzyVariable fsVariable = new FuzzyVariable( parameters[0].ParamName, parameters[0].Min, parameters[0].Max); foreach (Term term in parameters[0].Terms) { fsVariable.Terms.Add(new FuzzyTerm(term.Name, new NormalMembershipFunction(term.b, term.c))); } return fsVariable; } return null; }
public static List<FuzzyVariable> GetInputVariables(int stage = 3) { List<FuzzyVariable> variables = new List<FuzzyVariable>(); XmlSerializer serializer = new XmlSerializer(typeof(ParamsList)); var fs = new FileStream(VARIABLES_DATA, FileMode.Open); var parametersList = (ParamsList)serializer.Deserialize(fs); var parameters = (from item in parametersList.Items where item.Type == ParameterType.Input && item.Stage <= stage select item) .ToList(); fs.Close(); // Create input and output variables for the system foreach (var inputVariable in parameters) { FuzzyVariable fsVariable = new FuzzyVariable( inputVariable.ParamName, inputVariable.Min, inputVariable.Max); foreach (Term term in inputVariable.Terms) { fsVariable.Terms.Add(new FuzzyTerm(term.Name, new NormalMembershipFunction(term.b, term.c))); } variables.Add(fsVariable); } return variables; }
void AddSugenoFuzzyRule( SugenoFuzzySystem fs, FuzzyVariable fv1, FuzzyVariable fv2, SugenoVariable sv, string value1, string value2, string result) { SugenoFuzzyRule rule = fs.EmptyRule(); rule.Condition.Op = OperatorType.And; rule.Condition.ConditionsList.Add(rule.CreateCondition(fv1, fv1.GetTermByName(value1))); rule.Condition.ConditionsList.Add(rule.CreateCondition(fv2, fv2.GetTermByName(value2))); rule.Conclusion.Var = sv; rule.Conclusion.Term = sv.GetFuncByName(result); fs.Rules.Add(rule); }
SugenoFuzzySystem CreateSystem() { // // Create empty Sugeno Fuzzy System // SugenoFuzzySystem fsCruiseControl = new SugenoFuzzySystem(); // // Create input variables for the system // FuzzyVariable fvSpeedError = new FuzzyVariable("SpeedError", -20.0, 20.0); fvSpeedError.Terms.Add(new FuzzyTerm("slower", new TriangularMembershipFunction(-35.0, -20.0, -5.0))); fvSpeedError.Terms.Add(new FuzzyTerm("zero", new TriangularMembershipFunction(-15.0, -0.0, 15.0))); fvSpeedError.Terms.Add(new FuzzyTerm("faster", new TriangularMembershipFunction(5.0, 20.0, 35.0))); fsCruiseControl.Input.Add(fvSpeedError); FuzzyVariable fvSpeedErrorDot = new FuzzyVariable("SpeedErrorDot", -5.0, 5.0); fvSpeedErrorDot.Terms.Add(new FuzzyTerm("slower", new TriangularMembershipFunction(-9.0, -5.0, -1.0))); fvSpeedErrorDot.Terms.Add(new FuzzyTerm("zero", new TriangularMembershipFunction(-4.0, -0.0, 4.0))); fvSpeedErrorDot.Terms.Add(new FuzzyTerm("faster", new TriangularMembershipFunction(1.0, 5.0, 9.0))); fsCruiseControl.Input.Add(fvSpeedErrorDot); // // Create output variables for the system // SugenoVariable svAccelerate = new SugenoVariable("Accelerate"); svAccelerate.Functions.Add(fsCruiseControl.CreateSugenoFunction("zero", new double[] { 0.0, 0.0, 0.0 })); svAccelerate.Functions.Add(fsCruiseControl.CreateSugenoFunction("faster", new double[] { 0.0, 0.0, 1.0 })); svAccelerate.Functions.Add(fsCruiseControl.CreateSugenoFunction("slower", new double[] { 0.0, 0.0, -1.0 })); svAccelerate.Functions.Add(fsCruiseControl.CreateSugenoFunction("func", new double[] { -0.04, -0.1, 0.0 })); fsCruiseControl.Output.Add(svAccelerate); // // Create fuzzy rules // AddSugenoFuzzyRule(fsCruiseControl, fvSpeedError, fvSpeedErrorDot, svAccelerate, "slower", "slower", "faster"); AddSugenoFuzzyRule(fsCruiseControl, fvSpeedError, fvSpeedErrorDot, svAccelerate, "slower", "zero", "faster"); AddSugenoFuzzyRule(fsCruiseControl, fvSpeedError, fvSpeedErrorDot, svAccelerate, "slower", "faster", "zero"); AddSugenoFuzzyRule(fsCruiseControl, fvSpeedError, fvSpeedErrorDot, svAccelerate, "zero", "slower", "faster"); AddSugenoFuzzyRule(fsCruiseControl, fvSpeedError, fvSpeedErrorDot, svAccelerate, "zero", "zero", "func"); AddSugenoFuzzyRule(fsCruiseControl, fvSpeedError, fvSpeedErrorDot, svAccelerate, "zero", "faster", "slower"); AddSugenoFuzzyRule(fsCruiseControl, fvSpeedError, fvSpeedErrorDot, svAccelerate, "faster", "slower", "zero"); AddSugenoFuzzyRule(fsCruiseControl, fvSpeedError, fvSpeedErrorDot, svAccelerate, "faster", "zero", "slower"); AddSugenoFuzzyRule(fsCruiseControl, fvSpeedError, fvSpeedErrorDot, svAccelerate, "faster", "faster", "slower"); // // Adding the same rules in text form // /////////////////////////////////////////////////////////////////// //SugenoFuzzyRule rule1 = fsCruiseControl.ParseRule("if (SpeedError is slower) and (SpeedErrorDot is slower) then (Accelerate is faster)"); //SugenoFuzzyRule rule2 = fsCruiseControl.ParseRule("if (SpeedError is slower) and (SpeedErrorDot is zero) then (Accelerate is faster)"); //SugenoFuzzyRule rule3 = fsCruiseControl.ParseRule("if (SpeedError is slower) and (SpeedErrorDot is faster) then (Accelerate is zero)"); //SugenoFuzzyRule rule4 = fsCruiseControl.ParseRule("if (SpeedError is zero) and (SpeedErrorDot is slower) then (Accelerate is faster)"); //SugenoFuzzyRule rule5 = fsCruiseControl.ParseRule("if (SpeedError is zero) and (SpeedErrorDot is zero) then (Accelerate is func)"); //SugenoFuzzyRule rule6 = fsCruiseControl.ParseRule("if (SpeedError is zero) and (SpeedErrorDot is faster) then (Accelerate is slower)"); //SugenoFuzzyRule rule7 = fsCruiseControl.ParseRule("if (SpeedError is faster) and (SpeedErrorDot is slower) then (Accelerate is faster)"); //SugenoFuzzyRule rule8 = fsCruiseControl.ParseRule("if (SpeedError is faster) and (SpeedErrorDot is zero) then (Accelerate is slower)"); //SugenoFuzzyRule rule9 = fsCruiseControl.ParseRule("if (SpeedError is faster) and (SpeedErrorDot is faster) then (Accelerate is slower)"); //fsCruiseControl.Rules.Add(rule1); //fsCruiseControl.Rules.Add(rule2); //fsCruiseControl.Rules.Add(rule3); //fsCruiseControl.Rules.Add(rule4); //fsCruiseControl.Rules.Add(rule5); //fsCruiseControl.Rules.Add(rule6); //fsCruiseControl.Rules.Add(rule7); //fsCruiseControl.Rules.Add(rule8); //fsCruiseControl.Rules.Add(rule9); /////////////////////////////////////////////////////////////////// return fsCruiseControl; }
/// <summary> /// Create a single condition /// </summary> /// <param name="var">A linguistic variable to which the condition is related</param> /// <param name="term">A term in expression 'var is term'</param> /// <param name="not">Does condition contain 'not'</param> /// <param name="hedge">Hedge modifier</param> /// <returns>Generated condition</returns> public FuzzyCondition CreateCondition(FuzzyVariable var, FuzzyTerm term, bool not, HedgeType hedge) { return(new FuzzyCondition(var, term, not, hedge)); }
/// <summary> /// Create a single condition /// </summary> /// <param name="var">A linguistic variable to which the condition is related</param> /// <param name="term">A term in expression 'var is term'</param> /// <param name="not">Does condition contain 'not'</param> /// <returns>Generated condition</returns> public FuzzyCondition CreateCondition(FuzzyVariable var, FuzzyTerm term, bool not) { return(new FuzzyCondition(var, term, not)); }
private List<FuzzyVariable> GetInputVariables(FuzzyCheckDBContext context) { List<FuzzyVariable> variables = new List<FuzzyVariable>(); foreach (var inputVariable in context.Parameters) { if (inputVariable.IsInput) { FuzzyVariable fsVariable = new FuzzyVariable( inputVariable.Name, inputVariable.Min, inputVariable.Max); variables.Add(fsVariable); } } foreach (var variable in variables) { var dbVariable = context.Parameters.Single(p => p.Name == variable.Name); foreach (var term in dbVariable.Terms) { variable.Terms.Add(new FuzzyTerm(term.Name, new NormalMembershipFunction(term.b, term.c))); } } return variables; }
private double PreprocessInputValue(FuzzyVariable variable, double value) { if (value <= variable.Min) { return variable.Min; } if (value >= variable.Max) { return variable.Max; } return value; }
private static MamdaniFuzzySystem UpdateParamsByMultiplier( DecisionMakerType1 originalDecisionMaker, double multiplier, VariableMFParam paramToUpdate, out bool canStretchMore) { canStretchMore = false; // Create empty fuzzy system MamdaniFuzzySystem newFs = new MamdaniFuzzySystem(); // Create input and output variables for the system foreach (var inputVariable in originalDecisionMaker.fsWellEval.Input) { FuzzyVariable fsVariable = new FuzzyVariable(inputVariable.Name, inputVariable.Min, inputVariable.Max); foreach (var term in inputVariable.Terms) { var mf = term.MembershipFunction as NormalMembershipFunction; if (paramToUpdate == VariableMFParam.Mean) { if (mf != null && (mf.B * multiplier >= fsVariable.Min && mf.B * multiplier <= fsVariable.Max)) { fsVariable.Terms.Add( new FuzzyTerm(term.Name, new NormalMembershipFunction(mf.B * multiplier, mf.Sigma))); canStretchMore = true; } else { if (mf != null) { fsVariable.Terms.Add(new FuzzyTerm(term.Name, new NormalMembershipFunction(mf.B, mf.Sigma))); canStretchMore = false; } } } if (paramToUpdate == VariableMFParam.Deviation) { if (mf != null && (mf.Sigma * multiplier >= 0.001 && mf.Sigma * multiplier <= 10)) { fsVariable.Terms.Add( new FuzzyTerm(term.Name, new NormalMembershipFunction(mf.B, mf.Sigma * multiplier))); } else { if (mf != null) { fsVariable.Terms.Add(new FuzzyTerm(term.Name, new NormalMembershipFunction(mf.B, mf.Sigma))); } } } if (paramToUpdate == VariableMFParam.RuleWeight) { if (mf != null) { fsVariable.Terms.Add(new FuzzyTerm(term.Name, new NormalMembershipFunction(mf.B, mf.Sigma))); } } } newFs.Input.Add(fsVariable); } foreach (var outputVariable in originalDecisionMaker.fsWellEval.Output) { var newVariable = new FuzzyVariable( outputVariable.Name, outputVariable.Min, outputVariable.Max, outputVariable.Unit); newVariable.Terms.Clear(); newVariable.Terms.AddRange(outputVariable.Terms); newFs.Output.Add(newVariable); } for (int i = 0; i < originalDecisionMaker.RulesDefinitions.Items.Count; i++) { MamdaniFuzzyRule newRule = newFs.ParseRule(originalDecisionMaker.RulesDefinitions.Items[i].Definition); double oldWeight = originalDecisionMaker.fsWellEval.Rules[i].Weight; if (paramToUpdate == VariableMFParam.RuleWeight) { if (oldWeight * multiplier >= 0.001 && oldWeight * multiplier <= 1) { newRule.Weight = oldWeight * multiplier; } } else { newRule.Weight = oldWeight; } newFs.Rules.Add(newRule); } return newFs; }
private static Bitmap GetTermImg(FuzzyVariable fv) { Bitmap bmp = new Bitmap(400, 200); if (fv != null) { RelationImage img = new RelationImage(fv); img.DrawImage(Graphics.FromImage(bmp)); } return bmp; }
private FuzzyVariable GetOutputVariable() { var parameters = (from item in db.Parameters where !item.IsInput select item).ToList(); List<FuzzyVariable> variables = new List<FuzzyVariable>(); foreach (var variable in parameters) { FuzzyVariable fsVariable = new FuzzyVariable( variable.Name, variable.Min, variable.Max); foreach (var term in variable.Terms) { fsVariable.Terms.Add(new FuzzyTerm(term.Name, new NormalMembershipFunction(term.b, term.c))); } return fsVariable; } return null; }
private List<FuzzyVariable> GetInputVariables() { List<FuzzyVariable> variables = new List<FuzzyVariable>(); foreach (var inputVariable in db.Parameters) { if (inputVariable.IsInput /* &¶meterValues.Any(pv => pv.ID == inputVariable.Id)*/) { FuzzyVariable fsVariable = new FuzzyVariable( inputVariable.Name, inputVariable.Min, inputVariable.Max); variables.Add(fsVariable); } } foreach (var variable in variables) { var dbVariable = db.Parameters.Single(p => p.Name == variable.Name); foreach (var term in dbVariable.Terms) { variable.Terms.Add(new FuzzyTerm(term.Name, new NormalMembershipFunction(term.b, term.c))); } } return variables; }
string DefuzzifyToClosestTerm(FuzzyVariable outputVariable, IMembershipFunction compositeMF, double min, double max) { int k = 50; double step = (max - min) / k; double maxArea = 0; string matchingTerm = outputVariable.Terms[0].Name; foreach (var term in outputVariable.Terms) { double coverageArea = 0; double leftX = min; double rightX = leftX + step; while (rightX <= max) { coverageArea += step * (Math.Min(term.MembershipFunction.GetValue(leftX), compositeMF.GetValue(leftX))); leftX += step; rightX += step; } if (coverageArea > maxArea) { maxArea = coverageArea; matchingTerm = term.Name; } } return matchingTerm; }
public static Dictionary<NodeInstance, double> PrioritizeNodes(List<NodeInstance> nodes) { MamdaniFuzzySystem fsNodeSys = new MamdaniFuzzySystem(); FuzzyVariable fvCPU = new FuzzyVariable("cpu", 0.0, 1); fvCPU.Terms.Add(new FuzzyTerm("low", new TriangularMembershipFunction(-.50, 0, .50))); fvCPU.Terms.Add(new FuzzyTerm("med", new TriangularMembershipFunction(0, .50, 1))); fvCPU.Terms.Add(new FuzzyTerm("high", new TriangularMembershipFunction(.50, 1, 1.5))); fsNodeSys.Input.Add(fvCPU); FuzzyVariable fvBandwidth = new FuzzyVariable("bandwidth", 0.0, 1); fvBandwidth.Terms.Add(new FuzzyTerm("low", new TriangularMembershipFunction(-.50, 0, .50))); fvBandwidth.Terms.Add(new FuzzyTerm("med", new TriangularMembershipFunction(0, .50, 1))); fvBandwidth.Terms.Add(new FuzzyTerm("high", new TriangularMembershipFunction(.50, 1, 1.5))); fsNodeSys.Input.Add(fvBandwidth); FuzzyVariable fvFreeSpace = new FuzzyVariable("freespace", 0.0, 1); fvFreeSpace.Terms.Add(new FuzzyTerm("low", new TriangularMembershipFunction(-.5, 0, .5))); fvFreeSpace.Terms.Add(new FuzzyTerm("moderate", new TriangularMembershipFunction(0, .5, 1))); fvFreeSpace.Terms.Add(new FuzzyTerm("ample", new TriangularMembershipFunction(.5, 1, 1.5))); fsNodeSys.Input.Add(fvFreeSpace); // // Create output variables for the system // FuzzyVariable fvRank = new FuzzyVariable("rank", 0, 1); fvRank.Terms.Add(new FuzzyTerm("low", new TriangularMembershipFunction(-0.25, 0, 0.25))); fvRank.Terms.Add(new FuzzyTerm("med_low", new TriangularMembershipFunction(0, 0.25, 0.50))); fvRank.Terms.Add(new FuzzyTerm("med", new TriangularMembershipFunction(0.25, 0.50, 0.75))); fvRank.Terms.Add(new FuzzyTerm("med_high", new TriangularMembershipFunction(0.50, 0.75, 1))); fvRank.Terms.Add(new FuzzyTerm("high", new TriangularMembershipFunction(0.75, 1, 1.25))); fsNodeSys.Output.Add(fvRank); MamdaniFuzzyRule rule1 = fsNodeSys.ParseRule("if (cpu is low) and (bandwidth is high) and (freespace is ample) then rank is med"); MamdaniFuzzyRule rule2 = fsNodeSys.ParseRule("if (cpu is low) and (bandwidth is high) and (freespace is moderate) then rank is med_low"); MamdaniFuzzyRule rule3 = fsNodeSys.ParseRule("if (cpu is low) and (bandwidth is high) and (freespace is low) then rank is low"); MamdaniFuzzyRule rule4 = fsNodeSys.ParseRule("if (cpu is low) and (bandwidth is med) and (freespace is ample) then rank is med_high"); MamdaniFuzzyRule rule5 = fsNodeSys.ParseRule("if (cpu is low) and (bandwidth is med) and (freespace is moderate) then rank is med_high"); MamdaniFuzzyRule rule6 = fsNodeSys.ParseRule("if (cpu is low) and (bandwidth is med) and (freespace is low) then rank is med_low"); MamdaniFuzzyRule rule7 = fsNodeSys.ParseRule("if (cpu is low) and (bandwidth is low) and (freespace is ample) then rank is high"); MamdaniFuzzyRule rule8 = fsNodeSys.ParseRule("if (cpu is low) and (bandwidth is low) and (freespace is moderate) then rank is med_high"); MamdaniFuzzyRule rule9 = fsNodeSys.ParseRule("if (cpu is low) and (bandwidth is low) and (freespace is low) then rank is med_low"); MamdaniFuzzyRule rule10 = fsNodeSys.ParseRule("if (cpu is med) and (bandwidth is high) and (freespace is ample) then rank is med"); MamdaniFuzzyRule rule11 = fsNodeSys.ParseRule("if (cpu is med) and (bandwidth is high) and (freespace is moderate) then rank is med_low"); MamdaniFuzzyRule rule12 = fsNodeSys.ParseRule("if (cpu is med) and (bandwidth is high) and (freespace is low) then rank is med_low"); MamdaniFuzzyRule rule13 = fsNodeSys.ParseRule("if (cpu is med) and (bandwidth is med) and (freespace is ample) then rank is med"); MamdaniFuzzyRule rule14 = fsNodeSys.ParseRule("if (cpu is med) and (bandwidth is med) and (freespace is moderate) then rank is med"); MamdaniFuzzyRule rule15 = fsNodeSys.ParseRule("if (cpu is med) and (bandwidth is med) and (freespace is low) then rank is low"); MamdaniFuzzyRule rule16 = fsNodeSys.ParseRule("if (cpu is med) and (bandwidth is low) and (freespace is ample) then rank is med_high"); MamdaniFuzzyRule rule17 = fsNodeSys.ParseRule("if (cpu is med) and (bandwidth is low) and (freespace is moderate) then rank is med_high"); MamdaniFuzzyRule rule18 = fsNodeSys.ParseRule("if (cpu is med) and (bandwidth is low) and (freespace is low) then rank is low"); MamdaniFuzzyRule rule19 = fsNodeSys.ParseRule("if (cpu is high) and (bandwidth is high) and (freespace is ample) then rank is med"); MamdaniFuzzyRule rule20 = fsNodeSys.ParseRule("if (cpu is high) and (bandwidth is high) and (freespace is moderate) then rank is med_low"); MamdaniFuzzyRule rule21 = fsNodeSys.ParseRule("if (cpu is high) and (bandwidth is high) and (freespace is low) then rank is low"); MamdaniFuzzyRule rule22 = fsNodeSys.ParseRule("if (cpu is high) and (bandwidth is med) and (freespace is ample) then rank is med"); MamdaniFuzzyRule rule23 = fsNodeSys.ParseRule("if (cpu is high) and (bandwidth is med) and (freespace is moderate) then rank is med_low"); MamdaniFuzzyRule rule24 = fsNodeSys.ParseRule("if (cpu is high) and (bandwidth is med) and (freespace is low) then rank is low"); MamdaniFuzzyRule rule25 = fsNodeSys.ParseRule("if (cpu is high) and (bandwidth is low) and (freespace is ample) then rank is med_low"); MamdaniFuzzyRule rule26 = fsNodeSys.ParseRule("if (cpu is high) and (bandwidth is low) and (freespace is moderate) then rank is med"); MamdaniFuzzyRule rule27 = fsNodeSys.ParseRule("if (cpu is high) and (bandwidth is low) and (freespace is low) then rank is low"); fsNodeSys.Rules.Add(rule1); fsNodeSys.Rules.Add(rule2); fsNodeSys.Rules.Add(rule3); fsNodeSys.Rules.Add(rule4); fsNodeSys.Rules.Add(rule5); fsNodeSys.Rules.Add(rule6); fsNodeSys.Rules.Add(rule7); fsNodeSys.Rules.Add(rule8); fsNodeSys.Rules.Add(rule9); fsNodeSys.Rules.Add(rule10); fsNodeSys.Rules.Add(rule11); fsNodeSys.Rules.Add(rule12); fsNodeSys.Rules.Add(rule13); fsNodeSys.Rules.Add(rule14); fsNodeSys.Rules.Add(rule15); fsNodeSys.Rules.Add(rule16); fsNodeSys.Rules.Add(rule17); fsNodeSys.Rules.Add(rule18); fsNodeSys.Rules.Add(rule19); fsNodeSys.Rules.Add(rule20); fsNodeSys.Rules.Add(rule21); fsNodeSys.Rules.Add(rule22); fsNodeSys.Rules.Add(rule23); fsNodeSys.Rules.Add(rule24); fsNodeSys.Rules.Add(rule25); fsNodeSys.Rules.Add(rule26); fsNodeSys.Rules.Add(rule27); var rankedNodes = new Dictionary<NodeInstance, double>(); for (int i = 0; i < nodes.Count; i++) { // // Fuzzify input values // Dictionary<FuzzyVariable, double> inputValues = new Dictionary<FuzzyVariable, double>(); inputValues.Add(fvCPU, nodes[i].CPU_Utilization); inputValues.Add(fvBandwidth, nodes[i].UsedBandwidth / nodes[i].MaxBandwidth); inputValues.Add(fvFreeSpace, nodes[i].FreeSpace / nodes[i].MaxBackupSpace); // // Calculate the result // Dictionary<FuzzyVariable, double> result = fsNodeSys.Calculate(inputValues); double rank = result[fvRank]; rankedNodes.Add(nodes[i], rank); //Console.WriteLine(nodes[i].ToString()); //Console.WriteLine("Rank: " + Math.Round(rank, 2).ToString()); //Console.WriteLine(); } var sortedNodes = (from entry in rankedNodes orderby entry.Value descending select entry) .ToDictionary(pair => pair.Key, pair => pair.Value); return sortedNodes; }
/// <summary> /// Creates new instance of image just to display a single-dimensional fuzzy set without any values specified. /// </summary> /// <param name="singleDimensionalSet">Single-dimensional set to display</param> public RelationImage(FuzzyVariable singleDimensionalSet) { _variable = singleDimensionalSet; _fullySpecified = false; _specifiedMembership = null; }
public DecisionMakerType2(string stretchedParametersXml, FuzzyVariable outputVariable, RulesList ruleDefinitions, List<FuzzyVariable> includedVariables) { XmlSerializer serializer = new XmlSerializer(typeof(Type2ParamsList)); XmlReaderSettings settings = new XmlReaderSettings(); using (StringReader textReader = new StringReader(stretchedParametersXml)) { using (XmlReader xmlReader = XmlReader.Create(textReader, settings)) { Type2ParamsList deserializedT2Params = (Type2ParamsList)serializer.Deserialize(xmlReader); inputVariables = new List<Type2FuzzyVariable>(); foreach (var variable in deserializedT2Params.Items) { if (includedVariables.Exists(v => v.Name == variable.ParamName)) { Type2FuzzyVariable newVariable = new Type2FuzzyVariable( variable.ParamName, variable.Min, variable.Max, variable.Unit); foreach (var term in variable.Terms) { Type2FuzzyTerm newTerm = new Type2FuzzyTerm( term.name, new NormalMembershipFunction(term.b.Upper, term.c.Upper), new NormalMembershipFunction(term.b.Lower, term.c.Lower)); newVariable.Terms.Add(newTerm); } inputVariables.Add(newVariable); } } // output variable this.outputVariable = new Type2FuzzyVariable( outputVariable.Name, outputVariable.Min, outputVariable.Max, outputVariable.Unit); foreach (var term in outputVariable.Terms) { Type2FuzzyTerm newTerm = new Type2FuzzyTerm( term.Name, new NormalMembershipFunction( (term.MembershipFunction as NormalMembershipFunction).B, (term.MembershipFunction as NormalMembershipFunction).Sigma), new NormalMembershipFunction( (term.MembershipFunction as NormalMembershipFunction).B, (term.MembershipFunction as NormalMembershipFunction).Sigma)); this.outputVariable.Terms.Add(newTerm); } // rules rules = new List<Type2MamdaniFuzzyRule>(); var updatedDefinitions = new List<RuleDef>(); foreach (var rule in ruleDefinitions.Items) { string[] splitDef = rule.Definition.Split( new[] {"if", "and", "(", ")"}, StringSplitOptions.RemoveEmptyEntries); string updatedDef = string.Empty; foreach (var condition in splitDef) { if (condition == string.Empty) { continue; } var trimmedCondition = condition.Trim(); if (trimmedCondition.StartsWith("then")) { updatedDef += trimmedCondition; } else { string variable = trimmedCondition.Split(' ')[0]; if (includedVariables.Exists(v => v.Name == variable)) { string keyword = updatedDef == string.Empty ? "if" : "and"; updatedDef += string.Format("{0} ({1}) ", keyword, trimmedCondition); } } } if (!updatedDefinitions.Exists(r => r.Definition.Equals(updatedDef))) { updatedDefinitions.Add(new RuleDef { Definition = updatedDef, Weight = rule.Weight }); Type2MamdaniFuzzyRule newRule = ParseRule(updatedDef); newRule.Weight = rule.Weight; rules.Add(newRule); } } isInitialized = true; } } }