Some functions return 0.0 or 0 instead of NaN or Infinity about basic HOT 1 OPEN

	private boolean executeMF_INT() {					// 2014-03-16 gt
		if (!evalNumericExpression()) return false;
		Double iD = EvalNumericExpressionValue;
		if (!iD.isNaN() && !iD.isInfinite()){ //2018-01-15gt
			EvalNumericExpressionIntValue = EvalNumericExpressionValue.longValue();
			EvalNumericExpressionValue = Double.valueOf(EvalNumericExpressionIntValue);
		}//2018-01-15gt
		VarIsInt = true;
		return true;
	}

		private boolean executeMF_FRAC() { // 2014-03-16 gt
			if (!evalNumericExpression())
				return false;
			//Old version does not work correctly with big numbers like 4.5678879E8
			String str = EvalNumericExpressionValue.toString();
			Double iD = EvalNumericExpressionValue;
			if (!iD.isNaN() && !iD.isInfinite()){ //2018-01-15gt
				if (str.indexOf("E") > -1) {//vv2017-04-15gt
					str = new BigDecimal(EvalNumericExpressionValue).toPlainString();//2017-05-05gt
					//str = String.format(Locale.US,"%.18f", new BigDecimal(EvalNumericExpressionValue));
				} //^^2017-04-15gt
				String sgn = (EvalNumericExpressionValue < 0) ? "-" : "";
				int point = str.indexOf('.');
				EvalNumericExpressionValue = (point < 0) ? 0.0
						: Double.parseDouble(sgn + str.substring(point));
			} //2018-01-15gt
			return true;
		}

	private boolean executeMF_base(int base) {			// BIN, OCT, or HEX, depending on the base parameter
		if (!getStringArg()) return false;				// Get and check the string expression
		if (base == 2){//BIN()//vv2018-01-15gt
			if (StringConstant.equals("111111111111000000000000000000000000000000000000000000000000000")){//IEEE 754, "NaN";
				EvalNumericExpressionValue = Math.sqrt(-1);
				return true;
			}
			if (StringConstant.equals("111111111110000000000000000000000000000000000000000000000000000")){//IEEE 754, +Infinitive
				EvalNumericExpressionValue = 1.0/0;
				return true;
			}
			if (StringConstant.equals("1111111111110000000000000000000000000000000000000000000000000000")){ //IEEE 754, -Infinitive
				EvalNumericExpressionValue = -1.0/0;
				return true;
			}
		}
		if (base == 8){//OCT()
			if (StringConstant.equals("777700000000000000000")){//IEEE 754, "NaN";
				EvalNumericExpressionValue = Math.sqrt(-1);
				return true;
			}
			if (StringConstant.equals("777600000000000000000")){//IEEE 754, +Infinitive
				EvalNumericExpressionValue = 1.0/0;
				return true;
			}
			if (StringConstant.equals("1777600000000000000000")){ //IEEE 754, -Infinitive
				EvalNumericExpressionValue = -1.0/0;
				return true;
			}
		}
		if (base == 16){//HEX()
			if (StringConstant.equals("7ff8000000000000")){//IEEE 754, "NaN";
				EvalNumericExpressionValue = Math.sqrt(-1);
				return true;
			}
			if (StringConstant.equals("7ff0000000000000")){//IEEE 754, +Infinitive
				EvalNumericExpressionValue = 1.0/0;
				return true;
			}
			if (StringConstant.equals("fff0000000000000")){ //IEEE 754, -Infinitive
				EvalNumericExpressionValue = -1.0/0;
				return true;
			}
		}//^^2018-01-15gt
		try {
			EvalNumericExpressionIntValue = new BigInteger(StringConstant, base).longValue();
			EvalNumericExpressionValue = EvalNumericExpressionIntValue.doubleValue();
			VarIsInt = true;
		} catch (NumberFormatException e) {
			return RunTimeError("Not a valid number: " + StringConstant);
		}
		return true;
	}

	private boolean executeSF_INT() {													// INT$
		if (!evalNumericExpression())	return false;
		if (!isNext(')'))				return false;	// Function must end with ')'
		Double testIsN = EvalNumericExpressionValue;//vv2018-01-15gt
		if (testIsN.isNaN()){ 
			StringConstant = "NaN";
		}else if (testIsN.isInfinite()){ 
			StringConstant = "Infinity";
			if (testIsN < 0)StringConstant = "-Infinity";
		}else{ //^^2018-01-15gt
			long val = EvalNumericExpressionValue.longValue();
			StringConstant = Long.toString(val);
		} //2018-01-15gt
		return true;
	}

	private boolean executeSF_HEX() {													// HEX$
		if (!evalNumericExpression())	return false;
		if (!isNext(')'))				return false;	// Function must end with ')'
		Double testIsN = EvalNumericExpressionValue; //vv2018-01-15gt
		if (testIsN.isNaN()){
			StringConstant = "7ff8000000000000"; //IEEE 754, "NaN";
		}else if (testIsN.isInfinite()){ 
			StringConstant = "7ff0000000000000"; //IEEE 754, +Infinitive
			if (testIsN < 0)StringConstant = "fff0000000000000"; //IEEE 754, -Infinitive
		}else{ //^^2018-01-15gt
			long val = EvalNumericExpressionValue.longValue();
			StringConstant = Long.toHexString(val);
		} //2018-01-15gt
		return true;
	}

	private boolean executeSF_OCT() {													// OCT$
		if (!evalNumericExpression())	return false;
		if (!isNext(')'))				return false;	// Function must end with ')'
		Double testIsN = EvalNumericExpressionValue; //vv2018-01-15gt
		if (testIsN.isNaN()){
			StringConstant = "777700000000000000000"; //IEEE 754, "NaN";
		}else if (testIsN.isInfinite()){ 
			StringConstant = "777600000000000000000"; //IEEE 754, +Infinitive
			if (testIsN < 0)StringConstant = "1777600000000000000000"; //IEEE 754, -Infinitive
		}else{ //^^2018-01-15gt
			long val = EvalNumericExpressionValue.longValue();
		StringConstant = Long.toOctalString(val);
	} //2018-01-15gt
		return true;
	}

	private boolean executeSF_BIN() {													// BIN$
		if (!evalNumericExpression())	return false;
		if (!isNext(')'))				return false;	// Function must end with ')'
		Double testIsN = EvalNumericExpressionValue; //vv2018-01-15gt
		if (testIsN.isNaN()){
			StringConstant = "111111111111000000000000000000000000000000000000000000000000000"; //IEEE 754, "NaN";
		}else if (testIsN.isInfinite()){ 
			StringConstant = "111111111110000000000000000000000000000000000000000000000000000"; //IEEE 754, +Infinitive
			if (testIsN < 0)StringConstant = "1111111111110000000000000000000000000000000000000000000000000000"; //IEEE 754, -Infinitive
		}else{ //^^2018-01-15gt
			long val = EvalNumericExpressionValue.longValue();
		StringConstant = Long.toBinaryString(val);
	} //2018-01-15gt
		return true;
	}