Package | Description |
---|---|
net.sf.tweety.logics.pl.analysis | |
net.sf.tweety.math.opt | |
net.sf.tweety.math.opt.solver | |
net.sf.tweety.math.term |
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 |
---|---|
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
|
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 | Field and Description |
---|---|
private java.util.Map<Variable,Term> |
RootFinder.startingPoint
The starting point of this root finder.
|
Modifier and Type | Method and Description |
---|---|
java.util.Map<Variable,Term> |
RootFinder.getStartingPoint()
Returns the starting point of this finder.
|
java.util.Set<Variable> |
ConstraintSatisfactionProblem.getVariables()
Returns all variables of this problem.
|
java.util.Set<Variable> |
OptimizationProblem.getVariables() |
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 |
---|---|
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(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(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(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(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(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(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(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(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 java.util.Map<java.lang.Integer,Variable> |
OpenOptSolver.idx2newVars
A map mapping indices to new variables.
|
private java.util.Map<Variable,Variable> |
OpenOptSolver.newVars2oldVars
A map mapping old variables to new variables.
|
private java.util.Map<Variable,Variable> |
OpenOptSolver.newVars2oldVars
A map mapping old variables to new variables.
|
private java.util.Map<Variable,Variable> |
OpenOptSolver.oldVars2newVars
A map mapping old variables to new variables.
|
private java.util.Map<Variable,Variable> |
OpenOptSolver.oldVars2newVars
A map mapping old variables to new variables.
|
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 |
---|---|
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 |
---|---|
private double[] |
HessianGradientDescent.bestGuess(double[] currentGuess,
double[] dir,
java.util.List<Term> gradient,
java.util.List<Variable> variables)
Find the best guess.
|
private Matrix |
BfgsSolver.evaluate(Matrix gradient,
Matrix currentGuess,
java.util.List<Variable> variables) |
private double |
BfgsSolver.nextBestStep(Matrix currentGuess,
Matrix searchDirection,
Matrix gradient,
java.util.List<Variable> variables) |
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 |
BinaryVariable
This class models a binary variable as a mathematical term.
|
class |
FloatVariable
This class models an float variable as a mathematical term.
|
class |
IntegerVariable
This class models an integer variable as a mathematical term.
|
Modifier and Type | Method and Description |
---|---|
java.util.Set<Variable> |
Variable.getVariables() |
java.util.Set<Variable> |
FunctionalTerm.getVariables() |
abstract java.util.Set<Variable> |
Term.getVariables()
Returns all variables in this term.
|
java.util.Set<Variable> |
Difference.getVariables() |
java.util.Set<Variable> |
AssociativeOperation.getVariables() |
java.util.Set<Variable> |
Fraction.getVariables() |
java.util.Set<Variable> |
Constant.getVariables() |
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) |
boolean |
Variable.isContinuous(Variable v) |
abstract boolean |
Term.isContinuous(Variable v)
Checks whether this term is continuous in v.
|
boolean |
Product.isContinuous(Variable v) |
boolean |
Difference.isContinuous(Variable v) |
boolean |
Minimum.isContinuous(Variable v) |
boolean |
Sum.isContinuous(Variable v) |
boolean |
Maximum.isContinuous(Variable v) |
boolean |
Root.isContinuous(Variable v) |
boolean |
Exp.isContinuous(Variable v) |
boolean |
Fraction.isContinuous(Variable v) |
boolean |
AbsoluteValue.isContinuous(Variable v) |
boolean |
Logarithm.isContinuous(Variable v) |
boolean |
Constant.isContinuous(Variable v) |
boolean |
Power.isContinuous(Variable v) |
Modifier and Type | Method and Description |
---|---|
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.
|
Term |
Term.replaceAllTerms(double[] values,
java.util.List<Variable> variables)
Replaces terms according to the given map.
|