Como obtener la raíz cuadrada de un número con Java

10/Feb/2013 Java , , , , Deja un comentario

Primeramente como se procede a hacer la raíz cuadrada de un numero con Java tenemos que tener en consideración como es el proceso, y este proceso es bastante sencillo aritméticamente hablando.

Para proceder a hacer la raíz cuadrada de un numero con Java debemos proceder a tomar el numero en pares de dígitos numéricos, luego procesar esos pares para obtener uno por uno un dígito de resultado para la raíz del numero.

No debemos olvidar que debemos considerar el resto de las operaciones para obtener la raíz cuadrada de un numero.

Entonces procedemos a ver en código como funcionaria esta idea, primero creamos los métodos que nos serán útiles para esto:

  • Necesitaremos un método de parseo de tuplas para obtener los pares de dígitos a usarse en el proceso de extracción de la raíz cuadrada.
  • Se usara también un método de obtención de mínimo numero positivo, puesto que esto nos ayudara a encontrar el resto mínimo para obtención del numero correcto para la mantisa de la raíz cuadrada.
  • Otro método utilitario para este caso seria, un método de procesado de radicación por tuplas.
  • Y finalmente el método de raíz cuadrada que hará uso de todos y cada uno de los métodos utilitarios señalados anteriormente.

Método de parseo de tuplas

Para este método tendremos que recibir como parámetro el numero como string y lo convertimos en char [] de ahi solo tendremos que recorrer el array de chars y de dos en dos ponerlos en la lista de tuplas.

El metodo quedaria asi:

  1. public static List parseNumber(String n){
  2. List<Integer> result=new ArrayList<Integer>();
  3. String number=n.trim();
  4. char [] numberChars=number.toCharArray();
  5. int length=numberChars.length;
  6. int i=0;
  7. if(length%2!=0){
  8. // si hay un numero impar de dígitos se toma el primer dígito
  9. result.add(new Integer(new Character(numberChars[0]).toString()));
  10. i=1;
  11. }
  12. for(;i<length;i+=2){
  13. //se toma los digitos por pares
  14. try{
  15. result.add(new Integer(new Character(numberChars[i]).toString()+
  16. new Character(numberChars[i+1]).toString()));
  17. }catch(Exception ex){}
  18. }
  19. return result;
  20. }

Obtener mínimo número positivo

Ahora el método de obtención de mínimo numero positivo seria como sigue; se evalúa cada elemento contra el mínimo y luego solo el numero menor y positivo es devuelto como resultado en el HashMap.

  1. public static HashMap minimoPositivo(List<HashMap> lista){
  2. Integer minimo=Integer.MAX_VALUE;
  3. int indice=0;
  4. HashMap result=new HashMap();
  5. for(HashMap elem:lista){// se recorre toda la lista
  6. Integer elemento=Integer.parseInt(elem.get("resto").toString());
  7. if(minimo>elemento && elemento>=0){// se obtiene el minimo positivo
  8. minimo=elemento;
  9. indice=Integer.parseInt(elem.get("indice").toString());
  10. }
  11. }
  12. result.put("indice",indice);
  13. result.put("resto",minimo);
  14. return result;
  15. }

Procesado de las raíces en función de cada tupla

El otro método es hacer el procesado de las raíces en función de cada tupla, para esto procesamos todos los restos posibles de evaluar todas las posibles raíces y los almacenamos en una lista.

A ese resultado le aplicamos la función minimoPositivo para obtener el indice correcto para la raíz, y también con el resto calculado devolvemos esto como respuesta en el HashMap.

  1. public static HashMap procesarRadicacion(Integer tupla,Integer raiz, Integer resto){
  2. HashMap result=new HashMap();
  3. List<HashMap> lista=new ArrayList<HashMap>();
  4. result.put("raiz",0);
  5. result.put("resto",0);
  6. Integer radical=raiz*2;
  7. Integer nuevoresto;
  8. Integer numero=0;
  9. try{
  10. numero=new Integer(resto.toString()+tupla.toString());
  11. }catch(Exception ex){
  12. System.err.println("El numero es demasiado grande no se puede procesar ...");
  13. }
  14. Integer nuevaraiz;
  15. Integer operando;
  16. for(Integer i=0;i<=9;i++){// se calcula los restos posibles
  17. operando=raiz*2;
  18. operando=Integer.parseInt(operando.toString()+i.toString());
  19. nuevoresto=numero-(operando*i);
  20. HashMap hash=new HashMap();
  21. hash.put("resto",nuevoresto);
  22. hash.put("indice",i);
  23. lista.add(hash);
  24. }
  25. HashMap Minimo=minimoPositivo(lista);//se obtiene el minimo
  26. nuevaraiz=new Integer(raiz.toString()+Minimo.get("indice").toString());
  27. result.put("raiz",nuevaraiz.toString());
  28. result.put("resto",Minimo.get("resto").toString());
  29. return result;
  30. }

Método para la Raíz Cuadrada

Finalmente el metodo de raizCuadrada, este metodo tiene que aplicar el parseo de tuplas luego de eso recorriendo cada tupla aplica el metodo procesarRadicacion de cada tupla, para de esta forma obtener la raiz del numero procesado y su resto.

  1. public static HashMap raizCuadrada(String number){
  2. HashMap result=new HashMap();
  3. List<Integer> tuplas=parseNumber(number);// se procesa el numero
  4. Integer raiz=0;
  5. Integer resto=0;
  6. for(Integer tupla:tuplas){//se procesan las tuplas de digitos
  7. HashMap process=procesarRadicacion(tupla, raiz, resto);
  8. try{raiz=Integer.parseInt(process.get("raiz").toString());}catch(Exception ex){}
  9. try{resto=Integer.parseInt(process.get("resto").toString());}catch(Exception ex){}
  10. }
  11. result.put("raiz", raiz.toString());
  12. result.put("resto", resto.toString());
  13. return result;
  14. }

Y ahora la forma de comprobar el funcionamiento de todo esto es mediante el siguiente codigo:

  1. String num="";
  2. System.out.println("Ingrese un numero : ");
  3. try{num = buffer.readLine();}catch(Exception ex){}
  4.  
  5. HashMap raiz=raizCuadrada(num);
  6. System.out.println("numero: "+num);
  7. System.out.println("raiz: "+raiz.get("raiz").toString());
  8. System.out.println("resto: "+raiz.get("resto").toString());

No olviden que el uso de este metodo de raiz cuadrada esta limitado por las capacidades del lenguaje de programacion y por tanto fallara esta implementacion si usamos un numero no soportado por la arquitectura de procesamiento de la maquina en uso para la ejecucion de este programa.

Vídeos sobre Java


Difunde el Conocimiento

Si te ha gustado el artículo o te ha sido de utilidad, no dejes de compartirlo con tus amigos en las redes sociales... Te estaremos muy agradecidos. :-D

¿Algo que nos quieras comentar?

Déjanos tu comentario, no te preocupes que tu email no será publicado

*

*