py: int: fix floor divide to be exactly the same as python

Author: ncw

py/bigint.go

@@ -214,74 +214,66 @@ func (a *BigInt) M__itruediv__(other Object) (Object, error){
 }
 
 func (a*BigInt) M__floordiv__(otherObject) (Object, error){
-ifb, ok:=convertToBigInt(other); ok{
-return (*BigInt)(new(big.Int).Quo((*big.Int)(a), (*big.Int)(b))).MaybeInt(), nil
- }
-returnNotImplemented, nil
+result, _, err:=a.M__divmod__(other)
+returnresult, err
 }
 
 func (a*BigInt) M__rfloordiv__(otherObject) (Object, error){
-ifb, ok:=convertToBigInt(other); ok{
-if (*big.Int)(a).Sign() ==0{
-returnnil, divisionByZero
- }
-return (*BigInt)(new(big.Int).Quo((*big.Int)(b), (*big.Int)(a))).MaybeInt(), nil
- }
-returnNotImplemented, nil
+result, _, err:=a.M__rdivmod__(other)
+returnresult, err
 }
 
 func (a*BigInt) M__ifloordiv__(otherObject) (Object, error){
-returna.M__floordiv__(other)
+result, _, err:=a.M__divmod__(other)
+returnresult, err
 }
 
 func (a*BigInt) M__mod__(otherObject) (Object, error){
-ifb, ok:=convertToBigInt(other); ok{
-if (*big.Int)(b).Sign() ==0{
-returnnil, divisionByZero
- }
-return (*BigInt)(new(big.Int).Rem((*big.Int)(a), (*big.Int)(b))).MaybeInt(), nil
- }
-returnNotImplemented, nil
+_, result, err:=a.M__divmod__(other)
+returnresult, err
 }
 
 func (a*BigInt) M__rmod__(otherObject) (Object, error){
-ifb, ok:=convertToBigInt(other); ok{
-if (*big.Int)(a).Sign() ==0{
-returnnil, divisionByZero
- }
-return (*BigInt)(new(big.Int).Rem((*big.Int)(b), (*big.Int)(a))).MaybeInt(), nil
- }
-returnNotImplemented, nil
+_, result, err:=a.M__rdivmod__(other)
+returnresult, err
 }
 
 func (a*BigInt) M__imod__(otherObject) (Object, error){
-returna.M__mod__(other)
+_, result, err:=a.M__divmod__(other)
+returnresult, err
+}
+
+func (a*BigInt) divMod(b*BigInt) (Object, Object, error){
+if (*big.Int)(b).Sign() ==0{
+returnnil, nil, divisionByZero
+ }
+r:=new(big.Int)
+q:=new(big.Int)
+q.QuoRem((*big.Int)(a), (*big.Int)(b), r)
+// Implement floor division
+negativeResult:= (*big.Int)(a).Sign() <0
+if (*big.Int)(b).Sign() <0{
+negativeResult=!negativeResult
+ }
+ifnegativeResult&&r.Sign() !=0{
+q.Sub(q, (*big.Int)(bigInt1))
+r.Add(r, (*big.Int)(b))
+ }
+return (*BigInt)(q).MaybeInt(), (*BigInt)(r).MaybeInt(), nil
 }
 
 func (a*BigInt) M__divmod__(otherObject) (Object, Object, error){
 ifb, ok:=convertToBigInt(other); ok{
-if (*big.Int)(b).Sign() ==0{
-returnnil, nil, divisionByZero
- }
-r:=new(big.Int)
-q:=new(big.Int)
-q.QuoRem((*big.Int)(a), (*big.Int)(b), r)
-return (*BigInt)(q).MaybeInt(), (*BigInt)(r).MaybeInt(), nil
+returna.divMod(b)
  }
-returnNotImplemented, None, nil
+returnNotImplemented, NotImplemented, nil
 }
 
 func (a*BigInt) M__rdivmod__(otherObject) (Object, Object, error){
 ifb, ok:=convertToBigInt(other); ok{
-if (*big.Int)(a).Sign() ==0{
-returnnil, nil, divisionByZero
- }
-r:=new(big.Int)
-q:=new(big.Int)
-q.QuoRem((*big.Int)(b), (*big.Int)(a), r)
-return (*BigInt)(q).MaybeInt(), (*BigInt)(r).MaybeInt(), nil
+returnb.divMod(a)
  }
-returnNotImplemented, None, nil
+returnNotImplemented, NotImplemented, nil
 }
 
 func (a*BigInt) M__pow__(other, modulusObject) (Object, error){

py/int.go

@@ -406,77 +406,65 @@ func (a Int) M__itruediv__(other Object) (Object, error){
 }
 
 func (aInt) M__floordiv__(otherObject) (Object, error){
-ifb, ok:=convertToInt(other); ok{
-ifb==0{
-returnnil, divisionByZero
- }
-// Can't overflow
-returnInt(a/b), nil
- }
-returnNotImplemented, nil
+result, _, err:=a.M__divmod__(other)
+returnresult, err
 }
 
 func (aInt) M__rfloordiv__(otherObject) (Object, error){
-ifb, ok:=convertToInt(other); ok{
-ifa==0{
-returnnil, divisionByZero
- }
-// Can't overflow
-returnInt(b/a), nil
- }
-returnNotImplemented, nil
+result, _, err:=a.M__rdivmod__(other)
+returnresult, err
 }
 
 func (aInt) M__ifloordiv__(otherObject) (Object, error){
-returna.M__floordiv__(other)
+result, _, err:=a.M__divmod__(other)
+returnresult, err
 }
 
 func (aInt) M__mod__(otherObject) (Object, error){
-ifb, ok:=convertToInt(other); ok{
-ifb==0{
-returnnil, divisionByZero
- }
-// Can't overflow
-returnInt(a%b), nil
- }
-returnNotImplemented, nil
+_, result, err:=a.M__divmod__(other)
+returnresult, err
 }
 
 func (aInt) M__rmod__(otherObject) (Object, error){
-ifb, ok:=convertToInt(other); ok{
-ifa==0{
-returnnil, divisionByZero
- }
-// Can't overflow
-returnInt(b%a), nil
- }
-returnNotImplemented, nil
+_, result, err:=a.M__rdivmod__(other)
+returnresult, err
 }
 
 func (aInt) M__imod__(otherObject) (Object, error){
-returna.M__mod__(other)
+_, result, err:=a.M__divmod__(other)
+returnresult, err
+}
+
+func (aInt) divMod(bInt) (Object, Object, error){
+ifb==0{
+returnnil, nil, divisionByZero
+ }
+// Can't overflow
+result, remainder:=Int(a/b), Int(a%b)
+// Implement floor division
+negativeResult:= (a<0)
+ifb<0{
+negativeResult=!negativeResult
+ }
+ifnegativeResult&&remainder!=0{
+result-=1
+remainder+=b
+ }
+returnresult, remainder, nil
 }
 
 func (aInt) M__divmod__(otherObject) (Object, Object, error){
 ifb, ok:=convertToInt(other); ok{
-ifb==0{
-returnnil, nil, divisionByZero
- }
-// Can't overflow
-returnInt(a/b), Int(a%b), nil
+returna.divMod(b)
  }
-returnNotImplemented, None, nil
+returnNotImplemented, NotImplemented, nil
 }
 
 func (aInt) M__rdivmod__(otherObject) (Object, Object, error){
 ifb, ok:=convertToInt(other); ok{
-ifa==0{
-returnnil, nil, divisionByZero
- }
-// Can't overflow
-returnInt(b/a), Int(b%a), nil
+returnb.divMod(a)
  }
-returnNotImplemented, None, nil
+returnNotImplemented, NotImplemented, nil
 }
 
 func (aInt) M__pow__(other, modulusObject) (Object, error){

py/tests/int.py

@@ -202,19 +202,77 @@ def approxEqual(a, b):
 approxEqual((8320894759108355333/688889843982879461528409053334), 1.2078701452470752e-11)
 approxEqual((647075625851211057828684328038/-326063662711018305247049652642), -1.9845070145847477)
 
-# FIXME
-# doc='binop //'
-# assert (5744409969029584448//-1220411214895984398) == -5
-# assert (801848568806426077475668423535//-8085312908136062722) == -99173473918
-# assert (-5721542802125298347//-987715757830780227623113033880) == 0
-# assert (457897615381227167341108005859//-353379489795893751557547859364) == -2
-
-# FIXME
-#doc='binop %'
-# assert (7341566843809298600%3978427562660778191) == 3363139281148520409
-# assert (294375077667396199949508874162%7786366607165572976) == 345835433804354002
-# assert (6316821303028268687%-707212250464589439185037502466) == -707212250458272617882009233779
-# assert (-119459441634706255601601571546%17130399946665545258117887219) == 453357991952561205223638987
+doc='Int divide signs'
+assert (123//20) ==6
+assert (123//-20) ==-7
+assert (-123//20) ==-7
+assert (-123//-20) ==6
+assert (123%20) ==3
+assert (123%-20) ==-17
+assert (-123%20) ==17
+assert (-123%-20) ==-3
+
+doc='Int divide signs exact'
+assert (200//20) ==10
+assert (200//-20) ==-10
+assert (-200//20) ==-10
+assert (-200//-20) ==10
+assert (200%20) ==0
+assert (200%-20) ==0
+assert (-200%20) ==0
+assert (-200%-20) ==0
+
+doc='Int divide zero'
+assert (200//201) ==0
+assert (200//-201) ==-1
+assert (-200//201) ==-1
+assert (-200//-201) ==0
+assert (200%201) ==200
+assert (200%-201) ==-1
+assert (-200%201) ==1
+assert (-200%-201) ==-200
+
+doc='BigInt divide zero'
+assert (2000000000000000000000//2000000000000000000001) ==0
+assert (2000000000000000000000//-2000000000000000000001) ==-1
+assert (-2000000000000000000000//2000000000000000000001) ==-1
+assert (-2000000000000000000000//-2000000000000000000001) ==0
+assert (2000000000000000000000%2000000000000000000001) ==2000000000000000000000
+assert (2000000000000000000000%-2000000000000000000001) ==-1
+assert (-2000000000000000000000%2000000000000000000001) ==1
+assert (-2000000000000000000000%-2000000000000000000001) ==-2000000000000000000000
+
+doc='BigInt divide signs'
+assert (1000000000000000000000000000001//100000000000000000001) ==9999999999
+assert (1000000000000000000000000000001//-100000000000000000001) ==-10000000000
+assert (-1000000000000000000000000000001//100000000000000000001) ==-10000000000
+assert (-1000000000000000000000000000001//-100000000000000000001) ==9999999999
+assert (1000000000000000000000000000001%100000000000000000001) ==99999999990000000002
+assert (1000000000000000000000000000001%-100000000000000000001) ==-9999999999
+assert (-1000000000000000000000000000001%100000000000000000001) ==9999999999
+assert (-1000000000000000000000000000001%-100000000000000000001) ==-99999999990000000002
+
+doc='BigInt divide signs equal'
+assert (1000000000000000000000000000000//100000000000000000000) ==10000000000
+assert (1000000000000000000000000000000//-100000000000000000000) ==-10000000000
+assert (-1000000000000000000000000000000//100000000000000000000) ==-10000000000
+assert (-1000000000000000000000000000000//-100000000000000000000) ==10000000000
+assert (1000000000000000000000000000000%100000000000000000000) ==0
+assert (1000000000000000000000000000000%-100000000000000000000) ==0
+assert (-1000000000000000000000000000000%100000000000000000000) ==0
+assert (-1000000000000000000000000000000%-100000000000000000000) ==0
+
+doc='binop //'
+assert (5744409969029584448//-1220411214895984398) ==-5
+assert (801848568806426077475668423535//-8085312908136062722) ==-99173473918
+assert (-5721542802125298347//-987715757830780227623113033880) ==0
+assert (457897615381227167341108005859//-353379489795893751557547859364) ==-2
+
+doc='binop %'
+assert (7341566843809298600%3978427562660778191) ==3363139281148520409
+assert (294375077667396199949508874162%7786366607165572976) ==345835433804354002
+assert (6316821303028268687%-707212250464589439185037502466) ==-707212250458272617882009233779
+assert (-119459441634706255601601571546%17130399946665545258117887219) ==453357991952561205223638987
 
 doc='binop &'
 assert (-6956530093671002017&-1100238534807351779) ==-8056622384673947619
@@ -326,35 +384,33 @@ def approxEqual(a, b):
 a/=-705476577911651649854533260835
 approxEqual(a, 0.9120485356446241)
 
-# FIXME
-#doc='augop //'
-# a = -2955145545873784447
-# a //= -8398154603067315189
-# assert a == 0
-# a = 764874707978666366468709717939
-# a //= -637453031923767022
-# assert a == -1199891866026
-# a = -3225133016360684087
-# a //= -106830573980181067612866984034
-# assert a == 0
-# a = -1017486275496211203702167393
-# a //= 707873786594465355113033731247
-# assert a == -1
-
-# FIXME
-# doc='augop %'
-# a = -4898359889955701722
-# a %= 2586537256564406544
-# assert a == 274714623173111366
-# a = 165600857868102801319021818388
-# a %= -5550996453372617970
-# assert a == -525692049140908922
-# a = -1667139790609035866
-# a %= 132512297800301099457101240885
-# assert a == 132512297798633959666492205019
-# a = 1223018728310354788098388057
-# a %= 756727576419043673398940776835
-# assert a == 1223018728310354788098388057
+doc='augop //'
+a=-2955145545873784447
+a//=-8398154603067315189
+asserta==0
+a=764874707978666366468709717939
+a//=-637453031923767022
+asserta==-1199891866026
+a=-3225133016360684087
+a//=-106830573980181067612866984034
+asserta==0
+a=-1017486275496211203702167393
+a//=707873786594465355113033731247
+asserta==-1
+
+doc='augop %'
+a=-4898359889955701722
+a%=2586537256564406544
+asserta==274714623173111366
+a=165600857868102801319021818388
+a%=-5550996453372617970
+asserta==-525692049140908922
+a=-1667139790609035866
+a%=132512297800301099457101240885
+asserta==132512297798633959666492205019
+a=1223018728310354788098388057
+a%=756727576419043673398940776835
+asserta==1223018728310354788098388057
 
 doc='augop &'
 a=-926347478023783305
@@ -401,8 +457,8 @@ def approxEqual(a, b):
 # FIXME
 # powmod
 # divmod
-# lsl
-# lsr
+# <<
+# >>
 # round
 # **
 # **=