main page modules namespaces classes files
Gecode/J home

BExpr.java

Go to the documentation of this file.

/* -*- indent-tabs-mode: nil -*- */
/*
 *  Main authors:
 *     Mikael Lagerkvist <lagerkvist@gecode.org>
 *
 *  Copyright:
 *     Mikael Lagerkvist, 2006
 *
 *  Last modified:
 *     $Date: 2007-11-30 16:59:40 +0100 (Fri, 30 Nov 2007) $ by $Author: zayenz $
 *     $Revision: 5528 $
 *
 *  This file is part of Gecode, the generic constraint
 *  development environment:
 *     http://www.gecode.org
 *
 *  Permission is hereby granted, free of charge, to any person obtaining
 *  a copy of this software and associated documentation files (the
 *  "Software"), to deal in the Software without restriction, including
 *  without limitation the rights to use, copy, modify, merge, publish,
 *  distribute, sublicense, and/or sell copies of the Software, and to
 *  permit persons to whom the Software is furnished to do so, subject to
 *  the following conditions:
 *
 *  The above copyright notice and this permission notice shall be
 *  included in all copies or substantial portions of the Software.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 */

package org.gecode;

import java.util.ArrayList;
import static org.gecode.BoolOpType.*;

public class BExpr {
    E e;

    public BExpr(BExpr be) {
        e = be.e;
    }

    public BExpr(BoolVar b) {
        e = new BoolE(b);
    }

    public BExpr(boolean v) {
        e = new BooleanE(v);
    }

    public BExpr(Expr e1, IntRelType irt, Expr e2) {
        e = new RelE(e1, irt, e2);
    }

    public BExpr(Expr e1, IntRelType irt, int d) {
        e = new RelE(e1, irt, new Expr(d));
    }

    public BExpr(IntVar v1, IntRelType irt, IntVar v2) {
        e = new RelE(new Expr(v1), irt, new Expr(v2));
    }

    public BExpr(IntVar v, IntRelType irt, int d) {
        e = new RelE(new Expr(v), irt, new Expr(d));
    }

    //  Methods for handling BExpr's

    public BExpr and(BExpr be) {
        if (e instanceof BiE && ((BiE)e).op == Op.AND) {
            ((BiE)e).e.add(be.e);
        } else {
            e = new BiE(e, Op.AND, be.e);
        }
        return this;
    }

    public BExpr or(BExpr be) {
        if (e instanceof BiE && ((BiE)e).op == Op.OR) {
            ((BiE)e).e.add(be.e);
        } else {
            e = new BiE(e, Op.OR, be.e);
        }
        return this;
    }

    public BExpr xor(BExpr be) {
        e = new BiE(e, Op.XOR, be.e);
        return this;
    }

    public BExpr imp(BExpr be) {
        e = new BiE(e, Op.IMP, be.e);
        return this;
    }

    public BExpr consequence_of(BExpr be) {
        e = new BiE(be.e, Op.IMP, e);
        return this;
    }


    public BExpr eqv(BExpr be) {
        e = new BiE(e, Op.EQV, be.e);
        return this;
    }

    //  Methods for handling BoolVars

    public BExpr and(BoolVar b) {
        if (e instanceof BiE && ((BiE)e).op == Op.AND) {
            ((BiE)e).e.add(new BoolE(b));
        } else {
            e = new BiE(e, Op.AND, new BoolE(b));
        }
        return this;
    }

    public BExpr or(BoolVar b) {
        if (e instanceof BiE && ((BiE)e).op == Op.OR) {
            ((BiE)e).e.add(new BoolE(b));
        } else {
            e = new BiE(e, Op.OR, new BoolE(b));
        }
        return this;
    }

    public BExpr xor(BoolVar b) {
        e = new BiE(e, Op.XOR, new BoolE(b));
        return this;
    }

    public BExpr imp(BoolVar b) {
        e = new BiE(e, Op.IMP, new BoolE(b));
        return this;
    }


    public BExpr consequence_of(BoolVar b) {
        e = new BiE(new BoolE(b), Op.IMP, e);
        return this;
    }

    public BExpr eqv(BoolVar b) {
        e = new BiE(e, Op.EQV, new BoolE(b));
        return this;
    }

    //  Methods for handling booleans
 
    public BExpr and(boolean v) {
        if (e instanceof BiE && ((BiE)e).op == Op.AND) {
            ((BiE)e).e.add(new BooleanE(v));
        } else {
            e = new BiE(e, Op.AND, new BooleanE(v));
        }
        return this;
    }

    public BExpr or(boolean v) {
        if (e instanceof BiE && ((BiE)e).op == Op.OR) {
            ((BiE)e).e.add(new BooleanE(v));
        } else {
            e = new BiE(e, Op.OR, new BooleanE(v));
        }
        return this;
    }

    public BExpr xor(boolean v) {
        e = new BiE(e, Op.XOR, new BooleanE(v));
        return this;
    }

    public BExpr imp(boolean v) {
        e = new BiE(e, Op.IMP, new BooleanE(v));
        return this;
    }


    public BExpr consequence_of(boolean v) {
        e = new BiE(new BooleanE(v), Op.IMP, e);
        return this;
    }

    public BExpr eqv(boolean v) {
        e = new BiE(e, Op.EQV, new BooleanE(v));
        return this;
    }

    //  Methods for handling relations

    public BExpr and(Expr e1, IntRelType irt, Expr e2) {
        if (e instanceof BiE && ((BiE)e).op == Op.AND) {
            ((BiE)e).e.add(new RelE(e1, irt, e2));
        } else {
            e = new BiE(e, Op.AND, new RelE(e1, irt, e2));
        }
        return this;
    }

    public BExpr or(Expr e1, IntRelType irt, Expr e2) {
        if (e instanceof BiE && ((BiE)e).op == Op.OR) {
            ((BiE)e).e.add(new RelE(e1, irt, e2));
        } else {
            e = new BiE(e, Op.OR, new RelE(e1, irt, e2));
        }
        return this;
    }

    public BExpr xor(Expr e1, IntRelType irt, Expr e2) {
        e = new BiE(e, Op.XOR, new RelE(e1, irt, e2));
        return this;
    }

    public BExpr imp(Expr e1, IntRelType irt, Expr e2) {
        e = new BiE(e, Op.IMP, new RelE(e1, irt, e2));
        return this;
    }


    public BExpr consequence_of(Expr e1, IntRelType irt, Expr e2) {
        e = new BiE(new RelE(e1, irt, e2), Op.IMP, e);
        return this;
    }

    public BExpr eqv(Expr e1, IntRelType irt, Expr e2) {
        e = new BiE(e, Op.EQV, new RelE(e1, irt, e2));
        return this;
    }

    //  Convenience methods

    // Variable number of arguments. No arguments is a no-op

    public BExpr and(BExpr... bes) {
        for(BExpr be: bes)
            and(be);
        return this;
    }

    public BExpr or(BExpr... bes) {
        for(BExpr be: bes)
            or(be);
        return this;
    }

    public BExpr eqv(BExpr... bes) {
        for (BExpr be: bes)
            eqv(be);
        return this;
    }

    public BExpr and(BoolVar... bvs) {
        for(BoolVar bv: bvs)
            and(bv);
        return this;
    }

    public BExpr or(BoolVar... bvs) {
        for(BoolVar bv: bvs)
            or(bv);
        return this;
    }


    public BExpr eqv(BoolVar... bvs) {
        for (BoolVar bv: bvs)
            eqv(bv);
        return this;
    }

    // Second expression integer

    public BExpr and(Expr e1, IntRelType irt, int d) {
        return and(e1, irt, new Expr(d));
    }

    public BExpr or(Expr e1, IntRelType irt, int d) {
        return or(e1, irt, new Expr(d));
    }

    public BExpr xor(Expr e1, IntRelType irt, int d) {
        return xor(e1, irt, new Expr(d));
    }

    public BExpr imp(Expr e1, IntRelType irt, int d) {
        return imp(e1, irt, new Expr(d));
    }


    public BExpr consequence_of(Expr e1, IntRelType irt, int d) {
        return consequence_of(e1, irt, new Expr(d));
    }

    public BExpr eqv(Expr e1, IntRelType irt, int d) {
        return eqv(e1, irt, new Expr(d));
    }

    // Both expressions IntVar's

    public BExpr and(IntVar v1, IntRelType irt, IntVar v2) {
        return and(new Expr(v1), irt, new Expr(v2));
    }

    public BExpr or(IntVar v1, IntRelType irt, IntVar v2) {
        return or(new Expr(v1), irt, new Expr(v2));
    }

    public BExpr xor(IntVar v1, IntRelType irt, IntVar v2) {
        return xor(new Expr(v1), irt, new Expr(v2));
    }

    public BExpr imp(IntVar v1, IntRelType irt, IntVar v2) {
        return imp(new Expr(v1), irt, new Expr(v2));
    }


    public BExpr consequence_of(IntVar v1, IntRelType irt, IntVar v2) {
        return consequence_of(new Expr(v1), irt, new Expr(v2));
    }

    public BExpr eqv(IntVar v1, IntRelType irt, IntVar v2) {
        return eqv(new Expr(v1), irt, new Expr(v2));
    }


    // First expression IntVar, second expression integer

    public BExpr and(IntVar v1, IntRelType irt, int d) {
        return and(new Expr(v1), irt, new Expr(d));
    }

    public BExpr or(IntVar v1, IntRelType irt, int d) {
        return or(new Expr(v1), irt, new Expr(d));
    }

    public BExpr xor(IntVar v1, IntRelType irt, int d) {
        return xor(new Expr(v1), irt, new Expr(d));
    }

    public BExpr imp(IntVar v1, IntRelType irt, int d) {
        return imp(new Expr(v1), irt, new Expr(d));
    }


    public BExpr consequence_of(IntVar v1, IntRelType irt, int d) {
        return consequence_of(new Expr(v1), irt, new Expr(d));
    }

    public BExpr eqv(IntVar v1, IntRelType irt, int d) {
        return eqv(new Expr(v1), irt, new Expr(d));
    }


    //  Syntax tree classes
    
    abstract class E {
        abstract BoolVar post(JavaSpace home);
        abstract E copy();
    }

    enum Op {AND, OR, XOR, IMP, EQV}

    //int indent;
    //void print(String s) {
    //        for(int i = 0; i < indent; ++i)
    //            System.err.print("  ");
    //        System.err.println(s);
    //}

    class BiE extends E {
        Op op;
        ArrayList<E> e;
        BiE(E e1, Op op, E e2) {
            e = new ArrayList<E>(2);
            this.op = op;
            e.add(e1); e.add(e2);
        }
        BoolVar post(JavaSpace home) {
            BoolVar res = new BoolVar(home);
            switch (op) {
            case AND:
                //print("Posting and"); ++indent;
                if (e.size() == 2) {
                  Gecode.rel(home, e.get(0).post(home), BOT_AND, e.get(1).post(home), res);
                } else {
                    VarArray<BoolVar> va = new VarArray<BoolVar>(e.size());
                    for (E exp: e) va.add(exp.post(home));
                    Gecode.rel(home, BOT_AND, va, res);
                }
                //--indent;
                return res;
            case OR:
                //print("Posting or"); ++indent;
                if (e.size() == 2) {
                    Gecode.rel(home, e.get(0).post(home), BOT_OR, e.get(1).post(home), res);
                } else {
                    VarArray<BoolVar> va = new VarArray<BoolVar>(e.size());
                    for (E exp: e) va.add(exp.post(home));
                    Gecode.rel(home, BOT_OR, va, res);
                }
                //--indent;
                return res;
            case XOR:
                Gecode.rel(home, e.get(0).post(home), BOT_XOR, e.get(1).post(home), res);
                return res;
            case IMP:
                Gecode.rel(home, e.get(0).post(home), BOT_IMP, e.get(1).post(home), res);
                return res;
            case EQV:
                Gecode.rel(home, e.get(0).post(home), BOT_EQV, e.get(1).post(home), res);
                return res;
            }
            return res;
        }
        BiE copy() {
            return new BiE(e.get(0).copy(), op, e.get(1).copy());
        }
    }
    class NE extends E {
        E e;
        NE(E e) {
            this.e = e;
        }
        BoolVar post(JavaSpace home) {
            BoolVar res = new BoolVar(home);
            Gecode.rel(home, res, IntRelType.IRT_NQ, e.post(home));
            return res;
        }
        NE copy() {
            return new NE(e.copy());
        }
    }
    class BoolE extends E {
        BoolVar b;
        BoolE(BoolVar b) {
            this.b = b;
        }
        BoolVar post(JavaSpace home) {
            //print("Posting BoolVar " + b);
            return b;
        }
        BoolE copy() {
            return new BoolE(b);
        }
    }
    class BooleanE extends E {
        boolean v;
        BooleanE(boolean v) {
            this.v = v;
        }
        BoolVar post(JavaSpace home) {
            //print("Posting boolean: " + v);
            return new BoolVar(home, v);
        }
        BooleanE copy() {
            return new BooleanE(v);
        }
    }
    class RelE extends E {
        Expr e1, e2;
        IntRelType irt;
        RelE(Expr e1, IntRelType irt, Expr e2) {
            this.e1 = e1;
            this.irt = irt;
            this.e2 = e2;
        }
        BoolVar post(JavaSpace home) {
            //print("Posting relation " + e1 + " " + irt + " " + e2);
            BoolVar res = new BoolVar(home);
            Gecode.post(home, e1, irt, e2, res);
            return res;
        }
        RelE copy() {
            return new RelE(e1, irt, e2);
        }
    }
}