Uses of Class
org.opennars.language.Term

Packages that use Term

Package	Description
org.opennars.control
org.opennars.control.concept
org.opennars.entity	Data entities that are independently stored
org.opennars.inference	The inference rules and control functions
org.opennars.io	Input/output management
org.opennars.language	Term hierarchy in Narsese Open-NARS implements the following formal language, Narsese.
org.opennars.main
org.opennars.operator
org.opennars.operator.mental
org.opennars.operator.misc
org.opennars.plugin.mental
org.opennars.plugin.perception
org.opennars.storage	Storage management

Uses of Term in org.opennars.control

Fields in org.opennars.control declared as Term

Modifier and Type	Field	Description
protected Term	DerivationContext.currentTerm

Methods in org.opennars.control that return Term

Modifier and Type	Method	Description
Term	DerivationContext.getCurrentTerm()

Methods in org.opennars.control with parameters of type Term

Modifier and Type	Method	Description
List<Task>	DerivationContext.doublePremiseTask(Term newContent, TruthValue newTruth, BudgetValue newBudget, boolean temporalInduction, boolean overlapAllowed)	Shared final operations by all double-premise rules, called from the rules except StructuralRules
List<Task>	DerivationContext.doublePremiseTask(Term newContent, TruthValue newTruth, BudgetValue newBudget, boolean temporalInduction, boolean overlapAllowed, boolean addToMemory)
boolean	DerivationContext.doublePremiseTaskRevised(Term newContent, TruthValue newTruth, BudgetValue newBudget, long counter)	Shared final operations by all double-premise rules, called from the rules except StructuralRules
void	DerivationContext.setCurrentTerm(Term currentTerm)
boolean	DerivationContext.singlePremiseTask(Term newContent, char punctuation, TruthValue newTruth, BudgetValue newBudget)	Shared final operations by all single-premise rules, called in StructuralRules
boolean	DerivationContext.singlePremiseTask(Term newContent, TruthValue newTruth, BudgetValue newBudget)	Shared final operations by all single-premise rules, called in StructuralRules

Uses of Term in org.opennars.control.concept

Fields in org.opennars.control.concept with type parameters of type Term

Modifier and Type	Field	Description
Map<Term,Term>	ProcessGoal.ExecutablePrecondition.substitution
Map<Term,Term>	ProcessGoal.ExecutablePrecondition.substitution

Method parameters in org.opennars.control.concept with type arguments of type Term

Modifier and Type	Method	Description
static void	ProcessAnticipation.anticipate(DerivationContext nal, Sentence mainSentence, BudgetValue budget, long mintime, long maxtime, float urgency, Map<Term,Term> substitution)
static void	ProcessAnticipation.anticipate(DerivationContext nal, Sentence mainSentence, BudgetValue budget, long mintime, long maxtime, float urgency, Map<Term,Term> substitution)

Uses of Term in org.opennars.entity

Classes in org.opennars.entity with type parameters of type Term

Modifier and Type	Class	Description
class	Sentence<T extends Term>	Sentence as defined by the NARS-theory A Sentence is used as the premises and conclusions of all inference rules.
class	Task<T extends Term>	A task to be processed, consists of a Sentence and a BudgetValue.

Fields in org.opennars.entity declared as Term

Modifier and Type	Field	Description
Term	TermLink.target	The linked Term
Term	Concept.term	The term is the unique ID of the concept
T	Sentence.term	The content of a Sentence is a Term
(package private) static Term	TruthValue.Truth_FALSE
(package private) static Term	TruthValue.Truth_TRUE
(package private) static Term	TruthValue.Truth_UNSURE

Fields in org.opennars.entity with type parameters of type Term

Modifier and Type	Field	Description
Bag<Task<Term>,Sentence<Term>>	Concept.seq_before
Bag<Task<Term>,Sentence<Term>>	Concept.seq_before

Methods in org.opennars.entity that return Term

Modifier and Type	Method	Description
Term	TermLink.getTarget()
Term	Concept.getTerm()
Term	TaskLink.getTerm()
Term	TermLink.getTerm()
Term	Concept.name()
Term	TruthValue.toWordTerm()

Methods in org.opennars.entity with parameters of type Term

Modifier and Type	Method	Description
Sentence	Sentence.clone(Term t)	clone with a different term
static TruthValue	TruthValue.fromWordTerm(Parameters narParameters, Term term)

Constructors in org.opennars.entity with parameters of type Term

Constructor	Description
Concept(BudgetValue b, Term tm, Memory memory)	Constructor, called in Memory.getConcept only
TermLink(short type, Term target, int i0)
TermLink(short type, Term target, int i0, int i1)
TermLink(short type, Term target, int i0, int i1, int i2)
TermLink(short type, Term target, int i0, int i1, int i2, int i3)
TermLink(Term target, short type, short... indices)	Constructor for TermLink template
TermLink(Term t, TermLink template, BudgetValue v)	Constructor to make actual TermLink from a template

Uses of Term in org.opennars.inference

Methods in org.opennars.inference that return types with arguments of type Term

Modifier and Type	Method	Description
static Set<org.apache.commons.lang3.tuple.Pair<Term,Float>>	CompositionalRules.introduceVariables(DerivationContext nal, Term implicationEquivalenceOrJunction, boolean subject)	Introduction of variables that appear either within subjects or within predicates and more than once

Methods in org.opennars.inference with parameters of type Term

Modifier and Type	Method	Description
(package private) static boolean	SyllogisticRules.abdIndCom(Term term1, Term term2, Sentence sentence1, Sentence sentence2, int figure, DerivationContext nal)	{<M ==> S>, <M ==> P>} |- {<S ==> P>, <P ==> S>, <S <=> P>}
static void	CompositionalRules.addVariableCandidates(Set<Term> candidates, Term side, boolean subject)	Add the variable candidates that appear as subjects and predicates
(package private) static void	SyllogisticRules.analogy(Term subj, Term pred, Sentence asym, Sentence sym, int figure, DerivationContext nal)	{<S ==> P>, <M <=> P>} |- <S ==> P>
private static void	RuleTables.applyRuleTable(TaskLink tLink, TermLink bLink, DerivationContext nal, Task task, Sentence taskSentence, Term taskTerm, Term beliefTerm, Sentence belief)
private static void	RuleTables.compoundAndSelf(CompoundTerm compound, Term component, boolean compoundTask, int index, DerivationContext nal)	Inference between a compound term and a component of it
private static void	RuleTables.compoundAndStatement(CompoundTerm compound, short index, Statement statement, short side, Term beliefTerm, DerivationContext nal)	Inference between a compound term and a statement
static BudgetValue	BudgetFunctions.compoundBackward(Term content, DerivationContext nal)	Backward inference with CompoundTerm conclusion, stronger case
static BudgetValue	BudgetFunctions.compoundBackwardWeak(Term content, DerivationContext nal)	Backward inference with CompoundTerm conclusion, weaker case
static BudgetValue	BudgetFunctions.compoundForward(TruthValue truth, Term content, DerivationContext nal)	Forward inference with CompoundTerm conclusion
static float	BudgetFunctions.conceptActivation(Memory mem, Term t)	Get the current activation level of a concept.
(package private) static boolean	SyllogisticRules.conditionalAbd(Term cond1, Term cond2, Statement st1, Statement st2, DerivationContext nal)	{<(&&, S2, S3) ==> P>, <(&&, S1, S3) ==> P>} |- <S1 ==> S2>
(package private) static void	SyllogisticRules.conditionalAna(Equivalence premise1, short index, Term premise2, int side, DerivationContext nal)	{<(&&, S1, S2, S3) <=> P>, S1} |- <(&&, S2, S3) <=> P> {<(&&, S2, S3) <=> P>, <S1 ==> S2>} |- <(&&, S1, S3) <=> P> {<(&&, S1, S3) <=> P>, <S1 ==>
(package private) static void	SyllogisticRules.conditionalDedInd(Sentence premise1Sentence, Implication premise1, short index, Term premise2, int side, DerivationContext nal)	{<(&&, S1, S2, S3) ==> P>, S1} |- <(&&, S2, S3) ==> P> {<(&&, S2, S3) ==> P>, <S1 ==> S2>} |- <(&&, S1, S3) ==> P> {<(&&, S1, S3) ==> P>, <S1 ==> S2>} |- <(&&, S2, S3) ==> P>
private static void	CompositionalRules.decomposeCompound(CompoundTerm compound, Term component, Term term1, int index, boolean compoundTask, int order, DerivationContext nal)	{<(S|P) ==> M>, <P ==> M>} |- <S ==> M>
(package private) static void	CompositionalRules.decomposeStatement(CompoundTerm compound, Term component, boolean compoundTask, int index, DerivationContext nal)	{(||, S, P), P} |- S {(&&, S, P), P} |- S
(package private) static void	SyllogisticRules.dedExe(Term term1, Term term2, Sentence sentence, Sentence belief, DerivationContext nal)	{<S ==> M>, <M ==> P>} |- {<S ==> P>, <P ==> S>}
private static void	StructuralRules.deriveSequenceTask(DerivationContext nal, Conjunction parentConj, Term[] total, TruthValue truth)	Derives a sequence task, inheriting properties from parentConj
private static void	CompositionalRules.eliminateVariableOfConditionAbductiveInner1(Sentence sentence, Sentence belief, DerivationContext nal, CompoundTerm s1, Map<Term,Term> res3, Term s12)
private static void	CompositionalRules.eliminateVariableOfConditionAbductiveTryCrossUnification(Sentence sentence, Sentence belief, DerivationContext nal, Term s1, Term p2, Map<Term,Term> res3, Map<Term,Term> res4)
private static void	CompositionalRules.eliminateVariableOfConditionAbductiveTryUnification1(Sentence sentence, Sentence belief, DerivationContext nal, Term p1, CompoundTerm p2, Map<Term,Term> res3, Map<Term,Term> res4)
(package private) static void	SyllogisticRules.elimiVarDep(CompoundTerm compound, Term component, boolean compoundTask, DerivationContext nal)	{(&&, <#x() --> S>, <#x() --> P>>, <M --> P>} |- <M --> S>
(package private) static void	StructuralRules.flattenSequence(CompoundTerm compound, Term component, boolean compoundTask, int index, DerivationContext nal)	{(#,(#,A,B),C), (#,A,B)@(#,(#,A,B), C)} |- (#,A,B,C) (same for &/)
private static void	RuleTables.goalFromQuestion(Task task, Term taskTerm, DerivationContext nal)
static void	RuleTables.goalFromWantBelief(Task task, short tIndex, short bIndex, Term taskTerm, DerivationContext nal, Term beliefTerm)
(package private) static void	StructuralRules.groupSequence(CompoundTerm compound, Term component, boolean compoundTask, int index, DerivationContext nal)	{(#,A,B,C,D,E), C@(#,A,B,C,D,E)} |- (#,(#,A,B),C,D,E), (#,A,B,C,(#,D,E)) Group sequence left and right Works for all conjunctions
static boolean	LocalRules.intervalProjection(DerivationContext nal, Term newBeliefTerm, Term oldBeliefTerm, List<Float> recent_ivals, TruthValue newTruth)	Interval projection Decides to use whether to use old or new term dependent on which one is more usual, also discounting the truth confidence according to the interval difference.
static Set<org.apache.commons.lang3.tuple.Pair<Term,Float>>	CompositionalRules.introduceVariables(DerivationContext nal, Term implicationEquivalenceOrJunction, boolean subject)	Introduction of variables that appear either within subjects or within predicates and more than once
(package private) static void	CompositionalRules.IntroVarSameSubjectOrPredicate(Sentence originalMainSentence, Sentence subSentence, Term component, Term content, int index, DerivationContext nal)
private static void	CompositionalRules.processComposed(Statement statement, Term subject, Term predicate, int order, TruthValue truth, DerivationContext nal)	Finish composing implication term
(package private) static void	SyllogisticRules.resemblance(Term term1, Term term2, Sentence belief, Sentence sentence, int figure, DerivationContext nal)	{<S <=> M>, << <=> P>} |- <S <=> P>
(package private) static void	StructuralRules.splitConjunctionApart(CompoundTerm compound, Term component, boolean compoundTask, int index, DerivationContext nal)	{(#,A,B,C,D,E), C@(#,A,B,C,D,E)} |- (#,A,B,C), (#,C,D,E) Works for all conjunctions
(package private) static boolean	StructuralRules.structuralCompound(CompoundTerm compound, Term component, boolean compoundTask, int index, DerivationContext nal)	{(&&, A, B), A@(&&, A, B)} |- A, or answer (&&, A, B)? using A {(||, A, B), A@(||, A, B)} |- A, or answer (||, A, B)? using A
private static void	StructuralRules.structuralStatement(Term subject, Term predicate, int order, TruthValue truth, DerivationContext nal)	Common final operations of the above two methods
private static void	RuleTables.syllogisms(TaskLink tLink, TermLink bLink, Term taskTerm, Term beliefTerm, DerivationContext nal)	Meta-table of syllogistic rules, indexed by the content classes of the taskSentence and the belief
(package private) static void	StructuralRules.takeOutFromConjunction(CompoundTerm compound, Term component, boolean compoundTask, int index, DerivationContext nal)	{(&&,A,B,C), B@(&&,A,B,C)} |- (&&,A,C) Works for all conjunctions
protected static boolean	TemporalRules.termForTemporalInduction(Term t)	whether a term can be used in temoralInduction(,,)
static boolean	TemporalRules.tooMuchTemporalStatements(Term t)	whether temporal induction can generate a task by avoiding producing wrong terms; only one temporal operator is allowed
private static void	StructuralRules.transformPredicatePI(short index, Term subject, CompoundTerm predicate, DerivationContext nal)	Equivalent transformation between products and images when the predicate is a compound {<(*, S, M) --> P>, S@(*, S, M)} |- <S --> (/, P, _, M)> {<S --> (/, P, _, M)>, P@(/, P, _, M)} |- <(*, S, M) --> P> {<S --> (/, P, _, M)>, M@(/, P, _, M)} |- <M --> (/, P, S, _)>
private static void	StructuralRules.transformSubjectPI(short index, CompoundTerm subject, Term predicate, DerivationContext nal)	Equivalent transformation between products and images when the subject is a compound {<(*, S, M) --> P>, S@(*, S, M)} |- <S --> (/, P, _, M)> {<S --> (/, P, _, M)>, P@(/, P, _, M)} |- <(*, S, M) --> P> {<S --> (/, P, _, M)>, M@(/, P, _, M)} |- <M --> (/, P, S, _)>

Method parameters in org.opennars.inference with type arguments of type Term

Modifier and Type	Method	Description
static void	CompositionalRules.addVariableCandidates(Set<Term> candidates, Term side, boolean subject)	Add the variable candidates that appear as subjects and predicates
private static void	CompositionalRules.eliminateVariableOfConditionAbductiveInner1(Sentence sentence, Sentence belief, DerivationContext nal, CompoundTerm s1, Map<Term,Term> res3, Term s12)
private static void	CompositionalRules.eliminateVariableOfConditionAbductiveInner1(Sentence sentence, Sentence belief, DerivationContext nal, CompoundTerm s1, Map<Term,Term> res3, Term s12)
private static void	CompositionalRules.eliminateVariableOfConditionAbductiveTryCrossUnification(Sentence sentence, Sentence belief, DerivationContext nal, Term s1, Term p2, Map<Term,Term> res3, Map<Term,Term> res4)
private static void	CompositionalRules.eliminateVariableOfConditionAbductiveTryCrossUnification(Sentence sentence, Sentence belief, DerivationContext nal, Term s1, Term p2, Map<Term,Term> res3, Map<Term,Term> res4)
private static void	CompositionalRules.eliminateVariableOfConditionAbductiveTryUnification1(Sentence sentence, Sentence belief, DerivationContext nal, Term p1, CompoundTerm p2, Map<Term,Term> res3, Map<Term,Term> res4)
private static void	CompositionalRules.eliminateVariableOfConditionAbductiveTryUnification1(Sentence sentence, Sentence belief, DerivationContext nal, Term p1, CompoundTerm p2, Map<Term,Term> res3, Map<Term,Term> res4)

Uses of Term in org.opennars.io

Methods in org.opennars.io that return Term

Modifier and Type	Method	Description
private Term	Narsese.parseAtomicTerm(String s0)	Parse a term that has no internal structure.
private Term	Narsese.parseCompoundTerm(String s0)	Parse a String to create a CompoundTerm.
Term	Narsese.parseTerm(String s)	Top-level method that react a Term in general, which may recursively call itself.

Methods in org.opennars.io that return types with arguments of type Term

Modifier and Type	Method	Description
private List<Term>	Narsese.parseArguments(String s0)	Parse a String into the argument get of a CompoundTerm.

Uses of Term in org.opennars.language

Subclasses of Term in org.opennars.language

Modifier and Type	Class	Description
class	CompoundTerm	Compound term as defined in the NARS-theory
class	Conjunction	Conjunction of statements as defined in the NARS-theory
class	DifferenceExt	A compound term whose extension is the difference of the extensions of its term as defined in the NARS-theory
class	DifferenceInt	A compound term whose extension is the difference of the intensions of its term as defined in the NARS-theory
class	Disjunction	A disjunction of Statements as defined in the NARS-theory
class	Equivalence	A Statement about an Equivalence relation as defined in the NARS-theory
class	Image	Generalization of Images as defined in the NARS-theory
class	ImageExt	An extension image as defined in the NARS-theory
class	ImageInt	An intension image as defined in the NARS-theory
class	Implication	A Statement about an Inheritance copula as defined in the NARS-theory
class	Inheritance	A Statement about an Inheritance relation as defined in the NARS-theory
class	IntersectionExt	A compound term whose extension is the intersection of the extensions of its term as defined in the NARS-theory
class	IntersectionInt	A compound term whose intension is the intersection of the extensions of its term as defined in the NARS-theory
class	Interval	This stores the magnitude of a time difference, which is the logarithm of the time difference in base D=duration ( @see Param.java ).
class	Negation	A negation of a statement as defined in the NARS-theory
class	Product	A Product is a sequence of 1 or more terms as defined in the NARS-theory
class	SetExt	An extensionally defined set, which contains one or more instances as defined in the NARS-theory
class	SetInt	An intensionally defined set, which contains one or more instances defining the Term.
class	SetTensional	Base class for SetInt (intensional set) and SetExt (extensional set)
class	Similarity	A Statement about a Similarity relation as defined in the NARS-theory
class	Statement	A statement is a compound term as defined in the NARS-theory, consisting of a subject, a predicate, and a relation symbol in between.
class	Variable	A variable term, which does not correspond to a concept

Fields in org.opennars.language declared as Term

Modifier and Type	Field	Description
static Term[]	Term.EmptyTermArray
private Term	Variable.scope
static Term	Term.SELF
static Term	Term.SEQ_SPATIAL
static Term	Term.SEQ_TEMPORAL
Term[]	CompoundTerm.term	list of (direct) term

Fields in org.opennars.language with type parameters of type Term

Modifier and Type	Field	Description
private static Map<CharSequence,Term>	Term.atoms

Methods in org.opennars.language that return Term

Modifier and Type	Method	Description
Term	CompoundTerm.applySubstitute(Map<Term,Term> subs)	Recursively apply a substitute to the current CompoundTerm May return null if the term can not be created
private static Term	Variables.applySubstituteAndRenameVariables(CompoundTerm t, Map<Term,Term> subs)	appliesSubstitute and renameVariables, resulting in a cloned object, will not change this instance
abstract Term	CompoundTerm.clone(Term[] replaced)	Must be Term return type because the type of Term may change with different arguments
Term	Conjunction.clone(Term[] t)
Term	DifferenceExt.clone(Term[] replaced)
Term	DifferenceInt.clone(Term[] replaced)
Term	Disjunction.clone(Term[] x)
Term	ImageExt.clone(Term[] replaced)
Term	ImageInt.clone(Term[] replaced)
Term	IntersectionExt.clone(Term[] replaced)
Term	IntersectionInt.clone(Term[] replaced)
Term	Negation.clone(Term[] replaced)
Term	Term.clone()	Make a new Term with the same name.
Term	Term.cloneDeep()
Term[]	CompoundTerm.cloneTerms(Term... additional)	Clone the component list
static Term[]	CompoundTerm.cloneTermsAppend(Term[] original, Term[] additional)	Deep clone an array list of terms
Term[]	CompoundTerm.cloneTermsDeep()	forced deep clone of terms
Term[]	CompoundTerm.cloneTermsExcept(boolean requireModification, Term[] toRemove)	Cloned array of Terms, except for one or more Terms.
Term[]	CompoundTerm.cloneTermsReplacing(Term from, Term to)
Term[]	CompoundTerm.cloneVariableTermsDeep()
static Term[]	Conjunction.flatten(Term[] args, int order, boolean isSpatial)
static Term	Term.get(int i)	gets the atomic term of an integer
static Term	Term.get(CharSequence name)	gets the atomic term given a name
Term	Statement.getPredicate()	Return the second component of the statement
Term	Image.getRelation()	Get the relation term in the Image
Term	Variable.getScope()
Term	Statement.getSubject()	Return the first component of the statement
Term	Image.getTheOtherComponent()	Get the other term in the Image
private static Term	Conjunction.make(Collection<Term> set, int temporalOrder, boolean spatial)
static Term	Conjunction.make(Term[] argList)	Try to make a new compound from a list of term.
static Term	Conjunction.make(Term[] argList, int temporalOrder)	Try to make a new compound from a list of term.
static Term	Conjunction.make(Term[] argList, int temporalOrder, boolean spatial)
static Term	Conjunction.make(Term prefix, Interval suffix, int temporalOrder)
static Term	Conjunction.make(Term prefix, Interval ival, Term suffix, int temporalOrder)
static Term	Conjunction.make(Term term1, Term term2)	Try to make a new compound from two term.
static Term	Conjunction.make(Term term1, Term term2, int temporalOrder)
static Term	Conjunction.make(Term term1, Term term2, int temporalOrder, boolean spatial)
static Term	DifferenceExt.make(Term[] arg)	Try to make a new DifferenceExt.
static Term	DifferenceExt.make(Term t1, Term t2)	Try to make a new compound from two term.
static Term	DifferenceInt.make(Term[] arg)	Try to make a new DifferenceExt.
static Term	DifferenceInt.make(Term t1, Term t2)	Try to make a new compound from two term.
static Term	Disjunction.make(Term[] t)
static Term	Disjunction.make(Term term1, Term term2)	Try to make a new Disjunction from two term.
static Term	ImageExt.make(ImageExt oldImage, Term component, short index)	Try to make an Image from an existing Image and a component.
static Term	ImageExt.make(Product product, Term relation, short index)	Try to make an Image from a Product and a relation.
static Term	ImageExt.make(Term[] argList)	Try to make a new ImageExt.
static Term	ImageInt.make(ImageInt oldImage, Term component, short index)	Try to make an Image from an existing Image and a component.
static Term	ImageInt.make(Product product, Term relation, short index)	Try to make an Image from a Product and a relation.
static Term	ImageInt.make(Term[] argList)	Try to make a new ImageExt.
static Term	IntersectionExt.make(Term[] t)
static Term	IntersectionExt.make(Term term1, Term term2)	Try to make a new compound from two term.
static Term	IntersectionInt.make(Term[] t)
static Term	IntersectionInt.make(Term term1, Term term2)	Try to make a new compound from two term.
static Term	Negation.make(Term t)	Try to make a Negation of one component.
static Term	Negation.make(Term[] argument)	Try to make a new Negation.
static Term	Product.make(CompoundTerm image, Term component, int index)	Try to make a Product from an ImageExt/ImageInt and a component.
static Term	Equivalence.makeTerm(Term subject, Term predicate, int temporalOrder)	alternate version of Inheritance.make that allows equivalent subject and predicate to be reduced to the common term.
static Term	Inheritance.makeTerm(Term subject, Term predicate)	alternate version of Inheritance.make that allows equivalent subject and predicate to be reduced to the common term.
static Term	Similarity.makeTerm(Term subject, Term predicate)	alternate version of make that allows equivalent subject and predicate to be reduced to the common term.
static Term	Terms.reduceComponentOneLayer(CompoundTerm compound, Term component, Memory memory)
static Term	Terms.reduceComponents(CompoundTerm compound, Term component, Memory memory)	Try to remove a component from a compound
static Term	Terms.reduceUntilLayer2(CompoundTerm _itself, Term replacement, Memory memory)
static Term	CompoundTerm.replaceIntervals(Term T)
Term	Statement.retBySide(Statement.EnumStatementSide side)	returns the subject (0) or predicate(1)
Term	CompoundTerm.setComponent(int index, Term t, Memory memory)	Try to replace a component in a compound at a given index by another one
static Term[]	Conjunction.simplifyIntervals(Term[] components)
static Term	Terms.term(Symbols.NativeOperator copula, Term[] componentList)	Try to make a compound term from an operator and a list of term
static Term	Terms.term(CompoundTerm compound, Collection<Term> components)
static Term	Terms.term(CompoundTerm compound, Term[] components)	Try to make a compound term from a template and a list of term
static Term[]	CompoundTerm.termArray(Term... t)	build a component list from terms
static Term	Term.text(String t)	Creates a quote-escaped term from a string.
static Term[]	Term.toSortedSetArray(Term... arg)
static Term	Terms.unwrapNegation(Term T)
static Term	Conjunction.UpdateRelativeIndices(int minX, int minY, int minsX, int minsY, Term term)
static Term[]	Terms.verifySortedAndUnique(Term[] arg, boolean allowSingleton)

Methods in org.opennars.language that return types with arguments of type Term

Modifier and Type	Method	Description
static Set<Term>	CompoundTerm.addComponentsRecursively(Term t, Set<Term> components)	Add all the components of term t into components recursively
List<Term>	CompoundTerm.asTermList()
List<Term>	CompoundTerm.cloneTermsListDeep()	forced deep clone of terms
private static Map<Term,Term>[]	Variables.copyMapFrom(Map<Term,Term>[] source)	copies two maps from source into two new maps
private static Map<Term,Term>[]	Variables.copyMapFrom(Map<Term,Term>[] source)	copies two maps from source into two new maps
Map<Term,Integer>	CompoundTerm.countTermRecursively(Map<Term,Integer> map)	Recursively count how often the terms are contained
Map<Term,Integer>	Term.countTermRecursively(Map<Term,Integer> map)	Recursively count how often the terms are contained
Map<Term,Integer>	Variable.countTermRecursively(Map<Term,Integer> map)
Set<Term>	CompoundTerm.getContainedTerms()	Gives a set of all contained term, recursively
Iterator<Term>	CompoundTerm.iterator()
static List<Term>	CompoundTerm.termList(Term... t)
static NavigableSet<Term>	Term.toSortedSet(Term... arg)

Methods in org.opennars.language with parameters of type Term

Modifier and Type	Method	Description
static Set<Term>	CompoundTerm.addComponentsRecursively(Term t, Set<Term> components)	Add all the components of term t into components recursively
static boolean	Negation.areMutuallyInverse(Term tc, Term ptc)
abstract Term	CompoundTerm.clone(Term[] replaced)	Must be Term return type because the type of Term may change with different arguments
Term	Conjunction.clone(Term[] t)
Term	DifferenceExt.clone(Term[] replaced)
Term	DifferenceInt.clone(Term[] replaced)
Term	Disjunction.clone(Term[] x)
Equivalence	Equivalence.clone(Term[] t)
Term	ImageExt.clone(Term[] replaced)
Term	ImageInt.clone(Term[] replaced)
Implication	Implication.clone(Term[] t)
Inheritance	Inheritance.clone(Term[] t)
Term	IntersectionExt.clone(Term[] replaced)
Term	IntersectionInt.clone(Term[] replaced)
Term	Negation.clone(Term[] replaced)
CompoundTerm	Product.clone(Term[] replaced)
SetExt	SetExt.clone(Term[] replaced)
SetInt	SetInt.clone(Term[] replaced)
Similarity	Similarity.clone(Term[] replaced)
Term[]	CompoundTerm.cloneTerms(Term... additional)	Clone the component list
static Term[]	CompoundTerm.cloneTermsAppend(Term[] original, Term[] additional)	Deep clone an array list of terms
Term[]	CompoundTerm.cloneTermsExcept(boolean requireModification, Term[] toRemove)	Cloned array of Terms, except for one or more Terms.
Term[]	CompoundTerm.cloneTermsReplacing(Term from, Term to)
boolean	CompoundTerm.containsAllTermsOf(Term t)	Check whether the compound contains all term of another term, or that term as a whole
static boolean	Terms.containsAny(Term[] a, Collection<Term> b)	a contains any of b NOT TESTED YET
boolean	CompoundTerm.containsTerm(Term t)	Check whether the compound contains a certain component Also matches variables, ex: (&&,<a --> b>,<b --> c>) also contains <a --> #1>
boolean	Term.containsTerm(Term target)	whether this contains a term in its components.
boolean	CompoundTerm.containsTermRecursively(Term target)	Recursively check if a compound contains a term
boolean	Term.containsTermRecursively(Term target)	Recursively check if a compound contains a term
static boolean	Variables.containVar(Term[] t)
static void	DifferenceInt.ensureValidDifferenceArguments(Term[] arg)
(package private) static boolean	Terms.equals(Term[] a, Term[] b)
static boolean	Terms.equalSubjectPredicateInRespectToImageAndProduct(Term a, Term b)
static boolean	Terms.equalSubTermsInRespectToImageAndProduct(Term a, Term b)
static List<Long>	CompoundTerm.extractIntervals(Memory mem, Term T)
static boolean	Variables.findSubstitute(Random rnd, char type, Term term1, Term term2, Map<Term,Term>[] map)	map is a 2-element array of Map<Term,Term>.
static boolean	Variables.findSubstitute(Random rnd, char type, Term term1, Term term2, Map<Term,Term>[] map, boolean allowPartial)
static boolean	Variables.findSubstitute(Random rnd, char type, Term term1, Term term2, Map<Term,Term> map1, Map<Term,Term> map2)
static Term[]	Conjunction.flatten(Term[] args, int order, boolean isSpatial)
static boolean	Variables.hasSubstitute(Random rnd, char type, Term term1, Term term2)	Check if two terms can be unified
static boolean	Variables.indepVarUsedInvalid(Term T)	examines whether a term is using an independent variable in an invalid way
protected void	CompoundTerm.init(Term[] term)	call this after changing Term[] contents
protected void	Image.init(Term[] components)
protected void	Statement.init(Term[] t)
static boolean	Statement.invalidPair(Term s1, Term s2)
private static boolean	Statement.invalidReflexive(Term t1, Term t2)	Check if one term is identical to or included in another one, except in a reflexive relation
static boolean	Statement.invalidStatement(Term subject, Term predicate)
static boolean	Statement.invalidStatement(Term subject, Term predicate, boolean checkSameTermInPredicateAndSubject)	Check the validity of a potential Statement.
static boolean	Conjunction.isConjunctionAndHasSameOrder(Term t, int order)
static boolean	Image.isPlaceHolder(Term t)
static boolean	Term.isSelf(Term t)
static Term	Conjunction.make(Term[] argList)	Try to make a new compound from a list of term.
static Term	Conjunction.make(Term[] argList, int temporalOrder)	Try to make a new compound from a list of term.
static Term	Conjunction.make(Term[] argList, int temporalOrder, boolean spatial)
static Term	Conjunction.make(Term prefix, Interval suffix, int temporalOrder)
static Term	Conjunction.make(Term prefix, Interval ival, Term suffix, int temporalOrder)
static Term	Conjunction.make(Term term1, Term term2)	Try to make a new compound from two term.
static Term	Conjunction.make(Term term1, Term term2, int temporalOrder)
static Term	Conjunction.make(Term term1, Term term2, int temporalOrder, boolean spatial)
static Term	DifferenceExt.make(Term[] arg)	Try to make a new DifferenceExt.
static Term	DifferenceExt.make(Term t1, Term t2)	Try to make a new compound from two term.
static Term	DifferenceInt.make(Term[] arg)	Try to make a new DifferenceExt.
static Term	DifferenceInt.make(Term t1, Term t2)	Try to make a new compound from two term.
static Term	Disjunction.make(Term[] t)
static Term	Disjunction.make(Term term1, Term term2)	Try to make a new Disjunction from two term.
static Equivalence	Equivalence.make(Term subject, Term predicate)	Try to make a new compound from two term.
static Equivalence	Equivalence.make(Term subject, Term predicate, int temporalOrder)
static Term	ImageExt.make(ImageExt oldImage, Term component, short index)	Try to make an Image from an existing Image and a component.
static Term	ImageExt.make(Product product, Term relation, short index)	Try to make an Image from a Product and a relation.
static Term	ImageExt.make(Term[] argList)	Try to make a new ImageExt.
static Term	ImageInt.make(ImageInt oldImage, Term component, short index)	Try to make an Image from an existing Image and a component.
static Term	ImageInt.make(Product product, Term relation, short index)	Try to make an Image from a Product and a relation.
static Term	ImageInt.make(Term[] argList)	Try to make a new ImageExt.
static ImageInt	ImageInt.make(Term[] argument, short index)	Try to make a new compound from a set of term.
static Implication	Implication.make(Term subject, Term predicate)	Try to make a new compound from two term.
static Implication	Implication.make(Term subject, Term predicate, int temporalOrder)
static Inheritance	Inheritance.make(Term subject, Term predicate)	Try to make a new compound from two term.
static Inheritance	Instance.make(Term subject, Term predicate)	Try to make a new compound from two components.
static Inheritance	InstanceProperty.make(Term subject, Term predicate)	Try to make a new compound from two components.
static Term	IntersectionExt.make(Term[] t)
static Term	IntersectionExt.make(Term term1, Term term2)	Try to make a new compound from two term.
static Term	IntersectionInt.make(Term[] t)
static Term	IntersectionInt.make(Term term1, Term term2)	Try to make a new compound from two term.
static Term	Negation.make(Term t)	Try to make a Negation of one component.
static Term	Negation.make(Term[] argument)	Try to make a new Negation.
static Term	Product.make(CompoundTerm image, Term component, int index)	Try to make a Product from an ImageExt/ImageInt and a component.
static Product	Product.make(Term... arg)
static Inheritance	Property.make(Term subject, Term predicate)	Try to make a new compound from two components.
static SetExt	SetExt.make(Term... t)
static SetInt	SetInt.make(Term... t)
static Similarity	Similarity.make(Term subject, Term predicate)	Try to make a new compound from two term.
static Statement	Statement.make(Symbols.NativeOperator o, Term subject, Term predicate, boolean customOrder, int order)	Make a Statement from String, called by StringParser
static Statement	Statement.make(Symbols.NativeOperator op, Term subj, Term pred, int order)	Make a Statement from given term, called by the rules
static Statement	Statement.make(Statement statement, Term subj, Term pred)	Make a Statement from given components, called by the rules
static Statement	Statement.make(Statement statement, Term subj, Term pred, int order)
static Variable	Variables.makeCommonVariable(Term v1, Term v2)
protected static CharSequence	CompoundTerm.makeCompoundName(Symbols.NativeOperator op, Term... arg)	default method to make the oldName of a compound term from given fields
protected static String	Image.makeImageName(Symbols.NativeOperator op, Term[] arg, int relationIndex)	default method to make the oldName of an image term from given fields
static CharSequence	Implication.makeName(Term subject, int temporalOrder, Term predicate)
protected static CharSequence	SetTensional.makeSetName(char opener, Term[] arg, char closer)	make the oldName of an ExtensionSet or IntensionSet
protected static CharSequence	Statement.makeStatementName(Term subject, Symbols.NativeOperator relation, Term predicate)
static Statement	Statement.makeSym(Statement statement, Term subj, Term pred, int order)	Make a symmetric Statement from given term and temporal information, called by the rules
static Term	Equivalence.makeTerm(Term subject, Term predicate, int temporalOrder)	alternate version of Inheritance.make that allows equivalent subject and predicate to be reduced to the common term.
static Term	Inheritance.makeTerm(Term subject, Term predicate)	alternate version of Inheritance.make that allows equivalent subject and predicate to be reduced to the common term.
static Term	Similarity.makeTerm(Term subject, Term predicate)	alternate version of make that allows equivalent subject and predicate to be reduced to the common term.
void	Term.recurseSubtermsContainingVariables(Term.TermVisitor v, Term parent)
void	Term.recurseTerms(Term.TermVisitor v, Term parent)
static Term	Terms.reduceComponentOneLayer(CompoundTerm compound, Term component, Memory memory)
static Term	Terms.reduceComponents(CompoundTerm compound, Term component, Memory memory)	Try to remove a component from a compound
static Term	Terms.reduceUntilLayer2(CompoundTerm _itself, Term replacement, Memory memory)
static Term	CompoundTerm.replaceIntervals(Term T)
Term	CompoundTerm.setComponent(int index, Term t, Memory memory)	Try to replace a component in a compound at a given index by another one
Variable	Variable.setScope(Term scope, CharSequence n)
(package private) static void	CompoundTerm.shuffle(Term[] ar, Random randomNumber)
static Term[]	Conjunction.simplifyIntervals(Term[] components)
static Term	Terms.term(Symbols.NativeOperator copula, Term[] componentList)	Try to make a compound term from an operator and a list of term
static Term	Terms.term(CompoundTerm compound, Term[] components)	Try to make a compound term from a template and a list of term
static Term[]	CompoundTerm.termArray(Term... t)	build a component list from terms
static List<Term>	CompoundTerm.termList(Term... t)
static NavigableSet<Term>	Term.toSortedSet(Term... arg)
static Term[]	Term.toSortedSetArray(Term... arg)
static boolean	Variables.unify(Random rnd, char type, Term[] t)	To unify two terms
static boolean	Variables.unify(Random rnd, char type, Term t1, Term t2, Term[] compound)	To unify two terms
static boolean	Variables.unify(Random rnd, char type, Term t1, Term t2, Term[] compound, boolean allowPartial)
static Term	Terms.unwrapNegation(Term T)
static CompoundTerm.ConvRectangle	CompoundTerm.UpdateConvRectangle(Term[] term)
static Term	Conjunction.UpdateRelativeIndices(int minX, int minY, int minsX, int minsY, Term term)
static boolean	Term.valid(Term content)	performs a thorough check of the validity of a term (by cloneDeep it) to see if it's valid
(package private) static void	Terms.verifyNonNull(Term... t)
static Term[]	Terms.verifySortedAndUnique(Term[] arg, boolean allowSingleton)
void	Term.TermVisitor.visit(Term t, Term superterm)

Method parameters in org.opennars.language with type arguments of type Term

Modifier and Type	Method	Description
static Set<Term>	CompoundTerm.addComponentsRecursively(Term t, Set<Term> components)	Add all the components of term t into components recursively
void	CompoundTerm.addTermsTo(Collection<Term> c)
private static void	Variables.appendToMap(Map<Term,Term> source, Map<Term,Term> target)
private static void	Variables.appendToMap(Map<Term,Term> source, Map<Term,Term> target)
Term	CompoundTerm.applySubstitute(Map<Term,Term> subs)	Recursively apply a substitute to the current CompoundTerm May return null if the term can not be created
Term	CompoundTerm.applySubstitute(Map<Term,Term> subs)	Recursively apply a substitute to the current CompoundTerm May return null if the term can not be created
private static Term	Variables.applySubstituteAndRenameVariables(CompoundTerm t, Map<Term,Term> subs)	appliesSubstitute and renameVariables, resulting in a cloned object, will not change this instance
private static Term	Variables.applySubstituteAndRenameVariables(CompoundTerm t, Map<Term,Term> subs)	appliesSubstitute and renameVariables, resulting in a cloned object, will not change this instance
CompoundTerm	CompoundTerm.applySubstituteToCompound(Map<Term,Term> substitute)	returns result of applySubstitute, if and only if it's a CompoundTerm.
CompoundTerm	CompoundTerm.applySubstituteToCompound(Map<Term,Term> substitute)	returns result of applySubstitute, if and only if it's a CompoundTerm.
static boolean	Terms.containsAny(Term[] a, Collection<Term> b)	a contains any of b NOT TESTED YET
Map<Term,Integer>	CompoundTerm.countTermRecursively(Map<Term,Integer> map)	Recursively count how often the terms are contained
Map<Term,Integer>	Term.countTermRecursively(Map<Term,Integer> map)	Recursively count how often the terms are contained
Map<Term,Integer>	Variable.countTermRecursively(Map<Term,Integer> map)
static boolean	Variables.findSubstitute(Random rnd, char type, Term term1, Term term2, Map<Term,Term> map1, Map<Term,Term> map2)
static boolean	Variables.findSubstitute(Random rnd, char type, Term term1, Term term2, Map<Term,Term> map1, Map<Term,Term> map2)
private static Term	Conjunction.make(Collection<Term> set, int temporalOrder, boolean spatial)
static SetExt	SetExt.make(Collection<Term> l)
static SetInt	SetInt.make(Collection<Term> l)
static Term	Terms.term(CompoundTerm compound, Collection<Term> components)

Constructors in org.opennars.language with parameters of type Term

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()
Conjunction(Term[] arg, int order, boolean normalized, boolean spatial)
Conjunction(Term[] arg, int order, boolean normalized, boolean spatial, CompoundTerm.ConvRectangle rect)	Constructor with partial values, called by make
DifferenceExt(Term[] arg)	Constructor with partial values, called by make
DifferenceInt(Term[] arg)	Constructor with partial values, called by make
Disjunction(Term[] arg)	Constructor with partial values, called by make
Equivalence(Term[] components, int order)	Constructor with partial values, called by make
Image(Term[] components, short relationIndex)
ImageExt(Term[] arg, short index)	Constructor with partial values, called by make
ImageInt(Term[] arg, short index)	constructor with partial values, called by make
Implication(Term[] arg, int order)	Constructor with partial values, called by make
Implication(Term[] arg, int order, long counter)	Constructor with partial values, called by make
Implication(Term subject, Term predicate, int order)
Inheritance(Term[] arg)	Constructor with partial values, called by make
Inheritance(Term subj, Term pred)
IntersectionExt(Term[] arg)	Constructor with partial values, called by make
IntersectionInt(Term[] arg)	Constructor with partial values, called by make
Negation(Term t)	avoid using this externally, because double-negatives can be unwrapped to the original term using Negation.make
Product(Term... arg)	Constructor with partial values, called by make
SetExt(Term... arg)	Constructor with partial values, called by make
SetInt(Term... arg)	Constructor with partial values, called by make
SetTensional(Term[] arg)	Constructor with partial values, called by make
Similarity(Term[] arg)	Constructor with partial values, called by make
Similarity(Term subj, Term pred)
Statement(Term[] arg)	Constructor with partial values, called by make Subclass constructors should call init after any initialization
Variable(CharSequence name, Term scope)	Constructor, from a given variable name

Constructor parameters in org.opennars.language with type arguments of type Term

Constructor	Description
Product(List<Term> x)

Uses of Term in org.opennars.main

Fields in org.opennars.main declared as Term

Modifier and Type	Field	Description
(package private) Term	NarNode.TargetNar.mustContainTerm

Fields in org.opennars.main with type parameters of type Term

Modifier and Type	Field	Description
protected Map<Term,SensoryChannel>	Nar.sensoryChannels

Methods in org.opennars.main with parameters of type Term

Modifier and Type	Method	Description
void	NarNode.addRedirectionTo(String targetIP, int targetPort, float taskThreshold, Term mustContainTerm, boolean sendInput)	Add another target Nar node to redirect tasks to, and under which conditions.
static void	NarNode.sendNarsese(String input, String targetIP, int targetPort, float taskThreshold, Term mustContainTerm)

Constructors in org.opennars.main with parameters of type Term

Constructor	Description
TargetNar(String targetIP, int targetPort, float threshold, Term mustContainTerm, boolean sendInput)	The target Nar node, specifying under which conditions the current Nar node redirects tasks to it.

Uses of Term in org.opennars.operator

Subclasses of Term in org.opennars.operator

Modifier and Type	Class	Description
class	FunctionOperator	Superclass of functions that execute synchronously (blocking, in thread) and take N input parameters and one variable argument (as the final argument), generating a new task with the result of the function substituted in the variable's place.
class	NullOperator	A class used as a template for Operator definition.
class	Operation	An operation is interpreted as an Inheritance relation.
class	Operator	An individual operator that can be execute by the system, which can be either inside NARS or outside it, in another system or device.

Fields in org.opennars.operator declared as Term

Modifier and Type	Field	Description
static Term[]	Operation.SELF_TERM_ARRAY

Methods in org.opennars.operator that return Term

Modifier and Type	Method	Description
protected abstract Term	FunctionOperator.function(Memory memory, Term[] x)	y = function(x)
protected abstract Term	FunctionOperator.getRange()	Deprecated.

Methods in org.opennars.operator with parameters of type Term

Modifier and Type	Method	Description
boolean	Operator.call(Operation operation, Term[] args, Memory memory, Timable time)	The standard way to carry out an operation, which invokes the execute method defined for the operator, and handles feedback tasks as input
float	FunctionOperator.equals(Term a, Term b)	(can be overridden in subclasses) the extent to which it is truth that the 2 given terms are equal.
protected List<Task>	FunctionOperator.execute(Operation operation, Term[] args, Memory m, Timable time)
protected List<Task>	NullOperator.execute(Operation operation, Term[] args, Memory memory, Timable time)	called from Operator
protected abstract List<Task>	Operator.execute(Operation operation, Term[] args, Memory memory, Timable time)	Required method for every operator, specifying the corresponding operation
protected abstract Term	FunctionOperator.function(Memory memory, Term[] x)	y = function(x)
static Operation	Operation.make(Operator oper, Term[] arg, boolean addSelf)	Try to make a new compound from two components.
static CharSequence	Operation.makeName(CharSequence op, Term[] arg)
static void	Operator.reportExecution(Operation operation, Term[] args, Object feedback, Memory memory)

Constructors in org.opennars.operator with parameters of type Term

Constructor	Description
Operation(Term[] t)
Operation(Term argProduct, Term operator)	Constructor with partial values, called by make

Uses of Term in org.opennars.operator.mental

Subclasses of Term in org.opennars.operator.mental

Modifier and Type	Class	Description
class	Anticipate	Operator that creates a judgment with a given statement
class	Believe	Operator that creates a judgment with a given statement Causes the system to belief things it has no evidence for
class	Consider	Operator that activates a concept
class	Doubt	Operator that activates a concept
class	Evaluate	Operator that creates a quest with a given statement
class	Feel	Feeling common operations
class	FeelBusy	Feeling busy value
class	FeelSatisfied	Feeling happy value
class	Hesitate	Operator that activates a concept
class	Name	Operator that give a CompoundTerm a new name
class	Register	Register a new operator when the system is running
class	Remind	Operator that activates a concept
class	Want	Operator that creates a goal with a given statement
class	Wonder	Operator that creates a question with a given statement

Fields in org.opennars.operator.mental declared as Term

Modifier and Type	Field	Description
private Term	Feel.feelingTerm
(package private) static Term	Feel.selfSubject

Fields in org.opennars.operator.mental with type parameters of type Term

Modifier and Type	Field	Description
Map<Anticipate.Prediction,LinkedHashSet<Term>>	Anticipate.anticipations
private Set<Term>	Anticipate.newTasks

Methods in org.opennars.operator.mental with parameters of type Term

Modifier and Type	Method	Description
void	Anticipate.anticipate(Term content, Memory memory, long occurenceTime, Task t, Timable time)
void	Anticipate.anticipationFeedback(Term content, Task t, Memory memory, Timable time)
protected void	Anticipate.deriveDidntHappen(Term aTerm, long expectedOccurenceTime, DerivationContext nal)
protected List<Task>	Anticipate.execute(Operation operation, Term[] args, Memory memory, Timable time)
protected List<Task>	Believe.execute(Operation operation, Term[] args, Memory memory, Timable time)	To create a judgment with a given statement
protected List<Task>	Consider.execute(Operation operation, Term[] args, Memory memory, Timable time)	To activate a concept as if a question has been asked about it
protected List<Task>	Doubt.execute(Operation operation, Term[] args, Memory memory, Timable time)	To activate a concept as if a question has been asked about it
protected List<Task>	Evaluate.execute(Operation operation, Term[] args, Memory memory, Timable time)	To create a quest with a given statement
protected List<Task>	FeelBusy.execute(Operation operation, Term[] args, Memory memory, Timable time)	To get the current value of an internal sensor
protected List<Task>	FeelSatisfied.execute(Operation operation, Term[] args, Memory memory, Timable time)	To get the current value of an internal sensor
protected List<Task>	Hesitate.execute(Operation operation, Term[] args, Memory memory, Timable time)	To activate a concept as if a question has been asked about it
protected List<Task>	Name.execute(Operation operation, Term[] args, Memory memory, Timable time)	To create a judgment with a given statement
protected List<Task>	Register.execute(Operation operation, Term[] args, Memory memory, Timable time)	To register a new operator
protected List<Task>	Remind.execute(Operation operation, Term[] args, Memory memory, Timable time)	To activate a concept as if a question has been asked about it
protected List<Task>	Want.execute(Operation operation, Term[] args, Memory memory, Timable time)	To create a goal with a given statement
protected List<Task>	Wonder.execute(Operation operation, Term[] args, Memory memory, Timable time)	To create a question with a given statement

Uses of Term in org.opennars.operator.misc

Subclasses of Term in org.opennars.operator.misc

Modifier and Type	Class	Description
class	Add	Count the number of elements in a set
class	Count	Count the number of elements in a set 'INVALID (^count,a)! (^count,a,b)! (^count,a,#b)! 'VALID: (^count,[a,b],#b)!
class	Reflect	Produces canonical "Reflective-Narsese" representation of a parameter term
class	System	Count the number of elements in a set

Fields in org.opennars.operator.misc declared as Term

Modifier and Type	Field	Description
(package private) static Term	Count.counted

Methods in org.opennars.operator.misc that return Term

Modifier and Type	Method	Description
protected Term	Add.function(Memory memory, Term[] x)
protected Term	Count.function(Memory memory, Term[] x)
protected Term	Reflect.function(Memory memory, Term[] x)
protected Term	System.function(Memory memory, Term[] x)
static Term	Reflect.getMetaTerm(Term node)
protected Term	Add.getRange()
protected Term	Count.getRange()
protected Term	Reflect.getRange()
protected Term	System.getRange()
static Term	Reflect.sop(String operatorName, Term... t)
static Term	Reflect.sop(Statement s, String operatorName)
static Term	Reflect.sop(Statement s, Term predicate)
static Term	Reflect.sop(Term subject, Term object, Term predicate)	<(*,subject,object) --> predicate>

Methods in org.opennars.operator.misc with parameters of type Term

Modifier and Type	Method	Description
protected Term	Add.function(Memory memory, Term[] x)
protected Term	Count.function(Memory memory, Term[] x)
protected Term	Reflect.function(Memory memory, Term[] x)
protected Term	System.function(Memory memory, Term[] x)
static Term	Reflect.getMetaTerm(Term node)
static Term	Reflect.sop(String operatorName, Term... t)
static Term	Reflect.sop(Statement s, Term predicate)
static Term	Reflect.sop(Term subject, Term object, Term predicate)	<(*,subject,object) --> predicate>

Uses of Term in org.opennars.plugin.mental

Subclasses of Term in org.opennars.plugin.mental

Modifier and Type	Class	Description
static class	Abbreviation.Abbreviate	Operator that give a CompoundTerm an atomic name

Fields in org.opennars.plugin.mental declared as Term

Modifier and Type	Field	Description
(package private) static Term	Counting.CARDINALITY

Methods in org.opennars.plugin.mental that return Term

Modifier and Type	Method	Description
Term	Abbreviation.Abbreviate.newSerialTerm(char prefix)
static Term	InternalExperience.toTerm(Sentence s, Memory mem, Timable time)

Methods in org.opennars.plugin.mental with parameters of type Term

Modifier and Type	Method	Description
protected void	InternalExperience.beliefReason(Sentence belief, Term beliefTerm, Term taskTerm, DerivationContext nal)	used in full internal experience mode only
protected List<Task>	Abbreviation.Abbreviate.execute(Operation operation, Term[] args, Memory memory, Timable time)	To create a judgment with a given statement

Uses of Term in org.opennars.plugin.perception

Fields in org.opennars.plugin.perception declared as Term

Modifier and Type	Field	Description
private Term	SensoryChannel.label
(package private) Term	VisionChannel.label

Methods in org.opennars.plugin.perception with parameters of type Term

Modifier and Type	Method	Description
double	SensoryChannel.priority(Term t)
double	SensoryChannel.topDownPriority(Term t)

Constructors in org.opennars.plugin.perception with parameters of type Term

Constructor	Description
SensoryChannel(Nar nar, Collection<SensoryChannel> reportResultsTo, int width, int height, int duration, Term label)
SensoryChannel(Nar nar, SensoryChannel reportResultsTo, int width, int height, int duration, Term label)

Uses of Term in org.opennars.storage

Fields in org.opennars.storage with type parameters of type Term

Modifier and Type	Field	Description
Bag<Concept,Term>	Memory.concepts
Bag<Task<Term>,Sentence<Term>>	Memory.novelTasks
Bag<Task<Term>,Sentence<Term>>	Memory.novelTasks
Bag<Task<Term>,Sentence<Term>>	Memory.recent_operations
Bag<Task<Term>,Sentence<Term>>	Memory.recent_operations
Bag<Task<Term>,Sentence<Term>>	Memory.seq_current
Bag<Task<Term>,Sentence<Term>>	Memory.seq_current

Methods in org.opennars.storage with parameters of type Term

Modifier and Type	Method	Description
Concept	Memory.concept(Term t)	Get an existing Concept for a given name
Concept	Memory.conceptualize(BudgetValue budget, Term term)	Get the Concept associated to a Term, or create it.

Constructor parameters in org.opennars.storage with type arguments of type Term

Constructor	Description
Memory(Parameters narParameters, Bag<Concept,Term> concepts, Bag<Task<Term>,Sentence<Term>> novelTasks, Bag<Task<Term>,Sentence<Term>> seq_current, Bag<Task<Term>,Sentence<Term>> recent_operations)	Create a new memory