use of nars.Op in project narchy by automenta.
the class PrologCore method pterm.
// NARS term -> Prolog term
public static alice.tuprolog.Term pterm(final Term term) {
if (term instanceof Compound) {
Op op = term.op();
alice.tuprolog.Term[] st = psubterms(((Compound) term));
switch(op) {
case IMPL:
return new Struct(":-", st[1], st[0]);
case CONJ:
return new Struct(",", st);
case NEG:
return new Struct(/*"\\="*/
"not", st);
case PROD:
// list
return new Struct(st);
case INH:
Term pred = term.sub(1);
if (pred.op() == ATOM) {
Term subj = term.sub(0);
if (subj.op() == PROD) {
alice.tuprolog.Term args = st[0];
return new Struct(wrapAtom(pred.toString()), args instanceof alice.tuprolog.Term ? Iterators.toArray(((Struct) st[0]).listIterator(), alice.tuprolog.Term.class) : new alice.tuprolog.Term[] { args });
}
}
break;
}
return new Struct(op.str, st);
} else if (term instanceof NormalizedVariable) {
switch(term.op()) {
case VAR_QUERY:
case VAR_PATTERN:
// ?? as if atomic
case VAR_DEP:
case // ??
VAR_INDEP:
return new Var("_" + (((NormalizedVariable) term).anonNum()));
}
} else if (term instanceof Atomic) {
return new Struct(wrapAtom(term.toString()));
}
throw new UnsupportedOperationException();
// //CharSequence s = termString(term);
// if (term instanceof Statement) {
// Statement i = (Statement)term;
// String predicate = classPredicate(i.getClass());
// alice.tuprolog.Term subj = alice.tuprolog.Term (i.getSubject());
// alice.tuprolog.Term obj = alice.tuprolog.Term (i.getPredicate());
// if ((subj!=null) && (obj!=null))
// return new Struct(predicate, subj, obj);
// }
// else if ((term instanceof SetTensional) || (term instanceof Product) /* conjunction */) {
// Compound s = (Compound)term;
// String predicate = classPredicate(s.getClass());
// alice.tuprolog.Term [] args = alice.tuprolog.Term s(s.term);
// if (args!=null)
// return new Struct(predicate, args);
// }
// //Image...
// //Conjunction...
// else if (term instanceof Negation) {
// alice.tuprolog.Term np = alice.tuprolog.Term (((Negation)term).term[0]);
// if (np == null) return null;
// return new Struct("negation", np);
// }
// else if (term.getClass().equals(Variable.class)) {
// return getVariable((Variable)term);
// }
// else if (term.getClass().equals(Atom.class)) {
// return new Struct(pescape(term.toString()));
// }
// else if (term instanceof Compound) {
// //unhandled type of compound term, store as an atomic string
// //NOT ready yet
// if (allTerms) {
// return new Struct('_' + pescape(term.toString()));
// }
// }
//
// return null;
}
use of nars.Op in project narchy by automenta.
the class NarseseParser method popTerms.
FasterList<Term> popTerms(Op[] op) /* hint */
{
FasterList tt = new FasterList(8);
ArrayValueStack<Object> stack = (ArrayValueStack) getContext().getValueStack();
while (!stack.isEmpty()) {
Object p = pop();
if (p instanceof Object[]) {
// it's an array so unpack by pushing everything back onto the stack except the last item which will be used as normal below
Object[] pp = (Object[]) p;
if (pp.length > 1) {
for (int i = pp.length - 1; i >= 1; i--) {
stack.push(pp[i]);
}
}
p = pp[0];
}
if (p == functionalForm) {
op[0] = ATOM;
break;
}
// beginning of stack frame for this term
if (p == Compound.class)
break;
if (p instanceof String) {
// throw new RuntimeException("string not expected here");
// Term t = $.the((String) p);
tt.add(Atomic.the((String) p));
} else if (p instanceof Term) {
if (p == Null) {
stack.clear();
return new FasterList(1).addingAll(Null);
}
tt.add(p);
} else if (p instanceof Op) {
if (op != null)
op[0] = (Op) p;
}
}
tt.reverse();
return tt;
}
use of nars.Op in project narchy by automenta.
the class Builtin method registerFunctors.
public static void registerFunctors(NAR nar) {
for (Concept t : Builtin.statik) {
nar.on(t);
}
nar.on(Functor.f1("varIntro", (x) -> {
Pair<Term, Map<Term, Term>> result = DepIndepVarIntroduction.the.apply(x, nar.random());
return result != null ? result.getOne() : Null;
}));
nar.on(Functor.f1((Atom) $.the("termlinkRandom"), (Term t) -> {
@Nullable Concept c = nar.conceptualize(t);
if (c == null)
return Null;
@Nullable PriReference<Term> tl = c.termlinks().sample(nar.random());
if (tl == null)
return Null;
return tl.get();
}));
// nar.on(Functor.f("service", (TermContainer c) ->
// $.sete(
// nar.services().map(
// (e) ->
// $.p(e, $.the(e.getValue().state())))
// .toArray(Term[]::new)
// )
// ));
/**
* subterm, but specifically inside an ellipsis. otherwise pass through
*/
nar.on(Functor.f("esubterm", (Subterms c) -> {
Term x = c.sub(0, null);
if (x == null)
return Null;
Term index = c.sub(1, Null);
if (index == Null)
return Null;
int which;
if (index != null) {
if (index instanceof Variable)
return Null;
which = $.intValue(index, -1);
if (which < 0) {
return Null;
}
} else {
// random
which = nar.random().nextInt(x.subs());
}
return x.sub(which);
}));
nar.on(Functor.f2((Atom) $.the("without"), (Term container, Term content) -> Op.without(container, x -> x.equals(content), nar.random())));
nar.on(Functor.f2((Atom) $.the("withoutPosOrNeg"), (Term container, Term content) -> Op.without(container, x -> x.unneg().equals(content), nar.random())));
/**
* TODO rename this to 'dropAnyCommutive'
* remove an element from a commutive conjunction (or set), at random, and try re-creating
* the compound. wont necessarily work in all situations.
* TODO move the type restriction to another functor to wrap this
*
* this also filter a single variable (depvar) from being a result
*/
nar.on(Functor.f1((Atom) $.the("dropAnySet"), (Term t) -> {
Op oo = t.op();
if (oo == INT) {
if (t instanceof Int.IntRange) {
// select random location in the int and split either up or down
Int.IntRange i = (Int.IntRange) t;
Random rng = nar.random();
if (i.min + 1 == i.max) {
// arity=2
return Int.the(rng.nextBoolean() ? i.min : i.max);
} else if (i.min + 2 == i.max) {
// arity=3
switch(rng.nextInt(4)) {
case 0:
return Int.the(i.min);
case 1:
return Int.range(i.min, i.min + 1);
case 2:
return Int.range(i.min + 1, i.min + 2);
case 3:
return Int.the(i.max);
default:
throw new UnsupportedOperationException();
}
} else {
int split = // midpoint, deterministic
(i.max + i.min) / 2;
// rng.nextInt(i.max-i.min-2);
return (rng.nextBoolean()) ? Int.range(i.min, split + 1) : Int.range(split + 1, i.max);
}
}
// cant drop int by itself
return Null;
}
if (!oo.in(SETi.bit | SETe.bit | SECTi.bit | SECTe.bit))
// returning the original value may cause feedback loop in callees expcting a change in value
return Null;
int size = t.subs();
switch(size) {
case 0:
assert (false) : "empty set impossible here";
return Null;
case 1:
return Null;
/* can't shrink below one element */
case 2:
int n = nar.random().nextInt(2);
return oo.the(t.sub(n));
default:
Term[] y = Terms.dropRandom(nar.random(), t.subterms());
return oo.the(y);
}
}));
/**
* depvar cleaning from commutive conj
*/
nar.on(Functor.f1((Atom) $.the("ifConjCommNoDepVars"), (Term t) -> {
if (!t.hasAny(VAR_DEP))
return t;
Op oo = t.op();
if (oo != CONJ)
return t;
SortedSet<Term> s = t.subterms().toSetSorted();
if (!s.removeIf(x -> x.unneg().op() == VAR_DEP))
return t;
return CONJ.the(t.dt(), s);
}));
/**
* drops a random contained event, whether at first layer or below
*/
nar.on(Functor.f1((Atom) $.the("dropAnyEvent"), (Term t) -> {
Op oo = t.op();
if (oo != CONJ)
// returning the original value may cause feedback loop in callees expcting a change in value
return Null;
FasterList<LongObjectPair<Term>> ee = Conj.eventList(t);
ee.remove(nar.random().nextInt(ee.size()));
return Conj.conj(ee);
// }
// if (r instanceof Variable /*&& r.op()!=VAR_DEP*/)
// return Null; //HACK dont allow returning a variable as an event during decomposition HACK TODO make more careful and return the only result if one subterm is a non-returnable variable
// return r;
}));
nar.on(Functor.f2((Atom) $.the("conjEvent"), (Term c, Term when) -> {
if (c.op() != CONJ || !(when instanceof Atom))
return Null;
// extract earliest or latest &| timeslice of events
throw new TODO();
// if (c.dt() == DTERNAL || c.dt() == 0) {
// return c.sub(nar.random().nextInt(c.subs())); //choose a subterm at random
// }
// assert (c.subs() == 2);
// int target;
// switch (when.toString()) {
// case "early":
// target = 0;
// break;
// case "late":
// target = 1;
// break;
// default:
// throw new UnsupportedOperationException();
// }
// if (c.dt() < 0)
// target = 1 - target;
// return c.sub(target);
}));
/**
* similar to without() but special handling for CONJ sub-events
*/
nar.on(Functor.f2((Atom) $.the("conjWithout"), (Term conj, Term event) -> {
if (conj.op() != CONJ || conj.impossibleSubTerm(event))
return Null;
FasterList<LongObjectPair<Term>> events = Conj.eventList(conj);
IntArrayList found = new IntArrayList(2);
int es = events.size();
assert (es > 1);
for (int i = 0; i < es; i++) {
if (event.equalsRoot(events.get(i).getTwo())) {
found.add(i);
}
}
int fs = found.size(), r;
switch(fs) {
case 0:
return Null;
case 1:
r = found.get(0);
break;
default:
r = found.get(nar.random().nextInt(fs));
break;
}
events.remove(r);
return Conj.conj(events);
// } else {
// return nullToNull(Op.without(conj, event::equalsRoot, nar.random()));
// }
}));
/**
* extracts only the events preceding the specified events
*/
nar.on(Functor.f2((Atom) $.the("conjDropIfLatest"), (Term conj, Term event) -> Conj.conjDrop(conj, event, false)));
nar.on(Functor.f2((Atom) $.the("conjDropIfEarliest"), (Term conj, Term event) -> Conj.conjDrop(conj, event, true)));
nar.on(Functor.f1Concept("belief", nar, (c, n) -> $.quote(n.belief(c, n.time()))));
nar.on(Functor.f1Concept("goal", nar, (c, n) -> $.quote(n.goal(c, n.time()))));
nar.on(f0("self", nar::self));
nar.on(Functor.f1("the", what -> {
if (what instanceof Atom) {
switch(what.toString()) {
case "sys":
return $.p($.quote(nar.emotion.summary()), $.quote(nar.concepts.summary()), $.quote(nar.emotion.summary()), $.quote(nar.exe.toString()));
}
}
Object x = nar.concept(what);
if (x == null)
x = what;
return $.quote($.p($.quote(x.getClass().toString()), $.quote(x.toString())));
}));
// /** slice(<compound>,<selector>)
// selector :-
// a specific integer value index, from 0 to compound size
// (a,b) pair of integers, a range of indices */
nar.on(Functor.f("slice", (args) -> {
if (args.subs() == 2) {
Term x = args.sub(0);
if (x.subs() > 0) {
int len = x.subs();
Term index = args.sub(1);
Op o = index.op();
if (o == INT) {
// specific index
int i = ((Int) index).id;
if (i >= 0 && i < len)
return x.sub(i);
else
return False;
} else if (o == PROD && index.subs() == 2) {
Term start = (index).sub(0);
if (start.op() == INT) {
Term end = (index).sub(1);
if (end.op() == INT) {
int si = ((Int) start).id;
if (si >= 0 && si < len) {
int ei = ((Int) end).id;
if (ei >= 0 && ei <= len) {
if (si == ei)
return Op.EmptyProduct;
if (si < ei) {
return $.p(Arrays.copyOfRange(x.subterms().arrayClone(), si, ei));
}
}
}
// TODO maybe reverse order will return reversed subproduct
return False;
}
}
}
}
}
return null;
}));
}
use of nars.Op in project narchy by automenta.
the class CaffeineIndex2 method get.
@Override
public Termed get(Term x, boolean createIfMissing) {
if (x.volume() > nar.termVolumeMax.intValue())
// quick check to avoid creating a vector for a term that will be invalid anyway
return null;
assert (!(x instanceof Variable)) : "variables should not be stored in index";
Op op = x.op();
TermContainerToOpMap<Termed> v;
if (createIfMissing) {
v = vectors.get(vector(x), k -> {
TermContainerToOpMap<Termed> t = new TermContainerToOpMap<>(k);
Termed p = nar.conceptBuilder.apply(x, null);
if (p != null)
t.compareAndSet(op.id, null, p);
return t;
});
} else {
v = vectors.getIfPresent(vector(x));
}
return v != null ? v.get(op.id) : null;
}
use of nars.Op in project narchy by automenta.
the class Compound method evalSafe.
/*@NotNull*/
@Override
default Term evalSafe(TermContext context, Op supertermOp, int subterm, int remain) {
if (remain-- <= 0)
return Null;
// Termed ff = context.applyIfPossible(this);
// if (!ff.equals(this))
// return ff.term();
/*if (subterms().hasAll(opBits))*/
Subterms uu = subterms();
Term[] xy = null;
// any contained evaluables
Op o = op();
// int possiblyFunctional = o == INH ? Op.funcInnerBits : Op.funcBits;
// boolean recurseIfChanged = false;
int ellipsisAdds = 0, ellipsisRemoves = 0;
for (int i = 0, n = uu.subs(); i < n; i++) {
Term xi = xy != null ? xy[i] : uu.sub(i);
Term yi = xi.evalSafe(context, o, i, remain);
if (yi == null) {
return Null;
} else {
if (yi instanceof EllipsisMatch) {
int ys = yi.subs();
ellipsisAdds += ys;
ellipsisRemoves++;
}
if (xi != yi && (xi.getClass() != yi.getClass() || !xi.equals(yi))) {
if (xy == null) {
// begin clone copy
xy = arrayClone();
}
xy[i] = yi;
}
}
}
if (ellipsisAdds > 0) {
// flatten ellipsis
xy = EllipsisMatch.flatten(xy, ellipsisAdds, ellipsisRemoves);
}
Term u;
if (/*changed*/
xy != null) {
u = o.a(dt(), xy);
// refresh root operator in case it has changed
o = u.op();
// refresh subterms
uu = u.subterms();
} else {
u = this;
}
// compute this without necessarily constructing the superterm, which happens after this if it doesnt recurse
if (o == INH && u.hasAll(Op.funcBits)) {
Term pred, subj;
if ((pred = uu.sub(1)) instanceof Functor && (subj = uu.sub(0)).op() == PROD) {
Term v = ((Functor) pred).apply(subj.subterms());
if (v instanceof AbstractPred) {
u = $.the(((AbstractPred) v).test(null));
} else if (v == null) {
// null means to keep 'u' unchanged same
} else {
// continue with the evaluation result
u = v;
}
}
}
if (u != this && (u.equals(this) && u.getClass() == getClass()))
// return to this instance, undoing any substitutions necessary to reach this eval
u = this;
return u;
}
Aggregations