/* 

  Global constraint increasing_except_0 et.al. in Picat.

  This constraint ensures that list X is increasing if we disregard any 0's.

  Implemented constraints:
  - increasing_except_0/1
  - increasing_except_0_strict/1
  - decreasing_except_0/1
  - decreasing_except_0_strict/1
  
  - increasing_except_C/2
  - increasing_except_C_strict/2
  - decreasing_except_C/2
  - decreasing_except_C_strict/2
  

  This Picat model was created by Hakan Kjellerstrand, hakank@gmail.com
  See also my Picat page: http://www.hakank.org/picat/

*/

import cp.


main => go.

go ?=>

  N = 5,
  X = new_list(N),
  X :: 0..N,

  increasing_except_0(X),
  % increasing_except_0_strict(X),  
  % decreasing_except_0(X),  
  % decreasing_except_0_strict(X),
  
  % increasing_except_C(X,3),
  % increasing_except_C_strict(X,3),  
  % decreasing_except_C(X,3),  
  % decreasing_except_C_strict(X,3),  
  


  solve(X),
  println(X),
  fail,
  
  nl.

go => true.


% 
% Ensures that array a is increasing if we disregard any 0's
% 
increasing_except_0(A) =>
  increasing_except_C(A,0).

increasing_except_0_strict(A) =>
  increasing_except_C_strict(A,0).


increasing_except_C(A,C) =>
  N = A.len,
  foreach(I in 1..N, J in I+1..N)
    (A[I] #!= C #/\ A[J] #!= C) #=> (A[I] #<= A[J])
  end.

increasing_except_C_strict(A,C) =>
  N = A.len,
  foreach(I in 1..N, J in I+1..N)
    (A[I] #!= C #/\ A[J] #!= C) #=> (A[I] #< A[J])
  end.


% 
% Ensures that array a is decreasing if we disregard any 0's
% 
decreasing_except_0(A) =>
  decreasing_except_C(A,0). 

decreasing_except_0_strict(A) =>
  decreasing_except_C_strict(A,0).


decreasing_except_C(A,C) =>
  N = A.len,
  foreach(I in 1..N, J in I+1..N)
    (A[I] #!= C #/\ A[J] #!= C) #=> (A[I] #>= A[J])
  end.

decreasing_except_C_strict(A,C) =>
  N = A.len,
  foreach(I in 1..N, J in I+1..N)
    (A[I] #!= C #/\ A[J] #!= C) #=> (A[I] #> A[J])
  end.