Skip to content

Commit 48c0899

Browse files
AklakanAklakan
committed
Merge branch 'release/0.9.5'
2 parents 42a2e7d + 5574512 commit 48c0899

File tree

426 files changed

+18142
-3297
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

426 files changed

+18142
-3297
lines changed

‎aksw-commons-algebra-parent/aksw-commons-algebra-allen-interval/pom.xml

Lines changed: 39 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,39 @@
1+
<project xmlns="http://maven.apache.org/POM/4.0.0"
2+
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3+
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
4+
<modelVersion>4.0.0</modelVersion>
5+
6+
<artifactId>aksw-commons-algebra-allen-interval</artifactId>
7+
<packaging>jar</packaging>
8+
9+
<parent>
10+
<artifactId>aksw-commons-algebra-parent</artifactId>
11+
<groupId>org.aksw.commons</groupId>
12+
<version>0.9.5</version>
13+
</parent>
14+
15+
<dependencies>
16+
17+
<!-- Collections -->
18+
<dependency>
19+
<groupId>com.google.guava</groupId>
20+
<artifactId>guava</artifactId>
21+
</dependency>
22+
23+
<!-- Unit Testing -->
24+
<dependency>
25+
<groupId>junit</groupId>
26+
<artifactId>junit</artifactId>
27+
<scope>test</scope>
28+
</dependency>
29+
30+
<!--
31+
<dependency>
32+
<groupId>org.apache.logging.log4j</groupId>
33+
<artifactId>log4j-slf4j-impl</artifactId>
34+
<scope>test</scope>
35+
</dependency>
36+
-->
37+
</dependencies>
38+
39+
</project>

‎aksw-commons-algebra-parent/aksw-commons-algebra-allen-interval/src/main/java/org/aksw/commons/algebra/allen/AllenConstants.java

Lines changed: 134 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,134 @@
1+
package org.aksw.commons.algebra.allen;
2+
3+
import java.util.HashMap;
4+
import java.util.List;
5+
import java.util.Map;
6+
import java.util.Objects;
7+
import java.util.stream.Collectors;
8+
import java.util.stream.IntStream;
9+
10+
public class AllenConstants {
11+
public final static short EMPTY = 0; // 0000000000000000
12+
13+
public final static short BEFORE = 1; // 0000000000000001
14+
public final static short AFTER = 2; // 0000000000000010
15+
public final static short DURING = 4; // 0000000000000100
16+
public final static short CONTAINS = 8; // 0000000000001000
17+
public final static short OVERLAPS = 16; // 0000000000010000
18+
public final static short OVERLAPPEDBY = 32; // 0000000000100000
19+
public final static short MEETS = 64; // 0000000001000000
20+
public final static short METBY = 128; // 0000000010000000
21+
public final static short STARTS = 256; // 0000000100000000
22+
public final static short STARTEDBY = 512; // 0000001000000000
23+
public final static short FINISHES = 1024; // 0000010000000000
24+
public final static short FINISHEDBY = 2048; // 0000100000000000
25+
public final static short EQUALS = 4096; // 0001000000000000
26+
// 0001111111111111
27+
public final static short ALL = (short) (BEFORE | AFTER | DURING | CONTAINS | OVERLAPS | OVERLAPPEDBY | MEETS | METBY | STARTS | STARTEDBY | FINISHES | FINISHEDBY | EQUALS);
28+
29+
public static final Map<Short, String> DFT_LABELS;
30+
31+
static {
32+
DFT_LABELS = new HashMap<>();
33+
DFT_LABELS.put(BEFORE, "before");
34+
DFT_LABELS.put(AFTER, "after");
35+
DFT_LABELS.put(DURING, "during");
36+
DFT_LABELS.put(CONTAINS, "contains");
37+
DFT_LABELS.put(OVERLAPS, "overlaps");
38+
DFT_LABELS.put(OVERLAPPEDBY, "overlapped by");
39+
DFT_LABELS.put(MEETS, "meets");
40+
DFT_LABELS.put(METBY, "met by");
41+
DFT_LABELS.put(STARTS, "starts");
42+
DFT_LABELS.put(STARTEDBY, "started by");
43+
DFT_LABELS.put(FINISHES, "finishes");
44+
DFT_LABELS.put(FINISHEDBY, "finished by");
45+
DFT_LABELS.put(EQUALS, "equals");
46+
}
47+
48+
public static short invert(short c) {
49+
short result = 0;
50+
// We could do a for loop over pairs of bits and swap them - but not sure how
51+
// stable the bit patterns are right now - so doing it explicitly for now
52+
if ((c & BEFORE) != 0) result |= AFTER;
53+
if ((c & AFTER) != 0) result |= BEFORE;
54+
55+
if ((c & DURING) != 0) result |= CONTAINS;
56+
if ((c & CONTAINS) != 0) result |= DURING;
57+
58+
if ((c & OVERLAPS) != 0) result |= OVERLAPPEDBY;
59+
if ((c & OVERLAPPEDBY) != 0) result |= OVERLAPS;
60+
61+
if ((c & MEETS) != 0) result |= METBY;
62+
if ((c & METBY) != 0) result |= MEETS;
63+
64+
if ((c & STARTS) != 0) result |= STARTEDBY;
65+
if ((c & STARTEDBY) != 0) result |= STARTS;
66+
67+
if ((c & FINISHES) != 0) result |= FINISHEDBY;
68+
if ((c & FINISHEDBY) != 0) result |= FINISHES;
69+
70+
if ((c & EQUALS) != 0) result |= EQUALS;
71+
return result;
72+
}
73+
74+
public static List<String> toLabels(short pattern, Map<Short, String> labelMap) {
75+
List<String> labels = IntStream.range(0, 13).map(i -> 1 << i)
76+
.map(mask -> pattern & mask)
77+
.filter(key -> key != 0)
78+
.mapToObj(key -> labelMap.get((short)key))
79+
.collect(Collectors.toList());
80+
return labels;
81+
}
82+
83+
public static List<String> toLabels(short pattern) {
84+
return toLabels(pattern, DFT_LABELS);
85+
}
86+
87+
public static String toString(short pattern) {
88+
return Objects.toString(toLabels(pattern));
89+
}
90+
91+
public final static short[][] transitivityMatrix = {
92+
// first row before
93+
{BEFORE,ALL,BEFORE | OVERLAPS | MEETS | DURING | STARTS, BEFORE, BEFORE, BEFORE | OVERLAPS | MEETS | DURING | STARTS, BEFORE, BEFORE | OVERLAPS | MEETS | DURING | STARTS, BEFORE, BEFORE, BEFORE | OVERLAPS | MEETS | DURING | STARTS, BEFORE, BEFORE},
94+
// {"<","< > d di o oi m mi s si f fi e","< o m d s","<","<","< o m d s","<","< o m d s","<","<","< o m d s","<","<"}
95+
96+
// second row after
97+
{ALL,AFTER,AFTER | OVERLAPPEDBY | METBY | DURING | FINISHES, AFTER, AFTER | OVERLAPPEDBY | METBY | DURING | FINISHES,AFTER,AFTER | OVERLAPPEDBY | METBY | DURING | FINISHES,AFTER,AFTER | OVERLAPPEDBY | METBY | DURING | FINISHES,AFTER,AFTER,AFTER,AFTER },
98+
// {"< > d di o oi m mi s si f fi e",">","> oi mi d f", ">", "> oi mi d f", ">", "> oi mi d f", ">", "> oi mi d f", ">", ">", ">", ">"}
99+
// third row during
100+
{BEFORE, AFTER,DURING,ALL,BEFORE | OVERLAPS | MEETS | DURING | STARTS, AFTER | OVERLAPPEDBY | METBY | DURING | FINISHES, BEFORE, AFTER, DURING, AFTER | OVERLAPPEDBY | METBY | DURING | FINISHES, DURING, BEFORE | OVERLAPS | MEETS | DURING | STARTS, DURING},
101+
// {"<",">","d", "< > d di o oi m mi s si f fi e", "< o m d s", "> oi mi d f", "<", ">", "d", "> oi mi d f", "d", "< o m d s","d"},
102+
// fourth row contains
103+
{BEFORE | OVERLAPS | MEETS | CONTAINS | FINISHEDBY, AFTER | OVERLAPPEDBY | CONTAINS | METBY | STARTEDBY, OVERLAPS | OVERLAPPEDBY | DURING | CONTAINS | EQUALS | STARTS | STARTEDBY | FINISHES | FINISHEDBY, CONTAINS, OVERLAPS | CONTAINS | FINISHEDBY,OVERLAPPEDBY | CONTAINS | STARTEDBY,OVERLAPS | CONTAINS | FINISHEDBY,OVERLAPPEDBY | CONTAINS | STARTEDBY,CONTAINS | FINISHEDBY | OVERLAPS, CONTAINS, CONTAINS | STARTEDBY | OVERLAPPEDBY, CONTAINS,CONTAINS},
104+
// {"< o m di fi","> oi mi di si","o oi d di e s si f fi","di","o di fi","oi di si","o di fi","oi di si","di fi o","di","di si oi","di","di"}
105+
// fifth row overlaps
106+
{BEFORE,AFTER | OVERLAPPEDBY | CONTAINS | METBY | STARTEDBY,OVERLAPS | DURING | STARTS, BEFORE | OVERLAPS | MEETS | CONTAINS | FINISHEDBY, BEFORE | OVERLAPS | MEETS, OVERLAPS | OVERLAPPEDBY | DURING | CONTAINS | EQUALS | STARTS | STARTEDBY | FINISHES | FINISHEDBY, BEFORE, OVERLAPPEDBY | CONTAINS | STARTEDBY, OVERLAPS, CONTAINS | FINISHEDBY | OVERLAPS, DURING | STARTS | OVERLAPS, BEFORE | OVERLAPS | MEETS, OVERLAPS},
107+
// {"<","> oi di mi si","o d s","< o m di fi","< o m", "o oi d di e s si f fi","<","oi di si","o","di fi o","d s o","< o m","o"},
108+
// six row overlapped by
109+
{BEFORE | OVERLAPS | MEETS | CONTAINS | FINISHEDBY, AFTER, OVERLAPPEDBY | DURING | FINISHES, AFTER | OVERLAPPEDBY | METBY | CONTAINS | STARTEDBY, OVERLAPS | OVERLAPPEDBY | DURING | CONTAINS | EQUALS | STARTS | STARTEDBY | FINISHES | FINISHEDBY, AFTER | OVERLAPPEDBY | METBY, OVERLAPS | CONTAINS | FINISHEDBY, AFTER, OVERLAPPEDBY | DURING | FINISHES, OVERLAPPEDBY | AFTER | METBY, OVERLAPPEDBY, OVERLAPPEDBY | CONTAINS | STARTEDBY, OVERLAPPEDBY},
110+
// {"< o m di fi",">","oi d f","> oi mi di si","o oi d di e s si f fi","> oi mi","o di fi",">","oi d f","oi > mi","oi","oi di si","oi"},
111+
// seventh row meets
112+
{BEFORE, AFTER | OVERLAPPEDBY | METBY | CONTAINS | STARTEDBY, OVERLAPS | DURING | STARTS, BEFORE, BEFORE, OVERLAPS | DURING | STARTS, BEFORE, FINISHES | FINISHEDBY | EQUALS, MEETS, MEETS, DURING | STARTS | OVERLAPS, BEFORE, MEETS},
113+
// {"<","> oi mi di si","o d s","<","<","o d s","<","f fi e","m","m","d s o","<","m"},
114+
// eights row metby
115+
{BEFORE | OVERLAPS | MEETS | CONTAINS | FINISHEDBY, AFTER, OVERLAPPEDBY | DURING | FINISHES, AFTER,OVERLAPPEDBY | DURING | FINISHES, AFTER, STARTS | STARTEDBY | EQUALS, AFTER, DURING | FINISHES | OVERLAPPEDBY, AFTER, METBY, METBY, METBY},
116+
// {"< o m di fi",">","oi d f",">","oi d f",">","s si e",">","d f oiX",">","mi","mi","mi"},
117+
// ninth row starts
118+
{BEFORE, AFTER, DURING, BEFORE | OVERLAPS | MEETS | CONTAINS | FINISHEDBY,BEFORE | OVERLAPS | MEETS, OVERLAPPEDBY | DURING | FINISHES, BEFORE, METBY, STARTS, STARTS | STARTEDBY | EQUALS, DURING, BEFORE | MEETS | OVERLAPS, STARTS},
119+
// {"<",">","d","< o m di fi","< o m","oi d f","<","mi","s","s si e","d","< m o","s"},
120+
// tenth row startedby
121+
{BEFORE | OVERLAPS | MEETS | CONTAINS | FINISHEDBY, AFTER, OVERLAPPEDBY | DURING | FINISHES, CONTAINS, OVERLAPS | CONTAINS | FINISHEDBY, OVERLAPPEDBY, OVERLAPS | CONTAINS | FINISHEDBY, METBY, STARTS | STARTEDBY | EQUALS, STARTEDBY, OVERLAPPEDBY, CONTAINS, STARTEDBY},
122+
// {"< o m di fi",">","oi d f","di","o di fi","oi","o di fi","mi","s si eX","si","oi","di","si"},
123+
// eleventh row finishes
124+
{BEFORE, AFTER, DURING, AFTER | OVERLAPPEDBY | METBY | CONTAINS | STARTEDBY,OVERLAPS | DURING | STARTS, AFTER | OVERLAPPEDBY | METBY , MEETS, AFTER, DURING, AFTER | OVERLAPPEDBY | METBY, FINISHES, FINISHES | FINISHEDBY | EQUALS, FINISHES},
125+
// {"<",">","d","> oi mi di si","o d s","> oi mi di","m",">","d","> oi mX","f","f fi e","f"},
126+
// twelfth row finishedby
127+
{BEFORE, AFTER | OVERLAPPEDBY | METBY | CONTAINS | STARTEDBY, OVERLAPS | DURING | STARTS, CONTAINS, OVERLAPS, OVERLAPPEDBY | CONTAINS | STARTEDBY, MEETS, STARTEDBY | OVERLAPPEDBY | CONTAINS, OVERLAPS, CONTAINS, FINISHES | FINISHEDBY | EQUALS, FINISHEDBY, FINISHEDBY},
128+
// {"<","> oi mi di si","o d s","di","o","oi di si","m","si oi di","o","di","f fi eX","fi","fi"},
129+
// thirteenth row equals
130+
{BEFORE,AFTER,DURING,CONTAINS,OVERLAPS,OVERLAPPEDBY,MEETS,METBY,STARTS,STARTEDBY,FINISHES,FINISHEDBY,EQUALS},
131+
// {"<",">","d","di","o","oi","m","mi","s","si","f","fi","e"}
132+
133+
};
134+
}

‎aksw-commons-algebra-parent/aksw-commons-algebra-allen-interval/src/main/java/org/aksw/commons/algebra/allen/AllenRelation.java

Lines changed: 142 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,142 @@
1+
package org.aksw.commons.algebra.allen;
2+
3+
import java.util.Arrays;
4+
import java.util.Objects;
5+
6+
/** An immutable wrapper for a bit-pattern (of primitive type 'short') that represents the Allen relations */
7+
public class AllenRelation {
8+
9+
/** Dummy relation with a 0 bit pattern. Useful for reduce/fold operations. */
10+
public static final AllenRelation EMPTY = AllenRelation.of(AllenConstants.EMPTY);
11+
12+
public static final AllenRelation BEFORE = AllenRelation.of(AllenConstants.BEFORE);
13+
public static final AllenRelation AFTER = AllenRelation.of(AllenConstants.AFTER);
14+
public static final AllenRelation DURING = AllenRelation.of(AllenConstants.DURING);
15+
public static final AllenRelation CONTAINS = AllenRelation.of(AllenConstants.CONTAINS);
16+
public static final AllenRelation OVERLAPS = AllenRelation.of(AllenConstants.OVERLAPS);
17+
public static final AllenRelation OVERLAPPEDBY = AllenRelation.of(AllenConstants.OVERLAPPEDBY);
18+
public static final AllenRelation MEETS = AllenRelation.of(AllenConstants.MEETS);
19+
public static final AllenRelation METBY = AllenRelation.of(AllenConstants.METBY);
20+
public static final AllenRelation STARTS = AllenRelation.of(AllenConstants.STARTS);
21+
public static final AllenRelation STARTEDBY = AllenRelation.of(AllenConstants.STARTEDBY);
22+
public static final AllenRelation FINISHES = AllenRelation.of(AllenConstants.FINISHES);
23+
public static final AllenRelation FINISHEDBY = AllenRelation.of(AllenConstants.FINISHEDBY);
24+
public static final AllenRelation EQUALS = AllenRelation.of(AllenConstants.EQUALS);
25+
26+
protected final short pattern;
27+
28+
/** The public API to create instances is {@link #create(short)}. */
29+
protected AllenRelation(short pattern) {
30+
super();
31+
this.pattern = pattern;
32+
}
33+
34+
public short getPattern() {
35+
return pattern;
36+
}
37+
38+
/** Create a new relation with the inverse */
39+
public AllenRelation invert() {
40+
return of(AllenConstants.invert(pattern));
41+
}
42+
43+
public static AllenRelation of(short pattern) {
44+
return new AllenRelation(pattern);
45+
}
46+
47+
public boolean isEmpty() {
48+
return pattern == 0;
49+
}
50+
51+
/** Combine all given patterns with bitwise OR */
52+
public static AllenRelation of(short pattern, short ... additionalPatterns) {
53+
short effectivePattern = pattern;
54+
for (short contrib : additionalPatterns) {
55+
effectivePattern |= contrib;
56+
}
57+
return of(effectivePattern);
58+
}
59+
60+
public AllenRelation union(AllenRelation other) {
61+
return new AllenRelation((short)(this.pattern | other.pattern));
62+
}
63+
64+
public static AllenRelation union(AllenRelation... others) {
65+
short unionPattern = (short)Arrays.asList(others).stream().mapToInt(AllenRelation::getPattern).reduce(0, (x, y) -> x | y);
66+
return of(unionPattern);
67+
}
68+
69+
boolean isBefore() {
70+
return (pattern & AllenConstants.BEFORE) != 0;
71+
}
72+
73+
boolean isAfter() {
74+
return (pattern & AllenConstants.AFTER) != 0;
75+
}
76+
77+
boolean isDuring() {
78+
return (pattern & AllenConstants.DURING) != 0;
79+
}
80+
81+
boolean isContaining() {
82+
return (pattern & AllenConstants.CONTAINS) != 0;
83+
}
84+
85+
boolean isOverlapping() {
86+
return (pattern & AllenConstants.OVERLAPS) != 0;
87+
}
88+
89+
boolean isOverlappedBy() {
90+
return (pattern & AllenConstants.OVERLAPPEDBY) != 0;
91+
}
92+
93+
boolean isMeeting() {
94+
return (pattern & AllenConstants.MEETS) != 0;
95+
}
96+
97+
boolean isMetBy() {
98+
return (pattern & AllenConstants.METBY) != 0;
99+
}
100+
101+
boolean isStarting() {
102+
return (pattern & AllenConstants.STARTS) != 0;
103+
}
104+
105+
boolean isStartedBy() {
106+
return (pattern & AllenConstants.STARTEDBY) != 0;
107+
}
108+
109+
boolean isFinishing() {
110+
return (pattern & AllenConstants.FINISHES) != 0;
111+
}
112+
113+
boolean isFinishedBy() {
114+
return (pattern & AllenConstants.FINISHEDBY) != 0;
115+
}
116+
117+
boolean isEqual() {
118+
return (pattern & AllenConstants.EQUALS) != 0;
119+
}
120+
121+
@Override
122+
public String toString() {
123+
return AllenConstants.toString(pattern);
124+
}
125+
126+
@Override
127+
public int hashCode() {
128+
return Objects.hash(pattern);
129+
}
130+
131+
@Override
132+
public boolean equals(Object obj) {
133+
if (this == obj)
134+
return true;
135+
if (obj == null)
136+
return false;
137+
if (getClass() != obj.getClass())
138+
return false;
139+
AllenRelation other = (AllenRelation) obj;
140+
return pattern == other.pattern;
141+
}
142+
}

0 commit comments

Comments
 (0)