s.java.lang.StrictMath Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of javaee-rt Show documentation
An Execution Environment for Java SCOREs
There is a newer version: 0.9.6
package s.java.lang;

import i.IInstrumentation;

import org.aion.avm.RuntimeMethodFeeSchedule;

public final class StrictMath extends Object {
    static {
        // Shadow classes MUST be loaded during bootstrap phase.
        IInstrumentation.attachedThreadInstrumentation.get().bootstrapOnly();
    }

    private StrictMath() {}

    public static final double avm_E = java.lang.StrictMath.E;

    public static final double avm_PI = java.lang.StrictMath.PI;

    public static double avm_sin(double a){
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_sin);
        return java.lang.StrictMath.sin(a);
    }

    public static double avm_cos(double a){
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_cos);
        return java.lang.StrictMath.cos(a);
    }

    public static double avm_tan(double a){
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_tan);
        return java.lang.StrictMath.tan(a);
    }

    public static double avm_asin(double a){
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_asin);
        return java.lang.StrictMath.asin(a);
    }

    public static double avm_acos(double a){
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_acos);
        return java.lang.StrictMath.acos(a);
    }

    public static double avm_atan(double a){
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_atan);
        return java.lang.StrictMath.atan(a);
    }

    public static strictfp double avm_toRadians(double angdeg) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_toRadians);
        return java.lang.StrictMath.toRadians(angdeg);
    }

    public static strictfp double avm_toDegrees(double angrad) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_toDegrees);
        return java.lang.StrictMath.toDegrees(angrad);
    }

    public static double avm_exp(double a) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_exp);
        return java.lang.StrictMath.exp(a);
    }

    public static double avm_log(double a){
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_log);
        return java.lang.StrictMath.log(a);
    }

    public static double avm_log10(double a){
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_log10);
        return java.lang.StrictMath.log10(a);
    }

    public static double avm_sqrt(double a){
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_sqrt);
        return java.lang.StrictMath.sqrt(a);
    }

    public static double avm_cbrt(double a) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_cbrt);
        return java.lang.StrictMath.cbrt(a);
    }

    public static double avm_IEEEremainder(double f1, double f2){
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_IEEEremainder);
        return java.lang.StrictMath.IEEEremainder(f1, f2);
    }

    public static double avm_ceil(double a) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_ceil);
        return java.lang.StrictMath.ceil(a);
    }

    public static double avm_floor(double a) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_floor);
        return java.lang.StrictMath.floor(a);
    }

    public static double avm_rint(double a) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_rint);
        return java.lang.StrictMath.rint(a);
    }

    public static double avm_atan2(double y, double x){
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_atan2);
        return java.lang.StrictMath.atan2(y, x);
    }

    public static double avm_pow(double a, double b) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_pow);
        return java.lang.StrictMath.pow(a, b);
    }

    public static int avm_round(float a) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_round);
        return java.lang.StrictMath.round(a);
    }

    public static long avm_round(double a) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_round_1);
        return java.lang.StrictMath.round(a);
    }

    public static int avm_addExact(int x, int y) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_addExact);
        return java.lang.StrictMath.addExact(x, y);
    }

    public static long avm_addExact(long x, long y) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_addExact_1);
        return java.lang.StrictMath.addExact(x, y);
    }

    public static int avm_subtractExact(int x, int y) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_subtractExact);
        return java.lang.StrictMath.subtractExact(x, y);
    }

    public static long avm_subtractExact(long x, long y) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_subtractExact_1);
        return java.lang.StrictMath.subtractExact(x, y);
    }

    public static int avm_multiplyExact(int x, int y) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_multiplyExact);
        return java.lang.StrictMath.multiplyExact(x, y);
    }

    public static long avm_multiplyExact(long x, int y) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_multiplyExact_1);
        return java.lang.StrictMath.multiplyExact(x, y);
    }

    public static long avm_multiplyExact(long x, long y) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_multiplyExact_2);
        return java.lang.StrictMath.multiplyExact(x, y);
    }

    public static int avm_toIntExact(long value) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_toIntExact);
        return java.lang.StrictMath.toIntExact(value);
    }

    public static long avm_multiplyFull(int x, int y) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_multiplyFull);
        return java.lang.StrictMath.multiplyFull(x, y);
    }

    public static long avm_multiplyHigh(long x, long y) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_multiplyHigh);
        return java.lang.StrictMath.multiplyHigh(x, y);
    }

    public static int avm_floorDiv(int x, int y) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_floorDiv);
        return java.lang.StrictMath.floorDiv(x, y);
    }

    public static long avm_floorDiv(long x, int y) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_floorDiv_1);
        return java.lang.StrictMath.floorDiv(x, y);
    }

    public static long avm_floorDiv(long x, long y) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_floorDiv_2);
        return java.lang.StrictMath.floorDiv(x, y);
    }

    public static int avm_floorMod(int x, int y) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_floorMod);
        return java.lang.StrictMath.floorMod(x , y);
    }

    public static int avm_floorMod(long x, int y) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_floorMod_1);
        return java.lang.StrictMath.floorMod(x , y);
    }

    public static long avm_floorMod(long x, long y) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_floorMod_2);
        return java.lang.StrictMath.floorMod(x, y);
    }

    public static int avm_abs(int a) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_abs);
        return java.lang.StrictMath.abs(a);
    }

    public static long avm_abs(long a) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_abs_1);
        return java.lang.StrictMath.abs(a);
    }

    public static float avm_abs(float a) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_abs_2);
        return java.lang.StrictMath.abs(a);
    }

    public static double avm_abs(double a) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_abs_3);
        return java.lang.StrictMath.abs(a);
    }

    public static int avm_max(int a, int b) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_max);
        return java.lang.StrictMath.max(a, b);
    }

    public static long avm_max(long a, long b) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_max_1);
        return java.lang.StrictMath.max(a, b);
    }

    public static float avm_max(float a, float b) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_max_2);
        return java.lang.StrictMath.max(a, b);
    }

    public static double avm_max(double a, double b) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_max_3);
        return java.lang.StrictMath.max(a, b);
    }

    public static int avm_min(int a, int b) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_min);
        return java.lang.StrictMath.min(a, b);
    }

    public static long avm_min(long a, long b) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_min_1);
        return java.lang.StrictMath.min(a, b);
    }

    public static float avm_min(float a, float b) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_min_2);
        return java.lang.StrictMath.min(a, b);
    }

    public static double avm_min(double a, double b) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_min_3);
        return java.lang.StrictMath.min(a, b);
    }

    public static double avm_fma(double a, double b, double c) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_fma);
        return java.lang.StrictMath.fma(a, b, c);
    }

    public static float avm_fma(float a, float b, float c) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_fma_1);
        return java.lang.StrictMath.fma(a, b, c);
    }

    public static double avm_ulp(double d) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_ulp);
        return java.lang.StrictMath.ulp(d);
    }

    public static float avm_ulp(float f) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_ulp_1);
        return java.lang.StrictMath.ulp(f);
    }

    public static double avm_signum(double d) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_signum);
        return java.lang.StrictMath.signum(d);
    }

    public static float avm_signum(float f) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_signum_1);
        return java.lang.StrictMath.signum(f);
    }

    public static double avm_sinh(double x){
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_sinh);
        return java.lang.StrictMath.sinh(x);
    }

    public static double avm_cosh(double x){
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_cosh);
        return java.lang.StrictMath.cosh(x);
    }

    public static double avm_tanh(double x){
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_tanh);
        return java.lang.StrictMath.tanh(x);
    }

    public static double avm_hypot(double x, double y) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_hypot);
        return java.lang.StrictMath.hypot(x, y);
    }

    public static double avm_expm1(double x){
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_expm1);
        return java.lang.StrictMath.expm1(x);
    }

    public static double avm_log1p(double x){
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_log1p);
        return java.lang.StrictMath.log1p(x);
    }

    public static double avm_copySign(double magnitude, double sign) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_copySign);
        return java.lang.StrictMath.copySign(magnitude, sign);
    }

    public static float avm_copySign(float magnitude, float sign) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_copySign_1);
        return java.lang.StrictMath.copySign(magnitude, sign);
    }

    public static int avm_getExponent(float f) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_getExponent);
        return java.lang.StrictMath.getExponent(f);
    }

    public static int avm_getExponent(double d) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_getExponent_1);
        return java.lang.StrictMath.getExponent(d);
    }

    public static double avm_nextAfter(double start, double direction) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_nextAfter);
        return java.lang.StrictMath.nextAfter(start, direction);
    }

    public static float avm_nextAfter(float start, double direction) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_nextAfter_1);
        return java.lang.StrictMath.nextAfter(start, direction);
    }

    public static double avm_nextUp(double d) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_nextUp);
        return java.lang.StrictMath.nextUp(d);
    }

    public static float avm_nextUp(float f) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_nextUp_1);
        return java.lang.StrictMath.nextUp(f);
    }

    public static double avm_nextDown(double d) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_nextDown);
        return java.lang.StrictMath.nextDown(d);
    }

    public static float avm_nextDown(float f) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_nextDown_1);
        return java.lang.StrictMath.nextDown(f);
    }

    public static double avm_scalb(double d, int scaleFactor) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_scalb);
        return java.lang.StrictMath.scalb(d, scaleFactor);
    }

    public static float avm_scalb(float f, int scaleFactor) {
        IInstrumentation.attachedThreadInstrumentation.get().chargeEnergy(RuntimeMethodFeeSchedule.StrictMath_avm_scalb_1);
        return java.lang.StrictMath.scalb(f, scaleFactor);
    }

    //========================================================
    // Methods below are excluded from shadowing
    //========================================================

    //public static double random()



}