/*
|
* Copyright (C) 2010 Google Inc.
|
*
|
* 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 benchmarks.regression;
|
|
/**
|
* Many of these tests are bogus in that the cost will vary wildly depending on inputs.
|
* For _my_ current purposes, that's okay. But beware!
|
*/
|
public class MathBenchmark {
|
private final double d = 1.2;
|
private final float f = 1.2f;
|
private final int i = 1;
|
private final long l = 1L;
|
|
// NOTE: To avoid the benchmarked function from being optimized away, we store the result
|
// and use it as the benchmark's return value. This is good enough for now but may not be in
|
// the future, a smart compiler could determine that the result value will depend on whether
|
// we get into the loop or not and turn the whole loop into an if statement.
|
|
public double timeAbsD(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.abs(d);
|
}
|
return result;
|
}
|
|
public float timeAbsF(int reps) {
|
float result = f;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.abs(f);
|
}
|
return result;
|
}
|
|
public int timeAbsI(int reps) {
|
int result = i;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.abs(i);
|
}
|
return result;
|
}
|
|
public long timeAbsL(int reps) {
|
long result = l;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.abs(l);
|
}
|
return result;
|
}
|
|
public double timeAcos(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.acos(d);
|
}
|
return result;
|
}
|
|
public double timeAsin(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.asin(d);
|
}
|
return result;
|
}
|
|
public double timeAtan(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.atan(d);
|
}
|
return result;
|
}
|
|
public double timeAtan2(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.atan2(3, 4);
|
}
|
return result;
|
}
|
|
public double timeCbrt(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.cbrt(d);
|
}
|
return result;
|
}
|
|
public double timeCeil(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.ceil(d);
|
}
|
return result;
|
}
|
|
public double timeCopySignD(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.copySign(d, d);
|
}
|
return result;
|
}
|
|
public float timeCopySignF(int reps) {
|
float result = f;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.copySign(f, f);
|
}
|
return result;
|
}
|
|
public double timeCopySignD_strict(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = StrictMath.copySign(d, d);
|
}
|
return result;
|
}
|
|
public float timeCopySignF_strict(int reps) {
|
float result = f;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = StrictMath.copySign(f, f);
|
}
|
return result;
|
}
|
|
public double timeCos(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.cos(d);
|
}
|
return result;
|
}
|
|
public double timeCosh(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.cosh(d);
|
}
|
return result;
|
}
|
|
public double timeExp(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.exp(d);
|
}
|
return result;
|
}
|
|
public double timeExpm1(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.expm1(d);
|
}
|
return result;
|
}
|
|
public double timeFloor(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.floor(d);
|
}
|
return result;
|
}
|
|
public int timeGetExponentD(int reps) {
|
int result = i;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.getExponent(d);
|
}
|
return result;
|
}
|
|
public int timeGetExponentF(int reps) {
|
int result = i;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.getExponent(f);
|
}
|
return result;
|
}
|
|
public double timeHypot(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.hypot(d, d);
|
}
|
return result;
|
}
|
|
public double timeIEEEremainder(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.IEEEremainder(d, d);
|
}
|
return result;
|
}
|
|
public double timeLog(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.log(d);
|
}
|
return result;
|
}
|
|
public double timeLog10(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.log10(d);
|
}
|
return result;
|
}
|
|
public double timeLog1p(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.log1p(d);
|
}
|
return result;
|
}
|
|
public double timeMaxD(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.max(d, d);
|
}
|
return result;
|
}
|
|
public float timeMaxF(int reps) {
|
float result = f;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.max(f, f);
|
}
|
return result;
|
}
|
|
public int timeMaxI(int reps) {
|
int result = i;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.max(i, i);
|
}
|
return result;
|
}
|
|
public long timeMaxL(int reps) {
|
long result = l;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.max(l, l);
|
}
|
return result;
|
}
|
|
public double timeMinD(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.min(d, d);
|
}
|
return result;
|
}
|
|
public float timeMinF(int reps) {
|
float result = f;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.min(f, f);
|
}
|
return result;
|
}
|
|
public int timeMinI(int reps) {
|
int result = i;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.min(i, i);
|
}
|
return result;
|
}
|
|
public long timeMinL(int reps) {
|
long result = l;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.min(l, l);
|
}
|
return result;
|
}
|
|
public double timeNextAfterD(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.nextAfter(d, d);
|
}
|
return result;
|
}
|
|
public float timeNextAfterF(int reps) {
|
float result = f;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.nextAfter(f, f);
|
}
|
return result;
|
}
|
|
public double timeNextUpD(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.nextUp(d);
|
}
|
return result;
|
}
|
|
public float timeNextUpF(int reps) {
|
float result = f;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.nextUp(f);
|
}
|
return result;
|
}
|
|
public double timePow(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.pow(d, d);
|
}
|
return result;
|
}
|
|
public double timeRandom(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.random();
|
}
|
return result;
|
}
|
|
public double timeRint(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.rint(d);
|
}
|
return result;
|
}
|
|
public long timeRoundD(int reps) {
|
long result = l;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.round(d);
|
}
|
return result;
|
}
|
|
public int timeRoundF(int reps) {
|
int result = i;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.round(f);
|
}
|
return result;
|
}
|
|
public double timeScalbD(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.scalb(d, 5);
|
}
|
return result;
|
}
|
|
public float timeScalbF(int reps) {
|
float result = f;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.scalb(f, 5);
|
}
|
return result;
|
}
|
|
public double timeSignumD(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.signum(d);
|
}
|
return result;
|
}
|
|
public float timeSignumF(int reps) {
|
float result = f;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.signum(f);
|
}
|
return result;
|
}
|
|
public double timeSin(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.sin(d);
|
}
|
return result;
|
}
|
|
public double timeSinh(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.sinh(d);
|
}
|
return result;
|
}
|
|
public double timeSqrt(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.sqrt(d);
|
}
|
return result;
|
}
|
|
public double timeTan(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.tan(d);
|
}
|
return result;
|
}
|
|
public double timeTanh(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.tanh(d);
|
}
|
return result;
|
}
|
|
public double timeToDegrees(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.toDegrees(d);
|
}
|
return result;
|
}
|
|
public double timeToRadians(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.toRadians(d);
|
}
|
return result;
|
}
|
|
public double timeUlpD(int reps) {
|
double result = d;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.ulp(d);
|
}
|
return result;
|
}
|
|
public float timeUlpF(int reps) {
|
float result = f;
|
for (int rep = 0; rep < reps; ++rep) {
|
result = Math.ulp(f);
|
}
|
return result;
|
}
|
}
|
