CompoundTerm (OpenNARS 3.0.4-SNAPSHOT API)

java.lang.Object
- org.opennars.language.Term
- - org.opennars.language.CompoundTerm

All Implemented Interfaces:

Serializable, Cloneable, Comparable<AbstractTerm>, Iterable<Term>, AbstractTerm

Direct Known Subclasses:

Conjunction, DifferenceExt, DifferenceInt, Disjunction, Image, IntersectionExt, IntersectionInt, Negation, Product, SetTensional, Statement
```
public abstract class CompoundTerm
extends Term
implements Iterable<Term>
```
Compound term as defined in the NARS-theory

Author:

Pei Wang, Patrick Hammer

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class Description

static class CompoundTerm.ConvRectangle

static class CompoundTerm.UnableToCloneException
- Nested classes/interfaces inherited from class org.opennars.language.Term
  Term.TermVisitor

Nested Classes
Modifier and Type	Class	Description
`static class`	`CompoundTerm.ConvRectangle`
`static class`	`CompoundTerm.UnableToCloneException`

Field Summary

Fields
Modifier and Type	Field	Description
`short`	`complexity`	syntactic complexity of the compound, the sum of those of its term plus 1
`(package private) static Interval`	`conceptival`
`(package private) int`	`containedTemporalRelations`
`(package private) int`	`hash`
`private boolean`	`hasIntervals`	Whether contains a variable
`private boolean`	`hasVarDeps`	Whether contains a variable
`private boolean`	`hasVariables`	Whether contains a variable
`private boolean`	`hasVarIndeps`	Whether contains a variable
`private boolean`	`hasVarQueries`	Whether contains a variable
`private boolean`	`normalized`
`Term[]`	`term`	list of (direct) term

Fields inherited from class org.opennars.language.Term
EmptyTermArray, imagination, index_variable, SELF, SEQ_SPATIAL, SEQ_TEMPORAL, term_indices

Constructor Summary

Constructors
Constructor	Description
`CompoundTerm(Term[] components)`	subclasses should be sure to call init() in their constructors; it is not done here to allow subclass constructors to set data before calling init()

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`static Set<Term>`	`addComponentsRecursively(Term t, Set<Term> components)`	Add all the components of term t into components recursively
`void`	`addTermsTo(Collection<Term> c)`
`Term`	`applySubstitute(Map<Term,Term> subs)`	Recursively apply a substitute to the current CompoundTerm May return null if the term can not be created
`CompoundTerm`	`applySubstituteToCompound(Map<Term,Term> substitute)`	returns result of applySubstitute, if and only if it's a CompoundTerm.
`List<Term>`	`asTermList()`
`abstract CompoundTerm`	`clone()`	clone method
`abstract Term`	`clone(Term[] replaced)`	Must be Term return type because the type of Term may change with different arguments
`CompoundTerm`	`cloneDeep()`
`CompoundTerm`	`cloneDeepVariables()`
`Term[]`	`cloneTerms(Term... additional)`	Clone the component list
`static Term[]`	`cloneTermsAppend(Term[] original, Term[] additional)`	Deep clone an array list of terms
`Term[]`	`cloneTermsDeep()`	forced deep clone of terms
`Term[]`	`cloneTermsExcept(boolean requireModification, Term[] toRemove)`	Cloned array of Terms, except for one or more Terms.
`List<Term>`	`cloneTermsListDeep()`	forced deep clone of terms
`Term[]`	`cloneTermsReplacing(Term from, Term to)`
`Term[]`	`cloneVariableTermsDeep()`
`int`	`compareTo(AbstractTerm that)`
`int`	`containedTemporalRelations()`
`boolean`	`containsAllTermsOf(Term t)`	Check whether the compound contains all term of another term, or that term as a whole
`boolean`	`containsTerm(Term t)`	Check whether the compound contains a certain component Also matches variables, ex: (&&,<a --> b>,<b --> c>) also contains <a --> #1>
`boolean`	`containsTermRecursively(Term target)`	Recursively check if a compound contains a term
`Map<Term,Integer>`	`countTermRecursively(Map<Term,Integer> map)`	Recursively count how often the terms are contained
`boolean`	`equals(Object that)`	Equal terms have identical name, though not necessarily the same reference.
`static List<Long>`	`extractIntervals(Memory mem, Term T)`
`private static void`	`ExtractIntervals(Memory mem, List<Long> ivals, CompoundTerm comp)`
`short`	`getComplexity()`	report the term's syntactic complexity
`Set<Term>`	`getContainedTerms()`	Gives a set of all contained term, recursively
`int`	`hashCode()`	Produce a hash code for the term
`boolean`	`hasInterval()`
`boolean`	`hasVar()`	Whether this compound term contains any variable term
`boolean`	`hasVarDep()`
`boolean`	`hasVarIndep()`
`boolean`	`hasVarQuery()`
`protected void`	`init(Term[] term)`	call this after changing Term[] contents
`void`	`invalidateName()`
`boolean`	`isCommutative()`	Check if the order of the term matters
`boolean`	`isNormalized()`
`Iterator<Term>`	`iterator()`
`protected static CharSequence`	`makeCompoundName(Symbols.NativeOperator op, Term... arg)`	default method to make the oldName of a compound term from given fields
`protected CharSequence`	`makeName()`	default method to make the oldName of the current term from existing fields.
`CharSequence`	`name()`	Reporting the name of the current Term.
`abstract Symbols.NativeOperator`	`operator()`	method to get the operator of the compound
`List<TermLink>`	`prepareComponentLinks()`	Build TermLink templates to constant term and subcomponents
`static Term`	`replaceIntervals(Term T)`
`private static void`	`ReplaceIntervals(CompoundTerm comp)`
`Term`	`setComponent(int index, Term t, Memory memory)`	Try to replace a component in a compound at a given index by another one
`void`	`setNormalized(boolean b)`
`(package private) static void`	`shuffle(Term[] ar, Random randomNumber)`
`int`	`size()`	get the number of term
`static Term[]`	`termArray(Term... t)`	build a component list from terms
`static List<Term>`	`termList(Term... t)`
`static void`	`transformIndependentVariableToDependent(CompoundTerm T)`
`static CompoundTerm.ConvRectangle`	`UpdateConvRectangle(Term[] term)`

Methods inherited from interface java.lang.Iterable
forEach, spliterator

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from class org.opennars.language.Term
get, get, getIsSpatial, getTemporalOrder, hasVar, isConstant, isExecutable, isHigherOrderStatement, isSelf, nameInternal, recurseSubtermsContainingVariables, recurseSubtermsContainingVariables, recurseTerms, setName, subjectOrPredicateIsIndependentVar, text, toSortedSet, toSortedSetArray, toString, valid

- Field Detail
  - term
```
public final Term[] term
```
    list of (direct) term
  - complexity
```
public short complexity
```
    syntactic complexity of the compound, the sum of those of its term plus 1
  - hasVariables
```
private boolean hasVariables
```
    Whether contains a variable
  - hasVarQueries
```
private boolean hasVarQueries
```
    Whether contains a variable
  - hasVarIndeps
```
private boolean hasVarIndeps
```
    Whether contains a variable
  - hasVarDeps
```
private boolean hasVarDeps
```
    Whether contains a variable
  - hasIntervals
```
private boolean hasIntervals
```
    Whether contains a variable
  - containedTemporalRelations
```
int containedTemporalRelations
```
  - hash
```
int hash
```
  - normalized
```
private boolean normalized
```
  - conceptival
```
static final Interval conceptival
```
- Constructor Detail
  - CompoundTerm
```
public CompoundTerm(Term[] components)
```
    subclasses should be sure to call init() in their constructors; it is not done here to allow subclass constructors to set data before calling init()
- Method Detail
  - operator
```
public abstract Symbols.NativeOperator operator()
```
    method to get the operator of the compound
    
    Overrides:
    
    operator in class Term
  - clone
```
public abstract CompoundTerm clone()
```
    clone method
    
    Overrides:
    
    clone in class Term
    
    Returns:
    
    A clone of the compound term
  - UpdateConvRectangle
```
public static CompoundTerm.ConvRectangle UpdateConvRectangle(Term[] term)
```
  - init
```
protected void init(Term[] term)
```
    call this after changing Term[] contents
  - invalidateName
```
public void invalidateName()
```
  - clone
```
public abstract Term clone(Term[] replaced)
```
    Must be Term return type because the type of Term may change with different arguments
  - cloneDeep
```
public CompoundTerm cloneDeep()
```
    Overrides:
    
    cloneDeep in class Term
  - transformIndependentVariableToDependent
```
public static void transformIndependentVariableToDependent(CompoundTerm T)
```
  - ReplaceIntervals
```
private static void ReplaceIntervals(CompoundTerm comp)
```
  - replaceIntervals
```
public static Term replaceIntervals(Term T)
```
  - ExtractIntervals
```
private static void ExtractIntervals(Memory mem,
                                     List<Long> ivals,
                                     CompoundTerm comp)
```
  - extractIntervals
```
public static List<Long> extractIntervals(Memory mem,
                                          Term T)
```
  - cloneDeepVariables
```
public CompoundTerm cloneDeepVariables()
```
  - containedTemporalRelations
```
public int containedTemporalRelations()
```
    Overrides:
    
    containedTemporalRelations in class Term
  - termArray
```
public static Term[] termArray(Term... t)
```
    build a component list from terms
    
    Returns:
    
    the component list
  - termList
```
public static List<Term> termList(Term... t)
```
  - makeName
```
protected CharSequence makeName()
```
    default method to make the oldName of the current term from existing fields. needs overridden in certain subclasses
    
    Returns:
    
    the oldName of the term
  - name
```
public CharSequence name()
```
    Description copied from class: Term
    
    Reporting the name of the current Term.
    
    Specified by:
    
    name in interface AbstractTerm
    
    Overrides:
    
    name in class Term
    
    Returns:
    
    The name of the term as a String
  - makeCompoundName
```
protected static CharSequence makeCompoundName(Symbols.NativeOperator op,
                                               Term... arg)
```
    default method to make the oldName of a compound term from given fields
    
    Parameters:
    
    op - the term operator
    
    arg - the list of term
    
    Returns:
    
    the oldName of the term
  - getComplexity
```
public short getComplexity()
```
    report the term's syntactic complexity
    
    Overrides:
    
    getComplexity in class Term
    
    Returns:
    
    the complexity value
  - isCommutative
```
public boolean isCommutative()
```
    Check if the order of the term matters
    commutative CompoundTerms: Sets, Intersections Commutative Statements: Similarity, Equivalence (except the one with a temporal order) Commutative CompoundStatements: Disjunction, Conjunction (except the one with a temporal order)
    
    Returns:
    
    The default value is false
  - size
```
public final int size()
```
    get the number of term
    
    Returns:
    
    the size of the component list
  - getContainedTerms
```
public Set<Term> getContainedTerms()
```
    Gives a set of all contained term, recursively
  - cloneTerms
```
public Term[] cloneTerms(Term... additional)
```
    Clone the component list
    
    Returns:
    
    The cloned component list
  - cloneTermsExcept
```
public Term[] cloneTermsExcept(boolean requireModification,
                               Term[] toRemove)
```
    Cloned array of Terms, except for one or more Terms.
    
    Parameters:
    
    toRemove -
    
    Returns:
    
    the cloned array with the missing terms removed, OR null if no terms were actually removed when requireModification=true
  - cloneTermsAppend
```
public static Term[] cloneTermsAppend(Term[] original,
                                      Term[] additional)
```
    Deep clone an array list of terms
    
    Parameters:
    
    original - The original component list
    
    Returns:
    
    an identical and separate copy of the list
  - asTermList
```
public List<Term> asTermList()
```
  - cloneTermsDeep
```
public Term[] cloneTermsDeep()
```
    forced deep clone of terms
  - cloneVariableTermsDeep
```
public Term[] cloneVariableTermsDeep()
```
  - cloneTermsListDeep
```
public List<Term> cloneTermsListDeep()
```
    forced deep clone of terms
  - shuffle
```
static void shuffle(Term[] ar,
                    Random randomNumber)
```
  - containsTerm
```
public boolean containsTerm(Term t)
```
    Check whether the compound contains a certain component Also matches variables, ex: (&&,<a --> b>,<b --> c>) also contains <a --> #1>
    
    Overrides:
    
    containsTerm in class Term
    
    Parameters:
    
    t - The component to be checked
    
    Returns:
    
    Whether the component is in the compound
  - containsTermRecursively
```
public boolean containsTermRecursively(Term target)
```
    Recursively check if a compound contains a term
    
    Overrides:
    
    containsTermRecursively in class Term
    
    Parameters:
    
    target - The term to be searched
    
    Returns:
    
    Whether the target is in the current term
  - countTermRecursively
```
public Map<Term,Integer> countTermRecursively(Map<Term,Integer> map)
```
    Recursively count how often the terms are contained
    
    Overrides:
    
    countTermRecursively in class Term
    
    Parameters:
    
    map - The count map that will be created to count how often each term occurs
    
    Returns:
    
    The counts of the terms
  - addComponentsRecursively
```
public static Set<Term> addComponentsRecursively(Term t,
                                                 Set<Term> components)
```
    Add all the components of term t into components recursively
    
    Parameters:
    
    t - The term
    
    components - The components
    
    Returns:
  - containsAllTermsOf
```
public boolean containsAllTermsOf(Term t)
```
    Check whether the compound contains all term of another term, or that term as a whole
    
    Parameters:
    
    t - The other term
    
    Returns:
    
    Whether the term are all in the compound
  - setComponent
```
public Term setComponent(int index,
                         Term t,
                         Memory memory)
```
    Try to replace a component in a compound at a given index by another one
    
    Parameters:
    
    index - The location of replacement
    
    t - The new component
    
    memory - Reference to the memory
    
    Returns:
    
    The new compound
  - hasVar
```
public boolean hasVar()
```
    Whether this compound term contains any variable term
    
    Specified by:
    
    hasVar in interface AbstractTerm
    
    Overrides:
    
    hasVar in class Term
    
    Returns:
    
    Whether the name contains a variable
  - hasVarDep
```
public boolean hasVarDep()
```
    Overrides:
    
    hasVarDep in class Term
  - hasVarIndep
```
public boolean hasVarIndep()
```
    Overrides:
    
    hasVarIndep in class Term
  - hasVarQuery
```
public boolean hasVarQuery()
```
    Overrides:
    
    hasVarQuery in class Term
  - hasInterval
```
public boolean hasInterval()
```
    Overrides:
    
    hasInterval in class Term
  - applySubstitute
```
public Term applySubstitute(Map<Term,Term> subs)
```
    Recursively apply a substitute to the current CompoundTerm May return null if the term can not be created
    
    Parameters:
    
    subs -
  - applySubstituteToCompound
```
public CompoundTerm applySubstituteToCompound(Map<Term,Term> substitute)
```
    returns result of applySubstitute, if and only if it's a CompoundTerm. otherwise it is null
  - prepareComponentLinks
```
public List<TermLink> prepareComponentLinks()
```
    Build TermLink templates to constant term and subcomponents
    The compound type determines the link type; the component type determines whether to build the link.
    
    Returns:
    
    A list of TermLink templates
  - addTermsTo
```
public final void addTermsTo(Collection<Term> c)
```
  - hashCode
```
public int hashCode()
```
    Description copied from class: Term
    
    Produce a hash code for the term
    
    Overrides:
    
    hashCode in class Term
    
    Returns:
    
    An integer hash code
  - compareTo
```
public int compareTo(AbstractTerm that)
```
    Specified by:
    
    compareTo in interface Comparable<AbstractTerm>
    
    Overrides:
    
    compareTo in class Term
    
    Parameters:
    
    that - The Term to be compared with the current Term
    
    Returns:
    
    The same as compareTo as defined on Strings
  - equals
```
public boolean equals(Object that)
```
    Description copied from class: Term
    
    Equal terms have identical name, though not necessarily the same reference.
    
    Overrides:
    
    equals in class Term
    
    Parameters:
    
    that - The Term to be compared with the current Term
    
    Returns:
    
    Whether the two Terms are equal
  - setNormalized
```
public void setNormalized(boolean b)
```
  - isNormalized
```
public boolean isNormalized()
```
  - cloneTermsReplacing
```
public Term[] cloneTermsReplacing(Term from,
                                  Term to)
```
  - iterator
```
public Iterator<Term> iterator()
```
    Specified by:
    
    iterator in interface Iterable<Term>

Class CompoundTerm

Nested Class Summary

Nested classes/interfaces inherited from class org.opennars.language.Term

Field Summary

Fields inherited from class org.opennars.language.Term

Constructor Summary

Method Summary

Methods inherited from interface java.lang.Iterable

Methods inherited from class java.lang.Object

Methods inherited from class org.opennars.language.Term

Field Detail

term

complexity

hasVariables

hasVarQueries

hasVarIndeps

hasVarDeps

hasIntervals

containedTemporalRelations

hash

normalized

conceptival

Constructor Detail

CompoundTerm

Method Detail

operator

clone

UpdateConvRectangle

init

invalidateName

clone

cloneDeep

transformIndependentVariableToDependent

ReplaceIntervals

replaceIntervals

ExtractIntervals

extractIntervals

cloneDeepVariables

containedTemporalRelations

termArray

termList

makeName

name

makeCompoundName

getComplexity

isCommutative

size

getContainedTerms

cloneTerms

cloneTermsExcept

cloneTermsAppend

asTermList

cloneTermsDeep

cloneVariableTermsDeep

cloneTermsListDeep

shuffle

containsTerm

containsTermRecursively

countTermRecursively

addComponentsRecursively

containsAllTermsOf

setComponent

hasVar

hasVarDep

hasVarIndep

hasVarQuery

hasInterval

applySubstitute

applySubstituteToCompound

prepareComponentLinks

addTermsTo

hashCode

compareTo

equals

setNormalized

isNormalized

cloneTermsReplacing

iterator