| 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.events | |
| org.opennars.operator.mental | |
| org.opennars.plugin.mental |
| Modifier and Type | Method | Description |
|---|---|---|
static void |
TemporalInferenceControl.addToSequenceTasks(DerivationContext nal,
Task newEvent) |
|
static boolean |
TemporalInferenceControl.eventInference(Task newEvent,
DerivationContext nal) |
|
static boolean |
GeneralInferenceControl.fireConcept(DerivationContext nal,
int numTaskLinks) |
|
protected static void |
GeneralInferenceControl.fireTaskLink(DerivationContext nal,
int termLinks) |
|
static boolean |
GeneralInferenceControl.fireTermlink(TermLink termLink,
DerivationContext nal) |
|
static List<Task> |
TemporalInferenceControl.proceedWithTemporalInduction(Sentence newEvent,
Sentence stmLast,
Task controllerTask,
DerivationContext nal,
boolean SucceedingEventsInduction,
boolean addToMemory,
boolean allowSequence) |
| Modifier and Type | Method | Description |
|---|---|---|
protected static void |
ProcessJudgment.addToTargetConceptsPreconditions(Task task,
DerivationContext nal) |
Add <(&/,a,op()) =/> b> beliefs to preconditions in concept b
|
static void |
ProcessAnticipation.anticipate(DerivationContext nal,
Sentence mainSentence,
BudgetValue budget,
long mintime,
long maxtime,
float urgency,
Map<Term,Term> substitution) |
|
static void |
ProcessGoal.bestReactionForGoal(Concept concept,
DerivationContext nal,
Sentence projectedGoal,
Task task) |
When a goal is processed, use the best memorized reaction
that is applicable to the current context (recent events) in case that it exists.
|
private static ProcessGoal.ExecutablePrecondition |
ProcessGoal.calcBestExecutablePrecondition(DerivationContext nal,
Concept concept,
Sentence projectedGoal,
List<Task> execPreconditions,
Map<Operation,List<ProcessGoal.ExecutablePrecondition>> anticipationsToMake) |
Search for the best precondition that best matches recent events, and is most successful in leading to goal fulfilment
|
static void |
ProcessAnticipation.confirmAnticipation(Task task,
Concept concept,
DerivationContext nal) |
Whether a processed judgement task satisfies the anticipations within concept
|
static boolean |
ProcessGoal.executeOperation(DerivationContext nal,
Task t) |
Entry point for all potentially executable operation tasks.
|
private static boolean |
ProcessGoal.executePrecondition(DerivationContext nal,
ProcessGoal.ExecutablePrecondition precon,
Concept concept,
Sentence projectedGoal,
Task task) |
Execute the operation suggested by the most applicable precondition
|
static void |
ProcessAnticipation.firePredictions(Task judgementTask,
Concept concept,
DerivationContext nal,
Timable time,
TaskLink tasklink) |
Fire predictictive inference based on beliefs that are known to the concept's neighbours
|
static void |
ProcessJudgment.handleOperationFeedback(Task task,
DerivationContext nal) |
Handle the feedback of the operation that was processed as a judgment.
|
protected static boolean |
ProcessJudgment.isExecutableHypothesis(Task task,
DerivationContext nal) |
Check whether the task is an executable hypothesis of the form
<(&/,a,op()) =/> b>.
|
protected static void |
ProcessGoal.processGoal(Concept concept,
DerivationContext nal,
Task task) |
To accept a new goal, and check for revisions and realization, then
decide whether to actively pursue it, potentially executing in case of an operation goal
|
static void |
ProcessJudgment.processJudgment(Concept concept,
DerivationContext nal,
Task task) |
To accept a new judgment as belief, and check for revisions and solutions.
|
protected static void |
ProcessGoal.processOperationGoal(Sentence projectedGoal,
DerivationContext nal,
Concept concept,
Task oldGoalT,
Task task) |
To process an operation for potential execution
only called by processGoal
|
protected static void |
ProcessQuestion.processQuestion(Concept concept,
DerivationContext nal,
Task task) |
To answer a question by existing beliefs
|
static boolean |
ProcessTask.processTask(Concept concept,
DerivationContext nal,
Task task,
Timable time) |
Directly process a new task within a concept.Here task can either be a judgement, goal, question or quest.The function is called exactly once on each task.Using
local information and finishing in a constant time.
|
static void |
ProcessQuestion.ProcessWhatQuestion(Concept concept,
Task ques,
DerivationContext nal) |
Recognize an existing belief task as solution to the what question task, which contains a query variable
|
static void |
ProcessQuestion.ProcessWhatQuestionAnswer(Concept concept,
Task t,
DerivationContext nal) |
Recognize an added belief task as solution to what questions, those that contain query variable
|
static void |
ProcessGoal.questionFromGoal(Task task,
DerivationContext nal) |
Generate <?how =/> g>? question for g! goal.
|
| Modifier and Type | Method | Description |
|---|---|---|
Sentence |
Concept.getBelief(DerivationContext nal,
Task task) |
Select a isBelief to interact with the given task in inference
|
protected boolean |
Concept.insertTaskLink(TaskLink taskLink,
DerivationContext nal) |
Insert a TaskLink into the TaskLink bag
|
TaskLink |
Concept.linkToTask(Task task,
DerivationContext content) |
Link to a new task from all relevant concepts for continued processing in
the near future for unspecified time.
|
| 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>}
|
(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 |
TemporalRules.appendConclusion(DerivationContext nal,
TruthValue truth1,
BudgetValue budget1,
Statement statement1,
List<Task> success) |
|
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.asymmetricAsymmetric(Sentence taskSentence,
Sentence belief,
int figure,
DerivationContext nal) |
Syllogistic rules whose both premises are on the same asymmetric relation
|
private static void |
RuleTables.asymmetricSymmetric(Sentence asym,
Sentence sym,
int figure,
DerivationContext nal) |
Syllogistic rules whose first premise is on an asymmetric relation, and
the second on a symmetric relation
|
static BudgetValue |
BudgetFunctions.backward(TruthValue truth,
DerivationContext nal) |
Backward inference result and adjustment, stronger case
|
static BudgetValue |
BudgetFunctions.backwardWeak(TruthValue truth,
DerivationContext nal) |
Backward inference result and adjustment, weaker case
|
private static BudgetValue |
BudgetFunctions.budgetInference(float qual,
float complexity,
DerivationContext nal) |
Common processing for all inference step
|
private static void |
RuleTables.componentAndStatement(CompoundTerm compound,
short index,
Statement statement,
short side,
DerivationContext nal) |
Inference between a component term (of the current term) and a statement
|
(package private) static void |
CompositionalRules.composeCompound(Statement taskContent,
Statement beliefContent,
int index,
DerivationContext nal) |
{<S ==> M>, <P ==> M>} |-
{<(S|P) ==> M>, <(S&P) ==> M>, <(S-P) ==> M>, <(P-S) ==> M>} |
private static void |
RuleTables.compoundAndCompound(CompoundTerm taskTerm,
CompoundTerm beliefTerm,
int tindex,
int bindex,
DerivationContext nal) |
Inference between two compound terms
|
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
|
(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 |
RuleTables.conditionalDedIndWithVar(Sentence conditionalSentence,
Implication conditional,
short index,
Statement statement,
short side,
DerivationContext nal) |
Conditional deduction or induction, with variable unification
|
protected static boolean |
StructuralRules.contraposition(Statement statement,
Sentence sentence,
DerivationContext nal) |
{<A ==> B>, A@(--, A)} |- <(--, B) ==> (--, A)>
|
private static void |
LocalRules.conversion(DerivationContext nal) |
Produce an Inheritance/Implication from a reversed Inheritance/Implication
{<P --> S>} |- <S --> P> |
private static void |
LocalRules.convertedJudgment(TruthValue newTruth,
BudgetValue newBudget,
DerivationContext nal) |
Convert judgment into different relation
|
private static void |
LocalRules.convertRelation(DerivationContext nal) |
Switch between Inheritance/Implication and Similarity/Equivalence
{<S --> P>} |- <S <-> P> {<S <-> P>} |- <S --> P> |
private static void |
StructuralRules.createSequenceTaskByRange(Conjunction sourceConjunction,
int inclusiveStartIndex,
int inclusiveEndIndex,
DerivationContext nal) |
Derives a sub-sequence of a sequence based on a (inclusive) index range
|
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
|
(package private) static void |
SyllogisticRules.detachment(Sentence mainSentence,
Sentence subSentence,
int side,
boolean checkTermAgain,
DerivationContext nal) |
|
(package private) static void |
SyllogisticRules.detachment(Sentence mainSentence,
Sentence subSentence,
int side,
DerivationContext nal) |
{<<M --> S> ==> <M --> P>>, <M --> S>} |- <M --> P>
{<<M --> S> ==> <M --> P>>, <M --> P>} |- <M --> S> {<<M --> S> <=> <M --> P>>, <M --> S>} |- <M --> P> {<<M --> S> <=> <M --> P>>, <M --> P>} |- <M --> S> |
private static void |
RuleTables.detachmentWithVar(Sentence originalMainSentence,
Sentence subSentence,
int index,
boolean checkTermAgain,
DerivationContext nal) |
|
private static void |
RuleTables.detachmentWithVar(Sentence originalMainSentence,
Sentence subSentence,
int index,
DerivationContext nal) |
The detachment rule, with variable unification
|
static void |
CompositionalRules.eliminateVariableOfConditionAbductive(int figure,
Sentence sentence,
Sentence belief,
DerivationContext nal) |
|
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 &/)
|
static BudgetValue |
BudgetFunctions.forward(TruthValue truth,
DerivationContext nal) |
Forward inference result and adjustment
|
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
|
private static void |
LocalRules.inferToAsym(Sentence asym,
Sentence sym,
DerivationContext nal) |
Produce an Inheritance/Implication from a Similarity/Equivalence and a reversed Inheritance/Implication
{<S <-> P>, <P --> S>} |- <S --> P> |
private static void |
LocalRules.inferToSym(Sentence judgment1,
Sentence judgment2,
DerivationContext nal) |
Produce Similarity/Equivalence from a pair of reversed Inheritance/Implication
{<S --> P>, <P --> S} |- <S <-> p> |
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 boolean |
CompositionalRules.introVarInner(Statement premise1,
Statement premise2,
CompoundTerm oldCompound,
DerivationContext nal) |
{<M --> S>, <C ==> <M --> P>>} |- <(&&, <#x --> S>, C) ==> <#x --> P>>
{<M --> S>, (&&, C, <M --> P>)} |- (&&, C, <<#x --> S> ==> <#x --> P>>) |
static void |
CompositionalRules.introVarOuter(Statement taskContent,
Statement beliefContent,
int index,
DerivationContext nal) |
Introduce a dependent variable in an outer-layer conjunction
{<S --> P1>, <S --> P2>} |- (&&, <#x --> P1>, <#x --> P2>) |
(package private) static void |
CompositionalRules.IntroVarSameSubjectOrPredicate(Sentence originalMainSentence,
Sentence subSentence,
Term component,
Term content,
int index,
DerivationContext nal) |
|
static boolean |
LocalRules.match(Task task,
Sentence belief,
Concept beliefConcept,
DerivationContext nal) |
The task and belief have the same content
|
static void |
LocalRules.matchAsymSym(Sentence asym,
Sentence sym,
int figure,
DerivationContext nal) |
Inheritance/Implication matches Similarity/Equivalence
|
static void |
LocalRules.matchReverse(DerivationContext nal) |
The task and belief match reversely
|
private static void |
CompositionalRules.processComposed(Statement statement,
Term subject,
Term predicate,
int order,
TruthValue truth,
DerivationContext nal) |
Finish composing implication term
|
static void |
RuleTables.reason(TaskLink tLink,
TermLink bLink,
DerivationContext nal) |
Entry point of the inference engine
|
(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 BudgetValue |
BudgetFunctions.revise(TruthValue tTruth,
TruthValue bTruth,
TruthValue truth,
boolean feedbackToLinks,
DerivationContext nal) |
Evaluate the quality of a revision, then de-prioritize the premises
|
static boolean |
LocalRules.revision(Sentence newBelief,
Sentence oldBelief,
Concept beliefConcept,
boolean feedbackToLinks,
DerivationContext nal) |
Belief revision
Summarizes the evidence of two beliefs with same content.
|
static void |
StructuralRules.seqToImage(Conjunction conj,
int index,
DerivationContext nal) |
|
static BudgetValue |
LocalRules.solutionEval(Task problem,
Sentence solution,
Task task,
DerivationContext nal) |
Evaluate the quality of a belief as a solution to a problem, then reward
the belief and de-prioritize the problem
|
(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 void |
StructuralRules.structuralCompose1(CompoundTerm compound,
short index,
Statement statement,
DerivationContext nal) |
{<S --> P>, P@(P|Q)} |- <S --> (P|Q)>
|
(package private) static void |
StructuralRules.structuralCompose2(CompoundTerm compound,
short index,
Statement statement,
short side,
DerivationContext nal) |
{<S --> P>, S@(S&T)} |- <(S&T) --> (P&T)>
{<S --> P>, S@(M-S)} |- <(M-P) --> (M-S)> |
(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 |
(package private) static void |
StructuralRules.structuralDecompose1(CompoundTerm compound,
short index,
Statement statement,
DerivationContext nal) |
{<(S|T) --> P>, S@(S|T)} |- <S --> P>
{<S --> (P&T)>, P@(P&T)} |- <S --> P> |
(package private) static void |
StructuralRules.structuralDecompose2(Statement statement,
int index,
DerivationContext nal) |
{<(S*T) --> (P*T)>, S@(S*T)} |- <S --> P>
|
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
|
private static void |
RuleTables.symmetricSymmetric(Sentence belief,
Sentence taskSentence,
int figure,
DerivationContext nal) |
Syllogistic rules whose both premises are on the same symmetric relation
|
(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
|
static List<Task> |
TemporalRules.temporalInduction(Sentence s1,
Sentence s2,
DerivationContext nal,
boolean SucceedingEventsInduction,
boolean addToMemory,
boolean allowSequence) |
|
static void |
StructuralRules.transformNegation(CompoundTerm content,
DerivationContext nal) |
{A, A@(--, A)} |- (--, A)
|
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, _)> |
(package private) static void |
StructuralRules.transformProductImage(Inheritance inh,
CompoundTerm oldContent,
short[] indices,
DerivationContext nal) |
Equivalent transformation between products and images
{<(*, 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, _)> |
(package private) static void |
StructuralRules.transformSetRelation(CompoundTerm compound,
Statement statement,
short side,
DerivationContext nal) |
{<S --> {P}>} |- <S <-> {P}>
|
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, _)> |
static void |
RuleTables.transformTask(TaskLink tLink,
DerivationContext nal) |
The TaskLink is of type TRANSFORM, and the conclusion is an equivalent
transformation
|
static boolean |
LocalRules.trySolution(Sentence belief,
Task task,
DerivationContext nal,
boolean report) |
Check if a Sentence provide a better answer to a Question or Goal
|
| Modifier and Type | Method | Description |
|---|---|---|
abstract void |
Events.TaskImmediateProcess.onProcessed(Task t,
DerivationContext n) |
| Modifier and Type | Field | Description |
|---|---|---|
private DerivationContext |
Anticipate.nal |
| Modifier and Type | Method | Description |
|---|---|---|
protected void |
Anticipate.deriveDidntHappen(Term aTerm,
long expectedOccurenceTime,
DerivationContext nal) |
|
void |
Anticipate.updateAnticipations(DerivationContext nal) |
| Modifier and Type | Method | Description |
|---|---|---|
void |
Emotions.adjustBusy(float newValue,
float weight,
DerivationContext nal) |
|
void |
Emotions.adjustSatisfaction(float newValue,
float weight,
DerivationContext nal) |
|
protected void |
InternalExperience.beliefReason(Sentence belief,
Term beliefTerm,
Term taskTerm,
DerivationContext nal) |
used in full internal experience mode only
|
Copyright © 2020 OpenNARS. All rights reserved.