static bool isSubCalendarEventAlreadyInList(SubCalendarEvent MySubCalendarEvent, List<SubCalendarEvent> MyListCopy) { foreach (SubCalendarEvent SubCalendarElement in MyListCopy) { if (MySubCalendarEvent.ID == SubCalendarElement.ID) { return true; } } return false; }
public ClumpSubCalendarEvent(List<SubCalendarEvent> Appendables, TimeLine BoundaryTimeLine) { Appendables=Appendables.OrderBy(obj => obj.getCalendarEventRange.End).ToList(); SubCalendarEvent RelativeSubEvent = Appendables[0]; Appendables.Remove(RelativeSubEvent); ClumpSubCalendarEvent myThis = new ClumpSubCalendarEvent(RelativeSubEvent, Appendables, BoundaryTimeLine.CreateCopy()); SubCalEventsOverLapWithBase = myThis.SubCalEventsOverLapWithBase; //List<SubCalendarEvent> NonOverLapping; BaseEvent= myThis.BaseEvent; this.BoundaryTimeLine =myThis.BoundaryTimeLine; //List<SubCalendarEvent> BaseClump; //List<ClumpSubCalendarEvent> NonOverLapping_Clump; BreakOffClump= myThis.BreakOffClump; ClumpedResults= myThis.ClumpedResults; BaseReferenceStartTime = myThis.BaseReferenceStartTime; }
public void DeleteAppointment(SubCalendarEvent ActiveSection, string NameOfParentCalendarEvent, string entryID) { #if EnableOutlook if (entryID == "") { return; } Outlook.Application outlookApp = new Microsoft.Office.Interop.Outlook.Application(); Outlook.MAPIFolder calendar = outlookApp.Session.GetDefaultFolder(Outlook.OlDefaultFolders.olFolderCalendar); Outlook.Items calendarItems = calendar.Items; try { string SubJectString = ActiveSection.ID + "**" + NameOfParentCalendarEvent; if (ActiveSection.isComplete) { //SubJectString = ActiveSection.ID + "*\u221A*" + NameOfParentCalendarEvent; } Outlook.AppointmentItem item = calendarItems[SubJectString] as Outlook.AppointmentItem; item.Delete(); } catch { return; } /*Outlook.RecurrencePattern pattern = item.GetRecurrencePattern(); Outlook.AppointmentItem itemDelete = pattern. GetOccurrence(new DateTime(2006, 6, 28, 8, 0, 0)); if (itemDelete != null) { itemDelete.Delete(); }*/ #endif }
public static int CompareByStartDate(SubCalendarEvent SubCalendarEvent1, SubCalendarEvent SubCalendarEvent2) { return SubCalendarEvent1.Start.CompareTo(SubCalendarEvent2.Start); }
public SubCalendarEvent createCopy() { SubCalendarEvent MySubCalendarEventCopy = new SubCalendarEvent(this.ID, new DateTime(Start.Ticks), new DateTime(End.Ticks), BusyFrame.CreateCopy(), this.RigidSchedule, this.isEnabled, this.UiParams.createCopy(), this.Notes.createCopy(), this.Complete, this.LocationData, new TimeLine(CalendarEventRange.Start, CalendarEventRange.End)); //MySubCalendarEventCopy.LocationData = LocationData;//note check for possible reference issues for future versions /*MySubCalendarEventCopy.SubEventID = SubEventID; MySubCalendarEventCopy.BusyFrame = BusyFrame; MySubCalendarEventCopy.StartDateTime = StartDateTime; MySubCalendarEventCopy.EndDateTime = EndDateTime; MySubCalendarEventCopy.EventDuration = EventDuration; MySubCalendarEventCopy.RigidSchedule = RigidSchedule; MySubCalendarEventCopy.SchedulStatus = SchedulStatus; MySubCalendarEventCopy.otherPartyID = otherPartyID; MySubCalendarEventCopy.EventPreDeadline = EventPreDeadline; MySubCalendarEventCopy.EventRepetition = EventRepetition;*/ MySubCalendarEventCopy.ThirdPartyID = this.ThirdPartyID; return MySubCalendarEventCopy; }
virtual public bool shiftEvent(TimeSpan ChangeInTime, SubCalendarEvent[] UpdatedSubCalEvents) { TimeLine UpdatedTimeLine = new TimeLine(this.Start+ChangeInTime,this.End+ChangeInTime); foreach (SubCalendarEvent eachSubCalendarEvent in UpdatedSubCalEvents) { if(!(UpdatedTimeLine.IsTimeLineWithin(eachSubCalendarEvent.RangeTimeLine))) { return false; } } StartDateTime = StartDateTime + ChangeInTime; EndDateTime = EndDateTime + ChangeInTime; ArrayOfSubEvents = UpdatedSubCalEvents.ToArray(); return true; }
bool isSubCalendarEventInList(SubCalendarEvent SubCalendarEventToCheck, List<SubCalendarEvent> MyCurrentList) { foreach (SubCalendarEvent MySubCalendarEvent in MyCurrentList) { if (SubCalendarEventToCheck.ID == MySubCalendarEvent.ID) { return true; } } return false; }
public double Distance(SubCalendarEvent firstCity, SubCalendarEvent secondCity) { return DistanceMatrix[firstCity.SubEvent_ID.getLevelID(0)][Horizontal.IndexOf(secondCity.SubEvent_ID.getLevelID(0))]; }
/*SubCalendarEvent[] generateSubEvent(SubCalendarEvent[] ArrayOfEvents, int NumberOfSplit, TimeSpan TotalActiveDurationSubEvents, string ParentID) { TimeSpan TimeSpanEvent = EndDateTime - StartDateTime; //new TimeSpan((long)((().TotalSeconds/ ArrayOfEvents.Length)*100000000)); TimeSpanEvent = new TimeSpan(((long)TimeSpanEvent.TotalMilliseconds * 10000) / ArrayOfEvents.Length); TimeSpan ActiveDurationPerSubEvents = new TimeSpan((long)(((TotalActiveDurationSubEvents.TotalSeconds) * 10000000) / ArrayOfEvents.Length)); DateTime SubStart; DateTime SubEnd; for (int i = 0; i < ArrayOfEvents.Length; i++) { SubStart = StartDateTime.AddSeconds(TimeSpanEvent.TotalSeconds * i); SubEnd = StartDateTime.AddSeconds(TimeSpanEvent.TotalSeconds * (i + 1)); ArrayOfEvents[i] = new SubCalendarEvent(ActiveDurationPerSubEvents, SubStart, SubEnd, PrepTime, ParentID); } return ArrayOfEvents; }*/ public CalendarEvent createCopy() { CalendarEvent MyCalendarEventCopy = new SubCalendarEvent(); MyCalendarEventCopy.EventDuration = new TimeSpan(EventDuration.Ticks); MyCalendarEventCopy.CalendarEventName = CalendarEventName.ToString(); MyCalendarEventCopy.StartDateTime = new DateTime(StartDateTime.Ticks); MyCalendarEventCopy.EndDateTime = new DateTime(EndDateTime.Ticks); MyCalendarEventCopy.EventPreDeadline = new TimeSpan(EventPreDeadline.Ticks); MyCalendarEventCopy.PrepTime = new TimeSpan(PrepTime.Ticks); MyCalendarEventCopy.Priority = Priority; MyCalendarEventCopy.RepetitionFlag = RepetitionFlag; MyCalendarEventCopy.EventRepetition = EventRepetition.CreateCopy();// EventRepetition != null ? EventRepetition.CreateCopy() : EventRepetition; //protected bool Completed = false; MyCalendarEventCopy.RigidSchedule = RigidSchedule;//hack MyCalendarEventCopy.Splits = Splits; MyCalendarEventCopy.TimePerSplit = new TimeSpan(TimePerSplit.Ticks); MyCalendarEventCopy.CalendarEventID = CalendarEventID;//hack MyCalendarEventCopy.EventSequence = EventSequence.CreateCopy(); MyCalendarEventCopy.ArrayOfSubEvents = ArrayOfSubEvents.ToArray(); MyCalendarEventCopy.LocationData = LocationData;//hack you might need to make copy for (int i = 0; i < MyCalendarEventCopy.ArrayOfSubEvents.Length; i++) { MyCalendarEventCopy.ArrayOfSubEvents[i] = MyCalendarEventCopy.ArrayOfSubEvents[i].createCopy(); } MyCalendarEventCopy.SchedulStatus = SchedulStatus; MyCalendarEventCopy.otherPartyID = otherPartyID == null ? null : otherPartyID.ToString(); return MyCalendarEventCopy; }
public Bee(int status, SubCalendarEvent[] memoryMatrix, double measureOfQuality, int numberOfVisits) { this.status = status; this.memoryMatrix = new SubCalendarEvent[memoryMatrix.Length]; Array.Copy(memoryMatrix, this.memoryMatrix, memoryMatrix.Length); this.measureOfQuality = measureOfQuality; this.numberOfVisits = numberOfVisits; }
/*QUICK SORT SECTION END*/ public BusyTimeLine[] CheckIfMyRangeAlreadyHasSchedule(BusyTimeLine[] BusySlots, SubCalendarEvent MySubEvent) { List<BusyTimeLine> InvadingEvents = new List<BusyTimeLine>(); int i = 0; for (; i < BusySlots.Length; i++) { if ((BusySlots[i].End > MySubEvent.Start) && (BusySlots[i].End < MySubEvent.End)) { InvadingEvents.Add(BusySlots[i]); } } InvadingEvents = SortBusyTimeline(InvadingEvents, true); return InvadingEvents.ToArray(); }
SubCalendarEvent[] ReadSubSchedulesFromXMLNode(XmlNode MyXmlNode, CalendarEvent MyParent) { SubCalendarEvent[] MyArrayOfNodes = new SubCalendarEvent[MyXmlNode.ChildNodes.Count]; string ID = ""; DateTime Start = new DateTime(); DateTime End = new DateTime(); TimeSpan SubScheduleDuration = new TimeSpan(); TimeSpan PrepTime = new TimeSpan(); BusyTimeLine BusySlot = new BusyTimeLine(); bool Enabled; for (int i = 0; i < MyXmlNode.ChildNodes.Count; i++) { BusyTimeLine SubEventActivePeriod = new BusyTimeLine(MyXmlNode.ChildNodes[i].SelectSingleNode("ID").InnerText, stringToDateTime(MyXmlNode.ChildNodes[i].SelectSingleNode("ActiveStartTime").InnerText), stringToDateTime(MyXmlNode.ChildNodes[i].SelectSingleNode("ActiveEndTime").InnerText)); ID = MyXmlNode.ChildNodes[i].SelectSingleNode("ID").InnerText; Start = DateTime.Parse(MyXmlNode.ChildNodes[i].SelectSingleNode("ActiveStartTime").InnerText); End = DateTime.Parse(MyXmlNode.ChildNodes[i].SelectSingleNode("ActiveEndTime").InnerText); BusySlot = new BusyTimeLine(ID, Start, End); PrepTime = new TimeSpan(ConvertToMinutes(MyXmlNode.ChildNodes[i].SelectSingleNode("PrepTime").InnerText) * 60 * 10000000); //stringToDateTime(); Start = DateTime.Parse(MyXmlNode.ChildNodes[i].SelectSingleNode("StartTime").InnerText); End = DateTime.Parse(MyXmlNode.ChildNodes[i].SelectSingleNode("EndTime").InnerText); Enabled=Convert.ToBoolean(MyXmlNode.ChildNodes[i].SelectSingleNode("Enabled").InnerText); bool CompleteFlag = Convert.ToBoolean(MyXmlNode.ChildNodes[i].SelectSingleNode("Complete").InnerText); Location var1 = getLocation(MyXmlNode.ChildNodes[i]); MiscData noteData = getMiscData(MyXmlNode.ChildNodes[i]); EventDisplay UiData = getDisplayUINode(MyXmlNode.ChildNodes[i]); MyArrayOfNodes[i] = new SubCalendarEvent(ID, BusySlot, Start, End, PrepTime, MyParent.ID, MyParent.Rigid, Enabled, UiData, noteData, CompleteFlag, var1, MyParent.RangeTimeLine); MyArrayOfNodes[i].ThirdPartyID = MyXmlNode.ChildNodes[i].SelectSingleNode("ThirdPartyID").InnerText;//this is a hack to just update the Third partyID } return MyArrayOfNodes; }
public XmlElement CreateSubScheduleNode(SubCalendarEvent MySubEvent) { XmlDocument xmldoc = new XmlDocument(); XmlElement MyEventSubScheduleNode = xmldoc.CreateElement("EventSubSchedule"); DateTime StartTime = MySubEvent.Start; StartTime = Truncate(StartTime, TimeSpan.FromSeconds(1)); DateTime EndTime = MySubEvent.End; EndTime = Truncate(EndTime, TimeSpan.FromSeconds(1)); TimeSpan EventTimeSpan = MySubEvent.ActiveDuration; long AllSecs = (long)EventTimeSpan.TotalSeconds; long AllTicks = (long)EventTimeSpan.TotalMilliseconds; long DiffSecs = (long)(EndTime - StartTime).TotalSeconds; long DiffTicks = (long)(EndTime - StartTime).TotalMilliseconds; EventTimeSpan = new TimeSpan(AllSecs * 10000000); if ((EndTime - StartTime) != EventTimeSpan) { EndTime = StartTime.Add(EventTimeSpan); } MyEventSubScheduleNode.PrependChild(xmldoc.CreateElement("EndTime")); MyEventSubScheduleNode.ChildNodes[0].InnerText = EndTime.ToString(); MyEventSubScheduleNode.PrependChild(xmldoc.CreateElement("StartTime")); MyEventSubScheduleNode.ChildNodes[0].InnerText = StartTime.ToString(); MyEventSubScheduleNode.PrependChild(xmldoc.CreateElement("Duration")); MyEventSubScheduleNode.ChildNodes[0].InnerText = EventTimeSpan.ToString(); MyEventSubScheduleNode.PrependChild(xmldoc.CreateElement("ActiveEndTime")); MyEventSubScheduleNode.ChildNodes[0].InnerText = EndTime.ToString(); MyEventSubScheduleNode.PrependChild(xmldoc.CreateElement("ActiveStartTime")); MyEventSubScheduleNode.ChildNodes[0].InnerText = StartTime.ToString(); MyEventSubScheduleNode.PrependChild(xmldoc.CreateElement("PrepTime")); MyEventSubScheduleNode.ChildNodes[0].InnerText = MySubEvent.Preparation.ToString(); MyEventSubScheduleNode.PrependChild(xmldoc.CreateElement("ThirdPartyID")); MyEventSubScheduleNode.ChildNodes[0].InnerText = MySubEvent.ThirdPartyID; //MyEventSubScheduleNode.PrependChild(xmldoc.CreateElement("Name")); //MyEventSubScheduleNode.ChildNodes[0].InnerText = MySubEvent.Name.ToString(); MyEventSubScheduleNode.PrependChild(xmldoc.CreateElement("ID")); MyEventSubScheduleNode.ChildNodes[0].InnerText = MySubEvent.ID.ToString(); MyEventSubScheduleNode.PrependChild(xmldoc.CreateElement("Enabled")); MyEventSubScheduleNode.ChildNodes[0].InnerText = MySubEvent.isEnabled.ToString(); MyEventSubScheduleNode.PrependChild(xmldoc.CreateElement("Complete")); MyEventSubScheduleNode.ChildNodes[0].InnerText = MySubEvent.isComplete.ToString(); MyEventSubScheduleNode.PrependChild(xmldoc.CreateElement("Location")); MyEventSubScheduleNode.ChildNodes[0].InnerXml = CreateLocationNode(MySubEvent.myLocation, "EventSubScheduleLocation").InnerXml; MyEventSubScheduleNode.PrependChild(xmldoc.CreateElement("UIParams")); MyEventSubScheduleNode.ChildNodes[0].InnerXml = createDisplayUINode(MySubEvent.UIParam, "UIParams").InnerXml; MyEventSubScheduleNode.PrependChild(xmldoc.CreateElement("MiscData")); MyEventSubScheduleNode.ChildNodes[0].InnerXml = createMiscDataNode(MySubEvent.Notes, "MiscData").InnerXml; return MyEventSubScheduleNode; }
string SubCalendarEventToString(SubCalendarEvent arg1,string NameOfEvent,string CalendarID) { /* * This funciton takes a non repeat CalendarEvent and converts it to a JSON formatted string; */ string IDString="\""+arg1.ID+"\""; string SubCalTotalString = ""; string SubCalCalendarName = "\"" + NameOfEvent + "\""; string SubCalStartDate = "\"" + arg1.Start.ToString() + "\""; string SubCalEndDate = "\"" + arg1.End.ToString() + "\""; string SubCalTotalDuration = "\"" + arg1.ActiveDuration.ToString() + "\""; string SubCalRigid = "\"" + arg1.Rigid + "\""; string SubCalAddressDescription = "\"" + arg1.myLocation.Description + "\""; string SubCalAddress = "\"" + arg1.myLocation.Address + "\""; string SubCalCalEventStart = "\"" + arg1.getCalendarEventRange.Start + "\""; string SubCalCalEventEnd = "\"" + arg1.getCalendarEventRange.End + "\""; string SubCalEventLong = "\"" + arg1.myLocation.YCoordinate+ "\""; string SubCalEventLat = "\"" + arg1.myLocation.XCoordinate + "\""; CalendarID = "\"" + CalendarID + "\""; SubCalTotalString = "{\"ID\":" + IDString + ",\"CalendarID\":" + CalendarID + ",\"SubCalCalendarName\":" + SubCalCalendarName + ",\"SubCalStartDate\":" + SubCalStartDate + ",\"SubCalEndDate\":" + SubCalEndDate + ",\"SubCalTotalDuration\":" + SubCalTotalDuration + ",\"SubCalRigid\":" + SubCalRigid + ",\"SubCalAddressDescription\": " + SubCalAddressDescription + ",\"SubCalAddress\":" + SubCalAddress + ",\"SubCalCalEventStart\":" + SubCalCalEventStart + ",\"SubCalCalEventEnd\":" + SubCalCalEventEnd + ",\"SubCalEventLong\":" + SubCalEventLong + ",\"SubCalEventLat\":" + SubCalEventLat + "}"; string retValue = SubCalTotalString; return retValue; }
public SubCalendarEventListCounter(SubCalendarEvent StartingSubCalendarEvent, string ParentID) { this.ParentID = ParentID; ListOfSubCalEvents = new List<SubCalendarEvent>() { StartingSubCalendarEvent }; CurrentIndex = 0; }
public CalendarEvent GenerateRigidSubEvents(CalendarEvent MyCalendarEvent) { int i = 0; List<SubCalendarEvent> MyArrayOfSubEvents = new List<SubCalendarEvent>(); for (; i < MyCalendarEvent.AllEvents.Length; i++) { } if (MyCalendarEvent.RepetitionStatus) { SubCalendarEvent MySubEvent = new SubCalendarEvent(MyCalendarEvent.ActiveDuration, MyCalendarEvent.Repeat.Range.Start, MyCalendarEvent.Repeat.Range.End, MyCalendarEvent.Preparation, MyCalendarEvent.ID,MyCalendarEvent.Rigid, MyCalendarEvent.myLocation, MyCalendarEvent.RangeTimeLine); //new SubCalendarEvent(MyCalendarEvent.End, MyCalendarEvent.Repeat.Range.Start, MyCalendarEvent.Repeat.Range.End, MyCalendarEvent.Preparation, MyCalendarEvent.ID); for (; MySubEvent.Start < MyCalendarEvent.Repeat.Range.End; ) { MyArrayOfSubEvents.Add(MySubEvent); switch (MyCalendarEvent.Repeat.Frequency) { case "DAILY": { MySubEvent = new SubCalendarEvent(MyCalendarEvent.ActiveDuration, MyCalendarEvent.Repeat.Range.Start.AddDays(1), MyCalendarEvent.Repeat.Range.End.AddDays(1), MyCalendarEvent.Preparation, MyCalendarEvent.ID,MyCalendarEvent.Rigid, MyCalendarEvent.myLocation, MyCalendarEvent.RangeTimeLine); break; } case "WEEKLY": { MySubEvent = new SubCalendarEvent(MyCalendarEvent.ActiveDuration, MyCalendarEvent.Repeat.Range.Start.AddDays(7), MyCalendarEvent.Repeat.Range.End.AddDays(7), MyCalendarEvent.Preparation, MyCalendarEvent.ID, MyCalendarEvent.Rigid, MyCalendarEvent.myLocation, MyCalendarEvent.RangeTimeLine); break; } case "BI-WEEKLY": { MySubEvent = new SubCalendarEvent(MyCalendarEvent.ActiveDuration, MyCalendarEvent.Repeat.Range.Start.AddDays(14), MyCalendarEvent.Repeat.Range.End.AddDays(14), MyCalendarEvent.Preparation, MyCalendarEvent.ID, MyCalendarEvent.Rigid, MyCalendarEvent.myLocation, MyCalendarEvent.RangeTimeLine); break; } case "MONTHLY": { MySubEvent = new SubCalendarEvent(MyCalendarEvent.ActiveDuration, MyCalendarEvent.Repeat.Range.Start.AddMonths(1), MyCalendarEvent.Repeat.Range.End.AddMonths(1), MyCalendarEvent.Preparation, MyCalendarEvent.ID, MyCalendarEvent.Rigid, MyCalendarEvent.myLocation, MyCalendarEvent.RangeTimeLine); break; } case "YEARLY": { MySubEvent = new SubCalendarEvent(MyCalendarEvent.ActiveDuration, MyCalendarEvent.Repeat.Range.Start.AddYears(1), MyCalendarEvent.Repeat.Range.End.AddYears(1), MyCalendarEvent.Preparation, MyCalendarEvent.ID, MyCalendarEvent.Rigid, MyCalendarEvent.myLocation, MyCalendarEvent.RangeTimeLine); break; } } } } return MyCalendarEvent; // }
public bool UpdateThis(SubCalendarEvent SubEventEntry) { if ((this.ID == SubEventEntry.ID)&&canExistWithinTimeLine(SubEventEntry.getCalendarEventRange)) { StartDateTime= SubEventEntry.Start; EndDateTime= SubEventEntry.End; BusyFrame.updateBusyTimeLine(SubEventEntry.BusyFrame); AvailablePreceedingFreeSpace = SubEventEntry.AvailablePreceedingFreeSpace; RigidSchedule = SubEventEntry.Rigid; CalendarEventRange = SubEventEntry.CalendarEventRange; EventLocation = SubEventEntry.LocationData; Enabled = SubEventEntry.Enabled; ThirdPartyID = SubEventEntry.ThirdPartyID; return true; } throw new Exception("Error Detected: Trying to update SubCalendar Event with non matching ID"); }
} // GenerateRandomMemoryMatrix() public SubCalendarEvent[] GenerateNeighborMemoryMatrix(SubCalendarEvent[] memoryMatrix) { SubCalendarEvent[] result = new SubCalendarEvent[memoryMatrix.Length]; Array.Copy(memoryMatrix, result, memoryMatrix.Length); int Beginning = 0; int End = result.Length; switch (BeginningAndEnd) { case 1://must Beginning with City { Beginning = 1; End = result.Length; } break; case 2://must End with City { Beginning = 0; End = result.Length-1; } break; case 3://must end and Begin with Cities { Beginning = 1; End = result.Length-1; } break; default: { Beginning = 0; End = result.Length; } break; } int ranIndex = random.Next(Beginning, End); // [0, Length-1] inclusive int adjIndex; if (ranIndex == End - 1) adjIndex = Beginning; else adjIndex = ranIndex + 1; SubCalendarEvent tmp = result[ranIndex]; result[ranIndex] = result[adjIndex]; result[adjIndex] = tmp; return result; } // GenerateNeighborMemoryMatrix()
static public double AverageToAllNodes(SubCalendarEvent MySubEvents, List<SubCalendarEvent> allSubCalEvents, Dictionary<string, List<Double>> DistanceMatrix) { double retValue = 0; List<string> AllIds = allSubCalEvents.Select(obj => obj.SubEvent_ID.getLevelID(0)).ToList(); List<string> Allkeys = DistanceMatrix.Keys.ToList(); string iIndex = MySubEvents.SubEvent_ID.getLevelID(0); int i = 0; while (i < allSubCalEvents.Count) { string jIndex = AllIds[i]; int valueIndexofkeyValuePair = Allkeys.IndexOf(jIndex); double increment = DistanceMatrix[iIndex][valueIndexofkeyValuePair]; retValue += increment; i++; } retValue /= allSubCalEvents.Count; return retValue; }
private SubCalendarEvent AssignSubEventTimeSlot(SubCalendarEvent MySubEvent) { BusyTimeLine[] ArrayOfInvadingEvents = CheckIfMyRangeAlreadyHasSchedule(CompleteSchedule.OccupiedSlots, MySubEvent); TimeLine[] AvailableFreeSpots = getAllFreeSpots(new TimeLine(MySubEvent.Start, MySubEvent.End)); for (int i = 0; i < AvailableFreeSpots.Length; i++) { if (AvailableFreeSpots[i].TimelineSpan > (MySubEvent.ActiveDuration)) { DateTime DurationStartTime; TimeSpan MyTimeSpan = new TimeSpan((((AvailableFreeSpots[i].TimelineSpan - MySubEvent.ActiveDuration).Milliseconds) / 2) * 10000); DurationStartTime = AvailableFreeSpots[i].Start.Add(MyTimeSpan); MySubEvent.ActiveSlot = new BusyTimeLine(MySubEvent.ID, DurationStartTime, DurationStartTime.Add(MySubEvent.ActiveDuration)); } } return MySubEvent; }
} // TravelingSalesmanHive ctor public SubCalendarEvent[] GenerateRandomMemoryMatrix() { SubCalendarEvent[] result = new SubCalendarEvent[this.citiesData.cities.Length]; // // problem-specific //Dictionary<string, int> DictCount = new Dictionary<string, int>(); Dictionary<string, List<SubCalendarEvent>> DictCities = new Dictionary<string, List<SubCalendarEvent>>(); for (int j = 0; j < this.citiesData.cities.Length; j++) { if (DictCities.ContainsKey(this.citiesData.cities[j].SubEvent_ID.getLevelID(0))) { //++DictCount[this.citiesData.cities[j].SubEvent_ID.getLevelID(0)]; DictCities[this.citiesData.cities[j].SubEvent_ID.getLevelID(0)].Add(this.citiesData.cities[j]); } else { //DictCount.Add(this.citiesData.cities[j].SubEvent_ID.getLevelID(0), 1); DictCities.Add(this.citiesData.cities[j].SubEvent_ID.getLevelID(0), new List<SubCalendarEvent>() { this.citiesData.cities[j] }); } } int resultIndex = 0; int MaxResultIndex=this.citiesData.cities.Length; switch (BeginningAndEnd) { case 1://must Beginning with City { result[0] = this.citiesData.cities[0]; string ConcernedIndex = result[0].SubEvent_ID.getLevelID(0); DictCities[ConcernedIndex].Remove(result[0]); if (DictCities[ConcernedIndex].Count < 1) { DictCities.Remove(ConcernedIndex); } resultIndex=1; } break; case 2://must End with City { result[this.citiesData.cities.Length - 1] = this.citiesData.cities[this.citiesData.cities.Length - 1]; string ConcernedIndex = result[this.citiesData.cities.Length - 1].SubEvent_ID.getLevelID(0); DictCities[ConcernedIndex].Remove(result[this.citiesData.cities.Length - 1]); if (DictCities[ConcernedIndex].Count < 1) { DictCities.Remove(ConcernedIndex); } MaxResultIndex-=1; } break; case 3://must end and Begin with Cities { result[0] = this.citiesData.cities[0]; resultIndex=1; result[this.citiesData.cities.Length - 1] = this.citiesData.cities[this.citiesData.cities.Length - 1]; MaxResultIndex-=1; string ConcernedIndex=result[0].SubEvent_ID.getLevelID(0); DictCities[ConcernedIndex].Remove(result[0]); if (DictCities[ConcernedIndex].Count < 1) { DictCities.Remove(ConcernedIndex); } ConcernedIndex = result[this.citiesData.cities.Length - 1].SubEvent_ID.getLevelID(0); DictCities[ConcernedIndex].Remove(result[this.citiesData.cities.Length - 1]); if (DictCities[ConcernedIndex].Count < 1) { DictCities.Remove(ConcernedIndex); } } break; default: { ; } break; } List<string> AllNodeNames = DictCities.Keys.ToList(); List<string> ResultName = new List<string>(); while (resultIndex < MaxResultIndex) { for (int i = 0; i < AllNodeNames.Count; i++) // Fisher-Yates (Knuth) shuffle { int r = random.Next(i, AllNodeNames.Count); SubCalendarEvent temp; if (DictCities[AllNodeNames[r]].Count > 0) { string sTemp = AllNodeNames[r]; AllNodeNames[r] = AllNodeNames[i]; AllNodeNames[i] = sTemp; temp = DictCities[sTemp][0]; DictCities[sTemp].RemoveAt(0); result[resultIndex++] = temp; //result[i] = temp; if (DictCities[sTemp].Count < 1) { DictCities.Remove(sTemp); AllNodeNames.Remove(sTemp); --i; } } else { ; } /*//SubCalendarEvent temp = result[r]; result[r] = result[i]; result[i] = temp;*/ } } /* Array.Copy(this.citiesData.cities, result, this.citiesData.cities.Length); for (int i = 0; i < result.Length; i++) // Fisher-Yates (Knuth) shuffle { int r = random.Next(i, result.Length); SubCalendarEvent temp = result[r]; result[r] = result[i]; result[i] = temp; }*/ return result; } // GenerateRandomMemoryMatrix()
/*public ClumpSubCalendarEvent(List<SubCalendarEvent> BaseClump, List<SubCalendarEvent> Appendables, TimeLine BoundaryTimeLine) { int i = 0; NonOverLapping_Clump = new List<ClumpSubCalendarEvent>(); OverLapping_Clump = new List<ClumpSubCalendarEvent>(); List<SubCalendarEvent> UnClumppable = new List<SubCalendarEvent>(); if (BaseClump.Count < 1) { if (Appendables.Count > 0) { Appendables = Appendables.OrderBy(obj => obj.getCalendarEventRange.End).ToList(); SubCalendarEvent RelativeSubEvent = Appendables[0]; Appendables.Remove(Appendables[0]); ClumpSubCalendarEvent myThis = new ClumpSubCalendarEvent(RelativeSubEvent, Appendables, BoundaryTimeLine); NonOverLapping_Clump = myThis.NonOverLapping_Clump; BaseEvent = myThis.BaseEvent; NonOverLapping_Clump = myThis.NonOverLapping_Clump; OverLapping_Clump = myThis.OverLapping_Clump; ReferenceStartTime = myThis.ReferenceStartTime; SubCalEventsOverLapWithBase = myThis.SubCalEventsOverLapWithBase; BreakOffClump = myThis.BreakOffClump; } } else { BaseEvent = BaseClump[0];//this can be reevaluated to cater to the most constrained. i.e the one with limted a later sart time and percentage fill for whatever is left. ReferenceStartTime = BaseEvent.getCalendarEventRange.End < BoundaryTimeLine.End ? BaseEvent.getCalendarEventRange.End : BoundaryTimeLine.End; foreach (SubCalendarEvent mySubCalendarEvent in BaseClump) { ReferenceStartTime -= BaseEvent.ActiveDuration; } for (; i < Appendables.Count; i++) { List<SubCalendarEvent> ReferenceClump = new List<SubCalendarEvent>(BaseClump); DateTime TimeLimit = ReferenceStartTime - Appendables[i].ActiveDuration; bool Zero = (Appendables[i].getCalendarEventRange.Start <= TimeLimit); bool One = (TimeLimit >= BoundaryTimeLine.Start); //bool Two = (BoundaryTimeLine.TimelineSpan >= Appendables[i].EventTimeLine.TimelineSpan); if (Zero && One)// && Two) { List<SubCalendarEvent> Removed_Unnecessary = Appendables.ToList(); List<SubCalendarEvent> ExtendedList = ReferenceClump.ToList(); Removed_Unnecessary.Remove(Appendables[i]); ExtendedList.Add((Appendables[i])); ClumpSubCalendarEvent NewClump = new ClumpSubCalendarEvent(ExtendedList, Removed_Unnecessary, BoundaryTimeLine); NonOverLapping_Clump.Add(NewClump); if (CompleteResolvedNonOverlapping.Count > 100)//This is a hack to resolve the memory issue { break; } } else { SubCalEventsOverLapWithBase.Add(Appendables[i]); } if (SubCalEventsOverLapWithBase.Count > 0) { SubCalendarEvent BreakOffSubCalEvent = SubCalEventsOverLapWithBase[0]; SubCalEventsOverLapWithBase.Remove(BreakOffSubCalEvent); BreakOffClump = new ClumpSubCalendarEvent(BreakOffSubCalEvent, SubCalEventsOverLapWithBase, new TimeLine((getLeftMostPossibleStartLine(BaseEvent, BoundaryTimeLine) + BaseEvent.ActiveDuration), BoundaryTimeLine.End)); } } } }*/ DateTime getLeftMostPossibleStartLine(SubCalendarEvent Sorted, TimeLine Boundary) { if (Boundary.Start >= Sorted.getCalendarEventRange.Start) { return new DateTime(Boundary.Start.Ticks); } else { return new DateTime(Sorted.getCalendarEventRange.Start.Ticks); } }
} // GenerateNeighborMemoryMatrix() public double MeasureOfQuality(SubCalendarEvent[] memoryMatrix) { double answer = 0.0; for (int i = 0; i < memoryMatrix.Length - 1; ++i) { SubCalendarEvent c1 = memoryMatrix[i]; SubCalendarEvent c2 = memoryMatrix[i + 1]; double d = this.citiesData.Distance(c1, c2); answer += d; } return answer; } // MeasureOfQuality()
ClumpSubCalendarEvent populateClumpedResults(DateTime BaseEndTime,SubCalendarEvent refSubCalendarEvent, ClumpSubCalendarEvent refClumpSubCalendarEvent, DateTime RefereceStartTime, TimeLine BoundaryTimeLine) { List<SubCalendarEvent> Arg1 = ClumpedResults.Keys.ToList(); bool temp = Arg1.Remove(refSubCalendarEvent); refClumpSubCalendarEvent = new ClumpSubCalendarEvent(RefereceStartTime,BaseEndTime, Arg1, BoundaryTimeLine); return refClumpSubCalendarEvent; }
public Coordinate(int name, SubCalendarEvent MyEvent) { Name = name; Event = MyEvent; ID = MyEvent.SubEvent_ID.getStringIDAtLevel(0); }
public ClumpSubCalendarEvent(SubCalendarEvent BaseSubCalendarEvent, List<SubCalendarEvent> Appendables, TimeLine BoundaryTimeLine) { SubCalEventsOverLapWithBase = new List<SubCalendarEvent>(); BaseEvent = BaseSubCalendarEvent; DateTime var1 = BaseEvent.getCalendarEventRange.End < BoundaryTimeLine.End ? BaseEvent.getCalendarEventRange.End : BoundaryTimeLine.End;//hack assumes base can fit within boundary this.BoundaryTimeLine = new TimeLine(BoundaryTimeLine.Start, var1); DateTime ReferenceStartTime = var1 - BaseEvent.ActiveDuration; BreakOffClump = null; ClumpedResults = new Dictionary<SubCalendarEvent, ClumpSubCalendarEvent>(); int i = 0; for (; i < Appendables.Count; i++) { List<SubCalendarEvent> ReferenceClump = new List<SubCalendarEvent>(); ReferenceClump.Add(BaseSubCalendarEvent); DateTime TimeLimit = ReferenceStartTime - Appendables[i].ActiveDuration; bool Zero = (Appendables[i].getCalendarEventRange.Start <= TimeLimit); bool One = (TimeLimit >= BoundaryTimeLine.Start); //bool Two = (BoundaryTimeLine.TimelineSpan>=Appendables[i].EventTimeLine.TimelineSpan);//this is a hack, since the length of SubcalEvent Event TimeLine is the same length of time as its busy time span if (Zero && One)// && Two) { List<SubCalendarEvent> Removed_Unnecessary = Appendables.ToList(); // List<SubCalendarEvent> ExtendedList = ReferenceClump.ToList(); SubCalendarEvent RelativeSubEvent = Appendables[i]; Removed_Unnecessary.Remove(RelativeSubEvent); // ExtendedList.Add((Appendables[i])); ClumpedResults.Add(RelativeSubEvent, null); //NonOverLapping_Clump.Add(); if (Removed_Unnecessary.Count > 0) { ++Completed; if (Completed >= 100) { break; } } } else { //List<SubCalendarEvent> Removed_Unnecessary = Appendables.ToList(); //List<SubCalendarEvent> ExtendedList = ReferenceClump.ToList(); //Removed_Unnecessary.Remove(Appendables[i]); SubCalEventsOverLapWithBase.Add(Appendables[i]); } } List<SubCalendarEvent> arg1=ClumpedResults.Keys.ToList(); //if(arg1!=null) { int j=0; DateTime BaseReferenceEndTime = BaseEvent.getCalendarEventRange.End > BoundaryTimeLine.End ? BoundaryTimeLine.End : BaseEvent.getCalendarEventRange.End;//End Time for Base to be used as the reference for the current base end time for (;j<arg1.Count;j++) { ClumpedResults[arg1[j]] = populateClumpedResults(BaseReferenceEndTime, arg1[j], ClumpedResults[arg1[j]], ReferenceStartTime - arg1[j].ActiveDuration, BoundaryTimeLine); } } if (SubCalEventsOverLapWithBase.Count > 0) { SubCalendarEvent BreakOffSubCalEvent = SubCalEventsOverLapWithBase[0]; SubCalEventsOverLapWithBase.Remove(BreakOffSubCalEvent); BreakOffClump = new ClumpSubCalendarEvent(BreakOffSubCalEvent, SubCalEventsOverLapWithBase, new TimeLine((getLeftMostPossibleStartLine(BaseEvent, BoundaryTimeLine) + BaseEvent.ActiveDuration), BoundaryTimeLine.End)); } List<SubCalendarEvent> Fittable = new List<SubCalendarEvent>(); }
virtual public bool updateSubEvent(EventID SubEventID,SubCalendarEvent UpdatedSubEvent) { if (this.RepetitionStatus) { foreach (CalendarEvent MyCalendarEvent in Repeat.RecurringCalendarEvents) { if (MyCalendarEvent.updateSubEvent(SubEventID, UpdatedSubEvent)) { return true; } } } else { int i = 0; for (i = 0; i < ArrayOfSubEvents.Length;i++) { if (ArrayOfSubEvents[i].ID == SubEventID.ToString()) { SubCalendarEvent NewSubCalEvent = new SubCalendarEvent(UpdatedSubEvent.ID, UpdatedSubEvent.Start, UpdatedSubEvent.End, UpdatedSubEvent.ActiveSlot, UpdatedSubEvent.Rigid, UpdatedSubEvent.myLocation, this.RangeTimeLine); string thirdPartyID = ArrayOfSubEvents[i].ThirdPartyID; ArrayOfSubEvents[i] = NewSubCalEvent; ArrayOfSubEvents[i].ThirdPartyID = thirdPartyID; return true; } } } return false; }
public static double CalculateDistance(SubCalendarEvent Arg1,SubCalendarEvent Arg2) { if(Arg1.SubEvent_ID.getStringIDAtLevel(0)==Arg1.SubEvent_ID.getStringIDAtLevel(0)) { return double.MaxValue; } else { return Location.calculateDistance(Arg1.myLocation,Arg2.myLocation); } }
public CalendarEvent(CalendarEvent MyUpdated, SubCalendarEvent[] MySubEvents) { CalendarEventName = MyUpdated.Name; StartDateTime = MyUpdated.StartDateTime; EndDateTime = MyUpdated.End; EventSequence = new TimeLine(StartDateTime, EndDateTime); EventDuration = MyUpdated.ActiveDuration; Splits = MyUpdated.Splits; PrepTime = MyUpdated.PrepTime; EventPreDeadline = MyUpdated.PreDeadline; RigidSchedule = MyUpdated.Rigid; TimePerSplit = MyUpdated.TimePerSplit; ArrayOfSubEvents = new SubCalendarEvent[Splits]; if (MyUpdated.ID != null) { CalendarEventID = new EventID(MyUpdated.ID.Split('_')); } //CalendarEventID = new EventID(new string[] { EventIDGenerator.generate().ToString() }); //ArrayOfSubEvents = generateSubEvent(ArrayOfSubEvents, 4, EventDuration, CalendarEventID.ToString()); ArrayOfSubEvents = MySubEvents; SchedulStatus = false; EventRepetition = MyUpdated.Repeat; LocationData = MyUpdated.LocationData; UpdateLocationMatrix(LocationData); EventSequence = new TimeLine(StartDateTime, EndDateTime); //EventRepetition = new Repetition(EventRepetition.Enable, this, EventRepetition.Range, EventRepetition.Frequency); }
public static int CompareByEndDate(SubCalendarEvent SubCalendarEvent1, SubCalendarEvent SubCalendarEvent2) { return SubCalendarEvent1.End.CompareTo(SubCalendarEvent2.End); }