public void Deve_Popular_Id_Pelo_Construtor() { const int id = 1; var transicao = new Transicao(id); transicao.Id.Should().Be(id); }
// Use this for initialization void Start () { Propriedade<float> propriedade1 = new Propriedade<float>("propriedade1", 9); sistema.AdicionarPropriedade(propriedade1); Estado estado1 = new Estado("estado1",sistema); sistema.AdicionarEstado(estado1); Estado estado2 = new Estado("estado2", sistema); sistema.AdicionarEstado(estado2); Transicao transicao = new Transicao("valor maior que dez",estado1,estado2,sistema); sistema.AdicionarTransicao(transicao); Func<float, bool> comparacao = x => { return x > 10; }; Condicao<float> condicao = new Condicao<float>("maior", comparacao, transicao); transicao.AdicionarCondicao(condicao); Transicao transicao2 = new Transicao("valor menor que dez", estado2, estado1, sistema); sistema.AdicionarTransicao(transicao2); Func<float, bool> comparacao2 = x => { return x < 10; }; Condicao<float> condicao2 = new Condicao<float>("menor", comparacao2, transicao2); transicao2.AdicionarCondicao(condicao2); propriedade1.RegistrarObservador(condicao); propriedade1.RegistrarObservador(condicao2); sistema.SetarEstadoInicial(estado1.nome); }
// Adiciona várias transições no autômato public void addTransicao(string e1, string s, HashSet <string> e2) { Transicao t = GeraTransicao(e1, s, e2); Transicao te = new Transicao(); if (estados.Contains(t.estado1) & simbolos.Contains(t.simbolo) & estados.IsSupersetOf(t.estado2)) { KeyTransicao temp = new KeyTransicao(t.estado1, t.simbolo); if (!transicoes.ContainsKey(temp)) { transicoes.Add(temp, t); } else { transicoes.TryGetValue(temp, out te); foreach (string item in t.estado2) { if (!te.estado2.Contains(item)) { te.estado2.Add(item); } } } } }
public void analisar(string arquivoEntrada, AutomatoFinito automatoFinito, ref List <TabelaSimbolos> tokensReconhecidos, ref List <string> erros) { lerArquivo(arquivoEntrada); string textoLinha; for (int numeroLinha = 0; numeroLinha < _listaEntrada.Count; numeroLinha++) { // passa cada linha textoLinha = _listaEntrada[numeroLinha]; textoLinha = textoLinha.Replace(System.Environment.NewLine, " "); // remove quebra de linha e poe espaço List <string> matches = new List <string>(); // insere espaço antes dos operadores para separar foreach (System.Text.RegularExpressions.Match m in Utilidades.expressaoOperadores.Matches(textoLinha)) { if (matches.Contains(m.Value)) { continue; } matches.Insert(0, m.Value); textoLinha = textoLinha.Replace(matches[0], " " + matches[0] + " "); } _listaEntrada[numeroLinha] = Utilidades.expressaoEspacosDuplos.Replace(textoLinha, " ").Trim(); // remove espaços duplos string[] tokens = _listaEntrada[numeroLinha].Split(' '); // separa cada token pelo separador foreach (var token in tokens) { // passa cada token da linha Estado estadoAtual = automatoFinito.estados[0]; // estado inicial for (int i = 0; i < token.Length; i++) { // passa cada caractere do token // verifica se tem uma transição para esse caractere/simbolo // como ta determinizado, só tem uma ou nenhuma trasição por esse caractere/simbolo Transicao transicaoSimbolo = (estadoAtual.transicoes.Where(x => x.simbolo.Equals(token[i]))).FirstOrDefault(); if (transicaoSimbolo == null) { // não encontrou transição, leva o índice para a última posição i = token.Length - 1; } else { estadoAtual = transicaoSimbolo.estadoDestino; } if (i == token.Length - 1) // encontrou um separador { if (!estadoAtual.final || transicaoSimbolo == null) { // erro erros.Add("Linha " + (numeroLinha + 1) + ": a sequência de símbolos " + token + " não é reconhecida como sentença..."); } else { // token reconhecido tokensReconhecidos.Add(new TabelaSimbolos(tokensReconhecidos.Count(), token, estadoAtual, numeroLinha + 1)); } } } } } }
private bool elimEstMorto(ref Automato automato, ref Dictionary <string, bool> visitados, string estado) { bool ret = false; if (visitados.ContainsKey(estado)) { visitados.TryGetValue(estado, out ret); return(ret); } else { visitados.Add(estado, automato.estadosFinais.Contains(estado)); foreach (string s in automato.simbolos) { Transicao t = automato.GetTransicao(estado, s); foreach (string e2 in t.estado2) { if (elimEstMorto(ref automato, ref visitados, e2)) { ret = true; } } } } visitados.Remove(estado); visitados.Add(estado, ret | automato.estadosFinais.Contains(estado)); return(ret); }
public void Deve_Habilitar_Transicao_Quando_Tiver_Arco_Inibidor_Com_Peso_Maior_Que_Marcas() { var transicao = new Transicao(1); transicao.CriarArcoEntrada(new Lugar(1, 2), 3, TipoArco.Inibidor); transicao.EstáHabilitada.Should().BeTrue(); }
public void Nao_Deve_Habilitar_Transicao_Quando_Tiver_Arco_Inibidor_Com_Peso_Menor_Que_Marcas(int qtdMarcasLugar, int pesoArco) { var transicao = new Transicao(1); transicao.CriarArcoEntrada(new Lugar(1, qtdMarcasLugar), pesoArco, TipoArco.Inibidor); transicao.EstáHabilitada.Should().BeFalse(); }
public void Deve_Habilitar_Transicao_Com_Arco_Reset_Sempre(int qtdMarcasLugar, int pesoArco) { var transicao = new Transicao(1); transicao.CriarArcoEntrada(new Lugar(1, qtdMarcasLugar), pesoArco, TipoArco.Reset); transicao.EstáHabilitada.Should().BeTrue(); }
public void Deve_Habilitar_Transicao_Quando_Tiver_Arco_Normal_Com_Peso_Menor_Ou_Igual_Que_Marcas_Do_Lugar(int qtdMarcasLugar, int pesoArco) { var transicao = new Transicao(1); transicao.CriarArcoEntrada(new Lugar(1, qtdMarcasLugar), pesoArco, TipoArco.Normal); transicao.EstáHabilitada.Should().BeTrue(); }
//------------------------------------------------------------------- public void addTransition(int destino, ArrayList condicao, float probab) { Transicao t = new Transicao(); t.destino = destino; t.condicao = condicao; t.probabilidade = probab; transicoes.Add(t); }
IEnumerator LoadingScene() { Transicao transicao = FindObjectOfType <Transicao>(); transicao.StartTransicao(transparent, Color.black); yield return(new WaitUntil(() => transicao.finished)); SceneManager.LoadScene(ScenePoint); }
IEnumerator CarregarCena() { Transicao transicao = FindObjectOfType <Transicao>(); transicao.IniciarTransicao(transparente, Color.black); yield return(new WaitUntil(() => transicao.acabou)); SceneManager.LoadScene(cenaAlvo); }
public void FadeOff() { if (FadeAtual == null) { FadeAtual = FadeToBlack; } AtivarObjeto(); FadeAtual.TerminoudeMostrar += DesativarObjeto; FadeAtual.FadeOff(); }
// Pega uma transição existente public Transicao GetTransicao(string estado, string simbolo) { Transicao t = new Transicao(); KeyTransicao temp = new KeyTransicao(estado, simbolo); if (transicoes.ContainsKey(temp)) { transicoes.TryGetValue(temp, out t); } return(t); }
public void ExecutaTransicao(Transicao transicao) { if (transicao.PodeExecutar) { foreach (Lugar lugar in transicao.lugaresEntrada) { lugar.RetiraMarca(); } foreach (Lugar lugar in transicao.lugaresSaida) { lugar.AdicionaMarca(); } } }
//Metodo Elimina Estados Mortos. //Todo estado que não alcança un estado final é removido. public Automato eliminaEstadosMortos(Automato automato) { Dictionary <string, bool> t = new Dictionary <string, bool>(); elimEstMorto(ref automato, ref t, automato.estadoInicial); List <KeyTransicao> lk = new List <KeyTransicao>(); List <Transicao> li = new List <Transicao>(); foreach (KeyValuePair <string, bool> v in t) { if (v.Value == false) { automato.estados.Remove(v.Key); foreach (KeyValuePair <KeyTransicao, Transicao> tran in automato.transicoes) { if (tran.Key.estado == v.Key) { lk.Add(tran.Key); } if (tran.Value.estado2.Contains(v.Key)) { Transicao temp = tran.Value; temp.estado2.Remove(v.Key); li.Add(temp); } } } } foreach (KeyTransicao l in lk) { automato.transicoes.Remove(l); } foreach (Transicao l in li) { KeyTransicao kt = new KeyTransicao { estado = l.estado1, simbolo = l.simbolo }; automato.transicoes.Remove(kt); if (l.estado2.Count > 0) { automato.transicoes.Add(kt, l); } } return(automato); }
public void RecebeTransicoes() { Console.Write("Quantas transicões: "); int qtdTransicoes = int.Parse(Console.ReadLine()); for (int i = 1; i <= qtdTransicoes; i++) { Transicao transicao = new Transicao($"T{i}"); transicoes.Add(transicao); RecebeLugaresEntrada(transicao); RecebeLugaresSaida(transicao); } }
/// <summary> /// Recebe um Evento contendo um Token Lexico /// </summary> /// <param name="evento">Tipo: TOKEN_LEXICO, Conteudo: TokenLexico </param> /// <returns></returns> public SaidaRotina ReceberToken(Evento evento) { TokenLexico tokenLexico = (TokenLexico)evento.Conteudo; Transicao transicao = AutomatoFinito.BuscaTransicao(Cabecote.EstadoAtual, tokenLexico.Categoria); if (transicao != null) { Transicao(transicao); Acumulador.Add(tokenLexico); return(new SaidaRotina( new List <Evento>(), new List <Evento>(), new List <Evento>() )); } else { if (Cabecote.Aceito) { return(new SaidaRotina( new List <Evento>(), new List <Evento>() { new Evento(evento.InstanteProgramado + 1, TipoEvento.RESET, evento.Tarefa, null), new Evento(evento.InstanteProgramado + 2, TipoEvento.TOKEN_LEXICO, evento.Tarefa, evento.Conteudo) }, new List <Evento>() { new Evento(evento.InstanteProgramado + 1, TipoEvento.TOKEN_LEXICO, evento.Tarefa, GetTokenLexicoFromEstadoAtual()) } )); } else { List <Evento> eventosSaida = new List <Evento>(); eventosSaida.AddRange(Acumulador.Select(t => new Evento(evento.InstanteProgramado + 1, TipoEvento.TOKEN_LEXICO, evento.Tarefa, t))); eventosSaida.Add(new Evento(evento.InstanteProgramado + 2, TipoEvento.TOKEN_LEXICO, evento.Tarefa, evento.Conteudo)); return(new SaidaRotina( new List <Evento>(), new List <Evento>() { new Evento(evento.InstanteProgramado + 1, TipoEvento.RESET, evento.Tarefa, null) }, eventosSaida )); } } }
public void Deve_Popular_Propriedades_Da_Base_Pelo_Construtor() { var lugar = new Lugar(1, 10); const int peso = 1; var transicao = new Transicao(1); const DirecaoArco direcao = DirecaoArco.EntradaTransição; new ArcoNormal(lugar, peso, transicao, direcao) .Should() .BeEquivalentTo(new { Lugar = lugar, Peso = peso, Transicao = transicao, Direcao = direcao }); }
/// <summary> /// Recebe um Evento contendo uma CaracterCaracterizado /// </summary> /// <param name="evento">Tipo: ASCII, Conteudo: CaracterClassificado </param> /// <returns></returns> // Token possui Tipo (Identificador, Número, Especial) e Valor public SaidaRotina ReceberCaracter(Evento evento) { CaracterClassificado caracterClassificado = (CaracterClassificado)evento.Conteudo; Transicao transicao = AutomatoFinito.BuscaTransicao(Cabecote.EstadoAtual, caracterClassificado.Caracter); if (transicao != null) { Transicao(transicao); if (caracterClassificado.Funcao != FuncaoCaracter.DESCARTAVEL) { Acumulador.Add(caracterClassificado); } return(new SaidaRotina( new List <Evento>(), new List <Evento>(), new List <Evento>() )); } else if (caracterClassificado.Tipo == TipoCaracter.DELIMITADOR || Cabecote.Aceito) { return(new SaidaRotina( new List <Evento>(), new List <Evento>() { new Evento(evento.InstanteProgramado + 1, TipoEvento.RESET, evento.Tarefa, null), new Evento(evento.InstanteProgramado + 2, TipoEvento.ASCII, evento.Tarefa, evento.Conteudo) }, new List <Evento>() { new Evento(evento.InstanteProgramado + 1, TipoEvento.TOKEN_LEXICO, evento.Tarefa, GetTokenLexicoFromEstadoAtual()) } )); } else { TransicaoNA(); Acumulador.Add(caracterClassificado); return(new SaidaRotina( new List <Evento>(), new List <Evento>(), new List <Evento>() )); } }
private void RecebeLugaresSaida(Transicao transicao) { Console.Write($"Quais são os lugares de saida de {transicao.Nome}? "); string[] arrayLugares = Console.ReadLine().Split(','); if (arrayLugares.Length > 0) { foreach (string nome in arrayLugares) { Lugar lugar = lugares.Find(obj => obj.Nome == nome); Arco arco = new Arco(transicao, lugar); arcos.Add(arco); lugar.arco = arco; transicao.arcos.Add(arco); transicao.lugaresSaida.Add(lugar); } } }
// Ou cria uma nova transição ou adiciona o estado 2 em uma existente (indeterminizar) public Transicao GeraTransicao(string e1, string s, HashSet <string> e2) { Transicao t = new Transicao(); KeyTransicao temp = new KeyTransicao(e1, s); if (transicoes.ContainsKey(temp)) { transicoes.TryGetValue(temp, out t); } //char[] delimiter = { '*', '+' }; if (e1.Contains("*") || e1.Contains("+")) { // e1 = e1.Split(delimiter)[1]; e1 = e1.Replace("*", ""); e1 = e1.Replace("+", ""); } t.estado1 = e1; t.simbolo = s; foreach (string e in e2) { if (e.Contains("*") || e.Contains("+")) { //t.estado2.Add(e.Split(delimiter)[1]); string aux = e; aux = aux.Replace("*", ""); aux = aux.Replace("+", ""); t.estado2.Add(aux); } else { t.estado2.Add(e); } } return(t); }
public void CarregarSimulacao(string caminho) { var tipDado = eTipoDado.Nenhum; foreach (var linha in File.ReadAllLines(caminho)) { if (linha == "#LUGARES") { tipDado = eTipoDado.Lugar; continue; } if (linha == "#TRANSIÇÕES") { tipDado = eTipoDado.Transicao; continue; } if (linha == "#ARCOS") { tipDado = eTipoDado.Arco; continue; } switch (tipDado) { case eTipoDado.Lugar: var dados = linha.Split(';'); lugares.Add(new Lugar(dados[0], Int32.Parse(dados[1]))); break; case eTipoDado.Transicao: dados = linha.Split(';'); var transicao = new Transicao(dados[0]); transicoes.Add(transicao); break; case eTipoDado.Arco: dados = linha.Split(';'); var arco = new Arco(); arco.peso = Int32.Parse(dados[2]); if (dados[0].StartsWith("L")) { var origem = lugares.Find(l => l.Nome == dados[0]); arco.origem = origem; var destino = transicoes.Find(l => l.Nome == dados[1]); arco.destino = destino; origem.arco = arco; destino.arcos.Add(arco); } else { var origem = transicoes.Find(l => l.Nome == dados[0]); arco.origem = origem; var destino = lugares.Find(l => l.Nome == dados[1]); arco.destino = destino; origem.arcos.Add(arco); destino.arco = arco; } arcos.Add(arco); break; } } }
void Transicao(Transicao transicao) { Cabecote.EstadoAtual = transicao.Destino; Cabecote.Aceito = AutomatoFinito.ConfereEstadoFinal(Cabecote.EstadoAtual); }
public void DesfazerTransicao() { Transicao.Rollback(); }
public void FecharTransicao() { Transicao.Commit(); }
public void FadeINToBlack() { Debug.Log("Fade in to black chamado"); FadeAtual = FadeToBlack; FadeIn(); }
public void FadeINToWhite() { FadeAtual = FadeToWhite; FadeIn(); }