public void Dividir(TermoEquacao divisor, IEnumerable <TermoEquacao> listaTermos)
{
if (divisor.Valor == 0)
{
throw new DivideByZeroException("Tentativa de dividir por zero");
}
var termos = listaTermos.ToArray();
if (termos.Any(t => t.Tipo == TipoTermo.Divisor))
{
var divisorExistente = termos.First(t => t.Tipo == TipoTermo.Divisor);
divisorExistente.Valor *= divisor.Valor;
return;
}
foreach (var termo in termos)
{
termo.Valor /= divisor.Valor;
if (termo.Tipo == divisor.Tipo)
{
if (termo.Tipo == TipoTermo.Incognita)
{
termo.Potencia--;
}
}
else
{
termo.Tipo = TipoTermo.Incognita;
}
}
}
public void Multiplicar(TermoEquacao multiplicador, IEnumerable <TermoEquacao> listaTermos)
{
var termos = listaTermos.ToArray();
foreach (var termo in termos.Where(t => t.Tipo != TipoTermo.Divisor))
{
termo.Valor *= multiplicador.Valor;
if (termo.Tipo == multiplicador.Tipo)
{
if (termo.Tipo == TipoTermo.Incognita)
{
termo.Potencia++;
}
}
else
{
termo.Tipo = TipoTermo.Incognita;
}
}
//TODO testar simplificação
//if (termos.Any(t => t.Tipo == TipoTermo.Divisor))
//{
// var divisorExistente = termos.First(t => t.Tipo == TipoTermo.Divisor);
// //todos eles são divisíveis
// if (termos.All(t => t.Valor % divisorExistente.Valor == 0)) //se são divisíveis, simplificar
// {
// Dividir(divisorExistente, termos);
// }
//}
}
public void Subtrair(Lado ladoParaAplicar, TermoEquacao termo)
{
var listaTermos = ObterTermosDoLado(ladoParaAplicar);
calculadora.Subtrair(termo, listaTermos);
historicoOperacoes.RegistrarOperacao(new Subtracao(termo), ladoParaAplicar);
}
public void Dividir(Lado ladoParaAplicar, TermoEquacao divisor)
{
var listaTermos = ObterTermosDoLado(ladoParaAplicar);
calculadora.Dividir(divisor, listaTermos);
historicoOperacoes.RegistrarOperacao(new Divisao(divisor), ladoParaAplicar);
}
public void Multiplicar(Lado ladoParaAplicar, TermoEquacao multiplicador)
{
var listaTermos = ObterTermosDoLado(ladoParaAplicar);
calculadora.Multiplicar(multiplicador, listaTermos);
historicoOperacoes.RegistrarOperacao(new Multiplicacao(multiplicador), ladoParaAplicar);
}
public void Adicionar(TermoEquacao termo, ICollection <TermoEquacao> listaTermos)
{
var termoDoMesmoTipo = listaTermos.FirstOrDefault(t => t.Tipo == termo.Tipo && t.Potencia == termo.Potencia);
if (termoDoMesmoTipo != null)
{
termoDoMesmoTipo.Valor += termo.Valor;
}
else
{
listaTermos.Add(termo);
}
}
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);
}
public Adicao(TermoEquacao termo) : base(TipoOperacao.Adicao, termo)
{
}
public Multiplicacao(TermoEquacao termo)
: base(TipoOperacao.Multiplicacao, termo)
{
}
public Divisao(TermoEquacao termo)
: base(TipoOperacao.Divisao, termo)
{
}
//controlar histórico das operações
internal void AdicionarTermoLadoDireito(TermoEquacao termo)
{
termosDireita.Add(termo);
}
//controlar histórico das operações
internal void AdicionarTermoLadoEsquerdo(TermoEquacao termo)
{
termosEsquerda.Add(termo);
}
public Subtracao(TermoEquacao termo) : base(TipoOperacao.Subtracao, termo)
{
}
public static TermoEquacao ElevadoA(this TermoEquacao termo, int potencia)
{
termo.Potencia = potencia;
return(termo);
}
private static void DeveTerSubstituido(TermoEquacao termoOriginal, TermoEquacao por, IEnumerable <TermoEquacao> no)
{
no.Should().NotContain(t => t == termoOriginal);
no.Should().Contain(t => t == por);
}
public Operacao(TipoOperacao tipo, TermoEquacao termo)
{
Tipo = tipo;
Termo = termo;
}