xoolive / facile Goto Github PK

import facile
x = [facile.variable(0,1) for i in range (10)]
for a in range(10):
   for b in range(a, 10):
       c1 = 2*a != b
       c2 = x[a]!=x[b]
       facile.constraint( c1 | c2 )

A better error message than AttributeError: 'bool' object has no attribute '__getval' should be produced.

Besides, if you type facile.constraint( c2 | c1 ), you get the following error message:
TypeError: Argument 'c' has incorrect type (expected facile.Cstr, got bool)

A SyntaxError is raised when calling the following snippet:

import facile
a = facile.variable(0, 1)
facile.minimize([a], a)

However, facile.minimize([a], 1*a) is valid.

It may be necessary to have two-dimension arrays indexed by variables on both dimensions.
There is always the solution of index linearisation, but if the two-dimension option is feasible, it should be implemented.

The following methods have been implemented as we wanted to prevent users to call native min() or max() function on an array of expressions.

    # For Python 2.x
    def __nonzero__(self):
        print (array.__doc__)
        raise SyntaxError("This operation is not allowed. Check facile.array()")

    # For Python 3.x
    def __bool__(self):
        print (array.__doc__)
        raise SyntaxError("This operation is not allowed. Check facile.array()")

However, this exception makes no sense when raised upon writing the following code:

[a, b] = [facile.variable(0, 1) for i in range(2)]
# The user probably wanted to write facile.constraint(a == b | b != 0)
if a != b:
    facile.constraint(b != 0)

There seems to be occurrences of Fcl_stak.fail exceptions (index out of bound) that are not caught by Python.
No test case yet, to be reproduced.

• build for Windows when opam 2.2 is released https://ocaml.org/docs/ocaml-on-windows
• build for manylinux1 (remove the run-centos7.yml and include it here)
• release upon tag

Consider documentation for matrices

facile.variable(3, 2)

should raise an Exception.

>>> a = [facile.variable(0,3) for i in range(2)]
>>> b = [facile.variable(0,3) for i in range(2)]
>>> a == b

Raises a SyntaxError and offer to refer to facile.array

>>> a = [facile.variable(0,3) for i in range(2)]
>>> b = facile.array([facile.variable(0,3) for i in range(2)])
>>> a == b
False

A proper interface to the Goal module shall be considered for a Python binding.

Keywords: heuristics, labelling, callback, Fail, Success
see golf.ml, tiles.ml, scheduling.ml, jobshop.ml

For example:

a = [[facile.variable(0,1) for i in range(2)] for j in range(2)]
facile.solve(a)

1. solve should raise a proper exception.
2. If the elements of p are also iterable, we could consider being flexible.

Why on Earth would users write:

c = facile.Cstr(0)

Well, some did, deal with it!

There must be something around here to specify what mlvalue should be like.

Lazy students often write stupid constraints equivalent to the following one:

import facile
a = facile.variable(1, 2)
facile.constraint(a != a)
Fatal error: exception Fcl_stak.Fail("zero")
zsh: exit 2     python

which corresponds more or less to the following in Caml:

# open Facile;;
# open Easy;;      
# let a = Fd.interval 1 2;;
val a : Facile.Easy.Fd.t = <abstr>
# Cstr.post (fd2e a <>~ fd2e a);;
Exception: Fcl_stak.Fail "zero".

You cannot blame stupid students. This exception should be caught in Python and print a meaningful message.

facile.solve and facile.minimize only accept one-dimension arrays (Python iterable, numpy, or facile version) of variables. When we manipulate two-(or more) dimension arrays, we may appreciate to have the array automatically unravelled.
The following question will however arise: should the return type be of the same structure as the entry array (of arrays?) — at the risk of having to follow up with a tricky structure — or should we return an unravelled version?

The interface for solve() and minimize() has been developed ad hoc and may need some freshening/refactoring.

• I don't like the fact that the interfaces that trigger the resolution process are not consistent: one returns a boolean (False if no solution exists), a counter of backtracks is attached if you enable a proper option; the other returns an array of solutions, [] if no solution exists.
• Some users get confused by minimize() and solve() and think they have to call them both in this order so as to get a solution. Is it a documentation issue or an interface issue?
• Some heuristics are hard-coded and passed as arguments for the needs of attached examples and/or exercises for students. This access to resolution heuristics should be thought of more carefully. Try the new interface on the golf tournament problem golf.ml.
• Also, a decent interface that would transcript prolog.ml would be a plus!

Also consider whether there is a way to implement =>, <=> and xor as infix operator.
For now, it would be great to have:

[a, b] = [facile.variable(0, 1) for i in range(2)]
c = a != b
facile.constraint(not c)

Refer to the official documentation.

facile.constraint(c1 <= c2) does not automatically reify c1 and c2.
Current workaround is facile.constraint(c1 + 0 <= c2 + 0)