// license that can be found in the LICENSE file.

// No double error on ideal -> float{32,64} conversion overflow

package issue19947

var _ = float32(1) * 1e200 // ERROR "constant 1e\+200 overflows float32|1e200 .* overflows float32"
var _ = float64(1) * 1e500 // ERROR "constant 1e\+500 overflows float64|1e500 .* overflows float64"

		i := u >> 32 & 0x7F
		x := float64(j) * float64(wn[i])
		if absInt32(j) < kn[i] {
			// This case should be hit better than 99% of the time.
			return x
		}

		if i == 0 {
			// This extra work is only required for the base strip.
			for {
				x = -math.Log(r.Float64()) * (1.0 / rn)
				y := -math.Log(r.Float64())
				if y+y >= x*x {
					break
				}
			}
			if j > 0 {
				return rn + x
			}
			return -rn - x

// license that can be found in the LICENSE file.

package main


func f(i int, f float64) {
	i = 8
	f = 8.0
	return
}

func main() {
	f(3, float64(5))
}

/*
bug10.go:5: i undefined
bug10.go:6: illegal conversion of constant to 020({},<_o001>{<i><int32>INT32;<f><float32>FLOAT32;},{})
bug10.go:7: error in shape across assignment

            "type": "integer",
            "format": "int64"
          },
          "float32": {
            "description": "Float32 field.",
            "type": "number",
            "format": "float32"
          },
          "float64": {
            "description": "Float64 field.",
            "type": "number",
            "format": "float64"
          }
        },
        "x-kubernetes-group-version-kind": [
          {

		_ int        = g(1, 2)
		_ rune       = g(1, 'a')
		_ float64    = g(1, 'a', 2.3)
		_ float64    = g('a', 2.3)
		_ complex128 = g(2.3, 'a', 1i)
	)
	g(true, 'a' /* ERROR "mismatched types untyped bool and untyped rune (cannot infer P)" */)
	g(1, "foo" /* ERROR "mismatched types untyped int and untyped string (cannot infer P)" */)
	g(1, 2.3, "bar" /* ERROR "mismatched types untyped float and untyped string (cannot infer P)" */)

		},
		{
			name: "float64",
			obj:  float64(2.71),
		},
		{
			name: "float64 max",
			obj:  float64(math.MaxFloat64),
		},
		{
			name: "float64 smallest nonzero",
			obj:  float64(math.SmallestNonzeroFloat64),
		},
		{
			name: "float64 no fractional component",
			obj:  float64(5),
		},
		{
			name: "float32",
			obj:  float32(2.71),
		},
		{

func main() {
	for i := Bool; i < Last; i++ {
		switch x := f(i).(type) {
		case bool:
			assert(x == true && i == Bool, "bool")
		case int:
			assert(x == 7 && i == Int, "int")
		case float64:
			assert(x == 7.4 && i == Float, "float64")
		case string:
			assert(x == "hello" && i == String, "string")
		case S:
			assert(x.a == 1234 && i == Struct, "struct")
		case chan int:
			assert(x == c && i == Chan, "chan")
		case []int:

// license that can be found in the LICENSE file.

package rand

func GetNormalDistributionParameters() (float64, [128]uint32, [128]float32, [128]float32) {
	return rn, kn, wn, fn
}

func GetExponentialDistributionParameters() (float64, [256]uint32, [256]float32, [256]float32) {
	return re, ke, we, fe

// license that can be found in the LICENSE file.

// Test that nil checks are removed.
// Optimization is enabled.

package p

func f5(p *float32, q *float64, r *float32, s *float64) float64 {
	x := float64(*p) // ERROR "generated nil check"
	y := *q          // ERROR "generated nil check"
	*r = 7           // ERROR "removed nil check"
	*s = 9           // ERROR "removed nil check"
	return x + y

#include "mlir/IR/Types.h"  // from @llvm-project

namespace mlir::quant::stablehlo {

// Returns true if the type or its element type is a float type with bit_width
// > 16.
bool IsLargeFloatType(Type type);

// Converts large float type to bfloat16. Otherwise returns original type.
Type ToBfloat16Type(Type type);

}  // namespace mlir::quant::stablehlo