public void TestIntegerValue()
{
IntegerVariable var = new IntegerVariable();
var.CheckForStore(1);
Assert.AreEqual(1, var.Value);
}
public void TestIntegerVariableNullValue()
{
IntegerVariable var = new IntegerVariable();
bool actual = var.CheckForStore(null);
Assert.IsFalse(actual);
}
public new static IntegerVariable Random()
{
var x = new IntegerVariable();
x.SetRandomValues();
return(x);
}
protected override void InitializeConstraintSystem(ConstraintThingySolver solver)
{
const int n = 8;
// i stole this formulation of N-queens from the Choco documentation
IntegerVariable[] queens = new IntegerVariable[n];
for (int i = 0; i < n; i++)
{
queens[i] = new IntegerVariable(solver, null, new IntegerInterval(1, n));
}
for (int i = 0; i < n; i++)
{
for (int j = i + 1; j < n; j++)
{
int k = j - i;
IntegerVariable kVar = new IntegerVariable(solver, null, new IntegerInterval(k, k));
Constraint.NotEqual(queens[i], queens[j]);
Constraint.NotEqual(queens[i], Constraint.Add(queens[j], kVar));
Constraint.NotEqual(queens[i], Constraint.Subtract(queens[j], kVar));
}
}
}
public bool EvaluateCondition()
{
BooleanVariable booleanVariable = variable as BooleanVariable;
IntegerVariable integerVariable = variable as IntegerVariable;
FloatVariable floatVariable = variable as FloatVariable;
StringVariable stringVariable = variable as StringVariable;
bool condition = false;
if (booleanVariable != null)
{
condition = booleanVariable.Evaluate(compareOperator, booleanData.Value);
}
else if (integerVariable != null)
{
condition = integerVariable.Evaluate(compareOperator, integerData.Value);
}
else if (floatVariable != null)
{
condition = floatVariable.Evaluate(compareOperator, floatData.Value);
}
else if (stringVariable != null)
{
condition = stringVariable.Evaluate(compareOperator, stringData.Value);
}
return(condition);
}
public void then_can_create_variable()
{
Variable variable = new IntegerVariable(12, "Var12")
{
Driver = new DriverModbusRTU(),
DriverConfiguration = new DriverConfiguration()
};
}
private void AddValueToList(FieldInfo f)
{
IBaseVariable variable = null;
if (f.FieldType.ToString() == "System.String")
{
variable = new StringVariable();
}
else if (f.FieldType.ToString() == "System.Int32")
{
variable = new IntegerVariable();
}
else if (f.FieldType.ToString() == "System.Single")
{
variable = new FloatVariable();
}
else if (f.FieldType.ToString() == "System.Boolean")
{
variable = new BooleanVariable();
}
else if (f.FieldType.ToString() == "System.String[]")
{
variable = new StringVariableArray();
}
else if (f.FieldType.ToString() == "System.Int32[]")
{
variable = new IntegerVariableArray();
}
else if (f.FieldType.ToString() == "System.Single[]")
{
variable = new FloatVariableArray();
}
else if (f.FieldType.ToString() == "System.Boolean[]")
{
variable = new BooleanVariableArray();
}
else if (f.FieldType.ToString() == "UnityEngine.Vector2")
{
variable = new Vector2Variable();
}
else if (f.FieldType.ToString() == "UnityEngine.Vector3")
{
variable = new Vector3Variable();
}
else if (f.FieldType.ToString() == "UnityEngine.Vector2[]")
{
variable = new Vector2VariableArray();
}
else if (f.FieldType.ToString() == "UnityEngine.Vector3[]")
{
variable = new Vector3VariableArray();
}
if (variable != null)
{
variable.value = f.GetValue(this);
ListValue.Add((string)f.Name, variable);
}
}
void Awake()
{
TileSwapHandler.AnyPhysicalSwapMade += OnAnyPhysicalSwapMade;
TileSwapHandler.AnyBoardSwapMade += OnAnyBoardSwapMade;
minAmountForMatch = tileBoardVals.GetVariable("minAmountForMatch")
as IntegerVariable;
tiles = boardGenerator.GenerateBoard(this);
UpdateColumnsAndRows();
}
void GetReferencesFromScene()
{
flowchart = GameObject.FindObjectOfType <Flowchart>();
flowchartTransVar = flowchart.GetVariable <TransformVariable>("thisTrans");
gameSaver = GameObject.FindObjectOfType <GameSaver>();
gameLoader = GameObject.FindObjectOfType <GameLoader>();
saveManager = GameObject.FindObjectOfType <SaveManager>();
saveReader = saveManager.SaveReader;
someInt = flowchart.GetVariable <IntegerVariable>("someInt");
GetRefsToGameObjects();
}
//[Test]
//public void then_can_save_integer_1_byte_minValue_minus255()
//{
// byte[] allData = new byte[5];
// int value = 0x40;
// serializer.MinValue = -255;
// serializer.MaxValue = 255;
// serializer.Serialize(value, allData);
// allData[3].ShouldEqual((byte)0x3f);
// allData[4].ShouldEqual((byte)0x1);
//}
//[Test]
//public void then_can_deserialize_integer_1_byte_minValue_minus255()
//{
// byte[] allData = new byte[5];
// allData[3] = 0x3f;
// allData[4] = 0x1;
// int value = 0x40;
// serializer.MinValue = -255;
// serializer.MaxValue = 255;
// ((int)serializer.Deserialize(allData)).ShouldEqual(value);
//}
//[Test]
//public void then_can_save_integer_2_bytes()
//{
// byte[] allData = new byte[5];
// int value = 0x3020;
// serializer.MinValue = 0;
// serializer.MaxValue = 0xffff;
// serializer.Serialize(value, allData);
// allData[3].ShouldEqual((byte)0x20);
// allData[4].ShouldEqual((byte)0x30);
//}
//[Test]
//public void then_can_deserialize_integer_2_bytes()
//{
// byte[] allData = new byte[5];
// allData[3] = 0x20;
// allData[4] = 0x30;
// int result = 0x3020;
// serializer.MinValue = 0;
// serializer.MaxValue = 0xffff;
// ((int)serializer.Deserialize(allData)).ShouldEqual(result);
//}
//[Test]
//public void then_can_save_integer_3_bytes()
//{
// byte[] allData = new byte[7];
// int value = 0x302036;
// serializer.MinValue = 0;
// serializer.MaxValue = 0xffffff;
// serializer.Serialize(value, allData);
// allData[3].ShouldEqual((byte)0x36);
// allData[4].ShouldEqual((byte)0x20);
// allData[5].ShouldEqual((byte)0x30);
//}
//[Test]
//public void then_can_deserialize_integer_3_bytes()
//{
// byte[] allData = new byte[7];
// allData[3] = 0x36;
// allData[4] = 0x20;
// allData[5] = 0x30;
// int result = 0x302036;
// serializer.MinValue = 0;
// serializer.MaxValue = 0xffffff;
// ((int)serializer.Deserialize(allData)).ShouldEqual(result);
//}
//[Test]
//public void then_can_deserialize_integer_4_bytes()
//{
// byte[] allData = new byte[7];
// allData[3] = 0x78;
// allData[4] = 0x36;
// allData[5] = 0x20;
// allData[6] = 0x30;
// int result = 0x30203678;
// serializer.MinValue = 0;
// serializer.MaxValue = 0x7fffffff;
// ((int)serializer.Deserialize(allData)).ShouldEqual(result);
//}
private static IntegerVariableSerializer CreateSerializer(BitStream stream, int minValue, int maxValue)
{
IntegerVariable variable = new IntegerVariable(0, "intVar")
{
MinValue = minValue,
MaxValue = maxValue,
};
var serializer = new IntegerVariableSerializer(variable);
return(serializer);
}
public void IntegerDifferenceConstraint3()
{
ConstraintThingySolver solver = new ConstraintThingySolver();
IntegerVariable x = new IntegerVariable(solver, "x", new IntegerInterval(0, 0));
IntegerVariable y = new IntegerVariable(solver, "y", new IntegerInterval(5, 5));
IntegerVariable z = new IntegerVariable(solver, "z", new IntegerInterval(-50, -6));
Constraint.Difference(z, x, y);
Assert.AreEqual(0, solver.Solutions.Count());
}
public void then_work_with_one_driver_one_experiment()
{
Server server = new Server {
Timer = new RealtimeFixedIntervalTimer {
Interval = 20
}
};
ValueStorage storage = new ValueStorage();
server.ValueStorage = storage;
IDriver driver = new OneValueTestingDriver
{
ValueStorage = storage,
Timer = new RealtimeFixedIntervalTimer {
Interval = 20
},
ValueToPostToVariableStorage = Tuple.Create(1, 3.14),
};
Variable var1, var2, var3;
driver.AddVariable(var1 = new IntegerVariable(1, "Var1"));
driver.AddVariable(var2 = new IntegerVariable(2, "Var2"));
driver.AddVariable(var3 = new IntegerVariable(3, "Var3"));
server.AddDriver(driver);
Experiment experiment = new Experiment {
Name = "Exp1"
};
experiment.AddVariable(var1);
experiment.AddVariable(var2);
experiment.AddVariable(var3);
server.AddExperiment(experiment);
server.Start(0);
experiment.Start(0);
Thread.Sleep(100);
server.RequestVariables("Exp1", (values) =>
{
values.Count.ShouldEqual(3);
values[1].ShouldEqual(3.14);
values[2].ShouldBeNaN();
values[3].ShouldBeNaN();
Debug.WriteLine("Done!");
});
Thread.Sleep(100);
}
public void IntegerSumConstraint3()
{
ConstraintThingySolver solver = new ConstraintThingySolver();
IntegerVariable x = new IntegerVariable(solver, "x", new IntegerInterval(1, 1));
IntegerVariable y = new IntegerVariable(solver, "y", new IntegerInterval(1, 1));
IntegerVariable z = new IntegerVariable(solver, "z", new IntegerInterval(10, 10));
Constraint.Sum(z, x, y);
Assert.AreEqual(0, solver.Solutions.Count());
}
public void then_can_add_variable_value()
{
IValueStorage storage = new ValueStorage();
Variable variable = new IntegerVariable(16, "Var16");
double newValue = 14.54;
storage.Enqueue(variable.ID, newValue);
Tuple <int, double> read = storage.Dequeue();
read.Item1.ShouldEqual(variable.ID);
read.Item2.ShouldEqual(newValue);
}
public override void OnEnter()
{
if (key == "" ||
variable == null)
{
Continue();
return;
}
var flowchart = GetFlowchart();
// Prepend the current save profile (if any)
string prefsKey = SetSaveProfile.saveProfile + "_" + flowchart.SubstituteVariables(key);
System.Type variableType = variable.GetType();
if (variableType == typeof(BooleanVariable))
{
BooleanVariable booleanVariable = variable as BooleanVariable;
if (booleanVariable != null)
{
// PlayerPrefs does not have bool accessors, so just use int
booleanVariable.Value = (PlayerPrefs.GetInt(prefsKey) == 1);
}
}
else if (variableType == typeof(IntegerVariable))
{
IntegerVariable integerVariable = variable as IntegerVariable;
if (integerVariable != null)
{
integerVariable.Value = PlayerPrefs.GetInt(prefsKey);
}
}
else if (variableType == typeof(FloatVariable))
{
FloatVariable floatVariable = variable as FloatVariable;
if (floatVariable != null)
{
floatVariable.Value = PlayerPrefs.GetFloat(prefsKey);
}
}
else if (variableType == typeof(StringVariable))
{
StringVariable stringVariable = variable as StringVariable;
if (stringVariable != null)
{
stringVariable.Value = PlayerPrefs.GetString(prefsKey);
}
}
Continue();
}
public void then_fail_can_add_driver_start_variables()
{
int variableId = 17;
var variable = new IntegerVariable(variableId, "Name")
{
DriverConfiguration = new object()
};
driver.ValueStorage = new VariableStorageStub();
driver.Timer = new TimerStub();
driver.Start();
driver.AddVariable(variable);
}
private void OnCollisionEnter2D(Collision2D collision)
{
DebrisCreator?.Create();
SoundPlayer.Play(DestructionSound);
//начисление очков за сбитого врага
if (collision.gameObject.CompareTag("Player"))
{
PlayerScore += Info.ScoreToGain;
}
//процедура уничтожения астероида
Instantiate(DestructionEffect, gameObject.transform.position, Quaternion.identity);
Destroy(gameObject);
}
public void then_can_remove_driver_variables()
{
int variableId = 17;
var variable = new IntegerVariable(variableId, "Name")
{
DriverConfiguration = new object()
};
driver.ValueStorage = new VariableStorageStub();
driver.Timer = new TimerStub();
driver.AddVariable(variable);
driver.RemoveVarible(variableId).ShouldBeTrue();
}
public void then_work_heavy_scenario_single_instances()
{
Server server = new Server {
Timer = new RealtimeFixedIntervalTimer {
Interval = 20
}
};
ValueStorage storage = new ValueStorage();
server.ValueStorage = storage;
IDriver driver = new AllValuesTestingDriver
{
ValueStorage = storage,
Timer = new RealtimeFixedIntervalTimer {
Interval = 20
},
ValueToPost = 3.14
};
Experiment experiment = new Experiment {
Name = "Exp1"
};
int varCount = 1000;
for (int i = 0; i < varCount; i++)
{
var variable = new IntegerVariable(i, "Var" + i);
driver.AddVariable(variable);
experiment.AddVariable(variable);
}
server.AddDriver(driver);
server.AddExperiment(experiment);
server.Start(0);
experiment.Start(0);
Thread.Sleep(50);
server.RequestVariables("Exp1", (values) =>
{
values.Count.ShouldEqual(varCount);
for (int i = 0; i < varCount; i++)
{
values[i].ShouldEqual(3.14);
}
Debug.WriteLine("Done!");
});
Thread.Sleep(100);
}
public void when_zip_files_on_day()
{
Experiment exp = new Experiment();
exp.Name = "Exp1";
IDriver driver = new DriverInt()
{
ValueStorage = new ValueStorage()
};
IntegerVariable integerVariable = new IntegerVariable(0, "var1")
{
Driver = driver, MinValue = 0, MaxValue = 16, LogValues = true
};
exp.AddVariable(integerVariable); // 5 bits
IntegerVariable integerVariable1 = new IntegerVariable(1, "var2")
{
Driver = driver, MinValue = 0, MaxValue = 1015
};
exp.AddVariable(integerVariable1); // 10 bits
BoolVariable boolVariable = new BoolVariable(2, "var3")
{
Driver = driver, LogValues = true
};
exp.AddVariable(boolVariable); // 1 bits
driver.AddVariable(integerVariable);
driver.AddVariable(integerVariable1);
driver.AddVariable(boolVariable);
logger = new VariableLogger(new List <Experiment>()
{
exp
});
exp.Start(20);
Mock <IDateTimeProvider> mock = new Mock <IDateTimeProvider>(MockBehavior.Strict);
logger.TimeProvider = mock.Object;
mock.Setup(x => x.Now).Returns(DateTime.Now);
Dictionary <int, double> varValues = new Dictionary <int, double>
{
{ 0, 23 },
{ 1, 12 },
};
logger.ReceiveVariableValues(varValues);
mock.Setup(x => x.Now).Returns(new DateTime(2012, 5, 12));
logger.ReceiveVariableValues(varValues);
}
public void Cuando_recive_valores_son_salvados_solo_los_que_tienen_que_ser_salvados()
{
Experiment exp = new Experiment();
IDriver driver = new DriverInt()
{
ValueStorage = new ValueStorage()
};
IntegerVariable integerVariable = new IntegerVariable(0, "var1")
{
Driver = driver, MinValue = 0, MaxValue = 16, LogValues = true
};
exp.AddVariable(integerVariable); // 5 bits
IntegerVariable integerVariable1 = new IntegerVariable(1, "var2")
{
Driver = driver, MinValue = 0, MaxValue = 1015
};
exp.AddVariable(integerVariable1); // 10 bits
BoolVariable boolVariable = new BoolVariable(2, "var3")
{
Driver = driver, LogValues = true
};
exp.AddVariable(boolVariable); // 1 bits
driver.AddVariable(integerVariable);
driver.AddVariable(integerVariable1);
driver.AddVariable(boolVariable);
logger = new VariableLogger(new List <Experiment>()
{
exp
});
Dictionary <int, double> varValues = new Dictionary <int, double>
{
{ 0, 23 },
{ 1, 12 },
};
logger.ExperimentsLogger.Count.ShouldEqual(1);
ExperimentLoggerStub stub = new ExperimentLoggerStub(exp);
logger.ExperimentsLogger.RemoveAt(0);
logger.ExperimentsLogger.Add(stub);
logger.ReceiveVariableValues(varValues);
stub.ValuesReceive[0].ShouldEqual(23);
stub.ValuesReceive[1].ShouldEqual(12);
}
public void when_encoder_message_response_pakage_write_register()
{
c = 0;
_ints = new List <byte> {
1, 2, 3, 4, 5, 6, 186, 221, 8, 9, 10, 11, 12, 197, 106
};
var register = new IntegerVariable(1, "Var1")
{
DriverConfiguration =
new ModbusConfiguration(stationRtu.Object, 20483, ModbusTypeData.Inputs_Registers)
};
byte[] messag = new byte[] { 1, 6, 80, 3, 20, 0, 103, 202 };
port.Setup(x => x.Write(messag, 0, messag.Length));
encoderDecoder.CreateMessageResponsePackageWriteRegister(register, 20);
encoderDecoder.Message.SequenceEqual(messag);
encoderDecoder.Response.SequenceEqual(_ints);
}
public void then_can_save_variables()
{
Experiment exp = new Experiment();
IDriver driver = new DriverInt()
{
ValueStorage = new ValueStorage()
};
IntegerVariable integerVariable = new IntegerVariable(0, "var1")
{
Driver = driver, MinValue = 0, MaxValue = 16, LogValues = true
};
exp.AddVariable(integerVariable); // 5 bits
IntegerVariable integerVariable1 = new IntegerVariable(1, "var2")
{
Driver = driver, MinValue = 0, MaxValue = 1015
};
exp.AddVariable(integerVariable1); // 10 bits
BoolVariable boolVariable = new BoolVariable(2, "var3")
{
Driver = driver, LogValues = true
};
exp.AddVariable(boolVariable); // 1 bits
driver.AddVariable(integerVariable);
driver.AddVariable(integerVariable1);
driver.AddVariable(boolVariable);
ExperimentLoggerStub logger = new ExperimentLoggerStub(exp);
Dictionary <int, double> varValues = new Dictionary <int, double>
{
{ 0, 23 },
{ 1, 12 },
};
logger.ReceiveNewVariableValues(varValues);
exp.Start(0);
Thread.Sleep(50);
logger.ExperimentSerializer.Serializers.Count.ShouldEqual(2);
logger.ExperimentSerializer.Serializers.ElementAt(0).Value.ShouldBeInstanceOfType(typeof(IntegerVariableSerializer));
logger.ExperimentSerializer.Serializers.ElementAt(1).Value.ShouldBeInstanceOfType(typeof(BoolVariableSerializer));
}
//If a block is activated by the user, then this is not needed in the flowchart
//Copies the variables in the list from the GM flowcharts to the activated flowchart
public void CopyGameMasterToFlowchart()
{
gm = GameObject.Find("GameMaster").GetComponent <GameMaster>();
Flowchart gmQuest = gm.GetQuestFlowchart();
Flowchart target = this.GetComponent <Flowchart>();
Variable sourceVar = null;
for (int i = 0; i < varNames.Length; i++)
{
sourceVar = gmQuest.GetVariable(varNames[i]);
StringVariable tempstr = sourceVar as StringVariable;
if (tempstr != null)
{
target.SetStringVariable(varNames[i], tempstr.Value);
continue;
}
BooleanVariable tempBool = sourceVar as BooleanVariable;
if (tempBool != null)
{
target.SetBooleanVariable(varNames[i], tempBool.Value);
continue;
}
IntegerVariable tempInt = sourceVar as IntegerVariable;
if (tempInt != null)
{
target.SetIntegerVariable(varNames[i], tempInt.Value);
continue;
}
FloatVariable tempFloat = sourceVar as FloatVariable;
if (tempFloat != null)
{
target.SetFloatVariable(varNames[i], tempFloat.Value);
continue;
}
}
}
public void IntegerDifferenceConstraint5()
{
ConstraintThingySolver solver = new ConstraintThingySolver();
IntegerVariable x = new IntegerVariable(solver, "x", new IntegerInterval(1, 5));
IntegerVariable y = new IntegerVariable(solver, "y", new IntegerInterval(1, 5));
IntegerVariable z = new IntegerVariable(solver, "z", new IntegerInterval(-3, 10));
Constraint.Difference(z, x, y);
int solutionCount = 0;
foreach (var solution in solver.Solutions)
{
solutionCount++;
Assert.AreEqual(z.CurrentValue, x.CurrentValue - y.CurrentValue);
}
Assert.AreEqual(24, solutionCount);
}
public void IntegerSumConstraint5()
{
ConstraintThingySolver solver = new ConstraintThingySolver();
IntegerVariable x = new IntegerVariable(solver, "x", new IntegerInterval(1, 1));
IntegerVariable y = new IntegerVariable(solver, "y", new IntegerInterval(1, 2));
IntegerVariable z = new IntegerVariable(solver, "z", new IntegerInterval(3, 3));
Constraint.Sum(z, x, y);
int solutionCount = 0;
foreach (var solution in solver.Solutions)
{
solutionCount++;
Assert.AreEqual(z.CurrentValue, x.CurrentValue + y.CurrentValue);
}
Assert.AreEqual(1, solutionCount);
}
public void Setup()
{
server = new Server();
Experiment exp = new Experiment()
{
Name = expName
};
server.AddExperiment(exp);
Mock <IDriver> driver = new Mock <IDriver>(MockBehavior.Strict);
driver
.Setup(x => x.WriteValue(varId, newValue));
Variable variable = new IntegerVariable(varId, "Var1")
{
Driver = driver.Object
};
exp.AddVariable(variable);
}
public void EightQueens()
{
const int n = 8;
ConstraintThingySolver solver = new ConstraintThingySolver();
// i stole this formulation of N-queens from the Choco documentation
IntegerVariable[] queens = new IntegerVariable[n];
for (int i = 0; i < n; i++)
{
queens[i] = new IntegerVariable(solver, null, new IntegerInterval(1, n));
}
for (int i = 0; i < n; i++)
{
for (int j = i + 1; j < n; j++)
{
int k = j - i;
IntegerVariable kVar = new IntegerVariable(solver, null, new IntegerInterval(k, k));
Constraint.NotEqual(queens[i], queens[j]);
Constraint.NotEqual(queens[i], Constraint.Add(queens[j], kVar));
Constraint.NotEqual(queens[i], Constraint.Subtract(queens[j], kVar));
}
}
int answerCounter = 0;
foreach (var solution in solver.Solutions)
{
answerCounter++;
}
Assert.AreEqual(92, answerCounter);
}
public void SetUp()
{
exp = new Experiment {
Name = "Exp1"
};
driver = new DriverStub();
Variable var1 = new IntegerVariable(1, "Var1")
{
Driver = driver
};
Variable var2 = new IntegerVariable(2, "Var2")
{
Driver = driver
};
Variable var3 = new IntegerVariable(3, "Var3")
{
Driver = driver
};
exp.AddVariable(var1);
exp.AddVariable(var2);
exp.AddVariable(var3);
}
/**
* Loads a flatzinc file (passed as the first argument) and solves it.
*/
private static void Solve(String filename)
{
Model model = new Model(filename);
model.LoadFromFile(filename);
// Uncomment to see the model.
// Console.WriteLine(model.ToString());
// This is mandatory.
model.PresolveForCp(/*verbose=*/ false);
// Display basic statistics on the model.
model.PrintStatistics();
FlatzincParameters parameters = new FlatzincParameters();
// Initialize to default values as in the C++ runner.
parameters.all_solutions = false;
parameters.free_search = false;
parameters.last_conflict = false;
parameters.heuristic_period = 100;
parameters.ignore_unknown = false;
parameters.log_period = 10000000;
parameters.luby_restart = -1;
parameters.num_solutions = 0;
parameters.restart_log_size = -1;
parameters.threads = 0;
parameters.time_limit_in_ms = 10000;
parameters.logging = false;
parameters.verbose_impact = false;
parameters.thread_id = -1;
parameters.search_type = FlatzincParameters.DEFAULT;
// Mandatory to retrieve solutions.
parameters.store_all_solutions = true;
Solver solver = new Solver(model);
solver.Solve(parameters);
int last = solver.NumStoredSolutions() - 1;
if (last >= 0)
{
SolutionOutputSpecsVector output_vector = model.output();
foreach (SolutionOutputSpecs output in output_vector)
{
if (output.variable != null)
{
IntegerVariable var = output.variable;
Console.WriteLine(output.name + " = " +
solver.StoredValue(last, var));
}
if (output.flat_variables.Count > 0)
{
String line = output.name;
foreach (SolutionOutputSpecs.Bounds b in output.bounds)
{
line += "[" + b.ToString() + "]";
}
line += " = {";
bool start = true;
foreach (IntegerVariable var in output.flat_variables)
{
if (start)
{
start = false;
}
else
{
line += ", ";
}
line += solver.StoredValue(last, var);
}
line += "}";
Console.WriteLine(line);
}
}
}
}
