Package org.opennars.language

Class Statement

java.lang.Object

org.opennars.language.Term

org.opennars.language.CompoundTerm

org.opennars.language.Statement

All Implemented Interfaces:

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

Direct Known Subclasses:

Equivalence, Implication, Inheritance, Similarity

public abstract class Statement
extends CompoundTerm

A statement is a compound term as defined in the NARS-theory, consisting of a subject, a predicate, and a relation symbol in between. It can be of either first-order or higher-order.

Author:

Pei Wang, Patrick Hammer

See Also:

Serialized Form

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	Statement.EnumStatementSide

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

CompoundTerm.ConvRectangle, CompoundTerm.UnableToCloneException

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

Term.TermVisitor

Field Summary

Fields inherited from class org.opennars.language.CompoundTerm

complexity, conceptival, containedTemporalRelations, hash, term

Fields inherited from class org.opennars.language.Term

EmptyTermArray, imagination, index_variable, SELF, SEQ_SPATIAL, SEQ_TEMPORAL, term_indices

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	Statement(Term[] arg)	Constructor with partial values, called by make Subclass constructors should call init after any initialization

Method Summary

Modifier and Type	Method	Description
abstract Statement	clone()	clone method
Term	getPredicate()	Return the second component of the statement
Term	getSubject()	Return the first component of the statement
protected void	init(Term[] t)	call this after changing Term[] contents
boolean	invalid()	Check the validity of a potential Statement.
static boolean	invalidPair(Term s1, Term s2)
private static boolean	invalidReflexive(Term t1, Term t2)	Check if one term is identical to or included in another one, except in a reflexive relation
static boolean	invalidStatement(Term subject, Term predicate)
static boolean	invalidStatement(Term subject, Term predicate, boolean checkSameTermInPredicateAndSubject)	Check the validity of a potential Statement.
static Statement	make(Symbols.NativeOperator o, Term subject, Term predicate, boolean customOrder, int order)	Make a Statement from String, called by StringParser
static Statement	make(Symbols.NativeOperator op, Term subj, Term pred, int order)	Make a Statement from given term, called by the rules
static Statement	make(Statement statement, Term subj, Term pred)	Make a Statement from given components, called by the rules
static Statement	make(Statement statement, Term subj, Term pred, int order)
protected CharSequence	makeName()	Override the default in making the nameStr of the current term from existing fields
protected static CharSequence	makeStatementName(Term subject, Symbols.NativeOperator relation, Term predicate)
static Statement	makeSym(Statement statement, Term subj, Term pred, int order)	Make a symmetric Statement from given term and temporal information, called by the rules
Term	retBySide(Statement.EnumStatementSide side)	returns the subject (0) or predicate(1)
static Statement.EnumStatementSide	retOppositeSide(Statement.EnumStatementSide side)

Methods inherited from class org.opennars.language.CompoundTerm

addComponentsRecursively, addTermsTo, applySubstitute, applySubstituteToCompound, asTermList, clone, cloneDeep, cloneDeepVariables, cloneTerms, cloneTermsAppend, cloneTermsDeep, cloneTermsExcept, cloneTermsListDeep, cloneTermsReplacing, cloneVariableTermsDeep, compareTo, containedTemporalRelations, containsAllTermsOf, containsTerm, containsTermRecursively, countTermRecursively, equals, extractIntervals, getComplexity, getContainedTerms, hashCode, hasInterval, hasVar, hasVarDep, hasVarIndep, hasVarQuery, invalidateName, isCommutative, isNormalized, iterator, makeCompoundName, name, operator, prepareComponentLinks, replaceIntervals, setComponent, setNormalized, shuffle, size, termArray, termList, transformIndependentVariableToDependent, UpdateConvRectangle

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

Constructor Detail

Statement

protected Statement(Term[] arg)

Constructor with partial values, called by make Subclass constructors should call init after any initialization

Parameters:

arg - The component list of the term

Method Detail

init

protected void init(Term[] t)

Description copied from class: CompoundTerm

call this after changing Term[] contents

Overrides:

init in class CompoundTerm

make

public static Statement make(Statement statement,
                             Term subj,
                             Term pred)

Make a Statement from given components, called by the rules

Parameters:

subj - The first component

pred - The second component

statement - A sample statement providing the class type

Returns:

The Statement built

make

public static final Statement make(Symbols.NativeOperator o,
                                   Term subject,
                                   Term predicate,
                                   boolean customOrder,
                                   int order)

Make a Statement from String, called by StringParser

Parameters:

o - The relation String

subject - The first component

predicate - The second component

Returns:

The Statement built

make

public static final Statement make(Symbols.NativeOperator op,
                                   Term subj,
                                   Term pred,
                                   int order)

Make a Statement from given term, called by the rules

Parameters:

order - The temporal order of the statement

subj - The first component

pred - The second component

Returns:

The Statement built

make

public static final Statement make(Statement statement,
                                   Term subj,
                                   Term pred,
                                   int order)

makeSym

public static final Statement makeSym(Statement statement,
                                      Term subj,
                                      Term pred,
                                      int order)

Make a symmetric Statement from given term and temporal information, called by the rules

Parameters:

statement - A sample asymmetric statement providing the class type

subj - The first component

pred - The second component

order - The temporal order

Returns:

The Statement built

makeName

protected CharSequence makeName()

Override the default in making the nameStr of the current term from existing fields

Overrides:

makeName in class CompoundTerm

Returns:

the nameStr of the term

makeStatementName

protected static final CharSequence makeStatementName(Term subject,
                                                      Symbols.NativeOperator relation,
                                                      Term predicate)

invalidStatement

public static final boolean invalidStatement(Term subject,
                                             Term predicate,
                                             boolean checkSameTermInPredicateAndSubject)

Check the validity of a potential Statement. [To be refined]

Parameters:

subject - The first component

predicate - The second component

Returns:

Whether The Statement is invalid

invalidStatement

public static final boolean invalidStatement(Term subject,
                                             Term predicate)

invalidReflexive

private static boolean invalidReflexive(Term t1,
                                        Term t2)

Check if one term is identical to or included in another one, except in a reflexive relation

Parameters:

t1 - The first term

t2 - The second term

Returns:

Whether they cannot be related in a statement

invalidPair

public static boolean invalidPair(Term s1,
                                  Term s2)

invalid

public boolean invalid()

Check the validity of a potential Statement. [To be refined]

Minimum requirement: the two terms cannot be the same, or containing each other as component

Returns:

Whether The Statement is invalid

getSubject

public Term getSubject()

Return the first component of the statement

Returns:

The first component

getPredicate

public Term getPredicate()

Return the second component of the statement

Returns:

The second component

retBySide

public Term retBySide(Statement.EnumStatementSide side)

returns the subject (0) or predicate(1)

Parameters:

side - subject(0) or predicate(1)

Returns:

the term of the side

retOppositeSide

public static Statement.EnumStatementSide retOppositeSide(Statement.EnumStatementSide side)

clone

public abstract Statement clone()

Description copied from class: CompoundTerm

clone method

Specified by:

clone in class CompoundTerm

Returns:

A clone of the compound term