1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
|
/*
* SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
*
* SPDX-License-Identifier: EPL-2.0
*/
package tools.refinery.language.semantics.internal;
import org.eclipse.collections.api.LazyIntIterable;
import tools.refinery.store.tuple.Tuple;
import tools.refinery.logic.term.truthvalue.TruthValue;
abstract class DecisionTreeNode {
public DecisionTreeValue getReducedValue() {
return getChildKeys().isEmpty() ? getOtherwiseReducedValue() : null;
}
public abstract DecisionTreeValue getValue(int level, Tuple tuple);
public abstract DecisionTreeNode deepCopy();
public void mergeValue(int level, Tuple tuple, TruthValue value) {
int nextLevel = level - 1;
var key = tuple.get(level);
if (key < 0) {
mergeAllValues(nextLevel, tuple, value);
} else {
mergeSingleValue(key, nextLevel, tuple, value);
}
}
protected abstract void mergeAllValues(int nextLevel, Tuple tuple, TruthValue value);
protected abstract void mergeSingleValue(int key, int nextLevel, Tuple tuple, TruthValue value);
public DecisionTreeNode withMergedValue(int level, Tuple tuple, TruthValue value) {
var copy = deepCopy();
copy.mergeValue(level, tuple, value);
return copy;
}
public void setIfMissing(int level, Tuple tuple, TruthValue value) {
var key = tuple.get(level);
if (key < 0) {
throw new IllegalArgumentException("Not allowed set a missing wildcard");
}
doSetIfMissing(key, level - 1, tuple, value);
}
protected abstract void doSetIfMissing(int key, int nextLevel, Tuple tuple, TruthValue value);
public DecisionTreeNode withValueSetIfMissing(int level, Tuple tuple, TruthValue value) {
var copy = deepCopy();
copy.setIfMissing(level, tuple, value);
return copy;
}
public abstract void setAllMissing(TruthValue value);
public abstract void overwriteValues(DecisionTreeNode values);
public DecisionTreeNode withOverwrittenValues(DecisionTreeNode values) {
var copy = deepCopy();
copy.overwriteValues(values);
return copy;
}
public boolean moveNext(int level, DecisionTreeCursor cursor) {
var currentState = cursor.iterationState[level];
boolean found;
if (currentState == DecisionTreeCursor.STATE_FINISH) {
// Entering this node for the first time.
cursor.path.push(this);
if (cursor.defaultValue == getOtherwiseReducedValue()) {
var sortedChildren = getChildKeys().toSortedArray();
cursor.sortedChildren[level] = sortedChildren;
found = moveNextSparse(level, cursor, 0, sortedChildren);
} else {
found = moveNextDense(level, cursor, 0);
}
} else {
var sortedChildren = cursor.sortedChildren[level];
if (sortedChildren == null) {
found = moveNextDense(level, cursor, currentState + 1);
} else {
found = moveNextSparse(level, cursor, currentState + 1, sortedChildren);
}
}
if (!found) {
cursor.sortedChildren[level] = null;
cursor.iterationState[level] = DecisionTreeCursor.STATE_FINISH;
var popped = cursor.path.pop();
if (popped != this) {
throw new IllegalStateException("Invalid decision diagram cursor");
}
}
return found;
}
protected abstract DecisionTreeValue getOtherwiseReducedValue();
protected abstract LazyIntIterable getChildKeys();
public abstract DecisionTreeValue getMajorityValue();
protected abstract boolean moveNextSparse(int level, DecisionTreeCursor cursor, int startIndex,
int[] sortedChildren);
protected abstract boolean moveNextDense(int level, DecisionTreeCursor cursor, int startIndex);
}
|
