package android.util;
/**
- * Math routines similar to those found in {@link java.lang.Math}. On
- * versions of Android with a JIT, these are significantly slower than
- * the equivalent {@code Math} functions, which should be used in preference
- * to these.
+ * Math routines similar to those found in {@link java.lang.Math}.
+ *
+ * <p>Historically these methods were faster than the equivalent double-based
+ * {@link java.lang.Math} methods. On versions of Android with a JIT they
+ * became slower and have since been re-implemented to wrap calls to
+ * {@link java.lang.Math}. {@link java.lang.Math} should be used in
+ * preference.
*/
public class FloatMath {
* @param value to be converted
* @return the floor of value
*/
- public static native float floor(float value);
+ public static float floor(float value) {
+ return (float) Math.floor(value);
+ }
/**
* Returns the float conversion of the most negative (i.e. closest to
* @param value to be converted
* @return the ceiling of value
*/
- public static native float ceil(float value);
+ public static float ceil(float value) {
+ return (float) Math.ceil(value);
+ }
/**
* Returns the closest float approximation of the sine of the argument.
* @param angle to compute the cosine of, in radians
* @return the sine of angle
*/
- public static native float sin(float angle);
+ public static float sin(float angle) {
+ return (float) Math.sin(angle);
+ }
/**
* Returns the closest float approximation of the cosine of the argument.
* @param angle to compute the cosine of, in radians
* @return the cosine of angle
*/
- public static native float cos(float angle);
+ public static float cos(float angle) {
+ return (float) Math.cos(angle);
+ }
/**
* Returns the closest float approximation of the square root of the
* @param value to compute sqrt of
* @return the square root of value
*/
- public static native float sqrt(float value);
+ public static float sqrt(float value) {
+ return (float) Math.sqrt(value);
+ }
/**
* Returns the closest float approximation of the raising "e" to the power
* @param value to compute the exponential of
* @return the exponential of value
*/
- public static native float exp(float value);
+ public static float exp(float value) {
+ return (float) Math.exp(value);
+ }
/**
* Returns the closest float approximation of the result of raising {@code
* @param y the exponent of the operation.
* @return {@code x} to the power of {@code y}.
*/
- public static native float pow(float x, float y);
+ public static float pow(float x, float y) {
+ return (float) Math.pow(x, y);
+ }
/**
* Returns {@code sqrt(}<i>{@code x}</i><sup>{@code 2}</sup>{@code +} <i>
* @param y a float number
* @return the hypotenuse
*/
- public static native float hypot(float x, float y);
+ public static float hypot(float x, float y) {
+ return (float) Math.hypot(x, y);
+ }
}
android_util_Binder.cpp \
android_util_EventLog.cpp \
android_util_Log.cpp \
- android_util_FloatMath.cpp \
android_util_Process.cpp \
android_util_StringBlock.cpp \
android_util_XmlBlock.cpp \
extern int register_android_media_JetPlayer(JNIEnv *env);
extern int register_android_media_ToneGenerator(JNIEnv *env);
-extern int register_android_util_FloatMath(JNIEnv* env);
-
namespace android {
/*
REG_JNI(register_android_os_SystemClock),
REG_JNI(register_android_util_EventLog),
REG_JNI(register_android_util_Log),
- REG_JNI(register_android_util_FloatMath),
REG_JNI(register_android_content_AssetManager),
REG_JNI(register_android_content_StringBlock),
REG_JNI(register_android_content_XmlBlock),
+++ /dev/null
-#include "jni.h"
-#include <android_runtime/AndroidRuntime.h>
-#include <math.h>
-#include <float.h>
-#include "SkTypes.h"
-
-class MathUtilsGlue {
-public:
- static float FloorF(JNIEnv* env, jobject clazz, float x) {
- return floorf(x);
- }
-
- static float CeilF(JNIEnv* env, jobject clazz, float x) {
- return ceilf(x);
- }
-
- static float SinF(JNIEnv* env, jobject clazz, float x) {
- return sinf(x);
- }
-
- static float CosF(JNIEnv* env, jobject clazz, float x) {
- return cosf(x);
- }
-
- static float SqrtF(JNIEnv* env, jobject clazz, float x) {
- return sqrtf(x);
- }
-
- static float ExpF(JNIEnv* env, jobject clazz, float x) {
- return expf(x);
- }
-
- static float PowF(JNIEnv* env, jobject clazz, float x, float y) {
- return powf(x, y);
- }
-
- static float HypotF(JNIEnv* env, jobject clazz, float x, float y) {
- return hypotf(x, y);
- }
-};
-
-static JNINativeMethod gMathUtilsMethods[] = {
- {"floor", "(F)F", (void*) MathUtilsGlue::FloorF},
- {"ceil", "(F)F", (void*) MathUtilsGlue::CeilF},
- {"sin", "(F)F", (void*) MathUtilsGlue::SinF},
- {"cos", "(F)F", (void*) MathUtilsGlue::CosF},
- {"sqrt", "(F)F", (void*) MathUtilsGlue::SqrtF},
- {"exp", "(F)F", (void*) MathUtilsGlue::ExpF},
- {"pow", "(FF)F", (void*) MathUtilsGlue::PowF},
- {"hypot", "(FF)F", (void*) MathUtilsGlue::HypotF},
-};
-
-int register_android_util_FloatMath(JNIEnv* env)
-{
- int result = android::AndroidRuntime::registerNativeMethods(env,
- "android/util/FloatMath",
- gMathUtilsMethods,
- SK_ARRAY_COUNT(gMathUtilsMethods));
- return result;
-}
-
--- /dev/null
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package android.util;
+
+import com.google.caliper.Param;
+import com.google.caliper.Runner;
+import com.google.caliper.SimpleBenchmark;
+
+import android.util.FloatMath;
+
+public class FloatMathBenchmark extends SimpleBenchmark {
+
+ public float timeFloatMathCeil(int reps) {
+ // Keep an answer so we don't optimize the method call away.
+ float f = 0.0f;
+ for (int i = 0; i < reps; i++) {
+ f += FloatMath.ceil(100.123f);
+ }
+ return f;
+ }
+
+ public float timeFloatMathCeil_math(int reps) {
+ // Keep an answer so we don't optimize the method call away.
+ float f = 0.0f;
+ for (int i = 0; i < reps; i++) {
+ f += (float) Math.ceil(100.123f);
+ }
+ return f;
+ }
+
+ public float timeFloatMathCos(int reps) {
+ // Keep an answer so we don't optimize the method call away.
+ float f = 0.0f;
+ for (int i = 0; i < reps; i++) {
+ f += FloatMath.cos(100.123f);
+ }
+ return f;
+ }
+
+ public float timeFloatMathExp(int reps) {
+ // Keep an answer so we don't optimize the method call away.
+ float f = 0.0f;
+ for (int i = 0; i < reps; i++) {
+ f += FloatMath.exp(100.123f);
+ }
+ return f;
+ }
+
+ public float timeFloatMathFloor(int reps) {
+ // Keep an answer so we don't optimize the method call away.
+ float f = 0.0f;
+ for (int i = 0; i < reps; i++) {
+ f += FloatMath.floor(100.123f);
+ }
+ return f;
+ }
+
+ public float timeFloatMathHypot(int reps) {
+ // Keep an answer so we don't optimize the method call away.
+ float f = 0.0f;
+ for (int i = 0; i < reps; i++) {
+ f += FloatMath.hypot(100.123f, 100.123f);
+ }
+ return f;
+ }
+
+ public float timeFloatMathPow(int reps) {
+ // Keep an answer so we don't optimize the method call away.
+ float f = 0.0f;
+ for (int i = 0; i < reps; i++) {
+ f += FloatMath.pow(10.123f, 10.123f);
+ }
+ return f;
+ }
+
+ public float timeFloatMathSin(int reps) {
+ // Keep an answer so we don't optimize the method call away.
+ float f = 0.0f;
+ for (int i = 0; i < reps; i++) {
+ f += FloatMath.sin(100.123f);
+ }
+ return f;
+ }
+
+ public float timeFloatMathSqrt(int reps) {
+ // Keep an answer so we don't optimize the method call away.
+ float f = 0.0f;
+ for (int i = 0; i < reps; i++) {
+ f += FloatMath.sqrt(100.123f);
+ }
+ return f;
+ }
+
+ public float timeFloatMathSqrt_math(int reps) {
+ // Keep an answer so we don't optimize the method call away.
+ float f = 0.0f;
+ for (int i = 0; i < reps; i++) {
+ f += (float) Math.sqrt(100.123f);
+ }
+ return f;
+ }
+
+}
OSDN Git Service
