/* THIS FILE IS GENERATED. DO NOT EDIT */
package org.jruby.gen;

import org.jruby.Ruby;
import org.jruby.RubyModule;
import org.jruby.RubyClass;
import org.jruby.anno.TypePopulator;
import org.jruby.internal.runtime.methods.JavaMethod;
import org.jruby.internal.runtime.methods.DynamicMethod;
import org.jruby.runtime.Arity;
import org.jruby.runtime.Visibility;
import org.jruby.runtime.MethodIndex;
import java.util.Arrays;
import java.util.List;
import javax.annotation.Generated;

@Generated("org.jruby.anno.AnnotationBinder")
@SuppressWarnings("deprecation")
public class org$jruby$RubyMath$POPULATOR extends TypePopulator {
    public void populate(RubyModule cls, Class clazz) {
        JavaMethod javaMethod;
        DynamicMethod moduleMethod, aliasedMethod;
        RubyClass singletonClass = cls.getSingletonClass();
        Ruby runtime = cls.getRuntime();
        javaMethod = new org.jruby.RubyMath$INVOKER$s$1$0$frexp(cls, Visibility.PRIVATE, "frexp");
        populateMethod(javaMethod, 1, "frexp", true, false, org.jruby.RubyMath.class, "frexp", org.jruby.RubyArray.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "frexp", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "frexp", moduleMethod);
        javaMethod = new org.jruby.RubyMath$INVOKER$s$1$0$atanh(cls, Visibility.PRIVATE, "atanh");
        populateMethod(javaMethod, 1, "atanh", true, false, org.jruby.RubyMath.class, "atanh", org.jruby.RubyFloat.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "atanh", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "atanh", moduleMethod);
        javaMethod = new org.jruby.RubyMath$INVOKER$s$log(cls, Visibility.PRIVATE, "log");
        populateMethod(javaMethod, -1, "log", true, false, org.jruby.RubyMath.class, "log", org.jruby.RubyFloat.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "log", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "log", moduleMethod);
        javaMethod = new org.jruby.RubyMath$INVOKER$s$2$0$ldexp(cls, Visibility.PRIVATE, "ldexp");
        populateMethod(javaMethod, 2, "ldexp", true, false, org.jruby.RubyMath.class, "ldexp", org.jruby.RubyFloat.class, CONTEXT_ARG3);
        aliasedMethod = cls.putMethod(runtime, "ldexp", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "ldexp", moduleMethod);
        javaMethod = new org.jruby.RubyMath$INVOKER$s$1$0$erfc(cls, Visibility.PRIVATE, "erfc");
        populateMethod(javaMethod, 1, "erfc", true, false, org.jruby.RubyMath.class, "erfc", org.jruby.RubyFloat.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "erfc", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "erfc", moduleMethod);
        javaMethod = new org.jruby.RubyMath$INVOKER$s$1$0$cos(cls, Visibility.PRIVATE, "cos");
        populateMethod(javaMethod, 1, "cos", true, false, org.jruby.RubyMath.class, "cos", org.jruby.RubyFloat.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "cos", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "cos", moduleMethod);
        javaMethod = new org.jruby.RubyMath$INVOKER$s$1$0$log10(cls, Visibility.PRIVATE, "log10");
        populateMethod(javaMethod, 1, "log10", true, false, org.jruby.RubyMath.class, "log10", org.jruby.RubyFloat.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "log10", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "log10", moduleMethod);
        javaMethod = new org.jruby.RubyMath$INVOKER$s$1$0$atan(cls, Visibility.PRIVATE, "atan");
        populateMethod(javaMethod, 1, "atan", true, false, org.jruby.RubyMath.class, "atan", org.jruby.RubyFloat.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "atan", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "atan", moduleMethod);
        javaMethod = new org.jruby.RubyMath$INVOKER$s$1$0$cbrt(cls, Visibility.PRIVATE, "cbrt");
        populateMethod(javaMethod, 1, "cbrt", true, false, org.jruby.RubyMath.class, "cbrt", org.jruby.RubyFloat.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "cbrt", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "cbrt", moduleMethod);
        javaMethod = new org.jruby.RubyMath$INVOKER$s$1$0$tanh(cls, Visibility.PRIVATE, "tanh");
        populateMethod(javaMethod, 1, "tanh", true, false, org.jruby.RubyMath.class, "tanh", org.jruby.RubyFloat.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "tanh", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "tanh", moduleMethod);
        javaMethod = new org.jruby.RubyMath$INVOKER$s$1$0$sqrt(cls, Visibility.PRIVATE, "sqrt");
        populateMethod(javaMethod, 1, "sqrt", true, false, org.jruby.RubyMath.class, "sqrt", org.jruby.RubyFloat.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "sqrt", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "sqrt", moduleMethod);
        javaMethod = new org.jruby.RubyMath$INVOKER$s$2$0$hypot19(cls, Visibility.PRIVATE, "hypot");
        populateMethod(javaMethod, 2, "hypot19", true, false, org.jruby.RubyMath.class, "hypot19", org.jruby.RubyFloat.class, CONTEXT_ARG3);
        aliasedMethod = cls.putMethod(runtime, "hypot", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "hypot", moduleMethod);
        javaMethod = new org.jruby.RubyMath$INVOKER$s$1$0$erf(cls, Visibility.PRIVATE, "erf");
        populateMethod(javaMethod, 1, "erf", true, false, org.jruby.RubyMath.class, "erf", org.jruby.RubyFloat.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "erf", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "erf", moduleMethod);
        javaMethod = new org.jruby.RubyMath$INVOKER$s$1$0$sin(cls, Visibility.PRIVATE, "sin");
        populateMethod(javaMethod, 1, "sin", true, false, org.jruby.RubyMath.class, "sin", org.jruby.RubyFloat.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "sin", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "sin", moduleMethod);
        javaMethod = new org.jruby.RubyMath$INVOKER$s$1$0$exp(cls, Visibility.PRIVATE, "exp");
        populateMethod(javaMethod, 1, "exp", true, false, org.jruby.RubyMath.class, "exp", org.jruby.RubyFloat.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "exp", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "exp", moduleMethod);
        javaMethod = new org.jruby.RubyMath$INVOKER$s$1$0$log2(cls, Visibility.PRIVATE, "log2");
        populateMethod(javaMethod, 1, "log2", true, false, org.jruby.RubyMath.class, "log2", org.jruby.RubyFloat.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "log2", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "log2", moduleMethod);
        javaMethod = new org.jruby.RubyMath$INVOKER$s$2$0$atan2(cls, Visibility.PRIVATE, "atan2");
        populateMethod(javaMethod, 2, "atan2", true, false, org.jruby.RubyMath.class, "atan2", org.jruby.RubyFloat.class, CONTEXT_ARG3);
        aliasedMethod = cls.putMethod(runtime, "atan2", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "atan2", moduleMethod);
        javaMethod = new org.jruby.RubyMath$INVOKER$s$1$0$lgamma(cls, Visibility.PRIVATE, "lgamma");
        populateMethod(javaMethod, 1, "lgamma", true, false, org.jruby.RubyMath.class, "lgamma", org.jruby.RubyArray.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "lgamma", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "lgamma", moduleMethod);
        javaMethod = new org.jruby.RubyMath$INVOKER$s$1$0$tan(cls, Visibility.PRIVATE, "tan");
        populateMethod(javaMethod, 1, "tan", true, false, org.jruby.RubyMath.class, "tan", org.jruby.RubyFloat.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "tan", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "tan", moduleMethod);
        javaMethod = new org.jruby.RubyMath$INVOKER$s$1$0$sinh(cls, Visibility.PRIVATE, "sinh");
        populateMethod(javaMethod, 1, "sinh", true, false, org.jruby.RubyMath.class, "sinh", org.jruby.RubyFloat.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "sinh", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "sinh", moduleMethod);
        javaMethod = new org.jruby.RubyMath$INVOKER$s$1$0$acosh(cls, Visibility.PRIVATE, "acosh");
        populateMethod(javaMethod, 1, "acosh", true, false, org.jruby.RubyMath.class, "acosh", org.jruby.RubyFloat.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "acosh", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "acosh", moduleMethod);
        javaMethod = new org.jruby.RubyMath$INVOKER$s$1$0$acos(cls, Visibility.PRIVATE, "acos");
        populateMethod(javaMethod, 1, "acos", true, false, org.jruby.RubyMath.class, "acos", org.jruby.RubyFloat.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "acos", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "acos", moduleMethod);
        javaMethod = new org.jruby.RubyMath$INVOKER$s$1$0$cosh(cls, Visibility.PRIVATE, "cosh");
        populateMethod(javaMethod, 1, "cosh", true, false, org.jruby.RubyMath.class, "cosh", org.jruby.RubyFloat.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "cosh", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "cosh", moduleMethod);
        javaMethod = new org.jruby.RubyMath$INVOKER$s$1$0$asin(cls, Visibility.PRIVATE, "asin");
        populateMethod(javaMethod, 1, "asin", true, false, org.jruby.RubyMath.class, "asin", org.jruby.RubyFloat.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "asin", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "asin", moduleMethod);
        javaMethod = new org.jruby.RubyMath$INVOKER$s$1$0$asinh(cls, Visibility.PRIVATE, "asinh");
        populateMethod(javaMethod, 1, "asinh", true, false, org.jruby.RubyMath.class, "asinh", org.jruby.RubyFloat.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "asinh", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "asinh", moduleMethod);
        javaMethod = new org.jruby.RubyMath$INVOKER$s$1$0$gamma(cls, Visibility.PRIVATE, "gamma");
        populateMethod(javaMethod, 1, "gamma", true, false, org.jruby.RubyMath.class, "gamma", org.jruby.RubyFloat.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "gamma", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "gamma", moduleMethod);

        runtime.addBoundMethods("org.jruby.RubyMath", "frexp", "frexp", "atanh", "atanh", "log", "log", "ldexp", "ldexp", "erfc", "erfc", "cos", "cos", "log10", "log10", "atan", "atan", "cbrt", "cbrt", "tanh", "tanh", "sqrt", "sqrt", "hypot19", "hypot", "erf", "erf", "sin", "sin", "exp", "exp", "log2", "log2", "atan2", "atan2", "lgamma", "lgamma", "tan", "tan", "sinh", "sinh", "acosh", "acosh", "acos", "acos", "cosh", "cosh", "asin", "asin", "asinh", "asinh", "gamma", "gamma");
    }
    static {
    }
}