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
|
// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
package com.yahoo.tensor;
import java.util.Arrays;
/**
* An indexed tensor implementation holding values as doubles
*
* @author bratseth
*/
class IndexedDoubleTensor extends IndexedTensor {
private final double[] values;
IndexedDoubleTensor(TensorType type, DimensionSizes dimensionSizes, double[] values) {
super(type, dimensionSizes);
this.values = values;
}
@Override
public long size() {
return values.length;
}
@Override
public double get(long valueIndex) { return values[(int)valueIndex]; }
@Override
public float getFloat(long valueIndex) { return (float)get(valueIndex); }
@Override
public IndexedTensor withType(TensorType type) {
throwOnIncompatibleType(type);
return new IndexedDoubleTensor(type, dimensionSizes(), values);
}
@Override
public int hashCode() { return Arrays.hashCode(values); }
/** A bound builder can create the double array directly */
public static class BoundDoubleBuilder extends BoundBuilder {
private double[] values;
BoundDoubleBuilder(TensorType type, DimensionSizes sizes) {
this(type, sizes, new double[(int)sizes.totalSize()]);
}
BoundDoubleBuilder(TensorType type, DimensionSizes sizes, double[] values) {
super(type, sizes);
this.values = values;
}
@Override
public IndexedTensor.BoundBuilder cell(float value, long ... indexes) {
return cell((double)value, indexes);
}
@Override
public IndexedTensor.BoundBuilder cell(double value, long ... indexes) {
values[(int)toValueIndex(indexes, sizes())] = value;
return this;
}
@Override
public CellBuilder cell() {
return new CellBuilder(type, this);
}
@Override
public Builder cell(TensorAddress address, float value) {
return cell(address, (double)value);
}
@Override
public Builder cell(TensorAddress address, double value) {
values[(int)toValueIndex(address, sizes(), type)] = value;
return this;
}
@Override
public IndexedTensor build() {
IndexedTensor tensor = new IndexedDoubleTensor(type, sizes(), values);
// prevent further modification
values = null;
return tensor;
}
@Override
public Builder cell(Cell cell, float value) {
return cell(cell, (double)value);
}
@Override
public Builder cell(Cell cell, double value) {
long directIndex = cell.getDirectIndex();
if (directIndex >= 0) // optimization
values[(int)directIndex] = value;
else
super.cell(cell, value);
return this;
}
@Override
public void cellByDirectIndex(long index, float value) {
cellByDirectIndex(index, (double)value);
}
@Override
public void cellByDirectIndex(long index, double value) {
try {
values[(int) index] = value;
}
catch (IndexOutOfBoundsException e) {
throw new IllegalArgumentException("Can not set the cell at position " + index + " in a tensor " +
"of type " + type + ": Index is too large");
}
}
}
}
|
