public void Should_Genarate_States_Successfully_From_Instructions(string states, HashSet <IState> expected)
{
InstructionsInput input = new InstructionsInput {
instructions = "states: " + states + "\n"
};
Assert.AreEqual(input.PopulateStates(), expected);
}
public void Should_Genarate_Stack_Successfully_From_Instructions(string alphabet, HashSet <ILetter> expected)
{
InstructionsInput input = new InstructionsInput {
instructions = "stack: " + alphabet + "\n"
};
Assert.AreEqual(input.PopulateStack(), expected);
}
public ActionResult <FiniteAutomataEvaluationDTO> EvaluateInstructions([FromBody] InstructionsInput input)
{
try
{
return(Ok(_service.EvaluateFromInstructions(configuration, input)));
}
catch (Exception e)
{
return(BadRequest());
}
}
public static HashSet <IState> MarkFinalStates(this HashSet <IState> states, InstructionsInput input)
{
var result = RegexHelper.Match(input.instructions, Instruction.FINAL_STATES);
var finalStates = result.Trim().Split(InstructionDelimeter.FINAL_STATES_VALUES);
foreach (var state in states)
{
foreach (var finalState in finalStates)
{
if (state.Value.Equals(finalState))
{
state.Final = true;
}
}
}
return(states);
}
public FiniteAutomataEvaluationDTO EvaluateFromInstructions(IConfiguration configuration, InstructionsInput input)
{
this.structure = new FiniteAutomataStructure(input);
this.structure.GenerateOriginalInstructions(configuration);
if (!structure.IsDFA)
{
structure.BuildDFA();
structure.GenerateDFAInstructions(configuration);
}
return(new FiniteAutomataEvaluationDTO(this.structure));
}
public static HashSet <IState> PopulateTransitions(
this HashSet <IState> states,
IAlphabet alphabet,
HashSet <ILetter> stack,
InstructionsInput input)
{
var transitions = RegexHelper.Match(input.instructions, Instruction.TRANSITIONS).Split("\n");
foreach (var transition in transitions)
{
if (String.IsNullOrWhiteSpace(transition))
{
continue;
}
var transitionGroup = transition.Trim().Split(InstructionDelimeter.TRANSITION_FROM_TO);
var transitionFromValues = transitionGroup[0].Trim().Split(InstructionDelimeter.TRANSITION_FROM_VALUES, 2);
var toStateValue = transitionGroup[1].Trim();
var fromStateValue = transitionFromValues[0].Trim();
var transitionLetter = new Letter(transitionFromValues[1].Trim().ToCharArray()[0]);
var transitionValue = new DirectionValue
{
Letter = transitionLetter
};
var pushDownGroup = RegexHelper.Match(transitionFromValues[1], "(?<=\\[)([\\S\\s].*?)*(?=])").Trim();
if (!String.IsNullOrWhiteSpace(pushDownGroup))
{
var pushDownValues = pushDownGroup.Split(",");
var letterToPop = new Letter(pushDownValues[0].Trim().ToCharArray()[0]);
var letterToPush = new Letter(pushDownValues[1].Trim().ToCharArray()[0]);
if ((!letterToPop.IsEpsilon && !stack.Contains(letterToPop)) ||
(!letterToPush.IsEpsilon && !stack.Contains(letterToPush))
)
{
throw new Exception("Invalid push down values!");
}
transitionValue.LetterToPop = letterToPop;
transitionValue.LetterToPush = letterToPush;
}
if (transitionLetter.IsEpsilon && !alphabet.Letters.Contains(transitionLetter))
{
alphabet.Letters.Add(transitionLetter);
}
if (alphabet.Letters.Contains(transitionLetter))
{
foreach (var fromState in states)
{
if (fromState.Value.Equals(fromStateValue))
{
foreach (var toState in states)
{
if (toState.Value.Equals(toStateValue))
{
if (fromState.Directions.ContainsKey(toState))
{
fromState.Directions[toState].Add(transitionValue);
}
else
{
fromState.Directions.Add(toState, new HashSet <DirectionValue>()
{
transitionValue
});
}
}
}
}
}
}
}
return(states);
}
