private void Button_Click(object sender, RoutedEventArgs e)
{
double a = double.Parse(txtA.Text);
double b = double.Parse(txtB.Text);
double c = double.Parse(txtC.Text);
Equacao x = new Equacao();
x.SetABC(a, b, c);
txtdelta.Text = x.Delta().ToString();
double i, j;
if (x.X1(out i))
{
txtx1.Text = i.ToString();
}
else
{
txtx1.Text = "error";
}
if (x.X2(out j))
{
txtx2.Text = j.ToString();
}
else
{
txtx2.Text = "error";
}
}
private void updateItens(Equacao equacao)
{
foreach (var reagentes in equacao.Reagente)
{
var instance = GameObject.Instantiate(prefab.gameObject) as GameObject;
instance.transform.SetParent(this.reagentes.Find("ViewPort/Content"), false);
initializeItemView(instance, reagentes, 1);
BalanceamentoController.addFormule(instance);
Debug.Log(reagentes.Resposta);
if (!reagentes.Equals(equacao.Reagente[equacao.Reagente.Count - 1]))
{
var plusSing = GameObject.Instantiate(this.plusSing.gameObject) as GameObject;
plusSing.transform.SetParent(this.reagentes.Find("ViewPort/Content"), false);
}
}
foreach (var produtos in equacao.Produto)
{
var instance = GameObject.Instantiate(prefab.gameObject) as GameObject;
instance.transform.SetParent(this.produtos.Find("ViewPort/Content"), false);
initializeItemView(instance, produtos, 0);
Debug.Log(produtos.Resposta);
BalanceamentoController.addFormule(instance);
if (!produtos.Equals(equacao.Produto[equacao.Produto.Count - 1]))
{
var plusSing = GameObject.Instantiate(this.plusSing.gameObject) as GameObject;
plusSing.transform.SetParent(this.produtos.Find("ViewPort/Content"), false);
}
}
}
public void verificando_que_a_equacao_foi_simplificada()
{
Equacao equacao = interpretador.Interpretar("x + 2x - 2 + 8 = 4 - 2x");
DeveTerJuntadoAsIncognitasNoLado(equacao.LadoEsquerdo);
DeveTerJuntadoAsUnidadesNoLado(equacao.LadoEsquerdo);
DeveTerJuntadoAsIncognitasNoLado(equacao.LadoDireito);
DeveTerJuntadoAsUnidadesNoLado(equacao.LadoDireito);
}
// Start is called before the first frame update
void Start()
{
//Debug.Log(Application.persistentDataPath);
//Molecula.ImprimirMoleculas();
Equacao.ImprimirEquacoes();
NucleoController.instance().restartAll();
ScenesMaintenerController.Instance.stopAllSounds("music2");
ScenesMaintenerController.Instance.playMainSound();
ScenesMaintenerController.Instance.playBubbleSound();
}
public void interpretando_uma_equacao()
{
Equacao equacao = interpretador.Interpretar("x + 2x - 2 + 8 = (3x + 4 - 4x - 5)/2");
DeveHaver(quantidade: 3, tipo: TipoTermo.Incognita, lado: equacao.LadoEsquerdo);
DeveHaver(quantidade: 6, tipo: TipoTermo.Unidade, lado: equacao.LadoEsquerdo);
DeveHaver(quantidade: -1, tipo: TipoTermo.Incognita, lado: equacao.LadoDireito);
DeveHaver(quantidade: -1, tipo: TipoTermo.Unidade, lado: equacao.LadoDireito);
DeveHaver(quantidade: 2, tipo: TipoTermo.Divisor, lado: equacao.LadoDireito);
}
public static void Main(string[] args)
{
double x1, x2;
double x, y, z;
Console.WriteLine("\nCalculando Equacao do 2o. grau ...");
Console.WriteLine("Informe 'a'");
double a = double.Parse(Console.ReadLine());
Console.WriteLine("Informe 'b'");
double b = double.Parse(Console.ReadLine());
Console.WriteLine("Informe 'c'");
double c = double.Parse(Console.ReadLine());
Equacao e = new Equacao(a, b, c);
e.GetABC(out x, out y, out z);
Console.WriteLine("---------------------------");
Console.WriteLine($"a: {x:0.00}");
Console.WriteLine($"b: {y:0.00}");
Console.WriteLine($"c: {z:0.00}");
if (!e.RaizesReais(out x1, out x2))
{
Console.WriteLine("Equacao nao possui raizes reais.");
}
else
{
Console.WriteLine($"Raizes: {x1:0.00} e {x2:0.00}");
}
Console.WriteLine("---------------------------");
e.SetABC(a * 1.2, b * -1, c - 2.3);
Console.WriteLine($"Valores modificados para:\n{e}");
if (!e.RaizesReais(out x1, out x2))
{
Console.WriteLine("Equacao nao possui raizes reais.");
}
else
{
Console.WriteLine($"Raizes: {x1:0.00} e {x2:0.00}");
}
Console.WriteLine("---------------------------\n");
return;
}
// Start is called before the first frame update
private ControladorEquacoes()
{
equacoes = Equacao.todasEquacoes();
equacoesDivididas.Add("Facil", new List <Equacao>());
equacoesDivididas.Add("Médio", new List <Equacao>());
equacoesDivididas.Add("Dificil", new List <Equacao>());
foreach (int index in equacoes.Keys)
{
Equacao equacao = equacoes[index];
equacoesDivididas[equacao.Tipo].Add(equacao);
}
}
private void AtualizarRepresentacaoBalanca(Equacao equacao)
{
var representacao = equacao.ObterSnapshot();
AreaDropEsquerda.Children.Clear();
//AreaDropDireita.Children.Clear();
if (representacao.IncognitasEsquerda != 0)
{
var peso = new TrianguloArrastavel
{
TipoTermo = TipoTermo.Incognita,
Valor = representacao.IncognitasEsquerda,
};
AreaDropEsquerda.Children.Add(peso);
}
if (representacao.UnidadesEsquerda != 0)
{
var peso = new TrianguloArrastavel
{
TipoTermo = TipoTermo.Unidade,
Valor = representacao.UnidadesEsquerda
};
AreaDropEsquerda.Children.Add(peso);
}
//if (representacao.IncognitasDireita != 0)
//{
// var peso = new TrianguloArrastavel
// {
// TipoTermo = TipoTermo.Incognita,
// Valor = representacao.IncognitasDireita
// };
// AreaDropDireita.Children.Add(peso);
//}
//if (representacao.UnidadesDireita != 0)
//{
// var peso = new TrianguloArrastavel
// {
// TipoTermo = TipoTermo.Unidade,
// Valor = representacao.UnidadesDireita
// };
// AreaDropDireita.Children.Add(peso);
//}
AreaDropEsquerda.UpdateLayout();
//AreaDropDireita.UpdateLayout();
}
// Start is called before the first frame update
void Start()
{
Debug.Log("Inicio");
Dictionary <int, Atomo> atomos = Atomo.todosAtomos();
atomos[1].escreverAtomo();
Dictionary <int, Equacao> .ValueCollection equacoes = Equacao.todasEquacoes().Values;
Debug.Log("Inicio");
foreach (Equacao m in equacoes)
{
Debug.Log($"{m.Tipo}: {m.ToString()}");
}
}
private void AtualizarEquilibrioBalanca(Equacao equacao)
{
const int anguloQuandoDesequilibrada = 10;
switch (equacao.Equilibrio)
{
case Equilibrio.PendendoParaDireita:
AnguloPlataforma2 = anguloQuandoDesequilibrada;
break;
case Equilibrio.PendendoParaEsquerda:
AnguloPlataforma2 = -anguloQuandoDesequilibrada;
break;
default:
AnguloPlataforma2 = 0;
break;
}
}
private void CalcularClick(object sender, RoutedEventArgs e)
{
Equacao x = new Equacao();
x.SetABC(double.Parse(txtA.Text), double.Parse(txtB.Text), double.Parse(txtC.Text));
txtD.Text = x.Delta().ToString();
double r, s;
if (x.X1(out r))
{
x.X2(out s);
txtX1.Text = r.ToString();
txtX2.Text = s.ToString();
}
else
{
txtX1.Text = "Raiz complexa";
txtX2.Text = "Raiz complexa";
MessageBox.Show("A equacao não é do segundo grau ou não possui raízes reais");
}
}
public static void Main(string[] args)
{
Equacao e = new Equacao(0, 0, 0);
Console.WriteLine("Informe os coeficientes da equação:");
string[] c = Console.ReadLine().Split(" ");
double v1 = double.Parse(c[0]);
double v2 = double.Parse(c[1]);
double v3 = double.Parse(c[2]);
e.SetABC(v1, v2, v3);
Console.WriteLine(e);
Console.WriteLine($"Delta = {e.Delta()}");
if (e.RaizesReais(out double x1, out double x2))
{
Console.WriteLine($"X1 = {x1} e X2 = {x2}");
}
else
{
Console.WriteLine("Não possui raízes reais");
}
}
public static void RealizarOperacao(this Equacao equacao, TipoOperacao tipoOperacao, TermoEquacao termo, Lado lado)
{
switch (tipoOperacao)
{
case TipoOperacao.Adicao:
equacao.Somar(lado, termo);
break;
case TipoOperacao.Subtracao:
equacao.Subtrair(lado, termo);
break;
case TipoOperacao.Multiplicacao:
equacao.Multiplicar(lado, termo);
break;
case TipoOperacao.Divisao:
equacao.Dividir(lado, termo);
break;
default: throw new Exception(string.Format("Operação não suportada: {0}", tipoOperacao));
}
}
private void DeveTerRegistradoUmaOperacaoDe(TipoOperacao tipoEsperado, Lado lado, Equacao equacao, TermoEquacao termo, int noIndice)
{
var operacoes = equacao.HistoricoOperacoes.ObterOperacoes(lado);
var operacao = operacoes[noIndice];
operacao.Tipo.Should().Be(tipoEsperado);
operacao.Termo.Should().Be(termo);
}
private void AplicarOperacaoEReavaliarObjetivo(OperacaoArrastavel operacaoArrastavel, Lado lado, Equacao equacaoAtual)
{
var termo = ObterTermo(operacaoArrastavel.TipoTermo, operacaoArrastavel.Valor);
var operacao = new Operacao(operacaoArrastavel.TipoOperacao, termo);
equacaoAtual.AplicarOperacao(lado, operacao);
AtualizarEquilibrioBalanca(equacaoAtual);
AtualizarRepresentacaoBalanca(equacaoAtual);
AtualizarHistoricoOperacoes(equacaoAtual);
if (equacaoAtual.FoiResolvida())
{
this.ObterViewModel().AvancarParaMontagemDeUmaNovaEquacao();
//Dispatcher.BeginInvoke(new Action(delegate
//{
// this.ObterViewModel().AvancarParaMontagemDeUmaNovaEquacao();
//}), DispatcherPriority.Send, TimeSpan.FromMilliseconds(2000));
}
}
private void AtualizarHistoricoOperacoes(Equacao equacao)
{
HistoricoOperacoes.Atualizar(equacao.HistoricoOperacoes.PassoAPasso());
}
public void acaoAmarelo()
{
currentEquation = ControladorEquacoes.instance().pegarEquacao("Médio");
pontuacaoAcerto += 30;
}
public void acaoAzul()
{
currentEquation = ControladorEquacoes.instance().pegarEquacao("Facil");
pontuacaoAcerto += 10;
}
public InformacoesEquacao(Equacao equacaoProcessada, EquacaoBruta equacaoBruta)
{
EquacaoProcessada = equacaoProcessada;
EquacaoBruta = equacaoBruta;
}
public void acaoVermelho()
{
currentEquation = ControladorEquacoes.instance().pegarEquacao("Dificil");
pontuacaoAcerto += 40;
}
/**
* Recebe uma equacao como parametro, iguala o attr Utilizada como verdadeiro, impossibilitando esta equacao de ser
* selecionada novamente enquanto for verdadeiro e por fim retorna esta equacao para ser utilizada.
*/
public Equacao retirarQuestao(Equacao equacao)
{
equacao.Utilizada = true;
return(equacao);
}