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 bool CreateFuzzyRuleAndCompare(FetchRuleDTO rules, double inputValue1, double inputValue2, int ratio)
{
FuzzySystemResultDTO system = new FuzzySystemResultDTO();
system = CreateSystem(rules, inputValue1);
_fsGround = system.System;
inputValue1 = system.InputValue;
FuzzyVariable fvInput1 = _fsGround.InputByName(session.variables.FirstOrDefault(d => d.variableTypeID == (byte)Enums.VariableType.Input).visibleVariableName);
FuzzyVariable fvOutput1 = _fsGround.OutputByName(session.variables.FirstOrDefault(d => d.variableTypeID == (byte)Enums.VariableType.Output).visibleVariableName);
Dictionary <FuzzyVariable, double> inputValues1 = new Dictionary <FuzzyVariable, double>();
inputValues1.Add(fvInput1, inputValue1);
Dictionary <FuzzyVariable, double> result1 = _fsGround.Calculate(inputValues1);
_fsGround.DefuzzificationMethod = DefuzzificationMethod.Bisector;
double outputValue1 = result1[fvOutput1];
_fsGround = null;
system = CreateSystem(rules, inputValue2);
_fsGround = system.System;
inputValue2 = system.InputValue;
FuzzyVariable fvInput2 = _fsGround.InputByName(rules.VariableList.FirstOrDefault(d => d.variableTypeID == (byte)Enums.VariableType.Input).visibleVariableName);
FuzzyVariable fvOutput2 = _fsGround.OutputByName(rules.VariableList.FirstOrDefault(d => d.variableTypeID == (byte)Enums.VariableType.Output).visibleVariableName);
Dictionary <FuzzyVariable, double> inputValues2 = new Dictionary <FuzzyVariable, double>();
inputValues2.Add(fvInput2, inputValue2);
Dictionary <FuzzyVariable, double> result2 = _fsGround.Calculate(inputValues2);
_fsGround.DefuzzificationMethod = DefuzzificationMethod.Centroid;
double outputValue2 = result2[fvOutput2];
var result = ReturnNearbyResults(outputValue1, outputValue2, ratio);
return(result);
}
private string ReturnLimitNearbyResults(FetchRuleDTO rules, double outputValue)
{
string result = "";
var variableID = rules.VariableList.FirstOrDefault(dl => dl.variableTypeID == (byte)Enums.VariableType.Output).variableID;
//var OutputList = _variableItemService.Queryable().Where(d => d.variableID == variableID).ToList();
var OutputList = session.variableItems.Where(d => d.variableID == variableID).ToList();
for (int i = 0; i < OutputList.Count; i++)
{
if (i == OutputList.Count - 1)
{
//if (outputValue >= OutputList[i].MinDeger && outputValue <= OutputList[i].MaxDeger)
//{
result = OutputList[i].variableItemName;
break;
//}
}
else
{
if (OutputList[i].maxValue > OutputList[i + 1].minValue) //Bir sonraki tanım aralığı ile kesişimi var demektir
{
if (outputValue <= OutputList[i].maxValue && outputValue >= OutputList[i + 1].minValue)
{
result = Math.Abs(outputValue - OutputList[i].maxValue) > Math.Abs(outputValue - OutputList[i + 1].minValue) ? OutputList[i].variableItemName : OutputList[i + 1].variableItemName;
break;
}
}
else
{
if (outputValue >= OutputList[i].minValue && outputValue <= OutputList[i].maxValue)
{
result = OutputList[i].variableItemName;
break;
}
}
}
}
return(result);
}
public FetchRuleDTO FetchRule(long ruleID, SessionDTO sessionData)
{
session = sessionData;
FetchRuleDTO fetchRule = new FetchRuleDTO();
List <VariableItem> variableItemList = new List <VariableItem>();
// var rule = _ruleService.Queryable().FirstOrDefault(k => k.ruleID == ruleID && k.isActive == true);
var rule = session.rule;
var ruleListText = rule.ruleListTexts.ToList();
var variables = rule.variables.ToList();
foreach (var item in variables)
{
//var variableItems = _variableItemService.Queryable().Where(d => d.variableID == item.variableID).ToList();
var variableItems = session.variableItems.Where(d => d.variableID == item.variableID).ToList();
variableItemList.AddRange(variableItems);
}
fetchRule.FuzzyRule = rule;
fetchRule.RuleListText = ruleListText;
fetchRule.VariableList = variables;
fetchRule.VariableItemList = variableItemList;
return(fetchRule);
}
private FuzzySystemResultDTO CreateSystem(FetchRuleDTO rules, double inputValue)
{
FuzzySystemResultDTO result = new FuzzySystemResultDTO();
MamdaniFuzzySystem fsGround = new MamdaniFuzzySystem();
rules.VariableList = session.variables;
rules.RuleListText = session.rules;
rules.VariableItemList = session.variableItems;
foreach (var variable in rules.VariableList)
{
if (variable.variableTypeID == (byte)Enums.VariableType.Input)
{
FuzzyVariable fvInput = new FuzzyVariable(variable.visibleVariableName, 0.0, 1000.0);
var variableItems = rules.VariableItemList.Where(k => k.variableID == variable.variableID).ToList();
for (int i = 0; i < variableItems.Count; i++)
{
if (inputValue == variableItems[i].minValue)
{
inputValue++;
}
double maxValue;
if (i != variableItems.Count - 1)
{
if (variableItems[i].maxValue == variableItems[i + 1].minValue)
{
maxValue = variableItems[i].maxValue - 1;
}
else
{
maxValue = variableItems[i].maxValue;
}
}
else
{
maxValue = variableItems[i].maxValue;
}
fvInput.Terms.Add(new FuzzyTerm(variableItems[i].variableItemVisibleName, new TriangularMembershipFunction(variableItems[i].minValue, (variableItems[i].minValue + variableItems[i].maxValue) / 2, maxValue)));
}
fsGround.Input.Add(fvInput);
}
else
{
FuzzyVariable fvOutput = new FuzzyVariable(variable.visibleVariableName, 0.0, 1000.0);
var variableItems = rules.VariableItemList.Where(k => k.variableID == variable.variableID).ToList();
for (int i = 0; i < variableItems.Count; i++)
{
double maxValue;
if (i != variableItems.Count - 1)
{
if (variableItems[i].maxValue == variableItems[i + 1].minValue)
{
maxValue = variableItems[i].maxValue - 1;
}
else
{
maxValue = variableItems[i].maxValue;
}
}
else
{
maxValue = variableItems[i].maxValue;
}
fvOutput.Terms.Add(new FuzzyTerm(variableItems[i].variableItemVisibleName, new TriangularMembershipFunction(variableItems[i].minValue, (variableItems[i].minValue + variableItems[i].maxValue) / 2, maxValue)));
}
fsGround.Output.Add(fvOutput);
}
}
foreach (var ruleText in rules.RuleListText)
{
MamdaniFuzzyRule rule = fsGround.ParseRule(ruleText.ruleText);
fsGround.Rules.Add(rule);
}
result.System = fsGround;
result.InputValue = inputValue;
return(result);
}
