Parses and evaulates data Strings
* using simple expression evaluation.
* *
The grammar used in this parsing is similar to * that defined within the Java Language Specification * by James Gosling, Bill Joy, and Guy Steele but as * of 2.5.0 we have made significant additions to aid * the user of these facilities in interactive mode.
* *As of 2.5.0, the parser algorithms have all been
* refactored down to the new base class called
* BaseParser. The purpose of this class
* is therefore to define and install constants,
* operations, and functions. Each such entity is now
* public static final so they may be utilized by some
* other class that extends BaseParser if
* so desired.
The constants, functions, and operations are all
* commented individually. Summary tables of the
* constants, functions, and operations are provided
* immediately below and repeated in the comments for
* the methods
* addConstants(),
* addFunctions(), and
* addOperations().
* The summary tables for operations show precedence.
This class now provides an exponentiation operator
* denoted ^ that attempts exponentiation
* as an integral computation if possible. This is in
* contrast to the power function that
* always uses Math.pow in its
* implementation. By choosing ^ or
* power, the user may select implementation.
The function definitions continue to throw exceptions * if given incorrect arguments but will no longer throw * exceptions if mathematical errors occur. Rather the * computation proceeds as in Java itself to produce either * an infinity or NaN.
* *In 2.6.0, added hyperbolic functions.
* *Constant definitions:
* *| Identifier | *Type | *Definition | *
true |
* XBoolean |
* true |
*
false |
* XBoolean |
* false |
*
pi |
* XDouble |
* Math.PI |
*
e |
* XDouble |
* Math.E |
*
MaxInt |
* XInt |
* Integer.MAX_VALUE |
*
maxint |
* XInt |
* Integer.MAX_VALUE |
*
MinInt |
* XInt |
* Integer.MIN_VALUE |
*
minint |
* XInt |
* Integer.MIN_VALUE |
*
MaxLong |
* XLong |
* Long.MAX_VALUE |
*
maxlong |
* XLong |
* Long.MAX_VALUE |
*
MinLong |
* XLong |
* Long.MIN_VALUE |
*
minlong |
* XLong |
* Long.MIN_VALUE |
*
MaxDouble |
* XDouble |
* Double.MAX_VALUE |
*
maxdouble |
* XDouble |
* Double.MAX_VALUE |
*
MinDouble |
* XDouble |
* Double.MIN_VALUE |
*
mindouble |
* XDouble |
* Double.MIN_VALUE |
*
Infinity |
* XDouble |
* Double.POSITIVE_INFINITY |
*
infinity |
* XDouble |
* Double.POSITIVE_INFINITY |
*
NaN |
* XDouble |
* Double.NaN |
*
nan |
* XDouble |
* Double.NaN |
*
Function definitions:
* *| Function Name | *Typical Usage | *
abs |
* abs(x) |
*
ceiling |
* ceiling(x) |
*
floor |
* floor(x) |
*
round |
* round(x) |
*
max |
* max(x,y) |
*
min |
* min(x,y) |
*
sqrt |
* sqrt(x) |
*
power |
* power(x,y) |
*
root |
* root(x,y) |
*
todegrees |
* todegrees(theta) |
*
toradians |
* toradians(angle) |
*
sin |
* sin(theta) |
*
sindeg |
* sindeg(angle) |
*
cos |
* cos(theta) |
*
cosdeg |
* cosdeg(angle) |
*
tan |
* tan(theta) |
*
tandeg |
* tandeg(angle) |
*
asin |
* asin(s) |
*
asindeg |
* asindeg(s) |
*
acos |
* acos(c) |
*
acosdeg |
* acosdeg(c) |
*
atan |
* atan(t) |
*
atandeg(t) |
* atandeg(t) |
*
atan2 |
* atan2(y,x) |
*
atan2deg |
* atan2deg(y,x) |
*
exp |
* exp(x) |
*
log |
* log(x) |
*
ln |
* ln(x) |
*
log2 |
* log2(x) |
*
log10 |
* log10(x) |
*
logtobase |
* logtobase(x,b) |
*
sinh |
* sinh(x) |
*
cosh |
* cosh(x) |
*
tanh |
* tanh(x) |
*
asinh |
* asinh(x) |
*
acosh |
* acosh(x) |
*
atanh |
* atanh(x) |
*
In the above table:
* x and y
* stand for generic variables;
* theta
* is an angle in radians;
* angle
* is an angle in degrees;
*
* s, c, t
* stand for possible values of
* sin, cos, tan;
* and b
* is the base for a logarithm.
In 2.5.0, random was removed from the
* list of functions because as implemented in the class
* AbstractFunction a function has a fixed
* number of arguments. Instead, random is
* now implemented directly in BaseParser
* to take one of three forms with the following
* interpretations.
| Function Name | *Typical Usage | *Interpretation | *
random |
* random() |
* Random number between 0 and 1 | *
random |
* random(x) |
* Random number between 0 and x | *
random |
* random(x,y) |
* Random number between x and y | *
Operation definitions:
* *| Precedence | *Operations | *Symbols | *
| 0 | *IDENTITY |
* None |
*
| 1 | *operationOR |
* || |
*
| 2 | *operationAND |
* && |
*
| 3 | *operationEQ |
* == |
*
| 4 | *operationLT |
* < |
*
| 5 | *operationPlus |
* + |
*
| 6 | *operationTimes |
* * |
*
| 7 | *operationCaret |
* ^ |
*
| 8 | *operationNOT |
* ! |
*
abs. */
public static final AbstractFunction functionAbs =
new AbstractFunction("abs", 1)
{
public Object functionCall(Object[] values)
throws ParseException
{
checkValuesAsNumeric(values);
if (ParserUtilities.isXIntegral(values[0])) {
XBigInteger a =
ParserUtilities.toXBigInteger((XNumber) values[0]);
BigInteger va = a.getValue();
int test = va.compareTo(BigInteger.ZERO);
if (test >= 0)
return a;
va = va.negate();
return new XBigInteger(va);
}
XDouble x = ParserUtilities.toXDouble((XNumber) values[0]);
double vx = x.getValue();
if (vx >= 0)
return x;
return new XDouble(-vx);
}
};
/** AbstractFunction to implement ceiling. */
public static final AbstractFunction functionCeiling =
new AbstractFunction("ceiling", 1)
{
public Object functionCall(Object[] values)
throws ParseException
{
checkValuesAsNumeric(values);
if (ParserUtilities.isXIntegral(values[0])) {
XBigInteger a =
ParserUtilities.toXBigInteger((XNumber) values[0]);
return a;
}
XDouble x = ParserUtilities.toXDouble((XNumber) values[0]);
double vx = x.getValue();
vx = Math.ceil(vx);
return new XDouble(vx);
}
};
/** AbstractFunction to implement floor. */
public static final AbstractFunction functionFloor =
new AbstractFunction("floor", 1)
{
public Object functionCall(Object[] values)
throws ParseException
{
checkValuesAsNumeric(values);
if (ParserUtilities.isXIntegral(values[0])) {
XBigInteger a =
ParserUtilities.toXBigInteger((XNumber) values[0]);
return a;
}
XDouble x = ParserUtilities.toXDouble((XNumber) values[0]);
double vx = x.getValue();
vx = Math.floor(vx);
return new XDouble(vx);
}
};
/** AbstractFunction to implement round. */
public static final AbstractFunction functionRound =
new AbstractFunction("round", 1)
{
public Object functionCall(Object[] values)
throws ParseException
{
checkValuesAsNumeric(values);
if (ParserUtilities.isXIntegral(values[0])) {
XBigInteger a =
ParserUtilities.toXBigInteger((XNumber) values[0]);
return a;
}
XDouble x = ParserUtilities.toXDouble((XNumber) values[0]);
double vx = x.getValue();
vx = Math.rint(vx);
return new XDouble(vx);
}
};
/** AbstractFunction to implement max. */
public static final AbstractFunction functionMax =
new AbstractFunction("max", 2)
{
public Object functionCall(Object[] values)
throws ParseException
{
checkValuesAsNumeric(values);
if (ParserUtilities.isXIntegral(values[0]) &&
ParserUtilities.isXIntegral(values[1]))
{
XBigInteger a =
ParserUtilities.toXBigInteger((XNumber) values[0]);
XBigInteger b =
ParserUtilities.toXBigInteger((XNumber) values[1]);
BigInteger va = a.getValue();
BigInteger vb = b.getValue();
int test = va.compareTo(vb);
if (test >= 0)
return a;
return b;
}
XDouble x = ParserUtilities.toXDouble((XNumber) values[0]);
XDouble y = ParserUtilities.toXDouble((XNumber) values[1]);
double vx = x.getValue();
double vy = y.getValue();
if (vx >= vy)
return x;
return y;
}
};
/** AbstractFunction to implement min. */
public static final AbstractFunction functionMin =
new AbstractFunction("min", 2)
{
public Object functionCall(Object[] values)
throws ParseException
{
checkValuesAsNumeric(values);
if (ParserUtilities.isXIntegral(values[0]) &&
ParserUtilities.isXIntegral(values[1]))
{
XBigInteger a =
ParserUtilities.toXBigInteger((XNumber) values[0]);
XBigInteger b =
ParserUtilities.toXBigInteger((XNumber) values[1]);
BigInteger va = a.getValue();
BigInteger vb = b.getValue();
int test = va.compareTo(vb);
if (test >= 0)
return b;
return a;
}
XDouble x = ParserUtilities.toXDouble((XNumber) values[0]);
XDouble y = ParserUtilities.toXDouble((XNumber) values[1]);
double vx = x.getValue();
double vy = y.getValue();
if (vx >= vy)
return y;
return x;
}
};
/**
* AbstractFunction to implement sqrt
* based on Math.sqrt.
*/
public static final AbstractFunction functionSqrt =
new AbstractFunction("sqrt", 1)
{
public Object functionCall(Object[] values)
throws ParseException
{
checkValuesAsNumeric(values);
XDouble x = ParserUtilities.toXDouble((XNumber) values[0]);
double vx = x.getValue();
return new XDouble(Math.sqrt(vx));
}
};
/**
* AbstractFunction to implement power
* based on Math.pow.
*
* @see #operationCaret
*/
public static final AbstractFunction functionPower =
new AbstractFunction("power", 2)
{
public Object functionCall(Object[] values)
throws ParseException
{
checkValuesAsNumeric(values);
XDouble x = ParserUtilities.toXDouble((XNumber) values[0]);
XDouble y = ParserUtilities.toXDouble((XNumber) values[1]);
double vx = x.getValue();
double vy = y.getValue();
return new XDouble(Math.pow(vx, vy));
}
};
/**
* AbstractFunction to implement root
* based on MathUtilities.root.
*/
public static final AbstractFunction functionRoot =
new AbstractFunction("root", 2)
{
public Object functionCall(Object[] values)
throws ParseException
{
checkValuesAsNumeric(values);
XDouble x = ParserUtilities.toXDouble((XNumber) values[0]);
XDouble y = ParserUtilities.toXDouble((XNumber) values[1]);
double vx = x.getValue();
double vy = y.getValue();
return new XDouble(MathUtilities.root(vx, vy));
}
};
/**
* AbstractFunction to implement todegrees
* based on Math.toDegrees.
*/
public static final AbstractFunction functionToDegrees =
new AbstractFunction("todegrees", 1)
{
public Object functionCall(Object[] values)
throws ParseException
{
checkValuesAsNumeric(values);
XDouble x = ParserUtilities.toXDouble((XNumber) values[0]);
double vx = x.getValue();
return new XDouble(Math.toDegrees(vx));
}
};
/**
* AbstractFunction to implement toradians
* based on Math.toRadians.
*/
public static final AbstractFunction functionToRadians =
new AbstractFunction("toradians", 1)
{
public Object functionCall(Object[] values)
throws ParseException
{
checkValuesAsNumeric(values);
XDouble x = ParserUtilities.toXDouble((XNumber) values[0]);
double vx = x.getValue();
return new XDouble(Math.toRadians(vx));
}
};
/**
* AbstractFunction to implement sin
* based on Math.sin.
*/
public static final AbstractFunction functionSin =
new AbstractFunction("sin", 1)
{
public Object functionCall(Object[] values)
throws ParseException
{
checkValuesAsNumeric(values);
XDouble x = ParserUtilities.toXDouble((XNumber) values[0]);
double vx = x.getValue();
return new XDouble(Math.sin(vx));
}
};
/**
* AbstractFunction to implement sindeg
* based on Math.sin
* and appropriate degrees to radians conversion.
*/
public static final AbstractFunction functionSinDeg =
new AbstractFunction("sindeg", 1)
{
public Object functionCall(Object[] values)
throws ParseException
{
checkValuesAsNumeric(values);
XDouble x = ParserUtilities.toXDouble((XNumber) values[0]);
double vx = x.getValue();
return new XDouble(Math.sin(Math.toRadians(vx)));
}
};
/**
* AbstractFunction to implement cos
* based on Math.cos.
*/
public static final AbstractFunction functionCos =
new AbstractFunction("cos", 1)
{
public Object functionCall(Object[] values)
throws ParseException
{
checkValuesAsNumeric(values);
XDouble x = ParserUtilities.toXDouble((XNumber) values[0]);
double vx = x.getValue();
return new XDouble(Math.cos(vx));
}
};
/**
* AbstractFunction to implement cosdeg
* based on Math.cos
* and appropriate degrees to radians conversion.
*/
public static final AbstractFunction functionCosDeg =
new AbstractFunction("cosdeg", 1)
{
public Object functionCall(Object[] values)
throws ParseException
{
checkValuesAsNumeric(values);
XDouble x = ParserUtilities.toXDouble((XNumber) values[0]);
double vx = x.getValue();
return new XDouble(Math.cos(Math.toRadians(vx)));
}
};
/**
* AbstractFunction to implement tan
* based on Math.tan.
*/
public static final AbstractFunction functionTan =
new AbstractFunction("tan", 1)
{
public Object functionCall(Object[] values)
throws ParseException
{
checkValuesAsNumeric(values);
XDouble x = ParserUtilities.toXDouble((XNumber) values[0]);
double vx = x.getValue();
return new XDouble(Math.tan(vx));
}
};
/**
* AbstractFunction to implement tandeg
* based on Math.tan
* and appropriate degrees to radians conversion.
*/
public static final AbstractFunction functionTanDeg =
new AbstractFunction("tandeg", 1)
{
public Object functionCall(Object[] values)
throws ParseException
{
checkValuesAsNumeric(values);
XDouble x = ParserUtilities.toXDouble((XNumber) values[0]);
double vx = x.getValue();
return new XDouble(Math.tan(Math.toRadians(vx)));
}
};
/**
* AbstractFunction to implement asin
* based on Math.asin.
*/
public static final AbstractFunction functionASin =
new AbstractFunction("asin", 1)
{
public Object functionCall(Object[] values)
throws ParseException
{
checkValuesAsNumeric(values);
XDouble x = ParserUtilities.toXDouble((XNumber) values[0]);
double vx = x.getValue();
return new XDouble(Math.asin(vx));
}
};
/**
* AbstractFunction to implement asindeg
* based on Math.asin
* and appropriate radians to degrees conversion.
*/
public static final AbstractFunction functionASinDeg =
new AbstractFunction("asindeg", 1)
{
public Object functionCall(Object[] values)
throws ParseException
{
checkValuesAsNumeric(values);
XDouble x = ParserUtilities.toXDouble((XNumber) values[0]);
double vx = x.getValue();
return new XDouble(Math.toDegrees(Math.asin(vx)));
}
};
/**
* AbstractFunction to implement acos
* based on Math.acos.
*/
public static final AbstractFunction functionACos =
new AbstractFunction("acos", 1)
{
public Object functionCall(Object[] values)
throws ParseException
{
checkValuesAsNumeric(values);
XDouble x = ParserUtilities.toXDouble((XNumber) values[0]);
double vx = x.getValue();
return new XDouble(Math.acos(vx));
}
};
/**
* AbstractFunction to implement acosdeg
* based on Math.acos
* and appropriate radians to degrees conversion.
*/
public static final AbstractFunction functionACosDeg =
new AbstractFunction("acosdeg", 1)
{
public Object functionCall(Object[] values)
throws ParseException
{
checkValuesAsNumeric(values);
XDouble x = ParserUtilities.toXDouble((XNumber) values[0]);
double vx = x.getValue();
return new XDouble(Math.toDegrees(Math.acos(vx)));
}
};
/**
* AbstractFunction to implement atan
* based on Math.atan.
*/
public static final AbstractFunction functionATan =
new AbstractFunction("atan", 1)
{
public Object functionCall(Object[] values)
throws ParseException
{
checkValuesAsNumeric(values);
XDouble x = ParserUtilities.toXDouble((XNumber) values[0]);
double vx = x.getValue();
return new XDouble(Math.atan(vx));
}
};
/**
* AbstractFunction to implement atandeg
* based on Math.atan
* and appropriate radians to degrees conversion.
*/
public static final AbstractFunction functionATanDeg =
new AbstractFunction("atandeg", 1)
{
public Object functionCall(Object[] values)
throws ParseException
{
checkValuesAsNumeric(values);
XDouble x = ParserUtilities.toXDouble((XNumber) values[0]);
double vx = x.getValue();
return new XDouble(Math.toDegrees(Math.atan(vx)));
}
};
/**
* AbstractFunction to implement atan2
* based on Math.atan2.
*/
public static final AbstractFunction functionATan2 =
new AbstractFunction("atan2", 2)
{
public Object functionCall(Object[] values)
throws ParseException
{
checkValuesAsNumeric(values);
// note that for atan2, y precedes x
XDouble y = ParserUtilities.toXDouble((XNumber) values[0]);
XDouble x = ParserUtilities.toXDouble((XNumber) values[1]);
double vy = y.getValue();
double vx = x.getValue();
return new XDouble(Math.atan2(vy, vx));
}
};
/**
* AbstractFunction to implement atan2deg
* based on Math.atan2
* and appropriate radians to degrees conversion.
*/
public static final AbstractFunction functionATan2Deg =
new AbstractFunction("atan2deg", 2)
{
public Object functionCall(Object[] values)
throws ParseException
{
checkValuesAsNumeric(values);
// note that for atan2deg, y precedes x
XDouble y = ParserUtilities.toXDouble((XNumber) values[0]);
XDouble x = ParserUtilities.toXDouble((XNumber) values[1]);
double vy = y.getValue();
double vx = x.getValue();
return new XDouble(Math.toDegrees(Math.atan2(vy, vx)));
}
};
/**
* AbstractFunction to implement exp
* based on Math.exp.
*/
public static final AbstractFunction functionExp =
new AbstractFunction("exp", 1)
{
public Object functionCall(Object[] values)
throws ParseException
{
checkValuesAsNumeric(values);
XDouble x = ParserUtilities.toXDouble((XNumber) values[0]);
double vx = x.getValue();
return new XDouble(Math.exp(vx));
}
};
/**
* AbstractFunction to implement log
* based on Math.log.
This is identical to ln.
AbstractFunction to implement ln
* based on Math.log.
This is identical to log.
AbstractFunction to implement log2.
* *
log2(x) is computed as:
Math.log(x) / Math.log(2)
AbstractFunction to implement log10.
* *
log10(x) is computed as:
Math.log(x) / Math.log(10)
AbstractFunction to implement logtobase.
* *
logtobase(x,b) is computed as:
Math.log(x) / Math.log(b)
AbstractFunction to implement sinh.
* *
sinh(x) is computed as:
MathUtilities.sinh(x)
AbstractFunction to implement cosh.
* *
cosh(x) is computed as:
MathUtilities.cosh(x)
AbstractFunction to implement tanh.
* *
tanh(x) is computed as:
MathUtilities.tanh(x)
AbstractFunction to implement asinh.
* *
asinh(x) is computed as:
MathUtilities.asinh(x)
AbstractFunction to implement acosh.
* *
acosh(x) is computed as:
MathUtilities.acosh(x)
AbstractFunction to implement atanh.
* *
atanh(x) is computed as:
MathUtilities.atanh(x)
NumericOperation to implement plus.
* *Symbol: "+".
* *Unary and binary.
*/ public static final NumericOperation operationPlus = new NumericOperation("+", true, true) { public Object unaryForXIntegral(XBigInteger a) { return a; } public Object binaryForXIntegral(XBigInteger a, XBigInteger b) { BigInteger va = a.getValue(); BigInteger vb = b.getValue(); return new XBigInteger(va.add(vb)); } public Object unaryForXFloating(XDouble x) { return x; } public Object binaryForXFloating(XDouble x, XDouble y) { double vx = x.getValue(); double vy = y.getValue(); return new XDouble(vx + vy); } }; /** *NumericOperation to implement minus.
* *Symbol: "-".
* *Unary and binary.
*/ public static final NumericOperation operationMinus = new NumericOperation("-", true, true) { public Object unaryForXIntegral(XBigInteger a) { BigInteger va = a.getValue(); return new XBigInteger(va.negate()); } public Object binaryForXIntegral(XBigInteger a, XBigInteger b) { BigInteger va = a.getValue(); BigInteger vb = b.getValue(); return new XBigInteger(va.subtract(vb)); } public Object unaryForXFloating(XDouble x) { double vx = x.getValue(); return new XDouble(-vx); } public Object binaryForXFloating(XDouble x, XDouble y) { double vx = x.getValue(); double vy = y.getValue(); return new XDouble(vx - vy); } }; /** *NumericOperation to implement times.
* *Symbol: "*".
* *Binary.
*/ public static final NumericOperation operationTimes = new NumericOperation("*", false, true) { public Object binaryForXIntegral(XBigInteger a, XBigInteger b) { BigInteger va = a.getValue(); BigInteger vb = b.getValue(); return new XBigInteger(va.multiply(vb)); } public Object binaryForXFloating(XDouble x, XDouble y) { double vx = x.getValue(); double vy = y.getValue(); return new XDouble(vx * vy); } }; /** *NumericOperation to implement division.
* *Symbol: "/".
* *Binary.
*/ public static final NumericOperation operationSlash = new NumericOperation("/", false, true) { public Object binaryForXIntegral(XBigInteger a, XBigInteger b) { BigInteger va = a.getValue(); BigInteger vb = b.getValue(); if (vb.equals(BigInteger.ZERO)) { int test = va.compareTo(BigInteger.ZERO); if (test > 0) return new XDouble(Double.POSITIVE_INFINITY); if (test < 0) return new XDouble(Double.NEGATIVE_INFINITY); return new XDouble(Double.NaN); } return new XBigInteger(va.divide(vb)); } public Object binaryForXFloating(XDouble x, XDouble y) { double vx = x.getValue(); double vy = y.getValue(); return new XDouble(vx / vy); } }; /** *NumericOperation to implement remainder.
* *Symbol: "%".
* *Binary.
*/ public static final NumericOperation operationPercent = new NumericOperation("%", false, true) { public Object binaryForXIntegral(XBigInteger a, XBigInteger b) { BigInteger va = a.getValue(); BigInteger vb = b.getValue(); if (vb.equals(BigInteger.ZERO)) return new XDouble(Double.NaN); return new XBigInteger(va.remainder(vb)); } public Object binaryForXFloating(XDouble x, XDouble y) { double vx = x.getValue(); double vy = y.getValue(); return new XDouble(vx % vy); } }; /** *NumericOperation to implement exponentiation.
* *Symbol: "^".
* *Binary.
* *If the arguments are integral, that is, of type
* XBigInteger, then an effort will be
* made to carry out the exponentiation in integral
* arithmetic.
If the arguments are not integral or if it is
* impossible to do an integral computation, then
* this method reverts to using Math.pow.
This operation is more subtle than the function
* functionPower introduced in this class.
* The power function always uses Math.pow
* and makes no attempt to handle integral arguments in
* a special way.
It is intentional that this operation and the power * function operate differently. In some cases, the user * may want an integral computation but in other cases if * the internal BigInteger would be extremely large may * actually perfer to do the computation using double * precision floating point.
* * @see #functionPower */ public static final NumericOperation operationCaret = new NumericOperation("^", false, true) { private final BigInteger ZERO = BigInteger.ZERO; private final BigInteger ONE = BigInteger.ONE; private final BigInteger MINUSONE = ONE.negate(); public Object binaryForXIntegral(XBigInteger a, XBigInteger b) { BigInteger va = a.getValue(); BigInteger vb = b.getValue(); // special cases if (vb.equals(ZERO)) return new XBigInteger(ONE); int test = vb.compareTo(ZERO); if (va.equals(ZERO)) { if (test > 0) return new XBigInteger(ZERO); else return new XDouble(Double.NaN); } if (va.equals(ONE)) return new XBigInteger(ONE); if (va.equals(MINUSONE)) { int lowbit = vb.getLowestSetBit(); if (lowbit == 0) return new XBigInteger(MINUSONE); else return new XBigInteger(ONE); } // if vb is equivalent to a positive int exponent // then use the BigInteger pow function if (test > 0) { // get the associated exponent as an int int exponent = vb.intValue(); // prepare to test if vb equals exponent String bits = Integer.toBinaryString(exponent); BigInteger vc = new BigInteger(bits, 2); // if vb equals exponent use BigInteger pow if (vb.equals(vc)) { return new XBigInteger(va.pow(exponent)); } } // otherwise compute in double precision double vx = va.doubleValue(); double vy = vb.doubleValue(); return new XDouble(Math.pow(vx, vy)); } public Object binaryForXFloating(XDouble x, XDouble y) { double vx = x.getValue(); double vy = y.getValue(); return new XDouble(Math.pow(vx, vy)); } }; /** *BooleanOperation to implement equals.
* *Symbol: "==".
* *Binary. All types.
*/ public static final BooleanOperation operationEQ = new BooleanOperation("==", false, true, true) { public Object binaryForXBoolean(XBoolean p, XBoolean q) { boolean vp = p.getValue(); boolean vq = q.getValue(); return new XBoolean(vp == vq); } public Object binaryForXIntegral(XBigInteger a, XBigInteger b) { BigInteger va = a.getValue(); BigInteger vb = b.getValue(); int test = va.compareTo(vb); return new XBoolean(test == 0); } public Object binaryForXFloating(XDouble x, XDouble y) { double vx = x.getValue(); double vy = y.getValue(); return new XBoolean(vx == vy); } }; /** *BooleanOperation to implement not equals.
* *Symbol: "!=".
* *Binary. All types.
*/ public static final BooleanOperation operationNE = new BooleanOperation("!=", false, true, true) { public Object binaryForXBoolean(XBoolean p, XBoolean q) { boolean vp = p.getValue(); boolean vq = q.getValue(); return new XBoolean(vp != vq); } public Object binaryForXIntegral(XBigInteger a, XBigInteger b) { BigInteger va = a.getValue(); BigInteger vb = b.getValue(); int test = va.compareTo(vb); return new XBoolean(test != 0); } public Object binaryForXFloating(XDouble x, XDouble y) { double vx = x.getValue(); double vy = y.getValue(); return new XBoolean(vx != vy); } }; /** *BooleanOperation to implement less than.
* *Symbol: "<".
* *Binary. All types.
*/ public static final BooleanOperation operationLT = new BooleanOperation("<", false, true, true) { public Object binaryForXBoolean(XBoolean p, XBoolean q) { boolean vp = p.getValue(); boolean vq = q.getValue(); return new XBoolean(!vp && vq); } public Object binaryForXIntegral(XBigInteger a, XBigInteger b) { BigInteger va = a.getValue(); BigInteger vb = b.getValue(); int test = va.compareTo(vb); return new XBoolean(test < 0); } public Object binaryForXFloating(XDouble x, XDouble y) { double vx = x.getValue(); double vy = y.getValue(); return new XBoolean(vx < vy); } }; /** *BooleanOperation to implement greater than.
* *Symbol: ">".
* *Binary. All types.
*/ public static final BooleanOperation operationGT = new BooleanOperation(">", false, true, true) { public Object binaryForXBoolean(XBoolean p, XBoolean q) { boolean vp = p.getValue(); boolean vq = q.getValue(); return new XBoolean(vp && !vq); } public Object binaryForXIntegral(XBigInteger a, XBigInteger b) { BigInteger va = a.getValue(); BigInteger vb = b.getValue(); int test = va.compareTo(vb); return new XBoolean(test > 0); } public Object binaryForXFloating(XDouble x, XDouble y) { double vx = x.getValue(); double vy = y.getValue(); return new XBoolean(vx > vy); } }; /** *BooleanOperation to implement less than or equals.
* *Symbol: "<=".
* *Binary. All types.
*/ public static final BooleanOperation operationLE = new BooleanOperation("<=", false, true, true) { public Object binaryForXBoolean(XBoolean p, XBoolean q) { boolean vp = p.getValue(); boolean vq = q.getValue(); return new XBoolean(!vp || vq); } public Object binaryForXIntegral(XBigInteger a, XBigInteger b) { BigInteger va = a.getValue(); BigInteger vb = b.getValue(); int test = va.compareTo(vb); return new XBoolean(test <= 0); } public Object binaryForXFloating(XDouble x, XDouble y) { double vx = x.getValue(); double vy = y.getValue(); return new XBoolean(vx <= vy); } }; /** *BooleanOperation to implement greater than or equals.
* *Symbol: ">=".
* *Binary. All types.
*/ public static final BooleanOperation operationGE = new BooleanOperation(">=", false, true, true) { public Object binaryForXBoolean(XBoolean p, XBoolean q) { boolean vp = p.getValue(); boolean vq = q.getValue(); return new XBoolean(vp || !vq); } public Object binaryForXIntegral(XBigInteger a, XBigInteger b) { BigInteger va = a.getValue(); BigInteger vb = b.getValue(); int test = va.compareTo(vb); return new XBoolean(test >= 0); } public Object binaryForXFloating(XDouble x, XDouble y) { double vx = x.getValue(); double vy = y.getValue(); return new XBoolean(vx >= vy); } }; /** *BooleanOperation to implement "and".
* *Symbol: "&&".
* *Binary. Boolean only.
*/ public static final BooleanOperation operationAND = new BooleanOperation("&&", false, true, false) { public Object binaryForXBoolean(XBoolean p, XBoolean q) { boolean vp = p.getValue(); boolean vq = q.getValue(); return new XBoolean(vp && vq); } }; /** *BooleanOperation to implement "or".
* *Symbol: "||".
* *Binary. Boolean only.
*/ public static final BooleanOperation operationOR = new BooleanOperation("||", false, true, false) { public Object binaryForXBoolean(XBoolean p, XBoolean q) { boolean vp = p.getValue(); boolean vq = q.getValue(); return new XBoolean(vp || vq); } }; /** *BooleanOperation to implement "not".
* *Symbol: "!".
* *Binary. Boolean only.
*/ public static final BooleanOperation operationNOT = new BooleanOperation("!", true, false, false) { public Object unaryForXBoolean(XBoolean p) { boolean vp = p.getValue(); return new XBoolean(! vp); } }; ///////////// // Methods // ///////////// /** *Adds the standard constants for this parser * to the environment.
* *| Identifier | *Type | *Definition | *
true |
* XBoolean |
* true |
*
false |
* XBoolean |
* false |
*
pi |
* XDouble |
* Math.PI |
*
e |
* XDouble |
* Math.E |
*
MaxInt |
* XInt |
* Integer.MAX_VALUE |
*
maxint |
* XInt |
* Integer.MAX_VALUE |
*
MinInt |
* XInt |
* Integer.MIN_VALUE |
*
minint |
* XInt |
* Integer.MIN_VALUE |
*
MaxLong |
* XLong |
* Long.MAX_VALUE |
*
maxlong |
* XLong |
* Long.MAX_VALUE |
*
MinLong |
* XLong |
* Long.MIN_VALUE |
*
minlong |
* XLong |
* Long.MIN_VALUE |
*
MaxDouble |
* XDouble |
* Double.MAX_VALUE |
*
maxdouble |
* XDouble |
* Double.MAX_VALUE |
*
MinDouble |
* XDouble |
* Double.MIN_VALUE |
*
mindouble |
* XDouble |
* Double.MIN_VALUE |
*
Infinity |
* XDouble |
* Double.POSITIVE_INFINITY |
*
infinity |
* XDouble |
* Double.POSITIVE_INFINITY |
*
NaN |
* XDouble |
* Double.NaN |
*
nan |
* XDouble |
* Double.NaN |
*
Adds the standard functions for this parser * to the function table.
* *| Function Name | *Typical Usage | *
abs |
* abs(x) |
*
ceiling |
* ceiling(x) |
*
floor |
* floor(x) |
*
round |
* round(x) |
*
max |
* max(x,y) |
*
min |
* min(x,y) |
*
sqrt |
* sqrt(x) |
*
power |
* power(x,y) |
*
root |
* root(x,y) |
*
todegrees |
* todegrees(theta) |
*
toradians |
* toradians(angle) |
*
sin |
* sin(theta) |
*
sindeg |
* sindeg(angle) |
*
cos |
* cos(theta) |
*
cosdeg |
* cosdeg(angle) |
*
tan |
* tan(theta) |
*
tandeg |
* tandeg(angle) |
*
asin |
* asin(s) |
*
asindeg |
* asindeg(s) |
*
acos |
* acos(c) |
*
acosdeg |
* acosdeg(c) |
*
atan |
* atan(t) |
*
atandeg(t) |
* atandeg(t) |
*
atan2 |
* atan2(y,x) |
*
atan2deg |
* atan2deg(y,x) |
*
exp |
* exp(x) |
*
log |
* log(x) |
*
ln |
* ln(x) |
*
log2 |
* log2(x) |
*
log10 |
* log10(x) |
*
logtobase |
* logtobase(x,b) |
*
sinh |
* sinh(x) |
*
cosh |
* cosh(x) |
*
tanh |
* tanh(x) |
*
asinh |
* asinh(x) |
*
acosh |
* acosh(x) |
*
atanh |
* atanh(x) |
*
In the above table:
* x and y
* stand for generic variables;
* theta
* is an angle in radians;
* angle
* is an angle in degrees;
*
* s, c, t
* stand for possible values of
* sin, cos, tan;
* and b
* is the base for a logarithm.
In 2.5.0, random was removed from the
* list of functions because as implemented in the class
* AbstractFunction a function has a fixed
* number of arguments. Instead, random is
* now implemented directly in BaseParser
* to take one of three forms with the following
* interpretations.
| Function Name | *Typical Usage | *Interpretation | *
random |
* random() |
* Random number between 0 and 1 | *
random |
* random(x) |
* Random number between 0 and x | *
random |
* random(x,y) |
* Random number between x and y | *
Adds the standard operations for this parser * to the operation table.
* *Except for the introduction of the ^
* operation, follows Arnold, Gosling, Holmes:
The Java Programming Language, Third Edition, 6.10
* *| Precedence | *Operations | *Symbols | *
| 0 | *IDENTITY |
* None |
*
| 1 | *operationOR |
* || |
*
| 2 | *operationAND |
* && |
*
| 3 | *operationEQ |
* == |
*
| 4 | *operationLT |
* < |
*
| 5 | *operationPlus |
* + |
*
| 6 | *operationTimes |
* * |
*
| 7 | *operationCaret |
* ^ |
*
| 8 | *operationNOT |
* ! |
*