public QMoM(int numeroDePassos, double passo, double passoInicial, int numeroDePontos,
Integral.Funcao funcao, double limiteMinimo, double limiteMaximo, TermoFonteQMoM termoFonteQMoM)
: base(numeroDePassos, passo, passoInicial, numeroDePontos, funcao,
limiteMinimo, limiteMaximo)
{
this.termoFonteQMoM = termoFonteQMoM;
}
protected MomentosBase(int numeroDePassos, double passo, double passoInicial, int numeroDePontos,
Integral.Funcao funcaoInicial, double limiteMinimo, double limiteMaximo)
{
this.numeroDePassos = numeroDePassos;
this.passo = passo;
this.passoInicial = passoInicial;
this.numeroDePontos = numeroDePontos;
this.funcao = funcaoInicial;
this.limiteMinimo = limiteMinimo;
this.limiteMaximo = limiteMaximo;
}
public DQMoM(int numeroDePassos, double passo, double passoInicial, int numeroDePontos,
Integral.Funcao funcao, double limiteMinimo, double limiteMaximo, TermoFonteDQMoM termoFonteDQMoM)
: base(numeroDePassos, passo, passoInicial, numeroDePontos, funcao,
limiteMinimo, limiteMaximo)
{
this.termoFonteDQMoM = termoFonteDQMoM;
numericalRecipes = new NumericalRecipes();
FuncaoDeIntegracao funcaoDeIntegracao = new Funcao(numericalRecipes, numeroDePontos, MetodoDeCoeficientes, termoFonteDQMoM, DecorarAbscissas,
DecorarPesos, funcaoDeltaAbscissas);
rungeKutta4Ordem = new RungeKutta4Ordem(passo, funcaoDeIntegracao);
}
public static double CalcularBinomioDeNewton(Integral.Funcao a, Integral.Funcao b,double x, double n)
{
var resultado = 0.0;
for (int k = 0; k <= n; k++)
{
resultado += CoeficienteDeNewton(n, k) * Math.Pow(a(x), n - k) * Math.Pow(b(x), k);
}
return resultado;
}
public FixedPoint(int N,double limiteInferior,double limiteSuperior,
Integral.Funcao bf, Integral.Funcao an, FuncaoDupla fp,
Integral.Funcao D, Integral.Funcao funcaoInicial)
{
autoQuad = new AutoQuad(10, limiteInferior, limiteSuperior, precisaoRequerida, 10);
this.funcaoInicial = funcaoInicial;
this.an = an;
this.bf = bf;
this.fp = fp;
this.D = D;
this.N = N;
x0 = limiteInferior;
xf = limiteSuperior;
}
//public static double CalcularMomento(double[] pesos, double[] abscissas, double indice)
//{
// double momento = 0;
// for (int i = 0; i < pesos.Length; i++)
// {
// momento += pesos[i]*Math.Pow(abscissas[i], indice);
// }
// return momento;
//}
public static double CalcularMomento(MetodoCoeficientesDosMomentos metodoDeCoeficientes, double[] pesos, double[] abscissas, Integral.Funcao deltaAbscissas, double indice)
{
double momento = 0;
if (deltaAbscissas == null)
{
for (int i = 0; i < pesos.Length; i++)
{
momento += pesos[i] * Polinomio(metodoDeCoeficientes, abscissas[i], indice);
}
}
else
{
for (int i = 0; i < pesos.Length; i++)
{
momento += pesos[i] * Polinomio(metodoDeCoeficientes, (abscissas[i] + deltaAbscissas(abscissas[i])), indice);
}
}
return momento;
}
private double[] CalcularMomentosIniciaisMcCoyCSTR(int numeroDePontos, Integral.Funcao funcaoInicial)
{
double[] m0 = new double[numeroDePontos];
for (int i = 0; i < m0.Length; i++)
{
var i1 = i;
Integral.Funcao funcaoDeMomento =
x => funcaoInicial(x) * MomentosBase.Polinomio(MomentosBase.MetodoCoeficientesDosMomentos.PDA, x, i1);
double valorAutoquad = 0.0;
double valorComPrecisaoAutoquad;
double precisaoAutoquad;
double precisaoRequerida = 1e-10;
AutoQuad autoQuad = new AutoQuad(10, 125.0, 10000, precisaoRequerida, 15);
if (
!autoQuad.Calcular(funcaoDeMomento, out valorAutoquad, out valorComPrecisaoAutoquad,
out precisaoAutoquad))
throw new Exception("Erro no cálculo da AutoQuad");
if (precisaoAutoquad > precisaoRequerida)
throw new Exception("Precisão não foi atingida na AutoQuad");
m0[i] = valorAutoquad;
}
return m0;
}
private double[] CalcularMomentosIniciaisMcCoy(int numeroDePontos, Integral.Funcao funcaoInicial, MomentosBase.MetodoCoeficientesDosMomentos metodoCoeficientesDosMomentos)
{
double[] m0 = new double[numeroDePontos];
for (int i = 0; i < m0.Length; i++)
{
var i1 = i;
Integral.Funcao funcaoDeMomento =
x => funcaoInicial(x) * MomentosBase.Polinomio(metodoCoeficientesDosMomentos, x, i1);
double valorAutoquad = 0.0;
double valorComPrecisaoAutoquad;
double precisaoAutoquad;
double precisaoRequerida = 1e-14;
AutoQuad autoQuad = new AutoQuad(15, 125.0, 1200, precisaoRequerida, 15);
if (
!autoQuad.Calcular(funcaoDeMomento, out valorAutoquad, out valorComPrecisaoAutoquad,
out precisaoAutoquad))
throw new Exception("Erro no cálculo da AutoQuad");
if (precisaoAutoquad > precisaoRequerida)
MessageBox.Show("Precisão não foi atingida na AutoQuad");
if (i == 1) fatorNormalizacao = valorAutoquad;
m0[i] = valorAutoquad;
}
for (int i = 0; i < m0.Length; i++)
{
m0[i] = m0[i] / fatorNormalizacao;
}
return m0;
}
private double[] CalcularMomentosIniciais(Integral.Funcao funcaoInicial, MomentosBase.MetodoCoeficientesDosMomentos metodoCoeficientesDosMomentos)
{
var fator = FatorDeNormalizacao();
double[] m0 = new double[2 * m];
for (int i = 0; i < m0.Length; i++)
{
var i1 = i;
Integral.Funcao funcaoDeMomento =
x => funcaoInicial(x) * MomentosBase.Polinomio(metodoCoeficientesDosMomentos, x, i1);
double valorAutoquad;
double valorComPrecisaoAutoquad;
double precisaoAutoquad;
double precisaoRequerida = 1e-13;
AutoQuad autoQuad = new AutoQuad(10, Mmin, Mmax, precisaoRequerida, 10);
if (
!autoQuad.Calcular(funcaoDeMomento, out valorAutoquad, out valorComPrecisaoAutoquad,
out precisaoAutoquad))
throw new Exception("Erro no cálculo da AutoQuad");
if (precisaoAutoquad > precisaoRequerida)
throw new Exception("Precisão não foi atingida na AutoQuad");
m0[i] = valorAutoquad/fator;
}
return m0;
}
private static extern int CalcularAutoQuad2(Integral.Funcao funcao, int numeroDeIntervalos,
IntPtr limitesInferiorIntervalo, IntPtr limitesSuperiorIntervalo, IntPtr precisaoPorIntervalo,
IntPtr integralDoIntervalo, IntPtr integralTotal, IntPtr precisaoIntegralTotal,
IntPtr integralTotalComPrecisaoRequerida, IntPtr indicadorPrecisaoAtingidaNoIntervalo,
int numeroDeSubdivisoesIntervalo);
public bool Calcular(Integral.Funcao funcao, out double valorIntegral, out double valorIntegralPrecisao, out double precisaoObtida)
{
try
{
// Copy the array to unmanaged memory.
Marshal.Copy(limitesInferiorIntervalo, 0, limInf, limitesInferiorIntervalo.Length);
Marshal.Copy(limitesSuperiorIntervalo, 0, limSup, limitesSuperiorIntervalo.Length);
Marshal.Copy(precisaoPorIntervalo, 0, precis, precisaoPorIntervalo.Length);
}
catch
{
}
int resultado = CalcularAutoQuad2(funcao, numeroDeIntervalos, limInf, limSup, precis, integralIntervalo, integralTotal, precisaoIntegralTotal,
integralTotalComPrecisaoRequerida, indicadorPrecisaoAtingidaNoIntervalo, numeroDeSubdivisoesPorIntervalo);
Marshal.Copy(integralTotal, resultadoSemPrecisaoConfirmada, 0, resultadoSemPrecisaoConfirmada.Length);
Marshal.Copy(integralTotalComPrecisaoRequerida, resultadoComPrecisaoConfirmada, 0, resultadoComPrecisaoConfirmada.Length);
Marshal.Copy(precisaoIntegralTotal, precisaoAtingida, 0, precisaoAtingida.Length);
valorIntegral = resultadoSemPrecisaoConfirmada[0];
valorIntegralPrecisao = resultadoComPrecisaoConfirmada[0];
precisaoObtida = precisaoAtingida[0];
if (resultado > 0) return false;
return true;
}
private double[] CalcularMomentosIniciaisMcCoy(int numeroDePontos, Integral.Funcao funcaoInicial)
{
double[] m0 = new double[numeroDePontos];
for (int i = 0; i < m0.Length; i++)
{
var i1 = i;
Integral.Funcao funcaoDeMomento =
x => funcaoInicial(x) * Math.Pow(x, i1);
double valorAutoquad;
double valorComPrecisaoAutoquad;
double precisaoAutoquad;
if (
!autoQuad.Calcular(funcaoDeMomento, out valorAutoquad, out valorComPrecisaoAutoquad,
out precisaoAutoquad))
throw new Exception("Erro no cálculo da AutoQuad");
if (precisaoAutoquad > precisaoRequerida)
Trace.WriteLine("Precisão não foi atingida na AutoQuad. Precisão atingida = " + precisaoAutoquad + " Precisão requerida = " + precisaoRequerida);
if (i == 1) fatorDeNormalizacao = valorAutoquad;
m0[i] = valorAutoquad;
}
//for (int i = 0; i < m0.Length; i++)
//{
// m0[i] = m0[i] / fatorDeNormalizacao;
//}
return m0;
}
private void ObterSistemaLinear(int numeroDePontos, MetodoCoeficientesDosMomentos metodoCoeficientesDosMomentos, double[] pesos, double[] abscissas, Integral.Funcao funcaoDeltaAbscissas, TermoFonteDQMoM termoFonteSistemaLinearDqmoM, DecoradorDePesos decorarPesos, DecoradorDeAbscissas decorarAbscissas, double tempo)
{
if (decorarPesos != null) pesosDecorados = decorarPesos(pesos, tempo);
else pesosDecorados = pesos;
if (pesosDecorados == null) pesosDecorados = pesos;
if (decorarAbscissas != null) abscissasDecoradas = decorarAbscissas(abscissas, tempo);
else abscissasDecoradas = abscissas;
if (abscissasDecoradas == null) abscissasDecoradas = abscissas;
resposta = termoFonteSistemaLinearDqmoM(pesosDecorados, abscissasDecoradas, metodoCoeficientesDosMomentos,tempo);
if (resposta.Length != numeroDePontos) throw new Exception("Número de pontos deve ser igual na matriz de coeficientes e no termo fonte do DQMoM!");
for (int k = 0; k < numeroDePontos; k++)
{
for (int i = 0; i < numeroDePontos/2; i++)
{
if (funcaoDeltaAbscissas == null)
{
matrizDeCoeficientes[k, i] = Polinomio(metodoCoeficientesDosMomentos, abscissas[i], k);
matrizDeCoeficientes[k, i + numeroDePontos / 2] = pesos[i] * DerivadaPolinomio(metodoCoeficientesDosMomentos, abscissas[i], k);
}
else
{
matrizDeCoeficientes[k, i] = Polinomio(metodoCoeficientesDosMomentos, (abscissas[i] + funcaoDeltaAbscissas(abscissas[i])), k);
matrizDeCoeficientes[k, i + numeroDePontos / 2] = pesos[i] * DerivadaPolinomio(metodoCoeficientesDosMomentos, (abscissas[i] + funcaoDeltaAbscissas(abscissas[i])), k);
}
}
}
sistema.MatrizDeCoeficientes = matrizDeCoeficientes;
sistema.Resposta = resposta;
}
public Funcao(NumericalRecipes numericalRecipes, int numeroDePontos, MetodoCoeficientesDosMomentos metodoCoeficientesDosMomentos, TermoFonteDQMoM termoFonteDQMoM, DecoradorDeAbscissas decorarAbscissas, DecoradorDePesos decorarPesos, Integral.Funcao funcaodeltaAbscissas)
{
this.numeroDePontos = numeroDePontos;
this.termoFonteDQMoM = termoFonteDQMoM;
this.decorarAbscissas = decorarAbscissas;
this.decorarPesos = decorarPesos;
this.funcaodeltaAbscissas = funcaodeltaAbscissas;
this.metodoCoeficientesDosMomentos = metodoCoeficientesDosMomentos;
this.numericalRecipes = numericalRecipes;
SetVetores();
}
public Funcao(MetodoCoeficientesDosMomentos metodoDeCoeficientes, TermoFonteQMoM termoFonteQMoM, DecoradorDeAbscissas decorarAbscissas, DecoradorDePesos decorarPesos, Integral.Funcao funcaodeltaAbscissas)
{
this.termoFonteQMoM = termoFonteQMoM;
this.decorarAbscissas = decorarAbscissas;
this.decorarPesos = decorarPesos;
this.metodoDeCoeficientes = metodoDeCoeficientes;
this.funcaodeltaAbscissas = funcaodeltaAbscissas;
calculoMomento = CalculoMomento;
}