pdfcrowd.com open in browser PRO version Are you a developer?

Try out the HTML to PDF API

Los nmeros complejos
Definicin de nmero complejo
Los constructores
Mostrar un nmero complejo
El nmero complejo en forma polar
Operaciones con nmeros complejos
El cdigo fuente
El estudio de la clase Fraccion nos proporciona una pista para abordar el estudio de otras clases que representan a
entidades matemticas como la clase Complejo.
En esta pgina crearemos una clase denominada Complejo, y definiremos las operaciones entre nmeros complejos: suma,
producto y cociente de dos nmeros, el producto y cociente de un nmero complejo por un nmero real, la potencia de un
nmero complejo, que se utilizar para calcular el valor numrico de una funcin polinommica cuando su variable x es un
nmero complejo.
Otras cuestiones que trataremos, sern la representacin polar de un nmero complejo, el conjugado de un nmero complejo,
y la forma en la que podemos mostrar un nmero complejo redefiniendo la funcin miembro toString de la clase base Object.

Definicin de nmero complejo
pdfcrowd.com open in browser PRO version Are you a developer? Try out the HTML to PDF API
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 de x+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.
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;
pdfcrowd.com open in browser PRO version Are you a developer? Try out the HTML to PDF API
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);
pdfcrowd.com open in browser PRO version Are you a developer? Try out the HTML to PDF API
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.
pdfcrowd.com open in browser PRO version Are you a developer? Try out the HTML to PDF API

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.
pdfcrowd.com open in browser PRO version Are you a developer? Try out the HTML to PDF API

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
pdfcrowd.com open in browser PRO version Are you a developer? Try out the HTML to PDF API
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);
pdfcrowd.com open in browser PRO version Are you a developer? Try out the HTML to PDF API
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 ExcepcionDivideCero derivada de la
clase base Exception. 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.
pdfcrowd.com open in browser PRO version Are you a developer? Try out the HTML to PDF API
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
pdfcrowd.com open in browser PRO version Are you a developer? Try out the HTML to PDF API
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.
pdfcrowd.com open in browser PRO version Are you a developer? Try out the HTML to PDF API
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
pdfcrowd.com open in browser PRO version Are you a developer? Try out the HTML to PDF API
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, exponente-2*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.

El cdigo fuente
Complejo.java, ComplejoApp.java