/// <summary>
/// Método para realizar la suma 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 Sumar(NumeroComplejoBinomico a, NumeroComplejoBinomico b)
{
double parteReal = a.ParteReal + b.ParteReal;
double parteImaginaria = a.ParteImaginaria + b.ParteImaginaria;
return(new NumeroComplejoBinomico(Math.Round(parteReal, 3), Math.Round(parteImaginaria, 3)));
}
/// <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 binómico a polar.
/// </summary>
/// <param name="polar">número binómico que quiere pasarse a polar</param>
/// <returns>número complejo polar</returns>
public static NumeroComplejoPolar BinomicoAPolar(NumeroComplejoBinomico cartesiano)
{
double parteReal = cartesiano.ParteReal;
double parteImaginaria = cartesiano.ParteImaginaria;
double modulo = RedondeoDecimal(Math.Sqrt(parteReal * parteReal + parteImaginaria * parteImaginaria));
uint cuadrante = ObtenerCuadrante(parteReal, parteImaginaria);
double angulo = Math.Atan(parteImaginaria / parteReal);
switch (cuadrante)
{
case CUADRANTE_II:
angulo = angulo + Math.PI;
break;
case CUADRANTE_III:
angulo = angulo + Math.PI;
break;
case CUADRANTE_IV:
angulo = angulo + 2 * Math.PI;
break;
}
return(new NumeroComplejoPolar(modulo, angulo));
}
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);
}
/// <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);
}
/// <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;
}
/// <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 binómica</param>
/// <param name="b">número complejo en forma binómica</param>
/// <returns></returns>
public static NumeroComplejoBinomico Producto(NumeroComplejoBinomico a, NumeroComplejoBinomico b)
{
double parterealA = a.ParteReal;
double parteImgA = a.ParteImaginaria;
double parterealB = b.ParteReal;
double parteImgB = b.ParteImaginaria;
double parteRealRtado = (parterealA * parterealB) - (parteImgA * parteImgB);
double parteImgRtado = (parterealA * parteImgB) + (parteImgA * parterealB);
NumeroComplejoBinomico resltado = new NumeroComplejoBinomico(Math.Round(parteRealRtado, 3), Math.Round(parteImgRtado, 3));
return(resltado);
}
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;
}
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);
}
/// <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 NumeroComplejoBinomico getBinomico(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);
NumeroComplejoBinomico rtado = new NumeroComplejoBinomico(d_1, d_2);
return rtado;
}
public NumeroComplejoBinomico getBinomico(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);
NumeroComplejoBinomico rtado = new NumeroComplejoBinomico(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 binómico a polar.
/// </summary>
/// <param name="polar">número binómico que quiere pasarse a polar</param>
/// <returns>número complejo polar</returns>
public static NumeroComplejoPolar BinomicoAPolar(NumeroComplejoBinomico cartesiano)
{
double parteReal = cartesiano.ParteReal;
double parteImaginaria = cartesiano.ParteImaginaria;
double modulo = RedondeoDecimal(Math.Sqrt(parteReal * parteReal + parteImaginaria * parteImaginaria));
uint cuadrante = ObtenerCuadrante(parteReal, parteImaginaria);
double angulo = Math.Atan(parteImaginaria / parteReal);
switch (cuadrante)
{
case CUADRANTE_II:
angulo = angulo + Math.PI;
break;
case CUADRANTE_III:
angulo = angulo + Math.PI;
break;
case CUADRANTE_IV:
angulo = angulo + 2 * Math.PI;
break;
}
return new NumeroComplejoPolar(modulo, angulo);
}
/// <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 binómica</param>
/// <param name="b">número complejo en forma binómica</param>
/// <returns></returns>
public static NumeroComplejoBinomico Producto(NumeroComplejoBinomico a, NumeroComplejoBinomico b)
{
double parterealA = a.ParteReal;
double parteImgA = a.ParteImaginaria;
double parterealB = b.ParteReal;
double parteImgB = b.ParteImaginaria;
double parteRealRtado = (parterealA * parterealB) - (parteImgA * parteImgB);
double parteImgRtado = (parterealA * parteImgB) + (parteImgA * parterealB);
NumeroComplejoBinomico resltado = new NumeroComplejoBinomico(Math.Round(parteRealRtado,3), Math.Round(parteImgRtado,3));
return resltado;
}
/// <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 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 Sumar(NumeroComplejoBinomico a, NumeroComplejoBinomico b)
{
double parteReal = a.ParteReal + b.ParteReal;
double parteImaginaria = a.ParteImaginaria + b.ParteImaginaria;
return new NumeroComplejoBinomico(Math.Round(parteReal,3), Math.Round(parteImaginaria,3));
}
