Exemplo n.º 1
0
		public Complejo Restar(Complejo pOtroComplejo)
		{
			double mA = iReal - pOtroComplejo.Real;
			double mB = iImaginario - pOtroComplejo.Imaginario;

			return new Complejo(mA, mB);
		}
Exemplo n.º 2
0
		public Complejo Sumar(Complejo pOtroComplejo)
		{
			double mA = iReal + pOtroComplejo.Real;
			double mB = iImaginario + pOtroComplejo.Imaginario;

			return new Complejo(mA, mB);
		}
 /// <summary>
 /// La división de dos números complejos.
 /// </summary>
 /// <param name="pComplejo"></param>
 /// <returns>Devuelve una nueva instancia de la clase <c>Complejo</c>.</returns>
 public Complejo DividirPor(Complejo pComplejo)
 {
     return(new Complejo
            (
                ((this.Real * pComplejo.Real) + (this.Imaginario * pComplejo.Imaginario)) / (Math.Pow(pComplejo.Real, 2) + Math.Pow(pComplejo.Imaginario, 2)),
                ((this.Imaginario * pComplejo.Real) - (this.Real * pComplejo.Imaginario)) / (Math.Pow(pComplejo.Real, 2) + Math.Pow(pComplejo.Imaginario, 2))
            ));
 }
Exemplo n.º 4
0
		public Complejo MultiplicarPor(Complejo pOtroComplejo)
		{
			double mA = (iReal * pOtroComplejo.Real) -
				(iImaginario * pOtroComplejo.Imaginario);
			double mB = (iReal * pOtroComplejo.Imaginario) +
				(iImaginario * pOtroComplejo.Real);
			 return new Complejo(mA, mB);
		}
 /// <summary>
 /// La multiplicación de dos números complejos.
 /// </summary>
 /// <param name="pComplejo"></param>
 /// <returns>Devuelve una nueva instancia de la clase <c>Complejo</c>.</returns>
 public Complejo MultiplicarPor(Complejo pComplejo)
 {
     return
         (new Complejo
          (
              ((this.Real * pComplejo.Real) - (this.Imaginario * pComplejo.Imaginario)),
              ((this.Real * pComplejo.Imaginario) + (this.Imaginario * pComplejo.Real))
          ));
 }
Exemplo n.º 6
0
		public Complejo DividirPor(Complejo pOtroComplejo)
		{
			double mA = ((iReal * pOtroComplejo.Real) +
							(iImaginario * pOtroComplejo.Imaginario);
			double mB = (iImaginar)
			return new Complejo(mA / (Math.Pow(pOtroComplejo.Real, 2) +
								Math.Pow(pOtroComplejo.Imaginario, 2)),
							mB / (Math.Pow(pOtroComplejo.Real, 2) +
								Math.Pow(pOtroComplejo.Imaginario, 2)));
		}
Exemplo n.º 7
0
        static void Main(string[] args)
        {
            Console.Write("Ingrese la parte real del número complejo: ");
            double iReal = Convert.ToDouble(Console.ReadLine());

            Console.Write("Ingrese la parte imaginaria del número complejo: ");
            double iImaginario = Convert.ToDouble(Console.ReadLine());

            Complejo iComplejo = new Complejo(iReal, iImaginario);

            Console.Write("El complejo con el que trabajará es: {0}+{1}i", iComplejo.Real, iComplejo.Imaginario);
            Console.WriteLine();

            string opcion;

            do
            {
                Console.Clear();
                Console.WriteLine("Elija una operación a realizar con su número: ");
                Console.WriteLine("a) COMPARAR con otro complejo.");
                Console.WriteLine("b) SUMAR con otro complejo.");
                Console.WriteLine("c) RESTAR con otro complejo.");
                Console.WriteLine("d) MULTIPLICAR por otro complejo.");
                Console.WriteLine("e) DIVIDIR por otro complejo.");
                Console.WriteLine("f) Devolver el complejo CONJUGADO.");
                Console.WriteLine("g) Devolver ARGUMENTO EN RADIANES.");
                Console.WriteLine("h) Devolver ARGUMENTO EN GRADOS.");
                Console.WriteLine("i) Calcular MAGNITUD del Complejo.");
                Console.WriteLine("j) Indicar si el complejo es REAL o IMAGINARIO.");
                Console.WriteLine();
                Console.WriteLine("q) SALIR.");
                Console.WriteLine();
                opcion = Console.ReadLine();

                switch (opcion)
                {
                case "a":
                    Console.Write("Ingrese la parte real del complejo con el que desea comparar: ");
                    double iRa = Convert.ToDouble(Console.ReadLine());
                    Console.Write("Ingrese la parte imaginaria del complejo con el que desea comparar: ");
                    double iIma = Convert.ToDouble(Console.ReadLine());

                    if (iComplejo.EsIgual(iRa, iIma))
                    {
                        Console.Write("Los números son iguales.");
                    }
                    else
                    {
                        Console.Write("Los números no son iguales. ");
                    }
                    Console.ReadKey();
                    break;

                case "b":
                    Console.Write("Ingrese la parte real del complejo a sumar:");
                    double iRb = Convert.ToDouble(Console.ReadLine());
                    Console.Write("Ingrese la parte imaginaria del complejo a sumar: ");
                    double   iImb    = Convert.ToDouble(Console.ReadLine());
                    Complejo iComplb = new Complejo(iRb, iImb);
                    iComplb = iComplejo.Sumar(iComplb);
                    Console.Write("El resultado de la suma es {0} + {1}i", iComplb.Real, iComplb.Imaginario);
                    Console.ReadKey();
                    break;

                case "c":
                    Console.Write("Ingrese la parte real del complejo a restar:");
                    double iRc = Convert.ToDouble(Console.ReadLine());
                    Console.Write("Ingrese la parte imaginaria del complejo a sumar: ");
                    double   iImc    = Convert.ToDouble(Console.ReadLine());
                    Complejo iComplc = new Complejo(iRc, iImc);
                    iComplc = iComplejo.Restar(iComplc);
                    Console.Write("El resultado de la resta es {0} + {1}i", iComplc.Real, iComplc.Imaginario);
                    Console.ReadKey();
                    break;

                case "d":
                    Console.Write("Ingrese la parte real del complejo a multiplicar:");
                    double iRd = Convert.ToDouble(Console.ReadLine());
                    Console.Write("Ingrese la parte imaginaria del complejo a multiplicar: ");
                    double   iImd    = Convert.ToDouble(Console.ReadLine());
                    Complejo iCompld = new Complejo(iRd, iImd);
                    iCompld = iComplejo.MultiplicarPor(iCompld);
                    Console.Write("El resultado de la multiplicación es {0} + {1}i", iCompld.Real, iCompld.Imaginario);
                    Console.ReadKey();
                    break;

                case "e":
                    Console.Write("Ingrese la parte real del complejo a dividir:");
                    double iRe = Convert.ToDouble(Console.ReadLine());
                    Console.Write("Ingrese la parte imaginaria del complejo a dividir: ");
                    double   iIme    = Convert.ToDouble(Console.ReadLine());
                    Complejo iComple = new Complejo(iRe, iIme);
                    iComple = iComplejo.DividirPor(iComple);
                    Console.Write("El resultado de la división es {0} + {1}i", iComple.Real, iComple.Imaginario);
                    Console.ReadKey();
                    break;

                case "f":
                    Console.Write("El CONJUGADO de su complejo es el complejo {0}{1}i", iComplejo.Conjugado.Real,
                                  iComplejo.Conjugado.Imaginario);
                    Console.ReadKey();
                    break;

                case "g":
                    Console.Write("El ARGUMENTO en RADIANES de su complejo es: " + iComplejo.ArgumentoEnRadianes);
                    Console.ReadKey();
                    break;

                case "h":
                    Console.Write("El ARGUMENTO en GRADOS de su complejo es: " + iComplejo.ArgumentoEnGrados);
                    Console.ReadKey();
                    break;

                case "i":
                    Console.Write("La MAGNITUD de su complejo es: " + iComplejo.Magnitud);
                    Console.ReadKey();
                    break;
                }
            } while (opcion != "q");
        }
        /// <summary>
        /// Se evalúa la igualdad entre los números complejos como objetos de la clase <c>Complejo</c>.
        /// </summary>
        /// <param name="pComplejo"> un número complejo</param>
        /// <returns>true si los dos números complejos son iguales, false de lo contrario</returns>

        public bool EsIgual(Complejo pComplejo)
        {
            return(this == pComplejo);
        }
 /// <summary>
 /// La resta de dos números complejos.
 /// </summary>
 /// <param name="pComplejo"></param>
 /// <returns>Devuelve una nueva instancia de la clase <c>Complejo</c>, resultado de la resta de <para>pComplejo</para> y la instancia que responde al método.</returns>
 public Complejo Restar(Complejo pComplejo)
 {
     return(new Complejo(this.Real - pComplejo.Real, this.Imaginario - pComplejo.Imaginario));
 }
 /// <summary>
 /// La suma de dos números complejos.
 /// </summary>
 /// <param name="pComplejo"></param>
 /// <returns>Devuelve una nueva instancia de la clase <c>Complejo</c>, resultado de la suma de <para>pComplejo</para> y la instancia que responde al método.</returns>
 public Complejo Sumar(Complejo pComplejo)
 {
     return(new Complejo(this.Real + pComplejo.Real, this.Imaginario + pComplejo.Imaginario));
 }
Exemplo n.º 11
0
		public bool EsIgual(Complejo pOtroComplejo) {}