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
final class	FixedValue	Represents a single immutable number.
final 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 final Expression	ClpConstraintStore.Enforce.expression

Methods in org.projog.clp that return Expression

Modifier and Type	Method	Description
Expression	Expression.replace(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(Consumer<Expression> consumer)	Traverse this constraint.
void	Expression.walk(Consumer<Expression> consumer)	Traverse this expression.
void	FixedValue.walk(Consumer<Expression> r)
void	Variable.walk(Consumer<Expression> r)

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

Modifier	Constructor	Description
private	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
final class	And
final class	Equivalent
final class	Implication
final class	Nand
final class	Nor
final class	Not
final class	Or
final class	Xor

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

Modifier and Type	Method	Description
void	And.walk(Consumer<Expression> r)
void	Equivalent.walk(Consumer<Expression> r)
void	Implication.walk(Consumer<Expression> r)
void	Nand.walk(Consumer<Expression> r)
void	Nor.walk(Consumer<Expression> r)
void	Not.walk(Consumer<Expression> r)
void	Or.walk(Consumer<Expression> r)
void	Xor.walk(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
final class	Between	Enforces that the possible values of a given Expression are within the given range.
final class	EqualTo	Enforces that two Expressions have the same value.
final class	LessThan	Enforces that the value of one Expression is less than another.
final class	LessThanOrEqualTo	Enforces that the value of one Expression is less than or equal to another.
final 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 final Expression	Between.e
private final Expression	EqualTo.left
private final Expression	LessThan.left
private final Expression	LessThanOrEqualTo.left
private final Expression	NotEqualTo.left
private final Expression	EqualTo.right
private final Expression	LessThan.right
private final Expression	LessThanOrEqualTo.right
private final 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(Consumer<Expression> r)
void	EqualTo.walk(Consumer<Expression> r)
void	LessThan.walk(Consumer<Expression> r)
void	LessThanOrEqualTo.walk(Consumer<Expression> r)
void	NotEqualTo.walk(Consumer<Expression> r)

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

Modifier	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
final class	Absolute
final class	Add	The sum of two Expressions.
final class	Divide	The result of dividing one Expression by another.
class	Maximum
class	Minimum
final class	Minus
final class	Multiply	The product of two Expressions.
final class	Subtract	The difference of two Expressions.

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

Modifier and Type	Field	Description
private final Expression	Absolute.e
private final Expression	Minus.e
private final Expression	Add.left
private final Expression	Divide.left	The dividend.
private final Expression	Maximum.left
private final Expression	Minimum.left
private final Expression	Multiply.left
private final Expression	Subtract.left
private final Expression	Add.right
private final Expression	Divide.right	The divisor.
private final Expression	Maximum.right
private final Expression	Minimum.right
private final Expression	Multiply.right
private final 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, BiFunction<Long,Long,Long> f)
private static ExpressionResult	Multiply.setMin(ConstraintStore s, Expression left, long min, long leftMin, long rightMin, long rightMax, BiFunction<Long,Long,Long> f)

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

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

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

Modifier	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)