Enum ACOperatorKind 

pub enum ACOperatorKind {
    And,
    Or,
    Product,
    Sum,
}

The possible kinds of associative-commutative (AC) operator.

AC operators take a single vector as input and are commonly used alongside comprehensions.

Variants

And

Or

Product

Sum

Implementations

impl ACOperatorKind

pub fn as_expression(&self, child_expr: Expression) -> Expression

Creates a new Expression of this AC operator kind with the given child expression.

The child expression given should be of type matrix.

pub fn identity(&self) -> Literal

Returns the identity element of this operation.

Example

use conjure_cp_core::ast::{ac_operators::ACOperatorKind,Literal};

let identity = ACOperatorKind::And.identity();
assert_eq!(identity,Literal::Bool(true));

pub fn make_skip_operation( &self, guard_expr: Expression, tail_expr: Expression, ) -> Expression

Given some guard and tail expressions, constructs the skipping operator for this operation.

The skipping operator is operator that takes some boolean guard expression b and some tail expression x. If b is true, then it evaluates to x, otherwise it evaluates to the identity element.

Usage

This can be used to add guards to elements of AC operations. In the example model below, we only want to multiply y*z by 2 if multiplyByTwo is true:

find multiplyByTwo: bool
find x: int(1..5)
find y: int(1..5)
find z: int(1..5)

such that
  
x = product([y,z,[1,x;int(0..1)][toInt(b)]])

[1,x;int(0..1)][toInt(b)] is the skipping operator for product.

This method constructs the skipping operator, substituting in the given expressions for b and x.

pub fn return_type(&self) -> ReturnType

Gives the return type of the operator, and the return types its elements should be.

Trait Implementations

impl Clone for ACOperatorKind

fn clone(&self) -> ACOperatorKind

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ACOperatorKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Hash for ACOperatorKind

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ACOperatorKind

fn eq(&self, other: &ACOperatorKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFrom<&Expression> for ACOperatorKind

type Error = ()

The type returned in the event of a conversion error.

fn try_from( expr: &Expression, ) -> Result<ACOperatorKind, <ACOperatorKind as TryFrom<&Expression>>::Error>

Performs the conversion.

impl TryFrom<Box<Expression>> for ACOperatorKind

type Error = ()

The type returned in the event of a conversion error.

fn try_from( value: Box<Expression>, ) -> Result<ACOperatorKind, <ACOperatorKind as TryFrom<Box<Expression>>>::Error>

Performs the conversion.

impl TryFrom<Expression> for ACOperatorKind

type Error = ()

The type returned in the event of a conversion error.

fn try_from( value: Expression, ) -> Result<ACOperatorKind, <ACOperatorKind as TryFrom<Expression>>::Error>

Performs the conversion.

impl Copy for ACOperatorKind

impl Eq for ACOperatorKind

impl StructuralPartialEq for ACOperatorKind

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 1 byte

Size for each variant:

• And: 0 bytes
• Or: 0 bytes
• Product: 0 bytes
• Sum: 0 bytes