Uses of Class
net.sf.tweety.math.term.Term

Packages that use Term

Package	Description
net.sf.tweety.arg.prob.dynamics
net.sf.tweety.arg.prob.semantics
net.sf.tweety.logics.pl.analysis
net.sf.tweety.logics.rpcl.semantics
net.sf.tweety.math.equation
net.sf.tweety.math.func
net.sf.tweety.math.func.fuzzy
net.sf.tweety.math.matrix
net.sf.tweety.math.norm
net.sf.tweety.math.opt
net.sf.tweety.math.opt.solver
net.sf.tweety.math.term

Uses of Term in net.sf.tweety.arg.prob.dynamics

Method parameters in net.sf.tweety.arg.prob.dynamics with type arguments of type Term

Modifier and Type	Method	Description
protected void	AbstractPAChangeOperator.prepareOptimizationProblem(PartialProbabilityAssignment ppa, DungTheory theory, OptimizationProblem problem, java.util.Map<java.util.Collection<Argument>,FloatVariable> varsComp, java.util.Map<java.util.Collection<Argument>,FloatVariable> varsSem, java.util.Vector<Term> varsCompVector, java.util.Vector<Term> varsSemVector)

Uses of Term in net.sf.tweety.arg.prob.semantics

Methods in net.sf.tweety.arg.prob.semantics that return Term

Modifier and Type	Method	Description
protected Term	AbstractPASemantics.probabilityTerm(Argument arg, java.util.Map<java.util.Collection<Argument>,FloatVariable> worlds2vars)	Constructs the term expressing the probability of the given argument wrt.

Uses of Term in net.sf.tweety.logics.pl.analysis

Methods in net.sf.tweety.logics.pl.analysis that return Term

Modifier and Type	Method	Description
private Term	FuzzyInconsistencyMeasure.getTerm(PlFormula formula, java.util.Map<Proposition,Variable> assignments)	Returns a mathematical term representation of the given formula by replacing proposition by their given mathematical variables and replacing conjunction, disjunction, and negation by their fuzzy counterparts (taking the given t-norm and t-conorm into account).

Methods in net.sf.tweety.logics.pl.analysis that return types with arguments of type Term

Modifier and Type	Method	Description
private Pair<java.util.Map<Variable,Term>,java.lang.Double>	FuzzyInconsistencyMeasure.constructAndSolveProblem(java.util.Collection<PlFormula> formulas, java.util.Map<Proposition,Variable> assignments)	Utility method

Uses of Term in net.sf.tweety.logics.rpcl.semantics

Methods in net.sf.tweety.logics.rpcl.semantics that return Term

Modifier and Type	Method	Description
protected Term	AbstractRpclSemantics.probabilityTerm(FolFormula f, java.util.Map<Interpretation<FolBeliefSet,FolFormula>,FloatVariable> worlds2vars)	Constructs the term expressing the probability of the given formula "f" wrt.

Uses of Term in net.sf.tweety.math.equation

Fields in net.sf.tweety.math.equation declared as Term

Modifier and Type	Field	Description
private Term	Statement.leftTerm	The left term of this statement.
private Term	Statement.rightTerm	The right term of this statement.

Methods in net.sf.tweety.math.equation that return Term

Modifier and Type	Method	Description
Term	Statement.getLeftTerm()	Returns the left term of this statement.
Term	Statement.getRightTerm()	Returns the right term of this statement.

Methods in net.sf.tweety.math.equation with parameters of type Term

Modifier and Type	Method	Description
Statement	Equation.replaceTerm(Term toSubstitute, Term substitution)
Statement	Inequation.replaceTerm(Term toSubstitute, Term substitution)
abstract Statement	Statement.replaceTerm(Term toSubstitute, Term substitution)	Replaces each occurrence of "toSubstitute" by "substitution" and return the new statement.
void	Statement.setLeftTerm(Term t)	Sets the left term of this statement.
void	Statement.setRightTerm(Term t)	Sets the right term of this statement.

Method parameters in net.sf.tweety.math.equation with type arguments of type Term

Modifier and Type	Method	Description
Statement	Statement.replaceAllTerms(java.util.Map<? extends Term,? extends Term> substitutes)	Replaces terms according to the given map.
Statement	Statement.replaceAllTerms(java.util.Map<? extends Term,? extends Term> substitutes)	Replaces terms according to the given map.

Constructors in net.sf.tweety.math.equation with parameters of type Term

Constructor	Description
Equation(Term leftTerm, Term rightTerm)	Creates a new equation with the given terms.
Inequation(Term leftTerm, Term rightTerm, int type)	Creates a new inequation of the given type with the two terms.
Statement(Term leftTerm, Term rightTerm)	Creates a new statement with the given terms.

Uses of Term in net.sf.tweety.math.func

Methods in net.sf.tweety.math.func that return Term

Modifier and Type	Method	Description
Term	EntropyFunction.getTerm(java.util.Vector<Term> element)
Term	SimpleRealValuedFunction.getTerm(java.util.Vector<Term> element)

Method parameters in net.sf.tweety.math.func with type arguments of type Term

Modifier and Type	Method	Description
Term	EntropyFunction.getTerm(java.util.Vector<Term> element)
Term	SimpleRealValuedFunction.getTerm(java.util.Vector<Term> element)

Uses of Term in net.sf.tweety.math.func.fuzzy

Methods in net.sf.tweety.math.func.fuzzy that return Term

Modifier and Type	Method	Description
Term	BoundedSum.evalTerm(Term val1, Term val2)
Term	LukasiewiczNorm.evalTerm(Term val1, Term val2)
Term	MaximumCoNorm.evalTerm(Term val1, Term val2)
Term	MinimumNorm.evalTerm(Term val1, Term val2)
Term	ProbabilisticSum.evalTerm(Term val1, Term val2)
Term	ProductNorm.evalTerm(Term val1, Term val2)
Term	TCoNorm.evalTerm(java.util.Collection<Term> vals)	Gives a representation of this conorm as a mathematical term.
abstract Term	TCoNorm.evalTerm(Term val1, Term val2)	Gives a representation of this conorm as a mathematical term
Term	TNorm.evalTerm(java.util.Collection<Term> vals)	Gives a representation of this norm as a mathematical term.
abstract Term	TNorm.evalTerm(Term val1, Term val2)	Gives a representation of this norm as a mathematical term

Methods in net.sf.tweety.math.func.fuzzy with parameters of type Term

Modifier and Type	Method	Description
Term	BoundedSum.evalTerm(Term val1, Term val2)
Term	LukasiewiczNorm.evalTerm(Term val1, Term val2)
Term	MaximumCoNorm.evalTerm(Term val1, Term val2)
Term	MinimumNorm.evalTerm(Term val1, Term val2)
Term	ProbabilisticSum.evalTerm(Term val1, Term val2)
Term	ProductNorm.evalTerm(Term val1, Term val2)
abstract Term	TCoNorm.evalTerm(Term val1, Term val2)	Gives a representation of this conorm as a mathematical term
abstract Term	TNorm.evalTerm(Term val1, Term val2)	Gives a representation of this norm as a mathematical term

Method parameters in net.sf.tweety.math.func.fuzzy with type arguments of type Term

Modifier and Type	Method	Description
Term	TCoNorm.evalTerm(java.util.Collection<Term> vals)	Gives a representation of this conorm as a mathematical term.
Term	TNorm.evalTerm(java.util.Collection<Term> vals)	Gives a representation of this norm as a mathematical term.

Uses of Term in net.sf.tweety.math.matrix

Fields in net.sf.tweety.math.matrix declared as Term

Modifier and Type	Field	Description
private Term[][]	Matrix.entries	The entries of the matrix

Methods in net.sf.tweety.math.matrix that return Term

Modifier and Type	Method	Description
Term	Matrix.getEntry(int x, int y)	Returns the entry with the given coordinates.

Methods in net.sf.tweety.math.matrix with parameters of type Term

Modifier and Type	Method	Description
Matrix	Matrix.mult(Term scalar)	Multiply this matrix with the given scalar (every entry is multiplied)
void	Matrix.setEntry(int x, int y, Term entry)	Sets the entry at the given coordinates.

Uses of Term in net.sf.tweety.math.norm

Methods in net.sf.tweety.math.norm that return Term

Modifier and Type	Method	Description
abstract Term	AbstractRealVectorNorm.distanceTerm(java.util.Vector<Term> obj1, java.util.Vector<Term> obj2)
Term	AbstractRealVectorNorm.distanceTerm(Term[] obj1, Term[] obj2)
Term	AggregatingNorm.distanceTerm(java.util.Vector<Term> obj1, java.util.Vector<Term> obj2)
Term	AggregatingNorm.distanceTerm(Term[] obj1, Term[] obj2)
Term	EntropyNorm.distanceTerm(java.util.Vector<Term> obj1, java.util.Vector<Term> obj2)
Term	EntropyNorm.distanceTerm(Term[] obj1, Term[] obj2)
Term	ManhattanNorm.distanceTerm(java.util.Vector<Term> obj1, java.util.Vector<Term> obj2)
Term	MaximumNorm.distanceTerm(java.util.Vector<Term> obj1, java.util.Vector<Term> obj2)
Term	PNorm.distanceTerm(java.util.Vector<Term> obj1, java.util.Vector<Term> obj2)
Term	ProbabilisticAggregatingNorm.distanceTerm(java.util.Vector<Term> obj1, java.util.Vector<Term> obj2)
Term	ProbabilisticAggregatingNorm.distanceTerm(Term[] obj1, Term[] obj2)
Term	ProbabilisticPNorm.distanceTerm(java.util.Vector<Term> obj1, java.util.Vector<Term> obj2)
Term	ProbabilisticPNorm.distanceTerm(Term[] obj1, Term[] obj2)
Term	RealVectorNorm.distanceTerm(java.util.Vector<Term> obj1, java.util.Vector<Term> obj2)	The distance between the two objects as a term.
Term	RealVectorNorm.distanceTerm(Term[] obj1, Term[] obj2)	The distance between the two objects as a term.
abstract Term	AbstractRealVectorNorm.normTerm(java.util.Vector<Term> obj)
Term	AbstractRealVectorNorm.normTerm(Term[] obj)
Term	AggregatingNorm.normTerm(java.util.Vector<Term> obj)
Term	AggregatingNorm.normTerm(Term[] obj)
Term	EntropyNorm.normTerm(java.util.Vector<Term> obj)
Term	EntropyNorm.normTerm(Term[] obj)
Term	ManhattanNorm.normTerm(java.util.Vector<Term> obj)
Term	MaximumNorm.normTerm(java.util.Vector<Term> obj)
Term	PNorm.normTerm(java.util.Vector<Term> obj)
Term	ProbabilisticAggregatingNorm.normTerm(java.util.Vector<Term> obj)
Term	ProbabilisticAggregatingNorm.normTerm(Term[] obj)
Term	ProbabilisticPNorm.normTerm(java.util.Vector<Term> obj)
Term	ProbabilisticPNorm.normTerm(Term[] obj)
Term	RealVectorNorm.normTerm(java.util.Vector<Term> obj)	Returns the norm as a term of the given terms
Term	RealVectorNorm.normTerm(Term[] obj)	Returns the norm as a term of the given terms

Methods in net.sf.tweety.math.norm with parameters of type Term

Modifier and Type	Method	Description
Term	AbstractRealVectorNorm.distanceTerm(Term[] obj1, Term[] obj2)
Term	AggregatingNorm.distanceTerm(Term[] obj1, Term[] obj2)
Term	EntropyNorm.distanceTerm(Term[] obj1, Term[] obj2)
Term	ProbabilisticAggregatingNorm.distanceTerm(Term[] obj1, Term[] obj2)
Term	ProbabilisticPNorm.distanceTerm(Term[] obj1, Term[] obj2)
Term	RealVectorNorm.distanceTerm(Term[] obj1, Term[] obj2)	The distance between the two objects as a term.
Term	AbstractRealVectorNorm.normTerm(Term[] obj)
Term	AggregatingNorm.normTerm(Term[] obj)
Term	EntropyNorm.normTerm(Term[] obj)
Term	ProbabilisticAggregatingNorm.normTerm(Term[] obj)
Term	ProbabilisticPNorm.normTerm(Term[] obj)
Term	RealVectorNorm.normTerm(Term[] obj)	Returns the norm as a term of the given terms

Method parameters in net.sf.tweety.math.norm with type arguments of type Term

Modifier and Type	Method	Description
abstract Term	AbstractRealVectorNorm.distanceTerm(java.util.Vector<Term> obj1, java.util.Vector<Term> obj2)
Term	AggregatingNorm.distanceTerm(java.util.Vector<Term> obj1, java.util.Vector<Term> obj2)
Term	EntropyNorm.distanceTerm(java.util.Vector<Term> obj1, java.util.Vector<Term> obj2)
Term	ManhattanNorm.distanceTerm(java.util.Vector<Term> obj1, java.util.Vector<Term> obj2)
Term	MaximumNorm.distanceTerm(java.util.Vector<Term> obj1, java.util.Vector<Term> obj2)
Term	PNorm.distanceTerm(java.util.Vector<Term> obj1, java.util.Vector<Term> obj2)
Term	ProbabilisticAggregatingNorm.distanceTerm(java.util.Vector<Term> obj1, java.util.Vector<Term> obj2)
Term	ProbabilisticPNorm.distanceTerm(java.util.Vector<Term> obj1, java.util.Vector<Term> obj2)
Term	RealVectorNorm.distanceTerm(java.util.Vector<Term> obj1, java.util.Vector<Term> obj2)	The distance between the two objects as a term.
abstract Term	AbstractRealVectorNorm.normTerm(java.util.Vector<Term> obj)
Term	AggregatingNorm.normTerm(java.util.Vector<Term> obj)
Term	EntropyNorm.normTerm(java.util.Vector<Term> obj)
Term	ManhattanNorm.normTerm(java.util.Vector<Term> obj)
Term	MaximumNorm.normTerm(java.util.Vector<Term> obj)
Term	PNorm.normTerm(java.util.Vector<Term> obj)
Term	ProbabilisticAggregatingNorm.normTerm(java.util.Vector<Term> obj)
Term	ProbabilisticPNorm.normTerm(java.util.Vector<Term> obj)
Term	RealVectorNorm.normTerm(java.util.Vector<Term> obj)	Returns the norm as a term of the given terms

Uses of Term in net.sf.tweety.math.opt

Fields in net.sf.tweety.math.opt declared as Term

Modifier and Type	Field	Description
private Term	OptimizationProblem.targetFunction	The target function of this problem.

Fields in net.sf.tweety.math.opt with type parameters of type Term

Modifier and Type	Field	Description
private java.util.List<Term>	RootFinder.functions	The (multi-dimensional) function of this root finder.
private java.util.List<java.util.List<Term>>	NewtonRootFinder.jacobian	The jacobian of the function.
private java.util.Map<Variable,Term>	RootFinder.startingPoint	The starting point of this root finder.

Methods in net.sf.tweety.math.opt that return Term

Modifier and Type	Method	Description
Term	OptimizationProblem.getTargetFunction()	Returns the target function of this problem.

Methods in net.sf.tweety.math.opt that return types with arguments of type Term

Modifier and Type	Method	Description
java.util.List<Term>	RootFinder.getFunctions()	Returns the function of this root finder.
java.util.Map<Variable,Term>	RootFinder.getStartingPoint()	Returns the starting point of this finder.
private java.util.Map<Variable,Term>	NewtonRootFinder.midpoint(java.util.Map<Variable,Term> m1, java.util.Map<Variable,Term> m2)	Computes the midpoint of the two maps
java.util.Map<Variable,Term>	BfgsRootFinder.randomRoot()
java.util.Map<Variable,Term>	GradientDescentRootFinder.randomRoot()
java.util.Map<Variable,Term>	HessianGradientDescentRootFinder.randomRoot()
java.util.Map<Variable,Term>	LbfgsRootFinder.randomRoot()
java.util.Map<Variable,Term>	NewtonRootFinder.randomRoot()
java.util.Map<Variable,Term>	OpenOptRootFinder.randomRoot()
abstract java.util.Map<Variable,Term>	OptimizationRootFinder.randomRoot()
abstract java.util.Map<Variable,Term>	RootFinder.randomRoot()	Determines the values for the variables appearing in the function such the function evaluates to zero.
abstract java.util.Map<Variable,Term>	Solver.solve(ConstraintSatisfactionProblem problem)	Computes a solution to the given constraint satisfaction or optimization problem, i.e.

Methods in net.sf.tweety.math.opt with parameters of type Term

Modifier and Type	Method	Description
void	OptimizationProblem.setTargetFunction(Term targetFunction)	Sets the target function of this problem.

Method parameters in net.sf.tweety.math.opt with type arguments of type Term

Modifier and Type	Method	Description
private java.util.List<java.util.List<java.lang.Double>>	NewtonRootFinder.evaluateMatrix(java.util.List<java.util.List<Term>> functions, java.util.Map<Variable,? extends Term> mapping)	Evaluates each function in the given matrix with the given values for variables.
private java.util.List<java.util.List<java.lang.Double>>	NewtonRootFinder.evaluateMatrix(java.util.List<java.util.List<Term>> functions, java.util.Map<Variable,? extends Term> mapping)	Evaluates each function in the given matrix with the given values for variables.
private java.util.Map<Variable,Term>	NewtonRootFinder.midpoint(java.util.Map<Variable,Term> m1, java.util.Map<Variable,Term> m2)	Computes the midpoint of the two maps
void	RootFinder.setStartingPoint(java.util.Map<Variable,Term> startingPoint)	sets the starting point of this root finder.

Constructors in net.sf.tweety.math.opt with parameters of type Term

Constructor	Description
BfgsRootFinder(Term function, java.util.Map<Variable,Term> startingPoint)	Creates a new root finder for the given starting point and the given function
GradientDescentRootFinder(Term function, java.util.Map<Variable,Term> startingPoint)	Creates a new root finder for the given starting point and the given function
HessianGradientDescentRootFinder(Term function, java.util.Map<Variable,Term> startingPoint)	Creates a new root finder for the given starting point and the given function
LbfgsRootFinder(Term function, java.util.Map<Variable,Term> startingPoint)	Creates a new root finder for the given starting point and the given function
NewtonRootFinder(Term function, java.util.Map<Variable,Term> startingPoint)	Creates a new Newton root finder for the given starting point and the given function
OpenOptRootFinder(Term function, java.util.Map<Variable,Term> startingPoint)	Creates a new root finder for the given starting point and the given function
OptimizationRootFinder(Term function)	Creates a new root finder for the given function.
OptimizationRootFinder(Term function, java.util.Map<Variable,Term> startingPoint)	Creates a new root finder for the given starting point and the given function
RootFinder(Term function)	Creates a new root finder for the given function.
RootFinder(Term function, java.util.Map<Variable,Term> startingPoint)	Creates a new root finder for the given starting point and the given function

Constructor parameters in net.sf.tweety.math.opt with type arguments of type Term

Constructor	Description
BfgsRootFinder(java.util.List<Term> functions, java.util.Map<Variable,Term> startingPoint)	Creates a new root finder for the given starting point and the given (multi-dimensional) function
BfgsRootFinder(java.util.List<Term> functions, java.util.Map<Variable,Term> startingPoint)	Creates a new root finder for the given starting point and the given (multi-dimensional) function
BfgsRootFinder(Term function, java.util.Map<Variable,Term> startingPoint)	Creates a new root finder for the given starting point and the given function
GradientDescentRootFinder(java.util.List<Term> functions, java.util.Map<Variable,Term> startingPoint)	Creates a new root finder for the given starting point and the given (multi-dimensional) function
GradientDescentRootFinder(java.util.List<Term> functions, java.util.Map<Variable,Term> startingPoint)	Creates a new root finder for the given starting point and the given (multi-dimensional) function
GradientDescentRootFinder(Term function, java.util.Map<Variable,Term> startingPoint)	Creates a new root finder for the given starting point and the given function
HessianGradientDescentRootFinder(java.util.List<Term> functions, java.util.Map<Variable,Term> startingPoint)	Creates a new root finder for the given starting point and the given (multi-dimensional) function
HessianGradientDescentRootFinder(java.util.List<Term> functions, java.util.Map<Variable,Term> startingPoint)	Creates a new root finder for the given starting point and the given (multi-dimensional) function
HessianGradientDescentRootFinder(Term function, java.util.Map<Variable,Term> startingPoint)	Creates a new root finder for the given starting point and the given function
LbfgsRootFinder(java.util.List<Term> functions, java.util.Map<Variable,Term> startingPoint)	Creates a new root finder for the given starting point and the given (multi-dimensional) function
LbfgsRootFinder(java.util.List<Term> functions, java.util.Map<Variable,Term> startingPoint)	Creates a new root finder for the given starting point and the given (multi-dimensional) function
LbfgsRootFinder(Term function, java.util.Map<Variable,Term> startingPoint)	Creates a new root finder for the given starting point and the given function
NewtonRootFinder(java.util.List<Term> functions, java.util.Map<Variable,Term> startingPoint)	Creates a new Newton root finder for the given starting point and the given (multi-dimensional) function
NewtonRootFinder(java.util.List<Term> functions, java.util.Map<Variable,Term> startingPoint)	Creates a new Newton root finder for the given starting point and the given (multi-dimensional) function
NewtonRootFinder(Term function, java.util.Map<Variable,Term> startingPoint)	Creates a new Newton root finder for the given starting point and the given function
OpenOptRootFinder(java.util.List<Term> functions, java.util.Map<Variable,Term> startingPoint)	Creates a new root finder for the given starting point and the given (multi-dimensional) function
OpenOptRootFinder(java.util.List<Term> functions, java.util.Map<Variable,Term> startingPoint)	Creates a new root finder for the given starting point and the given (multi-dimensional) function
OpenOptRootFinder(Term function, java.util.Map<Variable,Term> startingPoint)	Creates a new root finder for the given starting point and the given function
OptimizationRootFinder(java.util.List<Term> functions, java.util.Map<Variable,Term> startingPoint)	Creates a new root finder for the given starting point and the given (multi-dimensional) function
OptimizationRootFinder(java.util.List<Term> functions, java.util.Map<Variable,Term> startingPoint)	Creates a new root finder for the given starting point and the given (multi-dimensional) function
OptimizationRootFinder(Term function, java.util.Map<Variable,Term> startingPoint)	Creates a new root finder for the given starting point and the given function
RootFinder(java.util.List<Term> functions, java.util.Map<Variable,Term> startingPoint)	Creates a new root finder for the given starting point and the given (multi-dimensional) function
RootFinder(java.util.List<Term> functions, java.util.Map<Variable,Term> startingPoint)	Creates a new root finder for the given starting point and the given (multi-dimensional) function
RootFinder(Term function, java.util.Map<Variable,Term> startingPoint)	Creates a new root finder for the given starting point and the given function

Uses of Term in net.sf.tweety.math.opt.solver

Fields in net.sf.tweety.math.opt.solver declared as Term

Modifier and Type	Field	Description
private Term	SimpleGeneticOptimizationSolver.FitnessComparator.minT

Fields in net.sf.tweety.math.opt.solver with type parameters of type Term

Modifier and Type	Field	Description
private java.util.Map<Variable,Term>	BfgsSolver.startingPoint	The starting point for the solver.
private java.util.Map<Variable,Term>	GradientDescent.startingPoint	The starting point for the solver.
private java.util.Map<Variable,Term>	HessianGradientDescent.startingPoint	The starting point for the solver.
private java.util.Map<Variable,Term>	LbfgsSolver.startingPoint	The starting point for the solver.
private java.util.Map<Variable,Term>	OpenOptSolver.startingPoint	A starting point for the optimization.
private java.util.Set<java.util.Map<Variable,Term>>	LagrangeSolver.startingPoints	The starting points for finding the optimum.

Methods in net.sf.tweety.math.opt.solver that return types with arguments of type Term

Modifier and Type	Method	Description
private java.util.Map<FloatVariable,Term>	SimpleGeneticOptimizationSolver.crossover(java.util.Map<FloatVariable,Term> ind1, java.util.Map<FloatVariable,Term> ind2)	Makes a crossover of the two individuals
private java.util.Map<FloatVariable,Term>	SimpleGeneticOptimizationSolver.mutate(java.util.Map<FloatVariable,Term> ind)	Mutates the given individual
protected java.util.Map<Variable,Term>	OpenOptSolver.parseOutput(java.lang.String output)	This method parses the output data of an OpenOpt run
java.util.Map<Variable,Term>	ApacheCommonsCMAESOptimizer.solve(ConstraintSatisfactionProblem problem)
java.util.Map<Variable,Term>	ApacheCommonsCMAESOptimizer.solve(Term t, int optimization_type)	Returns the variable assignment that maximizes/minimizes the given term (which only contains variables with defined upper and lower bounds).
java.util.Map<Variable,Term>	ApacheCommonsNonLinearConjugateGradientOptimizer.solve(ConstraintSatisfactionProblem problem)
java.util.Map<Variable,Term>	ApacheCommonsSimplex.solve(ConstraintSatisfactionProblem problem)
java.util.Map<Variable,Term>	BfgsSolver.solve(ConstraintSatisfactionProblem problem)
java.util.Map<Variable,Term>	GlpkSolver.solve(ConstraintSatisfactionProblem problem)
java.util.Map<Variable,Term>	GradientDescent.solve(ConstraintSatisfactionProblem problem)
java.util.Map<Variable,Term>	HessianGradientDescent.solve(ConstraintSatisfactionProblem problem)
java.util.Map<Variable,Term>	LagrangeSolver.solve(ConstraintSatisfactionProblem prob)
java.util.Map<Variable,Term>	LbfgsSolver.solve(ConstraintSatisfactionProblem problem)
java.util.Map<Variable,Term>	LpSolve.solve(ConstraintSatisfactionProblem problem)
java.util.Map<Variable,Term>	OctaveSqpSolver.solve(ConstraintSatisfactionProblem problem)
java.util.Map<Variable,Term>	OpenOptSolver.solve(ConstraintSatisfactionProblem problem)
java.util.Map<Variable,Term>	OpenOptWebSolver.solve(ConstraintSatisfactionProblem problem)
java.util.Map<Variable,Term>	SimpleGeneticOptimizationSolver.solve(ConstraintSatisfactionProblem problem)
java.util.Map<Variable,Term>	SimpleGeneticOptimizationSolver.solve(Term t, int optimization_objective)	Returns the variable assignment that maximizes/minimizes the given term (which only contains variables with defined upper and lower bounds).

Methods in net.sf.tweety.math.opt.solver with parameters of type Term

Modifier and Type	Method	Description
java.util.Map<Variable,Term>	ApacheCommonsCMAESOptimizer.solve(Term t, int optimization_type)	Returns the variable assignment that maximizes/minimizes the given term (which only contains variables with defined upper and lower bounds).
java.util.Map<Variable,Term>	SimpleGeneticOptimizationSolver.solve(Term t, int optimization_objective)	Returns the variable assignment that maximizes/minimizes the given term (which only contains variables with defined upper and lower bounds).

Method parameters in net.sf.tweety.math.opt.solver with type arguments of type Term

Modifier and Type	Method	Description
private double[]	HessianGradientDescent.bestGuess(double[] currentGuess, double[] dir, java.util.List<Term> gradient, java.util.List<Variable> variables)	Find the best guess.
int	SimpleGeneticOptimizationSolver.FitnessComparator.compare(java.util.Map<FloatVariable,Term> arg0, java.util.Map<FloatVariable,Term> arg1)
private java.util.Map<FloatVariable,Term>	SimpleGeneticOptimizationSolver.crossover(java.util.Map<FloatVariable,Term> ind1, java.util.Map<FloatVariable,Term> ind2)	Makes a crossover of the two individuals
private java.util.Map<FloatVariable,Term>	SimpleGeneticOptimizationSolver.mutate(java.util.Map<FloatVariable,Term> ind)	Mutates the given individual

Constructors in net.sf.tweety.math.opt.solver with parameters of type Term

Constructor	Description
FitnessComparator(Term t)

Constructor parameters in net.sf.tweety.math.opt.solver with type arguments of type Term

Constructor	Description
BfgsSolver(java.util.Map<Variable,Term> startingPoint)
GradientDescent(java.util.Map<Variable,Term> startingPoint)	Creates a new gradient descent solver
HessianGradientDescent(java.util.Map<Variable,Term> startingPoint)
LagrangeSolver(java.util.Map<Variable,Term> startingPoint)	Creates a new Lagrange solver for the given optimization problem
LagrangeSolver(java.util.Set<java.util.Map<Variable,Term>> startingPoints)	Creates a new Lagrange solver for the given optimization problem
LbfgsSolver(java.util.Map<Variable,Term> startingPoint)
OpenOptSolver(java.util.Map<Variable,Term> startingPoint)	Creates a new solver for the given problem.

Uses of Term in net.sf.tweety.math.term

Subclasses of Term in net.sf.tweety.math.term

Modifier and Type	Class	Description
class	AbsoluteValue	This class models the absolute value of the inner term.
class	AssociativeOperation
class	BinaryVariable	This class models a binary variable as a mathematical term.
class	Constant	This class models an abstract constant, e.g.
class	Difference	This class models a difference between two terms.
class	Exp	This class represents an exponential expression by "e".
class	FloatConstant	This class encapsulates a float as a term.
class	FloatVariable	This class models an float variable as a mathematical term.
class	Fraction	Instances of this class represent fractions of two terms.
class	FunctionalTerm	Instances of this class represent a functional term on some inner term.
class	IntegerConstant	This class encapsulates an integer as a term.
class	IntegerVariable	This class models an integer variable as a mathematical term.
class	Logarithm	Instances of this class represent application of the logarithm function on some term.
class	Maximum	This class models the maximum of two terms.
class	Minimum	This class models the minimum of two terms.
class	Power	This class represents a term raised to some power.
class	Product	This class models a product of two terms.
class	Root	This class represents a the nth root function
class	Sum	This class models a sum of two terms.
class	Variable	This class models a variable as a mathematical term.

Fields in net.sf.tweety.math.term declared as Term

Modifier and Type	Field	Description
private Term	Root.base	The base of the root
private Term	Fraction.denominator	The denominator of the fraction.
private Term	Difference.first	The two terms of the difference
private Term	Fraction.nominator	The nominator of the fraction.
private Term	Power.power	The power.
private Term	Difference.second	The two terms of the difference
private Term	FunctionalTerm.term	The inner term of this operation.

Fields in net.sf.tweety.math.term with type parameters of type Term

Modifier and Type	Field	Description
private java.util.List<Term>	AssociativeOperation.terms	The terms of this operation.

Methods in net.sf.tweety.math.term that return Term

Modifier and Type	Method	Description
Term	AbsoluteValue.derive(Variable v)
Term	Constant.derive(Variable v)
Term	Difference.derive(Variable v)
Term	Exp.derive(Variable v)
Term	Fraction.derive(Variable v)
Term	Logarithm.derive(Variable v)
Term	Maximum.derive(Variable v)
Term	Minimum.derive(Variable v)
Term	Power.derive(Variable v)
Term	Product.derive(Variable v)
Term	Root.derive(Variable v)
Term	Sum.derive(Variable v)
abstract Term	Term.derive(Variable v)	Differentiates the term with respect to the given variable.
Term	Variable.derive(Variable v)
Term	FunctionalTerm.getTerm()	Returns the inner term.
Term	Term.min(Term t)	Returns the minimum of this and the given term.
Term	Term.replaceAllTerms(double[] values, java.util.List<Variable> variables)	Replaces terms according to the given map.
Term	Term.replaceAllTerms(java.util.Map<? extends Term,? extends Term> substitutes)	Replaces terms according to the given map.
Term	AbsoluteValue.replaceTerm(Term toSubstitute, Term substitution)
Term	Constant.replaceTerm(Term toSubstitute, Term substitution)
Term	Difference.replaceTerm(Term toSubstitute, Term substitution)
Term	Exp.replaceTerm(Term toSubstitute, Term substitution)
Term	Fraction.replaceTerm(Term toSubstitute, Term substitution)
abstract Term	FunctionalTerm.replaceTerm(Term toSubstitute, Term substitution)
Term	Logarithm.replaceTerm(Term toSubstitute, Term substitution)
Term	Maximum.replaceTerm(Term toSubstitute, Term substitution)
Term	Minimum.replaceTerm(Term toSubstitute, Term substitution)
Term	Power.replaceTerm(Term toSubstitute, Term substitution)
Term	Product.replaceTerm(Term toSubstitute, Term substitution)
Term	Root.replaceTerm(Term toSubstitute, Term substitution)
Term	Sum.replaceTerm(Term toSubstitute, Term substitution)
abstract Term	Term.replaceTerm(Term toSubstitute, Term substitution)	Replaces each occurrence of "toSubstitute" by "substitution" and return the new term.
Term	Variable.replaceTerm(Term toSubstitute, Term substitution)
Term	AbsoluteValue.simplify()
Term	Constant.simplify()
Term	Difference.simplify()
Term	Exp.simplify()
Term	Fraction.simplify()
Term	Logarithm.simplify()
Term	Maximum.simplify()
Term	Minimum.simplify()
Term	Power.simplify()
Term	Product.simplify()
Term	Root.simplify()
Term	Sum.simplify()
abstract Term	Term.simplify()	Simplifies this term in an equivalent way: - Replaces products that contain a zero by the constant zero - Removes a term one from products - Removes a term zero from sums - Aggregates constants in sums, products, and minimums - Evaluates functional terms on constants - Simplifies fractions where possible.
Term	Variable.simplify()

Methods in net.sf.tweety.math.term that return types with arguments of type Term

Modifier and Type	Method	Description
java.util.List<Term>	AssociativeOperation.getTerms()	Returns the terms of this operation.

Methods in net.sf.tweety.math.term with parameters of type Term

Modifier and Type	Method	Description
Sum	Term.add(Term t)	Returns the sum of this and the given term.
void	AssociativeOperation.addTerm(Term t)	Adds the given term to this operation.
Term	Term.min(Term t)	Returns the minimum of this and the given term.
Difference	Term.minus(Term t)	Returns the sum of this and (-1) * the given term.
Product	Term.mult(Term t)	Returns the product of this and the given term.
void	AssociativeOperation.removeTerm(Term t)	Removes the given term from this operation.
Term	AbsoluteValue.replaceTerm(Term toSubstitute, Term substitution)
Term	Constant.replaceTerm(Term toSubstitute, Term substitution)
Term	Difference.replaceTerm(Term toSubstitute, Term substitution)
Term	Exp.replaceTerm(Term toSubstitute, Term substitution)
Term	Fraction.replaceTerm(Term toSubstitute, Term substitution)
abstract Term	FunctionalTerm.replaceTerm(Term toSubstitute, Term substitution)
Term	Logarithm.replaceTerm(Term toSubstitute, Term substitution)
Term	Maximum.replaceTerm(Term toSubstitute, Term substitution)
Term	Minimum.replaceTerm(Term toSubstitute, Term substitution)
Term	Power.replaceTerm(Term toSubstitute, Term substitution)
Term	Product.replaceTerm(Term toSubstitute, Term substitution)
Term	Root.replaceTerm(Term toSubstitute, Term substitution)
Term	Sum.replaceTerm(Term toSubstitute, Term substitution)
abstract Term	Term.replaceTerm(Term toSubstitute, Term substitution)	Replaces each occurrence of "toSubstitute" by "substitution" and return the new term.
Term	Variable.replaceTerm(Term toSubstitute, Term substitution)

Method parameters in net.sf.tweety.math.term with type arguments of type Term

Modifier and Type	Method	Description
void	AssociativeOperation.addAllTerm(java.util.Collection<Term> terms)	Adds all the given terms of this operation.
static double[][]	Term.evaluateMatrix(java.util.List<java.util.List<Term>> functions, double[] values, java.util.List<Variable> variables)	Evaluates each function in the given matrix with the given values for variables.
static double[]	Term.evaluateVector(java.util.List<Term> functions, double[] values, java.util.List<Variable> variables)	Evaluates each function in the given list with the given values for variables.
static java.util.List<java.lang.Double>	Term.evaluateVector(java.util.List<Term> functions, java.util.Map<Variable,? extends Term> mapping)	Evaluates each function in the given list with the given values for variables.
static java.util.List<java.lang.Double>	Term.evaluateVector(java.util.List<Term> functions, java.util.Map<Variable,? extends Term> mapping)	Evaluates each function in the given list with the given values for variables.
Term	Term.replaceAllTerms(java.util.Map<? extends Term,? extends Term> substitutes)	Replaces terms according to the given map.
Term	Term.replaceAllTerms(java.util.Map<? extends Term,? extends Term> substitutes)	Replaces terms according to the given map.

Constructors in net.sf.tweety.math.term with parameters of type Term

Constructor	Description
AbsoluteValue(Term term)	Creates a new absolute value term with the given inner term.
AssociativeOperation(Term first, Term second)	Creates a new operation with the given terms.
Difference(Term first, Term second)	Creates a new difference with the given terms.
Exp(Term term)	Creates a new exponential term with the given term.
Fraction(Term nominator, Term denominator)	Creates a new fraction of the two given terms.
FunctionalTerm(Term term)	Creates a new functional term with the given inner term.
Logarithm(Term term)	Creates a new logarithm term for the give inner term.
Maximum(Term first, Term second)	Creates a new maximum with the given terms.
Minimum(Term first, Term second)	Creates a new minimum with the given terms.
Power(Term term, Term power)	Creates a new power term with the given term and power.
Product(Term first, Term second)	Creates a new product with the given terms.
Root(Term term)	Creates a new square root.
Root(Term term, Term base)	Creates a new root for the given base.
Sum(Term first, Term second)	Creates a new sum with the given terms.

Constructor parameters in net.sf.tweety.math.term with type arguments of type Term

Constructor	Description
AssociativeOperation(java.util.Collection<? extends Term> terms)	Creates a new operation with the given list of terms.
Maximum(java.util.List<Term> terms)	Creates a new maximum with the given list of terms.
Minimum(java.util.List<Term> terms)	Creates a new minimum with the given list of terms.
Product(java.util.Collection<? extends Term> terms)	Creates a new product with the given list of terms.
Sum(java.util.Collection<? extends Term> terms)	Creates a new sum with the given list of terms.