public DFA Determinize() { if (IsDeterministic()) { return(new DFA(states, sigma, initialState, transitions)); } States pStates = new States(); State pInitialState = new State("{" + initialState.Name + "}", initialState.IsFinal); Transitions pTransitions = new Transitions(); Queue <States> queue = new Queue <States>(); queue.Enqueue(new States { initialState }); State sink = new State("{}"); bool sinkRequired = false; while (queue.Count > 0) { States current = queue.Dequeue(); if (pStates.Any(s => s.ToString().Equals(current.ToString()))) { continue; } State curr = new State(current.ToString(), current.Any(s => s.IsFinal)); pStates.Add(curr); foreach (string letter in sigma) { States next = new States(); foreach (State s in current) { try { foreach (State rState in transitions[(s, letter)])
public IEnumerable <FTPEntry> GetByFileState(int Skip, int Take, bool HasParents = false, params StateFile[] States) { return(Entities .Find(f => f.IsActive && States.Any(i => i == f.State) && ((HasParents && f.Parent != null) || (!HasParents && f.Parent == null))) .Skip(Skip) .Limit(Take) .ToEnumerable()); }
public void Tick() { CurrentTaskTimeout--; switch (CurrentState) { case CurrentStateType.WaitingInCenter: { if (States.Any(s => s.CurrentState == CurrentStateType.MovingTowardCenter) && CurrentTaskTimeout > 0) { break; } StartMovingTowardExplosion(); break; } case CurrentStateType.MovingToExplosionPoint: if (!DestinationsFulfilled && CurrentTaskTimeout > 0) { break; } StartExploding(); break; case CurrentStateType.Exploding: if (!DestinationsFulfilled && CurrentTaskTimeout > 0) { break; } CurrentState = CurrentStateType.WaitingInCircle; CurrentTaskTimeout = 3000; break; case CurrentStateType.WaitingInCircle: if (States.Any(s => s.CurrentState == CurrentStateType.Exploding || s.CurrentState == CurrentStateType.MovingToExplosionPoint) && CurrentTaskTimeout > 0) { break; } StartMovingTowardCenter(); break; case CurrentStateType.MovingTowardCenter: if (!DestinationsFulfilled && CurrentTaskTimeout > 0) { break; } CurrentState = CurrentStateType.WaitingInCenter; CurrentTaskTimeout = 2000; break; default: throw new ArgumentOutOfRangeException(); } }
public override JsonObject ExportStatusToJsonObject() { var status = base.ExportStatusToJsonObject(); if (States.Any()) { status.SetNamedValue("state", States[_index].Id.ToJsonValue()); } return(status); }
public NFA(States states, Alphabet sigma, State initialState, Transitions transitions) { this.states = states; this.sigma = sigma; this.initialState = initialState; this.transitions = transitions; if (!states.Any(s => s.Name.Equals(initialState.Name))) { throw new ArgumentException("Initial state must be contained in states!"); } }
private string FormatStates() { if( States == null || !States.Any() ) return String.Empty; string output = String.Empty; foreach( var scriptState in States ) { output += "\r\n" + scriptState.Decompile() + "\r\n"; } return output; }
private bool ProceedBackward() { if (States.Any()) { // Есть куда возвращаться CurrentState = States.Pop(); return(true); } else { // Некуда возвращаться, решения нет return(false); } }
public List <ValidationError> ValidateWorkflow() { List <ValidationError> errors = new List <ValidationError> (); if (!States.Any(s => s.Name == CurrentState)) { errors.Add(new ValidationError("Invalid current state")); } foreach (var state in States) { foreach (var t in state.Transitions) { if (!States.Any(s => s.Name == t.StateName)) { String message = "Invalid transition to state " + t.StateName + " from state " + state.Name; errors.Add(new ValidationError(message)); } foreach (var r in t.Rules) { var rule = CommandManager.GetCommand <IRule> (r.Name); if (rule == null) { errors.Add(new ValidationError("Invalid rule: " + r.Name)); } } foreach (var a in t.Actions) { var rule = CommandManager.GetCommand <IAction> (a.Name); if (rule == null) { errors.Add(new ValidationError("Invalid action: " + a.Name)); } } if (!AuthManager.PermissionIsValid(t.Permission)) { errors.Add(new ValidationError("Invalid permission " + t.Permission)); } } } return(errors); }
public int GetCategoryIndex(string category) { if (States.Any(x => x.Category == category)) { return(States.First(x => x.Category == category).CategoryIndex); } if (States.Count == 0) { return(1); } int highestCatIndex = States.Max(x => x.CategoryIndex); return(highestCatIndex + 1); }
void OnValidate() { if (Application.isPlaying) { return; } AnimatorController preview = Animator.runtimeAnimatorController as AnimatorController; if (!preview || preview.name != "UIPlayable Preview") { preview = new AnimatorController(); preview.name = "UIPlayable Preview"; preview.hideFlags = HideFlags.DontSave; preview.AddLayer("Base Layer"); preview.AddLayer("Preview Layer"); preview.layers[1].defaultWeight = 0; Animator.runtimeAnimatorController = preview; } foreach (var childAnimatorState in preview.layers[1].stateMachine.states) { var animatorState = childAnimatorState.state; bool exist = States.Any(state => state.Animation == animatorState.motion || state.LoopAnimation == animatorState.motion); if (!exist) { preview.RemoveLayer(1); preview.AddLayer("Preview Layer"); preview.layers[1].defaultWeight = 0; break; } } foreach (State state in States) { if (state.Animation) { AddMotionIfNotExist(preview, state.Animation); } if (state.LoopAnimation) { AddMotionIfNotExist(preview, state.LoopAnimation); } } }
public IState <TIn, TOut> AddState(IState <TIn, TOut> state) { if (state == null) { return(null); } if (States.Any(s => s.GUID == state.GUID)) { // We already have this state registered return(state); } if (RootState.Value == null) { // Set this to be the root state if none exists RootState = new Reference <IState <TIn, TOut> >(state); } state.Definition = this; States.Add(state); return(state); }
public Order InTransit() { if (!States.Any()) { throw new OrderStatesNotFoundBusinessException(); } var stateName = States.OrderByDescending(x => x.CreatedDate).FirstOrDefault().StateName; if (stateName != Consts.Order.Collecting) { throw new OrderStateIsNotValidBusinessException(); } States.Add(new State { CreatedDate = DateTime.Now, StateName = Consts.Order.InTransit }); return(this); }
private FA(State start, State final, IEnumerable <State> states) { Start = start; Final = final; States = states.Select((state, i) => { state.Id = i; return(state); }).ToList(); if (final == null) { if (!States.Any(state => state.IsFinal)) { Debug.Assert(false, "no final state in DFA"); } } else { if (States.Any(state => state.IsFinal)) { Debug.Assert(false, "final state in NFA"); } } }
public bool Validate() { if (States == null) { throw new ArgumentException("StateMachine: States are not defined"); } if (!States.Any(_ => _.StartPoint)) { throw new ArgumentException("StateMachine: initial state is not defined"); } if (States.Count(_ => _.StartPoint) > 1) { throw new ArgumentException("StateMachine: too many initial states"); } if (!States.Any(_ => _.EndPoint)) { throw new ArgumentException("StateMachine: final state is not defined"); } return(true); }
public bool IsCurrent(T applicationState) { return(States.Any() && States.Last().Equals(applicationState)); }