Version 3.6 (1/11/2024) ================================= + Added an interface to SCIP, which is better than other solvers for solving some integer programming problems. The SCIP interface is not included in the default binary executable. One has to install the interface from the source code following the installation instructions given in INSTALL. + Added the include directive, which allows splitting a large program file into multiple files. + Ported several global constraints from the sat module to cp, mip, and smt modules. + Modified the implementation of solve/1-2 in the cp module such that it instantiates all constrained variables, including hidden variables used in propagators. This change makes it unnecessary to call solve_suspended. + Added a new built-in, named del(Map,Key), which deletes a pair with Key from Map. + A bug fix in the cumulative global constraint, which occurs when there are tasks with 0 durations. + A bug fix in the SAT compiler, which affects domain variables with mixed signed values in certain contexts. + A new solver option, named maxsat, for the sat module. Picat communicates with maxsat through files. When the solve option maxsat is used for constraint optimization problems, the OS command 'maxsat' must be made available to Picat. Version 3.5 (7/2/2023) ================================= + Added the following new constraints into the sat module: acyclic_d(Vs,Es): The directed graph represented by Vs and Es is acyclic. path_d(Vs,Es,Src,Dest): The directed graph represented by Vs and Es is a path from Src to Dest. scc_d(Vs,Es): The directed graph represented by Vs and Es is strongly connected. + A bug fix in the SAT compiler Version 3.4 (3/11/2023) ================================= + Improved the implementations of print, println, printf, write, writeln, and writef. + Improved syntax error messages. + Fixed a bug in acyclic. + Fixed a bug in the SAT compiler. + Changed the definition of the path constraint. + Unsupported options in solve/2 result in warnings, not errors. + Several improvements on the SAT compiler. + Improved two functions in "picat_utilities.c". Version 3.3 (9/6/2022) ================================= + Fixed a bug in the function replace/3 in the util module. + Added an optimization into the SAT compiler, which converts more PB constraints into cardinality constraints. + Improved the encodings of the Z = min(X,Y) and Z = max(X,Y) constraints of the sat module. + Added the global constraints into sat: acyclic(Vs,Es): The undirected graph represented by Vs and Es is acyclic. path(Vs,Es,Src,Dest): + Fixed a bug in reading non-printable ASCII characters. + Improved the preprocessor for reification and implication constraints. + Improved the linearized MIP code of min(X,Y) and max(X,Y), where both X and Y are Boolean variables. + Treat L..U as an unevaluated range expression in domain variable declarations. + Warnings are issued for singleton variables occurring in bodies, not in heads. + Added nolog into the sys module. Version 3.2 (3/12/2022) ================================= + Improved the compiler so that it evaluates constant function calls at compile time. For example, for a function definition: f(a) = 1. f(b) = 2. The compiler replaces the call f(a) by 1 and the call f(b) by 2 at compile time, as long as the calls occur after the definition in the same file. + Added break(Cond) in foreach loops and list/array comprehensions Picat> foreach (I in 1..10, break(I > 3)) writeln(I) end 1 2 3 Picat> L = [I : I in 1..10, break(I > 3)] L = [1,2,3] + Added the following new built-ins into the sat module: tree(Vs,Es) tree(Vs,Es,K) + Fixed a bug in printf, which occurs when printing excessively long strings. + Changed the behavior of write/1 in the way that an atom is single quoted unless it matches [a-z][a-zA-Z0-9_]* + Improved the loader to avoid program area overflow. + Added command line options so that users can start Picat with a customized setting -p P: size of the program area -s S: size of the stack/heap -b B: size of the trail stack + Improved the encoding of scc. + Kissat is used as the default SAT solver. + Fixed a bug in printf/n and to_fstring/n, which occurs when the specifier is %s and the argument is "". Version 3.1 (5/6/2021) ================================= + Made several improvements on the SAT compiler. + Added a new solve option, named limit(N), which limits the number of solutions to be searched. + Added the following new built-ins into the sat module: hcp(Vs,Es) hcp(Vs,Es,K) hcp_grid(A) hcp_grid(A,Es) hcp_grid(A,Es,K) scc(Vs,Es) scc(Vs,Es,K) scc_grid(A) scc_grid(A,K) + Improved error messages for table_in and table_notin. + Improved the mip translation of entailment constraints. + Fixed a bug in X #<=> Y when X or Y is 1 + Fixed a bug in best_plan_nondet + Fixed a bug in c_MUL_MOD. + Fixed a bug that affected programs containing a certain range of big integers in heads. + Made it possible to trace calls in guards. + Made extended math functions available in both debug and normal execution modes. + Fixed a bug in the debugger that occurs when programs involving modules are compiled and used in debug mode. Version 3.0 (September 26, 2020) ================================= + Numerous improvements on the SAT compiler. + Reimplemented the circuit constraint of the sat module, as reported in the CP'20 paper. + Support of Horn clauses. Horn clauses are translated into pattern-matching rules based on user-supplied or automatically generated index declarations. + Support of DCG rules. DCG rules are translated into pattern-matching rules via Horn clauses. + Added the following new built-in predicates from Prolog: arg(I,T,A) functor(T,F,N) '=..'(X,Y) \+ ! + Changed the binding rules for higher-order calls. + Improved the implementation of higher-order calls. + Improved the debugger. No private calls or compiler-generated calls can be traced. + Fixed a bug in big-integer compilation. + Improved the implementation of the multiplication constraint in cp. + Fixed a bug in the preprocessor of non-linear constraints that use //, div, mod, or abs. + Fixed a bug in listdir/1 for Windows. + Changed the behavior of open(File,Mode): it returns a new stream for a file even if the file has already been opened. + Improved the translation of functions into tail-recursive predicates. + Improved the handling of the power function in constraints so that it's less likely to cause overflows. + Fixed a bug in vars/1 functions. + Beautified the C source code. Version 2.8 (December 5, 2019) ================================= + Added new built-in constraints in the sat module subcircuit_grid(A) subcircuit_grid(A,K) + Improved SAT encodings for at-most-k constraints + Improved error messages + Added the nn (Neural Network) module new_nn(Layers) = NN new_sparse_nn(Layers) = NN new_sparse_nn(Layers,Rate) = NN new_standard_nn(Layers) = NN nn_destroy(NN) nn_destroy_all nn_load(File) = NN nn_print(NN) nn_run(NN, Input) = Output nn_run(NN, Input, Opts) = Output nn_save(NN,File) nn_set_activation_function_hidden(NN, Func) nn_set_activation_function_layer(NN, Func, Layer) nn_set_activation_function_output(NN, Func) nn_set_activation_steepness_hidden(NN, Steepness) nn_set_activation_steepness_layer(NN, Steepness, Layer) nn_set_activation_steepness_output(NN, Steepness) nn_train(NN,Data) nn_train(NN,Data,Opts) nn_train_data_get(Data, I) = Pair nn_train_data_load(File) = Data nn_train_data_save(Data, File) nn_train_data_size(Data) = Size + Support of Cbc as an underlying MIP solver The solve predicate in the mip module supports a new option, named cbc, which instructs Picat to use the Cbc MIP solver. Picat uses the following command to call the Cbc solver: cbc TmpFile solve solu SolFile where SolFile is a file for the solution, and TmpFile is a file that stores the CPLEX-format constraints. Picat throws existence_error if the command cbc is not available. + Significant improvement of the SAT compiler. Use direct encoding if no variables are involved in arithmetic constraints. Hybrid encodings of table constraints. New encodings for small-domain arithmetic constraints. New implementation of the branch-and-bound algorithm for optimization problems. New decomposers for circuit, subcircuit, and regular constraints. + New built-ins on ASCII characters ascii_digit(Char) => ascii_digit(Char). ascii_alpha(Char) => ascii_alpha(Char). ascii_alpha_digit(Char) => ascii_alpha_digit(Char). ascii_lowercase(Char) => ascii_lowercase(Char). ascii_uppercase(Char) => ascii_uppercase(Char). + Changed the implementation of log(Base,X) + Bug fix in bigint multiplication Version 2.6 (February 7, 2019) ================================= + Table constraints can involve short tuples, where values can be the don't-care symbol *. + Added the new built-in predicate bigint(X) in the basic module. + Improved error messages + BDD encoding for table constraints + Tuples in table constraints must have the syntax {a1,...,an}, and the syntax (a1,...,an) is no longer supported for tuples in table constraints. Version 2.5 (October 8, 2018) ================================= + Added a new module, named smt, for constraint solving. The module requires z3 or cvc4 as the SMT solver. + Allow ranges in subscripts: A[From..To] is the same as slice(A,From,To). + copy_term_shalow(T) = copy_term_shalow(T). + one bug fix in the regular constraint + bug fixes in the SAT encoder + one bug fix in big-integer arithmetic Version 2.4 (April 15, 2018) ================================= + Support of the heap data structure heap_is_empty(Heap) => heap_is_empty(Heap). heap_pop(Heap) = heap_pop(Heap). heap_push(Heap,Elm) => heap_push(Heap,Elm). heap_size(Heap) = heap_size(Heap). heap_to_list(Heap) = heap_to_list(Heap). heap_top(Heap) = heap_top(Heap). new_max_heap(IntOrList) = new_max_heap(IntOrList). new_min_heap(IntOrList) = new_min_heap(IntOrList). + Dot-notations are treated as functions in term constructors and constraints. Examples: X = $f(math.pi) R = new_rectangle(), R.x #= R.y, R.width #= R.height, R.color #= cg.red + Improvements on the SAT compiler for Pseudo-Boolean constraints and global constraints + Colors in error messages (unix only) + A special comparator is used in comparing arrays + 64-bit executable for Windows + Bug fixes: round, ** Version 2.3 (February 1, 2018) ================================= + Incorporated new SAT encodings for the following global constraints: element, regular, circuit, subcircuit, table_in, and table_notin. + Added a new built-in in the planner module, named best_plan_bin, which uses branch-and-bound and binary search to find a best plan. + The compiler unfolds higher-order calls to map/2, map/3, reduce/2, and reduce/3, so that these calls are more efficient and obey the name-resolving rules in modules. + Minor improvements: sort, SAT compiler, tabling, planner. + Bug fixes: map/1, SAT compiler. Version 2.2 (August 10, 2017) ================================= + The mip module supports the same set of constraints as the sat and cp modules, including global constraints. + The solve/1-2 predicates in the mip module are non-deterministic, and can be used to return all solutions. + The sat module supports a new labeling option, named $threads(N), which, when specified, solves the generated CNF code using plingeling with N threads. The option threads is the same as $threads(8). + New constraint in cp, sat, and mip: count(V,FDVars,N): V occurs in FDVars N times. + Significant improvements in the SAT compiler. The PicatSAT solver submitted to MiniZinc Challenge 2017 is based on this version. + Added the following functions into the math module: acosh(X) acoth(X) acsch(X) asech(X) asinh(X) atanh(X) cosh(X) coth(X) csch(X) frand(Low,High) random(Low,High) sech(X) tanh(X) sinh(X) + several bug fixes Version 2.1 (March 12, 2017) ================================= + Extensions count(V,L) can occur in constraint expressions. + Improvements The SAT compiler performs constant propagation, which may lead to reduction in code sizes. The preprocessor of the SAT compiler is improved so that it excludes more no-good values. + bug fixes a bug in comparison of integers between -2^56..-2^28 and 2^28..2^56 a bug in the pow function that occurs when the operands are floats a bug in the sat compiler that affects large domains Version 2.0 (November 17, 2016) ================================= + Improvements in sat New implementations of the circuit, subcircuit, and regular constraints New and better ordering for breaking constraints into primitive ones + Extension of the planner module In addition to defining the final/1 (or final/3) and action/4 predicates, users can also provide a function, named heuristic(S), and a predicate, named sequence(P,A). The heuristic(S) function is used by the planner to check the heuristic value before each state expansion, and the sequence/2 predicate determines the next set of actions based on the current partial plan. + Interface to Gurobi The solve predicate in the mip module supports a new option, named gurobi, which instructs Picat to use the Gurobi MIP solver. Picat uses the following command to call the Gurobi solver: gurobi_cl ResultFile=SolFile TmpFile where SolFile is a file for the solution, and TmpFile is a file that stores the CPLEX-format constraints. Picat throws existence_error if the command gurobi_cl is not available. + Interface to GLPK The tight interface with GLPK was removed, and a new interface that interacts with GLPK through files was added. The solve predicate in the mip module supports a new option, named glpk, which instructs Picat to use the GLPK MIP solver. Picat uses the following command to call the GLPK solver: glpsol --lp -o SolFile TmpFile where SolFile is a file for the solution, and TmpFile is a file that stores the CPLEX-format constraints. Picat throws existence_error if the command glpsol is not available. + Capable of compiling programs that include big structures and big arrays (before the limit was 255). + Exceptions in math functions: asin(X), acos(X), X**Y, log(X), log10(X), log2(X), log(B,X) + Clean up exceptions. + zip(Lists) added into the basic module. + to_number(NumOrCharOrStr) added into the basic module. + cl_facts_table(Facts) and cl_facts_table(Facts,IndexInfo) added into the sys module. + New math functions added: acot(X) = acot(X). acsc(X) = acsc(X). asec(X) = asec(X). cot(X) = cot(X). csc(X) = csc(X). sec(X) = sec(X). + New command line option "--v" and "--version" + New command line option "-s Size" for specifying initial stack/heap size. + New built-in functions added to the util module: take(L,N), drop(L,N), chunks_of(L,N). Version 1.9 (April 3, 2016) ================================= + Improvements in sat more compact encodings for PB constraints and all_different. new algorithm for breaking arithmetic constraints. binary search for optimization. + Improvements in planner binary search for optimization (best_plan and best_plan_bb). + New built-in functions in basic maxint_small() = maxint_small(). minint_small() = minint_small(). + Removal of built-ins best_plan_downward/n in planner Version 1.8 (February 18, 2016) ================================= + New built-ins math: pow_mod(X,Y,Z) = pow_mod(X,Y,Z). (the same as X**Y mod Z, but more efficient) basic: to_radix_string(Val,Base) = to_radix_string(Val,Base). parse_radix_string(String,Base) = parse_radix_string(String,Base). put_attr(AttrVar,Key,Val) => put_attr(AttrVar,Key,Val). get_attr(AttrVar,Key) = get_attr(AttrVar,Key) get_attr(AttrVar,Key,DefaultVal) = get_attr(AttrVar,Key,DefaultVal) cp: solve_suspended => solve_suspended. solve_suspended(Options) => solve_suspended(Options). + Improvements multiplication and mod operations on big integers tabling for functions and single-answer predicates + Bug fixes The matrix_element constraint is extended so that the matrix can be non-ground. The missing internal predicate '$bc_clause'/1 added. Version 1.7 (January 3, 2016) ================================= + New built-in functions in basic: get_heap_map(ID) get_global_map(ID) get_table_map(ID) + Improvements of operations on global and table maps. + Improvements of maxof and minof. Version 1.6 (December 13, 2015) ================================= + New built-ins in basic: int(Term) => int(Term). sorted(ListOrArray) => sorted(ListOrArray). sorted_down(ListOrArray) => sorted_down(ListOrArray). to_float(NumOrString) = to_float(NumOrString). to_int(NumOrCharOrString) = to_int(NumOrCharOrString). + New global constraints in cp and sat: decreasing(FDVars) => decreasing(FDVars). decreasing_strict(FDVars) => decreasing_strict(FDVars). increasing(FDVars) => increasing(FDVars). increasing_strict(FDVars) => increasing_strict(FDVars). + Overloaded built-ins for arrays: avg(ListOrArray) max(ListOrArray) min(ListOrArray) prod(ListOrArray) sort(ListOrArray) sort(ListOrArray,Index) sort_down(ListOrArray) sort_down(ListOrArray,Index) sort_down_remove_dups(ListOrArray) sort_down_remove_dups(ListOrArray,Index) sort_remove_dups(ListOrArray) sort_remove_dups(ListOrArray,Index) sum(ListOrArray) + bug fixes to_integer(String) where String begins with a sign f(X) = 1..X. f(X,Y) = X++Y. Vertion 1.5 (November 23, 2015) ================================= + Support nested as-patterns in rule heads. + New built-in functions and predicates in the basic module: count_all(Goal) = Count return the number of instances of Goal that are true. new_set() = Map return a set, which is a map where all keys are mapped to the atom not_a_value. put(Map,Key) the same as put(Map,Key,not_a_value). + Bug fixes Version 1.4 (September 28, 2015) ================================= + Integers in the range from -2^56-1 to 2^56-1 are represented as one word on 64-bit platforms. + The default lower and upper bounds of domains are, respectively, -2^56-1 and 2^56-1 on 64-bit platforms. + An improved SAT encoding for entailment constraints. + An improvement in the propagator for the multiplication constraint. + Arrays can be iterated over by foreach loops without being converted into lists. + A bug fix in tabling. + Output logs from GLPK are suppressed. + The "lib" directory contains more library modules, including: fzn_picat_cp.pi: A FlatZinc interpreter in Picat using the cp module. fzn_picat_sat.pi: A FlatZinc interpreter in Picat using the sat module. gen_indent_all.pi: generates command lines for indenting C files using Stan Warford's function. json.pi: a JSON encoder and decoder by Mike Bionchik. sugar2pi.pi: A converter from Sugar's CSP format to Picat. sugar2pi.pi: A converter from Sugar's CSP format to Picat. xcsp2pi.pi: A converter from XCSP to Picat. Version 1.3 (August 1, 2015) ================================= + The sort functions are improved. + A bug in the parser that caused errors in parsing unary operators as atoms is fixed. + An improvement on the SAT encoding of the circuit constraint. + An improvement on the min(L) and max(L) constraint expressions. Version 1.2 (June 12, 2015) ================================= + Following predicates in the planner module are made polymorphic: plan/3: plan(S,Limit,Plan) and plan(S,Plan,PlanCost) best_plan/3: best_plan(S,Limit,Plan) and best_plan(S,Plan,PlanCost) best_plan_nondet/3: best_plan_nondet(S,Limit,Plan) and best_plan_nondet(S,Plan,PlanCost) best_plan_upward/3: best_plan_upward(S,Limit,Plan) and best_plan_upward(S,Plan,PlanCost) plan_unbounded/3: plan_unbounded(S,Limit,Plan) and plan_unbounded(S,Plan,PlanCost) + 'best_plan_upward' is renamed to 'best_plan_bb' (best_plan_upward is deprecated now). + New predicates added. sort(List,KeyIndex) sort_remove_dups(List,KeyIndex) sort_down(List,KeyIndex) sort_down_remove_dups(List,KeyIndex) + The functions min and max are modified in the following way: min(X,Y) and max(X,Y): X and Y can be any terms min(L) and max(L): L is a list of any terms + The compiler compiles min([Elm : ...]) and max([Elm : ...]) so that the generated code computes the aggregate but does not create a list. + The zip functions don't require argument lists to have the same length. + For the foreach iterator {E1,E2} in zip(L1,L2), the compiler generates code to avoid creating a zipped list. + Reimplement the built-ins in the os module to avoid creating temporary symbols. + Bug fixes in find_first_of/2 and find_last_of/2 in the util module. Version 1.1 (May 11, 2015) ================================= + A change in the GC policy. + A bug fix in the global table map, which can affect some planning programs. + A bug fix in the 'dump' option in solve/2. + Improvements in the SAT compiler. + An improved implementation of the function len(_) (also length(_)). Version 1.0 (April 3, 2015) ================================= + Added an external language interface with C. Users have to download the C source code in order to use this interface. + An improvement on the compiler enables it to compile huge rules (rules that contain tens of thousands subgoals and variables). + Added array comprehensions. An array comprehension {E : Iterator, ...} is the same as to_array([E : Iterator, ...]). + Added a new built-in function: insert_ordered_down(OrderedList,Elm). + New built-ins best_plan_nondet/2-4 added into the planner module, which allows returning multiple plans through backtracking. + Added the module 'datetime'. It only has three functions: current_datetime(), current_date(), current_day(), and current_time(). + Added a new command option '-g InitGoal', which allows Picat to execute a specified goal rather than the default main/0 or main/1. + Redundant commas and semicolons in if-then-else and loops give warnings rather than errors. + The exception evaluation_error(undefined) is changed to evaluation_error(undefined,error_value). + The exception evaluation_error(zero_divisor) is changed to zero_divisor. + Improvements on the SAT compiler. + New global constraints added into cp and sat: matrix_element(M,I,J,V), scalar_product(A, X, Product), scalar_product(A, X, Rel, Product), all_different_except_0(Xs), exactly(N, X, V), at_most(N,X,V), and at_least(N,X,V). + The command "picat File" returns 1 if a run-time or syntax error occurs while executing File. It returns 0 if no error occurs. Version 0.9 (March 1, 2015) ================================= + Table constraints accept arrays as tuples. For example, table_in({V1,V2},[{1,2},{2,3}]). The form (a1,a2,...,an) for tuples still works but is obsolete. + Espresso is used to generate compact CNF codes for the domain, table, element, and regular constraints. + SAT removed from the MSV version; the cygwin version must be used on Windows. + This version issues a more user-friendly error message for Prolog-style if-then (A -> B) with no else part. + Bug fixes (including bugs reported by Sergii Dymchenko) + All global constraints are removed from the mip module. Now, the mip module only supports linear constraints. Version 0.8 (January 24, 2015) ================================= + New space and parenthesis rules are applied to printing expressions. + Significant improvements in the SAT compiler, especially in the handling of arithmetic, reified arithmetic, table, cumulative, and all_different constraints. + The SAT solver can be called multiple times in one program execution and can be backtracked over. + The count(V,L,Rel,Count) constraint can be reified for cp, sat, and mip. + The option dump(File) added for solve/2 in the sat module, which dumps the generated CNF code into File. + The implementation of cp/2 in the os module is modified such that no file can be copied onto itself. + Type checking is added to several built-ins. + New built-ins added: bool_dvar(X) into basic, and nvalue(N,L) into sat and cp. + An improvement in evaluation of tabled programs that require only one answer. Version 0.7 (November 13, 2014) ================================= + In insert_ordered(L,T): L must be a proper list. + The two-product encoding is used in sat for the at-most-one constraint. + More efficient translation of X #=> Y in sat. + The function len(Term) is added, which is equivalent to length(Term). + The attribute len is added as an alias of length (e.g., [1,2].len = L) + Change the default labeling strategy for max/min back to maxof/minof (in version 0.6, it was maxof_inc/minof_inc). + The objective expression in minof/maxof/minof_inc/maxof_inc cannot contain dot or index notations. + An improvement in the debugger. + A bug fix in read_file_lines(File) for reading UTF-8 characters. + Standardize the behaviors of mod/2 and div/2 for cp, sat, and mip (// is the same as div). Version 0.6 (August 15, 2014) ================================= + Improvements in the SAT compiler (reified constraints, X #=< Y, etc.). + A new decomposition algorithm for the cumulative constraint. + A linear-time algorithm for vars(Term)=Vs. + New built-ins added to basic: minof_inc/2-3, maxof_inc/2-3. + maxof/2-3, minof/2-3, maxof_inc/2-3, minof_inc/2-3 are allowed to have real-number objective expressions. + nth(I,S,V) is modified such that S can be a structure (including an array). + A negative number such as -1 is treated as a number even in patterns. So integer($-1) succeeds. Version 0.5 (July 16, 2014) ================================= + Improvements in the SAT compiler. + Standardize the behaviors of mod/2 and div/2 for cp, sat, mip, and basic. + Improved implementation of X #= max(L) and X #= min(L) in cp. Version 0.4 (July 2, 2014) ================================= + New function get_table_map() added into basic. A table map is stored in the table area and both keys and values are hash-consed. + New predicates is_tabled_state(S) and current_resource_plan_cost(Amount,Plan,Cost) added into planner. + New global constraints added in cp and sat: subcircuit/1, lex_le/2, lex_lt/2, regular/6. + Re-implement cp/2 for copying files in os. + New statistics flag, table_blocks, added. + Several significant improvements in the SAT compiler. + Bug fixes: neqs/1, put non-ground pairs into the global map,... Version 0.3 (May 23, 2014) ================================= + Added the mip module that links Picat with GLPK. The mip module also supports real-domain linear constraints in addition to integer-domain constraints supported by cp and sat. See mip models at http://www.hakank.org/picat/#mip + the solve(Options,Vars) built-in in the sat and mip modules are also non-deterministic. + New labeling options for the cp module: rand, rand_var, and rand_val. + Reifications B #<=> X :: Y and B #<=> X notin Y are supported by all three constraint modules + The operator '++' is changed to right-associative. Version 0.2#1 (April 1, 2014) ================================= + The prism module added (the executable is picat_prism) + New built-ins added to 'basic' module. new_list(N,InitVal) = new_list(N,InitVal). bind_vars(Term,Val) => bind_vars(Term,Val). + bug fixes big-int arithmetic statistics on fd backtracks fd_degree between/3 etc. Version 0.1 (stable) (Feb. 3, 2014) ================================= + command(String)=Status added to module 'sys'. + length(Atom) returns the number of UTF-8 chars of Atom if Atom is an atom. + New built-in added to module 'ordset'. ordset(Term) => ordset(Term). + sublist/3 is removed from the 'basic' module. slice/2-3 can be used instead. + An improvement in the multiplication constraint X #= Y*Z in CP. + New functions in 'io' module read_picat_token() = TokenValue read_picat_token(FD) = TokenValue + bug fixes attribute variables @>=/2, @<=/2 writable/1 user's guide Version 0.1 beta-10 (Jan. 15, 2014) ================================= + Support UTF-8 + char_code(Char) is replaced by ord(Char) + code_char(Code) is replaced by chr(Code) + New built-ins added to the 'basic' module '@>'(X,Y) => X @> Y. '@>='(X,Y) => X @>= Y. '@<'(X,Y) => X @< Y. '@<='(X,Y) => X @=< Y. '@=<'(X,Y) => X @=< Y. list_to_and(L) = list_to_and(L). and_to_list(And) = and_to_list(And). + New built-ins added to the io module read_char_code() = read_char_code(stdin). read_char_code(FD,N) = read_char_code(FD,N). read_char_code(FD) = read_char_code(FD). write_char(Chars) => write_char(stdout,Chars). write_char(FD,Chars) => write_char(FD,Chars). write_char_code(Codes) => write_char_code(stdout,Codes). write_char_code(FD,Codes) => write_char_code(FD,Codes). + Bug fixes: the module system printf & writef Version 0.1 beta-8 (Dec. 15, 2013) ================================= + Allows the user to define the condition of the final states with final(+S,-Plan,-Cost). + New functions and predicates added to the planner module current_plan() current_resource_plan(Resource,Plan) + best_plan(...) is changed to use the downward algorithm. + Throws an exception if the top-level main predicate of a Picat application fails + size(Map) added that returns the size of Map. Version 0.1 beta-7 (Nov. 25, 2013) ================================= + length([X : Iterator,...]) is compiled into a loop that does not create the list + The ordset module is added + The circuit constraint is added into the sat module + The sat compiler is improved (reification and element constraints) + bug fixes: compiling list comprehensions in disjunction module lookup Version 0.1 beta-6 (Nov. 10, 2013) ================================= + function current_resource/0 is added to the planner module. + '::'/2 is added to cp and sat. + in/2 and notin/2 are removed from basic. + improvements of operations on maps + bug fix: indomain(X) in cp Version 0.1 beta-5 (Nov. 3, 2013) ================================ + X in D: D must be an integer list + X notin D: D must be an integer list + table constraints are added into cp and sat: table_in(VarTuples,ValTuples), table_notin(VarTuples,ValTuples) + assignment, cumulative are added into the sat module + slice/1-2 added into the 'basic' module: L.slice(StartIndex), L.slice(FromIndex,ToIndex) + bug fix: in module qualified names, the module name can be a pre-imported module. For example, math.pi. + the built-in 'false' is added. + allow Boolean expressions in arithmetic constraints for sat. Version 0.1 beta-4 (Oct. 5, 2013) ================================ + new operators: (A && B) is the same as (A,B) (A || B) is the same as (A;B) + new predicate in the sys module cl (read a program from the console) + changes to the 'basic' module: array(Term) (array({}) succeeds now) to_list(Term) (to_list({}) returns []) delete(List,X) = NewList (use = for equality test rather than ==) delete_all(List,X) = NewList (use = for equality test rather than ==) find(String, Substring, From, To) (moved to util) find_ignore_case(String, Substring, From, To) (moved to util) replace(T,Old,New) = CopyT (change of the prototype) + new predicates added to the util module: find(String, Substring, From, To) (originally in the 'basic' module) find_first_of(T,Pattern)=Index, find_ignore_case(String, Substring, From, To) (originally in the 'basic' module) find_last_of(T,Pattern)=Index. lstrip(L) lstrip(L,Elms), replace_at(T,I,New)=CopyT, rstrip(L), rstrip(L,Elms), strip(L), strip(L,Elms), + (sum(a++b) #= 1) raises an exception rather than fails + document the report option in solve/2 (sat). + improve the element constraint in the sat module + change the precedence of := (:= cannot be part of an expression) + X[...] := Exp (raise an error if the updated term is not a heap one). + bug fixes: a bug in read_int(FD) and read_int(). a bug in the loop compiler