鸿蒙传说
使用hashmap构建的Sparsed数组对于频繁读取的数据来说效率很低。最有效的实现使用Trie,它允许访问单个向量,其中段是分布的。Trie可以通过只执行只读的两个数组索引来计算表中是否存在一个元素,以获得存储元素的有效位置,或者知道它是否不在基础存储中。它还可以为稀疏数组的默认值提供备份存储中的默认位置,因此不需要对返回的索引进行任何测试,因为Trie保证所有可能的源索引至少映射到后备存储中的默认位置(在备份存储中经常存储零、空字符串或空对象)。有一些实现支持可快速更新的尝试,通过一个普通的“紧密()”操作来优化多个操作结束时备份存储的大小。尝试要比散列映射快得多,因为它们不需要任何复杂的散列函数,并且不需要处理读的冲突(对于Hashmap,无论是读还是写,这都需要一个循环来跳到下一个候选位置,并对它们进行测试以比较有效的源索引.)此外,JavaHashmap只能对象进行索引,并且为每个散列源索引创建一个Integer对象(每次读取都需要创建这个对象,而不仅仅是写),因为它强调垃圾收集器的内存操作成本很高。我真的希望JRE包含一个IntegerTrieMap<Object>作为慢速HashMap<Integer,Object>或LongTrieMap<Object>的默认实现,作为更慢的HashMap<Long,Object>的默认实现.但情况仍然并非如此。你可能想知道什么是Trie?它只是一个小的整数数组(在比矩阵的整个坐标范围更小的范围内),它允许将坐标映射到向量中的整数位置。例如,假设您想要一个只包含几个非零值的1024*1024矩阵。与其将矩阵存储在包含1024*1024个元素(超过100万)的数组中,您可能只想将其拆分为大小为16*16的子区间,而只需要64*64这样的子范围。在这种情况下,Trie索引将只包含64*64整数(4096),并且至少有16*16个数据元素(包含默认的零,或稀疏矩阵中最常见的子范围)。用于存储值的向量将只包含一个副本,用于相互相等的子区域(其中大多数都是零的,它们将由相同的子范围表示)。所以,而不是使用类似的语法matrix[i][j],您将使用如下语法:trie.values[trie.subrangePositions[(i & ~15) + (j >> 4)] +
((i & 15) << 4) + (j & 15)]使用Trie对象的访问方法可以更方便地处理。下面是一个内置在注释类中的示例(我希望它编译OK,因为它已经简化了;如果有错误需要更正,请通知我):/**
* Implement a sparse matrix. Currently limited to a static size
* (<code>SIZE_I</code>, <code>SIZE_I</code>).
*/public class DoubleTrie {
/* Matrix logical options */
public static final int SIZE_I = 1024;
public static final int SIZE_J = 1024;
public static final double DEFAULT_VALUE = 0.0;
/* Internal splitting options */
private static final int SUBRANGEBITS_I = 4;
private static final int SUBRANGEBITS_J = 4;
/* Internal derived splitting constants */
private static final int SUBRANGE_I =
1 << SUBRANGEBITS_I;
private static final int SUBRANGE_J =
1 << SUBRANGEBITS_J;
private static final int SUBRANGEMASK_I =
SUBRANGE_I - 1;
private static final int SUBRANGEMASK_J =
SUBRANGE_J - 1;
private static final int SUBRANGE_POSITIONS =
SUBRANGE_I * SUBRANGE_J;
/* Internal derived default values for constructors */
private static final int SUBRANGES_I =
(SIZE_I + SUBRANGE_I - 1) / SUBRANGE_I;
private static final int SUBRANGES_J =
(SIZE_J + SUBRANGE_J - 1) / SUBRANGE_J;
private static final int SUBRANGES =
SUBRANGES_I * SUBRANGES_J;
private static final int DEFAULT_POSITIONS[] =
new int[SUBRANGES](0);
private static final double DEFAULT_VALUES[] =
new double[SUBRANGE_POSITIONS](DEFAULT_VALUE);
/* Internal fast computations of the splitting subrange and offset. */
private static final int subrangeOf(
final int i, final int j) {
return (i >> SUBRANGEBITS_I) * SUBRANGE_J +
(j >> SUBRANGEBITS_J);
}
private static final int positionOffsetOf(
final int i, final int j) {
return (i & SUBRANGEMASK_I) * MAX_J +
(j & SUBRANGEMASK_J);
}
/**
* Utility missing in java.lang.System for arrays of comparable
* component types, including all native types like double here.
*/
public static final int arraycompare(
final double[] values1, final int position1,
final double[] values2, final int position2,
final int length) {
if (position1 >= 0 && position2 >= 0 && length >= 0) {
while (length-- > 0) {
double value1, value2;
if ((value1 = values1[position1 + length]) !=
(value2 = values2[position2 + length])) {
/* Note: NaN values are different from everything including
* all Nan values; they are are also neigher lower than nor
* greater than everything including NaN. Note that the two
* infinite values, as well as denormal values, are exactly
* ordered and comparable with <, <=, ==, >=, >=, !=. Note
* that in comments below, infinite is considered "defined".
*/
if (value1 < value2)
return -1; /* defined < defined. */
if (value1 > value2)
return 1; /* defined > defined. */
if (value1 == value2)
return 0; /* defined == defined. */
/* One or both are NaN. */
if (value1 == value1) /* Is not a NaN? */
return -1; /* defined < NaN. */
if (value2 == value2) /* Is not a NaN? */
return 1; /* NaN > defined. */
/* Otherwise, both are NaN: check their precise bits in
* range 0x7FF0000000000001L..0x7FFFFFFFFFFFFFFFL
* including the canonical 0x7FF8000000000000L, or in
* range 0xFFF0000000000001L..0xFFFFFFFFFFFFFFFFL.
* Needed for sort stability only (NaNs are otherwise
* unordered).
*/
long raw1, raw2;
if ((raw1 = Double.doubleToRawLongBits(value1)) !=
(raw2 = Double.doubleToRawLongBits(value2)))
return raw1 < raw2 ? -1 : 1;
/* Otherwise the NaN are strictly equal, continue. */
}
}
return 0;
}
throw new ArrayIndexOutOfBoundsException(
"The positions and length can't be negative");
}
/**
* Utility shortcut for comparing ranges in the same array.
*/
public static final int arraycompare(
final double[] values,
final int position1, final int position2,
final int length) {
return arraycompare(values, position1, values, position2, length);
}
/**
* Utility missing in java.lang.System for arrays of equalizable
* component types, including all native types like double here.
*/
public static final boolean arrayequals(
final double[] values1, final int position1,
final double[] values2, final int position2,
final int length) {
return arraycompare(values1, position1, values2, position2, length) ==
0;
}
/**
* Utility shortcut for identifying ranges in the same array.
*/
public static final boolean arrayequals(
final double[] values,
final int position1, final int position2,
final int length) {
return arrayequals(values, position1, values, position2, length);
}
/**
* Utility shortcut for copying ranges in the same array.
*/
public static final void arraycopy(
final double[] values,
final int srcPosition, final int dstPosition,
final int length) {
arraycopy(values, srcPosition, values, dstPosition, length);
}
/**
* Utility shortcut for resizing an array, preserving values at start.
*/
public static final double[] arraysetlength(
double[] values,
final int newLength) {
final int oldLength =
values.length < newLength ? values.length : newLength;
System.arraycopy(values, 0, values = new double[newLength], 0,
oldLength);
return values;
}
/* Internal instance members. */
private double values[];
private int subrangePositions[];
private bool isSharedValues;
private bool isSharedSubrangePositions;
/* Internal method. */
private final reset(
final double[] values,
final int[] subrangePositions) {
this.isSharedValues =
(this.values = values) == DEFAULT_VALUES;
this.isSharedsubrangePositions =
(this.subrangePositions = subrangePositions) ==
DEFAULT_POSITIONS;
}
/**
* Reset the matrix to fill it with the same initial value.
*
* @param initialValue The value to set in all cell positions.
*/
public reset(final double initialValue = DEFAULT_VALUE) {
reset(
(initialValue == DEFAULT_VALUE) ? DEFAULT_VALUES :
new double[SUBRANGE_POSITIONS](initialValue),
DEFAULT_POSITIONS);
}
/**
* Default constructor, using single default value.
*
* @param initialValue Alternate default value to initialize all
* positions in the matrix.
*/
public DoubleTrie(final double initialValue = DEFAULT_VALUE) {
this.reset(initialValue);
}
/**
* This is a useful preinitialized instance containing the
* DEFAULT_VALUE in all cells.
*/
public static DoubleTrie DEFAULT_INSTANCE = new DoubleTrie();
/**
* Copy constructor. Note that the source trie may be immutable
* or not; but this constructor will create a new mutable trie
* even if the new trie initially shares some storage with its
* source when that source also uses shared storage.
*/
public DoubleTrie(final DoubleTrie source) {
this.values = (this.isSharedValues =
source.isSharedValues) ?
source.values :
source.values.clone();
this.subrangePositions = (this.isSharedSubrangePositions =
source.isSharedSubrangePositions) ?
source.subrangePositions :
source.subrangePositions.clone());
}
/**
* Fast indexed getter.
*
* @param i Row of position to set in the matrix.
* @param j Column of position to set in the matrix.
* @return The value stored in matrix at that position.
*/
public double getAt(final int i, final int j) {
return values[subrangePositions[subrangeOf(i, j)] +
positionOffsetOf(i, j)];
}
/**
* Fast indexed setter.
*
* @param i Row of position to set in the sparsed matrix.
* @param j Column of position to set in the sparsed matrix.
* @param value The value to set at this position.
* @return The passed value.
* Note: this does not compact the sparsed matric after setting.
* @see compact(void)
*/
public double setAt(final int i, final int i, final double value) {
final int subrange = subrangeOf(i, j);
final int positionOffset = positionOffsetOf(i, j);
// Fast check to see if the assignment will change something.
int subrangePosition, valuePosition;
if (Double.compare(
values[valuePosition =
(subrangePosition = subrangePositions[subrange]) +
positionOffset],
value) != 0) {
/* So we'll need to perform an effective assignment in values.
* Check if the current subrange to assign is shared of not.
* Note that we also include the DEFAULT_VALUES which may be
* shared by several other (not tested) trie instances,
* including those instanciated by the copy contructor. */
if (isSharedValues) {
values = values.clone();
isSharedValues = false;
}
/* Scan all other subranges to check if the position in values
* to assign is shared by another subrange. */
for (int otherSubrange = subrangePositions.length;
--otherSubrange >= 0; ) {
if (otherSubrange != subrange)
continue; /* Ignore the target subrange. */
/* Note: the following test of range is safe with future
* interleaving of common subranges (TODO in compact()),
* even though, for now, subranges are sharing positions
* only between their common start and end position, so we
* could as well only perform the simpler test <code>
* (otherSubrangePosition == subrangePosition)</code>,
* instead of testing the two bounds of the positions
* interval of the other subrange. */
int otherSubrangePosition;
if ((otherSubrangePosition =
subrangePositions[otherSubrange]) >=
valuePosition &&
otherSubrangePosition + SUBRANGE_POSITIONS <
valuePosition) {
/* The target position is shared by some other
* subrange, we need to make it unique by cloning the
* subrange to a larger values vector, copying all the
* current subrange values at end of the new vector,
* before assigning the new value. This will require
* changing the position of the current subrange, but
* before doing that, we first need to check if the
* subrangePositions array itself is also shared
* between instances (including the DEFAULT_POSITIONS
* that should be preserved, and possible arrays
* shared by an external factory contructor whose
* source trie was declared immutable in a derived
* class). */
if (isSharedSubrangePositions) {
subrangePositions = subrangePositions.clone();
isSharedSubrangePositions = false;
}
/* TODO: no attempt is made to allocate less than a
* fully independant subrange, using possible
* interleaving: this would require scanning all
* other existing values to find a match for the
* modified subrange of values; but this could
* potentially leave positions (in the current subrange
* of values) unreferenced by any subrange, after the
* change of position for the current subrange. This
* scanning could be prohibitively long for each
* assignement, and for now it's assumed that compact()
* will be used later, after those assignements. */
values = setlengh(
values,
(subrangePositions[subrange] =
subrangePositions = values.length) +
SUBRANGE_POSITIONS);
valuePosition = subrangePositions + positionOffset;
break;
}
}
/* Now perform the effective assignment of the value. */
values[valuePosition] = value;
}
}
return value;
}
/**
* Compact the storage of common subranges.
* TODO: This is a simple implementation without interleaving, which
* would offer a better data compression. However, interleaving with its
* O(N²) complexity where N is the total length of values, should
* be attempted only after this basic compression whose complexity is
* O(n²) with n being SUBRANGE_POSITIIONS times smaller than N.
*/
public void compact() {
final int oldValuesLength = values.length;
int newValuesLength = 0;
for (int oldPosition = 0;
oldPosition < oldValuesLength;
oldPosition += SUBRANGE_POSITIONS) {
int oldPosition = positions[subrange];
bool commonSubrange = false;
/* Scan values for possible common subranges. */
for (int newPosition = newValuesLength;
(newPosition -= SUBRANGE_POSITIONS) >= 0; )
if (arrayequals(values, newPosition, oldPosition,
SUBRANGE_POSITIONS)) {
commonSubrange = true;
/* Update the subrangePositions|] with all matching
* positions from oldPosition to newPosition. There may
* be several index to change, if the trie has already
* been compacted() before, and later reassigned. */
for (subrange = subrangePositions.length;
--subrange >= 0; )
if (subrangePositions[subrange] == oldPosition)
subrangePositions[subrange] = newPosition;
break;
}
if (!commonSubrange) {
/* Move down the non-common values, if some previous
* subranges have been compressed when they were common.
*/
if (!commonSubrange && oldPosition != newValuesLength) {
arraycopy(values, oldPosition, newValuesLength,
SUBRANGE_POSITIONS);
/* Advance compressed values to preserve these new ones. */
newValuesLength += SUBRANGE_POSITIONS;
}
}
}
/* Check the number of compressed values. */
if (newValuesLength < oldValuesLength) {
values = values.arraysetlength(newValuesLength);
isSharedValues = false;
}
}}注意:此代码不完整,因为它处理单个矩阵大小,而它的密码器仅限于检测公共子范围,而不交叉它们。此外,根据矩阵大小,代码不确定用于将矩阵拆分为子范围(x或y坐标)的最佳宽度或高度。它只使用相同的静态子范围大小为16(这两个坐标),但它可以方便地任何其他小功率为2(但一个非幂2将减慢int indexOf(int, int)和int offsetOf(int, int)(内部方法),独立于两个坐标,并达到矩阵的最大宽度或高度。compact()方法应该能够确定最佳的拟合大小。如果这些拆分子范围的大小可能有所不同,则需要为这些子范围大小添加实例成员,而不是静态的。SUBRANGE_POSITIONS,并使静态方法int subrangeOf(int i, int j)和int positionOffsetOf(int i, int j)变成非静态的;以及初始化数组。DEFAULT_POSITIONS和DEFAULT_VALUES需要以不同的方式删除或重新定义。如果您想支持交错,基本上您将从将现有值除以大约相同大小的两个值开始(两者都是最小子范围大小的倍数,第一个子集可能比第二个子集多一个子区间),然后在所有连续的位置扫描较大的子集以找到匹配的交织;然后尝试匹配这些值。然后,通过将子集分成两半(也是最小子范围大小的倍数)递归循环,然后再扫描以匹配这些子集(这将使子集的数量乘以2:您必须想知道子范围索引的加倍大小是否值得与现有值的大小相比,以查看它是否提供了有效的压缩(如果没有,您就停止了:您已经从交错压缩过程中直接找到了最佳的子范围大小)。在这种情况下,在压缩过程中,子范围大小将是可变的。但是,这段代码显示了如何分配非零值并重新分配data数组,用于额外的(非零)子范围,以及如何优化(使用compact()在使用setAt(int i, int j, double value)方法)当数据中存在可能统一的重复子范围时存储此数据,并在subrangePositions阵列。总之,TRIE的所有原则都是在这里实现的:使用单个向量而不是双索引数组(每个数组分别分配)来表示矩阵总是更快(并且在内存中更紧凑,意味着更好的局部性)。改进可见于double getAt(int, int)方法!您节省了大量的空间,但是在赋值时,重新分配新的子范围可能需要时间。因此,子范围不应该太小,否则在设置矩阵时会发生太频繁的重新分配。通过检测公共子区间,可以将初始大矩阵自动转换为更紧凑的矩阵。然后,一个典型的实现将包含一个方法,例如compact()上面。但是,如果get()访问非常快,set()非常快,如果有许多公共子范围需要压缩(例如,用它自己减去一个大的非稀疏随机填充矩阵,或者将它乘以零,那么它可能会非常慢:在这种情况下,通过实例化一个新的矩阵和删除旧的矩阵来重置Trie会更简单、更快)。公共子区域在数据中使用公共存储,因此这种共享数据必须是只读的。如果必须更改单个值而不更改矩阵的其余部分,则必须首先确保在subrangePositions索引。否则,您需要在values向量,然后将这个新子区域的位置存储到subrangePositions索引。请注意,泛型Colt库虽然非常好,但在处理稀疏矩阵时却不太好,因为它使用散列(或行压缩)技术,目前还没有实现对尝试的支持,尽管它是一个很好的优化,这两者都节省了空间。和节省时间,特别是对于最频繁的getAt()操作。甚至这里描述的用于尝试的setAt()操作也节省了大量的时间(在这里实现的方法,即设置后无需自动压缩,仍然可以根据需求和估计的时间来实现,因为压缩仍然会以时间为代价节省大量存储空间):节省时间与子区间中单元格的数量成正比,而节省空间与每个子范围的单元格数成反比。如果要使用子范围大小,那么每个子范围的单元格数是2D矩阵中单元格总数的平方根(当使用3D矩阵时,它将是一个立方根)。Colt稀疏矩阵实现中使用的散列技术由于可能的冲突而增加了大量的存储开销和较慢的访问时间。尝试可以避免所有碰撞,然后可以保证在最坏的情况下将线性O(N)时间节省到O(1)时间,其中(N)是可能的碰撞次数(在稀疏矩阵的情况下,可能取决于矩阵中非缺省值单元的数目,即矩阵的总大小乘以与散列填充因子成正比的因子,对于非稀疏的,即全矩阵)。Colt中使用的RC(行压缩)技术离尝试更近,但这是另一个代价,这里使用的压缩技术对于最频繁的只读GET()操作具有非常慢的访问时间,而对于setAt()操作则是非常慢的压缩。此外,所使用的压缩不是正交的,与保持正交性的尝试表示不同。对于相关的查看操作,例如跨步、换位(视为基于整数循环模块操作的跨步操作)、子测距(以及一般的子选择,包括排序视图),尝试也将保持这种正交性。我只是希望Colt将来会被更新,以便使用TRY(即TrieSparseMatrix,而不是HashSparseMatrix和RCSparseMatrix)实现另一个实现。这些想法都在本文中。trive实现(基于int->int映射)也是基于类似于Colt的HashedSparseMatrix的散列技术,即它们具有相同的不便。尝试的速度要快得多,占用一定的额外空间(但是这个空间可以被优化,甚至可以比trove和Colt更好,在一个延迟的时间内,使用对结果的矩阵/trie的最后的紧凑()离子操作)。注意:此Trie实现绑定到特定的本机类型(此处为Double)。这是自愿的,因为使用装箱类型的一般实现有很大的空间开销(而且访问时间要慢得多)。在这里,它只使用本机的双维数组,而不是泛型向量。但当然也可以为尝试导出一个通用实现.不幸的是,Java仍然不允许使用本机类型的所有优点编写真正的泛型类,除非编写多个实现(对于一个泛型对象类型或每个本机类型),并通过类型工厂提供所有这些操作。该语言应该能够自动实例化本机实现并自动构建工厂(就目前而言,即使在Java 7中也不是这样,在这种情况下.net仍然保持其优势,适用于与本机类型一样快速的真正泛型类型)。