at.jku.risc.stout.tgau.algo

Class AntiUnifySystem

java.lang.Object

at.jku.risc.stout.tgau.algo.AntiUnifySystem

public class AntiUnifySystem
extends java.lang.Object

This class represents a rule based system for rigid anti-unification of term graphs. Parallel executation of two instances is NOT possible, since there are global arguments that are used among all the branches of one and the same run.
The algorithm Gen(R) is described in the paper:
Alexander Baumgartner, Temur Kutsia, Jordi Levy, Mateu Villaret. Term-Graph Anti-Unification.

Author:

Alexander Baumgartner

Field Summary

Fields

Modifier and Type	Field and Description
static int	BRANCH_COUNT
static java.util.Queue<AntiUnifySystem>	branchPointer
static DebugLevel	debugLevel
static java.io.PrintStream	debugOut
static boolean	ENABLE_COMMUTATIVE_RULES
static boolean	ENABLE_SPLIT_RULE
static TermGraph	G1
static TermGraph	G2
static NodeFactory	nf
static java.lang.String	OUTPUT_SEPARATOR
static RigidityFnc	rFnc
static RigidityFnc	rFncC

Constructor Summary

Constructors

Constructor and Description
AntiUnifySystem(java.util.Deque<PrintableX> problemSet, java.util.List<HedgeAUP> storeH, java.util.List<HedgeAUP> storeC, java.util.List<TermAUP> storeT, java.util.Map<TermAUP,TermVar> trail, TermGraph g) Most likely you don't need this constructor because the algorithm is encapsulated in the class AntiUnify which is much easier to use.

Method Summary

Modifier and Type	Method and Description
TermGraph	compute() Most likely you don't need this method because the algorithm is encapsulated in the class AntiUnify which is much easier to use.
void	doDecSBranch(HedgeAUP hAup, AlignmentList align, int idx)
int	getBranchId()
TermGraph	getGraph()
java.util.Deque<PrintableX>	getProblemSet()
java.util.List<? super PrintableX>	getStore() A concatenation of getStoreT() and getStoreH() and getStoreC()
java.util.List<HedgeAUP>	getStoreC() Store for HedgeAUPs where the order does not matter (commutative AUPs and AUPs that only consist of 0 or 1 arguments).
java.util.List<HedgeAUP>	getStoreH() Store for HedgeAUPs where the order matters (not commutative AUPs where one side has at least 2 arguments).
java.util.List<TermAUP>	getStoreT() Store for TermAUPs.
java.util.Map<TermAUP,TermVar>	getTrail()
void	mergeStore(java.util.List<? extends BaseAUP> store)
void	printTrail()

Methods inherited from class java.lang.Object

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

Field Detail

BRANCH_COUNT

public static int BRANCH_COUNT

branchPointer

public static java.util.Queue<AntiUnifySystem> branchPointer

debugLevel

public static DebugLevel debugLevel

debugOut

public static java.io.PrintStream debugOut

ENABLE_COMMUTATIVE_RULES

public static boolean ENABLE_COMMUTATIVE_RULES

ENABLE_SPLIT_RULE

public static boolean ENABLE_SPLIT_RULE

G1

public static TermGraph G1

G2

public static TermGraph G2

nf

public static NodeFactory nf

OUTPUT_SEPARATOR

public static java.lang.String OUTPUT_SEPARATOR

rFnc

public static RigidityFnc rFnc

rFncC

public static RigidityFnc rFncC

Constructor Detail

AntiUnifySystem

public AntiUnifySystem(java.util.Deque<PrintableX> problemSet,
                       java.util.List<HedgeAUP> storeH,
                       java.util.List<HedgeAUP> storeC,
                       java.util.List<TermAUP> storeT,
                       java.util.Map<TermAUP,TermVar> trail,
                       TermGraph g)

Most likely you don't need this constructor because the algorithm is encapsulated in the class AntiUnify which is much easier to use.

Parameters:

problemSet - The set of AUPs to be generalized.

storeH - The none-commutative store keeps track of solved hedge equations that are not commutative.

storeC - The commutative store that keeps track of solved hedge equations that are commutative.

storeT - The term store that keeps track of solved term equations.

trail - The trail keeps track of recursion variables.

g - The computed generalization. It is a term graph.

Method Detail

compute

public TermGraph compute()
                  throws IllegalAlignmentException

Most likely you don't need this method because the algorithm is encapsulated in the class AntiUnify which is much easier to use.

Throws:

IllegalAlignmentException

doDecSBranch

public void doDecSBranch(HedgeAUP hAup,
                         AlignmentList align,
                         int idx)
                  throws IllegalAlignmentException

Throws:

IllegalAlignmentException

getBranchId

public int getBranchId()

getGraph

public TermGraph getGraph()

getProblemSet

public java.util.Deque<PrintableX> getProblemSet()

getStore

public java.util.List<? super PrintableX> getStore()

A concatenation of getStoreT() and getStoreH() and getStoreC()

getStoreC

public java.util.List<HedgeAUP> getStoreC()

Store for HedgeAUPs where the order does not matter (commutative AUPs and AUPs that only consist of 0 or 1 arguments). If ENABLE_COMMUTATIVE_RULES is false then this store is empty.

getStoreH

public java.util.List<HedgeAUP> getStoreH()

Store for HedgeAUPs where the order matters (not commutative AUPs where one side has at least 2 arguments). If ENABLE_COMMUTATIVE_RULES is false then all HedgeAUPs are in this store.

getStoreT

public java.util.List<TermAUP> getStoreT()

Store for TermAUPs.

getTrail

public java.util.Map<TermAUP,TermVar> getTrail()

mergeStore

public void mergeStore(java.util.List<? extends BaseAUP> store)

printTrail

public void printTrail()