Package org.opennars.inference

Class TemporalRules

java.lang.Object

org.opennars.inference.TemporalRules

public class TemporalRules
extends Object

Author:

Pei Wang, Patrick Hammer

Field Summary

Fields

Modifier and Type	Field	Description
static int	ORDER_BACKWARD
static int	ORDER_CONCURRENT
static int	ORDER_FORWARD
static int	ORDER_INVALID
static int	ORDER_NONE

Constructor Summary

Constructors

Constructor	Description
TemporalRules()

Method Summary

Modifier and Type	Method	Description
static int	abdIndComOrder(int order1, int order2)
static int	analogyOrder(int order1, int order2, int figure)
private static void	appendConclusion(DerivationContext nal, TruthValue truth1, BudgetValue budget1, Statement statement1, List<Task> success)
static int	composeOrder(int order1, int order2)
static boolean	concurrent(long a, long b, int durationCycles)
static int	dedExeOrder(int order1, int order2)
static boolean	matchingOrder(int order1, int order2)
static boolean	matchingOrder(Sentence a, Sentence b)
static int	order(long timeDiff, int durationCycles)
static int	order(long a, long b, int durationCycles)	if (relative) event B after (stationary) event A then order=forward; event B before then order=backward occur at the same time, relative to duration: order = concurrent
static int	resemblanceOrder(int order1, int order2, int figure)
static int	reverseOrder(int order)
static List<Task>	temporalInduction(Sentence s1, Sentence s2, DerivationContext nal, boolean SucceedingEventsInduction, boolean addToMemory, boolean allowSequence)
protected static boolean	termForTemporalInduction(Term t)	whether a term can be used in temoralInduction(,,)
static boolean	tooMuchTemporalStatements(Term t)	whether temporal induction can generate a task by avoiding producing wrong terms; only one temporal operator is allowed

Methods inherited from class java.lang.Object

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

Field Detail

ORDER_NONE

public static final int ORDER_NONE

See Also:

Constant Field Values

ORDER_FORWARD

public static final int ORDER_FORWARD

See Also:

Constant Field Values

ORDER_CONCURRENT

public static final int ORDER_CONCURRENT

See Also:

Constant Field Values

ORDER_BACKWARD

public static final int ORDER_BACKWARD

See Also:

Constant Field Values

ORDER_INVALID

public static final int ORDER_INVALID

See Also:

Constant Field Values

Constructor Detail

TemporalRules

public TemporalRules()

Method Detail

reverseOrder

public static final int reverseOrder(int order)

matchingOrder

public static final boolean matchingOrder(Sentence a,
                                          Sentence b)

matchingOrder

public static final boolean matchingOrder(int order1,
                                          int order2)

dedExeOrder

public static final int dedExeOrder(int order1,
                                    int order2)

abdIndComOrder

public static final int abdIndComOrder(int order1,
                                       int order2)

analogyOrder

public static final int analogyOrder(int order1,
                                     int order2,
                                     int figure)

resemblanceOrder

public static final int resemblanceOrder(int order1,
                                         int order2,
                                         int figure)

composeOrder

public static final int composeOrder(int order1,
                                     int order2)

tooMuchTemporalStatements

public static final boolean tooMuchTemporalStatements(Term t)

whether temporal induction can generate a task by avoiding producing wrong terms; only one temporal operator is allowed

termForTemporalInduction

protected static boolean termForTemporalInduction(Term t)

whether a term can be used in temoralInduction(,,)

temporalInduction

public static List<Task> temporalInduction(Sentence s1,
                                           Sentence s2,
                                           DerivationContext nal,
                                           boolean SucceedingEventsInduction,
                                           boolean addToMemory,
                                           boolean allowSequence)

appendConclusion

private static void appendConclusion(DerivationContext nal,
                                     TruthValue truth1,
                                     BudgetValue budget1,
                                     Statement statement1,
                                     List<Task> success)

order

public static int order(long timeDiff,
                        int durationCycles)

order

public static int order(long a,
                        long b,
                        int durationCycles)

if (relative) event B after (stationary) event A then order=forward; event B before then order=backward occur at the same time, relative to duration: order = concurrent

concurrent

public static boolean concurrent(long a,
                                 long b,
                                 int durationCycles)