rishi/scryer-prolog
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #677 from notoria/clpz_mod

Browse Source 
Made mod stronger and addressed #675
This commit is contained in:
Mark Thom
2020-08-15 13:55:48 -03:00
committed by GitHub
parent 79a74038ac 0724c044d6
commit 62c9b8390b
1 changed files with 134 additions and 128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

262
src/lib/clpz.pl
View File

@@ -4928,7 +4928,7 @@ run_propagator(pmod(X,Y,Z), MState) -->
( Y == 0 -> { false }
; Y == Z -> { false }
% ; nonvar(Y), Z == X -> true
; X == Y -> kill(MState), Z = 0
; X == Y -> kill(MState), queue_goal(Z = 0)
; true
),
( nonvar(X), nonvar(Y) ->
@@ -4940,20 +4940,20 @@ run_propagator(pmod(X,Y,Z), MState) -->
),
( { fd_get(X, _, n(XL), _, _) } ->
( (XL - Z) mod Y =\= 0 ->
{ XMin is Z + Y * ((XL - Z) div Y + 1) }
; { XMin is Z + Y * ((XL - Z) div Y) }
XMin is Z + Y * ((XL - Z) div Y + 1)
; XMin is XL
),
{ fd_get(X, XD0, XPs),
domain_remove_smaller_than(XD0, XMin, XD2),
fd_put(X, XD2, XPs) }
domain_remove_smaller_than(XD0, XMin, XD2) },
fd_put(X, XD2, XPs)
% queue_goal(X #>= XMin)
; true
),
( { fd_get(X, _, _, n(XU), _) } ->
{ XMax is Z + Y * ((XU - Z) div Y) },
XMax is Z + Y * ((XU - Z) div Y),
{ fd_get(X, XD1, XPs),
domain_remove_greater_than(XD1, XMax, XD3),
fd_put(X, XD3, XPs) }
domain_remove_greater_than(XD1, XMax, XD3) },
fd_put(X, XD3, XPs)
% queue_goal(X #=< XMax)
; true
)
@@ -4973,14 +4973,14 @@ run_propagator(pmod(X,Y,Z), MState) -->
( Z > 0 ->
{ fd_get(Y, YD, YPs),
YMin is Z + 1,
domain_remove_smaller_than(YD, YMin, YD1),
fd_put(Y, YD1, YPs) }
domain_remove_smaller_than(YD, YMin, YD1) },
fd_put(Y, YD1, YPs)
% queue_goal(Y #> Z)
; Z < 0 ->
{ fd_get(Y, YD, YPs),
YMax is Z - 1,
domain_remove_greater_than(YD, YMax, YD1),
fd_put(Y, YD1, YPs) }
domain_remove_greater_than(YD, YMax, YD1) },
fd_put(Y, YD1, YPs)
% queue_goal(Y #< Z)
; true
)
@@ -4992,120 +4992,126 @@ run_propagator(pmod(X,Y,Z), MState) -->
run_propagator(pmodz(X,Y,Z), MState) -->
( nonvar(Z) -> true % Nothing to do.
; nonvar(X) ->
( X =:= 0 -> kill(MState), Z = X
; X > 0 ->
( { fd_get(Y, _, n(YL), _, _), YL > X } ->
kill(MState),
Z = X
; { fd_get(Z, ZD0, ZPs),
domain_remove_greater_than(ZD0, X, ZD2),
fd_put(Z, ZD2, ZPs) }
% queue_goal(Z #=< X)
( X =:= 0 -> kill(MState), queue_goal(Z = X)
; ( X > 0 ->
( { fd_get(Y, _, n(YL), _, _), YL > X } ->
kill(MState),
queue_goal(Z = X)
; { fd_get(Z, ZD0, ZPs),
domain_remove_greater_than(ZD0, X, ZD2) },
fd_put(Z, ZD2, ZPs)
% queue_goal(Z #=< X)
)
; X < 0 ->
( { fd_get(Y, _, _, n(YU), _), YU < X } ->
kill(MState),
queue_goal(Z = X)
; { fd_get(Z, ZD0, ZPs),
domain_remove_smaller_than(ZD0, X, ZD2) },
fd_put(Z, ZD2, ZPs)
% queue_goal(Z #>= X)
)
),
( { fd_get(Y, _, n(YL), n(YU), _), YL > 0 } ->
ZMax is YU - 1,
{ fd_get(Z, ZD1, ZPs),
domain_remove_smaller_than(ZD1, 0, ZD3),
domain_remove_greater_than(ZD3, ZMax, ZD5) },
fd_put(Z, ZD5, ZPs)
% queue_goal(Z in 0..ZMax)
; { fd_get(Y, _, n(YL), n(YU), _), YU < 0 } ->
ZMin is YL + 1,
{ fd_get(Z, ZD1, ZPs),
domain_remove_greater_than(ZD1, 0, ZD3),
domain_remove_smaller_than(ZD3, ZMin, ZD5) },
fd_put(Z, ZD5, ZPs)
% queue_goal(Z in ZMin..0)
; true
)
; X < 0 ->
( { fd_get(Y, _, _, n(YU), _), YU < X } ->
kill(MState),
Z = X
; { fd_get(Z, ZD0, ZPs),
domain_remove_smaller_than(ZD0, X, ZD2),
fd_put(Z, ZD2, ZPs) }
% queue_goal(Z #>= X)
)
),
( { fd_get(Y, _, n(YL), n(YU), _), YL > 0 } ->
{ ZMax is YU - 1 },
{ fd_get(Z, ZD1, ZPs),
domain_remove_smaller_than(ZD1, 0, ZD3),
domain_remove_greater_than(ZD3, ZMax, ZD5),
fd_put(Z, ZD5, ZPs) }
% queue_goal(Z in 0..ZMax)
; { fd_get(Y, _, n(YL), n(YU), _), YU < 0 } ->
{ ZMin is YL + 1 },
{ fd_get(Z, ZD1, ZPs),
domain_remove_greater_than(ZD1, 0, ZD3),
domain_remove_smaller_than(ZD3, ZMin, ZD5),
fd_put(Z, ZD5, ZPs) }
% queue_goal(Z in ZMin..0)
; true
)
; nonvar(Y) ->
( abs(Y) =:= 1 -> kill(MState), Z = 0
( abs(Y) =:= 1 -> kill(MState), queue_goal(Z = 0)
; Y < 0 ->
{ ZMin is Y + 1 },
{ fd_get(Z, ZD1, ZPs),
domain_remove_greater_than(ZD1, 0, ZD3),
domain_remove_smaller_than(ZD3, ZMin, ZD5),
fd_put(Z, ZD5, ZPs) }
% queue_goal(Z in ZMin..0)
( { fd_get(X, _, n(XL), n(XU), _), XU =< 0, Y < XL } ->
kill(MState),
queue_goal(Z = X)
; ZMin is Y + 1,
{ fd_get(Z, ZD1, ZPs),
domain_remove_greater_than(ZD1, 0, ZD3),
domain_remove_smaller_than(ZD3, ZMin, ZD5) },
fd_put(Z, ZD5, ZPs)
% queue_goal(Z in ZMin..0)
)
; Y > 0 ->
{ ZMax is Y - 1 },
{ fd_get(Z, ZD1, ZPs),
domain_remove_smaller_than(ZD1, 0, ZD3),
domain_remove_greater_than(ZD3, ZMax, ZD5),
fd_put(Z, ZD5, ZPs) }
% queue_goal(Z in 0..ZMax)
),
( { fd_get(X, _, n(XL), n(XU), _), XL >= 0 } ->
{ fd_get(Z, ZD0, ZPs),
domain_remove_greater_than(ZD0, XU, ZD2),
fd_put(Z, ZD2, ZPs) }
% queue_goal(Z #=< XU)
; { fd_get(X, _, n(XL), n(XU), _), XU =< 0 } ->
{ fd_get(Z, ZD0, ZPs),
domain_remove_smaller_than(ZD0, XL, ZD2),
fd_put(Z, ZD2, ZPs) }
% queue_goal(Z #>= XL)
; true
( { fd_get(X, _, n(XL), n(XU), _), XL >= 0, Y > XU } ->
kill(MState),
queue_goal(Z = X)
; ZMax is Y - 1,
{ fd_get(Z, ZD1, ZPs),
domain_remove_smaller_than(ZD1, 0, ZD3),
domain_remove_greater_than(ZD3, ZMax, ZD5) },
fd_put(Z, ZD5, ZPs)
% queue_goal(Z in 0..ZMax)
)
)
; ( { fd_get(X, _, n(XL), n(XU), _), XL >= 0 } ->
{ fd_get(Z, ZD0, ZPs),
domain_remove_greater_than(ZD0, XU, ZD2),
fd_put(Z, ZD2, ZPs) }
% queue_goal(Z #=< XU)
; { fd_get(X, _, n(XL), n(XU), _), XU =< 0 } ->
{ fd_get(Z, ZD0, ZPs),
domain_remove_smaller_than(ZD0, XL, ZD2),
fd_put(Z, ZD2, ZPs) }
% queue_goal(Z #>= XL)
; true
),
( { fd_get(Y, _, n(YL), n(YU), _), YL > 0 } ->
{ ZMax is YU - 1 },
{ fd_get(Z, ZD1, ZPs),
domain_remove_smaller_than(ZD1, 0, ZD3),
domain_remove_greater_than(ZD3, ZMax, ZD5),
fd_put(Z, ZD5, ZPs) }
% queue_goal(Z in 0..ZMax)
; { fd_get(Y, _, n(YL), n(YU), _), YU < 0 } ->
{ ZMin is YL + 1 },
{ fd_get(Z, ZD1, ZPs),
domain_remove_greater_than(ZD1, 0, ZD3),
domain_remove_smaller_than(ZD3, ZMin, ZD5),
fd_put(Z, ZD5, ZPs) }
% queue_goal(Z in ZMin..0)
; { fd_get(Y, _, n(YL), n(YU), _) } ->
{ ZMin is YL + 1,
ZMax is YU - 1 },
{ fd_get(Z, ZD1, ZPs),
domain_remove_greater_than(ZD1, ZMax, ZD3),
domain_remove_smaller_than(ZD3, ZMin, ZD5),
fd_put(Z, ZD5, ZPs) }
% queue_goal(Z in ZMin..ZMax)
%/* This doesn't work very well.
; { fd_get(Y, _, _, n(YU), _), YU > 0 } ->
{ fd_get(Z, ZD1, ZPs),
ZMax is YU - 1,
domain_remove_greater_than(ZD1, ZMax, ZD3),
fd_put(Z, ZD3, ZPs) }
% queue_goal(Z #< YU)
; { fd_get(Y, _, n(YL), _, _), YL < 0 } ->
{ fd_get(Z, ZD1, ZPs),
ZMin is YL + 1,
domain_remove_smaller_than(ZD1, ZMin, ZD3),
fd_put(Z, ZD3, ZPs) }
% queue_goal(Z #> YL)
% */
; true
; ( { fd_get(X, _, n(XL), n(XU), _), XL >= 0,
fd_get(Y, _, n(YL), _, _), XU < YL } ->
kill(MState),
queue_goal(Z = X)
; { fd_get(X, _, n(XL), n(XU), _), XU =< 0,
fd_get(Y, _, _, n(YU), _), XL > YU } ->
kill(MState),
queue_goal(Z = X)
; ( { fd_get(X, _, n(XL), n(XU), _), XL >= 0 } ->
{ fd_get(Z, ZD0, ZPs),
domain_remove_greater_than(ZD0, XU, ZD2) },
fd_put(Z, ZD2, ZPs)
% queue_goal(Z #=< XU)
; { fd_get(X, _, n(XL), n(XU), _), XU =< 0 } ->
{ fd_get(Z, ZD0, ZPs),
domain_remove_smaller_than(ZD0, XL, ZD2) },
fd_put(Z, ZD2, ZPs)
% queue_goal(Z #>= XL)
; true
),
( { fd_get(Y, _, n(YL), n(YU), _), YL > 0 } ->
ZMax is YU - 1,
{ fd_get(Z, ZD1, ZPs),
domain_remove_smaller_than(ZD1, 0, ZD3),
domain_remove_greater_than(ZD3, ZMax, ZD5) },
fd_put(Z, ZD5, ZPs)
% queue_goal(Z in 0..ZMax)
; { fd_get(Y, _, n(YL), n(YU), _), YU < 0 } ->
ZMin is YL + 1,
{ fd_get(Z, ZD1, ZPs),
domain_remove_greater_than(ZD1, 0, ZD3),
domain_remove_smaller_than(ZD3, ZMin, ZD5) },
fd_put(Z, ZD5, ZPs)
% queue_goal(Z in ZMin..0)
; { fd_get(Y, _, n(YL), n(YU), _) } ->
ZMin is YL + 1,
ZMax is YU - 1,
{ fd_get(Z, ZD1, ZPs),
domain_remove_greater_than(ZD1, ZMax, ZD3),
domain_remove_smaller_than(ZD3, ZMin, ZD5) },
fd_put(Z, ZD5, ZPs)
% queue_goal(Z in ZMin..ZMax)
%/* This doesn't work very well.
; { fd_get(Y, _, _, n(YU), _), YU > 0 } ->
{ fd_get(Z, ZD1, ZPs),
ZMax is YU - 1,
domain_remove_greater_than(ZD1, ZMax, ZD3) },
fd_put(Z, ZD3, ZPs)
% queue_goal(Z #< YU)
; { fd_get(Y, _, n(YL), _, _), YL < 0 } ->
{ fd_get(Z, ZD1, ZPs),
ZMin is YL + 1,
domain_remove_smaller_than(ZD1, ZMin, ZD3) },
fd_put(Z, ZD3, ZPs)
% queue_goal(Z #> YL)
% * /
; true
)
)
).
@@ -5116,26 +5122,26 @@ run_propagator(pmody(X,Y,Z), MState) -->
( Z > 0 -> % queue_goal(Y #> Z)
{ fd_get(Y, YD, YPs),
YMin is Z + 1,
domain_remove_smaller_than(YD, YMin, YD1),
fd_put(Y, YD1, YPs) }
domain_remove_smaller_than(YD, YMin, YD1) },
fd_put(Y, YD1, YPs)
; Z < 0 -> % queue_goal(Y #< Z)
{ fd_get(Y, YD, YPs),
YMax is Z - 1,
domain_remove_greater_than(YD, YMax, YD1),
fd_put(Y, YD1, YPs) }
domain_remove_greater_than(YD, YMax, YD1) },
fd_put(Y, YD1, YPs)
; Z =:= 0 -> kill(MState), queue_goal(X / Y #= _)
)
; ( { fd_get(Z, _, n(ZL), _, _), ZL > 0 } ->
{ fd_get(Y, YD, YPs),
YMin is ZL + 1,
domain_remove_smaller_than(YD, YMin, YD1),
fd_put(Y, YD1, YPs) }
domain_remove_smaller_than(YD, YMin, YD1) },
fd_put(Y, YD1, YPs)
% queue_goal(Y #> ZL)
; { fd_get(Z, _, _, n(ZU), _), ZU < 0 } ->
{ fd_get(Y, YD, YPs),
YMax is ZU - 1,
domain_remove_greater_than(YD, YMax, YD1),
fd_put(Y, YD1, YPs) }
domain_remove_greater_than(YD, YMax, YD1) },
fd_put(Y, YD1, YPs)
% queue_goal(Y #< ZU)
; true
)