public object Clone()
{
var res = new State { Fluents = new List<Fluent>() };
foreach (var fluent in Fluents)
res.Fluents.Add(new Fluent{ Name = fluent.Name, Value = fluent.Value });
return res;
}
/// <summary>
/// We check if all fluents of parameter state are equal to matching fluents stored in this object.
/// </summary>
/// <param name="state"></param>
/// <param name="time"></param>
/// <returns></returns>
public bool CheckState(State state, int time)
{
if (!time.Equals(Time))
{
return true;
}
return Expr.Evaluate(state);
}
public bool CheckRecords(State state, WorldAction worldAction, int time)
{
foreach (ScenarioObservationRecord obs in observations)
{
if (!obs.CheckState(state, time))
{
return false;
}
}
return true;
}
private IEnumerable<State> GetPossibleFutureStates(WorldAction worldAction, State state, int time)
{
var possibleFutureStates = new List<State>();
// Get released fluents
var releasedFluents = GetReleasedFluents(worldAction, state, time);
// Get possible state changes from ActionCausesIf records
var actionCausesRec = Descriptions.Where(t => t.Item1 == WorldDescriptionRecordType.ActionCausesIf)
.Select(t => t.Item2 as ActionCausesIfRecord).ToList();
ActionCausesIfRecord causedStatesX = null;
try
{
causedStatesX = actionCausesRec.Where(t => t.IsFulfilled(state, worldAction)).Aggregate((x, y) => x.Concat(y));
}
catch (InvalidOperationException)
{
return new List<State>(){state};
}
var causedStates = causedStatesX.GetResult();
var possibleStateChanges = new List<State>(causedStates.Select(t => new State { Fluents = t.ToList() }));
// Get all future states excluding released fluents changes
foreach (var stateChange in possibleStateChanges)
{
var template = (State)state.Clone();
template.Fluents.RemoveAll(t => stateChange.Fluents.Any(x => x.Name == t.Name));
template.Fluents.AddRange(stateChange.Fluents);
possibleFutureStates.Add(template);
}
// Include released fluents
foreach (var fluent in releasedFluents)
{
var statesToAdd = new List<State>();
foreach (var futureState in possibleFutureStates)
{
var copy = (State)futureState.Clone();
var fluentToRelease = copy.Fluents.First(t => t.Name == fluent.Name);
fluentToRelease.Value = !fluentToRelease.Value;
statesToAdd.Add(copy);
}
possibleFutureStates.AddRange(statesToAdd);
}
if (possibleFutureStates.Count == 0)
{
possibleFutureStates = new List<State>() { state };
}
return possibleFutureStates;
}
public void CheckConditionAtTimeAfterTimeTrue()
{
const int Time = 10;
_query = new ConditionAtTimeQuery(QuestionType.Ever, "aa && bb", Time - 1);
var state = new State();
var fluentList = new List<Fluent>
{
new Fluent("aa", true),
new Fluent("bb", true)
};
state.Fluents.AddRange(fluentList);
QueryResult result = _query.CheckCondition(state, null, Time);
Assert.AreEqual(QueryResult.True, result);
}
public void CheckConditionAtTimeNoTimeQueryResultUndefined()
{
const int Time = 0;
_query = new ConditionAtTimeQuery(QuestionType.Ever, "aa && bb");
var state = new State();
var fluentList = new List<Fluent>
{
new Fluent("aa", true),
new Fluent("bb", false)
};
state.Fluents.AddRange(fluentList);
QueryResult result = _query.CheckCondition(state, null, Time);
Assert.AreEqual(QueryResult.Undefined, result);
}
public void SetUp()
{
_idWorldAction = "idWorldAction";
_startTime = 3;
_durationTime = 5;
_state = new State
{
Fluents = new List<Fluent>{
new Fluent { Name = "a", Value = true },
new Fluent { Name = "b", Value = true },
new Fluent { Name = "c", Value = true },
new Fluent { Name = "d", Value = true }
}
};
_worldAction = new WorldAction(_idWorldAction, _startTime, _durationTime);
}
public override QueryResult CheckCondition(State state, WorldAction worldAction, int actualTime)
{
_logger.Info("Checking condition: " + this._condition + "\nwith parameters:\nstate: " + state + "\naction: " + worldAction);
QueryResult result = this.CheckTime(state, actualTime);
string logResult = "Method result: " + result;
if (QueryResult.Undefined == result)
{
_logger.Warn(logResult);
}
else
{
_logger.Info(logResult);
}
return result;
}
private bool CalculateCondition(State state)
{
var values = new List<Tuple<string, bool>>();
foreach (var name in _fluentNames)
{
var fluent = state.Fluents.FirstOrDefault(x => x.Name == name);
if (fluent != null && fluent.Equals(default(Fluent)))
{
_logger.Warn("Fluent '" + fluent.Name + "' does not exist!");
continue;
}
if (fluent != null)
{
var pair = new Tuple<string, bool>(fluent.Name, fluent.Value);
values.Add(pair);
}
}
return _logicExp.Evaluate(values);
}
public void GetImplications_GetPossibleFutureStates_WithOneRelease_Test()
{
// EXPECTED RESULT: a = true, b = false, c = false, e = true OR a = true, b = false, c = true, e = true
var expectedState1 = new State{
Fluents = new List<Fluent>{
new Fluent { Name = "a", Value = true },
new Fluent { Name = "b", Value = false },
new Fluent { Name = "c", Value = false },
new Fluent { Name = "e", Value = true }
}};
var expectedState2 = new State{
Fluents = new List<Fluent>{
new Fluent { Name = "a", Value = true },
new Fluent { Name = "b", Value = false },
new Fluent { Name = "c", Value = true },
new Fluent { Name = "e", Value = true }
}};
var leaf = new Vertex(_state, action_B_3, 10, null);
var implication = _worldDescription.GetImplications(leaf, 0);
Assert.AreEqual(2, implication.Count);
Assert.NotNull(implication[0].FutureState);
Assert.NotNull(implication[1].FutureState);
var futureState1 = implication[0].FutureState;
var futureState2 = implication[1].FutureState;
var eq11 = futureState1.Equals(expectedState1);
var eq12 = futureState1.Equals(expectedState2);
var eq21 = futureState2.Equals(expectedState1);
var eq22 = futureState2.Equals(expectedState2);
Assert.IsTrue( (eq11 && eq22) ^ (eq12 && eq21) );
}
public abstract QueryResult CheckCondition(State state, WorldAction worldAction, int time);
public void SetUp()
{
_state = new State{
Fluents = new List<Fluent>{
new Fluent { Name = "a", Value = true },
new Fluent { Name = "b", Value = true },
new Fluent { Name = "c", Value = true },
new Fluent { Name = "e", Value = true }
}};
var fluentC = new Fluent { Name = "c", Value = true };
_worldDescription = new WorldDescription();
// INITIALLY
_worldDescription.Descriptions.Add(new Tuple<WorldDescriptionRecordType, WorldDescriptionRecord>(WorldDescriptionRecordType.Initially, new InitialRecord("a || b || c || e")));
// ACTION CAUSES IF
_worldDescription.Descriptions.Add(new Tuple<WorldDescriptionRecordType, WorldDescriptionRecord>(WorldDescriptionRecordType.ActionCausesIf, new ActionCausesIfRecord(action_A_2, "a && !b", "c")));
_worldDescription.Descriptions.Add(new Tuple<WorldDescriptionRecordType, WorldDescriptionRecord>(WorldDescriptionRecordType.ActionCausesIf, new ActionCausesIfRecord(action_B_3, "a || b", "e")));
_worldDescription.Descriptions.Add(new Tuple<WorldDescriptionRecordType, WorldDescriptionRecord>(WorldDescriptionRecordType.ActionCausesIf, new ActionCausesIfRecord(action_B_3, "!b && !c", "e")));
// RELEASE FLUENT
_worldDescription.Descriptions.Add(new Tuple<WorldDescriptionRecordType, WorldDescriptionRecord>(WorldDescriptionRecordType.ActionReleasesIf, new ActionReleasesIfRecord(action_B_3, fluentC, "e || c")));
}
private List<State> CreateStatesBasedOnObservations(List<string> fluentNames, ScenarioDescription scenarioDescription, ref int time)
{
List<State> states = new List<State>();
time = scenarioDescription.GetNextObservationTime(0);
if (time == -1 || time > _TInf)
{
return states;
}
ScenarioObservationRecord observation = scenarioDescription.GetObservationFromTime(time);
if (observation == null)
{
_logger.Warn("Scenario has no observations!");
State state = new State();
state.AddFluents(fluentNames);
states.Add(state);
}
else
{
_logicExpression = new SimpleLogicExpression(observation.Expr as SimpleLogicExpression);
List<Fluent[]> possibleInitialValues = _logicExpression.CalculatePossibleFluents();
foreach (var valuation in possibleInitialValues)
{
State state = new State();
state.AddFluents(fluentNames);
foreach (var fluent in valuation)
{
try
{
state.Fluents.First(f => f.Name == fluent.Name).Value = fluent.Value;
}
catch (System.ArgumentNullException)
{
_logger.Error("Fluent " + fluent.Name + " doesn't exist!");
}
}
states.Add(state);
}
}
return states;
}
private IEnumerable<WorldAction> GetTriggeredActions(WorldAction worldAction, State state, int time)
{
var actionInvokesRecords = Descriptions.Where(t => t.Item1 == WorldDescriptionRecordType.ActionInvokesAfterIf)
.Select(t => t.Item2 as ActionInvokesAfterIfRecord).ToList();
var expressionTriggersRecords = Descriptions.Where(t => t.Item1 == WorldDescriptionRecordType.ExpressionTriggersAction)
.Select(t => t.Item2 as ExpressionTriggersActionRecord).ToList();
var triggeredActions = actionInvokesRecords.Where(t => t.IsFulfilled(state, worldAction)).Select(t => t.GetResult(time)).ToList();
triggeredActions.AddRange(expressionTriggersRecords.Where(t => t.IsFulfilled(state)).Select(t => t.GetResult(time)));
return triggeredActions;
}
private IEnumerable<Fluent> GetReleasedFluents(WorldAction worldAction, State state, int time)
{
var actionReleaseRecords = Descriptions.Where(t => t.Item1 == WorldDescriptionRecordType.ActionReleasesIf)
.Select(t => t.Item2 as ActionReleasesIfRecord).ToList();
var releasedFluents = actionReleaseRecords.Where(t => t.IsFulfilled(state, worldAction)).Select(t => t.GetResult(time));
return releasedFluents;
}
private QueryResult CheckTime(State state, int actualTime)
{
var result = QueryResult.Undefined;
if (-1 == _time)
{
result = CheckValuation(state);
if (result != QueryResult.True)
{
result = QueryResult.False == result ? QueryResult.Undefined : QueryResult.False;
}
}
else if (_time <= actualTime)
{
result = CheckValuation(state);
}
else
{
result = QueryResult.Undefined;
}
return result;
}
public bool Evaluate(State state)
{
if (_expression == null || _expression.Equals(string.Empty))
{
return true;
}
var expression = new CompiledExpression(this._expression);
expression.RegisterType("h", typeof(ExpressionHelper));
if (state != null)
{
foreach (var fluent in state.Fluents)
{
expression.RegisterType(fluent.Name, fluent.Value);
}
}
return (bool)expression.Eval();
}
private QueryResult CheckValuation(State state)
{
bool valuation = CalculateCondition(state);
QueryResult result = valuation ? QueryResult.True : QueryResult.False;
_logger.Info("Condition value:\ncondition: " + _condition + "result: " + result);
return result;
}
