at.jku.risc.stout.hoau.data

Class NodeFactory

java.lang.Object

at.jku.risc.stout.hoau.data.NodeFactory

public class NodeFactory
extends Object

A factory to create TermNodes, Hedges and atomic types ( TermAtoms). This factory has also the ability to automatically transform all the created bound variables so that they are all guaranteed to be distinct.

Author:

Alexander Baumgartner

Field Summary

Fields

Modifier and Type	Field and Description
static boolean	MAKE_BOUNDVAR_DISTINCT
static String	PREFIX_Constant
static String	PREFIX_FreshBoundVar
static String	PREFIX_FreshFreeVar
static String	PREFIX_Function
static String	PREFIX_IndividualVar
static String	PREFIX_Lambda
static String	SUFFIX_FreshBoundVar
static String	SUFFIX_FreshFreeVar

Constructor Summary

Constructors

Constructor and Description
NodeFactory()

Method Summary

Methods

Modifier and Type	Method and Description
void	addToHedge(TermNode node)
TermNode	createConstant(String name, String type)
TermNode	createFunction(String name, String type, Hedge hedge)
TermNode	createIndividualVar(String name, String type)
TermNode	createIndividualVar(String name, String type, Hedge hedge)
boolean	hasBoundVar(String name)
static BoundVariable	obtainFreshBoundVar(String originName, String type)
static Variable	obtainFreshVar(String type)
static TermNode	obtainFreshVarNode(String type)
Hedge	popHedge()
TermNode	popLambda(Hedge hedge)
void	pushHedge(boolean lambda) Everything what is not an argument list of a static function symbol is a lambda hedge.
void	pushLambda(String boundVar, String type)
static void	resetCounter()

Methods inherited from class java.lang.Object

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

Field Detail

MAKE_BOUNDVAR_DISTINCT

public static boolean MAKE_BOUNDVAR_DISTINCT

PREFIX_Constant

public static String PREFIX_Constant

PREFIX_FreshBoundVar

public static String PREFIX_FreshBoundVar

PREFIX_FreshFreeVar

public static String PREFIX_FreshFreeVar

PREFIX_Function

public static String PREFIX_Function

PREFIX_IndividualVar

public static String PREFIX_IndividualVar

PREFIX_Lambda

public static String PREFIX_Lambda

SUFFIX_FreshBoundVar

public static String SUFFIX_FreshBoundVar

SUFFIX_FreshFreeVar

public static String SUFFIX_FreshFreeVar

Constructor Detail

NodeFactory

public NodeFactory()

Method Detail

addToHedge

public void addToHedge(TermNode node)

createConstant

public TermNode createConstant(String name,
                      String type)

createFunction

public TermNode createFunction(String name,
                      String type,
                      Hedge hedge)

createIndividualVar

public TermNode createIndividualVar(String name,
                           String type)

createIndividualVar

public TermNode createIndividualVar(String name,
                           String type,
                           Hedge hedge)

hasBoundVar

public boolean hasBoundVar(String name)

obtainFreshBoundVar

public static BoundVariable obtainFreshBoundVar(String originName,
                                String type)

obtainFreshVar

public static Variable obtainFreshVar(String type)

obtainFreshVarNode

public static TermNode obtainFreshVarNode(String type)

popHedge

public Hedge popHedge()

popLambda

public TermNode popLambda(Hedge hedge)

pushHedge

public void pushHedge(boolean lambda)

Everything what is not an argument list of a static function symbol is a lambda hedge. We show an example where we denote lambda hedges with () and simple function argument hedges with [] and with \ we denote the lambda symbol:
(\x.f[a, x(f, (b, c))]) \x.\y.g[x(y)]
This lambda term will reduce to f[a, g[f[b c]]]

pushLambda

public void pushLambda(String boundVar,
              String type)
                throws MalformedTermException

Throws:

MalformedTermException

resetCounter

public static void resetCounter()