Permalink
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Jul 28, 2018
Sep 5, 2014
Dec 18, 2019
Dec 17, 2020
Sep 5, 2014
Dec 17, 2020
Apr 23, 2018
Dec 17, 2020
Apr 23, 2018
Dec 17, 2020
Dec 17, 2020
Sep 5, 2014
Jun 6, 2021
Jul 28, 2018
Sep 5, 2014
Sep 5, 2014
Jul 25, 2021
Sep 5, 2014
Sep 5, 2014
Mar 10, 2018
May 26, 2018
Mar 10, 2018
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Jun 29, 2021
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Jun 6, 2021
Sep 5, 2014
Aug 2, 2018
Mar 10, 2018
Sep 5, 2014
Sep 5, 2014
Jun 6, 2021
Mar 10, 2018
Sep 5, 2014
Feb 22, 2019
Sep 5, 2014
Mar 10, 2018
Jul 28, 2018
Sep 5, 2014
Sep 5, 2014
Feb 20, 2020
Jul 28, 2018
May 19, 2017
Jul 28, 2018
Feb 20, 2020
Jul 28, 2018
May 4, 2021
Jun 30, 2020
Sep 5, 2014
Sep 5, 2014
Feb 15, 2020
Sep 5, 2014
May 4, 2021
Sep 5, 2014
Jun 6, 2021
Feb 11, 2018
Sep 5, 2014
Jun 6, 2021
Sep 5, 2014
Sep 5, 2014
Jun 6, 2021
Mar 10, 2018
Sep 5, 2014
Sep 5, 2014
Feb 22, 2019
Sep 5, 2014
Jun 6, 2021
Jun 6, 2021
Mar 10, 2018
Mar 23, 2018
Mar 10, 2018
Sep 5, 2014
Sep 5, 2014
Mar 10, 2018
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Mar 10, 2018
Sep 5, 2014
Jun 6, 2021
Sep 5, 2014
Mar 10, 2018
Sep 5, 2014
Sep 5, 2014
Sep 5, 2014
Mar 10, 2018
Mar 10, 2018
Sep 5, 2014
Mar 10, 2018
Mar 10, 2018
Sep 5, 2014
Mar 10, 2018
Sep 5, 2014
Nov 28, 2018
Sep 5, 2014
Mar 10, 2018
Mar 10, 2018
Nov 28, 2018
Jun 14, 2018
Sep 5, 2014
Jan 11, 2021
Sep 5, 2014
Sep 5, 2014
Mar 10, 2018
Oct 27, 2019
Oct 27, 2019
Jun 6, 2021
Oct 22, 2019
Jan 7, 2021
Oct 22, 2019
Jun 13, 2021
Oct 22, 2019
Feb 11, 2018
Jun 6, 2021
Sep 5, 2014
Newer
100644
924 lines (834 sloc)
26.9 KB
1
;(function($B){
2
4
9
}
10
11
function int_value(obj){
12
// Instances of int subclasses that call int.__new__(cls, value)
37
}
38
39
int.as_integer_ratio = function(){
40
var $ = $B.args("as_integer_ratio", 1, {self:null}, ["self"],
41
arguments, {}, null, null)
42
return $B.$list([$.self, 1])
43
}
44
46
var $ = $B.args("from_bytes", 3,
47
{bytes:null, byteorder:null, signed:null},
48
["bytes", "byteorder", "signed"],
49
arguments, {signed: false}, null, null)
50
51
var x = $.bytes,
52
byteorder = $.byteorder,
53
signed = $.signed,
54
_bytes, _len
55
if(_b_.isinstance(x, [_b_.bytes, _b_.bytearray])){
56
_bytes = x.source
57
_len = x.source.length
58
}else{
59
_bytes = _b_.list.$factory(x)
60
_len = _bytes.length
61
for(var i = 0; i < _len; i++){
62
_b_.bytes.$factory([_bytes[i]])
63
}
64
}
65
if(byteorder == "big"){
66
_bytes.reverse()
67
}else if(byteorder != "little"){
68
throw _b_.ValueError.$factory(
69
"byteorder must be either 'little' or 'big'")
70
}
71
var num = _bytes[0]
72
if(signed && num >= 128){
73
num = num - 256
74
}
75
var _mult = 256
76
for(var i = 1; i < _len; i++){
77
num = $B.add($B.mul(_mult, _bytes[i]), num)
78
_mult = $B.mul(_mult, 256)
79
}
80
if(! signed){
81
return num
82
}
83
if(_bytes[_len - 1] < 128){
84
return num
85
}
86
return $B.sub(num, _mult)
87
}
88
91
{self: null, len: null, byteorder: null, signed: null},
92
["self", "len", "byteorder", "*", "signed"],
93
arguments, {signed: false}, null, null),
98
if(! _b_.isinstance(len, _b_.int)){
99
throw _b_.TypeError.$factory("integer argument expected, got " +
103
throw _b_.ValueError.$factory(
104
"byteorder must be either 'little' or 'big'")
105
}
106
107
if(_b_.isinstance(self, $B.long_int)){
108
return $B.long_int.to_bytes(self, len, byteorder, signed)
123
var quotient = Math.floor(value / 256),
124
rest = value - 256 * quotient
125
res.push(rest)
126
if(res.length > len){
127
throw _b_.OverflowError.$factory("int too big to convert")
131
while(res.length < len){
132
res.push(0)
133
}
134
if(byteorder == "big"){
135
res.reverse()
141
}
142
145
int.__add__ = function(self, other){
146
self = int_value(self)
147
if(_b_.isinstance(other, int)){
148
if(other.__class__ == $B.long_int){
149
return $B.long_int.__add__($B.long_int.$factory(self),
150
$B.long_int.$factory(other))
151
}
152
other = int_value(other)
153
var res = self + other
154
if(res > $B.min_int && res < $B.max_int){
155
return res
156
}else{
157
return $B.long_int.__add__($B.long_int.$factory(self),
158
$B.long_int.$factory(other))
159
}
160
}
161
return _b_.NotImplemented
162
}
163
164
int.__bool__ = function(self){
165
return int_value(self).valueOf() == 0 ? false : true
166
}
167
179
// compare object "self" to class "int"
183
if(_b_.isinstance(other, _b_.float)){
184
return self.valueOf() == other.valueOf()
185
}
189
}
191
}
192
199
if(fmt.type && 'bcdoxXn'.indexOf(fmt.type) == -1){
200
throw _b_.ValueError.$factory("Unknown format code '" + fmt.type +
228
if(fmt.sign !== undefined){
229
if((fmt.sign == " " || fmt.sign == "+" ) && self >= 0){
230
res = fmt.sign + res
231
}
232
}
251
for(var i = 0; i < nb; i++){
252
chunks.push(rest.substring(len - 3 * i - 3, len - 3 * i))
258
}
259
268
}
270
}
271
273
if(self.$brython_value){
274
// int subclass
275
var hash_method = $B.$getattr(self.__class__, '__hash__')
276
if(hash_method === int.__hash__){
277
if(typeof self.$brython_value == "number"){
278
return self.$brython_value
279
}else{ // long int
280
return $B.long_int.__hash__(self.$brython_value)
281
}
282
}else{
283
return hash_method(self)
284
}
285
}
286
return self.valueOf()
288
290
294
297
self.toString = function(){return value}
299
}
300
302
304
310
try{
311
return int.$factory($B.long_int.__lshift__($B.long_int.$factory(self),
312
$B.long_int.$factory(other)))
313
}catch(err){
314
console.log('err in lshift', self, other)
315
throw err
316
}
322
// can't use Javascript % because it works differently for negative numbers
324
if(other.__class__ === $B.long_int){
325
return $B.long_int.__mod__($B.long_int.$factory(self), other)
326
}
329
if(other === false){other = 0}
330
else if(other === true){other = 1}
331
if(other == 0){throw _b_.ZeroDivisionError.$factory(
334
}
336
}
337
341
if(other.__class__ == $B.long_int){
342
return $B.long_int.__mul__($B.long_int.$factory(self),
343
$B.long_int.$factory(other))
344
}
350
return int.$factory($B.long_int.__mul__($B.long_int.$factory(self),
351
$B.long_int.$factory(other)))
352
}
355
}
356
357
int.__ne__ = function(self, other){
358
var res = int.__eq__(self, other)
359
return (res === _b_.NotImplemented) ? res : !res
360
}
361
363
365
if(cls === undefined){
366
throw _b_.TypeError.$factory("int.__new__(): not enough arguments")
368
throw _b_.TypeError.$factory("int.__new__(X): X is not a type object")
369
}
370
if(cls === int){return int.$factory(value)}
371
return {
372
__class__: cls,
376
}
377
379
380
function extended_euclidean(a, b){
381
var d, u, v
382
if(b == 0){
383
return [a, 1, 0]
384
}else{
385
[d, u, v] = extended_euclidean(b, a % b)
386
return [d, v, u - Math.floor(a / b) * v]
387
}
388
}
389
395
other = int_value(other)
396
switch(other.valueOf()) {
397
case 0:
398
return int.$factory(1)
399
case 1:
400
return int.$factory(self.valueOf())
403
// If z is provided, the algorithm is faster than computing
404
// self ** other then applying the modulo z
405
if(z == 1){return 0}
406
var result = 1,
407
base = self % z,
408
exponent = other,
409
long_int = $B.long_int
410
if(exponent < 0){
411
var gcd, inv, _
412
[gcd, inv, _] = extended_euclidean(self, z)
413
if(gcd !== 1){
414
throw _b_.ValueError.$factory("not relative primes: " +
415
self + ' and ' + z)
416
}
417
return int.__pow__(inv, -exponent, z)
418
}
419
while(exponent > 0){
420
if(exponent % 2 == 1){
421
if(result * base > $B.max_int){
422
result = long_int.__mul__(
423
long_int.$factory(result),
424
long_int.$factory(base))
425
result = long_int.__mod__(result, z)
426
}else{
427
result = (result * base) % z
428
}
429
}
430
exponent = exponent >> 1
431
if(base * base > $B.max_int){
432
base = long_int.__mul__(long_int.$factory(base),
433
long_int.$factory(base))
434
base = long_int.__mod__(base, z)
435
}else{
436
base = (base * base) % z
437
}
442
if(res > $B.min_int && res < $B.max_int){
443
return other > 0 ? res : new Number(res)
444
}else if(res !== Infinity && !isFinite(res)){
445
return res
446
}else{
447
if($B.BigInt){
448
return {
449
__class__: $B.long_int,
450
value: ($B.BigInt(self) ** $B.BigInt(other)).toString(),
451
pos: true
452
}
453
}
454
return $B.long_int.__pow__($B.long_int.$from_int(self),
455
$B.long_int.$from_int(other))
457
}
470
}
471
var rpow = $B.$getattr(other, "__rpow__", _b_.None)
472
if(rpow !== _b_.None){
473
return rpow(self)
474
}
476
}
477
478
function __newobj__(){
479
// __newobj__ is called with a generator as only argument
480
var $ = $B.args('__newobj__', 0, {}, [], arguments, {}, 'args', null),
481
args = $.args
482
var res = args.slice(1)
483
res.__class__ = args[0]
484
return res
485
}
486
487
int.__reduce_ex__ = function(self){
488
return $B.fast_tuple([
489
__newobj__,
490
$B.fast_tuple([self.__class__ || int, int_value(self)]),
491
_b_.None,
492
_b_.None,
493
_b_.None])
494
}
495
499
}
500
503
self = int_value(self)
504
if(typeof other == "number" || _b_.isinstance(other, int)){
506
return int.$factory($B.long_int.__rshift__($B.long_int.$factory(self),
507
$B.long_int.$factory(other)))
511
513
if(typeof self == "number" || typeof self == "boolean"){
514
var cl_name = $B.class_name(self)
515
if(_b_.dir(self).indexOf(attr) > -1){
516
var msg = "attribute '" + attr + `' of '${cl_name}'` +
517
"objects is not writable"
522
}
523
// subclasses of int can have attributes set
526
}
527
528
int.__sub__ = function(self, other){
529
self = int_value(self)
530
if(_b_.isinstance(other, int)){
531
if(other.__class__ == $B.long_int){
532
return $B.long_int.__sub__($B.long_int.$factory(self),
533
$B.long_int.$factory(other))
534
}
535
other = int_value(other)
536
var res = self - other
537
if(res > $B.min_int && res < $B.max_int){
538
return res
539
}else{
540
return $B.long_int.__sub__($B.long_int.$factory(self),
541
$B.long_int.$factory(other))
542
}
543
}
544
return _b_.NotImplemented
545
}
546
553
if(other.__class__ === $B.long_int){
554
return new Number(self / parseInt(other.value))
555
}
556
return new Number(self / other)
557
}
559
}
560
562
s = _b_.bin(self)
563
s = $B.$getattr(s, "lstrip")("-0b") // remove leading zeros and minus sign
564
return s.length // len('100101') --> 6
565
}
566
568
int.numerator = function(self){
569
return int_value(self)
570
}
571
int.denominator = function(self){
572
return int.$factory(1)
573
}
574
int.imag = function(self){
575
return int.$factory(0)
576
}
577
int.real = function(self){
578
return self
579
}
580
581
for(var attr of ['numerator', 'denominator', 'imag', 'real']){
582
int[attr].setter = (function(x){
583
return function(self, value){
584
throw _b_.AttributeError.$factory(`attribute '${x}' of ` +
585
`'${$B.class_name(self)}' objects is not writable`)
586
}
587
})(attr)
588
}
595
self = int_value(self)
596
if(typeof other == "number" || _b_.isinstance(other, int)){
597
if(other.__class__ === $B.long_int){
598
return $B.long_int.__sub__($B.long_int.$factory(self),
599
$B.long_int.$factory(other))
602
if(self > $B.max_int32 || self < $B.min_int32 ||
603
other > $B.max_int32 || other < $B.min_int32){
604
return $B.long_int.__sub__($B.long_int.$factory(self),
605
$B.long_int.$factory(other))
610
}
611
614
for(var $op in $ops){
615
var opf = $op_func.replace(/-/gm, $op)
616
opf = opf.replace(new RegExp("sub", "gm"), $ops[$op])
617
eval("int.__" + $ops[$op] + "__ = " + opf)
618
}
619
620
621
// comparison methods
633
}
639
}
642
for(var $op in $B.$comps){
643
eval("int.__"+$B.$comps[$op] + "__ = " +
644
$comp_func.replace(/>/gm, $op).
645
replace(/__gt__/gm,"__" + $B.$comps[$op] + "__").
646
replace(/__lt__/, "__" + $B.$inv_comps[$op] + "__"))
647
}
648
649
// add "reflected" methods
650
var r_opnames = ["add", "sub", "mul", "truediv", "floordiv", "mod", "pow",
651
"lshift", "rshift", "and", "xor", "or", "divmod"]
652
653
for(var r_opname of r_opnames){
654
if(int["__r" + r_opname + "__"] === undefined &&
655
int['__' + r_opname + '__']){
656
int["__r" + r_opname + "__"] = (function(name){
657
return function(self, other){
658
if(_b_.isinstance(other, int)){
659
other = int_value(other)
660
return int["__" + name + "__"](other, self)
661
}
662
return _b_.NotImplemented
663
}
664
})(r_opname)
665
}
666
}
667
668
var $valid_digits = function(base) {
669
var digits = ""
670
if(base === 0){return "0"}
671
if(base < 10){
673
return digits
674
}
675
677
// A = 65 (10 + 55)
679
return digits
680
}
681
687
if(typeof value == "number" &&
688
(base === undefined || base == 10)){return parseInt(value)}
694
var $ns = $B.args("int", 2, {x:null, base:null}, ["x", "base"], arguments,
695
{"base": 10}, null, null),
696
value = $ns["x"],
697
base = $ns["base"]
708
718
if(base == 10){
719
if(value < $B.min_int || value > $B.max_int){
720
return $B.long_int.$factory(value)
721
}
727
var res = parseInt(value, base)
728
if(value < $B.min_int || value > $B.max_int){
729
return $B.long_int.$factory(value, base)
730
}
734
735
if(value === true){return Number(1)}
736
if(value === false){return Number(0)}
737
if(value.__class__ === $B.long_int){
742
744
function invalid(value, base){
745
throw _b_.ValueError.$factory("invalid literal for int() with base " +
746
base + ": '" + _b_.str.$factory(value) + "'")
747
}
748
752
if(typeof value == "string") {
753
var _value = value.trim() // remove leading/trailing whitespace
754
if(_value.length == 2 && base == 0 &&
755
(_value == "0b" || _value == "0o" || _value == "0x")){
756
throw _b_.ValueError.$factory("invalid value")
757
}
759
var _pre = _value.substr(0, 2).toUpperCase()
760
if(base == 0){
761
if(_pre == "0B"){base = 2}
762
if(_pre == "0O"){base = 8}
763
if(_pre == "0X"){base = 16}
764
}else if(_pre == "0X" && base != 16){invalid(_value, base)}
765
else if(_pre == "0O" && base != 8){invalid(_value, base)}
776
var _digits = $valid_digits(base),
777
_re = new RegExp("^[+-]?[" + _digits + "]" +
778
"[" + _digits + "_]*$", "i"),
779
match = _re.exec(_value)
793
}
806
throw _b_.TypeError.$factory(
807
"int() argument must be a string, a bytes-like " +
808
"object or a number, not '" + $B.class_name(value) + "'")
809
}
810
813
_b_.int = int
814
817
if(obj === null || obj === undefined ){ return false}
818
switch(typeof obj){
819
case "boolean":
820
return obj
821
case "number":
822
case "string":
823
if(obj){return true}
824
return false
825
default:
827
var klass = obj.__class__ || $B.get_class(obj),
828
missing = {},
829
bool_method = $B.$getattr(klass, "__bool__", missing)
830
if(bool_method === missing){
831
try{return _b_.len(obj) > 0}
834
var res = $B.$call(bool_method)(obj)
835
if(res !== true && res !== false){
836
throw _b_.TypeError.$factory("__bool__ should return " +
837
"bool, returned " + $B.class_name(res))
838
}
839
return res
853
$native: true,
854
$descriptors: {
855
"numerator": true,
856
"denominator": true,
857
"imag": true,
858
"real": true
859
}
863
if(_b_.isinstance(other, bool)){
864
return self && other
865
}else if(_b_.isinstance(other, int)){
866
return int.__and__(bool.__index__(self), int.__index__(other))
867
}
868
return _b_.NotImplemented
871
bool.__float__ = function(self){
872
return self ? new Number(1) : new Number(0)
873
}
874
883
if(_b_.isinstance(other, bool)){
884
return self || other
885
}else if(_b_.isinstance(other, int)){
886
return int.__or__(bool.__index__(self), int.__index__(other))
887
}
888
return _b_.NotImplemented
893
bool.__repr__ = function(self){
894
$B.builtins_repr_check(bool, arguments) // in brython_builtins.js
899
if(_b_.isinstance(other, bool)){
900
return self ^ other ? true : false
901
}else if(_b_.isinstance(other, int)){
902
return int.__xor__(bool.__index__(self), int.__index__(other))
903
}
904
return _b_.NotImplemented
907
bool.$factory = function(){
908
// Calls $B.$bool, which is used inside the generated JS code and skips
909
// arguments control.
915
bool.numerator = int.numerator
916
bool.denominator = int.denominator
917
bool.real = int.real
918
bool.imag = int.imag
919
924
})(__BRYTHON__)