/** * Expression cloning. */ @Override protected Expression clone() { Expression newExp = new Expression(this); if ( (initialTokens != null) && (initialTokens.size() > 0) ) newExp.initialTokens = createInitialTokens(0, initialTokens.size()-1, initialTokens); return newExp; } }
@Override protected void testScenario() { Expression e = new Expression(""); for (int i = 0; i <= super.iterNum; i++) { if (mXparser.isCurrentCalculationCancelled()) break; e = new Expression("sin(2+(3*4)^2)/10"); } e.calculate(); } }
HeadEqBody(String definitionString) { char c; eqPos = 0; int matchStatus = mXparser.NOT_FOUND; definitionError = false; do { c = definitionString.charAt(eqPos); if (c == '=') matchStatus = mXparser.FOUND; else eqPos++; } while ( (eqPos < definitionString.length()) && (matchStatus == mXparser.NOT_FOUND) ); if ( (matchStatus == mXparser.FOUND) && (eqPos > 0) && (eqPos <= definitionString.length()-2) ) { headStr = definitionString.substring(0, eqPos); bodyStr = definitionString.substring(eqPos+1); Expression headExpression = new Expression(headStr, ONLY_PARSER_KEYWORDS); headTokens = headExpression.getCopyOfInitialTokens(); } else { definitionError = true; headStr = ""; bodyStr = ""; headTokens = null; eqPos = -1; } } }
/** * Constructor for function definition based on * your own source code - this is via implementation * of FunctionExtensionVariadic interface. * * @param functionName Function name * @param functionExtensionVariadic Your own source code */ public Function(String functionName, FunctionExtensionVariadic functionExtensionVariadic) { super(Function.TYPE_ID); if ( mXparser.regexMatch(functionName, ParserSymbol.nameOnlyTokenRegExp) ) { this.functionName = functionName; functionExpression = new Expression("{body-ext-var}"); isVariadic = true; parametersNumber = -1; description = ""; this.functionExtensionVariadic = functionExtensionVariadic; functionBodyType = BODY_EXTENDED; } else { parametersNumber = 0; description = ""; functionExpression = new Expression(""); functionExpression.setSyntaxStatus(SYNTAX_ERROR_OR_STATUS_UNKNOWN, "[" + functionName + "]" + "Invalid function name, pattern not matches: " + ParserSymbol.nameTokenRegExp); } } /**
@Override protected void testScenario() { Expression e = new Expression(test.exprStr); for (int i = 0; i <= super.iterNum; i++) { if (mXparser.isCurrentCalculationCancelled()) break; e.calculate(); } } }
/** * Constructor for function definition based on * your own source code - this is via implementation * of FunctionExtension interface. * * @param functionName Function name * @param functionExtension Your own source code */ public Function(String functionName, FunctionExtension functionExtension) { super(Function.TYPE_ID); if ( mXparser.regexMatch(functionName, ParserSymbol.nameOnlyTokenRegExp) ) { this.functionName = functionName; functionExpression = new Expression("{body-ext}"); isVariadic = false; parametersNumber = functionExtension.getParametersNumber(); description = ""; this.functionExtension = functionExtension; functionBodyType = BODY_EXTENDED; } else { parametersNumber = 0; description = ""; functionExpression = new Expression(""); functionExpression.setSyntaxStatus(SYNTAX_ERROR_OR_STATUS_UNKNOWN, "[" + functionName + "]" + "Invalid function name, pattern not matches: " + ParserSymbol.nameTokenRegExp); } } /**
/** * Constructor - creates dependent argument(with hidden * argument expression). * * @param argumentName the argument name * @param argumentExpressionString the argument expression string * @param elements Optional parameters (comma separated) * such as Arguments, Constants, Functions * * @see Expression * @see PrimitiveElement */ public Argument(String argumentName, String argumentExpressionString, PrimitiveElement... elements) { super(Argument.TYPE_ID); if ( mXparser.regexMatch(argumentName, ParserSymbol.nameOnlyTokenRegExp) ) { this.argumentName=new String(argumentName); argumentValue=ARGUMENT_INITIAL_VALUE; argumentExpression = new Expression(argumentExpressionString, elements); argumentExpression.setDescription(argumentName); argumentType = DEPENDENT_ARGUMENT; } else { this.argumentValue = ARGUMENT_INITIAL_VALUE; argumentExpression = new Expression(); argumentExpression.setSyntaxStatus(SYNTAX_ERROR_OR_STATUS_UNKNOWN, "[" + argumentName + "] " + "Invalid argument name, pattern not match: " + ParserSymbol.nameOnlyTokenRegExp); } setSilentMode(); description = ""; } /**
@Override protected void testScenario() { Expression e = new Expression(""); for (int i = 0; i <= super.iterNum; i++) { if (mXparser.isCurrentCalculationCancelled()) break; e.setExpressionString("sin(2+(3*4)^2)/10"); e.checkSyntax(); } } }
/** * Constructor - creates free argument. * * @param argumentName the argument name * @param argumentValue the argument value */ public Argument(String argumentName, double argumentValue) { super(Argument.TYPE_ID); argumentExpression = new Expression(); if ( mXparser.regexMatch(argumentName, ParserSymbol.nameOnlyTokenRegExp) ) { this.argumentName=new String(argumentName); this.argumentValue=argumentValue; argumentType = FREE_ARGUMENT; } else { this.argumentValue = ARGUMENT_INITIAL_VALUE; argumentExpression.setSyntaxStatus(SYNTAX_ERROR_OR_STATUS_UNKNOWN, "[" + argumentName + "] " + "Invalid argument name, pattern not match: " + ParserSymbol.nameOnlyTokenRegExp); } setSilentMode(); description = ""; } /**
if ( mXparser.regexMatch(functionName, ParserSymbol.nameOnlyTokenRegExp) ) { this.functionName = functionName; functionExpression = new Expression(functionExpressionString, elements); functionExpression.setDescription(functionName); functionExpression.UDFExpression = true; parametersNumber = 0; description = ""; functionExpression = new Expression(""); functionExpression.setSyntaxStatus(SYNTAX_ERROR_OR_STATUS_UNKNOWN, "[" + functionName + "]" + "Invalid function name, pattern not matches: " + ParserSymbol.nameTokenRegExp);
/** * Forward difference operator * * @param pos the token position */ private void FORWARD_DIFFERENCE(int pos) { List<FunctionParameter> params = getFunctionParameters(pos, tokensList); FunctionParameter funParam = params.get(0); FunctionParameter xParam = params.get(1); ArgumentParameter x = getParamArgument(xParam.paramStr); Expression funExp = new Expression(funParam.paramStr, funParam.tokens, argumentsList, functionsList, constantsList, DISABLE_ULP_ROUNDING, UDFExpression, UDFVariadicParamsAtRunTime); if (verboseMode == true) funExp.setVerboseMode(); double h = 1; if (params.size() == 3) { FunctionParameter hParam = params.get(2); Expression hExp = new Expression(hParam.paramStr, hParam.tokens, argumentsList, functionsList, constantsList, DISABLE_ULP_ROUNDING, UDFExpression, UDFVariadicParamsAtRunTime); if (verboseMode == true) hExp.setVerboseMode(); h = hExp.calculate(); } calcSetDecreaseRemove(pos, Calculus.forwardDifference(funExp, h, x.argument) ); clearParamArgument(x); } /**
iterParams.fromExp = new Expression(iterParams.fromParam.paramStr, iterParams.fromParam.tokens, argumentsList, functionsList, constantsList, KEEP_ULP_ROUNDING_SETTINGS, UDFExpression, UDFVariadicParamsAtRunTime); iterParams.toExp = new Expression(iterParams.toParam.paramStr, iterParams.toParam.tokens, argumentsList, functionsList, constantsList, KEEP_ULP_ROUNDING_SETTINGS, UDFExpression, UDFVariadicParamsAtRunTime); iterParams.funExp = new Expression(iterParams.funParam.paramStr, iterParams.funParam.tokens, argumentsList, functionsList, constantsList, DISABLE_ULP_ROUNDING, UDFExpression, UDFVariadicParamsAtRunTime); iterParams.deltaExp = null; if (verboseMode == true) { if (iterParams.to < iterParams.from) iterParams.delta = -1.0; if (iterParams.withDelta == true) { iterParams.deltaExp = new Expression(iterParams.deltaParam.paramStr, iterParams.deltaParam.tokens, argumentsList, functionsList, constantsList, DISABLE_ULP_ROUNDING, UDFExpression, UDFVariadicParamsAtRunTime); if (index.presence == Argument.NOT_FOUND) { updateMissingTokens(iterParams.deltaParam.tokens, iterParams.indexParam.paramStr, index.index, Argument.TYPE_ID );
/** * Backward diffrence operator * * @param pos the token position */ private void BACKWARD_DIFFERENCE(int pos) { List<FunctionParameter> params = getFunctionParameters(pos, tokensList); FunctionParameter funParam = params.get(0); FunctionParameter xParam = params.get(1); ArgumentParameter x = getParamArgument(xParam.paramStr); Expression funExp = new Expression(funParam.paramStr, funParam.tokens, argumentsList, functionsList, constantsList, DISABLE_ULP_ROUNDING, UDFExpression, UDFVariadicParamsAtRunTime); if (verboseMode == true) funExp.setVerboseMode(); double h = 1; if (params.size() == 3) { FunctionParameter hParam = params.get(2); Expression hExp = new Expression(hParam.paramStr, hParam.tokens, argumentsList, functionsList, constantsList, DISABLE_ULP_ROUNDING, UDFExpression, UDFVariadicParamsAtRunTime); if (verboseMode == true) hExp.setVerboseMode(); h = hExp.calculate(); } calcSetDecreaseRemove(pos, Calculus.backwardDifference(funExp, h, x.argument) ); clearParamArgument(x); } /**
@Override protected void testScenario() { Argument x = new Argument("x"); Expression e = new Expression(test.exprStr, x); for (int i = 0; i <= super.iterNum; i++) { if (mXparser.isCurrentCalculationCancelled()) break; x.setArgumentValue(i); e.calculate(); } } }
/** * IF function * * @param pos the token position */ private void IF_CONDITION(int pos) { /* * Get condition string * 1st parameter * The goal is to avoid calculation * of not needed part of IF function * Example: If(1=1, 2, sin(3) ) - here sin(3) does not * require to be calculated. */ List<FunctionParameter> ifParams = getFunctionParameters(pos, tokensList); FunctionParameter ifParam = ifParams.get(0); Expression ifExp = new Expression(ifParam.paramStr, ifParam.tokens, argumentsList, functionsList, constantsList, KEEP_ULP_ROUNDING_SETTINGS, UDFExpression, UDFVariadicParamsAtRunTime); if (verboseMode == true) ifExp.setVerboseMode(); ifSetRemove(pos, ifExp.calculate()); } /**
/** * Constructor for function definition in natural math language, * for instance providing on string "f(x,y) = sin(x) + cos(x)" * is enough to define function "f" with parameters "x and y" * and function body "sin(x) + cos(x)". * * @param constantDefinitionString Constant definition in the form * of one String, ie "c = 2" or "c = 2*sin(pi/3)" * @param elements Optional parameters (comma separated) such as Arguments, Constants, Functions */ public Constant(String constantDefinitionString, PrimitiveElement...elements) { super(Constant.TYPE_ID); description = ""; syntaxStatus = SYNTAX_ERROR_OR_STATUS_UNKNOWN; relatedExpressionsList = new ArrayList<Expression>(); if ( mXparser.regexMatch(constantDefinitionString, ParserSymbol.constUnitgDefStrRegExp) ) { HeadEqBody headEqBody = new HeadEqBody(constantDefinitionString); constantName = headEqBody.headTokens.get(0).tokenStr; Expression bodyExpression = new Expression(headEqBody.bodyStr, elements); constantValue = bodyExpression.calculate(); syntaxStatus = bodyExpression.getSyntaxStatus(); errorMessage = bodyExpression.getErrorMessage(); } else errorMessage = "[" + constantDefinitionString + "] " + "--> pattern not mathes: " + ParserSymbol.constUnitgDefStrRegExp; } /**
e = new Expression(expr); double d = e.calculate(); ans = new BigDecimal(d, MathContext.DECIMAL64);
if ( mXparser.regexMatch(functionName, ParserSymbol.nameOnlyTokenRegExp) ) { this.functionName = functionName; functionExpression = new Expression(functionExpressionString); functionExpression.setDescription(functionName); functionExpression.UDFExpression = true; parametersNumber = 0; description = ""; functionExpression = new Expression(""); functionExpression.setSyntaxStatus(SYNTAX_ERROR_OR_STATUS_UNKNOWN, "[" + functionName + "]" + "Invalid function name, pattern not matches: " + ParserSymbol.nameTokenRegExp);
super.argumentExpression.setDescription(argumentDefinitionString); } else { super.argumentExpression = new Expression(); super.argumentExpression.setSyntaxStatus(SYNTAX_ERROR_OR_STATUS_UNKNOWN, "[" + argumentDefinitionString + "] " + "Invalid argument definition (patterns: f(n) = f(n-1) ... ).");
@Override protected void testScenario() { Argument x = new Argument("x"); Argument y = new Argument("y"); Function f = new Function("f(x,y)=3*x+4*y"); Expression e = new Expression(test.exprStr, f, x, y); for (int i = 0; i <= super.iterNum; i++) { if (mXparser.isCurrentCalculationCancelled()) break; x.setArgumentValue(i); y.setArgumentValue(i); e.calculate(); } } }