public ResultadoRegresion MetodoLagrange(ParametroRegresion parametro, double ValorX)
{
int CantPuntos = parametro.ValoresX.Count;
double Resultado = 0;
for (int j = 0; j < CantPuntos; j++)
{
double Productoria = 1;
for (int i = 0; i < CantPuntos; i++)
{
if (j != i)
{
Productoria = Productoria * ((ValorX - parametro.ValoresX[i]) / (parametro.ValoresX[j] - parametro.ValoresX[i]));
}
}
Resultado += Productoria * parametro.ValoresY[j];
}
ResultadoRegresion retornar = new ResultadoRegresion();
retornar.Resultado.Add(Resultado);
retornar.CoeficienteCorrelacion = 0;
return(retornar);
}
public ResultadoRegresion MinimosCuadrados(ParametrosRegresion parametros)
{
var resultado = new ResultadoRegresion();
var numeroDePares = parametros.NumPares;
double sumatoriaX = parametros.X.Sum();
double sumatoriaY = parametros.Y.Sum();
double sumatoriaXCuadrado = 0;
double promedioX = parametros.X.Sum() / parametros.NumPares;
double promedioY = parametros.Y.Sum() / parametros.NumPares;
foreach (var item in parametros.X)
{
sumatoriaXCuadrado = (sumatoriaXCuadrado + (item * item));
}
double sumatoriaXporY = 0;
for (int i = 0; i < numeroDePares; i++)
{
sumatoriaXporY = sumatoriaXporY + (parametros.X[i] * parametros.Y[i]);
}
double deltaA1 = (numeroDePares * sumatoriaXporY) - (sumatoriaX * sumatoriaY);
double delta = (numeroDePares * sumatoriaXCuadrado) - (sumatoriaX * sumatoriaX);
resultado.Pendiente = deltaA1 / delta;
resultado.OrdenadaOrigen = promedioY - (resultado.Pendiente * promedioX);
return(resultado);
}
private ResultadoRegresion MetodosCerrados(ParametroCompuesto parametros, MetodoCerradoDelegate calcularXr)
{
ResultadoRegresion resultado = new ResultadoRegresion();
var resultadoxi = Utilidad.EvaluarFuncion(parametros.Funcion, parametros.Xi);
var resultadoxd = Utilidad.EvaluarFuncion(parametros.Funcion, parametros.Xd);
if (resultadoxi.Equals(double.NaN) || resultadoxd.Equals(double.NaN))
{
throw new ArgumentException("Verificar Función", "parametros.Funcion");
}
if (resultadoxi * resultadoxd > 0)
{
throw new ArgumentException("Ingresar nuevamente los extremos", "parametros.Xi");
}
if (resultadoxi * resultadoxd == 0)
{
if (resultadoxi == 0)
{
resultado.Raiz = parametros.Xi;
}
else
{
resultado.Raiz = parametros.Xd;
}
resultado.Iteraciones = 0;
resultado.ErrorRelativo = 0;
return(resultado);
}
return(this.BuscarRaicesCerrados(parametros, calcularXr));
}
public ResultadoRegresion MetodoRegresionLineal(ParametroRegresion parametro)
{
ResultadoRegresion Devolver = new ResultadoRegresion();
var n = parametro.ValoresX.Count;
var SumatoriaX = parametro.ValoresX.Sum();
var SumatoriaY = parametro.ValoresY.Sum();
var SumatoriaXCuadrada = parametro.ValoresX.Sum(x => x * x);
double SumatoriaXporY = 0;
var PromedioY = SumatoriaY / n;
var PromedioX = SumatoriaX / n;
for (int i = 0; i < parametro.ValoresX.Count; i++)
{
SumatoriaXporY = SumatoriaXporY + (parametro.ValoresX[i] * parametro.ValoresY[i]);
}
var A1 = ((n * SumatoriaXporY) - (SumatoriaX * SumatoriaY)) / ((n * SumatoriaXCuadrada) - (SumatoriaX * SumatoriaX));
var A0 = PromedioY - (A1 * PromedioX);
Devolver.Resultado.Add(A0);
Devolver.Resultado.Add(A1);
Devolver.CoeficienteCorrelacion = this.CalcularCoeficienteDeCorrelacion(parametro, PromedioY, new List <double>()
{
A0, A1
});
return(Devolver);
}
private void button2_Click(object sender, EventArgs e)
{
bool band = true;
int numero = Convert.ToInt32(this.textBox1.Text);
double[] vecx = new double[numero];
double[] vecy = new double[numero];
List <TextBox> lista = panel1.Controls.OfType <TextBox>().ToList();
if (VerificarDatosMetodo(lista) == true)
{
for (int i = 0; i < numero; i++)
{
vecx[i] = Convert.ToDouble(lista.ElementAt(i).Text);
}
int c = 0;
int n = numero * 2;
for (int j = numero; j < n; j++)
{
vecy[c] = Convert.ToDouble(lista.ElementAt(j).Text);
c++;
}
}
else
{
MessageBox.Show("Complete todos los campos");
band = false;
}
if (band == true)
{
DatosParametros datos = new DatosParametros();
datos.NumPares = numero;
datos.X = vecx;
datos.Y = vecy;
ResultadoRegresion NuevoResultado = new ResultadoRegresion();
FormularioPrincipal formularioprincipal = this.Owner as FormularioPrincipal;
if (formularioprincipal != null)
{
NuevoResultado = formularioprincipal.MinimosCuadrados(datos);
string variable = "";
variable = Convert.ToString("EFECTIVIDAD: " + NuevoResultado.Efectividad + " ORDENADA ORIGEN: " + NuevoResultado.OrdenadaOrigen + " PENDIENTE: " + NuevoResultado.Pendiente);
MessageBox.Show(variable);
}
}
}
private void button1_Click(object sender, EventArgs e)
{
double[,] Matriz = new double[Cantidad, 2];
for (int i = 0; i < Cantidad; i++)
{
for (int j = 0; j < 2; j++)
{
string texto = dataGridView1.Rows[i].Cells[j].Value.ToString();
if (texto == "")
{
texto = "Invalido";
}
double textoADouble;
bool result = double.TryParse(texto, out textoADouble);
if (result)
{
Matriz[i, j] = textoADouble;
}
}
}
MatrizUsada = Matriz;
Regresion nuevaRegresion = new Regresion();
if (Metodo == "Regresión Lineal por mínimos cuadrados")
{
ResultadoRegresion nuevoResultado = new ResultadoRegresion();
nuevoResultado = nuevaRegresion.CalcularRegresionLineal(Matriz, Cantidad);
MessageBox.Show("El termino independiente es: " + nuevoResultado.Resultadoa0 + ", su coeficiente es: " + nuevoResultado.Resultadoa1 + ", y su coeficiente de correlacion es: " + nuevaRegresion.CoefienteCorrelacion(Matriz, Cantidad, nuevoResultado.Resultados));
}
else
{
if (Metodo == "Regresión Polinomial por mínimos cuadrados")
{
var nuevoResultado = nuevaRegresion.CalcularRegrecionPolinomial(Matriz, Cantidad, 2);
ResultadosRegresion = nuevoResultado.Resultados;
CoeficienteCorrelacion = nuevaRegresion.CoefienteCorrelacion(Matriz, Cantidad, nuevoResultado.Resultados);
ResultadosRegresion nuevoResultadoRegresion = new Regresión.ResultadosRegresion();
nuevoResultadoRegresion.Owner = this;
nuevoResultadoRegresion.Show();
}
else
{
var nuevoResultado = nuevaRegresion.CalcularLagrange(Matriz, Cantidad, numeroLagrange);
MessageBox.Show("El valor correspondiente cuando x= " + numeroLagrange + " es: " + nuevoResultado + ", a traves del metodo de Lagrange");
}
}
}
private ResultadoRegresion BuscarRaicesCerrados(ParametroCompuesto parametros, MetodoCerradoDelegate calcularXr)
{
ResultadoRegresion resultado = new ResultadoRegresion
{
ErrorRelativo = 0,
Iteraciones = 0
};
int contador = 0;
double anterior = 0;
double errorRelativo = 0;
var XI = parametros.Xi;
var XD = parametros.Xd;
double xr = calcularXr(XI, XD, parametros.Funcion);
if (xr != 0)
{
errorRelativo = (xr - anterior) / xr;
}
var resultadoXR = Utilidad.EvaluarFuncion(parametros.Funcion, xr);
while ((Math.Abs(errorRelativo) > parametros.Tolerancia || xr == 0) && contador < parametros.Iteraciones && Math.Abs(resultadoXR) > parametros.Tolerancia)
{
if (Utilidad.EvaluarFuncion(parametros.Funcion, XI) * Utilidad.EvaluarFuncion(parametros.Funcion, xr) > 0)
{
XI = xr;
}
else
{
XD = xr;
}
anterior = xr;
xr = calcularXr(XI, XD, parametros.Funcion);
contador += 1;
if (Math.Abs(xr) > ((parametros.Tolerancia) * 10))
{
errorRelativo = (xr - anterior) / xr;
}
resultadoXR = Utilidad.EvaluarFuncion(parametros.Funcion, xr);
}
resultado.Iteraciones = contador;
resultado.ErrorRelativo = errorRelativo;
resultado.Raiz = xr;
return(resultado);
}
private void MostrarResultado(ResultadoRegresion resultado)
{
Grilla_Res.Controls.Clear();
int Columna = 2;
ResultadoMat = new TextBox[resultado.Resultado.Count, Columna];
int TamañoText = Grilla_Res.Width / Columna;
for (int y = 0; y < Columna; y++)
{
for (int x = 0; x < resultado.Resultado.Count; x++)
{
ResultadoMat[x, y] = new TextBox();
if (y == 1)
{
ResultadoMat[x, y].Text = resultado.Resultado[x].ToString("0.0000");
}
else
{
if (resultado.Resultado.Count == 1)
{
ResultadoMat[x, y].Text = "F(x)";
}
else
{
ResultadoMat[x, y].Text = "A" + x;
}
}
ResultadoMat[x, y].Top = (x * Matriz[x, y].Height) + 20;
ResultadoMat[x, y].Left = y * TamañoText;
ResultadoMat[x, y].Width = TamañoText - 2;
Grilla_Res.Controls.Add(ResultadoMat[x, y]);
}
}
txt_Coeficiente.Text = resultado.CoeficienteCorrelacion.ToString();
}
private void btn_Calcular_Click(object sender, EventArgs e)
{
ParametroCompuesto parametros = new ParametroCompuesto();
parametros.Funcion = txt_Funcion.Text;
parametros.Iteraciones = Convert.ToInt32(txt_Iteraciones.Text);
parametros.Tolerancia = Convert.ToDouble(txt_Tolerancia.Text);
parametros.Xi = Convert.ToDouble(txt_ValorXi.Text);
parametros.Xd = Convert.ToDouble(txt_ValorXd.Text);
ResultadoRegresion Resultado = null;
switch (MetodoActual)
{
case EMetodo.Biseccion:
try
{
Resultado = this.MetodosRaices.Biseccion(parametros);
txt_Raiz.Text = Resultado.Raiz.ToString("0.000000000000");
txt_IteracionesActual.Text = Resultado.Iteraciones.ToString();
txt_Error.Text = Resultado.ErrorRelativo.ToString("0.000000000000");
}
catch (ArgumentException Exception)
{
MessageBox.Show(Exception.Message);
if (Exception.ParamName == "parametros.Xi")
{
txt_ValorXi.Text = string.Empty;
txt_ValorXd.Text = string.Empty;
}
}
break;
case EMetodo.ReglaFalsa:
try
{
Resultado = this.MetodosRaices.ReglaFalsa(parametros);
txt_Raiz.Text = Resultado.Raiz.ToString("0.000000000000");
txt_IteracionesActual.Text = Resultado.Iteraciones.ToString();
txt_Error.Text = Resultado.ErrorRelativo.ToString("0.000000000000");
}
catch (ArgumentException Exception)
{
MessageBox.Show(Exception.Message);
if (Exception.ParamName == "parametros.Xi")
{
txt_ValorXi.Text = string.Empty;
txt_ValorXd.Text = string.Empty;
}
}
break;
case EMetodo.Secante:
try
{
Resultado = this.MetodosRaices.Secante(parametros);
txt_Raiz.Text = Resultado.Raiz.ToString("0.000000000000");
txt_IteracionesActual.Text = Resultado.Iteraciones.ToString();
txt_Error.Text = Resultado.ErrorRelativo.ToString("0.000000000000");
}
catch (ArgumentException Exception)
{
MessageBox.Show(Exception.Message);
if (Exception.ParamName == "Xi")
{
txt_ValorXi.Text = string.Empty;
}
if (Exception.ParamName == "Xd")
{
txt_ValorXd.Text = string.Empty;
}
}
catch (DivideByZeroException Exception)
{
MessageBox.Show(Exception.Message);
}
catch (NoRaizException Exception)
{
MessageBox.Show(Exception.Message);
txt_Raiz.Text = Exception.Valor.ToString();
txt_IteracionesActual.Text = Exception.Iteraciones.ToString();
}
break;
}
}
public ResultadoRegresion MinimosCuadradosPolinomioGradoN(ParametrosRegresion parametros)
{
var resul = new ResultadoRegresion();
double sumatoriaX = parametros.X.Sum();
double sumatoriaY = parametros.Y.Sum();
double r = 0;
while (parametros.Grado <= 10 && r <= parametros.Error)
{
double[,] matriz = new double[parametros.Grado + 1, parametros.Grado + 2];
resul = null;
resul = new ResultadoRegresion();
var pot = 0;
for (int columna = 0; columna < parametros.Grado + 1; columna++)
{
if (columna > 0)
{
pot = columna;
for (int i = 0; i < parametros.Grado + 1; i++)
{
matriz[i, columna] = RetornarSumXpotencia(parametros.X, pot);
pot++;
}
}
else if (columna == 0)
{
pot = 1;
matriz[0, 0] = parametros.NumPares;
for (int i = 1; i < parametros.Grado + 1; i++)
{
matriz[i, columna] = RetornarSumXpotencia(parametros.X, pot);
pot++;
}
}
}
for (int i = 0; i < parametros.Grado + 1; i++)
{
if (i != 0)
{
pot = 1;
matriz[i, parametros.Grado + 1] = RetornarXPorY(i, parametros.X, parametros.Y);
pot++;
}
else
{
matriz[i, parametros.Grado + 1] = parametros.Y.Sum();
}
}
//var SistemaDeEcucuaciones = new SistemaDeEcuaciones();
var param = new ParametrosEcuaciones();
param.NumIncognitas = parametros.Grado + 1;
for (int i = 0; i < parametros.Grado + 1; i++)
{
for (int c = 0; c < parametros.Grado + 2; c++)
{
param.Coeficientes.Add(matriz[i, c]);
}
}
var resultadoGauss = metodosSistemaEcuaciones.GaussJordan(param);
r = CalcularR(parametros.X, parametros.Y, resultadoGauss.Resultados);
parametros.Grado++;
resul.Efectividad = r;
resul.Resul = resultadoGauss.Resultados;
resul.GradoFinal = parametros.Grado - 1;
}
return(resul);
}
public ResultadoRegresion Secante(ParametroCompuesto parametros)
{
ResultadoRegresion resultado = new ResultadoRegresion()
{
Iteraciones = 0,
ErrorRelativo = 0
};
VerificaParametros(parametros);
var resultadoxi = Utilidad.EvaluarFuncion(parametros.Funcion, parametros.Xi);
var resultadoxd = Utilidad.EvaluarFuncion(parametros.Funcion, parametros.Xd);
if (resultadoxd * resultadoxi == 0)
{
if (resultadoxd == 0)
{
resultado.Raiz = parametros.Xd;
}
else
{
resultado.Raiz = parametros.Xi;
}
return(resultado);
}
double errorRelativo = 0;
int contador = 0;
double anterior = 0;
var Xi = parametros.Xi;
var Xd = parametros.Xd;
double Xr = 0;
double resultadoXr = 0;
do
{
if ((Utilidad.EvaluarFuncion(parametros.Funcion, Xi) - Utilidad.EvaluarFuncion(parametros.Funcion, Xd)) == 0)
{
throw new DivideByZeroException("División por 0");
}
Xr = ((Utilidad.EvaluarFuncion(parametros.Funcion, Xi) * Xd) - (Utilidad.EvaluarFuncion(parametros.Funcion, Xd) * Xi)) / ((Utilidad.EvaluarFuncion(parametros.Funcion, Xi) - Utilidad.EvaluarFuncion(parametros.Funcion, Xd)));
resultadoXr = Utilidad.EvaluarFuncion(parametros.Funcion, Xr);
contador += 0;
if (resultadoXr.Equals(double.NaN))
{
throw new NoRaizException(Xr, "Punto fuera del dominio de la funcion", 0);
}
if (double.IsInfinity(resultadoXr))
{
throw new NoRaizException(Xr, "La Funcion evaluada en este punto es infinita", contador);
}
if (Xr != 0)
{
errorRelativo = ((Xr - anterior) / Xr);
}
Xi = Xd;
Xd = Xr;
anterior = Xr;
} while ((Math.Abs(errorRelativo) > parametros.Tolerancia || Xr == 0) && contador < parametros.Iteraciones && Math.Abs(resultadoXr) > parametros.Tolerancia);
if (Math.Abs(resultadoXr) > parametros.Tolerancia * 100)
{
throw new NoRaizException(Xr, "Valor muy alejado de la raiz", contador);
}
resultado.Raiz = Xr;
resultado.Iteraciones = contador;
resultado.ErrorRelativo = Math.Abs(errorRelativo);
return(resultado);
}
public ResultadoRegresion NewtonRaphson(ParametroSimple parametros)
{
ResultadoRegresion resultado = new ResultadoRegresion()
{
Iteraciones = 0,
ErrorRelativo = 0
};
double resultadoXr = Utilidad.EvaluarFuncion(parametros.Funcion, parametros.Xi);
if (resultadoXr.Equals(Double.NaN))
{
throw new ArgumentException("Verificar Funcion", "Funcion");
}
if (resultadoXr == 0)
{
resultado.Raiz = parametros.Xi;
return(resultado);
}
double Anterior = 0;
int Contador = 0;
double ValorX = parametros.Xi;
double Tolerancia = parametros.Tolerancia;
double ValorXTole = (ValorX + Tolerancia);
double ValorFXTole = Utilidad.EvaluarFuncion(parametros.Funcion, ValorXTole);
double ValorXfun = Utilidad.EvaluarFuncion(parametros.Funcion, ValorX);
double ValorNumerador = ValorFXTole - ValorXfun;
double Derivada = ValorNumerador / Tolerancia;
double xr = 0;
double errorRelativo = 0;
do
{
if (Math.Abs(Derivada) < parametros.Tolerancia)
{
throw new NoRaizException(ValorX, "La Recta TG en este punto es horizontal", Contador);
}
xr = ValorX - (Utilidad.EvaluarFuncion(parametros.Funcion, ValorX) / Derivada);
resultadoXr = Utilidad.EvaluarFuncion(parametros.Funcion, xr);
if (resultadoXr.Equals(double.NaN))
{
throw new NoRaizException(xr, "El valor no pertenece al dominio de la Funcion", Contador);
}
errorRelativo = (xr - Anterior) / xr;
Contador += 1;
Anterior = xr;
ValorX = xr;
ValorXTole = (ValorX + Tolerancia);
ValorFXTole = Utilidad.EvaluarFuncion(parametros.Funcion, ValorXTole);
ValorXfun = Utilidad.EvaluarFuncion(parametros.Funcion, ValorX);
ValorNumerador = ValorFXTole - ValorXfun;
Derivada = ValorNumerador / Tolerancia;
} while (Math.Abs(resultadoXr) > Tolerancia && Contador < parametros.Iteraciones && (Math.Abs(errorRelativo) > Tolerancia || xr == 0));
if (Math.Abs(resultadoXr) > Tolerancia * 100)
{
throw new NoRaizException(xr, "Valor muy alejado de la raiz", Contador);
}
resultado.Raiz = xr;
resultado.ErrorRelativo = Math.Abs(errorRelativo);
resultado.Iteraciones = Contador;
return(resultado);
}
