val = constant.MakeString(r.string())

	case types.IsInteger:
		var x big.Int
		r.mpint(&x, b)
		val = constant.Make(&x)

	case types.IsFloat:
		val = r.mpfloat(b)

	case types.IsComplex:
		re := r.mpfloat(b)
		im := r.mpfloat(b)
		val = constant.BinaryOp(re, token.ADD, constant.MakeImag(im))

	default:
		errorf("unexpected type %v", typ) // panics
		panic("unreachable")
	}

	SimType[TFUNC] = TPTR
	SimType[TUNSAFEPTR] = TPTR

	for et := TINT8; et <= TUINT64; et++ {
		IsInt[et] = true
	}
	IsInt[TINT] = true
	IsInt[TUINT] = true
	IsInt[TUINTPTR] = true

	IsFloat[TFLOAT32] = true
	IsFloat[TFLOAT64] = true

	IsComplex[TCOMPLEX64] = true
	IsComplex[TCOMPLEX128] = true
}

func makeErrorInterface() *Type {
	sig := NewSignature(FakeRecv(), nil, []*Field{

 *
 */
public class FloatConversionUtilTest extends TestCase {

    /**
     * @throws Exception
     */
    public void testToFloat() throws Exception {
        assertEquals(new Float("1000.5"), FloatConversionUtil.toFloat("1,000.5"));
    }

    /**
     * @throws Exception
     */
    public void testToPrimitiveFloat() throws Exception {

};

// APSInt provides operators which APInt does not, so allow for converting
// to APSInt for computation. Only APInts can be directly read from
// element attributes.
static const APFloat& AddSign(const APFloat& v) { return v; }
static APSInt AddSign(const APInt& v) { return APSInt(v); }

template <typename ResultType>
static LogicalResult FoldDivOpInternal(stablehlo::DivOp op,

func DoesNotExist(any) error {
	// special case logic in the Assert
	return nil
}

func Exactly(v float64) func(any) error {
	return func(f any) error {
		if v != toFloat(f) {
			return fmt.Errorf("want %v, got %v", v, toFloat(f))
		}
		return nil
	}
}

func Distribution(count uint64, sum float64) func(any) error {
	return func(f any) error {
		d := f.(*dto.Histogram)

#include "tensorflow/compiler/mlir/lite/stablehlo/transforms/passes.h"
#include "xla/mlir_hlo/mhlo/IR/hlo_ops.h"

namespace mlir {
namespace odml {

static const APFloat &addSign(const APFloat &v, Type) { return v; }
static APSInt addSign(const APInt &v, Type t) {
  // Add signedness information to the value, treating signless as signed,
  // unless it's i1.

	Uint32:        {Uint32, IsInteger | IsUnsigned, "uint32"},
	Uint64:        {Uint64, IsInteger | IsUnsigned, "uint64"},
	Uintptr:       {Uintptr, IsInteger | IsUnsigned, "uintptr"},
	Float32:       {Float32, IsFloat, "float32"},
	Float64:       {Float64, IsFloat, "float64"},
	Complex64:     {Complex64, IsComplex, "complex64"},
	Complex128:    {Complex128, IsComplex, "complex128"},
	String:        {String, IsString, "string"},

	Uint32:        {Uint32, IsInteger | IsUnsigned, "uint32"},
	Uint64:        {Uint64, IsInteger | IsUnsigned, "uint64"},
	Uintptr:       {Uintptr, IsInteger | IsUnsigned, "uintptr"},
	Float32:       {Float32, IsFloat, "float32"},
	Float64:       {Float64, IsFloat, "float64"},
	Complex64:     {Complex64, IsComplex, "complex64"},
	Complex128:    {Complex128, IsComplex, "complex128"},
	String:        {String, IsString, "string"},

other
barT

}

template <>
inline std::vector<float> GetVector(DenseElementsAttr elements) {
  auto type = elements.getType();
  auto elemType = type.getElementType();
  if (elemType.isF32()) {
    auto vec = llvm::to_vector(llvm::map_range(
        elements.getValues<APFloat>(),
        [&](APFloat value) -> float { return value.convertToFloat(); }));
    return std::vector<float>(vec.begin(), vec.end());
  }