use of nars.entity.Task in project opennars by opennars.
the class SpiralLayout method vertex.
@Override
public void vertex(AbstractGraphVis<Item, Object> g, VertexVis<Item, Object> v) {
Item vertex = v.getVertex();
float priority = vertex.getPriority();
boolean task = false;
Concept x = null;
if (vertex instanceof Concept) {
x = (Concept) vertex;
} else if (vertex instanceof Task) {
task = true;
x = nar.memory.concept(((Task) vertex).getTerm());
}
int i = 0;
try {
for (Concept c : nar.memory.concepts) {
if (x == c) {
// not elegant and fast but k at least no term equals
break;
}
i++;
}
} catch (Exception ex) {
}
float count_elems = nar.memory.concepts.size();
// float ratio = 30.0f*(0.10f + (((float)priority) / (1.0f)));
float ratio = 30.0f * (0.10f + (((float) i) / (count_elems)));
v.tx = (float) (ratio * Math.cos(ratio)) * spacing;
v.ty = (float) (ratio * Math.sin(ratio)) * spacing;
if (task) {
v.ty += spacing * Video.hashFloat(vertex.hashCode());
}
}
use of nars.entity.Task in project opennars by opennars.
the class CompositionalRules method introVarInner.
/**
* {<M --> S>, <C ==> <M --> P>>} |- <(&&, <#x --> S>, C) ==> <#x --> P>>
* {<M --> S>, (&&, C, <M --> P>)} |- (&&, C, <<#x --> S> ==> <#x --> P>>)
*
* @param taskContent The first premise directly used in internal induction,
* <M --> S>
* @param beliefContent The componentCommon to be used as a premise in
* internal induction, <M --> P>
* @param oldCompound The whole contentInd of the first premise, Implication
* or Conjunction
* @param nal Reference to the memory
*/
static boolean introVarInner(Statement premise1, Statement premise2, CompoundTerm oldCompound, DerivationContext nal) {
Task task = nal.getCurrentTask();
Sentence taskSentence = task.sentence;
if (!taskSentence.isJudgment() || (premise1.getClass() != premise2.getClass()) || oldCompound.containsTerm(premise1)) {
return false;
}
Term subject1 = premise1.getSubject();
Term subject2 = premise2.getSubject();
Term predicate1 = premise1.getPredicate();
Term predicate2 = premise2.getPredicate();
Term commonTerm1, commonTerm2;
if (subject1.equals(subject2)) {
commonTerm1 = subject1;
commonTerm2 = secondCommonTerm(predicate1, predicate2, 0);
} else if (predicate1.equals(predicate2)) {
commonTerm1 = predicate1;
commonTerm2 = secondCommonTerm(subject1, subject2, 0);
} else {
return false;
}
Sentence belief = nal.getCurrentBelief();
HashMap<Term, Term> substitute = new HashMap<>();
boolean b1 = false, b2 = false;
{
Variable varDep2 = new Variable("#varDep2");
Term content = Conjunction.make(premise1, oldCompound);
if (!(content instanceof CompoundTerm))
return false;
substitute.put(commonTerm1, varDep2);
content = ((CompoundTerm) content).applySubstitute(substitute);
TruthValue truth = intersection(taskSentence.truth, belief.truth);
BudgetValue budget = BudgetFunctions.forward(truth, nal);
b1 = (nal.doublePremiseTask(content, truth, budget, false, false)) != null;
}
substitute.clear();
{
Variable varInd1 = new Variable("$varInd1");
Variable varInd2 = new Variable("$varInd2");
substitute.put(commonTerm1, varInd1);
if (commonTerm2 != null) {
substitute.put(commonTerm2, varInd2);
}
Term content = Implication.make(premise1, oldCompound);
if ((content == null) || (!(content instanceof CompoundTerm))) {
return false;
}
content = ((CompoundTerm) content).applySubstituteToCompound(substitute);
TruthValue truth;
if (premise1.equals(taskSentence.term)) {
truth = induction(belief.truth, taskSentence.truth);
} else {
truth = induction(taskSentence.truth, belief.truth);
}
BudgetValue budget = BudgetFunctions.forward(truth, nal);
b2 = nal.doublePremiseTask(content, truth, budget, false, false) != null;
}
return b1 || b2;
}
use of nars.entity.Task in project opennars by opennars.
the class CompositionalRules method decomposeCompound.
/**
* {<(S|P) ==> M>, <P ==> M>} |- <S ==> M>
*
* @param implication The implication term to be decomposed
* @param componentCommon The part of the implication to be removed
* @param term1 The other term in the contentInd
* @param index The location of the shared term: 0 for subject, 1 for
* predicate
* @param compoundTask Whether the implication comes from the task
* @param nal Reference to the memory
*/
private static void decomposeCompound(CompoundTerm compound, Term component, Term term1, int index, boolean compoundTask, int order, DerivationContext nal) {
if ((compound instanceof Statement) || (compound instanceof ImageExt) || (compound instanceof ImageInt)) {
return;
}
Term term2 = reduceComponents(compound, component, nal.mem());
if (term2 == null) {
return;
}
long delta = 0;
while ((term2 instanceof Conjunction) && (((CompoundTerm) term2).term[0] instanceof Interval)) {
Interval interval = (Interval) ((CompoundTerm) term2).term[0];
delta += interval.time;
term2 = ((CompoundTerm) term2).setComponent(0, null, nal.mem());
}
Task task = nal.getCurrentTask();
Sentence sentence = task.sentence;
Sentence belief = nal.getCurrentBelief();
Statement oldContent = (Statement) task.getTerm();
TruthValue v1, v2;
if (compoundTask) {
v1 = sentence.truth;
v2 = belief.truth;
} else {
v1 = belief.truth;
v2 = sentence.truth;
}
TruthValue truth = null;
Term content;
if (index == 0) {
content = Statement.make(oldContent, term1, term2, order);
if (content == null) {
return;
}
if (oldContent instanceof Inheritance) {
if (compound instanceof IntersectionExt) {
truth = reduceConjunction(v1, v2);
} else if (compound instanceof IntersectionInt) {
truth = reduceDisjunction(v1, v2);
} else if ((compound instanceof SetInt) && (component instanceof SetInt)) {
truth = reduceConjunction(v1, v2);
} else if ((compound instanceof SetExt) && (component instanceof SetExt)) {
truth = reduceDisjunction(v1, v2);
} else if (compound instanceof DifferenceExt) {
if (compound.term[0].equals(component)) {
truth = reduceDisjunction(v2, v1);
} else {
truth = reduceConjunctionNeg(v1, v2);
}
}
} else if (oldContent instanceof Implication) {
if (compound instanceof Conjunction) {
truth = reduceConjunction(v1, v2);
} else if (compound instanceof Disjunction) {
truth = reduceDisjunction(v1, v2);
}
}
} else {
content = Statement.make(oldContent, term2, term1, order);
if (content == null) {
return;
}
if (oldContent instanceof Inheritance) {
if (compound instanceof IntersectionInt) {
truth = reduceConjunction(v1, v2);
} else if (compound instanceof IntersectionExt) {
truth = reduceDisjunction(v1, v2);
} else if ((compound instanceof SetExt) && (component instanceof SetExt)) {
truth = reduceConjunction(v1, v2);
} else if ((compound instanceof SetInt) && (component instanceof SetInt)) {
truth = reduceDisjunction(v1, v2);
} else if (compound instanceof DifferenceInt) {
if (compound.term[1].equals(component)) {
truth = reduceDisjunction(v2, v1);
} else {
truth = reduceConjunctionNeg(v1, v2);
}
}
} else if (oldContent instanceof Implication) {
if (compound instanceof Disjunction) {
truth = reduceConjunction(v1, v2);
} else if (compound instanceof Conjunction) {
truth = reduceDisjunction(v1, v2);
}
}
}
if (truth != null) {
BudgetValue budget = BudgetFunctions.compoundForward(truth, content, nal);
if (delta != 0) {
long baseTime = task.sentence.getOccurenceTime();
if (baseTime != Stamp.ETERNAL) {
baseTime += delta;
nal.getTheNewStamp().setOccurrenceTime(baseTime);
}
}
// (allow overlap), a form of detachment
nal.doublePremiseTask(content, truth, budget, false, true);
}
}
use of nars.entity.Task in project opennars by opennars.
the class CompositionalRules method decomposeStatement.
/**
* {(||, S, P), P} |- S {(&&, S, P), P} |- S
*
* @param implication The implication term to be decomposed
* @param componentCommon The part of the implication to be removed
* @param compoundTask Whether the implication comes from the task
* @param nal Reference to the memory
*/
static void decomposeStatement(CompoundTerm compound, Term component, boolean compoundTask, int index, DerivationContext nal) {
boolean isTemporalConjunction = (compound instanceof Conjunction) && !((Conjunction) compound).isSpatial;
if (isTemporalConjunction && (compound.getTemporalOrder() == TemporalRules.ORDER_FORWARD) && (index != 0)) {
return;
}
long occurrence_time = nal.getTheNewStamp().getOccurrenceTime();
if (isTemporalConjunction && (compound.getTemporalOrder() == TemporalRules.ORDER_FORWARD)) {
if (!nal.getCurrentTask().sentence.isEternal() && compound.term[index + 1] instanceof Interval) {
long shift_occurrence = ((Interval) compound.term[1]).time;
occurrence_time = nal.getCurrentTask().sentence.getOccurenceTime() + shift_occurrence;
}
}
Task task = nal.getCurrentTask();
Sentence taskSentence = task.sentence;
Sentence belief = nal.getCurrentBelief();
Term content = reduceComponents(compound, component, nal.mem());
if (content == null) {
return;
}
TruthValue truth = null;
BudgetValue budget;
if (taskSentence.isQuestion() || taskSentence.isQuest()) {
budget = BudgetFunctions.compoundBackward(content, nal);
nal.getTheNewStamp().setOccurrenceTime(occurrence_time);
nal.doublePremiseTask(content, truth, budget, false, false);
// special inference to answer conjunctive questions with query variables
if (taskSentence.term.hasVarQuery()) {
Concept contentConcept = nal.mem().concept(content);
if (contentConcept == null) {
return;
}
Sentence contentBelief = contentConcept.getBelief(nal, task);
if (contentBelief == null) {
return;
}
Task contentTask = new Task(contentBelief, task.budget, false);
nal.setCurrentTask(contentTask);
Term conj = Conjunction.make(component, content);
truth = intersection(contentBelief.truth, belief.truth);
budget = BudgetFunctions.compoundForward(truth, conj, nal);
nal.getTheNewStamp().setOccurrenceTime(occurrence_time);
nal.doublePremiseTask(conj, truth, budget, false, false);
}
} else {
TruthValue v1, v2;
if (compoundTask) {
v1 = taskSentence.truth;
v2 = belief.truth;
} else {
v1 = belief.truth;
v2 = taskSentence.truth;
}
if (compound instanceof Conjunction) {
if (taskSentence.isGoal()) {
if (compoundTask) {
truth = intersection(v1, v2);
} else {
return;
}
} else {
// isJudgment
truth = reduceConjunction(v1, v2);
}
} else if (compound instanceof Disjunction) {
if (taskSentence.isGoal()) {
if (compoundTask) {
truth = reduceConjunction(v2, v1);
} else {
return;
}
} else {
// isJudgment
truth = reduceDisjunction(v1, v2);
}
} else {
return;
}
budget = BudgetFunctions.compoundForward(truth, content, nal);
}
nal.getTheNewStamp().setOccurrenceTime(occurrence_time);
nal.doublePremiseTask(content, truth, budget, false, false);
}
use of nars.entity.Task in project opennars by opennars.
the class LocalRules method matchReverse.
/* -------------------- same terms, difference relations -------------------- */
/**
* The task and belief match reversely
*
* @param nal Reference to the memory
*/
public static void matchReverse(final DerivationContext nal) {
Task task = nal.getCurrentTask();
Sentence belief = nal.getCurrentBelief();
Sentence sentence = task.sentence;
if (matchingOrder(sentence.getTemporalOrder(), reverseOrder(belief.getTemporalOrder()))) {
if (sentence.isJudgment()) {
inferToSym(sentence, belief, nal);
} else {
conversion(nal);
}
}
}
Aggregations