/// <summary>
/// Método para realizar la suma de dos números complejos en forma polar.
/// </summary>
/// <param name="a">número complejo en forma polar</param>
/// <param name="b">número complejo en forma polar</param>
/// <returns></returns>
public static NumeroComplejoPolar Sumar(NumeroComplejoPolar a, NumeroComplejoPolar b)
{
NumeroComplejoBinomico aCarteisano = PolarABinomico(a);
NumeroComplejoBinomico bCartesiano = PolarABinomico(b);
return(BinomicoAPolar(Sumar(aCarteisano, bCartesiano)));
}
/// <summary>
/// Método utilizado para pasar un número de polar a binómico.
/// </summary>
/// <param name="polar">número polar que quiere pasarse a binómico</param>
/// <returns>número complejo binómico</returns>
public static NumeroComplejoBinomico PolarABinomico(NumeroComplejoPolar polar)
{
double parteReal = RedondeoDecimal(polar.Modulo * Math.Cos(polar.Angulo));
double parteImaginaria = RedondeoDecimal(polar.Modulo * Math.Sin(polar.Angulo));
return(new NumeroComplejoBinomico(parteReal, parteImaginaria));
}
/// <summary>
/// Método para realizar el cociente de dos números complejos en forma polar.
/// </summary>
/// <param name="a">número complejo en forma polar</param>
/// <param name="b">número complejo en forma polar</param>
/// <returns></returns>
public static NumeroComplejoPolar Cociente(NumeroComplejoPolar a, NumeroComplejoPolar b)
{
double modulo = RedondeoDecimal(a.Modulo / b.Modulo);
double angulo = a.Angulo - b.Angulo;
return(new NumeroComplejoPolar(Math.Round(modulo, 3), Math.Round(angulo, 3)));
}
/// <summary>
/// Método para realizar el cociente de dos números complejos en forma polar.
/// </summary>
/// <param name="a">número complejo en forma polar</param>
/// <param name="b">número complejo en forma polar</param>
/// <returns></returns>
public static NumeroComplejoPolar Cociente(NumeroComplejoPolar a, NumeroComplejoPolar b)
{
double modulo = RedondeoDecimal(a.Modulo / b.Modulo);
double angulo = a.Angulo - b.Angulo;
return new NumeroComplejoPolar(Math.Round(modulo,3), Math.Round(angulo,3));
}
/// <summary>
/// Método para realizar el producto de dos números complejos en forma binómica.
/// </summary>
/// <param name="a">número complejo en forma polar</param>
/// <param name="b">número complejo en forma polar</param>
/// <returns></returns>
public static NumeroComplejoPolar Producto(NumeroComplejoPolar a, NumeroComplejoPolar b)
{
double modulo = RedondeoDecimal(a.Modulo * b.Modulo);
double angulo = a.Angulo + b.Angulo;
return(new NumeroComplejoPolar(modulo, angulo));
}
/// <summary>
/// Método para realizar el cociente de dos números complejos en forma binómica.
/// </summary>
/// <param name="a">número complejo en forma binómica</param>
/// <param name="b">número complejo en forma binómica</param>
/// <returns></returns>
public static NumeroComplejoBinomico Cociente(NumeroComplejoBinomico a, NumeroComplejoBinomico b)
{
NumeroComplejoPolar aPolar = BinomicoAPolar(a);
NumeroComplejoPolar bPolar = BinomicoAPolar(b);
NumeroComplejoPolar resltado = Cociente(aPolar, bPolar);
return(PolarABinomico(resltado));
}
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;
}
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;
}
/// <summary>
/// Método para realizar la raiz de un número complejo en forma polar.
/// </summary>
/// <param name="a">número complejo en forma polar</param>
/// <param name="b">raiz que se le quiere aplicar</param>
/// <returns></returns>
public static List <NumeroComplejoPolar> Raiz(NumeroComplejoPolar a, double b)
{
double modulo = Math.Pow(a.Modulo, ((double)1 / b));
List <NumeroComplejoPolar> listaRaices = new List <NumeroComplejoPolar>();
for (int i = 0; i < b; i++)
{
double angulo = (a.Angulo < 0) ? a.Angulo + (2 * Math.PI) : a.Angulo;
angulo = ((double)(angulo + (i * 2 * Math.PI)) / b);
NumeroComplejoPolar raiz = new NumeroComplejoPolar(modulo, angulo);
listaRaices.Add(raiz);
}
return(listaRaices);
}
/// <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);
}
public NumeroComplejoPolar getPolar(string numero)
{
//viene en formato [a;b]
string parte_del_medio = numero.Substring(1, numero.Length - 2);
string[] partes_del_numero = parte_del_medio.Split(';');
string primera_parte = partes_del_numero[0];
string segunda_parte = partes_del_numero[1];
primera_parte = primera_parte.Replace('.', ',');
segunda_parte = segunda_parte.Replace('.', ',');
Double d_1 = Convert.ToDouble(primera_parte);
Double d_2 = Convert.ToDouble(segunda_parte);
NumeroComplejoPolar rtado = new NumeroComplejoPolar(d_1, d_2);
return rtado;
}
public NumeroComplejoPolar getPolar(string numero)
{ //viene en formato [a;b]
string parte_del_medio = numero.Substring(1, numero.Length - 2);
string[] partes_del_numero = parte_del_medio.Split(';');
string primera_parte = partes_del_numero[0];
string segunda_parte = partes_del_numero[1];
primera_parte = primera_parte.Replace('.', ',');
segunda_parte = segunda_parte.Replace('.', ',');
Double d_1 = Convert.ToDouble(primera_parte);
Double d_2 = Convert.ToDouble(segunda_parte);
NumeroComplejoPolar rtado = new NumeroComplejoPolar(d_1, d_2);
return(rtado);
}
/// <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);
}
/// <summary>
/// Método utilizado para pasar un número de polar a binómico.
/// </summary>
/// <param name="polar">número polar que quiere pasarse a binómico</param>
/// <returns>número complejo binómico</returns>
public static NumeroComplejoBinomico PolarABinomico(NumeroComplejoPolar polar)
{
double parteReal = RedondeoDecimal(polar.Modulo * Math.Cos(polar.Angulo));
double parteImaginaria = RedondeoDecimal(polar.Modulo * Math.Sin(polar.Angulo));
return new NumeroComplejoBinomico(parteReal, parteImaginaria);
}
/// <summary>
/// Método para realizar la potencia de un número complejo en forma binómica.
/// </summary>
/// <param name="a">número complejo en forma binómica</param>
/// <param name="b">potencia a la que se lo quiere elevar</param>
/// <returns></returns>
public static NumeroComplejoBinomico Potencia(NumeroComplejoBinomico a, int b)
{
if (b == 2)
{ // z^2 = a^2-b^2 + 2abj
double parteReal = Math.Pow(a.ParteReal, 2) - Math.Pow(a.ParteImaginaria, 2);
double parteImag = 2 * a.ParteReal * a.ParteImaginaria;
NumeroComplejoBinomico ncb = new NumeroComplejoBinomico(parteReal, parteImag);
return ncb;
}
NumeroComplejoPolar polar = OperadorDeComplejos.BinomicoAPolar(a);
double modulo = Math.Pow(polar.Modulo, b);
double angulo = polar.Angulo * b;
NumeroComplejoPolar rtado_polar = new NumeroComplejoPolar(modulo, angulo);
NumeroComplejoBinomico rtado_binomico = OperadorDeComplejos.PolarABinomico(rtado_polar);
return rtado_binomico;
}
/// <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;
}
/// <summary>
/// Método para realizar el producto de dos números complejos en forma binómica.
/// </summary>
/// <param name="a">número complejo en forma polar</param>
/// <param name="b">número complejo en forma polar</param>
/// <returns></returns>
public static NumeroComplejoPolar Producto(NumeroComplejoPolar a, NumeroComplejoPolar b)
{
double modulo = RedondeoDecimal(a.Modulo * b.Modulo);
double angulo = a.Angulo + b.Angulo;
return new NumeroComplejoPolar(modulo, angulo);
}
/// <summary>
/// Método para realizar la raiz de un número complejo en forma polar.
/// </summary>
/// <param name="a">número complejo en forma polar</param>
/// <param name="b">raiz que se le quiere aplicar</param>
/// <returns></returns>
public static List<NumeroComplejoPolar> Raiz(NumeroComplejoPolar a, double b)
{
double modulo = Math.Pow(a.Modulo, ((double)1 / b));
List<NumeroComplejoPolar> listaRaices = new List<NumeroComplejoPolar>();
for (int i = 0; i < b; i++)
{
double angulo = (a.Angulo < 0) ? a.Angulo + (2 * Math.PI) : a.Angulo;
angulo = ((double)(angulo + (i * 2 * Math.PI)) / b);
NumeroComplejoPolar raiz = new NumeroComplejoPolar(modulo, angulo);
listaRaices.Add(raiz);
}
return listaRaices;
}
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
*/
}
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
*/
}
/// <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;
}
/// <summary>
/// Método para realizar la suma de dos números complejos en forma polar.
/// </summary>
/// <param name="a">número complejo en forma polar</param>
/// <param name="b">número complejo en forma polar</param>
/// <returns></returns>
public static NumeroComplejoPolar Sumar(NumeroComplejoPolar a, NumeroComplejoPolar b)
{
NumeroComplejoBinomico aCarteisano = PolarABinomico(a);
NumeroComplejoBinomico bCartesiano = PolarABinomico(b);
return BinomicoAPolar(Sumar(aCarteisano, bCartesiano));
}
