Exemple #1
0
        void Introduce(ref OffsetLength thisOffsetLength, OffsetLength thatOffsetLength, int scale)
        {
            var handle = increments.Dereference(thatOffsetLength);

            for (int i = 0; i < handle.Length && !handle.Array[handle.Offset + i].IsEmpty; i++)
            {
                Introduce(ref thisOffsetLength, default(S), scale * handle.Array[handle.Offset + i].Weight, handle.Array[handle.Offset + i].TimeIndex);
            }
        }
Exemple #2
0
        void IntroduceIncrements(ref OffsetLength thisOffsetLength, OffsetLength thatOffsetLength, int scale)
        {
            var handle = increments.Dereference(thatOffsetLength);

            for (int i = 0; i < handle.Length; i++)
            {
                if (!handle.Array[handle.Offset + i].IsEmpty)
                {
                    var recordHandle = records.Dereference(handle.Array[handle.Offset + i].OffsetLength);

                    for (int j = 0; j < recordHandle.Length; j++)
                    {
                        if (recordHandle.Array[recordHandle.Offset + j].weight != 0)
                        {
                            Introduce(ref thisOffsetLength, recordHandle.Array[recordHandle.Offset + j].record, scale * recordHandle.Array[recordHandle.Offset + j].weight, handle.Array[handle.Offset + i].TimeIndex);
                        }
                    }
                }
            }
        }
Exemple #3
0
        protected Handle <Weighted <S> > EnsureAllocation(ref OffsetLength ol, int newLength)
        {
            var handle = records.Dereference(ol);

            if (newLength > handle.Length)
            {
                var newOl     = new OffsetLength();
                var newHandle = records.Allocate(out newOl, newLength);


#if false
                if (newHandle.Length < HashTableThresholdCount)
                {
                    for (int i = 0; i < handle.Length; i++)
                    {
                        newHandle.Array[newHandle.Offset + i] = handle.Array[handle.Offset + i];
                    }

                    for (int i = handle.Length; i < newHandle.Length; i++)
                    {
                        newHandle.Array[newHandle.Offset + i] = new Weighted <S>();
                    }
                }
                else
                {
                    for (int i = 0; i < handle.Length && handle.Array[handle.Offset + i].weight != 0; i++)
                    {
                        IntroduceAsHashTable(ref newOl, handle.Array[handle.Offset + i].record, handle.Array[handle.Offset + i].weight);
                    }
                }
#else
                for (int i = 0; i < newHandle.Length; i++)
                {
                    newHandle.Array[newHandle.Offset + i] = new Weighted <S>();
                }

                for (int i = 0; i < handle.Length; i++)
                {
                    if (handle.Array[handle.Offset + i].weight != 0)
                    {
                        Introduce(ref newOl, handle.Array[handle.Offset + i].record, handle.Array[handle.Offset + i].weight);
                    }
                }
#endif
                records.Release(ref ol);
                ol = newOl;

                //return newHandle;
                return(records.Dereference(ol));
            }
            else
            {
                return(handle);
            }
        }