public void Add(Sequence <T> sequence)
{
PredictionTree <T> lastNode = null;
if (!sequence.Any())
{
throw new InvalidOperationException("Sequence cannot be empty.");
}
if (tree == null)
{
lastNode = tree = new PredictionTree <T>(sequence.Head, null);
if (sequence.Tail.Any())
{
lastNode = tree.Add(sequence.Tail);
}
}
else
{
lastNode = tree.Add(sequence);
}
index.Add(sequence);
lookup.Add(sequence.Id, lastNode);
}
public void Learn(IEnumerable <T> sample)
{
Sequence <T> sequence = new Sequence <T>(++sampleCount, splitLength == 0 ? sample : sample.TakeLast(splitLength));
PredictionTree <T> lastNode = null;
if (!sequence.Any())
{
throw new InvalidOperationException("Sequence cannot be empty.");
}
if (tree == null)
{
lastNode = tree = new PredictionTree <T>(sequence.Head, null);
if (sequence.Tail.Any())
{
lastNode = tree.Add(sequence.Tail);
}
}
else
{
lastNode = tree.Add(sequence);
}
invertedIndex.Add(sequence);
lookupTable.Add(sequence.Id, lastNode);
}
public void TestAnyAndAdds2Failed()
{
var sequence = new Sequence().AddIgnoreSymbol(' ');
UnitError error = null;
var isLexem1Available = false;
var isLexem2Available = false;
var isAddLexem1Available = false;
var isAddLexem2Available = false;
//-----------------------------------------------------------------
sequence
.Any(
new StringUnit("lexem").Action(() => isLexem1Available = true),
new StringUnit("pop").Action(() => isLexem2Available = true)
)
.Add(
new StringUnit("xxx").Action(() => isAddLexem1Available = true),
new SymbolUnit(' '),
new StringUnit("ddd").Action(() => isAddLexem2Available = true)
)
.Error(x => error = x);
//-----------------------------------------------------------------
var result = sequence.DecodeLine(" xxx y");
Assert.IsFalse(result);
Assert.IsFalse(isLexem1Available);
Assert.IsFalse(isLexem2Available);
Assert.IsFalse(isAddLexem1Available);
Assert.IsFalse(isAddLexem2Available);
Assert.IsTrue(error.PositionInLine == 5);
Assert.IsTrue(string.Equals(((StringUnit)error.Unit).OriginalValue, "ddd", StringComparison.OrdinalIgnoreCase));
}
public PredictionTree <T> Add(Sequence <T> sequence)
{
if (!sequence.Any())
{
throw new InvalidOperationException("Sequence cannot be empty.");
}
var head = sequence.Head;
var tail = sequence.Tail;
PredictionTree <T> node = null;
if (Contains(head))
{
node = Get(head);
}
else
{
node = Add(head);
}
if (tail != null && tail.Any())
{
return(node.Add(tail));
}
else
{
return(node);
}
}
public void TestAnyAndAny1Failed()
{
var sequence = new Sequence().AddIgnoreSymbol(' ');
UnitError error = null;
var isLexem1Available = false;
var isLexem2Available = false;
var isLexem3Available = false;
//-----------------------------------------------------------------
sequence
.Any(new StringUnit("lexem")
.Action(() => isLexem1Available = true),
new StringUnit("pop")
.Action(() => isLexem2Available = true)
)
.Any(new StringUnit("xxx").Action(() => isLexem3Available = true))
.Error(x => error = x);
//-----------------------------------------------------------------
var result = sequence.DecodeLine("xxx pop");
Assert.IsFalse(result);
Assert.IsFalse(isLexem1Available);
Assert.IsFalse(isLexem2Available);
Assert.IsFalse(isLexem3Available);
Assert.IsTrue(error.PositionInLine == 4);
Assert.IsTrue(error.Unit == null);
}
public void TestAnyAndAdds3Success()
{
var sequence = new Sequence().AddIgnoreSymbol(' ');
UnitError error = null;
var isLexem1Available = false;
var isLexem2Available = false;
var isAddLexem1Available = false;
var isAddLexem2Available = false;
//-----------------------------------------------------------------
sequence
.Any(
new StringUnit("lexem").Action(() => isLexem1Available = true),
new StringUnit("pop").Action(() => isLexem2Available = true)
)
.Add(
new StringUnit("xxx").Action(() => isAddLexem1Available = true),
new SymbolUnit(' '),
new StringUnit("ddd").Action(() => isAddLexem2Available = true)
)
.Error(x => error = x);
//-----------------------------------------------------------------
var result = sequence.DecodeLine(" xxx ddd");
Assert.IsTrue(result);
Assert.IsFalse(isLexem1Available);
Assert.IsFalse(isLexem2Available);
Assert.IsTrue(isAddLexem1Available);
Assert.IsTrue(isAddLexem2Available);
Assert.IsTrue(error == null);
}
public void Test2BoardFailed()
{
var sequence = new Sequence().AddIgnoreSymbol(' ');
//-----------------------------------------------------------------
UnitError error = null;
//-----------------------------------------------------------------
sequence
.If(
new ValueUnit(),
new SymbolUnit(','),
new ValueUnit()
);
sequence
.Else(
new ValueUnit()
);
sequence.Any(
sequence.CreateListContainer(new SymbolUnit(' '), new StringUnit(_SlavingLexemName)),
sequence.CreateListContainer(new SymbolUnit(' '), new StringUnit(_UserLexemName))
);
sequence
.Error(x => error = x);
//-----------------------------------------------------------------
var result = sequence.DecodeLine("8,12 d");
Assert.IsFalse(result);
Assert.IsTrue(error.PositionInLine == 5);
Assert.IsTrue(error.Unit == null);
}
//--------------------------------------------------------------------------------------------------------------------
// - Stop Playing Animation
//--------------------------------------------------------------------------------------------------------------------
public void Stop()
{
if (Sequence.Any())
{
// Reset cursor position on Stop
Cursor.Reset();
Cursor.MoveNext();
Index = (uint)Cursor.Current;
playing_ = false;
}
}
public void TestAnys3Success()
{
var sequence = new Sequence().AddIgnoreSymbol(' ');
UnitError error = null;
var lexemCountAvailable = 0;
//-----------------------------------------------------------------
sequence
.Any(2, new StringUnit("lexem").Action(() => ++ lexemCountAvailable))
.Error(x => error = x);
//-----------------------------------------------------------------
var result = sequence.DecodeLine("");
Assert.IsTrue(result);
Assert.IsTrue(lexemCountAvailable == 0);
Assert.IsTrue(error == null);
}
public FlatDomain <bool> IsTrueImply(APC pc, Sequence <BoxedExpression> positiveAssumptions, Sequence <BoxedExpression> negativeAssumptions, BoxedExpression goal)
{
UnaryOperator op;
BoxedExpression arg;
while (goal.IsUnaryExpression(out op, out arg) && op.IsConversionOperator())
{
goal = arg;
}
if (positiveAssumptions.Any(assumption => assumption.Equals(goal)))
{
return(ProofOutcome.True);
}
return(ProofOutcome.Top);
}
public void TestAnys1Failed()
{
var sequence = new Sequence().AddIgnoreSymbol(' ');
UnitError error = null;
var lexemCountAvailable = 0;
//-----------------------------------------------------------------
sequence
.Any(2, new StringUnit("lexem").Action(() => ++ lexemCountAvailable))
.Error(x => error = x);
//-----------------------------------------------------------------
var result = sequence.DecodeLine("lexem lexem lexem");
Assert.IsFalse(result);
Assert.IsTrue(lexemCountAvailable == 0);
Assert.IsTrue(error != null);
Assert.IsTrue((error.Unit).IsFirstSymbol(error.Line[error.PositionInLine]));
}
private static Predicate <Pair <EdgeTag, Subroutine> > FilterRecursiveContracts(CFGBlock from, Sequence <Edge <CFGBlock, EdgeTag> > context)
{
return((candidate) => {
Subroutine sub = candidate.Value;
if (!sub.IsContract)
{
return true;
}
if (sub == @from.Subroutine)
{
return false;
}
if (context.Any(ctx => sub == ctx.From.Subroutine))
{
return false;
}
return true;
});
}
public void Tes2BoardSuccess()
{
var sequence = new Sequence().AddIgnoreSymbol(' ');
//-----------------------------------------------------------------
var shelfValue = "";
var slotValue = "";
var isSlavingAvailable = false;
var isUserAvailable = false;
UnitError error = null;
//-----------------------------------------------------------------
var shelfValueAction = new Action <ValueUnit>(x => shelfValue = x.Value);
var slotValueAction = new Action <ValueUnit>(x => slotValue = x.Value);
var slavingAction = new Action(() => isSlavingAvailable = true);
var userAction = new Action(() => isUserAvailable = true);
//-----------------------------------------------------------------
sequence
.If(
new ValueUnit().Action(shelfValueAction),
new SymbolUnit(','),
new ValueUnit().Action(slotValueAction)
);
sequence
.Else(
new ValueUnit().Action(slotValueAction)
);
sequence.Any(
sequence.CreateListContainer(new SymbolUnit(' '), new StringUnit(_SlavingLexemName).Action(slavingAction)),
sequence.CreateListContainer(new SymbolUnit(' '), new StringUnit(_UserLexemName).Action(userAction))
);
sequence
.Error(x => error = x);
//-----------------------------------------------------------------
var result = sequence.DecodeLine($"8,12 {_SlavingLexemName}");
Assert.IsTrue(result);
Assert.IsTrue(string.Equals(shelfValue, "8", StringComparison.OrdinalIgnoreCase));
Assert.IsTrue(string.Equals(slotValue, "12", StringComparison.OrdinalIgnoreCase));
Assert.IsTrue(isSlavingAvailable);
Assert.IsFalse(isUserAvailable);
Assert.IsTrue(error == null);
}
public void Test2Failed()
{
var sequence = new Sequence().AddIgnoreSymbol(' ');
//-----------------------------------------------------------------
var shelfValue = "";
var slotValue = "";
var channelValue = "";
var numberValue = "";
var raniValue = false;
var aniValue = "";
var ani2Value = "";
var arouteDelayValue = "";
var arouteNumValue = "";
var prioValue = "";
var infoValue = "";
var attribValue = "";
UnitError error = null;
//-----------------------------------------------------------------
var shelfValueAction = new Action <ValueUnit>(x => shelfValue = x.Value);
var slotValueAction = new Action <ValueUnit>(x => slotValue = x.Value);
var channelValueAction = new Action <ValueUnit>(x => channelValue = x.Value);
var numberValueAction = new Action <ValueUnit>(x => numberValue = x.Value);
var raniValueAction = new Action(() => raniValue = true);
var aniValueAction = new Action <ValueUnit>(x => aniValue = x.Value);
var ani2ValueAction = new Action <ValueUnit>(x => ani2Value = x.Value);
var arouteDelayValueAction = new Action <ValueUnit>(x => arouteDelayValue = x.Value);
var arouteNumValueAction = new Action <ValueUnit>(x => arouteNumValue = x.Value);
var prioValueAction = new Action <ValueUnit>(x => prioValue = x.Value);
var infoValueAction = new Action <ValueUnit>(x => infoValue = x.Value);
var attribValueAction = new Action <ValueUnit>(x => attribValue = x.Value);
//-----------------------------------------------------------------
sequence
.If(
new StringUnit("loc"),
new SymbolUnit('('),
new ValueUnit().Action(shelfValueAction),
new SymbolUnit(','),
new ValueUnit().Action(slotValueAction),
new SymbolUnit(','),
new ValueUnit().Action(channelValueAction),
new SymbolUnit(','),
new ValueUnit().Action(numberValueAction),
new SymbolUnit(')')
);
sequence
.Else(
new StringUnit("loc"),
new SymbolUnit('('),
new ValueUnit().Action(slotValueAction),
new SymbolUnit(','),
new ValueUnit().Action(channelValueAction),
new SymbolUnit(','),
new ValueUnit().Action(numberValueAction),
new SymbolUnit(')')
);
sequence
.Any(
sequence.CreateListContainer(new SymbolUnit(' '), new StringUnit("rani").Action(raniValueAction)),
sequence.CreateListContainer(new SymbolUnit(' '), new StringUnit("ani-"), new ValueUnit().Action(aniValueAction)),
sequence.CreateListContainer(new SymbolUnit(' '), new StringUnit("ani2-"), new ValueUnit().Action(ani2ValueAction)),
sequence.CreateListContainer(
new SymbolUnit(' '),
new StringUnit("aroute"),
new SymbolUnit('('),
new ValueUnit().Action(arouteDelayValueAction),
new SymbolUnit(','),
new ValueUnit().Action(arouteNumValueAction),
new SymbolUnit(')')
),
sequence.CreateListContainer(new SymbolUnit(' '), new StringUnit("prio-"), new ValueUnit().Action(prioValueAction)),
sequence.CreateListContainer(
new SymbolUnit(' '),
new StringUnit("info"),
new SymbolUnit('('),
new ValueUnit().Action(infoValueAction),
new SymbolUnit(')')
),
sequence.CreateListContainer(new SymbolUnit(' '), new StringUnit("attr-"), new ValueUnit().Action(attribValueAction))
)
.Error(x => error = x);
//-----------------------------------------------------------------
//-----------------------------------------------------------------
var result = sequence.DecodeLine("loc(6,1,2,3) attr-111 rani aki-23 prio-dd ani2-33");
Assert.IsFalse(result);
Assert.IsTrue(string.IsNullOrEmpty(shelfValue));
Assert.IsTrue(string.IsNullOrEmpty(slotValue));
Assert.IsTrue(string.IsNullOrEmpty(channelValue));
Assert.IsTrue(string.IsNullOrEmpty(numberValue));
Assert.IsFalse(raniValue);
Assert.IsTrue(string.IsNullOrEmpty(aniValue));
Assert.IsTrue(string.IsNullOrEmpty(ani2Value));
Assert.IsTrue(string.IsNullOrEmpty(arouteDelayValue));
Assert.IsTrue(string.IsNullOrEmpty(arouteNumValue));
Assert.IsTrue(string.IsNullOrEmpty(prioValue));
Assert.IsTrue(string.IsNullOrEmpty(infoValue));
Assert.IsTrue(string.IsNullOrEmpty(attribValue));
Assert.IsTrue(error.PositionInLine == 28);
Assert.IsTrue(error.Unit == null);
}
public void Test4Success()
{
var sequence = new Sequence().AddIgnoreSymbol(' ');
//-----------------------------------------------------------------
var shelfValue = "";
var slotValue = "";
var channelValue = "";
var numberValue = "";
var raniValue = false;
var aniValue = "";
var ani2Value = "";
var arouteDelayValue = "";
var arouteNumValue = "";
var prioValue = "";
var infoValue = "";
var attribValue = "";
UnitError error = null;
//-----------------------------------------------------------------
var shelfValueAction = new Action <ValueUnit>(x => shelfValue = x.Value);
var slotValueAction = new Action <ValueUnit>(x => slotValue = x.Value);
var channelValueAction = new Action <ValueUnit>(x => channelValue = x.Value);
var numberValueAction = new Action <ValueUnit>(x => numberValue = x.Value);
var raniValueAction = new Action(() => raniValue = true);
var aniValueAction = new Action <ValueUnit>(x => aniValue = x.Value);
var ani2ValueAction = new Action <ValueUnit>(x => ani2Value = x.Value);
var arouteDelayValueAction = new Action <ValueUnit>(x => arouteDelayValue = x.Value);
var arouteNumValueAction = new Action <ValueUnit>(x => arouteNumValue = x.Value);
var prioValueAction = new Action <ValueUnit>(x => prioValue = x.Value);
var infoValueAction = new Action <ValueUnit>(x => infoValue = x.Value);
var attribValueAction = new Action <ValueUnit>(x => attribValue = x.Value);
//-----------------------------------------------------------------
sequence
.If(
new StringUnit("loc"),
new SymbolUnit('('),
new ValueUnit().Action(shelfValueAction),
new SymbolUnit(','),
new ValueUnit().Action(slotValueAction),
new SymbolUnit(','),
new ValueUnit().Action(channelValueAction),
new SymbolUnit(','),
new ValueUnit().Action(numberValueAction),
new SymbolUnit(')')
);
sequence
.Else(
new StringUnit("loc"),
new SymbolUnit('('),
new ValueUnit().Action(slotValueAction),
new SymbolUnit(','),
new ValueUnit().Action(channelValueAction),
new SymbolUnit(','),
new ValueUnit().Action(numberValueAction),
new SymbolUnit(')')
);
sequence
.Any(
sequence.CreateListContainer(new SymbolUnit(' '), new StringUnit("rani").Action(raniValueAction)),
sequence.CreateListContainer(new SymbolUnit(' '), new StringUnit("ani-"), new ValueUnit().Action(aniValueAction)),
sequence.CreateListContainer(new SymbolUnit(' '), new StringUnit("ani2-"), new ValueUnit().Action(ani2ValueAction)),
sequence.CreateListContainer(
new SymbolUnit(' '),
new StringUnit("aroute"),
new SymbolUnit('('),
new ValueUnit().Action(arouteDelayValueAction),
new SymbolUnit(','),
new ValueUnit().Action(arouteNumValueAction),
new SymbolUnit(')')
),
sequence.CreateListContainer(new SymbolUnit(' '), new StringUnit("prio-"), new ValueUnit().Action(prioValueAction)),
sequence.CreateListContainer(
new SymbolUnit(' '),
new StringUnit("info"),
new SymbolUnit('('),
new ValueUnit().Action(infoValueAction),
new SymbolUnit(')')
),
sequence.CreateListContainer(new SymbolUnit(' '), new StringUnit("attr-"), new ValueUnit().Action(attribValueAction))
)
.Error(x => error = x);
//-----------------------------------------------------------------
//-----------------------------------------------------------------
var result = sequence.DecodeLine("loc(6,1,2,3)");
Assert.IsTrue(result);
Assert.IsTrue(string.Equals(shelfValue, "6", StringComparison.OrdinalIgnoreCase));
Assert.IsTrue(string.Equals(slotValue, "1", StringComparison.OrdinalIgnoreCase));
Assert.IsTrue(string.Equals(channelValue, "2", StringComparison.OrdinalIgnoreCase));
Assert.IsTrue(string.Equals(numberValue, "3", StringComparison.OrdinalIgnoreCase));
Assert.IsFalse(raniValue);
Assert.IsTrue(string.IsNullOrEmpty(aniValue));
Assert.IsTrue(string.IsNullOrEmpty(ani2Value));
Assert.IsTrue(string.IsNullOrEmpty(arouteDelayValue));
Assert.IsTrue(string.IsNullOrEmpty(arouteNumValue));
Assert.IsTrue(string.IsNullOrEmpty(prioValue));
Assert.IsTrue(string.IsNullOrEmpty(infoValue));
Assert.IsTrue(string.IsNullOrEmpty(attribValue));
Assert.IsTrue(error == null);
}
public bool Contains(TVar var)
{
return(variables.Any(v => v.Equals(var)));
}
