public StateContext(IStateMachine machine, IStateDiagram <TKey, TValue> diagram, TKey key, StateVector <TValue> state, string description)
{
this.Machine = machine ?? throw new ArgumentNullException(nameof(machine));
this.Diagram = diagram ?? throw new ArgumentNullException(nameof(diagram));
this.Key = key;
this.State = state;
this.Description = description;
this.Parameters = new ParameterCollection(machine);
}
public ServiceCallFunction(
HttpRequestMessageRunner runner,
IServiceResolver serviceResolver,
IHttpDataSerializer serializer,
ISerializationSchema serializationSchema,
IStateDiagram stateDiagram,
IChainedServiceResolver chainedServiceResolver,
TelemetryClient telemetryClient)
: base(runner, serviceResolver, serializer, serializationSchema, chainedServiceResolver, stateDiagram, telemetryClient)
{
}
protected State(IStateDiagram diagram, DateTime?timestamp, string description = null)
{
if (diagram == null)
{
throw new ArgumentNullException(nameof(diagram));
}
_diagram = diagram;
_timestamp = timestamp;
_description = description;
}
protected State(IStateDiagram diagram)
{
if (diagram == null)
{
throw new ArgumentNullException(nameof(diagram));
}
_diagram = diagram;
_timestamp = DateTime.Now;
_description = null;
}
public LinksFunctions(
HttpRequestMessageRunner runner,
IServiceResolver serviceResolver,
IHttpDataSerializer httpDataSerializer,
ISerializationSchema serializationSchema,
IChainedServiceResolver chainedServiceResolver,
IStateDiagram stateDiagram,
TelemetryClient telemetryClient) : base(runner, serviceResolver, httpDataSerializer, serializationSchema, chainedServiceResolver, stateDiagram, telemetryClient)
{
_runner = runner;
_serviceResolver = serviceResolver;
_telemetryClient = telemetryClient;
}
protected ServiceCallFunctionBase(HttpRequestMessageRunner runner,
IServiceResolver serviceResolver,
IHttpDataSerializer serializer,
ISerializationSchema serializationSchema,
IChainedServiceResolver chainedServiceResolver,
IStateDiagram stateDiagram,
TelemetryClient telemetryClient)
{
_runner = runner;
_serviceResolver = serviceResolver;
_serializer = serializer;
_serializationSchema = serializationSchema;
_chainedServiceResolver = chainedServiceResolver;
_telemetryClient = telemetryClient;
_stateDiagram = stateDiagram;
}
public IEnumerable <Instance> GenerateInstances(Prescription prescription, string prescriptionPath)
{
this.prescription = prescription;
this.specializedPrescription = JObject
.FromObject(prescription.SpecializedPrescription)
.ToObject <SpecializedPrescription>();
this.random = this.prescription.RandomSeed.HasValue ?
new Random(this.prescription.RandomSeed.Value) : new Random();
foreach (var stateDiagramKind in this.specializedPrescription.StateDiagrams)
{
IStateDiagram stateDiagram = null;
switch (stateDiagramKind)
{
case StateDiagramKind.Aghelinejad2017a:
stateDiagram = new StateDiagrams.Aghelinejad2017a();
break;
case StateDiagramKind.Benedikt2020aTwosby:
stateDiagram = new StateDiagrams.Benedikt2020aTwosby();
break;
}
foreach (var repetition in Enumerable.Range(0, this.prescription.RepetitionsCount))
{
foreach (var jobsCount in this.specializedPrescription.JobsCounts)
{
foreach (var maxProcessingTime in this.specializedPrescription.MaxProcessingTime)
{
foreach (var instance in this.GenerateInstances(
repetition: repetition,
jobsCount: jobsCount,
maxProcessingTime: maxProcessingTime,
stateDiagram: stateDiagram))
{
yield return(instance);
}
}
}
}
}
}
protected State(IStateDiagram <TKey, TValue> diagram, TKey key, TValue value)
{
this.Diagram = diagram ?? throw new ArgumentNullException(nameof(diagram));
this.Key = key;
this.Value = value;
}
public IEnumerable <Instance> GenerateInstances(
int repetition,
int jobsCount,
int maxProcessingTime,
IStateDiagram stateDiagram)
{
var jobs = new List <Job>();
foreach (var jobIndex in Enumerable.Range(0, jobsCount))
{
var processingTime = this.random.Next(1, maxProcessingTime + 1);
jobs.Add(new Job(
jobIndex,
jobIndex,
0,
processingTime));
}
// Generate all costs.
var maxHorizonMultiplier = this.specializedPrescription.HorizonMultipliers.Max();
int maxAvailableTime = (int)Math.Ceiling(jobs.Sum(job => job.ProcessingTime) * maxHorizonMultiplier);
int minNonProcessingTime = 1 + stateDiagram.OffOnTime[0] + stateDiagram.OnOffTime[0] + 1;
var allEnergyCosts = Enumerable
.Range(0, maxAvailableTime + minNonProcessingTime)
.Select(_ => this.random.Next(1, this.specializedPrescription.MaxEnergyCost + 1))
.ToArray();
foreach (var horizonMultiplier in this.specializedPrescription.HorizonMultipliers)
{
int availableTime = (int)Math.Ceiling(jobs.Sum(job => job.ProcessingTime) * horizonMultiplier);
var intervals = Enumerable
.Range(0, availableTime + minNonProcessingTime)
.Select(intervalIdx =>
new Interval(intervalIdx, LengthInterval * intervalIdx, LengthInterval * (intervalIdx + 1), allEnergyCosts[intervalIdx]))
.ToArray();
var metadata = new {
repetition,
jobsCount,
horizonMultiplier,
intervalsCount = intervals.Length,
stateDiagram = stateDiagram.GetType().Name
};
yield return(new Instance(
machinesCount: 1,
jobs: jobs.ToArray(),
intervals: intervals,
lengthInterval: LengthInterval,
offOnTime: stateDiagram.OffOnTime,
onOffTime: stateDiagram.OnOffTime,
offOnPowerConsumption: stateDiagram.OffOnPowerConsumption,
onOffPowerConsumption: stateDiagram.OnOffPowerConsumption,
offIdleTime: stateDiagram.OffIdleTime,
idleOffTime: stateDiagram.IdleOffTime,
offIdlePowerConsumption: stateDiagram.OffIdlePowerConsumption,
idleOffPowerConsumption: stateDiagram.IdleOffPowerConsumption,
onPowerConsumption: stateDiagram.OnPowerConsumption,
idlePowerConsumption: stateDiagram.IdlePowerConsumption,
offPowerConsumption: stateDiagram.OffPowerConsumption,
metadata: metadata));
}
}