/** * 获得数字对应的二进制字符串 * * @param number 数字 * @return 二进制字符串 */ public static String getBinaryStr(Number number) { if (number instanceof Long) { return Long.toBinaryString((Long) number); } else if (number instanceof Integer) { return Integer.toBinaryString((Integer) number); } else { return Long.toBinaryString(number.longValue()); } }
public static void print(double d){ System.out.println(Long.toBinaryString(Double.doubleToRawLongBits(d))); }
@Override public String apply(Number input) { if (input instanceof Long) { return "0b" + Long.toBinaryString(input.longValue()) + "L"; } if (input instanceof Integer) { return "0b" + Integer.toBinaryString(input.intValue()); } throw new IllegalArgumentException("unsupported non integer or long " + input); }
float f = 0.27f; double d2 = (double) f; double d3 = 0.27d; System.out.println(Integer.toBinaryString(Float.floatToRawIntBits(f))); System.out.println(Long.toBinaryString(Double.doubleToRawLongBits(d2))); System.out.println(Long.toBinaryString(Double.doubleToRawLongBits(d3)));
/** * return binary string of bitbuf */ public String toString() { String s = "00000000000000000000000000000000" + Long.toBinaryString(bitbuf); s = s.substring(s.length() - 32); return s.substring(0, 8) + " " + s.substring(8, 16) + " " + s.substring(16, 24) + " " + s.substring(24, 32) + " " + bitsLeft; } }
@Override protected String toStringOf(Long l) { return toGroupedBinary(Long.toBinaryString(l), 64); }
public static String toBinaryString(int value) { String formatted = Long.toBinaryString( value ); StringBuilder buf = new StringBuilder( StringHelper.repeat( '0', 32 ) ); buf.replace( 64 - formatted.length(), 64, formatted ); return buf.toString(); }
public static String toBinaryString(long value) { String formatted = Long.toBinaryString( value ); StringBuilder buf = new StringBuilder( StringHelper.repeat( '0', 64 ) ); buf.replace( 64 - formatted.length(), 64, formatted ); return buf.toString(); } }
protected String toStringOf(Double d) { return toGroupedBinary(Long.toBinaryString(Double.doubleToRawLongBits(d)), 64); }
@Override public void writeLong(BlockBuilder blockBuilder, long value) { try { toIntExact(value); } catch (ArithmeticException e) { throw new PrestoException(GENERIC_INTERNAL_ERROR, format("Value (%sb) is not a valid single-precision float", Long.toBinaryString(value).replace(' ', '0'))); } blockBuilder.writeInt((int) value).closeEntry(); }
@Override public void writeLong(BlockBuilder blockBuilder, long value) { try { toIntExact(value); } catch (ArithmeticException e) { throw new PrestoException(GENERIC_INTERNAL_ERROR, format("Value (%sb) is not a valid single-precision float", Long.toBinaryString(value).replace(' ', '0'))); } blockBuilder.writeInt((int) value).closeEntry(); }
/** 测试 */ public static void main(String[] args) { SnowflakeIdWorker idWorker = new SnowflakeIdWorker(0, 0); for (int i = 0; i < 1000; i++) { long id = idWorker.nextId(); System.out.println(Long.toBinaryString(id)); System.out.println(id); } }
public static BuilderInstruction buildConstant(double value, int register) { long longBits = Double.doubleToLongBits(value); String binaryValue = Long.toBinaryString(longBits); BuilderInstruction result; if (binaryValue.endsWith(LAST_48_BITS_ZERO)) { result = new BuilderInstruction21lh(Opcode.CONST_WIDE_HIGH16, register, longBits); } else { result = new BuilderInstruction51l(Opcode.CONST_WIDE, register, longBits); } return result; }
private static String dumpRef(long ref) { return StringUtils.leftPad(Long.toBinaryString(ref), 64, "0") + " o=" + Ref.getOffset(ref) + " s=" + Ref.getStateByte(ref) + " l=" + Ref.hasList(ref) + " h=" + Long.toBinaryString(Ref.getHashBits(ref)); }
static String toString(Collection<Long> cuboids) { StringBuilder buf = new StringBuilder(); buf.append("["); for (Long l : cuboids) { if (buf.length() > 1) buf.append(","); buf.append(l).append("(").append(Long.toBinaryString(l)).append(")"); } buf.append("]"); return buf.toString(); }
@Test public void testStableIdCalculation() { mLayoutOutput.setComponent(mTestComponent); long stableId = calculateLayoutOutputId(mLayoutOutput, LEVEL_TEST, OutputUnitType.CONTENT, SEQ_TEST); long stableIdSeq2 = calculateLayoutOutputId( mLayoutOutput, LEVEL_TEST + 1, OutputUnitType.CONTENT, SEQ_TEST + 1); assertThat(toBinaryString(stableId)).isEqualTo("100000001000000000000000001"); assertThat(toBinaryString(stableIdSeq2)).isEqualTo("100000010000000000000000010"); }
@Test public void testStableIdCalculation() { mVisibilityOutput.setComponent(mComponent); long stableId = calculateVisibilityOutputId( mVisibilityOutput, LEVEL_TEST, SEQ_TEST); long stableIdSeq2 = calculateVisibilityOutputId( mVisibilityOutput, LEVEL_TEST + 1, SEQ_TEST + 1); assertThat(toBinaryString(stableId)).isEqualTo("100000001000000000000000001"); assertThat(toBinaryString(stableIdSeq2)).isEqualTo("100000010000000000000000010"); }
@Test public void testStableIdForegroundType() { mLayoutOutput.setComponent(mTestComponent); mLayoutOutput.setId( calculateLayoutOutputId(mLayoutOutput, LEVEL_TEST, OutputUnitType.FOREGROUND, SEQ_TEST)); long stableId = mLayoutOutput.getId(); assertThat(toBinaryString(stableId)).isEqualTo("100000001100000000000000001"); }
@Test public void testStableIdBackgroundType() { mLayoutOutput.setComponent(mTestComponent); mLayoutOutput.setId( calculateLayoutOutputId(mLayoutOutput, LEVEL_TEST, OutputUnitType.BACKGROUND, SEQ_TEST)); long stableId = mLayoutOutput.getId(); assertThat(toBinaryString(stableId)).isEqualTo("100000001010000000000000001"); }
@Test public void testStableIdHostType() { mLayoutOutput.setComponent(mTestComponent); mLayoutOutput.setId( calculateLayoutOutputId(mLayoutOutput, LEVEL_TEST, OutputUnitType.HOST, SEQ_TEST)); long stableId = mLayoutOutput.getId(); assertThat(toBinaryString(stableId)).isEqualTo("100000001110000000000000001"); }