public static IEnumerable <ReferencePoint> Parse(IFuzzyFunction function)
{
return(function.GetType()
.GetProperties()
.Where(property => property.GetCustomAttributes(typeof(ReferencePointAttribute)).Any())
.Select(property => new ReferencePoint(property.Name)));
}
public static IEnumerable <InRangePoint> Parse(IFuzzyFunction function)
{
return(function.GetType()
.GetProperties()
.Where(property => property.GetCustomAttributes(typeof(InRangePointAttribute)).Any())
.Select(property => new KeyValuePair <string, InRangePointAttribute>(property.Name,
property.GetCustomAttribute <InRangePointAttribute>()))
.Select(attribute => new InRangePoint(attribute.Key, attribute.Value.LeftPoint, attribute.Value.RightPoint)));
}
private static ChartValues <ObservablePoint> GetFunctionResult(IFuzzyFunction func)
{
var result = new ChartValues <ObservablePoint>();
var points = FuzzyFunctionToChartValuesConvertor.GetValues(func);
result.AddRange(points);
return(result);
}
public Term CreateTermForVariable(string name, LinguisticVariable variable, IFuzzyFunction function)
{
Term term = new Term(name);
term.Variable = variable;
term.SetFunction(function);
variable.Terms.Add(term);
return(term);
}
public void SetFunction(IFuzzyFunction fuzzyFunction)
{
if (Variable == null)
{
throw new LinguisticVariableIsNotSpecifiedException("Linguistic variable was not specified for term");
}
fuzzyFunction.MaxInputValue = Variable.MaxValue;
fuzzyFunction.MinInputValue = Variable.MinValue;
this.FuzzyFunction = fuzzyFunction;
}
private static ObservablePoint[] GetValues(IFuzzyFunction function, int numberOfPoints)
{
List <ObservablePoint> points = new List <ObservablePoint>();
double step = (function.MaxInputValue - function.MinInputValue) / (double)numberOfPoints;
for (double x = function.MinInputValue; x <= function.MaxInputValue; x += step)
{
points.Add(new ObservablePoint(x, function.GetValue(x)));
}
return(points.ToArray());
}
public static ChartValues <ObservablePoint> GetValues(IFuzzyFunction function)
{
var chartValues = new ChartValues <ObservablePoint>();
ObservablePoint[] points;
if (function.Type == FuzzyFunctionType.Smoothness)
{
points = GetSmoothnessFunctionValues(function);
}
else if (function.Type == FuzzyFunctionType.PiecewiseLinear)
{
points = GetPiecewiseLinearFunctionValues(function);
}
else
{
points = GetHybridFunctionValues(function);
}
chartValues.AddRange(points);
return(chartValues);
}
public void FillLevels(IFuzzyFunction f, int levelsCount)
{
if (levelsCount <= 0)
levelsCount = StandardAlphaLevelsCount;
double d = 1.0/(levelsCount - 1);
for (int i = 0; i < levelsCount - 1; i++)
{
_alphaLevels.Add(d*i, f.GetAlphaLevel(d*i));
}
_alphaLevels.Add(1.0, f.GetAlphaLevel(1.0));
}
public DiscreteFuzzyNumber(IFuzzyFunction f, int levelsCount)
: this(new Dictionary<double, IntervalD>())
{
FillLevels(f, levelsCount);
}
public CroppedFunction(IFuzzyFunction targetFunction, double cropValue)
{
mTargetFunction = targetFunction;
CropLevel = cropValue;
Type = FuzzyFunctionType.PiecewiseLinear | mTargetFunction.Type;
}
private static ObservablePoint[] GetSmoothnessFunctionValues(IFuzzyFunction function)
{
return(GetValues(function, Quality.SmoothnessQuality));
}
private static ObservablePoint[] GetPiecewiseLinearFunctionValues(IFuzzyFunction function)
{
return(OptimazeValues(GetValues(function, Quality.PiecewiseLinearQuality)));
}
private static ObservablePoint[] GetHybridFunctionValues(IFuzzyFunction function)
{
return(GetValues(function, Quality.HybridQuality));
}
