Release Notes
 Project Team


 Release Notes

Version 2.3.2 of TOY adds to previous version (2.3.1):


- The Linux version did not work for Ubuntu 11.04

Version 2.3.1 of TOY adds to previous version (2.3.0):


- The Linux version did not work. Now, it has been fixed and tested on Ubuntu 6.10, Kubuntu 7.04 (Feisty), and Mandriva Linux 2007 Spring.

- Bridge unification did not exactly follow theory. Now, it infers from two bridges with the same variable at an end, the binding of the variables at the other ends. The following example illustrates this point.

With version 2.3.0:

Toy(R+FD)> X #== RX, Y #== RY, X == Y
      { Y -> X }
      { X #== RX,
        X #== RY }
      Elapsed time: 0 ms.
sol.1, more solutions (y/n/d/a) [y]?
      Elapsed time: 0 ms.

and with the current version:

Toy(R+FD)>  X #== RX, Y #== RY, X == Y
      { Y -> X,
        RY -> RX }
      { X #== RX }
      Elapsed time: 0 ms.
sol.1, more solutions (y/n/d/a) [y]?
      Elapsed time: 0 ms.

- It was possible to enable projection when finite domain and/or real constraint libraries were unloaded.

- Missing answers involved in reification when projection was enabled. In particular, the modified built-ins are: #>, #<,  #>=, #<=, <, > <=, and >=.

Version 2.3.0 of TOY adds to previous version (2.2.2):


- The real and Finite domain libraries can be enabled at the same time, allowing domain cooperation

- A communication constraint bridge for domain cooperation has beed added:

   (#==) :: int -> real -> bool

- Projection for the cooperation among constraint domains is allowed

- New commands:

   /proj Enables projection between constraint domains

   /noproj Disables projection between constraint domains

   /tolerance(E) Sets the tolerance of the bridge constraint to E

- More examples have been added:

   examples/. Uncataloged examples

   examples/cooperation Examples for the cooperation of constraints

- New chapters in the manual:

   Chapter 4. Cooperation of Constraint Domains

   Chapter 5. Interfacing T OY with a CLP Finite Domain Solver

- Dynamically determining the maximum upper and minimum

  lower bounds for finite domains, independent of SICStus version and platform



- The built-ins for reals and real constraints mod, div, gcd, round, trunc, floor and ceiling gave uncorrect results, as:

Toy> X == mod 10 5

{ X -> 0 }

Elapsed time: 0 ms.

sol.1, more solutions (y/n/d/a) [y]?


Elapsed time: 0 ms.

Toy> 0 == mod 10 5


Elapsed time: 0 ms.

- The constraints domain and belongs cleared some constraints in the Herbrand domain

Version 2.3.0 of TOY adds to previous version (2.2.2):


- Optimization functions have beed added to the library CFLPR:
  minimize, maximize :: real -> real, for linear optimization bb
  minimize, bb maximize :: real -> [real] -> real, for linear
  optimization with integral constraints

- When the library CLP(R) is activated, the function log/2 is now
  handled by the real solver

- The file miscfd.toy is added to contain useful finite domain

- More run-time errors due to demandness are handled by means of
  exceptions, instead of failures (e.g., belongs, sum, scalar product,

- The implementation of several finite domain functions has been
  modified, also adding some missing usage mode information

- New commands:
  /prolog(Goal) Executes the Prolog goal Goal
  /status       Informs about the loaded libraries
  /version      Displays the Toy software version

- More examples have been added. Moreover, the directory examples
  becomes more structured:
    examples/.            Uncataloged examples
    examples/apifd/.      Program examples for the API FD
    examples/cflpfp/.     Program examples for CFLP(FD)
    examples/cflpr/.      Program examples for CFLP(R)
    examples/debug/.      Debugging examples
    examples/failure/.    Programming with failure examples
    examples/flp/.        Functional logic programming examples
    examples/fp/.         Functional programming examples
    examples/h_constr/.   Program examples for Herbrand constraints
                          (equality and disequality)
    examples/io_file/.    Program examples for the library IO File
    examples/io_graphic/. Program examples for the library IO Graphic
    examples/lp/.         Logic programming examples
    examples/tads/.       Program examples for abstract data types

- New sections in the manual:
  * Release Notes History
  * Known Bugs


- substract (in misc.toy). See Section CHANGES below

- wakeoptions. See Section CHANGES below

- options. See Section CHANGES below

- newOptions. See Section CHANGES below


- fd_statistics and fd_statistics' have interchanged their role in
  order to adhere to the convention that the prime indicates that
  options can be used. The type of fd_statistics' has changed to
  statistics -> int

- substract (in misc.toy) becomes subtract

- wakeoptions becomes wakeOptions

- options becomes allDiffOptions

- newOptions becomes serialOptions


- The command type did not work on expressions. Fixed

- User-defined commands as described in section 1.5.5 of User Manual
  for version 2.2.2 did not work. Fixed

- sum and scalar_product were not correctly implemented, giving rise
  to type error exceptions. Fixed

- fd_statistics delivered duplicate solutions. Fixed

- /nocflpfd did not completely unload the library CFLPFD. Fixed

- The libraries IO File and IO Graphic could not be unloaded. Fixed

- When first loading the libraries IO File and IO Graphic, and
  depending on the previous state of the system, their functions were
  not available at command prompt until a program were compiled. Fixed

- The data type ioMode was documented as:
  data ioMode = read | write | append
  but the actual declaration is:
  data ioMode = readMode | writeMode | appendMode

Version 2.2.2 of TOY adds to previous version (2.2.1):


- Dyanmic cut optimization. It can be activated using the
  /cut command before compiling a program.

- The debugger now allows programs/goals with constraints over
  real numbers. See the example  examples/debug/ladder.toy

- New finite domain functions and constraints:
  * Membership constraints:
    subset :: int -> int -> bool         % Domain subset
    setcomplement :: int -> int -> bool  % Domain complement
    inset :: int -> int -> bool          % Domain member
    intersect :: int -> int -> int       % Domain intersection
    belongs :: int -> [int] -> bool      % Domain definition
  * Propositional constraints:
    (#\/) :: bool -> bool -> bool   % Disjunction
    (#<=>) :: bool -> bool -> bool  % Equivalence
    (#=>) :: bool -> bool -> bool   % Implication
  * Arithmetic constraint operators:
    (#&) :: int -> int -> int       % Integer remainder

- More constraints are now reifiable (e.g., sum, scalar_product, ...)

- Some constraints become more declarative as they do not demand
  arguments with known finite types. This is the case, for instance,
  of labeling. Now, it produces all the admissible options for labeling.
  Consider the following goal:
Toy(FD)> domain [X] 0 1, labeling L [X]
      {  X -> 0,
         L -> []   }
      Elapsed time: 110 ms.
more solutions (y/n/d) [y]?
      {  X -> 1,
         L -> []   }
      Elapsed time: 0 ms.
more solutions (y/n/d) [y]?
      {  X -> 0,
         L ->  [ bisect ]   }
      Elapsed time: 0 ms.
more solutions (y/n/d) [y]?
      {  X -> 1,
         L ->  [ bisect ]   }
      Elapsed time: 0 ms.
more solutions (y/n/d) [y]?
      {  X -> 0,
         L ->  [ bisect, ff ]   }
      Elapsed time: 0 ms.


Up to all the correct answers.

- More examples added to the distribution

- User Manual updated (draft published)

- New formatted output

- Nonlinear real functions revisited. Arguments of nonlinear real functions do not need to be instantiated:
  ln, exp, cot, asin, acos, atan, acot, sinh, cosh, tanh, coth, asinh, acosh, atanh, acoth


- all_distinct is deprecated since its behaviour is
  the same as all_different
- all_distinct' is deprecated since its behaviour is
  the same as all_different'


- [fdset] becomes simply fdset. See type declaration in User Manual


- The goal:

labeling X [Y]

ran into an infinite loop. Fixed

- The goal:

domain [(id X)] 0 1

with the program:

id :: A -> A
id A = A

shows the following error:

SYSTEM ERROR: type_error(domain([$$susp($id,[_116],_121,_122)],0,1),1,integer,$$susp($id,[_116],_121,_122)) :

The same situation held for labeling.

- Reification. Missing answer:
Toy(FD)> domain [X] 0 1, B #<=> (X#=0)
      {  X -> 0,
         B -> true   }
      Elapsed time: 0 ms.
more solutions (y/n/d) [y]?
      Elapsed time: 0 ms.

With the current version:
Toy(FD)> domain [X] 0 1, B #<=> (X#=0)
      {  X -> 0,
         B -> true   }
      Elapsed time: 0 ms.
more solutions (y/n/d) [y]?
      {  X -> 1,
         B -> false   }
      Elapsed time: 0 ms.
more solutions (y/n/d) [y]?
      Elapsed time: 0 ms.

- Equality and Inequality constraints missed during processing of scheduling constraints. Fixed

- Duplicate solutions with scheduling constraints. Fixed

- Non ground, non FD variables were output as {inf..sup}. Fixed


Version 2.2.1 of TOY adds to previous version (2.2.0):


- The set of examples has been extended with a new folder examples/debug
  containing examples of buggy programs that can be used for testing the
  declarative debugger.

- The computation tree generated by the declarative debugger is now stored
  in the directory JavaTree.  This avoids the creation of auxiliary files in the
  directory containing the program to be debugged.

Fixed Bugs:

- A program as

  data d = c int int
  f (c 3) = 4

  yielded an error during compilation (error code 24). Fixed.


Version 2.2.0 of TOY adds to previous version (2.2.1):


- The system variable TOYDIR is no longer necessary

- The answers for a goal are now displayed as two sets, the first one representing
  a substitution and the second one a conjunction of constraints. For instance,
  a goal like X==5, X/=Y displays the answer:
  { X -> 5}
  { Y /= 5}
  meaning that if X is substituted by 5 and Y is any value different from 5 the goal holds.
  However, not all Finite Domain Constraints are shown up to now
- Totality constraints allowed. They can be activated by typing /tot and disabled with /notot

- The declarative debugger handles programs including equality and disequality constraints

- Four new (non-declarative) primitives, collect, collectN, once, and fails have been included

  "collect e"  collects in a list all the values obtained when evaluating
  the expression e. For instance, a goal like collect (3 // 4 // 5) == R 
  has one answer { R -> [3,4,5] }. The elements of the list correspond
  to all the values V computed for the goal e==V. If e==V
  has no answer then "collect e" returns []

  "collectN n e" collects in a list the n first values obtained when
  evaluating e. For instance a goal like collectN 2 (3 // 4 // 5) == R
  has one answer { R -> [3,4] }. If the e cannot be evaluated to n values
  the primitive fails.

  "once e" is equivalent to "head (collectN 1 e)"

  "fails e" returns true if the goal e==V fails, or false if the goal
  e==V has some answer. For instance, the goal  fails (head [])==R
  has the single answer {R -> true}. In contrast,  fails (head [X|Xs]) == R
  has the single answer {R -> false}

- The system can display statistics about the number of head normal forms,
  the system memory or the number of the choice points required by the
  underlying Prolog program during a certain computation.  See /statistics
  in the help command (displayed by typing /help) to check all the

Fixed Bugs:

- The finite domain library was not working properly if no program
  was compiled after typing /cflpfd. Fixed

- Fixed an error which involved the combination of disequality and equality
  with real numbers. For example after loading the real numbers library
  (by typing /cflpr) a goal like X/=1, X==2 was throwing an exception

- Fixed an error that occurred when combining disequality and equality
  constraints of composed terms. For example X/=(1,1), X==(2,2)
  was throwing an exception


Version 2.1.0 of TOY adds to previous version (2.0):

- Finite Domain Constraints

- Enhanced Declarative Debugging

- Multiplatform Support (including Windows, UNIX, and Linux)

- Executables for Windows 98 and later, and SunOS54

[Home  ] [Download] [Release Notes] [Project Team] [License] [News]