blob: b8b3a90d7553235836cd1185c2f9d69b0322a4f9 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
|
class Integer
# call-seq:
# -int -> integer
#
# Returns +int+, negated.
def -@
Primitive.attr! 'inline'
Primitive.cexpr! 'rb_int_uminus(self)'
end
# call-seq:
# ~int -> integer
#
# One's complement: returns a number where each bit is flipped.
#
# Inverts the bits in an Integer. As integers are conceptually of
# infinite length, the result acts as if it had an infinite number of
# one bits to the left. In hex representations, this is displayed
# as two periods to the left of the digits.
#
# sprintf("%X", ~0x1122334455) #=> "..FEEDDCCBBAA"
def ~
Primitive.attr! 'inline'
Primitive.cexpr! 'rb_int_comp(self)'
end
def abs
Primitive.attr! 'inline'
Primitive.cexpr! 'rb_int_abs(self)'
end
# call-seq:
# int.bit_length -> integer
#
# Returns the number of bits of the value of +int+.
#
# "Number of bits" means the bit position of the highest bit
# which is different from the sign bit
# (where the least significant bit has bit position 1).
# If there is no such bit (zero or minus one), zero is returned.
#
# I.e. this method returns <i>ceil(log2(int < 0 ? -int : int+1))</i>.
#
# (-2**1000-1).bit_length #=> 1001
# (-2**1000).bit_length #=> 1000
# (-2**1000+1).bit_length #=> 1000
# (-2**12-1).bit_length #=> 13
# (-2**12).bit_length #=> 12
# (-2**12+1).bit_length #=> 12
# -0x101.bit_length #=> 9
# -0x100.bit_length #=> 8
# -0xff.bit_length #=> 8
# -2.bit_length #=> 1
# -1.bit_length #=> 0
# 0.bit_length #=> 0
# 1.bit_length #=> 1
# 0xff.bit_length #=> 8
# 0x100.bit_length #=> 9
# (2**12-1).bit_length #=> 12
# (2**12).bit_length #=> 13
# (2**12+1).bit_length #=> 13
# (2**1000-1).bit_length #=> 1000
# (2**1000).bit_length #=> 1001
# (2**1000+1).bit_length #=> 1001
#
# This method can be used to detect overflow in Array#pack as follows:
#
# if n.bit_length < 32
# [n].pack("l") # no overflow
# else
# raise "overflow"
# end
def bit_length
Primitive.attr! 'inline'
Primitive.cexpr! 'rb_int_bit_length(self)'
end
# call-seq:
# int.even? -> true or false
#
# Returns +true+ if +int+ is an even number.
def even?
Primitive.attr! 'inline'
Primitive.cexpr! 'rb_int_even_p(self)'
end
# call-seq:
# int.integer? -> true
#
# Since +int+ is already an Integer, this always returns +true+.
def integer?
return true
end
def magnitude
Primitive.attr! 'inline'
Primitive.cexpr! 'rb_int_abs(self)'
end
# call-seq:
# int.odd? -> true or false
#
# Returns +true+ if +int+ is an odd number.
def odd?
Primitive.attr! 'inline'
Primitive.cexpr! 'rb_int_odd_p(self)'
end
# call-seq:
# int.ord -> self
#
# Returns the +int+ itself.
#
# 97.ord #=> 97
#
# This method is intended for compatibility to character literals
# in Ruby 1.9.
#
# For example, <code>?a.ord</code> returns 97 both in 1.8 and 1.9.
def ord
return self
end
# call-seq:
# int.to_i -> integer
#
# Since +int+ is already an Integer, returns +self+.
#
# #to_int is an alias for #to_i.
def to_i
return self
end
# call-seq:
# int.to_int -> integer
#
# Since +int+ is already an Integer, returns +self+.
def to_int
return self
end
# call-seq:
# int.zero? -> true or false
#
# Returns +true+ if +int+ has a zero value.
def zero?
Primitive.attr! 'inline'
Primitive.cexpr! 'rb_int_zero_p(self)'
end
end
class Float
#
# call-seq:
# float.to_f -> self
#
# Since +float+ is already a Float, returns +self+.
#
def to_f
return self
end
#
# call-seq:
# float.abs -> float
# float.magnitude -> float
#
# Returns the absolute value of +float+.
#
# (-34.56).abs #=> 34.56
# -34.56.abs #=> 34.56
# 34.56.abs #=> 34.56
#
# Float#magnitude is an alias for Float#abs.
#
def abs
Primitive.attr! 'inline'
Primitive.cexpr! 'rb_float_abs(self)'
end
def magnitude
Primitive.attr! 'inline'
Primitive.cexpr! 'rb_float_abs(self)'
end
#
# call-seq:
# -float -> float
#
# Returns +float+, negated.
#
def -@
Primitive.attr! 'inline'
Primitive.cexpr! 'rb_float_uminus(self)'
end
#
# call-seq:
# float.zero? -> true or false
#
# Returns +true+ if +float+ is 0.0.
#
def zero?
Primitive.attr! 'inline'
Primitive.cexpr! 'flo_iszero(self) ? Qtrue : Qfalse'
end
end
|
