Examples of evaluate()

• DSP.fft.RDFT.evaluate()
  Evaluates the DFT of a real sequence x. @param x double[] containing the real sequence in natural order. @param X double[] containing the transform of the sequence in conjugate symmetric packed form.
• DSP.filter.LagrangePolynomial.evaluate()
  Evaluates the Lagrange polynomial at real value xp. Evaluates the Lagrange polynomial using the barycentric formula. @param xp double containing the real value for evaluation of the polynomial. @return double containing the value of the polynomial at xp.
• aima.core.agent.impl.aprog.simplerule.Rule.evaluate()
• at.tuwien.minimee.migration.evaluators.IMinimeeEvaluator.evaluate()
• at.tuwien.minimee.migration.evaluators.ImageCompareEvaluator.evaluate()
• brickhouse.hbase.SaltedBigIntUDF.evaluate()
• brickhouse.udf.sketch.SetSimilarityUDF.evaluate()
• bunchbridge.BunchFitnessAdaptor.evaluate()
• ca.eandb.jmist.framework.Function1.evaluate()
  Evaluates the function at the specified point in its domain. @param x The value at which to evaluate the function. @return The value of the function (units definedby the concrete class).
• ca.eandb.jmist.framework.function.AXpBFunction1.evaluate()
• ca.eandb.jmist.framework.function.ConstantFunction1.evaluate()
• caltrop.interpreter.ExprEvaluator.evaluate()
• caltrop.interpreter.StmtEvaluator.evaluate()
• cc.mallet.cluster.evaluate.ClusteringEvaluator.evaluate()
  @param truth @param predicted @return A String summarizing the evaluation metric.
• cc.mallet.cluster.evaluate.ClusteringEvaluators.evaluate()
  @param truth @param predicted @return A String summarizing the evaluation metric.
• cc.mallet.extract.ExtractionEvaluator.evaluate()
• cc.mallet.fst.TokenAccuracyEvaluator.evaluate()
• cc.mallet.fst.TransducerEvaluator.evaluate()
  Evaluates a TransducerTrainer and its Transducer on the instance lists specified in the constructor. .

  The default implementation calls the evaluator's evaluateInstanceList on each instance list. @param tt The TransducerTrainer to evaluate.

• cc.mallet.grmm.learning.ACRFEvaluator.evaluate()
  Evalutes the model in the middle of training. @param acrf Model tha is being trained. @param iter How many iterations have been completed. @param training Training set. @param validation Validation set; may be null. @param testing Testing set; maybe null. @return Whether to continue training. If return is false, training should be be stopped.
• cc.plural.jsonij.jpath.functions.RegexFunction.evaluate()
• ch.idsia.ai.tasks.MultiDifficultyProgressTask.evaluate()
• ch.idsia.ai.tasks.MultiSeedProgressTask.evaluate()
• ch.idsia.ai.tasks.ProgressTask.evaluate()
• ch.idsia.ai.tasks.Task.evaluate()
• ch.idsia.tools.Evaluator.evaluate()
• ch.qos.logback.classic.boolex.JaninoEventEvaluator.evaluate()
• ch.qos.logback.core.boolex.EventEvaluator.evaluate()
  Evaluates whether the event passed as parameter matches this evaluator's matching criteria.

  The Evaluator instance is free to evaluate the event as it pleases. In particular, the evaluation results may depend on previous events. @param event The event to evaluate @return true if there is a match, false otherwise. @throws NullPointerException can be thrown in presence of null values @throws EvaluationException Thrown during evaluation

• com.CompPad.model.GroovyEngine.evaluate()
• com.adahas.tools.jmxeval.util.ExprEval.evaluate()
  Evaluates the expression and return the result @param expression Mathematical expression @return Result value
• com.alibaba.citrus.expr.Expression.evaluate()
  在指定的上下文中计算表达式。 @param context ExpressionContext上下文 @return 表达式的计算结果
• com.alibaba.fastjson.support.odps.udf.JSONArrayAdd.evaluate()
• com.alibaba.fastjson.support.odps.udf.JSONContains.evaluate()
• com.alibaba.fastjson.support.odps.udf.JSONContainsValue.evaluate()
• com.alibaba.fastjson.support.odps.udf.JSONExtract.evaluate()
• com.alibaba.fastjson.support.odps.udf.JSONSet.evaluate()
• com.alibaba.tamper.process.script.ScriptExecutor.evaluate()
  接受Map context上下文，执行script
• com.alibaba.toolkit.util.collection.Predicate.evaluate()
  ����ָ�����������, ����true��false. @param input ������� @return true��false
• com.antlersoft.query.SetExpression.evaluate()
• com.bazaarvoice.jolt.common.pathelement.DollarPathElement.evaluate()
• com.bazaarvoice.jolt.common.pathelement.EvaluatablePathElement.evaluate()
  Evaluate this key as if it is an write path element. @param walkedPath "up the tree" list of LiteralPathElements, that may be used by this key as it is computing @return String path element to use for write tree building
• com.cibuddy.core.build.configuration.IIndicatorBehaviorConfiguration.evaluate()
• com.clearnlp.component.evaluation.SRLEvalFull.evaluate()
• com.cloudera.cdk.data.PartitionExpression.evaluate()
• com.cloudera.cdk.morphline.scriptengine.java.ScriptEvaluator.evaluate()
• com.codingcrayons.aspectfaces.evaluation.Evaluator.evaluate()
• com.ecyrd.speed4j.util.Percentile.evaluate()
  Returns an estimate of the pth percentile of the values in the values array.

  Calls to this method do not modify the internal quantile state of this statistic.

  • Returns Double.NaN if values has length 0
  • Returns (for any value of p) values[0] if values has length 1
  • Throws IllegalArgumentException if values is null

  See {@link Percentile} for a description of the percentile estimationalgorithm used. @param values input array of values @param p the percentile value to compute @return the result of the evaluation or Double.NaN if the array is empty @throws IllegalArgumentException if values is null

• com.envoisolutions.sxc.xpath.XPathEvaluator.evaluate()
• com.espertech.esper.epl.expression.ExprEvaluator.evaluate()
  Evaluate event tuple and return result. @param eventsPerStream - event tuple @param isNewData - indicates whether we are dealing with new data (istream) or old data (rstream) @param context context for expression evaluation @return evaluation result, a boolean value for OR/AND-type evalution nodes.
• com.espertech.esper.epl.expression.ExprPreviousEvalStrategy.evaluate()
• com.espertech.esper.epl.expression.ExprPriorEvalStrategy.evaluate()
• com.espertech.esper.epl.subquery.SubselectAggregationPreprocessorBase.evaluate()
• com.esri.gpt.catalog.discovery.PropertyValueType.evaluate()
• com.eviware.soapui.impl.wsdl.teststeps.WsdlGotoTestStep.GotoCondition.evaluate()
• com.facebook.presto.sql.planner.ExpressionInterpreter.evaluate()
• com.floreysoft.jmte.token.ForEachToken.evaluate()
• com.floreysoft.jmte.token.IfCmpToken.evaluate()
• com.floreysoft.jmte.token.IfToken.evaluate()
• com.floreysoft.jmte.token.Token.evaluate()
• com.foundationdb.server.types.TCast.evaluate()
• com.foundationdb.server.types.texpressions.TEvaluatableExpression.evaluate()
• com.gentics.api.lib.expressionparser.EvaluableExpression.evaluate()
• com.github.sommeri.less4j.core.compiler.expressions.ExpressionEvaluator.evaluate()
• com.google.common.css.compiler.passes.BooleanExpressionEvaluator.evaluate()
• com.google.gwt.thirdparty.common.css.compiler.passes.BooleanExpressionEvaluator.evaluate()
• com.google.gxp.compiler.base.StringConstant.evaluate()
• com.google.javascript.rhino.JSTypeExpression.evaluate()
  Evaluates the type expression into a {@code JSType} object.
• com.google.refine.expr.Evaluable.evaluate()
  Evaluate this expression in the given environment (bindings). @param bindings @return
• com.google.sitebricks.Evaluator.evaluate()
• com.halware.nakedide.eclipse.ext.annot.mdd.MetadataDescriptor.evaluate()
• com.icl.saxon.expr.Expression.evaluate()
• com.jayway.jsonpath.internal.Path.evaluate()
  Evaluates this path @param document the json document to apply the path on @param rootDocument the root json document that started this evaluation @param configuration configuration to use @return EvaluationContext containing results of evaluation
• com.jayway.jsonpath.internal.token.PredicateContextImpl.evaluate()
• com.k_int.IR.SearchTask.evaluate()
• com.meidusa.amoeba.parser.expression.ColumnExpression.evaluate()
• com.meidusa.amoeba.parser.expression.Expression.evaluate()
  表达式计算
• com.meidusa.amoeba.sqljep.function.PostfixCommandI.evaluate()
  Run the function on the stack. Pops the arguments from the stack, and pushes the result on the top of the stack.
• com.mobixess.jodb.soda.api.Evaluation.evaluate()
  callback method during {@linkplain Query#execute query execution}. @param Candidate reference to the candidate persistent object.
• com.neemsoft.jmep.Expression.evaluate()
• com.opengamma.analytics.financial.covariance.CovarianceMatrixCalculator.evaluate()
  Calculates a covariance matrix given an array of time series. The ordering of the elements is determined by the order of the array @param x An array of {@link DoubleTimeSeries}, not null or empty @return The covariance matrix
• com.opengamma.analytics.financial.equity.capm.CAPMBetaCalculator.evaluate()
• com.opengamma.analytics.financial.interestrate.MultipleYieldCurveFinderIRSJacobian.evaluate()
• com.opengamma.analytics.financial.interestrate.MultipleYieldCurveFinderJacobian.evaluate()
• com.opengamma.analytics.financial.model.finitedifference.ExponentialMeshing.evaluate()
• com.opengamma.analytics.financial.model.finitedifference.HyperbolicMeshing.evaluate()
• com.opengamma.analytics.financial.model.finitedifference.MeshingFunction.evaluate()
• com.opengamma.analytics.financial.riskreward.JensenAlphaCalculator.evaluate()
  Calculates Jensen's alpha @param assetReturnTS The return time series of the asset @param riskFreeReturnTS The risk-free return series @param beta The beta of the asset to the market @param marketReturnTS The market return series @return The Jensen alpha
• com.opengamma.analytics.financial.riskreward.SharpeRatioCalculator.evaluate()
  Calculates the annualized Sharpe ratio @param ts An array of time series where the first element is the return of the asset and the second is the return of the benchmark @return The Sharpe ratio @throws IllegalArgumentException If the array is null, doesn't contain two elements or if either of the elements is null
• com.opengamma.analytics.financial.riskreward.TotalRiskAlphaCalculator.evaluate()
  Calculates the total risk alpha. @param assetReturnTS The return series of the asset @param riskFreeReturnTS The risk-free return series @param marketReturnTS The return series of the market @return The total risk alpha
• com.opengamma.analytics.financial.riskreward.TreynorRatioCalculator.evaluate()
  Calculates the Treynor ratio @param assetReturnTS The asset price time series @param riskFreeReturnTS The risk-free return time series @param beta The beta of the asset @return The Treynor ratio
• com.opengamma.analytics.financial.timeseries.analysis.AutocorrelationFunctionCalculator.evaluate()
• com.opengamma.analytics.financial.timeseries.analysis.AutocovarianceFunctionCalculator.evaluate()
• com.opengamma.analytics.financial.timeseries.returns.TimeSeriesReturnCalculator.evaluate()
• com.opengamma.analytics.financial.timeseries.util.TimeSeriesWeightedVolatilityOperator.evaluate()
• com.opengamma.analytics.math.curve.InterpolatedCurveShiftFunction.evaluate()
  {@inheritDoc}
• com.opengamma.analytics.math.function.DoubleFunction1D.evaluate()
• com.opengamma.analytics.math.function.PiecewisePolynomialFunction1D.evaluate()
  @param pp PiecewisePolynomialResult @param xKey @return Values of piecewise polynomial functions at xKey When _dim in PiecewisePolynomialResult is greater than 1, i.e., the struct contains multiple splines, an element in the return values corresponds to each spline
• com.opengamma.analytics.math.function.PiecewisePolynomialFunction2D.evaluate()
  @param pp PiecewisePolynomialResult2D @param x0Key @param x1Key @return Value of piecewise polynomial function in 2D at (x0Key, x1Key)
• com.opengamma.analytics.math.function.RealPolynomialFunction1D.evaluate()
• com.opengamma.analytics.math.linearalgebra.CholeskyDecompositionCommons.evaluate()
  {@inheritDoc}
• com.opengamma.analytics.math.linearalgebra.InverseTridiagonalMatrixCalculator.evaluate()
  {@inheritDoc}
• com.opengamma.analytics.math.linearalgebra.LUDecompositionCommons.evaluate()
  {@inheritDoc}
• com.opengamma.analytics.math.linearalgebra.QRDecompositionCommons.evaluate()
  {@inheritDoc}
• com.opengamma.analytics.math.linearalgebra.SVDecompositionCommons.evaluate()
  {@inheritDoc}
• com.opengamma.analytics.math.statistics.descriptive.MeanCalculator.evaluate()
  @param x The array of data, not null or empty @return The arithmetic mean
• com.opengamma.analytics.math.statistics.descriptive.MedianCalculator.evaluate()
  @param x The array of data, not null or empty @return The median
• com.opengamma.analytics.math.statistics.descriptive.ModeCalculator.evaluate()
  @param x The array of data, not null or empty @return The arithmetic mean
• com.opengamma.analytics.math.statistics.descriptive.PercentileCalculator.evaluate()
  @param x The data, not null or empty @return The percentile
• com.opengamma.analytics.math.statistics.descriptive.PopulationVarianceCalculator.evaluate()
  @param x The array of data, not null, must contain at least two elements @return The population variance
• com.opengamma.analytics.math.statistics.descriptive.SampleFisherKurtosisCalculator.evaluate()
  @param x The array of data, not null. Must contain at least four data points. @return The sample Fisher kurtosis
• com.opengamma.analytics.math.statistics.descriptive.SampleSkewnessCalculator.evaluate()
  @param x The array of data, not null, must contain at least three data points @return The sample skewness
• com.opengamma.analytics.math.statistics.descriptive.SampleStandardDeviationCalculator.evaluate()
  @param x The array of data, not null, must contain at least two data points @return The sample standard deviation
• com.opengamma.analytics.math.statistics.descriptive.SampleVarianceCalculator.evaluate()
  @param x The array of data, not null, must contain at least two elements @return The sample variance
• com.opengamma.analytics.math.surface.InterpolatedSurfaceAdditiveShiftFunction.evaluate()
  {@inheritDoc}
• com.opengamma.financial.expression.UserExpression.Evaluator.evaluate()
• com.orientechnologies.orient.core.sql.filter.OSQLFilterCondition.evaluate()
• com.orientechnologies.orient.core.sql.filter.OSQLPredicate.evaluate()
• com.projity.grouping.core.transform.filtering.NodeFilter.evaluate()
• com.projity.grouping.core.transform.transformer.NodeTransformer.evaluate()
• com.puppetlabs.geppetto.pp.dsl.linking.PPSearchPath.evaluate()
  Evaluates the search path by replacing every occurrence of '$environment' with the given value. @param environment @return a new PPSearchPath if there were replacements.
• com.salesforce.phoenix.expression.Expression.evaluate()
  Access the value by setting a pointer to it (as opposed to making a copy of it which can be expensive) @param tuple Single row result during scan iteration @param ptr Pointer to byte value being accessed @return true if the expression could be evaluated (i.e. ptr was set)and false otherwise
• com.salesforce.phoenix.expression.LikeExpression.evaluate()
• com.salesforce.phoenix.expression.StringConcatExpression.evaluate()
• com.scratchdisk.script.ScriptEngine.evaluate()
• com.sk89q.worldedit.internal.expression.Expression.evaluate()
• com.sk89q.worldedit.scripting.CraftScriptEngine.evaluate()
• com.softwaremill.common.cdi.el.ELEvaluator.evaluate()
• com.sonyericsson.hudson.plugins.metadata.search.antlr.QueryWalker.evaluate()
• com.starflow.wf.engine.core.expression.xpath.XPathBuilder.evaluate()
  Evaluates the given xpath using the provided body as a String return type. @param context the camel context @param body the body @return result of the evaluation
• com.sun.corba.se.spi.orbutil.closure.Closure.evaluate()
• com.sun.tools.corba.se.idl.constExpr.Expression.evaluate()
  Compute the value of this expression.
• com.sun.xacml.AbstractPolicy.evaluate()
  Tries to evaluate the policy by calling the combining algorithm on the given policies or rules. The match method must always be called first, and must always return MATCH, before this method is called. @param context the representation of the request @return the result of evaluation
• com.sun.xacml.PDP.evaluate()
  Attempts to evaluate the request against the policies known to this PDP. This is really the core method of the entire XACML specification, and for most people will provide what you want. If you need any special handling, you should look at the version of this method that takes an EvaluationCtx.

  Note that if the request is somehow invalid (it was missing a required attribute, it was using an unsupported scope, etc), then the result will be a decision of INDETERMINATE. @param request the request to evaluate @return a response paired to the request

• com.sun.xacml.Rule.evaluate()
  Evaluates the rule against the supplied context. This will check that the target matches, and then try to evaluate the condition. If the target and condition apply, then the rule's effect is returned in the result.

  Note that rules are not required to have targets. If no target is specified, then the rule inherits its parent's target. In the event that this Rule has no Target then the match is assumed to be true, since evaluating a policy tree to this level required the parent's target to match. @param context the representation of the request we're evaluating @return the result of the evaluation

• com.tinkerpop.rexster.protocol.session.AbstractRexProSession.evaluate()
• com.volantis.styling.expressions.StylingFunction.evaluate()
  Called when the function is referenced from inside a {@link StyleFunctionCall}. @param context The evaluation context within which the function isbeing invoked. @param name The name of the function being invoked. @param arguments The arguments for the function being invoked. @return The value of the function.
• com.volantis.styling.impl.expressions.Arguments.evaluate()
  Evaluate the arguments returning them as a list. @param context The context within which they are evaluated. @return The list of evaluated values.
• com.volantis.styling.impl.expressions.FunctionCall.evaluate()
• com.volantis.styling.impl.expressions.StyleCompiledExpression.evaluate()
• com.volantis.styling.impl.functions.CounterFunction.evaluate()
  Execute the counter() function.

  The expected style values passed by the caller are:

  1. A {@link StyleString} containing the counter name
  2. A {@link com.volantis.mcs.themes.StyleKeyword} specifying the listrendering style

  @param context The evaluation context @param functionName The name of the function being called @param styleValues The style value arguments to this function @return A StyleValue representing the value of the function
• com.volantis.styling.impl.functions.CountersFunction.evaluate()
  Execute the counters() function.

  The expected style values passed by the caller are:

  1. A {@link StyleIdentifier} containing the counter name
  2. A {@link StyleString} containing the separator for the counters
  3. A {@link StyleKeyword} specifying the listrendering style

  @param context The evaluation context @param functionName The name of the function being called @param styleValues The style value arguments to this function @return A StyleValue representing the value of the function
• com.volantis.xml.expression.Expression.evaluate()
  Evaluate the expression. @param context The context within which the expression is evaluated. @return The result of the expression. @throws ExpressionException An exception if the exception resulted in anerror.
• de.tuhrig.thofu.types.LList.evaluate()
• edu.isi.karma.mapreduce.function.CollectJSONObject.evaluate()
• edu.isi.karma.mapreduce.function.MergeJSON.evaluate()
• edu.isi.karma.modeling.alignment.learner.SortableSemanticModel.evaluate()
• edu.mit.simile.backstage.util.MyTupleQuery.evaluate()
• edu.pitt.dbmi.nlp.noble.ontology.ILogicExpression.evaluate()
  evaluate this expression against given object @param object @return true if object passes this expression, false otherwise
• edu.pitt.ontology.ILogicExpression.evaluate()
  evaluate this expression against given object @param object @return true if object passes this expression, false otherwise
• edu.stanford.nlp.ling.tokensregex.types.Expression.evaluate()
  Evaluates the expression using the specified environment and arguments. Arguments are additional context not provided by the environment. @param env @param args @return Evaluated value
• edu.stanford.nlp.parser.metrics.AbstractEval.evaluate()
• edu.stanford.nlp.parser.metrics.Evalb.evaluate()
• edu.stanford.nlp.parser.metrics.TaggingEval.evaluate()
• edu.stanford.nlp.parser.metrics.UnlabeledAttachmentEval.evaluate()
• eu.admire.dispel.parser.expression.Tuple.evaluate()
• eu.bitfish.jcf.common.expression.AbstractExpression.evaluate()
  Evaluate an expression with the given object. @param obj The object on which the expression should be evaluated @return True if the object meets the criteria given in the expression @throws FilterException Thrown on any errors during evaluation
• flex2.compiler.as3.binding.TypeAnalyzer.evaluate()
  Currently only used for SkinParts. When metadata with the id SkinPart is found it gets added to the ClassInfo instance. @param cx The current context @param node The current metadata node
• gov.nasa.arc.mct.evaluator.api.Evaluator.evaluate()
• gov.nasa.arc.mct.evaluator.api.Executor.evaluate()
  Execute the evaluator with the given data values. The caller is responsible for ensuring the required set of values is available for evaluation. The children of the evaluator represent a super set of required feed values. @param data feed data that should be evaluated (this is the same structure that is provided in{@link gov.nasa.arc.mct.gui.FeedView#updateFromFeed(Map)}; however, the only property guaranteed to be available is {@link gov.nasa.arc.mct.components.FeedProvider#NORMALIZED_VALUE_KEY}. @param providers to be used when interacting with the feed, this can be used to change the parameters to be used (using a supplemental identification); however, when invoking this method the general approach should use the model children @return value from executing the evaluator
• gov.nasa.arc.mct.evaluator.enums.EnumEvaluator.evaluate()
  Evaluates the expression value. @param val the value. @return the calculated evaluation.
• gov.nist.scap.cpe.language.eval.CPEEvaluator.evaluate()
• gov.nist.scap.cpe.language.eval.CPEEvaluatorImpl.evaluate()
• grails.validation.ConstraintsEvaluator.evaluate()
  Evaluate constraints for the given class @param cls The class to evaluate constraints for @return A map of constrained properties
• groovy.lang.GroovyShell.evaluate()
  Evaluates some script against the current Binding and returns the result @param codeSource @throws CompilationFailedException
• groovy.lang.Script.evaluate()
  A helper method to allow the dynamic evaluation of groovy expressions using this scripts binding as the variable scope @param expression is the Groovy script expression to evaluate
• hivemall.knn.distance.PopcountUDF.evaluate()
• hivemall.knn.lsh.MinHashesUDF.evaluate()
• httl.Template.evaluate()
  Evaluate the template.

   Map<String, Object> map = new HashMap<String, Object>(); map.put("foo", foo); Object result = template.evaluate(map); 

  @see httl.Context @see httl.spi.Converter @param map - evaluate variables map @return evaluate result (string or byte[]) @throws ParseException - If the expression cannot be parsed on runtime
• hudson.plugins.emailext.plugins.content.FailedTestsContent.evaluate()
• hudson.plugins.emailext.plugins.content.JellyScriptContent.evaluate()
• hudson.plugins.emailext.plugins.content.ScriptContent.evaluate()
• info.bliki.wiki.template.expr.eval.DoubleEvaluator.evaluate()
  Parse the given expression String and evaluate it to a double value @param expression @return @throws SyntaxError
• interfaces.IRouge.evaluate()
  Method runs the evaluation and returns the resulting score @return The score
• javarepl.Evaluator.evaluate()
• javax.servlet.jsp.el.Expression.evaluate()
  Evaluates the expression.
• javax.servlet.jsp.el.ExpressionEvaluator.evaluate()
  Evaluates an expression. This method may perform some syntactic validation and, if so, it should raise an ELParseException error if it encounters syntactic errors. EL evaluation errors should cause an ELException to be raised. @param expression The expression to be evaluated. @param expectedType The expected type of the result of the evaluation @param vResolver A VariableResolver instance that can be used at runtime to resolve the name of implicit objects into Objects. @param fMapper A FunctionMapper to resolve functions found in the expression. It can be null, in which case no functions are supported for this invocation. @return The result of the expression evaluation. @exception ELException Thrown if the expression evaluation failed.
• javax.xml.xpath.XPath.evaluate()

  Evaluate an XPath expression in the specified context and return the result as the specified type.

  See Evaluation of XPath Expressions for context item evaluation, variable, function and QName resolution and return type conversion.

  If returnType is not one of the types defined in {@link XPathConstants} ({@link XPathConstants#NUMBER NUMBER}, {@link XPathConstants#STRING STRING}, {@link XPathConstants#BOOLEAN BOOLEAN}, {@link XPathConstants#NODE NODE} or{@link XPathConstants#NODESET NODESET}) then an IllegalArgumentException is thrown.

  If a null value is provided for item, an empty document will be used for the context. If expression or returnType is null, then a NullPointerException is thrown.

  @param expression The XPath expression. @param item The starting context (node or node list, for example). @param returnType The desired return type. @return Result of evaluating an XPath expression as an Object of returnType. @throws XPathExpressionException If expression cannot be evaluated. @throws IllegalArgumentException If returnType is not one of the types defined in {@link XPathConstants}. @throws NullPointerException If expression or returnType is null.
• javax.xml.xpath.XPathExpression.evaluate()

  Evaluate the compiled XPath expression in the specified context and return the result as the specified type.

  See Evaluation of XPath Expressions for context item evaluation, variable, function and QName resolution and return type conversion.

  If returnType is not one of the types defined in {@link XPathConstants}, then an IllegalArgumentException is thrown.

  If a null value is provided for item, an empty document will be used for the context. If returnType is null, then a NullPointerException is thrown.

  @param item The starting context (node or node list, for example). @param returnType The desired return type. @return The Object that is the result of evaluating the expression and converting the result toreturnType. @throws XPathExpressionException If the expression cannot be evaluated. @throws IllegalArgumentException If returnType is not one of the types defined in {@link XPathConstants}. @throws NullPointerException If returnType is null.
• javax.xml.xpath.XPathFunction.evaluate()

  Evaluate the function with the specified arguments.

  To the greatest extent possible, side-effects should be avoided in the definition of extension functions. The implementation evaluating an XPath expression is under no obligation to call extension functions in any particular order or any particular number of times.

  @param args The arguments, null is a valid value. @return The result of evaluating the XPath function as an Object. @throws XPathFunctionException If args cannot be evaluated with this XPath function.
• jbprocess.bpel.xpath.XpathBinaryOpExpression.evaluate()
• jmathexpr.Expression.evaluate()
  Tries to evaluate the expression. @return the evaluated expression
• jmathexpr.Variable.evaluate()
• jmathexpr.arithmetic.func.Exp.evaluate()
• jmathexpr.arithmetic.func.Log.evaluate()
• jmathexpr.arithmetic.func.Sqrt.evaluate()
• jmathexpr.arithmetic.op.Addition.evaluate()
• jmathexpr.arithmetic.op.Division.evaluate()
• jmathexpr.arithmetic.op.Exponentiation.evaluate()
• jmathexpr.arithmetic.op.Multiplication.evaluate()
• jmathexpr.arithmetic.op.Negation.evaluate()
• jmathexpr.arithmetic.op.Subtraction.evaluate()
• jmathexpr.arithmetic.rational.RationalNumber.evaluate()
• jmathexpr.arithmetic.rational.impl.LongRationalNumber.evaluate()
• jmathexpr.func.Function.evaluate()
• jmathexpr.relation.Equality.evaluate()
• jmathexpr.set.ElementOf.evaluate()
• joust.utils.tree.evaluation.EvaluationContext.evaluate()
  Evaluate statements.
• jsonij.json.jpath.functions.RegexFunction.evaluate()
• lotus.domino.Session.evaluate()
• lupos.rif.IExpression.evaluate()
• macromedia.asc.parser.MetaDataNode.evaluate()
• macromedia.asc.parser.Node.evaluate()
• macromedia.asc.parser.ProgramNode.evaluate()
• mage.player.ai.PermanentEvaluator.evaluate()
• mage.player.ai.simulators.CombatSimulator.evaluate()
• mil.nga.giat.geowave.analytics.mapreduce.kde.parser.CustomFunction.evaluate()
• mil.nga.giat.geowave.analytics.mapreduce.kde.parser.Expression.evaluate()
• mmrnmhrm.ui.text.FullPatternRule.evaluate()
• mondrian.calc.Calc.evaluate()
  Evaluates this expression. @param evaluator Provides dimensional context in which to evaluatethis expression @return Result of expression evaluation
• mondrian.rolap.StarColumnPredicate.evaluate()
  Returns whether this constraint would return true for a given value. @param value Value @return Whether predicate is true
• net.fortytwo.ripple.model.RippleValue.evaluate()
• net.gouline.riskybusiness.RiskEvaluator.evaluate()
• net.lagerwey.xml.xpath.XPath.evaluate()
• net.nutch.util.CommandRunner.evaluate()
• net.quenchnetworks.sassybarista.sass.eval.SassSheetEvaluator.evaluate()
• net.sf.doodleproject.numerics4j.continuedfraction.ContinuedFraction.evaluate()
  Evaluate this continued fraction at the given value. @param x the point of evalutation. @return the value of this continued fraction evaluated at x. @throws NumericException if the continued fraction could not beevaluated.
• net.sf.doodleproject.numerics4j.series.Series.evaluate()
  Evaluate this series at the given value. @param x the point of evalutation. @return the value of this series evaluated at x. @throws NumericException if the series could not be evaluated.
• net.sf.jmd.evaluation.IComparator.evaluate()
• net.sf.jmd.evaluation.impl.Comparator.evaluate()
  Evaluates all known Checks in the order they have been added.
• net.sf.jxls.parser.Expression.evaluate()
• net.sf.laja.context.Context.evaluate()
• net.sf.laja.template.Evaluator.evaluate()
• net.sf.laja.template.data.Data.evaluate()
• net.sf.saxon.query.XQueryExpression.evaluate()
  Execute a the compiled Query, returning the results as a List. @param env Provides the dynamic query evaluation context @return The results of the expression, as a List. The List represents the sequenceof items returned by the expression. Each item in the list will either be an object representing a node, or an object representing an atomic value. For the types of Java object that may be returned, see the description of the {@link net.sf.saxon.xpath.XPathEvaluator#evaluate evaluate} methodof class XPathProcessor
• net.sf.saxon.s9api.XPathSelector.evaluate()
  Evaluate the expression, returning the result as an XdmValue (that is, a sequence of nodes and/or atomic values).

  Note: Although a singleton result may be represented as an XdmItem, there is no guarantee that this will always be the case. If you know that the expression will return at most one node or atomic value, it is best to use the evaluateSingle method, which does guarantee that an XdmItem (or null) will be returned.

  @return An XdmValue representing the results of the expression. @throws SaxonApiException if a dynamic error occurs during the expression evaluation.
• net.sf.saxon.s9api.XQueryEvaluator.evaluate()
  Perform the query, returning the results as an XdmValue. This method must not be used with an updating query @return an XdmValue representing the results of the query @throws SaxonApiException if the query fails with a dynamic error @throws IllegalStateException if this is an updating query
• net.sf.saxon.sxpath.XPathExpression.evaluate()
  Execute the expression, returning the result as a List, whose members will be instances of the class {@link net.sf.saxon.om.Item} @param context the XPath dynamic context @return a list of items representing the result of the expression
• net.sf.saxon.xpath.XPathEvaluator.evaluate()
  Prepare and execute an XPath expression, supplied as a string, and returning the results as a List. @param expression The XPath expression to be evaluated, supplied as a string. @return The results of the expression, as a List. The List represents the sequenceof items returned by the expression. Each item in the list will either be an object representing a node, or a Java object representing an atomic value. The types of Java object that may be included in the list, and the XML Schema data types that they correspond to, are as follows:

  • Boolean (xs:boolean)
  • String (xs:string)
  • BigDecimal (xs:decimal)
  • Long (xs:integer and its derived types)
  • Double (xs:double)
  • Float (xs:float)
  • Date (xs:date, xs:dateTime)

  @deprecated since Saxon 8.9 - use the various method defined in the JAXP interface definition
• net.sourceforge.jFuzzyLogic.FIS.evaluate()
  Evaluate fuzzy rules in first function block
• net.sourceforge.jFuzzyLogic.FunctionBlock.evaluate()
  Evaluate fuzzy rules in this function block
• net.sourceforge.jFuzzyLogic.rule.FuzzyRuleSet.evaluate()
  Evaluate fuzzy rule set
• net.sourceforge.temply.base.rules.TemplyFunction.evaluate()
• opennlp.tools.chunker.ChunkerCrossValidator.evaluate()
  Starts the evaluation. @param samples the data to train and test @param nFolds number of folds @throws IOException
• opennlp.tools.chunker.ChunkerEvaluator.evaluate()
• opennlp.tools.doccat.DoccatCrossValidator.evaluate()
  Starts the evaluation. @param samples the data to train and test @param nFolds number of folds @throws IOException
• opennlp.tools.doccat.DocumentCategorizerEvaluator.evaluate()
  Reads all {@link DocumentSample} objects from the streamand evaluates each {@link DocumentSample} object with{@link #evaluteSample(DocumentSample)} method. @param samples the stream of reference {@link POSSample} whichshould be evaluated.
• opennlp.tools.namefind.TokenNameFinderCrossValidator.evaluate()
  Starts the evaluation. @param samples the data to train and test @param nFolds number of folds @throws IOException
• opennlp.tools.namefind.TokenNameFinderEvaluator.evaluate()
• opennlp.tools.parser.ParserEvaluator.evaluate()
• opennlp.tools.postag.POSEvaluator.evaluate()
• opennlp.tools.postag.POSTaggerCrossValidator.evaluate()
  Starts the evaluation. @param samples the data to train and test @param nFolds number of folds @throws IOException
• opennlp.tools.sentdetect.SDCrossValidator.evaluate()
  Starts the evaluation. @param samples the data to train and test @param nFolds number of folds @throws IOException
• opennlp.tools.sentdetect.SentenceDetectorEvaluator.evaluate()
• opennlp.tools.tokenize.TokenizerCrossValidator.evaluate()
  Starts the evaluation. @param samples the data to train and test @param nFolds number of folds @throws IOException
• opennlp.tools.tokenize.TokenizerEvaluator.evaluate()
• org.activiti.engine.impl.Condition.evaluate()
• org.activiti.engine.impl.scripting.ScriptingEngines.evaluate()
• org.apache.abdera.xpath.XPath.evaluate()
  Evaluate the specified XPath and return it's value
• org.apache.accumulo.core.security.VisibilityEvaluator.evaluate()
• org.apache.activemq.filter.PropertyExpression.evaluate()
• org.apache.ambari.server.controller.spi.Predicate.evaluate()
  Evaluate the predicate for the given resource. @param resource the resource to evaluate the predicate against @return the result of applying the predicate to the given resource
• org.apache.archiva.consumers.functors.ConsumerWantsFilePredicate.evaluate()
• org.apache.axiom.om.xpath.AXIOMXPath.evaluate()
• org.apache.batik.script.Interpreter.evaluate()
  This method should evaluate a piece of script. @param scriptreader a java.io.Reader on the piece of script @return if no exception is thrown during the call, should return thevalue of the last expression evaluated in the script
• org.apache.beehive.netui.script.el.ParsedExpression.evaluate()
• org.apache.camel.Expression.evaluate()
  Returns the value of the expression on the given exchange @param exchange the message exchange on which to evaluate the expression @return the value of the expression
• org.apache.camel.builder.ExpressionClause.evaluate()
• org.apache.camel.builder.xml.XPathBuilder.evaluate()
• org.apache.cayenne.exp.Expression.evaluate()
  Calculates expression value with object as a context for path expressions. @since 1.1
• org.apache.cocoon.el.Expression.evaluate()
• org.apache.commons.betwixt.expression.Expression.evaluate()
  Evaluates the expression on the bean with the given context and returns the result @param context evaluate against this Context @return the value of the expression
• org.apache.commons.collections.Predicate.evaluate()
  @return true if the input object matches this predicate, else returns false
• org.apache.commons.el.Expression.evaluate()
  Evaluates the expression in the given context
• org.apache.commons.el.ExpressionEvaluatorImpl.evaluate()
  Evaluates the given expression String @param pExpressionString The expression to be evaluated. @param pExpectedType The expected type of the result of the evaluation @param pResolver A VariableResolver instance that can be used at runtime to resolve the name of implicit objects into Objects. @param functions A FunctionMapper to resolve functions found in the expression. It can be null, in which case no functions are supported for this invocation. @return the expression String evaluated to the given expectedtype
• org.apache.commons.el.ValueSuffix.evaluate()
  Evaluates the expression in the given context, operating on the given value.
• org.apache.commons.jelly.expression.Expression.evaluate()
  Evaluates the expression with the given context and returns the result
• org.apache.commons.jexl.Expression.evaluate()
  Evaluates the expression with the variables contained in the supplied {@link JexlContext}. @param context A JexlContext containing variables. @return The result of this evaluation @throws Exception on any error
• org.apache.commons.jexl2.Expression.evaluate()
  Evaluates the expression with the variables contained in the supplied {@link JexlContext}. @param context A JexlContext containing variables. @return The result of this evaluation @throws JexlException on any error
• org.apache.commons.jxpath.CompiledExpression.evaluate()
• org.apache.commons.math.stat.descriptive.UnivariateStatistic.evaluate()
  Returns the result of evaluating the statistic over the input array. @param values input array @return the value of the statistic applied to the input array
• org.apache.commons.math.stat.descriptive.moment.Mean.evaluate()
  Returns the arithmetic mean of the entries in the specified portion of the input array, or Double.NaN if the designated subarray is empty.

  Throws IllegalArgumentException if the array is null.

  See {@link Mean} for details on the computing algorithm.

  @param values the input array @param begin index of the first array element to include @param length the number of elements to include @return the mean of the values or Double.NaN if length = 0 @throws IllegalArgumentException if the array is null or the array indexparameters are not valid
• org.apache.commons.math.stat.descriptive.moment.StandardDeviation.evaluate()
  Returns the Standard Deviation of the entries in the input array, or Double.NaN if the array is empty.

  Returns 0 for a single-value (i.e. length = 1) sample.

  Throws IllegalArgumentException if the array is null.

  Does not change the internal state of the statistic.

  @param values the input array @return the standard deviation of the values or Double.NaN if length = 0 @throws IllegalArgumentException if the array is null
• org.apache.commons.math.stat.descriptive.moment.Variance.evaluate()
  Returns the variance of the entries in the input array, or Double.NaN if the array is empty.

  See {@link Variance} for details on the computing algorithm.

  Returns 0 for a single-value (i.e. length = 1) sample.

  Throws IllegalArgumentException if the array is null.

  Does not change the internal state of the statistic.

  @param values the input array @return the variance of the values or Double.NaN if length = 0 @throws IllegalArgumentException if the array is null
• org.apache.commons.math.stat.descriptive.rank.Median.evaluate()
• org.apache.commons.math.stat.descriptive.rank.Min.evaluate()
  Returns the minimum of the entries in the specified portion of the input array, or Double.NaN if the designated subarray is empty.

  Throws IllegalArgumentException if the array is null or the array index parameters are not valid.

  • The result is NaN iff all values are NaN (i.e. NaN values have no impact on the value of the statistic).
  • If any of the values equals Double.NEGATIVE_INFINITY, the result is Double.NEGATIVE_INFINITY.

  @param values the input array @param begin index of the first array element to include @param length the number of elements to include @return the minimum of the values or Double.NaN if length = 0 @throws IllegalArgumentException if the array is null or the array indexparameters are not valid
• org.apache.commons.math.stat.descriptive.rank.Percentile.evaluate()
  Returns the result of evaluating the statistic over the stored data.

  The stored array is the one which was set by previous calls to

  @param p the percentile value to compute @return the value of the statistic applied to the stored data
• org.apache.commons.math.stat.descriptive.summary.Sum.evaluate()
  The sum of the entries in the specified portion of the input array, or Double.NaN if the designated subarray is empty.

  Throws IllegalArgumentException if the array is null.

  @param values the input array @param begin index of the first array element to include @param length the number of elements to include @return the sum of the values or Double.NaN if length = 0 @throws IllegalArgumentException if the array is null or the array indexparameters are not valid
• org.apache.commons.math.util.ContinuedFraction.evaluate()
  Evaluates the continued fraction at the value x. @param x the evaluation point. @return the value of the continued fraction evaluated at x. @throws MathException if the algorithm fails to converge.
• org.apache.commons.math3.stat.descriptive.UnivariateStatistic.evaluate()
  Returns the result of evaluating the statistic over the input array. @param values input array @return the value of the statistic applied to the input array @throws MathIllegalArgumentException if values is null
• org.apache.commons.math3.stat.descriptive.moment.Mean.evaluate()
  Returns the arithmetic mean of the entries in the specified portion of the input array, or Double.NaN if the designated subarray is empty.

  Throws IllegalArgumentException if the array is null.

  See {@link Mean} for details on the computing algorithm.

  @param values the input array @param begin index of the first array element to include @param length the number of elements to include @return the mean of the values or Double.NaN if length = 0 @throws MathIllegalArgumentException if the array is null or the array indexparameters are not valid
• org.apache.commons.math3.stat.descriptive.moment.StandardDeviation.evaluate()
  Returns the Standard Deviation of the entries in the input array, or Double.NaN if the array is empty.

  Returns 0 for a single-value (i.e. length = 1) sample.

  Throws MathIllegalArgumentException if the array is null.

  Does not change the internal state of the statistic.

  @param values the input array @return the standard deviation of the values or Double.NaN if length = 0 @throws MathIllegalArgumentException if the array is null
• org.apache.commons.math3.stat.descriptive.moment.Variance.evaluate()
  Returns the variance of the entries in the input array, or Double.NaN if the array is empty.

  See {@link Variance} for details on the computing algorithm.

  Returns 0 for a single-value (i.e. length = 1) sample.

  Throws MathIllegalArgumentException if the array is null.

  Does not change the internal state of the statistic.

  @param values the input array @return the variance of the values or Double.NaN if length = 0 @throws MathIllegalArgumentException if the array is null
• org.apache.commons.math3.stat.descriptive.rank.Median.evaluate()
  Returns the result of evaluating the statistic over the input array, using the supplied weights. @param values input array @param weights array of weights @return the value of the weighted statistic applied to the input array @throws MathIllegalArgumentException if either array is null, lengthsdo not match, weights contain NaN, negative or infinite values, or weights does not include at least on positive value
• org.apache.commons.math3.stat.descriptive.rank.Percentile.evaluate()
  Returns the result of evaluating the statistic over the stored data.

  The stored array is the one which was set by previous calls to

  @param p the percentile value to compute @return the value of the statistic applied to the stored data
• org.apache.commons.math3.stat.descriptive.summary.Sum.evaluate()
  The sum of the entries in the specified portion of the input array, or 0 if the designated subarray is empty.

  Throws MathIllegalArgumentException if the array is null.

  @param values the input array @param begin index of the first array element to include @param length the number of elements to include @return the sum of the values or 0 if length = 0 @throws MathIllegalArgumentException if the array is null or the array indexparameters are not valid
• org.apache.commons.math3.util.ContinuedFraction.evaluate()
  Evaluates the continued fraction at the value x. @param x the evaluation point. @return the value of the continued fraction evaluated at x. @throws ConvergenceException if the algorithm fails to converge.
• org.apache.ddlutils.util.MultiInstanceofPredicate.evaluate()
  {@inheritDoc}
• org.apache.deltaspike.core.impl.interpreter.PropertyExpressionInterpreter.evaluate()
• org.apache.directory.server.core.api.subtree.SubtreeEvaluator.evaluate()
  Determines if an entry is selected by a subtree specification. @param subtree the subtree specification @param apDn the distinguished name of the administrative point containing the subentry @param entryDn the distinguished name of the candidate entry @return true if the entry is selected by the specification, false if it is not @throws LdapException if errors are encountered while evaluating selection
• org.apache.directory.server.xdbm.search.Evaluator.evaluate()
  Evaluates a candidate to determine if a filter expression selects it. If an IndexEntry does has a null reference to the entry object, this Evaluator may set it if it has to access the full entry within the master table of the store. Subsequent evaluations on the IndexEntry then need not access the store to retreive the entry if they need to access it's attributes. @param entry the index record of the entry to evaluate @return true if filter selects the candidate false otherwise @throws Exception if there are faults during evaluation
• org.apache.directory.server.xdbm.search.evaluator.GreaterEqEvaluator.evaluate()
• org.apache.directory.server.xdbm.search.evaluator.LessEqEvaluator.evaluate()
• org.apache.directory.server.xdbm.search.evaluator.PresenceEvaluator.evaluate()
• org.apache.directory.server.xdbm.search.evaluator.SubstringEvaluator.evaluate()
• org.apache.expreval.expr.ExpressionTree.evaluate()
• org.apache.falcon.expression.ExpressionHelper.evaluate()
• org.apache.flex.forks.batik.script.Interpreter.evaluate()
  This method should evaluate a piece of script associated to a given description. @param scriptreader a java.io.Reader on the piece of script @param description description which can be later used (e.g., for error messages). @return if no exception is thrown during the call, should return thevalue of the last expression evaluated in the script
• org.apache.flex.forks.velocity.app.VelocityEngine.evaluate()
  renders the input string using the context into the output writer. To be used when a template is dynamically constructed, or want to use Velocity as a token replacer. @param context context to use in rendering input string @param out Writer in which to render the output @param logTag string to be used as the template name for log messages in case of error @param instring input string containing the VTL to be rendered @return true if successful, false otherwise. If false, seeVelocity runtime log
• org.apache.hadoop.hive.ql.exec.ExprNodeConstantEvaluator.evaluate()
• org.apache.hadoop.hive.ql.exec.ExprNodeEvaluator.evaluate()
  Evaluate the expression given the row. This method should use the rowInspector passed in from initialize to inspect the row object. The return value will be inspected by the return value of initialize.
• org.apache.hadoop.hive.ql.exec.vector.expressions.IfExprStringColumnStringColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.IfExprStringColumnStringScalar.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.IfExprStringGroupColumnStringGroupColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.IfExprStringGroupColumnStringScalar.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.IfExprStringScalarStringColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.IfExprStringScalarStringGroupColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.IfExprStringScalarStringScalar.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.DecimalColAddDecimalColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.DecimalColAddDecimalScalar.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.DecimalColDivideDecimalColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.DecimalColDivideDecimalScalar.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.DecimalColModuloDecimalColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.DecimalColModuloDecimalScalar.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.DecimalColMultiplyDecimalColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.DecimalColMultiplyDecimalScalar.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.DecimalColSubtractDecimalColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.DecimalColSubtractDecimalScalar.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.DecimalScalarAddDecimalColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.DecimalScalarDivideDecimalColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.DecimalScalarModuloDecimalColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.DecimalScalarMultiplyDecimalColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.DecimalScalarSubtractDecimalColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterDecimalColEqualDecimalColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterDecimalColEqualDecimalScalar.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterDecimalColGreaterEqualDecimalColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterDecimalColLessDecimalScalar.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterDecimalScalarEqualDecimalColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterDecimalScalarGreaterDecimalColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterDoubleColumnBetween.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterDoubleColumnNotBetween.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterLongColEqualLongScalar.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterLongColGreaterLongColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterLongColGreaterLongScalar.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterLongColLessLongColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterLongColumnBetween.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterLongColumnNotBetween.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterLongScalarGreaterLongColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterLongScalarLessLongColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterStringColumnBetween.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterStringColumnNotBetween.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FuncACosDoubleToDouble.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FuncASinDoubleToDouble.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FuncATanDoubleToDouble.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FuncAbsDoubleToDouble.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FuncCeilDoubleToLong.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FuncCosDoubleToDouble.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FuncDegreesDoubleToDouble.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FuncExpDoubleToDouble.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FuncFloorDoubleToLong.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FuncLnDoubleToDouble.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FuncLog10DoubleToDouble.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FuncLog2DoubleToDouble.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FuncRadiansDoubleToDouble.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FuncRoundDoubleToDouble.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FuncSignDoubleToDouble.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FuncSinDoubleToDouble.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FuncSqrtDoubleToDouble.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FuncTanDoubleToDouble.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.IfExprDoubleColumnDoubleColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.IfExprDoubleColumnDoubleScalar.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.IfExprDoubleScalarDoubleColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.IfExprDoubleScalarDoubleScalar.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.IfExprLongColumnLongColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.IfExprLongColumnLongScalar.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.IfExprLongScalarLongColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.IfExprLongScalarLongScalar.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.LongColAddLongColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.LongColAddLongScalar.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.LongColUnaryMinus.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.LongScalarModuloLongColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.expressions.gen.LongScalarSubtractLongColumn.evaluate()
• org.apache.hadoop.hive.ql.exec.vector.udf.VectorUDFAdaptor.evaluate()
• org.apache.hadoop.hive.ql.udf.UDFDayOfMonth.evaluate()
  Get the day of month from a date string. @param dateString the dateString in the format of "yyyy-MM-dd HH:mm:ss" or "yyyy-MM-dd". @return an int from 1 to 31. null if the dateString is not a valid date string.
• org.apache.hadoop.hive.ql.udf.UDFHour.evaluate()
  Get the hour from a date string. @param dateString the dateString in the format of "yyyy-MM-dd HH:mm:ss" or "yyyy-MM-dd". @return an int from 0 to 23. null if the dateString is not a valid date string.
• org.apache.hadoop.hive.ql.udf.UDFMinute.evaluate()
  Get the minute from a date string. @param dateString the dateString in the format of "yyyy-MM-dd HH:mm:ss" or "yyyy-MM-dd". @return an int from 0 to 59. null if the dateString is not a valid date string.
• org.apache.hadoop.hive.ql.udf.UDFMonth.evaluate()
  Get the month from a date string. @param dateString the dateString in the format of "yyyy-MM-dd HH:mm:ss" or "yyyy-MM-dd". @return an int from 1 to 12. null if the dateString is not a valid date string.
• org.apache.hadoop.hive.ql.udf.UDFSecond.evaluate()
  Get the minute from a date string. @param dateString the dateString in the format of "yyyy-MM-dd HH:mm:ss" or "yyyy-MM-dd". @return an int from 0 to 59. null if the dateString is not a valid date string.
• org.apache.hadoop.hive.ql.udf.UDFWeekOfYear.evaluate()
  Get the week of the year from a date string. @param dateString the dateString in the format of "yyyy-MM-dd HH:mm:ss" or "yyyy-MM-dd". @return an int from 1 to 53. null if the dateString is not a valid date string.
• org.apache.hadoop.hive.ql.udf.UDFYear.evaluate()
  Get the year from a date string. @param dateString the dateString in the format of "yyyy-MM-dd HH:mm:ss" or "yyyy-MM-dd". @return an int from 1 to 12. null if the dateString is not a valid date string.
• org.apache.hadoop.hive.ql.udf.generic.GenericUDAFEvaluator.evaluate()
  This function will be called by GroupByOperator when it sees a new input row. @param agg The object to store the aggregation result.
• org.apache.hadoop.hive.ql.udf.generic.GenericUDFAbs.evaluate()
• org.apache.hadoop.hive.ql.udf.generic.GenericUDFDate.evaluate()
• org.apache.hadoop.hive.ql.udf.generic.GenericUDFDateAdd.evaluate()
• org.apache.hadoop.hive.ql.udf.generic.GenericUDFDateDiff.evaluate()
• org.apache.hadoop.hive.ql.udf.generic.GenericUDFDateSub.evaluate()
• org.apache.hadoop.hive.ql.udf.generic.GenericUDFHash.evaluate()
• org.apache.hivemind.conditional.ClassNameEvaluator.evaluate()
• org.apache.hivemind.conditional.Evaluator.evaluate()
  Invoked by the Node to evaluate its own value. Typical implementations will extract the Node's {@link org.apache.hivemind.conditional.Node#getLeft() left} and{@link org.apache.hivemind.conditional.Node#getRight() right} properties and combine orotherwise evaluate them. Terminal nodes in the tree will have evaluators that don't do that but generate a return value internally.
• org.apache.hivemind.conditional.Node.evaluate()
  Evaluates the nodes using the context to provide access to runtime information.
• org.apache.hivemind.conditional.NodeImpl.evaluate()
• org.apache.hivemind.conditional.PropertyEvaluator.evaluate()
  Invokes {@link org.apache.hivemind.conditional.EvaluationContext#isPropertySet(String)}.
• org.apache.imperius.spl.core.Expression.evaluate()
  Evaluates the expression and return a result @return @throws SPLException
• org.apache.imperius.spl.parser.compiler.IdentPrimaryTuple.evaluate()
• org.apache.imperius.spl.parser.expression.primary.BasicCollectionExpression.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.Abs.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.Addition.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.AllInCollection.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.AnyInCollection.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.ApplyToCollection.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.AvrgInCollection.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.Ceiling.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.CollectionSize.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.Concatenate.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.Contains.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.DateTimeConstant.evaluate()
  Evaluates and returns the value of this expression using the specified SensorLookup to obtain the values of indeterminates (quantities whose magnitude cannot be determined at the time of authoring the expression) occuring in this expression. Since this Expression has a constant value, the specified SensorLookupis not used.

  @param s the specified SensorLookup @return the value of this expression @throws com.ibm.autonomic.policy.expression.EvaluationException

• org.apache.imperius.spl.parser.expressions.impl.Division.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.EndsWith.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.EqCollections.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.Equal.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.Exp.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.Floor.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.GetDayOfMonth.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.GetDayOfWeek.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.GetDayOfWeekInMonth.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.GetDayOfYear.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.GetHour12.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.GetHour24.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.GetMillisecond.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.GetMinute.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.GetMonth.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.GetSecond.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.GetWeekOfMonth.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.GetWeekOfYear.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.GetYear.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.Greater.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.GreaterOrEqual.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.InCollection.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.IsAfter.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.IsBefore.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.IsWithin.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.LeftSubstring.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.Less.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.LessOrEqual.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.Ln.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.Log10.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.LogicalAnd.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.LogicalNot.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.LogicalOr.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.LogicalXor.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.Max.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.MaxInCollection.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.MedianInCollection.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.MiddleSubstring.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.Min.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.MinInCollection.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.Mod.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.NotEqual.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.Power.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.Product.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.ReplaceSubstring.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.RightSubstring.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.Rint.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.Round.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.SdInCollection.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.SquareRoot.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.StartsWith.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.StringLength.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.SubCollection.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.Subtraction.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.Sum.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.ToBoolean.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.ToLower.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.ToMilliseconds.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.ToREAL32.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.ToREAL64.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.ToSINT16.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.ToSINT32.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.ToSINT64.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.ToSINT8.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.ToString.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.ToUpper.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.Union.evaluate()
• org.apache.imperius.spl.parser.expressions.impl.Word.evaluate()
• org.apache.ivory.expression.ExpressionHelper.evaluate()
• org.apache.jackrabbit.commons.predicate.Predicate.evaluate()
  Evaluates the predicate for the given object. @param object some object @return predicate result
• org.apache.jackrabbit.oak.query.fulltext.FullTextExpression.evaluate()
  Evaluate whether the value matches the condition. @param value the value @return true if it matches
• org.apache.log4j.rule.ColorRule.evaluate()
  {@inheritDoc}
• org.apache.log4j.rule.Rule.evaluate()
  Returns true if this implementation of the rule accepts the LoggingEvent, or false if not. What True/False means can be client-specific. @param e LoggingEvent this instance will evaluate @return true if this Rule instance accepts the event, otherwise false.
• org.apache.lucene.expressions.Expression.evaluate()
  Evaluates the expression for the given document. @param document docId of the document to compute a value for @param functionValues {@link FunctionValues} for each element of {@link #variables}. @return The computed value of the expression for the given document.
• org.apache.lucene.spatial.query.SpatialOperation.evaluate()
  Returns whether the relationship between indexedShape and queryShape is satisfied by this operation.
• org.apache.mahout.cf.taste.eval.RecommenderEvaluator.evaluate()

  Evaluates the quality of a {@link org.apache.mahout.cf.taste.recommender.Recommender}'s recommendations. The range of values that may be returned depends on the implementation, but lower values must mean better recommendations, with 0 being the lowest / best possible evaluation, meaning a perfect match. This method does not accept a {@link org.apache.mahout.cf.taste.recommender.Recommender} directly, butrather a {@link RecommenderBuilder} which can build the{@link org.apache.mahout.cf.taste.recommender.Recommender} to test on top of a given {@link DataModel}.

  Implementations will take a certain percentage of the preferences supplied by the given {@link DataModel}as "training data". This is typically most of the data, like 90%. This data is used to produce recommendations, and the rest of the data is compared against estimated preference values to see how much the {@link org.apache.mahout.cf.taste.recommender.Recommender}'s predicted preferences match the user's real preferences. Specifically, for each user, this percentage of the user's ratings are used to produce recommendatinos, and for each user, the remaining preferences are compared against the user's real preferences.

  For large datasets, it may be desirable to only evaluate based on a small percentage of the data. evaluationPercentage controls how many of the {@link DataModel}'s users are used in evaluation.

  To be clear, trainingPercentage and evaluationPercentage are not related. They do not need to add up to 1.0, for example.

  @param recommenderBuilder object that can build a {@link org.apache.mahout.cf.taste.recommender.Recommender} to test @param dataModelBuilder @param dataModelBuilder {@link DataModelBuilder} to use, or if null, a default {@link DataModel}implementation will be used @param dataModel dataset to test on @param trainingPercentage percentage of each user's preferences to use to produce recommendations; the rest are compared to estimated preference values to evaluate {@link org.apache.mahout.cf.taste.recommender.Recommender} performance @param evaluationPercentage percentage of users to use in evaluation @return a "score" representing how well the {@link org.apache.mahout.cf.taste.recommender.Recommender}'s estimated preferences match real values; lower scores mean a better match and 0 is a perfect match @throws TasteException if an error occurs while accessing the {@link DataModel}
• org.apache.mahout.cf.taste.eval.RecommenderIRStatsEvaluator.evaluate()
  @param recommenderBuilder object that can build a{@link org.apache.mahout.cf.taste.recommender.Recommender} to test @param dataModel dataset to test on @param rescorer if any, to use when computing recommendations @param at as in, "precision at 5". The number of recommendations to consider when evaluatingprecision, etc. @param relevanceThreshold {@link Item}s whose preference value is at least this value are considered "relevant" for the purposes of computations @return {@link IRStatistics} with resulting precision, recall, etc. @throws TasteException if an error occurs while accessing the {@link DataModel}
• org.apache.mahout.cf.taste.impl.eval.AverageAbsoluteDifferenceRecommenderEvaluator.evaluate()
• org.apache.mahout.cf.taste.impl.eval.GenericRecommenderIRStatsEvaluator.evaluate()
• org.apache.marmotta.kiwi.sparql.evaluation.KiWiEvaluationStrategyImpl.evaluate()
• org.apache.maven.archiva.repository.scanner.functors.ConsumerWantsFilePredicate.evaluate()
• org.apache.maven.enforcer.rule.api.EnforcerRuleHelper.evaluate()
• org.apache.maven.plugin.assembly.interpolation.AssemblyExpressionEvaluator.evaluate()
• org.apache.muse.ws.resource.properties.query.QueryExpression.evaluate()
  @param wsrpDoc A resource's WSRP document. @param query A query expression in the language described by getDialect(). @return An array of nodes from the given document that match the query expression. The array may be empty.
• org.apache.myfaces.extensions.cdi.core.impl.activation.PropertyExpressionInterpreter.evaluate()
  {@inheritDoc}
• org.apache.myfaces.tobago.internal.layout.IntervalList.evaluate()
• org.apache.nutch.util.CommandRunner.evaluate()
• org.apache.oodt.cas.workflow.structs.WorkflowConditionInstance.evaluate()

  The actual conditional: this method should return true if the condition is satisfied, otherwise, false.

  @param metadata Any metadata needed by the conditional to determine satisfaction. @return true if the condition is satisfied, otherwise, false.
• org.apache.oodt.xmlps.queryparser.Expression.evaluate()
  Defines how to turn this Expression into a String-readable query to an underlying SQL database. @return A String-readable version of this Expression.
• org.apache.oozie.util.ELEvaluator.evaluate()
  Evaluate an EL expression.

  @param expr EL expression to evaluate. @param clazz return type of the EL expression. @return the object the EL expression evaluated to. @throws Exception thrown if an EL function failed due to a transient error or EL expression could not beevaluated.

• org.apache.openejb.math.stat.descriptive.summary.Sum.evaluate()
  The sum of the entries in the specified portion of the input array, or Double.NaN if the designated subarray is empty.

  Throws IllegalArgumentException if the array is null.

  @param values the input array @param begin index of the first array element to include @param length the number of elements to include @return the sum of the values or Double.NaN if length = 0 @throws IllegalArgumentException if the array is null or the array indexparameters are not valid
• org.apache.openejb.server.cli.OpenEJBScripter.evaluate()
• org.apache.openejb.util.OpenEJBScripter.evaluate()
• org.apache.openjpa.kernel.exps.Val.evaluate()
  Return this value as a projection on the given candidate.
• org.apache.phoenix.expression.DecimalAddExpression.evaluate()
• org.apache.phoenix.expression.DecimalDivideExpression.evaluate()
• org.apache.phoenix.expression.DecimalMultiplyExpression.evaluate()
• org.apache.phoenix.expression.DecimalSubtractExpression.evaluate()
• org.apache.phoenix.expression.Expression.evaluate()
  Access the value by setting a pointer to it (as opposed to making a copy of it which can be expensive) @param tuple Single row result during scan iteration @param ptr Pointer to byte value being accessed @return true if the expression could be evaluated (i.e. ptr was set)and false otherwise
• org.apache.phoenix.expression.KeyValueColumnExpression.evaluate()
• org.apache.phoenix.expression.LikeExpression.evaluate()
• org.apache.phoenix.expression.StringConcatExpression.evaluate()
• org.apache.phoenix.expression.function.FunctionExpression.evaluate()
• org.apache.pluto.tags.el.ExpressionEvaluatorProxy.evaluate()
• org.apache.poi.hssf.record.formula.eval.OperationEval.evaluate()
• org.apache.poi.hssf.record.formula.functions.FreeRefFunction.evaluate()
  @param args the pre-evaluated arguments for this function. args is never null,nor are any of its elements. @param srcCellSheet zero based sheet index of the cell containing the currently evaluating formula @param srcCellRow zero based row index of the cell containing the currently evaluating formula @param srcCellCol zero based column index of the cell containing the currently evaluating formula @param workbook is the workbook containing the formula/cell being evaluated @return never null. Possibly an instance of ErrorEval in the case ofa specified Excel error (Exceptions are never thrown to represent Excel errors).
• org.apache.poi.hssf.record.formula.functions.Function.evaluate()
• org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator.evaluate()
  If cell contains a formula, the formula is evaluated and returned, else the CellValue simply copies the appropriate cell value from the cell and also its cell type. This method should be preferred over evaluateInCell() when the call should not modify the contents of the original cell. @param cell may be null signifying that the cell is not present (or blank) @return null if the supplied cell is null or blank
• org.apache.poi.ss.formula.WorkbookEvaluator.evaluate()
• org.apache.poi.ss.formula.functions.FreeRefFunction.evaluate()
  @param args the pre-evaluated arguments for this function. args is never null,nor are any of its elements. @param ec primarily used to identify the source cell containing the formula being evaluated.may also be used to dynamically create reference evals. @return never null. Possibly an instance of ErrorEval in the case ofa specified Excel error (Exceptions are never thrown to represent Excel errors).
• org.apache.poi.ss.formula.functions.Function.evaluate()
  @param args the evaluated function arguments. Empty values are represented with{@link BlankEval} or {@link MissingArgEval}, never null. @param srcRowIndex row index of the cell containing the formula under evaluation @param srcColumnIndex column index of the cell containing the formula under evaluation @return The evaluated result, possibly an {@link ErrorEval}, never null. Note - Excel uses the error code #NUM! instead of IEEE NaN, so when numeric functions evaluate to {@link Double#NaN} be sure to translate the result to {@link ErrorEval#NUM_ERROR}.
• org.apache.poi.ss.usermodel.FormulaEvaluator.evaluate()
  If cell contains a formula, the formula is evaluated and returned, else the CellValue simply copies the appropriate cell value from the cell and also its cell type. This method should be preferred over evaluateInCell() when the call should not modify the contents of the original cell. @param cell
• org.apache.poi.xslf.model.geom.Context.evaluate()
• org.apache.qpid.qmf2.common.QmfQuery.evaluate()
  Evaluate query against a QmfData instance. @return true if query matches the QmfData instance, else false.
• org.apache.servicemix.expression.Expression.evaluate()
  Evaluates the expression on the given exchange and message. @param exchange the message exchange @param message the message, typically an inbound message @return the value of the expression
• org.apache.servicemix.expression.JAXPBooleanXPathExpression.evaluate()
• org.apache.servicemix.expression.JAXPStringXPathExpression.evaluate()
• org.apache.solr.core.SolrConfig.evaluate()
• org.apache.synapse.util.xpath.SynapseXPath.evaluate()
  Specialized form of xpath evaluation function.An xpath evaluate() will be performed using two contexts (ie:-soap-envelope and on Synapse Message Context). This is useful for evaluating xpath on a nodeset for function contexts (we need both nodeset and synapse ctxts for evaluating function scope expressions) @param primaryContext a context object ie:- a soap envelope @param secondaryContext a context object ie:-synapse message ctxt @return result
• org.apache.syncope.core.util.JexlUtil.evaluate()
• org.apache.syncope.core.util.jexl.JexlUtil.evaluate()
• org.apache.taglibs.standard.lang.jstl.Evaluator.evaluate()
  Evaluates the expression at request time
• org.apache.tiles.TilesContainer.evaluate()
  Evaluates the given attribute. @param attribute The attribute to evaluate. @param requestItems the current request objects. @return The evaluated object. @since 2.1.0
• org.apache.tiles.evaluator.AttributeEvaluator.evaluate()
  Evaluates an expression. @param expression The expression to evaluate. @param request The request object. @return The evaluated object. @since 2.1.0
• org.apache.tiles.request.freemarker.autotag.FreemarkerModelBody.evaluate()
• org.apache.tiles.request.jsp.autotag.JspModelBody.evaluate()
• org.apache.tiles.request.velocity.autotag.VelocityModelBody.evaluate()
• org.apache.uima.ruta.testing.evaluator.ICasEvaluator.evaluate()
• org.apache.velocity.app.VelocityEngine.evaluate()
  renders the input string using the context into the output writer. To be used when a template is dynamically constructed, or want to use Velocity as a token replacer. @param context context to use in rendering input string @param out Writer in which to render the output @param logTag string to be used as the template name for log messages in case of error @param instring input string containing the VTL to be rendered @return true if successful, false otherwise. If false, seeVelocity runtime log
• org.apache.ws.notification.topics.expression.TopicExpressionEvaluator.evaluate()
  Evaluates the expression over a TopicSpace and returns the set of matching topics. @param topicSpaceSet topic list associated with the service/resource @param expression object passed by client representing the topic expression @return the set of topics that matched the specified expression @throws TopicPathDialectUnknownException if the topic expression dialect is not supported @throws TopicExpressionResolutionException if the expression could not be evaluated @throws org.apache.ws.notification.topics.expression.InvalidTopicExpressionException if the topic expression is invalid @throws TopicExpressionException if any other error occurs
• org.apache.ws.resource.properties.query.ExpressionEvaluator.evaluate()
  Evaluates the expression over a ResourcePropertySet and returns the result. @param queryExpr the query expression to evaluate @param resourcePropertySet a WSRF resource property set to be used as the evaluation context @return the result of the evaluation which depends on the expression. The results must be an xml serializableobject in order to be passed back correctly to a remote client. The easiest way of achieving this is to model it as a Bean, or simply return a SOAPElment or DOM Element. If the result object returned is null an empty query result is returned. @throws UnknownQueryExpressionDialectException if query dialect is unsupported @throws QueryEvaluationErrorException if query evaluation fails @throws InvalidQueryExpressionException if query expression is invalid
• org.apache.xalan.templates.AVT.evaluate()
  Evaluate the AVT and return a String. @param xctxt Te XPathContext to use to evaluate this. @param context The current source tree context. @param nsNode The current namespace context (stylesheet tree context). @return The AVT evaluated as a string @throws javax.xml.transform.TransformerException
• org.apache.xpath.domapi.XPathEvaluatorImpl.evaluate()
  Evaluates an XPath expression string and returns a result of the specified type if possible. @param expression The XPath expression string to be parsed and evaluated. @param contextNode The context is context node for the evaluation of this XPath expression. If the XPathEvaluator was obtained by casting the Document then this must be owned by the same document and must be a Document, Element, Attribute, Text, CDATASection, Comment, ProcessingInstruction, or XPathNamespace node. If the context node is a Text or a CDATASection, then the context is interpreted as the whole logical text node as seen by XPath, unless the node is empty in which case it may not serve as the XPath context. @param resolver The resolver permits translation of prefixes within the XPath expression into appropriate namespace URIs . If this is specified as null, any namespace prefix within the expression will result in DOMException being thrown with the code NAMESPACE_ERR. @param type If a specific type is specified, then the result will be coerced to return the specified type relying on XPath type conversions and fail if the desired coercion is not possible. This must be one of the type codes of XPathResult. @param result The result specifies a specific result object which may be reused and returned by this method. If this is specified as nullor the implementation does not reuse the specified result, a new result object will be constructed and returned.For XPath 1.0 results, this object will be of type XPathResult. @return The result of the evaluation of the XPath expression.For XPath 1.0 results, this object will be of type XPathResult. @exception XPathException INVALID_EXPRESSION_ERR: Raised if the expression is not legal according to the rules of the XPathEvaluatori
  TYPE_ERR: Raised if the result cannot be converted to return the specified type. @exception DOMException NAMESPACE_ERR: Raised if the expression contains namespace prefixes which cannot be resolved by the specified XPathNSResolver.
  WRONG_DOCUMENT_ERR: The Node is from a document that is not supported by this XPathEvaluator.
  NOT_SUPPORTED_ERR: The Node is not a type permitted as an XPath context node. @see org.w3c.dom.xpath.XPathEvaluator#evaluate(String,Node,XPathNSResolver,short,XPathResult)
• org.araneaframework.backend.list.memorybased.Expression.evaluate()
  Evaluates this Expression by returning its value. The returned value may also be null. @param resolver Resolver that is used to evalute Variables. @return the value of this Expression. @throws ExpressionEvaluationException when the evaluating fails.
• org.asturlinux.frade.currin.machine.Machine.evaluate()
• org.asturlinux.frade.currin.program.type.CurrinExpr.evaluate()
• org.asturlinux.frade.currin.program.type.CurrinRef.evaluate()
• org.auraframework.expression.Expression.evaluate()
  Evaluate this expression and return the result, resolving references against the passed in value provider.
• org.boris.expr.IExprFunction.evaluate()
• org.broad.igv.ui.TrackFilter.evaluate()
  Evaluate the TrackFilterElement set. @return
• org.broad.igv.util.FilterElement.evaluate()
  @param previousResult Result of the previous FilterElement that isbeing chained to this one (null if no previous FilterElement); @return
• org.camunda.bpm.engine.impl.Condition.evaluate()
• org.camunda.bpm.engine.impl.cmmn.CaseControlRule.evaluate()
• org.codehaus.commons.compiler.jdk.ExpressionEvaluator.evaluate()
• org.codehaus.janino.ExpressionEvaluator.evaluate()
• org.codehaus.janino.ScriptEvaluator.evaluate()
• org.codehaus.plexus.component.configurator.expression.ExpressionEvaluator.evaluate()
  Evaluate an expression. @param expression the expression @return the value of the expression
• org.custommonkey.xmlunit.XpathEngine.evaluate()
  Evaluate the result of executing the specified xpath syntax select expression on the specified document @param select @param document @return evaluated result
• org.datanucleus.query.expression.Expression.evaluate()
  Method to evaluate this expression, using the passed evaluator. @param eval Evaluator @return The result
• org.dom4j.XPath.evaluate()

  evaluate evaluates an XPath expression and returns the result as an {@link Object}. The object returned can either be a {@link List} of {@link Node}instances, a {@link Node}instance, a {@link String} or a {@link Number}instance depending on the XPath expression.

  @param context is either a node or a list of nodes on which to evalute theXPath @return the value of the XPath expression as a {@link List}of {@link Node} instances, a {@link Node}instance, a {@link String}or a {@link Number}instance depending on the XPath expression.
• org.drools.core.reteoo.ConditionalBranchEvaluator.evaluate()
• org.drools.reteoo.ConditionalBranchEvaluator.evaluate()
• org.drools.workflow.instance.impl.ConstraintEvaluator.evaluate()
• org.drools.workflow.instance.impl.ReturnValueConstraintEvaluator.evaluate()
• org.eclipse.core.expressions.Expression.evaluate()
  Evaluates this expression. @param context an evaluation context providing information like variable,name spaces, etc. necessary to evaluate this expression @return the result of the expression evaluation @throws CoreException if the evaluation failed. The concrete reason is defined by the subclass implementing this method
• org.eclipse.debug.core.model.IWatchExpression.evaluate()
• org.eclipse.jface.text.rules.IPredicateRule.evaluate()
  Evaluates the rule by examining the characters available from the provided character scanner. The token returned by this rule returns true when calling isUndefined, if the text that the rule investigated does not match the rule's requirements. Otherwise, this method returns this rule's success token. If this rules relies on a text pattern comprising a opening and a closing character sequence this method can also be called when the scanner is positioned already between the opening and the closing sequence. In this case, resume must be set to true. @param scanner the character scanner to be used by this rule @param resume indicates that the rule starts working between the opening and the closing character sequence @return the token computed by the rule
• org.eclipse.jface.text.templates.DocumentTemplateContext.evaluate()
• org.eclipse.jface.text.templates.TemplateContext.evaluate()
  Evaluates the template in this context and returns a template buffer.

  Evaluation means translating the template into a TemplateBuffer, resolving the defined variables in this context and possibly formatting the resolved buffer.

  @param template the template to evaluate @return returns the buffer with the evaluated template or null if the buffer could not be created @throws BadLocationException if evaluation fails due to concurrently changed documents etc. @throws TemplateException if the template specification is not valid
• org.eclipse.jst.jsf.core.tagmatcher.XPathMatchingAlgorithm.evaluate()
• org.eclipse.ocl.Query.evaluate()
• org.eclipse.php.internal.ui.corext.template.php.CodeTemplateContext.evaluate()
• org.eclipse.sapphire.modeling.el.Function.evaluate()
• org.eclipse.swt.browser.Browser.evaluate()
  Returns the result, if any, of executing the specified script.

  Evaluates a script containing javascript commands in the context of the current document. If document-defined functions or properties are accessed by the script then this method should not be invoked until the document has finished loading (ProgressListener.completed() gives notification of this).

  If the script returns a value with a supported type then a java representation of the value is returned. The supported javascript -> java mappings are:

  • javascript null or undefined -> null
  • javascript number -> java.lang.Double
  • javascript string -> java.lang.String
  • javascript boolean -> java.lang.Boolean
  • javascript array whose elements are all of supported types -> java.lang.Object[]

  An SWTException is thrown if the return value has an unsupported type, or if evaluating the script causes a javascript error to be thrown. @param script the script with javascript commands @return the return value, if any, of executing the script @exception IllegalArgumentException

  • ERROR_NULL_ARGUMENT - if the script is null

  @exception SWTException

  • ERROR_FAILED_EVALUATE when the script evaluation causes a javascript error to be thrown
  • ERROR_INVALID_RETURN_VALUE when the script returns a value of unsupported type
  • ERROR_THREAD_INVALID_ACCESS when called from the wrong thread
  • ERROR_WIDGET_DISPOSED when the widget has been disposed

  @see ProgressListener#completed(ProgressEvent) @since 3.5
• org.eclipse.test.internal.performance.eval.Evaluator.evaluate()
• org.eclipse.wst.xml.xpath2.processor.Evaluator.evaluate()
• org.eclipse.xpand2.XpandFacade.evaluate()
• org.encog.ml.prg.EncogProgram.evaluate()
  Execute the program and return the result. @return The result of running the program.
• org.exist.security.xacml.ExistPDP.evaluate()
  The method that will be used most of the time. It provides the simplest interface to the underlying PDP by permitting the request only if the ResponseCtx includes Results that have no Obligations and only have the decision Permit. Other cases result in a PermissionDeniedException. The other cases include when an applicable policy cannot be found and when an error occurs. @param request the access request @throws PermissionDeniedException if the request is not allowed
• org.fenixedu.academic.domain.curricularRules.PreviousYearsEnrolmentCurricularRule.evaluate()
• org.ff4j.strategy.ReleaseDateFlipStrategy.evaluate()
  {@inheritDoc}
• org.ff4j.strategy.el.ExpressionFlipStrategy.evaluate()
  {@inheritDoc}
• org.gdbms.engine.customQuery.CustomQuery.evaluate()
  Executes the custom query @param tables tables involved in the query @param values values passed to the query @return DataSource result of the query @throws ExecutionException if the custom query execution fails
• org.gdbms.engine.function.Function.evaluate()
  DOCUMENT ME! @param args DOCUMENT ME! @return DOCUMENT ME! @throws FunctionException DOCUMENT ME!
• org.geotools.coverage.grid.GridCoverage2D.evaluate()
  Returns the value vector for a given location (world coordinates). A value for each sample dimension is included in the vector.
• org.geotools.filter.AttributeExpressionImpl.evaluate()
  Gets the value of this property from the passed object. @param obj Object from which we need to extract a property value.
• org.geotools.filter.ConstantExpression.evaluate()
• org.geotools.filter.expression.AddImpl.evaluate()
• org.geotools.filter.function.ClassificationFunction.evaluate()
• org.geotools.filter.function.EqualIntervalFunction.evaluate()
• org.geotools.process.raster.FilterFunction_gridCoverageStats.evaluate()
• org.geotools.process.raster.FilterFunction_svgColorMap.evaluate()
• org.gephi.filters.spi.AttributableFilter.evaluate()
• org.gephi.filters.spi.EdgeFilter.evaluate()
• org.gephi.filters.spi.NodeFilter.evaluate()
• org.gradle.api.internal.project.ProjectInternal.evaluate()
• org.hibernate.validator.constraints.impl.scriptassert.ScriptEvaluator.evaluate()
  Makes the given object available in then engine-scoped script context and executes the given script. The execution of the script happens either synchronized or unsynchronized, depending on the engine's threading abilities. @param script The script to be executed. @param obj The object to be put into the context. @param objectAlias The name under which the given object shall be put into the context. @return The script's result. @throws ConstraintDeclarationException In case of any errors during script execution or if the scriptreturned null or another type than Boolean.
• org.hibernate.validator.internal.util.scriptengine.ScriptEvaluator.evaluate()
  Executes the given script, using the given variable bindings. The execution of the script happens either synchronized or unsynchronized, depending on the engine's threading abilities. @param script The script to be executed. @param bindings The bindings to be used. @return The script's result. @throws ScriptException In case of any errors during script execution.
• org.hibernate.validator.util.scriptengine.ScriptEvaluator.evaluate()
  Makes the given object available in then engine-scoped script context and executes the given script. The execution of the script happens either synchronized or unsynchronized, depending on the engine's threading abilities. @param script The script to be executed. @param obj The object to be put into the context. @param objectAlias The name under which the given object shall be put into the context. @return The script's result. @throws ScriptException In case of any errors during script execution.
• org.htmlparser.scanners.AppletScanner.evaluate()
• org.htmlparser.scanners.FormScanner.evaluate()
• org.htmlparser.scanners.FrameSetScanner.evaluate()
• org.htmlparser.scanners.ImageScanner.evaluate()
• org.htmlparser.scanners.LinkScanner.evaluate()
  Template Method, used to decide if this scanner can handle the Link tag type. If the evaluation returns true, the calling side makes a call to scan(). @param s The complete text contents of the Tag. @param previousOpenScanner Indicates any previous scanner which hasnt completed, before the currentscan has begun, and hence allows us to write scanners that can work with dirty html
• org.htmlparser.scanners.ScriptScanner.evaluate()
• org.htmlparser.scanners.StyleScanner.evaluate()
• org.htmlparser.scanners.TagScanner.evaluate()
  This method is used to decide if this scanner can handle this tag type. If the evaluation returns true, the calling side makes a call to scan(). This method has to be implemented meaningfully only if a first-word match with the scanner id does not imply a match (or extra processing needs to be done). Default returns true @param s The complete text contents of the Tag. @param previousOpenScanner Indicates any previous scanner which hasnt completed, before the currentscan has begun, and hence allows us to write scanners that can work with dirty html
• org.jacorb.notification.filter.FilterConstraint.evaluate()
• org.jacorb.notification.filter.etcl.AbstractTCLNode.evaluate()
  Evaluate this Node. @param context an EvaluationContext value contains all context information necessary for the evaluation @return an EvaluationResult value @exception EvaluationException occurs if e.g. an expression contains a reference to a non-existent struct member or if it is tried to add a string and a number
• org.jacorb.notification.filter.etcl.ETCLFilterConstraint.evaluate()
• org.jakstab.rtl.expressions.RTLExpression.evaluate()
  Returns a copy of this expression evaluated in the given context. Evaluation may change the type of all subexpressions and may reduce or increase the total number of objects. @param context the evaluation context, used for variable assignments and information propagation. @return An evaluated copy of this expression
• org.jakstab.rtl.statements.RTLStatement.evaluate()
  Returns this statement evaluated in the given context. Evaluation may change the type of all substatements and expressions, and may reduce or increase the total number of objects. Only statements are actually modified, embedded RTLExpressions are copied on change to preserve their immutable property. @param context the evaluation context, used for variable assignments and information propagation. @return An evaluated copy of this statement
• org.jamesii.simspex.spdm.evaluation.evaluator.FullPredictorEvaluator.evaluate()
• org.jamesii.simspex.spdm.evaluation.evaluator.IPredictorEvaluator.evaluate()
  Evaluates a predictor with test and training data as predefined by the corresponding data selectors. @param < T> the type of the performance tuples @param predictor the predictor to be evaluated @param trainingData the training data used to generate this predictor @param testData the test data that is available for this method @param parameters parameters for the predictor evaluator and the performance measurements @return predictor performance measurements
• org.javex.ExpressionImpl.evaluate()
• org.javex.evaluators.Evaluator.evaluate()
• org.javex.operands.ListOperand.evaluate()
• org.jaxen.BaseXPath.evaluate()
  Evaluate this XPath against a given context.

  The context of evaluation my be a document, an element, or a set of elements.

  If the expression evaluates to a single primitive (String, Number or Boolean) type, it is returned directly. Otherwise, the returned value is a List (a node-set, in the terms of the specification) of values.

  When using this method, one must be careful to test the class of the returned objects, and of each of the composite members if a List is returned. If the returned members are XML entities, they will be the actual Document, Element or Attribute objects as defined by the concrete XML object-model implementation, directly from the context document. This does not return copies of anything, but merely returns references to entities within the source document.

  @param node The node, nodeset or Context object for evaluation. This value can be null. @return The result of evaluating the XPath expressionagainst the supplied context.
• org.jaxen.XPath.evaluate()
  Evaluate this XPath against a given context.

  The context of evaluation my be a document, an element, or a set of elements.

  If the expression evaluates to a single primitive (String, Number or Boolean) type, it is returned directly. Otherwise, the returned value is a List (a node-set, in the terms of the specification) of values.

  When using this method, one must be careful to test the class of the returned objects, and of each of the composite members if a List is returned. If the returned members are XML entities, they will be the actual Document, Element or Attribute objects as defined by the concrete XML object-model implementation, directly from the context document. This does not return copies of anything, but merely returns references to entities within the source document.

  @param The node, nodeset or Context object for evaluation. This value can be null @return The result of evaluating the XPath expressionagainst the supplied context.
• org.jaxen.dom.DOMXPath.evaluate()
• org.jaxen.javabean.JavaBeanXPath.evaluate()
• org.jboss.security.xacml.interfaces.PolicyDecisionPoint.evaluate()
  Method to evaluate a XACML Request @param request The RequestContext that contains the XACML Request
• org.jboss.security.xacml.sunxacml.AbstractPolicy.evaluate()
  Tries to evaluate the policy by calling the combining algorithm on the given policies or rules. The match method must always be called first, and must always return MATCH, before this method is called. @param context the representation of the request @return the result of evaluation
• org.jboss.security.xacml.sunxacml.Rule.evaluate()
  Evaluates the rule against the supplied context. This will check that the target matches, and then try to evaluate the condition. If the target and condition apply, then the rule's effect is returned in the result.

  Note that rules are not required to have targets. If no target is specified, then the rule inherits its parent's target. In the event that this Rule has no Target then the match is assumed to be true, since evaluating a policy tree to this level required the parent's target to match. @param context the representation of the request we're evaluating @return the result of the evaluation

• org.jboss.test.security.sunxacml.conformance.support.TestPDP.evaluate()
• org.jbpm.process.instance.impl.ConstraintEvaluator.evaluate()
• org.jbpm.process.instance.impl.ReturnValueConstraintEvaluator.evaluate()
• org.jbpm.pvm.Condition.evaluate()
  evaluates this condition in the context of the given execution.
• org.jbpm.pvm.internal.model.Condition.evaluate()
  evaluates this condition in the context of the given execution.
• org.jenkinsci.plugins.tokenmacro.TokenMacro.evaluate()
• org.jfree.formula.Formula.evaluate()
• org.jfree.formula.operators.InfixOperator.evaluate()
  Evaluates the comptuation for both parameters. This method must never return null. @param context @param value1 @param value2 @return @throws EvaluationException
• org.jfree.layouting.layouter.style.functions.content.ContentFunction.evaluate()
• org.jfree.layouting.layouter.style.functions.values.StyleValueFunction.evaluate()
• org.jmathml.ASTFunction.ASTRoot.evaluate()
• org.jpox.store.mapped.query.Evaluator.evaluate()
  Method to evaluate the query. @param queryStmt The query statement @return The result
• org.jquantlib.math.RegularisedIncompleteBeta.evaluate()
  Regularised incomplete beta function @param a @param b @param x @param accuracy @param maxIteration @return regularised incomplete beta
• org.jquantlib.math.integrals.TabulatedGaussLegendre.evaluate()
• org.junit.internal.runners.statements.FailOnTimeout.evaluate()
• org.junit.runners.model.Statement.evaluate()
  Run the action, throwing a {@code Throwable} if anything goes wrong.
• org.jwildfire.base.mathparser.JEPWrapper.evaluate()
• org.jwildfire.envelope.Envelope.evaluate()
• org.jzkit.search.provider.iface.Searchable.evaluate()
  Create a AbstractIRResultSet. Evaluate the query with the Tasks evaluate method. This method must not block
• org.kitesdk.morphline.scriptengine.java.ScriptEvaluator.evaluate()
• org.milyn.cdr.xpath.evaluators.XPathExpressionEvaluator.evaluate()
  Does this XPath expression evaluate for the supplied {@link org.milyn.delivery.sax.SAXElement} context object.

  The implementation can update the context to a parent element if the expression targets multiple contexts. @param element The {@link org.milyn.delivery.sax.SAXElement} context to be evaluated against. @param executionContext Smooks {@link org.milyn.container.ExecutionContext}. @return True if the expression evaluates, otherwise false.

• org.mule.api.el.ExpressionLanguage.evaluate()
  Execute the expression returning the result. The expression will be executed by the expression language implementation without making any event or message context available. @param < T> the return type expected @param expression the expression to be executed @return the result of execution of the expression.
• org.mule.api.expression.ExpressionEvaluator.evaluate()
  Extracts a single property from the message @param expression the property expression or expression @param message the message to extract from @return the result of the extraction or null if the property was not found
• org.mule.api.expression.ExpressionManager.evaluate()
  aram message The current message being processed @return the result of the evaluation @throws ExpressionRuntimeException if the expression is invalid, or a null is found for the expression and'failIfNull is set to true.
• org.mule.el.mvel.MVELExpressionLanguage.evaluate()
• org.mule.expression.RegistryExpressionEvaluator.evaluate()
• org.mule.module.ognl.expression.OgnlExpressionEvaluator.evaluate()
• org.mule.module.xml.expression.JXPathExpressionEvaluator.evaluate()
• org.mule.routing.correlation.CorrelationPropertiesExpressionEvaluator.evaluate()
• org.nasutekds.server.admin.condition.Condition.evaluate()
  Evaluates this condition against the provided client managed object. @param context The client management context. @param managedObject The client managed object. @return Returns true if this condition issatisfied. @throws AuthorizationException If the condition could not be evaluated due to an authorization problem. @throws CommunicationException If the condition could not be evaluated due to an communication problem.
• org.netbeans.api.debugger.jpda.JPDADebugger.evaluate()
• org.noname.designer.core.interfaces.IEvaluator.evaluate()
• org.ocpsoft.rewrite.config.Rule.evaluate()
• org.ocpsoft.rewrite.servlet.config.Query.evaluate()
• org.opendope.conditions.Condition.evaluate()
• org.opengis.coverage.grid.GridCoverage.evaluate()
• org.opengis.filter.And.evaluate()
• org.opengis.filter.Filter.evaluate()
  Give an object, this method determines if the test(s) represented by this filter object are passed.

  This ability is used to allow Queries against both Features and and non spatial data (such as Record) and to express constraints on permissable data values.

  @param object @return true if the test(s) are passed for the provided object
• org.opengis.filter.Id.evaluate()
• org.opengis.filter.Or.evaluate()
• org.opengis.filter.PropertyIsBetween.evaluate()
• org.opengis.filter.PropertyIsEqualTo.evaluate()
• org.opengis.filter.PropertyIsGreaterThan.evaluate()
• org.opengis.filter.PropertyIsLessThan.evaluate()
• org.opengis.filter.PropertyIsLike.evaluate()
• org.opengis.filter.PropertyIsNotEqualTo.evaluate()
• org.opengis.filter.PropertyIsNull.evaluate()
• org.opengis.filter.expression.Expression.evaluate()
  Evaluates the given expression based on the content of the given object.
• org.opengis.filter.expression.Function.evaluate()
• org.opengis.filter.expression.Literal.evaluate()
• org.opengis.filter.expression.PropertyName.evaluate()
• org.opengis.filter.spatial.BBOX.evaluate()
• org.opengis.filter.spatial.Beyond.evaluate()
• org.opengis.filter.spatial.Contains.evaluate()
• org.opengis.filter.spatial.DWithin.evaluate()
• org.opengis.filter.spatial.Disjoint.evaluate()
• org.opengis.filter.spatial.Equals.evaluate()
• org.opengis.filter.spatial.Intersects.evaluate()
• org.opengis.filter.spatial.Within.evaluate()
• org.opengis.filter.temporal.After.evaluate()
• org.opengis.filter.temporal.Before.evaluate()
• org.opengis.filter.temporal.During.evaluate()
• org.openiaml.emf.properties.library.ReferencesCycles.evaluate()
• org.openquark.cal.internal.runtime.lecc.RTValue.evaluate()
  Return the evaluated RTValue. This may cause the value to be evaluated if this hasn't already been done. @param ec @return RTValue the result of evaluating this RTValue @throws CALExecutorException
• org.openrdf.query.BooleanQuery.evaluate()
• org.openrdf.query.GraphQuery.evaluate()
• org.openrdf.query.TupleQuery.evaluate()
• org.openrdf.query.algebra.evaluation.EvaluationStrategy.evaluate()
  Evaluates the tuple expression against the supplied triple source with the specified set of variable bindings as input. @param expr The Tuple Expression to evaluate @param bindings The variables bindings to use for evaluating the expression, if applicable. @return A cursor over the variable binding sets that match the tupleexpression.
• org.openrdf.query.algebra.evaluation.function.Function.evaluate()
• org.openrdf.query.algebra.evaluation.impl.EvaluationStrategyImpl.evaluate()
  Determines whether the two operands match according to the regex operator. @return true if the operands match according to theregex operator, false otherwise.
• org.openrdf.repository.http.HTTPBooleanQuery.evaluate()
• org.openrdf.repository.http.HTTPGraphQuery.evaluate()
• org.openrdf.repository.http.HTTPTupleQuery.evaluate()
• org.openrdf.sail.SailConnection.evaluate()
  Evaluates the supplied TupleExpr on the data contained in this Sail object, using the (optional) dataset and supplied bindings as input parameters. @param query The query to evaluate. @param bindings A set of input parameters for the query evaluation. The keys reference variable names that should be bound to the value they map to. @param includeInferred Indicates whether inferred triples are to be considered in the query result. If false, no inferred statements are returned; if true, inferred statements are returned if available @return The TupleQueryResult. @throws StoreException If the Sail object encountered an error or unexpected situation internally.
• org.opensaml.ws.security.SecurityPolicy.evaluate()
  Evaluates this policy. Rules are evaluated in the order returned by {@link #getPolicyRules()}. @param messageContext the message context being evaluated @throws SecurityPolicyException thrown if the requirements of the security policy, including those ofany of its rules, are not satisfied by the given message context. Also thrown if any error is encountered during evaluation
• org.outerj.expression.Expression.evaluate()
• org.pdf4j.saxon.xpath.XPathEvaluator.evaluate()
  Prepare and execute an XPath expression, supplied as a string, and returning the results as a List. @param expression The XPath expression to be evaluated, supplied as a string. @return The results of the expression, as a List. The List represents the sequenceof items returned by the expression. Each item in the list will either be an object representing a node, or a Java object representing an atomic value. The types of Java object that may be included in the list, and the XML Schema data types that they correspond to, are as follows:

  • Boolean (xs:boolean)
  • String (xs:string)
  • BigDecimal (xs:decimal)
  • Long (xs:integer and its derived types)
  • Double (xs:double)
  • Float (xs:float)
  • Date (xs:date, xs:dateTime)

  @deprecated since Saxon 8.9 - use the various method defined in the JAXP interface definition
• org.pentaho.reporting.libraries.css.resolver.function.ContentFunction.evaluate()
• org.pentaho.reporting.libraries.css.resolver.function.StyleValueFunction.evaluate()
• org.pentaho.reporting.libraries.formula.Formula.evaluate()
• org.pentaho.reporting.libraries.formula.lvalues.LValue.evaluate()
• org.pentaho.reporting.libraries.formula.operators.EqualOperator.evaluate()
• org.pentaho.reporting.libraries.formula.operators.InfixOperator.evaluate()
  Evaluates the comptuation for both parameters. This method must never return null. @param context @param value1 @param value2 @return @throws EvaluationException
• org.picocontainer.gems.constraints.And.evaluate()
• org.picocontainer.gems.constraints.Constraint.evaluate()
  Evaluate whether the given component adapter matches this constraint. @param adapter a ComponentAdapter value @return true if the adapter matches the constraint
• org.picocontainer.gems.constraints.Or.evaluate()
• org.renjin.compiler.ir.tac.IRBody.evaluate()
• org.renjin.eval.Context.evaluate()
• org.springframework.beans.factory.config.BeanExpressionResolver.evaluate()
  Evaluate the given value as an expression, if applicable; return the value as-is otherwise. @param value the value to check @param evalContext the evaluation context @return the resolved value (potentially the given value as-is) @throws BeansException if evaluation failed
• org.springframework.integration.xquery.support.XQueryParameter.evaluate()
  Evaluates the given message against the provided expression if one is set else, returns the static value provided. If none of the static value or expression are provided. The value returned is null. @param message @return
• org.springframework.scripting.ScriptEvaluator.evaluate()
  Evaluate the given script. @param script the ScriptSource for the script to evaluate @return the return value of the script, if any @throws ScriptCompilationException if the evaluator failed to read,compile or evaluate the script
• org.springframework.scripting.groovy.GroovyScriptEvaluator.evaluate()
• org.springframework.scripting.support.StandardScriptEvaluator.evaluate()
• org.teiid.query.eval.Evaluator.evaluate()
• org.terrier.evaluation.Evaluation.evaluate()
  Evaluates the given result file for the given qrels file. All subclasses must implement this method. @param resultFilename java.lang.String the filename of the result file to evaluate.
• org.w3c.dom.xpath.XPathEvaluator.evaluate()
  Evaluates an XPath expression string and returns a result of the specified type if possible. @param expression The XPath expression string to be parsed andevaluated. @param contextNode The context is context node for theevaluation of this XPath expression. If the XPathEvaluator was obtained by casting the Document then this must be owned by the same document and must be a Document, Element, Attribute, Text, CDATASection, Comment, ProcessingInstruction, or XPathNamespace node. If the context node is a Text or a CDATASection, then the context is interpreted as the whole logical text node as seen by XPath, unless the node is empty in which case it may not serve as the XPath context. @param resolver The resolver permits translation ofprefixes within the XPath expression into appropriate namespace URIs . If this is specified as null, any namespace prefix within the expression will result in DOMException being thrown with the code NAMESPACE_ERR. @param type If a specific type is specified, then theresult will be returned as the corresponding type.For XPath 1.0 results, this must be one of the codes of the XPathResult interface. @param result The result specifies a specific resultobject which may be reused and returned by this method. If this is specified as nullor the implementation does not reuse the specified result, a new result object will be constructed and returned.For XPath 1.0 results, this object will be of type XPathResult. @return The result of the evaluation of the XPath expression.For XPath1.0 results, this object will be of type XPathResult. @exception XPathException INVALID_EXPRESSION_ERR: Raised if the expression is not legal according to the rules of the XPathEvaluatori
  TYPE_ERR: Raised if the result cannot be converted to return the specified type. @exception DOMException NAMESPACE_ERR: Raised if the expression contains namespace prefixes which cannot be resolved by the specified XPathNSResolver.
  WRONG_DOCUMENT_ERR: The Node is from a document that is not supported by this XPathEvaluator.
  NOT_SUPPORTED_ERR: The Node is not a type permitted as an XPath context node or the request type is not permitted by this XPathEvaluator.
• org.w3c.dom.xpath.XPathExpression.evaluate()
  Evaluates this XPath expression and returns a result. @param contextNode The context is context node for theevaluation of this XPath expression.If the XPathEvaluator was obtained by casting the Document then this must be owned by the same document and must be a Document, Element, Attribute, Text, CDATASection, Comment, ProcessingInstruction, or XPathNamespace node.If the context node is a Text or a CDATASection, then the context is interpreted as the whole logical text node as seen by XPath, unless the node is empty in which case it may not serve as the XPath context. @param type If a specific type is specified, then theresult will be coerced to return the specified type relying on XPath conversions and fail if the desired coercion is not possible. This must be one of the type codes of XPathResult. @param result The result specifies a specific resultobject which may be reused and returned by this method. If this is specified as nullor the implementation does not reuse the specified result, a new result object will be constructed and returned.For XPath 1.0 results, this object will be of type XPathResult. @return The result of the evaluation of the XPath expression.For XPath1.0 results, this object will be of type XPathResult. @exception XPathException TYPE_ERR: Raised if the result cannot be converted to return the specified type. @exception DOMException WRONG_DOCUMENT_ERR: The Node is from a document that is not supported by the XPathEvaluator that created this XPathExpression .
  NOT_SUPPORTED_ERR: The Node is not a type permitted as an XPath context node or the request type is not permitted by this XPathExpression.
• org.webcamp.questionary.services.impl.PercentileScore.evaluate()
• org.wso2.carbon.identity.entitlement.pdp.EntitlementEngine.evaluate()
  Evaluates the given XACML request and returns the Response that the EntitlementEngine will hand back to the PEP. PEP needs construct the XACML request before sending it to the EntitlementEngine @param xamlRequest XACML request as an Element @return Response @throws com.sun.xacml.ParsingException @throws java.io.IOException
• org.wso2.carbon.mashup.javascript.messagereceiver.JavaScriptEngine.evaluate()
  Evaluates a Reader instance associated to a Javascript source. @param reader a Reader instance associated to a Javascript source @throws IOException if the Reader instance generates an IOException
• org.xmedia.metak.eval.SesameSparqlEvaluator.evaluate()
• org.yaac.server.egql.evaluator.Evaluator.evaluate()
• org.zkoss.zk.ui.Execution.evaluate()
  Evluates the specified expression with ${link #getVariableResolver} and {@link Page#getFunctionMapper} of the page of the specifiedcomponent.

  The function mapper is retrieved from component's page's function mapper ( {@link Page#getFunctionMapper}). If null, the current page, if any, is used to retrieve the mapper.

  For better performance, you can use the instance returned by {@link #getEvaluator} to parse and cached the parsed expression.{@link org.zkoss.zk.xel.ExValue} is a utility class to simplythe task. @param comp used as the self variable and to retrieve the functionmapper. Ignored if null. @see #getVariableResolver @see #getEvaluator

• org.zkoss.zk.xel.Evaluator.evaluate()
  Evaluates the expression. @param page the page, or null to ignore
• org.zkoss.zss.engine.xel.Token.evaluate()
• plm.util.gaussian.GaussianArHpEvaluator.evaluate()
• plm.util.hmm.gaussian.GaussianArHmmClassEvaluator.evaluate()
• plm.util.hmm.gaussian.GaussianArHmmPsiLearningEvaluator.evaluate()
• plm.util.hmm.gaussian.GaussianArHmmRmseEvaluator.evaluate()
• railo.runtime.img.math.Function2D.evaluate()
• ro.isdc.wro.extensions.script.RhinoScriptBuilder.evaluate()
  Evaluates a script from a reader. @param reader {@link Reader} of the script to evaluate. @param sourceName the name of the evaluated script. @return evaluated object. @throws IOException if the script couldn't be retrieved.
• rulesystem.ruleinput.RuleInput.evaluate()
• search.fitnessfunctions.SimpleXorFitnessFunction.evaluate()
• tcg.common.util.ExpressionParser.evaluate()
  Evaluate the expression.
  If the expression is not yet parsed, it will be parsed. If the operation (both the parsing, if it is not yet done, and the evaluation) fails, the return value is null. The caller is responsible for converting the result into the correct type. @return the result of the expression if successful, null otherwise. @throws Exception when the evaluation fails, exception is thrown.
• trees.ExpressionTree.evaluate()
  Evaluates this expression tree @return the number (integer or double) as the result of the expression @todo implement algorithm 4.1
• us.codecraft.xsoup.XPathEvaluator.evaluate()
• wyvern.tools.typedAST.core.Sequence.evaluate()
• wyvern.tools.typedAST.interfaces.TypedAST.evaluate()
  an interpreter