* @return 変換された{@link Float}
     */
    public static Float toFloat(final Object o) {
        return toFloat(o, null);
    }

    /**
     * {@link Float}に変換します。
     *
     * @param o
     *            変換元のオブジェクト
     * @param pattern
     *            パターン文字列
     * @return 変換された{@link Float}
     */
    public static Float toFloat(final Object o, final String pattern) {
        if (o == null) {

	return &Value{value: b}
}

// FromArray creates a Value from an array of values.
func FromArray(a []Value) *Value {
	return &Value{value: a}
}

// ToFloat works for int and float values
func (v Value) ToFloat() (val float64, ok bool) {
	switch x := v.value.(type) {
	case float64:
		return x, true
	case int64:
		return float64(x), true
	}
	return 0, false
}

 */
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 {
        assertEquals(1000.5, FloatConversionUtil.toPrimitiveFloat("1,000.5"), 0);
    }

            return DoubleConversionUtil.toDouble(o);
        } else if (type == Long.class) {
            return LongConversionUtil.toLong(o);
        } else if (type == Float.class) {
            return FloatConversionUtil.toFloat(o);
        } else if (type == Short.class) {
            return ShortConversionUtil.toShort(o);
        } else if (type == BigInteger.class) {
            return BigIntegerConversionUtil.toBigInteger(o);

                    }
                }
            }
        }

        final var docs = scoreDocMap.values().stream()
                .sorted((e1, e2) -> Float.compare(toFloat(e2.get(scoreField)), toFloat(e1.get(scoreField)))).toList();
        int offset = 0;
        for (int i = 0; i < windowSize / 2 && i < docs.size(); i++) {
            if (!mainIdSet.contains(docs.get(i).get(idField))) {

}

// Set - sets the value for a column name.
func (r *Record) Set(name string, value *sql.Value) (sql.Record, error) {
	var v interface{}
	if b, ok := value.ToBool(); ok {
		v = b
	} else if f, ok := value.ToFloat(); ok {
		v = f
	} else if i, ok := value.ToInt(); ok {
		v = i
	} else if t, ok := value.ToTimestamp(); ok {
		v = sql.FormatSQLTimestamp(t)
	} else if s, ok := value.ToString(); ok {
		v = s

        try {
            final RESULT result = entityType.newInstance();
            result.setAvailable(DfTypeUtil.toBoolean(source.get("available")));
            result.setBoost(DfTypeUtil.toFloat(source.get("boost")));
            result.setConfigParameter(DfTypeUtil.toString(source.get("configParameter")));
            result.setCreatedBy(DfTypeUtil.toString(source.get("createdBy")));

				return false
			}
			for i := range aA {
				if !cmp(aA[i], bA[i]) {
					return false
				}
			}
			return true
		}
		// Try as numbers
		aF, aOK := a.ToFloat()
		bF, bOK := b.ToFloat()

		diff := math.Abs(aF - bF)
		return aOK && bOK && diff < floatCmpTolerance
	}

	var rhs Value
	var err error
	var eltVal *Value
	switch {
	case e.JPathExpr != nil:

                args[index] = LongConversionUtil.toLong(args[index]);
                return true;
            } else if (paramTypes[index] == float.class) {
                args[index] = FloatConversionUtil.toFloat(args[index]);
                return true;
            } else if (paramTypes[index] == double.class) {
                args[index] = DoubleConversionUtil.toDouble(args[index]);
                return true;
            }

        try {
            final RESULT result = entityType.newInstance();
            result.setAvailable(DfTypeUtil.toBoolean(source.get("available")));
            result.setBoost(DfTypeUtil.toFloat(source.get("boost")));
            result.setCreatedBy(DfTypeUtil.toString(source.get("createdBy")));
            result.setCreatedTime(DfTypeUtil.toLong(source.get("createdTime")));