public void PopulateLowerTriangle()
{
if (!IsUpperTrianglePopulated)
{
throw new ArgumentNullException($"Upper triangle of matrix isn't populated");
}
//find lower triangle indexes
for (var i = 1; i < Size; i++)
{
var indexes = Enumerable.Range(0, i)
.Select(generatedNum => new TwoDimensionalArrayIndexes(i, generatedNum));
_lowerTriangleIndexes.AddRange(indexes);
}
//create divided value
var dividedValue = new FuzzyNumber <T>(_defaultValue);
//Set indexes
_lowerTriangleIndexes.ForEach(index =>
{
Matrix[index.Column, index.Row].RevertIfNegative();
Matrix[index.Row, index.Column] = dividedValue / Matrix[index.Column, index.Row];
});
}
private static void InitializeJudgementCombinations()
{
int i = 0, j = JudgementsArray.Length - 1;
while (i != j)
{
JudgmentCombinations[JudgementsArray[i]] = JudgementsArray[j];
JudgmentCombinations[JudgementsArray[j]] = JudgementsArray[i];
// Precise eveluations initialization
PreciseEvaluations[JudgementsArray[i]] = i + 2;
PreciseEvaluations[JudgementsArray[j]] = 1.0 / (i + 2);
// Fuzzy eveluations initialization
FuzzyEvaluations[JudgementsArray[i]] = new FuzzyNumber(i + 1, i + 2, i + 3);
FuzzyEvaluations[JudgementsArray[j]] = new FuzzyNumber(FuzzyEvaluations[JudgementsArray[i]]);
i++;
j--;
}
JudgmentCombinations[JudgementsArray[i]] = JudgementsArray[i];
_defaultJudgement = new VerbalJudgement(JudgementsArray[i]);
PreciseEvaluations[JudgementsArray[i]] = 1;
FuzzyEvaluations[JudgementsArray[i]] = new FuzzyNumber();
}
static FuzzyNumber FuzzyLogic(double x, double y)
{
var argument = domain.Near(y);
var isLeft = domain.NumberFromLambda(z => { if (z > 0)
{
return(0);
}
else
{
return(-z / domain.Max);
} });
var turnLeft = domain.Near(-1);
var result1 = FuzzyNumber.Relation(GoguenImplication(isLeft, turnLeft), argument);
var isRight = domain.NumberFromLambda(z => { if (z < 0)
{
return(0);
}
else
{
return(z / domain.Max);
} });
var turnRight = domain.Near(1);
var result2 = FuzzyNumber.Relation(GoguenImplication(isRight, turnRight), argument);
return(result1 & result2);
}
private AltSolutionModel()
{
Sigmas = new List <int>();
SigmaEquations = new List <string>();
FuzzyCosts = new List <FuzzyNumber>();
FirstFuzzyCost = 0;
}
private double getRuleValue(Rule rule)
{
List <double> ruleValues = new List <double>();
List <RuleItem> ins = rule.InputRules;
for (int i = 0; i < ins.Count; i++)
{
FuzzySet set = searchByLingVariable(ins[i].Variable);
if (set != null)
{
FuzzyNumber num = set.searchByMemShipValue(ins[i].MemberShipValue);
if (num != null)
{
ruleValues.Add(num.FuzzyValue);
}
else
{
return(0);
}
}
else
{
return(0);
}
}
return(Logic(ruleValues));
}
private void PopulateDiagonal()
{
for (var i = 0; i < Size; i++)
{
Matrix[i, i] = new FuzzyNumber <T>(_defaultValue);
}
}
public void SetFirstUnpopulatedElementInUpperTriangle(FuzzyNumber <T> value)
{
var index = _upperTriangleIndexes.FirstOrDefault();
Matrix[index.Row, index.Column] = value;
_upperTriangleIndexes.Remove(index);
}
public void MapBinary()
{
var fn = new FuzzyNumberFactory();
Assert.AreEqual(
fn.CreateTriangular(1, 3, 5).ToString(),
FuzzyNumber.Map(fn.CreateTriangular(0, 1, 2), fn.CreateTriangular(1, 2, 3), (x, y) => x + y).ToString()
);
}
public void MapUnary()
{
var fn = new FuzzyNumberFactory();
Assert.AreEqual(
fn.CreateTriangular(-3, -2, -1).ToString(),
FuzzyNumber.Map(fn.CreateTriangular(.1, .2, .3), x => x * -10).ToString()
);
}
public PairMatrix(int size, T defaultValue)
{
Size = size;
_defaultValue = defaultValue;
_lowerTriangleIndexes = new List <TwoDimensionalArrayIndexes>();
_upperTriangleIndexes = new List <TwoDimensionalArrayIndexes>();
Matrix = new FuzzyNumber <T> [Size, Size];
PopulateDiagonal();
SetUpperTriangleIndexes();
}
public void SetFeatureFuzzyNumber(Feature feature, FuzzyNumber fuzzy_number)
{
if (features_fuzzy_numbers.ContainsKey(feature))
{
features_fuzzy_numbers [feature] = fuzzy_number;
}
else
{
features_fuzzy_numbers.Add(feature, fuzzy_number);
}
}
static Func <double, double, double> GoguenImplication(FuzzyNumber from, FuzzyNumber to)
{
return((x, y) => { if (from[x] == 0)
{
return 1;
}
else
{
return Math.Min(1, to[y] / from[x]);
} });
}
// Update is called once per frame
void FixedUpdate()
{
var triTest = FuzzyNumber.Triangular(0, 10, 20);
var trapTest = FuzzyNumber.Trapezoidal(-20, -10, 0, 10);
if (Input.GetKeyDown(KeyCode.Space))
{
DrawFuzzyNumber(trapTest, -20, 10, new Color(0, 1, 0));
}
//DrawFuzzyNumber(triTest, 0, 20, new Color(1, 0, 0));
}
public void SetFirstUnpopulatedIndex()
{
//GIVEN
var fuzzyNumber = new FuzzyNumber <double>(new double[] { 1, 2, 3 });
var indexPrev = unit.GetUnpopulatedIndex;
//WHEN
unit.SetFirstUnpopulatedElementInUpperTriangle(fuzzyNumber);
var indexNext = unit.GetUnpopulatedIndex;
//THEN
Assert.AreNotEqual(indexPrev, indexNext);
Assert.AreEqual(unit.Matrix[indexPrev.Row, indexPrev.Column], fuzzyNumber);
Assert.AreEqual(indexNext.Row, 0);
Assert.AreEqual(indexNext.Column, 2);
}
static public bool create_FuzzyScale(double a)
{
if (a >= 0.25 && a <= 2)
{
if (FuzzyNumber.Count == 0)
{
FuzzyNumber f = new FuzzyNumber(1, 1, 1 + a);
FuzzyNumber.Add(1, f);
f = new FuzzyNumber(9 - a, 9, 9);
FuzzyNumber.Add(9, f);
for (int i = 3; i <= 7; i = i + 2)
{
f = new FuzzyNumber(i - a, i, i + a);
FuzzyNumber.Add(i, f);
}
for (int i = 2; i <= 8; i = i + 2)
{
f = new FuzzyNumber(i - 1, i, i + 1);
FuzzyNumber.Add(i, f);
}
//RFuzzyNumber
/*f = new FuzzyNumber(1, 1, 1/(1 + a));
* ReversedFuzzyNumber.Add(1, f);
* f = new FuzzyNumber(1/(9 - a), 1/9, 1/9);
* ReversedFuzzyNumber.Add(1/9, f);
* for (int i = 3; i <= 7; i = i + 2)
* {
* f = new FuzzyNumber(1/(i - a),1/ i, 1/(i + a));
* ReversedFuzzyNumber.Add(1/i, f);
* }
*
*
* for (int i = 2; i <= 8; i = i + 2)
* {
* f = new FuzzyNumber(1/(i - 1), 1/i, 1/(i + 1));
* ReversedFuzzyNumber.Add(1/i, f);
* }*/
return(true);
}
}
return(false);
}
public void PopulateLowerTriangle()
{
//GIVEN
var fuzzyNumber = new FuzzyNumber <double>(new double[] { 1, 2, 3 });
var fuzzyNumber2 = new FuzzyNumber <double>(new double[] { -3, -2, -1 });
var fuzzyNumber3 = new FuzzyNumber <double>(new double[] { 2, 3, 4 });
//WHEN
unit.SetFirstUnpopulatedElementInUpperTriangle(fuzzyNumber);
unit.SetFirstUnpopulatedElementInUpperTriangle(fuzzyNumber2);
unit.SetFirstUnpopulatedElementInUpperTriangle(fuzzyNumber3);
unit.PopulateLowerTriangle();
//THEN
//1 0, 2 0, 2 1
Assert.That(unit.Matrix[1, 0].Numbers != null);
Assert.That(unit.Matrix[2, 0].Numbers != null);
Assert.That(unit.Matrix[2, 1].Numbers != null);
}
static void SavePlot(string Name, FuzzyNumber num)
{
using (var file = new StreamWriter(@"..\..\..\..\LaTeX\Plots\" + Name + ".txt"))
{
file.WriteLine("# N mu");
foreach (var e in num.Domain.Arguments)
{
if (Math.Abs(num[e]) > 0.01)
{
file.WriteLine("{0}\t{1}", DTS(e), DTS(num[e]));
}
}
}
using (var file = new StreamWriter(@"..\..\..\..\LaTeX\Plots\" + Name + ".value.txt"))
{
var sum = num.Domain.Arguments.Select(z => z * num[z]).Sum();
var wei = num.Domain.Arguments.Select(z => num[z]).Sum();
file.WriteLine("{0:0.000}", Math.Round(sum / wei, 3));
}
}
public List <FuzzySet> evaluateRules()
{
List <FuzzySet> OutSets = new List <FuzzySet>();
for (int i = 0; i < _rules.Count; i++)
{
List <RuleItem> outrules = _rules[i].OutputRules;
double firingStrength = getRuleValue(_rules[i]);
if (firingStrength > 0)
{
firedRules.Add(i + 1);
for (int j = 0; j < outrules.Count; j++)
{
String Var = outrules[j].Variable;
if (OutSets.Exists(delegate(FuzzySet f) { return(f.Variable == Var); }))
{
int index = OutSets.FindIndex(delegate(FuzzySet f) { return(f.Variable == Var); });
String Mem = outrules[j].MemberShipValue;
if (OutSets[index].Set.Exists(delegate(FuzzyNumber n) { return(n.MemberShipName == Mem); }))
{
int index2 = OutSets[index].Set.FindIndex(delegate(FuzzyNumber n) { return(n.MemberShipName == Mem); });
OutSets[index].Set[index2].FuzzyValue = Implication(OutSets[index].Set[index2].FuzzyValue, firingStrength);
}
else
{
FuzzyNumber num = new FuzzyNumber(Mem, firingStrength);
OutSets[index].Set.Add(num);
}
}
else
{
FuzzySet newset = new FuzzySet(Var);
newset.Set.Add(new FuzzyNumber(outrules[j].MemberShipValue, firingStrength));
OutSets.Add(newset);
}
}
}
}
return(OutSets);
}
public List<FuzzySet> evaluateRules()
{
List<FuzzySet> OutSets = new List<FuzzySet>();
for (int i = 0; i < rules.Count; i++)
{
List<RuleItem> outrules = rules[i].OutputRules;
double firingStrength = getRuleValue(rules[i]);
if (firingStrength > 0)
{
firedRules.Add(i + 1);
for (int j = 0; j < outrules.Count; j++)
{
String Var = outrules[j].Variable;
if (OutSets.Exists(delegate(FuzzySet f) { return f.Variable == Var; }))
{
int index = OutSets.FindIndex(delegate(FuzzySet f) { return f.Variable == Var; });
String Mem = outrules[j].MembershipValue;
if (OutSets[index].Set.Exists(delegate(FuzzyNumber n) { return n.MembershipName == Mem; }))
{
int index2 = OutSets[index].Set.FindIndex(delegate(FuzzyNumber n) { return n.MembershipName == Mem; });
OutSets[index].Set[index2].FuzzyValue = Implication(OutSets[index].Set[index2].FuzzyValue, firingStrength);
}
else
{
FuzzyNumber num = new FuzzyNumber(Mem, firingStrength);
OutSets[index].Set.Add(num);
}
}
else
{
FuzzySet newset = new FuzzySet(Var);
newset.Set.Add(new FuzzyNumber(outrules[j].MembershipValue, firingStrength));
OutSets.Add(newset);
}
}
}
}
return OutSets;
}
static void Main()
{
var domain = new Domain(0, 20);
domain.NearFunction = Domain.NearQuadratic(2);
var chart = new Chart()
{
Dock = DockStyle.Fill,
ChartAreas = { new ChartArea() },
Series =
{
((domain.Near(2) + domain.Near(3)) / domain.Near(2)).ToPlot(Color.Red),
FuzzyNumber.BinaryOperation(domain.Near(2), domain.Near(3),(a, b) => (a + b) / b).ToPlot(Color.Green)
}
};
var form = new Form();
form.Controls.Add(chart);
Application.Run(form);
}
public DataModel()
{
Supply = new int[] { 850, 800, 950 };
Demand = new int[] { 550, 500, 550, 650, 350 };
RealSourceCostMatrix = new Number[3, 5]
{
{ 4, 1, 2, 7, 8 },
{ 7, 5, 3, 4, 6 },
{ 8, 4, 6, 2, 5 },
};
ProbabilityDistribution = new double[3] {
0.15, 0.8, 0.5
};
FuzzySourceCostMatrix = new FuzzyNumber[3, 5]
{
{ new FuzzyNumber(3, 4, 6), new FuzzyNumber(1, 1, 3), new FuzzyNumber(1, 2, 4), new FuzzyNumber(4, 7, 10), new FuzzyNumber(7, 8, 10), },
{ new FuzzyNumber(4, 7, 8), new FuzzyNumber(2, 5, 7), new FuzzyNumber(2, 3, 6), new FuzzyNumber(3, 4, 5), new FuzzyNumber(3, 6, 8), },
{ new FuzzyNumber(5, 8, 12), new FuzzyNumber(2, 4, 5), new FuzzyNumber(4, 6, 9), new FuzzyNumber(1, 2, 4), new FuzzyNumber(4, 5, 7), },
};
//Костины данные
//Supply = new int[] { 900, 800, 580, 620 };
//Demand = new int[] { 550, 500, 550, 650, 350 };
//Катины данные
//Supply = new int[] { 120, 140, 115, 105 };
//Demand = new int[] { 75, 65, 90, 95, 100, 55 };
//SourceCostMatrix = new Number[4, 6]
//{
// {4,1,2,7,8,5},
// {7,5,3,4,6,8},
// {9,8,5,6,11,12},
// {8,4,6,2,5,10},
//};
}
public FuzzySolutionTabVM(AltSolutionModel altSolutionModel, int stepCount, int solutionCount, List <OptimizationPoint> currentPath) : base(altSolutionModel, $"E_{stepCount}_{solutionCount}")
{
CurrentPath = currentPath;
ApplySteppingStoneChange(1);
ActualSolutionMatrix = MathOperations.NewSolution(altSolutionModel.FirstSolution, CurrentPath);
_firstCost = altSolutionModel.FirstFuzzyCost;
CurrentCost = MathOperations.CalculateCost(ActualSolutionMatrix, altSolutionModel.Source.FuzzySourceCostMatrix, out string equation);
CurrentCostEquation = equation;
FirstCostTitle = $"Z_{stepCount}_1";
CurrentCostTitle = $"Z_{stepCount}_{solutionCount}";
FuzzyMeasurements = new Collection <FuzzyMeasurement>
{
new FuzzyMeasurement
{
FirstX = _firstCost.Left,
SecondX = CurrentCost.Left,
ProbabilityY = 0
},
new FuzzyMeasurement
{
FirstX = _firstCost.Middle,
SecondX = CurrentCost.Middle,
ProbabilityY = 1
},
new FuzzyMeasurement
{
FirstX = _firstCost.Right,
SecondX = CurrentCost.Right,
ProbabilityY = 0
},
};
}
double [] CalculateWeights(double[,] pairwise_comparison_arr)
{
int compared_count = pairwise_comparison_arr.GetLength(0);
double[] final_weights = new double[compared_count];
FuzzyNumber[,] fuzzy_arr = new FuzzyNumber[compared_count, compared_count];
FuzzyNumber[] fuzzytemp = new FuzzyNumber[compared_count];
fuzzy_synthetic_extent = new FuzzyNumber[compared_count];
FuzzyNumber temp = new FuzzyNumber();
TriangleFuzzyScale.create_FuzzyScale(0.75);
#region create fuzzy numbers matrix depending on Saati scale
for (int i = 0; i < compared_count; i++)
{
fuzzy_arr[i, i] = new FuzzyNumber(TriangleFuzzyScale.FuzzyNumber[1].l, TriangleFuzzyScale.FuzzyNumber[1].m, TriangleFuzzyScale.FuzzyNumber[1].u);
}
for (int i = 0; i < compared_count - 1; i++)
{
for (int j = i + 1; j < compared_count; j++)
{
double weight = pairwise_comparison_arr[i, j];
fuzzy_arr[j, i] = new FuzzyNumber();
fuzzy_arr[i, j] = new FuzzyNumber();
if (weight > 1)
{
fuzzy_arr[i, j].l = TriangleFuzzyScale.FuzzyNumber[Convert.ToInt32(weight)].l;
fuzzy_arr[i, j].m = TriangleFuzzyScale.FuzzyNumber[Convert.ToInt32(weight)].m;
fuzzy_arr[i, j].u = TriangleFuzzyScale.FuzzyNumber[Convert.ToInt32(weight)].u;
fuzzy_arr[j, i].l = TriangleFuzzyScale.FuzzyNumber[Convert.ToInt32(weight)].Reversed().l;
fuzzy_arr[j, i].m = TriangleFuzzyScale.FuzzyNumber[Convert.ToInt32(weight)].Reversed().m;
fuzzy_arr[j, i].u = TriangleFuzzyScale.FuzzyNumber[Convert.ToInt32(weight)].Reversed().u;
}
else
{
weight = Math.Round((1 / weight), 0);
fuzzy_arr[j, i].l = TriangleFuzzyScale.FuzzyNumber[Convert.ToInt32(weight)].l;
fuzzy_arr[j, i].m = TriangleFuzzyScale.FuzzyNumber[Convert.ToInt32(weight)].m;
fuzzy_arr[j, i].u = TriangleFuzzyScale.FuzzyNumber[Convert.ToInt32(weight)].u;
fuzzy_arr[i, j].l = TriangleFuzzyScale.FuzzyNumber[Convert.ToInt32(weight)].Reversed().l;
fuzzy_arr[i, j].m = TriangleFuzzyScale.FuzzyNumber[Convert.ToInt32(weight)].Reversed().m;
fuzzy_arr[i, j].u = TriangleFuzzyScale.FuzzyNumber[Convert.ToInt32(weight)].Reversed().u;
}
}
}
#endregion
#region // calculate fuzzy_synthetic_extent Si
for (int i = 0; i < compared_count; i++)
{
fuzzytemp[i] = new FuzzyNumber();
for (int j = 0; j < compared_count; j++)
{
fuzzytemp[i].l += fuzzy_arr[i, j].l;
fuzzytemp[i].m += fuzzy_arr[i, j].m;
fuzzytemp[i].u += fuzzy_arr[i, j].u;
}
}
temp = new FuzzyNumber();
for (int j = 0; j < compared_count; j++)
{
temp.l += fuzzytemp[j].l;
temp.m += fuzzytemp[j].m;
temp.u += fuzzytemp[j].u;
}
temp.l = 1 / temp.l;
temp.m = 1 / temp.m;
temp.u = 1 / temp.u;
for (int i = 0; i < compared_count; i++)
{
fuzzy_synthetic_extent[i] = new FuzzyNumber();
fuzzy_synthetic_extent[i].l = fuzzytemp[i].l * temp.u;
fuzzy_synthetic_extent[i].m = fuzzytemp[i].l * temp.m;
fuzzy_synthetic_extent[i].u = fuzzytemp[i].l * temp.l;
}
#endregion
#region // calculate Si>=Sk
double total_fuzzy_weights = 0;
for (int first_number = 0; first_number < compared_count; first_number++)
{
fuzzy_Si = new List <double>();
for (int second_number = 0; second_number < compared_count; second_number++)
{
if (first_number != second_number)
{
if (fuzzy_synthetic_extent[first_number].m >= fuzzy_synthetic_extent[second_number].m)
{
fuzzy_Si.Add(1);
}
else
if (fuzzy_synthetic_extent[second_number].l >= fuzzy_synthetic_extent[first_number].u)
{
fuzzy_Si.Add(0);
}
else
{
fuzzy_Si.Add((fuzzy_synthetic_extent[second_number].l - fuzzy_synthetic_extent[first_number].u) / ((fuzzy_synthetic_extent[first_number].m - fuzzy_synthetic_extent[first_number].u) - (fuzzy_synthetic_extent[second_number].m - fuzzy_synthetic_extent[second_number].l)));
}
}
} // end second for
final_weights[first_number] = fuzzy_Si.Min();
total_fuzzy_weights += final_weights[first_number];
}
#endregion
#region Normalize Fuzzy weights
for (int i = 0; i < compared_count; i++)
{
final_weights[i] = Math.Round((final_weights[i] / total_fuzzy_weights), 2);
}
#endregion
return(final_weights);
}
public FuzzyNumber Reversed()
{
FuzzyNumber f = new FuzzyNumber(1 / this.u, 1 / this.m, 1 / this.l);
return(f);
}
static void Compare(double x, double y)
{
var args = algorithms.Where(z => z.AlgorithmToFuzzy != null).Select(z => z.AlgorithmToFuzzy(x, y).ToPlot(z.Color)).ToArray();
FuzzyNumber.ShowChart(args);
}
static FuzzyNumber FuzzyAlgorithm(double x, double y)
{
return(FuzzyNumber.BinaryOperation(domain.Near(x), domain.Near(y), ExactAlgorithm));
}
static void Main()
{
domain = new Domain(0, 10);
domain.T = Domain.TMin;
domain.S = Domain.SMax;
var A2 = domain.Near(2);
var A3 = domain.Near(3);
SavePlot("2", A2);
SavePlot("3", A3);
SavePlot("2_cup1_3", A2 | A3);
SavePlot("2_cap1_3", A2 & A3);
domain.T = Domain.TMul;
domain.S = Domain.SSum;
SavePlot("2_cap2_3", A2 & A3);
SavePlot("2_cup2_3", A2 | A3);
domain.T = Domain.TMul;
domain.S = Domain.SMax;
SavePlot("2_plus_2", A2 + A2);
SavePlot("2_mult_2", A2 * A2);
SavePlot("8_div_2", domain.Near(8) / A2);
SavePlot("4", domain.Near(4));
domain.NearFunction = Domain.NearGauss(0.3);
MakePlots("K03");
domain.NearFunction = Domain.NearGauss(3);
MakePlots("K3");
domain.NearFunction = Domain.NearQuadratic(1);
MakePlots("Q");
domain.NearFunction = Domain.NearGauss(1);
domain.T = Domain.TMin;
MakePlots("min");
domain.T = Domain.TMul;
domain.S = Domain.SSum;
MakePlots("nomax");
domain.T = Domain.TMul;
domain.S = Domain.SMax;
SavePlot("3_times_2", SumTest(3, 2));
SavePlot("2_times_3", SumTest(2, 3));
SavePlot("1_times_6", SumTest(1, 6));
SavePlot("6_mult_1", domain.Near(6) * domain.Near(1));
SavePlot("3_mult_2", domain.Near(3) * domain.Near(2));
SavePlot("F_direct", ((domain.Near(2) + domain.Near(3)) / domain.Near(3)));
SavePlot("F_ext", FuzzyNumber.BinaryOperation(domain.Near(2), domain.Near(3), (a, b) => (a + b) / b));
domain = new Domain(-5, 5);
var tanh = domain.CreateEmpty();
foreach (var e in domain.Arguments)
{
tanh[e] = Math.Tanh(e);
}
SavePlot("Tanh", tanh);
}
