コード例 #1
0
        public void Ejercicio1()
        {
            MinimosCuadrados minimos = new MinimosCuadrados(ecuaciones);

            ParametrosMinimosCuadrados parametros = new ParametrosMinimosCuadrados();

            parametros.ValoresX = new List <decimal>()
            {
                -3, 0.5M, 1, 1.5M, 2, 3, 5
            };
            parametros.ValoresY = new List <decimal>()
            {
                -7.5M, -2.25M, -1.5M, 1M, 0, 0, 4.5M
            };

            ResultadoMinimosCuadrados resultado = new ResultadoMinimosCuadrados();

            resultado = minimos.ResolverCurvaLineal(parametros);

            string  recta = "Y = (1,4384x - 2,8762)";
            decimal CoeficienteCorrelacion = 96.7211M;

            Assert.AreEqual(resultado.RectaMejorAjuste, recta);
            Assert.AreEqual(resultado.CoeficientedeCorrelacion, CoeficienteCorrelacion);
        }
コード例 #2
0
        public List <List <decimal> > AveriguarMatrizGrado(ParametrosMinimosCuadrados parametros)
        {
            List <List <decimal> > Matriz = new List <List <decimal> >();

            for (int i = 0; i <= parametros.Grado; i++)
            {
                List <decimal> ecuacion = new List <decimal>();

                for (int x = 0; x <= parametros.Grado; x++)
                {
                    if (i == 0 && x == 0)
                    {
                        ecuacion.Add(parametros.ValoresX.Count);
                    }
                    else
                    {
                        this.ObtenerValoresXi(parametros.ValoresX, SistemaGrado10[i][x]);
                        var SumatoriaXi = this.ObtenerSuma(ValoresXi);
                        ecuacion.Add(SumatoriaXi);
                    }
                }
                if (i == 0)
                {
                    ecuacion.Add(this.ObtenerSuma(parametros.ValoresY));
                }
                else
                {
                    this.ObtenerValoresXi(parametros.ValoresX, i);
                    this.ObtenerMultiplicacionXY(ValoresXi, parametros.ValoresY);
                    ecuacion.Add(ObtenerSuma(this.MultiplicacionXY));
                }
                Matriz.Add(ecuacion);
            }
            return(Matriz);
        }
コード例 #3
0
        public ResultadoMinimosCuadrados ResolverCurvaLineal(ParametrosMinimosCuadrados parametros)
        {
            this.ObtenerValoresXi(parametros.ValoresX, 2);
            this.ObtenerMultiplicacionXY(parametros.ValoresX, parametros.ValoresY);

            decimal SumatoriaXY        = this.ObtenerSuma(MultiplicacionXY);
            decimal SumatoriaXCuadrado = this.ObtenerSuma(ValoresXi);
            decimal SumatoriaX         = this.ObtenerSuma(parametros.ValoresX);
            decimal SumatoriaY         = this.ObtenerSuma(parametros.ValoresY);
            int     puntos             = parametros.ValoresX.Count;

            decimal Pendiente = ((puntos * SumatoriaXY) - (SumatoriaX * SumatoriaY)) / ((puntos * SumatoriaXCuadrado) - Convert.ToDecimal(Math.Pow(Convert.ToDouble(SumatoriaX), 2)));

            decimal Ordenada = ((SumatoriaY) - Pendiente * (SumatoriaX)) / puntos;

            decimal Sr = 0;

            for (int i = 0; i <= parametros.ValoresX.Count - 1; i++)
            {
                Sr += Math.Round(this.ObtenerDiferencias(Convert.ToDouble(Pendiente), Convert.ToDouble(Ordenada), Convert.ToDouble(parametros.ValoresX[i]), Convert.ToDouble(parametros.ValoresY[i])), 4);
            }
            decimal yPrima = parametros.ValoresY.Average();

            decimal St = 0;

            foreach (var y in parametros.ValoresY)
            {
                St += Convert.ToDecimal(Math.Pow(Convert.ToDouble((y - yPrima)), 2));
            }

            decimal CoeficienteCorrelacion = Convert.ToDecimal(Math.Sqrt((Convert.ToDouble(St) - Convert.ToDouble(Sr)) / Convert.ToDouble(St)));
            decimal Porcentaje             = CoeficienteCorrelacion * 100;

            ResultadoMinimosCuadrados resultado = new ResultadoMinimosCuadrados();

            resultado.RectaMejorAjuste = "Y = (" + (Convert.ToString(Math.Round(Pendiente, 4)) + "x");

            if (Math.Round(Ordenada, 4) < 0)
            {
                resultado.RectaMejorAjuste = resultado.RectaMejorAjuste + Convert.ToString(Math.Round(Ordenada, 4)) + ")";
            }
            else
            {
                resultado.RectaMejorAjuste = resultado.RectaMejorAjuste + "+" + Convert.ToString(Math.Round(Ordenada, 4)) + ")";
            }
            if (Porcentaje >= 80)
            {
                resultado.Ajuste = "ACEPTABLE";
            }
            else
            {
                resultado.Ajuste = "NO ACEPTABLE";
            }
            resultado.CoeficientedeCorrelacion = Math.Round(Porcentaje, 4);
            return(resultado);
        }
コード例 #4
0
        public ResultadoIntegracionNumerica ResolverSimpson13Simple(ParametrosIntegracionNumerica parametros)
        {
            this.ObtenerParametros(parametros);

            double   xi  = (parametros.ValorExtremo1 + parametros.ValorExtremo2) / 2;
            Argument xii = new Argument("x", xi);

            ParametrosMinimosCuadrados parametroslagrange = new ParametrosMinimosCuadrados();

            List <Decimal> ValoresX = new List <decimal>();

            ValoresX.Add(Convert.ToDecimal(parametros.ValorExtremo1));
            ValoresX.Add(Convert.ToDecimal(xi));
            ValoresX.Add(Convert.ToDecimal(parametros.ValorExtremo2));

            List <Decimal> ValoresY = new List <decimal>();

            ValoresY.Add(Convert.ToDecimal(this.EvaluarFuncion(Nombre, Funcion, xa)));
            ValoresY.Add(Convert.ToDecimal(this.EvaluarFuncion(Nombre, Funcion, xii)));
            ValoresY.Add(Convert.ToDecimal(this.EvaluarFuncion(Nombre, Funcion, xb)));

            parametroslagrange.ValoresX = ValoresX;
            parametroslagrange.ValoresY = ValoresY;

            parametroslagrange.ValorX = Convert.ToDecimal(parametros.ValorExtremo1);
            var Rfxa = MinimosCuadrados.ResolverPolinomioLagrange(parametroslagrange);

            parametroslagrange.ValorX = Convert.ToDecimal(xi);
            var Rfxi = MinimosCuadrados.ResolverPolinomioLagrange(parametroslagrange);

            parametroslagrange.ValorX = Convert.ToDecimal(parametros.ValorExtremo2);
            var Rfxb = MinimosCuadrados.ResolverPolinomioLagrange(parametroslagrange);

            var h = (parametros.ValorExtremo2 - parametros.ValorExtremo1) / 2;

            double Area = Convert.ToDouble((h / 3) * (Convert.ToDouble(Rfxa.Imagen) + (4 * Convert.ToDouble(Rfxi.Imagen)) + Convert.ToDouble(Rfxb.Imagen)));

            ResultadoIntegracionNumerica resultado = new ResultadoIntegracionNumerica();

            resultado.ValorIntegral = Convert.ToDecimal(Area);

            return(resultado);
        }
コード例 #5
0
        public void Ejercicio2a()
        {
            MinimosCuadrados minimos = new MinimosCuadrados(ecuaciones);

            ParametrosMinimosCuadrados parametros = new ParametrosMinimosCuadrados();

            parametros.ValoresX = new List <decimal>()
            {
                -1, 0, 2, 3, 5, 6
            };
            parametros.ValoresY = new List <decimal>()
            {
                6, 4, 1, 1, 2, 5
            };

            ResultadoMinimosCuadrados resultado = new ResultadoMinimosCuadrados();

            resultado = minimos.ResolverCurvaLineal(parametros);
        }
コード例 #6
0
        public void Ejercicio3a()
        {
            MinimosCuadrados minimos = new MinimosCuadrados(ecuaciones);

            ParametrosMinimosCuadrados parametros = new ParametrosMinimosCuadrados();

            parametros.ValoresX = new List <decimal>()
            {
                0, 2, 3, 4, 6, 10
            };
            parametros.ValoresY = new List <decimal>()
            {
                36, 30, 28, 27, 26, 25.2M
            };

            ResultadoMinimosCuadrados resultado = new ResultadoMinimosCuadrados();

            resultado = minimos.ResolverCurvaLineal(parametros);
        }
コード例 #7
0
        public void Ejercicio2c()
        {
            MinimosCuadrados minimos = new MinimosCuadrados(ecuaciones);

            ParametrosMinimosCuadrados parametros = new ParametrosMinimosCuadrados();

            parametros.ValoresX = new List <decimal>()
            {
                -1, 0, 2, 3, 5, 6
            };
            parametros.ValoresY = new List <decimal>()
            {
                6, 4, 1, 1, 2, 5
            };
            parametros.ValorX = 4;

            ResultadoMinimosCuadrados resultado = new ResultadoMinimosCuadrados();

            resultado = minimos.ResolverPolinomioLagrange(parametros);
        }
コード例 #8
0
        public void Ejercicio4c()
        {
            MinimosCuadrados minimos = new MinimosCuadrados(ecuaciones);

            ParametrosMinimosCuadrados parametros = new ParametrosMinimosCuadrados();

            parametros.ValoresX = new List <decimal>()
            {
                0, 0.5M, 1, 2, 3, 6, 9, 12
            };
            parametros.ValoresY = new List <decimal>()
            {
                4.5M, 2.5M, 1.8333M, 1.3M, 1.071M, 0.8076M, 0.71M, 0.66M
            };
            parametros.Grado = 5;

            ResultadoMinimosCuadrados resultado = new ResultadoMinimosCuadrados();

            resultado = minimos.ResolverCurvaPolinomial(parametros);
        }
コード例 #9
0
        public void Ejercicio3b()
        {
            MinimosCuadrados minimos = new MinimosCuadrados(ecuaciones);

            ParametrosMinimosCuadrados parametros = new ParametrosMinimosCuadrados();

            parametros.ValoresX = new List <decimal>()
            {
                0, 2, 3, 4, 6, 10
            };
            parametros.ValoresY = new List <decimal>()
            {
                12, 16, 18, 20, 23, 24
            };
            parametros.Grado = 2;

            ResultadoMinimosCuadrados resultado = new ResultadoMinimosCuadrados();

            resultado = minimos.ResolverCurvaPolinomial(parametros);
        }
コード例 #10
0
        public void Ejercicio4a()
        {
            MinimosCuadrados minimos = new MinimosCuadrados(ecuaciones);

            ParametrosMinimosCuadrados parametros = new ParametrosMinimosCuadrados();

            parametros.ValoresX = new List <decimal>()
            {
                0, 0.5M, 1, 2, 3, 6, 9, 12
            };
            parametros.ValoresY = new List <decimal>()
            {
                4.5M, 2.5M, 1.8333M, 1.3M, 1.071M, 0.8076M, 0.71M, 0.66M
            };

            ResultadoMinimosCuadrados resultado = new ResultadoMinimosCuadrados();

            resultado = minimos.ResolverCurvaLineal(parametros);

            string Recta = "Y = (-0,2073x+2,5410)";

            Assert.AreEqual(Recta, resultado.RectaMejorAjuste);
        }
コード例 #11
0
        public void Ejercicio4b()
        {
            MinimosCuadrados minimos = new MinimosCuadrados(ecuaciones);

            ParametrosMinimosCuadrados parametros = new ParametrosMinimosCuadrados();

            parametros.ValoresX = new List <decimal>()
            {
                0, 0.5M, 1, 2, 3, 6, 9, 12
            };
            parametros.ValoresY = new List <decimal>()
            {
                4.5M, 2.5M, 1.8333M, 1.3M, 1.071M, 0.8076M, 0.71M, 0.66M
            };
            parametros.Grado = 2;

            ResultadoMinimosCuadrados resultado = new ResultadoMinimosCuadrados();

            resultado = minimos.ResolverCurvaPolinomial(parametros);

            string Recta = "Y = (0,0482x^(2))+(-0,7632x^(1))+(3,2103x^(0))";

            Assert.AreEqual(Recta, resultado.RectaMejorAjuste);
        }
コード例 #12
0
        public ResultadoMinimosCuadrados ResolverCurvaPolinomial(ParametrosMinimosCuadrados parametros)
        {
            this.InicializarSistemaGrado10();
            List <List <decimal> > SistemaResolver = this.AveriguarMatrizGrado(parametros);

            ResultadoEcuaciones Incognitas = MetodoEcuaciones.ResolverEcuacionGaussJordan(new ParametrosEcuaciones {
                ValoresIniciales = SistemaResolver
            });

            List <int> ListaIndices = new List <int>();

            for (int i = 0; i <= parametros.Grado; i++)
            {
                ListaIndices.Add(i);
            }

            string  Recta  = "Y = ";
            decimal ValorY = 0;

            for (int i = parametros.Grado; i >= 0; i--)
            {
                Recta  += "(" + (Convert.ToString(Math.Round(Incognitas.ResultadosEcuaciones[i], 4))) + "x^(" + ListaIndices[i] + "))";
                ValorY += (Incognitas.ResultadosEcuaciones[i] * Convert.ToDecimal(Math.Pow(Convert.ToDouble(parametros.ValorX), (Convert.ToDouble(ListaIndices[i])))));

                if (i != 0)
                {
                    Recta += "+";
                }
            }

            decimal Sr = 0;

            for (int i = 0; i <= parametros.ValoresX.Count - 1; i++)
            {
                decimal Error = 0;
                int     grado = parametros.Grado;
                for (int j = Incognitas.ResultadosEcuaciones.Count - 1; j >= 0; j--)
                {
                    Error += Incognitas.ResultadosEcuaciones[j] * (Convert.ToDecimal(Math.Pow(Convert.ToDouble(parametros.ValoresX[i]), grado)));
                    grado -= 1;
                }
                Error -= parametros.ValoresY[i];

                Sr += Convert.ToDecimal(Math.Pow(Convert.ToDouble(Error), 2));
            }

            decimal St = 0;

            decimal yPrima = parametros.ValoresY.Average();

            foreach (var y in parametros.ValoresY)
            {
                St += Convert.ToDecimal(Math.Pow(Convert.ToDouble((y - yPrima)), parametros.Grado));
            }

            decimal CoeficienteCorrelacion = Convert.ToDecimal(Math.Sqrt(Math.Abs((Convert.ToDouble(St) - Convert.ToDouble(Sr))) / Convert.ToDouble(St)));
            decimal Porcentaje             = CoeficienteCorrelacion * 100;

            ResultadoMinimosCuadrados resultado = new ResultadoMinimosCuadrados();

            resultado.RectaMejorAjuste = Recta;
            resultado.Imagen           = ValorY;

            if (Porcentaje >= 80)
            {
                resultado.Ajuste = "ACEPTABLE";
            }
            else
            {
                resultado.Ajuste = "NO ACEPTABLE";
            }

            resultado.CoeficientedeCorrelacion = Math.Round(Porcentaje, 4);

            return(resultado);
        }
コード例 #13
0
        public ResultadoMinimosCuadrados ResolverPolinomioLagrange(ParametrosMinimosCuadrados parametros)
        {
            string Polinomio = "Y= ";

            for (int i = 0; i <= parametros.ValoresX.Count - 1; i++)
            {
                string Numerador = "";
                for (int x = 0; x <= parametros.ValoresX.Count - 1; x++)
                {
                    if (x != i)
                    {
                        if (parametros.ValoresX[x] < 0)
                        {
                            Numerador = Numerador + "(x+" + Convert.ToString(parametros.ValoresX[x] * -1) + ")";
                        }
                        else
                        {
                            Numerador = Numerador + "(x-" + Convert.ToString(parametros.ValoresX[x]) + ")";
                        }
                        if (x != parametros.ValoresX.Count - 1)
                        {
                            if (i != parametros.ValoresX.Count - 1 && x != parametros.ValoresX.Count - 2)
                            {
                                Numerador = Numerador + "*";
                            }
                        }
                    }
                }

                int     contador    = 0;
                decimal denominador = 0;

                for (int x = 0; x <= parametros.ValoresX.Count - 1; x++)
                {
                    decimal resta = 0;
                    if (x != i)
                    {
                        resta     = parametros.ValoresX[i] - parametros.ValoresX[x];
                        contador += 1;
                        if (contador == 1)
                        {
                            denominador = resta;
                        }
                        else
                        {
                            denominador = denominador * resta;
                        }
                    }
                }
                string Polinomiox = "";
                Polinomiox = "(" + Convert.ToString(parametros.ValoresY[i] + "*" + Numerador + "/" + denominador + ")");
                Polinomio  = Polinomio + Polinomiox;

                if (i != parametros.ValoresX.Count - 1)
                {
                    Polinomio = Polinomio + "+";
                }
            }

            decimal ValorPunto = 0;

            if (Convert.ToString(parametros.ValorX) != "")
            {
                for (int j = 0; j <= parametros.ValoresX.Count - 1; j++)
                {
                    decimal Productoria = 0;
                    int     contador    = 0;
                    for (int i = 0; i <= parametros.ValoresX.Count - 1; i++)
                    {
                        if (j != i)
                        {
                            decimal Operacion = ((parametros.ValorX - parametros.ValoresX[i]) / (parametros.ValoresX[j] - parametros.ValoresX[i]));
                            contador += 1;

                            if (contador == 1)
                            {
                                Productoria = Operacion;
                            }
                            else
                            {
                                Productoria = Productoria * Operacion;
                            }
                        }
                    }
                    ValorPunto += Productoria * parametros.ValoresY[j];
                }
            }

            ResultadoMinimosCuadrados resultado = new ResultadoMinimosCuadrados();

            resultado.RectaMejorAjuste = Polinomio;
            resultado.Imagen           = ValorPunto;

            return(resultado);
        }
コード例 #14
0
        private void btnCalcular_Click(object sender, EventArgs e)
        {
            List <decimal> ValoresX = new List <decimal>();
            List <decimal> ValoresY = new List <decimal>();

            int cantidadvalores = Convert.ToInt32(txtboxCantidadValores.Text);

            for (int i = 0; i <= cantidadvalores - 1; i++)
            {
                ValoresX.Add(Convert.ToDecimal(Grilla.Rows[i].Cells[0].Value));
                ValoresY.Add(Convert.ToDecimal(Grilla.Rows[i].Cells[1].Value));
            }

            ResultadoMinimosCuadrados resultado = new ResultadoMinimosCuadrados();

            if (comboMetodo.Text == "REGRESION LINEAL")
            {
                ParametrosMinimosCuadrados parametros = new ParametrosMinimosCuadrados();
                parametros.ValoresX = ValoresX;
                parametros.ValoresY = ValoresY;

                resultado = MinimosCuadrados.ResolverCurvaLineal(parametros);

                this.labelResultado.Visible            = true;
                this.labelResultadoAjuste.Visible      = true;
                this.labelResultadoCoeficiente.Visible = true;
                this.labelCoeficiente.Visible          = true;
                this.labelRecta.Visible  = true;
                this.labelAjuste.Visible = true;
                this.Resultado.Visible   = true;
                this.txtboxRecta.Visible = true;

                this.labelResultadoAjuste.Text      = resultado.Ajuste;
                this.txtboxRecta.Text               = resultado.RectaMejorAjuste;
                this.Resultado.Text                 = "SE ENCONTRO LA RECTA DE MEJOR AJUSTE";
                this.labelResultadoCoeficiente.Text = Convert.ToString(resultado.CoeficientedeCorrelacion) + " %";
            }
            else
            {
                if (comboMetodo.Text == "REGRESION POLINOMIAL")
                {
                    ParametrosMinimosCuadrados parametros = new ParametrosMinimosCuadrados();
                    parametros.ValoresX = ValoresX;
                    parametros.ValoresY = ValoresY;

                    if (txtGrado.Text == "")
                    {
                        MessageBox.Show("No se colocaron correctamente los parametros", "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        this.btnCalcular.Enabled = true;
                        return;
                    }

                    parametros.Grado = Convert.ToInt32(txtGrado.Text);
                    if (textBoxValorX.Text != "")
                    {
                        parametros.ValorX = Convert.ToDecimal(textBoxValorX.Text);
                    }

                    resultado = MinimosCuadrados.ResolverCurvaPolinomial(parametros);

                    this.labelResultado.Visible            = true;
                    this.labelResultadoAjuste.Visible      = true;
                    this.labelResultadoCoeficiente.Visible = true;
                    this.labelCoeficiente.Visible          = true;
                    this.labelRecta.Visible  = true;
                    this.labelAjuste.Visible = true;
                    this.Resultado.Visible   = true;
                    this.txtboxRecta.Visible = true;
                    if (textBoxValorX.Text == "")
                    {
                        this.labelImagenY.Visible          = false;
                        this.labelImagenYResultado.Visible = false;
                    }
                    else
                    {
                        this.labelImagenY.Visible          = true;
                        this.labelImagenYResultado.Visible = true;
                    }

                    this.labelResultadoAjuste.Text      = resultado.Ajuste;
                    this.txtboxRecta.Text               = resultado.RectaMejorAjuste;
                    this.Resultado.Text                 = "SE ENCONTRO LA RECTA DE MEJOR AJUSTE";
                    this.labelResultadoCoeficiente.Text = Convert.ToString(resultado.CoeficientedeCorrelacion) + " %";
                    this.labelImagenYResultado.Text     = Convert.ToString(resultado.Imagen);
                }
                else
                {
                    ParametrosMinimosCuadrados parametros = new ParametrosMinimosCuadrados();
                    parametros.ValoresX = ValoresX;
                    parametros.ValoresY = ValoresY;
                    if (textBoxValorX.Text != "")
                    {
                        parametros.ValorX = Convert.ToDecimal(textBoxValorX.Text);
                    }

                    resultado = MinimosCuadrados.ResolverPolinomioLagrange(parametros);

                    this.labelResultado.Visible            = true;
                    this.labelResultadoAjuste.Visible      = false;
                    this.labelResultadoCoeficiente.Visible = false;
                    this.labelCoeficiente.Visible          = false;
                    this.labelRecta.Visible  = true;
                    this.labelAjuste.Visible = false;
                    this.Resultado.Visible   = true;
                    this.txtboxRecta.Visible = true;
                    if (textBoxValorX.Text == "")
                    {
                        this.labelImagenY.Visible          = false;
                        this.labelImagenYResultado.Visible = false;
                    }
                    else
                    {
                        this.labelImagenY.Visible          = true;
                        this.labelImagenYResultado.Visible = true;
                    }

                    this.labelResultadoAjuste.Text      = Convert.ToString(resultado.Imagen);
                    this.txtboxRecta.Text               = resultado.RectaMejorAjuste;
                    this.Resultado.Text                 = "SE ENCONTRO LA RECTA DE MEJOR AJUSTE";
                    this.labelResultadoCoeficiente.Text = Convert.ToString(resultado.CoeficientedeCorrelacion);
                    this.labelImagenYResultado.Text     = Convert.ToString(resultado.Imagen);
                }
            }
        }