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);
}
}
}
public DecisionMakerType1(MamdaniFuzzySystem fuzzySystem, RulesList rulesDefinitions)
{
this.fsWellEval = fuzzySystem;
this.RulesDefinitions = rulesDefinitions;
}
public ActionResult InitializeFLS()
{
try
{
// initialize the FLS
List<FuzzyVariable> inputVariables = GetInputVariables(db);
FuzzyVariable outputVariable = GetOutputVariable(db);
var ruleDefinitions = new RulesList();
ruleDefinitions.Items = (from r in db.Rules select new RuleDef { Definition = r.Definition, Weight = r.Weight }).ToList();
var decisionMakerT1 = new DecisionMakerType1(inputVariables, outputVariable, ruleDefinitions);
// DataProvider.DataProvider.SaveInputVariables(decisionMakerT1.SerializableParameters);
var decisionMakerT2 = new DecisionMakerType2(decisionMakerT1);
var learningDataSet = DataProvider.DataProvider.GetLearningDataSet();
decisionMakerT2.Initialize(learningDataSet);
// DataProvider.DataProvider.SaveInputVariables(decisionMakerT2.SerializableParameters);
var decisionMakerProperties = new DecisionMakerProperties
{
ParametersXml = DataProvider.DataProvider.WriteInputVariables(decisionMakerT2.SerializableParameters)
};
db.Database.ExecuteSqlCommand("TRUNCATE TABLE DecisionMakerProperties");
db.SaveChanges();
db.DecisionMakerProperties.Add(decisionMakerProperties);
db.SaveChanges();
return new HttpStatusCodeResult(HttpStatusCode.OK);
}
catch (Exception ex)
{
return new HttpStatusCodeResult(HttpStatusCode.InternalServerError, ex.Message);
}
}
private RulesList GetRulesDefinitions()
{
var rulesList = new RulesList();
rulesList.Items = (from r in db.Rules select new RuleDef { Definition = r.Definition, Weight = r.Weight }).ToList();
return rulesList;
}
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;
}
}
}
