/* * Returns the argument's ulp (unit in the last place). The size of a ulp of * a float value is the positive distance between this value and the float * value next larger in magnitude. For non-NaN {@code x}, * {@code ulp(-x) == ulp(x)}. * <p> * Special cases: * <ul> * <li>{@code ulp(+0.0) = Float.MIN_VALUE}</li> * <li>{@code ulp(-0.0) = Float.MIN_VALUE}</li> * <li>{@code ulp(+infintiy) = infinity}</li> * <li>{@code ulp(-infintiy) = infinity}</li> * <li>{@code ulp(NaN) = NaN}</li> * </ul> * * @param f * the floating-point value to compute ulp of. * @return the size of a ulp of the argument. */ public static float ulp(float f) { // special cases if (Float.isNaN(f)) { return(Float.NaN); } else if (float.IsInfinity(f)) { return(Float.POSITIVE_INFINITY); } else if (f == Float.MAX_VALUE || f == -Float.MAX_VALUE) { return((float)pow(2, 104)); } f = Math.abs(f); return(nextafterf(f, Float.MAX_VALUE) - f); }
/* * Returns the signum function of the argument. If the argument is less than * zero, it returns -1.0. If the argument is greater than zero, 1.0 is * returned. If the argument is either positive or negative zero, the * argument is returned as result. * <p> * Special cases: * <ul> * <li>{@code signum(+0.0) = +0.0}</li> * <li>{@code signum(-0.0) = -0.0}</li> * <li>{@code signum(+infinity) = +1.0}</li> * <li>{@code signum(-infinity) = -1.0}</li> * <li>{@code signum(NaN) = NaN}</li> * </ul> * * @param f * the value whose signum has to be computed. * @return the value of the signum function. */ public static float signum(float f) { if (Float.isNaN(f)) { return(Float.NaN); } float sig = f; if (f > 0) { sig = 1.0f; } else if (f < 0) { sig = -1.0f; } return(sig); }
/* * Returns the most negative (closest to negative infinity) of the two * arguments. * <p> * Special cases: * <ul> * <li>{@code min(NaN, (anything)) = NaN}</li> * <li>{@code min((anything), NaN) = NaN}</li> * <li>{@code min(+0.0, -0.0) = -0.0}</li> * <li>{@code min(-0.0, +0.0) = -0.0}</li> * </ul> * * @param f1 * the first argument. * @param f2 * the second argument. * @return the smaller of {@code f1} and {@code f2}. */ public static float min(float f1, float f2) { if (f1 > f2) { return(f2); } if (f1 < f2) { return(f1); } /* if either arg is NaN, return NaN */ if (f1 != f2) { return(Float.NaN); } /* min( +0.0,-0.0) == -0.0 */ if (f1 == 0.0f && ((Float.floatToIntBits(f1) | Float.floatToIntBits(f2)) & 0x80000000) != 0) { return(0.0f * (-1.0f)); } return(f1); }
/* * Answers the next larger float value to d. * * @param f * the float value to start * @return the next larger float value of d. * * @since 1.6 */ public static float nextUp(float f) { if (Float.isNaN(f)) { return(Float.NaN); } if ((f == Float.POSITIVE_INFINITY)) { return(Float.POSITIVE_INFINITY); } if (0 == f) { return(Float.MIN_VALUE); } else if (0 < f) { return(Float.intBitsToFloat(Float.floatToIntBits(f) + 1)); } else { return(Float.intBitsToFloat(Float.floatToIntBits(f) - 1)); } }
/** * Converts the specified float to its string representation. * * @param value * the float. * @return the float converted to a string. */ public static String valueOf(float value) { return(Float.toString(value)); }
/** * Constructs a new {@code AssertionError} with a message based on calling * {@link String#valueOf(float)} with the specified float value. * * @param detailMessage * the value to be converted into the message. */ public AssertionError(float detailMessage) : this(Float.toString(detailMessage)) { }
/* * Inserts the string representation of the specified {@code float} value at * the specified {@code offset}. The {@code float} value is converted to a * string according to the rule defined by {@link String#valueOf(float)}. * * @param offset * the index to insert at. * @param f * the {@code float} value to insert. * @return this builder. * @throws StringIndexOutOfBoundsException * if {@code offset} is negative or greater than the current * {@code length()}. * @see String#valueOf(float) */ public StringBuilder insert(int offset, float f) { insert0(offset, Float.toString(f)); return(this); }
/* * Appends the string representation of the specified {@code float} value. * The {@code float} value is converted to a string according to the rule * defined by {@link String#valueOf(float)}. * * @param f * the {@code float} value to append. * @return this builder. * @see String#valueOf(float) */ public StringBuilder append(float f) { append0(Float.toString(f)); return(this); }
/* * Inserts the string representation of the specified float into this buffer * at the specified offset. * * @param index * the index at which to insert. * @param f * the float to insert. * @return this buffer. * @throws StringIndexOutOfBoundsException * if {@code index < 0} or {@code index > length()}. */ public java.lang.StringBuffer insert(int index, float f) { return(insert(index, Float.toString(f))); }
/* * Adds the string representation of the specified float to the end of this * StringBuffer. * * @param f * the float to append. * @return this StringBuffer. * @see String#valueOf(float) */ public java.lang.StringBuffer append(float f) { return(append(Float.toString(f))); }
//, Comparable<Float> { public static java.lang.Float valueOf(String d) { System.Single sysD = Convert.ToSingle(d); Float returnValue = new Float(sysD); return returnValue; }