NEWS since version 1.0.3 (for 1.1) ------------------------ Changes to the FlatZinc language: * Boolean variable expressions as constraints are no longer supported. All constraints in FlatZinc must now be predicate applications. * String parameters are no longer supported. String literals are restricted to appearing as the arguments of annotations. * Set of bool and set of float parameters and literals are no longer supported. * The int_float_lin/4 objective expression is no longer supported. Other Changes: * The FlatZinc interpreter's finite-domain backend now implements global_cardinality_low_up as a built-in. * The FlatZinc interpreter's lazy clause generation solver now supports the int_mod/3 built-in. * Two additional modes of operation have been added to the FlatZinc solution processing tools, solns2dzn, that allow it to extract the first or last solution from a FlatZinc output stream. Also, there is no longer a default mode of operation for solns2dzn, it must now be specified by the user or an error will occur. * The following global constraints have been added to the MiniZinc library: all_equal decreasing G12 MiniZinc Distribution version 1.0.3 --------------------------------------- Bugs fixed in this release: * A fencepost error that was being introduced into flattened array access reifications has been fixed. * Common subexpression elimination has been improved in order to eliminate redundant int and float linear equations during flattening. * A bug that caused flattening to abort if array_*_element built-ins were redefined has been fixed. [Bug #82] * A bug in the implementation of the FlatZinc set_lt and set_gt built-ins has been fixed. Note that the expected outputs for the corresponding tests in the FCTS were also previously incomplete. * The omission of the string_lit tag from the XML-FlatZinc DTD has been corrected. G12 MiniZinc Distribution version 1.0.2 --------------------------------------- There have been no changes to the definitions of the MiniZinc and FlatZinc languages in this release. There have been no changes to the definition of XML-FlatZinc. Changes in this release: * The FlatZinc interpreter's lazy clause generation solver now supports the int_abs/2 built-in. * The residual support for output items in the FlatZinc interpreter has been removed. * The MiniZinc and FlatZinc interpreters now output approximate solutions for optimization problems when asked for more than one solution. Bugs fixed in this release: * Flattening of MiniZinc array expressions, for example product or array_union, where the argument is an array variable now works. * The FlatZinc interpreter now ensures that bounds are checked on scalar variable assignments. [Bug #74] * A bug in the MiniZinc-to-FlatZinc converter where: ann a = foo::bar::baz; constraint p(...)::a; would be flattened to: constraint p(...)::foo; rather than: constraint p(...)::foo:bar::baz; has been fixed. [Bug #77] G12 MiniZinc Distribution version 1.0.1 --------------------------------------- There have been no changes to the definitions of the MiniZinc and FlatZinc languages in this release. There have been no changes to the definition of XML-FlatZinc. Changes in this release: * MiniZinc tools command line changes The MiniZinc interpreter and MiniZinc-to-FlatZinc converter now recognise files with the .dzn extension as MiniZinc data files, i.e. you no longer need to use the --data option to use such files as data files. * FlatZinc output processing tool We have added a new tool, solns2dzn, that can be used to process the output of FlatZinc implementations in various ways. For example, it can extract each individual solution and write it to a separate file. * The FlatZinc interpreter's lazy clause generation solver now supports the int_times/3 built-in. * The global_cardinality_low_up global constraint has been added to the MiniZinc library. * The MiniZinc-to-FlatZinc converter now propagates annotations through assertions during flattening, For example, the following fragment of MiniZinc: predicate foo(int: x, array[int] of var int y); predicate bar(int: x, array[int] of var int y) = assert(x > 3, "value of x must be greater than 3", foo(x, y)); constraint bar(4, ys) :: baz; will be flattened into the following fragment of FlatZinc: constraint foo(4, ys) :: baz; Bugs fixed in this release: * A bug in the implementation of the FlatZinc built-in int_mod/3 in the FlatZinc interpreter's finite-domain backend has been fixed. * The MiniZinc-to-FlatZinc converter now does a better job of extracting output variables from output items. * The solver-specific global constraint definitions for the G12 lazy clause generation solver are now documented. They are in the ``g12_lazyfd'' directory of the MiniZinc library. * A bug that caused a segmentation fault in the type checker when checking large FlatZinc instances has been fixed. * A bug where a cycle of equalities caused mzn2fzn to go into a loop has been fixed. [Bug #65] * mzn2fzn now imposes constraints on arguments induced by predicate parameter types. [Bug #69] * Flattening of set2array coercions is now supported. [Bug #70] * A bug that caused mzn2fzn to abort on min/max expressions over empty arrays has been fixed. [Bug #71] * mzn2fzn now computes bounds on set cardinality variables correctly. G12 MiniZinc Distribution version 1.0 ------------------------------------- * Licence change The source code in the G12 MiniZinc distribution has now been released under a BSD-style licence. See the files README and COPYING in the distribution for details. The MiniZinc examples, global constraint definitions and libraries have been placed in the public domain. * XML-FlatZinc We have defined an XML representation for FlatZinc called XML-FlatZinc. Two new tools, fzn2xml and xml2fzn, can be used to convert between FlatZinc and XML-FlatZinc. * FlatZinc Conformance Test Suite We have added a suite of conformance tests for FlatZinc implementations. It includes tests for built-in constraints, output and the behaviour of the standard search annotations. Changes to the MiniZinc language: * Reification has been fixed. It is now a top-down process that correctly handles partial functions such as integer division. Users can now also supply alternative definitions for reified forms of predicates (this is useful if a backend does not provide reified forms of all predicates). * Users can supply alternative definitions for FlatZinc built-in constraints (e.g., one can force the generated FlatZinc to use just int_lt rather than int_lt and int_gt). * A new variable annotation has been added: is_output is used to indicate variables to be printed as part of the solution if no output item is supplied. This annotation is converted to output_var or output_array as appropriate by mzn2fzn. Changes to the FlatZinc language: * The outdomain_min and outdomain_max value choice methods are now supported in the finite-domain solver backend. * A new search annotation, seq_search, allows a sequential ordering to be imposed on search annotations. * The standard solve annotations now use nested annotations instead of strings to describe variable selection strategies, value choice methods, and exploration strategies. * FlatZinc model instances may now contain bodyless predicate declarations. This is to allow tools to type check FlatZinc that contains non-standard built-in predicates. * Two new annotations have been added that allow functional relationships between variables to be defined: is_defined_var on a variable declaration states that this var is defined as a function of some other variables by a constraint; defines_var(x) on a constraint states that the constraint provides a definition for the variable x. * The FlatZinc specification now specifies how multiple solutions should be output. * Two new variable annotations have been added to indicate which variables should be printed if a solution is found: output_var is used for non-array variables; output_array([IndexSet1, IndexSet2, ...]) is used for array variables. * Output items are no longer supported in FlatZinc. The built-in string operations, show/1 and show_cond/3 have also been removed from the language. Changes to the G12 MiniZinc-to-FlatZinc converter: * The converter now outputs array_xxx_element constraints instead of array_var_xxx_element constraints when the array argument is a constant. * An error is now reported if a variable is defined in a let expression in a negated or reified context. * The ZINC_STD_SEARCH_DIRS environment variable is no longer supported. The new environment variable MZN_STDLIB_DIR or the command line option ``--stdlib-dir'' can be used to set the MiniZinc library directory. * String array lookups are now supported. * Comparison of fixed string expressions is now supported. * Bodyless predicates in MiniZinc are now emitted at the head of the generated FlatZinc. For backwards compatibility this behaviour can be disabled using the ``--no-output-pred-decls'' command line option. Changes to the G12 MiniZinc and FlatZinc interpreters: * There is a new solver backend for the FlatZinc interpreter based upon the G12 lazy clause generation solver. This backend is selected with the ``lazy'' or ``lazyfd'' argument to the interpreter's ``--backend'' option. * The implementation of the int_negate/2 builtin constraint has been fixed. * The interpreters now take a flag (--solver-statistics or --solver-stats) causing any statistical information gathered by the solver to be appended to the output in the form of a Zinc comment. * The interpreters now take a flag (-a or --all-solutions) that causes then to return all solutions. * The interpreters now take a flag (-n or --num-solutions) taking an integer argument giving the maximum number of solutions to display. * The MiniZinc interpreter behaviour has changed for models with no output item: now only the values of variables annotated with is_output are printed. Other Changes: * The following global constraints have been added to the MiniZinc library: at_most1 nvalue precedence table G12 MiniZinc Distribution version 0.9 ------------------------------------- The G12 MiniZinc distribution now includes an interpreter for MiniZinc that does not go via FlatZinc. This helps to avoid problems caused by large intermediate FlatZinc files. The new interpreter supports more expressive output items. Since the executable for the new interpreter is named minizinc, the shell script of the same name that was found in previous versions has been removed from the distribution. Changes to the MiniZinc language: * The 'ann' type has been added. It is augmented by each annotation item. It allows annotations to be nested, even recursively, and thus makes them more powerful. Changes to the FlatZinc language: * The syntax of annotations has changed to allow them to be nested, in line with the corresponding change to MiniZinc. Changes to the G12 MiniZinc-to-FlatZinc converter: * Short-circuit evaluation is no longer applied to Boolean expressions. This is because, for instance, the expression (false /\ p(a[10])) should result in an error if 10 is not in the index set of a, rather than be simplified to just (false). * An problem that resulted in excessive run time for some models has been fixed. * Bounds inference for introduced variables has been improved. Changes to the FlatZinc language: * Two new built-ins have been added: bool_clause and bool_clause_reif. Changes to the G12 FlatZinc interpreter: * The rounding behaviour of the int_div built-in now conforms to the FlatZinc specification. Other Changes: * The lex_lesseq constraint has been added to globals.mzn. G12 MiniZinc Distribution version 0.8.1 --------------------------------------- This is primarily a bug-fix release. Changes to the FlatZinc language: * "indomain_split_reverse" can now be used a value choice method parameter in the standard search predicates. Changes to the G12 MiniZinc-to-FlatZinc converter: * When reifying a predicate that lacks a body, the specification of the MiniZinc-to-FlatZinc translation now requires that the reified version should have the suffix `_reif' added to it along with an extra Boolean argument. If no such predicate with that name exists then it is a translation-time error. The MiniZinc-to-FlatZinc converter now implements this behaviour. * A bug that was causing array types to be replaced by scalars when tightening array bounds has been fixed. Changes to the G12 FlatZinc interpreter: * "indomain_split_reverse" is now implemented as a value choice method for integer search. Other Changes: * A bug in the definition of the regular constraint in the MiniZinc globals library has been fixed. * The MiniZinc examples and benchmark suite have been placed in the public domain. * We have added some new MiniZinc examples and benchmarks G12 MiniZinc Distribution version 0.8 ------------------------------------- Changes to the MiniZinc language: * Output items can now make use of show_cond(A, B, C) expressions. show_cond(A, B, C) is equivalent to show(B) if A is true, and show(C) if not. Expression A does not have to be decidable at compile time. * Some aspects of how arrays work have changed. - Array indices no longer are automatically coerced according to context. - 1d array literals (eg. '[1,2,3]') are now always indexed from 1, not 0. - 2d array literal syntax has been introduced. For example: array[1..3,1..3] of int: a = [| 1, 2, 3 | 4, 5, 6 | 7, 8, 9 |]; 2d array literals are always (1,1)-indexed. The choice to use 1-indexing instead of 0-indexing is because we have found that, in practice, modellers use 1-indexing the vast majority of the time. Changes to the FlatZinc language: * Output items can now make use of 'show_cond' expressions, as in MiniZinc. * Solve minimize/maximize items can now specify linear expressions via the 'int_float_lin' built-in. * To match MiniZinc, array variables and literals are now always indexed from 1, not 0. * Var scalars can now be assigned to when declared, eg. "var int: x = y;". Changes to the G12 MiniZinc-to-FlatZinc converter: * A new command line option, `--no-warn-unknown-annotations', allows warnings about unknown annotations to be suppressed. * A new command line option, `--output-to-file', allows the name of the file in which the FlatZinc is written to be specified. * The ordering of search directories for the converter has been changed so that its standard search directories come after any user specified search directories. This allows the default globals.mzn to be more easily overridden with a custom version. * Numerous bug fixes and other improvements. Changes to the G12 FlatZinc interpreter: * The interpreter now uses a generic interpretation framework that allows it to support multiple solver backends. Currently, the only supported solver backend is the finite domain solver backend. There are a number of other experimental solver backends, e.g. MIP, hybrid FD/MIP, SAT, column generation, that we hope to support in future releases. * The following command line options have been added in order to provide finer grained control over warnings emitted by the interpreter: --no-warn-unknown-annotations --no-warn-false-constraints --no-warn-ignored-annotations --no-warn-empty-initial-domains --no-warn-unsupported-search-params Other Changes: * We have added more examples and benchmarks. G12 MiniZinc Distribution version 0.7.1 --------------------------------------- This is a bug-fix release. * The implementation of the regular and range constraints in the MiniZinc library has been fixed. Changes to the G12 MiniZinc-to-FlatZinc converter: * The missing support for superset expressions has been added. * Unused constants are no longer incorrectly changed into vars during flattening. * Flattening of expressions containing the built-in operation dom no longer cause the converter to abort. Changes to the G12 FlatZinc interpreter: * A bug that with satisfiability checking of models containing LP variables has been fixed. G12 MiniZinc Distribution version 0.7 ------------------------------------- Changes to the FlatZinc language: * FlatZinc now supports additional linear equality and disequality builtins. Changes to the G12 MiniZinc-to-FlatZinc converter: * The converter now supports now includes a `--statistics' option that allows its time and memory usage to be printed. * String concatenation expressions are now flattened properly. * Escaped single quotes can now be used in string literals. * The absolute value function for ints is now implemented. * Some bugs that caused the converter to run out of stack space have been fixed. Changes to the G12 FlatZinc interpreter: * The interpreter now includes a `--statistics' option that allows its time and memory usage to be printed. * The interpreter no longer runs out of stack space when reading large models. Other Changes: * We have added suite of MiniZinc benchmarks to the distribution. The benchmark suite is in the `benchmarks' directory. G12 MiniZinc Distribution version 0.6 ------------------------------------- This was the initial public release of the G12 MiniZinc Distribution. cording to context. - 1d array literals (eg. '[1,2,3]') are now always indexed from 1, not 0. - 2d array literal syntax has been introduced. For example: array[1..3,1..3] of int: a = [| 1, 2, 3 | 4, 5, 6 | 7, 8, 9 |]; 2d array literals are always (1,1)-indexed. The choice to use 1-indexing instead of 0-indexing is because we have found that, in practice, modellers use 1-indexing the vast majority of the time. Changes to the FlatZinc language: * Output items can now make use of 'show_cond' expressions, as in MiniZinc. * Solve minimize/maximize items can now specify linear expressions via the 'int_float_lin' built-in. * To match MiniZinc, array variables and literals are now always indexed from 1, not 0. * Var scalars can now be assigned to when declared, eg. "var int: x = y;". Changes to the G12 MiniZinc-to-FlatZinc converter: * A new command line option, `--no-warn-unknown-annotations', allows warnings about unknown annotations to be suppressed. * A new command line option, `--output-to-file', allows the name of the file in which the FlatZinc is written to be specified. * The ordering of search directories for the converter has been changed so that its standard search directories come after any user specified search directories. This allows the default globals.mzn to be more easily overridden with a custom version. * Numerous bug fixes and other improvements. Changes to the G12 FlatZinc interpreter: * The interpreter now uses a generic interpretation framework that allows it to support multiple solver backends. Currently, the only supported solver backend is the finite domain solver backend. There are a number of other experimental solver backends, e.g. MIP, hybrid FD/MIP, SAT, column generation, that we hope to support in future releases. * The following command line options have been added in order to provide finer grained control over warnings emitted by the interprete