import net.sf.javabdd.JFactory; //导入依赖的package包/类
/**
 * Constructs a {@link JBDDProvider} with the {@link Type} of the BDD library to use, a given number of variables,
 * the growth rate of the number of variables, and the initial number of nodes.
 * 
 * @param type
 *            the type of the BDD library
 * @param vars
 *            the number of variables
 * @param variableGrowthFactor
 *            the factor by which to extend the number of variables if required
 * @param initialNumberofNodes
 *            the initial number of nodes reserved in the BDD factory
 */
public JBDDProvider(Type type, int vars, int variableGrowthFactor, int initialNumberofNodes) {
	switch (type) {
	case JDD:
		factory = JDDFactory.init(initialNumberofNodes, initialNumberofNodes);
		break;
	default:
		factory = JFactory.init(initialNumberofNodes, initialNumberofNodes);
		factory.autoReorder(BDDFactory.REORDER_SIFT);
	}

	factory.setVarNum(vars);
	this.vars = vars;
	this.variableGrowthFactor = variableGrowthFactor;
}
 

import net.sf.javabdd.JFactory; //导入依赖的package包/类
@Override
public void init() {
	// Type.JAVABDD should be the standard BDD Factory
	this.factory = new JBDDProviderFactory();
	JBDDProvider<Object> provider = (JBDDProvider<Object>) factory.getProvider();
	Assert.assertTrue("JavaBDD should be the standard JBDDProviderFactory.",
			provider.getFactory() instanceof JFactory);
}
 

import net.sf.javabdd.JFactory; //导入依赖的package包/类
public SequenceBasedAndGateDecomposer(StateGraph stategraph, Netlist netlist) {
    this.netlist = netlist;
    this.factory = JFactory.init(1000, 250);
    this.sigidmap = new HashMap<>();
    this.quasimap = HashBiMap.create();
    this.origsg = stategraph;
    this.sghelper = new AndDecoSGHelper(stategraph.getSTG().getFile());
}
 

import net.sf.javabdd.JFactory; //导入依赖的package包/类
/**
 * Calls the logic synthesis flow
 * 
 * @return Status code:
 *         0: Everything okay
 *         1: Something failed
 */
private static int execute() {
    BDDFactory storage = JFactory.init(netlistNodesize, netlistNodesize / 4);
    storage.setCacheRatio(4f);

    TechLibrary tech = readTechnology(options.getTechnology(), config.defaultTech, storage);
    if(tech == null) {
        logger.error("No technology found");
        return 1;
    }

    Flow flow = new Flow(options, tech, storage);
    return flow.execute();
}
 

import net.sf.javabdd.JFactory; //导入依赖的package包/类
public ReasoningWithBDD(VariableOrderingHeuristic voHeuristic, int nodeNum, int cacheSize, long maxBuildingTime, ReorderMethod reorderMethod, String orderingFormulasStrategy) {
	super();
	this.variableOrderingHeuristic = voHeuristic;
	this.nodeNum = nodeNum;
	this.cacheSize = cacheSize;
	this.reorderMethod = reorderMethod;
	states = new LinkedHashMap<String,ReasoningWithBDDState>();
	this.maxBuildingTime = maxBuildingTime;
	this.heuristicRunningTime = -1;
	this.bddBuildingTime = -1;
	this.orderingFormulasStrategy = orderingFormulasStrategy;
	bddFactory = JFactory.init(nodeNum,cacheSize);
}
 

import net.sf.javabdd.JFactory; //导入依赖的package包/类
@Override
public void reset() {
	
	
	variables = new HashMap<String, BDD>();
	featuresMap = new HashMap<String, GenericFeature>();
	vars = new HashMap<Integer, String>();
	subtrees = new ArrayList<BDD>();
	factory = JFactory.init(1000000, 10000); // This can be optimized taking
	numvar = 1;								 // into account the size of
}
 

import net.sf.javabdd.JFactory; //导入依赖的package包/类
@Before
public void setUp() {
	factory = JavaBDDAdapterFactory.init(100, 10);
	factory.setVarNum(10);
	jfactory = JFactory.init(100, 10);
	jfactory.setVarNum(10);
}