Optimize primitive boxing

prism/src/explicit/CTMCModelChecker.java

@@ -259,7 +259,7 @@ public StateValues doTransient(CTMC ctmc, double t, StateValues initDist) throws
 
 		// Build initial distribution (if not specified)
 		if (initDist == null) {
-			initDistNew = new StateValues(TypeDouble.getInstance(), new Double(0.0), ctmc);
+			initDistNew = new StateValues(TypeDouble.getInstance(), 0.0, ctmc);
 			double initVal = 1.0 / ctmc.getNumInitialStates();
 			for (int in : ctmc.getInitialStates()) {
 				initDistNew.setDoubleValue(in, initVal);

prism/src/explicit/FastAdaptiveUniformisationModelChecker.java

@@ -215,7 +215,7 @@ private Result checkExpressionProb(ExpressionProb expr) throws PrismException
 		mainLog.println("\nTotal probability lost is : " + fau.getTotalDiscreteLoss());
 		mainLog.println("Maximal number of states stored during analysis : " + fau.getMaxNumStates());
 
-		return new Result(new Double(fau.getValue()));
+		return new Result(fau.getValue());
 	}
 
 	/**
@@ -244,6 +244,6 @@ private Result checkExpressionReward(ExpressionReward expr) throws PrismExceptio
 		fau.computeTransientProbsAdaptive(time);
 		mainLog.println("\nTotal probability lost is : " + fau.getTotalDiscreteLoss());
 		mainLog.println("Maximal number of states stored during analysis : " + fau.getMaxNumStates());
-		return new Result(new Double(fau.getValue()));
+		return new Result(fau.getValue());
 	}
 }

prism/src/explicit/PrismExplicit.java

@@ -179,7 +179,7 @@ public void exportStatesToFile(ModulesFile mf, Model model, int exportType, File
 		// print states
 		StateValues statesList = null;
 		try {
-			statesList = new StateValues(TypeBool.getInstance(), new Boolean(true), model);
+			statesList = new StateValues(TypeBool.getInstance(), true, model);
 		} catch (PrismLangException e) {
 			// Can't go wrong - type always fine
 		}

prism/src/explicit/ProbModelChecker.java

@@ -1029,8 +1029,8 @@ protected StateValues checkRewardCumulative(Model model, Rewards modelRewards, E
 
 		// Compute/return the rewards
 		// A trivial case: "C<=0" (prob is 1 in target states, 0 otherwise)
-		if (timeInt == 0 || timeDouble == 0) {
-			return new StateValues(TypeDouble.getInstance(), model.getNumStates(), new Double(0));
+		if (timeInt == 0 || timeDouble == 0.0) {
+			return new StateValues(TypeDouble.getInstance(), model.getNumStates(), 0.0);
 		}
 		// Otherwise: numerical solution
 		ModelCheckerResult res = null;

prism/src/explicit/StateModelChecker.java

@@ -1006,7 +1006,7 @@ protected StateValues checkExpressionFilter(Model model, ExpressionFilter expr,
 			// Compute count
 			int count = vals.countOverBitSet(bsFilter);
 			// Store as object/vector
-			resObj = new Integer(count);
+			resObj = count;
 			resVals = new StateValues(expr.getType(), resObj, model);
 			// Create explanation of result and print some details to log
 			resultExpl = filterTrue ? "Count of satisfying states" : "Count of satisfying states also in filter";
@@ -1061,7 +1061,7 @@ protected StateValues checkExpressionFilter(Model model, ExpressionFilter expr,
 			// Check "for all" over filter
 			b = vals.forallOverBitSet(bsFilter);
 			// Store as object/vector
-			resObj = new Boolean(b);
+			resObj = Boolean.valueOf(b);
 			resVals = new StateValues(expr.getType(), resObj, model);
 			// Create explanation of result and print some details to log
 			resultExpl = "Property " + (b ? "" : "not ") + "satisfied in ";
@@ -1089,7 +1089,7 @@ protected StateValues checkExpressionFilter(Model model, ExpressionFilter expr,
 			// Check "there exists" over filter
 			b = vals.existsOverBitSet(bsFilter);
 			// Store as object/vector
-			resObj = new Boolean(b);
+			resObj = Boolean.valueOf(b);
 			resVals = new StateValues(expr.getType(), resObj, model);
 			// Create explanation of result and print some details to log
 			resultExpl = "Property satisfied in ";

prism/src/explicit/StateValues.java

@@ -1422,14 +1422,14 @@ public Object minOverBitSet(BitSet filter) throws PrismException
 				if (valuesI[i] < minI)
 					minI = valuesI[i];
 			}
-			return new Integer(minI);
+			return minI;
 		} else if (type instanceof TypeDouble) {
 			double minD = Double.POSITIVE_INFINITY;
 			for (int i = filter.nextSetBit(0); i >= 0; i = filter.nextSetBit(i + 1)) {
 				if (valuesD[i] < minD)
 					minD = valuesD[i];
 			}
-			return new Double(minD);
+			return minD;
 		}
 		throw new PrismException("Can't take min over a vector of type " + type);
 	}
@@ -1445,14 +1445,14 @@ public Object maxOverBitSet(BitSet filter) throws PrismException
 				if (valuesI[i] > maxI)
 					maxI = valuesI[i];
 			}
-			return new Integer(maxI);
+			return maxI;
 		} else if (type instanceof TypeDouble) {
 			double maxD = Double.NEGATIVE_INFINITY;
 			for (int i = filter.nextSetBit(0); i >= 0; i = filter.nextSetBit(i + 1)) {
 				if (valuesD[i] > maxD)
 					maxD = valuesD[i];
 			}
-			return new Double(maxD);
+			return maxD;
 		}
 		throw new PrismException("Can't take max over a vector of type " + type);
 	}
@@ -1498,7 +1498,7 @@ public int countOverBitSet(BitSet filter) throws PrismException
 				if (valuesB.get(i))
 					count++;
 			}
-			return new Integer(count);
+			return count;
 		}
 		throw new PrismException("Can't take count over a vector of type " + type);
 	}
@@ -1513,13 +1513,13 @@ public Object sumOverBitSet(BitSet filter) throws PrismException
 			for (int i = filter.nextSetBit(0); i >= 0; i = filter.nextSetBit(i + 1)) {
 				sumI += valuesI[i];
 			}
-			return new Integer(sumI);
+			return sumI;
 		} else if (type instanceof TypeDouble) {
 			double sumD = 0.0;
 			for (int i = filter.nextSetBit(0); i >= 0; i = filter.nextSetBit(i + 1)) {
 				sumD += valuesD[i];
 			}
-			return new Double(sumD);
+			return sumD;
 		}
 		throw new PrismException("Can't take sum over a vector of type " + type);
 	}

prism/src/jdd/JDDVars.java

@@ -382,7 +382,9 @@ public void sortByIndex()
 			@Override
 			public int compare(JDDNode a, JDDNode b)
 			{
-				return new Integer(a.getIndex()).compareTo(b.getIndex());
+				int x = a.getIndex();
+				int y = b.getIndex();
+				return (x < y) ? -1 : ((x == y) ? 0 : 1);
 			}
 		});
 	}

prism/src/jltl2ba/Buchi.java

@@ -731,7 +731,7 @@ public NBA toNBA(APSet apset) throws PrismException
 		for (s = bstates.prv; s != bstates; s = s.prv) {
 			stateindex = nba.nba_i_newState();
 			// System.out.println("Seen ltl2ba state " + s.id + ", mapped to " + stateindex);
-			map.put(new LTL2BAState(s.id, s._final), new Integer(stateindex));
+			map.put(new LTL2BAState(s.id, s._final), stateindex);
 
 			if (s.id == -1)
 				nba.nba_i_setStartState(stateindex);

prism/src/jltl2ba/MyBitSet.java

@@ -64,7 +64,7 @@ public Vector<Integer> IntegerList()
 		Vector<Integer> tmp = new Vector<Integer>();
 		for (int i = 0; i < this.size(); i++)
 			if (this.get(i))
-				tmp.add(new Integer(i));
+				tmp.add(i);
 		return tmp;
 	}
 
@@ -137,7 +137,7 @@ public boolean hasNext() {
 		}
 
 		public Integer next() {
-			Integer rv = new Integer(index);
+			Integer rv = index;
 			index = _bitset.nextSetBit(index + 1);
 			return rv;
 		}

prism/src/jltl2dstar/DA.java

@@ -219,7 +219,7 @@ public void makeCompact() throws PrismException {
 			Vector<Integer> mapping = new Vector<Integer>(_index.size());
 			for (i = 0, j = 0; i < _index.size(); i++) {
 				if (_index.get(i) != null) {
-					mapping.set(i, new Integer(j));
+					mapping.set(i, j);
 					if (j != i) {
 						_index.set(j, _index.get(i));
 						_index.set(i, null);

prism/src/jltl2dstar/DRAOptimizations.java

@@ -142,8 +142,8 @@ public int countColors() {
 		public void setColor(int state, int color) {
 			assert(color < _nr_of_colors);
 
-			_coloring.set(state, new Integer(color));
-			_color2state.set(color, new Integer(state));
+			_coloring.set(state, color);
+			_color2state.set(color, state);
 
 			if (_detailed) {
 				_color2states.get(color).set(state);
@@ -326,7 +326,7 @@ public DRA optimizeBisimulation(DRA dra, boolean printColoring, boolean detailed
 		states.setSize(dra.size());
 
 		for (int i = 0; i < dra.size(); i++) {
-			states.set(i, new Integer(i));
+			states.set(i, i);
 		}
 
 		AcceptanceSignatureContainer accsig_container = new AcceptanceSignatureContainer(dra);

prism/src/jltl2dstar/RabinAcceptance.java

@@ -364,7 +364,7 @@ public boolean hasNext() {
 
 		public Integer next() throws NoSuchElementException {
 			if (hasNext()) {
-				Integer rv = new Integer(index);
+				Integer rv = index;
 				increment();
 				return rv;
 			}

prism/src/jltl2dstar/SCCs.java

@@ -131,7 +131,7 @@ public void setState2SCC(int state, int scc) {
 		if (_state_to_scc.size() <= state) {
 			_state_to_scc.setSize(state + 1);
 		}
-		_state_to_scc.set(state, new Integer(scc));
+		_state_to_scc.set(state, scc);
 	}
 
 	/** Set flag that the graph was discovered to be disjoint */

prism/src/param/StateBoolean.java

@@ -38,7 +38,7 @@ final class StateBoolean extends StateValue {
 
 	public StateBoolean()
 	{
-		value = new Boolean(false);
+		value = false;
 	}
 
 	public StateBoolean(boolean value)

prism/src/parser/PrismParser.jj

@@ -1471,7 +1471,7 @@ Expression ExpressionLiteral(boolean prop, boolean pathprop) :
 	<REG_INT> {
 		try {
 			int i = Integer.parseInt(getToken(0).image);
-			ret = new ExpressionLiteral(TypeInt.getInstance(), new Integer(i));
+			ret = new ExpressionLiteral(TypeInt.getInstance(), i);
 		} catch (NumberFormatException e) {
 			// Need to catch this because some matches for regexp REG_INT
 			// are not valid integers (e.g. too big).
@@ -1483,18 +1483,18 @@ Expression ExpressionLiteral(boolean prop, boolean pathprop) :
 	|
 	<REG_DOUBLE> {
 		try {
-			double d = Double.parseDouble(getToken(0).image);
-			ret = new ExpressionLiteral(TypeDouble.getInstance(), new Double(d), getToken(0).image);
+			Double d = Double.valueOf(getToken(0).image);
+			ret = new ExpressionLiteral(TypeDouble.getInstance(), d, getToken(0).image);
 		} catch (NumberFormatException e) {
 			// Need to catch this because some matches for regexp REG_DOUBLE
 			// may not be valid doubles.
 			ParseException ex = new ParseException("Invalid double literal");
 			// NB: can't call generateParseException() here; it crashes
 		}}
 	|
-	<TRUE> { ret = new ExpressionLiteral(TypeBool.getInstance(), new Boolean(true)); }
+	<TRUE> { ret = new ExpressionLiteral(TypeBool.getInstance(), true); }
 	|
-	<FALSE> { ret = new ExpressionLiteral(TypeBool.getInstance(), new Boolean(false)); }
+	<FALSE> { ret = new ExpressionLiteral(TypeBool.getInstance(), false); }
 	)
 	{ ret.setPosition(getToken(0)); return ret; }
 }

prism/src/parser/Values.java

@@ -408,22 +408,10 @@ public boolean equals(Object o)
 	@Override
 	public Object clone()
 	{
-		Values res;
-		int i, n;
-		String s;
-		Object o;
-
-		res = new Values();
-		n = getNumValues();
-		for (i = 0; i < n; i++) {
-			s = getName(i);
-			o = getValue(i);
-			if (o instanceof Integer) o = new Integer(((Integer)o).intValue());
-			else if (o instanceof Double) o = new Double(((Double)o).doubleValue());
-			else o = new Boolean(((Boolean)o).booleanValue());
-			res.addValue(s, o);
+		Values res = new Values();
+		for (int i = 0, n = getNumValues(); i < n; i++) {
+			res.addValue(getName(i), getValue(i));
 		}
-
 		return res;
 	}
 

prism/src/parser/VarList.java

@@ -322,11 +322,11 @@ public Object decodeFromInt(int var, int val)
 		Type type = getType(var);
 		// Integer type
 		if (type instanceof TypeInt) {
-			return new Integer(val + getLow(var));
+			return val + getLow(var);
 		}
 		// Boolean type
 		else if (type instanceof TypeBool) {
-			return new Boolean(val != 0);
+			return val != 0;
 		}
 		// Anything else
 		return null;

prism/src/parser/ast/ExpressionBinaryOp.java

@@ -147,69 +147,69 @@ public Object evaluate(EvaluateContext ec) throws PrismLangException
 	{
 		switch (op) {
 		case IMPLIES:
-			return new Boolean(!operand1.evaluateBoolean(ec) || operand2.evaluateBoolean(ec));
+			return !operand1.evaluateBoolean(ec) || operand2.evaluateBoolean(ec);
 		case IFF:
-			return new Boolean(operand1.evaluateBoolean(ec) == operand2.evaluateBoolean(ec));
+			return operand1.evaluateBoolean(ec) == operand2.evaluateBoolean(ec);
 		case OR:
-			return new Boolean(operand1.evaluateBoolean(ec) || operand2.evaluateBoolean(ec));
+			return operand1.evaluateBoolean(ec) || operand2.evaluateBoolean(ec);
 		case AND:
-			return new Boolean(operand1.evaluateBoolean(ec) && operand2.evaluateBoolean(ec));
+			return operand1.evaluateBoolean(ec) && operand2.evaluateBoolean(ec);
 		case EQ:
 			if (operand1.getType() == TypeInt.getInstance() && operand2.getType() == TypeInt.getInstance()) {
-				return new Boolean(operand1.evaluateInt(ec) == operand2.evaluateInt(ec));
+				return operand1.evaluateInt(ec) == operand2.evaluateInt(ec);
 			} else {
-				return new Boolean(operand1.evaluateDouble(ec) == operand2.evaluateDouble(ec));
+				return operand1.evaluateDouble(ec) == operand2.evaluateDouble(ec);
 			}
 		case NE:
 			if (operand1.getType() == TypeInt.getInstance() && operand2.getType() == TypeInt.getInstance()) {
-				return new Boolean(operand1.evaluateInt(ec) != operand2.evaluateInt(ec));
+				return operand1.evaluateInt(ec) != operand2.evaluateInt(ec);
 			} else {
-				return new Boolean(operand1.evaluateDouble(ec) != operand2.evaluateDouble(ec));
+				return operand1.evaluateDouble(ec) != operand2.evaluateDouble(ec);
 			}
 		case GT:
 			if (operand1.getType() == TypeInt.getInstance() && operand2.getType() == TypeInt.getInstance()) {
-				return new Boolean(operand1.evaluateInt(ec) > operand2.evaluateInt(ec));
+				return operand1.evaluateInt(ec) > operand2.evaluateInt(ec);
 			} else {
-				return new Boolean(operand1.evaluateDouble(ec) > operand2.evaluateDouble(ec));
+				return operand1.evaluateDouble(ec) > operand2.evaluateDouble(ec);
 			}
 		case GE:
 			if (operand1.getType() == TypeInt.getInstance() && operand2.getType() == TypeInt.getInstance()) {
-				return new Boolean(operand1.evaluateInt(ec) >= operand2.evaluateInt(ec));
+				return operand1.evaluateInt(ec) >= operand2.evaluateInt(ec);
 			} else {
-				return new Boolean(operand1.evaluateDouble(ec) >= operand2.evaluateDouble(ec));
+				return operand1.evaluateDouble(ec) >= operand2.evaluateDouble(ec);
 			}
 		case LT:
 			if (operand1.getType() == TypeInt.getInstance() && operand2.getType() == TypeInt.getInstance()) {
-				return new Boolean(operand1.evaluateInt(ec) < operand2.evaluateInt(ec));
+				return operand1.evaluateInt(ec) < operand2.evaluateInt(ec);
 			} else {
-				return new Boolean(operand1.evaluateDouble(ec) < operand2.evaluateDouble(ec));
+				return operand1.evaluateDouble(ec) < operand2.evaluateDouble(ec);
 			}
 		case LE:
 			if (operand1.getType() == TypeInt.getInstance() && operand2.getType() == TypeInt.getInstance()) {
-				return new Boolean(operand1.evaluateInt(ec) <= operand2.evaluateInt(ec));
+				return operand1.evaluateInt(ec) <= operand2.evaluateInt(ec);
 			} else {
-				return new Boolean(operand1.evaluateDouble(ec) <= operand2.evaluateDouble(ec));
+				return operand1.evaluateDouble(ec) <= operand2.evaluateDouble(ec);
 			}
 		case PLUS:
 			if (operand1.getType() == TypeInt.getInstance() && operand2.getType() == TypeInt.getInstance()) {
-				return new Integer(operand1.evaluateInt(ec) + operand2.evaluateInt(ec));
+				return operand1.evaluateInt(ec) + operand2.evaluateInt(ec);
 			} else {
-				return new Double(operand1.evaluateDouble(ec) + operand2.evaluateDouble(ec));
+				return operand1.evaluateDouble(ec) + operand2.evaluateDouble(ec);
 			}
 		case MINUS:
 			if (operand1.getType() == TypeInt.getInstance() && operand2.getType() == TypeInt.getInstance()) {
-				return new Integer(operand1.evaluateInt(ec) - operand2.evaluateInt(ec));
+				return operand1.evaluateInt(ec) - operand2.evaluateInt(ec);
 			} else {
-				return new Double(operand1.evaluateDouble(ec) - operand2.evaluateDouble(ec));
+				return operand1.evaluateDouble(ec) - operand2.evaluateDouble(ec);
 			}
 		case TIMES:
 			if (operand1.getType() == TypeInt.getInstance() && operand2.getType() == TypeInt.getInstance()) {
-				return new Integer(operand1.evaluateInt(ec) * operand2.evaluateInt(ec));
+				return operand1.evaluateInt(ec) * operand2.evaluateInt(ec);
 			} else {
-				return new Double(operand1.evaluateDouble(ec) * operand2.evaluateDouble(ec));
+				return operand1.evaluateDouble(ec) * operand2.evaluateDouble(ec);
 			}
 		case DIVIDE:
-			return new Double(operand1.evaluateDouble(ec) / operand2.evaluateDouble(ec));
+			return operand1.evaluateDouble(ec) / operand2.evaluateDouble(ec);
 		}
 		throw new PrismLangException("Unknown binary operator", this);
 	}