//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); }