//
//	Asinh(±0) = ±0
//	Asinh(±Inf) = ±Inf
//	Asinh(NaN) = NaN
func Asinh(x float64) float64 {
	if haveArchAsinh {
		return archAsinh(x)
	}
	return asinh(x)
}

func asinh(x float64) float64 {
	const (
		Ln2      = 6.93147180559945286227e-01 // 0x3FE62E42FEFA39EF
		NearZero = 1.0 / (1 << 28)            // 2**-28
		Large    = 1 << 28                    // 2**28
	)
	// special cases

	They are implemented by computing the arctangent
	after appropriate range reduction.
*/

// Asin returns the arcsine, in radians, of x.
//
// Special cases are:
//
//	Asin(±0) = ±0
//	Asin(x) = NaN if x < -1 or x > 1
func Asin(x float64) float64 {
	if haveArchAsin {
		return archAsin(x)
	}
	return asin(x)
}

func asin(x float64) float64 {
	if x == 0 {
		return x // special case
	}
	sign := false

	// Output: 0.00
}

func ExampleAcosh() {
	fmt.Printf("%.2f", math.Acosh(1))
	// Output: 0.00
}

func ExampleAsin() {
	fmt.Printf("%.2f", math.Asin(0))
	// Output: 0.00
}

func ExampleAsinh() {
	fmt.Printf("%.2f", math.Asinh(0))
	// Output: 0.00
}

func ExampleAtan() {
	fmt.Printf("%.2f", math.Atan(0))
	// Output: 0.00
}

func ExampleAtan2() {
	fmt.Printf("%.2f", math.Atan2(0, 0))

        expect:
        for (int i = DefaultJavaLanguageVersion.LOWER_CACHED_VERSION; i <= DefaultJavaLanguageVersion.HIGHER_CACHED_VERSION; i++) {
            assert knownVersions[i - DefaultJavaLanguageVersion.LOWER_CACHED_VERSION].asInt() == i
        }
    }

    def 'special cases versions 1 to 4'() {
        given:
        def values = 1..4

        expect:
        values.forEach {

            return chooseSpecFromCompileOptions(toolchainJavaHome);
        }

        if (!toolchain.isCurrentJvm()) {
            return getForkingSpec(toolchainJavaHome, toolchain.getLanguageVersion().asInt());
        }

        return getDefaultSpec();
    }

    private T chooseSpecFromCompileOptions(File fallbackJavaHome) {
        File forkJavaHome = compileOptions.getForkOptions().getJavaHome();

    }

    private final int version;

    private DefaultJavaLanguageVersion(int version) {
        this.version = version;
    }

    @Override
    public int asInt() {
        return version;
    }

    @Override
    public String toString() {
        if (version < 5) {
            return String.format("1.%d", version);
        }
        return Integer.toString(version);

            getVendor() >> DefaultJvmVendorSpec.any().toString()
            getImplementation() >> JvmImplementation.VENDOR_SPECIFIC.toString()
        }, false)
        then:
        javaToolchain.languageVersion.asInt() == languageVersion
        javaToolchain.javaRuntimeVersion == runtimeVersion
        javaToolchain.jvmVersion == jvmVersion

        where:
        javaVersion | runtimeVersion  | jvmVersion   | languageVersion

     * <p>
     * Given the type used, this method returns the simple version even for versions lower than 5.
     *
     * @return the version number
     * @see #toString()
     */
    int asInt();

    /**
     * Return this version as a String, "14" for Java 14.
     * <p>
     * This method will return {@code 1.<version>} when the version is lower than 5.
     *
     * @since 6.8

    @Suppress("DEPRECATION")
    private
    fun resolveJvmTarget(): JavaVersion =
        if (jvmTarget.isPresent) jvmTarget.get()
        else JavaVersion.toVersion(javaLauncher.get().metadata.languageVersion.asInt())

                    // Access toolchain related information
                    def compileJavaVersion = project.tasks.compileJava.javaCompiler.get().metadata.languageVersion.asInt()
                    return new ToolchainModel(path: project.path, javaVersion: compileJavaVersion);
                }
            }
        """
    }

    @TargetGradleVersion(">=8.1")