Package net.sf.tweety.lp.asp.syntax

Class AggregateAtom

  • All Implemented Interfaces:
    Formula, ComplexLogicalFormula, LogicStructure, SimpleLogicalFormula
    public class AggregateAtom
extends ASPBodyElement
    This class represents an aggregate. Aggregates are functions that range over sets of terms and literals and evaluate to some value. For example, using the aggregate function #count one could obtain the number of employees of one department. Normally, this value is then compared to another value with a comparative operator like "=" to produce a truth value (also known as 'aggregate relation'). For example, this could be used to express the condition that the number of employees in one department has to be greater than 0.
    An aggregate that contains such a comparison is also referred to as an aggregate atom and can appear in the body of a rule.
    Author:
    Tim Janus, Thomas Vengels, Anna Gessler

    • Constructor Detail

      • AggregateAtom

        public AggregateAtom()
        Empty default constructor.

      • AggregateAtom

        public AggregateAtom​(ASPOperator.AggregateFunction func,
                     java.util.List<AggregateElement> elements)
        Creates a new Aggregate with the given aggregate function and the given aggregate elements.
        Parameters:
        func - an aggregate function
        elements - list of aggregate elements

      • AggregateAtom

        public AggregateAtom​(ASPOperator.AggregateFunction func,
                     java.util.List<AggregateElement> elements,
                     ASPOperator.BinaryOperator relation,
                     Term<?> t)
        Creates a new Aggregate with the given aggregate function, the given aggregate elements, and the given aggregate relation.
        Parameters:
        func - an aggregate function
        elements - list of aggregate elements
        relation - the relation
        t - some term

      • AggregateAtom

        public AggregateAtom​(AggregateAtom other)
        Copy-Constructor
        Parameters:
        other - another AggregateAtom

    • Method Detail

      • toString

        public java.lang.String toString()
        Overrides:
        toString in class java.lang.Object

      • getLiterals

        public java.util.SortedSet<ASPLiteral> getLiterals()
        Description copied from class: ASPBodyElement
        Returns all literals in this element in form of a SortedSet. Literals are atoms or strict negations of atoms.
        Specified by:
        getLiterals in class ASPBodyElement
        Returns:
        all the literals used in the rule element

      • getSignature

        public FolSignature getSignature()
        Description copied from interface: Formula
        Returns the signature of the language of this formula.
        Specified by:
        getSignature in interface Formula
        Specified by:
        getSignature in class ASPElement
        Returns:
        the signature of the language of this formula.

      • isLiteral

        public boolean isLiteral()
        Returns:
        true if the formula represents a literal in the language or false otherwise

      • getTerms

        public java.util.Set<Term<?>> getTerms()
        Returns:
        a set containing all terms of this logical structure

      • getTerms

        public <C extends Term<?>> java.util.Set<C> getTerms​(java.lang.Class<C> cls)
        Description copied from interface: LogicStructure
        Processes the set containing all terms of type C. This method uses the equals method of the given Class and therefore does not add terms which are sub classes of type C to the set.
        Type Parameters:
        C - the type of terms
        Parameters:
        cls - The Class structure containing type information about the searched term
        Returns:
        A set containing all terms of type C of this logical structure

      • getAggregateElements

        public java.util.List<AggregateElement> getAggregateElements()

      • hasLeftRelation

        public boolean hasLeftRelation()
        Returns true if the aggregate has a left aggregate relation (meaning a term that the aggregate's resulting value will be compared to using a comparative operator).
        Returns:
        true if aggregate has left aggregate relation

      • hasRightRelation

        public boolean hasRightRelation()
        Returns true if the aggregate has a right aggregate relation (meaning a term that the aggregate's resulting value will be compared to using a comparative operator).
        Returns:
        true if aggregate has right aggregate relation

      • setFunction

        public void setFunction​(ASPOperator.AggregateFunction function)
        Sets the aggregate function.
        Parameters:
        function - an aggregate function

      • getRightOperator

        public ASPOperator.BinaryOperator getRightOperator()
        Returns the operator of the right aggregate relation.
        Returns:
        comparative operator

      • setRightOperator

        public void setRightOperator​(ASPOperator.BinaryOperator op)
        Sets the operator of the right aggregate relation.
        Parameters:
        op - comparative operator

      • getRightGuard

        public Term<?> getRightGuard()
        Returns the right relation term (right guard).
        Returns:
        Term

      • setRightGuard

        public void setRightGuard​(Term<?> relationTerm)
        Set the right relation term (right guard).
        Parameters:
        relationTerm - some term

      • getLeftOperator

        public ASPOperator.BinaryOperator getLeftOperator()
        Returns the operator of the left aggregate relation.
        Returns:
        comparative operator

      • setLeftOperator

        public void setLeftOperator​(ASPOperator.BinaryOperator op)
        Sets the operator of the left aggregate relation.
        Parameters:
        op - comparative operator

      • getLeftGuard

        public Term<?> getLeftGuard()
        Get the left relation term (right guard).
        Returns:
        Term

      • setLeftGuard

        public void setLeftGuard​(Term<?> relationTerm)
        Set the left relation term (right guard).
        Parameters:
        relationTerm - some term