Uses of Interface
org.projog.clp.Expression

Packages that use Expression

Package	Description
org.projog.clp	A constraint logic programming library for finite domains.
org.projog.clp.bool	Contains boolean constraints.
org.projog.clp.compare	Contains constraints which compare numeric values represented by instances of Expression.
org.projog.clp.math	Contains classes that perform arithmetic operators using instances of Expression.

Uses of Expression in org.projog.clp

Subinterfaces of Expression in org.projog.clp

Modifier and Type	Interface	Description
interface	Constraint	A rule that restricts the numeric values that can be used to solve a problem.
interface	LeafExpression

Classes in org.projog.clp that implement Expression

Modifier and Type	Class	Description
class	FixedValue	Represents a single immutable number.
class	Variable	An expression that can have one or more possible numeric values.

Fields in org.projog.clp declared as Expression

Modifier and Type	Field	Description
private Expression	ClpConstraintStore.Enforce.expression

Methods in org.projog.clp that return Expression

Modifier and Type	Method	Description
Expression	Expression.replace(java.util.function.Function<LeafExpression,LeafExpression> function)	Returns a Expression with LeafExpressions in this Expression replaced with values returned from the given function.

Methods in org.projog.clp with parameters of type Expression

Modifier and Type	Method	Description
ClpConstraintStore.Enforce	ClpConstraintStore.Builder.enforce(Expression e)
void	ClpConstraintStore.Enforce.equalTo(Expression opposite)
private VariableState	ClpConstraintStore.getExpression(Expression e)
long	ClpConstraintStore.getMax(Expression id)
long	ReadConstraintStore.getMax(Expression id)
long	ClpConstraintStore.getMin(Expression id)
long	ReadConstraintStore.getMin(Expression id)
void	ClpConstraintStore.Enforce.lessThan(Expression opposite)
void	ClpConstraintStore.Enforce.lessThanOrEqualTo(Expression opposite)
void	ClpConstraintStore.Enforce.notEqualTo(Expression opposite)
ClpConstraintStore.EnforceAll	ClpConstraintStore.EnforceAll.notEqualTo(Expression opposite)
ExpressionResult	ClpConstraintStore.setMax(Expression id, long max)
ExpressionResult	ConstraintStore.setMax(Expression id, long max)
ExpressionResult	ClpConstraintStore.setMin(Expression id, long min)
ExpressionResult	ConstraintStore.setMin(Expression id, long min)
ExpressionResult	ClpConstraintStore.setNot(Expression id, long not)
ExpressionResult	ConstraintStore.setNot(Expression id, long not)
ExpressionResult	ClpConstraintStore.setValue(Expression id, long value)
ExpressionResult	ConstraintStore.setValue(Expression id, long value)
private ExpressionResult	ClpConstraintStore.update(Expression e, VariableStateResult r)

Method parameters in org.projog.clp with type arguments of type Expression

Modifier and Type	Method	Description
void	Constraint.walk(java.util.function.Consumer<Expression> consumer)	Traverse this constraint.
void	Expression.walk(java.util.function.Consumer<Expression> consumer)	Traverse this expression.
void	FixedValue.walk(java.util.function.Consumer<Expression> r)
void	Variable.walk(java.util.function.Consumer<Expression> r)

Constructors in org.projog.clp with parameters of type Expression

Constructor	Description
Enforce(ClpConstraintStore.Builder builder, Expression expression)

Uses of Expression in org.projog.clp.bool

Classes in org.projog.clp.bool that implement Expression

Modifier and Type	Class	Description
class	And
class	Equivalent
class	Implication
class	Nand
class	Nor
class	Not
class	Or
class	Xor

Method parameters in org.projog.clp.bool with type arguments of type Expression

Modifier and Type	Method	Description
void	And.walk(java.util.function.Consumer<Expression> r)
void	Equivalent.walk(java.util.function.Consumer<Expression> r)
void	Implication.walk(java.util.function.Consumer<Expression> r)
void	Nand.walk(java.util.function.Consumer<Expression> r)
void	Nor.walk(java.util.function.Consumer<Expression> r)
void	Not.walk(java.util.function.Consumer<Expression> r)
void	Or.walk(java.util.function.Consumer<Expression> r)
void	Xor.walk(java.util.function.Consumer<Expression> r)

Uses of Expression in org.projog.clp.compare

Classes in org.projog.clp.compare that implement Expression

Modifier and Type	Class	Description
class	Between	Enforces that the possible values of a given Expression are within the given range.
class	EqualTo	Enforces that two Expressions have the same value.
class	LessThan	Enforces that the value of one Expression is less than another.
class	LessThanOrEqualTo	Enforces that the value of one Expression is less than or equal to another.
class	NotEqualTo	Enforces that two Expressions do not have the same value.

Fields in org.projog.clp.compare declared as Expression

Modifier and Type	Field	Description
private Expression	Between.e
private Expression	EqualTo.left
private Expression	LessThan.left
private Expression	LessThanOrEqualTo.left
private Expression	NotEqualTo.left
private Expression	EqualTo.right
private Expression	LessThan.right
private Expression	LessThanOrEqualTo.right
private Expression	NotEqualTo.right

Methods in org.projog.clp.compare with parameters of type Expression

Modifier and Type	Method	Description
(package private) static ConstraintResult	EqualTo.enforce(Expression left, Expression right, ConstraintStore m)
(package private) static ConstraintResult	LessThan.enforce(Expression left, Expression right, ConstraintStore m)
(package private) static ConstraintResult	LessThanOrEqualTo.enforce(Expression left, Expression right, ConstraintStore m)
(package private) static ConstraintResult	NotEqualTo.enforce(Expression left, Expression right, ConstraintStore m)

Method parameters in org.projog.clp.compare with type arguments of type Expression

Modifier and Type	Method	Description
void	Between.walk(java.util.function.Consumer<Expression> r)
void	EqualTo.walk(java.util.function.Consumer<Expression> r)
void	LessThan.walk(java.util.function.Consumer<Expression> r)
void	LessThanOrEqualTo.walk(java.util.function.Consumer<Expression> r)
void	NotEqualTo.walk(java.util.function.Consumer<Expression> r)

Constructors in org.projog.clp.compare with parameters of type Expression

Constructor	Description
Between(Expression e, long min, long max)	Enforces that the possible values of the given Expression are within the given range (inclusive).
EqualTo(Expression left, Expression right)
LessThan(Expression left, Expression right)	Enforces that the value of left is less than the value of right.
LessThanOrEqualTo(Expression left, Expression right)	Enforces that the value of left is less than or equal to the value of right.
NotEqualTo(Expression left, Expression right)

Uses of Expression in org.projog.clp.math

Classes in org.projog.clp.math that implement Expression

Modifier and Type	Class	Description
class	Absolute
class	Add	The sum of two Expressions.
class	Divide	The result of dividing one Expression by another.
class	Maximum
class	Minimum
class	Minus
class	Multiply	The product of two Expressions.
class	Subtract	The difference of two Expressions.

Fields in org.projog.clp.math declared as Expression

Modifier and Type	Field	Description
private Expression	Absolute.e
private Expression	Minus.e
private Expression	Add.left
private Expression	Divide.left	The dividend.
private Expression	Maximum.left
private Expression	Minimum.left
private Expression	Multiply.left
private Expression	Subtract.left
private Expression	Add.right
private Expression	Divide.right	The divisor.
private Expression	Maximum.right
private Expression	Minimum.right
private Expression	Multiply.right
private Expression	Subtract.right

Methods in org.projog.clp.math with parameters of type Expression

Modifier and Type	Method	Description
private static ExpressionResult	Multiply.setMax(ConstraintStore s, Expression left, long max, long leftMax, long rightMin, long rightMax, java.util.function.BiFunction<java.lang.Long,java.lang.Long,java.lang.Long> f)
private static ExpressionResult	Multiply.setMin(ConstraintStore s, Expression left, long min, long leftMin, long rightMin, long rightMax, java.util.function.BiFunction<java.lang.Long,java.lang.Long,java.lang.Long> f)

Method parameters in org.projog.clp.math with type arguments of type Expression

Modifier and Type	Method	Description
void	Absolute.walk(java.util.function.Consumer<Expression> consumer)
void	Add.walk(java.util.function.Consumer<Expression> r)
void	Divide.walk(java.util.function.Consumer<Expression> r)
void	Maximum.walk(java.util.function.Consumer<Expression> r)
void	Minimum.walk(java.util.function.Consumer<Expression> r)
void	Minus.walk(java.util.function.Consumer<Expression> consumer)
void	Multiply.walk(java.util.function.Consumer<Expression> r)
void	Subtract.walk(java.util.function.Consumer<Expression> r)

Constructors in org.projog.clp.math with parameters of type Expression

Constructor	Description
Absolute(Expression e)
Add(Expression left, Expression right)
Divide(Expression left, Expression right)
Maximum(Expression left, Expression right)
Minimum(Expression left, Expression right)
Minus(Expression e)
Multiply(Expression left, Expression right)
Subtract(Expression left, Expression right)