olimaticer
commented
6 years ago 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;
}
Also supported IEEE 754, Infinitive now. Gregor
INT Input of a NaN (Not a Number) Value returns 0.0 GitHub#259 Fixed with a return of "NaN" INT$ Input of a NaN (Not a Number) Value returns 0 GitHub#259 Fixed with a return of "NaN" HEX$ Input of a NaN (Not a Number) Value returns 0 GitHub#259 Fixed with a return of "NaN" OFT$ Input of a NaN (Not a Number) Value returns 0 GitHub#259 Fixed with a return of "NaN" BIN$ Input of a NaN (Not a Number) Value returns 0 GitHub#259 Fixed with a return of "NaN"