public async Task TestBasicNoOptimizerUsageAsync() { // test historic sequence behavior, where the initial values start at 1... var sequence = new SourceMock(1); var optimizer = OptimizerFactory.BuildOptimizer(OptimizerFactory.None, typeof(long), 1, -1); for (int i = 1; i < 11; i++) { long next = (long)await(optimizer.GenerateAsync(sequence, CancellationToken.None)); Assert.That(next, Is.EqualTo(i)); } Assert.That(sequence.TimesCalled, Is.EqualTo(10)); Assert.That(sequence.CurrentValue, Is.EqualTo(10)); // test historic table behavior, where the initial values started at 0 (we now force 1 to be the first used id value) sequence = new SourceMock(0); optimizer = OptimizerFactory.BuildOptimizer(OptimizerFactory.None, typeof(long), 1, -1); for (int i = 1; i < 11; i++) { long next = (long)await(optimizer.GenerateAsync(sequence, CancellationToken.None)); Assert.That(next, Is.EqualTo(i)); } Assert.That(sequence.TimesCalled, Is.EqualTo(11)); // an extra time to get to 1 initially Assert.That(sequence.CurrentValue, Is.EqualTo(10)); }
public async Task TestBasicPooledLoOptimizerUsageAsync() { var sequence = new SourceMock(1, 3); var optimizer = OptimizerFactory.BuildOptimizer(OptimizerFactory.PoolLo, typeof(long), 3, -1); Assert.That(sequence.TimesCalled, Is.EqualTo(0)); Assert.That(sequence.CurrentValue, Is.EqualTo(-1)); var next = (long)await(optimizer.GenerateAsync(sequence, CancellationToken.None)); Assert.That(next, Is.EqualTo(1)); Assert.That(sequence.TimesCalled, Is.EqualTo(1)); Assert.That(sequence.CurrentValue, Is.EqualTo(1)); next = (long)await(optimizer.GenerateAsync(sequence, CancellationToken.None)); Assert.That(next, Is.EqualTo(2)); Assert.That(sequence.TimesCalled, Is.EqualTo(1)); Assert.That(sequence.CurrentValue, Is.EqualTo(1)); next = (long)await(optimizer.GenerateAsync(sequence, CancellationToken.None)); Assert.That(next, Is.EqualTo(3)); Assert.That(sequence.TimesCalled, Is.EqualTo(1)); Assert.That(sequence.CurrentValue, Is.EqualTo(1)); // force a "clock over" next = (long)await(optimizer.GenerateAsync(sequence, CancellationToken.None)); Assert.That(next, Is.EqualTo(4)); Assert.That(sequence.TimesCalled, Is.EqualTo(2)); Assert.That(sequence.CurrentValue, Is.EqualTo(1 + 3)); }
public async Task TestSubsequentPooledLoOptimizerUsageAsync() { // test the pooled optimizer in situation where the sequence is already beyond its initial value on init. // cheat by telling the sequence to start with 1000 var sequence = new SourceMock(1001, 3, 5); // but tell the optimizer the start-with is 1 var optimizer = OptimizerFactory.BuildOptimizer(OptimizerFactory.PoolLo, typeof(long), 3, 1); Assert.That(sequence.TimesCalled, Is.EqualTo(5)); Assert.That(sequence.CurrentValue, Is.EqualTo(1001)); var next = (long)await(optimizer.GenerateAsync(sequence, CancellationToken.None)); Assert.That(next, Is.EqualTo(1001 + 3)); Assert.That(sequence.TimesCalled, Is.EqualTo(5 + 1)); Assert.That(sequence.CurrentValue, Is.EqualTo(1001 + 3)); next = (long)await(optimizer.GenerateAsync(sequence, CancellationToken.None)); Assert.That(next, Is.EqualTo(1001 + 3 + 1)); Assert.That(sequence.TimesCalled, Is.EqualTo(5 + 1)); Assert.That(sequence.CurrentValue, Is.EqualTo(1001 + 3)); next = (long)await(optimizer.GenerateAsync(sequence, CancellationToken.None)); Assert.That(next, Is.EqualTo(1001 + 3 + 2)); Assert.That(sequence.TimesCalled, Is.EqualTo(5 + 1)); Assert.That(sequence.CurrentValue, Is.EqualTo(1001 + 3)); // force a "clock over" next = (long)await(optimizer.GenerateAsync(sequence, CancellationToken.None)); Assert.That(next, Is.EqualTo(1001 + 3 + 3)); Assert.That(sequence.TimesCalled, Is.EqualTo(5 + 2)); Assert.That(sequence.CurrentValue, Is.EqualTo(1001 + 6)); }
public void TestBasicPooledLoOptimizerUsage() { var sequence = new SourceMock(1, 3); var optimizer = OptimizerFactory.BuildOptimizer(OptimizerFactory.PoolLo, typeof(long), 3, -1); Assert.That(sequence.TimesCalled, Is.EqualTo(0)); Assert.That(sequence.CurrentValue, Is.EqualTo(-1)); var next = (long)optimizer.Generate(sequence); Assert.That(next, Is.EqualTo(1)); Assert.That(sequence.TimesCalled, Is.EqualTo(1)); Assert.That(sequence.CurrentValue, Is.EqualTo(1)); next = (long)optimizer.Generate(sequence); Assert.That(next, Is.EqualTo(2)); Assert.That(sequence.TimesCalled, Is.EqualTo(1)); Assert.That(sequence.CurrentValue, Is.EqualTo(1)); next = (long)optimizer.Generate(sequence); Assert.That(next, Is.EqualTo(3)); Assert.That(sequence.TimesCalled, Is.EqualTo(1)); Assert.That(sequence.CurrentValue, Is.EqualTo(1)); // force a "clock over" next = (long)optimizer.Generate(sequence); Assert.That(next, Is.EqualTo(4)); Assert.That(sequence.TimesCalled, Is.EqualTo(2)); Assert.That(sequence.CurrentValue, Is.EqualTo(1 + 3)); }
public void TestSubsequentPooledOptimizerUsage() { // test the pooled optimizer in situation where the sequence is already beyond its initial value on init. // cheat by telling the sequence to start with 1000 var sequence = new SourceMock(1001, 3, 5); // but tell the optimizer the start-with is 1 var optimizer = OptimizerFactory.BuildOptimizer(OptimizerFactory.Pool, typeof(long), 3, 1); Assert.That(sequence.TimesCalled, Is.EqualTo(5)); Assert.That(sequence.CurrentValue, Is.EqualTo(1001)); long next = (long)optimizer.Generate(sequence); Assert.That(next, Is.EqualTo(1001)); Assert.That(sequence.TimesCalled, Is.EqualTo(5 + 1)); Assert.That(sequence.CurrentValue, Is.EqualTo(1001 + 3)); next = (long)optimizer.Generate(sequence); Assert.That(next, Is.EqualTo(1001 + 1)); Assert.That(sequence.TimesCalled, Is.EqualTo(5 + 1)); Assert.That(sequence.CurrentValue, Is.EqualTo(1001 + 3)); next = (long)optimizer.Generate(sequence); Assert.That(next, Is.EqualTo(1001 + 2)); Assert.That(sequence.TimesCalled, Is.EqualTo(5 + 1)); Assert.That(sequence.CurrentValue, Is.EqualTo(1001 + 3)); // force a "clock over" next = (long)optimizer.Generate(sequence); Assert.That(next, Is.EqualTo(1001 + 3)); Assert.That(sequence.TimesCalled, Is.EqualTo(5 + 2)); Assert.That(sequence.CurrentValue, Is.EqualTo(1001 + 6)); }
static void Main(string[] args) //args[0] optimizer key //OMR -OnlyMoveAndRotate { //Console.WriteLine("paste description"); string description = Console.ReadLine(); // string description = File.ReadAllText("/Users/denis/Downloads/part-1-initial/prob-001.desc").Trim(); var parser = new Parser(description); var mine = parser.ConfigMine(); string optKey = string.Empty; if (args?.Length != 0) { optKey = args[0]; } var optimizer = OptimizerFactory.CreateOptimizer(optKey); var executer = new Executer(mine, optimizer); Console.WriteLine(executer.PrintActionSequence()); Console.ReadLine(); }
public static Solution Solve(IEnumerable <MenuOrder> menuOrders, IEnumerable <Worker> workers) { ProblemInstance instance = GetInstance(menuOrders, workers); Evaluator evaluator = EvaluatorFactory.getMakespanEvaluator(); Optimizer optimizer = OptimizerFactory.getPSOOptimizer(); //粒子群优化器,可以调用其他的 return(optimizer.minimize(instance, evaluator)); }
public PlcDataMapper(int pduSize, ReadOperation readEventHandler, WriteOperation writeEventHandler, UpdateMonitoring updateHandler, ReadBlockInfo blockInfoHandler, OptimizerType optimizer = OptimizerType.Block) { PduSize = pduSize; _readEventHandler = readEventHandler; _writeEventHandler = writeEventHandler; _updateHandler = updateHandler; _blockInfoHandler = blockInfoHandler; Optimizer = OptimizerFactory.CreateOptimizer(optimizer); ReadDataBlockSize = pduSize - _readDataHeaderLength; if (ReadDataBlockSize <= 0) { ExceptionThrowHelper.ThrowInvalidPduSizeException(_readDataHeaderLength); } PlcMetaDataTreePath.CreateAbsolutePath(PlcObjectResolver.RootNodeName); }
public async Task TestBasicHiLoOptimizerUsageAsync() { const int increment = 10; long next; // test historic sequence behavior, where the initial values start at 1... var sequence = new SourceMock(1); var optimizer = OptimizerFactory.BuildOptimizer(OptimizerFactory.HiLo, typeof(long), increment, -1); for (int i = 1; i <= increment; i++) { next = (long)await(optimizer.GenerateAsync(sequence, CancellationToken.None)); Assert.That(next, Is.EqualTo(i)); } Assert.That(sequence.TimesCalled, Is.EqualTo(1)); // once to initialize state Assert.That(sequence.CurrentValue, Is.EqualTo(1)); // force a "clock over" next = (long)await(optimizer.GenerateAsync(sequence, CancellationToken.None)); Assert.That(next, Is.EqualTo(11)); Assert.That(sequence.TimesCalled, Is.EqualTo(2)); Assert.That(sequence.CurrentValue, Is.EqualTo(2)); // test historic table behavior, where the initial values started at 0 (we now force 1 to be the first used id value) sequence = new SourceMock(0); optimizer = OptimizerFactory.BuildOptimizer(OptimizerFactory.HiLo, typeof(long), increment, -1); for (int i = 1; i <= increment; i++) { next = (long)await(optimizer.GenerateAsync(sequence, CancellationToken.None)); Assert.That(next, Is.EqualTo(i)); } Assert.That(sequence.TimesCalled, Is.EqualTo(2)); // here have have an extra call to get to 1 initially Assert.That(sequence.CurrentValue, Is.EqualTo(1)); // force a "clock over" next = (long)await(optimizer.GenerateAsync(sequence, CancellationToken.None)); Assert.That(next, Is.EqualTo(11)); Assert.That(sequence.TimesCalled, Is.EqualTo(3)); Assert.That(sequence.CurrentValue, Is.EqualTo(2)); }
public async Task TestBasicPooledOptimizerUsageAsync() { long next; // test historic sequence behavior, where the initial values start at 1... var sequence = new SourceMock(1, 10); var optimizer = OptimizerFactory.BuildOptimizer(OptimizerFactory.Pool, typeof(long), 10, -1); for (int i = 1; i < 11; i++) { next = (long)await(optimizer.GenerateAsync(sequence, CancellationToken.None)); Assert.That(next, Is.EqualTo(i)); } Assert.That(sequence.TimesCalled, Is.EqualTo(2)); // twice to initialize state Assert.That(sequence.CurrentValue, Is.EqualTo(11)); // force a "clock over" next = (long)await(optimizer.GenerateAsync(sequence, CancellationToken.None)); Assert.That(next, Is.EqualTo(11)); Assert.That(sequence.TimesCalled, Is.EqualTo(3)); Assert.That(sequence.CurrentValue, Is.EqualTo(21)); }
public async Task TestRecoveredPooledLoOptimizerUsageAsync() { var sequence = new SourceMock(1, 3); var optimizer = OptimizerFactory.BuildOptimizer(OptimizerFactory.PoolLo, typeof(long), 3, 1); Assert.That(sequence.TimesCalled, Is.EqualTo(0)); Assert.That(sequence.CurrentValue, Is.EqualTo(-1)); long next = (long)await(optimizer.GenerateAsync(sequence, CancellationToken.None)); Assert.That(next, Is.EqualTo(1)); Assert.That(sequence.TimesCalled, Is.EqualTo(1)); Assert.That(sequence.CurrentValue, Is.EqualTo(1)); // app ends, and starts back up (we should "lose" only 2 and 3 as id values) var optimizer2 = OptimizerFactory.BuildOptimizer(OptimizerFactory.PoolLo, typeof(long), 3, 1); next = (long)await(optimizer2.GenerateAsync(sequence, CancellationToken.None)); Assert.That(next, Is.EqualTo(4)); Assert.That(sequence.TimesCalled, Is.EqualTo(2)); Assert.That(sequence.CurrentValue, Is.EqualTo(4)); }
public void TestRecoveredPooledOptimizerUsage() { var sequence = new SourceMock(1, 3); var optimizer = OptimizerFactory.BuildOptimizer(OptimizerFactory.Pool, typeof(long), 3, 1); Assert.That(sequence.TimesCalled, Is.EqualTo(0)); Assert.That(sequence.CurrentValue, Is.EqualTo(-1)); var next = (long)optimizer.Generate(sequence); Assert.That(next, Is.EqualTo(1)); Assert.That(sequence.TimesCalled, Is.EqualTo(2)); Assert.That(sequence.CurrentValue, Is.EqualTo(4)); // app ends, and starts back up (we should "lose" only 2 and 3 as id values) var optimizer2 = OptimizerFactory.BuildOptimizer(OptimizerFactory.Pool, typeof(long), 3, 1); next = (long)optimizer2.Generate(sequence); Assert.That(next, Is.EqualTo(4)); Assert.That(sequence.TimesCalled, Is.EqualTo(3)); Assert.That(sequence.CurrentValue, Is.EqualTo(7)); }