Class: Numeric

44
45
46

# File 'opal/opal/corelib/numeric.rb', line 44
def %(other)
 self - other * div(other)
end

36
37
38

# File 'opal/opal/corelib/numeric.rb', line 36
def +@
 self
end

40
41
42

# File 'opal/opal/corelib/numeric.rb', line 40
def -@
 0 - self
end

28
29
30
31
32
33
34

# File 'opal/opal/corelib/numeric.rb', line 28
def <=>(other)
 if equal? other
 return 0
 end
 nil
end

14
15
16
17
18
19
20
21
22
23
24
25
26

# File 'opal/opal/corelib/numeric.rb', line 14
def __coerced__(method, other)
 if other.respond_to?(:coerce)
 a, b = other.coerce(self)
 a.__send__ method, b
 else
 case method
 when :+, :-, :*, :/, :%, :&, :|, :^, :**
 raise TypeError , "#{other.class} can't be coerced into Numeric"
 when :>, :>=, :<, :<=, :<=>
 raise ArgumentError , "comparison of #{self.class} with #{other.class} failed"
 end
 end
end

48
49
50

# File 'opal/opal/corelib/numeric.rb', line 48
def abs
 self < 0 ? -self : self
end

52
53
54

# File 'opal/opal/corelib/numeric.rb', line 52
def abs2
 self * self
end

56
57
58

# File 'opal/opal/corelib/numeric.rb', line 56
def angle
 self < 0 ? Math ::PI  : 0
end

62
63
64

# File 'opal/opal/corelib/numeric.rb', line 62
def ceil(ndigits = 0)
 to_f.ceil(ndigits)
end

332
333
334

# File 'opal/opal/corelib/numeric.rb', line 332
def clone(freeze: true)
 self
end

6
7
8
9
10
11
12

# File 'opal/opal/corelib/numeric.rb', line 6
def coerce(other)
 if other.instance_of? self.class
 return [other, self]
 end
 [Float (other), Float (self)]
end

66
67
68

# File 'opal/opal/corelib/numeric.rb', line 66
def conj
 self
end

72
73
74

# File 'opal/opal/corelib/numeric.rb', line 72
def denominator
 to_r.denominator
end

76
77
78
79
80

# File 'opal/opal/corelib/numeric.rb', line 76
def div(other)
 raise ZeroDivisionError , 'divided by o' if other == 0
 (self / other).floor
end

82
83
84

# File 'opal/opal/corelib/numeric.rb', line 82
def divmod(other)
 [div(other), self % other]
end

328
329
330

# File 'opal/opal/corelib/numeric.rb', line 328
def dup
 self
end

86
87
88

# File 'opal/opal/corelib/numeric.rb', line 86
def fdiv(other)
 to_f / other
end

336
337
338

# File 'opal/opal/corelib/numeric.rb', line 336
def finite?
 true
end

90
91
92

# File 'opal/opal/corelib/numeric.rb', line 90
def floor(ndigits = 0)
 to_f.floor(ndigits)
end

94
95
96

# File 'opal/opal/corelib/numeric.rb', line 94
def i
 Complex (0, self)
end

98
99
100

# File 'opal/opal/corelib/numeric.rb', line 98
def imag
 0
end

340
341
342

# File 'opal/opal/corelib/numeric.rb', line 340
def infinite?
 nil
end

104
105
106

# File 'opal/opal/corelib/numeric.rb', line 104
def integer?
 false
end

324
325
326

# File 'opal/opal/corelib/numeric.rb', line 324
def negative?
 self < 0
end

112
113
114

# File 'opal/opal/corelib/numeric.rb', line 112
def nonzero?
 zero? ? nil : self
end

116
117
118

# File 'opal/opal/corelib/numeric.rb', line 116
def numerator
 to_r.numerator
end

122
123
124

# File 'opal/opal/corelib/numeric.rb', line 122
def polar
 [abs, arg]
end

320
321
322

# File 'opal/opal/corelib/numeric.rb', line 320
def positive?
 self > 0
end

126
127
128

# File 'opal/opal/corelib/numeric.rb', line 126
def quo(other)
 Opal .coerce_to! (self, Rational , :to_r) / other
end

130
131
132

# File 'opal/opal/corelib/numeric.rb', line 130
def real
 self
end

134
135
136

# File 'opal/opal/corelib/numeric.rb', line 134
def real?
 true
end

138
139
140

# File 'opal/opal/corelib/numeric.rb', line 138
def rect
 [self, 0]
end

144
145
146

# File 'opal/opal/corelib/numeric.rb', line 144
def round(digits = undefined)
 to_f.round(digits)
end

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
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302

# File 'opal/opal/corelib/numeric.rb', line 148
def step(limit = undefined, step = undefined, to: undefined, by: undefined, &block)
 %x{
 if (limit !== undefined && to !== undefined) {
 #{raise ArgumentError , 'to is given twice'}
 }
 if (step !== undefined && by !== undefined) {
 #{raise ArgumentError , 'step is given twice'}
 }
 if (to !== undefined) {
 limit = to;
 }
 if (by !== undefined) {
 step = by;
 }
 if (limit === undefined) {
 limit = nil;
 }
 function validateParameters() {
 if (step === nil) {
 #{raise TypeError , 'step must be numeric'}
 }
 if (step != null && #{step == 0}) {
 #{raise ArgumentError , "step can't be 0"}
 }
 if (step === nil || step == null) {
 step = 1;
 }
 var sign = #{step <=> 0};
 if (sign === nil) {
 #{raise ArgumentError , "0 can't be coerced into #{step.class}"}
 }
 if (limit === nil || limit == null) {
 limit = sign > 0 ? #{Float ::INFINITY } : #{-Float ::INFINITY };
 }
 #{Opal .compare (self, limit)}
 }
 function stepFloatSize() {
 if ((step > 0 && self > limit) || (step < 0 && self < limit)) {
 return 0;
 } else if (step === Infinity || step === -Infinity) {
 return 1;
 } else {
 var abs = Math.abs, floor = Math.floor,
 err = (abs(self) + abs(limit) + abs(limit - self)) / abs(step) * #{Float ::EPSILON };
 if (err === Infinity || err === -Infinity) {
 return 0;
 } else {
 if (err > 0.5) {
 err = 0.5;
 }
 return floor((limit - self) / step + err) + 1
 }
 }
 }
 function stepSize() {
 validateParameters();
 if (step === 0) {
 return Infinity;
 }
 if (step % 1 !== 0) {
 return stepFloatSize();
 } else if ((step > 0 && self > limit) || (step < 0 && self < limit)) {
 return 0;
 } else {
 var ceil = Math.ceil, abs = Math.abs,
 lhs = abs(self - limit) + 1,
 rhs = abs(step);
 return ceil(lhs / rhs);
 }
 }
 }
 return enum_for(:step, limit, step, &`stepSize`) unless block_given?
 %x{
 validateParameters();
 var isDesc = #{step.negative?},
 isInf = #{step == 0} ||
 (limit === Infinity && !isDesc) ||
 (limit === -Infinity && isDesc);
 if (self.$$is_number && step.$$is_number && limit.$$is_number) {
 if (self % 1 === 0 && (isInf || limit % 1 === 0) && step % 1 === 0) {
 var value = self;
 if (isInf) {
 for (;; value += step) {
 block(value);
 }
 } else if (isDesc) {
 for (; value >= limit; value += step) {
 block(value);
 }
 } else {
 for (; value <= limit; value += step) {
 block(value);
 }
 }
 return self;
 } else {
 var begin = #{to_f}.valueOf();
 step = #{step.to_f}.valueOf();
 limit = #{limit.to_f}.valueOf();
 var n = stepFloatSize();
 if (!isFinite(step)) {
 if (n !== 0) block(begin);
 } else if (step === 0) {
 while (true) {
 block(begin);
 }
 } else {
 for (var i = 0; i < n; i++) {
 var d = i * step + self;
 if (step >= 0 ? limit < d : limit > d) {
 d = limit;
 }
 block(d);
 }
 }
 return self;
 }
 }
 }
 counter = self
 while `isDesc ? #{counter >= limit} : #{counter <= limit}`
 yield counter
 counter += step
 end
end

304
305
306

# File 'opal/opal/corelib/numeric.rb', line 304
def to_c
 Complex (self, 0)
end

308
309
310

# File 'opal/opal/corelib/numeric.rb', line 308
def to_int
 to_i
end

312
313
314

# File 'opal/opal/corelib/numeric.rb', line 312
def truncate(ndigits = 0)
 to_f.truncate(ndigits)
end

316
317
318

# File 'opal/opal/corelib/numeric.rb', line 316
def zero?
 self == 0
end