Modifier and Type | Method and 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) |
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) |
Modifier and Type | Method and 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.
|
Modifier and Type | Method and Description |
---|---|
private Term |
FuzzyInconsistencyMeasure.getTerm(PropositionalFormula 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).
|
Modifier and Type | Method and Description |
---|---|
private Pair<java.util.Map<Variable,Term>,java.lang.Double> |
FuzzyInconsistencyMeasure.constructAndSolveProblem(java.util.Collection<PropositionalFormula> formulas,
java.util.Map<Proposition,Variable> assignments)
Utility method
|
Modifier and Type | Method and 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.
|
Modifier and Type | Field and Description |
---|---|
private Term |
Statement.leftTerm
The left term of this statement.
|
private Term |
Statement.rightTerm
The right term of this statement.
|
Modifier and Type | Method and Description |
---|---|
Term |
Statement.getLeftTerm()
Returns the left term of this statement.
|
Term |
Statement.getRightTerm()
Returns the right term of this statement.
|
Modifier and Type | Method and Description |
---|---|
abstract Statement |
Statement.replaceTerm(Term toSubstitute,
Term substitution)
Replaces each occurrence of "toSubstitute" by "substitution" and
return the new statement.
|
Statement |
Inequation.replaceTerm(Term toSubstitute,
Term substitution) |
Statement |
Equation.replaceTerm(Term toSubstitute,
Term substitution) |
void |
Statement.setLeftTerm(Term t)
Sets the left term of this statement.
|
void |
Statement.setRightTerm(Term t)
Sets the right term of this statement.
|
Modifier and Type | Method and 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.
|
Constructor and 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.
|
Modifier and Type | Method and Description |
---|---|
Term |
SimpleRealValuedFunction.getTerm(java.util.Vector<Term> element) |
Term |
EntropyFunction.getTerm(java.util.Vector<Term> element) |
Modifier and Type | Method and Description |
---|---|
Term |
SimpleRealValuedFunction.getTerm(java.util.Vector<Term> element) |
Term |
EntropyFunction.getTerm(java.util.Vector<Term> element) |
Modifier and Type | Method and Description |
---|---|
Term |
TNorm.evalTerm(java.util.Collection<Term> vals)
Gives a representation of this norm as a mathematical term.
|
Term |
TCoNorm.evalTerm(java.util.Collection<Term> vals)
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
|
Term |
ProbabilisticSum.evalTerm(Term val1,
Term val2) |
Term |
MinimumNorm.evalTerm(Term val1,
Term val2) |
Term |
LukasiewiczNorm.evalTerm(Term val1,
Term val2) |
Term |
MaximumCoNorm.evalTerm(Term val1,
Term val2) |
Term |
ProductNorm.evalTerm(Term val1,
Term val2) |
Term |
BoundedSum.evalTerm(Term val1,
Term val2) |
abstract Term |
TCoNorm.evalTerm(Term val1,
Term val2)
Gives a representation of this conorm as a mathematical term
|
Modifier and Type | Method and Description |
---|---|
abstract Term |
TNorm.evalTerm(Term val1,
Term val2)
Gives a representation of this norm as a mathematical term
|
Term |
ProbabilisticSum.evalTerm(Term val1,
Term val2) |
Term |
MinimumNorm.evalTerm(Term val1,
Term val2) |
Term |
LukasiewiczNorm.evalTerm(Term val1,
Term val2) |
Term |
MaximumCoNorm.evalTerm(Term val1,
Term val2) |
Term |
ProductNorm.evalTerm(Term val1,
Term val2) |
Term |
BoundedSum.evalTerm(Term val1,
Term val2) |
abstract Term |
TCoNorm.evalTerm(Term val1,
Term val2)
Gives a representation of this conorm as a mathematical term
|
Modifier and Type | Method and Description |
---|---|
Term |
TNorm.evalTerm(java.util.Collection<Term> vals)
Gives a representation of this norm as a mathematical term.
|
Term |
TCoNorm.evalTerm(java.util.Collection<Term> vals)
Gives a representation of this conorm as a mathematical term.
|
Modifier and Type | Field and Description |
---|---|
private Term[][] |
Matrix.entries
The entries of the matrix
|
Modifier and Type | Method and Description |
---|---|
Term |
Matrix.getEntry(int x,
int y)
Returns the entry with the given coordinates.
|
Modifier and Type | Method and 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.
|
Modifier and Type | Method and Description |
---|---|
Term |
ProbabilisticAggregatingNorm.distanceTerm(Term[] obj1,
Term[] obj2) |
Term |
RealVectorNorm.distanceTerm(Term[] obj1,
Term[] obj2)
The distance between the two objects as a term.
|
Term |
AbstractRealVectorNorm.distanceTerm(Term[] obj1,
Term[] obj2) |
Term |
EntropyNorm.distanceTerm(Term[] obj1,
Term[] obj2) |
Term |
ProbabilisticPNorm.distanceTerm(Term[] obj1,
Term[] obj2) |
Term |
AggregatingNorm.distanceTerm(Term[] obj1,
Term[] obj2) |
Term |
ProbabilisticAggregatingNorm.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.
|
Term |
MaximumNorm.distanceTerm(java.util.Vector<Term> obj1,
java.util.Vector<Term> obj2) |
abstract Term |
AbstractRealVectorNorm.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 |
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 |
ProbabilisticPNorm.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 |
ProbabilisticAggregatingNorm.normTerm(Term[] obj) |
Term |
RealVectorNorm.normTerm(Term[] obj)
Returns the norm as a term of the given terms
|
Term |
AbstractRealVectorNorm.normTerm(Term[] obj) |
Term |
EntropyNorm.normTerm(Term[] obj) |
Term |
ProbabilisticPNorm.normTerm(Term[] obj) |
Term |
AggregatingNorm.normTerm(Term[] obj) |
Term |
ProbabilisticAggregatingNorm.normTerm(java.util.Vector<Term> obj) |
Term |
RealVectorNorm.normTerm(java.util.Vector<Term> obj)
Returns the norm as a term of the given terms
|
Term |
MaximumNorm.normTerm(java.util.Vector<Term> obj) |
abstract Term |
AbstractRealVectorNorm.normTerm(java.util.Vector<Term> obj) |
Term |
PNorm.normTerm(java.util.Vector<Term> obj) |
Term |
EntropyNorm.normTerm(java.util.Vector<Term> obj) |
Term |
ManhattanNorm.normTerm(java.util.Vector<Term> obj) |
Term |
ProbabilisticPNorm.normTerm(java.util.Vector<Term> obj) |
Term |
AggregatingNorm.normTerm(java.util.Vector<Term> obj) |
Modifier and Type | Method and Description |
---|---|
Term |
ProbabilisticAggregatingNorm.distanceTerm(Term[] obj1,
Term[] obj2) |
Term |
ProbabilisticAggregatingNorm.distanceTerm(Term[] obj1,
Term[] obj2) |
Term |
RealVectorNorm.distanceTerm(Term[] obj1,
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.
|
Term |
AbstractRealVectorNorm.distanceTerm(Term[] obj1,
Term[] obj2) |
Term |
AbstractRealVectorNorm.distanceTerm(Term[] obj1,
Term[] obj2) |
Term |
EntropyNorm.distanceTerm(Term[] obj1,
Term[] obj2) |
Term |
EntropyNorm.distanceTerm(Term[] obj1,
Term[] obj2) |
Term |
ProbabilisticPNorm.distanceTerm(Term[] obj1,
Term[] obj2) |
Term |
ProbabilisticPNorm.distanceTerm(Term[] obj1,
Term[] obj2) |
Term |
AggregatingNorm.distanceTerm(Term[] obj1,
Term[] obj2) |
Term |
AggregatingNorm.distanceTerm(Term[] obj1,
Term[] obj2) |
Term |
ProbabilisticAggregatingNorm.normTerm(Term[] obj) |
Term |
RealVectorNorm.normTerm(Term[] obj)
Returns the norm as a term of the given terms
|
Term |
AbstractRealVectorNorm.normTerm(Term[] obj) |
Term |
EntropyNorm.normTerm(Term[] obj) |
Term |
ProbabilisticPNorm.normTerm(Term[] obj) |
Term |
AggregatingNorm.normTerm(Term[] obj) |
Modifier and Type | Method and Description |
---|---|
Term |
ProbabilisticAggregatingNorm.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 |
RealVectorNorm.distanceTerm(java.util.Vector<Term> obj1,
java.util.Vector<Term> obj2)
The distance between the two objects as a term.
|
Term |
RealVectorNorm.distanceTerm(java.util.Vector<Term> obj1,
java.util.Vector<Term> obj2)
The distance between the two objects as a term.
|
Term |
MaximumNorm.distanceTerm(java.util.Vector<Term> obj1,
java.util.Vector<Term> obj2) |
Term |
MaximumNorm.distanceTerm(java.util.Vector<Term> obj1,
java.util.Vector<Term> obj2) |
abstract Term |
AbstractRealVectorNorm.distanceTerm(java.util.Vector<Term> obj1,
java.util.Vector<Term> obj2) |
abstract Term |
AbstractRealVectorNorm.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 |
PNorm.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 |
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 |
ManhattanNorm.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 |
ProbabilisticPNorm.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 |
AggregatingNorm.distanceTerm(java.util.Vector<Term> obj1,
java.util.Vector<Term> obj2) |
Term |
ProbabilisticAggregatingNorm.normTerm(java.util.Vector<Term> obj) |
Term |
RealVectorNorm.normTerm(java.util.Vector<Term> obj)
Returns the norm as a term of the given terms
|
Term |
MaximumNorm.normTerm(java.util.Vector<Term> obj) |
abstract Term |
AbstractRealVectorNorm.normTerm(java.util.Vector<Term> obj) |
Term |
PNorm.normTerm(java.util.Vector<Term> obj) |
Term |
EntropyNorm.normTerm(java.util.Vector<Term> obj) |
Term |
ManhattanNorm.normTerm(java.util.Vector<Term> obj) |
Term |
ProbabilisticPNorm.normTerm(java.util.Vector<Term> obj) |
Term |
AggregatingNorm.normTerm(java.util.Vector<Term> obj) |
Modifier and Type | Field and Description |
---|---|
private Term |
OptimizationProblem.targetFunction
The target function of this problem.
|
Modifier and Type | Field and 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.
|
Modifier and Type | Method and Description |
---|---|
Term |
OptimizationProblem.getTargetFunction()
Returns the target function of this problem.
|
Modifier and Type | Method and 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> |
NewtonRootFinder.randomRoot() |
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> |
OpenOptRootFinder.randomRoot() |
java.util.Map<Variable,Term> |
LbfgsRootFinder.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.
|
Modifier and Type | Method and Description |
---|---|
void |
OptimizationProblem.setTargetFunction(Term targetFunction)
Sets the target function of this problem.
|
Modifier and Type | Method and 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
|
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.
|
Constructor and 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 and 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
|
Modifier and Type | Field and Description |
---|---|
private Term |
SimpleGeneticOptimizationSolver.FitnessComparator.minT |
Modifier and Type | Field and Description |
---|---|
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> |
BfgsSolver.startingPoint
The starting point for the solver.
|
private java.util.Map<Variable,Term> |
OpenOptSolver.startingPoint
A starting point for the optimization.
|
private java.util.Map<Variable,Term> |
GradientDescent.startingPoint
The starting point for the solver.
|
private java.util.Set<java.util.Map<Variable,Term>> |
LagrangeSolver.startingPoints
The starting points for finding the optimum.
|
Modifier and Type | Method and 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> |
HessianGradientDescent.solve(ConstraintSatisfactionProblem problem) |
java.util.Map<Variable,Term> |
ApacheCommonsSimplex.solve(ConstraintSatisfactionProblem problem) |
java.util.Map<Variable,Term> |
ApacheCommonsCMAESOptimizer.solve(ConstraintSatisfactionProblem problem) |
java.util.Map<Variable,Term> |
OpenOptWebSolver.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> |
LbfgsSolver.solve(ConstraintSatisfactionProblem problem) |
java.util.Map<Variable,Term> |
SimpleGeneticOptimizationSolver.solve(ConstraintSatisfactionProblem problem) |
java.util.Map<Variable,Term> |
LagrangeSolver.solve(ConstraintSatisfactionProblem prob) |
java.util.Map<Variable,Term> |
BfgsSolver.solve(ConstraintSatisfactionProblem problem) |
java.util.Map<Variable,Term> |
OpenOptSolver.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> |
ApacheCommonsNonLinearConjugateGradientOptimizer.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> |
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).
|
Modifier and Type | Method and 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).
|
Modifier and Type | Method and 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) |
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.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
|
Constructor and Description |
---|
FitnessComparator(Term t) |
Constructor and 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.
|
Modifier and Type | Class and 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.
|
Modifier and Type | Field and 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.
|
Modifier and Type | Field and Description |
---|---|
private java.util.List<Term> |
AssociativeOperation.terms
The terms of this operation.
|
Modifier and Type | Method and Description |
---|---|
Term |
Variable.derive(Variable v) |
abstract Term |
Term.derive(Variable v)
Differentiates the term with respect to the given variable.
|
Term |
Product.derive(Variable v) |
Term |
Difference.derive(Variable v) |
Term |
Minimum.derive(Variable v) |
Term |
Sum.derive(Variable v) |
Term |
Maximum.derive(Variable v) |
Term |
Root.derive(Variable v) |
Term |
Exp.derive(Variable v) |
Term |
Fraction.derive(Variable v) |
Term |
AbsoluteValue.derive(Variable v) |
Term |
Logarithm.derive(Variable v) |
Term |
Constant.derive(Variable v) |
Term |
Power.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 |
Variable.replaceTerm(Term toSubstitute,
Term substitution) |
abstract Term |
FunctionalTerm.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 |
Product.replaceTerm(Term toSubstitute,
Term substitution) |
Term |
Difference.replaceTerm(Term toSubstitute,
Term substitution) |
Term |
Minimum.replaceTerm(Term toSubstitute,
Term substitution) |
Term |
Sum.replaceTerm(Term toSubstitute,
Term substitution) |
Term |
Maximum.replaceTerm(Term toSubstitute,
Term substitution) |
Term |
Root.replaceTerm(Term toSubstitute,
Term substitution) |
Term |
Exp.replaceTerm(Term toSubstitute,
Term substitution) |
Term |
Fraction.replaceTerm(Term toSubstitute,
Term substitution) |
Term |
AbsoluteValue.replaceTerm(Term toSubstitute,
Term substitution) |
Term |
Logarithm.replaceTerm(Term toSubstitute,
Term substitution) |
Term |
Constant.replaceTerm(Term toSubstitute,
Term substitution) |
Term |
Power.replaceTerm(Term toSubstitute,
Term substitution) |
Term |
Variable.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 |
Product.simplify() |
Term |
Difference.simplify() |
Term |
Minimum.simplify() |
Term |
Sum.simplify() |
Term |
Maximum.simplify() |
Term |
Root.simplify() |
Term |
Exp.simplify() |
Term |
Fraction.simplify() |
Term |
AbsoluteValue.simplify() |
Term |
Logarithm.simplify() |
Term |
Constant.simplify() |
Term |
Power.simplify() |
Modifier and Type | Method and Description |
---|---|
java.util.List<Term> |
AssociativeOperation.getTerms()
Returns the terms of this operation.
|
Modifier and Type | Method and 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 |
Variable.replaceTerm(Term toSubstitute,
Term substitution) |
abstract Term |
FunctionalTerm.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 |
Product.replaceTerm(Term toSubstitute,
Term substitution) |
Term |
Difference.replaceTerm(Term toSubstitute,
Term substitution) |
Term |
Minimum.replaceTerm(Term toSubstitute,
Term substitution) |
Term |
Sum.replaceTerm(Term toSubstitute,
Term substitution) |
Term |
Maximum.replaceTerm(Term toSubstitute,
Term substitution) |
Term |
Root.replaceTerm(Term toSubstitute,
Term substitution) |
Term |
Exp.replaceTerm(Term toSubstitute,
Term substitution) |
Term |
Fraction.replaceTerm(Term toSubstitute,
Term substitution) |
Term |
AbsoluteValue.replaceTerm(Term toSubstitute,
Term substitution) |
Term |
Logarithm.replaceTerm(Term toSubstitute,
Term substitution) |
Term |
Constant.replaceTerm(Term toSubstitute,
Term substitution) |
Term |
Power.replaceTerm(Term toSubstitute,
Term substitution) |
Modifier and Type | Method and 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.
|
Constructor and 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 and 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.
|