clase y clase StrictMath Detallado fuente Math
definición de clase
public final class Math {
}public final class StrictMath {
}La última clase modificada no puede ser heredada, que no puede tener su propia subclase
la clase de matemáticas proporcionar algunas funciones trigonométricas
contraste
public static double sin(double a) {
return StrictMath.sin(a); // default impl. delegates to StrictMath
} public static native double sin(double a);La plataforma Java tiene usuarios y código nativo de C API de interoperabilidad, que se refiere como una interfaz nativa de Java (Java Native Interface).
Use palabras clave nativa Descripción Este método es una función nativa, es decir, este método es utilizar el lenguaje C / C ++ y compilado como DLL, para llamar al java.
Lograr estos cuerpos funcionan en la DLL, el código fuente del JDK no está incluido, no debería ver. Para las diferentes plataformas también son diferentes. Este es el mecanismo subyacente de Java, Java es en realidad llamando diferentes métodos nativos en diferentes plataformas para lograr el acceso al sistema operativo.
Dos más -strictfp esencial diferencia
public static strictfp double toRadians(double angdeg) {
// Do not delegate to Math.toRadians(angdeg) because
// this method has the strictfp modifier.
return angdeg / 180.0 * PI;
} public static double toRadians(double angdeg) {
return angdeg / 180.0 * PI;
}strictfp explicación:
Sobre suelo y método floorMod
public static double ceil(double a) {
return StrictMath.ceil(a); // default impl. delegates to StrictMath
}
public static double floor(double a) {
return StrictMath.floor(a); // default impl. delegates to StrictMath
} public static double ceil(double a) {
return floorOrCeil(a, -0.0, 1.0, 1.0);
}
public static double floor(double a) {
return floorOrCeil(a, -1.0, 0.0, -1.0);
}
private static double floorOrCeil(double a,
double negativeBoundary,
double positiveBoundary,
double sign) {
int exponent = Math.getExponent(a);
if (exponent < 0) {
/*
* Absolute value of argument is less than 1.
* floorOrceil(-0.0) => -0.0
* floorOrceil(+0.0) => +0.0
*/
return ((a == 0.0) ? a :
( (a < 0.0) ? negativeBoundary : positiveBoundary) );
} else if (exponent >= 52) {
/*
* Infinity, NaN, or a value so large it must be integral.
*/
return a;
}
// Else the argument is either an integral value already XOR it
// has to be rounded to one.
assert exponent >= 0 && exponent <= 51;
long doppel = Double.doubleToRawLongBits(a);
long mask = DoubleConsts.SIGNIF_BIT_MASK >> exponent;
if ( (mask & doppel) == 0L )
return a; // integral value
else {
double result = Double.longBitsToDouble(doppel & (~mask));
if (sign*a > 0.0)
result = result + sign;
return result;
}
}
x = Math.getExponent (y) correspondiente a Math.pow = Y (2, X), X ^ 2
Doble exponente El Math.getExponent = (1.); // exponente imparcial
Si el argumento es infinito o NaN, entonces el resultado es Float .MAX_EXPONENT + 1.
Si el parámetro es cero o menos de lo normal, entonces el resultado es Float.MIN_EXPONENT-1.
Aproximadamente 0 y 0L
sistema de memoria java de
Ejemplo:
Largo fw = 10000000000L;
de hecho, sólo un tipo variable de memoria fw largo, que está presente en, donde el valor no se almacena en la pila (Stack), que apunta a la pila (stack) otra pieza de almacenamiento real memoria, más el valor de L finalidad es permitir el montón crear una larga tipo de memoria necesaria para que el valor de venta.
Por lo tanto antes como después de dicha = es, de hecho, dos de memoria diferente, pero hay un puntero invisible para conectar los dos.
Sin consecuencias:
- Sin L defecto es int, int a tiempo para estar a salvo, se encenderá automáticamente, puede compilar
- Flotador sin F es el tipo predeterminado doble, doble giro flotador posible pérdida de precisión, porque no sería cambiar automáticamente, el paso del compilador
- Si el rango no se supera int más L, dirigirá el error
public static int floorMod(int x, int y) {
int r = x - floorDiv(x, y) * y;
return r;
}
public static long floorMod(long x, long y) {
return x - floorDiv(x, y) * y;
}
public static int floorDiv(int x, int y) {
int r = x / y;
// if the signs are different and modulo not zero, round down
if ((x ^ y) < 0 && (r * y != x)) {
r--;
}
return r;
}modo Java buscar se utiliza Math.floorMod (dividendo, divisor) Método
Cuando el mismo número de dividendo y el divisor, y el resto de módulo resultados obtenidos son iguales
se obtiene cociente Proceso resto y se añade al número positivo o negativo con un valor absoluto del cociente
se obtiene cociente Proceso modulo excepto valor del cociente 1 signo con un valor absoluto y se añade, la alícuota.
El resto proceso:
señal que depende de la cantidad de dividendo, el dividendo es positivo, en comparación con el dividendo positivo y negativo es negativo
proceso de módulo:
Die signo depende del divisor, el divisor es positivo, en comparación con un resultado positivo, el divisor es responsable de la negativa
public static int abs(int a) {
return (a < 0) ? -a : a;
} public static float abs(float a) {
return (a <= 0.0F) ? 0.0F - a : a;
} public static double abs(double a) {
return (a <= 0.0D) ? 0.0D - a : a;
} public static int max(int a, int b) {
return (a >= b) ? a : b;
} public static float max(float a, float b) {
if (a != a)
return a; // a is NaN
if ((a == 0.0f) &&
(b == 0.0f) &&
(Float.floatToRawIntBits(a) == negativeZeroFloatBits)) {
// Raw conversion ok since NaN can't map to -0.0.
return b;
}
return (a >= b) ? a : b;
}
