/*
 * 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.renderscript.cts;

import android.util.Log;

public class CoreMathVerifier {
    static {
        System.loadLibrary("coremathtestcpp_jni");
    }

    /* The level of precision we expect out of the half_* functions.  floats (f32) have 23 bits of
     * mantissa and halfs (f16) have 10 bits.  8192 = 2 ^ (23 - 10).
     */
    private static final int HALF_PRECISION = 8192;
    // The level of precision we expect out of the fast_* functions.
    private static final int FAST_PRECISION = 8192;
    // The level of precision we expect out of the native_* functions.
    private static final int NATIVE_PRECISION = 8192;

    // Static classes used to return multiple values from a few JNI functions.
    static public class FrexpResult {
        public float significand;
        public int exponent;
    }

    static public class LgammaResult {
        public float lgamma;
        public int gammaSign;
    }

    static public class RemquoResult {
        public float remainder;
        public int quotient;
    }

    /* We're calling into native:
     * - not all functions are available in Java, notably gamma and erf,
     * - Java lacks float version of these functions, so we can compare implementations with
     *   similar constraints, and
     * - handling unsigned integers, especially longs, is painful and error prone in Java.
     */
    static native float acos(float x);
    static native float acosh(float x);
    static native float asin(float x);
    static native float asinh(float x);
    static native float atan(float x);
    static native float atan2(float x, float y);
    static native float atanh(float x);
    static native float cbrt(float x);
    static native float ceil(float x);
    static native float cos(float x);
    static native float cosh(float x);
    static native float erf(float x);
    static native float erfc(float x);
    static native float exp(float x);
    static native float exp10(float x);
    static native float exp2(float x);
    static native float expm1(float x);
    static native float floor(float x);
    static native FrexpResult frexp(float x);
    static native float hypot(float x, float y);
    static native int ilogb(float x);
    static native float ldexp(float x, int exp);
    static native float lgamma(float x);
    static native LgammaResult lgamma2(float x);
    static native float log(float x);
    static native float logb(float x);
    static native float log10(float x);
    static native float log1p(float x);
    static native float log2(float x);
    static native byte maxI8(byte x, byte y);
    static native byte maxU8(byte x, byte y);
    static native short maxI16(short x, short y);
    static native short maxU16(short x, short y);
    static native int maxI32(int x, int y);
    static native int maxU32(int x, int y);
    static native long maxI64(long x, long y);
    static native long maxU64(long x, long y);
    static native byte minI8(byte x, byte y);
    static native byte minU8(byte x, byte y);
    static native short minI16(short x, short y);
    static native short minU16(short x, short y);
    static native int minI32(int x, int y);
    static native int minU32(int x, int y);
    static native long minI64(long x, long y);
    static native long minU64(long x, long y);
    static native float pow(float x, float y);
    static native RemquoResult remquo(float numerator, float denominator);
    static native float rint(float x);
    static native float round(float x);
    static native float sin(float x);
    static native float sinh(float x);
    static native float sqrt(float x);
    static native float tan(float x);
    static native float tanh(float x);
    static native float tgamma(float x);
    static native float trunc(float x);

    static native byte   convertCharToChar(byte x);
    static native byte   convertCharToUchar(byte x);
    static native short  convertCharToShort(byte x);
    static native short  convertCharToUshort(byte x);
    static native int    convertCharToInt(byte x);
    static native int    convertCharToUint(byte x);
    static native long   convertCharToLong(byte x);
    static native long   convertCharToUlong(byte x);
    static native float  convertCharToFloat(byte x);
    static native double convertCharToDouble(byte x);

    static native byte   convertUcharToChar(byte x);
    static native byte   convertUcharToUchar(byte x);
    static native short  convertUcharToShort(byte x);
    static native short  convertUcharToUshort(byte x);
    static native int    convertUcharToInt(byte x);
    static native int    convertUcharToUint(byte x);
    static native long   convertUcharToLong(byte x);
    static native long   convertUcharToUlong(byte x);
    static native float  convertUcharToFloat(byte x);
    static native double convertUcharToDouble(byte x);

    static native byte   convertShortToChar(short x);
    static native byte   convertShortToUchar(short x);
    static native short  convertShortToShort(short x);
    static native short  convertShortToUshort(short x);
    static native int    convertShortToInt(short x);
    static native int    convertShortToUint(short x);
    static native long   convertShortToLong(short x);
    static native long   convertShortToUlong(short x);
    static native float  convertShortToFloat(short x);
    static native double convertShortToDouble(short x);

    static native byte   convertUshortToChar(short x);
    static native byte   convertUshortToUchar(short x);
    static native short  convertUshortToShort(short x);
    static native short  convertUshortToUshort(short x);
    static native int    convertUshortToInt(short x);
    static native int    convertUshortToUint(short x);
    static native long   convertUshortToLong(short x);
    static native long   convertUshortToUlong(short x);
    static native float  convertUshortToFloat(short x);
    static native double convertUshortToDouble(short x);

    static native byte   convertIntToChar(int x);
    static native byte   convertIntToUchar(int x);
    static native short  convertIntToShort(int x);
    static native short  convertIntToUshort(int x);
    static native int    convertIntToInt(int x);
    static native int    convertIntToUint(int x);
    static native long   convertIntToLong(int x);
    static native long   convertIntToUlong(int x);
    static native float  convertIntToFloat(int x);
    static native double convertIntToDouble(int x);

    static native byte   convertUintToChar(int x);
    static native byte   convertUintToUchar(int x);
    static native short  convertUintToShort(int x);
    static native short  convertUintToUshort(int x);
    static native int    convertUintToInt(int x);
    static native int    convertUintToUint(int x);
    static native long   convertUintToLong(int x);
    static native long   convertUintToUlong(int x);
    static native float  convertUintToFloat(int x);
    static native double convertUintToDouble(int x);

    static native byte   convertLongToChar(long x);
    static native byte   convertLongToUchar(long x);
    static native short  convertLongToShort(long x);
    static native short  convertLongToUshort(long x);
    static native int    convertLongToInt(long x);
    static native int    convertLongToUint(long x);
    static native long   convertLongToLong(long x);
    static native long   convertLongToUlong(long x);
    static native float  convertLongToFloat(long x);
    static native double convertLongToDouble(long x);

    static native byte   convertUlongToChar(long x);
    static native byte   convertUlongToUchar(long x);
    static native short  convertUlongToShort(long x);
    static native short  convertUlongToUshort(long x);
    static native int    convertUlongToInt(long x);
    static native int    convertUlongToUint(long x);
    static native long   convertUlongToLong(long x);
    static native long   convertUlongToUlong(long x);
    static native float  convertUlongToFloat(long x);
    static native double convertUlongToDouble(long x);

    static native byte   convertFloatToChar(float x);
    static native byte   convertFloatToUchar(float x);
    static native short  convertFloatToShort(float x);
    static native short  convertFloatToUshort(float x);
    static native int    convertFloatToInt(float x);
    static native int    convertFloatToUint(float x);
    static native long   convertFloatToLong(float x);
    static native long   convertFloatToUlong(float x);
    static native float  convertFloatToFloat(float x);
    static native double convertFloatToDouble(float x);

    static native byte   convertDoubleToChar(double x);
    static native byte   convertDoubleToUchar(double x);
    static native short  convertDoubleToShort(double x);
    static native short  convertDoubleToUshort(double x);
    static native int    convertDoubleToInt(double x);
    static native int    convertDoubleToUint(double x);
    static native long   convertDoubleToLong(double x);
    static native long   convertDoubleToUlong(double x);
    static native float  convertDoubleToFloat(double x);
    static native double convertDoubleToDouble(double x);

    static private Target.Floaty pi32(Target t) {
        return t.new32((float) Math.PI);
    }

    static private Target.Floaty any32(Target t) {
        return t.new32(Float.NEGATIVE_INFINITY, Float.NaN, Float.POSITIVE_INFINITY);
    }

    static private Target.Floaty acos(float f, Target t) {
        Target.Floaty in = t.new32(f);
        return t.new32(
            acos(in.mid32()),
            acos(in.min32()),
            acos(in.max32()));
    }

    static private Target.Floaty acosh(float f, Target t) {
        Target.Floaty in = t.new32(f);
        return t.new32(
            acosh(in.mid32()),
            acosh(in.min32()),
            acosh(in.max32()));
    }

    static private Target.Floaty acospi(float f, Target t) {
        return t.divide(acos(f, t), pi32(t));
    }

    static private Target.Floaty asin(float f, Target t) {
        Target.Floaty in = t.new32(f);
        return t.new32(
            asin(in.mid32()),
            asin(in.min32()),
            asin(in.max32()));
    }

    static private Target.Floaty asinh(float f, Target t) {
        Target.Floaty in = t.new32(f);
        return t.new32(
            asinh(in.mid32()),
            asinh(in.min32()),
            asinh(in.max32()));
    }

    static private Target.Floaty asinpi(float f, Target t) {
        return t.divide(asin(f, t), pi32(t));
    }

    static private Target.Floaty atan(float f, Target t) {
        Target.Floaty in = t.new32(f);
        return t.new32(
            atan(in.mid32()),
            atan(in.min32()),
            atan(in.max32()));
    }

    static private Target.Floaty atanh(float f, Target t) {
        Target.Floaty in = t.new32(f);
        return t.new32(
            atanh(in.mid32()),
            atanh(in.min32()),
            atanh(in.max32()));
    }

    static private Target.Floaty atanpi(float f, Target t) {
        return t.divide(atan(f, t), pi32(t));
    }

    static private Target.Floaty atan2(float y, float x, Target t) {
        Target.Floaty numerator = t.new32(y);
        Target.Floaty denominator = t.new32(x);
        return t.new32(
            atan2(numerator.mid32(), denominator.mid32()),
            atan2(numerator.min32(), denominator.min32()),
            atan2(numerator.min32(), denominator.max32()),
            atan2(numerator.max32(), denominator.min32()),
            atan2(numerator.max32(), denominator.max32()));
    }

    static private Target.Floaty atan2pi(float y, float x, Target t) {
        return t.divide(atan2(y, x, t), pi32(t));
    }

    static private Target.Floaty cbrt(float f, Target t) {
        Target.Floaty in = t.new32(f);
        return t.new32(
            cbrt(in.mid32()),
            cbrt(in.min32()),
            cbrt(in.max32()));
    }

    static private Target.Floaty cos(float f, Target t) {
        Target.Floaty in = t.new32(f);
        return t.new32(
            cos(in.mid32()),
            cos(in.min32()),
            cos(in.max32()));
    }

    static private Target.Floaty cosh(float f, Target t) {
        Target.Floaty in = t.new32(f);
        return t.new32(
            cosh(in.mid32()),
            cosh(in.min32()),
            cosh(in.max32()));
    }

    static private Target.Floaty cospi(float f, Target t) {
        Target.Floaty in = t.multiply(t.new32(f), pi32(t));
        return t.new32(
            cos(in.mid32()),
            cos(in.min32()),
            cos(in.max32()));
    }

    // Computes the cross product of two 3D vectors.
    static private void cross(float[] v1, float[] v2, Target.Floaty[] out, Target t) {
        Target.Floaty a12 = t.multiply(t.new32(v1[1]), t.new32(v2[2]));
        Target.Floaty a21 = t.multiply(t.new32(v1[2]), t.new32(v2[1]));
        out[0] = t.subtract(a12, a21);
        Target.Floaty a02 = t.multiply(t.new32(v1[0]), t.new32(v2[2]));
        Target.Floaty a20 = t.multiply(t.new32(v1[2]), t.new32(v2[0]));
        out[1] = t.subtract(a20, a02);
        Target.Floaty a01 = t.multiply(t.new32(v1[0]), t.new32(v2[1]));
        Target.Floaty a10 = t.multiply(t.new32(v1[1]), t.new32(v2[0]));
        out[2] = t.subtract(a01, a10);
        if (out.length == 4) {
            out[3] = t.new32(0.f);
        }
    }

    // Returns the distance between two points in n-dimensional space.
    static private Target.Floaty distance(float[] point1, float[] point2, Target t) {
        Target.Floaty sum = t.new32(0.f);
        for (int i = 0; i < point1.length; i++) {
            Target.Floaty diff = t.subtract(t.new32(point1[i]), t.new32(point2[i]));
            sum = t.add(sum, t.multiply(diff, diff));
        }
        Target.Floaty d = t.sqrt(sum);
        return d;
    }

    static private Target.Floaty exp(float f, Target t) {
        Target.Floaty in = t.new32(f);
        return t.new32(
            exp(in.mid32()),
            exp(in.min32()),
            exp(in.max32()));
    }

    static private Target.Floaty exp10(float f, Target t) {
        Target.Floaty in = t.new32(f);
        return t.new32(
            exp10(in.mid32()),
            exp10(in.min32()),
            exp10(in.max32()));
    }

    static private Target.Floaty exp2(float f, Target t) {
        Target.Floaty in = t.new32(f);
        return t.new32(
            exp2(in.mid32()),
            exp2(in.min32()),
            exp2(in.max32()));
    }

    static private Target.Floaty expm1(float f, Target t) {
        Target.Floaty in = t.new32(f);
        return t.new32(
            expm1(in.mid32()),
            expm1(in.min32()),
            expm1(in.max32()));
    }

    static private Target.Floaty hypot(float x, float y, Target t) {
        Target.Floaty inX = t.new32(x);
        Target.Floaty inY = t.new32(y);
        return t.new32(
            hypot(inX.mid32(), inY.mid32()),
            hypot(inX.min32(), inY.min32()),
            hypot(inX.min32(), inY.max32()),
            hypot(inX.max32(), inY.min32()),
            hypot(inX.max32(), inY.max32()));
    }

    // Returns the length of the n-dimensional vector.
    static private Target.Floaty length(float[] array, Target t) {
        Target.Floaty sum = t.new32(0.f);
        for (int i = 0; i < array.length; i++) {
            Target.Floaty f = t.new32(array[i]);
            sum = t.add(sum, t.multiply(f, f));
        }
        Target.Floaty l = t.sqrt(sum);
        return l;
    }

    static private Target.Floaty log(float f, Target t) {
        Target.Floaty in = t.new32(f);
        return t.new32(
            log(in.mid32()),
            log(in.min32()),
            log(in.max32()));
    }

    static private Target.Floaty log10(float f, Target t) {
        Target.Floaty in = t.new32(f);
        return t.new32(
            log10(in.mid32()),
            log10(in.min32()),
            log10(in.max32()));
    }

    static private Target.Floaty log1p(float f, Target t) {
        Target.Floaty in = t.new32(f);
        return t.new32(
            log1p(in.mid32()),
            log1p(in.min32()),
            log1p(in.max32()));
    }

    static private Target.Floaty log2(float f, Target t) {
        Target.Floaty in = t.new32(f);
        return t.new32(
            log2(in.mid32()),
            log2(in.min32()),
            log2(in.max32()));
    }

    // Normalizes the n-dimensional vector, i.e. makes it length 1.
    static private void normalize(float[] in, Target.Floaty[] out, Target t) {
        Target.Floaty l = length(in, t);
        boolean isZero = l.get32() == 0.f;
        for (int i = 0; i < in.length; i++) {
            out[i] = t.new32(in[i]);
            if (!isZero) {
                out[i] = t.divide(out[i], l);
            }
        }
    }

    static private Target.Floaty powr(float x, float y, Target t) {
        Target.Floaty base = t.new32(x);
        Target.Floaty exponent = t.new32(y);
        return t.new32(
            pow(base.mid32(), exponent.mid32()),
            pow(base.min32(), exponent.min32()),
            pow(base.min32(), exponent.max32()),
            pow(base.max32(), exponent.min32()),
            pow(base.max32(), exponent.max32()));
    }

    static private Target.Floaty recip(float f, Target t) {
        Target.Floaty in = t.new32(f);
        return t.divide(t.new32(1.f), in);
    }

    static private Target.Floaty rootn(float inV, int inN, Target t) {
        /* Rootn of a negative number should be possible only if the number
         * is odd.  In cases where the int is very large, our approach will
         * lose whether the int is odd, and we'll get a NaN for weird cases
         * like rootn(-3.95, 818181881), which should return 1.  We handle the
         * case by handling the sign ourselves.  We use copysign to handle the
         * negative zero case.
         */
        float value;
        if ((inN & 0x1) == 0x1) {
            value = Math.copySign(pow(Math.abs(inV), 1.f / inN),
                    inV);
        } else {
            value = pow(inV, 1.f / inN);
        }
        if (inN == 0) {
            return t.new32(value, Float.NaN);
        } else {
            return t.new32(value);
        }
    }

    static private Target.Floaty rsqrt(float f, Target t) {
        Target.Floaty in = t.new32(f);
        return t.divide(t.new32(1.f), t.sqrt(in));
    }

    static private Target.Floaty sin(float f, Target t) {
        Target.Floaty in = t.new32(f);
        return t.new32(
            sin(in.mid32()),
            sin(in.min32()),
            sin(in.max32()));
    }

    static private Target.Floaty sinh(float f, Target t) {
        Target.Floaty in = t.new32(f);
        return t.new32(
            sinh(in.mid32()),
            sinh(in.min32()),
            sinh(in.max32()));
    }

    static private Target.Floaty sinpi(float f, Target t) {
        Target.Floaty in = t.multiply(t.new32(f), pi32(t));
        return t.new32(
            sin(in.mid32()),
            sin(in.min32()),
            sin(in.max32()));
    }

    static private Target.Floaty sqrt(float f, Target t) {
        Target.Floaty in = t.new32(f);
        return t.sqrt(in);
    }

    static private Target.Floaty tan(float f, Target t) {
        Target.Floaty in = t.new32(f);
        float min = tan(in.min32());
        float max = tan(in.max32());
        /* If the tan of the min is greater than that of the max,
         * we spanned a discontinuity.
         */
        if (min > max) {
            return any32(t);
        } else {
            return t.new32(tan(f), min, max);
        }
    }

    static private Target.Floaty tanh(float f, Target t) {
        Target.Floaty in = t.new32(f);
        return t.new32(
            tanh(in.mid32()),
            tanh(in.min32()),
            tanh(in.max32()));
    }

    static private Target.Floaty tanpi(float f, Target t) {
        Target.Floaty in = t.multiply(t.new32(f), pi32(t));
        float min = tan(in.min32());
        float max = tan(in.max32());
        /* If the tan of the min is greater than that of the max,
         * we spanned a discontinuity.
         */
        if (min > max) {
            return any32(t);
        } else {
            return t.new32(tan(in.mid32()), min, max);
        }
    }

    static public void computeAbs(TestAbs.ArgumentsCharUchar args) {
        args.out = (byte)Math.abs(args.inV);
    }

    static public void computeAbs(TestAbs.ArgumentsShortUshort args) {
        args.out = (short)Math.abs(args.inV);
    }

    static public void computeAbs(TestAbs.ArgumentsIntUint args) {
        args.out = Math.abs(args.inV);
    }

    static public void computeAcos(TestAcos.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(4, 128, false);
        args.out = acos(args.inV, t);
    }

    static public void computeAcosh(TestAcosh.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(4, 128, false);
        args.out = acosh(args.inV, t);
    }

    static public void computeAcospi(TestAcospi.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(5, 128, false);
        args.out = acospi(args.inV, t);
    }

    static public void computeAsin(TestAsin.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(4, 128, false);
        args.out = asin(args.inV, t);
    }

    static public void computeAsinh(TestAsinh.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(4, 128, false);
        args.out = asinh(args.inV, t);
    }

    static public void computeAsinpi(TestAsinpi.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(5, 128, false);
        args.out = asinpi(args.inV, t);
    }

    static public void computeAtan(TestAtan.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(5, 128, false);
        args.out = atan(args.inV, t);
    }

    static public void computeAtanh(TestAtanh.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(5, 128, false);
        args.out = atanh(args.inV, t);
    }

    static public void computeAtanpi(TestAtanpi.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(5, 128, false);
        args.out = atanpi(args.inV, t);
    }

    static public void computeAtan2(TestAtan2.ArgumentsFloatFloatFloat args, Target t) {
        t.setPrecision(6, 128, false);
        args.out = atan2(args.inNumerator, args.inDenominator, t);
    }

    static public void computeAtan2pi(TestAtan2pi.ArgumentsFloatFloatFloat args, Target t) {
        t.setPrecision(6, 128, false);
        args.out = atan2pi(args.inNumerator, args.inDenominator, t);
    }

    static public void computeCbrt(TestCbrt.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(2, 128, false);
        args.out = cbrt(args.inV, t);
    }

    static public void computeCeil(TestCeil.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(0, 1, false);
        Target.Floaty in = t.new32(args.inV);
        args.out = t.new32(
            ceil(in.mid32()),
            ceil(in.min32()),
            ceil(in.max32()));
    }

    static public void computeClamp(TestClamp.ArgumentsCharCharCharChar args) {
        args.out = minI8(args.inMaxValue, maxI8(args.inValue, args.inMinValue));
    }

    static public void computeClamp(TestClamp.ArgumentsUcharUcharUcharUchar args) {
        args.out = minU8(args.inMaxValue, maxU8(args.inValue, args.inMinValue));
    }

    static public void computeClamp(TestClamp.ArgumentsShortShortShortShort args) {
        args.out = minI16(args.inMaxValue, maxI16(args.inValue, args.inMinValue));
    }

    static public void computeClamp(TestClamp.ArgumentsUshortUshortUshortUshort args) {
        args.out = minU16(args.inMaxValue, maxU16(args.inValue, args.inMinValue));
    }

    static public void computeClamp(TestClamp.ArgumentsIntIntIntInt args) {
        args.out = minI32(args.inMaxValue, maxI32(args.inValue, args.inMinValue));
    }

    static public void computeClamp(TestClamp.ArgumentsUintUintUintUint args) {
        args.out = minU32(args.inMaxValue, maxU32(args.inValue, args.inMinValue));
    }

    static public void computeClamp(TestClamp.ArgumentsFloatFloatFloatFloat args, Target t) {
        t.setPrecision(0, 0, false);
        args.out = t.new32(Math.min(args.inMaxValue,
                        Math.max(args.inValue, args.inMinValue)));
    }

    static public void computeClamp(TestClamp.ArgumentsLongLongLongLong args) {
        args.out = minI64(args.inMaxValue, maxI64(args.inValue, args.inMinValue));
    }

    static public void computeClamp(TestClamp.ArgumentsUlongUlongUlongUlong args) {
        args.out = minU64(args.inMaxValue, maxU64(args.inValue, args.inMinValue));
    }

    static public void computeClz(TestClz.ArgumentsCharChar args) {
        int x = args.inValue;
        args.out = (byte) (Integer.numberOfLeadingZeros(x & 0xff) - 24);
    }

    static public void computeClz(TestClz.ArgumentsUcharUchar args) {
        int x = args.inValue;
        args.out = (byte) (Integer.numberOfLeadingZeros(x & 0xff) - 24);
    }

    static public void computeClz(TestClz.ArgumentsShortShort args) {
        args.out = (short) (Integer.numberOfLeadingZeros(args.inValue & 0xffff) - 16);
    }

    static public void computeClz(TestClz.ArgumentsUshortUshort args) {
        args.out = (short) (Integer.numberOfLeadingZeros(args.inValue & 0xffff) - 16);
    }

    static public void computeClz(TestClz.ArgumentsIntInt args) {
        args.out = (int) Integer.numberOfLeadingZeros(args.inValue);
    }

    static public void computeClz(TestClz.ArgumentsUintUint args) {
        args.out = (int) Integer.numberOfLeadingZeros(args.inValue);
    }


    static public void computeConvert(TestConvert.ArgumentsCharChar args) {
        args.out = convertCharToChar(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsCharUchar args) {
        args.out = convertCharToUchar(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsCharShort args) {
        args.out = convertCharToShort(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsCharUshort args) {
        args.out = convertCharToUshort(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsCharInt args) {
        args.out = convertCharToInt(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsCharUint args) {
        args.out = convertCharToUint(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsCharLong args) {
        args.out = convertCharToLong(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsCharUlong args) {
        args.out = convertCharToUlong(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsCharFloat args, Target t) {
        t.setPrecision(0, 0, false);
        args.out = t.new32(convertCharToFloat(args.inV));
    }
    static public void computeConvert(TestConvert.ArgumentsCharDouble args, Target t) {
        t.setPrecision(0, 0, false);
        args.out = t.new64(convertCharToDouble(args.inV));
    }

    static public void computeConvert(TestConvert.ArgumentsUcharChar args) {
        args.out = convertUcharToChar(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUcharUchar args) {
        args.out = convertUcharToUchar(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUcharShort args) {
        args.out = convertUcharToShort(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUcharUshort args) {
        args.out = convertUcharToUshort(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUcharInt args) {
        args.out = convertUcharToInt(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUcharUint args) {
        args.out = convertUcharToUint(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUcharLong args) {
        args.out = convertUcharToLong(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUcharUlong args) {
        args.out = convertUcharToUlong(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUcharFloat args, Target t) {
        t.setPrecision(0, 0, false);
        args.out = t.new32(convertUcharToFloat(args.inV));
    }
    static public void computeConvert(TestConvert.ArgumentsUcharDouble args, Target t) {
        t.setPrecision(0, 0, false);
        args.out = t.new64(convertUcharToDouble(args.inV));
    }

    static public void computeConvert(TestConvert.ArgumentsShortChar args) {
        args.out = convertShortToChar(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsShortUchar args) {
        args.out = convertShortToUchar(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsShortShort args) {
        args.out = convertShortToShort(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsShortUshort args) {
        args.out = convertShortToUshort(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsShortInt args) {
        args.out = convertShortToInt(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsShortUint args) {
        args.out = convertShortToUint(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsShortLong args) {
        args.out = convertShortToLong(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsShortUlong args) {
        args.out = convertShortToUlong(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsShortFloat args, Target t) {
        t.setPrecision(0, 0, false);
        args.out = t.new32(convertShortToFloat(args.inV));
    }
    static public void computeConvert(TestConvert.ArgumentsShortDouble args, Target t) {
        t.setPrecision(0, 0, false);
        args.out = t.new64(convertShortToDouble(args.inV));
    }

    static public void computeConvert(TestConvert.ArgumentsUshortChar args) {
        args.out = convertUshortToChar(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUshortUchar args) {
        args.out = convertUshortToUchar(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUshortShort args) {
        args.out = convertUshortToShort(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUshortUshort args) {
        args.out = convertUshortToUshort(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUshortInt args) {
        args.out = convertUshortToInt(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUshortUint args) {
        args.out = convertUshortToUint(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUshortLong args) {
        args.out = convertUshortToLong(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUshortUlong args) {
        args.out = convertUshortToUlong(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUshortFloat args, Target t) {
        t.setPrecision(0, 0, false);
        args.out = t.new32(convertUshortToFloat(args.inV));
    }
    static public void computeConvert(TestConvert.ArgumentsUshortDouble args, Target t) {
        t.setPrecision(0, 0, false);
        args.out = t.new64(convertUshortToDouble(args.inV));
    }

    static public void computeConvert(TestConvert.ArgumentsIntChar args) {
        args.out = convertIntToChar(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsIntUchar args) {
        args.out = convertIntToUchar(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsIntShort args) {
        args.out = convertIntToShort(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsIntUshort args) {
        args.out = convertIntToUshort(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsIntInt args) {
        args.out = convertIntToInt(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsIntUint args) {
        args.out = convertIntToUint(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsIntLong args) {
        args.out = convertIntToLong(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsIntUlong args) {
        args.out = convertIntToUlong(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsIntFloat args, Target t) {
        t.setPrecision(1, 1, false);
        args.out = t.new32(convertIntToFloat(args.inV));
    }
    static public void computeConvert(TestConvert.ArgumentsIntDouble args, Target t) {
        t.setPrecision(0, 0, false);
        args.out = t.new64(convertIntToDouble(args.inV));
    }

    static public void computeConvert(TestConvert.ArgumentsUintChar args) {
        args.out = convertUintToChar(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUintUchar args) {
        args.out = convertUintToUchar(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUintShort args) {
        args.out = convertUintToShort(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUintUshort args) {
        args.out = convertUintToUshort(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUintInt args) {
        args.out = convertUintToInt(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUintUint args) {
        args.out = convertUintToUint(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUintLong args) {
        args.out = convertUintToLong(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUintUlong args) {
        args.out = convertUintToUlong(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUintFloat args, Target t) {
        t.setPrecision(1, 1, false);
        args.out = t.new32(convertUintToFloat(args.inV));
    }
    static public void computeConvert(TestConvert.ArgumentsUintDouble args, Target t) {
        t.setPrecision(0, 0, false);
        args.out = t.new64(convertUintToDouble(args.inV));
    }

    static public void computeConvert(TestConvert.ArgumentsLongChar args) {
        args.out = convertLongToChar(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsLongUchar args) {
        args.out = convertLongToUchar(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsLongShort args) {
        args.out = convertLongToShort(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsLongUshort args) {
        args.out = convertLongToUshort(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsLongInt args) {
        args.out = convertLongToInt(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsLongUint args) {
        args.out = convertLongToUint(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsLongLong args) {
        args.out = convertLongToLong(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsLongUlong args) {
        args.out = convertLongToUlong(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsLongFloat args, Target t) {
        t.setPrecision(1, 1, false);
        args.out = t.new32(convertLongToFloat(args.inV));
    }
    static public void computeConvert(TestConvert.ArgumentsLongDouble args, Target t) {
        t.setPrecision(1, 1, false);
        args.out = t.new64(convertLongToDouble(args.inV));
    }

    static public void computeConvert(TestConvert.ArgumentsUlongChar args) {
        args.out = convertUlongToChar(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUlongUchar args) {
        args.out = convertUlongToUchar(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUlongShort args) {
        args.out = convertUlongToShort(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUlongUshort args) {
        args.out = convertUlongToUshort(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUlongInt args) {
        args.out = convertUlongToInt(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUlongUint args) {
        args.out = convertUlongToUint(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUlongLong args) {
        args.out = convertUlongToLong(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUlongUlong args) {
        args.out = convertUlongToUlong(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsUlongFloat args, Target t) {
        t.setPrecision(1, 1, false);
        args.out = t.new32(convertUlongToFloat(args.inV));
    }
    static public void computeConvert(TestConvert.ArgumentsUlongDouble args, Target t) {
        t.setPrecision(1, 1, false);
        args.out = t.new64(convertUlongToDouble(args.inV));
    }

    static public void computeConvert(TestConvert.ArgumentsFloatChar args) {
        args.out = convertFloatToChar(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsFloatUchar args) {
        args.out = convertFloatToUchar(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsFloatShort args) {
        args.out = convertFloatToShort(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsFloatUshort args) {
        args.out = convertFloatToUshort(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsFloatInt args) {
        args.out = convertFloatToInt(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsFloatUint args) {
        args.out = convertFloatToUint(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsFloatLong args) {
        args.out = convertFloatToLong(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsFloatUlong args) {
        args.out = convertFloatToUlong(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(0, 0, false);
        args.out = t.new32(convertFloatToFloat(args.inV));
    }
    static public void computeConvert(TestConvert.ArgumentsFloatDouble args, Target t) {
        t.setPrecision(0, 0, false);
        args.out = t.new64(convertFloatToDouble(args.inV));
    }

    static public void computeConvert(TestConvert.ArgumentsDoubleChar args) {
        args.out = convertDoubleToChar(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsDoubleUchar args) {
        args.out = convertDoubleToUchar(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsDoubleShort args) {
        args.out = convertDoubleToShort(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsDoubleUshort args) {
        args.out = convertDoubleToUshort(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsDoubleInt args) {
        args.out = convertDoubleToInt(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsDoubleUint args) {
        args.out = convertDoubleToUint(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsDoubleLong args) {
        args.out = convertDoubleToLong(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsDoubleUlong args) {
        args.out = convertDoubleToUlong(args.inV);
    }
    static public void computeConvert(TestConvert.ArgumentsDoubleFloat args, Target t) {
        t.setPrecision(1, 1, false);
        args.out = t.new32(convertDoubleToFloat(args.inV));
    }
    static public void computeConvert(TestConvert.ArgumentsDoubleDouble args, Target t) {
        t.setPrecision(0, 0, false);
        args.out = t.new64(convertDoubleToDouble(args.inV));
    }

    static public void computeCopysign(TestCopysign.ArgumentsFloatFloatFloat args, Target t) {
        t.setPrecision(0, 0, false);
        args.out = t.new32(Math.copySign(args.inMagnitudeValue, args.inSignValue));
    }

    static public void computeCos(TestCos.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(4, 128, false);
        args.out = cos(args.inV, t);
    }

    static public void computeCosh(TestCosh.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(4, 128, false);
        args.out = cosh(args.inV, t);
    }

    static public void computeCospi(TestCospi.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(4, 128, false);
        args.out = cospi(args.inV, t);
    }

    static public void computeCross(TestCross.ArgumentsFloatNFloatNFloatN args, Target t) {
        t.setPrecision(1, 4, false);
        cross(args.inLeftVector, args.inRightVector, args.out, t);
    }

    static public void computeDegrees(TestDegrees.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(3, 3, false);
        Target.Floaty in = t.new32(args.inV);
        Target.Floaty k = t.new32((float)(180.0 / Math.PI));
        args.out = t.multiply(in, k);
    }

    static public void computeDistance(TestDistance.ArgumentsFloatFloatFloat args, Target t) {
        t.setPrecision(1, 1, false);
        args.out = distance(new float[] {args.inLeftVector}, new float[] {args.inRightVector}, t);
    }

    static public void computeDistance(TestDistance.ArgumentsFloatNFloatNFloat args, Target t) {
        t.setPrecision(1, 1, false);
        args.out = distance(args.inLeftVector, args.inRightVector, t);
    }

    static public void computeDot(TestDot.ArgumentsFloatFloatFloat args, Target t) {
        t.setPrecision(1, 4, false);
        Target.Floaty a = t.new32(args.inLeftVector);
        Target.Floaty b = t.new32(args.inRightVector);
        args.out = t.multiply(a, b);
    }

    static public void computeDot(TestDot.ArgumentsFloatNFloatNFloat args, Target t) {
        t.setPrecision(1, 4, false);
        Target.Floaty sum = t.new32(0.f);
        for (int i = 0; i < args.inLeftVector.length; i++) {
            Target.Floaty a = t.new32(args.inLeftVector[i]);
            Target.Floaty b = t.new32(args.inRightVector[i]);
            sum = t.add(sum, t.multiply(a, b));
        }
        args.out = sum;
    }

    static public void computeErf(TestErf.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(16, 128, false);
        Target.Floaty in = t.new32(args.inV);
        args.out = t.new32(
            erf(args.inV),
            erf(in.min32()),
            erf(in.max32()));
    }

    static public void computeErfc(TestErfc.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(16, 128, false);
        Target.Floaty in = t.new32(args.inV);
        args.out = t.new32(
            erfc(args.inV),
            erfc(in.min32()),
            erfc(in.max32()));
    }

    static public void computeExp(TestExp.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(3, 16, false);
        args.out = exp(args.inV, t);
    }

    static public void computeExp10(TestExp10.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(3, 32, false);
        args.out = exp10(args.inV, t);
    }

    static public void computeExp2(TestExp2.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(3, 16, false);
        args.out = exp2(args.inV, t);
    }

    static public void computeExpm1(TestExpm1.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(3, 16, false);
        args.out = expm1(args.inV, t);
    }

    static public void computeFabs(TestFabs.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(0, 0, false);
        Target.Floaty in = t.new32(args.inV);
        args.out = t.new32(
            Math.abs(args.inV),
            Math.abs(in.min32()),
            Math.abs(in.max32()));
    }

    static public void computeFastDistance(TestFastDistance.ArgumentsFloatFloatFloat args, Target t) {
        t.setPrecision(FAST_PRECISION, FAST_PRECISION, false);
        args.out = distance(new float[] {args.inLeftVector}, new float[] {args.inRightVector}, t);
    }

    static public void computeFastDistance(TestFastDistance.ArgumentsFloatNFloatNFloat args, Target t) {
        t.setPrecision(FAST_PRECISION, FAST_PRECISION, false);
        args.out = distance(args.inLeftVector, args.inRightVector, t);
    }

    static public void computeFastLength(TestFastLength.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(FAST_PRECISION, FAST_PRECISION, false);
        args.out = length(new float[] {args.inV}, t);
    }

    static public void computeFastLength(TestFastLength.ArgumentsFloatNFloat args, Target t) {
        t.setPrecision(FAST_PRECISION, FAST_PRECISION, false);
        args.out = length(args.inV, t);
    }

    static public void computeFastNormalize(TestFastNormalize.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(FAST_PRECISION, FAST_PRECISION, false);
        Target.Floaty[] out = new Target.Floaty[1];
        normalize(new float[] {args.inV}, out, t);
        args.out = out[0];
    }

    static public void computeFastNormalize(TestFastNormalize.ArgumentsFloatNFloatN args, Target t) {
        t.setPrecision(FAST_PRECISION, FAST_PRECISION, false);
        normalize(args.inV, args.out, t);
    }

    static public void computeFdim(TestFdim.ArgumentsFloatFloatFloat args, Target t) {
        t.setPrecision(1, 1, false);
        Target.Floaty inA = t.new32(args.inA);
        Target.Floaty inB = t.new32(args.inB);
        Target.Floaty r = t.subtract(inA, inB);
        args.out = t.new32(
            Math.max(0.f, r.mid32()),
            Math.max(0.f, r.min32()),
            Math.max(0.f, r.max32()));
    }

    static public void computeFloor(TestFloor.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(0, 0, false);
        Target.Floaty in = t.new32(args.inV);
        args.out = t.new32(
            floor(args.inV),
            floor(in.min32()),
            floor(in.max32()));
    }

    static public void computeFma(TestFma.ArgumentsFloatFloatFloatFloat args, Target t) {
        t.setPrecision(1, 1, false);
        Target.Floaty ab = t.multiply(t.new32(args.inMultiplicand1), t.new32(args.inMultiplicand2));
        args.out = t.add(ab, t.new32(args.inOffset));
    }

    static public void computeFmax(TestFmax.ArgumentsFloatFloatFloat args, Target t) {
        t.setPrecision(0, 0, false);
        Target.Floaty a = t.new32(args.inA);
        Target.Floaty b = t.new32(args.inB);
        args.out = t.new32(
            Math.max(args.inA, args.inB),
            Math.max(a.min32(), b.min32()),
            Math.max(a.min32(), b.max32()),
            Math.max(a.max32(), b.min32()),
            Math.max(a.max32(), b.max32()));
    }

    static public void computeFmin(TestFmin.ArgumentsFloatFloatFloat args, Target t) {
        t.setPrecision(0, 0, false);
        Target.Floaty a = t.new32(args.inA);
        Target.Floaty b = t.new32(args.inB);
        args.out = t.new32(
            Math.min(args.inA, args.inB),
            Math.min(a.min32(), b.min32()),
            Math.min(a.min32(), b.max32()),
            Math.min(a.max32(), b.min32()),
            Math.min(a.max32(), b.max32()));
    }

    static public void computeFmod(TestFmod.ArgumentsFloatFloatFloat args, Target t) {
        t.setPrecision(1, 1, false);
        Target.Floaty numerator = t.new32(args.inNumerator);
        Target.Floaty denominator = t.new32(args.inDenominator);
        args.out = t.new32(
            args.inNumerator % args.inDenominator,
            numerator.min32() % denominator.min32(),
            numerator.min32() % denominator.max32(),
            numerator.max32() % denominator.min32(),
            numerator.max32() % denominator.max32());
    }

    static public void computeFract(TestFract.ArgumentsFloatFloatFloat args, Target t) {
        t.setPrecision(1, 1, false);
        float floor = floor(args.inV);
        args.outFloor = t.new32(floor);
        // 0x1.fffffep-1f is 0.999999...
        args.out = t.new32(Math.min(args.inV - floor, 0x1.fffffep-1f));
    }

    static public void computeFract(TestFract.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(1, 1, false);
        float floor = floor(args.inV);
        // 0x1.fffffep-1f is 0.999999...
        args.out = t.new32(Math.min(args.inV - floor, 0x1.fffffep-1f));
    }

    static public void computeFrexp(TestFrexp.ArgumentsFloatIntFloat args, Target t) {
        t.setPrecision(0, 0, false);
        FrexpResult result = frexp(args.inV);
        args.out = t.new32(result.significand);
        args.outExponent = result.exponent;
    }

    static public void computeHalfRecip(TestHalfRecip.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(HALF_PRECISION, HALF_PRECISION, false);
        args.out = recip(args.inV, t);
    }

    static public void computeHalfRsqrt(TestHalfRsqrt.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(HALF_PRECISION, HALF_PRECISION, false);
        args.out = rsqrt(args.inV, t);
    }

    static public void computeHalfSqrt(TestHalfSqrt.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(HALF_PRECISION, HALF_PRECISION, false);
        args.out = sqrt(args.inV, t);
    }

    static public void computeHypot(TestHypot.ArgumentsFloatFloatFloat args, Target t) {
        t.setPrecision(4, 4, false);
        args.out = hypot(args.inA, args.inB, t);
    }

    static public String verifyIlogb(TestIlogb.ArgumentsFloatInt args) {
        // Special case when the input is 0.  We accept two different answers.
        if (args.inV == 0.f) {
            if (args.out != -Integer.MAX_VALUE && args.out != Integer.MIN_VALUE) {
                return "Expected " + Integer.toString(-Integer.MAX_VALUE) + " or " +
                    Integer.toString(Integer.MIN_VALUE);
            }
        } else {
            int result = ilogb(args.inV);
            if (args.out != result) {
                return "Expected " + Integer.toString(result);
            }
        }
        return null;
    }

    static public void computeLdexp(TestLdexp.ArgumentsFloatIntFloat args, Target t) {
        t.setPrecision(1, 1, false);
        Target.Floaty inMantissa = t.new32(args.inMantissa);
        args.out = t.new32(
            ldexp(inMantissa.mid32(), args.inExponent),
            ldexp(inMantissa.min32(), args.inExponent),
            ldexp(inMantissa.max32(), args.inExponent));
    }

    static public void computeLength(TestLength.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(1, 1, false);
        args.out = length(new float[]{args.inV}, t);
    }

    static public void computeLength(TestLength.ArgumentsFloatNFloat args, Target t) {
        t.setPrecision(1, 1, false);
        args.out = length(args.inV, t);
    }

    static public void computeLgamma(TestLgamma.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(16, 128, false);
        Target.Floaty in = t.new32(args.inV);
        args.out = t.new32(
            lgamma(in.mid32()),
            lgamma(in.min32()),
            lgamma(in.max32()));
    }

    /* TODO Until -0 handling is corrected in bionic & associated drivers, we temporarily
     * disable the verification of -0.  We do this with a custom verifier.  Once bionic
     * is fixed, we can restore computeLgamma and remove verifyLgamma.
    static public void computeLgamma(TestLgamma.ArgumentsFloatIntFloat args, Target t) {
        t.setPrecision(16, 128, false);
        Target.Floaty in = t.new32(args.inV);
        LgammaResult result = lgamma2(in.mid32());
        LgammaResult resultMin = lgamma2(in.min32());
        LgammaResult resultMax = lgamma2(in.max32());
        args.out = t.new32(result.lgamma, resultMin.lgamma, resultMax.lgamma);
        args.outY = result.gammaSign;
    }
    */
    static public String verifyLgamma(TestLgamma.ArgumentsFloatIntFloat args, Target t) {
        t.setPrecision(16, 128, false);
        Target.Floaty in = t.new32(args.inV);
        LgammaResult result = lgamma2(in.mid32());
        LgammaResult resultMin = lgamma2(in.min32());
        LgammaResult resultMax = lgamma2(in.max32());
        Target.Floaty expectedOut = t.new32(result.lgamma, resultMin.lgamma, resultMax.lgamma);
        boolean isNegativeZero = args.inV == 0.f && 1.f / args.inV < 0.f;
        /* TODO The current implementation of bionic does not handle the -0.f case correctly.
         * It should set the sign to -1 but sets it to 1.
         */
        if (!expectedOut.couldBe(args.out) ||
            (args.outSignOfGamma != result.gammaSign && !isNegativeZero)) {
            StringBuilder message = new StringBuilder();
            message.append(String.format("Input in %14.8g {%8x}:\n", args.inV, Float.floatToRawIntBits(args.inV)));
            message.append("Expected out: ");
            message.append(expectedOut.toString());
            message.append("\n");
            message.append(String.format("Actual   out: %14.8g {%8x}", args.out, Float.floatToRawIntBits(args.out)));
            message.append(String.format("Expected outSign: %d\n", result.gammaSign));
            message.append(String.format("Actual   outSign: %d\n", args.outSignOfGamma));
            return message.toString();
        }

        return null;
    }

    // TODO The relaxed ulf for the various log are taken from the old tests.
    // They are not consistent.
    static public void computeLog(TestLog.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(3, 16, false);
        args.out = log(args.inV, t);
    }

    static public void computeLog10(TestLog10.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(3, 16, false);
        args.out = log10(args.inV, t);
    }

    static public void computeLog1p(TestLog1p.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(2, 16, false);
        args.out = log1p(args.inV, t);
    }

    static public void computeLog2(TestLog2.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(3, 128, false);
        args.out = log2(args.inV, t);
    }

    static public void computeLogb(TestLogb.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(0, 0, false);
        Target.Floaty in = t.new32(args.inV);
        args.out = t.new32(
            logb(in.mid32()),
            logb(in.min32()),
            logb(in.max32()));
    }

    static public void computeMad(TestMad.ArgumentsFloatFloatFloatFloat args, Target t) {
        t.setPrecision(1, 4, false);
        Target.Floaty ab = t.multiply(t.new32(args.inMultiplicand1), t.new32(args.inMultiplicand2));
        args.out = t.add(ab, t.new32(args.inOffset));
    }

    static public void computeMax(TestMax.ArgumentsCharCharChar args) {
        args.out = maxI8(args.inA, args.inB);
    }

    static public void computeMax(TestMax.ArgumentsUcharUcharUchar args) {
        args.out = maxU8(args.inA, args.inB);
    }

    static public void computeMax(TestMax.ArgumentsShortShortShort args) {
        args.out = maxI16(args.inA, args.inB);
    }

    static public void computeMax(TestMax.ArgumentsUshortUshortUshort args) {
        args.out = maxU16(args.inA, args.inB);
    }

    static public void computeMax(TestMax.ArgumentsIntIntInt args) {
        args.out = maxI32(args.inA, args.inB);
    }

    static public void computeMax(TestMax.ArgumentsUintUintUint args) {
        args.out = maxU32(args.inA, args.inB);
    }

    static public void computeMax(TestMax.ArgumentsLongLongLong args) {
        args.out = maxI64(args.inA, args.inB);
    }

    static public void computeMax(TestMax.ArgumentsUlongUlongUlong args) {
        args.out = maxU64(args.inA, args.inB);
    }

    static public void computeMax(TestMax.ArgumentsFloatFloatFloat args, Target t) {
        t.setPrecision(0, 0, false);
        Target.Floaty a = t.new32(args.inA);
        Target.Floaty b = t.new32(args.inB);
        args.out = t.new32(
            Math.max(a.mid32(), b.mid32()),
            Math.max(a.min32(), b.min32()),
            Math.max(a.min32(), b.max32()),
            Math.max(a.max32(), b.min32()),
            Math.max(a.max32(), b.max32()));
    }

    static public void computeMin(TestMin.ArgumentsCharCharChar args) {
        args.out = minI8(args.inA, args.inB);
    }

    static public void computeMin(TestMin.ArgumentsUcharUcharUchar args) {
        args.out = minU8(args.inA, args.inB);
    }

    static public void computeMin(TestMin.ArgumentsShortShortShort args) {
        args.out = minI16(args.inA, args.inB);
    }

    static public void computeMin(TestMin.ArgumentsUshortUshortUshort args) {
        args.out = minU16(args.inA, args.inB);
    }

    static public void computeMin(TestMin.ArgumentsIntIntInt args) {
        args.out = minI32(args.inA, args.inB);
    }

    static public void computeMin(TestMin.ArgumentsUintUintUint args) {
        args.out = minU32(args.inA, args.inB);
    }

    static public void computeMin(TestMin.ArgumentsLongLongLong args) {
        args.out = minI64(args.inA, args.inB);
    }

    static public void computeMin(TestMin.ArgumentsUlongUlongUlong args) {
        args.out = minU64(args.inA, args.inB);
    }

    static public void computeMin(TestMin.ArgumentsFloatFloatFloat args, Target t) {
        t.setPrecision(0, 0, false);
        args.out = t.new32(Math.min(args.inA, args.inB));
    }

    static public void computeMix(TestMix.ArgumentsFloatFloatFloatFloat args, Target t) {
        t.setPrecision(1, 4, false);
        Target.Floaty start = t.new32(args.inStart);
        Target.Floaty stop = t.new32(args.inStop);
        Target.Floaty diff = t.subtract(stop, start);
        args.out = t.add(start, t.multiply(diff, t.new32(args.inFraction)));
    }

    static public void computeModf(TestModf.ArgumentsFloatFloatFloat args, Target t) {
        t.setPrecision(0, 0, false);
        float ret = (float)(int)args.inV;
        args.outIntegralPart = t.new32(ret);
        args.out = t.new32(args.inV - ret);
    }

    static public void computeNan(TestNan.ArgumentsUintFloat args, Target t) {
        t.setPrecision(0, 0, false);
        // TODO(jeanluc) We're not using the input argument
        args.out = t.new32(Float.NaN);
    }

    static public void computeNativeAcos(TestNativeAcos.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = acos(args.inV, t);
    }

    static public void computeNativeAcosh(TestNativeAcosh.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = acosh(args.inV, t);
    }

    static public void computeNativeAcospi(TestNativeAcospi.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = acospi(args.inV, t);
    }

    static public void computeNativeAsin(TestNativeAsin.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = asin(args.inV, t);
    }

    static public void computeNativeAsinh(TestNativeAsinh.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = asinh(args.inV, t);
    }

    static public void computeNativeAsinpi(TestNativeAsinpi.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = asinpi(args.inV, t);
    }

    static public void computeNativeAtan(TestNativeAtan.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = atan(args.inV, t);
    }

    static public void computeNativeAtanh(TestNativeAtanh.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = atanh(args.inV, t);
    }

    static public void computeNativeAtanpi(TestNativeAtanpi.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = atanpi(args.inV, t);
    }

    static public void computeNativeAtan2(TestNativeAtan2.ArgumentsFloatFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = atan2(args.inNumerator, args.inDenominator, t);
    }

    static public void computeNativeAtan2pi(TestNativeAtan2pi.ArgumentsFloatFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = atan2pi(args.inNumerator, args.inDenominator, t);
    }

    static public void computeNativeCbrt(TestNativeCbrt.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = cbrt(args.inV, t);
    }

    static public void computeNativeCos(TestNativeCos.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = cos(args.inV, t);
    }

    static public void computeNativeCosh(TestNativeCosh.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = cosh(args.inV, t);
    }

    static public void computeNativeCospi(TestNativeCospi.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = cospi(args.inV, t);
    }

    static public void computeNativeDistance(TestNativeDistance.ArgumentsFloatFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = distance(new float[]{args.inLeftVector}, new float[]{args.inRightVector}, t);
    }

    static public void computeNativeDistance(TestNativeDistance.ArgumentsFloatNFloatNFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = distance(args.inLeftVector, args.inRightVector, t);
    }

    static public void computeNativeDivide(TestNativeDivide.ArgumentsFloatFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = t.divide(t.new32(args.inLeftVector), t.new32(args.inRightVector));
    }

    static public void computeNativeExp(TestNativeExp.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = exp(args.inV, t);
    }

    static public void computeNativeExp10(TestNativeExp10.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = exp10(args.inV, t);
    }

    static public void computeNativeExp2(TestNativeExp2.ArgumentsFloatFloat args, Target t) {
        // TODO we would like to use NATIVE_PRECISION, NATIVE_PRECISION
        t.setPrecision(13000, 13000, true);
        args.out = exp2(args.inV, t);
    }

    static public void computeNativeExpm1(TestNativeExpm1.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = expm1(args.inV, t);
    }

    static public void computeNativeHypot(TestNativeHypot.ArgumentsFloatFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = hypot(args.inA, args.inB, t);
    }

    static public void computeNativeLength(TestNativeLength.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = length(new float[] {args.inV}, t);
    }

    static public void computeNativeLength(TestNativeLength.ArgumentsFloatNFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = length(args.inV, t);
    }

    static public void computeNativeLog(TestNativeLog.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        // For very small values, allow anything.
        if (Math.abs(args.inV) < 1.e-20) {
            args.out = any32(t);
        } else {
            args.out = log(args.inV, t);
        }
    }

    static public void computeNativeLog10(TestNativeLog10.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        // For very small values, allow anything.
        if (Math.abs(args.inV) < 1.e-20) {
            args.out = any32(t);
        } else {
            args.out = log10(args.inV, t);
        }
    }

    static public void computeNativeLog1p(TestNativeLog1p.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = log1p(args.inV, t);
    }

    static public void computeNativeLog2(TestNativeLog2.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        // For very small values, allow anything.
        if (Math.abs(args.inV) < 1.e-20) {
            args.out = any32(t);
        } else {
            args.out = log2(args.inV, t);
        }
    }

    static public void computeNativeNormalize(TestNativeNormalize.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        Target.Floaty[] out = new Target.Floaty[1];
        normalize(new float[] {args.inV}, out, t);
        args.out = out[0];
    }

    static public void computeNativeNormalize(TestNativeNormalize.ArgumentsFloatNFloatN args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        normalize(args.inV, args.out, t);
    }

    static public void computeNativePowr(TestNativePowr.ArgumentsFloatFloatFloat args, Target t) {
        // TODO we would like to use NATIVE_PRECISION, NATIVE_PRECISION
        t.setPrecision(32000, 32000, true);
        // For very small values, allow anything.
        if (Math.abs(args.inBase) < 1.e-20) {
            args.out = any32(t);
        } else {
            args.out = powr(args.inBase, args.inExponent, t);
        }
    }

    static public void computeNativeRecip(TestNativeRecip.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = recip(args.inV, t);
    }

    static public void computeNativeRootn(TestNativeRootn.ArgumentsFloatIntFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        // Allow anything for zero.
        if (args.inN == 0) {
            args.out = any32(t);
        } else {
            args.out = rootn(args.inV, args.inN, t);
        }
    }

    static public void computeNativeRsqrt(TestNativeRsqrt.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = rsqrt(args.inV, t);
    }

    static public void computeNativeSin(TestNativeSin.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = sin(args.inV, t);
    }

    static public void computeNativeSincos(TestNativeSincos.ArgumentsFloatFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.outCos = cos(args.inV, t);
        args.out = sin(args.inV, t);
    }

    static public void computeNativeSinh(TestNativeSinh.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = sinh(args.inV, t);
    }

    static public void computeNativeSinpi(TestNativeSinpi.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = sinpi(args.inV, t);
    }

    static public void computeNativeSqrt(TestNativeSqrt.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = sqrt(args.inV, t);
    }

    static public void computeNativeTan(TestNativeTan.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = tan(args.inV, t);
    }

    static public void computeNativeTanh(TestNativeTanh.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = tanh(args.inV, t);
    }

    static public void computeNativeTanpi(TestNativeTanpi.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(NATIVE_PRECISION, NATIVE_PRECISION, true);
        args.out = tanpi(args.inV, t);
    }

    static public void computeNextafter(TestNextafter.ArgumentsFloatFloatFloat args, Target t) {
        t.setPrecision(0, 0, false);
        args.out = t.new32(Math.nextAfter(args.inV, args.inTarget));
    }

    static public void computeNormalize(TestNormalize.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(1, 1, false);
        Target.Floaty[] out = new Target.Floaty[1];
        normalize(new float[] {args.inV}, out, t);
        args.out = out[0];
    }

    static public void computeNormalize(TestNormalize.ArgumentsFloatNFloatN args, Target t) {
        t.setPrecision(1, 1, false);
        normalize(args.inV, args.out, t);
    }

    static public void computePow(TestPow.ArgumentsFloatFloatFloat args, Target t) {
        t.setPrecision(16, 128, false);
        Target.Floaty base = t.new32(args.inBase);
        Target.Floaty exponent = t.new32(args.inExponent);
        args.out = t.new32(
            pow(base.mid32(), exponent.mid32()),
            pow(base.min32(), exponent.min32()),
            pow(base.min32(), exponent.max32()),
            pow(base.max32(), exponent.min32()),
            pow(base.max32(), exponent.max32()));
    }

    static public void computePown(TestPown.ArgumentsFloatIntFloat args, Target t) {
        t.setPrecision(16, 128, false);
        Target.Floaty in = t.new32(args.inBase);
        // We use double for the calculations because floats does not have enough
        // mantissa bits.  Knowing if an int is odd or even will matter for negative
        // numbers.  Using a float loses the lowest bit.
        final double y = (double) args.inExponent;
        args.out = t.new32(
            (float) Math.pow(in.mid32(), y),
            (float) Math.pow(in.min32(), y),
            (float) Math.pow(in.max32(), y));
    }

    static public void computePowr(TestPowr.ArgumentsFloatFloatFloat args, Target t) {
        t.setPrecision(16, 128, false);
        args.out = powr(args.inBase, args.inExponent, t);
    }

    static public void computeRadians(TestRadians.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(3, 3, false);
        Target.Floaty in = t.new32(args.inV);
        Target.Floaty k = t.new32((float)(Math.PI / 180.0));
        args.out = t.multiply(in, k);
    }

    static public void computeRemainder(TestRemainder.ArgumentsFloatFloatFloat args, Target t) {
        t.setPrecision(0, 0, false);
        RemquoResult result = remquo(args.inNumerator, args.inDenominator);
        args.out = t.new32(result.remainder);
    }

    static public String verifyRemquo(TestRemquo.ArgumentsFloatFloatIntFloat args, Target t) {
        t.setPrecision(0, 0, false);
        RemquoResult expected = remquo(args.inNumerator, args.inDenominator);
        // If the expected remainder is NaN, we don't validate the quotient.  It's because of
        // a division by zero.
        if (expected.remainder != expected.remainder) {
            // Check that the value we got is NaN too.
            if (args.out == args.out) {
                return "Expected a remainder of NaN but got " +  Float.toString(args.out);
            }
        } else {
            // The quotient should have the same lowest three bits.
            if ((args.outQuotient & 0x07) != (expected.quotient & 0x07)) {
                return "Quotient returned " +  Integer.toString(args.outQuotient) +
                    " does not have the same lower three bits as the expected " +
                    Integer.toString(expected.quotient);
            }
            Target.Floaty remainder = t.new32(expected.remainder);
            if (!remainder.couldBe(args.out)) {
                return "Remainder returned " + Float.toString(args.out) +
                    " is not similar to the expected " +
                    remainder.toString();
            }
        }
        return null;
    }

    static public void computeRint(TestRint.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(0, 0, false);
        Target.Floaty in = t.new32(args.inV);
        args.out = t.new32(
            rint(in.mid32()),
            rint(in.min32()),
            rint(in.max32()));
    }

    static public void computeRootn(TestRootn.ArgumentsFloatIntFloat args, Target t) {
        t.setPrecision(16, 16, false);
        args.out = rootn(args.inV, args.inN, t);
    }

    static public void computeRound(TestRound.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(0, 0, false);
        Target.Floaty in = t.new32(args.inV);
        args.out = t.new32(
            round(in.mid32()),
            round(in.min32()),
            round(in.max32()));
    }

    static public void computeRsqrt(TestRsqrt.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(2, 2, false);
        args.out = rsqrt(args.inV, t);
    }

    static public void computeSign(TestSign.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(0, 0, false);
        args.out = t.new32(Math.signum(args.inV));
    }

    static public void computeSin(TestSin.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(4, 128, false);
        args.out = sin(args.inV, t);
    }

    static public void computeSincos(TestSincos.ArgumentsFloatFloatFloat args, Target t) {
        t.setPrecision(4, 128, false);
        args.outCos = cos(args.inV,t );
        args.out = sin(args.inV, t);
    }

    static public void computeSinh(TestSinh.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(4, 128, false);
        args.out = sinh(args.inV, t);
    }

    static public void computeSinpi(TestSinpi.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(4, 128, false);
        args.out = sinpi(args.inV, t);
    }

    static public void computeSqrt(TestSqrt.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(3, 3, false);
        args.out = sqrt(args.inV, t);
    }

    static public void computeStep(TestStep.ArgumentsFloatFloatFloat args, Target t) {
        t.setPrecision(0, 0, false);
        args.out = t.new32(args.inV < args.inEdge ? 0.f : 1.f);
    }

    static public void computeTan(TestTan.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(5, 128, false);
        args.out = tan(args.inV, t);
    }

    static public void computeTanh(TestTanh.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(5, 128, false);
        args.out = tanh(args.inV, t);
    }

    static public void computeTanpi(TestTanpi.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(4, 128, false);
        args.out = tanpi(args.inV, t);
    }

    static public void computeTgamma(TestTgamma.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(16, 128, false);
        Target.Floaty in = t.new32(args.inV);
        args.out = t.new32(
            tgamma(in.mid32()),
            tgamma(in.min32()),
            tgamma(in.max32()));
    }

    static public void computeTrunc(TestTrunc.ArgumentsFloatFloat args, Target t) {
        t.setPrecision(0, 0, false);
        Target.Floaty in = t.new32(args.inV);
        args.out = t.new32(
            trunc(in.mid32()),
            trunc(in.min32()),
            trunc(in.max32()));
    }
}