import kodkod.util.ints.SparseSequence; //导入依赖的package包/类
/**
 * Returns a new matrix such that an entry in the returned matrix represents
 * a conjunction of the corresponding entries in this and other matrix. The
 * effect of this method is the same as calling
 * this.compose(ExprOperator.Binary.AND, other).
 *
 * @return { m: BooleanMatrix | m.dimensions = this.dimensions && m.factory
 *         = this.factory && all i: [0..m.dimensions.capacity) |
 *         m.elements[i] = this.elements[i] AND other.elements[i] }
 * @throws NullPointerException other = null
 * @throws IllegalArgumentException
 *             !other.dimensions.equals(this.dimensions) || this.factory !=
 *             other.factory
 */
public final BooleanMatrix and(BooleanMatrix other) {
	checkFactory(this.factory, other.factory);
	checkDimensions(this.dims, other.dims);

	final BooleanMatrix ret = new BooleanMatrix(dims, factory, cells, other.cells);
	ret.mergeDefConds(this, other);

	final SparseSequence<BooleanValue> s1 = other.cells;
	if (cells.isEmpty() || s1.isEmpty())
		return ret;
	for (IndexedEntry<BooleanValue> e0 : cells) {
		BooleanValue v1 = s1.get(e0.index());
		if (v1 != null)
			ret.fastSet(e0.index(), factory.and(e0.value(), v1));
	}
	return ret;
}
 

import kodkod.util.ints.SparseSequence; //导入依赖的package包/类
/**
 * Returns a new matrix such that an entry in the returned matrix represents
 * a combination of the corresponding entries in this and other matrix. The
 * effect of this method is the same as calling
 * this.compose(ExprOperator.Binary.OR, other).
 *
 * @return { m: BooleanMatrix | m.dimensions = this.dimensions && m.factory
 *         = this.factory && all i: [0..m.dimensions.capacity) |
 *         m.elements[i] = this.elements[i] OR other.elements[i] }
 * @throws NullPointerException other = null
 * @throws IllegalArgumentException
 *             !other.dimensions.equals(this.dimensions) || this.factory !=
 *             other.factory
 */
public final BooleanMatrix or(BooleanMatrix other) {
	checkFactory(this.factory, other.factory);
	checkDimensions(this.dims, other.dims);
	if (this.cells.isEmpty())
		return other.clone();
	else if (other.cells.isEmpty())
		return this.clone();

	final BooleanMatrix ret = new BooleanMatrix(dims, factory, cells, other.cells);
	ret.mergeDefConds(this, other);

	final SparseSequence<BooleanValue> retSeq = ret.cells;
	for (IndexedEntry<BooleanValue> e0 : cells) {
		BooleanValue v1 = other.cells.get(e0.index());
		if (v1 == null)
			retSeq.put(e0.index(), e0.value());
		else
			retSeq.put(e0.index(), factory.or(e0.value(), v1));
	}
	for (IndexedEntry<BooleanValue> e1 : other.cells) {
		if (!cells.containsIndex(e1.index()))
			retSeq.put(e1.index(), e1.value());
	}
	return ret;
}
 

import kodkod.util.ints.SparseSequence; //导入依赖的package包/类
/**
 * Returns a new matrix such that an entry in the returned matrix represents a 
 * combination of the corresponding entries in this and other matrix.  The effect 
 * of this method is the same as calling this.compose(ExprOperator.Binary.OR, other).
 * 
 * @return { m: BooleanMatrix | m.dimensions = this.dimensions && m.factory = this.factory &&
 *                              all i: [0..m.dimensions.capacity) | 
 *                               m.elements[i] = this.elements[i] OR other.elements[i] }
 * @throws NullPointerException  other = null 
 * @throws IllegalArgumentException  !other.dimensions.equals(this.dimensions) || this.factory != other.factory
 */
public final BooleanMatrix or(BooleanMatrix  other) {
    checkFactory(this.factory, other.factory); checkDimensions(this.dims, other.dims);
    
    final BooleanMatrix ret = new BooleanMatrix(dims, factory, cells, other.cells);
    ret.mergeDefConds(this, other);
    
    final SparseSequence<BooleanValue> retSeq = ret.cells;
    for(IndexedEntry<BooleanValue> e0 : cells) {
        BooleanValue v1 = other.cells.get(e0.index());
        if (v1==null)
            retSeq.put(e0.index(), e0.value());
        else
            retSeq.put(e0.index(), factory.or(e0.value(), v1));
    }
    for(IndexedEntry<BooleanValue> e1 : other.cells) {
        if (!cells.containsIndex(e1.index()))
            retSeq.put(e1.index(), e1.value());
    }
    return ret;
}
 

import kodkod.util.ints.SparseSequence; //导入依赖的package包/类
/**
 * Returns a boolean matrix m such that m = this if the given condition evaluates
 * to TRUE and m = other otherwise.
 * 
 * @return { m: BooleanMatrix | m.dimensions = this.dimensions &&
 *                              all i: [0..m.dimensions.capacity) | 
 *                                 m.elements[i] = condition => this.elements[i], other.elements[i] }
 * @throws NullPointerException  other = null || condition = null
 * @throws IllegalArgumentException  !other.dimensions.equals(this.dimensions) || this.factory != other.factory
 */
public final BooleanMatrix choice(BooleanValue condition, BooleanMatrix other) {
    checkFactory(this.factory, other.factory); checkDimensions(this.dims, other.dims);
    if (condition==TRUE) return this.clone();
    else if (condition==FALSE) return other.clone();

    final BooleanMatrix ret =  new BooleanMatrix(dims, factory);
    final SparseSequence<BooleanValue> otherCells = other.cells;
    for(IndexedEntry<BooleanValue> e0 : cells) {
        BooleanValue v1 = otherCells.get(e0.index());
        if (v1==null)
            ret.fastSet(e0.index(), factory.and(condition, e0.value()));
        else
            ret.fastSet(e0.index(), factory.ite(condition, e0.value(), v1));
    }
    for(IndexedEntry<BooleanValue> e1 : other.cells) {
        if (!cells.containsIndex(e1.index()))
            ret.fastSet(e1.index(), factory.and(condition.negation(), e1.value()));
    }
    
    BooleanValue of = factory.ite(condition, defCond().getOverflow(), other.defCond().getOverflow());
    BooleanValue accumOF = factory.ite(condition, defCond().getAccumOverflow(), other.defCond().getAccumOverflow());
    ret.defCond().setOverflows(of, accumOF);
    return ret;
}
 

import kodkod.util.ints.SparseSequence; //导入依赖的package包/类
/**
 * Returns a new matrix such that an entry in the returned matrix represents a 
 * combination of the corresponding entries in this and other matrix.  The effect 
 * of this method is the same as calling this.compose(ExprOperator.Binary.OR, other).
 * 
 * @return { m: BooleanMatrix | m.dimensions = this.dimensions && m.factory = this.factory &&
 *                              all i: [0..m.dimensions.capacity) | 
 *                               m.elements[i] = this.elements[i] OR other.elements[i] }
 * @throws NullPointerException  other = null 
 * @throws IllegalArgumentException  !other.dimensions.equals(this.dimensions) || this.factory != other.factory
 */
public final BooleanMatrix or(BooleanMatrix  other) {
	checkFactory(this.factory, other.factory); 
	checkDimensions(this.dims, other.dims);
	if (this.cells.isEmpty())
		return other.clone();
	else if (other.cells.isEmpty())
		return this.clone();
	final BooleanMatrix ret = new BooleanMatrix(dims, factory, cells, other.cells);
	final SparseSequence<BooleanValue> retSeq = ret.cells;
	for(IndexedEntry<BooleanValue> e0 : cells) {
		BooleanValue v1 = other.cells.get(e0.index());
		if (v1==null)
			retSeq.put(e0.index(), e0.value());
		else
			retSeq.put(e0.index(), factory.or(e0.value(), v1));
	}
	for(IndexedEntry<BooleanValue> e1 : other.cells) {
		if (!cells.containsIndex(e1.index()))
			retSeq.put(e1.index(), e1.value());
	}

	return ret;
}
 

import kodkod.util.ints.SparseSequence; //导入依赖的package包/类
/**
 * Returns a boolean matrix m such that m = this if the given condition evaluates
 * to TRUE and m = other otherwise.
 * 
 * @return { m: BooleanMatrix | m.dimensions = this.dimensions &&
    *                              all i: [0..m.dimensions.capacity) | 
    *                                 m.elements[i] = condition => this.elements[i], other.elements[i] }
    * @throws NullPointerException  other = null || condition = null
    * @throws IllegalArgumentException  !other.dimensions.equals(this.dimensions) || this.factory != other.factory
 */
public final BooleanMatrix choice(BooleanValue condition, BooleanMatrix other) {
	checkFactory(this.factory, other.factory); 
	checkDimensions(this.dims, other.dims);
	if (condition==TRUE) return this.clone();
	else if (condition==FALSE) return other.clone();

	final BooleanMatrix ret =  new BooleanMatrix(dims, factory);
	final SparseSequence<BooleanValue> otherCells = other.cells;
	for(IndexedEntry<BooleanValue> e0 : cells) {
		BooleanValue v1 = otherCells.get(e0.index());
		if (v1==null)
			ret.fastSet(e0.index(), factory.and(condition, e0.value()));
		else
			ret.fastSet(e0.index(), factory.ite(condition, e0.value(), v1));
	}
	for(IndexedEntry<BooleanValue> e1 : other.cells) {
		if (!cells.containsIndex(e1.index()))
			ret.fastSet(e1.index(), factory.and(condition.negation(), e1.value()));
	}
	return ret;
}
 

import kodkod.util.ints.SparseSequence; //导入依赖的package包/类
/**
 * Constructs a Bounds object with the given factory and mappings.
 */
private Bounds(TupleFactory factory, Map<Relation,TupleSet> lower, Map<Relation,TupleSet> upper,
		SparseSequence<TupleSet> intbounds) {
	this.factory = factory;
	this.lowers = lower;
	this.uppers = upper;
	this.intbounds = intbounds;
	this.relations = relations(lowers, uppers);
	this.atom2rel = new HashMap<Object,Relation>();
	for (Entry<Relation,TupleSet> e : uppers.entrySet()) {
		addAtomRel(e.getKey(), e.getValue());
	}
}
 

import kodkod.util.ints.SparseSequence; //导入依赖的package包/类
private Instance(Universe u, Map<Relation,TupleSet> tuples, SparseSequence<TupleSet> ints) {
	if (u == null)
		throw new NullPointerException("universe=null");
	this.universe = u;
	this.tuples = tuples;
	this.ints = ints;
}
 

import kodkod.util.ints.SparseSequence; //导入依赖的package包/类
/**
 * Constructs a new matrix with the given dimensions and factory, backed by
 * a sparse sequence which can most efficiently hold the elements storable
 * in the sparse sequences s0 and s1.
 * 
 * @ensures this.dimensions' = dimensions && this.factory' = factory &&
 *          this.elements' = [0..dimensions.capacity)->one FALSE
 */
private BooleanMatrix(Dimensions d, BooleanFactory f, SparseSequence<BooleanValue> s0,
		SparseSequence<BooleanValue> s1) {
	this.dims = d;
	this.factory = f;
	final Class< ? > c0 = s0.getClass(), c1 = s1.getClass();
	if (c0 != c1 || c0 == RangeSequence.class)
		this.cells = new RangeSequence<BooleanValue>();
	else if (c0 == HomogenousSequence.class)
		this.cells = new HomogenousSequence<BooleanValue>(TRUE, Ints.bestSet(d.capacity()));
	else
		this.cells = new TreeSequence<BooleanValue>();
}
 

import kodkod.util.ints.SparseSequence; //导入依赖的package包/类
/**
 * Returns a boolean matrix m such that m = this if the given condition
 * evaluates to TRUE and m = other otherwise.
 *
 * @return { m: BooleanMatrix | m.dimensions = this.dimensions && all i:
 *         [0..m.dimensions.capacity) | m.elements[i] = condition =>
 *         this.elements[i], other.elements[i] }
 * @throws NullPointerException other = null || condition = null
 * @throws IllegalArgumentException
 *             !other.dimensions.equals(this.dimensions) || this.factory !=
 *             other.factory
 */
public final BooleanMatrix choice(BooleanValue condition, BooleanMatrix other) {
	checkFactory(this.factory, other.factory);
	checkDimensions(this.dims, other.dims);
	if (condition == TRUE)
		return this.clone();
	else if (condition == FALSE)
		return other.clone();

	final BooleanMatrix ret = new BooleanMatrix(dims, factory);
	final SparseSequence<BooleanValue> otherCells = other.cells;
	for (IndexedEntry<BooleanValue> e0 : cells) {
		BooleanValue v1 = otherCells.get(e0.index());
		if (v1 == null)
			ret.fastSet(e0.index(), factory.and(condition, e0.value()));
		else
			ret.fastSet(e0.index(), factory.ite(condition, e0.value(), v1));
	}
	for (IndexedEntry<BooleanValue> e1 : other.cells) {
		if (!cells.containsIndex(e1.index()))
			ret.fastSet(e1.index(), factory.and(condition.negation(), e1.value()));
	}

	BooleanValue of = factory.ite(condition, defCond().getOverflow(), other.defCond().getOverflow());
	BooleanValue accumOF = factory.ite(condition, defCond().getAccumOverflow(), other.defCond().getAccumOverflow());
	ret.defCond().setOverflows(of, accumOF);
	return ret;
}
 

import kodkod.util.ints.SparseSequence; //导入依赖的package包/类
/**
 * Constructs a new LeafInterpreter using the given values.
 * 
 * @requires lowers.keySet() = uppers.keySet()
 * @ensures this.universe' = universe && this.relations' = lowers.keySet()
 *          && this.ints' = ints.indices && this.factory' = factory &&
 *          this.ubounds' = uppers && this.lbounds' = lowers &&
 *          this.ibounds' = ints
 */
private LeafInterpreter(Universe universe, Map<Relation,TupleSet> lowers, Map<Relation,TupleSet> uppers,
		SparseSequence<TupleSet> ints, BooleanFactory factory, Map<Relation,IntRange> vars) {
	this.universe = universe;
	this.lowers = lowers;
	this.uppers = uppers;
	this.ints = ints;
	this.factory = factory;
	this.vars = vars;
}
 

import kodkod.util.ints.SparseSequence; //导入依赖的package包/类
/**
 * Constructs a Bounds object with the given factory and mappings.
 */
private Bounds(TupleFactory factory, Map<Relation, TupleSet> lower, Map<Relation, TupleSet> upper, SparseSequence<TupleSet> intbounds) {
	this.factory = factory;
	this.lowers = lower;
	this.uppers = upper;
	this.intbounds = intbounds;
}
 

import kodkod.util.ints.SparseSequence; //导入依赖的package包/类
/**
 * Constructs a new matrix with the given dimensions and factory, 
 * backed by a sparse sequence which can most efficiently hold
 * the elements storable in the sparse sequences s0 and s1.
 * @ensures this.dimensions' = dimensions && this.factory' = factory && 
 *          this.elements' = [0..dimensions.capacity)->one FALSE 
 */
private BooleanMatrix(Dimensions d, BooleanFactory f, SparseSequence<BooleanValue> s0, SparseSequence<BooleanValue> s1) {
    this.dims = d;
    this.factory = f;
    final Class<?> c0 = s0.getClass(), c1 = s1.getClass();
    if (c0!=c1 || c0==RangeSequence.class) 
        this.cells = new  RangeSequence<BooleanValue>();
    else if (c0==HomogenousSequence.class) 
        this.cells = new HomogenousSequence<BooleanValue>(TRUE, Ints.bestSet(d.capacity())); 
    else 
        this.cells = new TreeSequence<BooleanValue>();  
}
 

import kodkod.util.ints.SparseSequence; //导入依赖的package包/类
/**
 * Returns a new matrix such that an entry in the returned matrix represents a 
 * conjunction of the corresponding entries in this and other matrix.  The effect 
 * of this method is the same as calling this.compose(ExprOperator.Binary.AND, other).
 * 
 * @return { m: BooleanMatrix | m.dimensions = this.dimensions && m.factory = this.factory &&
 *                              all i: [0..m.dimensions.capacity) | 
 *                               m.elements[i] = this.elements[i] AND other.elements[i] }
 * @throws NullPointerException  other = null
 * @throws IllegalArgumentException  !other.dimensions.equals(this.dimensions) || this.factory != other.factory
 */
public final BooleanMatrix and(BooleanMatrix  other) {
    checkFactory(this.factory, other.factory); checkDimensions(this.dims, other.dims);
    
    final BooleanMatrix ret = new BooleanMatrix(dims, factory, cells, other.cells);
    ret.mergeDefConds(this, other);
    
    final  SparseSequence<BooleanValue> s1 = other.cells;
    for(IndexedEntry<BooleanValue> e0 : cells) {
        BooleanValue v1 = s1.get(e0.index());
        if (v1!=null)
            ret.fastSet(e0.index(), factory.and(e0.value(), v1));
    }
    return ret;
}
 

import kodkod.util.ints.SparseSequence; //导入依赖的package包/类
/**
 * Constructs a new LeafInterpreter using the given values.
 * @requires lowers.keySet() = uppers.keySet()
 * @ensures this.universe' = universe && this.relations' = lowers.keySet() &&
 * this.ints' = ints.indices && this.factory' = factory && 
 * this.ubounds' = uppers && this.lbounds' = lowers && 
 * this.ibounds' = ints
 */
private LeafInterpreter(Universe universe, Map<Relation, TupleSet> lowers, Map<Relation, TupleSet> uppers, 
		SparseSequence<TupleSet> ints, BooleanFactory factory, Map<Relation, IntRange> vars) {
	this.universe = universe;
	this.lowers = lowers;
	this.uppers = uppers;
	this.ints = ints;
	this.factory = factory;
	this.vars = vars;
}
 

import kodkod.util.ints.SparseSequence; //导入依赖的package包/类
/**
 * Constructs a Bounds object with the given factory and mappings.
 */
private Bounds(TupleFactory factory, Map<Relation, TupleSet> lower, Map<Relation, TupleSet> upper, SparseSequence<TupleSet> intbounds) {
	this.factory = factory;
	this.lowers = lower;
	this.uppers = upper;
	this.intbounds = intbounds;
	this.relations = relations(lowers, uppers);
}
 

import kodkod.util.ints.SparseSequence; //导入依赖的package包/类
/**
 * Constructs a new matrix with the given dimensions and factory, 
 * backed by a sparse sequence which can most efficiently hold
 * the elements storable in the sparse sequences s0 and s1.
 * @ensures this.dimensions' = dimensions && this.factory' = factory && 
 *          this.elements' = [0..dimensions.capacity)->one FALSE 
 */
private BooleanMatrix(Dimensions d, BooleanFactory f, SparseSequence<BooleanValue> s0, SparseSequence<BooleanValue> s1) {
	this.dims = d;
	this.factory = f;
	final Class<?> c0 = s0.getClass(), c1 = s1.getClass();
	if (c0!=c1 || c0==RangeSequence.class) 
		this.cells = new RangeSequence<BooleanValue>();
	else if (c0==HomogenousSequence.class) 
		this.cells = new HomogenousSequence<BooleanValue>(TRUE, Ints.bestSet(d.capacity())); 
	else 
		this.cells = new TreeSequence<BooleanValue>();	
}
 

import kodkod.util.ints.SparseSequence; //导入依赖的package包/类
/**
 * Returns a new matrix such that an entry in the returned matrix represents a 
 * conjunction of the corresponding entries in this and other matrix.  The effect 
 * of this method is the same as calling this.compose(ExprOperator.Binary.AND, other).
 * 
 * @return { m: BooleanMatrix | m.dimensions = this.dimensions && m.factory = this.factory &&
 *                              all i: [0..m.dimensions.capacity) | 
 *                               m.elements[i] = this.elements[i] AND other.elements[i] }
 * @throws NullPointerException  other = null
 * @throws IllegalArgumentException  !other.dimensions.equals(this.dimensions) || this.factory != other.factory
 */
public final BooleanMatrix and(BooleanMatrix  other) {
	checkFactory(this.factory, other.factory); 
	checkDimensions(this.dims, other.dims);
	final BooleanMatrix ret = new BooleanMatrix(dims, factory, cells, other.cells);
	final SparseSequence<BooleanValue> s1 = other.cells;
	if (cells.isEmpty() || s1.isEmpty()) return ret;
	for(IndexedEntry<BooleanValue> e0 : cells) {
		BooleanValue v1 = s1.get(e0.index());
		if (v1!=null)
			ret.fastSet(e0.index(), factory.and(e0.value(), v1));
	}
	return ret;
}
 

import kodkod.util.ints.SparseSequence; //导入依赖的package包/类
/**
 * Constructs a new propagator.
 */
private Propagator(Set<Formula> conjuncts, SparseSequence<Expression> empties, SparseSequence<IntConstant> constants) {
	super(empties, constants);
	this.conjuncts = conjuncts;
	this.negs = new LinkedHashSet<Formula>();
	for(Formula f: conjuncts) { 
		if (f instanceof NotFormula)
			negs.add(((NotFormula)f).formula());
	}
}
 

import kodkod.util.ints.SparseSequence; //导入依赖的package包/类
/**
 * Constructs a new simplifier that will use the given collection 
 * of empty expressions and integer constants.  The empties sequence must map each of its indices
 * to an empty expression of the same arity as the index.  The constants sequence must map each of
 * its indices to a Kodkod constant with the same value as the index.
 */
@SuppressWarnings("unchecked")
Simplifier(SparseSequence<Expression> empties, SparseSequence<IntConstant> constants) {
	super(Collections.EMPTY_SET);
	this.empties = empties;
	this.constants = constants;
}