rt/emul/mini/src/main/resources/org/apidesign/vm4brwsr/emul/lang/java_lang_Number.js
1 // empty line needed here
3 (function(numberPrototype) {
8 return (((x * (y >> 16)) << 16) + x * (y & 0xFFFF)) | 0;
10 var __m32 = 0xFFFFFFFF;
12 numberPrototype.next32 = function(low) {
16 var l = new Number(low);
21 numberPrototype.high32 = function() {
25 return x.hi ? x.hi : (Math.floor(x / (__m32 + 1))) | 0;
27 numberPrototype.toFP = function() {
28 return this.hi ? this.hi * (__m32 + 1) + this : this;
30 numberPrototype.toLong = function() {
31 var hi = (this / (__m32 + 1)) | 0;
32 var low = (this % (__m32 + 1)) | 0;
41 return hi.next32(low);
44 numberPrototype.toExactString = function() {
46 // check for Long.MIN_VALUE
47 if ((this.hi == (0x80000000 | 0)) && (this == 0)) {
48 return '-9223372036854775808';
51 var a = [6, 9, 2, 7, 6, 9, 4, 9, 2, 4];
54 var neg = this.hi < 0;
63 for (var i = 0; i < a.length; i++) {
65 var low_digit = low % 10;
66 digit = (res % 10) + low_digit;
68 low = Math.floor(low / 10);
69 res = Math.floor(res / 10);
75 s = String(digit).concat(s);
77 s = String(res).concat(s).replace(/^0+/, '');
78 return (neg ? '-' : '').concat(s);
83 function add64(x, y) {
90 var hi = (high32(x) + high32(y) + carry) | 0;
91 return hi.next32(low);
94 function sub64(x, y) {
101 var hi = (high32(x) - high32(y) - carry) | 0;
102 return hi.next32(low);
105 function mul64(x, y) {
106 var low = mul32(x, y);
107 low += (low < 0) ? (__m32 + 1) : 0;
108 // first count upper 32 bits of (x.low * x.low)
112 for (var i = 0; i < 32; i++) {
118 hi_low += (hi_hi & 1) ? 0x8000 : 0;
122 var hi = (hi_hi << 16) + hi_low;
124 var m1 = mul32(high32(x), y);
125 var m2 = mul32(x, high32(y));
126 hi = add32(add32(hi, m1), m2);
128 return hi.next32(low);
131 function and64(x, y) {
133 low += (low < 0) ? (__m32 + 1) : 0;
135 var hi = x.hi & y.hi;
136 return hi.next32(low);
142 function or64(x, y) {
144 low += (low < 0) ? (__m32 + 1) : 0;
146 var hi = x.hi | y.hi;
147 return hi.next32(low);
152 function xor64(x, y) {
154 low += (low < 0) ? (__m32 + 1) : 0;
156 var hi = x.hi ^ y.hi;
157 return hi.next32(low);
163 function shl64(thiz, x) {
165 if (x === 0) return thiz;
167 var hi = thiz << (x - 32);
170 var hi = high32(thiz) << x;
171 var low_reminder = thiz >> (32 - x);
174 low += (low < 0) ? (__m32 + 1) : 0;
175 return hi.next32(low);
179 function shr64(thiz, x) {
181 if (x === 0) return thiz;
183 var low = high32(thiz) >> (x - 32);
184 low += (low < 0) ? (__m32 + 1) : 0;
187 var low = thiz >>> x;
188 var hi_reminder = high32(thiz) << (32 - x);
190 low += (low < 0) ? (__m32 + 1) : 0;
191 var hi = high32(thiz) >> x;
192 return hi.next32(low);
196 function ushr64(thiz, x) {
198 if (x === 0) return thiz;
200 var low = high32(thiz) >>> (x - 32);
201 low += (low < 0) ? (__m32 + 1) : 0;
204 var low = thiz >>> x;
205 var hi_reminder = high32(thiz) << (32 - x);
207 low += (low < 0) ? (__m32 + 1) : 0;
208 var hi = high32(thiz) >>> x;
209 return hi.next32(low);
213 function compare64(x, y) {
214 if (high32(x) === high32(y)) {
215 return (x < y) ? -1 : ((x > y) ? 1 : 0);
217 return (high32(x) < high32(y)) ? -1 : 1;
223 if ((hi === 0) && (low < 0)) {
228 low += (low < 0) ? (__m32 + 1) : 0;
229 var ret = hi.next32(low);
230 return add64(ret, 1);
233 function __handleDivByZero() {
234 var exception = new vm.java_lang_ArithmeticException;
235 vm.java_lang_ArithmeticException(false).constructor
236 .cons__VLjava_lang_String_2.call(exception, "/ by zero");
241 function __Int64(hi32, lo32) {
242 this.hi32 = hi32 | 0;
243 this.lo32 = lo32 | 0;
245 this.get32 = function(bitIndex) {
249 var selector = bitIndex >>> 5;
267 var shift = bitIndex & 31;
272 return (v1 << (32 - shift)) | (v0 >>> shift);
275 this.get16 = function(bitIndex) {
276 return this.get32(bitIndex) & 0xffff;
279 this.set16 = function(bitIndex, value) {
281 var shift = bitIndex & 15;
282 var svalue = (value & 0xffff) << shift;
283 var smask = 0xffff << shift;
284 var selector = bitIndex >>> 4;
289 this.lo32 = (this.lo32 & ~(smask >>> 16))
293 this.lo32 = (this.lo32 & ~smask) | svalue;
296 this.lo32 = (this.lo32 & ~(smask << 16))
298 this.hi32 = (this.hi32 & ~(smask >>> 16))
302 this.hi32 = (this.hi32 & ~smask) | svalue;
305 this.hi32 = (this.hi32 & ~(smask << 16))
311 this.getDigit = function(index, shift) {
312 return this.get16((index << 4) - shift);
315 this.getTwoDigits = function(index, shift) {
316 return this.get32(((index - 1) << 4) - shift);
319 this.setDigit = function(index, shift, value) {
320 this.set16((index << 4) - shift, value);
323 this.countSignificantDigits = function() {
327 if (this.hi32 === 0) {
328 if (this.lo32 === 0) {
333 remaining = this.lo32;
336 remaining = this.hi32;
343 return (remaining < 65536) ? sd - 1 : sd;
346 this.toNumber = function() {
347 var lo32 = this.lo32;
352 return this.hi32.next32(lo32);
356 function __countLeadingZeroes16(number) {
369 if (number < 16384) {
374 return (number < 32768) ? nlz + 1 : nlz;
377 // q = u / v; r = u - q * v;
379 function __div64(q, r, u, v) {
380 var m = u.countSignificantDigits();
381 var n = v.countSignificantDigits();
386 // v has single digit
387 var vd = v.getDigit(0, 0);
389 for (var i = m - 1; i >= 0; --i) {
390 var ui = (carry << 16) | u.getDigit(i, 0);
394 var qi = (ui / vd) | 0;
395 q.setDigit(i, 0, qi);
396 carry = ui - qi * vd;
412 var nrm = __countLeadingZeroes16(v.getDigit(n - 1, 0));
414 var vd1 = v.getDigit(n - 1, nrm);
415 var vd0 = v.getDigit(n - 2, nrm);
416 for (var j = m - n; j >= 0; --j) {
417 // Calculate qj estimate
418 var ud21 = r.getTwoDigits(j + n, nrm);
419 var ud2 = ud21 >>> 16;
424 var qest = (ud2 === vd1) ? 0xFFFF : ((ud21 / vd1) | 0);
425 var rest = ud21 - qest * vd1;
427 // 0 <= (qest - qj) <= 2
429 // Refine qj estimate
430 var ud0 = r.getDigit(j + n - 2, nrm);
431 while ((qest * vd0) > ((rest * 0x10000) + ud0)) {
436 // 0 <= (qest - qj) <= 1
438 // Multiply and subtract
440 for (var i = 0; i < n; ++i) {
441 var vi = qest * v.getDigit(i, nrm);
442 var ui = r.getDigit(i + j, nrm) - carry - (vi & 0xffff);
443 r.setDigit(i + j, nrm, ui);
444 carry = (vi >>> 16) - (ui >> 16);
446 var uj = ud2 - carry;
454 for (var i = 0; i < n; ++i) {
455 var ui = r.getDigit(i + j, nrm) + v.getDigit(i, nrm)
457 r.setDigit(i + j, nrm, ui);
463 q.setDigit(j, 0, qest);
464 r.setDigit(j + n, nrm, uj);
468 function div64(x, y) {
469 var negateResult = false;
472 if ((high32(x) & 0x80000000) !== 0) {
474 negateResult = !negateResult;
479 if ((high32(y) & 0x80000000) !== 0) {
481 negateResult = !negateResult;
486 if ((v === 0) && (high32(v) === 0)) {
490 if (high32(u) === 0) {
491 if (high32(v) === 0) {
492 var result = (u / v) | 0;
493 return negateResult ? neg64(result) : result;
499 var u64 = new __Int64(high32(u), u);
500 var v64 = new __Int64(high32(v), v);
501 var q64 = new __Int64(0, 0);
502 var r64 = new __Int64(0, 0);
504 __div64(q64, r64, u64, v64);
506 var result = q64.toNumber();
507 return negateResult ? neg64(result) : result;
510 function mod64(x, y) {
511 var negateResult = false;
514 if ((high32(x) & 0x80000000) !== 0) {
516 negateResult = !negateResult;
521 if ((high32(y) & 0x80000000) !== 0) {
527 if ((v === 0) && (high32(v) === 0)) {
531 if (high32(u) === 0) {
532 var result = (high32(v) === 0) ? (u % v) : u;
533 return negateResult ? neg64(result) : result;
536 var u64 = new __Int64(high32(u), u);
537 var v64 = new __Int64(high32(v), v);
538 var q64 = new __Int64(0, 0);
539 var r64 = new __Int64(0, 0);
541 __div64(q64, r64, u64, v64);
543 var result = r64.toNumber();
544 return negateResult ? neg64(result) : result;
547 var b = numberPrototype['__bit64'] = {};
560 b.compare64 = compare64;
561 })(Number.prototype);
563 vm.java_lang_Number(false);