Exemple #1
0
        private void button2_Click(object sender, EventArgs e)
        {
            string str_nro1 = textBox1.Text.Trim();
            string raiz     = textBox2.Text.Trim();
            double raiz_double;
            NumeroComplejoBinomico binomico1;
            NumeroComplejoPolar    polar1;

            if (raiz.Trim().Equals("") || raiz.Trim().Equals("0"))
            {
                MessageBox.Show("Ingrese una raiz válida", null, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return;
            }
            else
            {
                try
                {
                    raiz_double = Convert.ToDouble(raiz.Replace('.', ','));
                }
                catch
                {
                    MessageBox.Show("Ingrese una raiz válida", null, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                    return;
                }
            }
            if (!numeroValido(str_nro1))
            {
                MessageBox.Show("El número ingresado no cumple con el formato establecido. \nFormatos: (a,b) o [a;b].", null, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return;
            }

            if (str_nro1.Substring(0, 1).Equals("("))
            {
                binomico1 = getBinomico(str_nro1);
                polar1    = OperadorDeComplejos.BinomicoAPolar(binomico1);
                NumeroComplejoBinomico aux = OperadorDeComplejos.PolarABinomico(polar1);
            }
            else
            {
                polar1    = getPolar(str_nro1);
                binomico1 = OperadorDeComplejos.PolarABinomico(polar1);
            }

            List <NumeroComplejoPolar>    listaRaicesPolares   = OperadorDeComplejos.Raiz(polar1, raiz_double);
            List <NumeroComplejoBinomico> listaRaicesBinomicas = OperadorDeComplejos.Raiz(binomico1, raiz_double);

            List <NumeroComplejoPolar> listaRaicesPrimitivas = new List <NumeroComplejoPolar>();

            for (int k = 0; k < listaRaicesPolares.Count; k++)
            {
                int raizint = Convert.ToInt16(raiz_double);
                if (mcd(raizint, k) == 1)
                {
                    listaRaicesPrimitivas.Add(listaRaicesPolares[k]);
                }
            }

            label9.Text = stringListaRaicesPolares(listaRaicesPrimitivas);
        }
        private void button1_Click(object sender, EventArgs e)
        {
            string str_nro1 = numero1.Text.Trim();
            string potencia = numero2.Text.Trim();
            int    potencia_int;
            NumeroComplejoBinomico binomico1;
            NumeroComplejoPolar    polar1;

            if (potencia.Trim().Equals("") || potencia.Trim().Equals("0"))
            {
                MessageBox.Show("Ingrese una potencia válida", null, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return;
            }
            else
            {
                try
                {
                    potencia_int = Convert.ToInt16(potencia);
                }
                catch {
                    MessageBox.Show("Ingrese una potencia válida", null, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                    return;
                }
            }
            if (!numeroValido(str_nro1))
            {
                MessageBox.Show("El número ingresado no cumple con el formato establecido. \nFormatos: (a,b) o [a;b].", null, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return;
            }

            if (str_nro1.Substring(0, 1).Equals("("))
            {
                binomico1 = getBinomico(str_nro1);
                polar1    = OperadorDeComplejos.BinomicoAPolar(binomico1);
                NumeroComplejoBinomico aux = OperadorDeComplejos.PolarABinomico(polar1);
            }
            else
            {
                polar1    = getPolar(str_nro1);
                binomico1 = OperadorDeComplejos.PolarABinomico(polar1);
            }

            NumeroComplejoPolar    potenciapolar    = OperadorDeComplejos.Potencia(polar1, potencia_int);
            NumeroComplejoBinomico potenciabinomico = OperadorDeComplejos.PolarABinomico(potenciapolar);

            string str_productopolar = potenciapolar.ObtenerPolar();
            string str_productobinom = potenciabinomico.ObtenerBinomica();

            label_res_polar.Text = str_productopolar;
            label_res_binom.Text = str_productobinom;
        }
Exemple #3
0
        private void button1_Click(object sender, EventArgs e)
        {
            string str_nro1 = numero1.Text.Trim();
            string str_nro2 = numero2.Text.Trim();
            NumeroComplejoBinomico binomico1;
            NumeroComplejoBinomico binomico2;
            NumeroComplejoPolar    polar1;
            NumeroComplejoPolar    polar2;


            if (!numeroValido(str_nro1) || !numeroValido(str_nro2))
            {
                MessageBox.Show("Los números ingresados no cumplen con el formato establecido. \nFormatos: (a,b) o [a;b].", null, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return;
            }

            if (str_nro1.Substring(0, 1).Equals("("))
            {
                binomico1 = getBinomico(str_nro1);
                polar1    = OperadorDeComplejos.BinomicoAPolar(binomico1);
                NumeroComplejoBinomico aux = OperadorDeComplejos.PolarABinomico(polar1);
            }
            else
            {
                polar1    = getPolar(str_nro1);
                binomico1 = OperadorDeComplejos.PolarABinomico(polar1);
            }
            if (str_nro2.Substring(0, 1).Equals("("))
            {
                binomico2 = getBinomico(str_nro2);
                polar2    = OperadorDeComplejos.BinomicoAPolar(binomico2);
            }
            else
            {
                polar2    = getPolar(str_nro2);
                binomico2 = OperadorDeComplejos.PolarABinomico(polar2);
            }

            binomico2.setParteReal(binomico2.ParteReal * -1);
            binomico2.setParteImaginaria(binomico2.ParteImaginaria * -1);
            NumeroComplejoBinomico sumadobinomico = OperadorDeComplejos.Sumar(binomico1, binomico2);
            NumeroComplejoPolar    sumadopolar    = OperadorDeComplejos.BinomicoAPolar(sumadobinomico);

            string str_sumadopolar = sumadopolar.ObtenerPolar();

            label_resul.Text = str_sumadopolar;
            string str_sumadobinomico = sumadobinomico.ObtenerBinomica();

            label7.Text = str_sumadobinomico;
        }
Exemple #4
0
        private void button1_Click(object sender, EventArgs e)
        {
            string str_nro1 = numero1.Text.Trim();
            string raiz     = numero2.Text.Trim();
            double raiz_double;
            NumeroComplejoBinomico binomico1;
            NumeroComplejoPolar    polar1;

            if (raiz.Trim().Equals("") || raiz.Trim().Equals("0"))
            {
                MessageBox.Show("Ingrese una raiz válida", null, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return;
            }
            else
            {
                try
                {
                    raiz_double = Convert.ToDouble(raiz.Replace('.', ','));
                }
                catch
                {
                    MessageBox.Show("Ingrese una raiz válida", null, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                    return;
                }
            }
            if (!numeroValido(str_nro1))
            {
                MessageBox.Show("El número ingresado no cumple con el formato establecido. \nFormatos: (a,b) o [a;b].", null, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return;
            }

            if (str_nro1.Substring(0, 1).Equals("("))
            {
                binomico1 = getBinomico(str_nro1);
                polar1    = OperadorDeComplejos.BinomicoAPolar(binomico1);
                NumeroComplejoBinomico aux = OperadorDeComplejos.PolarABinomico(polar1);
            }
            else
            {
                polar1    = getPolar(str_nro1);
                binomico1 = OperadorDeComplejos.PolarABinomico(polar1);
            }

            List <NumeroComplejoPolar>    listaRaicesPolares   = OperadorDeComplejos.Raiz(polar1, raiz_double);
            List <NumeroComplejoBinomico> listaRaicesBinomicas = OperadorDeComplejos.Raiz(binomico1, raiz_double);

            label_res_polar.Text = stringListaRaicesPolares(listaRaicesPolares);
            label_res_binom.Text = stringListaRaicesBinomicas(listaRaicesBinomicas);
        }
Exemple #5
0
        /// <summary>
        /// Método para realizar la raiz de un número complejo en forma binomica.
        /// </summary>
        /// <param name="a">número complejo en forma binómica</param>
        /// <param name="b">raiz que se le quiere aplicar</param>
        /// <returns></returns>
        public static List <NumeroComplejoBinomico> Raiz(NumeroComplejoBinomico a, double b)
        {
            NumeroComplejoPolar polar = OperadorDeComplejos.BinomicoAPolar(a);
            double modulo             = Math.Pow(polar.Modulo, ((double)1 / b));
            List <NumeroComplejoBinomico> listaRaices = new List <NumeroComplejoBinomico>();

            for (int i = 0; i < b; i++)
            {
                double angulo = (polar.Angulo < 0) ? polar.Angulo + (2 * Math.PI) : polar.Angulo;
                angulo = ((double)(angulo + (i * 2 * Math.PI)) / b);
                NumeroComplejoPolar    raiz          = new NumeroComplejoPolar(modulo, angulo);
                NumeroComplejoBinomico raiz_binomica = OperadorDeComplejos.PolarABinomico(raiz);
                listaRaices.Add(raiz_binomica);
            }
            return(listaRaices);
        }
Exemple #6
0
        /// <summary>
        /// Método para realizar la potencia de un número complejo en forma polar.
        /// </summary>
        /// <param name="a">número complejo en forma polar</param>
        /// <param name="b">potencia a la que se lo quiere elevar</param>
        /// <returns></returns>
        public static NumeroComplejoPolar Potencia(NumeroComplejoPolar a, int b)
        {
            if (b == 2)
            { // z^2 = a^2-b^2 + 2abj
                NumeroComplejoBinomico aBinomico = OperadorDeComplejos.PolarABinomico(a);
                double parteReal             = Math.Pow(aBinomico.ParteReal, 2) - Math.Pow(aBinomico.ParteImaginaria, 2);
                double parteImag             = 2 * aBinomico.ParteReal * aBinomico.ParteImaginaria;
                NumeroComplejoBinomico ncb   = new NumeroComplejoBinomico(parteReal, parteImag);
                NumeroComplejoPolar    rtado = OperadorDeComplejos.BinomicoAPolar(ncb);
                return(rtado);
            }

            double modulo = Math.Pow(a.Modulo, b);
            double angulo = a.Angulo * b;
            NumeroComplejoPolar rtado_polar = new NumeroComplejoPolar(modulo, angulo);

            return(rtado_polar);
        }
        private void button1_Click(object sender, EventArgs e)
        {
            int tipoOperacion;
            int tipoFuncion1, tipoFuncion2;

            Double amplitud1   = 0;
            Double amplitud2   = 0;
            Double fase1       = 0;
            Double fase2       = 0;
            Double frecuencia1 = 0;
            Double frecuencia2 = 0;

            NumeroComplejoBinomico fasor1B;
            NumeroComplejoBinomico fasor2B;
            NumeroComplejoBinomico resultadoOperacionB;
            NumeroComplejoPolar    resultadoOperacionP;

            // Valido que se ingresen solo números
            try
            {
                amplitud1   = Convert.ToDouble(numero1.Text.Trim());
                amplitud2   = Convert.ToDouble(textBox4.Text.Trim());
                fase1       = Convert.ToDouble(numero2.Text.Trim());
                fase2       = Convert.ToDouble(textBox3.Text.Trim());
                frecuencia1 = Convert.ToDouble(textBox1.Text.Trim());
                frecuencia2 = Convert.ToDouble(textBox2.Text.Trim());
            }
            catch
            {
                MessageBox.Show("Solo puede ingresar números.", null, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }

            // Valido que se indique si es SUMA o RESTA
            if (radioButton5.Checked)
            {
                tipoOperacion = 1;           // SUMA es 1 y RESTA es 2
            }
            else
            {
                if (radioButton6.Checked)
                {
                    tipoOperacion = 2;
                }
                else
                {
                    MessageBox.Show("Debe especificar si desea SUMAR o RESTAR.", null, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
            }

            // Valido que se indique si la primer función es COSENO o SENO
            if (radioButton1.Checked)
            {
                tipoFuncion1 = 1;            // COSENO es 1 y SENO es 2
            }
            else
            {
                if (radioButton2.Checked)
                {
                    tipoFuncion1 = 2;
                }
                else
                {
                    MessageBox.Show("Debe especificar si la primer función es SENO o COSENO.", null, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
            }

            // Valido que se indique si la segunda función es COSENO o SENO
            if (radioButton3.Checked)
            {
                tipoFuncion2 = 1;            // COSENO es 1 y SENO es 2
            }
            else
            {
                if (radioButton4.Checked)
                {
                    tipoFuncion2 = 2;
                }
                else
                {
                    MessageBox.Show("Debe especificar si la segunda función es SENO o COSENO.", null, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
            }

            // Valido que las frecuencias de las dos funciones sean iguales (así se puede aplicar fasores)
            if (!(frecuencia1 == frecuencia2))
            {
                MessageBox.Show("Las frecuencias de ambas funciones deben ser iguales.", null, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }

            // Valido que ambas funciones sean SENO o COSENO
            if (radioButton1.Checked && radioButton4.Checked)
            {
                // Transformar la segunda función
                fase2 = fase2 - (1 / 2);
            }

            if (radioButton2.Checked && radioButton3.Checked)
            {
                // Transformar la primer función
                fase1 = fase1 + (1 / 2);
            }

            NumeroComplejoPolar fasor1p = new
                                          NumeroComplejoPolar(amplitud1, fase1);

            NumeroComplejoPolar fasor2p = new
                                          NumeroComplejoPolar(amplitud2, fase2);

            fasor1B = OperadorDeComplejos.PolarABinomico(fasor1p);
            fasor2B = OperadorDeComplejos.PolarABinomico(fasor2p);

            // Sumo o resto según la operación indicada
            if (radioButton5.Checked)
            {
                resultadoOperacionB = OperadorDeComplejos.Sumar(fasor1B, fasor2B);
            }
            else
            {
                fasor2B.setParteReal(fasor2B.ParteReal * -1);
                fasor2B.setParteImaginaria(fasor2B.ParteImaginaria * -1);
                resultadoOperacionB = OperadorDeComplejos.Sumar(fasor1B, fasor2B);
            }

            resultadoOperacionP = OperadorDeComplejos.BinomicoAPolar(resultadoOperacionB);

            string str_resultado = resultadoOperacionP.Modulo + "cos(" + frecuencia1 + "t+" + resultadoOperacionP.Angulo + "π)";

            label11.Text = str_resultado;

            /* - validar que las frecuencias de ambas funciones son iguales
             * - ambas frecuencias son iguales      SI, validar si ambas son senos o cosenos
             *                                      NO, informar que ambas frecuencias deben ser iguales
             *
             * - ambas son senos o cosenos          SI, armar fasor
             *                                      NO, transformar a todo coseno o todo seno
             *
             * - armar fasor es obtener módulo y argumento (amplitud y fase)
             * - pasar a forma canónica
             * - sumar o restar (según la variable OPERACION)
             * - pasar a forma exponencial
             * - imprimir por pantalla
             */
        }