public void ToStringTest(string varName)
{
var sut = new VariableCondition(varName);
var actual = sut.ToString();
actual.Should().Be(varName);
}
public VariableConditionItem(string groupID, string key, VariableCondition cond, string value)
{
this.groupID = groupID;
this.key = key;
this.type = VariableType.String;
this.cond = cond;
this.vString = value;
}
public VariableConditionViewModel(VariableCondition condition) : base(condition)
{
Option = new OptionViewModel(condition, nameof(condition.Value));
Text = new TextViewModel(condition);
Attach(Option);
Attach(Text);
}
public VariableConditionItem(string groupID, string key, VariableCondition cond, float value)
{
this.groupID = groupID;
this.key = key;
this.type = VariableType.Float;
this.cond = cond;
this.vFloat = value;
}
public VariableConditionItem(string groupID, string key, VariableCondition cond, bool value)
{
this.groupID = groupID;
this.key = key;
this.type = VariableType.Bool;
this.cond = cond;
this.vBool = value;
}
public override void DrawCommandGUI()
{
serializedObject.Update();
EditorGUILayout.PropertyField(serializedObject.FindProperty("anyOrAllConditions"));
conditions.arraySize = EditorGUILayout.IntField("Size", conditions.arraySize);
GUILayout.Label("Conditions", EditorStyles.boldLabel);
VariableCondition t = target as VariableCondition;
var flowchart = (Flowchart)t.GetFlowchart();
if (flowchart == null)
{
return;
}
EditorGUI.indentLevel++;
for (int i = 0; i < conditions.arraySize; i++)
{
var conditionAnyVar = conditions.GetArrayElementAtIndex(i).FindPropertyRelative("anyVar");
var conditionCompare = conditions.GetArrayElementAtIndex(i).FindPropertyRelative("compareOperator");
EditorGUILayout.PropertyField(conditionAnyVar, new GUIContent("Variable"), true);
// Get selected variable
Variable selectedVariable = conditionAnyVar.FindPropertyRelative("variable").objectReferenceValue as Variable;
if (selectedVariable == null)
{
continue;
}
GUIContent[] operatorsList = emptyList;
operatorsList = selectedVariable.IsComparisonSupported() ? compareListAll : compareListEqualOnly;
// Get previously selected operator
int selectedIndex = conditionCompare.enumValueIndex;
if (selectedIndex < 0 || selectedIndex >= operatorsList.Length)
{
// Default to first index if the operator is not found in the available operators list
// This can occur when changing between variable types
selectedIndex = 0;
}
selectedIndex = EditorGUILayout.Popup(
new GUIContent("Compare", "The comparison operator to use when comparing values"),
selectedIndex,
operatorsList);
conditionCompare.enumValueIndex = selectedIndex;
EditorGUILayout.Separator();
}
EditorGUI.indentLevel--;
serializedObject.ApplyModifiedProperties();
}
public void SynchronizeDataFromJson(JsonDto jto, Simulator sim)
{
var checkedProperties = new List <string>();
ValidateAndUpdateValueAsNeeded(nameof(Device),
checkedProperties,
_device?.GetJsonReference().Guid, jto.Device.Guid,
() => _device = sim.GetAssignableDeviceByGuid(jto.Device?.Guid) ??
throw new LPGException("Could not find a device with for " + jto.Device));
ValidateAndUpdateValueAsNeeded(nameof(Location),
checkedProperties, Location?.Guid, jto.Location.Guid,
() =>
_location = sim.Locations.FindByGuid(jto.Location?.Guid));
ValidateAndUpdateValueAsNeeded(nameof(TimeLimit),
checkedProperties, TimeLimit?.Guid, jto.TimeLimit.Guid,
() =>
_timeLimit = sim.TimeLimits.FindByGuid(jto.TimeLimit?.Guid));
ValidateAndUpdateValueAsNeeded(nameof(TimeProfile),
checkedProperties,
TimeProfile?.Guid, jto.TimeProfile?.Guid,
() => _timeprofile = sim.Timeprofiles.FindByJsonReference(jto.TimeProfile));
if (TimeStandardDeviation != jto.StandardDeviation)
{
_timeStandardDeviation = jto.StandardDeviation;
NeedsUpdate = true;
}
if (Variable?.Guid != jto.Variable?.Guid)
{
_variable = sim.Variables.FindByGuid(jto.Variable?.Guid);
NeedsUpdate = true;
}
if (VariableCondition != jto.VariableCondition)
{
_variableCondition = jto.VariableCondition;
NeedsUpdate = true;
}
// ReSharper disable once CompareOfFloatsByEqualityOperator
if (VariableValue != jto.VariableValue)
{
_variableValue = jto.VariableValue;
NeedsUpdate = true;
}
if (LoadType?.Guid != jto.LoadType?.Guid)
{
_vLoadType = sim.LoadTypes.FindByGuid(jto.Variable?.Guid);
NeedsUpdate = true;
}
ValidateAndUpdateValueAsNeeded(nameof(Guid),
checkedProperties,
Guid, jto.Guid,
() => Guid = jto.Guid);
CheckIfAllPropertiesWereCovered(checkedProperties, this);
SaveToDB();
}
public void Evaluate(object value)
{
var variables = A.Fake <IVariableDictionary>(i => i.Strict());
A.CallTo(() => variables["VarName"]).Returns(value);
var sut = new VariableCondition("VarName");
var actual = sut.Evaluate(variables);
actual.Should().Be(value);
}
public VariableRequirementDto([NotNull] string name, double value, [NotNull] string location, StrGuid locationGuid,
VariableCondition variableCondition,
StrGuid variableGuid)
{
VariableGuid = variableGuid;
Name = name;
Value = value;
CalcLocationName = location;
LocationGuid = locationGuid;
VariableCondition = variableCondition;
}
public VariableRequirement([NotNull] string name, double value, [NotNull] string location, StrGuid locationGuid,
VariableCondition variableCondition, [NotNull] CalcVariableRepository repository,
StrGuid variableGuid)
{
_repository = repository;
_variableGuid = variableGuid;
Name = name;
Value = value;
CalcLocationName = location;
LocationGuid = locationGuid;
VariableCondition = variableCondition;
}
public JsonDto(StrGuid guid, JsonReference device, JsonReference location, JsonReference timeLimit, JsonReference timeProfile,
decimal standardDeviation, JsonReference variable, VariableCondition variableCondition, double variableValue, JsonReference loadType)
{
Guid = guid;
Device = device;
Location = location;
TimeLimit = timeLimit;
TimeProfile = timeProfile;
StandardDeviation = standardDeviation;
Variable = variable;
VariableCondition = variableCondition;
VariableValue = variableValue;
LoadType = loadType;
}
public AffVariableRequirement(double value, [CanBeNull] int?id, [CanBeNull] int?affordanceID, [NotNull] string connectionString,
VariableLocationMode variableLocationMode, [CanBeNull] Location location, VariableCondition condition,
[CanBeNull] Variable variable,
[NotNull] string description, [NotNull] string name, StrGuid guid) : base(name, TableName, connectionString, guid)
{
_value = value;
ID = id;
_affordanceID = affordanceID;
TypeDescription = "Affordance Variable Requirement";
_variableLocationMode = variableLocationMode;
_location = location;
_condition = condition;
_variable = variable;
_description = description;
}
public static bool CheckCondition(double currentVariableValue, VariableCondition variableCondition,
double setValue)
{
var execute = true;
switch (variableCondition)
{
case VariableCondition.Equal:
if (Math.Abs(currentVariableValue - setValue) > 0.000001)
{
execute = false;
}
break;
case VariableCondition.EqualOrGreater:
if (currentVariableValue < setValue) // this is correct because >= inverted is <
{
execute = false;
}
break;
case VariableCondition.EqualOrLess:
if (currentVariableValue > setValue)
{
execute = false;
}
break;
case VariableCondition.Greater:
if (currentVariableValue <= setValue)
{
execute = false;
}
break;
case VariableCondition.Less:
if (currentVariableValue >= setValue)
{
execute = false;
}
break;
default:
throw new LPGException("Forgotten VariableCondition");
}
return(execute);
}
/// <summary>
/// Transforms the tree model to a symbolic regression model
/// </summary>
/// <returns>A new symbolic regression model which matches the tree model</returns>
public SymbolicRegressionModel CreateSymbolicRegressionModel()
{
var rootSy = new ProgramRootSymbol();
var startSy = new StartSymbol();
var varCondSy = new VariableCondition()
{
IgnoreSlope = true
};
var constSy = new Constant();
var startNode = startSy.CreateTreeNode();
startNode.AddSubtree(CreateSymbolicRegressionTreeRecursive(tree, 0, varCondSy, constSy));
var rootNode = rootSy.CreateTreeNode();
rootNode.AddSubtree(startNode);
return(new SymbolicRegressionModel(TargetVariable, new SymbolicExpressionTree(rootNode), new SymbolicDataAnalysisExpressionTreeLinearInterpreter()));
}
public HHTAutonomousDevice([CanBeNull] int?pID, [CanBeNull] IAssignableDevice device,
[CanBeNull] TimeBasedProfile timeprofile, int householdTraitID, decimal timeStandardDeviation,
[CanBeNull] VLoadType vLoadType, [CanBeNull] TimeLimit timeLimit, [NotNull] string connectionString, [NotNull] string name,
[CanBeNull] Location location, double variableValue, VariableCondition variableCondition,
[CanBeNull] Variable variable, StrGuid guid) : base(name, TableName, connectionString, guid)
{
TypeDescription = "Household Trait Autonomous Device";
ID = pID;
_device = device;
_timeprofile = timeprofile;
_householdTraitID = householdTraitID;
_timeStandardDeviation = timeStandardDeviation;
_vLoadType = vLoadType;
_timeLimit = timeLimit;
_location = location;
_variableValue = variableValue;
_variableCondition = variableCondition;
_variable = variable;
}
public HouseTypeDevice([CanBeNull] int?pID, [CanBeNull] IAssignableDevice adev, [CanBeNull] TimeBasedProfile profile,
int houseID,
[CanBeNull] TimeLimit timeLimit, double timeStandardDeviation, [CanBeNull] VLoadType loadType,
[NotNull] string connectionString, [NotNull] string name,
[CanBeNull] Location loc, double variableValue, VariableCondition variableCondition,
[CanBeNull] Variable variable, StrGuid guid)
: base(name, TableName, connectionString, guid)
{
ID = pID;
_location = loc;
_device = adev;
_profile = profile;
HouseID = houseID;
TimeLimit = timeLimit;
_timeStandardDeviation = timeStandardDeviation;
_loadType = loadType;
_variableValue = variableValue;
TypeDescription = "House Type Device";
_variableCondition = variableCondition;
_variable = variable;
}
public ISymbolicExpressionTree ExtractTree(int treeIdx)
{
var rf = RandomForest;
// hoping that the internal representation of alglib is stable
// TREE FORMAT
// W[Offs] - size of sub-array (for the tree)
// node info:
// W[K+0] - variable number (-1 for leaf mode)
// W[K+1] - threshold (class/value for leaf node)
// W[K+2] - ">=" branch index (absent for leaf node)
// skip irrelevant trees
int offset = 0;
for (int i = 0; i < treeIdx - 1; i++)
{
offset = offset + (int)Math.Round(rf.innerobj.trees[offset]);
}
var constSy = new Constant();
var varCondSy = new VariableCondition()
{
IgnoreSlope = true
};
var node = CreateRegressionTreeRec(rf.innerobj.trees, offset, offset + 1, constSy, varCondSy);
var startNode = new StartSymbol().CreateTreeNode();
startNode.AddSubtree(node);
var root = new ProgramRootSymbol().CreateTreeNode();
root.AddSubtree(startNode);
return(new SymbolicExpressionTree(root));
}
public static string ConvertToVariableDescription(VariableCondition tc)
{
var entries = MakeAllEntries();
return(entries.First(x => x.VariableCondition == tc).Description);
}
private ISymbolicExpressionTreeNode CreateSymbolicRegressionTreeRecursive(TreeNode[] treeNodes, int nodeIdx, VariableCondition varCondSy, Constant constSy)
{
var curNode = treeNodes[nodeIdx];
if (curNode.VarName == TreeNode.NO_VARIABLE)
{
var node = (ConstantTreeNode)constSy.CreateTreeNode();
node.Value = curNode.Val;
return(node);
}
else
{
var node = (VariableConditionTreeNode)varCondSy.CreateTreeNode();
node.VariableName = curNode.VarName;
node.Threshold = curNode.Val;
var left = CreateSymbolicRegressionTreeRecursive(treeNodes, curNode.LeftIdx, varCondSy, constSy);
var right = CreateSymbolicRegressionTreeRecursive(treeNodes, curNode.RightIdx, varCondSy, constSy);
node.AddSubtree(left);
node.AddSubtree(right);
return(node);
}
}
public ConditionalAction(VariableCondition variableCondition)
{
VariableCondition = variableCondition;
Name = nameof(ConditionalAction);
}
public static VariableCondition[] Remove(int index, VariableCondition[] list)
{
ArrayList tmp = new ArrayList();
foreach(VariableCondition str in list) tmp.Add(str);
tmp.RemoveAt(index);
return tmp.ToArray(typeof(VariableCondition)) as VariableCondition[];
}
public static VariableCondition VariableConditionSettings(VariableCondition vars)
{
vars.needed = (AIConditionNeeded)EditorGUILayout.EnumPopup("Needed",
vars.needed, GUILayout.Width(mWidth));
if(GUILayout.Button("Add Variable", GUILayout.Width(mWidth)))
{
vars.AddVariable();
}
for(int i=0; i<vars.variableKey.Length; i++)
{
EditorGUILayout.BeginHorizontal();
if(GUILayout.Button("Remove", GUILayout.Width(mWidth*0.5f)))
{
vars.RemoveVariable(i);
break;
}
vars.checkType[i] = EditorGUILayout.Toggle(
vars.checkType[i], GUILayout.Width(20));
vars.variableKey[i] = EditorGUILayout.TextField(
vars.variableKey[i], GUILayout.Width(mWidth*0.5f));
if(vars.checkType[i]) GUILayout.Label("== ");
else GUILayout.Label(" != ");
vars.variableValue[i] = EditorGUILayout.TextField(
vars.variableValue[i], GUILayout.Width(mWidth*0.5f));
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.Separator();
if(GUILayout.Button("Add Number Variable", GUILayout.Width(mWidth)))
{
vars.AddNumberVariable();
}
for(int i=0; i<vars.numberVarKey.Length; i++)
{
EditorGUILayout.BeginHorizontal();
if(GUILayout.Button("Remove", GUILayout.Width(mWidth*0.5f)))
{
vars.RemoveNumberVariable(i);
break;
}
vars.numberCheckType[i] = EditorGUILayout.Toggle(
vars.numberCheckType[i], GUILayout.Width(20));
vars.numberVarKey[i] = EditorGUILayout.TextField(
vars.numberVarKey[i], GUILayout.Width(mWidth*0.5f));
if(!vars.numberCheckType[i]) GUILayout.Label("not");
vars.numberValueCheck[i] = (ValueCheck)EditorGUILayout.EnumPopup(
vars.numberValueCheck[i], GUILayout.Width(mWidth*0.4f));
vars.numberVarValue[i] = EditorGUILayout.FloatField(
vars.numberVarValue[i], GUILayout.Width(mWidth*0.5f));
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.Separator();
return vars;
}
public Models.VisualScript.Action GetAction()
{
var variableCondition = new VariableCondition(SelectedVariableName, SelectedObject.Name, ConditionType, ValueToCompare);
return(new ConditionalAction(variableCondition));
}
public TiggerConditionEntry(VariableCondition variableCondition, [NotNull] string description)
{
VariableCondition = variableCondition;
Description = description;
}
private ISymbolicExpressionTreeNode CreateRegressionTreeRec(double[] trees, int offset, int k, Constant constSy, VariableCondition varCondSy)
{
// alglib source for evaluation of one tree (dfprocessinternal)
// offs = 0
//
// Set pointer to the root
//
// k = offs + 1;
//
// //
// // Navigate through the tree
// //
// while (true) {
// if ((double)(df.trees[k]) == (double)(-1)) {
// if (df.nclasses == 1) {
// y[0] = y[0] + df.trees[k + 1];
// } else {
// idx = (int)Math.Round(df.trees[k + 1]);
// y[idx] = y[idx] + 1;
// }
// break;
// }
// if ((double)(x[(int)Math.Round(df.trees[k])]) < (double)(df.trees[k + 1])) {
// k = k + innernodewidth;
// } else {
// k = offs + (int)Math.Round(df.trees[k + 2]);
// }
// }
if ((double)(trees[k]) == (double)(-1))
{
var constNode = (ConstantTreeNode)constSy.CreateTreeNode();
constNode.Value = trees[k + 1];
return(constNode);
}
else
{
var condNode = (VariableConditionTreeNode)varCondSy.CreateTreeNode();
condNode.VariableName = AllowedInputVariables[(int)Math.Round(trees[k])];
condNode.Threshold = trees[k + 1];
condNode.Slope = double.PositiveInfinity;
var left = CreateRegressionTreeRec(trees, offset, k + 3, constSy, varCondSy);
var right = CreateRegressionTreeRec(trees, offset, offset + (int)Math.Round(trees[k + 2]), constSy, varCondSy);
condNode.AddSubtree(left); // not 100% correct because interpreter uses: if(x <= thres) left() else right() and RF uses if(x < thres) left() else right() (see above)
condNode.AddSubtree(right);
return(condNode);
}
}
public override void DrawCommandGUI()
{
serializedObject.Update();
VariableCondition t = target as VariableCondition;
var flowchart = (Flowchart)t.GetFlowchart();
if (flowchart == null)
{
return;
}
// Select Variable
EditorGUILayout.PropertyField(variableProp);
if (variableProp.objectReferenceValue == null)
{
serializedObject.ApplyModifiedProperties();
return;
}
// Get selected variable
Variable selectedVariable = variableProp.objectReferenceValue as Variable;
System.Type variableType = selectedVariable.GetType();
// Get operators for the variable
CompareOperator[] compareOperators = VariableCondition.operatorsByVariableType[variableType];
// Create operator list
List <GUIContent> operatorsList = new List <GUIContent>();
foreach (var compareOperator in compareOperators)
{
switch (compareOperator)
{
case CompareOperator.Equals:
operatorsList.Add(new GUIContent("=="));
break;
case CompareOperator.NotEquals:
operatorsList.Add(new GUIContent("!="));
break;
case CompareOperator.LessThan:
operatorsList.Add(new GUIContent("<"));
break;
case CompareOperator.GreaterThan:
operatorsList.Add(new GUIContent(">"));
break;
case CompareOperator.LessThanOrEquals:
operatorsList.Add(new GUIContent("<="));
break;
case CompareOperator.GreaterThanOrEquals:
operatorsList.Add(new GUIContent(">="));
break;
default:
Debug.LogError("The " + compareOperator.ToString() + " operator has no matching GUIContent.");
break;
}
}
// Get previously selected operator
int selectedIndex = System.Array.IndexOf(compareOperators, t._CompareOperator);
if (selectedIndex < 0)
{
// Default to first index if the operator is not found in the available operators list
// This can occur when changing between variable types
selectedIndex = 0;
}
selectedIndex = EditorGUILayout.Popup(
new GUIContent("Compare", "The comparison operator to use when comparing values"),
selectedIndex,
operatorsList.ToArray());
compareOperatorProp.enumValueIndex = (int)compareOperators[selectedIndex];
EditorGUILayout.PropertyField(propByVariableType[variableType]);
serializedObject.ApplyModifiedProperties();
}
public override void DrawCommandGUI()
{
serializedObject.Update();
VariableCondition t = target as VariableCondition;
var flowchart = (Flowchart)t.GetFlowchart();
if (flowchart == null)
{
return;
}
EditorGUILayout.PropertyField(variableProp);
if (variableProp.objectReferenceValue == null)
{
serializedObject.ApplyModifiedProperties();
return;
}
Variable selectedVariable = variableProp.objectReferenceValue as Variable;
System.Type variableType = selectedVariable.GetType();
List <GUIContent> operatorList = new List <GUIContent>();
operatorList.Add(new GUIContent("=="));
operatorList.Add(new GUIContent("!="));
if (variableType == typeof(IntegerVariable) ||
variableType == typeof(FloatVariable))
{
operatorList.Add(new GUIContent("<"));
operatorList.Add(new GUIContent(">"));
operatorList.Add(new GUIContent("<="));
operatorList.Add(new GUIContent(">="));
}
compareOperatorProp.enumValueIndex = EditorGUILayout.Popup(new GUIContent("Compare", "The comparison operator to use when comparing values"),
compareOperatorProp.enumValueIndex,
operatorList.ToArray());
if (variableType == typeof(BooleanVariable))
{
EditorGUILayout.PropertyField(booleanDataProp);
}
else if (variableType == typeof(IntegerVariable))
{
EditorGUILayout.PropertyField(integerDataProp);
}
else if (variableType == typeof(FloatVariable))
{
EditorGUILayout.PropertyField(floatDataProp);
}
else if (variableType == typeof(StringVariable))
{
EditorGUILayout.PropertyField(stringDataProp);
}
serializedObject.ApplyModifiedProperties();
}
public static VariableCondition[] Add(VariableCondition n, VariableCondition[] list)
{
ArrayList tmp = new ArrayList();
foreach(VariableCondition str in list) tmp.Add(str);
tmp.Add(n);
return tmp.ToArray(typeof(VariableCondition)) as VariableCondition[];
}
