private object GetParameterValue(IParameter param, IExecutionContext context, out string actualName)
{
param = (IParameter)param.Clone();
ILookupParameter lookupParam = param as ILookupParameter;
if (lookupParam != null)
{
actualName = lookupParam.ActualName;
lookupParam.ExecutionContext = context;
}
else
{
actualName = null;
}
object value = null;
try {
value = param.ActualValue;
}
catch (Exception x) {
value = x.Message;
}
return(value);
}
public PythonProcessSemanticHelper(IEnumerable<string> variableNames, int limit, ILookupParameter<PythonProcess> pythonProcessParameter) {
this.pythonProcessParameter = pythonProcessParameter;
if (variableNames == null || variableNames.Count() == 0 || limit <= 0) {
traceCodeWithVariables = String.Empty;
} else {
traceCodeWithVariables = String.Format(traceCode, String.Join("', '", variableNames.Where(x => !String.IsNullOrWhiteSpace(x))), limit);
}
}
public override IOperation Apply()
{
var results = ResultCollectionParameter.ActualValue;
if (!results.ContainsKey(RegressionSolutionQualitiesResultName))
{
var newDataTable = new DataTable(RegressionSolutionQualitiesResultName);
results.Add(new Result(RegressionSolutionQualitiesResultName, "Chart displaying the training and test qualities of the regression solutions.", newDataTable));
}
var dataTable = (DataTable)results[RegressionSolutionQualitiesResultName].Value;
// only if the parameters are available (not available in old persisted code)
ILookupParameter <DoubleValue> trainingQualityParam = null;
ILookupParameter <DoubleValue> testQualityParam = null;
// store actual names of parameter because it is changed below
trainingQualityParam = TrainingQualityParameter;
string prevTrainingQualityParamName = trainingQualityParam.ActualName;
testQualityParam = TestQualityParameter;
string prevTestQualityParamName = testQualityParam.ActualName;
foreach (var result in results.Where(r => r.Value is IRegressionSolution))
{
var solution = (IRegressionSolution)result.Value;
var trainingR2Name = result.Name + " Training R²";
if (!dataTable.Rows.ContainsKey(trainingR2Name))
{
dataTable.Rows.Add(new DataRow(trainingR2Name));
}
var testR2Name = result.Name + " Test R²";
if (!dataTable.Rows.ContainsKey(testR2Name))
{
dataTable.Rows.Add(new DataRow(testR2Name));
}
dataTable.Rows[trainingR2Name].Values.Add(solution.TrainingRSquared);
dataTable.Rows[testR2Name].Values.Add(solution.TestRSquared);
// also add training and test R² to the scope using the parameters
// HACK: we change the ActualName of the parameter to write two variables for each solution in the results collection
trainingQualityParam.ActualName = trainingR2Name;
trainingQualityParam.ActualValue = new DoubleValue(solution.TrainingRSquared);
testQualityParam.ActualName = testR2Name;
testQualityParam.ActualValue = new DoubleValue(solution.TestRSquared);
}
trainingQualityParam.ActualName = prevTrainingQualityParamName;
testQualityParam.ActualName = prevTestQualityParamName;
return(base.Apply());
}
private void AfterDeserialization()
{
if (!Parameters.ContainsKey("SwarmBestQuality"))
{
ILookupParameter <DoubleValue> oldBestQualityParameter = Parameters["BestQuality"] as ILookupParameter <DoubleValue>;
Parameters.Add(new LookupParameter <DoubleValue>("SwarmBestQuality", "Swarm's best quality."));
if (oldBestQualityParameter.ActualName != oldBestQualityParameter.Name)
{
SwarmBestQualityParameter.ActualName = oldBestQualityParameter.ActualName;
}
Parameters.Remove("BestQuality");
}
RegisterEvents();
}
private void UpdateMoveEvaluation()
{
IVRPEvaluator evaluator = ProblemInstance.SolutionEvaluator;
ICollection <IParameter> addedParameters = new List <IParameter>();
try {
foreach (IParameter parameter in evaluator.Parameters)
{
if (parameter is ILookupParameter &&
parameter != evaluator.VRPToursParameter &&
parameter != evaluator.ProblemInstanceParameter)
{
ILookupParameter evaluatorParameter = parameter as ILookupParameter;
string resultName = evaluatorParameter.ActualName;
if (!this.Parameters.ContainsKey(resultName))
{
ILookupParameter resultParameter = new LookupParameter <IItem>(resultName);
resultParameter.ExecutionContext = ExecutionContext;
this.Parameters.Add(resultParameter);
addedParameters.Add(resultParameter);
}
string moveResultName = VRPMoveEvaluator.MovePrefix + resultName;
if (!this.Parameters.ContainsKey(moveResultName))
{
ILookupParameter moveResultParameter = new LookupParameter <IItem>(moveResultName);
moveResultParameter.ExecutionContext = ExecutionContext;
this.Parameters.Add(moveResultParameter);
addedParameters.Add(moveResultParameter);
}
ILookupParameter result = Parameters[resultName] as ILookupParameter;
ILookupParameter moveResult = Parameters[moveResultName] as ILookupParameter;
result.ActualValue = moveResult.ActualValue;
}
}
} finally {
foreach (IParameter parameter in addedParameters)
{
this.Parameters.Remove(parameter);
}
}
}
public override IOperation Apply()
{
IVariable var;
foreach (IParameter param in CollectedValues)
{
ILookupParameter lookupParam = param as ILookupParameter;
string name = lookupParam != null ? lookupParam.TranslatedName : param.Name;
CurrentScope.Variables.TryGetValue(name, out var);
IItem value = param.ActualValue;
if (var != null)
{
var.Value = value == null ? null : (IItem)value.Clone();
}
else
{
CurrentScope.Variables.Add(new Variable(name, param.Description, value == null ? null : (IItem)value.Clone()));
}
}
return(base.Apply());
}
protected virtual SolutionMessage BuildSolutionMessage()
{
lock (clientLock) {
SolutionMessage.Builder protobufBuilder = SolutionMessage.CreateBuilder();
protobufBuilder.SolutionId = 0;
foreach (IParameter param in CollectedValues)
{
IItem value = param.ActualValue;
if (value != null)
{
ILookupParameter lookupParam = param as ILookupParameter;
string name = lookupParam != null ? lookupParam.TranslatedName : param.Name;
try {
MessageBuilder.AddToMessage(value, name, protobufBuilder);
} catch (ArgumentException ex) {
throw new InvalidOperationException(string.Format("ERROR while building solution message: Parameter {0} cannot be added to the message", name), ex);
}
}
}
return(protobufBuilder.Build());
}
}
public override IOperation Apply()
{
bool copy = CopyValueParameter.Value.Value;
ResultCollection results = ResultsParameter.ActualValue;
IResult result;
foreach (IParameter param in CollectedValues)
{
IItem value = param.ActualValue;
if (value != null)
{
ILookupParameter lookupParam = param as ILookupParameter;
string name = lookupParam != null ? lookupParam.TranslatedName : param.Name;
IScopeTreeLookupParameter scopeTreeLookupParam = param as IScopeTreeLookupParameter;
if ((scopeTreeLookupParam != null) && (scopeTreeLookupParam.Depth == 0))
{
IEnumerator enumerator = ((IEnumerable)value).GetEnumerator();
if (enumerator.MoveNext())
{
value = (IItem)enumerator.Current;
}
}
results.TryGetValue(name, out result);
if (result != null)
{
result.Value = copy ? (IItem)value.Clone() : value;
}
else
{
results.Add(new Result(name, param.Description, copy ? (IItem)value.Clone() : value));
}
}
}
return(base.Apply());
}
private void CreatePerGenerationTable(ILookupParameter <DataTable> generationalDataTableParameter, double value, string title, string description = "")
{
ResultCollection results = ResultsParameter.ActualValue;
DataTable generationalDataTable = generationalDataTableParameter.ActualValue;
if (generationalDataTable == null)
{
generationalDataTable = new DataTable(title, description);
generationalDataTable.VisualProperties.YAxisTitle = title;
generationalDataTable.VisualProperties.XAxisTitle = "Generation";
generationalDataTableParameter.ActualValue = generationalDataTable;
results.Add(new Result(title, generationalDataTable));
}
if (!generationalDataTable.Rows.ContainsKey(title))
{
// initialize a new row for the symbol and pad with zeros
DataRow row = new DataRow(title, "");
row.VisualProperties.StartIndexZero = true;
generationalDataTable.Rows.Add(row);
}
generationalDataTable.Rows[title].Values.Add(Math.Round(value, 3));
}
private void CreateAbsoluteCrossoverTable(IEnumerable <string> values, ILookupParameter <DataTable> dataTableParameter, string title)
{
ResultCollection results = ResultsParameter.ActualValue;
DataTable dataTable = dataTableParameter.ActualValue;
if (dataTable == null)
{
dataTable = new DataTable(title, description);
dataTable.VisualProperties.YAxisTitle = "Crossover per symbol";
dataTable.VisualProperties.XAxisTitle = "Generation";
dataTableParameter.ActualValue = dataTable;
results.Add(new Result(title, dataTable));
}
// all rows must have the same number of values so we can just take the first
int numberOfValues = dataTable.Rows.Select(r => r.Values.Count).DefaultIfEmpty().First();
foreach (var pair in values.GroupBy(x => x, x => x))
{
if (!dataTable.Rows.ContainsKey(pair.Key))
{
// initialize a new row for the symbol and pad with zeros
DataRow row = new DataRow(pair.Key, "", Enumerable.Repeat(0.0, numberOfValues));
row.VisualProperties.StartIndexZero = true;
dataTable.Rows.Add(row);
}
dataTable.Rows[pair.Key].Values.Add(pair.Count());
}
// add a zero for each data row that was not modified in the previous loop
foreach (var row in dataTable.Rows.Where(r => r.Values.Count != numberOfValues + 1))
{
row.Values.Add(0.0);
}
}
public override IOperation Apply()
{
DataTable table = DataTableParameter.ActualValue;
if (table == null)
{
table = new DataTable(DataTableParameter.ActualName);
DataTableParameter.ActualValue = table;
}
foreach (IParameter param in CollectedValues)
{
ILookupParameter lookupParam = param as ILookupParameter;
string name = lookupParam != null ? lookupParam.TranslatedName : param.Name;
if (param.ActualValue is DoubleValue)
{
AddValue(table, (param.ActualValue as DoubleValue).Value, name, param.Description);
}
else if (param.ActualValue is IntValue)
{
AddValue(table, (param.ActualValue as IntValue).Value, name, param.Description);
}
else if (param.ActualValue is IEnumerable <DoubleValue> )
{
IEnumerable <DoubleValue> values = (IEnumerable <DoubleValue>)param.ActualValue;
if (values.Count() <= 1)
{
foreach (DoubleValue data in values)
{
AddValue(table, data != null ? data.Value : double.NaN, name, param.Description);
}
}
else
{
int counter = 1;
foreach (DoubleValue data in values)
{
AddValue(table, data != null ? data.Value : double.NaN, name + " " + counter.ToString(), param.Description);
counter++;
}
}
}
else if (param.ActualValue is IEnumerable <IntValue> )
{
IEnumerable <IntValue> values = (IEnumerable <IntValue>)param.ActualValue;
if (values.Count() <= 1)
{
foreach (IntValue data in values)
{
AddValue(table, data != null ? data.Value : double.NaN, name, param.Description);
}
}
else
{
int counter = 1;
foreach (IntValue data in values)
{
AddValue(table, data != null ? data.Value : double.NaN, name + " " + counter.ToString(), param.Description);
counter++;
}
}
}
else
{
AddValue(table, double.NaN, name, param.Description);
}
}
return(base.Apply());
}
