En este caso, voy a detallar una clase sencilla que implementa una calculadora de números complejos en Java.
Para los que no lo recuerden, un número complejo consta de dos partes, una parte real y una parte imaginaria; la parte imaginaria se compone del número √-1 o lo que es lo mismo i. Un número complejo lo podemos representar vectorialmente como z = (a,b), binomial z = a + bi, polar mediante un módulo y un ángulo z = r α, trigonométrica z = r (cos α + i sin α) y por último la forma exponencial y que no voy a incluir en la clase aunque a mi parecer es la más elegante e iα = cos α + i sin α.
Cada forma tiene su fin, por ejemplo la suma y las resta son más fáciles con la forma binomial mientras que la multiplicación, división y exponenciación lo son con la forma polar; en el caso de la clase todos los cálculos los he realizado con la forma binomial.
Si pasamos a la clase, como ya he comentado está implementada en Java y consta de cuatro propiedades, parte real mediante x, parte imaginaria mediante y, el módulo que es calculado en base de x e y, y por último el argumento o ángulo.
A continuación paso el diagrama de la clase donde se exponen los métodos con la mayoría de las operaciones:
Pasando un ejemplo
A continuación paso el código:
Consejos.
o Visual Basic
Para los que no lo recuerden, un número complejo consta de dos partes, una parte real y una parte imaginaria; la parte imaginaria se compone del número √-1 o lo que es lo mismo i. Un número complejo lo podemos representar vectorialmente como z = (a,b), binomial z = a + bi, polar mediante un módulo y un ángulo z = r α, trigonométrica z = r (cos α + i sin α) y por último la forma exponencial y que no voy a incluir en la clase aunque a mi parecer es la más elegante e iα = cos α + i sin α.
Cada forma tiene su fin, por ejemplo la suma y las resta son más fáciles con la forma binomial mientras que la multiplicación, división y exponenciación lo son con la forma polar; en el caso de la clase todos los cálculos los he realizado con la forma binomial.
Si pasamos a la clase, como ya he comentado está implementada en Java y consta de cuatro propiedades, parte real mediante x, parte imaginaria mediante y, el módulo que es calculado en base de x e y, y por último el argumento o ángulo.
A continuación paso el diagrama de la clase donde se exponen los métodos con la mayoría de las operaciones:
// Pasamos dos números complejos
// Efectuamos los cálculos
Complex c1=new Complex(4,5);
Complex c2=new Complex(7,6);
System.out.println("(" + c1.toString() + ") + (" + c2.toString() + ") = " + c1.addComplex(c2));
System.out.println("(" +c1.toString() + ") - (" + c2.toString() + ") = " + c1.substractComplex(c2));
System.out.println("(" +c1.toString() + ") x (" + c2.toString() + ") = " + c1.multiplyComplex(c2));
System.out.println("(" +c1.toString() + ") / (" + c2.toString() + ") = " + c1.divideComplex(c2));
System.out.println("Opuesto de " + c1.toString() + " = " + c1.opposite().toString());
System.out.println("Inverso de " + c1.toString() + " = " + c1.reverse().toString());
System.out.println(c1.toString() + " = " + c1.polarToString());
System.out.println(c1.toString() + " = " + c1.polarToString(true));
System.out.println(c2.toString() + " = " + c2.polarToString());
System.out.println(c2.toString() + " = " + c2.polarToString(true));
c2.convertToBinomial(5, 36.86*Math.PI/180);
System.out.println("Convertir 5) 36.86º a binomial = " + c2.toString());
Resultado(4 + 5i) + (7 + 6i) = 11 + 11i (4 + 5i) - (7 + 6i) = -3 -1i (4 + 5i) x (7 + 6i) = -2 + 59i (4 + 5i) / (7 + 6i) = 0,68 + 0,13i Opuesto de 4 + 5i = -4 -5i Inverso de 4 + 5i = 0,1 -0,12i 4 + 5i = 5,7)0,896 radians 4 + 5i = 5,7)51,3º 7 + 6i = 9,9)0,709 radians 7 + 6i = 9,9)40,6º Convertir 5) 36.86º a binomial = 4 -3i
A continuación paso el código:
/******************************************************
* @author: Joaquín Martínez Rus (c) 2016
* @version: 1.0
* File: Complex.java
* Created: 17/07/2016
* Project: Calculadora de números complejos
* Comments: Clase Complex.
*******************************************************/
public class Complex {
/**
* Inicia una nueva instancia de la clase Complex con valor z = 0 + 0i;
*/
public Complex(){
this(0,0);
}
/**
* Inicia una nueva instancia de la clase Complex
* @param _x Parte real
* @param _y Parte imaginaria
*/
public Complex(double _x, double _y){
this.x=_x;
this.y=_y;
this.setModule();
this.setGrades();
}
double x;
double y;
double module;
double grades;
public double getX() {
return x;
}
public void setX(double x) {
this.x = x;
}
public double getY() {
return y;
}
public void setY(double y) {
this.y = y;
}
public double getModule() {
return module;
}
/**
* Asigna y calcula el valor del módulo
*/
public void setModule(){
this.module=Math.sqrt(Math.pow(x, 2)+ Math.pow(x, 2));
}
/**
* Asigna el valor del módulo
*/
public void setModule(double module) {
this.module = module;
}
public double getGrades() {
return grades;
}
public void setGrades() {
this.grades = Math.atan2(y, x);
}
public void setGrades(double grades) {
this.grades = grades;
}
/**
* Suma al número complejo otro número complejo
* @param _complex Número complejo de la suma
* @return Objeto Complex
*/
public Complex addComplex(Complex _complex){
return new Complex(this.x + _complex.x, this.y + _complex.y);
}
/**
* Resta al número complejo otro número complejo
* @param _complex Número complejo de la resta
* @return Objeto Complex
*/
public Complex substractComplex(Complex _complex){
return new Complex(this.x - _complex.x, this.y - _complex.y);
}
/**
* Multiplica al número complejo otro número complejo
* @param _complex Número complejo de la multiplicación
* @return Objeto Complex
*/
public Complex multiplyComplex(Complex _complex){
return new Complex((this.x * _complex.x - this.y * _complex.y),
(this.x * _complex.y + this.y * _complex.x));
}
/**
* Divide el número complejo actual entre el valor del parámetro
* @param _complex Denominador
* @return Objeto Complex
*/
public Complex divideComplex(Complex _complex){
return divideComplex(this,_complex);
}
/**
* Divide dos números complejos
* @param _complex1 Numerador
* @param _complex2 Denominado
* @return Objeto Complex
*/
public Complex divideComplex(Complex _complex1, Complex _complex2){
double xx = (_complex1.x * _complex2.x + _complex1.y * _complex2.y)/(Math.pow(_complex2.x,2)+Math.pow(_complex2.y,2));
double yy = (_complex1.y * _complex2.x - _complex1.x * _complex2.y)/(Math.pow(_complex2.x,2)+Math.pow(_complex2.y,2));
return new Complex(xx, yy);
}
/**
* Obtiene un número complejo en forma vectorial
* @return Cadena de texto
*/
public String vectorialtoString(){
return "(" + ConsoleUtilities.toNumber(this.x,2) + ", " + ConsoleUtilities.toNumber(this.y,2) + ")";
}
/**
* Obtiene un número complejo en forma binomial
* @return Cadena de texto
*/
@Override
public String toString(){
return ConsoleUtilities.toNumber(this.x,2) + (this.y < 0? " - ": " + ") + ConsoleUtilities.toNumber(this.y,2) + "i";
}
/**
* Obtiene un número complejo en forma polar
* @return Cadena de texto
*/
public String polarToString(){
return polarToString(false);
}
/**
* Obtiene un número complejo en forma polar
* @param isDegrees Mostrar como grados centigrados o radianes
* @return Cadena de texto
*/
public String polarToString(boolean isDegrees){
double angle=isDegrees?this.getGrades()*180/Math.PI:this.getGrades();
String angleToString = (isDegrees?ConsoleUtilities.toNumber(angle,1):ConsoleUtilities.toNumber(angle,3)) + (isDegrees? "º": " radians");
return ConsoleUtilities.toNumber(this.module,1) + ")" + angleToString;
}
/**
* Obtiene el conjugado de un número complejo
* @param complex Número complejo
* @return Objeto Complex
*/
public Complex conjugate(Complex complex){
return new Complex(complex.x, - complex.y);
}
/**
* Calcula el opuesto de un número complejo
* @return Objeto Complex
*/
public Complex opposite(){
return opposite(this);
}
/**
* Calcula el opuesto de un número complejo
* @param _complex Número complejo
* @return Objeto Complex
*/
public Complex opposite(Complex _complex){
return new Complex(-_complex.x, - _complex.y);
}
/**
* Obtiene el conjugado de un número complejo
* @return Objeto Complex
*/
public Complex conjugate(){
return conjugate(this);
}
/**
* Obtiene el inverso de un número complejo
* @return Objeto Complex
*/
public Complex reverse(){
return reverse(this);
}
/**
* Obtiene el inverso de un número complejo
* @param complex Número complejo del cálculo
* @return Objeto Complex
*/
public Complex reverse(Complex complex){
double denominador=Math.pow(complex.x, 2) + Math.pow(complex.y, 2);
return new Complex( complex.x/denominador, - complex.y/denominador);
}
/**
* Convierte un número complejo de forma polar a binomial
* @param module Modulo del número complejo
* @param argument Argumento en radianes del número complejo
* @return Objeto Complex
*/
public Complex convertPolarToBinomial(double module, double argument){
double _x = Math.abs(module) * Math.cos(argument);
double _y = Math.abs(module) * Math.sin(argument);
return new Complex(_x,-_y);
}
/**
* Asigna los valores real e imaginario en base al módulo y el argumento
* @param module Modulo del número complejo
* @param argument Argumento en radianes del número complejo
*/
public void convertToBinomial(double module, double argument){
Complex _complex=convertPolarToBinomial(module, argument);
this.x=_complex.x;
this.y=_complex.y;
}
/**
* Comprueba dos números complejos
* @param _complex Número complejo a comparar
* @return Objeto Complex
*/
public boolean equals(Complex _complex){
if (_complex==null) {
return false;
}
if (this.getClass()!=_complex.getClass()) {
return false;
}
return this.x ==_complex.x && this.y == _complex.y;
}
}
Consejos.
- La clase debe estar bien definida. Constructores, propiedades y métodos
- Antes de escribir código, genera un diagrama de clases como mínimo (esto implica pensar que vas a hacer), además una buena estructura puede hacer nuestro código más robusto.
- Piensa en las cuatro características de la Programación Orientada a Objetos, Abstracción, Encapsulamiento, Herencia y Polimorfismo (hay alguna más, pero estas son las principales y debes tenerlas muy claras)
- Los métodos deben contener el código justo. Un método con mucho código no hace la clase legible y lo vuelve débil.
- Las clases deben funcionar en cualquier medio. Si usara esta clase en modo gráfico con ventanas en vez de modo consola, debería de funcionar del igual modo, solo debo llamar al método de operación y obtener su resultado mediante los métodos apropiados.
- Usa los comentarios, tanto dentro de los métodos como en su documentación. Por ejemplo, si llamo al método divideComplex de la clase Complex, cuando estoy escribiendo el método, aparecerá el método y el texto que nosotros escribimos, en este caso yo escribí "Divide el número complejo actual entre el valor del parámetro" junto con los parámetros y el valor retornado. Cuando las clases se hacen muy grandes y complejas, es necesario documentarlas todo lo que se pueda.
- Además de los comentarios, a mi me gusta agrupar el código por regiones con Java uso
// <editor-fold defaultstate="collapsed" desc="REQUEST FROM KEYBOARD">
/**
* Devuelve un valor desde el teclado
* @param textIn Texto que se visualiza en la consola
* @return Texto procedente del teclado
* @throws IOException
*/
public static String readText(String textIn, boolean allowEmpty) throws IOException{
// Declaración de variables
BufferedReader keyboardIn=new BufferedReader(new InputStreamReader(System.in));
String textOut=null;
// Imprimir texto de consola
System.out.println(textIn);
// Solicitar datos desde teclado
do {
textOut=keyboardIn.readLine();
} while (ConsoleUtilities.isNullOrEmpty(textOut) && !allowEmpty);
// Retornar texto
return textOut;
}
// </editor-fold>
Esto me va permitir expandir o contraer todo el código contenido entre las etiquetas o para el caso de C# #region Private Methods
// Aquí iría el código
#endregion
o Visual Basic
#Región MiRegion #End Region
- Cíñete a la nomenclatura estándar con cada lenguaje de programación, por ejemplo Java o C# o Visual Basic.
- Créate un clase con herramientas, por ejemplo, para aplicaciones del tipo consola en Java, tengo una clase con métodos estáticos donde implemento herramientas que puedo usar en este medio como un método que genera un menú automáticamente, un lector desde teclado de texto o números, un formateador de texto, un serializador, etc. Para C# tengo otro tipo de clases donde extiendo funcionalidades a las clases creadas, en fin, código que reutilizaré más a menudo de lo que me pienso.
- Si hacemos todo esto, en un futuro nos será más fácil, modificar, entender que hicimos o ampliar nuestras clases.
Y esto es todo por hoy. Saludos!
No hay comentarios:
Publicar un comentario