public static double CalcAverageMz(Peak peak, int[] indx, double[,] mzCalibrationPar,
double[,] intensityCalibrationPar, double absoluteCalibration)
{
if (double.IsNaN(absoluteCalibration))
{
absoluteCalibration = 0;
}
double norm1 = 0;
double m = 0;
if (mzCalibrationPar == null)
{
foreach (int index0 in indx)
{
norm1 += peak.origIntensity[index0];
double mz = peak.centerMz[index0];
m += peak.origIntensity[index0] * mz;
}
m /= norm1;
return(m);
}
foreach (int index0 in indx)
{
norm1 += peak.origIntensity[index0];
double mz = peak.centerMz[index0] * (1 + 1e-6 * NumericalRecipes.RelativeCorrection(peak.centerMz[index0], mzCalibrationPar,
intensityCalibrationPar,
peak.origIntensity[index0],
peak.massRange[index0]) +
1e-6 * absoluteCalibration);
m += peak.origIntensity[index0] * mz;
}
m /= norm1;
return(m);
}
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 double MaxQuantScore()
{
//Test which is better between without and with neutral loss ... keep best score
double lnp = Math.Log(0.06);
double lnq = Math.Log(1.0 - 0.06);
int n = TotalTheoreticalProducts;
int k = MatchingProducts;
n = Math.Max(n, k);
double s = -k * lnp - (n - k) * lnq -
NumericalRecipes.Factln(n) + NumericalRecipes.Factln(k) + NumericalRecipes.Factln(n - k);
s = 10.0 * s / Math.Log(10);
return(s);
}
public static double Score(double[] masses, MsmsPeakAnnotation[] descriptions, double[] specMasses, float[] specIntensities,
double tol, string tolUnit, out MsmsPeakAnnotation[] description, out float[] intensities,
out float[] massDiffs,
double lnp, double lnq)
{
int n;
int k =
CountMatches(masses, descriptions, specMasses, specIntensities, tol, tolUnit, out description, out intensities, out massDiffs, out n);
n = Math.Max(n, k);
double s = -k * lnp - (n - k) * lnq -
NumericalRecipes.Factln(n) + NumericalRecipes.Factln(k) + NumericalRecipes.Factln(n - k);
return(10.0 * s / NumUtil.log10);
}
private static double EstimateN(double[] x, double[] y, int ic)
{
double dm = x[ic];
for (int i = 0; i < y.Length; i++)
{
x[i] -= dm;
y[i] = Math.Log(y[i]);
}
//int im = ic - 1;
//int ip = ic + 1;
//double a2 = (y[im] * (x[ip] - x[ic]) + y[ic] * (x[im] - x[ip]) + y[ip] * (x[ic] - x[im])) /
// (x[im] * x[im] * (x[ip] - x[ic]) + x[ic] * x[ic] * (x[im] - x[ip]) + x[ip] * x[ip] * (x[ic] - x[im]));
//double a1 = (y[ic] - y[im] - a2 * (x[ic] * x[ic] - x[im] * x[im])) / (x[ic] - x[im]);
//double a0 = y[im] - a1 * x[im] - a2 * x[im] * x[im];
//double[] a = new double[] {a0, a1, a2};
double[] a = new double[3];
NumericalRecipes.LinFit2(x, y, a, Qwert);
return(dm - a[1] / a[2] * 0.5);
}
private void ObterAutovaloresEAutovetores()
{
int dimensaoDaMatriz = jacobi.GetUpperBound(0) + 1;
autovalores = new double[dimensaoDaMatriz];
autovetores = new double[dimensaoDaMatriz, dimensaoDaMatriz];
NumericalRecipes auto = new NumericalRecipes();
if (!auto.CalcularAutovaloresEAutovetores(jacobi, dimensaoDaMatriz, autovalores, autovetores))
throw new Exception("Erro: O número de iterações máximo foi alcançado durante os cálculos de autovalores e autovetores");
}
private static void TestImpl(double[] x, double mean, out double stat, out double bothtails,
out double lefttail, out double righttail)
{
int n = x.Length;
int i;
stat = 0;
if (n <= 1)
{
bothtails = 1.0;
lefttail = 1.0;
righttail = 1.0;
return;
}
//
// Mean
//
double xmean = 0;
for (i = 0; i <= n - 1; i++)
{
xmean = xmean + x[i];
}
xmean = xmean / n;
//
// Variance (using corrected two-pass algorithm)
//
double xstddev = 0;
if (n != 1)
{
double v1 = 0;
for (i = 0; i <= n - 1; i++)
{
v1 = v1 + (x[i] - xmean) * (x[i] - xmean);
}
double v2 = 0;
for (i = 0; i <= n - 1; i++)
{
v2 = v2 + (x[i] - xmean);
}
v2 = v2 * v2 / n;
double xvariance = (v1 - v2) / (n - 1);
if (xvariance < 0)
{
xvariance = 0;
}
xstddev = Math.Sqrt(xvariance);
}
if (xstddev == 0)
{
bothtails = 1.0;
lefttail = 1.0;
righttail = 1.0;
return;
}
stat = (xmean - mean) / (xstddev / Math.Sqrt(n));
double df = n - 1;
try {
double p;
if (stat > 0)
{
p = 1 - 0.5 * NumericalRecipes.Betai(df / 2, 0.5, df / (df + stat * stat));
}
else
{
p = 0.5 * NumericalRecipes.Betai(df / 2, 0.5, df / (df + stat * stat));
}
bothtails = 2 * Math.Min(p, 1 - p);
lefttail = p;
righttail = 1 - p;
} catch (Exception) {
bothtails = 1.0;
lefttail = 1.0;
righttail = 1.0;
return;
}
}
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();
}
private void IntegrarDasslc(double[] pesos0, double[] abscissas0, double[] pesosEAbscissas0,List<double[]> momentos)
{
EscreverMensagem("Início dos cálculos usando Dasslc\n");
EscreverMensagem("Tempo Momentos Pesos Abscissas\n");
for (int i = 0; i < Pesos[0].Length; i++)
{
EscreverMensagem(Passos[0] + "; " + momentos[0][i] + "; " + Pesos[0][i] + " ; " + Abscissas[0][i]);
}
for (int i = Pesos[0].Length; i < momentos[0].Length; i++)
{
EscreverMensagem(Passos[0] + " ; " + momentos[0][i]);
}
int indiceTempo = 0;
var sistema = ObterSistemaLinear(numeroDePontos, MetodoDeCoeficientes, pesos0, abscissas0, funcaoDeltaAbscissas, termoFonteDQMoM, DecorarPesos, DecorarAbscissas, indiceTempo);
double[] deltaPesosEAbscissas0 = new double[pesosEAbscissas0.Length];
//Resolve o sistema para t = t0
NumericalRecipes numericalRecipes = new NumericalRecipes();
bool calculou = numericalRecipes.CalcularSistemaLinear(sistema.MatrizDeCoeficientes, sistema.Dimensao, sistema.Resposta, deltaPesosEAbscissas0);
if(!calculou) throw new Exception("Erro no cálculo do sistema linear. Matriz singular.");
List<KeyValuePair<double, double[]>> pesosEAbscissas;
Dasslc dasslc = new Dasslc(pesosEAbscissas0.Length, passoInicial, passo, numeroDePassos, pesosEAbscissas0, deltaPesosEAbscissas0);
if (ToleranciaRelativaDasslc > 0) dasslc.ToleranciaRelativa = ToleranciaRelativaDasslc;
if (ToleranciaAbsolutaDasslc > 0) dasslc.ToleranciaAbsoluta = ToleranciaAbsolutaDasslc;
if (PassoInicialDasslc > 0) dasslc.PassoInicial = PassoInicialDasslc;
if (PassoMaximoDasslc > 0) dasslc.PassoMaximo = PassoMaximoDasslc;
int codigoErro;
dasslc.delegateMensagens = DelegateMensagens;
if(!dasslc.Calcular(DelegateSistemaLinear, out pesosEAbscissas,out codigoErro))
throw new Exception("Erro durante a integração temporal, pelo cálculo da DasslC. Código = "+codigoErro);
for (int j = 1; j < pesosEAbscissas.Count; j++)
{
double[] pesos;
double[] abscissas;
SepararPesosEAbscissas(pesosEAbscissas[j].Value, out pesos, out abscissas);
double[] m = new double[numeroDePontos];
for (int i = 0; i < m.Length; i++)
{
m[i] = CalcularMomento(MetodoDeCoeficientes, pesos, abscissas, funcaoDeltaAbscissas, i);
}
momentos.Add(m);
Pesos.Add(pesos);
Abscissas.Add(abscissas);
Tempo.Add(pesosEAbscissas[j].Key);
}
for (int t = 1; t < (numeroDePassos); t++)
{
Passos[t] = Passos[t - 1] + passo;
}
}
public new void Dispose()
{
numericalRecipes = null;
rungeKutta4Ordem = null;
base.Dispose();
}
