clojure.core.logic.fd — org.clojure/core.logic 1.0.1

!= clj

(!= u v)

A finite domain constraint. u and v must not be equal. u and v must eventually be given domains if vars.

!=c clj

(!=c u v)

* clj

(* x y product)

A finite domain constraint for multiplication and thus division. x, y & product must be eventually be given domains if vars.

*c clj

(*c u v w)

+ clj

(+ x y sum)

A finite domain constraint for addition and subtraction. x, y & sum must eventually be given domains if vars.

+c clj

(+c u v w)

- clj

(- u v w)

->fd clj

(->fd vars exprs)

-distinct clj

(-distinct x y* n*)

-distinctc clj

(-distinctc x y* n*)

The real individual distinct constraint. x is a var that now is bound to a single value. y* were the non-singleton bound vars that existed at the construction of the constraint. n* is the set of singleton domain values that existed at the construction of the constraint. We use categorize to determine the current non-singleton bound vars and singleton vlaues. if x is in n* or the new singletons we have failed. If not we simply remove the value of x from the remaining non-singleton domains bound to vars.

-domc clj

(-domc x)

< clj

(< u v)

A finite domain constraint. u must be less than v. u and v must eventually be given domains if vars.

<= clj

(<= u v)

A finite domain constraint. u must be less than or equal to v. u and v must eventually be given domains if vars.

<=c clj

(<=c u v)

== clj

(== u v)

A finite domain constraint. u and v must be equal. u and v must eventually be given domains if vars.

==c clj

(==c u v)

> clj

(> u v)

A finite domain constraint. u must be greater than v. u and v must eventually be given domains if vars.

>= clj

(>= u v)

A finite domain constraint. u must be greater than or equal to v. u and v must eventually be given domains if vars.

binops clj

binops->fd clj

bounded-listo clj

(bounded-listo l n)

Ensure that the list l never grows beyond bound n. n must have been assigned a domain.

bounds clj

(bounds i)

difference* clj

(difference* is js)

disjoint?* clj

(disjoint?* is js)

distinct clj

(distinct v*)

A finite domain constraint that will guarantee that all vars that occur in v* will be unified with unique values. v* need not be ground. Any vars in v* should eventually be given a domain.

distinctc clj

(distinctc v*)

The real distinct constraint. v* can be seq of logic vars and values or it can be a logic var itself. This constraint does not run until v* has become ground. When it has become ground we group v* into a set of logic vars and a sorted set of known singleton values. We then construct the individual constraint for each var.

dom clj

(dom x dom)

Assign a var x a domain.

domain clj

(domain & args)

Construct a domain for assignment to a var. Arguments should be integers given in sorted order. domains may be more efficient than intervals when only a few values are possible.

domc clj

(domc x)

eq clj macro

(eq & forms)

eq* clj

(eq* form vars)

(eq* form vars out)

eq-form clj

(eq-form form)

expand clj

(expand form)

ext-dom-fd clj

(ext-dom-fd a x dom domp)

extend-to-fd clj macro

(extend-to-fd t)

finite-domain? clj

(finite-domain? x)

get-dom clj

(get-dom a x)

IInterval clj protocol

-lb clj

(-lb this)

-ub clj

(-ub this)

IIntervals clj protocol

-intervals clj

(-intervals this)

in clj macro

(in & xs-and-dom)

Assign vars to domain. The domain must come last.

intersection* clj

(intersection* is js)

interval clj

(interval ub)

(interval lb ub)

Construct an interval for an assignment to a var. intervals may be more efficient that the domain type when the range of possiblities is large.

interval-< clj

(interval-< i j)

interval-<= clj

(interval-<= i j)

interval-> clj

(interval-> i j)

interval->= clj

(interval->= i j)

interval? clj

(interval? x)

ISet clj protocol

-difference clj

(-difference this that)

-disjoint? clj

(-disjoint? this that)

-intersection clj

(-intersection this that)

-member? clj

(-member? this n)

ISortedDomain clj protocol

-drop-before clj

(-drop-before this n)

-drop-one clj

(-drop-one this)

-keep-before clj

(-keep-before this n)

list-sorted? clj

(list-sorted? pred ls)

map-sum clj

(map-sum f)

multi-interval clj

(multi-interval)

(multi-interval i0)

(multi-interval i0 i1)

(multi-interval i0 i1 & ir)

normalize-intervals clj

(normalize-intervals is)

process-dom clj

(process-dom x dom domp)

If x is a var we update its domain. If it's an integer we check that it's a member of the given domain. dom is then new domain, it should have already been calculated from domp which was the previous domain.

quot clj

(quot u v w)

resolve-storable-dom clj

(resolve-storable-dom a x dom domp)

singleton-dom? clj

(singleton-dom? x)

sorted-set->domain clj

(sorted-set->domain s)

to-vals clj

(to-vals dom)

unify-with-domain* clj