Definicin de nmero complejo

Un nmero complejo, es una entidad matemtica que viene dada por un par de nmeros reales, el primero x se denomina la parte real y al segundo y la parte imaginaria. Los nmeros complejos se representa por un par de nmeros entre parntesis (x, y), como los puntos del plano, o bien, en la forma usual dex+yi, i se denomina la unidad imaginaria, la raz cuadrada de menos uno. La clase Complejo constar de dos miembros dato, la parte real real, y la parte imaginaria imag, ambos del tipo predefinido double. Los nmeros complejos son una extensin de los nmeros reales y forman el mnimo cuerpo algebraicamente cerrado que los contiene. El conjunto de los nmeros complejos se designa como , siendo el conjunto de los reales se cumple que . Los nmeros complejos incluyen todas las races de los polinomios, a diferencia de los reales. Todo nmero complejo puede representarse como la suma de un nmero real y un nmero imaginario (que es un mltiplo real de launidad imaginaria, que se indica con la letra i). public class Complejo{ private double real; private double imag; //faltan las funciones miembro }

Los constructores Crearemos los objetos de la clase Complejo, que denominaremos nmeros complejos, o simplemente complejos, llamando a algunos de los constructores de dicha clase. Tendremos un constructor por defecto, que reserva espacio en memoria para dos nmeros del tipo double, y los inicializa por defecto, a cero. El constructor por defecto se llama cuando se crea un objeto c de la clase Complejo de la forma Complejo c=new Complejo(); El constructor explcito, reserva espacio en memoria, e inicializa los miembros dato con los valores que el usuario le pasa al constructor. Para crear un nmero complejo cuya parte real sea 2 y cuya parte imaginaria sea 3, se escribe. Complejo c=new Complejo(2.0, 3.0); La definicin de la clase Complejo con dos constructores ser la siguiente

public class Complejo{ private double real; private double imag;

public Complejo() { real=0.0; imag=0.0; } public Complejo(double real, double imag){ this.real=real; this.imag=imag; } //otras funciones miembro }

Mostrar un nmero complejo Para mostrar un nmero complejo transformndolo en su representacin textual, se redefine la funcin miembro toString de la clase base Object. En el lenguaje Java todas las clases derivan de la clase base Object, que es una clase que tiene una implementacin mnima. public class Complejo{ private double real; private double imag;

public String toString(){ //... } }

Como vemos los miembros dato de la clase Complejo tienen el modificador private, por tanto no son accesibles fuera de dicha clase, pero podemos conocer los valores que guardan a travs de la redefinicin de toString. La funcin toString devuelve un string es decir, un objeto de la clase String, que se llama implcitamente cuando se pone un objeto de la clase Complejo como el argumento de la funcin println. Complejo c=new Complejo(2.0, 3.0); System.out.println(c); Podemos redefinir toString como queramos, por ejemplo, que la parte real e imaginaria aparezcan entre parntesis separados por una coma, o bien, de la forma habitual x+yi. Adems, limitamos el nmero de decimales que aparecen en la pantalla a dos, empleando la funcin esttica Math.round. Hay que tener en cuanta que esta funcin devuelve un entero int que hemos de promocionar (casting) a double para poder efectuar la divisin entre 100. (double)Math.round(100*real)/100 Por defecto, los nmeros positivos no muestran su signo delante. Por tanto, si y fuese positivo el nmero complejo se mostrara como x yi. Para para mostrar adecuadamente el nmero complejo cuando la parte imaginaria es positiva y cuando es negativa, se ha dividido el cdigo de la funcin toString en dos partes public String toString(){ if(imag>0) return new String((double)Math.round(100*real)/100+ " + "+(double)Math.round(100*imag)/100+"*i"); return new String((double)Math.round(100*real)/100+ " - "+(double)Math.round(-100*imag)/100+"*i"); }

El nmero complejo en forma polar Tambin, podemos conocer el nmero complejo en el formato denominado polar. Basta conocer un poco de geometra para transformar un complejo en formato binario (x, y) a formato polar rq, tal como puede verse en la figura. x e y son respectivamente, la abscisa y ordenada del punto, r es la

distancia desde el origen al punto, y q es el ngulo que forma con el eje X. El cdigo de las funciones denominadas modulo y argumento es el siguiente.

public double modulo(){ return Math.sqrt(real*real+imag*imag); } public double argumento(){ double angulo=Math.atan2(imag, real); if(angulo<0) angulo=2*Math.PI+angulo; return angulo*180/Math.PI; } Para hallar el argumento o ngulo q que forma con el eje X, se emplea la funcin esttica Math.atan2, que devuelve el ngulo en radianes entre -p y +p. Dicho ngulo lo hemos de transformar en un ngulo comprendido entre 0 y 2p y despus expresarlo en grados.

Operaciones con nmeros complejos Declararemos las funciones que realizan las operaciones entre nmeros complejos como estticas, ligadas a la clase Complejo en vez de a objetos de dicha clase, siguiendo el esquema trazado para la clase Fraccion.

Suma de dos nmeros complejos

Cuando se suman dos nmeros complejos la parte real es la suma de las partes reales de los complejos sumandos, y la parte imaginaria, es la suma de las partes imaginarias de los sumandos. La definicin de la funcin suma no reviste dificultad alguna, ya que devuelve un complejo cuya parte real es la suma de la parte real de c1 y la parte real c2, y cuya parte imaginaria es la suma de la parte imaginaria de c1 y la parte imaginaria de c2 public static Complejo suma(Complejo c1, Complejo c2){ double x=c1.real+c2.real; double y=c1.imag+c2.imag; return new Complejo(x, y); } Para sumar dos nmeros complejos se efecta la llamada a la funcin esttica suma de la siguiente forma Complejo a1=new Complejo(1.0, 2.0); Complejo a2=new Complejo(-1.0, 3.0); Complejo resultado=Complejo.suma(a1, a2); System.out.println("Suma "+resultado);

Producto de dos nmeros complejos La regla es ahora un poco ms compleja, pero la codificacin de la funcin producto es similar a la de la funcin suma

public static Complejo producto(Complejo c1, Complejo c2){ double x=c1.real*c2.real-c1.imag*c2.imag; double y=c1.real*c2.imag+c1.imag*c2.real; return new Complejo(x, y); }

Como variantes de esta operacin tenemos el producto de un nmero real por un nmero complejo, y la operacin commutativa, el producto de un nmero complejo por un nmero real. Cuando se multiplica un nmero real por un nmero complejo se multiplica su parte real y su parte imaginaria por dicho nmero real. public static Complejo producto(Complejo c, double d){ double x=c.real*d; double y=c.imag*d; return new Complejo(x, y); } public static Complejo producto(double d, Complejo c){ double x=c.real*d; double y=c.imag*d; return new Complejo(x, y); } Las tres funciones producto tienen el mismo nombre. El lenguaje Java permite sobrecargar las funciones miembro siempre que tengan distinto nmero de parmetros, o el mismo nmero de parmetros pero de distinto tipo. Podemos ahorrarnos las variables locales x e y, definiendo las funciones producto del siguiente modo. public static Complejo producto(Complejo c, double d){ return new Complejo(c.real*d, c.imag*d); } public static Complejo producto(double d, Complejo c){ return new Complejo(c.real*d, c.imag*d); } Para multiplicar dos nmeros complejos se efecta la llamada a la funcin esttica producto de la siguiente forma Complejo a1=new Complejo (1.0, 2.0); Complejo a2=new Complejo (-1.0, 3.0);

Complejo resultado=Complejo. Producto(a1, a2); System. Out. Println ("Producto "+resultado); Resultado=Complejo. producto(a1, 3.5); System.out.println("Producto "+resultado); resultado=Complejo.producto(2.0, a2); System.out.println("Producto "+resultado);

Cociente de dos nmeros complejos La frmula para hallar el cociente de dos nmeros complejos es

El nmero complejo c-di se dice que es el conjugado de c+di. El producto de un complejo por su conjugado nos da el cuadrado de su mdulo. Si el mdulo del nmero complejo denominador es cero, entonces se lanza una excepcin que notifica al usuario de esta evantualidad. La forma en la que se lanza (throw) una excepcin aparece en el cdigo. public static Complejo cociente(Complejo c1, Complejo c2) throws ExcepcionDivideCero{ double aux, x, y; if(c2.modulo()==0.0){ throw new ExcepcionDivideCero("Divide entre cero"); }else{ aux=c2.real*c2.real+c2.imag*c2.imag; x=(c1.real*c2.real+c1.imag*c2.imag)/aux; y=(c1.imag*c2.real-c1.real*c2.imag)/aux; } return new Complejo(x, y); }

Cuando el mdulo del complejo denominador es cero, se crea un objeto de la clase Excepcin Divide Cero derivada de la clase base Excepcin. La definicin de esta clase es muy simple, ya que se limita a pasar el mensaje "Divide entre cero" al constructor de la clase base. class ExcepcionDivideCero extends Exception { public ExcepcionDivideCero() { super(); } public ExcepcionDivideCero(String s) { super(s); } } Cuando se efecte el cociente entre dos nmeros complejos se deber colocar la llamada a la operacin cociente en un bloque try...catch. Complejo a1=new Complejo (1.0, 2.0); Complejo a2=new Complejo (-1.0, 3.0); Complejo resultado; try{ Resultado= Complejo. cociente(a1, a2); }catch(ExcepcionDivideCero ex){ System.out.println("Al calcular el cociente se ha producido una excepcin\n " +ex.getClass()+ " con el mensaje "+ ex.getMessage()); } System.out.println("Cociente "+resultado); El lector podra pensar que no es necesario definir la excepcin propia ExcepcionDivideCero cuando el lenguaje Java dispone de ArithmeticException para este propsito. Sin embargo, esta excepcin se lanza solamente cuando se dividen nmeros enteros.

Potencia de un nmero complejo Para hallar la potencia de un nmero complejo, aplicamos el binomio de Newton. Teniendo en cuenta las potencias de la unidad imaginaria el resultado es

otro nmero complejo cuya parte real es

(1) y cuya parte imaginaria es

(2) Precisamos, para llevar a cabo este clculo de dos funciones auxiliares denominadas combinatorio y potencia, una que calcule en nmero combinatorio m sobre n, y otra que calcule el resultado de elevar un nmero real a una potencia entera. Empezaremos por la ms sencilla, la que calcula la potencia de un nmero real que ser similar a la potencia de un nmero entero que ya estudiamos. Para este propsito, se puede emplear la funcin Math.pow, que tiene dos parmetros del tipo double. private static double potencia(double base, int exponente){ double resultado=1.0; for(int i=0; i<exponente; i++){ resultado*=base; } return resultado; } Ya se calcul el factorial de un nmero, y el nmero combinatorio m sobre n, en trminos de la funcin factorial.

Alternativamente, podemos definir una funcin combinatorio que devuelva el cociente entre el numerador y el denominador private static double combinatorio(int m, int n){ long num=1; long den=1; for(int i=m; i>m-n; i--){ num*=i; } for(int i=2; i<=n; i++){ den*=i; } return (double)num/den; } El primer bucle for calcula el numerador, y el segundo bucle for halla el denominador. Ya que se calculan productos de nmeros enteros, el resultado se guarda por precaucin en un nmero de tipo long, para evitar que se sobrepase el valor del mayor entero que se puede guardar en el tipo predefinido int, lo que no ocurrir casi nunca a efectos prcticos. Para obtener el cociente se ha de promocionar (casting) el numerador de long a double. return (double)num/den; Finalmente, definimos la potencia de un nmero complejo en trminos de las dos funciones auxiliares anteriores. Se traduce la expresin (1) a cdigo para hallar la parte real del nmero complejo resultante, y la expresin (2) para hallar su parte imaginaria. Nos daremos cuenta que el nmero total de trminos del desarrollo del binomio es par, si el exponente es impar, y es impar si el exponente es par. En el primer caso, el nmero de trminos que contribuyen a la parte real es igual a los que contribuyen a la parte imaginaria. En el segundo caso, tendremos un trmino menos que contribuye a la parte imaginaria, por este motivo se ha de salir del bucle (sentencia break) despus de calcular la ltima contribucin a la parte real. Podemos observar, que los signos de los distintos trminos son alternados, si el ndice del trmino es par el signo es positivo, y si es impar el

signo es negativo, esto lo podemos calcular mediante la versin simplificada de if... else. signo=(i%2==0) ? +1 : -1; El cdigo completo de la funcin potencia es, el siguiente public static Complejo potencia(Complejo c, int exponente){ double x=0.0, y=0.0; int signo; for(int i=0; i<=exponente; i++){ signo=(i%2==0) ? 1 : -1; //parte real x+=combinatorio(exponente, 2*i)*potencia(c.real, exponente2*i)*potencia(c.imag, 2*i)*signo; if(exponente==2*i) break; //parte imaginaria y+=combinatorio(exponente, 2*i+1)*potencia(c.real, exponente(2*i+1))*potencia(c.imag, 2*i+1)*signo; } return new Complejo(x, y); } Para efectuar la llamada a la funcin potencia, por ejemplo, para hallar el cubo de un nmero complejo Complejo a1=new Complejo(1.0, 2.0); Complejo resultado=Complejo.potencia(a1, 3); System.out.println("Potencia "+resultado); La funcin potencia se utiliza para calcular el valor numrico de una funcin polinommica cuando su variable x es un nmero complejo.