/** * Returns an {@code UnsignedInteger} corresponding to a given bit representation. The argument is * interpreted as an unsigned 32-bit value. Specifically, the sign bit of {@code bits} is * interpreted as a normal bit, and all other bits are treated as usual. * * <p>If the argument is nonnegative, the returned result will be equal to {@code bits}, * otherwise, the result will be equal to {@code 2^32 + bits}. * * <p>To represent unsigned decimal constants, consider {@link #valueOf(long)} instead. * * @since 14.0 */ public static UnsignedInteger fromIntBits(int bits) { return new UnsignedInteger(bits); }
/** * Returns an {@code UnsignedInteger} corresponding to a given bit representation. The argument is * interpreted as an unsigned 32-bit value. Specifically, the sign bit of {@code bits} is * interpreted as a normal bit, and all other bits are treated as usual. * * <p>If the argument is nonnegative, the returned result will be equal to {@code bits}, * otherwise, the result will be equal to {@code 2^32 + bits}. * * <p>To represent unsigned decimal constants, consider {@link #valueOf(long)} instead. * * @since 14.0 */ public static UnsignedInteger fromIntBits(int bits) { return new UnsignedInteger(bits); }
/** * Returns an {@code UnsignedInteger} corresponding to a given bit representation. The argument is * interpreted as an unsigned 32-bit value. Specifically, the sign bit of {@code bits} is * interpreted as a normal bit, and all other bits are treated as usual. * * <p>If the argument is nonnegative, the returned result will be equal to {@code bits}, * otherwise, the result will be equal to {@code 2^32 + bits}. * * <p>To represent unsigned decimal constants, consider {@link #valueOf(long)} instead. * * @since 14.0 */ public static UnsignedInteger fromIntBits(int bits) { return new UnsignedInteger(bits); }
/** * Returns an {@code UnsignedInteger} that, when treated as signed, is * equal to {@code value}. */ public static UnsignedInteger asUnsigned(int value) { return new UnsignedInteger(value); }
/** * Returns an {@code UnsignedInteger} corresponding to a given bit representation. * The argument is interpreted as an unsigned 32-bit value. Specifically, the sign bit * of {@code bits} is interpreted as a normal bit, and all other bits are treated as usual. * * <p>If the argument is nonnegative, the returned result will be equal to {@code bits}, * otherwise, the result will be equal to {@code 2^32 + bits}. * * <p>To represent unsigned decimal constants, consider {@link #valueOf(long)} instead. * * @since 14.0 */ public static UnsignedInteger fromIntBits(int bits) { return new UnsignedInteger(bits); }
/** * Returns an {@code UnsignedInteger} corresponding to a given bit representation. * The argument is interpreted as an unsigned 32-bit value. Specifically, the sign bit * of {@code bits} is interpreted as a normal bit, and all other bits are treated as usual. * * <p>If the argument is nonnegative, the returned result will be equal to {@code bits}, * otherwise, the result will be equal to {@code 2^32 + bits}. * * <p>To represent unsigned decimal constants, consider {@link #valueOf(long)} instead. * * @since 14.0 */ public static UnsignedInteger fromIntBits(int bits) { return new UnsignedInteger(bits); }
/** * Returns an {@code UnsignedInteger} corresponding to a given bit representation. * The argument is interpreted as an unsigned 32-bit value. Specifically, the sign bit * of {@code bits} is interpreted as a normal bit, and all other bits are treated as usual. * * <p>If the argument is nonnegative, the returned result will be equal to {@code bits}, * otherwise, the result will be equal to {@code 2^32 + bits}. * * <p>To represent unsigned decimal constants, consider {@link #valueOf(long)} instead. * * @since 14.0 */ public static UnsignedInteger fromIntBits(int bits) { return new UnsignedInteger(bits); }
/** * Returns an {@code UnsignedInteger} corresponding to a given bit representation. * The argument is interpreted as an unsigned 32-bit value. Specifically, the sign bit * of {@code bits} is interpreted as a normal bit, and all other bits are treated as usual. * * <p>If the argument is nonnegative, the returned result will be equal to {@code bits}, * otherwise, the result will be equal to {@code 2^32 + bits}. * * <p>To represent unsigned decimal constants, consider {@link #valueOf(long)} instead. * * @since 14.0 */ public static UnsignedInteger fromIntBits(int bits) { return new UnsignedInteger(bits); }
/** * Returns an {@code UnsignedInteger} corresponding to a given bit representation. * The argument is interpreted as an unsigned 32-bit value. Specifically, the sign bit * of {@code bits} is interpreted as a normal bit, and all other bits are treated as usual. * * <p>If the argument is nonnegative, the returned result will be equal to {@code bits}, * otherwise, the result will be equal to {@code 2^32 + bits}. * * <p>To represent unsigned decimal constants, consider {@link #valueOf(long)} instead. * * @since 14.0 */ public static UnsignedInteger fromIntBits(int bits) { return new UnsignedInteger(bits); }
/** * Returns an {@code UnsignedInteger} corresponding to a given bit representation. * The argument is interpreted as an unsigned 32-bit value. Specifically, the sign bit * of {@code bits} is interpreted as a normal bit, and all other bits are treated as usual. * * <p>If the argument is nonnegative, the returned result will be equal to {@code bits}, * otherwise, the result will be equal to {@code 2^32 + bits}. * * <p>To represent unsigned decimal constants, consider {@link #valueOf(long)} instead. * * @since 14.0 */ public static UnsignedInteger fromIntBits(int bits) { return new UnsignedInteger(bits); }
/** * Returns an {@code UnsignedInteger} corresponding to a given bit representation. * The argument is interpreted as an unsigned 32-bit value. Specifically, the sign bit * of {@code bits} is interpreted as a normal bit, and all other bits are treated as usual. * * <p>If the argument is nonnegative, the returned result will be equal to {@code bits}, * otherwise, the result will be equal to {@code 2^32 + bits}. * * <p>To represent unsigned decimal constants, consider {@link #valueOf(long)} instead. * * @since 14.0 */ public static UnsignedInteger fromIntBits(int bits) { return new UnsignedInteger(bits); }
/** * Returns an {@code UnsignedInteger} corresponding to a given bit representation. The argument is * interpreted as an unsigned 32-bit value. Specifically, the sign bit of {@code bits} is * interpreted as a normal bit, and all other bits are treated as usual. * * <p>If the argument is nonnegative, the returned result will be equal to {@code bits}, * otherwise, the result will be equal to {@code 2^32 + bits}. * * <p>To represent unsigned decimal constants, consider {@link #valueOf(long)} instead. * * @since 14.0 */ public static UnsignedInteger fromIntBits(int bits) { return new UnsignedInteger(bits); }
/** * Returns an {@code UnsignedInteger} corresponding to a given bit representation. The argument is * interpreted as an unsigned 32-bit value. Specifically, the sign bit of {@code bits} is * interpreted as a normal bit, and all other bits are treated as usual. * * <p>If the argument is nonnegative, the returned result will be equal to {@code bits}, * otherwise, the result will be equal to {@code 2^32 + bits}. * * <p>To represent unsigned decimal constants, consider {@link #valueOf(long)} instead. * * @since 14.0 */ public static UnsignedInteger fromIntBits(int bits) { return new UnsignedInteger(bits); }
/** * Returns an {@code UnsignedInteger} corresponding to a given bit representation. * The argument is interpreted as an unsigned 32-bit value. Specifically, the sign bit * of {@code bits} is interpreted as a normal bit, and all other bits are treated as usual. * * <p>If the argument is nonnegative, the returned result will be equal to {@code bits}, * otherwise, the result will be equal to {@code 2^32 + bits}. * * <p>To represent unsigned decimal constants, consider {@link #valueOf(long)} instead. * * @since 14.0 */ public static UnsignedInteger fromIntBits(int bits) { return new UnsignedInteger(bits); }