//Maker bank
public static void TerminateTransaction(BizPortalSessionContext context, Member member, MaintenanceTransaction maintenanceTransaction)
{
MaintenanceWorkflow functionWorkflow = ((AddMaintenanceWorkflowTransaction)maintenanceTransaction).Target;
string title = functionWorkflow.CreatorGroup.Title;
DateTime now = DateTime.Now;
MemberFunction mf = context.PersistenceSession.QueryOver <MemberFunction>()
.Where(m => m.Member == member && m.ID == functionWorkflow.MemberFunction.ID).SingleOrDefault();
if (mf == null)
{
return;
}
IList <FunctionWorkflow> fs = mf.EffectiveWorkflows.Where(f => f.CreatorGroup.Title == title)
.OrderByDescending(f => f.EffectivePeriod.EffectiveDate)
.Skip(1)
.ToList();
if (fs.Count == 0)
{
return;
}
foreach (var fwf in fs)
{
//TerminateTransactionNotCommit(context, (int)ClientAdminFunctionID.TerminateFunctionWorkflow, fwf, functionWorkflow.CreatorGroup, false);
fwf.EffectivePeriod.ExpiryDate = now;
}
}
public void ImpMinTest()
{
// Set our input
MemberFunction inMF = new MemberFunction(new List <double[]>
{
new double[] { 0, 0 },
new double[] { 1, 1 },
new double[] { 2, 1 },
new double[] { 3, 0 },
});
// Run the test
MemberFunction outMF = FISOperators.ImpMin(inMF, 0.5, 3.0);
// Here's what we expect to get
List <double[]> expected = new List <double[]>
{
new double[] { 0, 0 },
new double[] { 0.5, 1.5 },
new double[] { 2.5, 1.5 },
new double[] { 3, 0 },
};
for (int i = 0; i < expected.Count; i++)
{
Assert.AreEqual(outMF.Coords[i][0], expected[i][0]);
Assert.AreEqual(outMF.Coords[i][1], expected[i][1]);
}
}
public override void BuildNode(ITreeBuilder treeBuilder,
object dataObject,
NodeInfo nodeInfo)
{
MemberFunction f = (MemberFunction)dataObject;
nodeInfo.Label = f.Name;
switch (f.Access)
{
case CX_CXXAccessSpecifier.@Public:
nodeInfo.Icon = Context.GetIcon(Stock.Method);
break;
case CX_CXXAccessSpecifier.@Protected:
nodeInfo.Icon = Context.GetIcon(Stock.ProtectedMethod);
break;
case CX_CXXAccessSpecifier.@Private:
nodeInfo.Icon = Context.GetIcon(Stock.PrivateMethod);
break;
case CX_CXXAccessSpecifier.@InvalidAccessSpecifier:
nodeInfo.Icon = Context.GetIcon(Stock.Method);
break;
}
}
public static MaintenanceWorkflow GetInstance(MemberFunction memberfunction, MemberUserGroup memberUserGroup)
{
return(new MaintenanceWorkflow
{
MemberFunction = memberfunction,
CreatorGroup = memberUserGroup,
});
}
public static IList <MaintenanceWorkflow> GetFunctionWorkFlowEffectives(MemberFunction mf)
{
IList <MaintenanceWorkflow> fwfs = new List <MaintenanceWorkflow>();
foreach (MaintenanceWorkflow fw in mf.Workflows)
{
if (fw.IsEffective)
{
fwfs.Add(fw);
}
}
return(fwfs);
}
/// Implements <Property> ::= <Property> '.' <Identifier>
public Reduction CreateRULE_PROPERTY_DOT(Reduction reduction)
{
IFunctor nested =
new MemberFunction(((Reduction)((Token)reduction.GetToken(2)).Data).Tag.ToString());
IFunctor func =
new MemberFunction(((Reduction)((Token)reduction.GetToken(0)).Data).Tag.ToString());
reduction.Tag = new CompositeFunction(func, nested);
if (NCacheLog.IsInfoEnabled)
{
NCacheLog.Info("RULE_PROPERTY_DOT -> " + reduction.Tag);
}
return(null);
}
public void FISDefuzzBisectTest()
{
// Test a symmetric shape
MemberFunction inMf = new MemberFunction(new List <double[]>
{
new double[] { 0, 0 },
new double[] { 1, 1 },
new double[] { 2, 1 },
new double[] { 3, 0 },
});
double result = Defuzzify.DefuzzBisect(inMf);
// REsult should be the balancing point along the x axis
Assert.AreEqual(result, 1.5);
// Test a lopsided shape
MemberFunction inMf2 = new MemberFunction(new List <double[]>
{
new double[] { 0, 0 },
new double[] { 1, 0 },
new double[] { 1, 1 },
new double[] { 2, 1 },
new double[] { 3, 1 },
});
double result2 = Defuzzify.DefuzzBisect(inMf2);
// REsult should be the balancing point along the x axis
Assert.AreEqual(result2, 2);
// Test a shape where the bisect happens beteen points
MemberFunction inMf3 = new MemberFunction(new List <double[]>
{
new double[] { 0, 0 },
new double[] { 1, 0 },
new double[] { 1, 1 },
new double[] { 2, 1 },
new double[] { 4, 1 },
});
double result3 = Defuzzify.DefuzzBisect(inMf3);
// REsult should be the balancing point along the x axis
Assert.AreEqual(result3, 2.5);
}
/// <summary>
/// Defuzzify a membership function using the Smallest of Maximum method.
/// </summary>
/// <param name="mf"></param>
/// <returns></returns>
public static double FISDefuzzSmallMax(MemberFunction mf)
{
double x = mf.Coords[0][0];
double y = mf.Coords[0][1];
for (int i = 1; i < mf.Length; i++)
{
if (mf.Coords[i][1] > y)
{
x = mf.Coords[i][0];
y = mf.Coords[i][1];
}
}
return(x);
}
public static bool IsViewMemberFunction(MemberFunction mf)
{
if (mf == null)
{
return(false);
}
if (!mf.Function.RequireAmountLimit)
{
return(true);
}
else
{
return(false);
}
}
public void getXTest()
{
MemberFunction mf1 = new MemberFunction(new List <double[]>()
{
new double[2] {
1, 0
}, //0
new double[2] {
2, 1
}, //1 <-- horiz
new double[2] {
3, 1
}, //2 <-- Vertical
new double[2] {
3, 2
}, //3 <-- horiz
new double[2] {
4, 2
}, //4
new double[2] {
5, 0
} //5
});
double x1 = mf1.getX(0, 1, 0.5); // Slopey test
Assert.AreEqual(x1, 1.5);
double x2 = mf1.getX(0, 1, 0.9); // Slopey test
Assert.AreEqual(x2, 1.9);
double x3 = mf1.getX(1, 2, 1); // horiz test
Assert.AreEqual(x3, 2);
double x4 = mf1.getX(2, 3, 1); // Vert test
Assert.AreEqual(x4, 3);
double x5 = mf1.getX(4, 5, 0.5);
Assert.AreEqual(x5, 4.75);
double x6 = mf1.getX(5, 4, 0.5); // BAckwards indeces just for fun
Assert.AreEqual(x6, 4.75);
}
/// <summary>
/// Defuzzify a membership function using the Centroid method
///
/// NOTE: This method was found to be problematic and so we modeled it after the
/// centroid from SciPy fuzzy:
/// https://github.com/scikit-fuzzy/scikit-fuzzy/blob/master/skfuzzy/defuzzify/defuzz.py
/// https://www.mathworks.com/help/fuzzy/examples/defuzzification-methods.html
/// </summary>
/// <param name="mf"></param>
/// <returns></returns>
public static double DefuzzCentroid(MemberFunction mf)
{
double sum_moment_area = 0;
double sum_area = 0;
for (int i = 1; i < mf.Length; i++)
{
double moment = 0;
double area = 0;
double x1 = mf.Coords[i - 1][0];
double x2 = mf.Coords[i][0];
double y1 = mf.Coords[i - 1][1];
double y2 = mf.Coords[i][1];
// Check that this isn't zero height or zero length
if (!(y1 == 0 && y2 == 0) && x1 != x2)
{
// Rectangle
if (y1 == y2)
{
moment = 0.5 * (x1 + x2);
area = (x2 - x1) * y1;
}
// Triangle with height y2
else if (y1 == 0 && y2 != 0)
{
moment = (2 * x2 + x1) / 3;
area = 0.5 * (x2 - x1) * y2;
}
// Triangle with height y1
else if (y2 == 0 && y1 != 0)
{
moment = (2 * x1 + x2) / 3;
area = 0.5 * (x2 - x1) * y1;
}
// Other cases
else
{
moment = (2 / 3 * (x2 - x1) * (y2 + 0.5 * y1)) / (y1 + y2) + x1;
area = 0.5 * (x2 - x1) * (y1 + y2);
}
}
sum_moment_area += moment * area;
sum_area += area;
}
return(sum_moment_area / sum_area);
}
public static MaintenanceWorkflow GetInstance(MemberFunction memberfunction, MemberUserGroup memberUserGroup, UserGroupRole role)
{
MaintenanceWorkflow functionWorkFlow = null;
switch (role)
{
case UserGroupRole.Admin:
functionWorkFlow = new MaintenanceWorkflow
{
MemberFunction = memberfunction,
CreatorGroup = memberUserGroup,
//DebitableBankAccounts = workflowBankAccounts,
ApprovalTiers = new List <ApprovalTier> {
new ApprovalTier {
ApproverGroup = memberUserGroup,
},
},
};
break;
case UserGroupRole.Creator:
functionWorkFlow = new MaintenanceWorkflow
{
MemberFunction = memberfunction,
CreatorGroup = memberUserGroup,
//DebitableBankAccounts = workflowBankAccounts,
};
break;
case UserGroupRole.Approver:
functionWorkFlow = new MaintenanceWorkflow
{
MemberFunction = memberfunction,
ApprovalTiers = new List <ApprovalTier> {
new ApprovalTier {
ApproverGroup = memberUserGroup,
},
},
//DebitableBankAccounts = workflowBankAccounts,
};
break;
default:
break;
}
return(functionWorkFlow);
}
public void AggMaxTest()
{
// Set our inputs
MemberFunction inMF = new MemberFunction(new List <double[]>
{
new double[] { 0, 0 },
new double[] { 1, 1 },
new double[] { 2, 1 },
new double[] { 3, 0 },
});
MemberFunction outMf = new MemberFunction(new List <double[]>
{
new double[] { 1.4, 0 },
new double[] { 1.5, 2 },
new double[] { 3, 2 },
new double[] { 4, 0 },
});
// Run the test
FISOperators.AggMax(inMF, outMf);
// Here's what we expect to get
List <double[]> expected = new List <double[]>
{
new double[] { 0, 0 },
new double[] { 1, 1 },
new double[] { 1.4, 1 },
new double[] { 1.5, 2 },
new double[] { 2, 2 },
new double[] { 3, 2 },
new double[] { 4, 0 },
};
// Visual output for sanity
for (int i = 0; i < expected.Count; i++)
{
Debug.WriteLine(String.Format("({0}, {1}) ==> ({2}, {3})", outMf.Coords[i][0], outMf.Coords[i][1], expected[i][0], expected[i][1]));
}
// Test the values
for (int i = 0; i < expected.Count; i++)
{
Assert.AreEqual(outMf.Coords[i][0], expected[i][0]);
Assert.AreEqual(outMf.Coords[i][1], expected[i][1]);
}
}
public void DefuzzCentroidTest()
{
// Set our input
// https://www.mathworks.com/help/fuzzy/examples/defuzzification-methods.html
MemberFunction inMf = new MemberFunction(new List <double[]>
{
new double[] { 0, 0 },
new double[] { 1, 1 },
new double[] { 2, 1 },
new double[] { 3, 0 },
});
double result = Defuzzify.DefuzzCentroid(inMf);
// Should be the point along the x axis that divides the shape
// into two equal pieces
Assert.AreEqual(result, 1.5);
}
public void fuzzifyTest()
{
MemberFunction mf1 = new MemberFunction(new List <double[]>()
{
new double[2] {
1, 0
}, //0
new double[2] {
2, 1
}, //1 <-- horiz
new double[2] {
3, 1
}, //2 <-- Vertical
new double[2] {
3, 2
}, //3 <-- horiz
new double[2] {
4, 2
}, //4
new double[2] {
5, 0
} //5
});
Assert.AreEqual(mf1.fuzzify(0), 0);
Assert.AreEqual(mf1.fuzzify(1), 0);
Assert.AreEqual(mf1.fuzzify(2), 1);
Assert.AreEqual(mf1.fuzzify(3), 1);
Assert.AreEqual(mf1.fuzzify(4), 2);
Assert.AreEqual(mf1.fuzzify(5), 0);
Assert.AreEqual(mf1.fuzzify(0.5), 0);
Assert.AreEqual(mf1.fuzzify(1.5), 0.5);
Assert.AreEqual(mf1.fuzzify(2.5), 1);
Assert.AreEqual(mf1.fuzzify(3.5), 2);
Assert.AreEqual(mf1.fuzzify(4.5), 1);
Assert.AreEqual(mf1.fuzzify(5.5), 0);
Assert.AreEqual(mf1.fuzzify(-100), 0);
Assert.AreEqual(mf1.fuzzify(100), 0);
Assert.AreEqual(mf1.fuzzify(double.PositiveInfinity), 0);
Assert.AreEqual(mf1.fuzzify(double.NegativeInfinity), 0);
}
public void addMFTest()
{
MemberFunctionSet mfSet = new MemberFunctionSet(0, 5);
MemberFunction mf1 = new MemberFunction(new List <double[]>()
{
new double[2] {
1, 0
},
new double[2] {
2, 1
},
new double[2] {
3, 1
},
new double[2] {
4, 0
}
});
MemberFunction mf2 = new MemberFunction(new List <double[]>()
{
new double[2] {
1, 0
},
new double[2] {
2, 1
},
new double[2] {
4, 0
}
});
mfSet.addMF("jerry", mf1);
Assert.AreEqual(mfSet.Count, 1);
Assert.AreSame(mfSet.MFunctions[0], mf1);
Assert.AreEqual(mfSet.Indices["jerry"], 0);
mfSet.addMF("garry", mf2);
Assert.AreEqual(mfSet.Count, 2);
Assert.AreSame(mfSet.MFunctions[1], mf2);
Assert.AreEqual(mfSet.Indices["garry"], 1);
}
/// <summary>
/// Defuzzify a membership function using the Middle of Maximum method.
/// https://www.mathworks.com/help/fuzzy/examples/defuzzification-methods.html
/// </summary>
/// <param name="mf"></param>
/// <returns></returns>
public static double FISDefuzzMidMax(MemberFunction mf)
{
double minX = mf.Coords[0][0];
double maxX = mf.Coords[0][0];
double y = mf.Coords[0][1];
for (int i = 1; i < mf.Length; i++)
{
if (mf.Coords[i][1] > y)
{
minX = mf.Coords[i][0];
maxX = minX;
y = mf.Coords[i][1];
}
else if (mf.Coords[i][1] == y)
{
maxX = mf.Coords[i][0];
}
}
return(minX + (maxX - minX) / 2);
}
public void FISDefuzzMaxMethodsTest()
{
// Test a shape where the bisect happens beteen points
MemberFunction inMf3 = new MemberFunction(new List <double[]>
{
new double[] { 0, 0 },
new double[] { 1, 0 },
new double[] { 1, 1 },
new double[] { 2, 2 },
new double[] { 4, 2 },
new double[] { 5, 0 },
});
double LargeMax = Defuzzify.FISDefuzzLargeMax(inMf3);
double MidMax = Defuzzify.FISDefuzzMidMax(inMf3);
double SmallMax = Defuzzify.FISDefuzzSmallMax(inMf3);
// REsult should be the balancing point along the x axis
Assert.AreEqual(LargeMax, 4);
Assert.AreEqual(MidMax, 3);
Assert.AreEqual(SmallMax, 2);
}
public void clearTest()
{
MemberFunction mf1 = new MemberFunction(new List <double[]>()
{
new double[2] {
1, 0
},
new double[2] {
2, 1
},
new double[2] {
3, 1
},
new double[2] {
4, 0
}
});
mf1.clear();
Assert.AreEqual(mf1.MaxY, 0);
testCoord(mf1.Coords, new List <double[]>());
}
public MemberController()
{
memberRepository = new MemberRepository();
memberFunction = new MemberFunction();
}
public static IList <MaintenanceWorkflow> GetIsNotFinalizedMaintenanceWorkf(BizPortalSessionContext context, MemberFunction memberFunction)
{
return(context.PersistenceSession
.QueryOver <MaintenanceWorkflow>()
.Where(mwf => mwf.IsNotFinalized == true && mwf.MemberFunction.ID == memberFunction.ID)
.List());
}
private void UpdateLocalDbContextMemberFunctionsObjects()
{
viewCoreData.CloseEditor();
//Funktionen eines jeden Mitglieds in Datenbank abspeichern
for (int i = 0; i < dbContext.Members.Local.Count; i++)
{
//Um dieses Mitglied geht es aktuell
Member member = dbContext.Members.Local[i];
//Bisherige Funktionen des Mitglieds in Liste schreiben
List <int> oldFunctionIds = new List <int>();
foreach (MemberFunction function in member.MemberFunctions)
{
oldFunctionIds.Add(function.FunctionID.Value);
}
//Aktuelle Funktionen des Mitglieds in Listen schreiben
List <int> newFunctionIds = new List <int>();
string newFunctionIdsString = colFunctionsCellValues[i].ToString();
if (!String.IsNullOrEmpty(newFunctionIdsString))
{
int seperatorPos = newFunctionIdsString.IndexOf(colFuntionsIdSeperator);
while (seperatorPos != -1)
{
newFunctionIds.Add(Convert.ToInt32(newFunctionIdsString.Substring(0, seperatorPos)));
newFunctionIdsString = newFunctionIdsString.Remove(0, seperatorPos + colFuntionsIdSeperator.Length);
seperatorPos = newFunctionIdsString.IndexOf(colFuntionsIdSeperator);
}
newFunctionIds.Add(Convert.ToInt32(newFunctionIdsString));
}
newFunctionIdsString = null;
//Listen aufsteigend sortieren
oldFunctionIds.Sort();
newFunctionIds.Sort();
if (!(oldFunctionIds.Count == 0 && newFunctionIds.Count == 0))
{
//Alle bisherigen und aktuellen Funktions-Ids in Liste schreiben, Duplikate entfernen und Liste sortieren
List <int> allFunctionIds = new List <int>();
allFunctionIds.AddRange(oldFunctionIds);
allFunctionIds.AddRange(newFunctionIds);
allFunctionIds = allFunctionIds.Distinct().ToList <int>();
allFunctionIds.Sort();
//Zwei neue ID-Listen erstellen:
// Neue Funktionen des Mitglieds
// Entfernte Funktionen des Mitglieds
List <int> memberFunctionsToAdd = new List <int>();
List <int> memberFunctionsToDelete = new List <int>();
//Listen befüllen
while (allFunctionIds.Count > 0)
{
int id = allFunctionIds.First();
if (id != oldFunctionIds.FirstOrDefault())
{
memberFunctionsToAdd.Add(id);
newFunctionIds.Remove(id);
}
else if (id != newFunctionIds.FirstOrDefault())
{
memberFunctionsToDelete.Add(id);
oldFunctionIds.Remove(id);
}
else
{
oldFunctionIds.Remove(id);
newFunctionIds.Remove(id);
}
allFunctionIds.Remove(id);
}
//Ehemalige Funtionen des Mitglieds löschen
foreach (int id in memberFunctionsToDelete)
{
MemberFunction function = (from a in dbContext.MemberFunctions.Local
where a.MemberID == member.ID &&
a.FunctionID == id
select a).SingleOrDefault();
dbContext.MemberFunctions.Local.Remove(function);
}
//Neue Funtionen des Mitglieds hinzufügen
foreach (int id in memberFunctionsToAdd)
{
MemberFunction function = new MemberFunction()
{
FunctionID = id,
MemberID = member.ID
};
dbContext.MemberFunctions.Local.Add(function);
}
}
}
}
/// <summary>
/// Defuzzify a membership function using the Bisector method.
/// https://www.mathworks.com/help/fuzzy/examples/defuzzification-methods.html
/// </summary>
/// <param name="mf"></param>
/// <returns></returns>
public static double DefuzzBisect(MemberFunction mf)
{
double areaTotal = 0;
double[] areas = new double[mf.Length];
// Find the area of each segment
for (int i = 0; i < mf.Length - 1; i++)
{
double x1 = mf.Coords[i][0];
double x2 = mf.Coords[i + 1][0];
double y1 = mf.Coords[i][1];
double y2 = mf.Coords[i + 1][1];
areas[i] = 0.5 * (x2 - x1) * (y1 + y2);
areaTotal += areas[i];
}
double halfArea = areaTotal / 2;
double xMin = 0;
double xMax = 0;
double yLast = 0;
double x = 0;
double y = 0;
double m = 0;
// This is our accumulating area
double tmpArea = 0;
for (int i = 0; i < mf.Length - 1; i++)
{
// Get the area of this segment
m = areas[i];
x = xMax = mf.Coords[i][0];
// Add points in until we cross over to the haldway point
if (tmpArea + m <= halfArea)
{
tmpArea += m;
}
// Cut the distance in hald until we are reasonable close to the point we want
else
{
xMin = mf.Coords[i][0];
xMax = mf.Coords[i + 1][0];
yLast = mf.Coords[i][1];
while (halfArea - tmpArea > 0.000001)
{
x = xMin + ((xMax - xMin) / 2);
y = mf.fuzzify(x);
m = Area(new double[2] {
xMin, yLast
}, new double[2] {
x, y
});
if (tmpArea + m > halfArea)
{
xMax = x;
}
else if (tmpArea + m <= halfArea)
{
tmpArea += m;
xMin = x;
}
}
break;
}
}
return(x);
}
public Class(string name, string module)
{
Name = name;
Module = module;
CtorForMembersWithValues = new MemberFunction(".ctorForInit", "na", new List <string>(), this);
}
public bool TryGetFunction(string name, out MemberFunction func)
{
return(Functions.TryGetValue(name, out func));
}
public void MemberFunctionTest()
{
// Empty Constructor
MemberFunction construct1 = new MemberFunction();
Assert.AreEqual(construct1.MaxY, 0);
testCoord(construct1.Coords, new List <double[]>());
// List Constructor
MemberFunction construct2 = new MemberFunction(new List <double[]>()
{
new double[2] {
1, 0
},
new double[2] {
2, 1
},
new double[2] {
3, 1
},
new double[2] {
4, 0
}
});
testCoord(construct2.Coords, new List <double[]>()
{
new double[2] {
1, 0
},
new double[2] {
2, 1
},
new double[2] {
3, 1
},
new double[2] {
4, 0
}
});
Assert.AreEqual(construct2.MaxY, 1);
// Triangle
MemberFunction construct3 = new MemberFunction(1, 2.5, 3, 0.9);
testCoord(construct3.Coords, new List <double[]>()
{
new double[2] {
1, 0
},
new double[2] {
2.5, 0.9
},
new double[2] {
3, 0
}
});
Assert.AreEqual(construct3.MaxY, 0.9);
// Trapezoid
MemberFunction construct4 = new MemberFunction(1, 2.5, 3, 4, 0.9);
testCoord(construct4.Coords, new List <double[]>()
{
new double[2] {
1, 0
},
new double[2] {
2.5, 0.9
},
new double[2] {
3, 0.9
},
new double[2] {
4, 0
}
});
Assert.AreEqual(construct4.MaxY, 0.9);
}
