redondear - math.round javascript
¿Cómo puedo obtener partes dobles y fraccionadas del doble en JSP/Java? (17)
¿Cómo puedo obtener partes dobles y fraccionadas del doble en JSP / Java? Si el valor es 3.25, entonces quiero obtener fractional =.25 , whole = 3
¿Cómo podemos hacer esto en Java?
Google te ayudaría si usaras los términos correctos para buscar "obtener fraccional y parte completa de double java"
http://www.java2s.com/Code/Java/Data-Type/Obtainingtheintegerandfractionalparts.htm
double num;
long iPart;
double fPart;
// Get user input
num = 2.3d;
iPart = (long) num;
fPart = num - iPart;
System.out.println("Integer part = " + iPart);
System.out.println("Fractional part = " + fPart);
Productos:
Integer part = 2
Fractional part = 0.2999999999999998
Usaría BigDecimal para la solución. Me gusta esto:
double value = 3.25;
BigDecimal wholeValue = BigDecimal.valueOf(value).setScale(0, BigDecimal.ROUND_DOWN);
double fractionalValue = value - wholeValue.doubleValue();
[Editar: La pregunta originalmente le preguntó cómo obtener la mantisa y el exponente.]
Donde n es el número para obtener la mantisa real / exponente:
exponent = int(log(n))
mantissa = n / 10^exponent
O bien, para obtener la respuesta que estabas buscando:
exponent = int(n)
mantissa = n - exponent
Estos no son Java exactamente, pero deberían ser fáciles de convertir.
double value = 3.25;
double fractionalPart = value % 1;
double integralPart = value - fractionalPart;
public class MyMain2 {
public static void main(String[] args) {
double myDub;
myDub=1234.5678;
long myLong;
myLong=(int)myDub;
myDub=(myDub%1)*10000;
int myInt=(int)myDub;
System.out.println(myLong + "/n" + myInt);
}
}
Dado que esta pregunta de 1 año fue iniciada por alguien que corrigió el tema de la pregunta, y esta pregunta ha sido etiquetada con jsp , y nadie aquí fue capaz de dar una respuesta específica JSP, aquí está mi contribución dirigida a JSP.
Use JSTL (simplemente suelte jstl-1.2.jar en /WEB-INF/lib ) fmt taglib. Hay una <fmt:formatNumber> que hace exactamente lo que quieres y de una manera bastante fácil con la ayuda de los atributos maxFractionDigits y maxIntegerDigits .
Aquí hay un SSCCE , solo copie y pase.
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>
<%
// Just for quick prototyping. Don''t do this in real! Use servlet/javabean.
double d = 3.25;
request.setAttribute("d", d);
%>
<!doctype html>
<html lang="en">
<head>
<title>SO question 343584</title>
</head>
<body>
<p>Whole: <fmt:formatNumber value="${d}" maxFractionDigits="0" />
<p>Fraction: <fmt:formatNumber value="${d}" maxIntegerDigits="0" />
</body>
</html>
Salida:
Conjunto: 3
Fracción: .25
Eso es. No es necesario masajearlo con la ayuda del código Java sin procesar.
Como la etiqueta fmt:formatNumber no siempre arroja el resultado correcto, aquí hay otro enfoque solo de JSP: Simplemente formatea el número como cadena y hace el resto del cálculo en la cadena, ya que es más fácil y no involucra otros aritméticos de punto flotante.
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
<%
double[] numbers = { 0.0, 3.25, 3.75, 3.5, 2.5, -1.5, -2.5 };
pageContext.setAttribute("numbers", numbers);
%>
<html>
<body>
<ul>
<c:forEach var="n" items="${numbers}">
<li>${n} = ${fn:substringBefore(n, ".")} + ${n - fn:substringBefore(n, ".")}</li>
</c:forEach>
</ul>
</body>
</html>
No sé si esto es más rápido pero estoy usando
float fp = ip % 1.0f;
La lógica principal tiene que encontrar primero cuántos dígitos hay después del punto decimal.
Este código funciona para cualquier número de hasta 16 dígitos. Si usa BigDecimal, puede ejecutarlo solo por hasta 18 dígitos. pon el valor de entrada (tu número) a la variable "num", aquí como ejemplo lo he codificado.
double num, temp=0;
double frac,j=1;
num=1034.235;
// FOR THE FRACTION PART
do{
j=j*10;
temp= num*j;
}while((temp%10)!=0);
j=j/10;
temp=(int)num;
frac=(num*j)-(temp*j);
System.out.println("Double number= "+num);
System.out.println("Whole part= "+(int)num+" fraction part= "+(int)frac);
Muchas de estas respuestas tienen horribles errores de redondeo porque están emitiendo números de un tipo a otro. Qué tal si:
double x=123.456;
double fractionalPart = x-Math.floor(x);
double wholePart = Math.floor(x);
La respuesta aceptada no funciona bien para números negativos entre -0 y -1.0. También da negativo a la parte fraccionaria.
Por ejemplo: para el número -0,35
devoluciones
Parte entera = 0 Parte fraccionaria = -0.35
Si está trabajando con coordenadas GPS, es mejor tener un resultado con el signo en la parte entera como:
Parte entera = -0 Parte fraccionaria = 0.35
Estos números se utilizan, por ejemplo, para las coordenadas de GPS, donde son importantes el signo de Latitud o Posición larga
Código de propuesta:
double num;
double iPart;
double fPart;
// Get user input
num = -0.35d;
iPart = (long) num;
//Correct numbers between -0.0 and -1.0
iPart = (num<=-0.0000001 && num>-1.0)? -iPart : iPart ;
fPart = Math.abs(num - iPart);
System.out.println(String.format("Integer part = %01.0f",iPart));
System.out.println(String.format("Fractional part = %01.04f",fPart));
Salida:
Integer part = -0
Fractional part = 0,3500
Desde Java 8, puede usar Math.floorDiv .
Devuelve el valor int más grande (más cercano al infinito positivo) que es menor o igual que el cociente algebraico.
Algunos ejemplos:
floorDiv(4, 3) == 1
floorDiv(-4, 3) == -2
Alternativamente, el operador / puede ser utilizado:
(4 / 3) == 1
(-4 / 3) == -1
Referencias
La mantisa y el exponente de un número IEEE de doble punto flotante son los valores tales que
value = sign * (1 + mantissa) * pow(2, exponent)
si la mantisa tiene la forma 0.101010101_base 2 (es decir, su bit más significativo se desplaza para que esté después del punto binario) y el exponente se ajusta para el sesgo.
Desde 1.6, java.lang.Math también proporciona un método directo para obtener el exponente imparcial (llamado getExponent (double))
Sin embargo, los números que está pidiendo son las partes integrales y fraccionarias del número, que se pueden obtener usando
integral = Math.floor(x)
fractional = x - Math.floor(x)
aunque puede que desee tratar los números negativos de manera diferente (floor(-3.5) == -4.0) , dependiendo de por qué quiere las dos partes.
Le sugiero encarecidamente que no llame a estas mantisas y exponente.
La pregunta original preguntaba por el exponente y la mantisa, en lugar de la parte fraccionaria y entera.
Para obtener el exponente y la mantisa de un doble, puede convertirlo en la representación IEEE 754 y extraer los bits así:
long bits = Double.doubleToLongBits(3.25);
boolean isNegative = (bits & 0x8000000000000000L) != 0;
long exponent = (bits & 0x7ff0000000000000L) >> 52;
long mantissa = bits & 0x000fffffffffffffL;
String value = "3.06";
if(!value.isEmpty()){
if(value.contains(".")){
String block = value.substring(0,value.indexOf("."));
System.out.println(block);
}else{
System.out.println(value);
}
}
¿Qué pasa si tu número es 2.39999999999999? Supongo que quieres obtener el valor decimal exacto. Luego usa BigDecimal:
Integer x,y,intPart;
BigDecimal bd,bdInt,bdDec;
bd = new BigDecimal("2.39999999999999");
intPart = bd.intValue();
bdInt = new BigDecimal(intPart);
bdDec = bd.subtract(bdInt);
System.out.println("Number : " + bd);
System.out.println("Whole number part : " + bdInt);
System.out.println("Decimal number part : " + bdDec);
La parte entera se obtiene a partir de una conversión simple y para la división fraccional de series:
double value = 123.004567890
int integerPart;
int fractionPart;
/**
* To control zeroes omitted from start after parsing.
*/
int decimals;
integerPart = (int) value; // 123
fractionPart =
Integer.valueOf(
String.valueOf(value)
.split(".")
[1]); // 004567890
decimals =
String.valueOf(value)
.split(".")
[1]
.length(); // 9