Package org.opennars.language

Class Variables

java.lang.Object

org.opennars.language.Variables

public class Variables
extends Object

Static utility class for static methods related to Variables

Author:

Patrick Hammer

Constructor Summary

Constructors

Constructor	Description
Variables()

Method Summary

Modifier and Type	Method	Description
static boolean	allowUnification(char type, char uniType)
private static void	appendToMap(Map<Term,Term> source, Map<Term,Term> target)
private static Term	applySubstituteAndRenameVariables(CompoundTerm t, Map<Term,Term> subs)	appliesSubstitute and renameVariables, resulting in a cloned object, will not change this instance
static boolean	containVar(CharSequence n)	Check whether a string represent a name of a term that contains a variable
static boolean	containVar(Term[] t)
private static Map<Term,Term>[]	copyMapFrom(Map<Term,Term>[] source)	copies two maps from source into two new maps
static boolean	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	findSubstitute(Random rnd, char type, Term term1, Term term2, Map<Term,Term>[] map, boolean allowPartial)
static boolean	findSubstitute(Random rnd, char type, Term term1, Term term2, Map<Term,Term> map1, Map<Term,Term> map2)
static boolean	hasSubstitute(Random rnd, char type, Term term1, Term term2)	Check if two terms can be unified
static boolean	indepVarUsedInvalid(Term T)	examines whether a term is using an independent variable in an invalid way
static Variable	makeCommonVariable(Term v1, Term v2)
static boolean	unify(Random rnd, char type, Term[] t)	To unify two terms
static boolean	unify(Random rnd, char type, Term t1, Term t2, Term[] compound)	To unify two terms
static boolean	unify(Random rnd, char type, Term t1, Term t2, Term[] compound, boolean allowPartial)

Methods inherited from class java.lang.Object

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

Constructor Detail

Variables

public Variables()

Method Detail

findSubstitute

public static boolean findSubstitute(Random rnd,
                                     char type,
                                     Term term1,
                                     Term term2,
                                     Map<Term,Term> map1,
                                     Map<Term,Term> map2)

allowUnification

public static boolean allowUnification(char type,
                                       char uniType)

findSubstitute

public static boolean findSubstitute(Random rnd,
                                     char type,
                                     Term term1,
                                     Term term2,
                                     Map<Term,Term>[] map)

map is a 2-element array of Map<Term,Term>. it may be null, in which case the maps will be instantiated as necessary. this is to delay the instantiation of the 2 Map until necessary to avoid wasting them if they are not used.

findSubstitute

public static boolean findSubstitute(Random rnd,
                                     char type,
                                     Term term1,
                                     Term term2,
                                     Map<Term,Term>[] map,
                                     boolean allowPartial)

copyMapFrom

private static Map<Term,Term>[] copyMapFrom(Map<Term,Term>[] source)

copies two maps from source into two new maps

Parameters:

source - source maps (two)

Returns:

copied maps

appendToMap

private static void appendToMap(Map<Term,Term> source,
                                Map<Term,Term> target)

containVar

public static boolean containVar(CharSequence n)

Check whether a string represent a name of a term that contains a variable

Parameters:

n - The string name to be checked

Returns:

Whether the name contains a variable

containVar

public static final boolean containVar(Term[] t)

unify

public static boolean unify(Random rnd,
                            char type,
                            Term[] t)

To unify two terms

Parameters:

type - The type of variable that can be substituted

t - The first and second term as an array, which will have been modified upon returning true

Returns:

Whether the unification is possible. 't' will refer to the unified terms

unify

public static boolean unify(Random rnd,
                            char type,
                            Term t1,
                            Term t2,
                            Term[] compound)

To unify two terms

Parameters:

type - The type of variable that can be substituted

t1 - The compound containing the first term, possibly modified

t2 - The compound containing the second term, possibly modified

compound - The first and second term as an array, which will have been modified upon returning true

Returns:

Whether the unification is possible. 't' will refer to the unified terms

unify

public static boolean unify(Random rnd,
                            char type,
                            Term t1,
                            Term t2,
                            Term[] compound,
                            boolean allowPartial)

applySubstituteAndRenameVariables

private static Term applySubstituteAndRenameVariables(CompoundTerm t,
                                                      Map<Term,Term> subs)

appliesSubstitute and renameVariables, resulting in a cloned object, will not change this instance

makeCommonVariable

public static Variable makeCommonVariable(Term v1,
                                          Term v2)

indepVarUsedInvalid

public static boolean indepVarUsedInvalid(Term T)

examines whether a term is using an independent variable in an invalid way

Parameters:

T - term to be examined

Returns:

Whether the term contains an independent variable

hasSubstitute

public static boolean hasSubstitute(Random rnd,
                                    char type,
                                    Term term1,
                                    Term term2)

Check if two terms can be unified

Parameters:

type - The type of variable that can be substituted

term1 - The first term to be unified

term2 - The second term to be unified

Returns:

Whether there is a substitution