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
Sep 5, 2014
Sep 5, 2014
Feb 20, 2020
Jul 28, 2018
Oct 9, 2021
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
Oct 9, 2021
Oct 9, 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
927 lines (837 sloc)
27.1 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")
378
}
379
381
382
function extended_euclidean(a, b){
383
var d, u, v
384
if(b == 0){
385
return [a, 1, 0]
386
}else{
387
[d, u, v] = extended_euclidean(b, a % b)
388
return [d, v, u - Math.floor(a / b) * v]
389
}
390
}
391
397
other = int_value(other)
398
switch(other.valueOf()) {
399
case 0:
400
return int.$factory(1)
401
case 1:
402
return int.$factory(self.valueOf())
403
}
404
if(z !== undefined && z !== _b_.None){
405
// If z is provided, the algorithm is faster than computing
406
// self ** other then applying the modulo z
407
if(z == 1){return 0}
408
var result = 1,
409
base = self % z,
410
exponent = other,
411
long_int = $B.long_int
412
if(exponent < 0){
413
var gcd, inv, _
414
[gcd, inv, _] = extended_euclidean(self, z)
415
if(gcd !== 1){
416
throw _b_.ValueError.$factory("not relative primes: " +
417
self + ' and ' + z)
418
}
419
return int.__pow__(inv, -exponent, z)
420
}
421
while(exponent > 0){
422
if(exponent % 2 == 1){
423
if(result * base > $B.max_int){
424
result = long_int.__mul__(
425
long_int.$factory(result),
426
long_int.$factory(base))
427
result = long_int.__mod__(result, z)
428
}else{
429
result = (result * base) % z
430
}
431
}
432
exponent = exponent >> 1
433
if(base * base > $B.max_int){
434
base = long_int.__mul__(long_int.$factory(base),
435
long_int.$factory(base))
436
base = long_int.__mod__(base, z)
437
}else{
438
base = (base * base) % z
439
}
440
}
441
return result
442
}
443
var res = Math.pow(self.valueOf(), other.valueOf())
444
if(res > $B.min_int && res < $B.max_int){
445
return other > 0 ? res : new Number(res)
446
}else if(res !== Infinity && !isFinite(res)){
447
return res
448
}else{
449
if($B.BigInt){
450
return {
451
__class__: $B.long_int,
452
value: ($B.BigInt(self) ** $B.BigInt(other)).toString(),
453
pos: true
454
}
455
}
456
return $B.long_int.__pow__($B.long_int.$from_int(self),
457
$B.long_int.$from_int(other))
458
}
459
}
472
}
473
var rpow = $B.$getattr(other, "__rpow__", _b_.None)
474
if(rpow !== _b_.None){
475
return rpow(self)
476
}
478
}
479
480
function __newobj__(){
481
// __newobj__ is called with a generator as only argument
482
var $ = $B.args('__newobj__', 0, {}, [], arguments, {}, 'args', null),
483
args = $.args
484
var res = args.slice(1)
485
res.__class__ = args[0]
486
return res
487
}
488
489
int.__reduce_ex__ = function(self){
490
return $B.fast_tuple([
491
__newobj__,
492
$B.fast_tuple([self.__class__ || int, int_value(self)]),
493
_b_.None,
494
_b_.None,
495
_b_.None])
496
}
497
501
}
502
505
self = int_value(self)
506
if(typeof other == "number" || _b_.isinstance(other, int)){
508
return int.$factory($B.long_int.__rshift__($B.long_int.$factory(self),
509
$B.long_int.$factory(other)))
513
515
if(typeof self == "number" || typeof self == "boolean"){
516
var cl_name = $B.class_name(self)
517
if(_b_.dir(self).indexOf(attr) > -1){
518
throw _b_.AttributeError.$factory("attribute '" + attr +
519
`' of '${cl_name}' objects is not writable`)
521
throw _b_.AttributeError.$factory(`'${cl_name}' object` +
522
` has no attribute '${attr}'`)
525
}
526
// subclasses of int can have attributes set
529
}
530
531
int.__sub__ = function(self, other){
532
self = int_value(self)
533
if(_b_.isinstance(other, int)){
534
if(other.__class__ == $B.long_int){
535
return $B.long_int.__sub__($B.long_int.$factory(self),
536
$B.long_int.$factory(other))
537
}
538
other = int_value(other)
539
var res = self - other
540
if(res > $B.min_int && res < $B.max_int){
541
return res
542
}else{
543
return $B.long_int.__sub__($B.long_int.$factory(self),
544
$B.long_int.$factory(other))
545
}
546
}
547
return _b_.NotImplemented
548
}
549
556
if(other.__class__ === $B.long_int){
557
return new Number(self / parseInt(other.value))
558
}
559
return new Number(self / other)
560
}
562
}
563
565
s = _b_.bin(self)
566
s = $B.$getattr(s, "lstrip")("-0b") // remove leading zeros and minus sign
567
return s.length // len('100101') --> 6
568
}
569
571
int.numerator = function(self){
572
return int_value(self)
573
}
574
int.denominator = function(self){
575
return int.$factory(1)
576
}
577
int.imag = function(self){
578
return int.$factory(0)
579
}
580
int.real = function(self){
581
return self
582
}
583
584
for(var attr of ['numerator', 'denominator', 'imag', 'real']){
585
int[attr].setter = (function(x){
586
return function(self, value){
587
throw _b_.AttributeError.$factory(`attribute '${x}' of ` +
588
`'${$B.class_name(self)}' objects is not writable`)
589
}
590
})(attr)
591
}
598
self = int_value(self)
599
if(typeof other == "number" || _b_.isinstance(other, int)){
600
if(other.__class__ === $B.long_int){
601
return $B.long_int.__sub__($B.long_int.$factory(self),
602
$B.long_int.$factory(other))
605
if(self > $B.max_int32 || self < $B.min_int32 ||
606
other > $B.max_int32 || other < $B.min_int32){
607
return $B.long_int.__sub__($B.long_int.$factory(self),
608
$B.long_int.$factory(other))
613
}
614
617
for(var $op in $ops){
618
var opf = $op_func.replace(/-/gm, $op)
619
opf = opf.replace(new RegExp("sub", "gm"), $ops[$op])
620
eval("int.__" + $ops[$op] + "__ = " + opf)
621
}
622
623
624
// comparison methods
636
}
642
}
645
for(var $op in $B.$comps){
646
eval("int.__"+$B.$comps[$op] + "__ = " +
647
$comp_func.replace(/>/gm, $op).
648
replace(/__gt__/gm,"__" + $B.$comps[$op] + "__").
649
replace(/__lt__/, "__" + $B.$inv_comps[$op] + "__"))
650
}
651
652
// add "reflected" methods
653
var r_opnames = ["add", "sub", "mul", "truediv", "floordiv", "mod", "pow",
654
"lshift", "rshift", "and", "xor", "or", "divmod"]
655
656
for(var r_opname of r_opnames){
657
if(int["__r" + r_opname + "__"] === undefined &&
658
int['__' + r_opname + '__']){
659
int["__r" + r_opname + "__"] = (function(name){
660
return function(self, other){
661
if(_b_.isinstance(other, int)){
662
other = int_value(other)
663
return int["__" + name + "__"](other, self)
664
}
665
return _b_.NotImplemented
666
}
667
})(r_opname)
668
}
669
}
670
671
var $valid_digits = function(base) {
672
var digits = ""
673
if(base === 0){return "0"}
674
if(base < 10){
676
return digits
677
}
678
680
// A = 65 (10 + 55)
682
return digits
683
}
684
690
if(typeof value == "number" &&
691
(base === undefined || base == 10)){return parseInt(value)}
697
var $ns = $B.args("int", 2, {x:null, base:null}, ["x", "base"], arguments,
698
{"base": 10}, null, null),
699
value = $ns["x"],
700
base = $ns["base"]
711
721
if(base == 10){
722
if(value < $B.min_int || value > $B.max_int){
723
return $B.long_int.$factory(value)
724
}
730
var res = parseInt(value, base)
731
if(value < $B.min_int || value > $B.max_int){
732
return $B.long_int.$factory(value, base)
733
}
737
738
if(value === true){return Number(1)}
739
if(value === false){return Number(0)}
740
if(value.__class__ === $B.long_int){
745
747
function invalid(value, base){
748
throw _b_.ValueError.$factory("invalid literal for int() with base " +
749
base + ": '" + _b_.str.$factory(value) + "'")
750
}
751
755
if(typeof value == "string") {
756
var _value = value.trim() // remove leading/trailing whitespace
757
if(_value.length == 2 && base == 0 &&
758
(_value == "0b" || _value == "0o" || _value == "0x")){
759
throw _b_.ValueError.$factory("invalid value")
760
}
762
var _pre = _value.substr(0, 2).toUpperCase()
763
if(base == 0){
764
if(_pre == "0B"){base = 2}
765
if(_pre == "0O"){base = 8}
766
if(_pre == "0X"){base = 16}
767
}else if(_pre == "0X" && base != 16){invalid(_value, base)}
768
else if(_pre == "0O" && base != 8){invalid(_value, base)}
779
var _digits = $valid_digits(base),
780
_re = new RegExp("^[+-]?[" + _digits + "]" +
781
"[" + _digits + "_]*$", "i"),
782
match = _re.exec(_value)
796
}
809
throw _b_.TypeError.$factory(
810
"int() argument must be a string, a bytes-like " +
811
"object or a number, not '" + $B.class_name(value) + "'")
812
}
813
816
_b_.int = int
817
820
if(obj === null || obj === undefined ){ return false}
821
switch(typeof obj){
822
case "boolean":
823
return obj
824
case "number":
825
case "string":
826
if(obj){return true}
827
return false
828
default:
830
var klass = obj.__class__ || $B.get_class(obj),
831
missing = {},
832
bool_method = $B.$getattr(klass, "__bool__", missing)
833
if(bool_method === missing){
834
try{return _b_.len(obj) > 0}
837
var res = $B.$call(bool_method)(obj)
838
if(res !== true && res !== false){
839
throw _b_.TypeError.$factory("__bool__ should return " +
840
"bool, returned " + $B.class_name(res))
841
}
842
return res
856
$native: true,
857
$descriptors: {
858
"numerator": true,
859
"denominator": true,
860
"imag": true,
861
"real": true
862
}
866
if(_b_.isinstance(other, bool)){
867
return self && other
868
}else if(_b_.isinstance(other, int)){
869
return int.__and__(bool.__index__(self), int.__index__(other))
870
}
871
return _b_.NotImplemented
874
bool.__float__ = function(self){
875
return self ? new Number(1) : new Number(0)
876
}
877
886
if(_b_.isinstance(other, bool)){
887
return self || other
888
}else if(_b_.isinstance(other, int)){
889
return int.__or__(bool.__index__(self), int.__index__(other))
890
}
891
return _b_.NotImplemented
896
bool.__repr__ = function(self){
897
$B.builtins_repr_check(bool, arguments) // in brython_builtins.js
902
if(_b_.isinstance(other, bool)){
903
return self ^ other ? true : false
904
}else if(_b_.isinstance(other, int)){
905
return int.__xor__(bool.__index__(self), int.__index__(other))
906
}
907
return _b_.NotImplemented
910
bool.$factory = function(){
911
// Calls $B.$bool, which is used inside the generated JS code and skips
912
// arguments control.
918
bool.numerator = int.numerator
919
bool.denominator = int.denominator
920
bool.real = int.real
921
bool.imag = int.imag
922
927
})(__BRYTHON__)