Mercurial > hg > graal-compiler
comparison graal/com.oracle.truffle.ruby.nodes/src/com/oracle/truffle/ruby/nodes/core/FloatNodes.java @ 13529:856c2c294f84
Merge.
author | Christian Humer <christian.humer@gmail.com> |
---|---|
date | Tue, 07 Jan 2014 18:53:04 +0100 |
parents | 0fbee3eb71f0 |
children |
comparison
equal
deleted
inserted
replaced
13528:5a0c694ef735 | 13529:856c2c294f84 |
---|---|
1 /* | |
2 * Copyright (c) 2013 Oracle and/or its affiliates. All rights reserved. This | |
3 * code is released under a tri EPL/GPL/LGPL license. You can use it, | |
4 * redistribute it and/or modify it under the terms of the: | |
5 * | |
6 * Eclipse Public License version 1.0 | |
7 * GNU General Public License version 2 | |
8 * GNU Lesser General Public License version 2.1 | |
9 */ | |
10 package com.oracle.truffle.ruby.nodes.core; | |
11 | |
12 import java.math.*; | |
13 | |
14 import com.oracle.truffle.api.*; | |
15 import com.oracle.truffle.api.dsl.*; | |
16 import com.oracle.truffle.ruby.runtime.*; | |
17 import com.oracle.truffle.ruby.runtime.core.*; | |
18 import com.oracle.truffle.ruby.runtime.core.array.*; | |
19 | |
20 @CoreClass(name = "Float") | |
21 public abstract class FloatNodes { | |
22 | |
23 @CoreMethod(names = "+@", maxArgs = 0) | |
24 public abstract static class PosNode extends CoreMethodNode { | |
25 | |
26 public PosNode(RubyContext context, SourceSection sourceSection) { | |
27 super(context, sourceSection); | |
28 } | |
29 | |
30 public PosNode(PosNode prev) { | |
31 super(prev); | |
32 } | |
33 | |
34 @Specialization | |
35 public double pos(double value) { | |
36 return value; | |
37 } | |
38 | |
39 } | |
40 | |
41 @CoreMethod(names = "-@", maxArgs = 0) | |
42 public abstract static class NegNode extends CoreMethodNode { | |
43 | |
44 public NegNode(RubyContext context, SourceSection sourceSection) { | |
45 super(context, sourceSection); | |
46 } | |
47 | |
48 public NegNode(NegNode prev) { | |
49 super(prev); | |
50 } | |
51 | |
52 @Specialization | |
53 public double neg(double value) { | |
54 return -value; | |
55 } | |
56 | |
57 } | |
58 | |
59 @CoreMethod(names = "+", minArgs = 1, maxArgs = 1) | |
60 public abstract static class AddNode extends CoreMethodNode { | |
61 | |
62 public AddNode(RubyContext context, SourceSection sourceSection) { | |
63 super(context, sourceSection); | |
64 } | |
65 | |
66 public AddNode(AddNode prev) { | |
67 super(prev); | |
68 } | |
69 | |
70 @Specialization | |
71 public double add(double a, int b) { | |
72 return a + b; | |
73 } | |
74 | |
75 @Specialization | |
76 public double add(double a, double b) { | |
77 return a + b; | |
78 } | |
79 | |
80 @Specialization | |
81 public double add(double a, BigInteger b) { | |
82 return a + b.doubleValue(); | |
83 } | |
84 | |
85 } | |
86 | |
87 @CoreMethod(names = "-", minArgs = 1, maxArgs = 1) | |
88 public abstract static class SubNode extends CoreMethodNode { | |
89 | |
90 public SubNode(RubyContext context, SourceSection sourceSection) { | |
91 super(context, sourceSection); | |
92 } | |
93 | |
94 public SubNode(SubNode prev) { | |
95 super(prev); | |
96 } | |
97 | |
98 @Specialization | |
99 public double sub(double a, int b) { | |
100 return a - b; | |
101 } | |
102 | |
103 @Specialization | |
104 public double sub(double a, double b) { | |
105 return a - b; | |
106 } | |
107 | |
108 @Specialization | |
109 public double sub(double a, BigInteger b) { | |
110 return a - b.doubleValue(); | |
111 } | |
112 | |
113 } | |
114 | |
115 @CoreMethod(names = "*", minArgs = 1, maxArgs = 1) | |
116 public abstract static class MulNode extends CoreMethodNode { | |
117 | |
118 public MulNode(RubyContext context, SourceSection sourceSection) { | |
119 super(context, sourceSection); | |
120 } | |
121 | |
122 public MulNode(MulNode prev) { | |
123 super(prev); | |
124 } | |
125 | |
126 @Specialization | |
127 public double mul(double a, int b) { | |
128 return a * b; | |
129 } | |
130 | |
131 @Specialization | |
132 public double mul(double a, double b) { | |
133 return a * b; | |
134 } | |
135 | |
136 @Specialization | |
137 public double mul(double a, BigInteger b) { | |
138 return a * b.doubleValue(); | |
139 } | |
140 | |
141 } | |
142 | |
143 @CoreMethod(names = "**", minArgs = 1, maxArgs = 1) | |
144 public abstract static class PowNode extends CoreMethodNode { | |
145 | |
146 public PowNode(RubyContext context, SourceSection sourceSection) { | |
147 super(context, sourceSection); | |
148 } | |
149 | |
150 public PowNode(PowNode prev) { | |
151 super(prev); | |
152 } | |
153 | |
154 @Specialization | |
155 public double mul(double a, int b) { | |
156 return Math.pow(a, b); | |
157 } | |
158 | |
159 @Specialization | |
160 public double mul(double a, double b) { | |
161 return Math.pow(a, b); | |
162 } | |
163 | |
164 @Specialization | |
165 public double mul(double a, BigInteger b) { | |
166 return Math.pow(a, b.doubleValue()); | |
167 } | |
168 | |
169 } | |
170 | |
171 @CoreMethod(names = "/", minArgs = 1, maxArgs = 1) | |
172 public abstract static class DivNode extends CoreMethodNode { | |
173 | |
174 public DivNode(RubyContext context, SourceSection sourceSection) { | |
175 super(context, sourceSection); | |
176 } | |
177 | |
178 public DivNode(DivNode prev) { | |
179 super(prev); | |
180 } | |
181 | |
182 @Specialization | |
183 public double div(double a, int b) { | |
184 return a / b; | |
185 } | |
186 | |
187 @Specialization | |
188 public double div(double a, double b) { | |
189 return a / b; | |
190 } | |
191 | |
192 @Specialization | |
193 public double div(double a, BigInteger b) { | |
194 return a / b.doubleValue(); | |
195 } | |
196 | |
197 } | |
198 | |
199 @CoreMethod(names = "%", minArgs = 1, maxArgs = 1) | |
200 public abstract static class ModNode extends CoreMethodNode { | |
201 | |
202 public ModNode(RubyContext context, SourceSection sourceSection) { | |
203 super(context, sourceSection); | |
204 } | |
205 | |
206 public ModNode(ModNode prev) { | |
207 super(prev); | |
208 } | |
209 | |
210 @Specialization | |
211 public double mod(@SuppressWarnings("unused") double a, @SuppressWarnings("unused") int b) { | |
212 throw new UnsupportedOperationException(); | |
213 } | |
214 | |
215 @Specialization | |
216 public double mod(@SuppressWarnings("unused") double a, @SuppressWarnings("unused") double b) { | |
217 throw new UnsupportedOperationException(); | |
218 } | |
219 | |
220 @Specialization | |
221 public double mod(@SuppressWarnings("unused") double a, @SuppressWarnings("unused") BigInteger b) { | |
222 throw new UnsupportedOperationException(); | |
223 } | |
224 | |
225 } | |
226 | |
227 @CoreMethod(names = "divmod", minArgs = 1, maxArgs = 1) | |
228 public abstract static class DivModNode extends CoreMethodNode { | |
229 | |
230 public DivModNode(RubyContext context, SourceSection sourceSection) { | |
231 super(context, sourceSection); | |
232 } | |
233 | |
234 public DivModNode(DivModNode prev) { | |
235 super(prev); | |
236 } | |
237 | |
238 @Specialization | |
239 public RubyArray divMod(@SuppressWarnings("unused") double a, @SuppressWarnings("unused") int b) { | |
240 throw new UnsupportedOperationException(); | |
241 } | |
242 | |
243 @Specialization | |
244 public RubyArray divMod(@SuppressWarnings("unused") double a, @SuppressWarnings("unused") double b) { | |
245 throw new UnsupportedOperationException(); | |
246 } | |
247 | |
248 @Specialization | |
249 public RubyArray divMod(@SuppressWarnings("unused") double a, @SuppressWarnings("unused") BigInteger b) { | |
250 throw new UnsupportedOperationException(); | |
251 } | |
252 | |
253 } | |
254 | |
255 @CoreMethod(names = "<", minArgs = 1, maxArgs = 1) | |
256 public abstract static class LessNode extends CoreMethodNode { | |
257 | |
258 public LessNode(RubyContext context, SourceSection sourceSection) { | |
259 super(context, sourceSection); | |
260 } | |
261 | |
262 public LessNode(LessNode prev) { | |
263 super(prev); | |
264 } | |
265 | |
266 @Specialization | |
267 public boolean less(double a, int b) { | |
268 return a < b; | |
269 } | |
270 | |
271 @Specialization | |
272 public boolean less(double a, double b) { | |
273 return a < b; | |
274 } | |
275 | |
276 @Specialization | |
277 public boolean less(double a, BigInteger b) { | |
278 return BigInteger.valueOf((long) a).compareTo(b) < 0; | |
279 } | |
280 } | |
281 | |
282 @CoreMethod(names = "<=", minArgs = 1, maxArgs = 1) | |
283 public abstract static class LessEqualNode extends CoreMethodNode { | |
284 | |
285 public LessEqualNode(RubyContext context, SourceSection sourceSection) { | |
286 super(context, sourceSection); | |
287 } | |
288 | |
289 public LessEqualNode(LessEqualNode prev) { | |
290 super(prev); | |
291 } | |
292 | |
293 @Specialization | |
294 public boolean lessEqual(double a, int b) { | |
295 return a <= b; | |
296 } | |
297 | |
298 @Specialization | |
299 public boolean lessEqual(double a, double b) { | |
300 return a <= b; | |
301 } | |
302 | |
303 @Specialization | |
304 public boolean lessEqual(double a, BigInteger b) { | |
305 return BigInteger.valueOf((long) a).compareTo(b) <= 0; | |
306 } | |
307 } | |
308 | |
309 @CoreMethod(names = "==", minArgs = 1, maxArgs = 1) | |
310 public abstract static class EqualNode extends CoreMethodNode { | |
311 | |
312 public EqualNode(RubyContext context, SourceSection sourceSection) { | |
313 super(context, sourceSection); | |
314 } | |
315 | |
316 public EqualNode(EqualNode prev) { | |
317 super(prev); | |
318 } | |
319 | |
320 @Specialization | |
321 public boolean equal(double a, int b) { | |
322 return a == b; | |
323 } | |
324 | |
325 @Specialization | |
326 public boolean equal(double a, double b) { | |
327 return a == b; | |
328 } | |
329 | |
330 @Specialization | |
331 public boolean equal(double a, BigInteger b) { | |
332 return BigInteger.valueOf((long) a).compareTo(b) == 0; | |
333 } | |
334 } | |
335 | |
336 @CoreMethod(names = "!=", minArgs = 1, maxArgs = 1) | |
337 public abstract static class NotEqualNode extends CoreMethodNode { | |
338 | |
339 public NotEqualNode(RubyContext context, SourceSection sourceSection) { | |
340 super(context, sourceSection); | |
341 } | |
342 | |
343 public NotEqualNode(NotEqualNode prev) { | |
344 super(prev); | |
345 } | |
346 | |
347 @Specialization | |
348 public boolean notEqual(double a, int b) { | |
349 return a != b; | |
350 } | |
351 | |
352 @Specialization | |
353 public boolean notEqual(double a, double b) { | |
354 return a != b; | |
355 } | |
356 | |
357 @Specialization | |
358 public boolean notEqual(double a, BigInteger b) { | |
359 return BigInteger.valueOf((long) a).compareTo(b) != 0; | |
360 } | |
361 } | |
362 | |
363 @CoreMethod(names = ">=", minArgs = 1, maxArgs = 1) | |
364 public abstract static class GreaterEqualNode extends CoreMethodNode { | |
365 | |
366 public GreaterEqualNode(RubyContext context, SourceSection sourceSection) { | |
367 super(context, sourceSection); | |
368 } | |
369 | |
370 public GreaterEqualNode(GreaterEqualNode prev) { | |
371 super(prev); | |
372 } | |
373 | |
374 @Specialization | |
375 public boolean greaterEqual(double a, int b) { | |
376 return a >= b; | |
377 } | |
378 | |
379 @Specialization | |
380 public boolean greaterEqual(double a, double b) { | |
381 return a >= b; | |
382 } | |
383 | |
384 @Specialization | |
385 public boolean greaterEqual(double a, BigInteger b) { | |
386 return BigInteger.valueOf((long) a).compareTo(b) >= 0; | |
387 } | |
388 } | |
389 | |
390 @CoreMethod(names = ">", minArgs = 1, maxArgs = 1) | |
391 public abstract static class GreaterNode extends CoreMethodNode { | |
392 | |
393 public GreaterNode(RubyContext context, SourceSection sourceSection) { | |
394 super(context, sourceSection); | |
395 } | |
396 | |
397 public GreaterNode(GreaterNode prev) { | |
398 super(prev); | |
399 } | |
400 | |
401 @Specialization | |
402 public boolean equal(double a, int b) { | |
403 return a > b; | |
404 } | |
405 | |
406 @Specialization | |
407 public boolean equal(double a, double b) { | |
408 return a > b; | |
409 } | |
410 | |
411 @Specialization | |
412 public boolean equal(double a, BigInteger b) { | |
413 return BigInteger.valueOf((long) a).compareTo(b) > 0; | |
414 } | |
415 } | |
416 | |
417 @CoreMethod(names = "abs", maxArgs = 0) | |
418 public abstract static class AbsNode extends CoreMethodNode { | |
419 | |
420 public AbsNode(RubyContext context, SourceSection sourceSection) { | |
421 super(context, sourceSection); | |
422 } | |
423 | |
424 public AbsNode(AbsNode prev) { | |
425 super(prev); | |
426 } | |
427 | |
428 @Specialization | |
429 public double abs(double n) { | |
430 return Math.abs(n); | |
431 } | |
432 | |
433 } | |
434 | |
435 @CoreMethod(names = "inspect", maxArgs = 0) | |
436 public abstract static class InpsectNode extends CoreMethodNode { | |
437 | |
438 public InpsectNode(RubyContext context, SourceSection sourceSection) { | |
439 super(context, sourceSection); | |
440 } | |
441 | |
442 public InpsectNode(InpsectNode prev) { | |
443 super(prev); | |
444 } | |
445 | |
446 @Specialization | |
447 public RubyString inspect(double n) { | |
448 return getContext().makeString(Double.toString(n)); | |
449 } | |
450 | |
451 } | |
452 | |
453 @CoreMethod(names = "nonzero?", maxArgs = 0) | |
454 public abstract static class NonZeroNode extends CoreMethodNode { | |
455 | |
456 public NonZeroNode(RubyContext context, SourceSection sourceSection) { | |
457 super(context, sourceSection); | |
458 } | |
459 | |
460 public NonZeroNode(NonZeroNode prev) { | |
461 super(prev); | |
462 } | |
463 | |
464 @Specialization | |
465 public Object nonZero(double value) { | |
466 if (value == 0) { | |
467 return false; | |
468 } else { | |
469 return value; | |
470 } | |
471 } | |
472 | |
473 } | |
474 | |
475 @CoreMethod(names = "to_s", maxArgs = 0) | |
476 public abstract static class ToSNode extends CoreMethodNode { | |
477 | |
478 public ToSNode(RubyContext context, SourceSection sourceSection) { | |
479 super(context, sourceSection); | |
480 } | |
481 | |
482 public ToSNode(ToSNode prev) { | |
483 super(prev); | |
484 } | |
485 | |
486 @Specialization | |
487 public RubyString toS(double value) { | |
488 return getContext().makeString(Double.toString(value)); | |
489 } | |
490 | |
491 } | |
492 | |
493 } |