pkg math, func Log10(float64) float64
pkg math, func Log1p(float64) float64
pkg math, func Log2(float64) float64
pkg math, func Logb(float64) float64
pkg math, func Max(float64, float64) float64
pkg math, func Min(float64, float64) float64
pkg math, func Mod(float64, float64) float64
pkg math, func Modf(float64) (float64, float64)
pkg math, func NaN() float64
pkg math, func Nextafter(float64, float64) float64

}

// Return a tensor handle containing a 100x100 matrix of floats
TFE_TensorHandle* TestMatrixTensorHandle100x100(TFE_Context* ctx);

// Return a tensor handle containing a 3x2 matrix of doubles
TFE_TensorHandle* DoubleTestMatrixTensorHandle3X2(TFE_Context* ctx);

// Return a tensor handle containing a 3x2 matrix of floats
TFE_TensorHandle* TestMatrixTensorHandle3X2(TFE_Context* ctx);

		err = errors.New("entity too large")
		return
	}

	configuredPartSize := minPartSize
	// Use floats for part size for all calculations to avoid
	// overflows during float64 to int64 conversions.
	partSizeFlt := float64(objectSize / maxPartsCount)
	partSizeFlt = math.Ceil(partSizeFlt/float64(configuredPartSize)) * float64(configuredPartSize)

	// Part size.
	partSize = int64(partSizeFlt)
	if partSize == 0 {

	Timestamp2 *PrimaryTerm `parser:" @@ \")\" "`
}

// LitValue represents a literal value parsed from the sql
type LitValue struct {
	Float   *float64       `parser:"(  @Float"`
	Int     *float64       `parser:" | @Int"` // To avoid value out of range, use float64 instead
	String  *LiteralString `parser:" | @LitString"`
	Boolean *Boolean       `parser:" | @(\"TRUE\" | \"FALSE\")"`
	Null    bool           `parser:" | @\"NULL\""`

	}
}

func floatCast(v *Value) (float64, error) {
	switch x := v.value.(type) {
	case float64:
		return x, nil
	case int64:
		return float64(x), nil
	case string:
		f, err := strconv.ParseFloat(strings.TrimSpace(x), 64)
		if err != nil {
			return 0, errCastFailure("could not parse as float")
		}
		return f, nil
	case []byte:

        return l;
    }


    /*
     * Encode floats
     */

    public static int enc_floatle ( float f, byte[] dst, int di ) {
        return enc_uint32le(Float.floatToIntBits(f), dst, di);
    }


    public static int enc_floatbe ( float f, byte[] dst, int di ) {
        return enc_uint32be(Float.floatToIntBits(f), dst, di);
    }


    /*

    List<Byte> bytes = Arrays.asList((byte) 0, (byte) 1, (byte) 2);
    List<Short> shorts = Arrays.asList((short) 0, (short) 1, (short) 2);
    List<Integer> ints = Arrays.asList(0, 1, 2);
    List<Float> floats = Arrays.asList((float) 0, (float) 1, (float) 2);
    List<Long> longs = Arrays.asList((long) 0, (long) 1, (long) 2);
    List<Double> doubles = Arrays.asList((double) 0, (double) 1, (double) 2);

    List<Byte> bytes = Arrays.asList((byte) 0, (byte) 1, (byte) 2);
    List<Short> shorts = Arrays.asList((short) 0, (short) 1, (short) 2);
    List<Integer> ints = Arrays.asList(0, 1, 2);
    List<Float> floats = Arrays.asList((float) 0, (float) 1, (float) 2);
    List<Long> longs = Arrays.asList((long) 0, (long) 1, (long) 2);
    List<Double> doubles = Arrays.asList((double) 0, (double) 1, (double) 2);

        return l;
    }

    /* Encode floats
     */

    public static int enc_floatle( float f, byte[] dst, int di )
    {
        return enc_uint32le( Float.floatToIntBits( f ), dst, di );
    }
    public static int enc_floatbe( float f, byte[] dst, int di )
    {
        return enc_uint32be( Float.floatToIntBits( f ), dst, di );
    }

    /* Decode floating point numbers

pkg flag, method (*FlagSet) Output() io.Writer
pkg html/template, type Srcset string
pkg math, func Erfcinv(float64) float64
pkg math, func Erfinv(float64) float64
pkg math, func Round(float64) float64
pkg math, func RoundToEven(float64) float64
pkg math/big, const MaxBase = 62
pkg math/big, method (*Float) Sqrt(*Float) *Float
pkg math/big, method (*Int) CmpAbs(*Int) int
pkg math/rand, func Shuffle(int, func(int, int))