public static IFuzzySet CompositionOfBinaryRelations(IFuzzySet r1, IFuzzySet r2)
{
IDomain xDomain = r1.GetDomain()[0];
IDomain yDomain = r1.GetDomain()[1];
IDomain zDomain = r2.GetDomain()[1];
var result = new MutableFuzzySet(Domain.Combine(xDomain, zDomain));
var or = Operations.ZadehOr();
var and = Operations.ZadehAnd();
foreach (var x in xDomain)
{
foreach (var z in zDomain)
{
var value = 0.0;
foreach (var y in yDomain)
{
var value1 = r1.GetValueAt(DomainElement.Of(x[0], y[0]));
var value2 = r2.GetValueAt(DomainElement.Of(y[0], z[0]));
value = or(value, and(value1, value2));
}
result.Set(DomainElement.Of(x[0], z[0]), value);
}
}
return(result);
}
public static IFuzzySet CompositionOfBinaryRelations(IFuzzySet relation1, IFuzzySet relation2, IBinaryFunction tNorm, IBinaryFunction sNorm) //zadatak ne specificira koristi li se max-min kompozicija
{ //stoga je konfigurabilno
MutableFuzzySet compositeRelation = new MutableFuzzySet(Domain.Combine(relation1.GetDomain().GetComponent(0), relation2.GetDomain().GetComponent(1)));
if (relation1 == relation2) //jer ugnjezdjeni foreach nad istom 'relation' instancom stvara probleme
{
relation2 = DeepCopy(relation1);
}
foreach (DomainElement element1 in compositeRelation.GetDomain())
{
int x = element1.GetComponentValue(0);
int z = element1.GetComponentValue(1);
double funccomp = compositeRelation.GetValueAt(DomainElement.Of(x, z));
double Max = 0;
foreach (DomainElement element_a in relation1.GetDomain()) //funca
{
foreach (DomainElement element_b in relation2.GetDomain()) //funcb
{
if (element_a.GetComponentValue(1) == element_b.GetComponentValue(0))
{
int y = element_a.GetComponentValue(1); //y
Max = sNorm.ValueAt(tNorm.ValueAt(relation1.GetValueAt(DomainElement.Of(x, y)), relation2.GetValueAt(DomainElement.Of(y, z))), Max);
}
}
}
compositeRelation.Set(DomainElement.Of(x, z), Max);
}
return(compositeRelation);
}
public static IFuzzySet?CompositionOfBinaryRelations(IFuzzySet A, IFuzzySet B)
{
if (!AreRelationsMultiplicative(A, B))
{
return(null);
}
var rowAComponent = A.GetDomain().GetComponent(0);
var columnAComponent = A.GetDomain().GetComponent(1);
var rowBComponent = B.GetDomain().GetComponent(0);
var columnBComponent = B.GetDomain().GetComponent(1);
var rowsA = rowAComponent.GetCardinality();
var colsA = columnAComponent.GetCardinality();
var colsB = columnBComponent.GetCardinality();
var fuzzySet = new MutableFuzzySet(new CompositeDomain(new SimpleDomain[]
{
(SimpleDomain)rowAComponent,
(SimpleDomain)columnBComponent
}));
for (var i = 0; i < rowsA; i++)
{
for (var j = 0; j < colsB; j++)
{
var maxValue = 0.0;
for (var k = 0; k < colsA; k++)
{
var iElement = rowAComponent.ElementForIndex(i).GetComponentValue(0);
var jElement = columnBComponent.ElementForIndex(j).GetComponentValue(0);
var kElement = rowAComponent.ElementForIndex(k).GetComponentValue(0);
var ikElement = new DomainElement(iElement, kElement);
var kjElement = new DomainElement(kElement, jElement);
var ikElementValue = A.GetValueAt(ikElement);
var kjElementValue = B.GetValueAt(kjElement);
var newElementValue = Math.Min(ikElementValue, kjElementValue);
if (maxValue < newElementValue)
{
maxValue = newElementValue;
}
}
var iiElement = rowAComponent.ElementForIndex(i).GetComponentValue(0);
var jjElement = columnBComponent.ElementForIndex(j).GetComponentValue(0);
var ijElement = new DomainElement(iiElement, jjElement);
fuzzySet.Set(ijElement, maxValue);
}
}
return(fuzzySet);
}
public static IFuzzySet UnaryOperation(IFuzzySet fuzzySet, IUnaryFunction unary)
{
MutableFuzzySet A = new MutableFuzzySet(fuzzySet.GetDomain());
foreach (DomainElement e in fuzzySet.GetDomain())
{
A.Set(e, unary.ValueAt(fuzzySet.GetValueAt(e)));
}
return(A);
}
public IFuzzySet Calculate(IFuzzySet set)
{
IList<double> memberships = new List<double>();
for (int i = 0; i < set.GetDomain().GetCardinality(); i++)
{
double value = set.GetMembershipFor(set.GetDomain().ElementAt(i));
memberships.Add(1 - value);
}
return FuzzySetFactory.CreateFuzzySet(set.GetDomain(), memberships);
}
public string Defuzzyfie(IFuzzySet set)
{
double sumNumerator = 0.0;
double sumDenominator = 0.0;
for (int i = 0; i < set.GetDomain().GetCardinality(); i++)
{
sumNumerator += (set.GetMembershipFor(set.GetDomain().ElementAt(i)) * (int)set.GetDomain().ElementAt(i)[0]);
sumDenominator += set.GetMembershipFor(set.GetDomain().ElementAt(i));
}
return Convert.ToInt32(sumNumerator / sumDenominator).ToString();
}
public static IFuzzySet BinaryOperation(IFuzzySet set1, IFuzzySet set2, IBinaryFunction function)
{
var newSet = new MutableFuzzySet(set1.GetDomain());
foreach (var element in set1.GetDomain())
{
newSet.Set(element, function.ValueAt(set1.GetValueAt(element), set2.GetValueAt(element)));
}
return(newSet);
}
public IFuzzySet Calculate(IFuzzySet set)
{
IList <double> memberships = new List <double>();
for (int i = 0; i < set.GetDomain().GetCardinality(); i++)
{
double value = set.GetMembershipFor(set.GetDomain().ElementAt(i));
memberships.Add(1 - value);
}
return(FuzzySetFactory.CreateFuzzySet(set.GetDomain(), memberships));
}
public static IFuzzySet UnaryOperation(IFuzzySet set, UnaryFunction function)
{
var result = new MutableFuzzySet(set.GetDomain());
foreach (var element in set.GetDomain())
{
result.Set(element, function(set.GetValueAt(element)));
}
return(result);
}
public static bool IsUtimesURelation(IFuzzySet relation)
{
if (relation.GetDomain().GetNumberOfComponents() == 2)
{
if (relation.GetDomain().GetComponent(0) == relation.GetDomain().GetComponent(1))
{
return(true);
}
}
return(false);
}
public string Defuzzyfie(IFuzzySet set)
{
double sumNumerator = 0.0;
double sumDenominator = 0.0;
for (int i = 0; i < set.GetDomain().GetCardinality(); i++)
{
sumNumerator += (set.GetMembershipFor(set.GetDomain().ElementAt(i)) * (int)set.GetDomain().ElementAt(i)[0]);
sumDenominator += set.GetMembershipFor(set.GetDomain().ElementAt(i));
}
return(Convert.ToInt32(sumNumerator / sumDenominator).ToString());
}
public static IFuzzySet BinaryOperation(IFuzzySet set1, IFuzzySet set2, BinaryFunction function)
{
var result = new MutableFuzzySet(set1.GetDomain());
foreach (var element in set1.GetDomain())
{
var x = set1.GetValueAt(element);
var y = set2.GetValueAt(element);
result.Set(element, function(x, y));
}
return(result);
}
public static bool IsMaxMinTransitive(IFuzzySet relation)
{
if (!IsUTimesURelation(relation))
{
return(false);
}
IDomain domain = relation.GetDomain()[0];
foreach (var x in domain)
{
foreach (var z in domain)
{
var value = 0.0;
foreach (var y in domain)
{
var xy = relation.GetValueAt(DomainElement.Of(x[0], y[0]));
var yz = relation.GetValueAt(DomainElement.Of(y[0], z[0]));
value = Math.Max(value, Math.Min(xy, yz));
}
if (value > relation.GetValueAt(DomainElement.Of(x[0], z[0])))
{
return(false);
}
}
}
return(true);
}
public static void Primjer23()
{
IDomain u = Domain.IntRange(1, 5); // {1,2,3,4}
IFuzzySet r = new MutableFuzzySet(Domain.Combine(u, u))
.Set(DomainElement.Of(1, 1), 1)
.Set(DomainElement.Of(2, 2), 1)
.Set(DomainElement.Of(3, 3), 1)
.Set(DomainElement.Of(4, 4), 1)
.Set(DomainElement.Of(1, 2), 0.3)
.Set(DomainElement.Of(2, 1), 0.3)
.Set(DomainElement.Of(2, 3), 0.5)
.Set(DomainElement.Of(3, 2), 0.5)
.Set(DomainElement.Of(3, 4), 0.2)
.Set(DomainElement.Of(4, 3), 0.2);
IFuzzySet r2 = r;
Console.WriteLine("Početna relacija je neizrazita relacija ekvivalencije? " + Relations.Relations.IsFuzzyEquivalence(r2));
Console.WriteLine();
for (int i = 1; i <= 3; i++)
{
r2 = Relations.Relations.CompositionOfBinaryRelations(r2, r, Operations.Operations.ZadehAnd(), Operations.Operations.ZadehOr());
Console.WriteLine("Broj odrađenih kompozicija: " + i + ". Relacija je:");
foreach (DomainElement e in r2.GetDomain())
{
Console.WriteLine("mu(" + e + ")=" + r2.GetValueAt(e));
}
Console.WriteLine("Ova relacija je neizrazita relacija ekvivalencije? " + Relations.Relations.IsFuzzyEquivalence(r2));
Console.WriteLine();
}
}
private static void PrintExample5()
{
Console.WriteLine("EXAMPLE 5");
IDomain u1 = IDomain.IntRange(1, 5); // {1,2,3,4}
IDomain u2 = IDomain.IntRange(1, 4); // {1,2,3}
IDomain u3 = IDomain.IntRange(1, 5); // {1,2,3,4}
IFuzzySet r1 = new MutableFuzzySet(IDomain.Combine(u1, u2))
.Set(DomainElement.Of(1, 1), 0.3)
.Set(DomainElement.Of(1, 2), 1)
.Set(DomainElement.Of(3, 3), 0.5)
.Set(DomainElement.Of(4, 3), 0.5);
IFuzzySet r2 = new MutableFuzzySet(IDomain.Combine(u2, u3))
.Set(DomainElement.Of(1, 1), 1)
.Set(DomainElement.Of(2, 1), 0.5)
.Set(DomainElement.Of(2, 2), 0.7)
.Set(DomainElement.Of(3, 3), 1)
.Set(DomainElement.Of(3, 4), 0.4);
IFuzzySet r1r2 = Relations.CompositionOfBinaryRelations(r1, r2) !;
foreach (var element in r1r2.GetDomain())
{
Console.WriteLine($"mu({element}) = {r1r2.GetValueAt(element)}");
}
Console.WriteLine("---------------------------------------");
Console.WriteLine();
}
public static bool IsMaxMinTransitive(IFuzzySet relation)
{
IFuzzySet copiedRelation = DeepCopy(relation); //jer ugnjezdjeni foreach nad istom 'relation' instancom stvara probleme
foreach (DomainElement element1 in relation.GetDomain())
{
int x = element1.GetComponentValue(0);
int z = element1.GetComponentValue(1);
double funcxz = relation.GetValueAt(DomainElement.Of(x, z));
double Max = 0;
foreach (DomainElement element2 in copiedRelation.GetDomain())
{
if (element2.GetComponentValue(0) == element2.GetComponentValue(1))
{
int y = element2.GetComponentValue(0);
if (Math.Min(copiedRelation.GetValueAt(DomainElement.Of(x, y)), copiedRelation.GetValueAt(DomainElement.Of(y, z))) > Max)
{
Max = Math.Min(copiedRelation.GetValueAt(DomainElement.Of(x, y)), copiedRelation.GetValueAt(DomainElement.Of(y, z)));
}
}
}
if (funcxz < Max)
{
return(false);
}
}
return(true);
}
public IFuzzySet Calculate(IFuzzySet first, IFuzzySet second)
{
if (!first.GetDomain().Equals(second.GetDomain()))
{
throw new ApplicationException("Domains are not the same.");
}
IList<double> memberships = new List<double>();
IDomain domain = first.GetDomain();
for (int i = 0; i < first.GetDomain().GetCardinality(); i++)
{
double value1 = first.GetMembershipFor(domain.ElementAt(i));
double value2 = second.GetMembershipFor(domain.ElementAt(i));
memberships.Add(Math.Min(value1, value2));
}
return FuzzySetFactory.CreateFuzzySet(domain, memberships);
}
public static bool IsSymmetric(IFuzzySet relation)
{
if (!IsUTimesURelation(relation))
{
return(false);
}
var domain = relation.GetDomain();
var firstComponent = domain.GetComponent(0);
var secondComponent = domain.GetComponent(1);
for (var i = 0; i < firstComponent.GetCardinality(); i++)
{
for (var j = i + 1; j < secondComponent.GetCardinality(); j++)
{
var iElementIndex = firstComponent.ElementForIndex(i).GetComponentValue(0);
var jElementIndex = secondComponent.ElementForIndex(j).GetComponentValue(0);
var ijValue = relation.GetValueAt(new DomainElement(iElementIndex, jElementIndex));
var jiValue = relation.GetValueAt(new DomainElement(jElementIndex, iElementIndex));
if (ijValue != jiValue)
{
return(false);
}
}
}
return(true);
}
public IFuzzySet Calculate(IFuzzySet first, IFuzzySet second)
{
if (!first.GetDomain().Equals(second.GetDomain()))
{
throw new ApplicationException("Domains are not the same.");
}
IList <double> memberships = new List <double>();
IDomain domain = first.GetDomain();
for (int i = 0; i < domain.GetCardinality(); i++)
{
double value1 = first.GetMembershipFor(domain.ElementAt(i));
double value2 = second.GetMembershipFor(domain.ElementAt(i));
memberships.Add(value1 + value2 - value1 * value2);
}
return(FuzzySetFactory.CreateFuzzySet(domain, memberships));
}
public static IFuzzySet BinaryOperation(IFuzzySet fuzzySetA, IFuzzySet fuzzySetB, IBinaryFunction binary)
{
MutableFuzzySet A = new MutableFuzzySet(fuzzySetA.GetDomain());
//if (fuzzySetA.GetDomain() != fuzzySetB.GetDomain())
//{
// if (fuzzySetA.GetDomain().GetComponent(fuzzySetA.GetDomain().GetNumberOfComponents() - 1) != fuzzySetB.GetDomain().GetComponent(fuzzySetB.GetDomain().GetNumberOfComponents() - 1))
// {
// Console.WriteLine("Can't do binary operation on sets with different domains");
// return A;
// }
//}
foreach (DomainElement e in fuzzySetA.GetDomain())
{
A.Set(e, binary.ValueAt(fuzzySetA.GetValueAt(e), fuzzySetB.GetValueAt(e)));
}
return(A);
}
public static bool IsSymmetric(IFuzzySet relation)
{
foreach (DomainElement element1 in relation.GetDomain())
{
if (relation.GetValueAt(DomainElement.Of(element1.GetComponentValue(0), element1.GetComponentValue(1))) != relation.GetValueAt(DomainElement.Of(element1.GetComponentValue(1), element1.GetComponentValue(0))))
{
return(false);
}
}
return(true);
}
public static void Print(IFuzzySet set, string headingText) //metoda za ispis neizr skupa
{
if (headingText != null)
{
Console.WriteLine(headingText);
}
foreach (DomainElement e in set.GetDomain())
{
Console.WriteLine("D{0} = {1}", e, set.GetValueAt(e));
}
Console.WriteLine();
}
private static void PrintFuzzySet(IFuzzySet set, string headingText = "")
{
if (!string.IsNullOrEmpty(headingText))
{
Console.WriteLine(headingText);
}
foreach (var de in set.GetDomain())
{
Console.WriteLine($"d({de}) = {set.GetValueAt(de):0.000000}");
}
Console.WriteLine();
}
public IFuzzySet Calculate(IFuzzySet first, IFuzzySet second)
{
IList<double> memberships = new List<double>();
IDomain domain = DomainFactory.CreateDomain(new IDomain[] { first.GetDomain(), second.GetDomain() });
IFuzzySet firstCyl = first.CylindricalExtension(domain);
IFuzzySet secondCyl = second.CylindricalExtension(domain);
for (int i = 0; i < domain.GetCardinality(); i++)
{
double value1 = firstCyl.GetMembershipFor(domain.ElementAt(i));
double value2 = secondCyl.GetMembershipFor(domain.ElementAt(i));
memberships.Add(value1 * value2);
}
return FuzzySetFactory.CreateFuzzySet(domain, memberships);
}
public static bool IsUTimesURelation(IFuzzySet relation)
{
IDomain domain = relation.GetDomain();
if (domain.GetNumberOfComponents() != 2)
{
return(false);
}
IDomain a = domain[0];
IDomain b = domain[1];
return(a.All(element => b.HasElement(element)));
}
public IFuzzySet Calculate(IFuzzySet first, IFuzzySet second)
{
IList <double> memberships = new List <double>();
IDomain domain = DomainFactory.CreateDomain(new IDomain[] { first.GetDomain(), second.GetDomain() });
IFuzzySet firstCyl = first.CylindricalExtension(domain);
IFuzzySet secondCyl = second.CylindricalExtension(domain);
for (int i = 0; i < domain.GetCardinality(); i++)
{
double value1 = firstCyl.GetMembershipFor(domain.ElementAt(i));
double value2 = secondCyl.GetMembershipFor(domain.ElementAt(i));
memberships.Add(value1 * value2);
}
return(FuzzySetFactory.CreateFuzzySet(domain, memberships));
}
public int Defuzzify(IFuzzySet set)
{
double numerator = 0;
double denominator = 0;
foreach (var element in set.GetDomain())
{
numerator += element[0] * set.GetValueAt(element);
denominator += set.GetValueAt(element);
}
if (denominator == 0)
{
return(0);
}
return((int)(numerator / denominator));
}
public int Defuzzify(IFuzzySet set)
{
var numerator = 0.0;
var denominator = 0.0;
foreach (var element in set.GetDomain())
{
numerator += set.GetValueAt(element) * element.GetComponentValue(0);
denominator += Math.Round(set.GetValueAt(element));
}
if (denominator == 0.0)
{
return(0);
}
return((int)(numerator / denominator));
}
public static bool IsMaxMinTransitive(IFuzzySet relation)
{
if (!IsUTimesURelation(relation))
{
return(false);
}
var universalComponent = relation.GetDomain().GetComponent(0);
for (var x = 0; x < universalComponent.GetCardinality(); x++)
{
for (var z = 0; z < universalComponent.GetCardinality(); z++)
{
var xValue = universalComponent.ElementForIndex(x).GetComponentValue(0);
var zValue = universalComponent.ElementForIndex(z).GetComponentValue(0);
var xzElementValue = relation.GetValueAt(new DomainElement(xValue, zValue));
var maxYValue = 0.0;
for (var y = 0; y < universalComponent.GetCardinality(); y++)
{
var yValue = universalComponent.ElementForIndex(y).GetComponentValue(0);
var xyElementValue = relation.GetValueAt(new DomainElement(xValue, yValue));
var yzElementValue = relation.GetValueAt(new DomainElement(yValue, zValue));
var tmpMaxYValue = Math.Min(xyElementValue, yzElementValue);
if (tmpMaxYValue > maxYValue)
{
maxYValue = tmpMaxYValue;
}
}
if (!(xzElementValue < maxYValue))
{
continue;
}
return(false);
}
}
return(true);
}
public IFuzzySet Accept(int[] inputs)
{
IDomain domain = consequent.GetDomain();
MutableFuzzySet solution = new MutableFuzzySet(domain);
foreach (var element in domain)
{
//Console.Error.WriteLine(antecedent[1]);
//Console.Error.WriteLine(inputs[0]);
double tmp = antecedent[0].GetValueAt(DomainElement.Of(inputs[0]));
for (int i = 1; i < antecedent.Length; ++i)
{
tmp = tNorm(tmp, antecedent[i].GetValueAt(DomainElement.Of(inputs[i])));
}
solution.Set(element, implication(tmp, consequent.GetValueAt(element)));
}
return(solution);
}
public static bool IsReflexive(IFuzzySet relation)
{
if (!IsUTimesURelation(relation))
{
return(false);
}
IDomain domain = relation.GetDomain()[0];
foreach (var element in domain)
{
int value = element[0];
if (Math.Abs(1 - relation.GetValueAt(DomainElement.Of(value, value))) > TOLERANCE)
{
return(false);
}
}
return(true);
}
public int Defuzzyfy(IFuzzySet union)
{
double sum1 = 0;
double sum2 = 0;
foreach (DomainElement element in union.GetDomain())
{
sum1 += element.GetComponentValue(0) * union.GetValueAt(element);
sum2 += union.GetValueAt(element);
}
double CoA = sum1 / sum2;
if (sum2 < 0.00001)
{
return(0);
}
return((int)CoA);
}
protected override IFuzzySet GetAcceleration(params string[][] variables)
{
IList <IFuzzySet> sets = new List <IFuzzySet>();
IFuzzySet set;
foreach (var rule in accelerationRules)
{
IList <double> values = new List <double>();
for (int i = 0; i < rule.Item1.Count; i++)
{
IFuzzySet variable = rule.Item1[i];
double value = variable.GetMembershipFor(variable.GetDomain().FromStringRepresentation(variables[i]));
values.Add(value);
}
double min = values.Min();
set = FuzzySetFactory.CreateFuzzySet(rule.Item2.GetDomain(), Enumerable.Repeat(min, rule.Item2.GetDomain().GetCardinality()));
sets.Add(set.TNorm(rule.Item2, tNorm));
}
set = FuzzySetFactory.CreateFuzzySet(accelerationRules[0].Item2.GetDomain(), Enumerable.Repeat(0.0, accelerationRules[0].Item2.GetDomain().GetCardinality()));
return(sets.Aggregate((current, next) => current.SNorm(next, sNorm)));
}
public static bool IsReflexive(IFuzzySet relation)
{
if (!IsUTimesURelation(relation))
{
return(false);
}
var domain = relation.GetDomain();
var firstComponent = domain.GetComponent(0);
for (var i = 0; i < firstComponent.GetCardinality(); i++)
{
var diagonalValue = firstComponent.ElementForIndex(i).GetComponentValue(0);
if (relation.GetValueAt(new DomainElement(diagonalValue, diagonalValue)) != 1)
{
return(false);
}
}
return(true);
}
