//manar
public Enums.DayType gettypeofnewsdays(int rnum)
{
Enums.DayType daytype = Enums.DayType.Good;
int size = this.DayTypeDistributions.Count;
bool found;
for (int i = 0; i < size; i++)
{
int range = this.DayTypeDistributions[i].MinRange;
found = false;
int mx = this.DayTypeDistributions[i].MaxRange;
if (mx == 0)
{
mx = 100;
}
while (range <= mx)
{
if (rnum == range)
{
daytype = this.DayTypeDistributions[i].DayType;
found = true;
break;
}
++range;
}
if (found == true)
{
break;
}
} //endfor
return(daytype);
} //end
} //end
public int getdemand(int rnum, Enums.DayType newsdatatype)
{
int demand = 0,
size = this.DemandDistributions.Count,
ind = (int)newsdatatype;
bool found;
for (int i = 0; i < size; i++)
{
int range = this.DemandDistributions[i].DayTypeDistributions[ind].MinRange;
found = false;
int mx = this.DemandDistributions[i].DayTypeDistributions[ind].MaxRange;
if (mx == 0)
{
mx = 100;
}
while (range <= mx)
{
if (rnum == range)
{
demand = this.DemandDistributions[i].Demand;
found = true;
break;
}
++range;
}
if (found == true)
{
break;
}
} //endfor
return(demand);
} //end
//OPERATION
Enums.DayType GetDayType(int Entry)
{
Enums.DayType Out = new Enums.DayType();
foreach (DayTypeDistribution DTD in DayTypeDistributions)
{
if (Entry <= DTD.MaxRange && Entry >= DTD.MinRange)
{
Out = DTD.DayType;
}
}
return(Out);
}
private int GetDemand(int rand, Enums.DayType dayType)
{
for (int i = 0; i < DemandDistributions.Count; i++)
{
var temp = DemandDistributions[i].DayTypeDistributions.Find(x => x.DayType == dayType);
if (rand >= temp.MinRange && rand <= temp.MaxRange)
{
return(DemandDistributions[i].Demand);
}
}
return(rand);
}
public int get_demand(int ran, Enums.DayType da)
{
for (int i = 0; i < DemandDistributions.Count; i++)
{
for (int j = 0; j < DemandDistributions[i].DayTypeDistributions.Count; j++)
{
if (DemandDistributions[i].DayTypeDistributions[j].MinRange <= ran && DemandDistributions[i].DayTypeDistributions[j].MaxRange >= ran && DemandDistributions[i].DayTypeDistributions[j].DayType == da)
{
return(DemandDistributions[i].Demand);
}
}
}
return(0);
}
int getDemand(Enums.DayType DT, int randomNum)
{
int index = (int)DT;
for (int i = 0; i < DemandDistributions.Count; i++)
{
if (DemandDistributions[i].DayTypeDistributions[index].MinRange <= randomNum && DemandDistributions[i].DayTypeDistributions[index].MaxRange >= randomNum)
{
index = i;
break;
}
}
return(DemandDistributions[index].Demand);
}
public void setter(Enums.DayType DT, double P, ref double cumSum, ref int minRange)
{
this.DayType = DT;
this.Probability = P;
cumSum += P;
this.CummProbability = cumSum;
this.MinRange = minRange;
this.MaxRange = int.Parse((cumSum * 100).ToString());
minRange = this.MaxRange + 1;
if (cumSum == 1)
{
this.MaxRange = 0;
minRange = 0;
}
}
int GetDemand(int Entry, Enums.DayType DTE)
{
int Out = -1;
foreach (DemandDistribution DD in DemandDistributions)
{
if (DD.DayTypeDistributions[(int)DTE].MaxRange >= Entry && DD.DayTypeDistributions[(int)DTE].MinRange <= Entry)
{
Out = DD.Demand;
break;
}
}
if (Out == -1)
{
throw new Exception("Warning demand distrubution didn't match any of the known ranges!");
}
return(Out);
}
public async Task <ServiceResponse <GetDeparturesDTO> > GetDepartures(string dayType, int lineId)
{
ServiceResponse <GetDeparturesDTO> response = new ServiceResponse <GetDeparturesDTO>();
Enums.DayType day = (Enums.DayType)Enum.Parse(typeof(Enums.DayType), dayType);
//Enums.LineType line = (Enums.LineType) Enum.Parse(typeof(Enums.LineType), lineType);
List <DepartureDTO> departures = new List <DepartureDTO>();
try
{
Timetable timetable = await _context.Timetables
.Include(t => t.Departures)
.FirstOrDefaultAsync(t => t.Active == true && t.DayType == day && t.LineId == lineId);
if (timetable != null)
{
foreach (var departure in timetable.Departures)
{
departures.Add(new DepartureDTO
{
Id = departure.Id,
// Removing the date part
Time = departure.Time.ToString().Split(' ')[1].Substring(0, 5)
}
);
}
departures.OrderByDescending(d => d.Time);
response.Data = new GetDeparturesDTO {
TimetableId = timetable.Id, Departures = departures
};
}
else
{
response.Success = false;
response.Message = "Timetable not found.";
}
}
catch (Exception e)
{
response.Success = false;
response.Message = e.Message;
}
return(response);
}
public static int demand(int number, Enums.DayType type, List <DemandDistribution> distribution)
{
int x = 0;
if (type == Enums.DayType.Good)
{
for (int i = 0; i < distribution.Count; ++i)
{
if (number >= distribution[i].DayTypeDistributions[0].MinRange && number <= distribution[i].DayTypeDistributions[0].MaxRange)
{
return(distribution[i].Demand);
}
}
}
else if (type == Enums.DayType.Fair)
{
for (int i = 0; i < distribution.Count; ++i)
{
if (number >= distribution[i].DayTypeDistributions[1].MinRange && number <= distribution[i].DayTypeDistributions[1].MaxRange)
{
return(distribution[i].Demand);
}
}
}
else if (type == Enums.DayType.Poor)
{
for (int i = 0; i < distribution.Count; ++i)
{
if (number >= distribution[i].DayTypeDistributions[2].MinRange && number <= distribution[i].DayTypeDistributions[2].MaxRange)
{
return(distribution[i].Demand);
}
}
}
return(x);
}
public List <DemandDistribution> demandFill(List <int> D, List <double> P1, List <double> P2, List <double> P3, Enums.DayType DT1, Enums.DayType DT2, Enums.DayType DT3)
{
List <DemandDistribution> res = new List <DemandDistribution>();
int count = D.Count;
double c1, c2, c3 = c2 = c1 = 0;
int min1, min2, min3 = min2 = min1 = 1;
for (int i = 0; i < count; i++)
{
DemandDistribution item = new DemandDistribution();
item.Demand = D[i];
DayTypeDistribution d1 = new DayTypeDistribution(), d2 = new DayTypeDistribution(), d3 = new DayTypeDistribution();
//fill d1
d1.setter(DT1, P1[i], ref c1, ref min1);
item.DayTypeDistributions.Add(d1);
//fill d2
d2.setter(DT2, P2[i], ref c2, ref min2);
item.DayTypeDistributions.Add(d2);
//fill d3
d3.setter(DT3, P3[i], ref c3, ref min3);
item.DayTypeDistributions.Add(d3);
res.Add(item);
}
if (c1 != 1)
{
invalidprob[0] = true;
}
if (c2 != 1)
{
invalidprob[1] = true;
}
if (c3 != 1)
{
invalidprob[2] = true;
}
return((c1 != 1 || c2 != 1 || c3 != 1) ? null : res);
}
private void demandFill_Click(object sender, EventArgs e)
{
Program.f1.s.DemandDistributions.Clear();
List <int> D = new List <int>();
List <double> P1 = new List <double>(), P2 = new List <double>(), P3 = new List <double>();
Enums.DayType DT11 = Enums.DayType.Good, DT2 = Enums.DayType.Fair, DT3 = Enums.DayType.Poor;
for (int i = 0; i < dgv_d.Rows.Count - 1; ++i)
{
string val;
if (dgv_d.Rows[i].Cells["dDemand"].Value != null)
{
val = dgv_d.Rows[i].Cells["dDemand"].Value.ToString();
if (Program.f1.s.isNum(val) == true)
{
D.Add(int.Parse(val));
}
else
{
MessageBox.Show("Invalid Demand Cell " + (i + 1).ToString() + " in Demand Distro.", "Caution", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
if (dgv_d.Rows[i].Cells["dGoodProb"].Value != null)
{
val = dgv_d.Rows[i].Cells["dGoodProb"].Value.ToString();
if (Program.f1.s.isNum(val) == true)
{
P1.Add(double.Parse(val));
}
else
{
MessageBox.Show("Invalid Good Probability Cell " + (i + 1).ToString() + " in Demand Distro.", "Caution", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
if (dgv_d.Rows[i].Cells["dFairProb"].Value != null)
{
val = dgv_d.Rows[i].Cells["dFairProb"].Value.ToString();
if (Program.f1.s.isNum(val) == true)
{
P2.Add(double.Parse(val));
}
else
{
MessageBox.Show("Invalid Fair Probability Cell " + (i + 1).ToString() + " in Demand Distro.", "Caution", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
if (dgv_d.Rows[i].Cells["dPoorProb"].Value != null)
{
val = dgv_d.Rows[i].Cells["dPoorProb"].Value.ToString();
if (Program.f1.s.isNum(val) == true)
{
P3.Add(double.Parse(val));
}
else
{
MessageBox.Show("Invalid Fair Probability Cell " + (i + 1).ToString() + " in Demand Distro.", "Caution", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
while (P1.Count < D.Count)
{
P1.Add(0);
}
while (P2.Count < D.Count)
{
P2.Add(0);
}
while (P3.Count < D.Count)
{
P3.Add(0);
}
if (D.Count < P1.Count || D.Count < P2.Count || D.Count < P3.Count)
{
MessageBox.Show("Error,Probability Fields with no Demands matched fields!\nAdd the incomplete Demands", "Caution", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
List <DemandDistribution> d = new List <DemandDistribution>();
d = Program.f1.s.demandFill(D, P1, P2, P3, DT11, DT2, DT3);
if (d == null)
{
//Good Wrong Cumulative Sum
if (Program.f1.s.invalidprob[0] == true)
{
MessageBox.Show("Probability Input for Good Days Invalid!", "Caution", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
//Fair Wrong Cumulative Sum
if (Program.f1.s.invalidprob[1] == true)
{
MessageBox.Show("Probability Input for Fair Days Invalid!", "Caution", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
//Poor Wrong Cumulative Sum
if (Program.f1.s.invalidprob[2] == true)
{
MessageBox.Show("Probability Input for Poor Days Invalid!", "Caution", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
else
{
Program.f1.s.DemandDistributions = d;
dgv_d.Rows.Clear();
//Fill Data Grid View
foreach (DemandDistribution item in d)
{
dgv_d.Rows.Add(
item.Demand,
//Good
item.DayTypeDistributions[0].Probability,
item.DayTypeDistributions[0].CummProbability,
item.DayTypeDistributions[0].MinRange,
item.DayTypeDistributions[0].MaxRange,
//Fair
item.DayTypeDistributions[1].Probability,
item.DayTypeDistributions[1].CummProbability,
item.DayTypeDistributions[1].MinRange,
item.DayTypeDistributions[1].MaxRange,
//Poor
item.DayTypeDistributions[2].Probability,
item.DayTypeDistributions[2].CummProbability,
item.DayTypeDistributions[2].MinRange,
item.DayTypeDistributions[2].MaxRange
);
}
MessageBox.Show(" Done :) ");
}
}
}
public DayTypeDistribution(Enums.DayType DayType, decimal Probability)
{
this.DayType = DayType;
this.Probability = Probability;
}
/// <summary>
/// Calculates the distribution for a given demand distribution
/// </summary>
/// <param name="Distribution">Demand distribution</param>
/// <param name="RandomNumber">A random number between 0 and 99</param>
/// <returns>The desired value that corrisponds to the given random number</returns>
static private int CalculateDistribution(List <DemandDistribution> Distribution, Enums.DayType dayType, int RandomNumber)
{
int j = 0;
while (j < Distribution[0].DayTypeDistributions.Count)
{
if (Distribution[0].DayTypeDistributions[j].DayType == dayType)
{
break;
}
j++;
}
if (j == Distribution[0].DayTypeDistributions.Count)
{
throw new ArgumentException("The given day type doesn't exist");
}
for (int i = 0; i < Distribution.Count; i++)
{
if (CalculateSingleRowDistribution(Distribution[i].DayTypeDistributions[j],
(i == 0) ? null : Distribution[i - 1].DayTypeDistributions[j],
RandomNumber))
{
return(Distribution[i].Demand);
}
}
throw new Exception("Couldn't determine demand value");
}
