No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Curso de Introducción a Java SE

Curso de Introducción a Java SE

Anahí Salgado Díaz de la Vega

Anahí Salgado Díaz de la Vega

Operaciones matemáticas

17/39
Recursos

Math es una clase de Java que nos ayuda a ejecutar diferentes operaciones matemáticas:

Math.PI // 3.141592653589793
Math.E // 2.718281828459045

Math.ceil(2.1) // 3.0 (redondear hacia arriba)
Math.floar(2.1) // 2.0 (redondear hacia abajo)

Math.pow(2, 3) // 8.0 (número elevado a una potencia)
Math.sqrt(3) // 1.73... (raíz cuadrada)

Math.max(2, 3) // 3.0 (el número más grande)

// Área de un círculo (PI * r^2):
Math.PI * Math.pow(r, 2)

// Área de una esfera (4 * PI * r^2):
4 * Math.PI * Math.pow(r, 2)

// Volumen de una esfera ( (4/3) * PI * r^3):
(4/3) * Math.PI * Math.pow(r, 3)

Aportes 387

Preguntas 15

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

¡Hola!
Aquí les dejo mi código comentado con algunas funciones extras de Math 😃

public class MathematicOperations {
    public static void main(String[] args) {
        //Valores enteros
        int a = 5;
        int b = 10;

        //Valores con decimales
        double i = 2.1;
        double j = 3.5;

        //Redondea hacia arriba
        System.out.println(Math.ceil(i));

        //Redondea hacia abajo
        System.out.println(Math.floor(j));

        //Devuelve el valor mayor
        System.out.println(Math.max(a,b));

        //Imprime un numero elevado a otro
        System.out.println(Math.pow(a,b));

        //Devuelve el valor absoluto de un argumento dado
        System.out.println(Math.abs(j));

        //Devuelve la suma de sus argumentos
        System.out.println(Math.addExact(a,b));

        //Devuelve la tangente del arco de un angulo (-pi/2 y pi/2)
        System.out.println(Math.atan(j));

        //Devuelve la raiz cubica de un valor double
        System.out.println(Math.cbrt(i));

        //Devuvleve el coseno hiperbolico de un valor double
        System.out.println(Math.cosh(j));

        //Devuelve el coseno trigonometrico de un angulo
        System.out.println(Math.cos(j));

        //Devuelve el numero elevado a la potencia de un valor double
        System.out.println(Math.exp(i));
    }
}

¡Saludos!

Recordando el colegio y sus fórmulas de matemáticas 😱😁:

**Using class Math:
**

Run:

El resultado del volumen de la esfera es incorrect0

Una solución podria ser
// Volumen de una esfera
// (4* PI *r3) / 3
System.out.println("Volumen de una esfera "+ (4 * Math.PI * Math.pow(y,3))/ 3 );

Me encanta verte China, saludos

La profe se apasiona en cada clase, sin duda una gran profesora. 💚

Hola! en cuanto al calculo del Volumen de la esfera esos 4/3 esta devolviendo un entero por lo que el resultado no es correcto. se podría colocar delante (float)4/3 para resolver el problema, quizá exista otra solución, mientras con eso resolví jaja. excelente curso.

double y = 3;
System.out.printLn(4*Math.PI*Math.pow(y,2));

No es necesario los parentesis en la operacion de volumen de una esfera. Esto porque por regla matematica, las operaciones se realizan de izq a derecha, siguiendo el orden de (Potencia primero, * y / segundo, y + y - tercero) y siempre de izq a derecha primero.

//Volumen de una esfera (4/3 * pi * r3)
System.out.println(4/3 * Math.PI * Math.pow(y,3));

 var cir=3;
        var es=3;
        // circulo
         System.out.println(Math.PI*Math.pow(cir,2));
         //esfera
         System.out.println(Math.PI*Math.pow(es,2)*4);

por si quieren ver una descripcion de una operación matemática pueden presionar ctrl + i , con eso ya pueden hacer sus formulas matematicas.

Una de muchas posibles soluciones

public class MathematicOperation {
    public static void main(String[] args) {
        double x = 2.1;
        double y = 3;
        //devuelve un entero hacia arriba
        System.out.println(Math.ceil(x));
        //devuelve un entero hacia abajo
        System.out.println(Math.floor(x));
        //devuelve un numero elevado a otro numero
        System.out.println(Math.pow(x,y));
        //cual es el valor mas alto o mayor
        System.out.println(Math.max(x,y));
        //devuelve la raiz cuadrada de un numero
        System.out.println(Math.sqrt(y));
        //area un circulo pi*r^2
        System.out.println(Math.PI * Math.pow(y,2));
        //area de una esfera 4*PI*r^2
        System.out.println(4 * Math.PI * Math.pow(y,2));
    }
}

de acuerdo a la pregunta de Anahi seria:

System.out.println(4Math.PIMath.pow(y,2));

System.out.println( 4 * Math.PI * Math.pow(x, 2) );
System.out.println(4 * Math.PI * Math.pow(x,2));

Realicé un pequeño programa en el que el usuario ingresa la accion a realizar y dependiendo de su selección se mostrará algo, aquí el código:


{
    public static void main(String[] args) {
        String selector = "";
        double numUno, numDos;

        Scanner in = new Scanner(System.in);

        System.out.println("1 - Realizar potencias");
        System.out.println("2 - Obtener raiz cuadrada");
        System.out.println("3 - Encontrar el numero mayor");

        System.out.println("\nIngresa la operacion que deseas realizar: ");
        selector = in.nextLine();

        if (selector.equals("1")) {
            System.out.println("Ingresa el número a elevar: "); numUno = in.nextDouble();
            System.out.println("Ingresa la potencia: "); numDos = in.nextDouble();
            System.out.println(Math.pow(numUno,numDos));
        }
        if (selector.equals("2")) {
            System.out.println("Ingresa el numero: "); numUno = in.nextDouble();
            System.out.println(Math.sqrt(numUno));
        }
        if (selector.equals("3")) {
            System.out.println("Ingresa el primero número: "); numUno = in.nextDouble();
            System.out.println("Ingresa el segundo número: "); numDos = in.nextDouble();
            System.out.println(Math.max(numUno,numDos));
        }

    }
}

Area de una esfera:

//Area de una esfera
//4 * Pi * r2
double x = 2.1;
double y = 3;
System.out.println(4 * Math.PI * Math.pow(y, 2));

System.out.println(4 * Math.PI * Math.pow(y,2));

area de una esfera
4pi*r2
System.out.println(4 * Math.PI * Math.pow(y,2));

        System.out.println(4 * Math.PI * Math.pow(y,2));
 

Juro que no vi la solucion de nadie, al caso solo era reemplazar los valores.

   //Area de una esfera (4 * PI * r2)
        System.out.println(4 * Math.PI * Math.pow(y,2));
        //113.09733552923255

Creo que la respuesta puede ser:

System.out.println(4 * Math.PI * Math.pow(y,4));
    // Area de una esfera
    // 4*Pi*r2
    System.out.println(Math.PI*4*Math.pow(y,2));
import java.util.Scanner;


public class JavaOperadores1 {
    public static void main(String[] args) {
        //Permite ingresar datos por teclado
        Scanner s = new Scanner(System.in);
        System.out.println("Ingrese 5 numeros");
        
        var num1 = s.nextInt();
        var num2 = s.nextInt();
        var num3 = s.nextInt();
        var num4 = s.nextInt();
        var num5 = s.nextInt();

        //Esto lo logre luego de buscar un buen rato.
        //Math.max y Math.min devuelve un valor entre dos numeros, por lo tanto se hace una comparacion en secuencia
        var max = Math.max(Math.max(Math.max(Math.max(num1, num2), num3), num4), num5);
        var min = Math.min(Math.min(Math.min(Math.min(num1, num2), num3), num4), num5);

        //Devuelve el numero mayor
        System.out.println("El numero maximo es: " + max);
        //Devuelve el numero menor
        System.out.println("El numero minimo es: " + min);

        //La raiz del num3

        System.out.println("La raiz cuadrada de " + num3 + " es " + Math.sqrt(num3));

        //La potencia del num1 con el numero 5
        System.out.println("La potencia del " + num1 + " con el " + num5 + " es " + Math.pow(num1, num5));

    }
}

Hola, aquí les dejo mi aporte, de como resolver el área de una esfera!

    public static void main(String[] args) {

        int a = 5;

        System.out.println((Math.PI * 4) * Math.pow(a, 2));

    }

Tener cuidado al operar números decimales, por ejemplo al calcular el volumen debe ser:
System.out.println(4 / 3.0 * Math.PI * Math.pow(y,3));
para obtener como resultado: 113.09733552923254
considerando que y=3

📑 Java nos proporciona Math para trabajar con operaciones matemáticas.

System.out.println(4*Math.PI * Math.pow(x,2));

System.out.println((4 * Math.PI) * Math.pow(y,2));

Lo hice la siguiente manera:
System.out.println((4 * Math.PI) * Math.pow(y,2));
Resultado: 113.09733552923255

Excelente explicación, muy util el Math.ceil() y el Math.floor()

System.*out*.println(Math.*PI* \* 4 \* Math.*pow*(y,3));
Hola! esta fue la conclusión a la que llegue en el ejercicio del área de la esfera: //area de esfera int pi = (int) (Math.*PI*\*4); System.*out*.println(pi \* Math.*pow*(y,2));
//area de una esfera 4/3 \*pi\*r3 System.*out*.println( (4/3)\* Math.*PI* \* Math.*pow*(y,3));
//4\*pi\*r2 System.*out*.println(4 \* Math.*PI* \* Math.*pow*(y,2));
//Area de una esfera //4\*PI\*r2 System.*out*.println(4 \* Math.*PI* \* Math.*pow*(y,2));
//Area de una esfera //4\*PI\*r2 System.out.println("Area de una esfera: " + 4 \* Math.PI \* Math.pow(y,2));
public class Operaciones{ public static void main(String args){ int r=3; System.out.println(Math.PI*4*Math.pow(r,2)); } }
![]()//área de una esfera //4\*PI\*r2 System.out.println(4 \* Math.PI \* Math.pow(y,2)); //113.09733552923255
La respuesta que veo posible para resolver el problema del area de una esfera es: `System.out.println((4*Math.PI) * Math.pow(y,2));` suponiendo que el radio es y elevado a la segunda potencia!
Recordar que en el volumen de la esfera estamos utilizando variables de tipo double para realizar las operaciones, por lo tanto, los cuatro tercios deberían de ser de la siguiente manera: (4.0 / 3.0) ![]()![](https://static.platzi.com/media/user_upload/image-0a7db41c-68a3-44f3-9303-4b95d421b611.jpg)
```js public class MathematicOperations { public static void main(String[] args) { double x = 2.1; double y = 3; //devuelve un entero haci arriba System.out.println(Math.ceil(x)); //devueve un entero haci abajo System.out.println(Math.floor(x)); //Devuelve un numero elevado a otro System.out.println(Math.pow(x,y)); //Deveuelve el numero mayor System.out.println(Math.max(x,y)); //Devuelve la raiz cuadrada System.out.println(Math.sqrt(y)); // Devuelve el area de un circulo // Pi * r2 System.out.println(Math.PI * Math.pow(y,2)); //Devuelve el are ade una esfera //4*PI*r2 System.out.println(4 * Math.PI * Math.pow(y,2)); //volumen d euna esfera //(4/3) * PI * r3 System.out.println((4/3)* Math.PI * Math.pow(y,3)); } } ```public class MathematicOperations { public static void main(String\[] args) { double x = 2.1; double y = 3; //devuelve un entero haci arriba System.*out*.println(Math.*ceil*(x)); //devueve un entero haci abajo System.*out*.println(Math.*floor*(x)); //Devuelve un numero elevado a otro System.*out*.println(Math.*pow*(x,y)); //Deveuelve el numero mayor System.*out*.println(Math.*max*(x,y)); //Devuelve la raiz cuadrada System.*out*.println(Math.*sqrt*(y)); // Devuelve el area de un circulo // Pi \* r2 System.*out*.println(Math.*PI* \* Math.*pow*(y,2)); //Devuelve el are ade una esfera //4\*PI\*r2 System.*out*.println(4 \* Math.*PI* \* Math.*pow*(y,2)); //volumen d euna esfera //(4/3) \* PI \* r3 System.*out*.println((4/3)\* Math.*PI* \* Math.*pow*(y,3)); } }
Hola, no me funciona Math. , he intentado importarla pero no lo he podido hacer con : import java.lang.Math; ¿alguien me podría ayudar? Muchas gracias
System.*out*.println(4 \* Math.*PI* \* Math.*pow*(y,2));
//Area de una esfera : 4 * PI * r2
        System.out.println((4 * Math.PI) * Math.pow(y,2));
        // No se si mi respuesta esta buena 
Buenas a todoas! Aquí dejo el código del ejercicio de la esfera junto a una captura de pantalla del output en consola. ```java import java.util.Scanner; public class _004_MathOperationsAreaEsfera { public static void main(String [] Args){ Scanner entrada = new Scanner(System.in); //Area de una esfera a=4*pi*radio^2 System.out.print("Ingrese el radio de la esfera..: "); double radio = entrada.nextDouble(); double areaEsfera = 4*Math.PI*Math.pow(radio,2); System.out.println("El area de la esfera con radio "+radio+" es: "+(float)areaEsfera+" unidades cuadradas."); } } ```import java.util.Scanner; public class \_004\_MathOperationsAreaEsfera { public static void main(String \[] Args){ Scanner entrada = new Scanner(System.*in*); //Area de una esfera a=4\*pi\*radio^2 System.*out*.print("Ingrese el radio de la esfera..: "); double radio = entrada.nextDouble(); double areaEsfera = 4\*Math.*PI*\*Math.*pow*(radio,2); System.*out*.println("El area de la esfera con radio "+radio+" es: "+(float)areaEsfera+" unidades cuadradas."); } }
```js // area de una esfera // 4*PI*r2 double areaEsfera = 4 * Math.PI * Math.pow(4, 2); System.out.println(areaEsfera); ```Mi solución..
Dejo acá todas las funciones, con un mensaje para cada una de ellas, en la cual utilice StringBuilder, el cual es una forma de hacer más legible y performante la concatenación de mensjaes, reemplazando el '+'. En este caso no tiene mayor impacto, pero es una buena práctica a futuro. `double x = 2.1;` `double y = 3;````java ``` `StringBuilder sb = new StringBuilder();` `// Redondea un decimal hacia arriba` `sb.append("Valor redondeado de ").append(x).append(" hacia arriba es: ").append(Math.``ceil``(x)).append("\n");` `// Redondea un decimal hacia abajo` `sb.append("Valor redondeado de ").append(x).append(" hacia abajo es: ").append(Math.``floor``(x)).append("\n");` `// Eleva un número` `sb.append("Elevar '").append(x).append("' a la potencia de '").append(y).append("' da como resultado: ").append(Math.``pow``(x, y)).append("\n");` `// Devuelve el mayor valor` `sb.append("El valor máximo entre '").append(x).append("' y '").append(y).append("' es: ").append(``max``(x, y)).append("\n");` `// Raíz cuadrada de un valor` `sb.append("La raíz cuadrada de '").append(x).append("' es: ").append(Math.``sqrt``(x)).append("\n");` `// El área de un círculo es pi * R^2` `sb.append("El área de un círculo de radio '").append(y).append("' es: ").append(Math.``PI ``* Math.``pow``(y, 2)).append("\n");` `// El área de una esfera es '4*PI*R^2'` `sb.append("El área de una esfera de radio '").append(y).append("' es: ").append(4 * Math.``PI ``* Math.``pow``(y, 2)).append("\n");` `// Volumen de una esfera (4/3*pi*r3)` `sb.append("El volumen de una esfera de radio '").append(y).append("' es: ").append((4 / 3) * Math.``PI ``* Math.``pow``(y, 3));` `String ResultImp = sb.toString();` `System.``out``.println(ResultImp);`

Aquí mi solución al reto:

// Área de una esfera (4 * pi * r^2)
System.out.println(4 * Math.PI * Math.pow(y, 2));

Un error que noté es que al dividir 4 entre 3 nos arroja el resultado como un entero, es decir que el resultado es 1. Para que esto no suceda y nos de el valor exacto de la división debemos convertir ese resultado a double:

System.out.println(((double) 4 / 3) * Math.PI * Math.pow(y, 3));

Volumen de la ESFERA:

_

Área de la ESFERA:

_

a mi me salio 113.09 con:
System.out.println(4* Math.PI* Math.pow(y,2));

//Área de un círculo Pi * radio^2

        int radio = 3;
        double areaCirculo = Math.PI * Math.pow(radio, 2);
        System.out.println(areaCirculo);


        //Area de una esféra 4 * Pi * radio^2

        System.out.println(4 * Math.PI * Math.pow(radio,2));

Volumen de una esfera:
(4 *pi * r3) / 3

System.out.println((4 * Math.PI * Math.pow(y, 3))/3);

según leí en comentarios la fórmula está mal. en Google la fórmula es 4/3 • π• r^3 entonces System.out.println((4/3)*Math.PI*Math(pow(y.3))

Comparto el código desarrollado dentro de la clase

public class MathematicOperations {
    public static void main(String[] args) {
        double x = 2.1;
        double y = 3;

        //devuelve un entero hacía arriba
        System.out.println(Math.ceil(x)); //3.0

        //devuelve un entero hacía abajo
        System.out.println(Math.floor(x)); //2.0

        //devuelve un numero elevado a otro, ejemplo 2^3 =8
        System.out.println(Math.pow(x,y));

        //devuelve el número mayor
        System.out.println(Math.max(x,y)); //3.0

        //devuelve la raiz cuadrada
        System.out.println(Math.sqrt(y)); //1.73205

        //Area de un circulo
        //pi * r2
        System.out.println(Math.PI * Math.pow(y,2)); //28.27433

        //area de una esfera
        // 4*pi*r2
        System.out.println(4 * Math.PI * Math.pow(y,2)); //113.09733552923255

        //Volumen de una esfera
        //(4/3)*pi*r3
        System.out.println((4/3) * Math.PI * Math.pow(y,3)); //84.82300164692441

        }
    }

Este sería el código para definir el área de una esfera de radio 1.

// Area de una esfera
double radio = 1.0;
double resp = 4 * Math.PI * Math.pow(radio, 2);
System.out.println(resp);

Area de una esfera.
Ejercicio sin ver el resultado:

//Area de una esfera
//(4/3)*pi *r3
System.out.println((4/3) * Math.PI * Math.pow(y,3));

Pausa minuto 7.10.
Resolvi el ejercicio de calculoo area de esfera de la siguiente manera:

//area de una esfera.
//4PIr2+
System.out.println((Math.PI * Math.pow(y,2))*4);

El area de una esfera sería:

System.out.println(4 * Math.PI * Math.pow(y,2));
    System.out.println(4 * Math.PI * Math.pow(y,2));

Creo que esa es la linea para resolver el area de una esfera

  //Area de una esfera
        //4PI * r2
        System.out.println("El area de la esfera 'y' es: "+		 
        (Math.PI*4)*Math.pow(y,2));```

System.out.println(4 * Math.PI * Math.pow(y,2));

Creo que el área de una esfera sería
System.out.println(4 * Math.PI * Math.pow(x,2));

System.out.println(4Math.PIMath.pow(x,y));

//area de una esfera
//4*PI*r2
System.out.println(4*Math.PI * Math.pow(y,2));

que divertidas las operaciones para calcular el área, super interesante

asi obtengo el area de la esfera

//area de una esfera
        // 4*PI*r2
        System.out.println(4 * Math.PI * Math.pow(y,2));

Lo realize de la siguiente manera:

double esfera= 4* Math.PI*Math.pow(y,2);
        System.out.println(esfera);

Creo que asi funciona

System.out.println(4 * Math.PI * Math.pow(y,2));

Este sería mi código de la clase:

package practices;
public class MathematicOperations {
    public static void main(String[] args) {
        double x = 2.1;
        double y = 3;
        
        //Devuelve un entero hacia arriba
        System.out.println(Math.ceil(x));
        
        //Devuelve un entero hacia abajo
        System.out.println(Math.floor(x));
        
        //Devuelve un número elevado a otro
        System.out.println(Math.pow(x, y));
        
        //Devuelve el número mayor
        System.out.println(Math.max(x, y));
        
        //Devuelve la raíz cuadrada
        System.out.println(Math.sqrt(y));
        
        //Area de un círculo: PI * R**2
        System.out.println(Math.PI * Math.pow(y, 2));
        
        //Area de una esfera: 4*PI*r2
        System.out.println(4 * Math.PI * Math.pow(y, 2));
        
        //Volumen de una esfera: (4/3)*PI * r3
        System.out.println((4/3) * Math.PI * Math.pow(y, 3));
    }
}

Sin ver el video asi lo solucione
//Por ejemplo sacar el area de una esfera Formula 4PI por radio al cuadrado
System.out.println((Math.PI * 4) * Math.pow(y, 2));

si ahi una mejor forma la aprendere despues de ver el video ajajaj

//Area de una esfera
//4PIr2
System.out.println((4 * Math.PI * Math.pow(y,3))/3);

        System.out.println("This is the area of a sphere with a radius of Y: " + Math.PI*4*Math.pow(y, 2));

🥋🥋🥋⛩️

System.out.println((4*Math.PI)*Math.pow(y,2));

## respuesta ``` System.out.println(4*Math.PI*Math(y,2);

Hola, Aquí el ejercicio propuesto:

Ya que sale un “Warning” cuando hacemos la operación estuve buscando formas de evitar esto y mirando las opciones que decia el IDE encontre esto hacer ( (double) 4/3 ) de esta forma sabe que tendra un punto flotante o punto doble en este caso, pero tambien se puede resolver haciendo (4.0/3.0) y con esto java detecta automaticamente que la operacion es de punto doble ❤️

        // Volumen de una esfera
        // 4/3 * PI * r3
        System.out.println("Volumen de una esfera usando PI Y pow");
        System.out.println(((double)4/3) * Math.PI * Math.pow(y, 2));

        // el (double) lo usamos para que no salga un warning*
        // Warning: Integer Division in Floating-Point Context

Comparto mi codigo de are de una esfera
//area de una esfera
//4PIR2
System.out.println ("El area de una esfera: " + (4)
Math.PI* Math.pow(y,2) );

formula para el volumen de una esfera
https://www.youtube.com/watch?v=5KYGSh8rGX4
System.out.println((4/3 * Math.PI)* (Math.pow(Y,3)));

el área de la esfera:
System.out.println(4Math.PIMath.pow(y,2));

Area de un esfera

System.out.println(4*Math.PI*Math.pow(y,2));
113.09733552923255

Para calcular el radio de una esfera:

System.out.println( (4) * Math.PI * Math.pow(r, 2) );

//area de esfera 4pir2
System.out.println(4Math.PIMath.pow(y, 2));

Aquí mi respuesta para resolver el área de una esfera

<code> 
//área de una esfera 4+PI*r2
        System.out.println(4 * Math.PI * Math.pow(y,2))
    System.out.println(4 * Math.PI * Math.pow(y,2));
  • Clase Math que viene lista con una serie de funciones interesantes para realizar estas operaciones mucho más sencillo.
  • Tienes que escribir Math con mayúscula porque es una clase.
  • Las constantes se escriben con mayúscula.
  • el método Ceil nos devuelve un número entero dependiendo del valor que se tenga. (devuelve hacía arriba)
  • For nos va a devolver un entero pero en este caso será hacía abajo.
  • Nos devuelve un número elevado a otro número. Pow.
  • Saber cual es el dato más grande entre dos datos o cual es el valor mayor entre esos dos. max ( devuelve el número mayor).
  • Devuelve la raíz cuadrada. sqrt.
  • Calcular el area de un circulo. pi * r2
  • Area de una esfera. 4 * PI * r2
  • Volumen de una esfera. (4/3) * pi * r3

var y = 3;
//Ara de una esfera
//4 * PI * r2
System.out.println(4Math.PIMath.pow(y,2));

double y=3; // y es el RADIO

System.out.println(Math.PI4Math.pow(y, 2));

RUN

Segun mis calculos mentales 108 mas o menos. pero ya viendolo, si es una parte exacta es la que comparto.

Según considero así se haría el área de una esfera:

<code> System.out.println(4*Math.PI*Math.pow(y,2))
//El area de una esfera
System.out.println(4*Math.PI*(Math.pow(y,2)));
//Resultado: 113.097335

Excelente con MAth!