Package org.opennars.language

Class Terms

java.lang.Object

org.opennars.language.Terms

public class Terms
extends Object

Static utility class for static methods related to Terms

Author:

Patrick Hammer

Constructor Summary

Constructors

Constructor	Description
Terms()

Method Summary

Modifier and Type	Method	Description
static <T> boolean	contains(T[] array, T v)
static <T> boolean	containsAll(T[] a, T[] b)	compres a set of terms (assumed to be unique) with another set to find if their contents match.
static boolean	containsAny(Term[] a, Collection<Term> b)	a contains any of b NOT TESTED YET
(package private) static boolean	equals(Term[] a, Term[] b)
static boolean	equalSubjectPredicateInRespectToImageAndProduct(Term a, Term b)
static boolean	equalSubTermsInRespectToImageAndProduct(Term a, Term b)
static <T> int	indexOf(T[] array, T v)
static List<TermLink>	prepareComponentLinks(List<TermLink> componentLinks, short type, CompoundTerm term)	Collect TermLink templates into a list, go down one level except in special cases
static List<TermLink>	prepareComponentLinks(List<TermLink> componentLinks, CompoundTerm ct)
static Term	reduceComponentOneLayer(CompoundTerm compound, Term component, Memory memory)
static Term	reduceComponents(CompoundTerm compound, Term component, Memory memory)	Try to remove a component from a compound
static Term	reduceUntilLayer2(CompoundTerm _itself, Term replacement, Memory memory)
static Term	term(Symbols.NativeOperator copula, Term[] componentList)	Try to make a compound term from an operator and a list of term
static Term	term(CompoundTerm compound, Collection<Term> components)
static Term	term(CompoundTerm compound, Term[] components)	Try to make a compound term from a template and a list of term
static Term	unwrapNegation(Term T)
static void	verifyNonNull(Collection t)
(package private) static void	verifyNonNull(Term... t)
static Term[]	verifySortedAndUnique(Term[] arg, boolean allowSingleton)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Terms

public Terms()

Method Detail

equalSubTermsInRespectToImageAndProduct

public static boolean equalSubTermsInRespectToImageAndProduct(Term a,
                                                              Term b)

reduceUntilLayer2

public static Term reduceUntilLayer2(CompoundTerm _itself,
                                     Term replacement,
                                     Memory memory)

term

public static Term term(CompoundTerm compound,
                        Term[] components)

Try to make a compound term from a template and a list of term

Parameters:

compound - The template

components - The term

Returns:

A compound term or null

term

public static Term term(CompoundTerm compound,
                        Collection<Term> components)

term

public static Term term(Symbols.NativeOperator copula,
                        Term[] componentList)

Try to make a compound term from an operator and a list of term

Called from StringParser

Parameters:

copula - Term operator

componentList - Component list

Returns:

A term or null

reduceComponents

public static Term reduceComponents(CompoundTerm compound,
                                    Term component,
                                    Memory memory)

Try to remove a component from a compound

Parameters:

compound - The compound

component - The component

memory - Reference to the memory

Returns:

The new compound

reduceComponentOneLayer

public static Term reduceComponentOneLayer(CompoundTerm compound,
                                           Term component,
                                           Memory memory)

unwrapNegation

public static Term unwrapNegation(Term T)

equalSubjectPredicateInRespectToImageAndProduct

public static boolean equalSubjectPredicateInRespectToImageAndProduct(Term a,
                                                                      Term b)

prepareComponentLinks

public static List<TermLink> prepareComponentLinks(List<TermLink> componentLinks,
                                                   short type,
                                                   CompoundTerm term)

Collect TermLink templates into a list, go down one level except in special cases

Parameters:

componentLinks - The list of TermLink templates built so far

type - The type of TermLink to be built

term - The CompoundTerm for which the links are built

prepareComponentLinks

public static List<TermLink> prepareComponentLinks(List<TermLink> componentLinks,
                                                   CompoundTerm ct)

indexOf

public static <T> int indexOf(T[] array,
                              T v)

containsAll

public static <T> boolean containsAll(T[] a,
                                      T[] b)

compres a set of terms (assumed to be unique) with another set to find if their contents match. they can be in different order and still match. this is useful for comparing whether compound terms in which order doesn't matter (ex: conjunction) are equivalent.

containsAny

public static boolean containsAny(Term[] a,
                                  Collection<Term> b)

a contains any of b NOT TESTED YET

contains

public static <T> boolean contains(T[] array,
                                   T v)

equals

static boolean equals(Term[] a,
                      Term[] b)

verifyNonNull

public static void verifyNonNull(Collection t)

verifyNonNull

static void verifyNonNull(Term... t)

verifySortedAndUnique

public static Term[] verifySortedAndUnique(Term[] arg,
                                           boolean allowSingleton)