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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
package com.yahoo.tensor;
import junit.framework.TestCase;
import org.junit.Test;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import static junit.framework.TestCase.assertTrue;
import static junit.framework.TestCase.fail;
import static org.junit.Assert.assertEquals;
/**
* @author bratseth
*/
public class IndexedTensorTestCase {
private final int vSize = 1;
private final int wSize = 2;
private final int xSize = 3;
private final int ySize = 4;
private final int zSize = 5;
@Test
public void testEmpty() {
Tensor empty = Tensor.Builder.of(TensorType.empty).build();
assertEquals(1, empty.size());
assertEquals((double)0.0, (double)empty.valueIterator().next(), 0.00000001);
Tensor emptyFromString = Tensor.from(TensorType.empty, "{}");
assertEquals(empty, emptyFromString);
}
@Test
public void testSingleValue() {
Tensor singleValue = Tensor.Builder.of(TensorType.empty).cell(TensorAddress.empty, 3.5).build();
assertTrue(singleValue instanceof IndexedTensor);
assertEquals("{3.5}", singleValue.toString());
Tensor singleValueFromString = Tensor.from(TensorType.empty, "{3.5}");
assertEquals("{3.5}", singleValueFromString.toString());
assertTrue(singleValueFromString instanceof IndexedTensor);
assertEquals(singleValue, singleValueFromString);
}
@Test
public void testBoundBuilding() {
TensorType type = new TensorType.Builder().indexed("v", vSize)
.indexed("w", wSize)
.indexed("x", xSize)
.indexed("y", ySize)
.indexed("z", zSize)
.build();
assertBuildingVWXYZ(type);
}
@Test
public void testUnboundBuilding() {
TensorType type = new TensorType.Builder().indexed("w")
.indexed("v")
.indexed("x")
.indexed("y")
.indexed("z").build();
assertBuildingVWXYZ(type);
}
private void assertBuildingVWXYZ(TensorType type) {
IndexedTensor.Builder builder = IndexedTensor.Builder.of(type);
// Build in scrambled order
for (int v = 0; v < vSize; v++)
for (int w = 0; w < wSize; w++)
for (int y = 0; y < ySize; y++)
for (int x = xSize - 1; x >= 0; x--)
for (int z = 0; z < zSize; z++)
builder.cell(value(v, w, x, y, z), v, w, x, y, z);
IndexedTensor tensor = (IndexedTensor)builder.build();
// Lookup by index arguments
for (int v = 0; v < vSize; v++)
for (int w = 0; w < wSize; w++)
for (int y = 0; y < ySize; y++)
for (int x = xSize - 1; x >= 0; x--)
for (int z = 0; z < zSize; z++)
assertEquals(value(v, w, x, y, z), (int) tensor.get(v, w, x, y, z));
// Lookup by TensorAddress argument
for (int v = 0; v < vSize; v++)
for (int w = 0; w < wSize; w++)
for (int y = 0; y < ySize; y++)
for (int x = xSize - 1; x >= 0; x--)
for (int z = 0; z < zSize; z++)
assertEquals(value(v, w, x, y, z), (int) tensor.get(TensorAddress.of(v, w, x, y, z)));
// Lookup from cells
Map<TensorAddress, Double> cells = tensor.cells();
assertEquals(tensor.size(), cells.size());
for (int v = 0; v < vSize; v++)
for (int w = 0; w < wSize; w++)
for (int y = 0; y < ySize; y++)
for (int x = xSize - 1; x >= 0; x--)
for (int z = 0; z < zSize; z++)
assertEquals(value(v, w, x, y, z), cells.get(TensorAddress.of(v, w, x, y, z)).intValue());
// Lookup from iterator
Map<TensorAddress, Double> cellsOfIterator = new HashMap<>();
for (Iterator<Tensor.Cell> i = tensor.cellIterator(); i.hasNext(); ) {
Map.Entry<TensorAddress, Double> cell = i.next();
cellsOfIterator.put(cell.getKey(), cell.getValue());
}
assertEquals(tensor.size(), cellsOfIterator.size());
for (int v = 0; v < vSize; v++)
for (int w = 0; w < wSize; w++)
for (int y = 0; y < ySize; y++)
for (int x = xSize - 1; x >= 0; x--)
for (int z = 0; z < zSize; z++)
assertEquals(value(v, w, x, y, z), cellsOfIterator.get(TensorAddress.of(v, w, x, y, z)).intValue());
}
/** Returns a unique value for some given cell indexes */
private int value(int v, int w, int x, int y, int z) {
return v + 3 * w + 7 * x + 11 * y + 13 * z;
}
}
|
