1# func reverse(value: u8) -> u8: 

2# """Reverse the bit order. 

3# 

4# """ 

5# 

6# value = ((value & 0xaa) >> 1) | ((value & 0x55) << 1) 

7# value = ((value & 0xcc) >> 2) | ((value & 0x33) << 2) 

8# 

9# return ((value & 0xf0) >> 4) | ((value & 0x0f) << 4) 

10 

11func reverse(value: u32) -> u32: 

12 """Reverse the bit order. 

13 

14 """ 

15 

16 value = ((value & 0xaaaaaaaa) >> 1) | ((value & 0x55555555) << 1) 

17 value = ((value & 0xcccccccc) >> 2) | ((value & 0x33333333) << 2) 

18 value = ((value & 0xf0f0f0f0) >> 4) | ((value & 0x0f0f0f0f) << 4) 

19 value = ((value & 0xff00ff00) >> 8) | ((value & 0x00ff00ff) << 8) 

20 

21 return (value >> 16) | (value << 16) 

22 

23func leading_ones(value: u32) -> u32: 

24 """Count number of leading bits that are one. 

25 

26 """ 

27 

28 for i in range(32): 

29 if (value & (0x80000000 >> u32(i))) == 0: 

30 return u32(i) 

31 

32 return 32 

33 

34func leading_zeros(value: u32) -> u32: 

35 """Count number of leading bits that are zero. 

36 

37 """ 

38 

39 return leading_ones(~value) 

40 

41func count_ones(value: u32) -> u32: 

42 """Count number of bits that are one. 

43 

44 """ 

45 

46 value = value - ((value >> 1) & 0x55555555) 

47 value = (value & 0x33333333) + ((value >> 2) & 0x33333333) 

48 

49 return (((value + (value >> 4)) & 0x0f0f0f0f) * 0x01010101) >> 24 

50 

51func count_zeros(value: u32) -> u32: 

52 """Count number of bits that are zero. 

53 

54 """ 

55 

56 return count_ones(~value) 

57 

58func rotate_left(value: u32, count: u32) -> u32: 

59 """Rotate bits left count times. 

60 

61 """ 

62 

63 count %= 32 

64 

65 return (value << count) | (value >> (32 - count)) 

66 

67func rotate_right(value: u32, count: u32) -> u32: 

68 """Rotate bits right count times. 

69 

70 """ 

71 

72 count %= 32 

73 

74 return (value >> count) | (value << (32 - count)) 

75 

76# @test 

77# func test_reverse_u8(): 

78# value: u8 = 0x12 

79# assert reverse(value) == 0x48 

80 

81test reverse_u32(): 

82 value: u32 = 0x12345678 

83 assert reverse(value) == 0x1e6a2c48 

84 

85test leading_ones(): 

86 value: u32 = 0x00000000 

87 assert leading_ones(value) == 0 

88 

89 value = 0x80000000 

90 assert leading_ones(value) == 1 

91 

92 value = 0xffffffff 

93 assert leading_ones(value) == 32 

94 

95 value = 0xffffffef 

96 assert leading_ones(value) == 27 

97 

98test leading_zeros(): 

99 value: u32 = 0xffffffff 

100 assert leading_zeros(value) == 0 

101 

102 value = 0x7fffffff 

103 assert leading_zeros(value) == 1 

104 

105 value = 0x00000000 

106 assert leading_zeros(value) == 32 

107 

108 value = 0x00000010 

109 assert leading_zeros(value) == 27 

110 

111test count_ones(): 

112 value: u32 = 0x00000000 

113 assert count_ones(value) == 0 

114 

115 value = 0x10003000 

116 assert count_ones(value) == 3 

117 

118 value = 0xffffffff 

119 assert count_ones(value) == 32 

120 

121test count_zeros(): 

122 value: u32 = 0xffffffff 

123 assert count_zeros(value) == 0 

124 

125 value = 0xefffcfff 

126 assert count_zeros(value) == 3 

127 

128 value = 0x00000000 

129 assert count_zeros(value) == 32 

130 

131test rotate_left(): 

132 value: u32 = 0x12345678 

133 assert rotate_left(value, 8) == 0x34567812 

134 assert rotate_left(value, 8 + 32) == 0x34567812 

135 

136 value = 0x00000001 

137 assert rotate_left(value, 1) == 0x00000002 

138 

139test rotate_right(): 

140 value: u32 = 0x12345678 

141 assert rotate_right(value, 8) == 0x78123456 

142 assert rotate_right(value, 8 + 32) == 0x78123456 

143 

144 value = 0x00000001 

145 assert rotate_right(value, 1) == 0x80000000