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 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 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 SingleRuleConclusion(int L, int D, int LK, int DK, int V, int S) //TODO napravi varijantu i za StrojMinimum i za StrojProdukt
{
double[] antecMembershipFunctions = new double[] {
_antec1.GetValueAt(DomainElement.Of(L)),
_antec2.GetValueAt(DomainElement.Of(D)),
_antec3.GetValueAt(DomainElement.Of(LK)),
_antec4.GetValueAt(DomainElement.Of(DK)),
_antec5.GetValueAt(DomainElement.Of(V)),
_antec6.GetValueAt(DomainElement.Of(S))
};
double minMembershipFunc = antecMembershipFunctions.Min();
IFuzzySet antecedents = new CalculatedFuzzySet( //mjere pripadnosti su na minimumu mj.pripadnosti antecedenata
_conseq.GetDomain(),
StandardFuzzySets.UniversalFunction(minMembershipFunc)
);
//KormiloFuzzySystemMin.Print(antecedents, "antecedents:");
//KormiloFuzzySystemMin.Print(_conseq, "_conseq:");
//KormiloFuzzySystemMin.Print(_antec5, "_antec:");
IFuzzySet conclusion = Operations.Operations.BinaryOperation(antecedents, _conseq, Operations.Operations.ZadehAnd());
//KormiloFuzzySystemMin.Print(conclusion, "conclusion:");
return(conclusion);
}
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);
}
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 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();
}
}
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 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 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 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 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 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);
}
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 IFuzzySet UnaryOperation(IFuzzySet set, IUnaryFunction function)
{
var newSet = new MutableFuzzySet(set.GetDomain());
foreach (var element in newSet.GetDomain())
{
newSet.Set(element, function.ValueAt(set.GetValueAt(element)));
}
return(newSet);
}
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();
}
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);
}
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 static bool IsSymmetric(IFuzzySet relation)
{
if (!IsUTimesURelation(relation))
{
return(false);
}
IDomain domain = relation.GetDomain();
foreach (var domainElement in domain)
{
int a = domainElement[0];
int b = domainElement[1];
var value1 = relation.GetValueAt(domainElement);
var value2 = relation.GetValueAt(DomainElement.Of(b, a));
if (Math.Abs(value1 - value2) > TOLERANCE)
{
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 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 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);
}
private static void PrintExample6()
{
Console.WriteLine("EXAMPLE 6");
IDomain uFinal = IDomain.IntRange(1, 5); // {1,2,3,4}
IFuzzySet r = new MutableFuzzySet(IDomain.Combine(uFinal, uFinal))
.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($"Pocetna relacija je neizrazita relacija ekvivalencija? {Relations.IsFuzzyEquivalence(r2)}");
Console.WriteLine();
for (var i = 0; i < 3; i++)
{
r2 = Relations.CompositionOfBinaryRelations(r2, r) !;
Console.WriteLine($"Broj odradenih kompozicija je: {i + 1}. Relacija je: ");
foreach (var element in r2.GetDomain())
{
Console.WriteLine($"mu({element}) = {r2.GetValueAt(element)}");
}
Console.WriteLine($"Ova relacija je neizrazita relacija ekvivalencije? {Relations.IsFuzzyEquivalence(r2)}");
Console.WriteLine();
}
Console.WriteLine("---------------------------------------");
Console.WriteLine();
}
public static void Primjer22()
{
IDomain u1 = Domain.IntRange(1, 5); // {1,2,3,4}
IDomain u2 = Domain.IntRange(1, 4); // {1,2,3}
IDomain u3 = Domain.IntRange(1, 5); // {1,2,3,4}
IFuzzySet r1 = new MutableFuzzySet(Domain.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(Domain.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.Relations.CompositionOfBinaryRelations(r1, r2, Operations.Operations.ZadehAnd(), Operations.Operations.ZadehOr());
foreach (DomainElement e in r1r2.GetDomain())
{
Console.WriteLine("mu(" + e + ")=" + r1r2.GetValueAt(e));
}
}
