You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucenenet.apache.org by ni...@apache.org on 2021/02/17 12:13:32 UTC
[lucenenet] branch master updated (84a1329 -> a8477ee)
This is an automated email from the ASF dual-hosted git repository.
nightowl888 pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/lucenenet.git.
from 84a1329 Lucene.Net.Classification: Removed leading underscore from member vars in several classes (#422)
new 453ecb9 SWEEP: Removed unnecessary casts to sbyte to check ranges
new de116a9 SWEEP: Removed unnecessary casts of int or long to (sbyte) prior to cast to (byte), as overflow automatically fixes this
new b1e737e SWEEP: Replaced 2 casts with call to TripleShift method for unsigned right shift
new 884a057 Lucene.Net.Store (ByteArrayDataInput + DataInput): Removed unnecessary intermediate cast to ushort
new a8477ee azure-pipelines.yml: Added option to explicitly run x86 tests without having to do a nightly run which adds additional testing time
The 5 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
azure-pipelines.yml | 20 +-
.../Analysis/CharFilter/BaseCharFilter.cs | 5 +-
.../Compound/Hyphenation/HyphenationTree.cs | 7 +-
.../Analysis/Hunspell/Dictionary.cs | 3 +-
.../Analysis/Hunspell/Stemmer.cs | 9 +-
.../Analysis/Synonym/SynonymFilter.cs | 3 +-
.../Dict/BinaryDictionary.cs | 15 +-
.../Dict/ConnectionCosts.cs | 5 +-
src/Lucene.Net.Analysis.SmartCn/Hhmm/PathNode.cs | 3 +-
.../Hhmm/SegTokenPair.cs | 3 +-
.../BlockTerms/FixedGapTermsIndexReader.cs | 3 +-
.../IntBlock/FixedIntBlockIndexInput.cs | 7 +-
.../IntBlock/VariableIntBlockIndexInput.cs | 7 +-
.../Memory/DirectDocValuesConsumer.cs | 2 +-
.../Memory/DirectPostingsFormat.cs | 11 +-
src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs | 5 +-
src/Lucene.Net.Codecs/Memory/FSTTermOutputs.cs | 7 +-
.../Memory/MemoryPostingsFormat.cs | 11 +-
.../Pulsing/PulsingPostingsReader.cs | 9 +-
src/Lucene.Net.Codecs/Sep/SepPostingsReader.cs | 5 +-
src/Lucene.Net.Codecs/Sep/SepSkipListReader.cs | 5 +-
.../SimpleText/SimpleTextDocValuesWriter.cs | 2 +-
.../RandomSamplingFacetsCollector.cs | 3 +-
src/Lucene.Net.Facet/Range/LongRangeCounter.cs | 5 +-
.../Taxonomy/DocValuesOrdinalsReader.cs | 2 +-
.../Taxonomy/FastTaxonomyFacetCounts.cs | 2 +-
.../Taxonomy/WriterCache/CompactLabelToOrdinal.cs | 17 +-
.../Highlight/SimpleSpanFragmenter.cs | 5 +-
.../MemoryIndex.MemoryIndexReader.cs | 5 +-
.../Index/Sorter/SortingAtomicReader.cs | 5 +-
.../Util/Fst/UpToTwoPositiveIntOutputs.cs | 9 +-
src/Lucene.Net.Queries/Function/BoostedQuery.cs | 7 +-
.../ValueSources/DoubleConstValueSource.cs | 5 +-
.../Function/ValueSources/DualFloatFunction.cs | 7 +-
.../Function/ValueSources/LinearFloatFunction.cs | 7 +-
.../Function/ValueSources/RangeMapFloatFunction.cs | 7 +-
.../ValueSources/ReciprocalFloatFunction.cs | 5 +-
.../Standard/Parser/EscapeQuerySyntaxImpl.cs | 5 +-
src/Lucene.Net.Replicator/RevisionFile.cs | 3 +-
.../Queries/SortedSetSortField.cs | 7 +-
.../Util/DistanceToShapeValueSource.cs | 5 +-
.../Codecs/Lucene3x/PreFlexRWFieldInfosWriter.cs | 4 +-
.../Codecs/Lucene3x/PreFlexRWNormsConsumer.cs | 8 +-
.../Codecs/Lucene3x/PreFlexRWStoredFieldsWriter.cs | 4 +-
.../Codecs/Lucene40/Lucene40DocValuesWriter.cs | 10 +-
.../Compressing/AbstractTestLZ4CompressionMode.cs | 5 +-
.../Index/TestBackwardsCompatibility.cs | 7 +-
.../Index/TestBackwardsCompatibility3x.cs | 7 +-
.../Index/TestBinaryDocValuesUpdates.cs | 5 +-
src/Lucene.Net.Tests/Index/TestCompoundFile.cs | 8 +-
src/Lucene.Net.Tests/Index/TestIndexInput.cs | 48 +++-
src/Lucene.Net.Tests/Index/TestIndexWriter.cs | 6 +-
.../Index/TestIndexWriterExceptions.cs | 4 +-
src/Lucene.Net.Tests/Index/TestStressIndexing2.cs | 5 +-
src/Lucene.Net.Tests/Store/TestDirectory.cs | 4 +-
src/Lucene.Net.Tests/Store/TestHugeRamFile.cs | 6 +-
src/Lucene.Net.Tests/Util/Packed/TestPackedInts.cs | 5 +-
src/Lucene.Net.Tests/Util/TestNumericUtils.cs | 11 +-
src/Lucene.Net.Tests/Util/TestPagedBytes.cs | 4 +-
src/Lucene.Net/Codecs/BlockTreeTermsReader.cs | 27 +-
src/Lucene.Net/Codecs/BlockTreeTermsWriter.cs | 4 +-
.../CompressingStoredFieldsIndexReader.cs | 7 +-
.../Compressing/CompressingStoredFieldsReader.cs | 3 +-
.../Compressing/CompressingTermVectorsReader.cs | 3 +-
.../Compressing/CompressingTermVectorsWriter.cs | 9 +-
src/Lucene.Net/Codecs/Compressing/LZ4.cs | 14 +-
.../Codecs/Lucene3x/Lucene3xSkipListReader.cs | 3 +-
src/Lucene.Net/Codecs/Lucene3x/SegmentTermDocs.cs | 5 +-
.../Codecs/Lucene3x/SegmentTermPositions.cs | 3 +-
.../Codecs/Lucene3x/TermInfosReaderIndex.cs | 4 +-
src/Lucene.Net/Codecs/Lucene40/BitVector.cs | 3 +-
.../Codecs/Lucene40/Lucene40FieldInfosReader.cs | 3 +-
.../Codecs/Lucene40/Lucene40PostingsReader.cs | 21 +-
.../Codecs/Lucene40/Lucene40SegmentInfoWriter.cs | 4 +-
.../Codecs/Lucene40/Lucene40SkipListReader.cs | 3 +-
.../Codecs/Lucene40/Lucene40StoredFieldsWriter.cs | 4 +-
.../Codecs/Lucene40/Lucene40TermVectorsReader.cs | 3 +-
.../Codecs/Lucene40/Lucene40TermVectorsWriter.cs | 7 +-
src/Lucene.Net/Codecs/Lucene41/ForUtil.cs | 5 +-
.../Codecs/Lucene41/Lucene41PostingsReader.cs | 9 +-
.../Codecs/Lucene42/Lucene42FieldInfosReader.cs | 9 +-
.../Codecs/Lucene45/Lucene45DocValuesProducer.cs | 3 +-
.../Codecs/Lucene46/Lucene46FieldInfosReader.cs | 9 +-
.../Codecs/Lucene46/Lucene46SegmentInfoWriter.cs | 4 +-
src/Lucene.Net/Codecs/TermVectorsWriter.cs | 3 +-
src/Lucene.Net/Index/DocTermOrds.cs | 27 +-
.../Index/FreqProxTermsWriterPerField.cs | 5 +-
src/Lucene.Net/Index/ReaderUtil.cs | 5 +-
src/Lucene.Net/Index/SegmentInfos.cs | 4 +-
src/Lucene.Net/Index/SortedDocValues.cs | 4 +-
src/Lucene.Net/Index/SortedSetDocValues.cs | 4 +-
src/Lucene.Net/Index/TermsHashPerField.cs | 12 +-
src/Lucene.Net/Search/DocTermOrdsRangeFilter.cs | 3 +-
src/Lucene.Net/Search/FieldCacheRangeFilter.cs | 3 +-
src/Lucene.Net/Search/Spans/SpanFirstQuery.cs | 3 +-
.../Search/Spans/SpanNearPayloadCheckQuery.cs | 3 +-
src/Lucene.Net/Search/Spans/SpanNearQuery.cs | 5 +-
src/Lucene.Net/Search/Spans/SpanOrQuery.cs | 5 +-
.../Search/Spans/SpanPayloadCheckQuery.cs | 5 +-
.../Search/Spans/SpanPositionRangeQuery.cs | 3 +-
src/Lucene.Net/Store/BufferedIndexInput.cs | 26 +-
src/Lucene.Net/Store/ByteArrayDataInput.cs | 30 +--
src/Lucene.Net/Store/ByteBufferIndexInput.cs | 9 +-
src/Lucene.Net/Store/DataInput.cs | 30 +--
src/Lucene.Net/Store/DataOutput.cs | 25 +-
src/Lucene.Net/Store/FlushInfo.cs | 4 +-
src/Lucene.Net/Store/MMapDirectory.cs | 4 +-
src/Lucene.Net/Store/MergeInfo.cs | 4 +-
src/Lucene.Net/Util/Automaton/SpecialOperations.cs | 5 +-
src/Lucene.Net/Util/BroadWord.cs | 28 +-
src/Lucene.Net/Util/FixedBitSet.cs | 12 +-
src/Lucene.Net/Util/Fst/FST.cs | 11 +-
src/Lucene.Net/Util/Fst/FSTEnum.cs | 5 +-
src/Lucene.Net/Util/Fst/Util.cs | 7 +-
src/Lucene.Net/Util/InPlaceMergeSorter.cs | 3 +-
src/Lucene.Net/Util/IndexableBinaryStringTools.cs | 33 ++-
src/Lucene.Net/Util/IntroSorter.cs | 4 +-
src/Lucene.Net/Util/LongBitSet.cs | 10 +-
src/Lucene.Net/Util/LongsRef.cs | 3 +-
src/Lucene.Net/Util/MathUtil.cs | 6 +-
src/Lucene.Net/Util/Mutable/MutableValueDouble.cs | 3 +-
src/Lucene.Net/Util/OpenBitSet.cs | 12 +-
src/Lucene.Net/Util/OpenBitSetIterator.cs | 15 +-
src/Lucene.Net/Util/PForDeltaDocIdSet.cs | 26 +-
.../Util/Packed/AbstractBlockPackedWriter.cs | 7 +-
src/Lucene.Net/Util/Packed/AbstractPagedMutable.cs | 5 +-
src/Lucene.Net/Util/Packed/BlockPackedReader.cs | 5 +-
.../Util/Packed/BlockPackedReaderIterator.cs | 23 +-
src/Lucene.Net/Util/Packed/BlockPackedWriter.cs | 4 +-
src/Lucene.Net/Util/Packed/BulkOperation.cs | 3 +-
src/Lucene.Net/Util/Packed/BulkOperationPacked.cs | 35 +--
src/Lucene.Net/Util/Packed/BulkOperationPacked1.cs | 36 +--
.../Util/Packed/BulkOperationPacked10.cs | 140 +++++-----
.../Util/Packed/BulkOperationPacked11.cs | 284 +++++++++++----------
.../Util/Packed/BulkOperationPacked12.cs | 68 ++---
.../Util/Packed/BulkOperationPacked13.cs | 284 +++++++++++----------
.../Util/Packed/BulkOperationPacked14.cs | 140 +++++-----
.../Util/Packed/BulkOperationPacked15.cs | 284 +++++++++++----------
.../Util/Packed/BulkOperationPacked16.cs | 8 +-
.../Util/Packed/BulkOperationPacked17.cs | 284 +++++++++++----------
.../Util/Packed/BulkOperationPacked18.cs | 140 +++++-----
.../Util/Packed/BulkOperationPacked19.cs | 284 +++++++++++----------
src/Lucene.Net/Util/Packed/BulkOperationPacked2.cs | 20 +-
.../Util/Packed/BulkOperationPacked20.cs | 68 ++---
.../Util/Packed/BulkOperationPacked21.cs | 284 +++++++++++----------
.../Util/Packed/BulkOperationPacked22.cs | 140 +++++-----
.../Util/Packed/BulkOperationPacked23.cs | 284 +++++++++++----------
.../Util/Packed/BulkOperationPacked24.cs | 32 +--
src/Lucene.Net/Util/Packed/BulkOperationPacked3.cs | 284 +++++++++++----------
src/Lucene.Net/Util/Packed/BulkOperationPacked4.cs | 12 +-
src/Lucene.Net/Util/Packed/BulkOperationPacked5.cs | 284 +++++++++++----------
src/Lucene.Net/Util/Packed/BulkOperationPacked6.cs | 140 +++++-----
src/Lucene.Net/Util/Packed/BulkOperationPacked7.cs | 284 +++++++++++----------
src/Lucene.Net/Util/Packed/BulkOperationPacked8.cs | 8 +-
src/Lucene.Net/Util/Packed/BulkOperationPacked9.cs | 282 ++++++++++----------
.../Util/Packed/BulkOperationPackedSingleBlock.cs | 5 +-
.../Util/Packed/DirectPacked64SingleBlockReader.cs | 3 +-
src/Lucene.Net/Util/Packed/DirectPackedReader.cs | 7 +-
src/Lucene.Net/Util/Packed/EliasFanoDecoder.cs | 42 +--
src/Lucene.Net/Util/Packed/EliasFanoEncoder.cs | 20 +-
.../Util/Packed/MonotonicAppendingLongBuffer.cs | 3 +-
.../Util/Packed/MonotonicBlockPackedReader.cs | 3 +-
src/Lucene.Net/Util/Packed/Packed16ThreeBlocks.cs | 13 +-
src/Lucene.Net/Util/Packed/Packed64.cs | 27 +-
src/Lucene.Net/Util/Packed/Packed64SingleBlock.cs | 53 ++--
src/Lucene.Net/Util/Packed/Packed8ThreeBlocks.cs | 13 +-
src/Lucene.Net/Util/Packed/PackedDataInput.cs | 3 +-
src/Lucene.Net/Util/Packed/PackedDataOutput.cs | 7 +-
src/Lucene.Net/Util/Packed/PackedInts.cs | 4 +-
src/Lucene.Net/Util/PriorityQueue.cs | 5 +-
src/Lucene.Net/Util/RamUsageEstimator.cs | 8 +-
src/Lucene.Net/Util/Sorter.cs | 13 +-
src/Lucene.Net/Util/StringHelper.cs | 8 +-
src/Lucene.Net/Util/TimSorter.cs | 7 +-
src/Lucene.Net/Util/ToStringUtils.cs | 3 +-
src/Lucene.Net/Util/WAH8DocIdSet.cs | 17 +-
176 files changed, 2806 insertions(+), 2601 deletions(-)
[lucenenet] 04/05: Lucene.Net.Store (ByteArrayDataInput +
DataInput): Removed unnecessary intermediate cast to ushort
Posted by ni...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
nightowl888 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/lucenenet.git
commit 884a05735339ea98c29762f6b54387f16bf51ef2
Author: Shad Storhaug <sh...@shadstorhaug.com>
AuthorDate: Tue Feb 16 23:43:09 2021 +0700
Lucene.Net.Store (ByteArrayDataInput + DataInput): Removed unnecessary intermediate cast to ushort
---
src/Lucene.Net/Store/ByteArrayDataInput.cs | 4 ++--
src/Lucene.Net/Store/DataInput.cs | 4 ++--
2 files changed, 4 insertions(+), 4 deletions(-)
diff --git a/src/Lucene.Net/Store/ByteArrayDataInput.cs b/src/Lucene.Net/Store/ByteArrayDataInput.cs
index 8fe9220..562355e 100644
--- a/src/Lucene.Net/Store/ByteArrayDataInput.cs
+++ b/src/Lucene.Net/Store/ByteArrayDataInput.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
namespace Lucene.Net.Store
{
@@ -93,7 +93,7 @@ namespace Lucene.Net.Store
/// </summary>
public override short ReadInt16()
{
- return (short)(ushort)(((bytes[pos++] & 0xFF) << 8) | (bytes[pos++] & 0xFF));
+ return (short)(((bytes[pos++] & 0xFF) << 8) | (bytes[pos++] & 0xFF));
}
/// <summary>
diff --git a/src/Lucene.Net/Store/DataInput.cs b/src/Lucene.Net/Store/DataInput.cs
index 64eabc9..4609c9a 100644
--- a/src/Lucene.Net/Store/DataInput.cs
+++ b/src/Lucene.Net/Store/DataInput.cs
@@ -1,4 +1,4 @@
-using Lucene.Net.Diagnostics;
+using Lucene.Net.Diagnostics;
using System;
using System.Collections.Generic;
using System.IO;
@@ -95,7 +95,7 @@ namespace Lucene.Net.Store
/// <seealso cref="DataOutput.WriteInt16(short)"/>
public virtual short ReadInt16()
{
- return (short)(ushort)(((ReadByte() & 0xFF) << 8) | (ReadByte() & 0xFF));
+ return (short)(((ReadByte() & 0xFF) << 8) | (ReadByte() & 0xFF));
}
/// <summary>
[lucenenet] 01/05: SWEEP: Removed unnecessary casts to sbyte to
check ranges
Posted by ni...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
nightowl888 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/lucenenet.git
commit 453ecb967b86587f6563e9c822d5cf74e99a3404
Author: Shad Storhaug <sh...@shadstorhaug.com>
AuthorDate: Mon Feb 15 23:36:03 2021 +0700
SWEEP: Removed unnecessary casts to sbyte to check ranges
---
.../Taxonomy/DocValuesOrdinalsReader.cs | 2 +-
.../Taxonomy/FastTaxonomyFacetCounts.cs | 2 +-
src/Lucene.Net/Store/BufferedIndexInput.cs | 26 +++++++++++-----------
src/Lucene.Net/Store/ByteArrayDataInput.cs | 26 +++++++++++-----------
src/Lucene.Net/Store/DataInput.cs | 26 +++++++++++-----------
.../Util/Packed/BlockPackedReaderIterator.cs | 16 ++++++-------
6 files changed, 49 insertions(+), 49 deletions(-)
diff --git a/src/Lucene.Net.Facet/Taxonomy/DocValuesOrdinalsReader.cs b/src/Lucene.Net.Facet/Taxonomy/DocValuesOrdinalsReader.cs
index 7621924..6b42aa3 100644
--- a/src/Lucene.Net.Facet/Taxonomy/DocValuesOrdinalsReader.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/DocValuesOrdinalsReader.cs
@@ -109,7 +109,7 @@ namespace Lucene.Net.Facet.Taxonomy
while (offset < upto)
{
byte b = buf.Bytes[offset++];
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
ordinals.Int32s[ordinals.Length] = ((value << 7) | b) + prev;
value = 0;
diff --git a/src/Lucene.Net.Facet/Taxonomy/FastTaxonomyFacetCounts.cs b/src/Lucene.Net.Facet/Taxonomy/FastTaxonomyFacetCounts.cs
index 7c36937..54deaf0 100644
--- a/src/Lucene.Net.Facet/Taxonomy/FastTaxonomyFacetCounts.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/FastTaxonomyFacetCounts.cs
@@ -82,7 +82,7 @@ namespace Lucene.Net.Facet.Taxonomy
while (offset < end)
{
byte b = bytes[offset++];
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
prev = ord = ((ord << 7) | b) + prev;
++m_values[ord];
diff --git a/src/Lucene.Net/Store/BufferedIndexInput.cs b/src/Lucene.Net/Store/BufferedIndexInput.cs
index 716f1c0..6da7586 100644
--- a/src/Lucene.Net/Store/BufferedIndexInput.cs
+++ b/src/Lucene.Net/Store/BufferedIndexInput.cs
@@ -260,26 +260,26 @@ namespace Lucene.Net.Store
if (5 <= (bufferLength - bufferPosition))
{
byte b = m_buffer[bufferPosition++];
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return b;
}
int i = b & 0x7F;
b = m_buffer[bufferPosition++];
i |= (b & 0x7F) << 7;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = m_buffer[bufferPosition++];
i |= (b & 0x7F) << 14;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = m_buffer[bufferPosition++];
i |= (b & 0x7F) << 21;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
@@ -306,56 +306,56 @@ namespace Lucene.Net.Store
if (9 <= bufferLength - bufferPosition)
{
byte b = m_buffer[bufferPosition++];
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return b;
}
long i = b & 0x7FL;
b = m_buffer[bufferPosition++];
i |= (b & 0x7FL) << 7;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = m_buffer[bufferPosition++];
i |= (b & 0x7FL) << 14;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = m_buffer[bufferPosition++];
i |= (b & 0x7FL) << 21;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = m_buffer[bufferPosition++];
i |= (b & 0x7FL) << 28;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = m_buffer[bufferPosition++];
i |= (b & 0x7FL) << 35;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = m_buffer[bufferPosition++];
i |= (b & 0x7FL) << 42;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = m_buffer[bufferPosition++];
i |= (b & 0x7FL) << 49;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = m_buffer[bufferPosition++];
i |= (b & 0x7FL) << 56;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
diff --git a/src/Lucene.Net/Store/ByteArrayDataInput.cs b/src/Lucene.Net/Store/ByteArrayDataInput.cs
index 06d29cc..8fe9220 100644
--- a/src/Lucene.Net/Store/ByteArrayDataInput.cs
+++ b/src/Lucene.Net/Store/ByteArrayDataInput.cs
@@ -123,26 +123,26 @@ namespace Lucene.Net.Store
public override int ReadVInt32()
{
byte b = bytes[pos++];
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return b;
}
int i = b & 0x7F;
b = bytes[pos++];
i |= (b & 0x7F) << 7;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = bytes[pos++];
i |= (b & 0x7F) << 14;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = bytes[pos++];
i |= (b & 0x7F) << 21;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
@@ -162,56 +162,56 @@ namespace Lucene.Net.Store
public override long ReadVInt64()
{
byte b = bytes[pos++];
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return b;
}
long i = b & 0x7FL;
b = bytes[pos++];
i |= (b & 0x7FL) << 7;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = bytes[pos++];
i |= (b & 0x7FL) << 14;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = bytes[pos++];
i |= (b & 0x7FL) << 21;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = bytes[pos++];
i |= (b & 0x7FL) << 28;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = bytes[pos++];
i |= (b & 0x7FL) << 35;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = bytes[pos++];
i |= (b & 0x7FL) << 42;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = bytes[pos++];
i |= (b & 0x7FL) << 49;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = bytes[pos++];
i |= (b & 0x7FL) << 56;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
diff --git a/src/Lucene.Net/Store/DataInput.cs b/src/Lucene.Net/Store/DataInput.cs
index bec94e8..64eabc9 100644
--- a/src/Lucene.Net/Store/DataInput.cs
+++ b/src/Lucene.Net/Store/DataInput.cs
@@ -123,26 +123,26 @@ namespace Lucene.Net.Store
public virtual int ReadVInt32()
{
byte b = ReadByte();
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return b;
}
int i = b & 0x7F;
b = ReadByte();
i |= (b & 0x7F) << 7;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = ReadByte();
i |= (b & 0x7F) << 14;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = ReadByte();
i |= (b & 0x7F) << 21;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
@@ -191,56 +191,56 @@ namespace Lucene.Net.Store
return i;
*/
byte b = ReadByte();
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return b;
}
long i = b & 0x7FL;
b = ReadByte();
i |= (b & 0x7FL) << 7;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = ReadByte();
i |= (b & 0x7FL) << 14;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = ReadByte();
i |= (b & 0x7FL) << 21;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = ReadByte();
i |= (b & 0x7FL) << 28;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = ReadByte();
i |= (b & 0x7FL) << 35;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = ReadByte();
i |= (b & 0x7FL) << 42;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = ReadByte();
i |= (b & 0x7FL) << 49;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = ReadByte();
i |= (b & 0x7FL) << 56;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
diff --git a/src/Lucene.Net/Util/Packed/BlockPackedReaderIterator.cs b/src/Lucene.Net/Util/Packed/BlockPackedReaderIterator.cs
index 1b43ac8..d0b7c49 100644
--- a/src/Lucene.Net/Util/Packed/BlockPackedReaderIterator.cs
+++ b/src/Lucene.Net/Util/Packed/BlockPackedReaderIterator.cs
@@ -48,50 +48,50 @@ namespace Lucene.Net.Util.Packed
internal static long ReadVInt64(DataInput @in)
{
byte b = @in.ReadByte();
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return b;
}
long i = b & 0x7FL;
b = @in.ReadByte();
i |= (b & 0x7FL) << 7;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = @in.ReadByte();
i |= (b & 0x7FL) << 14;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = @in.ReadByte();
i |= (b & 0x7FL) << 21;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = @in.ReadByte();
i |= (b & 0x7FL) << 28;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = @in.ReadByte();
i |= (b & 0x7FL) << 35;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = @in.ReadByte();
i |= (b & 0x7FL) << 42;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
b = @in.ReadByte();
i |= (b & 0x7FL) << 49;
- if ((sbyte)b >= 0)
+ if (b <= sbyte.MaxValue) // LUCENENET: Optimized equivalent of "if ((sbyte)b >= 0)"
{
return i;
}
[lucenenet] 02/05: SWEEP: Removed unnecessary casts of int or long
to (sbyte) prior to cast to (byte), as overflow automatically fixes this
Posted by ni...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
nightowl888 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/lucenenet.git
commit de116a9b6362e80e26b7132f8693775b0a1ac53d
Author: Shad Storhaug <sh...@shadstorhaug.com>
AuthorDate: Tue Feb 16 00:34:12 2021 +0700
SWEEP: Removed unnecessary casts of int or long to (sbyte) prior to cast to (byte), as overflow automatically fixes this
---
.../Memory/DirectDocValuesConsumer.cs | 2 +-
.../SimpleText/SimpleTextDocValuesWriter.cs | 2 +-
.../Codecs/Lucene3x/PreFlexRWFieldInfosWriter.cs | 4 +-
.../Codecs/Lucene3x/PreFlexRWNormsConsumer.cs | 8 ++--
.../Codecs/Lucene3x/PreFlexRWStoredFieldsWriter.cs | 4 +-
.../Codecs/Lucene40/Lucene40DocValuesWriter.cs | 10 ++---
src/Lucene.Net.Tests/Index/TestCompoundFile.cs | 8 ++--
src/Lucene.Net.Tests/Index/TestIndexInput.cs | 48 +++++++++++++++++++++-
src/Lucene.Net.Tests/Index/TestIndexWriter.cs | 6 +--
.../Index/TestIndexWriterExceptions.cs | 4 +-
src/Lucene.Net.Tests/Store/TestDirectory.cs | 4 +-
src/Lucene.Net.Tests/Store/TestHugeRamFile.cs | 6 +--
src/Lucene.Net.Tests/Util/TestPagedBytes.cs | 4 +-
src/Lucene.Net/Codecs/BlockTreeTermsWriter.cs | 4 +-
.../Compressing/CompressingTermVectorsWriter.cs | 4 +-
src/Lucene.Net/Codecs/Compressing/LZ4.cs | 12 +++---
.../Codecs/Lucene40/Lucene40SegmentInfoWriter.cs | 4 +-
.../Codecs/Lucene40/Lucene40StoredFieldsWriter.cs | 4 +-
src/Lucene.Net/Codecs/Lucene41/ForUtil.cs | 4 +-
.../Codecs/Lucene46/Lucene46SegmentInfoWriter.cs | 4 +-
src/Lucene.Net/Index/SegmentInfos.cs | 4 +-
src/Lucene.Net/Store/DataOutput.cs | 22 +++++-----
src/Lucene.Net/Util/Fst/FST.cs | 8 ++--
src/Lucene.Net/Util/PForDeltaDocIdSet.cs | 18 ++++----
.../Util/Packed/AbstractBlockPackedWriter.cs | 6 +--
src/Lucene.Net/Util/Packed/BlockPackedWriter.cs | 4 +-
src/Lucene.Net/Util/Packed/PackedDataOutput.cs | 6 +--
src/Lucene.Net/Util/WAH8DocIdSet.cs | 4 +-
28 files changed, 131 insertions(+), 87 deletions(-)
diff --git a/src/Lucene.Net.Codecs/Memory/DirectDocValuesConsumer.cs b/src/Lucene.Net.Codecs/Memory/DirectDocValuesConsumer.cs
index 66538ee..d7b6787 100644
--- a/src/Lucene.Net.Codecs/Memory/DirectDocValuesConsumer.cs
+++ b/src/Lucene.Net.Codecs/Memory/DirectDocValuesConsumer.cs
@@ -139,7 +139,7 @@ namespace Lucene.Net.Codecs.Memory
switch (byteWidth)
{
case 1:
- data.WriteByte((byte)(sbyte) v);
+ data.WriteByte((byte) v);
break;
case 2:
data.WriteInt16((short) v);
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesWriter.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesWriter.cs
index 3d5cca8..9739692 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesWriter.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesWriter.cs
@@ -192,7 +192,7 @@ namespace Lucene.Net.Codecs.SimpleText
// pad to fit
for (int i = length; i < maxLength; i++)
{
- data.WriteByte((byte)(sbyte) ' ');
+ data.WriteByte((byte) ' ');
}
SimpleTextUtil.WriteNewline(data);
SimpleTextUtil.Write(data, value == null ? "F" : "T", scratch);
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWFieldInfosWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWFieldInfosWriter.cs
index 0538bdc..7d20215 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWFieldInfosWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWFieldInfosWriter.cs
@@ -1,4 +1,4 @@
-using Lucene.Net.Diagnostics;
+using Lucene.Net.Diagnostics;
using Lucene.Net.Index;
using Lucene.Net.Store;
using Lucene.Net.Util;
@@ -101,7 +101,7 @@ namespace Lucene.Net.Codecs.Lucene3x
{
// to allow null norm types we need to indicate if norms are written
// only in RW case
- output.WriteByte((byte)(sbyte)(fi.NormType == Index.DocValuesType.NONE ? 0 : 1));
+ output.WriteByte((byte)(fi.NormType == Index.DocValuesType.NONE ? 0 : 1));
}
if (Debugging.AssertsEnabled) Debugging.Assert(fi.Attributes == null); // not used or supported
}
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWNormsConsumer.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWNormsConsumer.cs
index b70ab92..704e5c8 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWNormsConsumer.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWNormsConsumer.cs
@@ -1,4 +1,4 @@
-using Lucene.Net.Diagnostics;
+using Lucene.Net.Diagnostics;
using Lucene.Net.Index;
using Lucene.Net.Store;
using Lucene.Net.Util;
@@ -80,11 +80,11 @@ namespace Lucene.Net.Codecs.Lucene3x
if (Debugging.AssertsEnabled) Debugging.Assert(field.Number > lastFieldNumber,"writing norms fields out of order {0} -> {1}", lastFieldNumber, field.Number);
foreach (var n in values)
{
- if (((sbyte)(byte)(long)n) < sbyte.MinValue || ((sbyte)(byte)(long)n) > sbyte.MaxValue)
+ if (((sbyte)n) < sbyte.MinValue || ((sbyte)n) > sbyte.MaxValue)
{
- throw new NotSupportedException("3.x cannot index norms that won't fit in a byte, got: " + ((sbyte)(byte)(long)n));
+ throw new NotSupportedException("3.x cannot index norms that won't fit in a byte, got: " + ((sbyte)n));
}
- @out.WriteByte((byte)(sbyte)n);
+ @out.WriteByte((byte)n);
}
lastFieldNumber = field.Number;
}
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWStoredFieldsWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWStoredFieldsWriter.cs
index 608acc8..567cb2f 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWStoredFieldsWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWStoredFieldsWriter.cs
@@ -1,4 +1,4 @@
-using Lucene.Net.Diagnostics;
+using Lucene.Net.Diagnostics;
using Lucene.Net.Documents;
using Lucene.Net.Index;
using Lucene.Net.Store;
@@ -159,7 +159,7 @@ namespace Lucene.Net.Codecs.Lucene3x
}
}
- fieldsStream.WriteByte((byte)(sbyte)bits);
+ fieldsStream.WriteByte((byte)bits);
if (bytes != null)
{
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40DocValuesWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40DocValuesWriter.cs
index 0640c13..683c5ca 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40DocValuesWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40DocValuesWriter.cs
@@ -1,4 +1,4 @@
-using Lucene.Net.Diagnostics;
+using Lucene.Net.Diagnostics;
using Lucene.Net.Index;
using Lucene.Net.Store;
using Lucene.Net.Support;
@@ -442,12 +442,12 @@ namespace Lucene.Net.Codecs.Lucene40
if (Debugging.AssertsEnabled) Debugging.Assert(i >= 0 && i <= short.MaxValue);
if (i < 128)
{
- o.WriteByte((byte)(sbyte)i);
+ o.WriteByte((byte)i);
}
else
{
- o.WriteByte((byte)unchecked((sbyte)(0x80 | (i >> 8))));
- o.WriteByte((byte)unchecked((sbyte)(i & 0xff)));
+ o.WriteByte((byte)(0x80 | (i >> 8)));
+ o.WriteByte((byte)(i & 0xff));
}
}
@@ -466,7 +466,7 @@ namespace Lucene.Net.Codecs.Lucene40
bool anyMissing = false;
foreach (long n in docToOrd)
{
- if ((long)n == -1)
+ if (n == -1)
{
anyMissing = true;
break;
diff --git a/src/Lucene.Net.Tests/Index/TestCompoundFile.cs b/src/Lucene.Net.Tests/Index/TestCompoundFile.cs
index 7c53e49..b56f0ae 100644
--- a/src/Lucene.Net.Tests/Index/TestCompoundFile.cs
+++ b/src/Lucene.Net.Tests/Index/TestCompoundFile.cs
@@ -1,4 +1,4 @@
-using Lucene.Net.Documents;
+using Lucene.Net.Documents;
using Lucene.Net.Store;
using NUnit.Framework;
using System;
@@ -310,7 +310,7 @@ namespace Lucene.Net.Index
IndexOutput os = fsdir.CreateOutput(file, IOContext.DEFAULT);
for (int i = 0; i < 2000; i++)
{
- os.WriteByte((byte)(sbyte)i);
+ os.WriteByte((byte)i);
}
os.Dispose();
@@ -632,7 +632,7 @@ namespace Lucene.Net.Index
var largeBuf = new byte[2048];
for (int i = 0; i < largeBuf.Length; i++)
{
- largeBuf[i] = (byte)unchecked((sbyte)(new Random(1).NextDouble() * 256));
+ largeBuf[i] = (byte)(new Random(1).NextDouble() * 256);
}
long currentPos = os.GetFilePointer();
@@ -823,7 +823,7 @@ namespace Lucene.Net.Index
for (int fileIdx = 0; fileIdx < FILE_COUNT; fileIdx++)
{
IndexOutput @out = d.CreateOutput("file." + fileIdx, NewIOContext(Random));
- @out.WriteByte((byte)(sbyte)fileIdx);
+ @out.WriteByte((byte)fileIdx);
@out.Dispose();
}
diff --git a/src/Lucene.Net.Tests/Index/TestIndexInput.cs b/src/Lucene.Net.Tests/Index/TestIndexInput.cs
index 3cdea38..5b3c809 100644
--- a/src/Lucene.Net.Tests/Index/TestIndexInput.cs
+++ b/src/Lucene.Net.Tests/Index/TestIndexInput.cs
@@ -1,4 +1,4 @@
-using NUnit.Framework;
+using NUnit.Framework;
using System;
using System.IO;
using Assert = Lucene.Net.TestFramework.Assert;
@@ -34,7 +34,51 @@ namespace Lucene.Net.Index
[TestFixture]
public class TestIndexInput : LuceneTestCase
{
- internal static readonly byte[] READ_TEST_BYTES = new byte[] { unchecked((byte)(sbyte)0x80), 0x01, unchecked((byte)(sbyte)0xFF), 0x7F, unchecked((byte)(sbyte)0x80), unchecked((byte)(sbyte)0x80), 0x01, unchecked((byte)(sbyte)0x81), unchecked((byte)(sbyte)0x80), 0x01, unchecked((byte)(sbyte)0xFF), unchecked((byte)(sbyte)0xFF), unchecked((byte)(sbyte)0xFF), unchecked((byte)(sbyte)0xFF), 0x07, unchecked((byte)(sbyte)0xFF), unchecked((byte)(sbyte)0xFF), unchecked((byte)(sbyte)0xFF), u [...]
+ internal static readonly byte[] READ_TEST_BYTES = new byte[] {
+ (byte) 0x80, 0x01,
+ (byte) 0xFF, 0x7F,
+ (byte) 0x80, (byte) 0x80, 0x01,
+ (byte) 0x81, (byte) 0x80, 0x01,
+ (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0x07,
+ (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0x0F,
+ (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0x07,
+ (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0x7F,
+ 0x06, (byte) 'L', (byte) 'u', (byte) 'c', (byte) 'e', (byte) 'n', (byte) 'e',
+
+ // 2-byte UTF-8 (U+00BF "INVERTED QUESTION MARK")
+ 0x02, (byte) 0xC2, (byte) 0xBF,
+ 0x0A, (byte) 'L', (byte) 'u', (byte) 0xC2, (byte) 0xBF,
+ (byte) 'c', (byte) 'e', (byte) 0xC2, (byte) 0xBF,
+ (byte) 'n', (byte) 'e',
+
+ // 3-byte UTF-8 (U+2620 "SKULL AND CROSSBONES")
+ 0x03, (byte) 0xE2, (byte) 0x98, (byte) 0xA0,
+ 0x0C, (byte) 'L', (byte) 'u', (byte) 0xE2, (byte) 0x98, (byte) 0xA0,
+ (byte) 'c', (byte) 'e', (byte) 0xE2, (byte) 0x98, (byte) 0xA0,
+ (byte) 'n', (byte) 'e',
+
+ // surrogate pairs
+ // (U+1D11E "MUSICAL SYMBOL G CLEF")
+ // (U+1D160 "MUSICAL SYMBOL EIGHTH NOTE")
+ 0x04, (byte) 0xF0, (byte) 0x9D, (byte) 0x84, (byte) 0x9E,
+ 0x08, (byte) 0xF0, (byte) 0x9D, (byte) 0x84, (byte) 0x9E,
+ (byte) 0xF0, (byte) 0x9D, (byte) 0x85, (byte) 0xA0,
+ 0x0E, (byte) 'L', (byte) 'u',
+ (byte) 0xF0, (byte) 0x9D, (byte) 0x84, (byte) 0x9E,
+ (byte) 'c', (byte) 'e',
+ (byte) 0xF0, (byte) 0x9D, (byte) 0x85, (byte) 0xA0,
+ (byte) 'n', (byte) 'e',
+
+ // null bytes
+ 0x01, 0x00,
+ 0x08, (byte) 'L', (byte) 'u', 0x00, (byte) 'c', (byte) 'e', 0x00, (byte) 'n', (byte) 'e',
+
+ // tests for Exceptions on invalid values
+ (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0x17,
+ (byte) 0x01, // guard value
+ (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+ (byte) 0x01, // guard value
+ };
internal static readonly int COUNT = RandomMultiplier * 65536;
internal static int[] INTS;
diff --git a/src/Lucene.Net.Tests/Index/TestIndexWriter.cs b/src/Lucene.Net.Tests/Index/TestIndexWriter.cs
index 7e9ed60..dc706d8 100644
--- a/src/Lucene.Net.Tests/Index/TestIndexWriter.cs
+++ b/src/Lucene.Net.Tests/Index/TestIndexWriter.cs
@@ -1,4 +1,4 @@
-using J2N.Text;
+using J2N.Text;
using J2N.Threading;
using Lucene.Net.Analysis;
using Lucene.Net.Analysis.TokenAttributes;
@@ -2341,7 +2341,7 @@ namespace Lucene.Net.Index
{
// Create my own random file:
IndexOutput @out = dir.CreateOutput("myrandomfile", NewIOContext(Random));
- @out.WriteByte((byte)(sbyte)42);
+ @out.WriteByte((byte)42);
@out.Dispose();
(new IndexWriter(dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random)))).Dispose();
@@ -2432,7 +2432,7 @@ namespace Lucene.Net.Index
{
// Create my own random file:
IndexOutput @out = dir.CreateOutput("_a.frq", NewIOContext(Random));
- @out.WriteByte((byte)(sbyte)42);
+ @out.WriteByte((byte)42);
@out.Dispose();
(new IndexWriter(dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random)))).Dispose();
diff --git a/src/Lucene.Net.Tests/Index/TestIndexWriterExceptions.cs b/src/Lucene.Net.Tests/Index/TestIndexWriterExceptions.cs
index c9ca8a4..35b944d 100644
--- a/src/Lucene.Net.Tests/Index/TestIndexWriterExceptions.cs
+++ b/src/Lucene.Net.Tests/Index/TestIndexWriterExceptions.cs
@@ -1,4 +1,4 @@
-using J2N.Threading;
+using J2N.Threading;
using J2N.Threading.Atomic;
using Lucene.Net.Analysis;
using Lucene.Net.Attributes;
@@ -1347,7 +1347,7 @@ namespace Lucene.Net.Index
IndexOutput @out = dir.CreateOutput(IndexFileNames.FileNameFromGeneration(IndexFileNames.SEGMENTS, "", 1 + gen), NewIOContext(Random));
@out.CopyBytes(@in, @in.Length - 1);
byte b = @in.ReadByte();
- @out.WriteByte((byte)(sbyte)(1 + b));
+ @out.WriteByte((byte)(1 + b));
@out.Dispose();
@in.Dispose();
diff --git a/src/Lucene.Net.Tests/Store/TestDirectory.cs b/src/Lucene.Net.Tests/Store/TestDirectory.cs
index 4fb2d95..4d1913e 100644
--- a/src/Lucene.Net.Tests/Store/TestDirectory.cs
+++ b/src/Lucene.Net.Tests/Store/TestDirectory.cs
@@ -1,4 +1,4 @@
-using J2N;
+using J2N;
using J2N.Threading;
using Lucene.Net.Attributes;
using Lucene.Net.Support;
@@ -194,7 +194,7 @@ namespace Lucene.Net.Store
string fname = "foo." + i;
string lockname = "foo" + i + ".lck";
IndexOutput @out = dir.CreateOutput(fname, NewIOContext(Random));
- @out.WriteByte((byte)(sbyte)i);
+ @out.WriteByte((byte)i);
@out.WriteBytes(largeBuffer, largeBuffer.Length);
@out.Dispose();
diff --git a/src/Lucene.Net.Tests/Store/TestHugeRamFile.cs b/src/Lucene.Net.Tests/Store/TestHugeRamFile.cs
index 22f9558..40f6b12 100644
--- a/src/Lucene.Net.Tests/Store/TestHugeRamFile.cs
+++ b/src/Lucene.Net.Tests/Store/TestHugeRamFile.cs
@@ -1,4 +1,4 @@
-using NUnit.Framework;
+using NUnit.Framework;
using System;
using System.Collections.Generic;
using Assert = Lucene.Net.TestFramework.Assert;
@@ -73,11 +73,11 @@ namespace Lucene.Net.Store
var b2 = new byte[RAMOutputStream.BUFFER_SIZE / 3];
for (int i = 0; i < b1.Length; i++)
{
- b1[i] = (byte)(sbyte)(i & 0x0007F);
+ b1[i] = (byte)(i & 0x0007F);
}
for (int i = 0; i < b2.Length; i++)
{
- b2[i] = (byte)(sbyte)(i & 0x0003F);
+ b2[i] = (byte)(i & 0x0003F);
}
long n = 0;
Assert.AreEqual(n, @out.Length, "output length must match");
diff --git a/src/Lucene.Net.Tests/Util/TestPagedBytes.cs b/src/Lucene.Net.Tests/Util/TestPagedBytes.cs
index 3a2c679..2b67251 100644
--- a/src/Lucene.Net.Tests/Util/TestPagedBytes.cs
+++ b/src/Lucene.Net.Tests/Util/TestPagedBytes.cs
@@ -1,4 +1,4 @@
-using Lucene.Net.Store;
+using Lucene.Net.Store;
using Lucene.Net.Support;
using NUnit.Framework;
using System;
@@ -194,7 +194,7 @@ namespace Lucene.Net.Util
var arr = new byte[TestUtil.NextInt32(Random, blockSize / 2, blockSize * 2)];
for (int i = 0; i < arr.Length; ++i)
{
- arr[i] = (byte)(sbyte)i;
+ arr[i] = (byte)i;
}
long numBytes = (1L << 31) + TestUtil.NextInt32(Random, 1, blockSize * 3);
var p = new PagedBytes(blockBits);
diff --git a/src/Lucene.Net/Codecs/BlockTreeTermsWriter.cs b/src/Lucene.Net/Codecs/BlockTreeTermsWriter.cs
index 2b2e54d..342bbdd 100644
--- a/src/Lucene.Net/Codecs/BlockTreeTermsWriter.cs
+++ b/src/Lucene.Net/Codecs/BlockTreeTermsWriter.cs
@@ -1,4 +1,4 @@
-using J2N.Text;
+using J2N.Text;
using Lucene.Net.Diagnostics;
using Lucene.Net.Support;
using Lucene.Net.Util.Fst;
@@ -517,7 +517,7 @@ namespace Lucene.Net.Codecs
//if (DEBUG) {
// System.out.println(" write floorLeadByte=" + Integer.toHexString(sub.floorLeadByte&0xff));
//}
- scratchBytes.WriteByte((byte)(sbyte)sub.FloorLeadByte);
+ scratchBytes.WriteByte((byte)sub.FloorLeadByte);
if (Debugging.AssertsEnabled) Debugging.Assert(sub.Fp > Fp);
scratchBytes.WriteVInt64((sub.Fp - Fp) << 1 | (uint)(sub.HasTerms ? 1 : 0));
}
diff --git a/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsWriter.cs b/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsWriter.cs
index 1faa1c1..3bc953f 100644
--- a/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsWriter.cs
+++ b/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsWriter.cs
@@ -1,4 +1,4 @@
-using Lucene.Net.Diagnostics;
+using Lucene.Net.Diagnostics;
using Lucene.Net.Support;
using System;
using System.Collections.Generic;
@@ -478,7 +478,7 @@ namespace Lucene.Net.Codecs.Compressing
if (Debugging.AssertsEnabled) Debugging.Assert(numDistinctFields > 0);
int bitsRequired = PackedInt32s.BitsRequired(fieldNums.Max);
int token = (Math.Min(numDistinctFields - 1, 0x07) << 5) | bitsRequired;
- vectorsStream.WriteByte((byte)(sbyte)token);
+ vectorsStream.WriteByte((byte)token);
if (numDistinctFields - 1 >= 0x07)
{
vectorsStream.WriteVInt32(numDistinctFields - 1 - 0x07);
diff --git a/src/Lucene.Net/Codecs/Compressing/LZ4.cs b/src/Lucene.Net/Codecs/Compressing/LZ4.cs
index 7df0575..70c910d 100644
--- a/src/Lucene.Net/Codecs/Compressing/LZ4.cs
+++ b/src/Lucene.Net/Codecs/Compressing/LZ4.cs
@@ -1,4 +1,4 @@
-using J2N.Numerics;
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Support;
using System;
@@ -177,16 +177,16 @@ namespace Lucene.Net.Codecs.Compressing
{
while (l >= 0xFF)
{
- @out.WriteByte(unchecked((byte)(sbyte)0xFF));
+ @out.WriteByte(/*(byte)*/0xFF); // LUCENENET: Removed unnecessary cast
l -= 0xFF;
}
- @out.WriteByte((byte)(sbyte)l);
+ @out.WriteByte((byte)l);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static void EncodeLiterals(byte[] bytes, int token, int anchor, int literalLen, DataOutput @out)
{
- @out.WriteByte((byte)(sbyte)token);
+ @out.WriteByte((byte)token);
// encode literal length
if (literalLen >= 0x0F)
@@ -216,8 +216,8 @@ namespace Lucene.Net.Codecs.Compressing
// encode match dec
int matchDec = matchOff - matchRef;
if (Debugging.AssertsEnabled) Debugging.Assert(matchDec > 0 && matchDec < 1 << 16);
- @out.WriteByte((byte)(sbyte)matchDec);
- @out.WriteByte((byte)(sbyte)((int)((uint)matchDec >> 8)));
+ @out.WriteByte((byte)matchDec);
+ @out.WriteByte((byte)(int)((uint)matchDec >> 8));
// encode match len
if (matchLen >= MIN_MATCH + 0x0F)
diff --git a/src/Lucene.Net/Codecs/Lucene40/Lucene40SegmentInfoWriter.cs b/src/Lucene.Net/Codecs/Lucene40/Lucene40SegmentInfoWriter.cs
index 8b4b00f..15e3fc3 100644
--- a/src/Lucene.Net/Codecs/Lucene40/Lucene40SegmentInfoWriter.cs
+++ b/src/Lucene.Net/Codecs/Lucene40/Lucene40SegmentInfoWriter.cs
@@ -1,4 +1,4 @@
-using Lucene.Net.Support;
+using Lucene.Net.Support;
using System;
namespace Lucene.Net.Codecs.Lucene40
@@ -60,7 +60,7 @@ namespace Lucene.Net.Codecs.Lucene40
output.WriteString(si.Version);
output.WriteInt32(si.DocCount);
- output.WriteByte((byte)(sbyte)(si.UseCompoundFile ? SegmentInfo.YES : SegmentInfo.NO));
+ output.WriteByte((byte)(si.UseCompoundFile ? SegmentInfo.YES : SegmentInfo.NO));
output.WriteStringStringMap(si.Diagnostics);
output.WriteStringStringMap(Collections.EmptyMap<string, string>());
output.WriteStringSet(si.GetFiles());
diff --git a/src/Lucene.Net/Codecs/Lucene40/Lucene40StoredFieldsWriter.cs b/src/Lucene.Net/Codecs/Lucene40/Lucene40StoredFieldsWriter.cs
index 47bf7c8..67e292f 100644
--- a/src/Lucene.Net/Codecs/Lucene40/Lucene40StoredFieldsWriter.cs
+++ b/src/Lucene.Net/Codecs/Lucene40/Lucene40StoredFieldsWriter.cs
@@ -1,4 +1,4 @@
-using J2N;
+using J2N;
using Lucene.Net.Diagnostics;
using Lucene.Net.Documents;
using System;
@@ -217,7 +217,7 @@ namespace Lucene.Net.Codecs.Lucene40
}
}
- fieldsStream.WriteByte((byte)(sbyte)bits);
+ fieldsStream.WriteByte((byte)bits);
if (bytes != null)
{
diff --git a/src/Lucene.Net/Codecs/Lucene41/ForUtil.cs b/src/Lucene.Net/Codecs/Lucene41/ForUtil.cs
index 4406d54..975221e 100644
--- a/src/Lucene.Net/Codecs/Lucene41/ForUtil.cs
+++ b/src/Lucene.Net/Codecs/Lucene41/ForUtil.cs
@@ -1,4 +1,4 @@
-using Lucene.Net.Diagnostics;
+using Lucene.Net.Diagnostics;
using Lucene.Net.Store;
using Lucene.Net.Support;
using Lucene.Net.Util.Packed;
@@ -165,7 +165,7 @@ namespace Lucene.Net.Codecs.Lucene41
{
if (IsAllEqual(data))
{
- @out.WriteByte((byte)(sbyte)ALL_VALUES_EQUAL);
+ @out.WriteByte((byte)ALL_VALUES_EQUAL);
@out.WriteVInt32(data[0]);
return;
}
diff --git a/src/Lucene.Net/Codecs/Lucene46/Lucene46SegmentInfoWriter.cs b/src/Lucene.Net/Codecs/Lucene46/Lucene46SegmentInfoWriter.cs
index aaa3869..35af117 100644
--- a/src/Lucene.Net/Codecs/Lucene46/Lucene46SegmentInfoWriter.cs
+++ b/src/Lucene.Net/Codecs/Lucene46/Lucene46SegmentInfoWriter.cs
@@ -1,4 +1,4 @@
-namespace Lucene.Net.Codecs.Lucene46
+namespace Lucene.Net.Codecs.Lucene46
{
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
@@ -56,7 +56,7 @@ namespace Lucene.Net.Codecs.Lucene46
output.WriteString(si.Version);
output.WriteInt32(si.DocCount);
- output.WriteByte((byte)(sbyte)(si.UseCompoundFile ? SegmentInfo.YES : SegmentInfo.NO));
+ output.WriteByte((byte)(si.UseCompoundFile ? SegmentInfo.YES : SegmentInfo.NO));
output.WriteStringStringMap(si.Diagnostics);
output.WriteStringSet(si.GetFiles());
CodecUtil.WriteFooter(output);
diff --git a/src/Lucene.Net/Index/SegmentInfos.cs b/src/Lucene.Net/Index/SegmentInfos.cs
index bdfc679..b9b396d 100644
--- a/src/Lucene.Net/Index/SegmentInfos.cs
+++ b/src/Lucene.Net/Index/SegmentInfos.cs
@@ -1,4 +1,4 @@
-using J2N;
+using J2N;
using J2N.Collections.Generic.Extensions;
using Lucene.Net.Diagnostics;
using Lucene.Net.Support;
@@ -672,7 +672,7 @@ namespace Lucene.Net.Index
output.WriteStringStringMap(si.Attributes);
- output.WriteByte((byte)(sbyte)(si.UseCompoundFile ? SegmentInfo.YES : SegmentInfo.NO));
+ output.WriteByte((byte)(si.UseCompoundFile ? SegmentInfo.YES : SegmentInfo.NO));
output.WriteStringStringMap(si.Diagnostics);
output.WriteStringSet(si.GetFiles());
diff --git a/src/Lucene.Net/Store/DataOutput.cs b/src/Lucene.Net/Store/DataOutput.cs
index 93493e4..c86194c 100644
--- a/src/Lucene.Net/Store/DataOutput.cs
+++ b/src/Lucene.Net/Store/DataOutput.cs
@@ -1,4 +1,4 @@
-using Lucene.Net.Diagnostics;
+using Lucene.Net.Diagnostics;
using System.Collections.Generic;
using System.IO;
@@ -72,10 +72,10 @@ namespace Lucene.Net.Store
/// <seealso cref="DataInput.ReadInt32()"/>
public virtual void WriteInt32(int i)
{
- WriteByte((byte)(sbyte)(i >> 24));
- WriteByte((byte)(sbyte)(i >> 16));
- WriteByte((byte)(sbyte)(i >> 8));
- WriteByte((byte)(sbyte)i);
+ WriteByte((byte)(i >> 24));
+ WriteByte((byte)(i >> 16));
+ WriteByte((byte)(i >> 8));
+ WriteByte((byte)i);
}
/// <summary>
@@ -86,8 +86,8 @@ namespace Lucene.Net.Store
/// <seealso cref="DataInput.ReadInt16()"/>
public virtual void WriteInt16(short i)
{
- WriteByte((byte)(sbyte)((ushort)i >> 8));
- WriteByte((byte)(sbyte)(ushort)i);
+ WriteByte((byte)((ushort)i >> 8));
+ WriteByte((byte)(ushort)i);
}
/// <summary>
@@ -199,10 +199,10 @@ namespace Lucene.Net.Store
{
while ((i & ~0x7F) != 0)
{
- WriteByte((byte)unchecked((sbyte)((i & 0x7F) | 0x80)));
+ WriteByte((byte)((i & 0x7F) | 0x80));
i = (int)((uint)i >> 7);
}
- WriteByte((byte)(sbyte)i);
+ WriteByte((byte)i);
}
/// <summary>
@@ -234,10 +234,10 @@ namespace Lucene.Net.Store
if (Debugging.AssertsEnabled) Debugging.Assert(i >= 0L);
while ((i & ~0x7FL) != 0L)
{
- WriteByte((byte)unchecked((sbyte)((i & 0x7FL) | 0x80L)));
+ WriteByte((byte)((i & 0x7FL) | 0x80L));
i = (long)((ulong)i >> 7);
}
- WriteByte((byte)(sbyte)i);
+ WriteByte((byte)i);
}
/// <summary>
diff --git a/src/Lucene.Net/Util/Fst/FST.cs b/src/Lucene.Net/Util/Fst/FST.cs
index fe0379c..8c7d8a1 100644
--- a/src/Lucene.Net/Util/Fst/FST.cs
+++ b/src/Lucene.Net/Util/Fst/FST.cs
@@ -1,4 +1,4 @@
-using J2N.Collections;
+using J2N.Collections;
using Lucene.Net.Diagnostics;
using Lucene.Net.Support;
using System;
@@ -594,7 +594,7 @@ namespace Lucene.Net.Util.Fst
if (inputType == FST.INPUT_TYPE.BYTE1)
{
if (Debugging.AssertsEnabled) Debugging.Assert(v <= 255,"v={0}", v);
- @out.WriteByte((byte)(sbyte)v);
+ @out.WriteByte((byte)v);
}
else if (inputType == FST.INPUT_TYPE.BYTE2)
{
@@ -723,7 +723,7 @@ namespace Lucene.Net.Util.Fst
flags += FST.BIT_ARC_HAS_OUTPUT;
}
- bytes.WriteByte((byte)(sbyte)flags);
+ bytes.WriteByte((byte)flags);
WriteLabel(bytes, arc.Label);
// System.out.println(" write arc: label=" + (char) arc.Label + " flags=" + flags + " target=" + target.Node + " pos=" + bytes.getPosition() + " output=" + outputs.outputToString(arc.Output));
@@ -1886,7 +1886,7 @@ namespace Lucene.Net.Util.Fst
}
if (Debugging.AssertsEnabled) Debugging.Assert(flags != FST.ARCS_AS_FIXED_ARRAY);
- writer.WriteByte((byte)(sbyte)flags);
+ writer.WriteByte((byte)flags);
fst.WriteLabel(writer, arc.Label);
diff --git a/src/Lucene.Net/Util/PForDeltaDocIdSet.cs b/src/Lucene.Net/Util/PForDeltaDocIdSet.cs
index e98da7c..a3b61b1 100644
--- a/src/Lucene.Net/Util/PForDeltaDocIdSet.cs
+++ b/src/Lucene.Net/Util/PForDeltaDocIdSet.cs
@@ -1,4 +1,4 @@
-using J2N.Numerics;
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Support;
using System;
@@ -252,15 +252,15 @@ namespace Lucene.Net.Util
if (numExceptions > 0)
{
if (Debugging.AssertsEnabled) Debugging.Assert(bitsPerException > 0);
- data.WriteByte((byte)(sbyte)numExceptions);
- data.WriteByte((byte)(sbyte)bitsPerException);
+ data.WriteByte((byte)numExceptions);
+ data.WriteByte((byte)bitsPerException);
PackedInt32s.IEncoder encoder = PackedInt32s.GetEncoder(PackedInt32s.Format.PACKED, PackedInt32s.VERSION_CURRENT, bitsPerException);
int numIterations = (numExceptions + encoder.ByteValueCount - 1) / encoder.ByteValueCount;
encoder.Encode(exceptions, 0, data.Bytes, data.Length, numIterations);
data.Length += (int)PackedInt32s.Format.PACKED.ByteCount(PackedInt32s.VERSION_CURRENT, numExceptions, bitsPerException);
for (int i = 0; i < numExceptions; ++i)
{
- data.WriteByte((byte)(sbyte)exceptionIndices[i]);
+ data.WriteByte((byte)exceptionIndices[i]);
}
}
}
@@ -274,7 +274,7 @@ namespace Lucene.Net.Util
doc += 1 + buffer[i];
while (doc >= 8)
{
- data.WriteByte((byte)(sbyte)current);
+ data.WriteByte((byte)current);
current = 0;
doc -= 8;
}
@@ -282,7 +282,7 @@ namespace Lucene.Net.Util
}
if (current != 0)
{
- data.WriteByte((byte)(sbyte)current);
+ data.WriteByte((byte)current);
}
}
@@ -305,7 +305,7 @@ namespace Lucene.Net.Util
{
token |= HAS_EXCEPTIONS;
}
- data.WriteByte((byte)(sbyte)token);
+ data.WriteByte((byte)token);
PforEncode();
}
else
@@ -313,13 +313,13 @@ namespace Lucene.Net.Util
// use unary
blockSize = unaryBlockSize;
int token = UNARY | (bufferSize < BLOCK_SIZE ? LAST_BLOCK : 0);
- data.WriteByte((byte)(sbyte)token);
+ data.WriteByte((byte)token);
UnaryEncode();
}
if (bufferSize < BLOCK_SIZE)
{
- data.WriteByte((byte)(sbyte)bufferSize);
+ data.WriteByte((byte)bufferSize);
}
++numBlocks;
diff --git a/src/Lucene.Net/Util/Packed/AbstractBlockPackedWriter.cs b/src/Lucene.Net/Util/Packed/AbstractBlockPackedWriter.cs
index 294e514..78a3d2c 100644
--- a/src/Lucene.Net/Util/Packed/AbstractBlockPackedWriter.cs
+++ b/src/Lucene.Net/Util/Packed/AbstractBlockPackedWriter.cs
@@ -1,4 +1,4 @@
-using Lucene.Net.Diagnostics;
+using Lucene.Net.Diagnostics;
using Lucene.Net.Support;
using System;
using System.Runtime.CompilerServices;
@@ -47,10 +47,10 @@ namespace Lucene.Net.Util.Packed
int k = 0;
while ((i & ~0x7FL) != 0L && k++ < 8)
{
- @out.WriteByte(unchecked((byte)(sbyte)((i & 0x7FL) | 0x80L)));
+ @out.WriteByte((byte)((i & 0x7FL) | 0x80L));
i = (long)((ulong)i >> 7);
}
- @out.WriteByte((byte)(sbyte)i);
+ @out.WriteByte((byte)i);
}
protected DataOutput m_out;
diff --git a/src/Lucene.Net/Util/Packed/BlockPackedWriter.cs b/src/Lucene.Net/Util/Packed/BlockPackedWriter.cs
index c6f579a..4ec3645 100644
--- a/src/Lucene.Net/Util/Packed/BlockPackedWriter.cs
+++ b/src/Lucene.Net/Util/Packed/BlockPackedWriter.cs
@@ -1,4 +1,4 @@
-using Lucene.Net.Diagnostics;
+using Lucene.Net.Diagnostics;
using System;
using System.Runtime.CompilerServices;
@@ -93,7 +93,7 @@ namespace Lucene.Net.Util.Packed
}
int token = (bitsRequired << BPV_SHIFT) | (min == 0 ? MIN_VALUE_EQUALS_0 : 0);
- m_out.WriteByte((byte)(sbyte)token);
+ m_out.WriteByte((byte)token);
if (min != 0)
{
diff --git a/src/Lucene.Net/Util/Packed/PackedDataOutput.cs b/src/Lucene.Net/Util/Packed/PackedDataOutput.cs
index 39e13da..6c9e390 100644
--- a/src/Lucene.Net/Util/Packed/PackedDataOutput.cs
+++ b/src/Lucene.Net/Util/Packed/PackedDataOutput.cs
@@ -1,4 +1,4 @@
-using Lucene.Net.Diagnostics;
+using Lucene.Net.Diagnostics;
using System;
using System.Runtime.CompilerServices;
@@ -58,7 +58,7 @@ namespace Lucene.Net.Util.Packed
{
if (remainingBits == 0)
{
- @out.WriteByte((byte)(sbyte)current);
+ @out.WriteByte((byte)current);
current = 0L;
remainingBits = 8;
}
@@ -77,7 +77,7 @@ namespace Lucene.Net.Util.Packed
{
if (remainingBits < 8)
{
- @out.WriteByte((byte)(sbyte)current);
+ @out.WriteByte((byte)current);
}
remainingBits = 8;
current = 0L;
diff --git a/src/Lucene.Net/Util/WAH8DocIdSet.cs b/src/Lucene.Net/Util/WAH8DocIdSet.cs
index 844aaac..7ebe22c 100644
--- a/src/Lucene.Net/Util/WAH8DocIdSet.cs
+++ b/src/Lucene.Net/Util/WAH8DocIdSet.cs
@@ -1,4 +1,4 @@
-using Lucene.Net.Diagnostics;
+using Lucene.Net.Diagnostics;
using Lucene.Net.Support;
using System;
using System.Collections.Generic;
@@ -324,7 +324,7 @@ namespace Lucene.Net.Util
{
token |= 1 << 3;
}
- @out.WriteByte((byte)(sbyte)token);
+ @out.WriteByte((byte)token);
if (cleanLengthMinus2 > 0x03)
{
@out.WriteVInt32((int)((uint)cleanLengthMinus2 >> 2));
[lucenenet] 05/05: azure-pipelines.yml: Added option to explicitly
run x86 tests without having to do a nightly run which adds additional
testing time
Posted by ni...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
nightowl888 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/lucenenet.git
commit a8477eeda7b841c1f7c90436dcd942be3f662083
Author: Shad Storhaug <sh...@shadstorhaug.com>
AuthorDate: Wed Feb 17 00:01:11 2021 +0700
azure-pipelines.yml: Added option to explicitly run x86 tests without having to do a nightly run which adds additional testing time
---
azure-pipelines.yml | 20 +++++++++++---------
1 file changed, 11 insertions(+), 9 deletions(-)
diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index 1e44f50..232cd46 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -1,4 +1,4 @@
-# Licensed to the Apache Software Foundation (ASF) under one
+# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
@@ -49,6 +49,8 @@ name: 'vNext$(rev:.r)' # Format for build number (will be overridden)
# Verbose: 'false' (Optional - set to true for verbose logging output)
# Multiplier: '1' (Optional - the number of iterations to multiply applicable tests by)
+# RunX86Tests: 'false' (Optional - set to 'true' to enable x86 tests)
+
variables:
- name: BuildCounter
value: $[counter(variables['VersionSuffix'],coalesce(variables['BuildCounterSeed'], 1250))]
@@ -348,8 +350,8 @@ stages:
maximumParallelJobs: $(maximumParallelJobs)
maximumAllowedFailures: $(maximumAllowedFailures)
- - job: Test_net5_0_x86 # Only run Nightly
- condition: and(succeeded(), ne(variables['RunTests'], 'false'), eq(variables['IsNightly'], 'true'))
+ - job: Test_net5_0_x86 # Only run Nightly or if explicitly enabled with RunX86Tests
+ condition: and(succeeded(), ne(variables['RunTests'], 'false'), or(eq(variables['IsNightly'], 'true'), eq(variables['RunX86Tests'], 'true')))
strategy:
matrix:
Windows:
@@ -412,8 +414,8 @@ stages:
maximumParallelJobs: $(maximumParallelJobs)
maximumAllowedFailures: $(maximumAllowedFailures)
- - job: Test_netcoreapp3_1_x86 # Only run Nightly
- condition: and(succeeded(), ne(variables['RunTests'], 'false'), eq(variables['IsNightly'], 'true'))
+ - job: Test_netcoreapp3_1_x86 # Only run Nightly or if explicitly enabled with RunX86Tests
+ condition: and(succeeded(), ne(variables['RunTests'], 'false'), or(eq(variables['IsNightly'], 'true'), eq(variables['RunX86Tests'], 'true')))
strategy:
matrix:
Windows:
@@ -476,8 +478,8 @@ stages:
maximumParallelJobs: $(maximumParallelJobs)
maximumAllowedFailures: $(maximumAllowedFailures)
- - job: Test_netcoreapp2_2_x86 # Only run Nightly
- condition: and(succeeded(), ne(variables['RunTests'], 'false'), eq(variables['IsNightly'], 'true'))
+ - job: Test_netcoreapp2_2_x86 # Only run Nightly or if explicitly enabled with RunX86Tests
+ condition: and(succeeded(), ne(variables['RunTests'], 'false'), or(eq(variables['IsNightly'], 'true'), eq(variables['RunX86Tests'], 'true')))
strategy:
matrix:
Windows:
@@ -523,8 +525,8 @@ stages:
maximumParallelJobs: 8
maximumAllowedFailures: 2 # Maximum allowed failures for a successful build
- - job: Test_net48_Windows_x86 # Only run Nightly
- condition: and(succeeded(), ne(variables['RunTests'], 'false'), eq(variables['IsNightly'], 'true'))
+ - job: Test_net48_Windows_x86 # Only run Nightly or if explicitly enabled with RunX86Tests
+ condition: and(succeeded(), ne(variables['RunTests'], 'false'), or(eq(variables['IsNightly'], 'true'), eq(variables['RunX86Tests'], 'true')))
displayName: 'Test net48,x86 on Windows'
pool:
vmImage: 'windows-2019'
[lucenenet] 03/05: SWEEP: Replaced 2 casts with call to TripleShift
method for unsigned right shift
Posted by ni...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
nightowl888 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/lucenenet.git
commit b1e737ee0af4cf1b3b524ca592b3672f1ef6c52d
Author: Shad Storhaug <sh...@shadstorhaug.com>
AuthorDate: Tue Feb 16 20:46:07 2021 +0700
SWEEP: Replaced 2 casts with call to TripleShift method for unsigned right shift
---
.../Analysis/CharFilter/BaseCharFilter.cs | 5 +-
.../Compound/Hyphenation/HyphenationTree.cs | 7 +-
.../Analysis/Hunspell/Dictionary.cs | 3 +-
.../Analysis/Hunspell/Stemmer.cs | 9 +-
.../Analysis/Synonym/SynonymFilter.cs | 3 +-
.../Dict/BinaryDictionary.cs | 15 +-
.../Dict/ConnectionCosts.cs | 5 +-
src/Lucene.Net.Analysis.SmartCn/Hhmm/PathNode.cs | 3 +-
.../Hhmm/SegTokenPair.cs | 3 +-
.../BlockTerms/FixedGapTermsIndexReader.cs | 3 +-
.../IntBlock/FixedIntBlockIndexInput.cs | 7 +-
.../IntBlock/VariableIntBlockIndexInput.cs | 7 +-
.../Memory/DirectPostingsFormat.cs | 11 +-
src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs | 5 +-
src/Lucene.Net.Codecs/Memory/FSTTermOutputs.cs | 7 +-
.../Memory/MemoryPostingsFormat.cs | 11 +-
.../Pulsing/PulsingPostingsReader.cs | 9 +-
src/Lucene.Net.Codecs/Sep/SepPostingsReader.cs | 5 +-
src/Lucene.Net.Codecs/Sep/SepSkipListReader.cs | 5 +-
.../RandomSamplingFacetsCollector.cs | 3 +-
src/Lucene.Net.Facet/Range/LongRangeCounter.cs | 5 +-
.../Taxonomy/WriterCache/CompactLabelToOrdinal.cs | 17 +-
.../Highlight/SimpleSpanFragmenter.cs | 5 +-
.../MemoryIndex.MemoryIndexReader.cs | 5 +-
.../Index/Sorter/SortingAtomicReader.cs | 5 +-
.../Util/Fst/UpToTwoPositiveIntOutputs.cs | 9 +-
src/Lucene.Net.Queries/Function/BoostedQuery.cs | 7 +-
.../ValueSources/DoubleConstValueSource.cs | 5 +-
.../Function/ValueSources/DualFloatFunction.cs | 7 +-
.../Function/ValueSources/LinearFloatFunction.cs | 7 +-
.../Function/ValueSources/RangeMapFloatFunction.cs | 7 +-
.../ValueSources/ReciprocalFloatFunction.cs | 5 +-
.../Standard/Parser/EscapeQuerySyntaxImpl.cs | 5 +-
src/Lucene.Net.Replicator/RevisionFile.cs | 3 +-
.../Queries/SortedSetSortField.cs | 7 +-
.../Util/DistanceToShapeValueSource.cs | 5 +-
.../Compressing/AbstractTestLZ4CompressionMode.cs | 5 +-
.../Index/TestBackwardsCompatibility.cs | 7 +-
.../Index/TestBackwardsCompatibility3x.cs | 7 +-
.../Index/TestBinaryDocValuesUpdates.cs | 5 +-
src/Lucene.Net.Tests/Index/TestStressIndexing2.cs | 5 +-
src/Lucene.Net.Tests/Util/Packed/TestPackedInts.cs | 5 +-
src/Lucene.Net.Tests/Util/TestNumericUtils.cs | 11 +-
src/Lucene.Net/Codecs/BlockTreeTermsReader.cs | 27 +-
.../CompressingStoredFieldsIndexReader.cs | 7 +-
.../Compressing/CompressingStoredFieldsReader.cs | 3 +-
.../Compressing/CompressingTermVectorsReader.cs | 3 +-
.../Compressing/CompressingTermVectorsWriter.cs | 5 +-
src/Lucene.Net/Codecs/Compressing/LZ4.cs | 4 +-
.../Codecs/Lucene3x/Lucene3xSkipListReader.cs | 3 +-
src/Lucene.Net/Codecs/Lucene3x/SegmentTermDocs.cs | 5 +-
.../Codecs/Lucene3x/SegmentTermPositions.cs | 3 +-
.../Codecs/Lucene3x/TermInfosReaderIndex.cs | 4 +-
src/Lucene.Net/Codecs/Lucene40/BitVector.cs | 3 +-
.../Codecs/Lucene40/Lucene40FieldInfosReader.cs | 3 +-
.../Codecs/Lucene40/Lucene40PostingsReader.cs | 21 +-
.../Codecs/Lucene40/Lucene40SkipListReader.cs | 3 +-
.../Codecs/Lucene40/Lucene40TermVectorsReader.cs | 3 +-
.../Codecs/Lucene40/Lucene40TermVectorsWriter.cs | 7 +-
src/Lucene.Net/Codecs/Lucene41/ForUtil.cs | 5 +-
.../Codecs/Lucene41/Lucene41PostingsReader.cs | 9 +-
.../Codecs/Lucene42/Lucene42FieldInfosReader.cs | 9 +-
.../Codecs/Lucene45/Lucene45DocValuesProducer.cs | 3 +-
.../Codecs/Lucene46/Lucene46FieldInfosReader.cs | 9 +-
src/Lucene.Net/Codecs/TermVectorsWriter.cs | 3 +-
src/Lucene.Net/Index/DocTermOrds.cs | 27 +-
.../Index/FreqProxTermsWriterPerField.cs | 5 +-
src/Lucene.Net/Index/ReaderUtil.cs | 5 +-
src/Lucene.Net/Index/SortedDocValues.cs | 4 +-
src/Lucene.Net/Index/SortedSetDocValues.cs | 4 +-
src/Lucene.Net/Index/TermsHashPerField.cs | 12 +-
src/Lucene.Net/Search/DocTermOrdsRangeFilter.cs | 3 +-
src/Lucene.Net/Search/FieldCacheRangeFilter.cs | 3 +-
src/Lucene.Net/Search/Spans/SpanFirstQuery.cs | 3 +-
.../Search/Spans/SpanNearPayloadCheckQuery.cs | 3 +-
src/Lucene.Net/Search/Spans/SpanNearQuery.cs | 5 +-
src/Lucene.Net/Search/Spans/SpanOrQuery.cs | 5 +-
.../Search/Spans/SpanPayloadCheckQuery.cs | 5 +-
.../Search/Spans/SpanPositionRangeQuery.cs | 3 +-
src/Lucene.Net/Store/ByteBufferIndexInput.cs | 9 +-
src/Lucene.Net/Store/DataOutput.cs | 7 +-
src/Lucene.Net/Store/FlushInfo.cs | 4 +-
src/Lucene.Net/Store/MMapDirectory.cs | 4 +-
src/Lucene.Net/Store/MergeInfo.cs | 4 +-
src/Lucene.Net/Util/Automaton/SpecialOperations.cs | 5 +-
src/Lucene.Net/Util/BroadWord.cs | 28 +-
src/Lucene.Net/Util/FixedBitSet.cs | 12 +-
src/Lucene.Net/Util/Fst/FST.cs | 3 +-
src/Lucene.Net/Util/Fst/FSTEnum.cs | 5 +-
src/Lucene.Net/Util/Fst/Util.cs | 7 +-
src/Lucene.Net/Util/InPlaceMergeSorter.cs | 3 +-
src/Lucene.Net/Util/IndexableBinaryStringTools.cs | 33 ++-
src/Lucene.Net/Util/IntroSorter.cs | 4 +-
src/Lucene.Net/Util/LongBitSet.cs | 10 +-
src/Lucene.Net/Util/LongsRef.cs | 3 +-
src/Lucene.Net/Util/MathUtil.cs | 6 +-
src/Lucene.Net/Util/Mutable/MutableValueDouble.cs | 3 +-
src/Lucene.Net/Util/OpenBitSet.cs | 12 +-
src/Lucene.Net/Util/OpenBitSetIterator.cs | 15 +-
src/Lucene.Net/Util/PForDeltaDocIdSet.cs | 8 +-
.../Util/Packed/AbstractBlockPackedWriter.cs | 5 +-
src/Lucene.Net/Util/Packed/AbstractPagedMutable.cs | 5 +-
src/Lucene.Net/Util/Packed/BlockPackedReader.cs | 5 +-
.../Util/Packed/BlockPackedReaderIterator.cs | 7 +-
src/Lucene.Net/Util/Packed/BulkOperation.cs | 3 +-
src/Lucene.Net/Util/Packed/BulkOperationPacked.cs | 35 +--
src/Lucene.Net/Util/Packed/BulkOperationPacked1.cs | 36 +--
.../Util/Packed/BulkOperationPacked10.cs | 140 +++++-----
.../Util/Packed/BulkOperationPacked11.cs | 284 +++++++++++----------
.../Util/Packed/BulkOperationPacked12.cs | 68 ++---
.../Util/Packed/BulkOperationPacked13.cs | 284 +++++++++++----------
.../Util/Packed/BulkOperationPacked14.cs | 140 +++++-----
.../Util/Packed/BulkOperationPacked15.cs | 284 +++++++++++----------
.../Util/Packed/BulkOperationPacked16.cs | 8 +-
.../Util/Packed/BulkOperationPacked17.cs | 284 +++++++++++----------
.../Util/Packed/BulkOperationPacked18.cs | 140 +++++-----
.../Util/Packed/BulkOperationPacked19.cs | 284 +++++++++++----------
src/Lucene.Net/Util/Packed/BulkOperationPacked2.cs | 20 +-
.../Util/Packed/BulkOperationPacked20.cs | 68 ++---
.../Util/Packed/BulkOperationPacked21.cs | 284 +++++++++++----------
.../Util/Packed/BulkOperationPacked22.cs | 140 +++++-----
.../Util/Packed/BulkOperationPacked23.cs | 284 +++++++++++----------
.../Util/Packed/BulkOperationPacked24.cs | 32 +--
src/Lucene.Net/Util/Packed/BulkOperationPacked3.cs | 284 +++++++++++----------
src/Lucene.Net/Util/Packed/BulkOperationPacked4.cs | 12 +-
src/Lucene.Net/Util/Packed/BulkOperationPacked5.cs | 284 +++++++++++----------
src/Lucene.Net/Util/Packed/BulkOperationPacked6.cs | 140 +++++-----
src/Lucene.Net/Util/Packed/BulkOperationPacked7.cs | 284 +++++++++++----------
src/Lucene.Net/Util/Packed/BulkOperationPacked8.cs | 8 +-
src/Lucene.Net/Util/Packed/BulkOperationPacked9.cs | 282 ++++++++++----------
.../Util/Packed/BulkOperationPackedSingleBlock.cs | 5 +-
.../Util/Packed/DirectPacked64SingleBlockReader.cs | 3 +-
src/Lucene.Net/Util/Packed/DirectPackedReader.cs | 7 +-
src/Lucene.Net/Util/Packed/EliasFanoDecoder.cs | 42 +--
src/Lucene.Net/Util/Packed/EliasFanoEncoder.cs | 20 +-
.../Util/Packed/MonotonicAppendingLongBuffer.cs | 3 +-
.../Util/Packed/MonotonicBlockPackedReader.cs | 3 +-
src/Lucene.Net/Util/Packed/Packed16ThreeBlocks.cs | 13 +-
src/Lucene.Net/Util/Packed/Packed64.cs | 27 +-
src/Lucene.Net/Util/Packed/Packed64SingleBlock.cs | 53 ++--
src/Lucene.Net/Util/Packed/Packed8ThreeBlocks.cs | 13 +-
src/Lucene.Net/Util/Packed/PackedDataInput.cs | 3 +-
src/Lucene.Net/Util/Packed/PackedDataOutput.cs | 5 +-
src/Lucene.Net/Util/Packed/PackedInts.cs | 4 +-
src/Lucene.Net/Util/PriorityQueue.cs | 5 +-
src/Lucene.Net/Util/RamUsageEstimator.cs | 8 +-
src/Lucene.Net/Util/Sorter.cs | 13 +-
src/Lucene.Net/Util/StringHelper.cs | 8 +-
src/Lucene.Net/Util/TimSorter.cs | 7 +-
src/Lucene.Net/Util/ToStringUtils.cs | 3 +-
src/Lucene.Net/Util/WAH8DocIdSet.cs | 17 +-
151 files changed, 2622 insertions(+), 2463 deletions(-)
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/BaseCharFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/BaseCharFilter.cs
index 097ba8c..46fa322 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/BaseCharFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/BaseCharFilter.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Diagnostics;
+using J2N.Numerics;
+using Lucene.Net.Diagnostics;
using Lucene.Net.Support;
using Lucene.Net.Util;
using System.Diagnostics;
@@ -61,7 +62,7 @@ namespace Lucene.Net.Analysis.CharFilters
while (hi >= lo)
{
- mid = (int)((uint)(lo + hi) >> 1);
+ mid = (lo + hi).TripleShift(1);
if (currentOff < offsets[mid])
{
hi = mid - 1;
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/HyphenationTree.cs b/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/HyphenationTree.cs
index 21d966a..f9373a7 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/HyphenationTree.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/HyphenationTree.cs
@@ -1,4 +1,5 @@
-using System;
+using J2N.Numerics;
+using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
@@ -100,7 +101,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
byte v = m_vspace[k++];
while (v != 0)
{
- char c = (char)(((int)((uint)v >> 4)) - 1 + '0');
+ char c = (char)(v.TripleShift(4) - 1 + '0');;
buf.Append(c);
c = (char)(v & 0x0f);
if (c == 0)
@@ -251,7 +252,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
byte v = m_vspace[k++];
while (v != 0)
{
- char c = (char)((((int)((uint)v >> 4))) - 1);
+ char c = (char)(v.TripleShift(4) - 1);
buf.Append(c);
c = (char)(v & 0x0f);
if (c == 0)
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs b/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs
index b61ebd9..6804308 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs
@@ -1,5 +1,6 @@
using J2N;
using J2N.Collections.Generic.Extensions;
+using J2N.Numerics;
using J2N.Text;
using Lucene.Net.Diagnostics;
using Lucene.Net.Store;
@@ -946,7 +947,7 @@ namespace Lucene.Net.Analysis.Hunspell
{
return CharsRef.EMPTY_CHARS;
}
- int len = (int)((uint)b.Length >> 1);
+ int len = b.Length.TripleShift(1);
char[] flags = new char[len];
int upto = 0;
int end = b.Offset + b.Length;
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Stemmer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Stemmer.cs
index 9388316..6cdd491 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Stemmer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Stemmer.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Analysis.Util;
+using J2N.Numerics;
+using Lucene.Net.Analysis.Util;
using Lucene.Net.Diagnostics;
using Lucene.Net.Store;
using Lucene.Net.Util;
@@ -197,7 +198,7 @@ namespace Lucene.Net.Analysis.Hunspell
char stripOrd = (char)(affixReader.ReadInt16() & 0xffff);
int condition = (char)(affixReader.ReadInt16() & 0xffff);
bool crossProduct = (condition & 1) == 1;
- condition = (int)((uint)condition >> 1);
+ condition = condition.TripleShift(1);
char append = (char)(affixReader.ReadInt16() & 0xffff);
bool compatible;
@@ -266,7 +267,7 @@ namespace Lucene.Net.Analysis.Hunspell
char stripOrd = (char)(affixReader.ReadInt16() & 0xffff);
int condition = (char)(affixReader.ReadInt16() & 0xffff);
bool crossProduct = (condition & 1) == 1;
- condition = (int)((uint)condition >> 1);
+ condition = condition.TripleShift(1);
char append = (char)(affixReader.ReadInt16() & 0xffff);
bool compatible;
@@ -368,7 +369,7 @@ namespace Lucene.Net.Analysis.Hunspell
affixReader.SkipBytes(2); // strip
int condition = (char)(affixReader.ReadInt16() & 0xffff);
bool crossProduct = (condition & 1) == 1;
- condition = (int)((uint)condition >> 1);
+ condition = condition.TripleShift(1);
char append = (char)(affixReader.ReadInt16() & 0xffff);
List<CharsRef> stems = new List<CharsRef>();
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymFilter.cs
index faa5c59..50622b7 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymFilter.cs
@@ -1,4 +1,5 @@
using J2N;
+using J2N.Numerics;
using Lucene.Net.Analysis.TokenAttributes;
using Lucene.Net.Diagnostics;
using Lucene.Net.Store;
@@ -493,7 +494,7 @@ namespace Lucene.Net.Analysis.Synonym
int code = bytesReader.ReadVInt32();
bool keepOrig = (code & 0x1) == 0;
- int count = (int)((uint)code >> 1);
+ int count = code.TripleShift(1);
//System.out.println(" addOutput count=" + count + " keepOrig=" + keepOrig);
for (int outputIDX = 0; outputIDX < count; outputIDX++)
{
diff --git a/src/Lucene.Net.Analysis.Kuromoji/Dict/BinaryDictionary.cs b/src/Lucene.Net.Analysis.Kuromoji/Dict/BinaryDictionary.cs
index eb3c754..9ca9d5d 100644
--- a/src/Lucene.Net.Analysis.Kuromoji/Dict/BinaryDictionary.cs
+++ b/src/Lucene.Net.Analysis.Kuromoji/Dict/BinaryDictionary.cs
@@ -1,5 +1,6 @@
using J2N;
using J2N.IO;
+using J2N.Numerics;
using Lucene.Net.Codecs;
using Lucene.Net.Store;
using Lucene.Net.Util;
@@ -120,7 +121,7 @@ namespace Lucene.Net.Analysis.Ja.Dict
targetMapOffsets[sourceId] = ofs;
sourceId++;
}
- accum += (int)((uint)val) >> 1;
+ accum += val.TripleShift(1);
targetMap[ofs] = accum;
}
if (sourceId + 1 != targetMapOffsets.Length)
@@ -222,12 +223,12 @@ namespace Lucene.Net.Analysis.Ja.Dict
public virtual int GetLeftId(int wordId)
{
- return (short)((ushort)buffer.GetInt16(wordId)) >> 3;
+ return buffer.GetInt16(wordId).TripleShift(3);
}
public virtual int GetRightId(int wordId)
{
- return (short)((ushort)buffer.GetInt16(wordId)) >> 3;
+ return buffer.GetInt16(wordId).TripleShift(3);
}
public virtual int GetWordCost(int wordId)
@@ -241,7 +242,7 @@ namespace Lucene.Net.Analysis.Ja.Dict
{
int offset = BaseFormOffset(wordId);
int data = buffer.Get(offset++) & 0xff;
- int prefix = (int)((uint)data) >> 4;
+ int prefix = data.TripleShift(4);
int suffix = data & 0xF;
char[] text = new char[prefix + suffix];
System.Array.Copy(surfaceForm, off, text, 0, prefix);
@@ -263,7 +264,7 @@ namespace Lucene.Net.Analysis.Ja.Dict
{
int offset = ReadingOffset(wordId);
int readingData = buffer.Get(offset++) & 0xff;
- return ReadString(offset, (int)((uint)readingData) >> 1, (readingData & 1) == 1);
+ return ReadString(offset, readingData.TripleShift(1), (readingData & 1) == 1);
}
else
{
@@ -296,7 +297,7 @@ namespace Lucene.Net.Analysis.Ja.Dict
{
int offset = PronunciationOffset(wordId);
int pronunciationData = buffer.Get(offset++) & 0xff;
- return ReadString(offset, (int)((uint)pronunciationData) >> 1, (pronunciationData & 1) == 1);
+ return ReadString(offset, pronunciationData.TripleShift(1), (pronunciationData & 1) == 1);
}
else
{
@@ -346,7 +347,7 @@ namespace Lucene.Net.Analysis.Ja.Dict
}
else
{
- readingLength = (int)((uint)readingData) >> 1;
+ readingLength = readingData.TripleShift(1);
}
return offset + readingLength;
}
diff --git a/src/Lucene.Net.Analysis.Kuromoji/Dict/ConnectionCosts.cs b/src/Lucene.Net.Analysis.Kuromoji/Dict/ConnectionCosts.cs
index 2d41024..3845a77 100644
--- a/src/Lucene.Net.Analysis.Kuromoji/Dict/ConnectionCosts.cs
+++ b/src/Lucene.Net.Analysis.Kuromoji/Dict/ConnectionCosts.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Codecs;
+using J2N.Numerics;
+using Lucene.Net.Codecs;
using Lucene.Net.Store;
using Lucene.Net.Support;
using System;
@@ -52,7 +53,7 @@ namespace Lucene.Net.Analysis.Ja.Dict
for (int i = 0; i < a.Length; i++)
{
int raw = @in.ReadVInt32();
- accum += ((int)((uint)raw) >> 1) ^ -(raw & 1);
+ accum += raw.TripleShift(1) ^ -(raw & 1);
a[i] = (short)accum;
}
}
diff --git a/src/Lucene.Net.Analysis.SmartCn/Hhmm/PathNode.cs b/src/Lucene.Net.Analysis.SmartCn/Hhmm/PathNode.cs
index cda6cac..6b60c1b 100644
--- a/src/Lucene.Net.Analysis.SmartCn/Hhmm/PathNode.cs
+++ b/src/Lucene.Net.Analysis.SmartCn/Hhmm/PathNode.cs
@@ -1,4 +1,5 @@
// lucene version compatibility level: 4.8.1
+using J2N.Numerics;
using System;
namespace Lucene.Net.Analysis.Cn.Smart.Hhmm
@@ -53,7 +54,7 @@ namespace Lucene.Net.Analysis.Cn.Smart.Hhmm
result = prime * result + PreNode;
long temp;
temp = J2N.BitConversion.DoubleToInt64Bits(Weight);
- result = prime * result + (int)(temp ^ (int)((uint)temp >> 32));
+ result = prime * result + (int)(temp ^ temp.TripleShift(32));
return result;
}
diff --git a/src/Lucene.Net.Analysis.SmartCn/Hhmm/SegTokenPair.cs b/src/Lucene.Net.Analysis.SmartCn/Hhmm/SegTokenPair.cs
index d554b41..8a6ebdd 100644
--- a/src/Lucene.Net.Analysis.SmartCn/Hhmm/SegTokenPair.cs
+++ b/src/Lucene.Net.Analysis.SmartCn/Hhmm/SegTokenPair.cs
@@ -1,4 +1,5 @@
// lucene version compatibility level: 4.8.1
+using J2N.Numerics;
using Lucene.Net.Support;
namespace Lucene.Net.Analysis.Cn.Smart.Hhmm
@@ -65,7 +66,7 @@ namespace Lucene.Net.Analysis.Cn.Smart.Hhmm
result = prime * result + To;
long temp;
temp = J2N.BitConversion.DoubleToInt64Bits(Weight);
- result = prime * result + (int)(temp ^ (int)((uint)temp >> 32));
+ result = prime * result + (int)(temp ^ temp.TripleShift(32));
return result;
}
diff --git a/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexReader.cs b/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexReader.cs
index 4e36e23..361f11e 100644
--- a/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexReader.cs
+++ b/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexReader.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Index;
using Lucene.Net.Store;
@@ -195,7 +196,7 @@ namespace Lucene.Net.Codecs.BlockTerms
while (hi >= lo)
{
- int mid = (int)(((uint)(lo + hi)) >> 1);
+ int mid = (lo + hi).TripleShift(1);
long offset2 = fieldIndex.termOffsets.Get(mid);
int length2 = (int)(fieldIndex.termOffsets.Get(1 + mid) - offset2);
diff --git a/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexInput.cs b/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexInput.cs
index 357ef3d..ab70dc0 100644
--- a/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexInput.cs
+++ b/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexInput.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Codecs.Sep;
+using J2N.Numerics;
+using Lucene.Net.Codecs.Sep;
using Lucene.Net.Diagnostics;
using Lucene.Net.Store;
using System.Diagnostics;
@@ -164,12 +165,12 @@ namespace Lucene.Net.Codecs.IntBlock
if ((uptoDelta & 1) == 1)
{
// same block
- upto += (int)((uint)uptoDelta >> 1);
+ upto += uptoDelta.TripleShift(1);
}
else
{
// new block
- upto = (int)((uint)uptoDelta >> 1);
+ upto = uptoDelta.TripleShift(1);
fp += indexIn.ReadVInt64();
}
}
diff --git a/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexInput.cs b/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexInput.cs
index 23b3770..af67ee5 100644
--- a/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexInput.cs
+++ b/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexInput.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Codecs.Sep;
+using J2N.Numerics;
+using Lucene.Net.Codecs.Sep;
using Lucene.Net.Diagnostics;
using Lucene.Net.Store;
using Lucene.Net.Support;
@@ -193,12 +194,12 @@ namespace Lucene.Net.Codecs.IntBlock
if ((uptoDelta & 1) == 1)
{
// same block
- upto += (int)((uint)uptoDelta >> 1);
+ upto += uptoDelta.TripleShift(1);
}
else
{
// new block
- upto = (int)((uint)uptoDelta >> 1);
+ upto = uptoDelta.TripleShift(1);
fp += indexIn.ReadVInt64();
}
}
diff --git a/src/Lucene.Net.Codecs/Memory/DirectPostingsFormat.cs b/src/Lucene.Net.Codecs/Memory/DirectPostingsFormat.cs
index c31aa8e..3402074 100644
--- a/src/Lucene.Net.Codecs/Memory/DirectPostingsFormat.cs
+++ b/src/Lucene.Net.Codecs/Memory/DirectPostingsFormat.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Diagnostics;
+using J2N.Numerics;
+using Lucene.Net.Diagnostics;
using Lucene.Net.Index;
using Lucene.Net.Support;
using System;
@@ -903,7 +904,7 @@ namespace Lucene.Net.Codecs.Memory
while (low <= high)
{
- int mid = (int) ((uint) (low + high) >> 1);
+ int mid = (low + high).TripleShift(1);
int cmp = outerInstance.Compare(mid, term);
if (cmp < 0)
{
@@ -1479,7 +1480,7 @@ namespace Lucene.Net.Codecs.Memory
skipUpto = 0;
goto nextTermContinue;
}
- int mid = (int)((uint)(low + high) >> 1);
+ int mid = (low + high).TripleShift(1);
int cmp = (outerInstance.termBytes[outerInstance.termOffsets[mid] + stateUpto] & 0xFF) -
targetLabel;
// if (DEBUG) {
@@ -2336,7 +2337,7 @@ namespace Lucene.Net.Codecs.Memory
break;
}
- int mid = (int) ((uint) (low + high) >> 1);
+ int mid = (low + high).TripleShift(1);
int cmp = docIDs[mid] - target;
//System.out.println(" bsearch low=" + low + " high=" + high+ ": docIDs[" + mid + "]=" + docIDs[mid]);
@@ -2542,7 +2543,7 @@ namespace Lucene.Net.Codecs.Memory
break;
}
- int mid = (int) ((uint) (low + high) >> 1);
+ int mid = (low + high).TripleShift(1);
int cmp = docIDs[mid] - target;
//System.out.println(" bsearch low=" + low + " high=" + high+ ": docIDs[" + mid + "]=" + docIDs[mid]);
diff --git a/src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs b/src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs
index b7b19d3..e361514 100644
--- a/src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs
+++ b/src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Diagnostics;
+using J2N.Numerics;
+using Lucene.Net.Diagnostics;
using Lucene.Net.Index;
using Lucene.Net.Store;
using Lucene.Net.Support;
@@ -366,7 +367,7 @@ namespace Lucene.Net.Codecs.Memory
int code = statsReader.ReadVInt32();
if (outerInstance.HasFreqs)
{
- docFreq[i] = ((int)((uint)code >> 1));
+ docFreq[i] = code.TripleShift(1);
if ((code & 1) == 1)
{
totalTermFreq[i] = docFreq[i];
diff --git a/src/Lucene.Net.Codecs/Memory/FSTTermOutputs.cs b/src/Lucene.Net.Codecs/Memory/FSTTermOutputs.cs
index f072365..570858a 100644
--- a/src/Lucene.Net.Codecs/Memory/FSTTermOutputs.cs
+++ b/src/Lucene.Net.Codecs/Memory/FSTTermOutputs.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Diagnostics;
+using J2N.Numerics;
+using Lucene.Net.Diagnostics;
using Lucene.Net.Support;
using System.Diagnostics;
@@ -309,7 +310,7 @@ namespace Lucene.Net.Codecs.Memory
int bit0 = bits & 1;
int bit1 = bits & 2;
int bit2 = bits & 4;
- var bytesSize = ((int) ((uint) bits >> 3));
+ var bytesSize = bits.TripleShift(3);
if (bit1 > 0 && bytesSize == 0) // determine extra length
{
bytesSize = input.ReadVInt32();
@@ -331,7 +332,7 @@ namespace Lucene.Net.Codecs.Memory
int code = input.ReadVInt32();
if (_hasPos)
{
- totalTermFreq = docFreq = (int) ((uint) code >> 1);
+ totalTermFreq = docFreq = code.TripleShift(1);
if ((code & 1) == 0)
{
totalTermFreq += input.ReadVInt64();
diff --git a/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs b/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs
index a53cfb4..d5758fb 100644
--- a/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs
+++ b/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Diagnostics;
+using J2N.Numerics;
+using Lucene.Net.Diagnostics;
using Lucene.Net.Index;
using Lucene.Net.Util.Fst;
using System;
@@ -438,7 +439,7 @@ namespace Lucene.Net.Codecs.Memory
else
{
int code = @in.ReadVInt32();
- accum += (int)((uint)code >> 1);
+ accum += code.TripleShift(1);
//System.out.println(" docID=" + accum + " code=" + code);
if ((code & 1) != 0)
{
@@ -599,7 +600,7 @@ namespace Lucene.Net.Codecs.Memory
docUpto++;
int code = @in.ReadVInt32();
- accum += (int)((uint)code >> 1);
+ accum += code.TripleShift(1);
if ((code & 1) != 0)
{
freq = 1;
@@ -665,7 +666,7 @@ namespace Lucene.Net.Codecs.Memory
else
{
int code = @in.ReadVInt32();
- pos += (int)((uint)code >> 1);
+ pos += code.TripleShift(1);
if ((code & 1) != 0)
{
payloadLength = @in.ReadVInt32();
@@ -683,7 +684,7 @@ namespace Lucene.Net.Codecs.Memory
// new offset length
offsetLength = @in.ReadVInt32();
}
- startOffset += (int)((uint)offsetCode >> 1);
+ startOffset += offsetCode.TripleShift(1);
}
if (storePayloads)
diff --git a/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsReader.cs b/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsReader.cs
index 7c46920..dc1e2b3 100644
--- a/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsReader.cs
+++ b/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsReader.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using J2N.Runtime.CompilerServices;
using Lucene.Net.Diagnostics;
using Lucene.Net.Index;
@@ -380,7 +381,7 @@ namespace Lucene.Net.Codecs.Pulsing
}
else
{
- _accum += (int)((uint)code >> 1); ; // shift off low bit
+ _accum += code.TripleShift(1); ; // shift off low bit
_freq = (code & 1) != 0 ? 1 : _postings.ReadVInt32();
// LUCENENET specific - to avoid boxing, changed from CompareTo() to IndexOptionsComparer.Compare()
@@ -519,7 +520,7 @@ namespace Lucene.Net.Codecs.Pulsing
}
var code = _postings.ReadVInt32();
- _accum += (int)((uint)code >> 1); // shift off low bit
+ _accum += code.TripleShift(1); // shift off low bit
_freq = (code & 1) != 0 ? 1 : _postings.ReadVInt32();
_posPending = _freq;
_startOffset = _storeOffsets ? 0 : -1; // always return -1 if no offsets are stored
@@ -557,7 +558,7 @@ namespace Lucene.Net.Codecs.Pulsing
{
_payloadLength = _postings.ReadVInt32();
}
- _position += (int)((uint)code >> 1);
+ _position += code.TripleShift(1);
_payloadRetrieved = false;
}
else
@@ -573,7 +574,7 @@ namespace Lucene.Net.Codecs.Pulsing
// new offset length
_offsetLength = _postings.ReadVInt32();
}
- _startOffset += (int)((uint)offsetCode >> 1);
+ _startOffset += offsetCode.TripleShift(1);
}
return _position;
diff --git a/src/Lucene.Net.Codecs/Sep/SepPostingsReader.cs b/src/Lucene.Net.Codecs/Sep/SepPostingsReader.cs
index c87d3c3..3c525bf 100644
--- a/src/Lucene.Net.Codecs/Sep/SepPostingsReader.cs
+++ b/src/Lucene.Net.Codecs/Sep/SepPostingsReader.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Diagnostics;
+using J2N.Numerics;
+using Lucene.Net.Diagnostics;
using Lucene.Net.Index;
using Lucene.Net.Store;
using Lucene.Net.Util;
@@ -691,7 +692,7 @@ namespace Lucene.Net.Codecs.Sep
payloadLength = posReader.Next();
if (Debugging.AssertsEnabled) Debugging.Assert(payloadLength >= 0);
}
- position += (int)(((uint)code) >> 1);
+ position += code.TripleShift(1);
pendingPayloadBytes += payloadLength;
payloadPending = payloadLength > 0;
}
diff --git a/src/Lucene.Net.Codecs/Sep/SepSkipListReader.cs b/src/Lucene.Net.Codecs/Sep/SepSkipListReader.cs
index 3f38673..2c9bedf 100644
--- a/src/Lucene.Net.Codecs/Sep/SepSkipListReader.cs
+++ b/src/Lucene.Net.Codecs/Sep/SepSkipListReader.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Diagnostics;
+using J2N.Numerics;
+using Lucene.Net.Diagnostics;
using Lucene.Net.Index;
using Lucene.Net.Store;
using Lucene.Net.Support;
@@ -209,7 +210,7 @@ namespace Lucene.Net.Codecs.Sep
payloadLength[level] = skipStream.ReadVInt32();
}
//delta >>>= 1;
- delta = (int)((uint)delta >> 1);
+ delta = delta.TripleShift(1);
}
else
{
diff --git a/src/Lucene.Net.Facet/RandomSamplingFacetsCollector.cs b/src/Lucene.Net.Facet/RandomSamplingFacetsCollector.cs
index 418c83e..06667da 100644
--- a/src/Lucene.Net.Facet/RandomSamplingFacetsCollector.cs
+++ b/src/Lucene.Net.Facet/RandomSamplingFacetsCollector.cs
@@ -1,4 +1,5 @@
// Lucene version compatibility level 4.8.1
+using J2N.Numerics;
using System;
using System.Collections.Generic;
using System.IO;
@@ -71,7 +72,7 @@ namespace Lucene.Net.Facet
public virtual long RandomInt64()
{
x ^= (x << 21);
- x ^= ((long)((ulong)x >> 35));
+ x ^= (x.TripleShift(35));
x ^= (x << 4);
return x;
}
diff --git a/src/Lucene.Net.Facet/Range/LongRangeCounter.cs b/src/Lucene.Net.Facet/Range/LongRangeCounter.cs
index 63a40a7..2495c85 100644
--- a/src/Lucene.Net.Facet/Range/LongRangeCounter.cs
+++ b/src/Lucene.Net.Facet/Range/LongRangeCounter.cs
@@ -1,4 +1,5 @@
// Lucene version compatibility level 4.8.1
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using System.Collections.Generic;
using System.Text;
@@ -178,7 +179,7 @@ namespace Lucene.Net.Facet.Range
int hi = boundaries.Length - 1;
while (true)
{
- int mid = (int)((uint)(lo + hi) >> 1);
+ int mid = (lo + hi).TripleShift(1);
//System.out.println(" cycle lo=" + lo + " hi=" + hi + " mid=" + mid + " boundary=" + boundaries[mid] + " to " + boundaries[mid+1]);
if (v <= boundaries[mid])
{
@@ -261,7 +262,7 @@ namespace Lucene.Net.Facet.Range
}
else
{
- int mid = (int)((uint)(start + end) >> 1);
+ int mid = (start + end).TripleShift(1);
Int64RangeNode left = Split(start, mid, elementaryIntervals);
Int64RangeNode right = Split(mid, end, elementaryIntervals);
return new Int64RangeNode(left.start, right.end, left, right, -1);
diff --git a/src/Lucene.Net.Facet/Taxonomy/WriterCache/CompactLabelToOrdinal.cs b/src/Lucene.Net.Facet/Taxonomy/WriterCache/CompactLabelToOrdinal.cs
index 685c86d..4b766e9 100644
--- a/src/Lucene.Net.Facet/Taxonomy/WriterCache/CompactLabelToOrdinal.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/WriterCache/CompactLabelToOrdinal.cs
@@ -1,4 +1,5 @@
// Lucene version compatibility level 4.8.1
+using J2N.Numerics;
using System;
using System.IO;
using System.Runtime.Serialization;
@@ -312,10 +313,8 @@ namespace Lucene.Net.Facet.Taxonomy.WriterCache
{
int hash = label.GetHashCode();
-#pragma warning disable IDE0054 // Use compound assignment
- hash = hash ^ (((int)((uint)hash >> 20)) ^ ((int)((uint)hash >> 12)));
- hash = hash ^ ((int)((uint)hash >> 7)) ^ ((int)((uint)hash >> 4));
-#pragma warning restore IDE0054 // Use compound assignment
+ hash = hash ^ hash.TripleShift(20) ^ hash.TripleShift(12);
+ hash = hash ^ hash.TripleShift(7) ^ hash.TripleShift(4);
return hash;
@@ -324,10 +323,8 @@ namespace Lucene.Net.Facet.Taxonomy.WriterCache
internal static int StringHashCode(CharBlockArray labelRepository, int offset)
{
int hash = CategoryPathUtils.HashCodeOfSerialized(labelRepository, offset);
-#pragma warning disable IDE0054 // Use compound assignment
- hash = hash ^ (((int)((uint)hash >> 20)) ^ ((int)((uint)hash >> 12)));
- hash = hash ^ ((int)((uint)hash >> 7)) ^ ((int)((uint)hash >> 4));
-#pragma warning restore IDE0054 // Use compound assignment
+ hash = hash ^ hash.TripleShift(20) ^ hash.TripleShift(12);
+ hash = hash ^ hash.TripleShift(7) ^ hash.TripleShift(4);
return hash;
}
@@ -450,8 +447,8 @@ namespace Lucene.Net.Facet.Taxonomy.WriterCache
}
// Now that we've hashed the components of the label, do the
// final part of the hash algorithm.
- hash = hash ^ (((int)((uint)hash >> 20)) ^ ((int)((uint)hash >> 12)));
- hash = hash ^ ((int)((uint)hash >> 7)) ^ ((int)((uint)hash >> 4));
+ hash = hash ^ hash.TripleShift(20) ^ hash.TripleShift(12);
+ hash = hash ^ hash.TripleShift(7) ^ hash.TripleShift(4);
// Add the label, and let's keep going
l2o.AddLabelOffset(hash, cid, lastStartOffset);
cid++;
diff --git a/src/Lucene.Net.Highlighter/Highlight/SimpleSpanFragmenter.cs b/src/Lucene.Net.Highlighter/Highlight/SimpleSpanFragmenter.cs
index c8b460b..d93530f 100644
--- a/src/Lucene.Net.Highlighter/Highlight/SimpleSpanFragmenter.cs
+++ b/src/Lucene.Net.Highlighter/Highlight/SimpleSpanFragmenter.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Analysis;
+using J2N.Numerics;
+using Lucene.Net.Analysis;
using Lucene.Net.Analysis.TokenAttributes;
using System.Collections.Generic;
@@ -83,7 +84,7 @@ namespace Lucene.Net.Search.Highlight
}
bool isNewFrag = offsetAtt.EndOffset >= (fragmentSize * currentNumFrags)
- && (textSize - offsetAtt.EndOffset) >= (int)((uint)fragmentSize >> 1);
+ && (textSize - offsetAtt.EndOffset) >= fragmentSize.TripleShift(1);
if (isNewFrag)
diff --git a/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs b/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs
index c418ea2..a05ac8c 100644
--- a/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs
+++ b/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs
@@ -1,4 +1,5 @@
-using J2N.Collections.Generic.Extensions;
+using J2N.Collections.Generic.Extensions;
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Search;
using Lucene.Net.Search.Similarities;
@@ -235,7 +236,7 @@ namespace Lucene.Net.Index.Memory
int mid; // LUCENENET: IDE0059: Remove unnecessary value assignment
while (low <= high)
{
- mid = (int)((uint)(low + high) >> 1);
+ mid = (low + high).TripleShift(1);
hash.Get(ords[mid], bytesRef);
int cmp = comparer.Compare(bytesRef, b);
if (cmp < 0)
diff --git a/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs b/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs
index 4bfefda..2be2a78 100644
--- a/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs
+++ b/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Diagnostics;
+using J2N.Numerics;
+using Lucene.Net.Diagnostics;
using Lucene.Net.Search;
using Lucene.Net.Store;
using Lucene.Net.Support;
@@ -709,7 +710,7 @@ namespace Lucene.Net.Index.Sorter
public override int NextPosition()
{
int token = postingInput.ReadVInt32();
- pos += (int)((uint)token >> 1);
+ pos += token.TripleShift(1);
if (storeOffsets)
{
startOffset = endOffset + postingInput.ReadVInt32();
diff --git a/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs b/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs
index 23fb938..75f9cd6 100644
--- a/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs
+++ b/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Diagnostics;
+using J2N.Numerics;
+using Lucene.Net.Diagnostics;
using Lucene.Net.Store;
using System;
using System.Runtime.CompilerServices;
@@ -95,7 +96,7 @@ namespace Lucene.Net.Util.Fst
public override int GetHashCode()
{
- return (int)((first ^ ((long)((ulong)first >> 32))) ^ (second ^ (second >> 32)));
+ return (int)((first ^ (first.TripleShift(32))) ^ (second ^ (second >> 32)));
}
}
@@ -239,7 +240,7 @@ namespace Lucene.Net.Util.Fst
if ((code & 1) == 0)
{
// single long
- long v = (long)((ulong)code >> 1);
+ long v = code.TripleShift(1);
if (v == 0)
{
return NO_OUTPUT;
@@ -252,7 +253,7 @@ namespace Lucene.Net.Util.Fst
else
{
// two longs
- long first = (long)((ulong)code >> 1);
+ long first = code.TripleShift(1);
long second = @in.ReadVInt64();
return new TwoInt64s(first, second);
}
diff --git a/src/Lucene.Net.Queries/Function/BoostedQuery.cs b/src/Lucene.Net.Queries/Function/BoostedQuery.cs
index db79ea9..844d02d 100644
--- a/src/Lucene.Net.Queries/Function/BoostedQuery.cs
+++ b/src/Lucene.Net.Queries/Function/BoostedQuery.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Index;
+using J2N.Numerics;
+using Lucene.Net.Index;
using Lucene.Net.Search;
using Lucene.Net.Util;
using System.Collections;
@@ -216,9 +217,9 @@ namespace Lucene.Net.Queries.Function
public override int GetHashCode()
{
int h = q.GetHashCode();
- h ^= (h << 17) | ((int)((uint)h >> 16));
+ h ^= (h << 17) | (h.TripleShift(16));
h += boostVal.GetHashCode();
- h ^= (h << 8) | ((int)((uint)h >> 25));
+ h ^= (h << 8) | (h.TripleShift(25));
h += J2N.BitConversion.SingleToInt32Bits(Boost);
return h;
}
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/DoubleConstValueSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/DoubleConstValueSource.cs
index 9353af8..3b9cdb1 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/DoubleConstValueSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/DoubleConstValueSource.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Index;
+using J2N.Numerics;
+using Lucene.Net.Index;
using Lucene.Net.Queries.Function.DocValues;
using System;
using System.Collections;
@@ -107,7 +108,7 @@ namespace Lucene.Net.Queries.Function.ValueSources
public override int GetHashCode()
{
long bits = J2N.BitConversion.DoubleToRawInt64Bits(constant);
- return (int)(bits ^ ((long)((ulong)bits >> 32)));
+ return (int)(bits ^ (bits.TripleShift(32)));
}
public override bool Equals(object o)
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/DualFloatFunction.cs b/src/Lucene.Net.Queries/Function/ValueSources/DualFloatFunction.cs
index d46128e..e13574e 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/DualFloatFunction.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/DualFloatFunction.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Index;
+using J2N.Numerics;
+using Lucene.Net.Index;
using Lucene.Net.Queries.Function.DocValues;
using Lucene.Net.Search;
using System.Collections;
@@ -94,9 +95,9 @@ namespace Lucene.Net.Queries.Function.ValueSources
public override int GetHashCode()
{
int h = m_a.GetHashCode();
- h ^= (h << 13) | ((int)((uint)h >> 20));
+ h ^= (h << 13) | (h.TripleShift(20));
h += m_b.GetHashCode();
- h ^= (h << 23) | ((int)((uint)h >> 10));
+ h ^= (h << 23) | (h.TripleShift(10));
h += Name.GetHashCode();
return h;
}
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/LinearFloatFunction.cs b/src/Lucene.Net.Queries/Function/ValueSources/LinearFloatFunction.cs
index 64ff15a..cc092fc 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/LinearFloatFunction.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/LinearFloatFunction.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Index;
+using J2N.Numerics;
+using Lucene.Net.Index;
using Lucene.Net.Queries.Function.DocValues;
using Lucene.Net.Search;
using System.Collections;
@@ -93,9 +94,9 @@ namespace Lucene.Net.Queries.Function.ValueSources
public override int GetHashCode()
{
int h = J2N.BitConversion.SingleToInt32Bits(m_slope);
- h = ((int)((uint)h >> 2)) | (h << 30);
+ h = (h.TripleShift(2)) | (h << 30);
h += J2N.BitConversion.SingleToInt32Bits(m_intercept);
- h ^= (h << 14) | ((int)((uint)h >> 19));
+ h ^= (h << 14) | (h.TripleShift(19));
return h + m_source.GetHashCode();
}
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/RangeMapFloatFunction.cs b/src/Lucene.Net.Queries/Function/ValueSources/RangeMapFloatFunction.cs
index ccc7fd1..e38bd56 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/RangeMapFloatFunction.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/RangeMapFloatFunction.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Index;
+using J2N.Numerics;
+using Lucene.Net.Index;
using Lucene.Net.Queries.Function.DocValues;
using Lucene.Net.Search;
using System.Collections;
@@ -104,9 +105,9 @@ namespace Lucene.Net.Queries.Function.ValueSources
public override int GetHashCode()
{
int h = m_source.GetHashCode();
- h ^= (h << 10) | ((int)((uint)h >> 23));
+ h ^= (h << 10) | (h.TripleShift(23));
h += J2N.BitConversion.SingleToInt32Bits(m_min);
- h ^= (h << 14) | ((int)((uint)h >> 19));
+ h ^= (h << 14) | (h.TripleShift(19));
h += J2N.BitConversion.SingleToInt32Bits(m_max);
h += m_target.GetHashCode();
if (m_defaultVal != null)
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/ReciprocalFloatFunction.cs b/src/Lucene.Net.Queries/Function/ValueSources/ReciprocalFloatFunction.cs
index 6d16c43..62aac92 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/ReciprocalFloatFunction.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/ReciprocalFloatFunction.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Index;
+using J2N.Numerics;
+using Lucene.Net.Index;
using Lucene.Net.Queries.Function.DocValues;
using Lucene.Net.Search;
using System;
@@ -110,7 +111,7 @@ namespace Lucene.Net.Queries.Function.ValueSources
public override int GetHashCode()
{
int h = J2N.BitConversion.SingleToInt32Bits(m_a) + J2N.BitConversion.SingleToInt32Bits(m_m);
- h ^= (h << 13) | ((int)((uint)h >> 20));
+ h ^= (h << 13) | (h.TripleShift(20));
return h + (J2N.BitConversion.SingleToInt32Bits(m_b)) + m_source.GetHashCode();
}
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/EscapeQuerySyntaxImpl.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/EscapeQuerySyntaxImpl.cs
index 9d084db..544abe1 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/EscapeQuerySyntaxImpl.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/EscapeQuerySyntaxImpl.cs
@@ -1,4 +1,5 @@
-using J2N.Text;
+using J2N.Numerics;
+using J2N.Text;
using Lucene.Net.QueryParsers.Flexible.Core.Messages;
using Lucene.Net.QueryParsers.Flexible.Core.Parser;
using Lucene.Net.QueryParsers.Flexible.Core.Util;
@@ -275,7 +276,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
if (codePointMultiplier > 0)
{
codePoint += HexToInt32(curChar) * codePointMultiplier;
- codePointMultiplier = (int)((uint)codePointMultiplier >> 4);
+ codePointMultiplier = codePointMultiplier.TripleShift(4);
if (codePointMultiplier == 0)
{
output[length++] = (char)codePoint;
diff --git a/src/Lucene.Net.Replicator/RevisionFile.cs b/src/Lucene.Net.Replicator/RevisionFile.cs
index 4d5c563..ab5371d 100644
--- a/src/Lucene.Net.Replicator/RevisionFile.cs
+++ b/src/Lucene.Net.Replicator/RevisionFile.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using System;
namespace Lucene.Net.Replicator
@@ -69,7 +70,7 @@ namespace Lucene.Net.Replicator
public override int GetHashCode()
{
- return FileName.GetHashCode() ^ (int)(Length ^ (long)((ulong)Length >> 32));
+ return FileName.GetHashCode() ^ (int)(Length ^ Length.TripleShift(32));
}
public override string ToString()
diff --git a/src/Lucene.Net.Sandbox/Queries/SortedSetSortField.cs b/src/Lucene.Net.Sandbox/Queries/SortedSetSortField.cs
index 38a5123..79b814c 100644
--- a/src/Lucene.Net.Sandbox/Queries/SortedSetSortField.cs
+++ b/src/Lucene.Net.Sandbox/Queries/SortedSetSortField.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Diagnostics;
+using J2N.Numerics;
+using Lucene.Net.Diagnostics;
using Lucene.Net.Index;
using Lucene.Net.Search;
using Lucene.Net.Util;
@@ -287,7 +288,7 @@ namespace Lucene.Net.Sandbox.Queries
}
else
{
- return (int)@in.OrdAt((int)((uint)(count - 1)) >> 1);
+ return (int)@in.OrdAt((count - 1).TripleShift(1));
}
}
@@ -324,7 +325,7 @@ namespace Lucene.Net.Sandbox.Queries
}
else
{
- return (int)@in.OrdAt((int)((uint)count >> 1));
+ return (int)@in.OrdAt(count.TripleShift(1));
}
}
diff --git a/src/Lucene.Net.Spatial/Util/DistanceToShapeValueSource.cs b/src/Lucene.Net.Spatial/Util/DistanceToShapeValueSource.cs
index caf3a38..247e657 100644
--- a/src/Lucene.Net.Spatial/Util/DistanceToShapeValueSource.cs
+++ b/src/Lucene.Net.Spatial/Util/DistanceToShapeValueSource.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Index;
+using J2N.Numerics;
+using Lucene.Net.Index;
using Lucene.Net.Queries.Function;
using Lucene.Net.Queries.Function.DocValues;
using Lucene.Net.Search;
@@ -122,7 +123,7 @@ namespace Lucene.Net.Spatial.Util
result = shapeValueSource.GetHashCode();
result = 31 * result + queryPoint.GetHashCode();
temp = J2N.BitConversion.DoubleToInt64Bits(multiplier);
- result = 31 * result + (int)(temp ^ ((long)((ulong)temp) >> 32));
+ result = 31 * result + (int)(temp ^ (temp.TripleShift(32)));
return result;
}
}
diff --git a/src/Lucene.Net.Tests/Codecs/Compressing/AbstractTestLZ4CompressionMode.cs b/src/Lucene.Net.Tests/Codecs/Compressing/AbstractTestLZ4CompressionMode.cs
index 0a7d861..50eb109 100644
--- a/src/Lucene.Net.Tests/Codecs/Compressing/AbstractTestLZ4CompressionMode.cs
+++ b/src/Lucene.Net.Tests/Codecs/Compressing/AbstractTestLZ4CompressionMode.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using J2N.Text;
using Lucene.Net.Randomized.Generators;
using NUnit.Framework;
@@ -35,7 +36,7 @@ namespace Lucene.Net.Codecs.Compressing
for (; ; )
{
int token = compressed[off++] & 0xFF;
- int literalLen = (int)((uint)token >> 4);
+ int literalLen = token.TripleShift(4);
if (literalLen == 0x0F)
{
while (compressed[off] == 0xFF)
@@ -79,7 +80,7 @@ namespace Lucene.Net.Codecs.Compressing
if (decompressedOff + matchLen < decompressed.Length - LZ4.LAST_LITERALS)
{
bool moreCommonBytes = decompressed[decompressedOff + matchLen] == decompressed[decompressedOff - matchDec + matchLen];
- bool nextSequenceHasLiterals = ((int)((uint)(compressed[off] & 0xFF) >> 4)) != 0;
+ bool nextSequenceHasLiterals = (compressed[off] & 0xFF).TripleShift(4) != 0;
Assert.IsTrue(!moreCommonBytes || !nextSequenceHasLiterals);
}
diff --git a/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility.cs b/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility.cs
index eb895bd..d37a8f2 100644
--- a/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility.cs
+++ b/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility.cs
@@ -1,5 +1,6 @@
-using J2N;
+using J2N;
using J2N.Collections.Generic.Extensions;
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Index.Extensions;
using NUnit.Framework;
@@ -504,7 +505,7 @@ namespace Lucene.Net.Index
int id = Convert.ToInt32(reader.Document(i).Get("id"));
Assert.AreEqual(id, dvByte.Get(i));
- sbyte[] bytes = new sbyte[] { (sbyte)((int)((uint)id >> 24)), (sbyte)((int)((uint)id >> 16)), (sbyte)((int)((uint)id >> 8)), (sbyte)id };
+ sbyte[] bytes = new sbyte[] { (sbyte)(id.TripleShift(24)), (sbyte)(id.TripleShift(16)), (sbyte)(id.TripleShift(8)), (sbyte)id };
BytesRef expectedRef = new BytesRef((byte[])(Array)bytes);
BytesRef scratch = new BytesRef();
@@ -710,7 +711,7 @@ namespace Lucene.Net.Index
doc.Add(new Int64Field("trieLong", (long)id, Field.Store.NO));
// add docvalues fields
doc.Add(new NumericDocValuesField("dvByte", (sbyte)id));
- sbyte[] bytes = new sbyte[] { (sbyte)((int)((uint)id >> 24)), (sbyte)((int)((uint)id >> 16)), (sbyte)((int)((uint)id >> 8)), (sbyte)id };
+ sbyte[] bytes = new sbyte[] { (sbyte)(id.TripleShift(24)), (sbyte)(id.TripleShift(16)), (sbyte)(id.TripleShift(8)), (sbyte)id };
BytesRef @ref = new BytesRef((byte[])(Array)bytes);
doc.Add(new BinaryDocValuesField("dvBytesDerefFixed", @ref));
doc.Add(new BinaryDocValuesField("dvBytesDerefVar", @ref));
diff --git a/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility3x.cs b/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility3x.cs
index eda9e29..5a8604a 100644
--- a/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility3x.cs
+++ b/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility3x.cs
@@ -1,4 +1,5 @@
-using J2N;
+using J2N;
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Index.Extensions;
using NUnit.Framework;
@@ -473,7 +474,7 @@ namespace Lucene.Net.Index
int id = Convert.ToInt32(reader.Document(i).Get("id"));
Assert.AreEqual(id, dvByte.Get(i));
- sbyte[] bytes = new sbyte[] { (sbyte)((int)((uint)id >> 24)), (sbyte)((int)((uint)id >> 16)), (sbyte)((int)((uint)id >> 8)), (sbyte)id };
+ sbyte[] bytes = new sbyte[] { (sbyte)(id.TripleShift(24)), (sbyte)(id.TripleShift(16)), (sbyte)(id.TripleShift(8)), (sbyte)id };
BytesRef expectedRef = new BytesRef((byte[])(Array)bytes);
BytesRef scratch = new BytesRef();
@@ -671,7 +672,7 @@ namespace Lucene.Net.Index
doc.Add(new Int64Field("trieLong", (long)id, Field.Store.NO));
// add docvalues fields
doc.Add(new NumericDocValuesField("dvByte", (sbyte)id));
- sbyte[] bytes = new sbyte[] { (sbyte)((int)((uint)id >> 24)), (sbyte)((int)((uint)id >> 16)), (sbyte)((int)((uint)id >> 8)), (sbyte)id };
+ sbyte[] bytes = new sbyte[] { (sbyte)(id.TripleShift(24)), (sbyte)(id.TripleShift(16)), (sbyte)(id.TripleShift(8)), (sbyte)id };
BytesRef @ref = new BytesRef((byte[])(Array)bytes);
doc.Add(new BinaryDocValuesField("dvBytesDerefFixed", @ref));
doc.Add(new BinaryDocValuesField("dvBytesDerefVar", @ref));
diff --git a/src/Lucene.Net.Tests/Index/TestBinaryDocValuesUpdates.cs b/src/Lucene.Net.Tests/Index/TestBinaryDocValuesUpdates.cs
index a38cdd8..29f2f4a 100644
--- a/src/Lucene.Net.Tests/Index/TestBinaryDocValuesUpdates.cs
+++ b/src/Lucene.Net.Tests/Index/TestBinaryDocValuesUpdates.cs
@@ -1,4 +1,5 @@
-using J2N;
+using J2N;
+using J2N.Numerics;
using J2N.Threading;
using J2N.Threading.Atomic;
using Lucene.Net.Attributes;
@@ -90,7 +91,7 @@ namespace Lucene.Net.Index
while ((value & ~0x7FL) != 0L)
{
bytes.Bytes[bytes.Length++] = unchecked((byte)((value & 0x7FL) | 0x80L));
- value = (long)((ulong)value >> 7);
+ value = value.TripleShift(7);
}
bytes.Bytes[bytes.Length++] = (byte)value;
// System.err.println("[" + Thread.currentThread().getName() + "] value=" + orig + ", bytes=" + bytes);
diff --git a/src/Lucene.Net.Tests/Index/TestStressIndexing2.cs b/src/Lucene.Net.Tests/Index/TestStressIndexing2.cs
index b8dd2c2..4624df4 100644
--- a/src/Lucene.Net.Tests/Index/TestStressIndexing2.cs
+++ b/src/Lucene.Net.Tests/Index/TestStressIndexing2.cs
@@ -1,4 +1,5 @@
-using J2N.Collections.Generic.Extensions;
+using J2N.Collections.Generic.Extensions;
+using J2N.Numerics;
using J2N.Text;
using J2N.Threading;
using Lucene.Net.Analysis.TokenAttributes;
@@ -657,7 +658,7 @@ namespace Lucene.Net.Index
// now compare
for (int i = 0; i < len1; i++)
{
- Assert.AreEqual(info1[i], info2[i], "i=" + i + " len=" + len1 + " d1=" + ((long)((ulong)info1[i] >> 32)) + " f1=" + (info1[i] & int.MaxValue) + " d2=" + ((long)((ulong)info2[i] >> 32)) + " f2=" + (info2[i] & int.MaxValue) + " field=" + field1 + " term=" + term1.Utf8ToString());
+ Assert.AreEqual(info1[i], info2[i], "i=" + i + " len=" + len1 + " d1=" + (info1[i].TripleShift(32)) + " f1=" + (info1[i] & int.MaxValue) + " d2=" + (info2[i].TripleShift(32)) + " f2=" + (info2[i] & int.MaxValue) + " field=" + field1 + " term=" + term1.Utf8ToString());
}
}
}
diff --git a/src/Lucene.Net.Tests/Util/Packed/TestPackedInts.cs b/src/Lucene.Net.Tests/Util/Packed/TestPackedInts.cs
index f1bfabc..99c393f 100644
--- a/src/Lucene.Net.Tests/Util/Packed/TestPackedInts.cs
+++ b/src/Lucene.Net.Tests/Util/Packed/TestPackedInts.cs
@@ -1,4 +1,5 @@
-using J2N.IO;
+using J2N.IO;
+using J2N.Numerics;
using Lucene.Net.Randomized.Generators;
using Lucene.Net.Support;
using NUnit.Framework;
@@ -1032,7 +1033,7 @@ namespace Lucene.Net.Util.Packed
{
// clear highest bits for packed
int toClear = 64 % bpv;
- blocks[i] = (int)((uint)(blocks[i] << toClear) >> toClear);
+ blocks[i] = (blocks[i] << toClear).TripleShift(toClear);
}
}
diff --git a/src/Lucene.Net.Tests/Util/TestNumericUtils.cs b/src/Lucene.Net.Tests/Util/TestNumericUtils.cs
index 27caf2b..a6663c3 100644
--- a/src/Lucene.Net.Tests/Util/TestNumericUtils.cs
+++ b/src/Lucene.Net.Tests/Util/TestNumericUtils.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using J2N.Text;
using Lucene.Net.Support;
using NUnit.Framework;
@@ -323,9 +324,9 @@ namespace Lucene.Net.Util
neededShifts.MoveNext();
Assert.AreEqual(neededShifts.Current, shift, "shift");
neededBounds.MoveNext();
- Assert.AreEqual(neededBounds.Current, (long)((ulong)min >> shift), "inner min bound");
+ Assert.AreEqual(neededBounds.Current, min.TripleShift(shift), "inner min bound");
neededBounds.MoveNext();
- Assert.AreEqual(neededBounds.Current, (long)((ulong)max >> shift), "inner max bound");
+ Assert.AreEqual(neededBounds.Current, max.TripleShift(shift), "inner max bound");
}
}
@@ -414,7 +415,7 @@ namespace Lucene.Net.Util
}
if (random.NextBoolean())
{
- val = (long)((ulong)val >> 1);
+ val = val.TripleShift(1);
}
}
@@ -516,9 +517,9 @@ namespace Lucene.Net.Util
neededShifts.MoveNext();
Assert.AreEqual(neededShifts.Current, shift, "shift");
neededBounds.MoveNext();
- Assert.AreEqual(neededBounds.Current, (int)((uint)min >> shift), "inner min bound");
+ Assert.AreEqual(neededBounds.Current, min.TripleShift(shift), "inner min bound");
neededBounds.MoveNext();
- Assert.AreEqual(neededBounds.Current, (int)((uint)max >> shift), "inner max bound");
+ Assert.AreEqual(neededBounds.Current, max.TripleShift(shift), "inner max bound");
}
}
diff --git a/src/Lucene.Net/Codecs/BlockTreeTermsReader.cs b/src/Lucene.Net/Codecs/BlockTreeTermsReader.cs
index 3d712ca..036ecc3 100644
--- a/src/Lucene.Net/Codecs/BlockTreeTermsReader.cs
+++ b/src/Lucene.Net/Codecs/BlockTreeTermsReader.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Index;
using Lucene.Net.Support;
@@ -574,7 +575,7 @@ namespace Lucene.Net.Codecs
// System.out.println("BTTR: seg=" + segment + " field=" + fieldInfo.name + " rootBlockCode=" + rootCode + " divisor=" + indexDivisor);
// }
- rootBlockFP = (int)((uint)(new ByteArrayDataInput(rootCode.Bytes, rootCode.Offset, rootCode.Length)).ReadVInt64() >> BlockTreeTermsWriter.OUTPUT_FLAGS_NUM_BITS);
+ rootBlockFP = new ByteArrayDataInput(rootCode.Bytes, rootCode.Offset, rootCode.Length).ReadVInt64().TripleShift(BlockTreeTermsWriter.OUTPUT_FLAGS_NUM_BITS);
if (indexIn != null)
{
@@ -767,7 +768,7 @@ namespace Lucene.Net.Codecs
do
{
- fp = fpOrig + ((int)((uint)floorDataReader.ReadVInt64() >> 1));
+ fp = fpOrig + (floorDataReader.ReadVInt64().TripleShift(1));
numFollowFloorBlocks--;
// if (DEBUG) System.out.println(" skip floor block2! nextFloorLabel=" + (char) nextFloorLabel + " vs target=" + (char) transitions[transitionIndex].getMin() + " newFP=" + fp + " numFollowFloorBlocks=" + numFollowFloorBlocks);
if (numFollowFloorBlocks != 0)
@@ -828,7 +829,7 @@ namespace Lucene.Net.Codecs
// Maybe skip floor blocks:
while (numFollowFloorBlocks != 0 && nextFloorLabel <= transitions[0].Min)
{
- fp = fpOrig + ((int)((uint)floorDataReader.ReadVInt64() >> 1));
+ fp = fpOrig + (floorDataReader.ReadVInt64().TripleShift(1));
numFollowFloorBlocks--;
// if (DEBUG) System.out.println(" skip floor block! nextFloorLabel=" + (char) nextFloorLabel + " vs target=" + (char) transitions[0].getMin() + " newFP=" + fp + " numFollowFloorBlocks=" + numFollowFloorBlocks);
if (numFollowFloorBlocks != 0)
@@ -846,14 +847,14 @@ namespace Lucene.Net.Codecs
outerInstance.@in.Seek(fp);
int code_ = outerInstance.@in.ReadVInt32();
- entCount = (int)((uint)code_ >> 1);
+ entCount = code_.TripleShift(1);
if (Debugging.AssertsEnabled) Debugging.Assert(entCount > 0);
isLastInFloor = (code_ & 1) != 0;
// term suffixes:
code_ = outerInstance.@in.ReadVInt32();
isLeafBlock = (code_ & 1) != 0;
- int numBytes = (int)((uint)code_ >> 1);
+ int numBytes = code_.TripleShift(1);
// if (DEBUG) System.out.println(" entCount=" + entCount + " lastInFloor?=" + isLastInFloor + " leafBlock?=" + isLeafBlock + " numSuffixBytes=" + numBytes);
if (suffixBytes.Length < numBytes)
{
@@ -922,7 +923,7 @@ namespace Lucene.Net.Codecs
if (Debugging.AssertsEnabled) Debugging.Assert(nextEnt != -1 && nextEnt < entCount, "nextEnt={0} entCount={1} fp={2}", nextEnt, entCount, fp);
nextEnt++;
int code = suffixesReader.ReadVInt32();
- suffix = (int)((uint)code >> 1);
+ suffix = code.TripleShift(1);
startBytePos = suffixesReader.Position;
suffixesReader.SkipBytes(suffix);
if ((code & 1) == 0)
@@ -1725,7 +1726,7 @@ namespace Lucene.Net.Codecs
{
scratchReader.Reset(frameData.Bytes, frameData.Offset, frameData.Length);
long code = scratchReader.ReadVInt64();
- long fpSeek = (long)((ulong)code >> BlockTreeTermsWriter.OUTPUT_FLAGS_NUM_BITS);
+ long fpSeek = code.TripleShift(BlockTreeTermsWriter.OUTPUT_FLAGS_NUM_BITS);
Frame f = GetFrame(1 + currentFrame.ord);
f.hasTerms = (code & BlockTreeTermsWriter.OUTPUT_FLAG_HAS_TERMS) != 0;
f.hasTermsOrig = f.hasTerms;
@@ -2737,7 +2738,7 @@ namespace Lucene.Net.Codecs
outerInstance.@in.Seek(fp);
int code = outerInstance.@in.ReadVInt32();
- entCount = (int)((uint)code >> 1);
+ entCount = code.TripleShift(1);
if (Debugging.AssertsEnabled) Debugging.Assert(entCount > 0);
isLastInFloor = (code & 1) != 0;
if (Debugging.AssertsEnabled) Debugging.Assert(arc == null || (isLastInFloor || isFloor));
@@ -2750,7 +2751,7 @@ namespace Lucene.Net.Codecs
// term suffixes:
code = outerInstance.@in.ReadVInt32();
isLeafBlock = (code & 1) != 0;
- int numBytes = (int)((uint)code >> 1);
+ int numBytes = code.TripleShift(1);
if (suffixBytes.Length < numBytes)
{
suffixBytes = new byte[ArrayUtil.Oversize(numBytes, 1)];
@@ -2883,7 +2884,7 @@ namespace Lucene.Net.Codecs
if (Debugging.AssertsEnabled) Debugging.Assert(nextEnt != -1 && nextEnt < entCount, "nextEnt={0} entCount={1} fp={2}", nextEnt, entCount, fp);
nextEnt++;
int code = suffixesReader.ReadVInt32();
- suffix = (int)((uint)code >> 1);
+ suffix = code.TripleShift(1);
startBytePos = suffixesReader.Position;
outerInstance.term.Length = prefix + suffix;
if (outerInstance.term.Bytes.Length < outerInstance.term.Length)
@@ -2945,7 +2946,7 @@ namespace Lucene.Net.Codecs
while (true)
{
long code = floorDataReader.ReadVInt64();
- newFP = fpOrig + ((long)((ulong)code >> 1));
+ newFP = fpOrig + (code.TripleShift(1));
hasTerms = (code & 1) != 0;
// if (DEBUG) {
// System.out.println(" label=" + toHex(nextFloorLabel) + " fp=" + newFP + " hasTerms?=" + hasTerms + " numFollowFloor=" + numFollowFloorBlocks);
@@ -3071,7 +3072,7 @@ namespace Lucene.Net.Codecs
if (Debugging.AssertsEnabled) Debugging.Assert(nextEnt < entCount);
nextEnt++;
int code = suffixesReader.ReadVInt32();
- suffixesReader.SkipBytes(isLeafBlock ? code : (int)((uint)code >> 1));
+ suffixesReader.SkipBytes(isLeafBlock ? code : code.TripleShift(1));
//if (DEBUG) System.out.println(" " + nextEnt + " (of " + entCount + ") ent isSubBlock=" + ((code&1)==1));
if ((code & 1) != 0)
{
@@ -3274,7 +3275,7 @@ namespace Lucene.Net.Codecs
nextEnt++;
int code = suffixesReader.ReadVInt32();
- suffix = (int)((uint)code >> 1);
+ suffix = code.TripleShift(1);
// if (DEBUG) {
// BytesRef suffixBytesRef = new BytesRef();
// suffixBytesRef.bytes = suffixBytes;
diff --git a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsIndexReader.cs b/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsIndexReader.cs
index 576e195..b12a6d9 100644
--- a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsIndexReader.cs
+++ b/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsIndexReader.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Support;
using System;
using System.Runtime.CompilerServices;
@@ -40,7 +41,7 @@ namespace Lucene.Net.Codecs.Compressing
{
internal static long MoveLowOrderBitToSign(long n)
{
- return (((long)((ulong)n >> 1)) ^ -(n & 1));
+ return ((n.TripleShift(1)) ^ -(n & 1));
}
internal readonly int maxDoc;
@@ -121,7 +122,7 @@ namespace Lucene.Net.Codecs.Compressing
int lo = 0, hi = docBases.Length - 1;
while (lo <= hi)
{
- int mid = (int)((uint)(lo + hi) >> 1);
+ int mid = (lo + hi).TripleShift(1);
int midValue = docBases[mid];
if (midValue == docID)
{
@@ -160,7 +161,7 @@ namespace Lucene.Net.Codecs.Compressing
int lo = 0, hi = docBasesDeltas[block].Count - 1;
while (lo <= hi)
{
- int mid = (int)((uint)(lo + hi) >> 1);
+ int mid = (lo + hi).TripleShift(1);
int midValue = RelativeDocBase(block, mid);
if (midValue == relativeDoc)
{
diff --git a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsReader.cs b/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsReader.cs
index 742169b..4ca4fda 100644
--- a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsReader.cs
+++ b/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsReader.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Codecs.Lucene40;
using Lucene.Net.Diagnostics;
using Lucene.Net.Support;
@@ -356,7 +357,7 @@ namespace Lucene.Net.Codecs.Compressing
for (int fieldIDX = 0; fieldIDX < numStoredFields; fieldIDX++)
{
long infoAndBits = documentInput.ReadVInt64();
- int fieldNumber = (int)((long)((ulong)infoAndBits >> CompressingStoredFieldsWriter.TYPE_BITS));
+ int fieldNumber = (int)infoAndBits.TripleShift(CompressingStoredFieldsWriter.TYPE_BITS);
FieldInfo fieldInfo = fieldInfos.FieldInfo(fieldNumber);
int bits = (int)(infoAndBits & CompressingStoredFieldsWriter.TYPE_MASK);
diff --git a/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsReader.cs b/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsReader.cs
index 0e4f03f..c3ccdd0 100644
--- a/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsReader.cs
+++ b/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsReader.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Index;
using Lucene.Net.Store;
@@ -224,7 +225,7 @@ namespace Lucene.Net.Codecs.Compressing
int token = vectorsStream.ReadByte() & 0xFF;
if (Debugging.AssertsEnabled) Debugging.Assert(token != 0); // means no term vectors, cannot happen since we checked for numFields == 0
int bitsPerFieldNum = token & 0x1F;
- int totalDistinctFields = (int)((uint)token >> 5);
+ int totalDistinctFields = token.TripleShift(5);
if (totalDistinctFields == 0x07)
{
totalDistinctFields += vectorsStream.ReadVInt32();
diff --git a/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsWriter.cs b/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsWriter.cs
index 3bc953f..f4b612f 100644
--- a/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsWriter.cs
+++ b/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsWriter.cs
@@ -6,6 +6,7 @@ using System.Diagnostics;
using System.Runtime.CompilerServices;
using JCG = J2N.Collections.Generic;
using ArrayUtil = Lucene.Net.Util.ArrayUtil;
+using J2N.Numerics;
namespace Lucene.Net.Codecs.Compressing
{
@@ -843,7 +844,7 @@ namespace Lucene.Net.Codecs.Compressing
{
payloadLengthsBuf[payStart + i] = 0;
}
- position += (int)((uint)code >> 1);
+ position += code.TripleShift(1);
positionsBuf[posStart + i] = position;
}
}
@@ -851,7 +852,7 @@ namespace Lucene.Net.Codecs.Compressing
{
for (int i = 0; i < numProx; ++i)
{
- position += ((int)((uint)positions.ReadVInt32() >> 1));
+ position += positions.ReadVInt32().TripleShift(1);
positionsBuf[posStart + i] = position;
}
}
diff --git a/src/Lucene.Net/Codecs/Compressing/LZ4.cs b/src/Lucene.Net/Codecs/Compressing/LZ4.cs
index 70c910d..7f213db 100644
--- a/src/Lucene.Net/Codecs/Compressing/LZ4.cs
+++ b/src/Lucene.Net/Codecs/Compressing/LZ4.cs
@@ -111,7 +111,7 @@ namespace Lucene.Net.Codecs.Compressing
{
// literals
int token = compressed.ReadByte() & 0xFF;
- int literalLen = (int)(((uint)token) >> 4);
+ int literalLen = token.TripleShift(4);
if (literalLen != 0)
{
@@ -217,7 +217,7 @@ namespace Lucene.Net.Codecs.Compressing
int matchDec = matchOff - matchRef;
if (Debugging.AssertsEnabled) Debugging.Assert(matchDec > 0 && matchDec < 1 << 16);
@out.WriteByte((byte)matchDec);
- @out.WriteByte((byte)(int)((uint)matchDec >> 8));
+ @out.WriteByte((byte)matchDec.TripleShift(8));
// encode match len
if (matchLen >= MIN_MATCH + 0x0F)
diff --git a/src/Lucene.Net/Codecs/Lucene3x/Lucene3xSkipListReader.cs b/src/Lucene.Net/Codecs/Lucene3x/Lucene3xSkipListReader.cs
index 7d37cc4..86e4d3f 100644
--- a/src/Lucene.Net/Codecs/Lucene3x/Lucene3xSkipListReader.cs
+++ b/src/Lucene.Net/Codecs/Lucene3x/Lucene3xSkipListReader.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Support;
using System;
using System.Runtime.CompilerServices;
@@ -107,7 +108,7 @@ namespace Lucene.Net.Codecs.Lucene3x
{
payloadLength[level] = skipStream.ReadVInt32();
}
- delta = (int)((uint)delta >> 1);
+ delta = delta.TripleShift(1);
}
else
{
diff --git a/src/Lucene.Net/Codecs/Lucene3x/SegmentTermDocs.cs b/src/Lucene.Net/Codecs/Lucene3x/SegmentTermDocs.cs
index a24fa90..20f4f97 100644
--- a/src/Lucene.Net/Codecs/Lucene3x/SegmentTermDocs.cs
+++ b/src/Lucene.Net/Codecs/Lucene3x/SegmentTermDocs.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using System;
using System.Diagnostics;
@@ -168,7 +169,7 @@ namespace Lucene.Net.Codecs.Lucene3x
}
else
{
- doc += (int)((uint)docCode >> 1); // shift off low bit
+ doc += docCode.TripleShift(1); // shift off low bit
if ((docCode & 1) != 0) // if low bit is set
{
freq = 1; // freq is one
@@ -207,7 +208,7 @@ namespace Lucene.Net.Codecs.Lucene3x
{
// manually inlined call to next() for speed
int docCode = m_freqStream.ReadVInt32();
- doc += (int)((uint)docCode >> 1); // shift off low bit
+ doc += docCode.TripleShift(1); // shift off low bit
if ((docCode & 1) != 0) // if low bit is set
{
freq = 1; // freq is one
diff --git a/src/Lucene.Net/Codecs/Lucene3x/SegmentTermPositions.cs b/src/Lucene.Net/Codecs/Lucene3x/SegmentTermPositions.cs
index de24367..9515d7d 100644
--- a/src/Lucene.Net/Codecs/Lucene3x/SegmentTermPositions.cs
+++ b/src/Lucene.Net/Codecs/Lucene3x/SegmentTermPositions.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Index;
using System;
@@ -115,7 +116,7 @@ namespace Lucene.Net.Codecs.Lucene3x
{
payloadLength = proxStream.ReadVInt32();
}
- delta = (int)((uint)delta >> 1);
+ delta = delta.TripleShift(1);
needToLoadPayload = true;
}
else if (delta == -1)
diff --git a/src/Lucene.Net/Codecs/Lucene3x/TermInfosReaderIndex.cs b/src/Lucene.Net/Codecs/Lucene3x/TermInfosReaderIndex.cs
index 69c15d9..e70b092 100644
--- a/src/Lucene.Net/Codecs/Lucene3x/TermInfosReaderIndex.cs
+++ b/src/Lucene.Net/Codecs/Lucene3x/TermInfosReaderIndex.cs
@@ -1,4 +1,4 @@
-using J2N.Numerics;
+using J2N.Numerics;
using J2N.Text;
using System;
using System.Collections.Generic;
@@ -174,7 +174,7 @@ namespace Lucene.Net.Codecs.Lucene3x
BytesRef scratch = new BytesRef();
while (hi >= lo)
{
- int mid = (int)((uint)(lo + hi) >> 1);
+ int mid = (lo + hi).TripleShift(1);
int delta = CompareTo(term, mid, input, scratch);
if (delta < 0)
{
diff --git a/src/Lucene.Net/Codecs/Lucene40/BitVector.cs b/src/Lucene.Net/Codecs/Lucene40/BitVector.cs
index e7ca8c1..1973cd2 100644
--- a/src/Lucene.Net/Codecs/Lucene40/BitVector.cs
+++ b/src/Lucene.Net/Codecs/Lucene40/BitVector.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Support;
using System;
@@ -76,7 +77,7 @@ namespace Lucene.Net.Codecs.Lucene40
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static int GetNumBytes(int size) // LUCENENET: CA1822: Mark members as static
{
- int bytesLength = (int)((uint)size >> 3);
+ int bytesLength = size.TripleShift(3);
if ((size & 7) != 0)
{
bytesLength++;
diff --git a/src/Lucene.Net/Codecs/Lucene40/Lucene40FieldInfosReader.cs b/src/Lucene.Net/Codecs/Lucene40/Lucene40FieldInfosReader.cs
index 488c0de..f6256f6 100644
--- a/src/Lucene.Net/Codecs/Lucene40/Lucene40FieldInfosReader.cs
+++ b/src/Lucene.Net/Codecs/Lucene40/Lucene40FieldInfosReader.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Index;
using System;
using System.Collections.Generic;
@@ -103,7 +104,7 @@ namespace Lucene.Net.Codecs.Lucene40
// DV Types are packed in one byte
byte val = input.ReadByte();
LegacyDocValuesType oldValuesType = GetDocValuesType((sbyte)(val & 0x0F));
- LegacyDocValuesType oldNormsType = GetDocValuesType((sbyte)(((int)((uint)val >> 4)) & 0x0F));
+ LegacyDocValuesType oldNormsType = GetDocValuesType((sbyte)(val.TripleShift(4) & 0x0F));
IDictionary<string, string> attributes = input.ReadStringStringMap();
if (oldValuesType.GetMapping() != DocValuesType.NONE)
{
diff --git a/src/Lucene.Net/Codecs/Lucene40/Lucene40PostingsReader.cs b/src/Lucene.Net/Codecs/Lucene40/Lucene40PostingsReader.cs
index 734ecb5..61bb3f0 100644
--- a/src/Lucene.Net/Codecs/Lucene40/Lucene40PostingsReader.cs
+++ b/src/Lucene.Net/Codecs/Lucene40/Lucene40PostingsReader.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Index;
using Lucene.Net.Support;
@@ -388,7 +389,7 @@ namespace Lucene.Net.Codecs.Lucene40
{
while (low <= hi)
{
- int mid = (int)((uint)(hi + low) >> 1);
+ int mid = (hi + low).TripleShift(1);
int doc = docs[mid];
if (doc < target)
{
@@ -474,7 +475,7 @@ namespace Lucene.Net.Codecs.Lucene40
for (int i = 0; i < size; i++)
{
int code = freqIn.ReadVInt32();
- docAc += (int)((uint)code >> 1); // shift off low bit
+ docAc += code.TripleShift(1); // shift off low bit
freqs[i] = ReadFreq(freqIn, code);
docs[i] = docAc;
}
@@ -578,7 +579,7 @@ namespace Lucene.Net.Codecs.Lucene40
}
else
{
- docAcc += (int)((uint)code >> 1); // shift off low bit
+ docAcc += code.TripleShift(1); // shift off low bit
frq = ReadFreq(freqIn, code);
}
if (docAcc >= target)
@@ -605,7 +606,7 @@ namespace Lucene.Net.Codecs.Lucene40
}
else
{
- m_accum += (int)((uint)code >> 1); // shift off low bit
+ m_accum += code.TripleShift(1); // shift off low bit
m_freq = ReadFreq(freqIn, code);
}
return m_accum;
@@ -677,7 +678,7 @@ namespace Lucene.Net.Codecs.Lucene40
}
else
{
- docAcc += (int)((uint)code >> 1); // shift off low bit
+ docAcc += code.TripleShift(1); // shift off low bit
frq = ReadFreq(freqIn, code);
}
if (docAcc >= target && liveDocs.Get(docAcc))
@@ -710,7 +711,7 @@ namespace Lucene.Net.Codecs.Lucene40
}
else
{
- docAcc += (int)((uint)code >> 1); // shift off low bit
+ docAcc += code.TripleShift(1); // shift off low bit
frq = ReadFreq(freqIn, code);
}
if (liveDocs.Get(docAcc))
@@ -815,7 +816,7 @@ namespace Lucene.Net.Codecs.Lucene40
// Decode next doc/freq pair
int code = freqIn.ReadVInt32();
- accum += (int)((uint)code >> 1); // shift off low bit
+ accum += code.TripleShift(1); // shift off low bit
if ((code & 1) != 0) // if low bit is set
{
freq = 1; // freq is one
@@ -1046,7 +1047,7 @@ namespace Lucene.Net.Codecs.Lucene40
// Decode next doc/freq pair
int code = freqIn.ReadVInt32();
- accum += (int)((uint)code >> 1); // shift off low bit
+ accum += code.TripleShift(1); // shift off low bit
if ((code & 1) != 0) // if low bit is set
{
freq = 1; // freq is one
@@ -1198,7 +1199,7 @@ namespace Lucene.Net.Codecs.Lucene40
if (Debugging.AssertsEnabled) Debugging.Assert(payloadLength != -1);
payloadPending = true;
- code_ = (int)((uint)code_ >> 1);
+ code_ = code_.TripleShift(1);
}
position += code_;
@@ -1210,7 +1211,7 @@ namespace Lucene.Net.Codecs.Lucene40
// new offset length
offsetLength = proxIn.ReadVInt32();
}
- startOffset += (int)((uint)offsetCode >> 1);
+ startOffset += offsetCode.TripleShift(1);
}
posPendingCount--;
diff --git a/src/Lucene.Net/Codecs/Lucene40/Lucene40SkipListReader.cs b/src/Lucene.Net/Codecs/Lucene40/Lucene40SkipListReader.cs
index f074e7d..e353831 100644
--- a/src/Lucene.Net/Codecs/Lucene40/Lucene40SkipListReader.cs
+++ b/src/Lucene.Net/Codecs/Lucene40/Lucene40SkipListReader.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Support;
using System;
using System.Runtime.CompilerServices;
@@ -138,7 +139,7 @@ namespace Lucene.Net.Codecs.Lucene40
offsetLength[level] = skipStream.ReadVInt32();
}
}
- delta = (int)((uint)delta >> 1);
+ delta = delta.TripleShift(1);
}
else
{
diff --git a/src/Lucene.Net/Codecs/Lucene40/Lucene40TermVectorsReader.cs b/src/Lucene.Net/Codecs/Lucene40/Lucene40TermVectorsReader.cs
index 4ebb197..bdccfbb 100644
--- a/src/Lucene.Net/Codecs/Lucene40/Lucene40TermVectorsReader.cs
+++ b/src/Lucene.Net/Codecs/Lucene40/Lucene40TermVectorsReader.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Index;
using Lucene.Net.Support;
@@ -498,7 +499,7 @@ namespace Lucene.Net.Codecs.Lucene40
for (int posUpto = 0; posUpto < freq; posUpto++)
{
int code = tvf.ReadVInt32();
- pos += (int)((uint)code >> 1);
+ pos += code.TripleShift(1);
positions[posUpto] = pos;
if ((code & 1) != 0)
{
diff --git a/src/Lucene.Net/Codecs/Lucene40/Lucene40TermVectorsWriter.cs b/src/Lucene.Net/Codecs/Lucene40/Lucene40TermVectorsWriter.cs
index 6055bf1..5c8875e 100644
--- a/src/Lucene.Net/Codecs/Lucene40/Lucene40TermVectorsWriter.cs
+++ b/src/Lucene.Net/Codecs/Lucene40/Lucene40TermVectorsWriter.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using J2N.Text;
using Lucene.Net.Diagnostics;
using System;
@@ -208,11 +209,11 @@ namespace Lucene.Net.Codecs.Lucene40
scratch.Grow(length);
scratch.Length = length;
positions.ReadBytes(scratch.Bytes, scratch.Offset, scratch.Length);
- WritePosition((int)((uint)code >> 1), scratch);
+ WritePosition(code.TripleShift(1), scratch);
}
else
{
- WritePosition((int)((uint)code >> 1), null);
+ WritePosition(code.TripleShift(1), null);
}
}
tvf.WriteBytes(payloadData.Bytes, payloadData.Offset, payloadData.Length);
@@ -222,7 +223,7 @@ namespace Lucene.Net.Codecs.Lucene40
// pure positions, no payloads
for (int i = 0; i < numProx; i++)
{
- tvf.WriteVInt32((int)((uint)positions.ReadVInt32() >> 1));
+ tvf.WriteVInt32(positions.ReadVInt32().TripleShift(1));
}
}
diff --git a/src/Lucene.Net/Codecs/Lucene41/ForUtil.cs b/src/Lucene.Net/Codecs/Lucene41/ForUtil.cs
index 975221e..ee1b8af 100644
--- a/src/Lucene.Net/Codecs/Lucene41/ForUtil.cs
+++ b/src/Lucene.Net/Codecs/Lucene41/ForUtil.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Diagnostics;
+using J2N.Numerics;
+using Lucene.Net.Diagnostics;
using Lucene.Net.Store;
using Lucene.Net.Support;
using Lucene.Net.Util.Packed;
@@ -142,7 +143,7 @@ namespace Lucene.Net.Codecs.Lucene41
for (int bpv = 1; bpv <= 32; ++bpv)
{
var code = @in.ReadVInt32();
- var formatId = (int)((uint)code >> 5);
+ var formatId = code.TripleShift(5);
var bitsPerValue = (code & 31) + 1;
PackedInt32s.Format format = PackedInt32s.Format.ById(formatId);
diff --git a/src/Lucene.Net/Codecs/Lucene41/Lucene41PostingsReader.cs b/src/Lucene.Net/Codecs/Lucene41/Lucene41PostingsReader.cs
index 7683ecf..414bd3a 100644
--- a/src/Lucene.Net/Codecs/Lucene41/Lucene41PostingsReader.cs
+++ b/src/Lucene.Net/Codecs/Lucene41/Lucene41PostingsReader.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Index;
using Lucene.Net.Store;
@@ -109,7 +110,7 @@ namespace Lucene.Net.Codecs.Lucene41
for (int i = 0; i < num; i++)
{
int code = docIn.ReadVInt32();
- docBuffer[i] = (int)((uint)code >> 1);
+ docBuffer[i] = code.TripleShift(1);
if ((code & 1) != 0)
{
freqBuffer[i] = 1;
@@ -766,7 +767,7 @@ namespace Lucene.Net.Codecs.Lucene41
{
payloadLength = posIn.ReadVInt32();
}
- posDeltaBuffer[i] = (int)((uint)code >> 1);
+ posDeltaBuffer[i] = code.TripleShift(1);
if (payloadLength != 0)
{
posIn.Seek(posIn.GetFilePointer() + payloadLength);
@@ -1281,7 +1282,7 @@ namespace Lucene.Net.Codecs.Lucene41
// System.out.println(" i=" + i + " payloadLen=" + payloadLength);
// }
payloadLengthBuffer[i] = payloadLength;
- posDeltaBuffer[i] = (int)((uint)code >> 1);
+ posDeltaBuffer[i] = code.TripleShift(1);
if (payloadLength != 0)
{
if (payloadByteUpto + payloadLength > payloadBytes.Length)
@@ -1308,7 +1309,7 @@ namespace Lucene.Net.Codecs.Lucene41
{
offsetLength = posIn.ReadVInt32();
}
- offsetStartDeltaBuffer[i] = (int)((uint)deltaCode >> 1);
+ offsetStartDeltaBuffer[i] = deltaCode.TripleShift(1);
offsetLengthBuffer[i] = offsetLength;
// if (DEBUG) {
// System.out.println(" startOffDelta=" + offsetStartDeltaBuffer[i] + " offsetLen=" + offsetLengthBuffer[i]);
diff --git a/src/Lucene.Net/Codecs/Lucene42/Lucene42FieldInfosReader.cs b/src/Lucene.Net/Codecs/Lucene42/Lucene42FieldInfosReader.cs
index de1a50b..5c53f00 100644
--- a/src/Lucene.Net/Codecs/Lucene42/Lucene42FieldInfosReader.cs
+++ b/src/Lucene.Net/Codecs/Lucene42/Lucene42FieldInfosReader.cs
@@ -1,4 +1,5 @@
-using J2N.Collections.Generic.Extensions;
+using J2N.Collections.Generic.Extensions;
+using J2N.Numerics;
using System;
using System.Collections.Generic;
@@ -95,8 +96,8 @@ namespace Lucene.Net.Codecs.Lucene42
// DV Types are packed in one byte
sbyte val = (sbyte)input.ReadByte();
- DocValuesType docValuesType = GetDocValuesType(input, (sbyte)(val & 0x0F));
- DocValuesType normsType = GetDocValuesType(input, (sbyte)(((int)((uint)val >> 4)) & 0x0F));
+ DocValuesType docValuesType = GetDocValuesType(input, (byte)(val & 0x0F));
+ DocValuesType normsType = GetDocValuesType(input, (byte)((val.TripleShift(4)) & 0x0F));
IDictionary<string, string> attributes = input.ReadStringStringMap();
infos[i] = new FieldInfo(name, isIndexed, fieldNumber, storeTermVector,
omitNorms, storePayloads, indexOptions, docValuesType, normsType, attributes.AsReadOnly());
@@ -120,7 +121,7 @@ namespace Lucene.Net.Codecs.Lucene42
}
}
- private static DocValuesType GetDocValuesType(IndexInput input, sbyte b)
+ private static DocValuesType GetDocValuesType(IndexInput input, byte b)
{
if (b == 0)
{
diff --git a/src/Lucene.Net/Codecs/Lucene45/Lucene45DocValuesProducer.cs b/src/Lucene.Net/Codecs/Lucene45/Lucene45DocValuesProducer.cs
index fd29a7a..7677e7d 100644
--- a/src/Lucene.Net/Codecs/Lucene45/Lucene45DocValuesProducer.cs
+++ b/src/Lucene.Net/Codecs/Lucene45/Lucene45DocValuesProducer.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using J2N.Threading.Atomic;
using Lucene.Net.Index;
using Lucene.Net.Util;
@@ -1130,7 +1131,7 @@ namespace Lucene.Net.Codecs.Lucene45
while (low <= high)
{
- long mid = (int)((uint)(low + high) >> 1);
+ long mid = (low + high).TripleShift(1);
DoSeek(mid * outerInstance.interval);
int cmp = termBuffer.CompareTo(text);
diff --git a/src/Lucene.Net/Codecs/Lucene46/Lucene46FieldInfosReader.cs b/src/Lucene.Net/Codecs/Lucene46/Lucene46FieldInfosReader.cs
index 4997850..0c41a05 100644
--- a/src/Lucene.Net/Codecs/Lucene46/Lucene46FieldInfosReader.cs
+++ b/src/Lucene.Net/Codecs/Lucene46/Lucene46FieldInfosReader.cs
@@ -1,4 +1,5 @@
-using J2N.Collections.Generic.Extensions;
+using J2N.Collections.Generic.Extensions;
+using J2N.Numerics;
using System.Collections.Generic;
namespace Lucene.Net.Codecs.Lucene46
@@ -92,8 +93,8 @@ namespace Lucene.Net.Codecs.Lucene46
// DV Types are packed in one byte
byte val = input.ReadByte();
- DocValuesType docValuesType = GetDocValuesType(input, (sbyte)(val & 0x0F));
- DocValuesType normsType = GetDocValuesType(input, (sbyte)(((int)((uint)val >> 4)) & 0x0F));
+ DocValuesType docValuesType = GetDocValuesType(input, (byte)(val & 0x0F));
+ DocValuesType normsType = GetDocValuesType(input, (byte)((val.TripleShift(4)) & 0x0F));
long dvGen = input.ReadInt64();
IDictionary<string, string> attributes = input.ReadStringStringMap();
infos[i] = new FieldInfo(name, isIndexed, fieldNumber, storeTermVector, omitNorms, storePayloads, indexOptions, docValuesType, normsType, attributes.AsReadOnly());
@@ -127,7 +128,7 @@ namespace Lucene.Net.Codecs.Lucene46
}
}
- private static DocValuesType GetDocValuesType(IndexInput input, sbyte b)
+ private static DocValuesType GetDocValuesType(IndexInput input, byte b)
{
if (b == 0)
{
diff --git a/src/Lucene.Net/Codecs/TermVectorsWriter.cs b/src/Lucene.Net/Codecs/TermVectorsWriter.cs
index a817481..7a2126f 100644
--- a/src/Lucene.Net/Codecs/TermVectorsWriter.cs
+++ b/src/Lucene.Net/Codecs/TermVectorsWriter.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using J2N.Text;
using Lucene.Net.Diagnostics;
using System;
@@ -169,7 +170,7 @@ namespace Lucene.Net.Codecs
else
{
int code = positions.ReadVInt32();
- position += (int)((uint)code >> 1);
+ position += code.TripleShift(1);
if ((code & 1) != 0)
{
// this position has a payload
diff --git a/src/Lucene.Net/Index/DocTermOrds.cs b/src/Lucene.Net/Index/DocTermOrds.cs
index 8ea8a63..891f592 100644
--- a/src/Lucene.Net/Index/DocTermOrds.cs
+++ b/src/Lucene.Net/Index/DocTermOrds.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Diagnostics;
+using J2N.Numerics;
+using Lucene.Net.Diagnostics;
using System;
using System.Collections.Generic;
using System.IO;
@@ -255,7 +256,7 @@ namespace Lucene.Net.Index
this.m_field = field;
this.m_maxTermDocFreq = maxTermDocFreq;
this.indexIntervalBits = indexIntervalBits;
- indexIntervalMask = (int)((uint)0xffffffff >> (32 - indexIntervalBits));
+ indexIntervalMask = (int)(0xffffffff >> (32 - indexIntervalBits)); // LUCENENET: No need to cast to uint here for the triple shift because the literal already is uint
indexInterval = 1 << indexIntervalBits;
}
@@ -466,7 +467,7 @@ namespace Lucene.Net.Index
{
// index into byte array (actually the end of
// the doc-specific byte[] when building)
- int pos = (int)((uint)val >> 8);
+ int pos = val.TripleShift(8);
int ilen = VInt32Size(delta);
var arr = bytes[doc];
int newend = pos + ilen;
@@ -533,7 +534,7 @@ namespace Lucene.Net.Index
for (int j = 0; j < ipos; j++)
{
tempArr[j] = (sbyte)val;
- val = (int)((uint)val >> 8);
+ val = val.TripleShift(8);
}
// point at the end index in the byte[]
index[doc] = (endPos << 8) | 1;
@@ -597,7 +598,7 @@ namespace Lucene.Net.Index
int val = index[doc];
if ((val & 0xff) == 1)
{
- int len = (int)((uint)val >> 8);
+ int len = val.TripleShift(8);
//System.out.println(" ptr pos=" + pos);
index[doc] = (pos << 8) | 1; // change index to point to start of array
if ((pos & 0xff000000) != 0)
@@ -703,22 +704,22 @@ namespace Lucene.Net.Index
/// </summary>
private static int WriteInt32(int x, sbyte[] arr, int pos)
{
- var a = ((int)((uint)x >> (7 * 4)));
+ var a = x.TripleShift(7 * 4);
if (a != 0)
{
arr[pos++] = (sbyte)(a | 0x80);
}
- a = ((int)((uint)x >> (7 * 3)));
+ a = x.TripleShift(7 * 3);
if (a != 0)
{
arr[pos++] = (sbyte)(a | 0x80);
}
- a = ((int)((uint)x >> (7 * 2)));
+ a = x.TripleShift(7 * 2);
if (a != 0)
{
arr[pos++] = (sbyte)(a | 0x80);
}
- a = ((int)((uint)x >> (7 * 1)));
+ a = x.TripleShift(7 * 1);
if (a != 0)
{
arr[pos++] = (sbyte)(a | 0x80);
@@ -869,7 +870,7 @@ namespace Lucene.Net.Index
//System.out.println(" seek(ord) targetOrd=" + targetOrd + " delta=" + delta + " ord=" + ord + " ii=" + indexInterval);
if (delta < 0 || delta > outerInstance.indexInterval)
{
- int idx = (int)((long)((ulong)targetOrd >> outerInstance.indexIntervalBits));
+ int idx = (int)targetOrd.TripleShift(outerInstance.indexIntervalBits);
BytesRef @base = outerInstance.m_indexedTermsArray[idx];
//System.out.println(" do seek term=" + base.utf8ToString());
ord = idx << outerInstance.indexIntervalBits;
@@ -1001,7 +1002,7 @@ namespace Lucene.Net.Index
//System.out.println(" tnum=" + tnum);
delta = 0;
}
- code = (int)((uint)code >> 8);
+ code = code.TripleShift(8);
}
}
else
@@ -1045,9 +1046,9 @@ namespace Lucene.Net.Index
if ((code & 0xff) == 1)
{
// a pointer
- upto = (int)((uint)code >> 8);
+ upto = code.TripleShift(8);
//System.out.println(" pointer! upto=" + upto);
- int whichArray = ((int)((uint)docID >> 16)) & 0xff;
+ int whichArray = (docID.TripleShift(16)) & 0xff;
arr = outerInstance.m_tnums[whichArray];
}
else
diff --git a/src/Lucene.Net/Index/FreqProxTermsWriterPerField.cs b/src/Lucene.Net/Index/FreqProxTermsWriterPerField.cs
index eff6529..95cb5c6 100644
--- a/src/Lucene.Net/Index/FreqProxTermsWriterPerField.cs
+++ b/src/Lucene.Net/Index/FreqProxTermsWriterPerField.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using J2N.Text;
using Lucene.Net.Analysis.TokenAttributes;
using Lucene.Net.Diagnostics;
@@ -544,7 +545,7 @@ namespace Lucene.Net.Index
}
else
{
- docID += (int)((uint)code >> 1);
+ docID += code.TripleShift(1);
if ((code & 1) != 0)
{
termFreq = 1;
@@ -610,7 +611,7 @@ namespace Lucene.Net.Index
if (readPositions)
{
int code = prox.ReadVInt32();
- position += (int)((uint)code >> 1);
+ position += code.TripleShift(1);
if ((code & 1) != 0)
{
diff --git a/src/Lucene.Net/Index/ReaderUtil.cs b/src/Lucene.Net/Index/ReaderUtil.cs
index 914f3ba..6426498 100644
--- a/src/Lucene.Net/Index/ReaderUtil.cs
+++ b/src/Lucene.Net/Index/ReaderUtil.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using System.Collections.Generic;
namespace Lucene.Net.Index
@@ -55,7 +56,7 @@ namespace Lucene.Net.Index
int hi = size - 1; // for first element less than n, return its index
while (hi >= lo)
{
- int mid = (int)((uint)(lo + hi) >> 1);
+ int mid = (lo + hi).TripleShift(1);
int midValue = docStarts[mid];
if (n < midValue)
{
@@ -89,7 +90,7 @@ namespace Lucene.Net.Index
int hi = size - 1; // for first element less than n, return its index
while (hi >= lo)
{
- int mid = (int)((uint)(lo + hi) >> 1);
+ int mid = (lo + hi).TripleShift(1);
int midValue = leaves[mid].DocBase;
if (n < midValue)
{
diff --git a/src/Lucene.Net/Index/SortedDocValues.cs b/src/Lucene.Net/Index/SortedDocValues.cs
index 5235ef7..ed21a45 100644
--- a/src/Lucene.Net/Index/SortedDocValues.cs
+++ b/src/Lucene.Net/Index/SortedDocValues.cs
@@ -1,3 +1,5 @@
+using J2N.Numerics;
+
namespace Lucene.Net.Index
{
/*
@@ -87,7 +89,7 @@ namespace Lucene.Net.Index
while (low <= high)
{
- int mid = (int)((uint)(low + high) >> 1);
+ int mid = (low + high).TripleShift(1);
LookupOrd(mid, spare);
int cmp = spare.CompareTo(key);
diff --git a/src/Lucene.Net/Index/SortedSetDocValues.cs b/src/Lucene.Net/Index/SortedSetDocValues.cs
index 9418ea8..b1ce6d0 100644
--- a/src/Lucene.Net/Index/SortedSetDocValues.cs
+++ b/src/Lucene.Net/Index/SortedSetDocValues.cs
@@ -1,3 +1,5 @@
+using J2N.Numerics;
+
namespace Lucene.Net.Index
{
/*
@@ -83,7 +85,7 @@ namespace Lucene.Net.Index
while (low <= high)
{
- long mid = (int)((uint)(low + high) >> 1);
+ long mid = (low + high).TripleShift(1);
LookupOrd(mid, spare);
int cmp = spare.CompareTo(key);
diff --git a/src/Lucene.Net/Index/TermsHashPerField.cs b/src/Lucene.Net/Index/TermsHashPerField.cs
index 5d7429c..59b0ba2 100644
--- a/src/Lucene.Net/Index/TermsHashPerField.cs
+++ b/src/Lucene.Net/Index/TermsHashPerField.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Analysis.TokenAttributes;
using Lucene.Net.Diagnostics;
using System;
@@ -282,11 +283,6 @@ namespace Lucene.Net.Index
internal int[] intUptos;
internal int intUptoStart;
- internal void WriteByte(int stream, sbyte b)
- {
- WriteByte(stream, (byte)b);
- }
-
internal void WriteByte(int stream, byte b)
{
int upto = intUptos[intUptoStart + stream];
@@ -322,10 +318,10 @@ namespace Lucene.Net.Index
if (Debugging.AssertsEnabled) Debugging.Assert(stream < streamCount);
while ((i & ~0x7F) != 0)
{
- WriteByte(stream, (sbyte)((i & 0x7f) | 0x80));
- i = (int)((uint)i >> 7);
+ WriteByte(stream, (byte)((i & 0x7f) | 0x80));
+ i = i.TripleShift(7);
}
- WriteByte(stream, (sbyte)i);
+ WriteByte(stream, (byte)i);
}
internal override void Finish()
diff --git a/src/Lucene.Net/Search/DocTermOrdsRangeFilter.cs b/src/Lucene.Net/Search/DocTermOrdsRangeFilter.cs
index e2d0d20..fa365fb 100644
--- a/src/Lucene.Net/Search/DocTermOrdsRangeFilter.cs
+++ b/src/Lucene.Net/Search/DocTermOrdsRangeFilter.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using System;
using System.Text;
@@ -187,7 +188,7 @@ namespace Lucene.Net.Search
{
int h = field.GetHashCode();
h ^= (lowerVal != null) ? lowerVal.GetHashCode() : 550356204;
- h = (h << 1) | ((int)((uint)h >> 31)); // rotate to distinguish lower from upper
+ h = (h << 1) | (h.TripleShift(31)); // rotate to distinguish lower from upper
h ^= (upperVal != null) ? upperVal.GetHashCode() : -1674416163;
h ^= (includeLower ? 1549299360 : -365038026) ^ (includeUpper ? 1721088258 : 1948649653);
return h;
diff --git a/src/Lucene.Net/Search/FieldCacheRangeFilter.cs b/src/Lucene.Net/Search/FieldCacheRangeFilter.cs
index 76dcdb9..5d38226 100644
--- a/src/Lucene.Net/Search/FieldCacheRangeFilter.cs
+++ b/src/Lucene.Net/Search/FieldCacheRangeFilter.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using System;
using System.Text;
@@ -746,7 +747,7 @@ namespace Lucene.Net.Search
{
int h = field.GetHashCode();
h ^= (lowerVal != null) ? lowerVal.GetHashCode() : 550356204;
- h = (h << 1) | ((int)((uint)h >> 31)); // rotate to distinguish lower from upper
+ h = (h << 1) | (h.TripleShift(31)); // rotate to distinguish lower from upper
h ^= (upperVal != null) ? upperVal.GetHashCode() : -1674416163;
h ^= (parser != null) ? parser.GetHashCode() : -1572457324;
h ^= (includeLower ? 1549299360 : -365038026) ^ (includeUpper ? 1721088258 : 1948649653);
diff --git a/src/Lucene.Net/Search/Spans/SpanFirstQuery.cs b/src/Lucene.Net/Search/Spans/SpanFirstQuery.cs
index 4a8d9dc..57d6964 100644
--- a/src/Lucene.Net/Search/Spans/SpanFirstQuery.cs
+++ b/src/Lucene.Net/Search/Spans/SpanFirstQuery.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using System.Text;
@@ -93,7 +94,7 @@ namespace Lucene.Net.Search.Spans
public override int GetHashCode()
{
int h = m_match.GetHashCode();
- h ^= (h << 8) | ((int)((uint)h >> 25)); // reversible
+ h ^= (h << 8) | (h.TripleShift(25)); // reversible
h ^= J2N.BitConversion.SingleToRawInt32Bits(Boost) ^ m_end;
return h;
}
diff --git a/src/Lucene.Net/Search/Spans/SpanNearPayloadCheckQuery.cs b/src/Lucene.Net/Search/Spans/SpanNearPayloadCheckQuery.cs
index 13087b5..73a8f49 100644
--- a/src/Lucene.Net/Search/Spans/SpanNearPayloadCheckQuery.cs
+++ b/src/Lucene.Net/Search/Spans/SpanNearPayloadCheckQuery.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Support;
using System.Collections;
using System.Collections.Generic;
@@ -137,7 +138,7 @@ namespace Lucene.Net.Search.Spans
public override int GetHashCode()
{
int h = m_match.GetHashCode();
- h ^= (h << 8) | ((int)((uint)h >> 25)); // reversible
+ h ^= (h << 8) | (h.TripleShift(25)); // reversible
//TODO: is this right?
h ^= payloadEqualityComparer.GetHashCode(m_payloadToMatch); // LUCENENET NOTE: Need to use the structural equality comparer to compare equality of all contained values
h ^= J2N.BitConversion.SingleToRawInt32Bits(Boost);
diff --git a/src/Lucene.Net/Search/Spans/SpanNearQuery.cs b/src/Lucene.Net/Search/Spans/SpanNearQuery.cs
index e846b6e..f244154 100644
--- a/src/Lucene.Net/Search/Spans/SpanNearQuery.cs
+++ b/src/Lucene.Net/Search/Spans/SpanNearQuery.cs
@@ -1,4 +1,5 @@
-using J2N.Collections.Generic.Extensions;
+using J2N.Collections.Generic.Extensions;
+using J2N.Numerics;
using System;
using System.Collections.Generic;
using System.Text;
@@ -221,7 +222,7 @@ namespace Lucene.Net.Search.Spans
// Mix bits before folding in things like boost, since it could cancel the
// last element of clauses. this particular mix also serves to
// differentiate SpanNearQuery hashcodes from others.
- result ^= (result << 14) | ((int)((uint)result >> 19)); // reversible
+ result ^= (result << 14) | (result.TripleShift(19)); // reversible
result += J2N.BitConversion.SingleToRawInt32Bits(Boost);
result += m_slop;
result ^= (m_inOrder ? unchecked((int)0x99AFD3BD) : 0);
diff --git a/src/Lucene.Net/Search/Spans/SpanOrQuery.cs b/src/Lucene.Net/Search/Spans/SpanOrQuery.cs
index 9f298dd..f59b725 100644
--- a/src/Lucene.Net/Search/Spans/SpanOrQuery.cs
+++ b/src/Lucene.Net/Search/Spans/SpanOrQuery.cs
@@ -1,4 +1,5 @@
-using J2N.Collections.Generic.Extensions;
+using J2N.Collections.Generic.Extensions;
+using J2N.Numerics;
using System;
using System.Collections.Generic;
using System.Text;
@@ -172,7 +173,7 @@ namespace Lucene.Net.Search.Spans
{
//If this doesn't work, hash all elemnts together instead. This version was used to reduce time complexity
int h = clauses.GetHashCode();
- h ^= (h << 10) | ((int)(((uint)h) >> 23));
+ h ^= (h << 10) | (h.TripleShift(23));
h ^= J2N.BitConversion.SingleToRawInt32Bits(Boost);
return h;
}
diff --git a/src/Lucene.Net/Search/Spans/SpanPayloadCheckQuery.cs b/src/Lucene.Net/Search/Spans/SpanPayloadCheckQuery.cs
index 3685f7c..9fb0dc2 100644
--- a/src/Lucene.Net/Search/Spans/SpanPayloadCheckQuery.cs
+++ b/src/Lucene.Net/Search/Spans/SpanPayloadCheckQuery.cs
@@ -1,8 +1,9 @@
-using Lucene.Net.Support;
+using Lucene.Net.Support;
using System.Collections.Generic;
using System;
using System.Text;
using System.Collections;
+using J2N.Numerics;
namespace Lucene.Net.Search.Spans
{
@@ -141,7 +142,7 @@ namespace Lucene.Net.Search.Spans
public override int GetHashCode()
{
int h = m_match.GetHashCode();
- h ^= (h << 8) | ((int)((uint)h >> 25)); // reversible
+ h ^= (h << 8) | (h.TripleShift(25)); // reversible
//TODO: is this right?
h ^= payloadEqualityComparer.GetHashCode(m_payloadToMatch); // LUCENENET NOTE: Need to use the structural equality comparer to compare equality of all contained values
h ^= J2N.BitConversion.SingleToRawInt32Bits(Boost);
diff --git a/src/Lucene.Net/Search/Spans/SpanPositionRangeQuery.cs b/src/Lucene.Net/Search/Spans/SpanPositionRangeQuery.cs
index c0a7782..b37b948 100644
--- a/src/Lucene.Net/Search/Spans/SpanPositionRangeQuery.cs
+++ b/src/Lucene.Net/Search/Spans/SpanPositionRangeQuery.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using System.Text;
@@ -98,7 +99,7 @@ namespace Lucene.Net.Search.Spans
public override int GetHashCode()
{
int h = m_match.GetHashCode();
- h ^= (h << 8) | ((int)((uint)h >> 25)); // reversible
+ h ^= (h << 8) | (h.TripleShift(25)); // reversible
h ^= J2N.BitConversion.SingleToRawInt32Bits(Boost) ^ m_end ^ m_start;
return h;
}
diff --git a/src/Lucene.Net/Store/ByteBufferIndexInput.cs b/src/Lucene.Net/Store/ByteBufferIndexInput.cs
index 73d6a7b..4b7951e 100644
--- a/src/Lucene.Net/Store/ByteBufferIndexInput.cs
+++ b/src/Lucene.Net/Store/ByteBufferIndexInput.cs
@@ -1,4 +1,5 @@
-using J2N.IO;
+using J2N.IO;
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Util.Fst;
using System;
@@ -89,7 +90,7 @@ namespace Lucene.Net.Store
if (Debugging.AssertsEnabled)
{
Debugging.Assert(chunkSizePower >= 0 && chunkSizePower <= 30);
- Debugging.Assert(((long)((ulong)length >> chunkSizePower)) < int.MaxValue);
+ Debugging.Assert(length.TripleShift(chunkSizePower) < int.MaxValue);
}
// LUCENENET specific: MMapIndexInput calls SetBuffers() to populate
@@ -327,8 +328,8 @@ namespace Lucene.Net.Store
{
long sliceEnd = offset + length;
- int startIndex = (int)((long)((ulong)offset >> chunkSizePower));
- int endIndex = (int)((long)((ulong)sliceEnd >> chunkSizePower));
+ int startIndex = (int)(offset.TripleShift(chunkSizePower));
+ int endIndex = (int)(sliceEnd.TripleShift(chunkSizePower));
// we always allocate one more slice, the last one may be a 0 byte one
ByteBuffer[] slices = new ByteBuffer[endIndex - startIndex + 1];
diff --git a/src/Lucene.Net/Store/DataOutput.cs b/src/Lucene.Net/Store/DataOutput.cs
index c86194c..ac1d591 100644
--- a/src/Lucene.Net/Store/DataOutput.cs
+++ b/src/Lucene.Net/Store/DataOutput.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Diagnostics;
+using J2N.Numerics;
+using Lucene.Net.Diagnostics;
using System.Collections.Generic;
using System.IO;
@@ -200,7 +201,7 @@ namespace Lucene.Net.Store
while ((i & ~0x7F) != 0)
{
WriteByte((byte)((i & 0x7F) | 0x80));
- i = (int)((uint)i >> 7);
+ i = i.TripleShift(7);
}
WriteByte((byte)i);
}
@@ -235,7 +236,7 @@ namespace Lucene.Net.Store
while ((i & ~0x7FL) != 0L)
{
WriteByte((byte)((i & 0x7FL) | 0x80L));
- i = (long)((ulong)i >> 7);
+ i = i.TripleShift(7);
}
WriteByte((byte)i);
}
diff --git a/src/Lucene.Net/Store/FlushInfo.cs b/src/Lucene.Net/Store/FlushInfo.cs
index d4a7f66..ca404f4 100644
--- a/src/Lucene.Net/Store/FlushInfo.cs
+++ b/src/Lucene.Net/Store/FlushInfo.cs
@@ -1,3 +1,5 @@
+using J2N.Numerics;
+
namespace Lucene.Net.Store
{
/*
@@ -43,7 +45,7 @@ namespace Lucene.Net.Store
{
const int prime = 31;
int result = 1;
- result = prime * result + (int)(EstimatedSegmentSize ^ ((long)((ulong)EstimatedSegmentSize >> 32)));
+ result = prime * result + (int)(EstimatedSegmentSize ^ (EstimatedSegmentSize.TripleShift(32)));
result = prime * result + NumDocs;
return result;
}
diff --git a/src/Lucene.Net/Store/MMapDirectory.cs b/src/Lucene.Net/Store/MMapDirectory.cs
index cd01d15..eade8fa 100644
--- a/src/Lucene.Net/Store/MMapDirectory.cs
+++ b/src/Lucene.Net/Store/MMapDirectory.cs
@@ -1,4 +1,4 @@
-using J2N.IO;
+using J2N.IO;
using J2N.IO.MemoryMappedFiles;
using J2N.Numerics;
using Lucene.Net.Diagnostics;
@@ -298,7 +298,7 @@ namespace Lucene.Net.Store
long chunkSize = 1L << chunkSizePower;
// we always allocate one more buffer, the last one may be a 0 byte one
- int nrBuffers = (int)((long)((ulong)length >> chunkSizePower)) + 1;
+ int nrBuffers = (int)length.TripleShift(chunkSizePower) + 1;
ByteBuffer[] buffers = new ByteBuffer[nrBuffers];
diff --git a/src/Lucene.Net/Store/MergeInfo.cs b/src/Lucene.Net/Store/MergeInfo.cs
index 696ba64..e7704c3 100644
--- a/src/Lucene.Net/Store/MergeInfo.cs
+++ b/src/Lucene.Net/Store/MergeInfo.cs
@@ -1,3 +1,5 @@
+using J2N.Numerics;
+
namespace Lucene.Net.Store
{
/*
@@ -50,7 +52,7 @@ namespace Lucene.Net.Store
const int prime = 31;
int result = 1;
result = prime * result
- + (int)(EstimatedMergeBytes ^ ((long)((ulong)EstimatedMergeBytes >> 32)));
+ + (int)(EstimatedMergeBytes ^ (EstimatedMergeBytes.TripleShift(32)));
result = prime * result + (IsExternal ? 1231 : 1237);
result = prime * result + MergeMaxNumSegments;
result = prime * result + TotalDocCount;
diff --git a/src/Lucene.Net/Util/Automaton/SpecialOperations.cs b/src/Lucene.Net/Util/Automaton/SpecialOperations.cs
index b2e9dcd..1d8b8cb 100644
--- a/src/Lucene.Net/Util/Automaton/SpecialOperations.cs
+++ b/src/Lucene.Net/Util/Automaton/SpecialOperations.cs
@@ -1,4 +1,5 @@
-using J2N.Collections.Generic.Extensions;
+using J2N.Collections.Generic.Extensions;
+using J2N.Numerics;
using J2N.Text;
using System.Collections.Generic;
using System.Linq;
@@ -57,7 +58,7 @@ namespace Lucene.Net.Util.Automaton
int b = points.Length;
while (b - a > 1)
{
- int d = (int)((uint)(a + b) >> 1);
+ int d = (a + b).TripleShift(1);
if (points[d] > c)
{
b = d;
diff --git a/src/Lucene.Net/Util/BroadWord.cs b/src/Lucene.Net/Util/BroadWord.cs
index 3269054..3ae1823 100644
--- a/src/Lucene.Net/Util/BroadWord.cs
+++ b/src/Lucene.Net/Util/BroadWord.cs
@@ -1,4 +1,4 @@
-using J2N.Numerics;
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using System.Runtime.CompilerServices;
@@ -46,13 +46,13 @@ namespace Lucene.Net.Util
internal static int BitCount(long x)
{
// Step 0 leaves in each pair of bits the number of ones originally contained in that pair:
- x = x - ((long)((ulong)(x & unchecked((long)0xAAAAAAAAAAAAAAAAL)) >> 1));
+ x = x - ((x & unchecked((long)0xAAAAAAAAAAAAAAAAL)).TripleShift(1));
// Step 1, idem for each nibble:
- x = (x & 0x3333333333333333L) + (((long)((ulong)x >> 2)) & 0x3333333333333333L);
+ x = (x & 0x3333333333333333L) + ((x.TripleShift(2)) & 0x3333333333333333L);
// Step 2, idem for each byte:
- x = (x + ((long)((ulong)x >> 4))) & 0x0F0F0F0F0F0F0F0FL;
+ x = (x + (x.TripleShift(4))) & 0x0F0F0F0F0F0F0F0FL;
// Multiply to sum them all into the high byte, and return the high byte:
- return (int)((long)((ulong)(x * L8_L) >> 56));
+ return (int)((x * L8_L).TripleShift(56));
}
/// <summary>
@@ -60,29 +60,29 @@ namespace Lucene.Net.Util
/// <returns> The index of the r-th 1 bit in x, or if no such bit exists, 72. </returns>
public static int Select(long x, int r)
{
- long s = x - ((long)((ulong)(x & unchecked((long)0xAAAAAAAAAAAAAAAAL)) >> 1)); // Step 0, pairwise bitsums
+ long s = x - ((x & unchecked((long)0xAAAAAAAAAAAAAAAAL)).TripleShift(1)); // Step 0, pairwise bitsums
// Correct a small mistake in algorithm 2:
// Use s instead of x the second time in right shift 2, compare to Algorithm 1 in rank9 above.
- s = (s & 0x3333333333333333L) + (((long)((ulong)s >> 2)) & 0x3333333333333333L); // Step 1, nibblewise bitsums
+ s = (s & 0x3333333333333333L) + ((s.TripleShift(2)) & 0x3333333333333333L); // Step 1, nibblewise bitsums
- s = ((s + ((long)((ulong)s >> 4))) & 0x0F0F0F0F0F0F0F0FL) * L8_L; // Step 2, bytewise bitsums
+ s = ((s + (s.TripleShift(4))) & 0x0F0F0F0F0F0F0F0FL) * L8_L; // Step 2, bytewise bitsums
- long b = (long)((ulong)(((long)((ulong)SmallerUpTo7_8(s, (r * L8_L)) >> 7)) * L8_L) >> 53); // & (~7L); // Step 3, side ways addition for byte number times 8
+ long b = ((SmallerUpTo7_8(s, (r * L8_L)).TripleShift(7)) * L8_L).TripleShift(53); // & (~7L); // Step 3, side ways addition for byte number times 8
- long l = r - (((long)((ulong)(s << 8) >> (int)b)) & 0xFFL); // Step 4, byte wise rank, subtract the rank with byte at b-8, or zero for b=0;
+ long l = r - (((s << 8).TripleShift((int)b)) & 0xFFL); // Step 4, byte wise rank, subtract the rank with byte at b-8, or zero for b=0;
if (Debugging.AssertsEnabled) Debugging.Assert(0L <= 1, "{0}", l);
//assert l < 8 : l; //fails when bit r is not available.
// Select bit l from byte (x >>> b):
- long spr = ((((long)((ulong)x >> (int)b)) & 0xFFL) * L8_L) & L9_L; // spread the 8 bits of the byte at b over the long at L9 positions
+ long spr = (((x.TripleShift((int)b)) & 0xFFL) * L8_L) & L9_L; // spread the 8 bits of the byte at b over the long at L9 positions
// long spr_bigger8_zero = smaller8(0L, spr); // inlined smaller8 with 0L argument:
// FIXME: replace by biggerequal8_one formula from article page 6, line 9. four operators instead of five here.
long spr_bigger8_zero = ((H8_L - (spr & (~H8_L))) ^ (~spr)) & H8_L;
- s = ((long)((ulong)spr_bigger8_zero >> 7)) * L8_L; // Step 5, sideways byte add the 8 bits towards the high byte
+ s = (spr_bigger8_zero.TripleShift(7)) * L8_L; // Step 5, sideways byte add the 8 bits towards the high byte
- int res = (int)(b + ((long)((ulong)(((long)((ulong)SmallerUpTo7_8(s, (l * L8_L)) >> 7)) * L8_L) >> 56))); // Step 6
+ int res = (int)(b + (((SmallerUpTo7_8(s, (l * L8_L)).TripleShift(7)) * L8_L).TripleShift(56))); // Step 6
return res;
}
@@ -159,7 +159,7 @@ namespace Lucene.Net.Util
while ((x != 0L) && (r > 0))
{
int ntz = x.TrailingZeroCount();
- x = (long)((ulong)x >> (ntz + 1));
+ x = x.TripleShift(ntz + 1);
s += (ntz + 1);
r -= 1;
}
diff --git a/src/Lucene.Net/Util/FixedBitSet.cs b/src/Lucene.Net/Util/FixedBitSet.cs
index 58d1bd3..e6013e1 100644
--- a/src/Lucene.Net/Util/FixedBitSet.cs
+++ b/src/Lucene.Net/Util/FixedBitSet.cs
@@ -1,4 +1,4 @@
-using J2N.Numerics;
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Support;
using System;
@@ -157,7 +157,7 @@ namespace Lucene.Net.Util
/// Returns the number of 64 bit words it would take to hold <paramref name="numBits"/> </summary>
public static int Bits2words(int numBits)
{
- int numLong = (int)((uint)numBits >> 6);
+ int numLong = numBits.TripleShift(6);
if ((numBits & 63) != 0)
{
numLong++;
@@ -602,8 +602,7 @@ namespace Lucene.Net.Util
*/
long startmask = -1L << startIndex;
- long endmask = (long)(unchecked((ulong)-1) >> -endIndex);
- //long endmask = -(int)((uint)1L >> -endIndex); // 64-(endIndex&0x3f) is the same as -endIndex due to wrap
+ long endmask = (-1L).TripleShift(-endIndex); // 64-(endIndex&0x3f) is the same as -endIndex due to wrap
if (startWord == endWord)
{
@@ -642,8 +641,7 @@ namespace Lucene.Net.Util
int endWord = (endIndex - 1) >> 6;
long startmask = -1L << startIndex;
- long endmask = (long)(unchecked((ulong)-1) >> -endIndex);
- //long endmask = -(int)((uint)1UL >> -endIndex); // 64-(endIndex&0x3f) is the same as -endIndex due to wrap
+ long endmask = (-1L).TripleShift(-endIndex); // 64-(endIndex&0x3f) is the same as -endIndex due to wrap
if (startWord == endWord)
{
@@ -730,7 +728,7 @@ namespace Lucene.Net.Util
for (int i = numWords; --i >= 0; )
{
h ^= bits[i];
- h = (h << 1) | ((long)((ulong)h >> 63)); // rotate left
+ h = (h << 1) | (h.TripleShift(63)); // rotate left
}
// fold leftmost bits into right and add a constant to prevent
// empty sets from returning 0, which is too common.
diff --git a/src/Lucene.Net/Util/Fst/FST.cs b/src/Lucene.Net/Util/Fst/FST.cs
index 8c7d8a1..d405d43 100644
--- a/src/Lucene.Net/Util/Fst/FST.cs
+++ b/src/Lucene.Net/Util/Fst/FST.cs
@@ -1,4 +1,5 @@
using J2N.Collections;
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Support;
using System;
@@ -1354,7 +1355,7 @@ namespace Lucene.Net.Util.Fst
while (low <= high)
{
//System.out.println(" cycle");
- int mid = (int)((uint)(low + high) >> 1);
+ int mid = (low + high).TripleShift(1);
@in.Position = arc.PosArcsStart;
@in.SkipBytes(arc.BytesPerArc * mid + 1);
int midLabel = ReadLabel(@in);
diff --git a/src/Lucene.Net/Util/Fst/FSTEnum.cs b/src/Lucene.Net/Util/Fst/FSTEnum.cs
index 5293480..888ba9f 100644
--- a/src/Lucene.Net/Util/Fst/FSTEnum.cs
+++ b/src/Lucene.Net/Util/Fst/FSTEnum.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using System;
using System.Runtime.CompilerServices;
@@ -172,7 +173,7 @@ namespace Lucene.Net.Util.Fst
bool found = false;
while (low <= high)
{
- mid = (int)((uint)(low + high) >> 1);
+ mid = (low + high).TripleShift(1);
@in.Position = arc.PosArcsStart;
@in.SkipBytes(arc.BytesPerArc * mid + 1);
int midLabel = m_fst.ReadLabel(@in);
@@ -345,7 +346,7 @@ namespace Lucene.Net.Util.Fst
bool found = false;
while (low <= high)
{
- mid = (int)((uint)(low + high) >> 1);
+ mid = (low + high).TripleShift(1);
@in.Position = arc.PosArcsStart;
@in.SkipBytes(arc.BytesPerArc * mid + 1);
int midLabel = m_fst.ReadLabel(@in);
diff --git a/src/Lucene.Net/Util/Fst/Util.cs b/src/Lucene.Net/Util/Fst/Util.cs
index 40835da..8e6c7b3 100644
--- a/src/Lucene.Net/Util/Fst/Util.cs
+++ b/src/Lucene.Net/Util/Fst/Util.cs
@@ -1,4 +1,5 @@
-using J2N;
+using J2N;
+using J2N.Numerics;
using J2N.Text;
using Lucene.Net.Diagnostics;
using System;
@@ -181,7 +182,7 @@ namespace Lucene.Net.Util.Fst
bool exact = false;
while (low <= high)
{
- mid = (int)((uint)(low + high) >> 1);
+ mid = (low + high).TripleShift(1);
@in.Position = arc.PosArcsStart;
@in.SkipBytes(arc.BytesPerArc * mid);
var flags = (sbyte)@in.ReadByte();
@@ -1143,7 +1144,7 @@ namespace Lucene.Net.Util.Fst
// " targetLabel=" + targetLabel);
while (low <= high)
{
- mid = (int)((uint)(low + high) >> 1);
+ mid = (low + high).TripleShift(1);
@in.Position = arc.PosArcsStart;
@in.SkipBytes(arc.BytesPerArc * mid + 1);
int midLabel = fst.ReadLabel(@in);
diff --git a/src/Lucene.Net/Util/InPlaceMergeSorter.cs b/src/Lucene.Net/Util/InPlaceMergeSorter.cs
index 6423f59..5f414df 100644
--- a/src/Lucene.Net/Util/InPlaceMergeSorter.cs
+++ b/src/Lucene.Net/Util/InPlaceMergeSorter.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using System.Runtime.CompilerServices;
namespace Lucene.Net.Util
@@ -53,7 +54,7 @@ namespace Lucene.Net.Util
}
else
{
- int mid = (int)((uint)(from + to) >> 1);
+ int mid = (from + to).TripleShift(1);
MergeSort(from, mid);
MergeSort(mid, to);
MergeInPlace(from, mid, to);
diff --git a/src/Lucene.Net/Util/IndexableBinaryStringTools.cs b/src/Lucene.Net/Util/IndexableBinaryStringTools.cs
index a7849d6..d986709 100644
--- a/src/Lucene.Net/Util/IndexableBinaryStringTools.cs
+++ b/src/Lucene.Net/Util/IndexableBinaryStringTools.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using System;
using System.Runtime.CompilerServices;
@@ -158,11 +159,14 @@ namespace Lucene.Net.Util
codingCase = CODING_CASES[caseNum];
if (2 == codingCase.numBytes)
{
- outputArray[outputCharNum] = (char)(((inputArray[inputByteNum] & 0xFF) << codingCase.initialShift) + (((int)((uint)(inputArray[inputByteNum + 1] & 0xFF) >> codingCase.finalShift)) & codingCase.finalMask) & (short)0x7FFF);
+ outputArray[outputCharNum] = (char)(((inputArray[inputByteNum] & 0xFF) << codingCase.initialShift)
+ + (((inputArray[inputByteNum + 1] & 0xFF).TripleShift(codingCase.finalShift)) & codingCase.finalMask) & /*(short)*/0x7FFF); // LUCENENET: Removed unnecessary cast
} // numBytes is 3
else
{
- outputArray[outputCharNum] = (char)(((inputArray[inputByteNum] & 0xFF) << codingCase.initialShift) + ((inputArray[inputByteNum + 1] & 0xFF) << codingCase.middleShift) + (((int)((uint)(inputArray[inputByteNum + 2] & 0xFF) >> codingCase.finalShift)) & codingCase.finalMask) & (short)0x7FFF);
+ outputArray[outputCharNum] = (char)(((inputArray[inputByteNum] & 0xFF) << codingCase.initialShift)
+ + ((inputArray[inputByteNum + 1] & 0xFF) << codingCase.middleShift)
+ + (((inputArray[inputByteNum + 2] & 0xFF).TripleShift(codingCase.finalShift)) & codingCase.finalMask) & /*(short)*/0x7FFF); // LUCENENET: Removed unnecessary cast
}
inputByteNum += codingCase.advanceBytes;
if (++caseNum == CODING_CASES.Length)
@@ -175,13 +179,14 @@ namespace Lucene.Net.Util
if (inputByteNum + 1 < inputLength) // codingCase.numBytes must be 3
{
- outputArray[outputCharNum++] = (char)((((inputArray[inputByteNum] & 0xFF) << codingCase.initialShift) + ((inputArray[inputByteNum + 1] & 0xFF) << codingCase.middleShift)) & (short)0x7FFF);
+ outputArray[outputCharNum++] = (char)((((inputArray[inputByteNum] & 0xFF) << codingCase.initialShift) + ((inputArray[inputByteNum + 1] & 0xFF) <<
+ codingCase.middleShift)) & /*(short)*/0x7FFF); // LUCENENET: Removed unnecessary cast
// Add trailing char containing the number of full bytes in final char
outputArray[outputCharNum++] = (char)1;
}
else if (inputByteNum < inputLength)
{
- outputArray[outputCharNum++] = (char)(((inputArray[inputByteNum] & 0xFF) << codingCase.initialShift) & (short)0x7FFF);
+ outputArray[outputCharNum++] = (char)(((inputArray[inputByteNum] & 0xFF) << codingCase.initialShift) & /*(short)*/0x7FFF); // LUCENENET: Removed unnecessary cast
// Add trailing char containing the number of full bytes in final char
outputArray[outputCharNum++] = caseNum == 0 ? (char)1 : (char)0;
} // No left over bits - last char is completely filled.
@@ -246,18 +251,18 @@ namespace Lucene.Net.Util
{
if (0 == caseNum)
{
- outputArray[outputByteNum] = (sbyte)((short)((ushort)inputChar >> codingCase.initialShift));
+ outputArray[outputByteNum] = (sbyte)(inputChar.TripleShift(codingCase.initialShift));
}
else
{
- outputArray[outputByteNum] += (sbyte)((short)((ushort)inputChar >> codingCase.initialShift));
+ outputArray[outputByteNum] += (sbyte)(inputChar.TripleShift(codingCase.initialShift));
}
outputArray[outputByteNum + 1] = (sbyte)((inputChar & codingCase.finalMask) << codingCase.finalShift);
} // numBytes is 3
else
{
- outputArray[outputByteNum] += (sbyte)((short)((ushort)inputChar >> codingCase.initialShift));
- outputArray[outputByteNum + 1] = (sbyte)((int)((uint)(inputChar & codingCase.middleMask) >> codingCase.middleShift));
+ outputArray[outputByteNum] += (sbyte)(inputChar.TripleShift(codingCase.initialShift));
+ outputArray[outputByteNum + 1] = (sbyte)((inputChar & codingCase.middleMask).TripleShift(codingCase.middleShift));
outputArray[outputByteNum + 2] = (sbyte)((inputChar & codingCase.finalMask) << codingCase.finalShift);
}
outputByteNum += codingCase.advanceBytes;
@@ -273,17 +278,17 @@ namespace Lucene.Net.Util
{
outputArray[outputByteNum] = 0;
}
- outputArray[outputByteNum] += (sbyte)((short)((ushort)inputChar >> codingCase.initialShift));
+ outputArray[outputByteNum] += (sbyte)(inputChar.TripleShift(codingCase.initialShift));
int bytesLeft = numOutputBytes - outputByteNum;
if (bytesLeft > 1)
{
if (2 == codingCase.numBytes)
{
- outputArray[outputByteNum + 1] = (sbyte)((int)((uint)(inputChar & codingCase.finalMask) >> codingCase.finalShift));
+ outputArray[outputByteNum + 1] = (sbyte)((inputChar & codingCase.finalMask).TripleShift(codingCase.finalShift));
} // numBytes is 3
else
{
- outputArray[outputByteNum + 1] = (sbyte)((int)((uint)(inputChar & codingCase.middleMask) >> codingCase.middleShift));
+ outputArray[outputByteNum + 1] = (sbyte)((inputChar & codingCase.middleMask).TripleShift(codingCase.middleShift));
if (bytesLeft > 2)
{
outputArray[outputByteNum + 2] = (sbyte)((inputChar & codingCase.finalMask) << codingCase.finalShift);
@@ -304,8 +309,8 @@ namespace Lucene.Net.Util
this.initialShift = initialShift;
this.middleShift = middleShift;
this.finalShift = finalShift;
- this.finalMask = (short)((int)((uint)(short)0xFF >> finalShift));
- this.middleMask = (short)((short)0xFF << middleShift);
+ this.finalMask = /*(short)*/((short)0xFF.TripleShift(finalShift)); // LUCENENET: Removed unnecessary cast
+ this.middleMask = (short)(/*(short)*/0xFF << middleShift); // LUCENENET: Removed unnecessary cast
}
internal CodingCase(int initialShift, int finalShift)
@@ -313,7 +318,7 @@ namespace Lucene.Net.Util
this.numBytes = 2;
this.initialShift = initialShift;
this.finalShift = finalShift;
- this.finalMask = (short)((int)((uint)(short)0xFF >> finalShift));
+ this.finalMask = /*(short)*/((short)0xFF.TripleShift(finalShift)); // LUCENENET: Removed unnecessary cast
if (finalShift != 0)
{
advanceBytes = 1;
diff --git a/src/Lucene.Net/Util/IntroSorter.cs b/src/Lucene.Net/Util/IntroSorter.cs
index e06bf4b..a5ebd05 100644
--- a/src/Lucene.Net/Util/IntroSorter.cs
+++ b/src/Lucene.Net/Util/IntroSorter.cs
@@ -1,4 +1,4 @@
-using J2N.Numerics;
+using J2N.Numerics;
using System.Runtime.CompilerServices;
namespace Lucene.Net.Util
@@ -69,7 +69,7 @@ namespace Lucene.Net.Util
return;
}
- int mid = (int)((uint)(from + to) >> 1);
+ int mid = (from + to).TripleShift(1);
if (Compare(from, mid) > 0)
{
diff --git a/src/Lucene.Net/Util/LongBitSet.cs b/src/Lucene.Net/Util/LongBitSet.cs
index 7295513..ca87789 100644
--- a/src/Lucene.Net/Util/LongBitSet.cs
+++ b/src/Lucene.Net/Util/LongBitSet.cs
@@ -1,4 +1,4 @@
-using J2N.Numerics;
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Support;
using System;
@@ -73,7 +73,7 @@ namespace Lucene.Net.Util
/// Returns the number of 64 bit words it would take to hold <paramref name="numBits"/>. </summary>
public static int Bits2words(long numBits)
{
- int numLong = (int)((long)((ulong)numBits >> 6));
+ int numLong = (int)numBits.TripleShift(6);
if ((numBits & 63) != 0)
{
numLong++;
@@ -329,7 +329,7 @@ namespace Lucene.Net.Util
*/
long startmask = -1L << (int)startIndex;
- long endmask = (long)(unchecked(((ulong)-1L)) >> (int)-endIndex); // 64-(endIndex&0x3f) is the same as -endIndex due to wrap
+ long endmask = (-1L).TripleShift((int)-endIndex); // 64-(endIndex&0x3f) is the same as -endIndex due to wrap
if (startWord == endWord)
{
@@ -368,7 +368,7 @@ namespace Lucene.Net.Util
int endWord = (int)((endIndex - 1) >> 6);
long startmask = -1L << (int)startIndex;
- long endmask = (long)(0xffffffffffffffffUL >> (int)-endIndex);//-(int)((uint)1L >> (int)-endIndex); // 64-(endIndex&0x3f) is the same as -endIndex due to wrap
+ long endmask = (-1L).TripleShift((int)-endIndex); // 64-(endIndex&0x3f) is the same as -endIndex due to wrap
if (startWord == endWord)
{
@@ -456,7 +456,7 @@ namespace Lucene.Net.Util
for (int i = numWords; --i >= 0; )
{
h ^= bits[i];
- h = (h << 1) | ((long)((ulong)h >> 63)); // rotate left
+ h = (h << 1) | (h.TripleShift(63)); // rotate left
}
// fold leftmost bits into right and add a constant to prevent
// empty sets from returning 0, which is too common.
diff --git a/src/Lucene.Net/Util/LongsRef.cs b/src/Lucene.Net/Util/LongsRef.cs
index 90f07e0..03443bc 100644
--- a/src/Lucene.Net/Util/LongsRef.cs
+++ b/src/Lucene.Net/Util/LongsRef.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Support;
using System;
@@ -117,7 +118,7 @@ namespace Lucene.Net.Util
long end = Offset + Length;
for (int i = Offset; i < end; i++)
{
- result = prime * result + (int)(longs[i] ^ ((long)((ulong)longs[i] >> 32)));
+ result = prime * result + (int)(longs[i] ^ (longs[i].TripleShift(32)));
}
return result;
}
diff --git a/src/Lucene.Net/Util/MathUtil.cs b/src/Lucene.Net/Util/MathUtil.cs
index 02de931..86b3fc2 100644
--- a/src/Lucene.Net/Util/MathUtil.cs
+++ b/src/Lucene.Net/Util/MathUtil.cs
@@ -1,4 +1,4 @@
-using J2N.Numerics;
+using J2N.Numerics;
using System;
using System.Runtime.CompilerServices;
@@ -78,10 +78,10 @@ namespace Lucene.Net.Util
return a;
}
int commonTrailingZeros = (a | b).TrailingZeroCount();
- a = (long)((ulong)a >> a.TrailingZeroCount());
+ a = a.TripleShift(a.TrailingZeroCount());
while (true)
{
- b = (long)((ulong)b >> b.TrailingZeroCount());
+ b = b.TripleShift(b.TrailingZeroCount());
if (a == b)
{
break;
diff --git a/src/Lucene.Net/Util/Mutable/MutableValueDouble.cs b/src/Lucene.Net/Util/Mutable/MutableValueDouble.cs
index f61494a..2490cc8 100644
--- a/src/Lucene.Net/Util/Mutable/MutableValueDouble.cs
+++ b/src/Lucene.Net/Util/Mutable/MutableValueDouble.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using System.Runtime.CompilerServices;
namespace Lucene.Net.Util.Mutable
@@ -81,7 +82,7 @@ namespace Lucene.Net.Util.Mutable
public override int GetHashCode()
{
long x = J2N.BitConversion.DoubleToInt64Bits(Value);
- return (int)x + (int)((long)((ulong)x >> 32));
+ return (int)x + (int)x.TripleShift(32);
}
}
}
\ No newline at end of file
diff --git a/src/Lucene.Net/Util/OpenBitSet.cs b/src/Lucene.Net/Util/OpenBitSet.cs
index 48e5ec6..de94d41 100644
--- a/src/Lucene.Net/Util/OpenBitSet.cs
+++ b/src/Lucene.Net/Util/OpenBitSet.cs
@@ -1,4 +1,4 @@
-using J2N.Numerics;
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Support;
using System;
@@ -260,7 +260,7 @@ namespace Lucene.Net.Util
if (Debugging.AssertsEnabled) Debugging.Assert(index >= 0 && index < numBits);
int i = index >> 6; // div 64
int bit = index & 0x3f; // mod 64
- return ((int)((long)((ulong)m_bits[i] >> bit))) & 0x01;
+ return ((int)m_bits[i].TripleShift(bit)) & 0x01;
}
/*
@@ -467,7 +467,7 @@ namespace Lucene.Net.Util
int endWord = (int)((endIndex - 1) >> 6);
long startmask = -1L << (int)startIndex;
- long endmask = -(int)((uint)1L >> (int)-endIndex); // 64-(endIndex&0x3f) is the same as -endIndex due to wrap
+ long endmask = (-1L).TripleShift((int)-endIndex); // 64-(endIndex&0x3f) is the same as -endIndex due to wrap
// invert masks since we are clearing
startmask = ~startmask;
@@ -757,13 +757,13 @@ namespace Lucene.Net.Util
/// </summary>
public virtual long NextSetBit(long index)
{
- int i = (int)((long)((ulong)index >> 6));
+ int i = (int)index.TripleShift(6);
if (i >= m_wlen)
{
return -1;
}
int subIndex = (int)index & 0x3f; // index within the word
- long word = (long)((ulong)m_bits[i] >> subIndex); // skip all the bits to the right of index
+ long word = m_bits[i].TripleShift(subIndex); // skip all the bits to the right of index
if (word != 0)
{
@@ -1110,7 +1110,7 @@ namespace Lucene.Net.Util
for (int i = m_bits.Length; --i >= 0; )
{
h ^= m_bits[i];
- h = (h << 1) | ((long)((ulong)h >> 63)); // rotate left
+ h = (h << 1) | (h.TripleShift(63)); // rotate left
}
// fold leftmost bits into right and add a constant to prevent
// empty sets from returning 0, which is too common.
diff --git a/src/Lucene.Net/Util/OpenBitSetIterator.cs b/src/Lucene.Net/Util/OpenBitSetIterator.cs
index a09cfe5..0bf27e8 100644
--- a/src/Lucene.Net/Util/OpenBitSetIterator.cs
+++ b/src/Lucene.Net/Util/OpenBitSetIterator.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using System.Runtime.CompilerServices;
namespace Lucene.Net.Util
@@ -58,17 +59,17 @@ namespace Lucene.Net.Util
if ((int)word == 0)
{
wordShift += 32;
- word = (long)((ulong)word >> 32);
+ word = word.TripleShift(32);
}
if ((word & 0x0000FFFF) == 0)
{
wordShift += 16;
- word = (long)((ulong)word >> 16);
+ word = word.TripleShift(16);
}
if ((word & 0x000000FF) == 0)
{
wordShift += 8;
- word = (long)((ulong)word >> 8);
+ word = word.TripleShift(8);
}
indexArray = BitUtil.BitList((byte)word);
}
@@ -101,7 +102,7 @@ namespace Lucene.Net.Util
{
if (word != 0)
{
- word = (long)((ulong)word >> 8);
+ word = word.TripleShift(8);
wordShift += 8;
}
@@ -121,7 +122,7 @@ namespace Lucene.Net.Util
}
int bitIndex = (indexArray & 0x0f) + wordShift;
- indexArray = (int)((uint)indexArray >> 4);
+ indexArray = indexArray.TripleShift(4);
// should i<<6 be cached as a separate variable?
// it would only save one cycle in the best circumstances.
return curDocId = (i << 6) + bitIndex;
@@ -137,7 +138,7 @@ namespace Lucene.Net.Util
return curDocId = NO_MORE_DOCS;
}
wordShift = target & 0x3f;
- word = (long)((ulong)arr[i] >> wordShift);
+ word = arr[i].TripleShift(wordShift);
if (word != 0)
{
wordShift--; // compensate for 1 based arrIndex
@@ -158,7 +159,7 @@ namespace Lucene.Net.Util
Shift();
int bitIndex = (indexArray & 0x0f) + wordShift;
- indexArray = (int)((uint)indexArray >> 4);
+ indexArray = indexArray.TripleShift(4);
// should i<<6 be cached as a separate variable?
// it would only save one cycle in the best circumstances.
return curDocId = (i << 6) + bitIndex;
diff --git a/src/Lucene.Net/Util/PForDeltaDocIdSet.cs b/src/Lucene.Net/Util/PForDeltaDocIdSet.cs
index a3b61b1..84c2a64 100644
--- a/src/Lucene.Net/Util/PForDeltaDocIdSet.cs
+++ b/src/Lucene.Net/Util/PForDeltaDocIdSet.cs
@@ -183,7 +183,7 @@ namespace Lucene.Net.Util
{
deltaSum += 1 + buffer[i];
}
- int blockSize = (int)((uint)(deltaSum + 0x07) >> 3); // round to the next byte
+ int blockSize = (deltaSum + 0x07).TripleShift(3); // round to the next byte
++blockSize; // header
if (bufferSize < BLOCK_SIZE)
{
@@ -233,7 +233,7 @@ namespace Lucene.Net.Util
if (buffer[i] > mask)
{
exceptionIndices[ex] = i;
- exceptions[ex++] = (int)((uint)buffer[i] >> bitsPerValue);
+ exceptions[ex++] = buffer[i].TripleShift(bitsPerValue);
buffer[i] &= mask;
}
}
@@ -483,7 +483,7 @@ namespace Lucene.Net.Util
for (int i = 0; i < BLOCK_SIZE; )
{
var b = data[offset++];
- for (int bitList = BitUtil.BitList(b); bitList != 0; ++i, bitList = (int)((uint)bitList >> 4))
+ for (int bitList = BitUtil.BitList(b); bitList != 0; ++i, bitList = bitList.TripleShift(4))
{
nextDocs[i] = docID + (bitList & 0x0F);
}
@@ -561,7 +561,7 @@ namespace Lucene.Net.Util
// we found a window containing our target, let's binary search now
while (lo <= hi)
{
- int mid = (int)((uint)(lo + hi) >> 1);
+ int mid = (lo + hi).TripleShift(1);
int midDocID = (int)docIDs.Get(mid);
if (midDocID <= target)
{
diff --git a/src/Lucene.Net/Util/Packed/AbstractBlockPackedWriter.cs b/src/Lucene.Net/Util/Packed/AbstractBlockPackedWriter.cs
index 78a3d2c..9d3d85f 100644
--- a/src/Lucene.Net/Util/Packed/AbstractBlockPackedWriter.cs
+++ b/src/Lucene.Net/Util/Packed/AbstractBlockPackedWriter.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Diagnostics;
+using J2N.Numerics;
+using Lucene.Net.Diagnostics;
using Lucene.Net.Support;
using System;
using System.Runtime.CompilerServices;
@@ -48,7 +49,7 @@ namespace Lucene.Net.Util.Packed
while ((i & ~0x7FL) != 0L && k++ < 8)
{
@out.WriteByte((byte)((i & 0x7FL) | 0x80L));
- i = (long)((ulong)i >> 7);
+ i = i.TripleShift(7);
}
@out.WriteByte((byte)i);
}
diff --git a/src/Lucene.Net/Util/Packed/AbstractPagedMutable.cs b/src/Lucene.Net/Util/Packed/AbstractPagedMutable.cs
index 0a9a670..a90b0a9 100644
--- a/src/Lucene.Net/Util/Packed/AbstractPagedMutable.cs
+++ b/src/Lucene.Net/Util/Packed/AbstractPagedMutable.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using System;
using System.Runtime.CompilerServices;
@@ -79,7 +80,7 @@ namespace Lucene.Net.Util.Packed
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal int PageIndex(long index)
{
- return (int)((long)((ulong)index >> pageShift));
+ return (int)index.TripleShift(pageShift);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -160,7 +161,7 @@ namespace Lucene.Net.Util.Packed
T result = (T)this;
return result;
}
- long extra = (long)((ulong)minSize >> 3);
+ long extra = minSize.TripleShift(3);
if (extra < 3)
{
extra = 3;
diff --git a/src/Lucene.Net/Util/Packed/BlockPackedReader.cs b/src/Lucene.Net/Util/Packed/BlockPackedReader.cs
index f32c4ca..ac80ba4 100644
--- a/src/Lucene.Net/Util/Packed/BlockPackedReader.cs
+++ b/src/Lucene.Net/Util/Packed/BlockPackedReader.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Store;
using System;
@@ -46,7 +47,7 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < numBlocks; ++i)
{
int token = @in.ReadByte() & 0xFF;
- int bitsPerValue = (int)((uint)token >> AbstractBlockPackedWriter.BPV_SHIFT);
+ int bitsPerValue = token.TripleShift(AbstractBlockPackedWriter.BPV_SHIFT);
if (bitsPerValue > 64)
{
throw new Exception("Corrupted");
@@ -84,7 +85,7 @@ namespace Lucene.Net.Util.Packed
public override long Get(long index)
{
if (Debugging.AssertsEnabled) Debugging.Assert(index >= 0 && index < valueCount);
- int block = (int)((long)((ulong)index >> blockShift));
+ int block = (int)(index.TripleShift(blockShift));
int idx = (int)(index & blockMask);
return (minValues == null ? 0 : minValues[block]) + subReaders[block].Get(idx);
}
diff --git a/src/Lucene.Net/Util/Packed/BlockPackedReaderIterator.cs b/src/Lucene.Net/Util/Packed/BlockPackedReaderIterator.cs
index d0b7c49..b35825d 100644
--- a/src/Lucene.Net/Util/Packed/BlockPackedReaderIterator.cs
+++ b/src/Lucene.Net/Util/Packed/BlockPackedReaderIterator.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Support;
using System;
@@ -37,7 +38,7 @@ namespace Lucene.Net.Util.Packed
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static long ZigZagDecode(long n)
{
- return (((long)((ulong)n >> 1)) ^ -(n & 1));
+ return ((n.TripleShift(1)) ^ -(n & 1));
}
// same as DataInput.ReadVInt64 but supports negative values
@@ -163,7 +164,7 @@ namespace Lucene.Net.Util.Packed
while (count >= blockSize)
{
int token = @in.ReadByte() & 0xFF;
- int bitsPerValue = (int)((uint)token >> AbstractBlockPackedWriter.BPV_SHIFT);
+ int bitsPerValue = token.TripleShift(AbstractBlockPackedWriter.BPV_SHIFT);
if (bitsPerValue > 64)
{
throw new IOException("Corrupted");
@@ -257,7 +258,7 @@ namespace Lucene.Net.Util.Packed
{
int token = @in.ReadByte() & 0xFF;
bool minEquals0 = (token & AbstractBlockPackedWriter.MIN_VALUE_EQUALS_0) != 0;
- int bitsPerValue = (int)((uint)token >> AbstractBlockPackedWriter.BPV_SHIFT);
+ int bitsPerValue = token.TripleShift(AbstractBlockPackedWriter.BPV_SHIFT);
if (bitsPerValue > 64)
{
throw new IOException("Corrupted");
diff --git a/src/Lucene.Net/Util/Packed/BulkOperation.cs b/src/Lucene.Net/Util/Packed/BulkOperation.cs
index 63281d4..0987bc8 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperation.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperation.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using System;
@@ -185,7 +186,7 @@ namespace Lucene.Net.Util.Packed
{
for (int j = 1; j <= 8; ++j)
{
- blocks[blocksOffset++] = (byte)((long)((ulong)block >> (64 - (j << 3))));
+ blocks[blocksOffset++] = (byte)block.TripleShift(64 - (j << 3));
}
return blocksOffset;
}
diff --git a/src/Lucene.Net/Util/Packed/BulkOperationPacked.cs b/src/Lucene.Net/Util/Packed/BulkOperationPacked.cs
index a887472..af04385 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperationPacked.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperationPacked.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using System;
@@ -40,7 +41,7 @@ namespace Lucene.Net.Util.Packed
int blocks = bitsPerValue;
while ((blocks & 1) == 0)
{
- blocks = (int)((uint)blocks >> 1);
+ blocks = blocks.TripleShift(1);
}
this.longBlockCount = blocks;
this.longValueCount = 64 * longBlockCount / bitsPerValue;
@@ -48,8 +49,8 @@ namespace Lucene.Net.Util.Packed
int byteValueCount = longValueCount;
while ((byteBlockCount & 1) == 0 && (byteValueCount & 1) == 0)
{
- byteBlockCount = (int)((uint)byteBlockCount >> 1);
- byteValueCount = (int)((uint)byteValueCount >> 1);
+ byteBlockCount = byteBlockCount.TripleShift(1);
+ byteValueCount = byteValueCount.TripleShift(1);
}
this.byteBlockCount = byteBlockCount;
this.byteValueCount = byteValueCount;
@@ -87,12 +88,12 @@ namespace Lucene.Net.Util.Packed
bitsLeft -= bitsPerValue;
if (bitsLeft < 0)
{
- values[valuesOffset++] = ((blocks[blocksOffset++] & ((1L << (bitsPerValue + bitsLeft)) - 1)) << -bitsLeft) | ((long)((ulong)blocks[blocksOffset] >> (64 + bitsLeft)));
+ values[valuesOffset++] = ((blocks[blocksOffset++] & ((1L << (bitsPerValue + bitsLeft)) - 1)) << -bitsLeft) | (blocks[blocksOffset].TripleShift(64 + bitsLeft));
bitsLeft += 64;
}
else
{
- values[valuesOffset++] = ((long)((ulong)blocks[blocksOffset] >> bitsLeft)) & mask;
+ values[valuesOffset++] = (blocks[blocksOffset].TripleShift(bitsLeft)) & mask;
}
}
}
@@ -114,11 +115,11 @@ namespace Lucene.Net.Util.Packed
{
// flush
int bits = 8 - bitsLeft;
- values[valuesOffset++] = nextValue | ((long)((ulong)bytes >> bits));
+ values[valuesOffset++] = nextValue | (bytes.TripleShift(bits));
while (bits >= bitsPerValue)
{
bits -= bitsPerValue;
- values[valuesOffset++] = ((long)((ulong)bytes >> bits)) & mask;
+ values[valuesOffset++] = (bytes.TripleShift(bits)) & mask;
}
// then buffer
bitsLeft = bitsPerValue - bits;
@@ -140,12 +141,12 @@ namespace Lucene.Net.Util.Packed
bitsLeft -= bitsPerValue;
if (bitsLeft < 0)
{
- values[valuesOffset++] = (int)(((blocks[blocksOffset++] & ((1L << (bitsPerValue + bitsLeft)) - 1)) << -bitsLeft) | ((long)((ulong)blocks[blocksOffset] >> (64 + bitsLeft))));
+ values[valuesOffset++] = (int)(((blocks[blocksOffset++] & ((1L << (bitsPerValue + bitsLeft)) - 1)) << -bitsLeft) | (blocks[blocksOffset].TripleShift(64 + bitsLeft)));
bitsLeft += 64;
}
else
{
- values[valuesOffset++] = (int)(((long)((ulong)blocks[blocksOffset] >> bitsLeft)) & mask);
+ values[valuesOffset++] = (int)((blocks[blocksOffset].TripleShift(bitsLeft)) & mask);
}
}
}
@@ -167,11 +168,11 @@ namespace Lucene.Net.Util.Packed
{
// flush
int bits = 8 - bitsLeft;
- values[valuesOffset++] = nextValue | ((int)((uint)bytes >> bits));
+ values[valuesOffset++] = nextValue | (bytes.TripleShift(bits));
while (bits >= bitsPerValue)
{
bits -= bitsPerValue;
- values[valuesOffset++] = ((int)((uint)bytes >> bits)) & intMask;
+ values[valuesOffset++] = (bytes.TripleShift(bits)) & intMask;
}
// then buffer
bitsLeft = bitsPerValue - bits;
@@ -201,7 +202,7 @@ namespace Lucene.Net.Util.Packed
} // bitsLeft < 0
else
{
- nextBlock |= (long)((ulong)values[valuesOffset] >> -bitsLeft);
+ nextBlock |= values[valuesOffset].TripleShift(-bitsLeft);
blocks[blocksOffset++] = nextBlock;
nextBlock = (values[valuesOffset++] & ((1L << -bitsLeft) - 1)) << (64 + bitsLeft);
bitsLeft += 64;
@@ -229,7 +230,7 @@ namespace Lucene.Net.Util.Packed
} // bitsLeft < 0
else
{
- nextBlock |= ((uint)(values[valuesOffset] & 0xFFFFFFFFL) >> -bitsLeft);
+ nextBlock |= (values[valuesOffset] & 0xFFFFFFFFL).TripleShift(-bitsLeft);
blocks[blocksOffset++] = nextBlock;
nextBlock = (values[valuesOffset++] & ((1L << -bitsLeft) - 1)) << (64 + bitsLeft);
bitsLeft += 64;
@@ -255,11 +256,11 @@ namespace Lucene.Net.Util.Packed
{
// flush as many blocks as possible
int bits = bitsPerValue - bitsLeft;
- blocks[blocksOffset++] = (byte)((uint)nextBlock | ((long)((ulong)v >> bits)));
+ blocks[blocksOffset++] = (byte)((uint)nextBlock | (v.TripleShift(bits)));
while (bits >= 8)
{
bits -= 8;
- blocks[blocksOffset++] = (byte)((long)((ulong)v >> bits));
+ blocks[blocksOffset++] = (byte)(v.TripleShift(bits));
}
// then buffer
bitsLeft = 8 - bits;
@@ -287,11 +288,11 @@ namespace Lucene.Net.Util.Packed
{
// flush as many blocks as possible
int bits = bitsPerValue - bitsLeft;
- blocks[blocksOffset++] = (byte)(nextBlock | ((int)((uint)v >> bits)));
+ blocks[blocksOffset++] = (byte)(nextBlock | (v.TripleShift(bits)));
while (bits >= 8)
{
bits -= 8;
- blocks[blocksOffset++] = (byte)((int)((uint)v >> bits));
+ blocks[blocksOffset++] = (byte)(v.TripleShift(bits));
}
// then buffer
bitsLeft = 8 - bits;
diff --git a/src/Lucene.Net/Util/Packed/BulkOperationPacked1.cs b/src/Lucene.Net/Util/Packed/BulkOperationPacked1.cs
index 76c53e1..38dbe3e 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperationPacked1.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperationPacked1.cs
@@ -1,4 +1,6 @@
-// this file has been automatically generated, DO NOT EDIT
+// this file has been automatically generated, DO NOT EDIT
+
+using J2N.Numerics;
namespace Lucene.Net.Util.Packed
{
@@ -36,7 +38,7 @@ namespace Lucene.Net.Util.Packed
long block = blocks[blocksOffset++];
for (int shift = 63; shift >= 0; shift -= 1)
{
- values[valuesOffset++] = (int)(((long)((ulong)block >> shift)) & 1);
+ values[valuesOffset++] = (int)((block.TripleShift(shift)) & 1);
}
}
}
@@ -46,13 +48,13 @@ namespace Lucene.Net.Util.Packed
for (int j = 0; j < iterations; ++j)
{
var block = blocks[blocksOffset++];
- values[valuesOffset++] = ((int)((uint)block >> 7)) & 1;
- values[valuesOffset++] = ((int)((uint)block >> 6)) & 1;
- values[valuesOffset++] = ((int)((uint)block >> 5)) & 1;
- values[valuesOffset++] = ((int)((uint)block >> 4)) & 1;
- values[valuesOffset++] = ((int)((uint)block >> 3)) & 1;
- values[valuesOffset++] = ((int)((uint)block >> 2)) & 1;
- values[valuesOffset++] = ((int)((uint)block >> 1)) & 1;
+ values[valuesOffset++] = block.TripleShift(7) & 1;
+ values[valuesOffset++] = block.TripleShift(6) & 1;
+ values[valuesOffset++] = block.TripleShift(5) & 1;
+ values[valuesOffset++] = block.TripleShift(4) & 1;
+ values[valuesOffset++] = block.TripleShift(3) & 1;
+ values[valuesOffset++] = block.TripleShift(2) & 1;
+ values[valuesOffset++] = block.TripleShift(1) & 1;
values[valuesOffset++] = block & 1;
}
}
@@ -64,7 +66,7 @@ namespace Lucene.Net.Util.Packed
long block = blocks[blocksOffset++];
for (int shift = 63; shift >= 0; shift -= 1)
{
- values[valuesOffset++] = ((long)((ulong)block >> shift)) & 1;
+ values[valuesOffset++] = (block.TripleShift(shift)) & 1;
}
}
}
@@ -74,13 +76,13 @@ namespace Lucene.Net.Util.Packed
for (int j = 0; j < iterations; ++j)
{
var block = blocks[blocksOffset++];
- values[valuesOffset++] = ((int)((uint)block >> 7)) & 1;
- values[valuesOffset++] = ((int)((uint)block >> 6)) & 1;
- values[valuesOffset++] = ((int)((uint)block >> 5)) & 1;
- values[valuesOffset++] = ((int)((uint)block >> 4)) & 1;
- values[valuesOffset++] = ((int)((uint)block >> 3)) & 1;
- values[valuesOffset++] = ((int)((uint)block >> 2)) & 1;
- values[valuesOffset++] = ((int)((uint)block >> 1)) & 1;
+ values[valuesOffset++] = block.TripleShift(7) & 1;
+ values[valuesOffset++] = block.TripleShift(6) & 1;
+ values[valuesOffset++] = block.TripleShift(5) & 1;
+ values[valuesOffset++] = block.TripleShift(4) & 1;
+ values[valuesOffset++] = block.TripleShift(3) & 1;
+ values[valuesOffset++] = block.TripleShift(2) & 1;
+ values[valuesOffset++] = block.TripleShift(1) & 1;
values[valuesOffset++] = block & 1;
}
}
diff --git a/src/Lucene.Net/Util/Packed/BulkOperationPacked10.cs b/src/Lucene.Net/Util/Packed/BulkOperationPacked10.cs
index 521d7b6..92adcca 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperationPacked10.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperationPacked10.cs
@@ -1,4 +1,6 @@
-// this file has been automatically generated, DO NOT EDIT
+// this file has been automatically generated, DO NOT EDIT
+
+using J2N.Numerics;
namespace Lucene.Net.Util.Packed
{
@@ -34,41 +36,41 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)((long)((ulong)block0 >> 54));
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 44)) & 1023L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 34)) & 1023L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 24)) & 1023L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 14)) & 1023L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 4)) & 1023L);
+ values[valuesOffset++] = (int)(block0.TripleShift(54));
+ values[valuesOffset++] = (int)((block0.TripleShift(44)) & 1023L);
+ values[valuesOffset++] = (int)((block0.TripleShift(34)) & 1023L);
+ values[valuesOffset++] = (int)((block0.TripleShift(24)) & 1023L);
+ values[valuesOffset++] = (int)((block0.TripleShift(14)) & 1023L);
+ values[valuesOffset++] = (int)((block0.TripleShift(4)) & 1023L);
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block0 & 15L) << 6) | ((long)((ulong)block1 >> 58)));
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 48)) & 1023L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 38)) & 1023L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 28)) & 1023L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 18)) & 1023L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 8)) & 1023L);
+ values[valuesOffset++] = (int)(((block0 & 15L) << 6) | (block1.TripleShift(58)));
+ values[valuesOffset++] = (int)((block1.TripleShift(48)) & 1023L);
+ values[valuesOffset++] = (int)((block1.TripleShift(38)) & 1023L);
+ values[valuesOffset++] = (int)((block1.TripleShift(28)) & 1023L);
+ values[valuesOffset++] = (int)((block1.TripleShift(18)) & 1023L);
+ values[valuesOffset++] = (int)((block1.TripleShift(8)) & 1023L);
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block1 & 255L) << 2) | ((long)((ulong)block2 >> 62)));
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 52)) & 1023L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 42)) & 1023L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 32)) & 1023L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 22)) & 1023L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 12)) & 1023L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 2)) & 1023L);
+ values[valuesOffset++] = (int)(((block1 & 255L) << 2) | (block2.TripleShift(62)));
+ values[valuesOffset++] = (int)((block2.TripleShift(52)) & 1023L);
+ values[valuesOffset++] = (int)((block2.TripleShift(42)) & 1023L);
+ values[valuesOffset++] = (int)((block2.TripleShift(32)) & 1023L);
+ values[valuesOffset++] = (int)((block2.TripleShift(22)) & 1023L);
+ values[valuesOffset++] = (int)((block2.TripleShift(12)) & 1023L);
+ values[valuesOffset++] = (int)((block2.TripleShift(2)) & 1023L);
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block2 & 3L) << 8) | ((long)((ulong)block3 >> 56)));
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 46)) & 1023L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 36)) & 1023L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 26)) & 1023L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 16)) & 1023L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 6)) & 1023L);
+ values[valuesOffset++] = (int)(((block2 & 3L) << 8) | (block3.TripleShift(56)));
+ values[valuesOffset++] = (int)((block3.TripleShift(46)) & 1023L);
+ values[valuesOffset++] = (int)((block3.TripleShift(36)) & 1023L);
+ values[valuesOffset++] = (int)((block3.TripleShift(26)) & 1023L);
+ values[valuesOffset++] = (int)((block3.TripleShift(16)) & 1023L);
+ values[valuesOffset++] = (int)((block3.TripleShift(6)) & 1023L);
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block3 & 63L) << 4) | ((long)((ulong)block4 >> 60)));
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 50)) & 1023L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 40)) & 1023L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 30)) & 1023L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 20)) & 1023L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 10)) & 1023L);
+ values[valuesOffset++] = (int)(((block3 & 63L) << 4) | (block4.TripleShift(60)));
+ values[valuesOffset++] = (int)((block4.TripleShift(50)) & 1023L);
+ values[valuesOffset++] = (int)((block4.TripleShift(40)) & 1023L);
+ values[valuesOffset++] = (int)((block4.TripleShift(30)) & 1023L);
+ values[valuesOffset++] = (int)((block4.TripleShift(20)) & 1023L);
+ values[valuesOffset++] = (int)((block4.TripleShift(10)) & 1023L);
values[valuesOffset++] = (int)(block4 & 1023L);
}
}
@@ -79,11 +81,11 @@ namespace Lucene.Net.Util.Packed
{
int byte0 = blocks[blocksOffset++] & 0xFF;
int byte1 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (byte0 << 2) | ((int)((uint)byte1 >> 6));
+ values[valuesOffset++] = (byte0 << 2) | (byte1.TripleShift(6));
int byte2 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte1 & 63) << 4) | ((int)((uint)byte2 >> 4));
+ values[valuesOffset++] = ((byte1 & 63) << 4) | (byte2.TripleShift(4));
int byte3 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte2 & 15) << 6) | ((int)((uint)byte3 >> 2));
+ values[valuesOffset++] = ((byte2 & 15) << 6) | (byte3.TripleShift(2));
int byte4 = blocks[blocksOffset++] & 0xFF;
values[valuesOffset++] = ((byte3 & 3) << 8) | byte4;
}
@@ -94,41 +96,41 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (long)((ulong)block0 >> 54);
- values[valuesOffset++] = ((long)((ulong)block0 >> 44)) & 1023L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 34)) & 1023L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 24)) & 1023L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 14)) & 1023L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 4)) & 1023L;
+ values[valuesOffset++] = (block0.TripleShift(54));
+ values[valuesOffset++] = (block0.TripleShift(44)) & 1023L;
+ values[valuesOffset++] = (block0.TripleShift(34)) & 1023L;
+ values[valuesOffset++] = (block0.TripleShift(24)) & 1023L;
+ values[valuesOffset++] = (block0.TripleShift(14)) & 1023L;
+ values[valuesOffset++] = (block0.TripleShift(4)) & 1023L;
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block0 & 15L) << 6) | ((long)((ulong)block1 >> 58));
- values[valuesOffset++] = ((long)((ulong)block1 >> 48)) & 1023L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 38)) & 1023L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 28)) & 1023L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 18)) & 1023L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 8)) & 1023L;
+ values[valuesOffset++] = ((block0 & 15L) << 6) | (block1.TripleShift(58));
+ values[valuesOffset++] = (block1.TripleShift(48)) & 1023L;
+ values[valuesOffset++] = (block1.TripleShift(38)) & 1023L;
+ values[valuesOffset++] = (block1.TripleShift(28)) & 1023L;
+ values[valuesOffset++] = (block1.TripleShift(18)) & 1023L;
+ values[valuesOffset++] = (block1.TripleShift(8)) & 1023L;
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block1 & 255L) << 2) | ((long)((ulong)block2 >> 62));
- values[valuesOffset++] = ((long)((ulong)block2 >> 52)) & 1023L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 42)) & 1023L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 32)) & 1023L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 22)) & 1023L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 12)) & 1023L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 2)) & 1023L;
+ values[valuesOffset++] = ((block1 & 255L) << 2) | (block2.TripleShift(62));
+ values[valuesOffset++] = (block2.TripleShift(52)) & 1023L;
+ values[valuesOffset++] = (block2.TripleShift(42)) & 1023L;
+ values[valuesOffset++] = (block2.TripleShift(32)) & 1023L;
+ values[valuesOffset++] = (block2.TripleShift(22)) & 1023L;
+ values[valuesOffset++] = (block2.TripleShift(12)) & 1023L;
+ values[valuesOffset++] = (block2.TripleShift(2)) & 1023L;
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block2 & 3L) << 8) | ((long)((ulong)block3 >> 56));
- values[valuesOffset++] = ((long)((ulong)block3 >> 46)) & 1023L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 36)) & 1023L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 26)) & 1023L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 16)) & 1023L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 6)) & 1023L;
+ values[valuesOffset++] = ((block2 & 3L) << 8) | (block3.TripleShift(56));
+ values[valuesOffset++] = (block3.TripleShift(46)) & 1023L;
+ values[valuesOffset++] = (block3.TripleShift(36)) & 1023L;
+ values[valuesOffset++] = (block3.TripleShift(26)) & 1023L;
+ values[valuesOffset++] = (block3.TripleShift(16)) & 1023L;
+ values[valuesOffset++] = (block3.TripleShift(6)) & 1023L;
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block3 & 63L) << 4) | ((long)((ulong)block4 >> 60));
- values[valuesOffset++] = ((long)((ulong)block4 >> 50)) & 1023L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 40)) & 1023L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 30)) & 1023L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 20)) & 1023L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 10)) & 1023L;
+ values[valuesOffset++] = ((block3 & 63L) << 4) | (block4.TripleShift(60));
+ values[valuesOffset++] = (block4.TripleShift(50)) & 1023L;
+ values[valuesOffset++] = (block4.TripleShift(40)) & 1023L;
+ values[valuesOffset++] = (block4.TripleShift(30)) & 1023L;
+ values[valuesOffset++] = (block4.TripleShift(20)) & 1023L;
+ values[valuesOffset++] = (block4.TripleShift(10)) & 1023L;
values[valuesOffset++] = block4 & 1023L;
}
}
@@ -139,11 +141,11 @@ namespace Lucene.Net.Util.Packed
{
long byte0 = blocks[blocksOffset++] & 0xFF;
long byte1 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (byte0 << 2) | ((long)((ulong)byte1 >> 6));
+ values[valuesOffset++] = (byte0 << 2) | (byte1.TripleShift(6));
long byte2 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte1 & 63) << 4) | ((long)((ulong)byte2 >> 4));
+ values[valuesOffset++] = ((byte1 & 63) << 4) | (byte2.TripleShift(4));
long byte3 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte2 & 15) << 6) | ((long)((ulong)byte3 >> 2));
+ values[valuesOffset++] = ((byte2 & 15) << 6) | (byte3.TripleShift(2));
long byte4 = blocks[blocksOffset++] & 0xFF;
values[valuesOffset++] = ((byte3 & 3) << 8) | byte4;
}
diff --git a/src/Lucene.Net/Util/Packed/BulkOperationPacked11.cs b/src/Lucene.Net/Util/Packed/BulkOperationPacked11.cs
index f19f299..c945cc1 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperationPacked11.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperationPacked11.cs
@@ -1,4 +1,6 @@
-// this file has been automatically generated, DO NOT EDIT
+// this file has been automatically generated, DO NOT EDIT
+
+using J2N.Numerics;
namespace Lucene.Net.Util.Packed
{
@@ -34,79 +36,79 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)((long)((ulong)block0 >> 53));
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 42)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 31)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 20)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 9)) & 2047L);
+ values[valuesOffset++] = (int)(block0.TripleShift(53));
+ values[valuesOffset++] = (int)((block0.TripleShift(42)) & 2047L);
+ values[valuesOffset++] = (int)((block0.TripleShift(31)) & 2047L);
+ values[valuesOffset++] = (int)((block0.TripleShift(20)) & 2047L);
+ values[valuesOffset++] = (int)((block0.TripleShift(9)) & 2047L);
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block0 & 511L) << 2) | ((long)((ulong)block1 >> 62)));
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 51)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 40)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 29)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 18)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 7)) & 2047L);
+ values[valuesOffset++] = (int)(((block0 & 511L) << 2) | (block1.TripleShift(62)));
+ values[valuesOffset++] = (int)((block1.TripleShift(51)) & 2047L);
+ values[valuesOffset++] = (int)((block1.TripleShift(40)) & 2047L);
+ values[valuesOffset++] = (int)((block1.TripleShift(29)) & 2047L);
+ values[valuesOffset++] = (int)((block1.TripleShift(18)) & 2047L);
+ values[valuesOffset++] = (int)((block1.TripleShift(7)) & 2047L);
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block1 & 127L) << 4) | ((long)((ulong)block2 >> 60)));
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 49)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 38)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 27)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 16)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 5)) & 2047L);
+ values[valuesOffset++] = (int)(((block1 & 127L) << 4) | (block2.TripleShift(60)));
+ values[valuesOffset++] = (int)((block2.TripleShift(49)) & 2047L);
+ values[valuesOffset++] = (int)((block2.TripleShift(38)) & 2047L);
+ values[valuesOffset++] = (int)((block2.TripleShift(27)) & 2047L);
+ values[valuesOffset++] = (int)((block2.TripleShift(16)) & 2047L);
+ values[valuesOffset++] = (int)((block2.TripleShift(5)) & 2047L);
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block2 & 31L) << 6) | ((long)((ulong)block3 >> 58)));
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 47)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 36)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 25)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 14)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 3)) & 2047L);
+ values[valuesOffset++] = (int)(((block2 & 31L) << 6) | (block3.TripleShift(58)));
+ values[valuesOffset++] = (int)((block3.TripleShift(47)) & 2047L);
+ values[valuesOffset++] = (int)((block3.TripleShift(36)) & 2047L);
+ values[valuesOffset++] = (int)((block3.TripleShift(25)) & 2047L);
+ values[valuesOffset++] = (int)((block3.TripleShift(14)) & 2047L);
+ values[valuesOffset++] = (int)((block3.TripleShift(3)) & 2047L);
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block3 & 7L) << 8) | ((long)((ulong)block4 >> 56)));
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 45)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 34)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 23)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 12)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 1)) & 2047L);
+ values[valuesOffset++] = (int)(((block3 & 7L) << 8) | (block4.TripleShift(56)));
+ values[valuesOffset++] = (int)((block4.TripleShift(45)) & 2047L);
+ values[valuesOffset++] = (int)((block4.TripleShift(34)) & 2047L);
+ values[valuesOffset++] = (int)((block4.TripleShift(23)) & 2047L);
+ values[valuesOffset++] = (int)((block4.TripleShift(12)) & 2047L);
+ values[valuesOffset++] = (int)((block4.TripleShift(1)) & 2047L);
long block5 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block4 & 1L) << 10) | ((long)((ulong)block5 >> 54)));
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 43)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 32)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 21)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 10)) & 2047L);
+ values[valuesOffset++] = (int)(((block4 & 1L) << 10) | (block5.TripleShift(54)));
+ values[valuesOffset++] = (int)((block5.TripleShift(43)) & 2047L);
+ values[valuesOffset++] = (int)((block5.TripleShift(32)) & 2047L);
+ values[valuesOffset++] = (int)((block5.TripleShift(21)) & 2047L);
+ values[valuesOffset++] = (int)((block5.TripleShift(10)) & 2047L);
long block6 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block5 & 1023L) << 1) | ((long)((ulong)block6 >> 63)));
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 52)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 41)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 30)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 19)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 8)) & 2047L);
+ values[valuesOffset++] = (int)(((block5 & 1023L) << 1) | (block6.TripleShift(63)));
+ values[valuesOffset++] = (int)((block6.TripleShift(52)) & 2047L);
+ values[valuesOffset++] = (int)((block6.TripleShift(41)) & 2047L);
+ values[valuesOffset++] = (int)((block6.TripleShift(30)) & 2047L);
+ values[valuesOffset++] = (int)((block6.TripleShift(19)) & 2047L);
+ values[valuesOffset++] = (int)((block6.TripleShift(8)) & 2047L);
long block7 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block6 & 255L) << 3) | ((long)((ulong)block7 >> 61)));
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 50)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 39)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 28)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 17)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 6)) & 2047L);
+ values[valuesOffset++] = (int)(((block6 & 255L) << 3) | (block7.TripleShift(61)));
+ values[valuesOffset++] = (int)((block7.TripleShift(50)) & 2047L);
+ values[valuesOffset++] = (int)((block7.TripleShift(39)) & 2047L);
+ values[valuesOffset++] = (int)((block7.TripleShift(28)) & 2047L);
+ values[valuesOffset++] = (int)((block7.TripleShift(17)) & 2047L);
+ values[valuesOffset++] = (int)((block7.TripleShift(6)) & 2047L);
long block8 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block7 & 63L) << 5) | ((long)((ulong)block8 >> 59)));
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 48)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 37)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 26)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 15)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 4)) & 2047L);
+ values[valuesOffset++] = (int)(((block7 & 63L) << 5) | (block8.TripleShift(59)));
+ values[valuesOffset++] = (int)((block8.TripleShift(48)) & 2047L);
+ values[valuesOffset++] = (int)((block8.TripleShift(37)) & 2047L);
+ values[valuesOffset++] = (int)((block8.TripleShift(26)) & 2047L);
+ values[valuesOffset++] = (int)((block8.TripleShift(15)) & 2047L);
+ values[valuesOffset++] = (int)((block8.TripleShift(4)) & 2047L);
long block9 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block8 & 15L) << 7) | ((long)((ulong)block9 >> 57)));
- values[valuesOffset++] = (int)(((long)((ulong)block9 >> 46)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block9 >> 35)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block9 >> 24)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block9 >> 13)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block9 >> 2)) & 2047L);
+ values[valuesOffset++] = (int)(((block8 & 15L) << 7) | (block9.TripleShift(57)));
+ values[valuesOffset++] = (int)((block9.TripleShift(46)) & 2047L);
+ values[valuesOffset++] = (int)((block9.TripleShift(35)) & 2047L);
+ values[valuesOffset++] = (int)((block9.TripleShift(24)) & 2047L);
+ values[valuesOffset++] = (int)((block9.TripleShift(13)) & 2047L);
+ values[valuesOffset++] = (int)((block9.TripleShift(2)) & 2047L);
long block10 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block9 & 3L) << 9) | ((long)((ulong)block10 >> 55)));
- values[valuesOffset++] = (int)(((long)((ulong)block10 >> 44)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block10 >> 33)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block10 >> 22)) & 2047L);
- values[valuesOffset++] = (int)(((long)((ulong)block10 >> 11)) & 2047L);
+ values[valuesOffset++] = (int)(((block9 & 3L) << 9) | (block10.TripleShift(55)));
+ values[valuesOffset++] = (int)((block10.TripleShift(44)) & 2047L);
+ values[valuesOffset++] = (int)((block10.TripleShift(33)) & 2047L);
+ values[valuesOffset++] = (int)((block10.TripleShift(22)) & 2047L);
+ values[valuesOffset++] = (int)((block10.TripleShift(11)) & 2047L);
values[valuesOffset++] = (int)(block10 & 2047L);
}
}
@@ -117,21 +119,21 @@ namespace Lucene.Net.Util.Packed
{
int byte0 = blocks[blocksOffset++] & 0xFF;
int byte1 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (byte0 << 3) | ((int)((uint)byte1 >> 5));
+ values[valuesOffset++] = (byte0 << 3) | (byte1.TripleShift(5));
int byte2 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte1 & 31) << 6) | ((int)((uint)byte2 >> 2));
+ values[valuesOffset++] = ((byte1 & 31) << 6) | (byte2.TripleShift(2));
int byte3 = blocks[blocksOffset++] & 0xFF;
int byte4 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte2 & 3) << 9) | (byte3 << 1) | ((int)((uint)byte4 >> 7));
+ values[valuesOffset++] = ((byte2 & 3) << 9) | (byte3 << 1) | (byte4.TripleShift(7));
int byte5 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte4 & 127) << 4) | ((int)((uint)byte5 >> 4));
+ values[valuesOffset++] = ((byte4 & 127) << 4) | (byte5.TripleShift(4));
int byte6 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte5 & 15) << 7) | ((int)((uint)byte6 >> 1));
+ values[valuesOffset++] = ((byte5 & 15) << 7) | (byte6.TripleShift(1));
int byte7 = blocks[blocksOffset++] & 0xFF;
int byte8 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte6 & 1) << 10) | (byte7 << 2) | ((int)((uint)byte8 >> 6));
+ values[valuesOffset++] = ((byte6 & 1) << 10) | (byte7 << 2) | (byte8.TripleShift(6));
int byte9 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte8 & 63) << 5) | ((int)((uint)byte9 >> 3));
+ values[valuesOffset++] = ((byte8 & 63) << 5) | (byte9.TripleShift(3));
int byte10 = blocks[blocksOffset++] & 0xFF;
values[valuesOffset++] = ((byte9 & 7) << 8) | byte10;
}
@@ -142,79 +144,79 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (long)((ulong)block0 >> 53);
- values[valuesOffset++] = ((long)((ulong)block0 >> 42)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 31)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 20)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 9)) & 2047L;
+ values[valuesOffset++] = block0.TripleShift(53);
+ values[valuesOffset++] = (block0.TripleShift(42)) & 2047L;
+ values[valuesOffset++] = (block0.TripleShift(31)) & 2047L;
+ values[valuesOffset++] = (block0.TripleShift(20)) & 2047L;
+ values[valuesOffset++] = (block0.TripleShift(9)) & 2047L;
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block0 & 511L) << 2) | ((long)((ulong)block1 >> 62));
- values[valuesOffset++] = ((long)((ulong)block1 >> 51)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 40)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 29)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 18)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 7)) & 2047L;
+ values[valuesOffset++] = ((block0 & 511L) << 2) | (block1.TripleShift(62));
+ values[valuesOffset++] = (block1.TripleShift(51)) & 2047L;
+ values[valuesOffset++] = (block1.TripleShift(40)) & 2047L;
+ values[valuesOffset++] = (block1.TripleShift(29)) & 2047L;
+ values[valuesOffset++] = (block1.TripleShift(18)) & 2047L;
+ values[valuesOffset++] = (block1.TripleShift(7)) & 2047L;
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block1 & 127L) << 4) | ((long)((ulong)block2 >> 60));
- values[valuesOffset++] = ((long)((ulong)block2 >> 49)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 38)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 27)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 16)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 5)) & 2047L;
+ values[valuesOffset++] = ((block1 & 127L) << 4) | (block2.TripleShift(60));
+ values[valuesOffset++] = (block2.TripleShift(49)) & 2047L;
+ values[valuesOffset++] = (block2.TripleShift(38)) & 2047L;
+ values[valuesOffset++] = (block2.TripleShift(27)) & 2047L;
+ values[valuesOffset++] = (block2.TripleShift(16)) & 2047L;
+ values[valuesOffset++] = (block2.TripleShift(5)) & 2047L;
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block2 & 31L) << 6) | ((long)((ulong)block3 >> 58));
- values[valuesOffset++] = ((long)((ulong)block3 >> 47)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 36)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 25)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 14)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 3)) & 2047L;
+ values[valuesOffset++] = ((block2 & 31L) << 6) | (block3.TripleShift(58));
+ values[valuesOffset++] = (block3.TripleShift(47)) & 2047L;
+ values[valuesOffset++] = (block3.TripleShift(36)) & 2047L;
+ values[valuesOffset++] = (block3.TripleShift(25)) & 2047L;
+ values[valuesOffset++] = (block3.TripleShift(14)) & 2047L;
+ values[valuesOffset++] = (block3.TripleShift(3)) & 2047L;
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block3 & 7L) << 8) | ((long)((ulong)block4 >> 56));
- values[valuesOffset++] = ((long)((ulong)block4 >> 45)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 34)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 23)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 12)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 1)) & 2047L;
+ values[valuesOffset++] = ((block3 & 7L) << 8) | (block4.TripleShift(56));
+ values[valuesOffset++] = (block4.TripleShift(45)) & 2047L;
+ values[valuesOffset++] = (block4.TripleShift(34)) & 2047L;
+ values[valuesOffset++] = (block4.TripleShift(23)) & 2047L;
+ values[valuesOffset++] = (block4.TripleShift(12)) & 2047L;
+ values[valuesOffset++] = (block4.TripleShift(1)) & 2047L;
long block5 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block4 & 1L) << 10) | ((long)((ulong)block5 >> 54));
- values[valuesOffset++] = ((long)((ulong)block5 >> 43)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 32)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 21)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 10)) & 2047L;
+ values[valuesOffset++] = ((block4 & 1L) << 10) | (block5.TripleShift(54));
+ values[valuesOffset++] = (block5.TripleShift(43)) & 2047L;
+ values[valuesOffset++] = (block5.TripleShift(32)) & 2047L;
+ values[valuesOffset++] = (block5.TripleShift(21)) & 2047L;
+ values[valuesOffset++] = (block5.TripleShift(10)) & 2047L;
long block6 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block5 & 1023L) << 1) | ((long)((ulong)block6 >> 63));
- values[valuesOffset++] = ((long)((ulong)block6 >> 52)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 41)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 30)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 19)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 8)) & 2047L;
+ values[valuesOffset++] = ((block5 & 1023L) << 1) | (block6.TripleShift(63));
+ values[valuesOffset++] = (block6.TripleShift(52)) & 2047L;
+ values[valuesOffset++] = (block6.TripleShift(41)) & 2047L;
+ values[valuesOffset++] = (block6.TripleShift(30)) & 2047L;
+ values[valuesOffset++] = (block6.TripleShift(19)) & 2047L;
+ values[valuesOffset++] = (block6.TripleShift(8)) & 2047L;
long block7 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block6 & 255L) << 3) | ((long)((ulong)block7 >> 61));
- values[valuesOffset++] = ((long)((ulong)block7 >> 50)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block7 >> 39)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block7 >> 28)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block7 >> 17)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block7 >> 6)) & 2047L;
+ values[valuesOffset++] = ((block6 & 255L) << 3) | (block7.TripleShift(61));
+ values[valuesOffset++] = (block7.TripleShift(50)) & 2047L;
+ values[valuesOffset++] = (block7.TripleShift(39)) & 2047L;
+ values[valuesOffset++] = (block7.TripleShift(28)) & 2047L;
+ values[valuesOffset++] = (block7.TripleShift(17)) & 2047L;
+ values[valuesOffset++] = (block7.TripleShift(6)) & 2047L;
long block8 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block7 & 63L) << 5) | ((long)((ulong)block8 >> 59));
- values[valuesOffset++] = ((long)((ulong)block8 >> 48)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block8 >> 37)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block8 >> 26)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block8 >> 15)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block8 >> 4)) & 2047L;
+ values[valuesOffset++] = ((block7 & 63L) << 5) | (block8.TripleShift(59));
+ values[valuesOffset++] = (block8.TripleShift(48)) & 2047L;
+ values[valuesOffset++] = (block8.TripleShift(37)) & 2047L;
+ values[valuesOffset++] = (block8.TripleShift(26)) & 2047L;
+ values[valuesOffset++] = (block8.TripleShift(15)) & 2047L;
+ values[valuesOffset++] = (block8.TripleShift(4)) & 2047L;
long block9 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block8 & 15L) << 7) | ((long)((ulong)block9 >> 57));
- values[valuesOffset++] = ((long)((ulong)block9 >> 46)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block9 >> 35)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block9 >> 24)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block9 >> 13)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block9 >> 2)) & 2047L;
+ values[valuesOffset++] = ((block8 & 15L) << 7) | (block9.TripleShift(57));
+ values[valuesOffset++] = (block9.TripleShift(46)) & 2047L;
+ values[valuesOffset++] = (block9.TripleShift(35)) & 2047L;
+ values[valuesOffset++] = (block9.TripleShift(24)) & 2047L;
+ values[valuesOffset++] = (block9.TripleShift(13)) & 2047L;
+ values[valuesOffset++] = (block9.TripleShift(2)) & 2047L;
long block10 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block9 & 3L) << 9) | ((long)((ulong)block10 >> 55));
- values[valuesOffset++] = ((long)((ulong)block10 >> 44)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block10 >> 33)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block10 >> 22)) & 2047L;
- values[valuesOffset++] = ((long)((ulong)block10 >> 11)) & 2047L;
+ values[valuesOffset++] = ((block9 & 3L) << 9) | (block10.TripleShift(55));
+ values[valuesOffset++] = (block10.TripleShift(44)) & 2047L;
+ values[valuesOffset++] = (block10.TripleShift(33)) & 2047L;
+ values[valuesOffset++] = (block10.TripleShift(22)) & 2047L;
+ values[valuesOffset++] = (block10.TripleShift(11)) & 2047L;
values[valuesOffset++] = block10 & 2047L;
}
}
@@ -225,21 +227,21 @@ namespace Lucene.Net.Util.Packed
{
long byte0 = blocks[blocksOffset++] & 0xFF;
long byte1 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (byte0 << 3) | ((long)((ulong)byte1 >> 5));
+ values[valuesOffset++] = (byte0 << 3) | (byte1.TripleShift(5));
long byte2 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte1 & 31) << 6) | ((long)((ulong)byte2 >> 2));
+ values[valuesOffset++] = ((byte1 & 31) << 6) | (byte2.TripleShift(2));
long byte3 = blocks[blocksOffset++] & 0xFF;
long byte4 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte2 & 3) << 9) | (byte3 << 1) | ((long)((ulong)byte4 >> 7));
+ values[valuesOffset++] = ((byte2 & 3) << 9) | (byte3 << 1) | (byte4.TripleShift(7));
long byte5 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte4 & 127) << 4) | ((long)((ulong)byte5 >> 4));
+ values[valuesOffset++] = ((byte4 & 127) << 4) | (byte5.TripleShift(4));
long byte6 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte5 & 15) << 7) | ((long)((ulong)byte6 >> 1));
+ values[valuesOffset++] = ((byte5 & 15) << 7) | (byte6.TripleShift(1));
long byte7 = blocks[blocksOffset++] & 0xFF;
long byte8 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte6 & 1) << 10) | (byte7 << 2) | ((long)((ulong)byte8 >> 6));
+ values[valuesOffset++] = ((byte6 & 1) << 10) | (byte7 << 2) | (byte8.TripleShift(6));
long byte9 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte8 & 63) << 5) | ((long)((ulong)byte9 >> 3));
+ values[valuesOffset++] = ((byte8 & 63) << 5) | (byte9.TripleShift(3));
long byte10 = blocks[blocksOffset++] & 0xFF;
values[valuesOffset++] = ((byte9 & 7) << 8) | byte10;
}
diff --git a/src/Lucene.Net/Util/Packed/BulkOperationPacked12.cs b/src/Lucene.Net/Util/Packed/BulkOperationPacked12.cs
index c72492d..41b4ab2 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperationPacked12.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperationPacked12.cs
@@ -1,4 +1,6 @@
-// this file has been automatically generated, DO NOT EDIT
+// this file has been automatically generated, DO NOT EDIT
+
+using J2N.Numerics;
namespace Lucene.Net.Util.Packed
{
@@ -34,23 +36,23 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)((long)((ulong)block0 >> 52));
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 40)) & 4095L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 28)) & 4095L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 16)) & 4095L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 4)) & 4095L);
+ values[valuesOffset++] = (int)(block0.TripleShift(52));
+ values[valuesOffset++] = (int)((block0.TripleShift(40)) & 4095L);
+ values[valuesOffset++] = (int)((block0.TripleShift(28)) & 4095L);
+ values[valuesOffset++] = (int)((block0.TripleShift(16)) & 4095L);
+ values[valuesOffset++] = (int)((block0.TripleShift(4)) & 4095L);
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block0 & 15L) << 8) | ((long)((ulong)block1 >> 56)));
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 44)) & 4095L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 32)) & 4095L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 20)) & 4095L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 8)) & 4095L);
+ values[valuesOffset++] = (int)(((block0 & 15L) << 8) | (block1.TripleShift(56)));
+ values[valuesOffset++] = (int)((block1.TripleShift(44)) & 4095L);
+ values[valuesOffset++] = (int)((block1.TripleShift(32)) & 4095L);
+ values[valuesOffset++] = (int)((block1.TripleShift(20)) & 4095L);
+ values[valuesOffset++] = (int)((block1.TripleShift(8)) & 4095L);
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block1 & 255L) << 4) | ((long)((ulong)block2 >> 60)));
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 48)) & 4095L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 36)) & 4095L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 24)) & 4095L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 12)) & 4095L);
+ values[valuesOffset++] = (int)(((block1 & 255L) << 4) | (block2.TripleShift(60)));
+ values[valuesOffset++] = (int)((block2.TripleShift(48)) & 4095L);
+ values[valuesOffset++] = (int)((block2.TripleShift(36)) & 4095L);
+ values[valuesOffset++] = (int)((block2.TripleShift(24)) & 4095L);
+ values[valuesOffset++] = (int)((block2.TripleShift(12)) & 4095L);
values[valuesOffset++] = (int)(block2 & 4095L);
}
}
@@ -61,7 +63,7 @@ namespace Lucene.Net.Util.Packed
{
int byte0 = blocks[blocksOffset++] & 0xFF;
int byte1 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (byte0 << 4) | ((int)((uint)byte1 >> 4));
+ values[valuesOffset++] = (byte0 << 4) | (byte1.TripleShift(4));
int byte2 = blocks[blocksOffset++] & 0xFF;
values[valuesOffset++] = ((byte1 & 15) << 8) | byte2;
}
@@ -72,23 +74,23 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (long)((ulong)block0 >> 52);
- values[valuesOffset++] = ((long)((ulong)block0 >> 40)) & 4095L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 28)) & 4095L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 16)) & 4095L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 4)) & 4095L;
+ values[valuesOffset++] = block0.TripleShift(52);
+ values[valuesOffset++] = (block0.TripleShift(40)) & 4095L;
+ values[valuesOffset++] = (block0.TripleShift(28)) & 4095L;
+ values[valuesOffset++] = (block0.TripleShift(16)) & 4095L;
+ values[valuesOffset++] = (block0.TripleShift(4)) & 4095L;
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block0 & 15L) << 8) | ((long)((ulong)block1 >> 56));
- values[valuesOffset++] = ((long)((ulong)block1 >> 44)) & 4095L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 32)) & 4095L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 20)) & 4095L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 8)) & 4095L;
+ values[valuesOffset++] = ((block0 & 15L) << 8) | (block1.TripleShift(56));
+ values[valuesOffset++] = (block1.TripleShift(44)) & 4095L;
+ values[valuesOffset++] = (block1.TripleShift(32)) & 4095L;
+ values[valuesOffset++] = (block1.TripleShift(20)) & 4095L;
+ values[valuesOffset++] = (block1.TripleShift(8)) & 4095L;
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block1 & 255L) << 4) | ((long)((ulong)block2 >> 60));
- values[valuesOffset++] = ((long)((ulong)block2 >> 48)) & 4095L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 36)) & 4095L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 24)) & 4095L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 12)) & 4095L;
+ values[valuesOffset++] = ((block1 & 255L) << 4) | (block2.TripleShift(60));
+ values[valuesOffset++] = (block2.TripleShift(48)) & 4095L;
+ values[valuesOffset++] = (block2.TripleShift(36)) & 4095L;
+ values[valuesOffset++] = (block2.TripleShift(24)) & 4095L;
+ values[valuesOffset++] = (block2.TripleShift(12)) & 4095L;
values[valuesOffset++] = block2 & 4095L;
}
}
@@ -99,7 +101,7 @@ namespace Lucene.Net.Util.Packed
{
long byte0 = blocks[blocksOffset++] & 0xFF;
long byte1 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (byte0 << 4) | ((long)((ulong)byte1 >> 4));
+ values[valuesOffset++] = (byte0 << 4) | (byte1.TripleShift(4));
long byte2 = blocks[blocksOffset++] & 0xFF;
values[valuesOffset++] = ((byte1 & 15) << 8) | byte2;
}
diff --git a/src/Lucene.Net/Util/Packed/BulkOperationPacked13.cs b/src/Lucene.Net/Util/Packed/BulkOperationPacked13.cs
index c1f3f75..cafecee 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperationPacked13.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperationPacked13.cs
@@ -1,4 +1,6 @@
-// this file has been automatically generated, DO NOT EDIT
+// this file has been automatically generated, DO NOT EDIT
+
+using J2N.Numerics;
namespace Lucene.Net.Util.Packed
{
@@ -34,81 +36,81 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)((long)((ulong)block0 >> 51));
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 38)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 25)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 12)) & 8191L);
+ values[valuesOffset++] = (int)(block0.TripleShift(51));
+ values[valuesOffset++] = (int)((block0.TripleShift(38)) & 8191L);
+ values[valuesOffset++] = (int)((block0.TripleShift(25)) & 8191L);
+ values[valuesOffset++] = (int)((block0.TripleShift(12)) & 8191L);
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block0 & 4095L) << 1) | ((long)((ulong)block1 >> 63)));
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 50)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 37)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 24)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 11)) & 8191L);
+ values[valuesOffset++] = (int)(((block0 & 4095L) << 1) | (block1.TripleShift(63)));
+ values[valuesOffset++] = (int)((block1.TripleShift(50)) & 8191L);
+ values[valuesOffset++] = (int)((block1.TripleShift(37)) & 8191L);
+ values[valuesOffset++] = (int)((block1.TripleShift(24)) & 8191L);
+ values[valuesOffset++] = (int)((block1.TripleShift(11)) & 8191L);
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block1 & 2047L) << 2) | ((long)((ulong)block2 >> 62)));
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 49)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 36)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 23)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 10)) & 8191L);
+ values[valuesOffset++] = (int)(((block1 & 2047L) << 2) | (block2.TripleShift(62)));
+ values[valuesOffset++] = (int)((block2.TripleShift(49)) & 8191L);
+ values[valuesOffset++] = (int)((block2.TripleShift(36)) & 8191L);
+ values[valuesOffset++] = (int)((block2.TripleShift(23)) & 8191L);
+ values[valuesOffset++] = (int)((block2.TripleShift(10)) & 8191L);
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block2 & 1023L) << 3) | ((long)((ulong)block3 >> 61)));
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 48)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 35)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 22)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 9)) & 8191L);
+ values[valuesOffset++] = (int)(((block2 & 1023L) << 3) | (block3.TripleShift(61)));
+ values[valuesOffset++] = (int)((block3.TripleShift(48)) & 8191L);
+ values[valuesOffset++] = (int)((block3.TripleShift(35)) & 8191L);
+ values[valuesOffset++] = (int)((block3.TripleShift(22)) & 8191L);
+ values[valuesOffset++] = (int)((block3.TripleShift(9)) & 8191L);
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block3 & 511L) << 4) | ((long)((ulong)block4 >> 60)));
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 47)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 34)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 21)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 8)) & 8191L);
+ values[valuesOffset++] = (int)(((block3 & 511L) << 4) | (block4.TripleShift(60)));
+ values[valuesOffset++] = (int)((block4.TripleShift(47)) & 8191L);
+ values[valuesOffset++] = (int)((block4.TripleShift(34)) & 8191L);
+ values[valuesOffset++] = (int)((block4.TripleShift(21)) & 8191L);
+ values[valuesOffset++] = (int)((block4.TripleShift(8)) & 8191L);
long block5 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block4 & 255L) << 5) | ((long)((ulong)block5 >> 59)));
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 46)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 33)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 20)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 7)) & 8191L);
+ values[valuesOffset++] = (int)(((block4 & 255L) << 5) | (block5.TripleShift(59)));
+ values[valuesOffset++] = (int)((block5.TripleShift(46)) & 8191L);
+ values[valuesOffset++] = (int)((block5.TripleShift(33)) & 8191L);
+ values[valuesOffset++] = (int)((block5.TripleShift(20)) & 8191L);
+ values[valuesOffset++] = (int)((block5.TripleShift(7)) & 8191L);
long block6 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block5 & 127L) << 6) | ((long)((ulong)block6 >> 58)));
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 45)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 32)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 19)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 6)) & 8191L);
+ values[valuesOffset++] = (int)(((block5 & 127L) << 6) | (block6.TripleShift(58)));
+ values[valuesOffset++] = (int)((block6.TripleShift(45)) & 8191L);
+ values[valuesOffset++] = (int)((block6.TripleShift(32)) & 8191L);
+ values[valuesOffset++] = (int)((block6.TripleShift(19)) & 8191L);
+ values[valuesOffset++] = (int)((block6.TripleShift(6)) & 8191L);
long block7 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block6 & 63L) << 7) | ((long)((ulong)block7 >> 57)));
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 44)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 31)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 18)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 5)) & 8191L);
+ values[valuesOffset++] = (int)(((block6 & 63L) << 7) | (block7.TripleShift(57)));
+ values[valuesOffset++] = (int)((block7.TripleShift(44)) & 8191L);
+ values[valuesOffset++] = (int)((block7.TripleShift(31)) & 8191L);
+ values[valuesOffset++] = (int)((block7.TripleShift(18)) & 8191L);
+ values[valuesOffset++] = (int)((block7.TripleShift(5)) & 8191L);
long block8 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block7 & 31L) << 8) | ((long)((ulong)block8 >> 56)));
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 43)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 30)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 17)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 4)) & 8191L);
+ values[valuesOffset++] = (int)(((block7 & 31L) << 8) | (block8.TripleShift(56)));
+ values[valuesOffset++] = (int)((block8.TripleShift(43)) & 8191L);
+ values[valuesOffset++] = (int)((block8.TripleShift(30)) & 8191L);
+ values[valuesOffset++] = (int)((block8.TripleShift(17)) & 8191L);
+ values[valuesOffset++] = (int)((block8.TripleShift(4)) & 8191L);
long block9 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block8 & 15L) << 9) | ((long)((ulong)block9 >> 55)));
- values[valuesOffset++] = (int)(((long)((ulong)block9 >> 42)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block9 >> 29)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block9 >> 16)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block9 >> 3)) & 8191L);
+ values[valuesOffset++] = (int)(((block8 & 15L) << 9) | (block9.TripleShift(55)));
+ values[valuesOffset++] = (int)((block9.TripleShift(42)) & 8191L);
+ values[valuesOffset++] = (int)((block9.TripleShift(29)) & 8191L);
+ values[valuesOffset++] = (int)((block9.TripleShift(16)) & 8191L);
+ values[valuesOffset++] = (int)((block9.TripleShift(3)) & 8191L);
long block10 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block9 & 7L) << 10) | ((long)((ulong)block10 >> 54)));
- values[valuesOffset++] = (int)(((long)((ulong)block10 >> 41)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block10 >> 28)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block10 >> 15)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block10 >> 2)) & 8191L);
+ values[valuesOffset++] = (int)(((block9 & 7L) << 10) | (block10.TripleShift(54)));
+ values[valuesOffset++] = (int)((block10.TripleShift(41)) & 8191L);
+ values[valuesOffset++] = (int)((block10.TripleShift(28)) & 8191L);
+ values[valuesOffset++] = (int)((block10.TripleShift(15)) & 8191L);
+ values[valuesOffset++] = (int)((block10.TripleShift(2)) & 8191L);
long block11 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block10 & 3L) << 11) | ((long)((ulong)block11 >> 53)));
- values[valuesOffset++] = (int)(((long)((ulong)block11 >> 40)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block11 >> 27)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block11 >> 14)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block11 >> 1)) & 8191L);
+ values[valuesOffset++] = (int)(((block10 & 3L) << 11) | (block11.TripleShift(53)));
+ values[valuesOffset++] = (int)((block11.TripleShift(40)) & 8191L);
+ values[valuesOffset++] = (int)((block11.TripleShift(27)) & 8191L);
+ values[valuesOffset++] = (int)((block11.TripleShift(14)) & 8191L);
+ values[valuesOffset++] = (int)((block11.TripleShift(1)) & 8191L);
long block12 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block11 & 1L) << 12) | ((long)((ulong)block12 >> 52)));
- values[valuesOffset++] = (int)(((long)((ulong)block12 >> 39)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block12 >> 26)) & 8191L);
- values[valuesOffset++] = (int)(((long)((ulong)block12 >> 13)) & 8191L);
+ values[valuesOffset++] = (int)(((block11 & 1L) << 12) | (block12.TripleShift(52)));
+ values[valuesOffset++] = (int)((block12.TripleShift(39)) & 8191L);
+ values[valuesOffset++] = (int)((block12.TripleShift(26)) & 8191L);
+ values[valuesOffset++] = (int)((block12.TripleShift(13)) & 8191L);
values[valuesOffset++] = (int)(block12 & 8191L);
}
}
@@ -119,23 +121,23 @@ namespace Lucene.Net.Util.Packed
{
int byte0 = blocks[blocksOffset++] & 0xFF;
int byte1 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (byte0 << 5) | ((int)((uint)byte1 >> 3));
+ values[valuesOffset++] = (byte0 << 5) | (byte1.TripleShift(3));
int byte2 = blocks[blocksOffset++] & 0xFF;
int byte3 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte1 & 7) << 10) | (byte2 << 2) | ((int)((uint)byte3 >> 6));
+ values[valuesOffset++] = ((byte1 & 7) << 10) | (byte2 << 2) | (byte3.TripleShift(6));
int byte4 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte3 & 63) << 7) | ((int)((uint)byte4 >> 1));
+ values[valuesOffset++] = ((byte3 & 63) << 7) | (byte4.TripleShift(1));
int byte5 = blocks[blocksOffset++] & 0xFF;
int byte6 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte4 & 1) << 12) | (byte5 << 4) | ((int)((uint)byte6 >> 4));
+ values[valuesOffset++] = ((byte4 & 1) << 12) | (byte5 << 4) | (byte6.TripleShift(4));
int byte7 = blocks[blocksOffset++] & 0xFF;
int byte8 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte6 & 15) << 9) | (byte7 << 1) | ((int)((uint)byte8 >> 7));
+ values[valuesOffset++] = ((byte6 & 15) << 9) | (byte7 << 1) | (byte8.TripleShift(7));
int byte9 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte8 & 127) << 6) | ((int)((uint)byte9 >> 2));
+ values[valuesOffset++] = ((byte8 & 127) << 6) | (byte9.TripleShift(2));
int byte10 = blocks[blocksOffset++] & 0xFF;
int byte11 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte9 & 3) << 11) | (byte10 << 3) | ((int)((uint)byte11 >> 5));
+ values[valuesOffset++] = ((byte9 & 3) << 11) | (byte10 << 3) | (byte11.TripleShift(5));
int byte12 = blocks[blocksOffset++] & 0xFF;
values[valuesOffset++] = ((byte11 & 31) << 8) | byte12;
}
@@ -146,81 +148,81 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (long)((ulong)block0 >> 51);
- values[valuesOffset++] = ((long)((ulong)block0 >> 38)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 25)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 12)) & 8191L;
+ values[valuesOffset++] = block0.TripleShift(51);
+ values[valuesOffset++] = (block0.TripleShift(38)) & 8191L;
+ values[valuesOffset++] = (block0.TripleShift(25)) & 8191L;
+ values[valuesOffset++] = (block0.TripleShift(12)) & 8191L;
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block0 & 4095L) << 1) | ((long)((ulong)block1 >> 63));
- values[valuesOffset++] = ((long)((ulong)block1 >> 50)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 37)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 24)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 11)) & 8191L;
+ values[valuesOffset++] = ((block0 & 4095L) << 1) | (block1.TripleShift(63));
+ values[valuesOffset++] = (block1.TripleShift(50)) & 8191L;
+ values[valuesOffset++] = (block1.TripleShift(37)) & 8191L;
+ values[valuesOffset++] = (block1.TripleShift(24)) & 8191L;
+ values[valuesOffset++] = (block1.TripleShift(11)) & 8191L;
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block1 & 2047L) << 2) | ((long)((ulong)block2 >> 62));
- values[valuesOffset++] = ((long)((ulong)block2 >> 49)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 36)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 23)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 10)) & 8191L;
+ values[valuesOffset++] = ((block1 & 2047L) << 2) | (block2.TripleShift(62));
+ values[valuesOffset++] = (block2.TripleShift(49)) & 8191L;
+ values[valuesOffset++] = (block2.TripleShift(36)) & 8191L;
+ values[valuesOffset++] = (block2.TripleShift(23)) & 8191L;
+ values[valuesOffset++] = (block2.TripleShift(10)) & 8191L;
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block2 & 1023L) << 3) | ((long)((ulong)block3 >> 61));
- values[valuesOffset++] = ((long)((ulong)block3 >> 48)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 35)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 22)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 9)) & 8191L;
+ values[valuesOffset++] = ((block2 & 1023L) << 3) | (block3.TripleShift(61));
+ values[valuesOffset++] = (block3.TripleShift(48)) & 8191L;
+ values[valuesOffset++] = (block3.TripleShift(35)) & 8191L;
+ values[valuesOffset++] = (block3.TripleShift(22)) & 8191L;
+ values[valuesOffset++] = (block3.TripleShift(9)) & 8191L;
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block3 & 511L) << 4) | ((long)((ulong)block4 >> 60));
- values[valuesOffset++] = ((long)((ulong)block4 >> 47)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 34)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 21)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 8)) & 8191L;
+ values[valuesOffset++] = ((block3 & 511L) << 4) | (block4.TripleShift(60));
+ values[valuesOffset++] = (block4.TripleShift(47)) & 8191L;
+ values[valuesOffset++] = (block4.TripleShift(34)) & 8191L;
+ values[valuesOffset++] = (block4.TripleShift(21)) & 8191L;
+ values[valuesOffset++] = (block4.TripleShift(8)) & 8191L;
long block5 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block4 & 255L) << 5) | ((long)((ulong)block5 >> 59));
- values[valuesOffset++] = ((long)((ulong)block5 >> 46)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 33)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 20)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 7)) & 8191L;
+ values[valuesOffset++] = ((block4 & 255L) << 5) | (block5.TripleShift(59));
+ values[valuesOffset++] = (block5.TripleShift(46)) & 8191L;
+ values[valuesOffset++] = (block5.TripleShift(33)) & 8191L;
+ values[valuesOffset++] = (block5.TripleShift(20)) & 8191L;
+ values[valuesOffset++] = (block5.TripleShift(7)) & 8191L;
long block6 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block5 & 127L) << 6) | ((long)((ulong)block6 >> 58));
- values[valuesOffset++] = ((long)((ulong)block6 >> 45)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 32)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 19)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 6)) & 8191L;
+ values[valuesOffset++] = ((block5 & 127L) << 6) | (block6.TripleShift(58));
+ values[valuesOffset++] = (block6.TripleShift(45)) & 8191L;
+ values[valuesOffset++] = (block6.TripleShift(32)) & 8191L;
+ values[valuesOffset++] = (block6.TripleShift(19)) & 8191L;
+ values[valuesOffset++] = (block6.TripleShift(6)) & 8191L;
long block7 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block6 & 63L) << 7) | ((long)((ulong)block7 >> 57));
- values[valuesOffset++] = ((long)((ulong)block7 >> 44)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block7 >> 31)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block7 >> 18)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block7 >> 5)) & 8191L;
+ values[valuesOffset++] = ((block6 & 63L) << 7) | (block7.TripleShift(57));
+ values[valuesOffset++] = (block7.TripleShift(44)) & 8191L;
+ values[valuesOffset++] = (block7.TripleShift(31)) & 8191L;
+ values[valuesOffset++] = (block7.TripleShift(18)) & 8191L;
+ values[valuesOffset++] = (block7.TripleShift(5)) & 8191L;
long block8 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block7 & 31L) << 8) | ((long)((ulong)block8 >> 56));
- values[valuesOffset++] = ((long)((ulong)block8 >> 43)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block8 >> 30)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block8 >> 17)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block8 >> 4)) & 8191L;
+ values[valuesOffset++] = ((block7 & 31L) << 8) | (block8.TripleShift(56));
+ values[valuesOffset++] = (block8.TripleShift(43)) & 8191L;
+ values[valuesOffset++] = (block8.TripleShift(30)) & 8191L;
+ values[valuesOffset++] = (block8.TripleShift(17)) & 8191L;
+ values[valuesOffset++] = (block8.TripleShift(4)) & 8191L;
long block9 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block8 & 15L) << 9) | ((long)((ulong)block9 >> 55));
- values[valuesOffset++] = ((long)((ulong)block9 >> 42)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block9 >> 29)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block9 >> 16)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block9 >> 3)) & 8191L;
+ values[valuesOffset++] = ((block8 & 15L) << 9) | (block9.TripleShift(55));
+ values[valuesOffset++] = (block9.TripleShift(42)) & 8191L;
+ values[valuesOffset++] = (block9.TripleShift(29)) & 8191L;
+ values[valuesOffset++] = (block9.TripleShift(16)) & 8191L;
+ values[valuesOffset++] = (block9.TripleShift(3)) & 8191L;
long block10 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block9 & 7L) << 10) | ((long)((ulong)block10 >> 54));
- values[valuesOffset++] = ((long)((ulong)block10 >> 41)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block10 >> 28)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block10 >> 15)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block10 >> 2)) & 8191L;
+ values[valuesOffset++] = ((block9 & 7L) << 10) | (block10.TripleShift(54));
+ values[valuesOffset++] = (block10.TripleShift(41)) & 8191L;
+ values[valuesOffset++] = (block10.TripleShift(28)) & 8191L;
+ values[valuesOffset++] = (block10.TripleShift(15)) & 8191L;
+ values[valuesOffset++] = (block10.TripleShift(2)) & 8191L;
long block11 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block10 & 3L) << 11) | ((long)((ulong)block11 >> 53));
- values[valuesOffset++] = ((long)((ulong)block11 >> 40)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block11 >> 27)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block11 >> 14)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block11 >> 1)) & 8191L;
+ values[valuesOffset++] = ((block10 & 3L) << 11) | (block11.TripleShift(53));
+ values[valuesOffset++] = (block11.TripleShift(40)) & 8191L;
+ values[valuesOffset++] = (block11.TripleShift(27)) & 8191L;
+ values[valuesOffset++] = (block11.TripleShift(14)) & 8191L;
+ values[valuesOffset++] = (block11.TripleShift(1)) & 8191L;
long block12 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block11 & 1L) << 12) | ((long)((ulong)block12 >> 52));
- values[valuesOffset++] = ((long)((ulong)block12 >> 39)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block12 >> 26)) & 8191L;
- values[valuesOffset++] = ((long)((ulong)block12 >> 13)) & 8191L;
+ values[valuesOffset++] = ((block11 & 1L) << 12) | (block12.TripleShift(52));
+ values[valuesOffset++] = (block12.TripleShift(39)) & 8191L;
+ values[valuesOffset++] = (block12.TripleShift(26)) & 8191L;
+ values[valuesOffset++] = (block12.TripleShift(13)) & 8191L;
values[valuesOffset++] = block12 & 8191L;
}
}
@@ -231,23 +233,23 @@ namespace Lucene.Net.Util.Packed
{
long byte0 = blocks[blocksOffset++] & 0xFF;
long byte1 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (byte0 << 5) | ((long)((ulong)byte1 >> 3));
+ values[valuesOffset++] = (byte0 << 5) | (byte1.TripleShift(3));
long byte2 = blocks[blocksOffset++] & 0xFF;
long byte3 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte1 & 7) << 10) | (byte2 << 2) | ((long)((ulong)byte3 >> 6));
+ values[valuesOffset++] = ((byte1 & 7) << 10) | (byte2 << 2) | (byte3.TripleShift(6));
long byte4 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte3 & 63) << 7) | ((long)((ulong)byte4 >> 1));
+ values[valuesOffset++] = ((byte3 & 63) << 7) | (byte4.TripleShift(1));
long byte5 = blocks[blocksOffset++] & 0xFF;
long byte6 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte4 & 1) << 12) | (byte5 << 4) | ((long)((ulong)byte6 >> 4));
+ values[valuesOffset++] = ((byte4 & 1) << 12) | (byte5 << 4) | (byte6.TripleShift(4));
long byte7 = blocks[blocksOffset++] & 0xFF;
long byte8 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte6 & 15) << 9) | (byte7 << 1) | ((long)((ulong)byte8 >> 7));
+ values[valuesOffset++] = ((byte6 & 15) << 9) | (byte7 << 1) | (byte8.TripleShift(7));
long byte9 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte8 & 127) << 6) | ((long)((ulong)byte9 >> 2));
+ values[valuesOffset++] = ((byte8 & 127) << 6) | (byte9.TripleShift(2));
long byte10 = blocks[blocksOffset++] & 0xFF;
long byte11 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte9 & 3) << 11) | (byte10 << 3) | ((long)((ulong)byte11 >> 5));
+ values[valuesOffset++] = ((byte9 & 3) << 11) | (byte10 << 3) | (byte11.TripleShift(5));
long byte12 = blocks[blocksOffset++] & 0xFF;
values[valuesOffset++] = ((byte11 & 31) << 8) | byte12;
}
diff --git a/src/Lucene.Net/Util/Packed/BulkOperationPacked14.cs b/src/Lucene.Net/Util/Packed/BulkOperationPacked14.cs
index a8847ce..277f7f2 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperationPacked14.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperationPacked14.cs
@@ -1,4 +1,6 @@
-// this file has been automatically generated, DO NOT EDIT
+// this file has been automatically generated, DO NOT EDIT
+
+using J2N.Numerics;
namespace Lucene.Net.Util.Packed
{
@@ -34,43 +36,43 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)((long)((ulong)block0 >> 50));
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 36)) & 16383L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 22)) & 16383L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 8)) & 16383L);
+ values[valuesOffset++] = (int)(block0.TripleShift(50));
+ values[valuesOffset++] = (int)((block0.TripleShift(36)) & 16383L);
+ values[valuesOffset++] = (int)((block0.TripleShift(22)) & 16383L);
+ values[valuesOffset++] = (int)((block0.TripleShift(8)) & 16383L);
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block0 & 255L) << 6) | ((long)((ulong)block1 >> 58)));
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 44)) & 16383L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 30)) & 16383L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 16)) & 16383L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 2)) & 16383L);
+ values[valuesOffset++] = (int)(((block0 & 255L) << 6) | (block1.TripleShift(58)));
+ values[valuesOffset++] = (int)((block1.TripleShift(44)) & 16383L);
+ values[valuesOffset++] = (int)((block1.TripleShift(30)) & 16383L);
+ values[valuesOffset++] = (int)((block1.TripleShift(16)) & 16383L);
+ values[valuesOffset++] = (int)((block1.TripleShift(2)) & 16383L);
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block1 & 3L) << 12) | ((long)((ulong)block2 >> 52)));
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 38)) & 16383L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 24)) & 16383L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 10)) & 16383L);
+ values[valuesOffset++] = (int)(((block1 & 3L) << 12) | (block2.TripleShift(52)));
+ values[valuesOffset++] = (int)((block2.TripleShift(38)) & 16383L);
+ values[valuesOffset++] = (int)((block2.TripleShift(24)) & 16383L);
+ values[valuesOffset++] = (int)((block2.TripleShift(10)) & 16383L);
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block2 & 1023L) << 4) | ((long)((ulong)block3 >> 60)));
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 46)) & 16383L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 32)) & 16383L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 18)) & 16383L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 4)) & 16383L);
+ values[valuesOffset++] = (int)(((block2 & 1023L) << 4) | (block3.TripleShift(60)));
+ values[valuesOffset++] = (int)((block3.TripleShift(46)) & 16383L);
+ values[valuesOffset++] = (int)((block3.TripleShift(32)) & 16383L);
+ values[valuesOffset++] = (int)((block3.TripleShift(18)) & 16383L);
+ values[valuesOffset++] = (int)((block3.TripleShift(4)) & 16383L);
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block3 & 15L) << 10) | ((long)((ulong)block4 >> 54)));
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 40)) & 16383L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 26)) & 16383L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 12)) & 16383L);
+ values[valuesOffset++] = (int)(((block3 & 15L) << 10) | (block4.TripleShift(54)));
+ values[valuesOffset++] = (int)((block4.TripleShift(40)) & 16383L);
+ values[valuesOffset++] = (int)((block4.TripleShift(26)) & 16383L);
+ values[valuesOffset++] = (int)((block4.TripleShift(12)) & 16383L);
long block5 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block4 & 4095L) << 2) | ((long)((ulong)block5 >> 62)));
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 48)) & 16383L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 34)) & 16383L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 20)) & 16383L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 6)) & 16383L);
+ values[valuesOffset++] = (int)(((block4 & 4095L) << 2) | (block5.TripleShift(62)));
+ values[valuesOffset++] = (int)((block5.TripleShift(48)) & 16383L);
+ values[valuesOffset++] = (int)((block5.TripleShift(34)) & 16383L);
+ values[valuesOffset++] = (int)((block5.TripleShift(20)) & 16383L);
+ values[valuesOffset++] = (int)((block5.TripleShift(6)) & 16383L);
long block6 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block5 & 63L) << 8) | ((long)((ulong)block6 >> 56)));
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 42)) & 16383L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 28)) & 16383L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 14)) & 16383L);
+ values[valuesOffset++] = (int)(((block5 & 63L) << 8) | (block6.TripleShift(56)));
+ values[valuesOffset++] = (int)((block6.TripleShift(42)) & 16383L);
+ values[valuesOffset++] = (int)((block6.TripleShift(28)) & 16383L);
+ values[valuesOffset++] = (int)((block6.TripleShift(14)) & 16383L);
values[valuesOffset++] = (int)(block6 & 16383L);
}
}
@@ -81,13 +83,13 @@ namespace Lucene.Net.Util.Packed
{
int byte0 = blocks[blocksOffset++] & 0xFF;
int byte1 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (byte0 << 6) | ((int)((uint)byte1 >> 2));
+ values[valuesOffset++] = (byte0 << 6) | (byte1.TripleShift(2));
int byte2 = blocks[blocksOffset++] & 0xFF;
int byte3 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte1 & 3) << 12) | (byte2 << 4) | ((int)((uint)byte3 >> 4));
+ values[valuesOffset++] = ((byte1 & 3) << 12) | (byte2 << 4) | (byte3.TripleShift(4));
int byte4 = blocks[blocksOffset++] & 0xFF;
int byte5 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte3 & 15) << 10) | (byte4 << 2) | ((int)((uint)byte5 >> 6));
+ values[valuesOffset++] = ((byte3 & 15) << 10) | (byte4 << 2) | (byte5.TripleShift(6));
int byte6 = blocks[blocksOffset++] & 0xFF;
values[valuesOffset++] = ((byte5 & 63) << 8) | byte6;
}
@@ -98,43 +100,43 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (long)((ulong)block0 >> 50);
- values[valuesOffset++] = ((long)((ulong)block0 >> 36)) & 16383L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 22)) & 16383L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 8)) & 16383L;
+ values[valuesOffset++] = block0.TripleShift(50);
+ values[valuesOffset++] = (block0.TripleShift(36)) & 16383L;
+ values[valuesOffset++] = (block0.TripleShift(22)) & 16383L;
+ values[valuesOffset++] = (block0.TripleShift(8)) & 16383L;
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block0 & 255L) << 6) | ((long)((ulong)block1 >> 58));
- values[valuesOffset++] = ((long)((ulong)block1 >> 44)) & 16383L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 30)) & 16383L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 16)) & 16383L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 2)) & 16383L;
+ values[valuesOffset++] = ((block0 & 255L) << 6) | (block1.TripleShift(58));
+ values[valuesOffset++] = (block1.TripleShift(44)) & 16383L;
+ values[valuesOffset++] = (block1.TripleShift(30)) & 16383L;
+ values[valuesOffset++] = (block1.TripleShift(16)) & 16383L;
+ values[valuesOffset++] = (block1.TripleShift(2)) & 16383L;
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block1 & 3L) << 12) | ((long)((ulong)block2 >> 52));
- values[valuesOffset++] = ((long)((ulong)block2 >> 38)) & 16383L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 24)) & 16383L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 10)) & 16383L;
+ values[valuesOffset++] = ((block1 & 3L) << 12) | (block2.TripleShift(52));
+ values[valuesOffset++] = (block2.TripleShift(38)) & 16383L;
+ values[valuesOffset++] = (block2.TripleShift(24)) & 16383L;
+ values[valuesOffset++] = (block2.TripleShift(10)) & 16383L;
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block2 & 1023L) << 4) | ((long)((ulong)block3 >> 60));
- values[valuesOffset++] = ((long)((ulong)block3 >> 46)) & 16383L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 32)) & 16383L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 18)) & 16383L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 4)) & 16383L;
+ values[valuesOffset++] = ((block2 & 1023L) << 4) | (block3.TripleShift(60));
+ values[valuesOffset++] = (block3.TripleShift(46)) & 16383L;
+ values[valuesOffset++] = (block3.TripleShift(32)) & 16383L;
+ values[valuesOffset++] = (block3.TripleShift(18)) & 16383L;
+ values[valuesOffset++] = (block3.TripleShift(4)) & 16383L;
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block3 & 15L) << 10) | ((long)((ulong)block4 >> 54));
- values[valuesOffset++] = ((long)((ulong)block4 >> 40)) & 16383L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 26)) & 16383L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 12)) & 16383L;
+ values[valuesOffset++] = ((block3 & 15L) << 10) | (block4.TripleShift(54));
+ values[valuesOffset++] = (block4.TripleShift(40)) & 16383L;
+ values[valuesOffset++] = (block4.TripleShift(26)) & 16383L;
+ values[valuesOffset++] = (block4.TripleShift(12)) & 16383L;
long block5 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block4 & 4095L) << 2) | ((long)((ulong)block5 >> 62));
- values[valuesOffset++] = ((long)((ulong)block5 >> 48)) & 16383L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 34)) & 16383L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 20)) & 16383L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 6)) & 16383L;
+ values[valuesOffset++] = ((block4 & 4095L) << 2) | (block5.TripleShift(62));
+ values[valuesOffset++] = (block5.TripleShift(48)) & 16383L;
+ values[valuesOffset++] = (block5.TripleShift(34)) & 16383L;
+ values[valuesOffset++] = (block5.TripleShift(20)) & 16383L;
+ values[valuesOffset++] = (block5.TripleShift(6)) & 16383L;
long block6 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block5 & 63L) << 8) | ((long)((ulong)block6 >> 56));
- values[valuesOffset++] = ((long)((ulong)block6 >> 42)) & 16383L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 28)) & 16383L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 14)) & 16383L;
+ values[valuesOffset++] = ((block5 & 63L) << 8) | (block6.TripleShift(56));
+ values[valuesOffset++] = (block6.TripleShift(42)) & 16383L;
+ values[valuesOffset++] = (block6.TripleShift(28)) & 16383L;
+ values[valuesOffset++] = (block6.TripleShift(14)) & 16383L;
values[valuesOffset++] = block6 & 16383L;
}
}
@@ -145,13 +147,13 @@ namespace Lucene.Net.Util.Packed
{
long byte0 = blocks[blocksOffset++] & 0xFF;
long byte1 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (byte0 << 6) | ((long)((ulong)byte1 >> 2));
+ values[valuesOffset++] = (byte0 << 6) | (byte1.TripleShift(2));
long byte2 = blocks[blocksOffset++] & 0xFF;
long byte3 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte1 & 3) << 12) | (byte2 << 4) | ((long)((ulong)byte3 >> 4));
+ values[valuesOffset++] = ((byte1 & 3) << 12) | (byte2 << 4) | (byte3.TripleShift(4));
long byte4 = blocks[blocksOffset++] & 0xFF;
long byte5 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte3 & 15) << 10) | (byte4 << 2) | ((long)((ulong)byte5 >> 6));
+ values[valuesOffset++] = ((byte3 & 15) << 10) | (byte4 << 2) | (byte5.TripleShift(6));
long byte6 = blocks[blocksOffset++] & 0xFF;
values[valuesOffset++] = ((byte5 & 63) << 8) | byte6;
}
diff --git a/src/Lucene.Net/Util/Packed/BulkOperationPacked15.cs b/src/Lucene.Net/Util/Packed/BulkOperationPacked15.cs
index dd8ef4e..358ef54 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperationPacked15.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperationPacked15.cs
@@ -1,4 +1,6 @@
-// this file has been automatically generated, DO NOT EDIT
+// this file has been automatically generated, DO NOT EDIT
+
+using J2N.Numerics;
namespace Lucene.Net.Util.Packed
{
@@ -34,83 +36,83 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)((long)((ulong)block0 >> 49));
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 34)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 19)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 4)) & 32767L);
+ values[valuesOffset++] = (int)(block0.TripleShift(49));
+ values[valuesOffset++] = (int)((block0.TripleShift(34)) & 32767L);
+ values[valuesOffset++] = (int)((block0.TripleShift(19)) & 32767L);
+ values[valuesOffset++] = (int)((block0.TripleShift(4)) & 32767L);
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block0 & 15L) << 11) | ((long)((ulong)block1 >> 53)));
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 38)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 23)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 8)) & 32767L);
+ values[valuesOffset++] = (int)(((block0 & 15L) << 11) | (block1.TripleShift(53)));
+ values[valuesOffset++] = (int)((block1.TripleShift(38)) & 32767L);
+ values[valuesOffset++] = (int)((block1.TripleShift(23)) & 32767L);
+ values[valuesOffset++] = (int)((block1.TripleShift(8)) & 32767L);
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block1 & 255L) << 7) | ((long)((ulong)block2 >> 57)));
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 42)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 27)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 12)) & 32767L);
+ values[valuesOffset++] = (int)(((block1 & 255L) << 7) | (block2.TripleShift(57)));
+ values[valuesOffset++] = (int)((block2.TripleShift(42)) & 32767L);
+ values[valuesOffset++] = (int)((block2.TripleShift(27)) & 32767L);
+ values[valuesOffset++] = (int)((block2.TripleShift(12)) & 32767L);
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block2 & 4095L) << 3) | ((long)((ulong)block3 >> 61)));
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 46)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 31)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 16)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 1)) & 32767L);
+ values[valuesOffset++] = (int)(((block2 & 4095L) << 3) | (block3.TripleShift(61)));
+ values[valuesOffset++] = (int)((block3.TripleShift(46)) & 32767L);
+ values[valuesOffset++] = (int)((block3.TripleShift(31)) & 32767L);
+ values[valuesOffset++] = (int)((block3.TripleShift(16)) & 32767L);
+ values[valuesOffset++] = (int)((block3.TripleShift(1)) & 32767L);
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block3 & 1L) << 14) | ((long)((ulong)block4 >> 50)));
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 35)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 20)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 5)) & 32767L);
+ values[valuesOffset++] = (int)(((block3 & 1L) << 14) | (block4.TripleShift(50)));
+ values[valuesOffset++] = (int)((block4.TripleShift(35)) & 32767L);
+ values[valuesOffset++] = (int)((block4.TripleShift(20)) & 32767L);
+ values[valuesOffset++] = (int)((block4.TripleShift(5)) & 32767L);
long block5 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block4 & 31L) << 10) | ((long)((ulong)block5 >> 54)));
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 39)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 24)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 9)) & 32767L);
+ values[valuesOffset++] = (int)(((block4 & 31L) << 10) | (block5.TripleShift(54)));
+ values[valuesOffset++] = (int)((block5.TripleShift(39)) & 32767L);
+ values[valuesOffset++] = (int)((block5.TripleShift(24)) & 32767L);
+ values[valuesOffset++] = (int)((block5.TripleShift(9)) & 32767L);
long block6 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block5 & 511L) << 6) | ((long)((ulong)block6 >> 58)));
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 43)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 28)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 13)) & 32767L);
+ values[valuesOffset++] = (int)(((block5 & 511L) << 6) | (block6.TripleShift(58)));
+ values[valuesOffset++] = (int)((block6.TripleShift(43)) & 32767L);
+ values[valuesOffset++] = (int)((block6.TripleShift(28)) & 32767L);
+ values[valuesOffset++] = (int)((block6.TripleShift(13)) & 32767L);
long block7 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block6 & 8191L) << 2) | ((long)((ulong)block7 >> 62)));
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 47)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 32)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 17)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 2)) & 32767L);
+ values[valuesOffset++] = (int)(((block6 & 8191L) << 2) | (block7.TripleShift(62)));
+ values[valuesOffset++] = (int)((block7.TripleShift(47)) & 32767L);
+ values[valuesOffset++] = (int)((block7.TripleShift(32)) & 32767L);
+ values[valuesOffset++] = (int)((block7.TripleShift(17)) & 32767L);
+ values[valuesOffset++] = (int)((block7.TripleShift(2)) & 32767L);
long block8 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block7 & 3L) << 13) | ((long)((ulong)block8 >> 51)));
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 36)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 21)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 6)) & 32767L);
+ values[valuesOffset++] = (int)(((block7 & 3L) << 13) | (block8.TripleShift(51)));
+ values[valuesOffset++] = (int)((block8.TripleShift(36)) & 32767L);
+ values[valuesOffset++] = (int)((block8.TripleShift(21)) & 32767L);
+ values[valuesOffset++] = (int)((block8.TripleShift(6)) & 32767L);
long block9 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block8 & 63L) << 9) | ((long)((ulong)block9 >> 55)));
- values[valuesOffset++] = (int)(((long)((ulong)block9 >> 40)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block9 >> 25)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block9 >> 10)) & 32767L);
+ values[valuesOffset++] = (int)(((block8 & 63L) << 9) | (block9.TripleShift(55)));
+ values[valuesOffset++] = (int)((block9.TripleShift(40)) & 32767L);
+ values[valuesOffset++] = (int)((block9.TripleShift(25)) & 32767L);
+ values[valuesOffset++] = (int)((block9.TripleShift(10)) & 32767L);
long block10 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block9 & 1023L) << 5) | ((long)((ulong)block10 >> 59)));
- values[valuesOffset++] = (int)(((long)((ulong)block10 >> 44)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block10 >> 29)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block10 >> 14)) & 32767L);
+ values[valuesOffset++] = (int)(((block9 & 1023L) << 5) | (block10.TripleShift(59)));
+ values[valuesOffset++] = (int)((block10.TripleShift(44)) & 32767L);
+ values[valuesOffset++] = (int)((block10.TripleShift(29)) & 32767L);
+ values[valuesOffset++] = (int)((block10.TripleShift(14)) & 32767L);
long block11 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block10 & 16383L) << 1) | ((long)((ulong)block11 >> 63)));
- values[valuesOffset++] = (int)(((long)((ulong)block11 >> 48)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block11 >> 33)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block11 >> 18)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block11 >> 3)) & 32767L);
+ values[valuesOffset++] = (int)(((block10 & 16383L) << 1) | (block11.TripleShift(63)));
+ values[valuesOffset++] = (int)((block11.TripleShift(48)) & 32767L);
+ values[valuesOffset++] = (int)((block11.TripleShift(33)) & 32767L);
+ values[valuesOffset++] = (int)((block11.TripleShift(18)) & 32767L);
+ values[valuesOffset++] = (int)((block11.TripleShift(3)) & 32767L);
long block12 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block11 & 7L) << 12) | ((long)((ulong)block12 >> 52)));
- values[valuesOffset++] = (int)(((long)((ulong)block12 >> 37)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block12 >> 22)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block12 >> 7)) & 32767L);
+ values[valuesOffset++] = (int)(((block11 & 7L) << 12) | (block12.TripleShift(52)));
+ values[valuesOffset++] = (int)((block12.TripleShift(37)) & 32767L);
+ values[valuesOffset++] = (int)((block12.TripleShift(22)) & 32767L);
+ values[valuesOffset++] = (int)((block12.TripleShift(7)) & 32767L);
long block13 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block12 & 127L) << 8) | ((long)((ulong)block13 >> 56)));
- values[valuesOffset++] = (int)(((long)((ulong)block13 >> 41)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block13 >> 26)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block13 >> 11)) & 32767L);
+ values[valuesOffset++] = (int)(((block12 & 127L) << 8) | (block13.TripleShift(56)));
+ values[valuesOffset++] = (int)((block13.TripleShift(41)) & 32767L);
+ values[valuesOffset++] = (int)((block13.TripleShift(26)) & 32767L);
+ values[valuesOffset++] = (int)((block13.TripleShift(11)) & 32767L);
long block14 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block13 & 2047L) << 4) | ((long)((ulong)block14 >> 60)));
- values[valuesOffset++] = (int)(((long)((ulong)block14 >> 45)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block14 >> 30)) & 32767L);
- values[valuesOffset++] = (int)(((long)((ulong)block14 >> 15)) & 32767L);
+ values[valuesOffset++] = (int)(((block13 & 2047L) << 4) | (block14.TripleShift(60)));
+ values[valuesOffset++] = (int)((block14.TripleShift(45)) & 32767L);
+ values[valuesOffset++] = (int)((block14.TripleShift(30)) & 32767L);
+ values[valuesOffset++] = (int)((block14.TripleShift(15)) & 32767L);
values[valuesOffset++] = (int)(block14 & 32767L);
}
}
@@ -121,25 +123,25 @@ namespace Lucene.Net.Util.Packed
{
int byte0 = blocks[blocksOffset++] & 0xFF;
int byte1 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (byte0 << 7) | ((int)((uint)byte1 >> 1));
+ values[valuesOffset++] = (byte0 << 7) | (byte1.TripleShift(1));
int byte2 = blocks[blocksOffset++] & 0xFF;
int byte3 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte1 & 1) << 14) | (byte2 << 6) | ((int)((uint)byte3 >> 2));
+ values[valuesOffset++] = ((byte1 & 1) << 14) | (byte2 << 6) | (byte3.TripleShift(2));
int byte4 = blocks[blocksOffset++] & 0xFF;
int byte5 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte3 & 3) << 13) | (byte4 << 5) | ((int)((uint)byte5 >> 3));
+ values[valuesOffset++] = ((byte3 & 3) << 13) | (byte4 << 5) | (byte5.TripleShift(3));
int byte6 = blocks[blocksOffset++] & 0xFF;
int byte7 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte5 & 7) << 12) | (byte6 << 4) | ((int)((uint)byte7 >> 4));
+ values[valuesOffset++] = ((byte5 & 7) << 12) | (byte6 << 4) | (byte7.TripleShift(4));
int byte8 = blocks[blocksOffset++] & 0xFF;
int byte9 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte7 & 15) << 11) | (byte8 << 3) | ((int)((uint)byte9 >> 5));
+ values[valuesOffset++] = ((byte7 & 15) << 11) | (byte8 << 3) | (byte9.TripleShift(5));
int byte10 = blocks[blocksOffset++] & 0xFF;
int byte11 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte9 & 31) << 10) | (byte10 << 2) | ((int)((uint)byte11 >> 6));
+ values[valuesOffset++] = ((byte9 & 31) << 10) | (byte10 << 2) | (byte11.TripleShift(6));
int byte12 = blocks[blocksOffset++] & 0xFF;
int byte13 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte11 & 63) << 9) | (byte12 << 1) | ((int)((uint)byte13 >> 7));
+ values[valuesOffset++] = ((byte11 & 63) << 9) | (byte12 << 1) | (byte13.TripleShift(7));
int byte14 = blocks[blocksOffset++] & 0xFF;
values[valuesOffset++] = ((byte13 & 127) << 8) | byte14;
}
@@ -150,83 +152,83 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (long)((ulong)block0 >> 49);
- values[valuesOffset++] = ((long)((ulong)block0 >> 34)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 19)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 4)) & 32767L;
+ values[valuesOffset++] = block0.TripleShift(49);
+ values[valuesOffset++] = (block0.TripleShift(34)) & 32767L;
+ values[valuesOffset++] = (block0.TripleShift(19)) & 32767L;
+ values[valuesOffset++] = (block0.TripleShift(4)) & 32767L;
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block0 & 15L) << 11) | ((long)((ulong)block1 >> 53));
- values[valuesOffset++] = ((long)((ulong)block1 >> 38)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 23)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 8)) & 32767L;
+ values[valuesOffset++] = ((block0 & 15L) << 11) | (block1.TripleShift(53));
+ values[valuesOffset++] = (block1.TripleShift(38)) & 32767L;
+ values[valuesOffset++] = (block1.TripleShift(23)) & 32767L;
+ values[valuesOffset++] = (block1.TripleShift(8)) & 32767L;
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block1 & 255L) << 7) | ((long)((ulong)block2 >> 57));
- values[valuesOffset++] = ((long)((ulong)block2 >> 42)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 27)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 12)) & 32767L;
+ values[valuesOffset++] = ((block1 & 255L) << 7) | (block2.TripleShift(57));
+ values[valuesOffset++] = (block2.TripleShift(42)) & 32767L;
+ values[valuesOffset++] = (block2.TripleShift(27)) & 32767L;
+ values[valuesOffset++] = (block2.TripleShift(12)) & 32767L;
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block2 & 4095L) << 3) | ((long)((ulong)block3 >> 61));
- values[valuesOffset++] = ((long)((ulong)block3 >> 46)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 31)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 16)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 1)) & 32767L;
+ values[valuesOffset++] = ((block2 & 4095L) << 3) | (block3.TripleShift(61));
+ values[valuesOffset++] = (block3.TripleShift(46)) & 32767L;
+ values[valuesOffset++] = (block3.TripleShift(31)) & 32767L;
+ values[valuesOffset++] = (block3.TripleShift(16)) & 32767L;
+ values[valuesOffset++] = (block3.TripleShift(1)) & 32767L;
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block3 & 1L) << 14) | ((long)((ulong)block4 >> 50));
- values[valuesOffset++] = ((long)((ulong)block4 >> 35)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 20)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 5)) & 32767L;
+ values[valuesOffset++] = ((block3 & 1L) << 14) | (block4.TripleShift(50));
+ values[valuesOffset++] = (block4.TripleShift(35)) & 32767L;
+ values[valuesOffset++] = (block4.TripleShift(20)) & 32767L;
+ values[valuesOffset++] = (block4.TripleShift(5)) & 32767L;
long block5 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block4 & 31L) << 10) | ((long)((ulong)block5 >> 54));
- values[valuesOffset++] = ((long)((ulong)block5 >> 39)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 24)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 9)) & 32767L;
+ values[valuesOffset++] = ((block4 & 31L) << 10) | (block5.TripleShift(54));
+ values[valuesOffset++] = (block5.TripleShift(39)) & 32767L;
+ values[valuesOffset++] = (block5.TripleShift(24)) & 32767L;
+ values[valuesOffset++] = (block5.TripleShift(9)) & 32767L;
long block6 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block5 & 511L) << 6) | ((long)((ulong)block6 >> 58));
- values[valuesOffset++] = ((long)((ulong)block6 >> 43)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 28)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 13)) & 32767L;
+ values[valuesOffset++] = ((block5 & 511L) << 6) | (block6.TripleShift(58));
+ values[valuesOffset++] = (block6.TripleShift(43)) & 32767L;
+ values[valuesOffset++] = (block6.TripleShift(28)) & 32767L;
+ values[valuesOffset++] = (block6.TripleShift(13)) & 32767L;
long block7 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block6 & 8191L) << 2) | ((long)((ulong)block7 >> 62));
- values[valuesOffset++] = ((long)((ulong)block7 >> 47)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block7 >> 32)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block7 >> 17)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block7 >> 2)) & 32767L;
+ values[valuesOffset++] = ((block6 & 8191L) << 2) | (block7.TripleShift(62));
+ values[valuesOffset++] = (block7.TripleShift(47)) & 32767L;
+ values[valuesOffset++] = (block7.TripleShift(32)) & 32767L;
+ values[valuesOffset++] = (block7.TripleShift(17)) & 32767L;
+ values[valuesOffset++] = (block7.TripleShift(2)) & 32767L;
long block8 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block7 & 3L) << 13) | ((long)((ulong)block8 >> 51));
- values[valuesOffset++] = ((long)((ulong)block8 >> 36)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block8 >> 21)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block8 >> 6)) & 32767L;
+ values[valuesOffset++] = ((block7 & 3L) << 13) | (block8.TripleShift(51));
+ values[valuesOffset++] = (block8.TripleShift(36)) & 32767L;
+ values[valuesOffset++] = (block8.TripleShift(21)) & 32767L;
+ values[valuesOffset++] = (block8.TripleShift(6)) & 32767L;
long block9 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block8 & 63L) << 9) | ((long)((ulong)block9 >> 55));
- values[valuesOffset++] = ((long)((ulong)block9 >> 40)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block9 >> 25)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block9 >> 10)) & 32767L;
+ values[valuesOffset++] = ((block8 & 63L) << 9) | (block9.TripleShift(55));
+ values[valuesOffset++] = (block9.TripleShift(40)) & 32767L;
+ values[valuesOffset++] = (block9.TripleShift(25)) & 32767L;
+ values[valuesOffset++] = (block9.TripleShift(10)) & 32767L;
long block10 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block9 & 1023L) << 5) | ((long)((ulong)block10 >> 59));
- values[valuesOffset++] = ((long)((ulong)block10 >> 44)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block10 >> 29)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block10 >> 14)) & 32767L;
+ values[valuesOffset++] = ((block9 & 1023L) << 5) | (block10.TripleShift(59));
+ values[valuesOffset++] = (block10.TripleShift(44)) & 32767L;
+ values[valuesOffset++] = (block10.TripleShift(29)) & 32767L;
+ values[valuesOffset++] = (block10.TripleShift(14)) & 32767L;
long block11 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block10 & 16383L) << 1) | ((long)((ulong)block11 >> 63));
- values[valuesOffset++] = ((long)((ulong)block11 >> 48)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block11 >> 33)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block11 >> 18)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block11 >> 3)) & 32767L;
+ values[valuesOffset++] = ((block10 & 16383L) << 1) | (block11.TripleShift(63));
+ values[valuesOffset++] = (block11.TripleShift(48)) & 32767L;
+ values[valuesOffset++] = (block11.TripleShift(33)) & 32767L;
+ values[valuesOffset++] = (block11.TripleShift(18)) & 32767L;
+ values[valuesOffset++] = (block11.TripleShift(3)) & 32767L;
long block12 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block11 & 7L) << 12) | ((long)((ulong)block12 >> 52));
- values[valuesOffset++] = ((long)((ulong)block12 >> 37)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block12 >> 22)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block12 >> 7)) & 32767L;
+ values[valuesOffset++] = ((block11 & 7L) << 12) | (block12.TripleShift(52));
+ values[valuesOffset++] = (block12.TripleShift(37)) & 32767L;
+ values[valuesOffset++] = (block12.TripleShift(22)) & 32767L;
+ values[valuesOffset++] = (block12.TripleShift(7)) & 32767L;
long block13 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block12 & 127L) << 8) | ((long)((ulong)block13 >> 56));
- values[valuesOffset++] = ((long)((ulong)block13 >> 41)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block13 >> 26)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block13 >> 11)) & 32767L;
+ values[valuesOffset++] = ((block12 & 127L) << 8) | (block13.TripleShift(56));
+ values[valuesOffset++] = (block13.TripleShift(41)) & 32767L;
+ values[valuesOffset++] = (block13.TripleShift(26)) & 32767L;
+ values[valuesOffset++] = (block13.TripleShift(11)) & 32767L;
long block14 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block13 & 2047L) << 4) | ((long)((ulong)block14 >> 60));
- values[valuesOffset++] = ((long)((ulong)block14 >> 45)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block14 >> 30)) & 32767L;
- values[valuesOffset++] = ((long)((ulong)block14 >> 15)) & 32767L;
+ values[valuesOffset++] = ((block13 & 2047L) << 4) | (block14.TripleShift(60));
+ values[valuesOffset++] = (block14.TripleShift(45)) & 32767L;
+ values[valuesOffset++] = (block14.TripleShift(30)) & 32767L;
+ values[valuesOffset++] = (block14.TripleShift(15)) & 32767L;
values[valuesOffset++] = block14 & 32767L;
}
}
@@ -237,25 +239,25 @@ namespace Lucene.Net.Util.Packed
{
long byte0 = blocks[blocksOffset++] & 0xFF;
long byte1 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (byte0 << 7) | ((long)((ulong)byte1 >> 1));
+ values[valuesOffset++] = (byte0 << 7) | (byte1.TripleShift(1));
long byte2 = blocks[blocksOffset++] & 0xFF;
long byte3 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte1 & 1) << 14) | (byte2 << 6) | ((long)((ulong)byte3 >> 2));
+ values[valuesOffset++] = ((byte1 & 1) << 14) | (byte2 << 6) | (byte3.TripleShift(2));
long byte4 = blocks[blocksOffset++] & 0xFF;
long byte5 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte3 & 3) << 13) | (byte4 << 5) | ((long)((ulong)byte5 >> 3));
+ values[valuesOffset++] = ((byte3 & 3) << 13) | (byte4 << 5) | (byte5.TripleShift(3));
long byte6 = blocks[blocksOffset++] & 0xFF;
long byte7 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte5 & 7) << 12) | (byte6 << 4) | ((long)((ulong)byte7 >> 4));
+ values[valuesOffset++] = ((byte5 & 7) << 12) | (byte6 << 4) | (byte7.TripleShift(4));
long byte8 = blocks[blocksOffset++] & 0xFF;
long byte9 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte7 & 15) << 11) | (byte8 << 3) | ((long)((ulong)byte9 >> 5));
+ values[valuesOffset++] = ((byte7 & 15) << 11) | (byte8 << 3) | (byte9.TripleShift(5));
long byte10 = blocks[blocksOffset++] & 0xFF;
long byte11 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte9 & 31) << 10) | (byte10 << 2) | ((long)((ulong)byte11 >> 6));
+ values[valuesOffset++] = ((byte9 & 31) << 10) | (byte10 << 2) | (byte11.TripleShift(6));
long byte12 = blocks[blocksOffset++] & 0xFF;
long byte13 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte11 & 63) << 9) | (byte12 << 1) | ((long)((ulong)byte13 >> 7));
+ values[valuesOffset++] = ((byte11 & 63) << 9) | (byte12 << 1) | (byte13.TripleShift(7));
long byte14 = blocks[blocksOffset++] & 0xFF;
values[valuesOffset++] = ((byte13 & 127) << 8) | byte14;
}
diff --git a/src/Lucene.Net/Util/Packed/BulkOperationPacked16.cs b/src/Lucene.Net/Util/Packed/BulkOperationPacked16.cs
index 01c4bcf..0d67d52 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperationPacked16.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperationPacked16.cs
@@ -1,4 +1,6 @@
-// this file has been automatically generated, DO NOT EDIT
+// this file has been automatically generated, DO NOT EDIT
+
+using J2N.Numerics;
namespace Lucene.Net.Util.Packed
{
@@ -36,7 +38,7 @@ namespace Lucene.Net.Util.Packed
long block = blocks[blocksOffset++];
for (int shift = 48; shift >= 0; shift -= 16)
{
- values[valuesOffset++] = (int)(((long)((ulong)block >> shift)) & 65535);
+ values[valuesOffset++] = (int)((block.TripleShift(shift)) & 65535);
}
}
}
@@ -56,7 +58,7 @@ namespace Lucene.Net.Util.Packed
long block = blocks[blocksOffset++];
for (int shift = 48; shift >= 0; shift -= 16)
{
- values[valuesOffset++] = ((long)((ulong)block >> shift)) & 65535;
+ values[valuesOffset++] = (block.TripleShift(shift)) & 65535;
}
}
}
diff --git a/src/Lucene.Net/Util/Packed/BulkOperationPacked17.cs b/src/Lucene.Net/Util/Packed/BulkOperationPacked17.cs
index 2fc2ff1..75a04ca 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperationPacked17.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperationPacked17.cs
@@ -1,4 +1,6 @@
-// this file has been automatically generated, DO NOT EDIT
+// this file has been automatically generated, DO NOT EDIT
+
+using J2N.Numerics;
namespace Lucene.Net.Util.Packed
{
@@ -34,85 +36,85 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)((long)((ulong)block0 >> 47));
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 30)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 13)) & 131071L);
+ values[valuesOffset++] = (int)(block0.TripleShift(47));
+ values[valuesOffset++] = (int)((block0.TripleShift(30)) & 131071L);
+ values[valuesOffset++] = (int)((block0.TripleShift(13)) & 131071L);
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block0 & 8191L) << 4) | ((long)((ulong)block1 >> 60)));
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 43)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 26)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 9)) & 131071L);
+ values[valuesOffset++] = (int)(((block0 & 8191L) << 4) | (block1.TripleShift(60)));
+ values[valuesOffset++] = (int)((block1.TripleShift(43)) & 131071L);
+ values[valuesOffset++] = (int)((block1.TripleShift(26)) & 131071L);
+ values[valuesOffset++] = (int)((block1.TripleShift(9)) & 131071L);
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block1 & 511L) << 8) | ((long)((ulong)block2 >> 56)));
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 39)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 22)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 5)) & 131071L);
+ values[valuesOffset++] = (int)(((block1 & 511L) << 8) | (block2.TripleShift(56)));
+ values[valuesOffset++] = (int)((block2.TripleShift(39)) & 131071L);
+ values[valuesOffset++] = (int)((block2.TripleShift(22)) & 131071L);
+ values[valuesOffset++] = (int)((block2.TripleShift(5)) & 131071L);
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block2 & 31L) << 12) | ((long)((ulong)block3 >> 52)));
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 35)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 18)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 1)) & 131071L);
+ values[valuesOffset++] = (int)(((block2 & 31L) << 12) | (block3.TripleShift(52)));
+ values[valuesOffset++] = (int)((block3.TripleShift(35)) & 131071L);
+ values[valuesOffset++] = (int)((block3.TripleShift(18)) & 131071L);
+ values[valuesOffset++] = (int)((block3.TripleShift(1)) & 131071L);
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block3 & 1L) << 16) | ((long)((ulong)block4 >> 48)));
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 31)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 14)) & 131071L);
+ values[valuesOffset++] = (int)(((block3 & 1L) << 16) | (block4.TripleShift(48)));
+ values[valuesOffset++] = (int)((block4.TripleShift(31)) & 131071L);
+ values[valuesOffset++] = (int)((block4.TripleShift(14)) & 131071L);
long block5 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block4 & 16383L) << 3) | ((long)((ulong)block5 >> 61)));
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 44)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 27)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 10)) & 131071L);
+ values[valuesOffset++] = (int)(((block4 & 16383L) << 3) | (block5.TripleShift(61)));
+ values[valuesOffset++] = (int)((block5.TripleShift(44)) & 131071L);
+ values[valuesOffset++] = (int)((block5.TripleShift(27)) & 131071L);
+ values[valuesOffset++] = (int)((block5.TripleShift(10)) & 131071L);
long block6 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block5 & 1023L) << 7) | ((long)((ulong)block6 >> 57)));
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 40)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 23)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 6)) & 131071L);
+ values[valuesOffset++] = (int)(((block5 & 1023L) << 7) | (block6.TripleShift(57)));
+ values[valuesOffset++] = (int)((block6.TripleShift(40)) & 131071L);
+ values[valuesOffset++] = (int)((block6.TripleShift(23)) & 131071L);
+ values[valuesOffset++] = (int)((block6.TripleShift(6)) & 131071L);
long block7 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block6 & 63L) << 11) | ((long)((ulong)block7 >> 53)));
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 36)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 19)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 2)) & 131071L);
+ values[valuesOffset++] = (int)(((block6 & 63L) << 11) | (block7.TripleShift(53)));
+ values[valuesOffset++] = (int)((block7.TripleShift(36)) & 131071L);
+ values[valuesOffset++] = (int)((block7.TripleShift(19)) & 131071L);
+ values[valuesOffset++] = (int)((block7.TripleShift(2)) & 131071L);
long block8 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block7 & 3L) << 15) | ((long)((ulong)block8 >> 49)));
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 32)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 15)) & 131071L);
+ values[valuesOffset++] = (int)(((block7 & 3L) << 15) | (block8.TripleShift(49)));
+ values[valuesOffset++] = (int)((block8.TripleShift(32)) & 131071L);
+ values[valuesOffset++] = (int)((block8.TripleShift(15)) & 131071L);
long block9 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block8 & 32767L) << 2) | ((long)((ulong)block9 >> 62)));
- values[valuesOffset++] = (int)(((long)((ulong)block9 >> 45)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block9 >> 28)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block9 >> 11)) & 131071L);
+ values[valuesOffset++] = (int)(((block8 & 32767L) << 2) | (block9.TripleShift(62)));
+ values[valuesOffset++] = (int)((block9.TripleShift(45)) & 131071L);
+ values[valuesOffset++] = (int)((block9.TripleShift(28)) & 131071L);
+ values[valuesOffset++] = (int)((block9.TripleShift(11)) & 131071L);
long block10 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block9 & 2047L) << 6) | ((long)((ulong)block10 >> 58)));
- values[valuesOffset++] = (int)(((long)((ulong)block10 >> 41)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block10 >> 24)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block10 >> 7)) & 131071L);
+ values[valuesOffset++] = (int)(((block9 & 2047L) << 6) | (block10.TripleShift(58)));
+ values[valuesOffset++] = (int)((block10.TripleShift(41)) & 131071L);
+ values[valuesOffset++] = (int)((block10.TripleShift(24)) & 131071L);
+ values[valuesOffset++] = (int)((block10.TripleShift(7)) & 131071L);
long block11 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block10 & 127L) << 10) | ((long)((ulong)block11 >> 54)));
- values[valuesOffset++] = (int)(((long)((ulong)block11 >> 37)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block11 >> 20)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block11 >> 3)) & 131071L);
+ values[valuesOffset++] = (int)(((block10 & 127L) << 10) | (block11.TripleShift(54)));
+ values[valuesOffset++] = (int)((block11.TripleShift(37)) & 131071L);
+ values[valuesOffset++] = (int)((block11.TripleShift(20)) & 131071L);
+ values[valuesOffset++] = (int)((block11.TripleShift(3)) & 131071L);
long block12 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block11 & 7L) << 14) | ((long)((ulong)block12 >> 50)));
- values[valuesOffset++] = (int)(((long)((ulong)block12 >> 33)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block12 >> 16)) & 131071L);
+ values[valuesOffset++] = (int)(((block11 & 7L) << 14) | (block12.TripleShift(50)));
+ values[valuesOffset++] = (int)((block12.TripleShift(33)) & 131071L);
+ values[valuesOffset++] = (int)((block12.TripleShift(16)) & 131071L);
long block13 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block12 & 65535L) << 1) | ((long)((ulong)block13 >> 63)));
- values[valuesOffset++] = (int)(((long)((ulong)block13 >> 46)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block13 >> 29)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block13 >> 12)) & 131071L);
+ values[valuesOffset++] = (int)(((block12 & 65535L) << 1) | (block13.TripleShift(63)));
+ values[valuesOffset++] = (int)((block13.TripleShift(46)) & 131071L);
+ values[valuesOffset++] = (int)((block13.TripleShift(29)) & 131071L);
+ values[valuesOffset++] = (int)((block13.TripleShift(12)) & 131071L);
long block14 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block13 & 4095L) << 5) | ((long)((ulong)block14 >> 59)));
- values[valuesOffset++] = (int)(((long)((ulong)block14 >> 42)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block14 >> 25)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block14 >> 8)) & 131071L);
+ values[valuesOffset++] = (int)(((block13 & 4095L) << 5) | (block14.TripleShift(59)));
+ values[valuesOffset++] = (int)((block14.TripleShift(42)) & 131071L);
+ values[valuesOffset++] = (int)((block14.TripleShift(25)) & 131071L);
+ values[valuesOffset++] = (int)((block14.TripleShift(8)) & 131071L);
long block15 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block14 & 255L) << 9) | ((long)((ulong)block15 >> 55)));
- values[valuesOffset++] = (int)(((long)((ulong)block15 >> 38)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block15 >> 21)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block15 >> 4)) & 131071L);
+ values[valuesOffset++] = (int)(((block14 & 255L) << 9) | (block15.TripleShift(55)));
+ values[valuesOffset++] = (int)((block15.TripleShift(38)) & 131071L);
+ values[valuesOffset++] = (int)((block15.TripleShift(21)) & 131071L);
+ values[valuesOffset++] = (int)((block15.TripleShift(4)) & 131071L);
long block16 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block15 & 15L) << 13) | ((long)((ulong)block16 >> 51)));
- values[valuesOffset++] = (int)(((long)((ulong)block16 >> 34)) & 131071L);
- values[valuesOffset++] = (int)(((long)((ulong)block16 >> 17)) & 131071L);
+ values[valuesOffset++] = (int)(((block15 & 15L) << 13) | (block16.TripleShift(51)));
+ values[valuesOffset++] = (int)((block16.TripleShift(34)) & 131071L);
+ values[valuesOffset++] = (int)((block16.TripleShift(17)) & 131071L);
values[valuesOffset++] = (int)(block16 & 131071L);
}
}
@@ -124,25 +126,25 @@ namespace Lucene.Net.Util.Packed
int byte0 = blocks[blocksOffset++] & 0xFF;
int byte1 = blocks[blocksOffset++] & 0xFF;
int byte2 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (byte0 << 9) | (byte1 << 1) | ((int)((uint)byte2 >> 7));
+ values[valuesOffset++] = (byte0 << 9) | (byte1 << 1) | (byte2.TripleShift(7));
int byte3 = blocks[blocksOffset++] & 0xFF;
int byte4 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte2 & 127) << 10) | (byte3 << 2) | ((int)((uint)byte4 >> 6));
+ values[valuesOffset++] = ((byte2 & 127) << 10) | (byte3 << 2) | (byte4.TripleShift(6));
int byte5 = blocks[blocksOffset++] & 0xFF;
int byte6 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte4 & 63) << 11) | (byte5 << 3) | ((int)((uint)byte6 >> 5));
+ values[valuesOffset++] = ((byte4 & 63) << 11) | (byte5 << 3) | (byte6.TripleShift(5));
int byte7 = blocks[blocksOffset++] & 0xFF;
int byte8 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte6 & 31) << 12) | (byte7 << 4) | ((int)((uint)byte8 >> 4));
+ values[valuesOffset++] = ((byte6 & 31) << 12) | (byte7 << 4) | (byte8.TripleShift(4));
int byte9 = blocks[blocksOffset++] & 0xFF;
int byte10 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte8 & 15) << 13) | (byte9 << 5) | ((int)((uint)byte10 >> 3));
+ values[valuesOffset++] = ((byte8 & 15) << 13) | (byte9 << 5) | (byte10.TripleShift(3));
int byte11 = blocks[blocksOffset++] & 0xFF;
int byte12 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte10 & 7) << 14) | (byte11 << 6) | ((int)((uint)byte12 >> 2));
+ values[valuesOffset++] = ((byte10 & 7) << 14) | (byte11 << 6) | (byte12.TripleShift(2));
int byte13 = blocks[blocksOffset++] & 0xFF;
int byte14 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte12 & 3) << 15) | (byte13 << 7) | ((int)((uint)byte14 >> 1));
+ values[valuesOffset++] = ((byte12 & 3) << 15) | (byte13 << 7) | (byte14.TripleShift(1));
int byte15 = blocks[blocksOffset++] & 0xFF;
int byte16 = blocks[blocksOffset++] & 0xFF;
values[valuesOffset++] = ((byte14 & 1) << 16) | (byte15 << 8) | byte16;
@@ -154,85 +156,85 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (long)((ulong)block0 >> 47);
- values[valuesOffset++] = ((long)((ulong)block0 >> 30)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 13)) & 131071L;
+ values[valuesOffset++] = block0.TripleShift(47);
+ values[valuesOffset++] = (block0.TripleShift(30)) & 131071L;
+ values[valuesOffset++] = (block0.TripleShift(13)) & 131071L;
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block0 & 8191L) << 4) | ((long)((ulong)block1 >> 60));
- values[valuesOffset++] = ((long)((ulong)block1 >> 43)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 26)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 9)) & 131071L;
+ values[valuesOffset++] = ((block0 & 8191L) << 4) | (block1.TripleShift(60));
+ values[valuesOffset++] = (block1.TripleShift(43)) & 131071L;
+ values[valuesOffset++] = (block1.TripleShift(26)) & 131071L;
+ values[valuesOffset++] = (block1.TripleShift(9)) & 131071L;
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block1 & 511L) << 8) | ((long)((ulong)block2 >> 56));
- values[valuesOffset++] = ((long)((ulong)block2 >> 39)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 22)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 5)) & 131071L;
+ values[valuesOffset++] = ((block1 & 511L) << 8) | (block2.TripleShift(56));
+ values[valuesOffset++] = (block2.TripleShift(39)) & 131071L;
+ values[valuesOffset++] = (block2.TripleShift(22)) & 131071L;
+ values[valuesOffset++] = (block2.TripleShift(5)) & 131071L;
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block2 & 31L) << 12) | ((long)((ulong)block3 >> 52));
- values[valuesOffset++] = ((long)((ulong)block3 >> 35)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 18)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 1)) & 131071L;
+ values[valuesOffset++] = ((block2 & 31L) << 12) | (block3.TripleShift(52));
+ values[valuesOffset++] = (block3.TripleShift(35)) & 131071L;
+ values[valuesOffset++] = (block3.TripleShift(18)) & 131071L;
+ values[valuesOffset++] = (block3.TripleShift(1)) & 131071L;
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block3 & 1L) << 16) | ((long)((ulong)block4 >> 48));
- values[valuesOffset++] = ((long)((ulong)block4 >> 31)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 14)) & 131071L;
+ values[valuesOffset++] = ((block3 & 1L) << 16) | (block4.TripleShift(48));
+ values[valuesOffset++] = (block4.TripleShift(31)) & 131071L;
+ values[valuesOffset++] = (block4.TripleShift(14)) & 131071L;
long block5 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block4 & 16383L) << 3) | ((long)((ulong)block5 >> 61));
- values[valuesOffset++] = ((long)((ulong)block5 >> 44)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 27)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 10)) & 131071L;
+ values[valuesOffset++] = ((block4 & 16383L) << 3) | (block5.TripleShift(61));
+ values[valuesOffset++] = (block5.TripleShift(44)) & 131071L;
+ values[valuesOffset++] = (block5.TripleShift(27)) & 131071L;
+ values[valuesOffset++] = (block5.TripleShift(10)) & 131071L;
long block6 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block5 & 1023L) << 7) | ((long)((ulong)block6 >> 57));
- values[valuesOffset++] = ((long)((ulong)block6 >> 40)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 23)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 6)) & 131071L;
+ values[valuesOffset++] = ((block5 & 1023L) << 7) | (block6.TripleShift(57));
+ values[valuesOffset++] = (block6.TripleShift(40)) & 131071L;
+ values[valuesOffset++] = (block6.TripleShift(23)) & 131071L;
+ values[valuesOffset++] = (block6.TripleShift(6)) & 131071L;
long block7 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block6 & 63L) << 11) | ((long)((ulong)block7 >> 53));
- values[valuesOffset++] = ((long)((ulong)block7 >> 36)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block7 >> 19)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block7 >> 2)) & 131071L;
+ values[valuesOffset++] = ((block6 & 63L) << 11) | (block7.TripleShift(53));
+ values[valuesOffset++] = (block7.TripleShift(36)) & 131071L;
+ values[valuesOffset++] = (block7.TripleShift(19)) & 131071L;
+ values[valuesOffset++] = (block7.TripleShift(2)) & 131071L;
long block8 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block7 & 3L) << 15) | ((long)((ulong)block8 >> 49));
- values[valuesOffset++] = ((long)((ulong)block8 >> 32)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block8 >> 15)) & 131071L;
+ values[valuesOffset++] = ((block7 & 3L) << 15) | (block8.TripleShift(49));
+ values[valuesOffset++] = (block8.TripleShift(32)) & 131071L;
+ values[valuesOffset++] = (block8.TripleShift(15)) & 131071L;
long block9 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block8 & 32767L) << 2) | ((long)((ulong)block9 >> 62));
- values[valuesOffset++] = ((long)((ulong)block9 >> 45)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block9 >> 28)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block9 >> 11)) & 131071L;
+ values[valuesOffset++] = ((block8 & 32767L) << 2) | (block9.TripleShift(62));
+ values[valuesOffset++] = (block9.TripleShift(45)) & 131071L;
+ values[valuesOffset++] = (block9.TripleShift(28)) & 131071L;
+ values[valuesOffset++] = (block9.TripleShift(11)) & 131071L;
long block10 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block9 & 2047L) << 6) | ((long)((ulong)block10 >> 58));
- values[valuesOffset++] = ((long)((ulong)block10 >> 41)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block10 >> 24)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block10 >> 7)) & 131071L;
+ values[valuesOffset++] = ((block9 & 2047L) << 6) | (block10.TripleShift(58));
+ values[valuesOffset++] = (block10.TripleShift(41)) & 131071L;
+ values[valuesOffset++] = (block10.TripleShift(24)) & 131071L;
+ values[valuesOffset++] = (block10.TripleShift(7)) & 131071L;
long block11 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block10 & 127L) << 10) | ((long)((ulong)block11 >> 54));
- values[valuesOffset++] = ((long)((ulong)block11 >> 37)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block11 >> 20)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block11 >> 3)) & 131071L;
+ values[valuesOffset++] = ((block10 & 127L) << 10) | (block11.TripleShift(54));
+ values[valuesOffset++] = (block11.TripleShift(37)) & 131071L;
+ values[valuesOffset++] = (block11.TripleShift(20)) & 131071L;
+ values[valuesOffset++] = (block11.TripleShift(3)) & 131071L;
long block12 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block11 & 7L) << 14) | ((long)((ulong)block12 >> 50));
- values[valuesOffset++] = ((long)((ulong)block12 >> 33)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block12 >> 16)) & 131071L;
+ values[valuesOffset++] = ((block11 & 7L) << 14) | (block12.TripleShift(50));
+ values[valuesOffset++] = (block12.TripleShift(33)) & 131071L;
+ values[valuesOffset++] = (block12.TripleShift(16)) & 131071L;
long block13 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block12 & 65535L) << 1) | ((long)((ulong)block13 >> 63));
- values[valuesOffset++] = ((long)((ulong)block13 >> 46)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block13 >> 29)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block13 >> 12)) & 131071L;
+ values[valuesOffset++] = ((block12 & 65535L) << 1) | (block13.TripleShift(63));
+ values[valuesOffset++] = (block13.TripleShift(46)) & 131071L;
+ values[valuesOffset++] = (block13.TripleShift(29)) & 131071L;
+ values[valuesOffset++] = (block13.TripleShift(12)) & 131071L;
long block14 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block13 & 4095L) << 5) | ((long)((ulong)block14 >> 59));
- values[valuesOffset++] = ((long)((ulong)block14 >> 42)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block14 >> 25)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block14 >> 8)) & 131071L;
+ values[valuesOffset++] = ((block13 & 4095L) << 5) | (block14.TripleShift(59));
+ values[valuesOffset++] = (block14.TripleShift(42)) & 131071L;
+ values[valuesOffset++] = (block14.TripleShift(25)) & 131071L;
+ values[valuesOffset++] = (block14.TripleShift(8)) & 131071L;
long block15 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block14 & 255L) << 9) | ((long)((ulong)block15 >> 55));
- values[valuesOffset++] = ((long)((ulong)block15 >> 38)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block15 >> 21)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block15 >> 4)) & 131071L;
+ values[valuesOffset++] = ((block14 & 255L) << 9) | (block15.TripleShift(55));
+ values[valuesOffset++] = (block15.TripleShift(38)) & 131071L;
+ values[valuesOffset++] = (block15.TripleShift(21)) & 131071L;
+ values[valuesOffset++] = (block15.TripleShift(4)) & 131071L;
long block16 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block15 & 15L) << 13) | ((long)((ulong)block16 >> 51));
- values[valuesOffset++] = ((long)((ulong)block16 >> 34)) & 131071L;
- values[valuesOffset++] = ((long)((ulong)block16 >> 17)) & 131071L;
+ values[valuesOffset++] = ((block15 & 15L) << 13) | (block16.TripleShift(51));
+ values[valuesOffset++] = (block16.TripleShift(34)) & 131071L;
+ values[valuesOffset++] = (block16.TripleShift(17)) & 131071L;
values[valuesOffset++] = block16 & 131071L;
}
}
@@ -244,25 +246,25 @@ namespace Lucene.Net.Util.Packed
long byte0 = blocks[blocksOffset++] & 0xFF;
long byte1 = blocks[blocksOffset++] & 0xFF;
long byte2 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (byte0 << 9) | (byte1 << 1) | ((long)((ulong)byte2 >> 7));
+ values[valuesOffset++] = (byte0 << 9) | (byte1 << 1) | (byte2.TripleShift(7));
long byte3 = blocks[blocksOffset++] & 0xFF;
long byte4 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte2 & 127) << 10) | (byte3 << 2) | ((long)((ulong)byte4 >> 6));
+ values[valuesOffset++] = ((byte2 & 127) << 10) | (byte3 << 2) | (byte4.TripleShift(6));
long byte5 = blocks[blocksOffset++] & 0xFF;
long byte6 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte4 & 63) << 11) | (byte5 << 3) | ((long)((ulong)byte6 >> 5));
+ values[valuesOffset++] = ((byte4 & 63) << 11) | (byte5 << 3) | (byte6.TripleShift(5));
long byte7 = blocks[blocksOffset++] & 0xFF;
long byte8 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte6 & 31) << 12) | (byte7 << 4) | ((long)((ulong)byte8 >> 4));
+ values[valuesOffset++] = ((byte6 & 31) << 12) | (byte7 << 4) | (byte8.TripleShift(4));
long byte9 = blocks[blocksOffset++] & 0xFF;
long byte10 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte8 & 15) << 13) | (byte9 << 5) | ((long)((ulong)byte10 >> 3));
+ values[valuesOffset++] = ((byte8 & 15) << 13) | (byte9 << 5) | (byte10.TripleShift(3));
long byte11 = blocks[blocksOffset++] & 0xFF;
long byte12 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte10 & 7) << 14) | (byte11 << 6) | ((long)((ulong)byte12 >> 2));
+ values[valuesOffset++] = ((byte10 & 7) << 14) | (byte11 << 6) | (byte12.TripleShift(2));
long byte13 = blocks[blocksOffset++] & 0xFF;
long byte14 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte12 & 3) << 15) | (byte13 << 7) | ((long)((ulong)byte14 >> 1));
+ values[valuesOffset++] = ((byte12 & 3) << 15) | (byte13 << 7) | (byte14.TripleShift(1));
long byte15 = blocks[blocksOffset++] & 0xFF;
long byte16 = blocks[blocksOffset++] & 0xFF;
values[valuesOffset++] = ((byte14 & 1) << 16) | (byte15 << 8) | byte16;
diff --git a/src/Lucene.Net/Util/Packed/BulkOperationPacked18.cs b/src/Lucene.Net/Util/Packed/BulkOperationPacked18.cs
index 6ed22d4..209661f 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperationPacked18.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperationPacked18.cs
@@ -1,4 +1,6 @@
-// this file has been automatically generated, DO NOT EDIT
+// this file has been automatically generated, DO NOT EDIT
+
+using J2N.Numerics;
namespace Lucene.Net.Util.Packed
{
@@ -34,45 +36,45 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)((long)((ulong)block0 >> 46));
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 28)) & 262143L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 10)) & 262143L);
+ values[valuesOffset++] = (int)(block0.TripleShift(46));
+ values[valuesOffset++] = (int)((block0.TripleShift(28)) & 262143L);
+ values[valuesOffset++] = (int)((block0.TripleShift(10)) & 262143L);
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block0 & 1023L) << 8) | ((long)((ulong)block1 >> 56)));
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 38)) & 262143L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 20)) & 262143L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 2)) & 262143L);
+ values[valuesOffset++] = (int)(((block0 & 1023L) << 8) | (block1.TripleShift(56)));
+ values[valuesOffset++] = (int)((block1.TripleShift(38)) & 262143L);
+ values[valuesOffset++] = (int)((block1.TripleShift(20)) & 262143L);
+ values[valuesOffset++] = (int)((block1.TripleShift(2)) & 262143L);
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block1 & 3L) << 16) | ((long)((ulong)block2 >> 48)));
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 30)) & 262143L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 12)) & 262143L);
+ values[valuesOffset++] = (int)(((block1 & 3L) << 16) | (block2.TripleShift(48)));
+ values[valuesOffset++] = (int)((block2.TripleShift(30)) & 262143L);
+ values[valuesOffset++] = (int)((block2.TripleShift(12)) & 262143L);
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block2 & 4095L) << 6) | ((long)((ulong)block3 >> 58)));
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 40)) & 262143L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 22)) & 262143L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 4)) & 262143L);
+ values[valuesOffset++] = (int)(((block2 & 4095L) << 6) | (block3.TripleShift(58)));
+ values[valuesOffset++] = (int)((block3.TripleShift(40)) & 262143L);
+ values[valuesOffset++] = (int)((block3.TripleShift(22)) & 262143L);
+ values[valuesOffset++] = (int)((block3.TripleShift(4)) & 262143L);
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block3 & 15L) << 14) | ((long)((ulong)block4 >> 50)));
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 32)) & 262143L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 14)) & 262143L);
+ values[valuesOffset++] = (int)(((block3 & 15L) << 14) | (block4.TripleShift(50)));
+ values[valuesOffset++] = (int)((block4.TripleShift(32)) & 262143L);
+ values[valuesOffset++] = (int)((block4.TripleShift(14)) & 262143L);
long block5 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block4 & 16383L) << 4) | ((long)((ulong)block5 >> 60)));
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 42)) & 262143L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 24)) & 262143L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 6)) & 262143L);
+ values[valuesOffset++] = (int)(((block4 & 16383L) << 4) | (block5.TripleShift(60)));
+ values[valuesOffset++] = (int)((block5.TripleShift(42)) & 262143L);
+ values[valuesOffset++] = (int)((block5.TripleShift(24)) & 262143L);
+ values[valuesOffset++] = (int)((block5.TripleShift(6)) & 262143L);
long block6 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block5 & 63L) << 12) | ((long)((ulong)block6 >> 52)));
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 34)) & 262143L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 16)) & 262143L);
+ values[valuesOffset++] = (int)(((block5 & 63L) << 12) | (block6.TripleShift(52)));
+ values[valuesOffset++] = (int)((block6.TripleShift(34)) & 262143L);
+ values[valuesOffset++] = (int)((block6.TripleShift(16)) & 262143L);
long block7 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block6 & 65535L) << 2) | ((long)((ulong)block7 >> 62)));
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 44)) & 262143L);
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 26)) & 262143L);
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 8)) & 262143L);
+ values[valuesOffset++] = (int)(((block6 & 65535L) << 2) | (block7.TripleShift(62)));
+ values[valuesOffset++] = (int)((block7.TripleShift(44)) & 262143L);
+ values[valuesOffset++] = (int)((block7.TripleShift(26)) & 262143L);
+ values[valuesOffset++] = (int)((block7.TripleShift(8)) & 262143L);
long block8 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block7 & 255L) << 10) | ((long)((ulong)block8 >> 54)));
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 36)) & 262143L);
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 18)) & 262143L);
+ values[valuesOffset++] = (int)(((block7 & 255L) << 10) | (block8.TripleShift(54)));
+ values[valuesOffset++] = (int)((block8.TripleShift(36)) & 262143L);
+ values[valuesOffset++] = (int)((block8.TripleShift(18)) & 262143L);
values[valuesOffset++] = (int)(block8 & 262143L);
}
}
@@ -84,13 +86,13 @@ namespace Lucene.Net.Util.Packed
int byte0 = blocks[blocksOffset++] & 0xFF;
int byte1 = blocks[blocksOffset++] & 0xFF;
int byte2 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (byte0 << 10) | (byte1 << 2) | ((int)((uint)byte2 >> 6));
+ values[valuesOffset++] = (byte0 << 10) | (byte1 << 2) | (byte2.TripleShift(6));
int byte3 = blocks[blocksOffset++] & 0xFF;
int byte4 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte2 & 63) << 12) | (byte3 << 4) | ((int)((uint)byte4 >> 4));
+ values[valuesOffset++] = ((byte2 & 63) << 12) | (byte3 << 4) | (byte4.TripleShift(4));
int byte5 = blocks[blocksOffset++] & 0xFF;
int byte6 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte4 & 15) << 14) | (byte5 << 6) | ((int)((uint)byte6 >> 2));
+ values[valuesOffset++] = ((byte4 & 15) << 14) | (byte5 << 6) | (byte6.TripleShift(2));
int byte7 = blocks[blocksOffset++] & 0xFF;
int byte8 = blocks[blocksOffset++] & 0xFF;
values[valuesOffset++] = ((byte6 & 3) << 16) | (byte7 << 8) | byte8;
@@ -102,45 +104,45 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (long)((ulong)block0 >> 46);
- values[valuesOffset++] = ((long)((ulong)block0 >> 28)) & 262143L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 10)) & 262143L;
+ values[valuesOffset++] = block0.TripleShift(46);
+ values[valuesOffset++] = (block0.TripleShift(28)) & 262143L;
+ values[valuesOffset++] = (block0.TripleShift(10)) & 262143L;
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block0 & 1023L) << 8) | ((long)((ulong)block1 >> 56));
- values[valuesOffset++] = ((long)((ulong)block1 >> 38)) & 262143L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 20)) & 262143L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 2)) & 262143L;
+ values[valuesOffset++] = ((block0 & 1023L) << 8) | (block1.TripleShift(56));
+ values[valuesOffset++] = (block1.TripleShift(38)) & 262143L;
+ values[valuesOffset++] = (block1.TripleShift(20)) & 262143L;
+ values[valuesOffset++] = (block1.TripleShift(2)) & 262143L;
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block1 & 3L) << 16) | ((long)((ulong)block2 >> 48));
- values[valuesOffset++] = ((long)((ulong)block2 >> 30)) & 262143L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 12)) & 262143L;
+ values[valuesOffset++] = ((block1 & 3L) << 16) | (block2.TripleShift(48));
+ values[valuesOffset++] = (block2.TripleShift(30)) & 262143L;
+ values[valuesOffset++] = (block2.TripleShift(12)) & 262143L;
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block2 & 4095L) << 6) | ((long)((ulong)block3 >> 58));
- values[valuesOffset++] = ((long)((ulong)block3 >> 40)) & 262143L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 22)) & 262143L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 4)) & 262143L;
+ values[valuesOffset++] = ((block2 & 4095L) << 6) | (block3.TripleShift(58));
+ values[valuesOffset++] = (block3.TripleShift(40)) & 262143L;
+ values[valuesOffset++] = (block3.TripleShift(22)) & 262143L;
+ values[valuesOffset++] = (block3.TripleShift(4)) & 262143L;
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block3 & 15L) << 14) | ((long)((ulong)block4 >> 50));
- values[valuesOffset++] = ((long)((ulong)block4 >> 32)) & 262143L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 14)) & 262143L;
+ values[valuesOffset++] = ((block3 & 15L) << 14) | (block4.TripleShift(50));
+ values[valuesOffset++] = (block4.TripleShift(32)) & 262143L;
+ values[valuesOffset++] = (block4.TripleShift(14)) & 262143L;
long block5 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block4 & 16383L) << 4) | ((long)((ulong)block5 >> 60));
- values[valuesOffset++] = ((long)((ulong)block5 >> 42)) & 262143L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 24)) & 262143L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 6)) & 262143L;
+ values[valuesOffset++] = ((block4 & 16383L) << 4) | (block5.TripleShift(60));
+ values[valuesOffset++] = (block5.TripleShift(42)) & 262143L;
+ values[valuesOffset++] = (block5.TripleShift(24)) & 262143L;
+ values[valuesOffset++] = (block5.TripleShift(6)) & 262143L;
long block6 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block5 & 63L) << 12) | ((long)((ulong)block6 >> 52));
- values[valuesOffset++] = ((long)((ulong)block6 >> 34)) & 262143L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 16)) & 262143L;
+ values[valuesOffset++] = ((block5 & 63L) << 12) | (block6.TripleShift(52));
+ values[valuesOffset++] = (block6.TripleShift(34)) & 262143L;
+ values[valuesOffset++] = (block6.TripleShift(16)) & 262143L;
long block7 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block6 & 65535L) << 2) | ((long)((ulong)block7 >> 62));
- values[valuesOffset++] = ((long)((ulong)block7 >> 44)) & 262143L;
- values[valuesOffset++] = ((long)((ulong)block7 >> 26)) & 262143L;
- values[valuesOffset++] = ((long)((ulong)block7 >> 8)) & 262143L;
+ values[valuesOffset++] = ((block6 & 65535L) << 2) | (block7.TripleShift(62));
+ values[valuesOffset++] = (block7.TripleShift(44)) & 262143L;
+ values[valuesOffset++] = (block7.TripleShift(26)) & 262143L;
+ values[valuesOffset++] = (block7.TripleShift(8)) & 262143L;
long block8 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block7 & 255L) << 10) | ((long)((ulong)block8 >> 54));
- values[valuesOffset++] = ((long)((ulong)block8 >> 36)) & 262143L;
- values[valuesOffset++] = ((long)((ulong)block8 >> 18)) & 262143L;
+ values[valuesOffset++] = ((block7 & 255L) << 10) | (block8.TripleShift(54));
+ values[valuesOffset++] = (block8.TripleShift(36)) & 262143L;
+ values[valuesOffset++] = (block8.TripleShift(18)) & 262143L;
values[valuesOffset++] = block8 & 262143L;
}
}
@@ -152,13 +154,13 @@ namespace Lucene.Net.Util.Packed
long byte0 = blocks[blocksOffset++] & 0xFF;
long byte1 = blocks[blocksOffset++] & 0xFF;
long byte2 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (byte0 << 10) | (byte1 << 2) | ((long)((ulong)byte2 >> 6));
+ values[valuesOffset++] = (byte0 << 10) | (byte1 << 2) | (byte2.TripleShift(6));
long byte3 = blocks[blocksOffset++] & 0xFF;
long byte4 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte2 & 63) << 12) | (byte3 << 4) | ((long)((ulong)byte4 >> 4));
+ values[valuesOffset++] = ((byte2 & 63) << 12) | (byte3 << 4) | (byte4.TripleShift(4));
long byte5 = blocks[blocksOffset++] & 0xFF;
long byte6 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte4 & 15) << 14) | (byte5 << 6) | ((long)((ulong)byte6 >> 2));
+ values[valuesOffset++] = ((byte4 & 15) << 14) | (byte5 << 6) | (byte6.TripleShift(2));
long byte7 = blocks[blocksOffset++] & 0xFF;
long byte8 = blocks[blocksOffset++] & 0xFF;
values[valuesOffset++] = ((byte6 & 3) << 16) | (byte7 << 8) | byte8;
diff --git a/src/Lucene.Net/Util/Packed/BulkOperationPacked19.cs b/src/Lucene.Net/Util/Packed/BulkOperationPacked19.cs
index ed52c91..8a83fc3 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperationPacked19.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperationPacked19.cs
@@ -1,4 +1,6 @@
-// this file has been automatically generated, DO NOT EDIT
+// this file has been automatically generated, DO NOT EDIT
+
+using J2N.Numerics;
namespace Lucene.Net.Util.Packed
{
@@ -34,87 +36,87 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)((long)((ulong)block0 >> 45));
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 26)) & 524287L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 7)) & 524287L);
+ values[valuesOffset++] = (int)(block0.TripleShift(45));
+ values[valuesOffset++] = (int)((block0.TripleShift(26)) & 524287L);
+ values[valuesOffset++] = (int)((block0.TripleShift(7)) & 524287L);
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block0 & 127L) << 12) | ((long)((ulong)block1 >> 52)));
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 33)) & 524287L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 14)) & 524287L);
+ values[valuesOffset++] = (int)(((block0 & 127L) << 12) | (block1.TripleShift(52)));
+ values[valuesOffset++] = (int)((block1.TripleShift(33)) & 524287L);
+ values[valuesOffset++] = (int)((block1.TripleShift(14)) & 524287L);
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block1 & 16383L) << 5) | ((long)((ulong)block2 >> 59)));
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 40)) & 524287L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 21)) & 524287L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 2)) & 524287L);
+ values[valuesOffset++] = (int)(((block1 & 16383L) << 5) | (block2.TripleShift(59)));
+ values[valuesOffset++] = (int)((block2.TripleShift(40)) & 524287L);
+ values[valuesOffset++] = (int)((block2.TripleShift(21)) & 524287L);
+ values[valuesOffset++] = (int)((block2.TripleShift(2)) & 524287L);
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block2 & 3L) << 17) | ((long)((ulong)block3 >> 47)));
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 28)) & 524287L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 9)) & 524287L);
+ values[valuesOffset++] = (int)(((block2 & 3L) << 17) | (block3.TripleShift(47)));
+ values[valuesOffset++] = (int)((block3.TripleShift(28)) & 524287L);
+ values[valuesOffset++] = (int)((block3.TripleShift(9)) & 524287L);
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block3 & 511L) << 10) | ((long)((ulong)block4 >> 54)));
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 35)) & 524287L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 16)) & 524287L);
+ values[valuesOffset++] = (int)(((block3 & 511L) << 10) | (block4.TripleShift(54)));
+ values[valuesOffset++] = (int)((block4.TripleShift(35)) & 524287L);
+ values[valuesOffset++] = (int)((block4.TripleShift(16)) & 524287L);
long block5 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block4 & 65535L) << 3) | ((long)((ulong)block5 >> 61)));
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 42)) & 524287L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 23)) & 524287L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 4)) & 524287L);
+ values[valuesOffset++] = (int)(((block4 & 65535L) << 3) | (block5.TripleShift(61)));
+ values[valuesOffset++] = (int)((block5.TripleShift(42)) & 524287L);
+ values[valuesOffset++] = (int)((block5.TripleShift(23)) & 524287L);
+ values[valuesOffset++] = (int)((block5.TripleShift(4)) & 524287L);
long block6 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block5 & 15L) << 15) | ((long)((ulong)block6 >> 49)));
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 30)) & 524287L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 11)) & 524287L);
+ values[valuesOffset++] = (int)(((block5 & 15L) << 15) | (block6.TripleShift(49)));
+ values[valuesOffset++] = (int)((block6.TripleShift(30)) & 524287L);
+ values[valuesOffset++] = (int)((block6.TripleShift(11)) & 524287L);
long block7 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block6 & 2047L) << 8) | ((long)((ulong)block7 >> 56)));
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 37)) & 524287L);
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 18)) & 524287L);
+ values[valuesOffset++] = (int)(((block6 & 2047L) << 8) | (block7.TripleShift(56)));
+ values[valuesOffset++] = (int)((block7.TripleShift(37)) & 524287L);
+ values[valuesOffset++] = (int)((block7.TripleShift(18)) & 524287L);
long block8 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block7 & 262143L) << 1) | ((long)((ulong)block8 >> 63)));
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 44)) & 524287L);
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 25)) & 524287L);
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 6)) & 524287L);
+ values[valuesOffset++] = (int)(((block7 & 262143L) << 1) | (block8.TripleShift(63)));
+ values[valuesOffset++] = (int)((block8.TripleShift(44)) & 524287L);
+ values[valuesOffset++] = (int)((block8.TripleShift(25)) & 524287L);
+ values[valuesOffset++] = (int)((block8.TripleShift(6)) & 524287L);
long block9 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block8 & 63L) << 13) | ((long)((ulong)block9 >> 51)));
- values[valuesOffset++] = (int)(((long)((ulong)block9 >> 32)) & 524287L);
- values[valuesOffset++] = (int)(((long)((ulong)block9 >> 13)) & 524287L);
+ values[valuesOffset++] = (int)(((block8 & 63L) << 13) | (block9.TripleShift(51)));
+ values[valuesOffset++] = (int)((block9.TripleShift(32)) & 524287L);
+ values[valuesOffset++] = (int)((block9.TripleShift(13)) & 524287L);
long block10 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block9 & 8191L) << 6) | ((long)((ulong)block10 >> 58)));
- values[valuesOffset++] = (int)(((long)((ulong)block10 >> 39)) & 524287L);
- values[valuesOffset++] = (int)(((long)((ulong)block10 >> 20)) & 524287L);
- values[valuesOffset++] = (int)(((long)((ulong)block10 >> 1)) & 524287L);
+ values[valuesOffset++] = (int)(((block9 & 8191L) << 6) | (block10.TripleShift(58)));
+ values[valuesOffset++] = (int)((block10.TripleShift(39)) & 524287L);
+ values[valuesOffset++] = (int)((block10.TripleShift(20)) & 524287L);
+ values[valuesOffset++] = (int)((block10.TripleShift(1)) & 524287L);
long block11 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block10 & 1L) << 18) | ((long)((ulong)block11 >> 46)));
- values[valuesOffset++] = (int)(((long)((ulong)block11 >> 27)) & 524287L);
- values[valuesOffset++] = (int)(((long)((ulong)block11 >> 8)) & 524287L);
+ values[valuesOffset++] = (int)(((block10 & 1L) << 18) | (block11.TripleShift(46)));
+ values[valuesOffset++] = (int)((block11.TripleShift(27)) & 524287L);
+ values[valuesOffset++] = (int)((block11.TripleShift(8)) & 524287L);
long block12 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block11 & 255L) << 11) | ((long)((ulong)block12 >> 53)));
- values[valuesOffset++] = (int)(((long)((ulong)block12 >> 34)) & 524287L);
- values[valuesOffset++] = (int)(((long)((ulong)block12 >> 15)) & 524287L);
+ values[valuesOffset++] = (int)(((block11 & 255L) << 11) | (block12.TripleShift(53)));
+ values[valuesOffset++] = (int)((block12.TripleShift(34)) & 524287L);
+ values[valuesOffset++] = (int)((block12.TripleShift(15)) & 524287L);
long block13 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block12 & 32767L) << 4) | ((long)((ulong)block13 >> 60)));
- values[valuesOffset++] = (int)(((long)((ulong)block13 >> 41)) & 524287L);
- values[valuesOffset++] = (int)(((long)((ulong)block13 >> 22)) & 524287L);
- values[valuesOffset++] = (int)(((long)((ulong)block13 >> 3)) & 524287L);
+ values[valuesOffset++] = (int)(((block12 & 32767L) << 4) | (block13.TripleShift(60)));
+ values[valuesOffset++] = (int)((block13.TripleShift(41)) & 524287L);
+ values[valuesOffset++] = (int)((block13.TripleShift(22)) & 524287L);
+ values[valuesOffset++] = (int)((block13.TripleShift(3)) & 524287L);
long block14 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block13 & 7L) << 16) | ((long)((ulong)block14 >> 48)));
- values[valuesOffset++] = (int)(((long)((ulong)block14 >> 29)) & 524287L);
- values[valuesOffset++] = (int)(((long)((ulong)block14 >> 10)) & 524287L);
+ values[valuesOffset++] = (int)(((block13 & 7L) << 16) | (block14.TripleShift(48)));
+ values[valuesOffset++] = (int)((block14.TripleShift(29)) & 524287L);
+ values[valuesOffset++] = (int)((block14.TripleShift(10)) & 524287L);
long block15 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block14 & 1023L) << 9) | ((long)((ulong)block15 >> 55)));
- values[valuesOffset++] = (int)(((long)((ulong)block15 >> 36)) & 524287L);
- values[valuesOffset++] = (int)(((long)((ulong)block15 >> 17)) & 524287L);
+ values[valuesOffset++] = (int)(((block14 & 1023L) << 9) | (block15.TripleShift(55)));
+ values[valuesOffset++] = (int)((block15.TripleShift(36)) & 524287L);
+ values[valuesOffset++] = (int)((block15.TripleShift(17)) & 524287L);
long block16 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block15 & 131071L) << 2) | ((long)((ulong)block16 >> 62)));
- values[valuesOffset++] = (int)(((long)((ulong)block16 >> 43)) & 524287L);
- values[valuesOffset++] = (int)(((long)((ulong)block16 >> 24)) & 524287L);
- values[valuesOffset++] = (int)(((long)((ulong)block16 >> 5)) & 524287L);
+ values[valuesOffset++] = (int)(((block15 & 131071L) << 2) | (block16.TripleShift(62)));
+ values[valuesOffset++] = (int)((block16.TripleShift(43)) & 524287L);
+ values[valuesOffset++] = (int)((block16.TripleShift(24)) & 524287L);
+ values[valuesOffset++] = (int)((block16.TripleShift(5)) & 524287L);
long block17 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block16 & 31L) << 14) | ((long)((ulong)block17 >> 50)));
- values[valuesOffset++] = (int)(((long)((ulong)block17 >> 31)) & 524287L);
- values[valuesOffset++] = (int)(((long)((ulong)block17 >> 12)) & 524287L);
+ values[valuesOffset++] = (int)(((block16 & 31L) << 14) | (block17.TripleShift(50)));
+ values[valuesOffset++] = (int)((block17.TripleShift(31)) & 524287L);
+ values[valuesOffset++] = (int)((block17.TripleShift(12)) & 524287L);
long block18 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block17 & 4095L) << 7) | ((long)((ulong)block18 >> 57)));
- values[valuesOffset++] = (int)(((long)((ulong)block18 >> 38)) & 524287L);
- values[valuesOffset++] = (int)(((long)((ulong)block18 >> 19)) & 524287L);
+ values[valuesOffset++] = (int)(((block17 & 4095L) << 7) | (block18.TripleShift(57)));
+ values[valuesOffset++] = (int)((block18.TripleShift(38)) & 524287L);
+ values[valuesOffset++] = (int)((block18.TripleShift(19)) & 524287L);
values[valuesOffset++] = (int)(block18 & 524287L);
}
}
@@ -126,27 +128,27 @@ namespace Lucene.Net.Util.Packed
int byte0 = blocks[blocksOffset++] & 0xFF;
int byte1 = blocks[blocksOffset++] & 0xFF;
int byte2 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (byte0 << 11) | (byte1 << 3) | ((int)((uint)byte2 >> 5));
+ values[valuesOffset++] = (byte0 << 11) | (byte1 << 3) | (byte2.TripleShift(5));
int byte3 = blocks[blocksOffset++] & 0xFF;
int byte4 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte2 & 31) << 14) | (byte3 << 6) | ((int)((uint)byte4 >> 2));
+ values[valuesOffset++] = ((byte2 & 31) << 14) | (byte3 << 6) | (byte4.TripleShift(2));
int byte5 = blocks[blocksOffset++] & 0xFF;
int byte6 = blocks[blocksOffset++] & 0xFF;
int byte7 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte4 & 3) << 17) | (byte5 << 9) | (byte6 << 1) | ((int)((uint)byte7 >> 7));
+ values[valuesOffset++] = ((byte4 & 3) << 17) | (byte5 << 9) | (byte6 << 1) | (byte7.TripleShift(7));
int byte8 = blocks[blocksOffset++] & 0xFF;
int byte9 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte7 & 127) << 12) | (byte8 << 4) | ((int)((uint)byte9 >> 4));
+ values[valuesOffset++] = ((byte7 & 127) << 12) | (byte8 << 4) | (byte9.TripleShift(4));
int byte10 = blocks[blocksOffset++] & 0xFF;
int byte11 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte9 & 15) << 15) | (byte10 << 7) | ((int)((uint)byte11 >> 1));
+ values[valuesOffset++] = ((byte9 & 15) << 15) | (byte10 << 7) | (byte11.TripleShift(1));
int byte12 = blocks[blocksOffset++] & 0xFF;
int byte13 = blocks[blocksOffset++] & 0xFF;
int byte14 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte11 & 1) << 18) | (byte12 << 10) | (byte13 << 2) | ((int)((uint)byte14 >> 6));
+ values[valuesOffset++] = ((byte11 & 1) << 18) | (byte12 << 10) | (byte13 << 2) | (byte14.TripleShift(6));
int byte15 = blocks[blocksOffset++] & 0xFF;
int byte16 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte14 & 63) << 13) | (byte15 << 5) | ((int)((uint)byte16 >> 3));
+ values[valuesOffset++] = ((byte14 & 63) << 13) | (byte15 << 5) | (byte16.TripleShift(3));
int byte17 = blocks[blocksOffset++] & 0xFF;
int byte18 = blocks[blocksOffset++] & 0xFF;
values[valuesOffset++] = ((byte16 & 7) << 16) | (byte17 << 8) | byte18;
@@ -158,87 +160,87 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (long)((ulong)block0 >> 45);
- values[valuesOffset++] = ((long)((ulong)block0 >> 26)) & 524287L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 7)) & 524287L;
+ values[valuesOffset++] = block0.TripleShift(45);
+ values[valuesOffset++] = (block0.TripleShift(26)) & 524287L;
+ values[valuesOffset++] = (block0.TripleShift(7)) & 524287L;
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block0 & 127L) << 12) | ((long)((ulong)block1 >> 52));
- values[valuesOffset++] = ((long)((ulong)block1 >> 33)) & 524287L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 14)) & 524287L;
+ values[valuesOffset++] = ((block0 & 127L) << 12) | (block1.TripleShift(52));
+ values[valuesOffset++] = (block1.TripleShift(33)) & 524287L;
+ values[valuesOffset++] = (block1.TripleShift(14)) & 524287L;
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block1 & 16383L) << 5) | ((long)((ulong)block2 >> 59));
- values[valuesOffset++] = ((long)((ulong)block2 >> 40)) & 524287L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 21)) & 524287L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 2)) & 524287L;
+ values[valuesOffset++] = ((block1 & 16383L) << 5) | (block2.TripleShift(59));
+ values[valuesOffset++] = (block2.TripleShift(40)) & 524287L;
+ values[valuesOffset++] = (block2.TripleShift(21)) & 524287L;
+ values[valuesOffset++] = (block2.TripleShift(2)) & 524287L;
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block2 & 3L) << 17) | ((long)((ulong)block3 >> 47));
- values[valuesOffset++] = ((long)((ulong)block3 >> 28)) & 524287L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 9)) & 524287L;
+ values[valuesOffset++] = ((block2 & 3L) << 17) | (block3.TripleShift(47));
+ values[valuesOffset++] = (block3.TripleShift(28)) & 524287L;
+ values[valuesOffset++] = (block3.TripleShift(9)) & 524287L;
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block3 & 511L) << 10) | ((long)((ulong)block4 >> 54));
- values[valuesOffset++] = ((long)((ulong)block4 >> 35)) & 524287L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 16)) & 524287L;
+ values[valuesOffset++] = ((block3 & 511L) << 10) | (block4.TripleShift(54));
+ values[valuesOffset++] = (block4.TripleShift(35)) & 524287L;
+ values[valuesOffset++] = (block4.TripleShift(16)) & 524287L;
long block5 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block4 & 65535L) << 3) | ((long)((ulong)block5 >> 61));
- values[valuesOffset++] = ((long)((ulong)block5 >> 42)) & 524287L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 23)) & 524287L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 4)) & 524287L;
+ values[valuesOffset++] = ((block4 & 65535L) << 3) | (block5.TripleShift(61));
+ values[valuesOffset++] = (block5.TripleShift(42)) & 524287L;
+ values[valuesOffset++] = (block5.TripleShift(23)) & 524287L;
+ values[valuesOffset++] = (block5.TripleShift(4)) & 524287L;
long block6 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block5 & 15L) << 15) | ((long)((ulong)block6 >> 49));
- values[valuesOffset++] = ((long)((ulong)block6 >> 30)) & 524287L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 11)) & 524287L;
+ values[valuesOffset++] = ((block5 & 15L) << 15) | (block6.TripleShift(49));
+ values[valuesOffset++] = (block6.TripleShift(30)) & 524287L;
+ values[valuesOffset++] = (block6.TripleShift(11)) & 524287L;
long block7 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block6 & 2047L) << 8) | ((long)((ulong)block7 >> 56));
- values[valuesOffset++] = ((long)((ulong)block7 >> 37)) & 524287L;
- values[valuesOffset++] = ((long)((ulong)block7 >> 18)) & 524287L;
+ values[valuesOffset++] = ((block6 & 2047L) << 8) | (block7.TripleShift(56));
+ values[valuesOffset++] = (block7.TripleShift(37)) & 524287L;
+ values[valuesOffset++] = (block7.TripleShift(18)) & 524287L;
long block8 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block7 & 262143L) << 1) | ((long)((ulong)block8 >> 63));
- values[valuesOffset++] = ((long)((ulong)block8 >> 44)) & 524287L;
- values[valuesOffset++] = ((long)((ulong)block8 >> 25)) & 524287L;
- values[valuesOffset++] = ((long)((ulong)block8 >> 6)) & 524287L;
+ values[valuesOffset++] = ((block7 & 262143L) << 1) | (block8.TripleShift(63));
+ values[valuesOffset++] = (block8.TripleShift(44)) & 524287L;
+ values[valuesOffset++] = (block8.TripleShift(25)) & 524287L;
+ values[valuesOffset++] = (block8.TripleShift(6)) & 524287L;
long block9 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block8 & 63L) << 13) | ((long)((ulong)block9 >> 51));
- values[valuesOffset++] = ((long)((ulong)block9 >> 32)) & 524287L;
- values[valuesOffset++] = ((long)((ulong)block9 >> 13)) & 524287L;
+ values[valuesOffset++] = ((block8 & 63L) << 13) | (block9.TripleShift(51));
+ values[valuesOffset++] = (block9.TripleShift(32)) & 524287L;
+ values[valuesOffset++] = (block9.TripleShift(13)) & 524287L;
long block10 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block9 & 8191L) << 6) | ((long)((ulong)block10 >> 58));
- values[valuesOffset++] = ((long)((ulong)block10 >> 39)) & 524287L;
- values[valuesOffset++] = ((long)((ulong)block10 >> 20)) & 524287L;
- values[valuesOffset++] = ((long)((ulong)block10 >> 1)) & 524287L;
+ values[valuesOffset++] = ((block9 & 8191L) << 6) | (block10.TripleShift(58));
+ values[valuesOffset++] = (block10.TripleShift(39)) & 524287L;
+ values[valuesOffset++] = (block10.TripleShift(20)) & 524287L;
+ values[valuesOffset++] = (block10.TripleShift(1)) & 524287L;
long block11 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block10 & 1L) << 18) | ((long)((ulong)block11 >> 46));
- values[valuesOffset++] = ((long)((ulong)block11 >> 27)) & 524287L;
- values[valuesOffset++] = ((long)((ulong)block11 >> 8)) & 524287L;
+ values[valuesOffset++] = ((block10 & 1L) << 18) | (block11.TripleShift(46));
+ values[valuesOffset++] = (block11.TripleShift(27)) & 524287L;
+ values[valuesOffset++] = (block11.TripleShift(8)) & 524287L;
long block12 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block11 & 255L) << 11) | ((long)((ulong)block12 >> 53));
- values[valuesOffset++] = ((long)((ulong)block12 >> 34)) & 524287L;
- values[valuesOffset++] = ((long)((ulong)block12 >> 15)) & 524287L;
+ values[valuesOffset++] = ((block11 & 255L) << 11) | (block12.TripleShift(53));
+ values[valuesOffset++] = (block12.TripleShift(34)) & 524287L;
+ values[valuesOffset++] = (block12.TripleShift(15)) & 524287L;
long block13 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block12 & 32767L) << 4) | ((long)((ulong)block13 >> 60));
- values[valuesOffset++] = ((long)((ulong)block13 >> 41)) & 524287L;
- values[valuesOffset++] = ((long)((ulong)block13 >> 22)) & 524287L;
- values[valuesOffset++] = ((long)((ulong)block13 >> 3)) & 524287L;
+ values[valuesOffset++] = ((block12 & 32767L) << 4) | (block13.TripleShift(60));
+ values[valuesOffset++] = (block13.TripleShift(41)) & 524287L;
+ values[valuesOffset++] = (block13.TripleShift(22)) & 524287L;
+ values[valuesOffset++] = (block13.TripleShift(3)) & 524287L;
long block14 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block13 & 7L) << 16) | ((long)((ulong)block14 >> 48));
- values[valuesOffset++] = ((long)((ulong)block14 >> 29)) & 524287L;
- values[valuesOffset++] = ((long)((ulong)block14 >> 10)) & 524287L;
+ values[valuesOffset++] = ((block13 & 7L) << 16) | (block14.TripleShift(48));
+ values[valuesOffset++] = (block14.TripleShift(29)) & 524287L;
+ values[valuesOffset++] = (block14.TripleShift(10)) & 524287L;
long block15 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block14 & 1023L) << 9) | ((long)((ulong)block15 >> 55));
- values[valuesOffset++] = ((long)((ulong)block15 >> 36)) & 524287L;
- values[valuesOffset++] = ((long)((ulong)block15 >> 17)) & 524287L;
+ values[valuesOffset++] = ((block14 & 1023L) << 9) | (block15.TripleShift(55));
+ values[valuesOffset++] = (block15.TripleShift(36)) & 524287L;
+ values[valuesOffset++] = (block15.TripleShift(17)) & 524287L;
long block16 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block15 & 131071L) << 2) | ((long)((ulong)block16 >> 62));
- values[valuesOffset++] = ((long)((ulong)block16 >> 43)) & 524287L;
- values[valuesOffset++] = ((long)((ulong)block16 >> 24)) & 524287L;
- values[valuesOffset++] = ((long)((ulong)block16 >> 5)) & 524287L;
+ values[valuesOffset++] = ((block15 & 131071L) << 2) | (block16.TripleShift(62));
+ values[valuesOffset++] = (block16.TripleShift(43)) & 524287L;
+ values[valuesOffset++] = (block16.TripleShift(24)) & 524287L;
+ values[valuesOffset++] = (block16.TripleShift(5)) & 524287L;
long block17 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block16 & 31L) << 14) | ((long)((ulong)block17 >> 50));
- values[valuesOffset++] = ((long)((ulong)block17 >> 31)) & 524287L;
- values[valuesOffset++] = ((long)((ulong)block17 >> 12)) & 524287L;
+ values[valuesOffset++] = ((block16 & 31L) << 14) | (block17.TripleShift(50));
+ values[valuesOffset++] = (block17.TripleShift(31)) & 524287L;
+ values[valuesOffset++] = (block17.TripleShift(12)) & 524287L;
long block18 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block17 & 4095L) << 7) | ((long)((ulong)block18 >> 57));
- values[valuesOffset++] = ((long)((ulong)block18 >> 38)) & 524287L;
- values[valuesOffset++] = ((long)((ulong)block18 >> 19)) & 524287L;
+ values[valuesOffset++] = ((block17 & 4095L) << 7) | (block18.TripleShift(57));
+ values[valuesOffset++] = (block18.TripleShift(38)) & 524287L;
+ values[valuesOffset++] = (block18.TripleShift(19)) & 524287L;
values[valuesOffset++] = block18 & 524287L;
}
}
@@ -250,27 +252,27 @@ namespace Lucene.Net.Util.Packed
long byte0 = blocks[blocksOffset++] & 0xFF;
long byte1 = blocks[blocksOffset++] & 0xFF;
long byte2 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (byte0 << 11) | (byte1 << 3) | ((long)((ulong)byte2 >> 5));
+ values[valuesOffset++] = (byte0 << 11) | (byte1 << 3) | (byte2.TripleShift(5));
long byte3 = blocks[blocksOffset++] & 0xFF;
long byte4 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte2 & 31) << 14) | (byte3 << 6) | ((long)((ulong)byte4 >> 2));
+ values[valuesOffset++] = ((byte2 & 31) << 14) | (byte3 << 6) | (byte4.TripleShift(2));
long byte5 = blocks[blocksOffset++] & 0xFF;
long byte6 = blocks[blocksOffset++] & 0xFF;
long byte7 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte4 & 3) << 17) | (byte5 << 9) | (byte6 << 1) | ((long)((ulong)byte7 >> 7));
+ values[valuesOffset++] = ((byte4 & 3) << 17) | (byte5 << 9) | (byte6 << 1) | (byte7.TripleShift(7));
long byte8 = blocks[blocksOffset++] & 0xFF;
long byte9 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte7 & 127) << 12) | (byte8 << 4) | ((long)((ulong)byte9 >> 4));
+ values[valuesOffset++] = ((byte7 & 127) << 12) | (byte8 << 4) | (byte9.TripleShift(4));
long byte10 = blocks[blocksOffset++] & 0xFF;
long byte11 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte9 & 15) << 15) | (byte10 << 7) | ((long)((ulong)byte11 >> 1));
+ values[valuesOffset++] = ((byte9 & 15) << 15) | (byte10 << 7) | (byte11.TripleShift(1));
long byte12 = blocks[blocksOffset++] & 0xFF;
long byte13 = blocks[blocksOffset++] & 0xFF;
long byte14 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte11 & 1) << 18) | (byte12 << 10) | (byte13 << 2) | ((long)((ulong)byte14 >> 6));
+ values[valuesOffset++] = ((byte11 & 1) << 18) | (byte12 << 10) | (byte13 << 2) | (byte14.TripleShift(6));
long byte15 = blocks[blocksOffset++] & 0xFF;
long byte16 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte14 & 63) << 13) | (byte15 << 5) | ((long)((ulong)byte16 >> 3));
+ values[valuesOffset++] = ((byte14 & 63) << 13) | (byte15 << 5) | (byte16.TripleShift(3));
long byte17 = blocks[blocksOffset++] & 0xFF;
long byte18 = blocks[blocksOffset++] & 0xFF;
values[valuesOffset++] = ((byte16 & 7) << 16) | (byte17 << 8) | byte18;
diff --git a/src/Lucene.Net/Util/Packed/BulkOperationPacked2.cs b/src/Lucene.Net/Util/Packed/BulkOperationPacked2.cs
index 713b0fe..8d91a99 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperationPacked2.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperationPacked2.cs
@@ -1,4 +1,6 @@
-// this file has been automatically generated, DO NOT EDIT
+// this file has been automatically generated, DO NOT EDIT
+
+using J2N.Numerics;
namespace Lucene.Net.Util.Packed
{
@@ -36,7 +38,7 @@ namespace Lucene.Net.Util.Packed
long block = blocks[blocksOffset++];
for (int shift = 62; shift >= 0; shift -= 2)
{
- values[valuesOffset++] = (int)(((long)((ulong)block >> shift)) & 3);
+ values[valuesOffset++] = (int)((block.TripleShift(shift)) & 3);
}
}
}
@@ -46,9 +48,9 @@ namespace Lucene.Net.Util.Packed
for (int j = 0; j < iterations; ++j)
{
var block = blocks[blocksOffset++];
- values[valuesOffset++] = ((int)((uint)block >> 6)) & 3;
- values[valuesOffset++] = ((int)((uint)block >> 4)) & 3;
- values[valuesOffset++] = ((int)((uint)block >> 2)) & 3;
+ values[valuesOffset++] = (block.TripleShift(6)) & 3;
+ values[valuesOffset++] = (block.TripleShift(4)) & 3;
+ values[valuesOffset++] = (block.TripleShift(2)) & 3;
values[valuesOffset++] = block & 3;
}
}
@@ -60,7 +62,7 @@ namespace Lucene.Net.Util.Packed
long block = blocks[blocksOffset++];
for (int shift = 62; shift >= 0; shift -= 2)
{
- values[valuesOffset++] = ((long)((ulong)block >> shift)) & 3;
+ values[valuesOffset++] = (block.TripleShift(shift)) & 3;
}
}
}
@@ -70,9 +72,9 @@ namespace Lucene.Net.Util.Packed
for (int j = 0; j < iterations; ++j)
{
var block = blocks[blocksOffset++];
- values[valuesOffset++] = ((int)((uint)block >> 6)) & 3;
- values[valuesOffset++] = ((int)((uint)block >> 4)) & 3;
- values[valuesOffset++] = ((int)((uint)block >> 2)) & 3;
+ values[valuesOffset++] = (block.TripleShift(6)) & 3;
+ values[valuesOffset++] = (block.TripleShift(4)) & 3;
+ values[valuesOffset++] = (block.TripleShift(2)) & 3;
values[valuesOffset++] = block & 3;
}
}
diff --git a/src/Lucene.Net/Util/Packed/BulkOperationPacked20.cs b/src/Lucene.Net/Util/Packed/BulkOperationPacked20.cs
index 95f7873..e826aed 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperationPacked20.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperationPacked20.cs
@@ -1,4 +1,6 @@
-// this file has been automatically generated, DO NOT EDIT
+// this file has been automatically generated, DO NOT EDIT
+
+using J2N.Numerics;
namespace Lucene.Net.Util.Packed
{
@@ -34,25 +36,25 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)((long)((ulong)block0 >> 44));
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 24)) & 1048575L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 4)) & 1048575L);
+ values[valuesOffset++] = (int)(block0.TripleShift(44));
+ values[valuesOffset++] = (int)((block0.TripleShift(24)) & 1048575L);
+ values[valuesOffset++] = (int)((block0.TripleShift(4)) & 1048575L);
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block0 & 15L) << 16) | ((long)((ulong)block1 >> 48)));
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 28)) & 1048575L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 8)) & 1048575L);
+ values[valuesOffset++] = (int)(((block0 & 15L) << 16) | (block1.TripleShift(48)));
+ values[valuesOffset++] = (int)((block1.TripleShift(28)) & 1048575L);
+ values[valuesOffset++] = (int)((block1.TripleShift(8)) & 1048575L);
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block1 & 255L) << 12) | ((long)((ulong)block2 >> 52)));
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 32)) & 1048575L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 12)) & 1048575L);
+ values[valuesOffset++] = (int)(((block1 & 255L) << 12) | (block2.TripleShift(52)));
+ values[valuesOffset++] = (int)((block2.TripleShift(32)) & 1048575L);
+ values[valuesOffset++] = (int)((block2.TripleShift(12)) & 1048575L);
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block2 & 4095L) << 8) | ((long)((ulong)block3 >> 56)));
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 36)) & 1048575L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 16)) & 1048575L);
+ values[valuesOffset++] = (int)(((block2 & 4095L) << 8) | (block3.TripleShift(56)));
+ values[valuesOffset++] = (int)((block3.TripleShift(36)) & 1048575L);
+ values[valuesOffset++] = (int)((block3.TripleShift(16)) & 1048575L);
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block3 & 65535L) << 4) | ((long)((ulong)block4 >> 60)));
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 40)) & 1048575L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 20)) & 1048575L);
+ values[valuesOffset++] = (int)(((block3 & 65535L) << 4) | (block4.TripleShift(60)));
+ values[valuesOffset++] = (int)((block4.TripleShift(40)) & 1048575L);
+ values[valuesOffset++] = (int)((block4.TripleShift(20)) & 1048575L);
values[valuesOffset++] = (int)(block4 & 1048575L);
}
}
@@ -64,7 +66,7 @@ namespace Lucene.Net.Util.Packed
int byte0 = blocks[blocksOffset++] & 0xFF;
int byte1 = blocks[blocksOffset++] & 0xFF;
int byte2 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (byte0 << 12) | (byte1 << 4) | ((int)((uint)byte2 >> 4));
+ values[valuesOffset++] = (byte0 << 12) | (byte1 << 4) | (byte2.TripleShift(4));
int byte3 = blocks[blocksOffset++] & 0xFF;
int byte4 = blocks[blocksOffset++] & 0xFF;
values[valuesOffset++] = ((byte2 & 15) << 16) | (byte3 << 8) | byte4;
@@ -76,25 +78,25 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (long)((ulong)block0 >> 44);
- values[valuesOffset++] = ((long)((ulong)block0 >> 24)) & 1048575L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 4)) & 1048575L;
+ values[valuesOffset++] = block0.TripleShift(44);
+ values[valuesOffset++] = (block0.TripleShift(24)) & 1048575L;
+ values[valuesOffset++] = (block0.TripleShift(4)) & 1048575L;
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block0 & 15L) << 16) | ((long)((ulong)block1 >> 48));
- values[valuesOffset++] = ((long)((ulong)block1 >> 28)) & 1048575L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 8)) & 1048575L;
+ values[valuesOffset++] = ((block0 & 15L) << 16) | (block1.TripleShift(48));
+ values[valuesOffset++] = (block1.TripleShift(28)) & 1048575L;
+ values[valuesOffset++] = (block1.TripleShift(8)) & 1048575L;
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block1 & 255L) << 12) | ((long)((ulong)block2 >> 52));
- values[valuesOffset++] = ((long)((ulong)block2 >> 32)) & 1048575L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 12)) & 1048575L;
+ values[valuesOffset++] = ((block1 & 255L) << 12) | (block2.TripleShift(52));
+ values[valuesOffset++] = (block2.TripleShift(32)) & 1048575L;
+ values[valuesOffset++] = (block2.TripleShift(12)) & 1048575L;
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block2 & 4095L) << 8) | ((long)((ulong)block3 >> 56));
- values[valuesOffset++] = ((long)((ulong)block3 >> 36)) & 1048575L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 16)) & 1048575L;
+ values[valuesOffset++] = ((block2 & 4095L) << 8) | (block3.TripleShift(56));
+ values[valuesOffset++] = (block3.TripleShift(36)) & 1048575L;
+ values[valuesOffset++] = (block3.TripleShift(16)) & 1048575L;
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block3 & 65535L) << 4) | ((long)((ulong)block4 >> 60));
- values[valuesOffset++] = ((long)((ulong)block4 >> 40)) & 1048575L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 20)) & 1048575L;
+ values[valuesOffset++] = ((block3 & 65535L) << 4) | (block4.TripleShift(60));
+ values[valuesOffset++] = (block4.TripleShift(40)) & 1048575L;
+ values[valuesOffset++] = (block4.TripleShift(20)) & 1048575L;
values[valuesOffset++] = block4 & 1048575L;
}
}
@@ -106,7 +108,7 @@ namespace Lucene.Net.Util.Packed
long byte0 = blocks[blocksOffset++] & 0xFF;
long byte1 = blocks[blocksOffset++] & 0xFF;
long byte2 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (byte0 << 12) | (byte1 << 4) | ((long)((ulong)byte2 >> 4));
+ values[valuesOffset++] = (byte0 << 12) | (byte1 << 4) | (byte2.TripleShift(4));
long byte3 = blocks[blocksOffset++] & 0xFF;
long byte4 = blocks[blocksOffset++] & 0xFF;
values[valuesOffset++] = ((byte2 & 15) << 16) | (byte3 << 8) | byte4;
diff --git a/src/Lucene.Net/Util/Packed/BulkOperationPacked21.cs b/src/Lucene.Net/Util/Packed/BulkOperationPacked21.cs
index d5daa92..c737d88 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperationPacked21.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperationPacked21.cs
@@ -1,4 +1,6 @@
-// this file has been automatically generated, DO NOT EDIT
+// this file has been automatically generated, DO NOT EDIT
+
+using J2N.Numerics;
namespace Lucene.Net.Util.Packed
{
@@ -34,89 +36,89 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)((long)((ulong)block0 >> 43));
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 22)) & 2097151L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 1)) & 2097151L);
+ values[valuesOffset++] = (int)(block0.TripleShift(43));
+ values[valuesOffset++] = (int)((block0.TripleShift(22)) & 2097151L);
+ values[valuesOffset++] = (int)((block0.TripleShift(1)) & 2097151L);
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block0 & 1L) << 20) | ((long)((ulong)block1 >> 44)));
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 23)) & 2097151L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 2)) & 2097151L);
+ values[valuesOffset++] = (int)(((block0 & 1L) << 20) | (block1.TripleShift(44)));
+ values[valuesOffset++] = (int)((block1.TripleShift(23)) & 2097151L);
+ values[valuesOffset++] = (int)((block1.TripleShift(2)) & 2097151L);
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block1 & 3L) << 19) | ((long)((ulong)block2 >> 45)));
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 24)) & 2097151L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 3)) & 2097151L);
+ values[valuesOffset++] = (int)(((block1 & 3L) << 19) | (block2.TripleShift(45)));
+ values[valuesOffset++] = (int)((block2.TripleShift(24)) & 2097151L);
+ values[valuesOffset++] = (int)((block2.TripleShift(3)) & 2097151L);
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block2 & 7L) << 18) | ((long)((ulong)block3 >> 46)));
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 25)) & 2097151L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 4)) & 2097151L);
+ values[valuesOffset++] = (int)(((block2 & 7L) << 18) | (block3.TripleShift(46)));
+ values[valuesOffset++] = (int)((block3.TripleShift(25)) & 2097151L);
+ values[valuesOffset++] = (int)((block3.TripleShift(4)) & 2097151L);
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block3 & 15L) << 17) | ((long)((ulong)block4 >> 47)));
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 26)) & 2097151L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 5)) & 2097151L);
+ values[valuesOffset++] = (int)(((block3 & 15L) << 17) | (block4.TripleShift(47)));
+ values[valuesOffset++] = (int)((block4.TripleShift(26)) & 2097151L);
+ values[valuesOffset++] = (int)((block4.TripleShift(5)) & 2097151L);
long block5 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block4 & 31L) << 16) | ((long)((ulong)block5 >> 48)));
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 27)) & 2097151L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 6)) & 2097151L);
+ values[valuesOffset++] = (int)(((block4 & 31L) << 16) | (block5.TripleShift(48)));
+ values[valuesOffset++] = (int)((block5.TripleShift(27)) & 2097151L);
+ values[valuesOffset++] = (int)((block5.TripleShift(6)) & 2097151L);
long block6 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block5 & 63L) << 15) | ((long)((ulong)block6 >> 49)));
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 28)) & 2097151L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 7)) & 2097151L);
+ values[valuesOffset++] = (int)(((block5 & 63L) << 15) | (block6.TripleShift(49)));
+ values[valuesOffset++] = (int)((block6.TripleShift(28)) & 2097151L);
+ values[valuesOffset++] = (int)((block6.TripleShift(7)) & 2097151L);
long block7 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block6 & 127L) << 14) | ((long)((ulong)block7 >> 50)));
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 29)) & 2097151L);
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 8)) & 2097151L);
+ values[valuesOffset++] = (int)(((block6 & 127L) << 14) | (block7.TripleShift(50)));
+ values[valuesOffset++] = (int)((block7.TripleShift(29)) & 2097151L);
+ values[valuesOffset++] = (int)((block7.TripleShift(8)) & 2097151L);
long block8 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block7 & 255L) << 13) | ((long)((ulong)block8 >> 51)));
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 30)) & 2097151L);
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 9)) & 2097151L);
+ values[valuesOffset++] = (int)(((block7 & 255L) << 13) | (block8.TripleShift(51)));
+ values[valuesOffset++] = (int)((block8.TripleShift(30)) & 2097151L);
+ values[valuesOffset++] = (int)((block8.TripleShift(9)) & 2097151L);
long block9 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block8 & 511L) << 12) | ((long)((ulong)block9 >> 52)));
- values[valuesOffset++] = (int)(((long)((ulong)block9 >> 31)) & 2097151L);
- values[valuesOffset++] = (int)(((long)((ulong)block9 >> 10)) & 2097151L);
+ values[valuesOffset++] = (int)(((block8 & 511L) << 12) | (block9.TripleShift(52)));
+ values[valuesOffset++] = (int)((block9.TripleShift(31)) & 2097151L);
+ values[valuesOffset++] = (int)((block9.TripleShift(10)) & 2097151L);
long block10 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block9 & 1023L) << 11) | ((long)((ulong)block10 >> 53)));
- values[valuesOffset++] = (int)(((long)((ulong)block10 >> 32)) & 2097151L);
- values[valuesOffset++] = (int)(((long)((ulong)block10 >> 11)) & 2097151L);
+ values[valuesOffset++] = (int)(((block9 & 1023L) << 11) | (block10.TripleShift(53)));
+ values[valuesOffset++] = (int)((block10.TripleShift(32)) & 2097151L);
+ values[valuesOffset++] = (int)((block10.TripleShift(11)) & 2097151L);
long block11 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block10 & 2047L) << 10) | ((long)((ulong)block11 >> 54)));
- values[valuesOffset++] = (int)(((long)((ulong)block11 >> 33)) & 2097151L);
- values[valuesOffset++] = (int)(((long)((ulong)block11 >> 12)) & 2097151L);
+ values[valuesOffset++] = (int)(((block10 & 2047L) << 10) | (block11.TripleShift(54)));
+ values[valuesOffset++] = (int)((block11.TripleShift(33)) & 2097151L);
+ values[valuesOffset++] = (int)((block11.TripleShift(12)) & 2097151L);
long block12 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block11 & 4095L) << 9) | ((long)((ulong)block12 >> 55)));
- values[valuesOffset++] = (int)(((long)((ulong)block12 >> 34)) & 2097151L);
- values[valuesOffset++] = (int)(((long)((ulong)block12 >> 13)) & 2097151L);
+ values[valuesOffset++] = (int)(((block11 & 4095L) << 9) | (block12.TripleShift(55)));
+ values[valuesOffset++] = (int)((block12.TripleShift(34)) & 2097151L);
+ values[valuesOffset++] = (int)((block12.TripleShift(13)) & 2097151L);
long block13 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block12 & 8191L) << 8) | ((long)((ulong)block13 >> 56)));
- values[valuesOffset++] = (int)(((long)((ulong)block13 >> 35)) & 2097151L);
- values[valuesOffset++] = (int)(((long)((ulong)block13 >> 14)) & 2097151L);
+ values[valuesOffset++] = (int)(((block12 & 8191L) << 8) | (block13.TripleShift(56)));
+ values[valuesOffset++] = (int)((block13.TripleShift(35)) & 2097151L);
+ values[valuesOffset++] = (int)((block13.TripleShift(14)) & 2097151L);
long block14 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block13 & 16383L) << 7) | ((long)((ulong)block14 >> 57)));
- values[valuesOffset++] = (int)(((long)((ulong)block14 >> 36)) & 2097151L);
- values[valuesOffset++] = (int)(((long)((ulong)block14 >> 15)) & 2097151L);
+ values[valuesOffset++] = (int)(((block13 & 16383L) << 7) | (block14.TripleShift(57)));
+ values[valuesOffset++] = (int)((block14.TripleShift(36)) & 2097151L);
+ values[valuesOffset++] = (int)((block14.TripleShift(15)) & 2097151L);
long block15 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block14 & 32767L) << 6) | ((long)((ulong)block15 >> 58)));
- values[valuesOffset++] = (int)(((long)((ulong)block15 >> 37)) & 2097151L);
- values[valuesOffset++] = (int)(((long)((ulong)block15 >> 16)) & 2097151L);
+ values[valuesOffset++] = (int)(((block14 & 32767L) << 6) | (block15.TripleShift(58)));
+ values[valuesOffset++] = (int)((block15.TripleShift(37)) & 2097151L);
+ values[valuesOffset++] = (int)((block15.TripleShift(16)) & 2097151L);
long block16 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block15 & 65535L) << 5) | ((long)((ulong)block16 >> 59)));
- values[valuesOffset++] = (int)(((long)((ulong)block16 >> 38)) & 2097151L);
- values[valuesOffset++] = (int)(((long)((ulong)block16 >> 17)) & 2097151L);
+ values[valuesOffset++] = (int)(((block15 & 65535L) << 5) | (block16.TripleShift(59)));
+ values[valuesOffset++] = (int)((block16.TripleShift(38)) & 2097151L);
+ values[valuesOffset++] = (int)((block16.TripleShift(17)) & 2097151L);
long block17 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block16 & 131071L) << 4) | ((long)((ulong)block17 >> 60)));
- values[valuesOffset++] = (int)(((long)((ulong)block17 >> 39)) & 2097151L);
- values[valuesOffset++] = (int)(((long)((ulong)block17 >> 18)) & 2097151L);
+ values[valuesOffset++] = (int)(((block16 & 131071L) << 4) | (block17.TripleShift(60)));
+ values[valuesOffset++] = (int)((block17.TripleShift(39)) & 2097151L);
+ values[valuesOffset++] = (int)((block17.TripleShift(18)) & 2097151L);
long block18 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block17 & 262143L) << 3) | ((long)((ulong)block18 >> 61)));
- values[valuesOffset++] = (int)(((long)((ulong)block18 >> 40)) & 2097151L);
- values[valuesOffset++] = (int)(((long)((ulong)block18 >> 19)) & 2097151L);
+ values[valuesOffset++] = (int)(((block17 & 262143L) << 3) | (block18.TripleShift(61)));
+ values[valuesOffset++] = (int)((block18.TripleShift(40)) & 2097151L);
+ values[valuesOffset++] = (int)((block18.TripleShift(19)) & 2097151L);
long block19 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block18 & 524287L) << 2) | ((long)((ulong)block19 >> 62)));
- values[valuesOffset++] = (int)(((long)((ulong)block19 >> 41)) & 2097151L);
- values[valuesOffset++] = (int)(((long)((ulong)block19 >> 20)) & 2097151L);
+ values[valuesOffset++] = (int)(((block18 & 524287L) << 2) | (block19.TripleShift(62)));
+ values[valuesOffset++] = (int)((block19.TripleShift(41)) & 2097151L);
+ values[valuesOffset++] = (int)((block19.TripleShift(20)) & 2097151L);
long block20 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block19 & 1048575L) << 1) | ((long)((ulong)block20 >> 63)));
- values[valuesOffset++] = (int)(((long)((ulong)block20 >> 42)) & 2097151L);
- values[valuesOffset++] = (int)(((long)((ulong)block20 >> 21)) & 2097151L);
+ values[valuesOffset++] = (int)(((block19 & 1048575L) << 1) | (block20.TripleShift(63)));
+ values[valuesOffset++] = (int)((block20.TripleShift(42)) & 2097151L);
+ values[valuesOffset++] = (int)((block20.TripleShift(21)) & 2097151L);
values[valuesOffset++] = (int)(block20 & 2097151L);
}
}
@@ -128,29 +130,29 @@ namespace Lucene.Net.Util.Packed
int byte0 = blocks[blocksOffset++] & 0xFF;
int byte1 = blocks[blocksOffset++] & 0xFF;
int byte2 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (byte0 << 13) | (byte1 << 5) | ((int)((uint)byte2 >> 3));
+ values[valuesOffset++] = (byte0 << 13) | (byte1 << 5) | (byte2.TripleShift(3));
int byte3 = blocks[blocksOffset++] & 0xFF;
int byte4 = blocks[blocksOffset++] & 0xFF;
int byte5 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte2 & 7) << 18) | (byte3 << 10) | (byte4 << 2) | ((int)((uint)byte5 >> 6));
+ values[valuesOffset++] = ((byte2 & 7) << 18) | (byte3 << 10) | (byte4 << 2) | (byte5.TripleShift(6));
int byte6 = blocks[blocksOffset++] & 0xFF;
int byte7 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte5 & 63) << 15) | (byte6 << 7) | ((int)((uint)byte7 >> 1));
+ values[valuesOffset++] = ((byte5 & 63) << 15) | (byte6 << 7) | (byte7.TripleShift(1));
int byte8 = blocks[blocksOffset++] & 0xFF;
int byte9 = blocks[blocksOffset++] & 0xFF;
int byte10 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte7 & 1) << 20) | (byte8 << 12) | (byte9 << 4) | ((int)((uint)byte10 >> 4));
+ values[valuesOffset++] = ((byte7 & 1) << 20) | (byte8 << 12) | (byte9 << 4) | (byte10.TripleShift(4));
int byte11 = blocks[blocksOffset++] & 0xFF;
int byte12 = blocks[blocksOffset++] & 0xFF;
int byte13 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte10 & 15) << 17) | (byte11 << 9) | (byte12 << 1) | ((int)((uint)byte13 >> 7));
+ values[valuesOffset++] = ((byte10 & 15) << 17) | (byte11 << 9) | (byte12 << 1) | (byte13.TripleShift(7));
int byte14 = blocks[blocksOffset++] & 0xFF;
int byte15 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte13 & 127) << 14) | (byte14 << 6) | ((int)((uint)byte15 >> 2));
+ values[valuesOffset++] = ((byte13 & 127) << 14) | (byte14 << 6) | (byte15.TripleShift(2));
int byte16 = blocks[blocksOffset++] & 0xFF;
int byte17 = blocks[blocksOffset++] & 0xFF;
int byte18 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte15 & 3) << 19) | (byte16 << 11) | (byte17 << 3) | ((int)((uint)byte18 >> 5));
+ values[valuesOffset++] = ((byte15 & 3) << 19) | (byte16 << 11) | (byte17 << 3) | (byte18.TripleShift(5));
int byte19 = blocks[blocksOffset++] & 0xFF;
int byte20 = blocks[blocksOffset++] & 0xFF;
values[valuesOffset++] = ((byte18 & 31) << 16) | (byte19 << 8) | byte20;
@@ -162,89 +164,89 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (long)((ulong)block0 >> 43);
- values[valuesOffset++] = ((long)((ulong)block0 >> 22)) & 2097151L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 1)) & 2097151L;
+ values[valuesOffset++] = block0.TripleShift(43);
+ values[valuesOffset++] = (block0.TripleShift(22)) & 2097151L;
+ values[valuesOffset++] = (block0.TripleShift(1)) & 2097151L;
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block0 & 1L) << 20) | ((long)((ulong)block1 >> 44));
- values[valuesOffset++] = ((long)((ulong)block1 >> 23)) & 2097151L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 2)) & 2097151L;
+ values[valuesOffset++] = ((block0 & 1L) << 20) | (block1.TripleShift(44));
+ values[valuesOffset++] = (block1.TripleShift(23)) & 2097151L;
+ values[valuesOffset++] = (block1.TripleShift(2)) & 2097151L;
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block1 & 3L) << 19) | ((long)((ulong)block2 >> 45));
- values[valuesOffset++] = ((long)((ulong)block2 >> 24)) & 2097151L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 3)) & 2097151L;
+ values[valuesOffset++] = ((block1 & 3L) << 19) | (block2.TripleShift(45));
+ values[valuesOffset++] = (block2.TripleShift(24)) & 2097151L;
+ values[valuesOffset++] = (block2.TripleShift(3)) & 2097151L;
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block2 & 7L) << 18) | ((long)((ulong)block3 >> 46));
- values[valuesOffset++] = ((long)((ulong)block3 >> 25)) & 2097151L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 4)) & 2097151L;
+ values[valuesOffset++] = ((block2 & 7L) << 18) | (block3.TripleShift(46));
+ values[valuesOffset++] = (block3.TripleShift(25)) & 2097151L;
+ values[valuesOffset++] = (block3.TripleShift(4)) & 2097151L;
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block3 & 15L) << 17) | ((long)((ulong)block4 >> 47));
- values[valuesOffset++] = ((long)((ulong)block4 >> 26)) & 2097151L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 5)) & 2097151L;
+ values[valuesOffset++] = ((block3 & 15L) << 17) | (block4.TripleShift(47));
+ values[valuesOffset++] = (block4.TripleShift(26)) & 2097151L;
+ values[valuesOffset++] = (block4.TripleShift(5)) & 2097151L;
long block5 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block4 & 31L) << 16) | ((long)((ulong)block5 >> 48));
- values[valuesOffset++] = ((long)((ulong)block5 >> 27)) & 2097151L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 6)) & 2097151L;
+ values[valuesOffset++] = ((block4 & 31L) << 16) | (block5.TripleShift(48));
+ values[valuesOffset++] = (block5.TripleShift(27)) & 2097151L;
+ values[valuesOffset++] = (block5.TripleShift(6)) & 2097151L;
long block6 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block5 & 63L) << 15) | ((long)((ulong)block6 >> 49));
- values[valuesOffset++] = ((long)((ulong)block6 >> 28)) & 2097151L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 7)) & 2097151L;
+ values[valuesOffset++] = ((block5 & 63L) << 15) | (block6.TripleShift(49));
+ values[valuesOffset++] = (block6.TripleShift(28)) & 2097151L;
+ values[valuesOffset++] = (block6.TripleShift(7)) & 2097151L;
long block7 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block6 & 127L) << 14) | ((long)((ulong)block7 >> 50));
- values[valuesOffset++] = ((long)((ulong)block7 >> 29)) & 2097151L;
- values[valuesOffset++] = ((long)((ulong)block7 >> 8)) & 2097151L;
+ values[valuesOffset++] = ((block6 & 127L) << 14) | (block7.TripleShift(50));
+ values[valuesOffset++] = (block7.TripleShift(29)) & 2097151L;
+ values[valuesOffset++] = (block7.TripleShift(8)) & 2097151L;
long block8 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block7 & 255L) << 13) | ((long)((ulong)block8 >> 51));
- values[valuesOffset++] = ((long)((ulong)block8 >> 30)) & 2097151L;
- values[valuesOffset++] = ((long)((ulong)block8 >> 9)) & 2097151L;
+ values[valuesOffset++] = ((block7 & 255L) << 13) | (block8.TripleShift(51));
+ values[valuesOffset++] = (block8.TripleShift(30)) & 2097151L;
+ values[valuesOffset++] = (block8.TripleShift(9)) & 2097151L;
long block9 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block8 & 511L) << 12) | ((long)((ulong)block9 >> 52));
- values[valuesOffset++] = ((long)((ulong)block9 >> 31)) & 2097151L;
- values[valuesOffset++] = ((long)((ulong)block9 >> 10)) & 2097151L;
+ values[valuesOffset++] = ((block8 & 511L) << 12) | (block9.TripleShift(52));
+ values[valuesOffset++] = (block9.TripleShift(31)) & 2097151L;
+ values[valuesOffset++] = (block9.TripleShift(10)) & 2097151L;
long block10 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block9 & 1023L) << 11) | ((long)((ulong)block10 >> 53));
- values[valuesOffset++] = ((long)((ulong)block10 >> 32)) & 2097151L;
- values[valuesOffset++] = ((long)((ulong)block10 >> 11)) & 2097151L;
+ values[valuesOffset++] = ((block9 & 1023L) << 11) | (block10.TripleShift(53));
+ values[valuesOffset++] = (block10.TripleShift(32)) & 2097151L;
+ values[valuesOffset++] = (block10.TripleShift(11)) & 2097151L;
long block11 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block10 & 2047L) << 10) | ((long)((ulong)block11 >> 54));
- values[valuesOffset++] = ((long)((ulong)block11 >> 33)) & 2097151L;
- values[valuesOffset++] = ((long)((ulong)block11 >> 12)) & 2097151L;
+ values[valuesOffset++] = ((block10 & 2047L) << 10) | (block11.TripleShift(54));
+ values[valuesOffset++] = (block11.TripleShift(33)) & 2097151L;
+ values[valuesOffset++] = (block11.TripleShift(12)) & 2097151L;
long block12 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block11 & 4095L) << 9) | ((long)((ulong)block12 >> 55));
- values[valuesOffset++] = ((long)((ulong)block12 >> 34)) & 2097151L;
- values[valuesOffset++] = ((long)((ulong)block12 >> 13)) & 2097151L;
+ values[valuesOffset++] = ((block11 & 4095L) << 9) | (block12.TripleShift(55));
+ values[valuesOffset++] = (block12.TripleShift(34)) & 2097151L;
+ values[valuesOffset++] = (block12.TripleShift(13)) & 2097151L;
long block13 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block12 & 8191L) << 8) | ((long)((ulong)block13 >> 56));
- values[valuesOffset++] = ((long)((ulong)block13 >> 35)) & 2097151L;
- values[valuesOffset++] = ((long)((ulong)block13 >> 14)) & 2097151L;
+ values[valuesOffset++] = ((block12 & 8191L) << 8) | (block13.TripleShift(56));
+ values[valuesOffset++] = (block13.TripleShift(35)) & 2097151L;
+ values[valuesOffset++] = (block13.TripleShift(14)) & 2097151L;
long block14 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block13 & 16383L) << 7) | ((long)((ulong)block14 >> 57));
- values[valuesOffset++] = ((long)((ulong)block14 >> 36)) & 2097151L;
- values[valuesOffset++] = ((long)((ulong)block14 >> 15)) & 2097151L;
+ values[valuesOffset++] = ((block13 & 16383L) << 7) | (block14.TripleShift(57));
+ values[valuesOffset++] = (block14.TripleShift(36)) & 2097151L;
+ values[valuesOffset++] = (block14.TripleShift(15)) & 2097151L;
long block15 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block14 & 32767L) << 6) | ((long)((ulong)block15 >> 58));
- values[valuesOffset++] = ((long)((ulong)block15 >> 37)) & 2097151L;
- values[valuesOffset++] = ((long)((ulong)block15 >> 16)) & 2097151L;
+ values[valuesOffset++] = ((block14 & 32767L) << 6) | (block15.TripleShift(58));
+ values[valuesOffset++] = (block15.TripleShift(37)) & 2097151L;
+ values[valuesOffset++] = (block15.TripleShift(16)) & 2097151L;
long block16 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block15 & 65535L) << 5) | ((long)((ulong)block16 >> 59));
- values[valuesOffset++] = ((long)((ulong)block16 >> 38)) & 2097151L;
- values[valuesOffset++] = ((long)((ulong)block16 >> 17)) & 2097151L;
+ values[valuesOffset++] = ((block15 & 65535L) << 5) | (block16.TripleShift(59));
+ values[valuesOffset++] = (block16.TripleShift(38)) & 2097151L;
+ values[valuesOffset++] = (block16.TripleShift(17)) & 2097151L;
long block17 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block16 & 131071L) << 4) | ((long)((ulong)block17 >> 60));
- values[valuesOffset++] = ((long)((ulong)block17 >> 39)) & 2097151L;
- values[valuesOffset++] = ((long)((ulong)block17 >> 18)) & 2097151L;
+ values[valuesOffset++] = ((block16 & 131071L) << 4) | (block17.TripleShift(60));
+ values[valuesOffset++] = (block17.TripleShift(39)) & 2097151L;
+ values[valuesOffset++] = (block17.TripleShift(18)) & 2097151L;
long block18 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block17 & 262143L) << 3) | ((long)((ulong)block18 >> 61));
- values[valuesOffset++] = ((long)((ulong)block18 >> 40)) & 2097151L;
- values[valuesOffset++] = ((long)((ulong)block18 >> 19)) & 2097151L;
+ values[valuesOffset++] = ((block17 & 262143L) << 3) | (block18.TripleShift(61));
+ values[valuesOffset++] = (block18.TripleShift(40)) & 2097151L;
+ values[valuesOffset++] = (block18.TripleShift(19)) & 2097151L;
long block19 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block18 & 524287L) << 2) | ((long)((ulong)block19 >> 62));
- values[valuesOffset++] = ((long)((ulong)block19 >> 41)) & 2097151L;
- values[valuesOffset++] = ((long)((ulong)block19 >> 20)) & 2097151L;
+ values[valuesOffset++] = ((block18 & 524287L) << 2) | (block19.TripleShift(62));
+ values[valuesOffset++] = (block19.TripleShift(41)) & 2097151L;
+ values[valuesOffset++] = (block19.TripleShift(20)) & 2097151L;
long block20 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block19 & 1048575L) << 1) | ((long)((ulong)block20 >> 63));
- values[valuesOffset++] = ((long)((ulong)block20 >> 42)) & 2097151L;
- values[valuesOffset++] = ((long)((ulong)block20 >> 21)) & 2097151L;
+ values[valuesOffset++] = ((block19 & 1048575L) << 1) | (block20.TripleShift(63));
+ values[valuesOffset++] = (block20.TripleShift(42)) & 2097151L;
+ values[valuesOffset++] = (block20.TripleShift(21)) & 2097151L;
values[valuesOffset++] = block20 & 2097151L;
}
}
@@ -256,29 +258,29 @@ namespace Lucene.Net.Util.Packed
long byte0 = blocks[blocksOffset++] & 0xFF;
long byte1 = blocks[blocksOffset++] & 0xFF;
long byte2 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (byte0 << 13) | (byte1 << 5) | ((long)((ulong)byte2 >> 3));
+ values[valuesOffset++] = (byte0 << 13) | (byte1 << 5) | (byte2.TripleShift(3));
long byte3 = blocks[blocksOffset++] & 0xFF;
long byte4 = blocks[blocksOffset++] & 0xFF;
long byte5 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte2 & 7) << 18) | (byte3 << 10) | (byte4 << 2) | ((long)((ulong)byte5 >> 6));
+ values[valuesOffset++] = ((byte2 & 7) << 18) | (byte3 << 10) | (byte4 << 2) | (byte5.TripleShift(6));
long byte6 = blocks[blocksOffset++] & 0xFF;
long byte7 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte5 & 63) << 15) | (byte6 << 7) | ((long)((ulong)byte7 >> 1));
+ values[valuesOffset++] = ((byte5 & 63) << 15) | (byte6 << 7) | (byte7.TripleShift(1));
long byte8 = blocks[blocksOffset++] & 0xFF;
long byte9 = blocks[blocksOffset++] & 0xFF;
long byte10 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte7 & 1) << 20) | (byte8 << 12) | (byte9 << 4) | ((long)((ulong)byte10 >> 4));
+ values[valuesOffset++] = ((byte7 & 1) << 20) | (byte8 << 12) | (byte9 << 4) | (byte10.TripleShift(4));
long byte11 = blocks[blocksOffset++] & 0xFF;
long byte12 = blocks[blocksOffset++] & 0xFF;
long byte13 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte10 & 15) << 17) | (byte11 << 9) | (byte12 << 1) | ((long)((ulong)byte13 >> 7));
+ values[valuesOffset++] = ((byte10 & 15) << 17) | (byte11 << 9) | (byte12 << 1) | (byte13.TripleShift(7));
long byte14 = blocks[blocksOffset++] & 0xFF;
long byte15 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte13 & 127) << 14) | (byte14 << 6) | ((long)((ulong)byte15 >> 2));
+ values[valuesOffset++] = ((byte13 & 127) << 14) | (byte14 << 6) | (byte15.TripleShift(2));
long byte16 = blocks[blocksOffset++] & 0xFF;
long byte17 = blocks[blocksOffset++] & 0xFF;
long byte18 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte15 & 3) << 19) | (byte16 << 11) | (byte17 << 3) | ((long)((ulong)byte18 >> 5));
+ values[valuesOffset++] = ((byte15 & 3) << 19) | (byte16 << 11) | (byte17 << 3) | (byte18.TripleShift(5));
long byte19 = blocks[blocksOffset++] & 0xFF;
long byte20 = blocks[blocksOffset++] & 0xFF;
values[valuesOffset++] = ((byte18 & 31) << 16) | (byte19 << 8) | byte20;
diff --git a/src/Lucene.Net/Util/Packed/BulkOperationPacked22.cs b/src/Lucene.Net/Util/Packed/BulkOperationPacked22.cs
index 6f2ead3..d29c76e 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperationPacked22.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperationPacked22.cs
@@ -1,4 +1,6 @@
-// this file has been automatically generated, DO NOT EDIT
+// this file has been automatically generated, DO NOT EDIT
+
+using J2N.Numerics;
namespace Lucene.Net.Util.Packed
{
@@ -34,47 +36,47 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)((long)((ulong)block0 >> 42));
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 20)) & 4194303L);
+ values[valuesOffset++] = (int)(block0.TripleShift(42));
+ values[valuesOffset++] = (int)((block0.TripleShift(20)) & 4194303L);
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block0 & 1048575L) << 2) | ((long)((ulong)block1 >> 62)));
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 40)) & 4194303L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 18)) & 4194303L);
+ values[valuesOffset++] = (int)(((block0 & 1048575L) << 2) | (block1.TripleShift(62)));
+ values[valuesOffset++] = (int)((block1.TripleShift(40)) & 4194303L);
+ values[valuesOffset++] = (int)((block1.TripleShift(18)) & 4194303L);
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block1 & 262143L) << 4) | ((long)((ulong)block2 >> 60)));
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 38)) & 4194303L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 16)) & 4194303L);
+ values[valuesOffset++] = (int)(((block1 & 262143L) << 4) | (block2.TripleShift(60)));
+ values[valuesOffset++] = (int)((block2.TripleShift(38)) & 4194303L);
+ values[valuesOffset++] = (int)((block2.TripleShift(16)) & 4194303L);
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block2 & 65535L) << 6) | ((long)((ulong)block3 >> 58)));
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 36)) & 4194303L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 14)) & 4194303L);
+ values[valuesOffset++] = (int)(((block2 & 65535L) << 6) | (block3.TripleShift(58)));
+ values[valuesOffset++] = (int)((block3.TripleShift(36)) & 4194303L);
+ values[valuesOffset++] = (int)((block3.TripleShift(14)) & 4194303L);
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block3 & 16383L) << 8) | ((long)((ulong)block4 >> 56)));
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 34)) & 4194303L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 12)) & 4194303L);
+ values[valuesOffset++] = (int)(((block3 & 16383L) << 8) | (block4.TripleShift(56)));
+ values[valuesOffset++] = (int)((block4.TripleShift(34)) & 4194303L);
+ values[valuesOffset++] = (int)((block4.TripleShift(12)) & 4194303L);
long block5 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block4 & 4095L) << 10) | ((long)((ulong)block5 >> 54)));
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 32)) & 4194303L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 10)) & 4194303L);
+ values[valuesOffset++] = (int)(((block4 & 4095L) << 10) | (block5.TripleShift(54)));
+ values[valuesOffset++] = (int)((block5.TripleShift(32)) & 4194303L);
+ values[valuesOffset++] = (int)((block5.TripleShift(10)) & 4194303L);
long block6 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block5 & 1023L) << 12) | ((long)((ulong)block6 >> 52)));
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 30)) & 4194303L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 8)) & 4194303L);
+ values[valuesOffset++] = (int)(((block5 & 1023L) << 12) | (block6.TripleShift(52)));
+ values[valuesOffset++] = (int)((block6.TripleShift(30)) & 4194303L);
+ values[valuesOffset++] = (int)((block6.TripleShift(8)) & 4194303L);
long block7 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block6 & 255L) << 14) | ((long)((ulong)block7 >> 50)));
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 28)) & 4194303L);
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 6)) & 4194303L);
+ values[valuesOffset++] = (int)(((block6 & 255L) << 14) | (block7.TripleShift(50)));
+ values[valuesOffset++] = (int)((block7.TripleShift(28)) & 4194303L);
+ values[valuesOffset++] = (int)((block7.TripleShift(6)) & 4194303L);
long block8 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block7 & 63L) << 16) | ((long)((ulong)block8 >> 48)));
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 26)) & 4194303L);
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 4)) & 4194303L);
+ values[valuesOffset++] = (int)(((block7 & 63L) << 16) | (block8.TripleShift(48)));
+ values[valuesOffset++] = (int)((block8.TripleShift(26)) & 4194303L);
+ values[valuesOffset++] = (int)((block8.TripleShift(4)) & 4194303L);
long block9 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block8 & 15L) << 18) | ((long)((ulong)block9 >> 46)));
- values[valuesOffset++] = (int)(((long)((ulong)block9 >> 24)) & 4194303L);
- values[valuesOffset++] = (int)(((long)((ulong)block9 >> 2)) & 4194303L);
+ values[valuesOffset++] = (int)(((block8 & 15L) << 18) | (block9.TripleShift(46)));
+ values[valuesOffset++] = (int)((block9.TripleShift(24)) & 4194303L);
+ values[valuesOffset++] = (int)((block9.TripleShift(2)) & 4194303L);
long block10 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block9 & 3L) << 20) | ((long)((ulong)block10 >> 44)));
- values[valuesOffset++] = (int)(((long)((ulong)block10 >> 22)) & 4194303L);
+ values[valuesOffset++] = (int)(((block9 & 3L) << 20) | (block10.TripleShift(44)));
+ values[valuesOffset++] = (int)((block10.TripleShift(22)) & 4194303L);
values[valuesOffset++] = (int)(block10 & 4194303L);
}
}
@@ -86,15 +88,15 @@ namespace Lucene.Net.Util.Packed
int byte0 = blocks[blocksOffset++] & 0xFF;
int byte1 = blocks[blocksOffset++] & 0xFF;
int byte2 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (byte0 << 14) | (byte1 << 6) | ((int)((uint)byte2 >> 2));
+ values[valuesOffset++] = (byte0 << 14) | (byte1 << 6) | (byte2.TripleShift(2));
int byte3 = blocks[blocksOffset++] & 0xFF;
int byte4 = blocks[blocksOffset++] & 0xFF;
int byte5 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte2 & 3) << 20) | (byte3 << 12) | (byte4 << 4) | ((int)((uint)byte5 >> 4));
+ values[valuesOffset++] = ((byte2 & 3) << 20) | (byte3 << 12) | (byte4 << 4) | (byte5.TripleShift(4));
int byte6 = blocks[blocksOffset++] & 0xFF;
int byte7 = blocks[blocksOffset++] & 0xFF;
int byte8 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte5 & 15) << 18) | (byte6 << 10) | (byte7 << 2) | ((int)((uint)byte8 >> 6));
+ values[valuesOffset++] = ((byte5 & 15) << 18) | (byte6 << 10) | (byte7 << 2) | (byte8.TripleShift(6));
int byte9 = blocks[blocksOffset++] & 0xFF;
int byte10 = blocks[blocksOffset++] & 0xFF;
values[valuesOffset++] = ((byte8 & 63) << 16) | (byte9 << 8) | byte10;
@@ -106,47 +108,47 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (long)((ulong)block0 >> 42);
- values[valuesOffset++] = ((long)((ulong)block0 >> 20)) & 4194303L;
+ values[valuesOffset++] = block0.TripleShift(42);
+ values[valuesOffset++] = (block0.TripleShift(20)) & 4194303L;
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block0 & 1048575L) << 2) | ((long)((ulong)block1 >> 62));
- values[valuesOffset++] = ((long)((ulong)block1 >> 40)) & 4194303L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 18)) & 4194303L;
+ values[valuesOffset++] = ((block0 & 1048575L) << 2) | (block1.TripleShift(62));
+ values[valuesOffset++] = (block1.TripleShift(40)) & 4194303L;
+ values[valuesOffset++] = (block1.TripleShift(18)) & 4194303L;
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block1 & 262143L) << 4) | ((long)((ulong)block2 >> 60));
- values[valuesOffset++] = ((long)((ulong)block2 >> 38)) & 4194303L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 16)) & 4194303L;
+ values[valuesOffset++] = ((block1 & 262143L) << 4) | (block2.TripleShift(60));
+ values[valuesOffset++] = (block2.TripleShift(38)) & 4194303L;
+ values[valuesOffset++] = (block2.TripleShift(16)) & 4194303L;
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block2 & 65535L) << 6) | ((long)((ulong)block3 >> 58));
- values[valuesOffset++] = ((long)((ulong)block3 >> 36)) & 4194303L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 14)) & 4194303L;
+ values[valuesOffset++] = ((block2 & 65535L) << 6) | (block3.TripleShift(58));
+ values[valuesOffset++] = (block3.TripleShift(36)) & 4194303L;
+ values[valuesOffset++] = (block3.TripleShift(14)) & 4194303L;
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block3 & 16383L) << 8) | ((long)((ulong)block4 >> 56));
- values[valuesOffset++] = ((long)((ulong)block4 >> 34)) & 4194303L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 12)) & 4194303L;
+ values[valuesOffset++] = ((block3 & 16383L) << 8) | (block4.TripleShift(56));
+ values[valuesOffset++] = (block4.TripleShift(34)) & 4194303L;
+ values[valuesOffset++] = (block4.TripleShift(12)) & 4194303L;
long block5 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block4 & 4095L) << 10) | ((long)((ulong)block5 >> 54));
- values[valuesOffset++] = ((long)((ulong)block5 >> 32)) & 4194303L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 10)) & 4194303L;
+ values[valuesOffset++] = ((block4 & 4095L) << 10) | (block5.TripleShift(54));
+ values[valuesOffset++] = (block5.TripleShift(32)) & 4194303L;
+ values[valuesOffset++] = (block5.TripleShift(10)) & 4194303L;
long block6 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block5 & 1023L) << 12) | ((long)((ulong)block6 >> 52));
- values[valuesOffset++] = ((long)((ulong)block6 >> 30)) & 4194303L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 8)) & 4194303L;
+ values[valuesOffset++] = ((block5 & 1023L) << 12) | (block6.TripleShift(52));
+ values[valuesOffset++] = (block6.TripleShift(30)) & 4194303L;
+ values[valuesOffset++] = (block6.TripleShift(8)) & 4194303L;
long block7 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block6 & 255L) << 14) | ((long)((ulong)block7 >> 50));
- values[valuesOffset++] = ((long)((ulong)block7 >> 28)) & 4194303L;
- values[valuesOffset++] = ((long)((ulong)block7 >> 6)) & 4194303L;
+ values[valuesOffset++] = ((block6 & 255L) << 14) | (block7.TripleShift(50));
+ values[valuesOffset++] = (block7.TripleShift(28)) & 4194303L;
+ values[valuesOffset++] = (block7.TripleShift(6)) & 4194303L;
long block8 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block7 & 63L) << 16) | ((long)((ulong)block8 >> 48));
- values[valuesOffset++] = ((long)((ulong)block8 >> 26)) & 4194303L;
- values[valuesOffset++] = ((long)((ulong)block8 >> 4)) & 4194303L;
+ values[valuesOffset++] = ((block7 & 63L) << 16) | (block8.TripleShift(48));
+ values[valuesOffset++] = (block8.TripleShift(26)) & 4194303L;
+ values[valuesOffset++] = (block8.TripleShift(4)) & 4194303L;
long block9 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block8 & 15L) << 18) | ((long)((ulong)block9 >> 46));
- values[valuesOffset++] = ((long)((ulong)block9 >> 24)) & 4194303L;
- values[valuesOffset++] = ((long)((ulong)block9 >> 2)) & 4194303L;
+ values[valuesOffset++] = ((block8 & 15L) << 18) | (block9.TripleShift(46));
+ values[valuesOffset++] = (block9.TripleShift(24)) & 4194303L;
+ values[valuesOffset++] = (block9.TripleShift(2)) & 4194303L;
long block10 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block9 & 3L) << 20) | ((long)((ulong)block10 >> 44));
- values[valuesOffset++] = ((long)((ulong)block10 >> 22)) & 4194303L;
+ values[valuesOffset++] = ((block9 & 3L) << 20) | (block10.TripleShift(44));
+ values[valuesOffset++] = (block10.TripleShift(22)) & 4194303L;
values[valuesOffset++] = block10 & 4194303L;
}
}
@@ -158,15 +160,15 @@ namespace Lucene.Net.Util.Packed
long byte0 = blocks[blocksOffset++] & 0xFF;
long byte1 = blocks[blocksOffset++] & 0xFF;
long byte2 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (byte0 << 14) | (byte1 << 6) | ((long)((ulong)byte2 >> 2));
+ values[valuesOffset++] = (byte0 << 14) | (byte1 << 6) | (byte2.TripleShift(2));
long byte3 = blocks[blocksOffset++] & 0xFF;
long byte4 = blocks[blocksOffset++] & 0xFF;
long byte5 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte2 & 3) << 20) | (byte3 << 12) | (byte4 << 4) | ((long)((ulong)byte5 >> 4));
+ values[valuesOffset++] = ((byte2 & 3) << 20) | (byte3 << 12) | (byte4 << 4) | (byte5.TripleShift(4));
long byte6 = blocks[blocksOffset++] & 0xFF;
long byte7 = blocks[blocksOffset++] & 0xFF;
long byte8 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte5 & 15) << 18) | (byte6 << 10) | (byte7 << 2) | ((long)((ulong)byte8 >> 6));
+ values[valuesOffset++] = ((byte5 & 15) << 18) | (byte6 << 10) | (byte7 << 2) | (byte8.TripleShift(6));
long byte9 = blocks[blocksOffset++] & 0xFF;
long byte10 = blocks[blocksOffset++] & 0xFF;
values[valuesOffset++] = ((byte8 & 63) << 16) | (byte9 << 8) | byte10;
diff --git a/src/Lucene.Net/Util/Packed/BulkOperationPacked23.cs b/src/Lucene.Net/Util/Packed/BulkOperationPacked23.cs
index edca46c..59d6936 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperationPacked23.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperationPacked23.cs
@@ -1,4 +1,6 @@
-// this file has been automatically generated, DO NOT EDIT
+// this file has been automatically generated, DO NOT EDIT
+
+using J2N.Numerics;
namespace Lucene.Net.Util.Packed
{
@@ -34,91 +36,91 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)((long)((ulong)block0 >> 41));
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 18)) & 8388607L);
+ values[valuesOffset++] = (int)(block0.TripleShift(41));
+ values[valuesOffset++] = (int)((block0.TripleShift(18)) & 8388607L);
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block0 & 262143L) << 5) | ((long)((ulong)block1 >> 59)));
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 36)) & 8388607L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 13)) & 8388607L);
+ values[valuesOffset++] = (int)(((block0 & 262143L) << 5) | (block1.TripleShift(59)));
+ values[valuesOffset++] = (int)((block1.TripleShift(36)) & 8388607L);
+ values[valuesOffset++] = (int)((block1.TripleShift(13)) & 8388607L);
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block1 & 8191L) << 10) | ((long)((ulong)block2 >> 54)));
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 31)) & 8388607L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 8)) & 8388607L);
+ values[valuesOffset++] = (int)(((block1 & 8191L) << 10) | (block2.TripleShift(54)));
+ values[valuesOffset++] = (int)((block2.TripleShift(31)) & 8388607L);
+ values[valuesOffset++] = (int)((block2.TripleShift(8)) & 8388607L);
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block2 & 255L) << 15) | ((long)((ulong)block3 >> 49)));
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 26)) & 8388607L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 3)) & 8388607L);
+ values[valuesOffset++] = (int)(((block2 & 255L) << 15) | (block3.TripleShift(49)));
+ values[valuesOffset++] = (int)((block3.TripleShift(26)) & 8388607L);
+ values[valuesOffset++] = (int)((block3.TripleShift(3)) & 8388607L);
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block3 & 7L) << 20) | ((long)((ulong)block4 >> 44)));
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 21)) & 8388607L);
+ values[valuesOffset++] = (int)(((block3 & 7L) << 20) | (block4.TripleShift(44)));
+ values[valuesOffset++] = (int)((block4.TripleShift(21)) & 8388607L);
long block5 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block4 & 2097151L) << 2) | ((long)((ulong)block5 >> 62)));
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 39)) & 8388607L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 16)) & 8388607L);
+ values[valuesOffset++] = (int)(((block4 & 2097151L) << 2) | (block5.TripleShift(62)));
+ values[valuesOffset++] = (int)((block5.TripleShift(39)) & 8388607L);
+ values[valuesOffset++] = (int)((block5.TripleShift(16)) & 8388607L);
long block6 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block5 & 65535L) << 7) | ((long)((ulong)block6 >> 57)));
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 34)) & 8388607L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 11)) & 8388607L);
+ values[valuesOffset++] = (int)(((block5 & 65535L) << 7) | (block6.TripleShift(57)));
+ values[valuesOffset++] = (int)((block6.TripleShift(34)) & 8388607L);
+ values[valuesOffset++] = (int)((block6.TripleShift(11)) & 8388607L);
long block7 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block6 & 2047L) << 12) | ((long)((ulong)block7 >> 52)));
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 29)) & 8388607L);
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 6)) & 8388607L);
+ values[valuesOffset++] = (int)(((block6 & 2047L) << 12) | (block7.TripleShift(52)));
+ values[valuesOffset++] = (int)((block7.TripleShift(29)) & 8388607L);
+ values[valuesOffset++] = (int)((block7.TripleShift(6)) & 8388607L);
long block8 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block7 & 63L) << 17) | ((long)((ulong)block8 >> 47)));
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 24)) & 8388607L);
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 1)) & 8388607L);
+ values[valuesOffset++] = (int)(((block7 & 63L) << 17) | (block8.TripleShift(47)));
+ values[valuesOffset++] = (int)((block8.TripleShift(24)) & 8388607L);
+ values[valuesOffset++] = (int)((block8.TripleShift(1)) & 8388607L);
long block9 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block8 & 1L) << 22) | ((long)((ulong)block9 >> 42)));
- values[valuesOffset++] = (int)(((long)((ulong)block9 >> 19)) & 8388607L);
+ values[valuesOffset++] = (int)(((block8 & 1L) << 22) | (block9.TripleShift(42)));
+ values[valuesOffset++] = (int)((block9.TripleShift(19)) & 8388607L);
long block10 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block9 & 524287L) << 4) | ((long)((ulong)block10 >> 60)));
- values[valuesOffset++] = (int)(((long)((ulong)block10 >> 37)) & 8388607L);
- values[valuesOffset++] = (int)(((long)((ulong)block10 >> 14)) & 8388607L);
+ values[valuesOffset++] = (int)(((block9 & 524287L) << 4) | (block10.TripleShift(60)));
+ values[valuesOffset++] = (int)((block10.TripleShift(37)) & 8388607L);
+ values[valuesOffset++] = (int)((block10.TripleShift(14)) & 8388607L);
long block11 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block10 & 16383L) << 9) | ((long)((ulong)block11 >> 55)));
- values[valuesOffset++] = (int)(((long)((ulong)block11 >> 32)) & 8388607L);
- values[valuesOffset++] = (int)(((long)((ulong)block11 >> 9)) & 8388607L);
+ values[valuesOffset++] = (int)(((block10 & 16383L) << 9) | (block11.TripleShift(55)));
+ values[valuesOffset++] = (int)((block11.TripleShift(32)) & 8388607L);
+ values[valuesOffset++] = (int)((block11.TripleShift(9)) & 8388607L);
long block12 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block11 & 511L) << 14) | ((long)((ulong)block12 >> 50)));
- values[valuesOffset++] = (int)(((long)((ulong)block12 >> 27)) & 8388607L);
- values[valuesOffset++] = (int)(((long)((ulong)block12 >> 4)) & 8388607L);
+ values[valuesOffset++] = (int)(((block11 & 511L) << 14) | (block12.TripleShift(50)));
+ values[valuesOffset++] = (int)((block12.TripleShift(27)) & 8388607L);
+ values[valuesOffset++] = (int)((block12.TripleShift(4)) & 8388607L);
long block13 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block12 & 15L) << 19) | ((long)((ulong)block13 >> 45)));
- values[valuesOffset++] = (int)(((long)((ulong)block13 >> 22)) & 8388607L);
+ values[valuesOffset++] = (int)(((block12 & 15L) << 19) | (block13.TripleShift(45)));
+ values[valuesOffset++] = (int)((block13.TripleShift(22)) & 8388607L);
long block14 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block13 & 4194303L) << 1) | ((long)((ulong)block14 >> 63)));
- values[valuesOffset++] = (int)(((long)((ulong)block14 >> 40)) & 8388607L);
- values[valuesOffset++] = (int)(((long)((ulong)block14 >> 17)) & 8388607L);
+ values[valuesOffset++] = (int)(((block13 & 4194303L) << 1) | (block14.TripleShift(63)));
+ values[valuesOffset++] = (int)((block14.TripleShift(40)) & 8388607L);
+ values[valuesOffset++] = (int)((block14.TripleShift(17)) & 8388607L);
long block15 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block14 & 131071L) << 6) | ((long)((ulong)block15 >> 58)));
- values[valuesOffset++] = (int)(((long)((ulong)block15 >> 35)) & 8388607L);
- values[valuesOffset++] = (int)(((long)((ulong)block15 >> 12)) & 8388607L);
+ values[valuesOffset++] = (int)(((block14 & 131071L) << 6) | (block15.TripleShift(58)));
+ values[valuesOffset++] = (int)((block15.TripleShift(35)) & 8388607L);
+ values[valuesOffset++] = (int)((block15.TripleShift(12)) & 8388607L);
long block16 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block15 & 4095L) << 11) | ((long)((ulong)block16 >> 53)));
- values[valuesOffset++] = (int)(((long)((ulong)block16 >> 30)) & 8388607L);
- values[valuesOffset++] = (int)(((long)((ulong)block16 >> 7)) & 8388607L);
+ values[valuesOffset++] = (int)(((block15 & 4095L) << 11) | (block16.TripleShift(53)));
+ values[valuesOffset++] = (int)((block16.TripleShift(30)) & 8388607L);
+ values[valuesOffset++] = (int)((block16.TripleShift(7)) & 8388607L);
long block17 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block16 & 127L) << 16) | ((long)((ulong)block17 >> 48)));
- values[valuesOffset++] = (int)(((long)((ulong)block17 >> 25)) & 8388607L);
- values[valuesOffset++] = (int)(((long)((ulong)block17 >> 2)) & 8388607L);
+ values[valuesOffset++] = (int)(((block16 & 127L) << 16) | (block17.TripleShift(48)));
+ values[valuesOffset++] = (int)((block17.TripleShift(25)) & 8388607L);
+ values[valuesOffset++] = (int)((block17.TripleShift(2)) & 8388607L);
long block18 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block17 & 3L) << 21) | ((long)((ulong)block18 >> 43)));
- values[valuesOffset++] = (int)(((long)((ulong)block18 >> 20)) & 8388607L);
+ values[valuesOffset++] = (int)(((block17 & 3L) << 21) | (block18.TripleShift(43)));
+ values[valuesOffset++] = (int)((block18.TripleShift(20)) & 8388607L);
long block19 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block18 & 1048575L) << 3) | ((long)((ulong)block19 >> 61)));
- values[valuesOffset++] = (int)(((long)((ulong)block19 >> 38)) & 8388607L);
- values[valuesOffset++] = (int)(((long)((ulong)block19 >> 15)) & 8388607L);
+ values[valuesOffset++] = (int)(((block18 & 1048575L) << 3) | (block19.TripleShift(61)));
+ values[valuesOffset++] = (int)((block19.TripleShift(38)) & 8388607L);
+ values[valuesOffset++] = (int)((block19.TripleShift(15)) & 8388607L);
long block20 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block19 & 32767L) << 8) | ((long)((ulong)block20 >> 56)));
- values[valuesOffset++] = (int)(((long)((ulong)block20 >> 33)) & 8388607L);
- values[valuesOffset++] = (int)(((long)((ulong)block20 >> 10)) & 8388607L);
+ values[valuesOffset++] = (int)(((block19 & 32767L) << 8) | (block20.TripleShift(56)));
+ values[valuesOffset++] = (int)((block20.TripleShift(33)) & 8388607L);
+ values[valuesOffset++] = (int)((block20.TripleShift(10)) & 8388607L);
long block21 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block20 & 1023L) << 13) | ((long)((ulong)block21 >> 51)));
- values[valuesOffset++] = (int)(((long)((ulong)block21 >> 28)) & 8388607L);
- values[valuesOffset++] = (int)(((long)((ulong)block21 >> 5)) & 8388607L);
+ values[valuesOffset++] = (int)(((block20 & 1023L) << 13) | (block21.TripleShift(51)));
+ values[valuesOffset++] = (int)((block21.TripleShift(28)) & 8388607L);
+ values[valuesOffset++] = (int)((block21.TripleShift(5)) & 8388607L);
long block22 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block21 & 31L) << 18) | ((long)((ulong)block22 >> 46)));
- values[valuesOffset++] = (int)(((long)((ulong)block22 >> 23)) & 8388607L);
+ values[valuesOffset++] = (int)(((block21 & 31L) << 18) | (block22.TripleShift(46)));
+ values[valuesOffset++] = (int)((block22.TripleShift(23)) & 8388607L);
values[valuesOffset++] = (int)(block22 & 8388607L);
}
}
@@ -130,31 +132,31 @@ namespace Lucene.Net.Util.Packed
int byte0 = blocks[blocksOffset++] & 0xFF;
int byte1 = blocks[blocksOffset++] & 0xFF;
int byte2 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (byte0 << 15) | (byte1 << 7) | ((int)((uint)byte2 >> 1));
+ values[valuesOffset++] = (byte0 << 15) | (byte1 << 7) | (byte2.TripleShift(1));
int byte3 = blocks[blocksOffset++] & 0xFF;
int byte4 = blocks[blocksOffset++] & 0xFF;
int byte5 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte2 & 1) << 22) | (byte3 << 14) | (byte4 << 6) | ((int)((uint)byte5 >> 2));
+ values[valuesOffset++] = ((byte2 & 1) << 22) | (byte3 << 14) | (byte4 << 6) | (byte5.TripleShift(2));
int byte6 = blocks[blocksOffset++] & 0xFF;
int byte7 = blocks[blocksOffset++] & 0xFF;
int byte8 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte5 & 3) << 21) | (byte6 << 13) | (byte7 << 5) | ((int)((uint)byte8 >> 3));
+ values[valuesOffset++] = ((byte5 & 3) << 21) | (byte6 << 13) | (byte7 << 5) | (byte8.TripleShift(3));
int byte9 = blocks[blocksOffset++] & 0xFF;
int byte10 = blocks[blocksOffset++] & 0xFF;
int byte11 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte8 & 7) << 20) | (byte9 << 12) | (byte10 << 4) | ((int)((uint)byte11 >> 4));
+ values[valuesOffset++] = ((byte8 & 7) << 20) | (byte9 << 12) | (byte10 << 4) | (byte11.TripleShift(4));
int byte12 = blocks[blocksOffset++] & 0xFF;
int byte13 = blocks[blocksOffset++] & 0xFF;
int byte14 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte11 & 15) << 19) | (byte12 << 11) | (byte13 << 3) | ((int)((uint)byte14 >> 5));
+ values[valuesOffset++] = ((byte11 & 15) << 19) | (byte12 << 11) | (byte13 << 3) | (byte14.TripleShift(5));
int byte15 = blocks[blocksOffset++] & 0xFF;
int byte16 = blocks[blocksOffset++] & 0xFF;
int byte17 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte14 & 31) << 18) | (byte15 << 10) | (byte16 << 2) | ((int)((uint)byte17 >> 6));
+ values[valuesOffset++] = ((byte14 & 31) << 18) | (byte15 << 10) | (byte16 << 2) | (byte17.TripleShift(6));
int byte18 = blocks[blocksOffset++] & 0xFF;
int byte19 = blocks[blocksOffset++] & 0xFF;
int byte20 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte17 & 63) << 17) | (byte18 << 9) | (byte19 << 1) | ((int)((uint)byte20 >> 7));
+ values[valuesOffset++] = ((byte17 & 63) << 17) | (byte18 << 9) | (byte19 << 1) | (byte20.TripleShift(7));
int byte21 = blocks[blocksOffset++] & 0xFF;
int byte22 = blocks[blocksOffset++] & 0xFF;
values[valuesOffset++] = ((byte20 & 127) << 16) | (byte21 << 8) | byte22;
@@ -166,91 +168,91 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (long)((ulong)block0 >> 41);
- values[valuesOffset++] = ((long)((ulong)block0 >> 18)) & 8388607L;
+ values[valuesOffset++] = block0.TripleShift(41);
+ values[valuesOffset++] = (block0.TripleShift(18)) & 8388607L;
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block0 & 262143L) << 5) | ((long)((ulong)block1 >> 59));
- values[valuesOffset++] = ((long)((ulong)block1 >> 36)) & 8388607L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 13)) & 8388607L;
+ values[valuesOffset++] = ((block0 & 262143L) << 5) | (block1.TripleShift(59));
+ values[valuesOffset++] = (block1.TripleShift(36)) & 8388607L;
+ values[valuesOffset++] = (block1.TripleShift(13)) & 8388607L;
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block1 & 8191L) << 10) | ((long)((ulong)block2 >> 54));
- values[valuesOffset++] = ((long)((ulong)block2 >> 31)) & 8388607L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 8)) & 8388607L;
+ values[valuesOffset++] = ((block1 & 8191L) << 10) | (block2.TripleShift(54));
+ values[valuesOffset++] = (block2.TripleShift(31)) & 8388607L;
+ values[valuesOffset++] = (block2.TripleShift(8)) & 8388607L;
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block2 & 255L) << 15) | ((long)((ulong)block3 >> 49));
- values[valuesOffset++] = ((long)((ulong)block3 >> 26)) & 8388607L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 3)) & 8388607L;
+ values[valuesOffset++] = ((block2 & 255L) << 15) | (block3.TripleShift(49));
+ values[valuesOffset++] = (block3.TripleShift(26)) & 8388607L;
+ values[valuesOffset++] = (block3.TripleShift(3)) & 8388607L;
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block3 & 7L) << 20) | ((long)((ulong)block4 >> 44));
- values[valuesOffset++] = ((long)((ulong)block4 >> 21)) & 8388607L;
+ values[valuesOffset++] = ((block3 & 7L) << 20) | (block4.TripleShift(44));
+ values[valuesOffset++] = (block4.TripleShift(21)) & 8388607L;
long block5 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block4 & 2097151L) << 2) | ((long)((ulong)block5 >> 62));
- values[valuesOffset++] = ((long)((ulong)block5 >> 39)) & 8388607L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 16)) & 8388607L;
+ values[valuesOffset++] = ((block4 & 2097151L) << 2) | (block5.TripleShift(62));
+ values[valuesOffset++] = (block5.TripleShift(39)) & 8388607L;
+ values[valuesOffset++] = (block5.TripleShift(16)) & 8388607L;
long block6 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block5 & 65535L) << 7) | ((long)((ulong)block6 >> 57));
- values[valuesOffset++] = ((long)((ulong)block6 >> 34)) & 8388607L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 11)) & 8388607L;
+ values[valuesOffset++] = ((block5 & 65535L) << 7) | (block6.TripleShift(57));
+ values[valuesOffset++] = (block6.TripleShift(34)) & 8388607L;
+ values[valuesOffset++] = (block6.TripleShift(11)) & 8388607L;
long block7 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block6 & 2047L) << 12) | ((long)((ulong)block7 >> 52));
- values[valuesOffset++] = ((long)((ulong)block7 >> 29)) & 8388607L;
- values[valuesOffset++] = ((long)((ulong)block7 >> 6)) & 8388607L;
+ values[valuesOffset++] = ((block6 & 2047L) << 12) | (block7.TripleShift(52));
+ values[valuesOffset++] = (block7.TripleShift(29)) & 8388607L;
+ values[valuesOffset++] = (block7.TripleShift(6)) & 8388607L;
long block8 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block7 & 63L) << 17) | ((long)((ulong)block8 >> 47));
- values[valuesOffset++] = ((long)((ulong)block8 >> 24)) & 8388607L;
- values[valuesOffset++] = ((long)((ulong)block8 >> 1)) & 8388607L;
+ values[valuesOffset++] = ((block7 & 63L) << 17) | (block8.TripleShift(47));
+ values[valuesOffset++] = (block8.TripleShift(24)) & 8388607L;
+ values[valuesOffset++] = (block8.TripleShift(1)) & 8388607L;
long block9 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block8 & 1L) << 22) | ((long)((ulong)block9 >> 42));
- values[valuesOffset++] = ((long)((ulong)block9 >> 19)) & 8388607L;
+ values[valuesOffset++] = ((block8 & 1L) << 22) | (block9.TripleShift(42));
+ values[valuesOffset++] = (block9.TripleShift(19)) & 8388607L;
long block10 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block9 & 524287L) << 4) | ((long)((ulong)block10 >> 60));
- values[valuesOffset++] = ((long)((ulong)block10 >> 37)) & 8388607L;
- values[valuesOffset++] = ((long)((ulong)block10 >> 14)) & 8388607L;
+ values[valuesOffset++] = ((block9 & 524287L) << 4) | (block10.TripleShift(60));
+ values[valuesOffset++] = (block10.TripleShift(37)) & 8388607L;
+ values[valuesOffset++] = (block10.TripleShift(14)) & 8388607L;
long block11 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block10 & 16383L) << 9) | ((long)((ulong)block11 >> 55));
- values[valuesOffset++] = ((long)((ulong)block11 >> 32)) & 8388607L;
- values[valuesOffset++] = ((long)((ulong)block11 >> 9)) & 8388607L;
+ values[valuesOffset++] = ((block10 & 16383L) << 9) | (block11.TripleShift(55));
+ values[valuesOffset++] = (block11.TripleShift(32)) & 8388607L;
+ values[valuesOffset++] = (block11.TripleShift(9)) & 8388607L;
long block12 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block11 & 511L) << 14) | ((long)((ulong)block12 >> 50));
- values[valuesOffset++] = ((long)((ulong)block12 >> 27)) & 8388607L;
- values[valuesOffset++] = ((long)((ulong)block12 >> 4)) & 8388607L;
+ values[valuesOffset++] = ((block11 & 511L) << 14) | (block12.TripleShift(50));
+ values[valuesOffset++] = (block12.TripleShift(27)) & 8388607L;
+ values[valuesOffset++] = (block12.TripleShift(4)) & 8388607L;
long block13 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block12 & 15L) << 19) | ((long)((ulong)block13 >> 45));
- values[valuesOffset++] = ((long)((ulong)block13 >> 22)) & 8388607L;
+ values[valuesOffset++] = ((block12 & 15L) << 19) | (block13.TripleShift(45));
+ values[valuesOffset++] = (block13.TripleShift(22)) & 8388607L;
long block14 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block13 & 4194303L) << 1) | ((long)((ulong)block14 >> 63));
- values[valuesOffset++] = ((long)((ulong)block14 >> 40)) & 8388607L;
- values[valuesOffset++] = ((long)((ulong)block14 >> 17)) & 8388607L;
+ values[valuesOffset++] = ((block13 & 4194303L) << 1) | (block14.TripleShift(63));
+ values[valuesOffset++] = (block14.TripleShift(40)) & 8388607L;
+ values[valuesOffset++] = (block14.TripleShift(17)) & 8388607L;
long block15 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block14 & 131071L) << 6) | ((long)((ulong)block15 >> 58));
- values[valuesOffset++] = ((long)((ulong)block15 >> 35)) & 8388607L;
- values[valuesOffset++] = ((long)((ulong)block15 >> 12)) & 8388607L;
+ values[valuesOffset++] = ((block14 & 131071L) << 6) | (block15.TripleShift(58));
+ values[valuesOffset++] = (block15.TripleShift(35)) & 8388607L;
+ values[valuesOffset++] = (block15.TripleShift(12)) & 8388607L;
long block16 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block15 & 4095L) << 11) | ((long)((ulong)block16 >> 53));
- values[valuesOffset++] = ((long)((ulong)block16 >> 30)) & 8388607L;
- values[valuesOffset++] = ((long)((ulong)block16 >> 7)) & 8388607L;
+ values[valuesOffset++] = ((block15 & 4095L) << 11) | (block16.TripleShift(53));
+ values[valuesOffset++] = (block16.TripleShift(30)) & 8388607L;
+ values[valuesOffset++] = (block16.TripleShift(7)) & 8388607L;
long block17 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block16 & 127L) << 16) | ((long)((ulong)block17 >> 48));
- values[valuesOffset++] = ((long)((ulong)block17 >> 25)) & 8388607L;
- values[valuesOffset++] = ((long)((ulong)block17 >> 2)) & 8388607L;
+ values[valuesOffset++] = ((block16 & 127L) << 16) | (block17.TripleShift(48));
+ values[valuesOffset++] = (block17.TripleShift(25)) & 8388607L;
+ values[valuesOffset++] = (block17.TripleShift(2)) & 8388607L;
long block18 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block17 & 3L) << 21) | ((long)((ulong)block18 >> 43));
- values[valuesOffset++] = ((long)((ulong)block18 >> 20)) & 8388607L;
+ values[valuesOffset++] = ((block17 & 3L) << 21) | (block18.TripleShift(43));
+ values[valuesOffset++] = (block18.TripleShift(20)) & 8388607L;
long block19 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block18 & 1048575L) << 3) | ((long)((ulong)block19 >> 61));
- values[valuesOffset++] = ((long)((ulong)block19 >> 38)) & 8388607L;
- values[valuesOffset++] = ((long)((ulong)block19 >> 15)) & 8388607L;
+ values[valuesOffset++] = ((block18 & 1048575L) << 3) | (block19.TripleShift(61));
+ values[valuesOffset++] = (block19.TripleShift(38)) & 8388607L;
+ values[valuesOffset++] = (block19.TripleShift(15)) & 8388607L;
long block20 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block19 & 32767L) << 8) | ((long)((ulong)block20 >> 56));
- values[valuesOffset++] = ((long)((ulong)block20 >> 33)) & 8388607L;
- values[valuesOffset++] = ((long)((ulong)block20 >> 10)) & 8388607L;
+ values[valuesOffset++] = ((block19 & 32767L) << 8) | (block20.TripleShift(56));
+ values[valuesOffset++] = (block20.TripleShift(33)) & 8388607L;
+ values[valuesOffset++] = (block20.TripleShift(10)) & 8388607L;
long block21 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block20 & 1023L) << 13) | ((long)((ulong)block21 >> 51));
- values[valuesOffset++] = ((long)((ulong)block21 >> 28)) & 8388607L;
- values[valuesOffset++] = ((long)((ulong)block21 >> 5)) & 8388607L;
+ values[valuesOffset++] = ((block20 & 1023L) << 13) | (block21.TripleShift(51));
+ values[valuesOffset++] = (block21.TripleShift(28)) & 8388607L;
+ values[valuesOffset++] = (block21.TripleShift(5)) & 8388607L;
long block22 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block21 & 31L) << 18) | ((long)((ulong)block22 >> 46));
- values[valuesOffset++] = ((long)((ulong)block22 >> 23)) & 8388607L;
+ values[valuesOffset++] = ((block21 & 31L) << 18) | (block22.TripleShift(46));
+ values[valuesOffset++] = (block22.TripleShift(23)) & 8388607L;
values[valuesOffset++] = block22 & 8388607L;
}
}
@@ -262,31 +264,31 @@ namespace Lucene.Net.Util.Packed
long byte0 = blocks[blocksOffset++] & 0xFF;
long byte1 = blocks[blocksOffset++] & 0xFF;
long byte2 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (byte0 << 15) | (byte1 << 7) | ((long)((ulong)byte2 >> 1));
+ values[valuesOffset++] = (byte0 << 15) | (byte1 << 7) | (byte2.TripleShift(1));
long byte3 = blocks[blocksOffset++] & 0xFF;
long byte4 = blocks[blocksOffset++] & 0xFF;
long byte5 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte2 & 1) << 22) | (byte3 << 14) | (byte4 << 6) | ((long)((ulong)byte5 >> 2));
+ values[valuesOffset++] = ((byte2 & 1) << 22) | (byte3 << 14) | (byte4 << 6) | (byte5.TripleShift(2));
long byte6 = blocks[blocksOffset++] & 0xFF;
long byte7 = blocks[blocksOffset++] & 0xFF;
long byte8 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte5 & 3) << 21) | (byte6 << 13) | (byte7 << 5) | ((long)((ulong)byte8 >> 3));
+ values[valuesOffset++] = ((byte5 & 3) << 21) | (byte6 << 13) | (byte7 << 5) | (byte8.TripleShift(3));
long byte9 = blocks[blocksOffset++] & 0xFF;
long byte10 = blocks[blocksOffset++] & 0xFF;
long byte11 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte8 & 7) << 20) | (byte9 << 12) | (byte10 << 4) | ((long)((ulong)byte11 >> 4));
+ values[valuesOffset++] = ((byte8 & 7) << 20) | (byte9 << 12) | (byte10 << 4) | (byte11.TripleShift(4));
long byte12 = blocks[blocksOffset++] & 0xFF;
long byte13 = blocks[blocksOffset++] & 0xFF;
long byte14 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte11 & 15) << 19) | (byte12 << 11) | (byte13 << 3) | ((long)((ulong)byte14 >> 5));
+ values[valuesOffset++] = ((byte11 & 15) << 19) | (byte12 << 11) | (byte13 << 3) | (byte14.TripleShift(5));
long byte15 = blocks[blocksOffset++] & 0xFF;
long byte16 = blocks[blocksOffset++] & 0xFF;
long byte17 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte14 & 31) << 18) | (byte15 << 10) | (byte16 << 2) | ((long)((ulong)byte17 >> 6));
+ values[valuesOffset++] = ((byte14 & 31) << 18) | (byte15 << 10) | (byte16 << 2) | (byte17.TripleShift(6));
long byte18 = blocks[blocksOffset++] & 0xFF;
long byte19 = blocks[blocksOffset++] & 0xFF;
long byte20 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte17 & 63) << 17) | (byte18 << 9) | (byte19 << 1) | ((long)((ulong)byte20 >> 7));
+ values[valuesOffset++] = ((byte17 & 63) << 17) | (byte18 << 9) | (byte19 << 1) | (byte20.TripleShift(7));
long byte21 = blocks[blocksOffset++] & 0xFF;
long byte22 = blocks[blocksOffset++] & 0xFF;
values[valuesOffset++] = ((byte20 & 127) << 16) | (byte21 << 8) | byte22;
diff --git a/src/Lucene.Net/Util/Packed/BulkOperationPacked24.cs b/src/Lucene.Net/Util/Packed/BulkOperationPacked24.cs
index c8178c3..a6be910 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperationPacked24.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperationPacked24.cs
@@ -1,4 +1,6 @@
-// this file has been automatically generated, DO NOT EDIT
+// this file has been automatically generated, DO NOT EDIT
+
+using J2N.Numerics;
namespace Lucene.Net.Util.Packed
{
@@ -34,15 +36,15 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)((long)((ulong)block0 >> 40));
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 16)) & 16777215L);
+ values[valuesOffset++] = (int)(block0.TripleShift(40));
+ values[valuesOffset++] = (int)((block0.TripleShift(16)) & 16777215L);
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block0 & 65535L) << 8) | ((long)((ulong)block1 >> 56)));
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 32)) & 16777215L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 8)) & 16777215L);
+ values[valuesOffset++] = (int)(((block0 & 65535L) << 8) | (block1.TripleShift(56)));
+ values[valuesOffset++] = (int)((block1.TripleShift(32)) & 16777215L);
+ values[valuesOffset++] = (int)((block1.TripleShift(8)) & 16777215L);
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block1 & 255L) << 16) | ((long)((ulong)block2 >> 48)));
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 24)) & 16777215L);
+ values[valuesOffset++] = (int)(((block1 & 255L) << 16) | (block2.TripleShift(48)));
+ values[valuesOffset++] = (int)((block2.TripleShift(24)) & 16777215L);
values[valuesOffset++] = (int)(block2 & 16777215L);
}
}
@@ -63,15 +65,15 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (long)((ulong)block0 >> 40);
- values[valuesOffset++] = ((long)((ulong)block0 >> 16)) & 16777215L;
+ values[valuesOffset++] = block0.TripleShift(40);
+ values[valuesOffset++] = (block0.TripleShift(16)) & 16777215L;
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block0 & 65535L) << 8) | ((long)((ulong)block1 >> 56));
- values[valuesOffset++] = ((long)((ulong)block1 >> 32)) & 16777215L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 8)) & 16777215L;
+ values[valuesOffset++] = ((block0 & 65535L) << 8) | (block1.TripleShift(56));
+ values[valuesOffset++] = (block1.TripleShift(32)) & 16777215L;
+ values[valuesOffset++] = (block1.TripleShift(8)) & 16777215L;
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block1 & 255L) << 16) | ((long)((ulong)block2 >> 48));
- values[valuesOffset++] = ((long)((ulong)block2 >> 24)) & 16777215L;
+ values[valuesOffset++] = ((block1 & 255L) << 16) | (block2.TripleShift(48));
+ values[valuesOffset++] = (block2.TripleShift(24)) & 16777215L;
values[valuesOffset++] = block2 & 16777215L;
}
}
diff --git a/src/Lucene.Net/Util/Packed/BulkOperationPacked3.cs b/src/Lucene.Net/Util/Packed/BulkOperationPacked3.cs
index ab99609..da6c1d7 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperationPacked3.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperationPacked3.cs
@@ -1,4 +1,6 @@
-// this file has been automatically generated, DO NOT EDIT
+// this file has been automatically generated, DO NOT EDIT
+
+using J2N.Numerics;
namespace Lucene.Net.Util.Packed
{
@@ -34,71 +36,71 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)((long)((ulong)block0 >> 61));
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 58)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 55)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 52)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 49)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 46)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 43)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 40)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 37)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 34)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 31)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 28)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 25)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 22)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 19)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 16)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 13)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 10)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 7)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 4)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 1)) & 7L);
+ values[valuesOffset++] = (int)(block0.TripleShift(61));
+ values[valuesOffset++] = (int)((block0.TripleShift(58)) & 7L);
+ values[valuesOffset++] = (int)((block0.TripleShift(55)) & 7L);
+ values[valuesOffset++] = (int)((block0.TripleShift(52)) & 7L);
+ values[valuesOffset++] = (int)((block0.TripleShift(49)) & 7L);
+ values[valuesOffset++] = (int)((block0.TripleShift(46)) & 7L);
+ values[valuesOffset++] = (int)((block0.TripleShift(43)) & 7L);
+ values[valuesOffset++] = (int)((block0.TripleShift(40)) & 7L);
+ values[valuesOffset++] = (int)((block0.TripleShift(37)) & 7L);
+ values[valuesOffset++] = (int)((block0.TripleShift(34)) & 7L);
+ values[valuesOffset++] = (int)((block0.TripleShift(31)) & 7L);
+ values[valuesOffset++] = (int)((block0.TripleShift(28)) & 7L);
+ values[valuesOffset++] = (int)((block0.TripleShift(25)) & 7L);
+ values[valuesOffset++] = (int)((block0.TripleShift(22)) & 7L);
+ values[valuesOffset++] = (int)((block0.TripleShift(19)) & 7L);
+ values[valuesOffset++] = (int)((block0.TripleShift(16)) & 7L);
+ values[valuesOffset++] = (int)((block0.TripleShift(13)) & 7L);
+ values[valuesOffset++] = (int)((block0.TripleShift(10)) & 7L);
+ values[valuesOffset++] = (int)((block0.TripleShift(7)) & 7L);
+ values[valuesOffset++] = (int)((block0.TripleShift(4)) & 7L);
+ values[valuesOffset++] = (int)((block0.TripleShift(1)) & 7L);
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block0 & 1L) << 2) | ((long)((ulong)block1 >> 62)));
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 59)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 56)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 53)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 50)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 47)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 44)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 41)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 38)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 35)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 32)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 29)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 26)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 23)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 20)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 17)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 14)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 11)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 8)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 5)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 2)) & 7L);
+ values[valuesOffset++] = (int)(((block0 & 1L) << 2) | (block1.TripleShift(62)));
+ values[valuesOffset++] = (int)((block1.TripleShift(59)) & 7L);
+ values[valuesOffset++] = (int)((block1.TripleShift(56)) & 7L);
+ values[valuesOffset++] = (int)((block1.TripleShift(53)) & 7L);
+ values[valuesOffset++] = (int)((block1.TripleShift(50)) & 7L);
+ values[valuesOffset++] = (int)((block1.TripleShift(47)) & 7L);
+ values[valuesOffset++] = (int)((block1.TripleShift(44)) & 7L);
+ values[valuesOffset++] = (int)((block1.TripleShift(41)) & 7L);
+ values[valuesOffset++] = (int)((block1.TripleShift(38)) & 7L);
+ values[valuesOffset++] = (int)((block1.TripleShift(35)) & 7L);
+ values[valuesOffset++] = (int)((block1.TripleShift(32)) & 7L);
+ values[valuesOffset++] = (int)((block1.TripleShift(29)) & 7L);
+ values[valuesOffset++] = (int)((block1.TripleShift(26)) & 7L);
+ values[valuesOffset++] = (int)((block1.TripleShift(23)) & 7L);
+ values[valuesOffset++] = (int)((block1.TripleShift(20)) & 7L);
+ values[valuesOffset++] = (int)((block1.TripleShift(17)) & 7L);
+ values[valuesOffset++] = (int)((block1.TripleShift(14)) & 7L);
+ values[valuesOffset++] = (int)((block1.TripleShift(11)) & 7L);
+ values[valuesOffset++] = (int)((block1.TripleShift(8)) & 7L);
+ values[valuesOffset++] = (int)((block1.TripleShift(5)) & 7L);
+ values[valuesOffset++] = (int)((block1.TripleShift(2)) & 7L);
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block1 & 3L) << 1) | ((long)((ulong)block2 >> 63)));
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 60)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 57)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 54)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 51)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 48)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 45)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 42)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 39)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 36)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 33)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 30)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 27)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 24)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 21)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 18)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 15)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 12)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 9)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 6)) & 7L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 3)) & 7L);
+ values[valuesOffset++] = (int)(((block1 & 3L) << 1) | (block2.TripleShift(63)));
+ values[valuesOffset++] = (int)((block2.TripleShift(60)) & 7L);
+ values[valuesOffset++] = (int)((block2.TripleShift(57)) & 7L);
+ values[valuesOffset++] = (int)((block2.TripleShift(54)) & 7L);
+ values[valuesOffset++] = (int)((block2.TripleShift(51)) & 7L);
+ values[valuesOffset++] = (int)((block2.TripleShift(48)) & 7L);
+ values[valuesOffset++] = (int)((block2.TripleShift(45)) & 7L);
+ values[valuesOffset++] = (int)((block2.TripleShift(42)) & 7L);
+ values[valuesOffset++] = (int)((block2.TripleShift(39)) & 7L);
+ values[valuesOffset++] = (int)((block2.TripleShift(36)) & 7L);
+ values[valuesOffset++] = (int)((block2.TripleShift(33)) & 7L);
+ values[valuesOffset++] = (int)((block2.TripleShift(30)) & 7L);
+ values[valuesOffset++] = (int)((block2.TripleShift(27)) & 7L);
+ values[valuesOffset++] = (int)((block2.TripleShift(24)) & 7L);
+ values[valuesOffset++] = (int)((block2.TripleShift(21)) & 7L);
+ values[valuesOffset++] = (int)((block2.TripleShift(18)) & 7L);
+ values[valuesOffset++] = (int)((block2.TripleShift(15)) & 7L);
+ values[valuesOffset++] = (int)((block2.TripleShift(12)) & 7L);
+ values[valuesOffset++] = (int)((block2.TripleShift(9)) & 7L);
+ values[valuesOffset++] = (int)((block2.TripleShift(6)) & 7L);
+ values[valuesOffset++] = (int)((block2.TripleShift(3)) & 7L);
values[valuesOffset++] = (int)(block2 & 7L);
}
}
@@ -108,15 +110,15 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
int byte0 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (int)((uint)byte0 >> 5);
- values[valuesOffset++] = ((int)((uint)byte0 >> 2)) & 7;
+ values[valuesOffset++] = byte0.TripleShift(5);
+ values[valuesOffset++] = (byte0.TripleShift(2)) & 7;
int byte1 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte0 & 3) << 1) | ((int)((uint)byte1 >> 7));
- values[valuesOffset++] = ((int)((uint)byte1 >> 4)) & 7;
- values[valuesOffset++] = ((int)((uint)byte1 >> 1)) & 7;
+ values[valuesOffset++] = ((byte0 & 3) << 1) | (byte1.TripleShift(7));
+ values[valuesOffset++] = (byte1.TripleShift(4)) & 7;
+ values[valuesOffset++] = (byte1.TripleShift(1)) & 7;
int byte2 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte1 & 1) << 2) | ((int)((uint)byte2 >> 6));
- values[valuesOffset++] = ((int)((uint)byte2 >> 3)) & 7;
+ values[valuesOffset++] = ((byte1 & 1) << 2) | (byte2.TripleShift(6));
+ values[valuesOffset++] = (byte2.TripleShift(3)) & 7;
values[valuesOffset++] = byte2 & 7;
}
}
@@ -126,71 +128,71 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (long)((ulong)block0 >> 61);
- values[valuesOffset++] = ((long)((ulong)block0 >> 58)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 55)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 52)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 49)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 46)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 43)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 40)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 37)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 34)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 31)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 28)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 25)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 22)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 19)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 16)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 13)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 10)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 7)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 4)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 1)) & 7L;
+ values[valuesOffset++] = block0.TripleShift(61);
+ values[valuesOffset++] = (block0.TripleShift(58)) & 7L;
+ values[valuesOffset++] = (block0.TripleShift(55)) & 7L;
+ values[valuesOffset++] = (block0.TripleShift(52)) & 7L;
+ values[valuesOffset++] = (block0.TripleShift(49)) & 7L;
+ values[valuesOffset++] = (block0.TripleShift(46)) & 7L;
+ values[valuesOffset++] = (block0.TripleShift(43)) & 7L;
+ values[valuesOffset++] = (block0.TripleShift(40)) & 7L;
+ values[valuesOffset++] = (block0.TripleShift(37)) & 7L;
+ values[valuesOffset++] = (block0.TripleShift(34)) & 7L;
+ values[valuesOffset++] = (block0.TripleShift(31)) & 7L;
+ values[valuesOffset++] = (block0.TripleShift(28)) & 7L;
+ values[valuesOffset++] = (block0.TripleShift(25)) & 7L;
+ values[valuesOffset++] = (block0.TripleShift(22)) & 7L;
+ values[valuesOffset++] = (block0.TripleShift(19)) & 7L;
+ values[valuesOffset++] = (block0.TripleShift(16)) & 7L;
+ values[valuesOffset++] = (block0.TripleShift(13)) & 7L;
+ values[valuesOffset++] = (block0.TripleShift(10)) & 7L;
+ values[valuesOffset++] = (block0.TripleShift(7)) & 7L;
+ values[valuesOffset++] = (block0.TripleShift(4)) & 7L;
+ values[valuesOffset++] = (block0.TripleShift(1)) & 7L;
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block0 & 1L) << 2) | ((long)((ulong)block1 >> 62));
- values[valuesOffset++] = ((long)((ulong)block1 >> 59)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 56)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 53)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 50)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 47)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 44)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 41)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 38)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 35)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 32)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 29)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 26)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 23)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 20)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 17)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 14)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 11)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 8)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 5)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 2)) & 7L;
+ values[valuesOffset++] = ((block0 & 1L) << 2) | (block1.TripleShift(62));
+ values[valuesOffset++] = (block1.TripleShift(59)) & 7L;
+ values[valuesOffset++] = (block1.TripleShift(56)) & 7L;
+ values[valuesOffset++] = (block1.TripleShift(53)) & 7L;
+ values[valuesOffset++] = (block1.TripleShift(50)) & 7L;
+ values[valuesOffset++] = (block1.TripleShift(47)) & 7L;
+ values[valuesOffset++] = (block1.TripleShift(44)) & 7L;
+ values[valuesOffset++] = (block1.TripleShift(41)) & 7L;
+ values[valuesOffset++] = (block1.TripleShift(38)) & 7L;
+ values[valuesOffset++] = (block1.TripleShift(35)) & 7L;
+ values[valuesOffset++] = (block1.TripleShift(32)) & 7L;
+ values[valuesOffset++] = (block1.TripleShift(29)) & 7L;
+ values[valuesOffset++] = (block1.TripleShift(26)) & 7L;
+ values[valuesOffset++] = (block1.TripleShift(23)) & 7L;
+ values[valuesOffset++] = (block1.TripleShift(20)) & 7L;
+ values[valuesOffset++] = (block1.TripleShift(17)) & 7L;
+ values[valuesOffset++] = (block1.TripleShift(14)) & 7L;
+ values[valuesOffset++] = (block1.TripleShift(11)) & 7L;
+ values[valuesOffset++] = (block1.TripleShift(8)) & 7L;
+ values[valuesOffset++] = (block1.TripleShift(5)) & 7L;
+ values[valuesOffset++] = (block1.TripleShift(2)) & 7L;
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block1 & 3L) << 1) | ((long)((ulong)block2 >> 63));
- values[valuesOffset++] = ((long)((ulong)block2 >> 60)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 57)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 54)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 51)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 48)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 45)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 42)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 39)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 36)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 33)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 30)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 27)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 24)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 21)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 18)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 15)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 12)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 9)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 6)) & 7L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 3)) & 7L;
+ values[valuesOffset++] = ((block1 & 3L) << 1) | (block2.TripleShift(63));
+ values[valuesOffset++] = (block2.TripleShift(60)) & 7L;
+ values[valuesOffset++] = (block2.TripleShift(57)) & 7L;
+ values[valuesOffset++] = (block2.TripleShift(54)) & 7L;
+ values[valuesOffset++] = (block2.TripleShift(51)) & 7L;
+ values[valuesOffset++] = (block2.TripleShift(48)) & 7L;
+ values[valuesOffset++] = (block2.TripleShift(45)) & 7L;
+ values[valuesOffset++] = (block2.TripleShift(42)) & 7L;
+ values[valuesOffset++] = (block2.TripleShift(39)) & 7L;
+ values[valuesOffset++] = (block2.TripleShift(36)) & 7L;
+ values[valuesOffset++] = (block2.TripleShift(33)) & 7L;
+ values[valuesOffset++] = (block2.TripleShift(30)) & 7L;
+ values[valuesOffset++] = (block2.TripleShift(27)) & 7L;
+ values[valuesOffset++] = (block2.TripleShift(24)) & 7L;
+ values[valuesOffset++] = (block2.TripleShift(21)) & 7L;
+ values[valuesOffset++] = (block2.TripleShift(18)) & 7L;
+ values[valuesOffset++] = (block2.TripleShift(15)) & 7L;
+ values[valuesOffset++] = (block2.TripleShift(12)) & 7L;
+ values[valuesOffset++] = (block2.TripleShift(9)) & 7L;
+ values[valuesOffset++] = (block2.TripleShift(6)) & 7L;
+ values[valuesOffset++] = (block2.TripleShift(3)) & 7L;
values[valuesOffset++] = block2 & 7L;
}
}
@@ -200,15 +202,15 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long byte0 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (long)((ulong)byte0 >> 5);
- values[valuesOffset++] = ((long)((ulong)byte0 >> 2)) & 7;
+ values[valuesOffset++] = byte0.TripleShift(5);
+ values[valuesOffset++] = (byte0.TripleShift(2)) & 7;
long byte1 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte0 & 3) << 1) | ((long)((ulong)byte1 >> 7));
- values[valuesOffset++] = ((long)((ulong)byte1 >> 4)) & 7;
- values[valuesOffset++] = ((long)((ulong)byte1 >> 1)) & 7;
+ values[valuesOffset++] = ((byte0 & 3) << 1) | (byte1.TripleShift(7));
+ values[valuesOffset++] = (byte1.TripleShift(4)) & 7;
+ values[valuesOffset++] = (byte1.TripleShift(1)) & 7;
long byte2 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte1 & 1) << 2) | ((long)((ulong)byte2 >> 6));
- values[valuesOffset++] = ((long)((ulong)byte2 >> 3)) & 7;
+ values[valuesOffset++] = ((byte1 & 1) << 2) | (byte2.TripleShift(6));
+ values[valuesOffset++] = (byte2.TripleShift(3)) & 7;
values[valuesOffset++] = byte2 & 7;
}
}
diff --git a/src/Lucene.Net/Util/Packed/BulkOperationPacked4.cs b/src/Lucene.Net/Util/Packed/BulkOperationPacked4.cs
index 0c5279e..28f1c34 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperationPacked4.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperationPacked4.cs
@@ -1,4 +1,6 @@
-// this file has been automatically generated, DO NOT EDIT
+// this file has been automatically generated, DO NOT EDIT
+
+using J2N.Numerics;
namespace Lucene.Net.Util.Packed
{
@@ -36,7 +38,7 @@ namespace Lucene.Net.Util.Packed
long block = blocks[blocksOffset++];
for (int shift = 60; shift >= 0; shift -= 4)
{
- values[valuesOffset++] = (int)(((long)((ulong)block >> shift)) & 15);
+ values[valuesOffset++] = (int)((block.TripleShift(shift)) & 15);
}
}
}
@@ -46,7 +48,7 @@ namespace Lucene.Net.Util.Packed
for (int j = 0; j < iterations; ++j)
{
var block = blocks[blocksOffset++];
- values[valuesOffset++] = ((int)((uint)block >> 4)) & 15;
+ values[valuesOffset++] = (block.TripleShift(4)) & 15;
values[valuesOffset++] = block & 15;
}
}
@@ -58,7 +60,7 @@ namespace Lucene.Net.Util.Packed
long block = blocks[blocksOffset++];
for (int shift = 60; shift >= 0; shift -= 4)
{
- values[valuesOffset++] = ((long)((ulong)block >> shift)) & 15;
+ values[valuesOffset++] = (block.TripleShift(shift)) & 15;
}
}
}
@@ -68,7 +70,7 @@ namespace Lucene.Net.Util.Packed
for (int j = 0; j < iterations; ++j)
{
var block = blocks[blocksOffset++];
- values[valuesOffset++] = ((int)((uint)block >> 4)) & 15;
+ values[valuesOffset++] = (block.TripleShift(4)) & 15;
values[valuesOffset++] = block & 15;
}
}
diff --git a/src/Lucene.Net/Util/Packed/BulkOperationPacked5.cs b/src/Lucene.Net/Util/Packed/BulkOperationPacked5.cs
index ff32c4f..5478aca 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperationPacked5.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperationPacked5.cs
@@ -1,4 +1,6 @@
-// this file has been automatically generated, DO NOT EDIT
+// this file has been automatically generated, DO NOT EDIT
+
+using J2N.Numerics;
namespace Lucene.Net.Util.Packed
{
@@ -34,73 +36,73 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)((long)((ulong)block0 >> 59));
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 54)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 49)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 44)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 39)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 34)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 29)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 24)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 19)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 14)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 9)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 4)) & 31L);
+ values[valuesOffset++] = (int)(block0.TripleShift(59));
+ values[valuesOffset++] = (int)((block0.TripleShift(54)) & 31L);
+ values[valuesOffset++] = (int)((block0.TripleShift(49)) & 31L);
+ values[valuesOffset++] = (int)((block0.TripleShift(44)) & 31L);
+ values[valuesOffset++] = (int)((block0.TripleShift(39)) & 31L);
+ values[valuesOffset++] = (int)((block0.TripleShift(34)) & 31L);
+ values[valuesOffset++] = (int)((block0.TripleShift(29)) & 31L);
+ values[valuesOffset++] = (int)((block0.TripleShift(24)) & 31L);
+ values[valuesOffset++] = (int)((block0.TripleShift(19)) & 31L);
+ values[valuesOffset++] = (int)((block0.TripleShift(14)) & 31L);
+ values[valuesOffset++] = (int)((block0.TripleShift(9)) & 31L);
+ values[valuesOffset++] = (int)((block0.TripleShift(4)) & 31L);
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block0 & 15L) << 1) | ((long)((ulong)block1 >> 63)));
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 58)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 53)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 48)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 43)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 38)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 33)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 28)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 23)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 18)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 13)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 8)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 3)) & 31L);
+ values[valuesOffset++] = (int)(((block0 & 15L) << 1) | (block1.TripleShift(63)));
+ values[valuesOffset++] = (int)((block1.TripleShift(58)) & 31L);
+ values[valuesOffset++] = (int)((block1.TripleShift(53)) & 31L);
+ values[valuesOffset++] = (int)((block1.TripleShift(48)) & 31L);
+ values[valuesOffset++] = (int)((block1.TripleShift(43)) & 31L);
+ values[valuesOffset++] = (int)((block1.TripleShift(38)) & 31L);
+ values[valuesOffset++] = (int)((block1.TripleShift(33)) & 31L);
+ values[valuesOffset++] = (int)((block1.TripleShift(28)) & 31L);
+ values[valuesOffset++] = (int)((block1.TripleShift(23)) & 31L);
+ values[valuesOffset++] = (int)((block1.TripleShift(18)) & 31L);
+ values[valuesOffset++] = (int)((block1.TripleShift(13)) & 31L);
+ values[valuesOffset++] = (int)((block1.TripleShift(8)) & 31L);
+ values[valuesOffset++] = (int)((block1.TripleShift(3)) & 31L);
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block1 & 7L) << 2) | ((long)((ulong)block2 >> 62)));
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 57)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 52)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 47)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 42)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 37)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 32)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 27)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 22)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 17)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 12)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 7)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 2)) & 31L);
+ values[valuesOffset++] = (int)(((block1 & 7L) << 2) | (block2.TripleShift(62)));
+ values[valuesOffset++] = (int)((block2.TripleShift(57)) & 31L);
+ values[valuesOffset++] = (int)((block2.TripleShift(52)) & 31L);
+ values[valuesOffset++] = (int)((block2.TripleShift(47)) & 31L);
+ values[valuesOffset++] = (int)((block2.TripleShift(42)) & 31L);
+ values[valuesOffset++] = (int)((block2.TripleShift(37)) & 31L);
+ values[valuesOffset++] = (int)((block2.TripleShift(32)) & 31L);
+ values[valuesOffset++] = (int)((block2.TripleShift(27)) & 31L);
+ values[valuesOffset++] = (int)((block2.TripleShift(22)) & 31L);
+ values[valuesOffset++] = (int)((block2.TripleShift(17)) & 31L);
+ values[valuesOffset++] = (int)((block2.TripleShift(12)) & 31L);
+ values[valuesOffset++] = (int)((block2.TripleShift(7)) & 31L);
+ values[valuesOffset++] = (int)((block2.TripleShift(2)) & 31L);
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block2 & 3L) << 3) | ((long)((ulong)block3 >> 61)));
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 56)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 51)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 46)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 41)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 36)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 31)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 26)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 21)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 16)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 11)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 6)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 1)) & 31L);
+ values[valuesOffset++] = (int)(((block2 & 3L) << 3) | (block3.TripleShift(61)));
+ values[valuesOffset++] = (int)((block3.TripleShift(56)) & 31L);
+ values[valuesOffset++] = (int)((block3.TripleShift(51)) & 31L);
+ values[valuesOffset++] = (int)((block3.TripleShift(46)) & 31L);
+ values[valuesOffset++] = (int)((block3.TripleShift(41)) & 31L);
+ values[valuesOffset++] = (int)((block3.TripleShift(36)) & 31L);
+ values[valuesOffset++] = (int)((block3.TripleShift(31)) & 31L);
+ values[valuesOffset++] = (int)((block3.TripleShift(26)) & 31L);
+ values[valuesOffset++] = (int)((block3.TripleShift(21)) & 31L);
+ values[valuesOffset++] = (int)((block3.TripleShift(16)) & 31L);
+ values[valuesOffset++] = (int)((block3.TripleShift(11)) & 31L);
+ values[valuesOffset++] = (int)((block3.TripleShift(6)) & 31L);
+ values[valuesOffset++] = (int)((block3.TripleShift(1)) & 31L);
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block3 & 1L) << 4) | ((long)((ulong)block4 >> 60)));
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 55)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 50)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 45)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 40)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 35)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 30)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 25)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 20)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 15)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 10)) & 31L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 5)) & 31L);
+ values[valuesOffset++] = (int)(((block3 & 1L) << 4) | (block4.TripleShift(60)));
+ values[valuesOffset++] = (int)((block4.TripleShift(55)) & 31L);
+ values[valuesOffset++] = (int)((block4.TripleShift(50)) & 31L);
+ values[valuesOffset++] = (int)((block4.TripleShift(45)) & 31L);
+ values[valuesOffset++] = (int)((block4.TripleShift(40)) & 31L);
+ values[valuesOffset++] = (int)((block4.TripleShift(35)) & 31L);
+ values[valuesOffset++] = (int)((block4.TripleShift(30)) & 31L);
+ values[valuesOffset++] = (int)((block4.TripleShift(25)) & 31L);
+ values[valuesOffset++] = (int)((block4.TripleShift(20)) & 31L);
+ values[valuesOffset++] = (int)((block4.TripleShift(15)) & 31L);
+ values[valuesOffset++] = (int)((block4.TripleShift(10)) & 31L);
+ values[valuesOffset++] = (int)((block4.TripleShift(5)) & 31L);
values[valuesOffset++] = (int)(block4 & 31L);
}
}
@@ -110,17 +112,17 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
int byte0 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (int)((uint)byte0 >> 3);
+ values[valuesOffset++] = byte0.TripleShift(3);
int byte1 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte0 & 7) << 2) | ((int)((uint)byte1 >> 6));
- values[valuesOffset++] = ((int)((uint)byte1 >> 1)) & 31;
+ values[valuesOffset++] = ((byte0 & 7) << 2) | (byte1.TripleShift(6));
+ values[valuesOffset++] = (byte1.TripleShift(1)) & 31;
int byte2 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte1 & 1) << 4) | ((int)((uint)byte2 >> 4));
+ values[valuesOffset++] = ((byte1 & 1) << 4) | (byte2.TripleShift(4));
int byte3 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte2 & 15) << 1) | ((int)((uint)byte3 >> 7));
- values[valuesOffset++] = ((int)((uint)byte3 >> 2)) & 31;
+ values[valuesOffset++] = ((byte2 & 15) << 1) | (byte3.TripleShift(7));
+ values[valuesOffset++] = (byte3.TripleShift(2)) & 31;
int byte4 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte3 & 3) << 3) | ((int)((uint)byte4 >> 5));
+ values[valuesOffset++] = ((byte3 & 3) << 3) | (byte4.TripleShift(5));
values[valuesOffset++] = byte4 & 31;
}
}
@@ -130,73 +132,73 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (long)((ulong)block0 >> 59);
- values[valuesOffset++] = ((long)((ulong)block0 >> 54)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 49)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 44)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 39)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 34)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 29)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 24)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 19)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 14)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 9)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 4)) & 31L;
+ values[valuesOffset++] = block0.TripleShift(59);
+ values[valuesOffset++] = (block0.TripleShift(54)) & 31L;
+ values[valuesOffset++] = (block0.TripleShift(49)) & 31L;
+ values[valuesOffset++] = (block0.TripleShift(44)) & 31L;
+ values[valuesOffset++] = (block0.TripleShift(39)) & 31L;
+ values[valuesOffset++] = (block0.TripleShift(34)) & 31L;
+ values[valuesOffset++] = (block0.TripleShift(29)) & 31L;
+ values[valuesOffset++] = (block0.TripleShift(24)) & 31L;
+ values[valuesOffset++] = (block0.TripleShift(19)) & 31L;
+ values[valuesOffset++] = (block0.TripleShift(14)) & 31L;
+ values[valuesOffset++] = (block0.TripleShift(9)) & 31L;
+ values[valuesOffset++] = (block0.TripleShift(4)) & 31L;
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block0 & 15L) << 1) | ((long)((ulong)block1 >> 63));
- values[valuesOffset++] = ((long)((ulong)block1 >> 58)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 53)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 48)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 43)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 38)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 33)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 28)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 23)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 18)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 13)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 8)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 3)) & 31L;
+ values[valuesOffset++] = ((block0 & 15L) << 1) | (block1.TripleShift(63));
+ values[valuesOffset++] = (block1.TripleShift(58)) & 31L;
+ values[valuesOffset++] = (block1.TripleShift(53)) & 31L;
+ values[valuesOffset++] = (block1.TripleShift(48)) & 31L;
+ values[valuesOffset++] = (block1.TripleShift(43)) & 31L;
+ values[valuesOffset++] = (block1.TripleShift(38)) & 31L;
+ values[valuesOffset++] = (block1.TripleShift(33)) & 31L;
+ values[valuesOffset++] = (block1.TripleShift(28)) & 31L;
+ values[valuesOffset++] = (block1.TripleShift(23)) & 31L;
+ values[valuesOffset++] = (block1.TripleShift(18)) & 31L;
+ values[valuesOffset++] = (block1.TripleShift(13)) & 31L;
+ values[valuesOffset++] = (block1.TripleShift(8)) & 31L;
+ values[valuesOffset++] = (block1.TripleShift(3)) & 31L;
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block1 & 7L) << 2) | ((long)((ulong)block2 >> 62));
- values[valuesOffset++] = ((long)((ulong)block2 >> 57)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 52)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 47)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 42)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 37)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 32)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 27)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 22)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 17)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 12)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 7)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 2)) & 31L;
+ values[valuesOffset++] = ((block1 & 7L) << 2) | (block2.TripleShift(62));
+ values[valuesOffset++] = (block2.TripleShift(57)) & 31L;
+ values[valuesOffset++] = (block2.TripleShift(52)) & 31L;
+ values[valuesOffset++] = (block2.TripleShift(47)) & 31L;
+ values[valuesOffset++] = (block2.TripleShift(42)) & 31L;
+ values[valuesOffset++] = (block2.TripleShift(37)) & 31L;
+ values[valuesOffset++] = (block2.TripleShift(32)) & 31L;
+ values[valuesOffset++] = (block2.TripleShift(27)) & 31L;
+ values[valuesOffset++] = (block2.TripleShift(22)) & 31L;
+ values[valuesOffset++] = (block2.TripleShift(17)) & 31L;
+ values[valuesOffset++] = (block2.TripleShift(12)) & 31L;
+ values[valuesOffset++] = (block2.TripleShift(7)) & 31L;
+ values[valuesOffset++] = (block2.TripleShift(2)) & 31L;
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block2 & 3L) << 3) | ((long)((ulong)block3 >> 61));
- values[valuesOffset++] = ((long)((ulong)block3 >> 56)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 51)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 46)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 41)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 36)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 31)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 26)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 21)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 16)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 11)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 6)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 1)) & 31L;
+ values[valuesOffset++] = ((block2 & 3L) << 3) | (block3.TripleShift(61));
+ values[valuesOffset++] = (block3.TripleShift(56)) & 31L;
+ values[valuesOffset++] = (block3.TripleShift(51)) & 31L;
+ values[valuesOffset++] = (block3.TripleShift(46)) & 31L;
+ values[valuesOffset++] = (block3.TripleShift(41)) & 31L;
+ values[valuesOffset++] = (block3.TripleShift(36)) & 31L;
+ values[valuesOffset++] = (block3.TripleShift(31)) & 31L;
+ values[valuesOffset++] = (block3.TripleShift(26)) & 31L;
+ values[valuesOffset++] = (block3.TripleShift(21)) & 31L;
+ values[valuesOffset++] = (block3.TripleShift(16)) & 31L;
+ values[valuesOffset++] = (block3.TripleShift(11)) & 31L;
+ values[valuesOffset++] = (block3.TripleShift(6)) & 31L;
+ values[valuesOffset++] = (block3.TripleShift(1)) & 31L;
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block3 & 1L) << 4) | ((long)((ulong)block4 >> 60));
- values[valuesOffset++] = ((long)((ulong)block4 >> 55)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 50)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 45)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 40)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 35)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 30)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 25)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 20)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 15)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 10)) & 31L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 5)) & 31L;
+ values[valuesOffset++] = ((block3 & 1L) << 4) | (block4.TripleShift(60));
+ values[valuesOffset++] = (block4.TripleShift(55)) & 31L;
+ values[valuesOffset++] = (block4.TripleShift(50)) & 31L;
+ values[valuesOffset++] = (block4.TripleShift(45)) & 31L;
+ values[valuesOffset++] = (block4.TripleShift(40)) & 31L;
+ values[valuesOffset++] = (block4.TripleShift(35)) & 31L;
+ values[valuesOffset++] = (block4.TripleShift(30)) & 31L;
+ values[valuesOffset++] = (block4.TripleShift(25)) & 31L;
+ values[valuesOffset++] = (block4.TripleShift(20)) & 31L;
+ values[valuesOffset++] = (block4.TripleShift(15)) & 31L;
+ values[valuesOffset++] = (block4.TripleShift(10)) & 31L;
+ values[valuesOffset++] = (block4.TripleShift(5)) & 31L;
values[valuesOffset++] = block4 & 31L;
}
}
@@ -206,17 +208,17 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long byte0 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (long)((ulong)byte0 >> 3);
+ values[valuesOffset++] = byte0.TripleShift(3);
long byte1 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte0 & 7) << 2) | ((long)((ulong)byte1 >> 6));
- values[valuesOffset++] = ((long)((ulong)byte1 >> 1)) & 31;
+ values[valuesOffset++] = ((byte0 & 7) << 2) | (byte1.TripleShift(6));
+ values[valuesOffset++] = (byte1.TripleShift(1)) & 31;
long byte2 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte1 & 1) << 4) | ((long)((ulong)byte2 >> 4));
+ values[valuesOffset++] = ((byte1 & 1) << 4) | (byte2.TripleShift(4));
long byte3 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte2 & 15) << 1) | ((long)((ulong)byte3 >> 7));
- values[valuesOffset++] = ((long)((ulong)byte3 >> 2)) & 31;
+ values[valuesOffset++] = ((byte2 & 15) << 1) | (byte3.TripleShift(7));
+ values[valuesOffset++] = (byte3.TripleShift(2)) & 31;
long byte4 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte3 & 3) << 3) | ((long)((ulong)byte4 >> 5));
+ values[valuesOffset++] = ((byte3 & 3) << 3) | (byte4.TripleShift(5));
values[valuesOffset++] = byte4 & 31;
}
}
diff --git a/src/Lucene.Net/Util/Packed/BulkOperationPacked6.cs b/src/Lucene.Net/Util/Packed/BulkOperationPacked6.cs
index 6450d7a..b244f89 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperationPacked6.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperationPacked6.cs
@@ -1,4 +1,6 @@
-// this file has been automatically generated, DO NOT EDIT
+// this file has been automatically generated, DO NOT EDIT
+
+using J2N.Numerics;
namespace Lucene.Net.Util.Packed
{
@@ -34,39 +36,39 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)((long)((ulong)block0 >> 58));
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 52)) & 63L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 46)) & 63L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 40)) & 63L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 34)) & 63L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 28)) & 63L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 22)) & 63L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 16)) & 63L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 10)) & 63L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 4)) & 63L);
+ values[valuesOffset++] = (int)(block0.TripleShift(58));
+ values[valuesOffset++] = (int)((block0.TripleShift(52)) & 63L);
+ values[valuesOffset++] = (int)((block0.TripleShift(46)) & 63L);
+ values[valuesOffset++] = (int)((block0.TripleShift(40)) & 63L);
+ values[valuesOffset++] = (int)((block0.TripleShift(34)) & 63L);
+ values[valuesOffset++] = (int)((block0.TripleShift(28)) & 63L);
+ values[valuesOffset++] = (int)((block0.TripleShift(22)) & 63L);
+ values[valuesOffset++] = (int)((block0.TripleShift(16)) & 63L);
+ values[valuesOffset++] = (int)((block0.TripleShift(10)) & 63L);
+ values[valuesOffset++] = (int)((block0.TripleShift(4)) & 63L);
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block0 & 15L) << 2) | ((long)((ulong)block1 >> 62)));
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 56)) & 63L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 50)) & 63L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 44)) & 63L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 38)) & 63L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 32)) & 63L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 26)) & 63L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 20)) & 63L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 14)) & 63L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 8)) & 63L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 2)) & 63L);
+ values[valuesOffset++] = (int)(((block0 & 15L) << 2) | (block1.TripleShift(62)));
+ values[valuesOffset++] = (int)((block1.TripleShift(56)) & 63L);
+ values[valuesOffset++] = (int)((block1.TripleShift(50)) & 63L);
+ values[valuesOffset++] = (int)((block1.TripleShift(44)) & 63L);
+ values[valuesOffset++] = (int)((block1.TripleShift(38)) & 63L);
+ values[valuesOffset++] = (int)((block1.TripleShift(32)) & 63L);
+ values[valuesOffset++] = (int)((block1.TripleShift(26)) & 63L);
+ values[valuesOffset++] = (int)((block1.TripleShift(20)) & 63L);
+ values[valuesOffset++] = (int)((block1.TripleShift(14)) & 63L);
+ values[valuesOffset++] = (int)((block1.TripleShift(8)) & 63L);
+ values[valuesOffset++] = (int)((block1.TripleShift(2)) & 63L);
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block1 & 3L) << 4) | ((long)((ulong)block2 >> 60)));
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 54)) & 63L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 48)) & 63L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 42)) & 63L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 36)) & 63L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 30)) & 63L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 24)) & 63L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 18)) & 63L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 12)) & 63L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 6)) & 63L);
+ values[valuesOffset++] = (int)(((block1 & 3L) << 4) | (block2.TripleShift(60)));
+ values[valuesOffset++] = (int)((block2.TripleShift(54)) & 63L);
+ values[valuesOffset++] = (int)((block2.TripleShift(48)) & 63L);
+ values[valuesOffset++] = (int)((block2.TripleShift(42)) & 63L);
+ values[valuesOffset++] = (int)((block2.TripleShift(36)) & 63L);
+ values[valuesOffset++] = (int)((block2.TripleShift(30)) & 63L);
+ values[valuesOffset++] = (int)((block2.TripleShift(24)) & 63L);
+ values[valuesOffset++] = (int)((block2.TripleShift(18)) & 63L);
+ values[valuesOffset++] = (int)((block2.TripleShift(12)) & 63L);
+ values[valuesOffset++] = (int)((block2.TripleShift(6)) & 63L);
values[valuesOffset++] = (int)(block2 & 63L);
}
}
@@ -76,11 +78,11 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
int byte0 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (int)((uint)byte0 >> 2);
+ values[valuesOffset++] = byte0.TripleShift(2);
int byte1 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte0 & 3) << 4) | ((int)((uint)byte1 >> 4));
+ values[valuesOffset++] = ((byte0 & 3) << 4) | (byte1.TripleShift(4));
int byte2 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte1 & 15) << 2) | ((int)((uint)byte2 >> 6));
+ values[valuesOffset++] = ((byte1 & 15) << 2) | (byte2.TripleShift(6));
values[valuesOffset++] = byte2 & 63;
}
}
@@ -90,39 +92,39 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (long)((ulong)block0 >> 58);
- values[valuesOffset++] = ((long)((ulong)block0 >> 52)) & 63L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 46)) & 63L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 40)) & 63L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 34)) & 63L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 28)) & 63L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 22)) & 63L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 16)) & 63L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 10)) & 63L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 4)) & 63L;
+ values[valuesOffset++] = block0.TripleShift(58);
+ values[valuesOffset++] = (block0.TripleShift(52)) & 63L;
+ values[valuesOffset++] = (block0.TripleShift(46)) & 63L;
+ values[valuesOffset++] = (block0.TripleShift(40)) & 63L;
+ values[valuesOffset++] = (block0.TripleShift(34)) & 63L;
+ values[valuesOffset++] = (block0.TripleShift(28)) & 63L;
+ values[valuesOffset++] = (block0.TripleShift(22)) & 63L;
+ values[valuesOffset++] = (block0.TripleShift(16)) & 63L;
+ values[valuesOffset++] = (block0.TripleShift(10)) & 63L;
+ values[valuesOffset++] = (block0.TripleShift(4)) & 63L;
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block0 & 15L) << 2) | ((long)((ulong)block1 >> 62));
- values[valuesOffset++] = ((long)((ulong)block1 >> 56)) & 63L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 50)) & 63L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 44)) & 63L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 38)) & 63L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 32)) & 63L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 26)) & 63L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 20)) & 63L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 14)) & 63L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 8)) & 63L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 2)) & 63L;
+ values[valuesOffset++] = ((block0 & 15L) << 2) | (block1.TripleShift(62));
+ values[valuesOffset++] = (block1.TripleShift(56)) & 63L;
+ values[valuesOffset++] = (block1.TripleShift(50)) & 63L;
+ values[valuesOffset++] = (block1.TripleShift(44)) & 63L;
+ values[valuesOffset++] = (block1.TripleShift(38)) & 63L;
+ values[valuesOffset++] = (block1.TripleShift(32)) & 63L;
+ values[valuesOffset++] = (block1.TripleShift(26)) & 63L;
+ values[valuesOffset++] = (block1.TripleShift(20)) & 63L;
+ values[valuesOffset++] = (block1.TripleShift(14)) & 63L;
+ values[valuesOffset++] = (block1.TripleShift(8)) & 63L;
+ values[valuesOffset++] = (block1.TripleShift(2)) & 63L;
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block1 & 3L) << 4) | ((long)((ulong)block2 >> 60));
- values[valuesOffset++] = ((long)((ulong)block2 >> 54)) & 63L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 48)) & 63L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 42)) & 63L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 36)) & 63L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 30)) & 63L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 24)) & 63L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 18)) & 63L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 12)) & 63L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 6)) & 63L;
+ values[valuesOffset++] = ((block1 & 3L) << 4) | (block2.TripleShift(60));
+ values[valuesOffset++] = (block2.TripleShift(54)) & 63L;
+ values[valuesOffset++] = (block2.TripleShift(48)) & 63L;
+ values[valuesOffset++] = (block2.TripleShift(42)) & 63L;
+ values[valuesOffset++] = (block2.TripleShift(36)) & 63L;
+ values[valuesOffset++] = (block2.TripleShift(30)) & 63L;
+ values[valuesOffset++] = (block2.TripleShift(24)) & 63L;
+ values[valuesOffset++] = (block2.TripleShift(18)) & 63L;
+ values[valuesOffset++] = (block2.TripleShift(12)) & 63L;
+ values[valuesOffset++] = (block2.TripleShift(6)) & 63L;
values[valuesOffset++] = block2 & 63L;
}
}
@@ -132,11 +134,11 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long byte0 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (long)((ulong)byte0 >> 2);
+ values[valuesOffset++] = byte0.TripleShift(2);
long byte1 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte0 & 3) << 4) | ((long)((ulong)byte1 >> 4));
+ values[valuesOffset++] = ((byte0 & 3) << 4) | (byte1.TripleShift(4));
long byte2 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte1 & 15) << 2) | ((long)((ulong)byte2 >> 6));
+ values[valuesOffset++] = ((byte1 & 15) << 2) | (byte2.TripleShift(6));
values[valuesOffset++] = byte2 & 63;
}
}
diff --git a/src/Lucene.Net/Util/Packed/BulkOperationPacked7.cs b/src/Lucene.Net/Util/Packed/BulkOperationPacked7.cs
index 9ad7361..749e4a2 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperationPacked7.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperationPacked7.cs
@@ -1,4 +1,6 @@
-// this file has been automatically generated, DO NOT EDIT
+// this file has been automatically generated, DO NOT EDIT
+
+using J2N.Numerics;
namespace Lucene.Net.Util.Packed
{
@@ -34,75 +36,75 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)((long)((ulong)block0 >> 57));
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 50)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 43)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 36)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 29)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 22)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 15)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 8)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 1)) & 127L);
+ values[valuesOffset++] = (int)(block0.TripleShift(57));
+ values[valuesOffset++] = (int)((block0.TripleShift(50)) & 127L);
+ values[valuesOffset++] = (int)((block0.TripleShift(43)) & 127L);
+ values[valuesOffset++] = (int)((block0.TripleShift(36)) & 127L);
+ values[valuesOffset++] = (int)((block0.TripleShift(29)) & 127L);
+ values[valuesOffset++] = (int)((block0.TripleShift(22)) & 127L);
+ values[valuesOffset++] = (int)((block0.TripleShift(15)) & 127L);
+ values[valuesOffset++] = (int)((block0.TripleShift(8)) & 127L);
+ values[valuesOffset++] = (int)((block0.TripleShift(1)) & 127L);
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block0 & 1L) << 6) | ((long)((ulong)block1 >> 58)));
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 51)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 44)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 37)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 30)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 23)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 16)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 9)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 2)) & 127L);
+ values[valuesOffset++] = (int)(((block0 & 1L) << 6) | (block1.TripleShift(58)));
+ values[valuesOffset++] = (int)((block1.TripleShift(51)) & 127L);
+ values[valuesOffset++] = (int)((block1.TripleShift(44)) & 127L);
+ values[valuesOffset++] = (int)((block1.TripleShift(37)) & 127L);
+ values[valuesOffset++] = (int)((block1.TripleShift(30)) & 127L);
+ values[valuesOffset++] = (int)((block1.TripleShift(23)) & 127L);
+ values[valuesOffset++] = (int)((block1.TripleShift(16)) & 127L);
+ values[valuesOffset++] = (int)((block1.TripleShift(9)) & 127L);
+ values[valuesOffset++] = (int)((block1.TripleShift(2)) & 127L);
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block1 & 3L) << 5) | ((long)((ulong)block2 >> 59)));
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 52)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 45)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 38)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 31)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 24)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 17)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 10)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 3)) & 127L);
+ values[valuesOffset++] = (int)(((block1 & 3L) << 5) | (block2.TripleShift(59)));
+ values[valuesOffset++] = (int)((block2.TripleShift(52)) & 127L);
+ values[valuesOffset++] = (int)((block2.TripleShift(45)) & 127L);
+ values[valuesOffset++] = (int)((block2.TripleShift(38)) & 127L);
+ values[valuesOffset++] = (int)((block2.TripleShift(31)) & 127L);
+ values[valuesOffset++] = (int)((block2.TripleShift(24)) & 127L);
+ values[valuesOffset++] = (int)((block2.TripleShift(17)) & 127L);
+ values[valuesOffset++] = (int)((block2.TripleShift(10)) & 127L);
+ values[valuesOffset++] = (int)((block2.TripleShift(3)) & 127L);
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block2 & 7L) << 4) | ((long)((ulong)block3 >> 60)));
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 53)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 46)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 39)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 32)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 25)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 18)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 11)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 4)) & 127L);
+ values[valuesOffset++] = (int)(((block2 & 7L) << 4) | (block3.TripleShift(60)));
+ values[valuesOffset++] = (int)((block3.TripleShift(53)) & 127L);
+ values[valuesOffset++] = (int)((block3.TripleShift(46)) & 127L);
+ values[valuesOffset++] = (int)((block3.TripleShift(39)) & 127L);
+ values[valuesOffset++] = (int)((block3.TripleShift(32)) & 127L);
+ values[valuesOffset++] = (int)((block3.TripleShift(25)) & 127L);
+ values[valuesOffset++] = (int)((block3.TripleShift(18)) & 127L);
+ values[valuesOffset++] = (int)((block3.TripleShift(11)) & 127L);
+ values[valuesOffset++] = (int)((block3.TripleShift(4)) & 127L);
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block3 & 15L) << 3) | ((long)((ulong)block4 >> 61)));
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 54)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 47)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 40)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 33)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 26)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 19)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 12)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 5)) & 127L);
+ values[valuesOffset++] = (int)(((block3 & 15L) << 3) | (block4.TripleShift(61)));
+ values[valuesOffset++] = (int)((block4.TripleShift(54)) & 127L);
+ values[valuesOffset++] = (int)((block4.TripleShift(47)) & 127L);
+ values[valuesOffset++] = (int)((block4.TripleShift(40)) & 127L);
+ values[valuesOffset++] = (int)((block4.TripleShift(33)) & 127L);
+ values[valuesOffset++] = (int)((block4.TripleShift(26)) & 127L);
+ values[valuesOffset++] = (int)((block4.TripleShift(19)) & 127L);
+ values[valuesOffset++] = (int)((block4.TripleShift(12)) & 127L);
+ values[valuesOffset++] = (int)((block4.TripleShift(5)) & 127L);
long block5 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block4 & 31L) << 2) | ((long)((ulong)block5 >> 62)));
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 55)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 48)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 41)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 34)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 27)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 20)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 13)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 6)) & 127L);
+ values[valuesOffset++] = (int)(((block4 & 31L) << 2) | (block5.TripleShift(62)));
+ values[valuesOffset++] = (int)((block5.TripleShift(55)) & 127L);
+ values[valuesOffset++] = (int)((block5.TripleShift(48)) & 127L);
+ values[valuesOffset++] = (int)((block5.TripleShift(41)) & 127L);
+ values[valuesOffset++] = (int)((block5.TripleShift(34)) & 127L);
+ values[valuesOffset++] = (int)((block5.TripleShift(27)) & 127L);
+ values[valuesOffset++] = (int)((block5.TripleShift(20)) & 127L);
+ values[valuesOffset++] = (int)((block5.TripleShift(13)) & 127L);
+ values[valuesOffset++] = (int)((block5.TripleShift(6)) & 127L);
long block6 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block5 & 63L) << 1) | ((long)((ulong)block6 >> 63)));
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 56)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 49)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 42)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 35)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 28)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 21)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 14)) & 127L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 7)) & 127L);
+ values[valuesOffset++] = (int)(((block5 & 63L) << 1) | (block6.TripleShift(63)));
+ values[valuesOffset++] = (int)((block6.TripleShift(56)) & 127L);
+ values[valuesOffset++] = (int)((block6.TripleShift(49)) & 127L);
+ values[valuesOffset++] = (int)((block6.TripleShift(42)) & 127L);
+ values[valuesOffset++] = (int)((block6.TripleShift(35)) & 127L);
+ values[valuesOffset++] = (int)((block6.TripleShift(28)) & 127L);
+ values[valuesOffset++] = (int)((block6.TripleShift(21)) & 127L);
+ values[valuesOffset++] = (int)((block6.TripleShift(14)) & 127L);
+ values[valuesOffset++] = (int)((block6.TripleShift(7)) & 127L);
values[valuesOffset++] = (int)(block6 & 127L);
}
}
@@ -112,19 +114,19 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
int byte0 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (int)((uint)byte0 >> 1);
+ values[valuesOffset++] = byte0.TripleShift(1);
int byte1 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte0 & 1) << 6) | ((int)((uint)byte1 >> 2));
+ values[valuesOffset++] = ((byte0 & 1) << 6) | (byte1.TripleShift(2));
int byte2 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte1 & 3) << 5) | ((int)((uint)byte2 >> 3));
+ values[valuesOffset++] = ((byte1 & 3) << 5) | (byte2.TripleShift(3));
int byte3 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte2 & 7) << 4) | ((int)((uint)byte3 >> 4));
+ values[valuesOffset++] = ((byte2 & 7) << 4) | (byte3.TripleShift(4));
int byte4 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte3 & 15) << 3) | ((int)((uint)byte4 >> 5));
+ values[valuesOffset++] = ((byte3 & 15) << 3) | (byte4.TripleShift(5));
int byte5 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte4 & 31) << 2) | ((int)((uint)byte5 >> 6));
+ values[valuesOffset++] = ((byte4 & 31) << 2) | (byte5.TripleShift(6));
int byte6 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte5 & 63) << 1) | ((int)((uint)byte6 >> 7));
+ values[valuesOffset++] = ((byte5 & 63) << 1) | (byte6.TripleShift(7));
values[valuesOffset++] = byte6 & 127;
}
}
@@ -134,75 +136,75 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (long)((ulong)block0 >> 57);
- values[valuesOffset++] = ((long)((ulong)block0 >> 50)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 43)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 36)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 29)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 22)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 15)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 8)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 1)) & 127L;
+ values[valuesOffset++] = block0.TripleShift(57);
+ values[valuesOffset++] = (block0.TripleShift(50)) & 127L;
+ values[valuesOffset++] = (block0.TripleShift(43)) & 127L;
+ values[valuesOffset++] = (block0.TripleShift(36)) & 127L;
+ values[valuesOffset++] = (block0.TripleShift(29)) & 127L;
+ values[valuesOffset++] = (block0.TripleShift(22)) & 127L;
+ values[valuesOffset++] = (block0.TripleShift(15)) & 127L;
+ values[valuesOffset++] = (block0.TripleShift(8)) & 127L;
+ values[valuesOffset++] = (block0.TripleShift(1)) & 127L;
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block0 & 1L) << 6) | ((long)((ulong)block1 >> 58));
- values[valuesOffset++] = ((long)((ulong)block1 >> 51)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 44)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 37)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 30)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 23)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 16)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 9)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 2)) & 127L;
+ values[valuesOffset++] = ((block0 & 1L) << 6) | (block1.TripleShift(58));
+ values[valuesOffset++] = (block1.TripleShift(51)) & 127L;
+ values[valuesOffset++] = (block1.TripleShift(44)) & 127L;
+ values[valuesOffset++] = (block1.TripleShift(37)) & 127L;
+ values[valuesOffset++] = (block1.TripleShift(30)) & 127L;
+ values[valuesOffset++] = (block1.TripleShift(23)) & 127L;
+ values[valuesOffset++] = (block1.TripleShift(16)) & 127L;
+ values[valuesOffset++] = (block1.TripleShift(9)) & 127L;
+ values[valuesOffset++] = (block1.TripleShift(2)) & 127L;
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block1 & 3L) << 5) | ((long)((ulong)block2 >> 59));
- values[valuesOffset++] = ((long)((ulong)block2 >> 52)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 45)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 38)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 31)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 24)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 17)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 10)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 3)) & 127L;
+ values[valuesOffset++] = ((block1 & 3L) << 5) | (block2.TripleShift(59));
+ values[valuesOffset++] = (block2.TripleShift(52)) & 127L;
+ values[valuesOffset++] = (block2.TripleShift(45)) & 127L;
+ values[valuesOffset++] = (block2.TripleShift(38)) & 127L;
+ values[valuesOffset++] = (block2.TripleShift(31)) & 127L;
+ values[valuesOffset++] = (block2.TripleShift(24)) & 127L;
+ values[valuesOffset++] = (block2.TripleShift(17)) & 127L;
+ values[valuesOffset++] = (block2.TripleShift(10)) & 127L;
+ values[valuesOffset++] = (block2.TripleShift(3)) & 127L;
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block2 & 7L) << 4) | ((long)((ulong)block3 >> 60));
- values[valuesOffset++] = ((long)((ulong)block3 >> 53)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 46)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 39)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 32)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 25)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 18)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 11)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 4)) & 127L;
+ values[valuesOffset++] = ((block2 & 7L) << 4) | (block3.TripleShift(60));
+ values[valuesOffset++] = (block3.TripleShift(53)) & 127L;
+ values[valuesOffset++] = (block3.TripleShift(46)) & 127L;
+ values[valuesOffset++] = (block3.TripleShift(39)) & 127L;
+ values[valuesOffset++] = (block3.TripleShift(32)) & 127L;
+ values[valuesOffset++] = (block3.TripleShift(25)) & 127L;
+ values[valuesOffset++] = (block3.TripleShift(18)) & 127L;
+ values[valuesOffset++] = (block3.TripleShift(11)) & 127L;
+ values[valuesOffset++] = (block3.TripleShift(4)) & 127L;
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block3 & 15L) << 3) | ((long)((ulong)block4 >> 61));
- values[valuesOffset++] = ((long)((ulong)block4 >> 54)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 47)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 40)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 33)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 26)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 19)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 12)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 5)) & 127L;
+ values[valuesOffset++] = ((block3 & 15L) << 3) | (block4.TripleShift(61));
+ values[valuesOffset++] = (block4.TripleShift(54)) & 127L;
+ values[valuesOffset++] = (block4.TripleShift(47)) & 127L;
+ values[valuesOffset++] = (block4.TripleShift(40)) & 127L;
+ values[valuesOffset++] = (block4.TripleShift(33)) & 127L;
+ values[valuesOffset++] = (block4.TripleShift(26)) & 127L;
+ values[valuesOffset++] = (block4.TripleShift(19)) & 127L;
+ values[valuesOffset++] = (block4.TripleShift(12)) & 127L;
+ values[valuesOffset++] = (block4.TripleShift(5)) & 127L;
long block5 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block4 & 31L) << 2) | ((long)((ulong)block5 >> 62));
- values[valuesOffset++] = ((long)((ulong)block5 >> 55)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 48)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 41)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 34)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 27)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 20)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 13)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 6)) & 127L;
+ values[valuesOffset++] = ((block4 & 31L) << 2) | (block5.TripleShift(62));
+ values[valuesOffset++] = (block5.TripleShift(55)) & 127L;
+ values[valuesOffset++] = (block5.TripleShift(48)) & 127L;
+ values[valuesOffset++] = (block5.TripleShift(41)) & 127L;
+ values[valuesOffset++] = (block5.TripleShift(34)) & 127L;
+ values[valuesOffset++] = (block5.TripleShift(27)) & 127L;
+ values[valuesOffset++] = (block5.TripleShift(20)) & 127L;
+ values[valuesOffset++] = (block5.TripleShift(13)) & 127L;
+ values[valuesOffset++] = (block5.TripleShift(6)) & 127L;
long block6 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block5 & 63L) << 1) | ((long)((ulong)block6 >> 63));
- values[valuesOffset++] = ((long)((ulong)block6 >> 56)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 49)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 42)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 35)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 28)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 21)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 14)) & 127L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 7)) & 127L;
+ values[valuesOffset++] = ((block5 & 63L) << 1) | (block6.TripleShift(63));
+ values[valuesOffset++] = (block6.TripleShift(56)) & 127L;
+ values[valuesOffset++] = (block6.TripleShift(49)) & 127L;
+ values[valuesOffset++] = (block6.TripleShift(42)) & 127L;
+ values[valuesOffset++] = (block6.TripleShift(35)) & 127L;
+ values[valuesOffset++] = (block6.TripleShift(28)) & 127L;
+ values[valuesOffset++] = (block6.TripleShift(21)) & 127L;
+ values[valuesOffset++] = (block6.TripleShift(14)) & 127L;
+ values[valuesOffset++] = (block6.TripleShift(7)) & 127L;
values[valuesOffset++] = block6 & 127L;
}
}
@@ -212,19 +214,19 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long byte0 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (long)((ulong)byte0 >> 1);
+ values[valuesOffset++] = byte0.TripleShift(1);
long byte1 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte0 & 1) << 6) | ((long)((ulong)byte1 >> 2));
+ values[valuesOffset++] = ((byte0 & 1) << 6) | (byte1.TripleShift(2));
long byte2 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte1 & 3) << 5) | ((long)((ulong)byte2 >> 3));
+ values[valuesOffset++] = ((byte1 & 3) << 5) | (byte2.TripleShift(3));
long byte3 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte2 & 7) << 4) | ((long)((ulong)byte3 >> 4));
+ values[valuesOffset++] = ((byte2 & 7) << 4) | (byte3.TripleShift(4));
long byte4 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte3 & 15) << 3) | ((long)((ulong)byte4 >> 5));
+ values[valuesOffset++] = ((byte3 & 15) << 3) | (byte4.TripleShift(5));
long byte5 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte4 & 31) << 2) | ((long)((ulong)byte5 >> 6));
+ values[valuesOffset++] = ((byte4 & 31) << 2) | (byte5.TripleShift(6));
long byte6 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte5 & 63) << 1) | ((long)((ulong)byte6 >> 7));
+ values[valuesOffset++] = ((byte5 & 63) << 1) | (byte6.TripleShift(7));
values[valuesOffset++] = byte6 & 127;
}
}
diff --git a/src/Lucene.Net/Util/Packed/BulkOperationPacked8.cs b/src/Lucene.Net/Util/Packed/BulkOperationPacked8.cs
index fe96aba..80f5ea0 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperationPacked8.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperationPacked8.cs
@@ -1,4 +1,6 @@
-// this file has been automatically generated, DO NOT EDIT
+// this file has been automatically generated, DO NOT EDIT
+
+using J2N.Numerics;
namespace Lucene.Net.Util.Packed
{
@@ -36,7 +38,7 @@ namespace Lucene.Net.Util.Packed
long block = blocks[blocksOffset++];
for (int shift = 56; shift >= 0; shift -= 8)
{
- values[valuesOffset++] = (int)(((long)((ulong)block >> shift)) & 255);
+ values[valuesOffset++] = (int)((block.TripleShift(shift)) & 255);
}
}
}
@@ -56,7 +58,7 @@ namespace Lucene.Net.Util.Packed
long block = blocks[blocksOffset++];
for (int shift = 56; shift >= 0; shift -= 8)
{
- values[valuesOffset++] = ((long)((ulong)block >> shift)) & 255;
+ values[valuesOffset++] = (block.TripleShift(shift)) & 255;
}
}
}
diff --git a/src/Lucene.Net/Util/Packed/BulkOperationPacked9.cs b/src/Lucene.Net/Util/Packed/BulkOperationPacked9.cs
index 5d73724..34058ee 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperationPacked9.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperationPacked9.cs
@@ -1,4 +1,6 @@
-// this file has been automatically generated, DO NOT EDIT
+// this file has been automatically generated, DO NOT EDIT
+
+using J2N.Numerics;
namespace Lucene.Net.Util.Packed
{
@@ -34,77 +36,77 @@ namespace Lucene.Net.Util.Packed
for (int i = 0; i < iterations; ++i)
{
long block0 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)((long)((ulong)block0 >> 55));
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 46)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 37)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 28)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 19)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 10)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block0 >> 1)) & 511L);
+ values[valuesOffset++] = (int)(block0.TripleShift(55));
+ values[valuesOffset++] = (int)((block0.TripleShift(46)) & 511L);
+ values[valuesOffset++] = (int)((block0.TripleShift(37)) & 511L);
+ values[valuesOffset++] = (int)((block0.TripleShift(28)) & 511L);
+ values[valuesOffset++] = (int)((block0.TripleShift(19)) & 511L);
+ values[valuesOffset++] = (int)((block0.TripleShift(10)) & 511L);
+ values[valuesOffset++] = (int)((block0.TripleShift(1)) & 511L);
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block0 & 1L) << 8) | ((long)((ulong)block1 >> 56)));
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 47)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 38)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 29)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 20)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 11)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block1 >> 2)) & 511L);
+ values[valuesOffset++] = (int)(((block0 & 1L) << 8) | (block1.TripleShift(56)));
+ values[valuesOffset++] = (int)((block1.TripleShift(47)) & 511L);
+ values[valuesOffset++] = (int)((block1.TripleShift(38)) & 511L);
+ values[valuesOffset++] = (int)((block1.TripleShift(29)) & 511L);
+ values[valuesOffset++] = (int)((block1.TripleShift(20)) & 511L);
+ values[valuesOffset++] = (int)((block1.TripleShift(11)) & 511L);
+ values[valuesOffset++] = (int)((block1.TripleShift(2)) & 511L);
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block1 & 3L) << 7) | ((long)((ulong)block2 >> 57)));
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 48)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 39)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 30)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 21)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 12)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block2 >> 3)) & 511L);
+ values[valuesOffset++] = (int)(((block1 & 3L) << 7) | (block2.TripleShift(57)));
+ values[valuesOffset++] = (int)((block2.TripleShift(48)) & 511L);
+ values[valuesOffset++] = (int)((block2.TripleShift(39)) & 511L);
+ values[valuesOffset++] = (int)((block2.TripleShift(30)) & 511L);
+ values[valuesOffset++] = (int)((block2.TripleShift(21)) & 511L);
+ values[valuesOffset++] = (int)((block2.TripleShift(12)) & 511L);
+ values[valuesOffset++] = (int)((block2.TripleShift(3)) & 511L);
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block2 & 7L) << 6) | ((long)((ulong)block3 >> 58)));
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 49)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 40)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 31)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 22)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 13)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block3 >> 4)) & 511L);
+ values[valuesOffset++] = (int)(((block2 & 7L) << 6) | (block3.TripleShift(58)));
+ values[valuesOffset++] = (int)((block3.TripleShift(49)) & 511L);
+ values[valuesOffset++] = (int)((block3.TripleShift(40)) & 511L);
+ values[valuesOffset++] = (int)((block3.TripleShift(31)) & 511L);
+ values[valuesOffset++] = (int)((block3.TripleShift(22)) & 511L);
+ values[valuesOffset++] = (int)((block3.TripleShift(13)) & 511L);
+ values[valuesOffset++] = (int)((block3.TripleShift(4)) & 511L);
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block3 & 15L) << 5) | ((long)((ulong)block4 >> 59)));
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 50)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 41)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 32)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 23)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 14)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block4 >> 5)) & 511L);
+ values[valuesOffset++] = (int)(((block3 & 15L) << 5) | (block4.TripleShift(59)));
+ values[valuesOffset++] = (int)((block4.TripleShift(50)) & 511L);
+ values[valuesOffset++] = (int)((block4.TripleShift(41)) & 511L);
+ values[valuesOffset++] = (int)((block4.TripleShift(32)) & 511L);
+ values[valuesOffset++] = (int)((block4.TripleShift(23)) & 511L);
+ values[valuesOffset++] = (int)((block4.TripleShift(14)) & 511L);
+ values[valuesOffset++] = (int)((block4.TripleShift(5)) & 511L);
long block5 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block4 & 31L) << 4) | ((long)((ulong)block5 >> 60)));
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 51)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 42)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 33)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 24)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 15)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block5 >> 6)) & 511L);
+ values[valuesOffset++] = (int)(((block4 & 31L) << 4) | (block5.TripleShift(60)));
+ values[valuesOffset++] = (int)((block5.TripleShift(51)) & 511L);
+ values[valuesOffset++] = (int)((block5.TripleShift(42)) & 511L);
+ values[valuesOffset++] = (int)((block5.TripleShift(33)) & 511L);
+ values[valuesOffset++] = (int)((block5.TripleShift(24)) & 511L);
+ values[valuesOffset++] = (int)((block5.TripleShift(15)) & 511L);
+ values[valuesOffset++] = (int)((block5.TripleShift(6)) & 511L);
long block6 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block5 & 63L) << 3) | ((long)((ulong)block6 >> 61)));
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 52)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 43)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 34)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 25)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 16)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block6 >> 7)) & 511L);
+ values[valuesOffset++] = (int)(((block5 & 63L) << 3) | (block6.TripleShift(61)));
+ values[valuesOffset++] = (int)((block6.TripleShift(52)) & 511L);
+ values[valuesOffset++] = (int)((block6.TripleShift(43)) & 511L);
+ values[valuesOffset++] = (int)((block6.TripleShift(34)) & 511L);
+ values[valuesOffset++] = (int)((block6.TripleShift(25)) & 511L);
+ values[valuesOffset++] = (int)((block6.TripleShift(16)) & 511L);
+ values[valuesOffset++] = (int)((block6.TripleShift(7)) & 511L);
long block7 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block6 & 127L) << 2) | ((long)((ulong)block7 >> 62)));
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 53)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 44)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 35)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 26)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 17)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block7 >> 8)) & 511L);
+ values[valuesOffset++] = (int)(((block6 & 127L) << 2) | (block7.TripleShift(62)));
+ values[valuesOffset++] = (int)((block7.TripleShift(53)) & 511L);
+ values[valuesOffset++] = (int)((block7.TripleShift(44)) & 511L);
+ values[valuesOffset++] = (int)((block7.TripleShift(35)) & 511L);
+ values[valuesOffset++] = (int)((block7.TripleShift(26)) & 511L);
+ values[valuesOffset++] = (int)((block7.TripleShift(17)) & 511L);
+ values[valuesOffset++] = (int)((block7.TripleShift(8)) & 511L);
long block8 = blocks[blocksOffset++];
- values[valuesOffset++] = (int)(((block7 & 255L) << 1) | ((long)((ulong)block8 >> 63)));
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 54)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 45)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 36)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 27)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 18)) & 511L);
- values[valuesOffset++] = (int)(((long)((ulong)block8 >> 9)) & 511L);
+ values[valuesOffset++] = (int)(((block7 & 255L) << 1) | (block8.TripleShift(63)));
+ values[valuesOffset++] = (int)((block8.TripleShift(54)) & 511L);
+ values[valuesOffset++] = (int)((block8.TripleShift(45)) & 511L);
+ values[valuesOffset++] = (int)((block8.TripleShift(36)) & 511L);
+ values[valuesOffset++] = (int)((block8.TripleShift(27)) & 511L);
+ values[valuesOffset++] = (int)((block8.TripleShift(18)) & 511L);
+ values[valuesOffset++] = (int)((block8.TripleShift(9)) & 511L);
values[valuesOffset++] = (int)(block8 & 511L);
}
}
@@ -115,19 +117,19 @@ namespace Lucene.Net.Util.Packed
{
int byte0 = blocks[blocksOffset++] & 0xFF;
int byte1 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (byte0 << 1) | ((int)((uint)byte1 >> 7));
+ values[valuesOffset++] = (byte0 << 1) | (byte1.TripleShift(7));
int byte2 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte1 & 127) << 2) | ((int)((uint)byte2 >> 6));
+ values[valuesOffset++] = ((byte1 & 127) << 2) | (byte2.TripleShift(6));
int byte3 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte2 & 63) << 3) | ((int)((uint)byte3 >> 5));
+ values[valuesOffset++] = ((byte2 & 63) << 3) | (byte3.TripleShift(5));
int byte4 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte3 & 31) << 4) | ((int)((uint)byte4 >> 4));
+ values[valuesOffset++] = ((byte3 & 31) << 4) | (byte4.TripleShift(4));
int byte5 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte4 & 15) << 5) | ((int)((uint)byte5 >> 3));
+ values[valuesOffset++] = ((byte4 & 15) << 5) | (byte5.TripleShift(3));
int byte6 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte5 & 7) << 6) | ((int)((uint)byte6 >> 2));
+ values[valuesOffset++] = ((byte5 & 7) << 6) | (byte6.TripleShift(2));
int byte7 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte6 & 3) << 7) | ((int)((uint)byte7 >> 1));
+ values[valuesOffset++] = ((byte6 & 3) << 7) | (byte7.TripleShift(1));
int byte8 = blocks[blocksOffset++] & 0xFF;
values[valuesOffset++] = ((byte7 & 1) << 8) | byte8;
}
@@ -139,76 +141,76 @@ namespace Lucene.Net.Util.Packed
{
long block0 = blocks[blocksOffset++];
values[valuesOffset++] = (long)((ulong)block0 >> 55);
- values[valuesOffset++] = ((long)((ulong)block0 >> 46)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 37)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 28)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 19)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 10)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block0 >> 1)) & 511L;
+ values[valuesOffset++] = (block0.TripleShift(46)) & 511L;
+ values[valuesOffset++] = (block0.TripleShift(37)) & 511L;
+ values[valuesOffset++] = (block0.TripleShift(28)) & 511L;
+ values[valuesOffset++] = (block0.TripleShift(19)) & 511L;
+ values[valuesOffset++] = (block0.TripleShift(10)) & 511L;
+ values[valuesOffset++] = (block0.TripleShift(1)) & 511L;
long block1 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block0 & 1L) << 8) | ((long)((ulong)block1 >> 56));
- values[valuesOffset++] = ((long)((ulong)block1 >> 47)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 38)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 29)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 20)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 11)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block1 >> 2)) & 511L;
+ values[valuesOffset++] = ((block0 & 1L) << 8) | (block1.TripleShift(56));
+ values[valuesOffset++] = (block1.TripleShift(47)) & 511L;
+ values[valuesOffset++] = (block1.TripleShift(38)) & 511L;
+ values[valuesOffset++] = (block1.TripleShift(29)) & 511L;
+ values[valuesOffset++] = (block1.TripleShift(20)) & 511L;
+ values[valuesOffset++] = (block1.TripleShift(11)) & 511L;
+ values[valuesOffset++] = (block1.TripleShift(2)) & 511L;
long block2 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block1 & 3L) << 7) | ((long)((ulong)block2 >> 57));
- values[valuesOffset++] = ((long)((ulong)block2 >> 48)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 39)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 30)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 21)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 12)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block2 >> 3)) & 511L;
+ values[valuesOffset++] = ((block1 & 3L) << 7) | (block2.TripleShift(57));
+ values[valuesOffset++] = (block2.TripleShift(48)) & 511L;
+ values[valuesOffset++] = (block2.TripleShift(39)) & 511L;
+ values[valuesOffset++] = (block2.TripleShift(30)) & 511L;
+ values[valuesOffset++] = (block2.TripleShift(21)) & 511L;
+ values[valuesOffset++] = (block2.TripleShift(12)) & 511L;
+ values[valuesOffset++] = (block2.TripleShift(3)) & 511L;
long block3 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block2 & 7L) << 6) | ((long)((ulong)block3 >> 58));
- values[valuesOffset++] = ((long)((ulong)block3 >> 49)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 40)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 31)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 22)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 13)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block3 >> 4)) & 511L;
+ values[valuesOffset++] = ((block2 & 7L) << 6) | (block3.TripleShift(58));
+ values[valuesOffset++] = (block3.TripleShift(49)) & 511L;
+ values[valuesOffset++] = (block3.TripleShift(40)) & 511L;
+ values[valuesOffset++] = (block3.TripleShift(31)) & 511L;
+ values[valuesOffset++] = (block3.TripleShift(22)) & 511L;
+ values[valuesOffset++] = (block3.TripleShift(13)) & 511L;
+ values[valuesOffset++] = (block3.TripleShift(4)) & 511L;
long block4 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block3 & 15L) << 5) | ((long)((ulong)block4 >> 59));
- values[valuesOffset++] = ((long)((ulong)block4 >> 50)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 41)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 32)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 23)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 14)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block4 >> 5)) & 511L;
+ values[valuesOffset++] = ((block3 & 15L) << 5) | (block4.TripleShift(59));
+ values[valuesOffset++] = (block4.TripleShift(50)) & 511L;
+ values[valuesOffset++] = (block4.TripleShift(41)) & 511L;
+ values[valuesOffset++] = (block4.TripleShift(32)) & 511L;
+ values[valuesOffset++] = (block4.TripleShift(23)) & 511L;
+ values[valuesOffset++] = (block4.TripleShift(14)) & 511L;
+ values[valuesOffset++] = (block4.TripleShift(5)) & 511L;
long block5 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block4 & 31L) << 4) | ((long)((ulong)block5 >> 60));
- values[valuesOffset++] = ((long)((ulong)block5 >> 51)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 42)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 33)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 24)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 15)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block5 >> 6)) & 511L;
+ values[valuesOffset++] = ((block4 & 31L) << 4) | (block5.TripleShift(60));
+ values[valuesOffset++] = (block5.TripleShift(51)) & 511L;
+ values[valuesOffset++] = (block5.TripleShift(42)) & 511L;
+ values[valuesOffset++] = (block5.TripleShift(33)) & 511L;
+ values[valuesOffset++] = (block5.TripleShift(24)) & 511L;
+ values[valuesOffset++] = (block5.TripleShift(15)) & 511L;
+ values[valuesOffset++] = (block5.TripleShift(6)) & 511L;
long block6 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block5 & 63L) << 3) | ((long)((ulong)block6 >> 61));
- values[valuesOffset++] = ((long)((ulong)block6 >> 52)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 43)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 34)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 25)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 16)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block6 >> 7)) & 511L;
+ values[valuesOffset++] = ((block5 & 63L) << 3) | (block6.TripleShift(61));
+ values[valuesOffset++] = (block6.TripleShift(52)) & 511L;
+ values[valuesOffset++] = (block6.TripleShift(43)) & 511L;
+ values[valuesOffset++] = (block6.TripleShift(34)) & 511L;
+ values[valuesOffset++] = (block6.TripleShift(25)) & 511L;
+ values[valuesOffset++] = (block6.TripleShift(16)) & 511L;
+ values[valuesOffset++] = (block6.TripleShift(7)) & 511L;
long block7 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block6 & 127L) << 2) | ((long)((ulong)block7 >> 62));
- values[valuesOffset++] = ((long)((ulong)block7 >> 53)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block7 >> 44)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block7 >> 35)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block7 >> 26)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block7 >> 17)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block7 >> 8)) & 511L;
+ values[valuesOffset++] = ((block6 & 127L) << 2) | (block7.TripleShift(62));
+ values[valuesOffset++] = (block7.TripleShift(53)) & 511L;
+ values[valuesOffset++] = (block7.TripleShift(44)) & 511L;
+ values[valuesOffset++] = (block7.TripleShift(35)) & 511L;
+ values[valuesOffset++] = (block7.TripleShift(26)) & 511L;
+ values[valuesOffset++] = (block7.TripleShift(17)) & 511L;
+ values[valuesOffset++] = (block7.TripleShift(8)) & 511L;
long block8 = blocks[blocksOffset++];
- values[valuesOffset++] = ((block7 & 255L) << 1) | ((long)((ulong)block8 >> 63));
- values[valuesOffset++] = ((long)((ulong)block8 >> 54)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block8 >> 45)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block8 >> 36)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block8 >> 27)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block8 >> 18)) & 511L;
- values[valuesOffset++] = ((long)((ulong)block8 >> 9)) & 511L;
+ values[valuesOffset++] = ((block7 & 255L) << 1) | (block8.TripleShift(63));
+ values[valuesOffset++] = (block8.TripleShift(54)) & 511L;
+ values[valuesOffset++] = (block8.TripleShift(45)) & 511L;
+ values[valuesOffset++] = (block8.TripleShift(36)) & 511L;
+ values[valuesOffset++] = (block8.TripleShift(27)) & 511L;
+ values[valuesOffset++] = (block8.TripleShift(18)) & 511L;
+ values[valuesOffset++] = (block8.TripleShift(9)) & 511L;
values[valuesOffset++] = block8 & 511L;
}
}
@@ -219,19 +221,19 @@ namespace Lucene.Net.Util.Packed
{
long byte0 = blocks[blocksOffset++] & 0xFF;
long byte1 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = (byte0 << 1) | ((long)((ulong)byte1 >> 7));
+ values[valuesOffset++] = (byte0 << 1) | (byte1.TripleShift(7));
long byte2 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte1 & 127) << 2) | ((long)((ulong)byte2 >> 6));
+ values[valuesOffset++] = ((byte1 & 127) << 2) | (byte2.TripleShift(6));
long byte3 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte2 & 63) << 3) | ((long)((ulong)byte3 >> 5));
+ values[valuesOffset++] = ((byte2 & 63) << 3) | (byte3.TripleShift(5));
long byte4 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte3 & 31) << 4) | ((long)((ulong)byte4 >> 4));
+ values[valuesOffset++] = ((byte3 & 31) << 4) | (byte4.TripleShift(4));
long byte5 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte4 & 15) << 5) | ((long)((ulong)byte5 >> 3));
+ values[valuesOffset++] = ((byte4 & 15) << 5) | (byte5.TripleShift(3));
long byte6 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte5 & 7) << 6) | ((long)((ulong)byte6 >> 2));
+ values[valuesOffset++] = ((byte5 & 7) << 6) | (byte6.TripleShift(2));
long byte7 = blocks[blocksOffset++] & 0xFF;
- values[valuesOffset++] = ((byte6 & 3) << 7) | ((long)((ulong)byte7 >> 1));
+ values[valuesOffset++] = ((byte6 & 3) << 7) | (byte7.TripleShift(1));
long byte8 = blocks[blocksOffset++] & 0xFF;
values[valuesOffset++] = ((byte7 & 1) << 8) | byte8;
}
diff --git a/src/Lucene.Net/Util/Packed/BulkOperationPackedSingleBlock.cs b/src/Lucene.Net/Util/Packed/BulkOperationPackedSingleBlock.cs
index c7b9bb3..b09fcbf 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperationPackedSingleBlock.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperationPackedSingleBlock.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using System;
namespace Lucene.Net.Util.Packed
@@ -67,7 +68,7 @@ namespace Lucene.Net.Util.Packed
values[valuesOffset++] = block & mask;
for (int j = 1; j < valueCount; ++j)
{
- block = (long)((ulong)block >> bitsPerValue);
+ block = block.TripleShift(bitsPerValue);
values[valuesOffset++] = block & mask;
}
return valuesOffset;
@@ -78,7 +79,7 @@ namespace Lucene.Net.Util.Packed
values[valuesOffset++] = (int)(block & mask);
for (int j = 1; j < valueCount; ++j)
{
- block = (long)((ulong)block >> bitsPerValue);
+ block = block.TripleShift(bitsPerValue);
values[valuesOffset++] = (int)(block & mask);
}
return valuesOffset;
diff --git a/src/Lucene.Net/Util/Packed/DirectPacked64SingleBlockReader.cs b/src/Lucene.Net/Util/Packed/DirectPacked64SingleBlockReader.cs
index b4ecd33..4c618b6 100644
--- a/src/Lucene.Net/Util/Packed/DirectPacked64SingleBlockReader.cs
+++ b/src/Lucene.Net/Util/Packed/DirectPacked64SingleBlockReader.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using System;
using System.IO;
using System.Runtime.CompilerServices;
@@ -49,7 +50,7 @@ namespace Lucene.Net.Util.Packed
long block = @in.ReadInt64();
int offsetInBlock = index % valuesPerBlock;
- return ((long)((ulong)block >> (offsetInBlock * m_bitsPerValue))) & mask;
+ return (block.TripleShift(offsetInBlock * m_bitsPerValue)) & mask;
}
catch (IOException e)
{
diff --git a/src/Lucene.Net/Util/Packed/DirectPackedReader.cs b/src/Lucene.Net/Util/Packed/DirectPackedReader.cs
index 6829ed6..754ca7c 100644
--- a/src/Lucene.Net/Util/Packed/DirectPackedReader.cs
+++ b/src/Lucene.Net/Util/Packed/DirectPackedReader.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using System;
using System.IO;
using System.Runtime.CompilerServices;
@@ -50,7 +51,7 @@ namespace Lucene.Net.Util.Packed
public override long Get(int index)
{
long majorBitPos = (long)index * m_bitsPerValue;
- long elementPos = (long)((ulong)majorBitPos >> 3);
+ long elementPos = majorBitPos.TripleShift(3);
try
{
@in.Seek(startPointer + elementPos);
@@ -62,7 +63,7 @@ namespace Lucene.Net.Util.Packed
int shiftRightBits = roundedBits - bitPos - m_bitsPerValue;
long rawValue;
- switch ((int)((uint)roundedBits >> 3))
+ switch (roundedBits.TripleShift(3))
{
case 1:
rawValue = @in.ReadByte();
@@ -106,7 +107,7 @@ namespace Lucene.Net.Util.Packed
default:
throw new InvalidOperationException("bitsPerValue too large: " + m_bitsPerValue);
}
- return ((long)((ulong)rawValue >> shiftRightBits)) & valueMask;
+ return (rawValue.TripleShift(shiftRightBits)) & valueMask;
}
catch (IOException ioe)
{
diff --git a/src/Lucene.Net/Util/Packed/EliasFanoDecoder.cs b/src/Lucene.Net/Util/Packed/EliasFanoDecoder.cs
index 12a00a3..acdf86e 100644
--- a/src/Lucene.Net/Util/Packed/EliasFanoDecoder.cs
+++ b/src/Lucene.Net/Util/Packed/EliasFanoDecoder.cs
@@ -1,4 +1,4 @@
-using J2N.Numerics;
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using System;
using System.Globalization;
@@ -115,9 +115,9 @@ namespace Lucene.Net.Util.Packed
return 0;
}
long bitPos = packIndex * numBits;
- int index = (int)((long)((ulong)bitPos >> LOG2_INT64_SIZE));
+ int index = (int)(bitPos.TripleShift(LOG2_INT64_SIZE));
int bitPosAtIndex = (int)(bitPos & ((sizeof(long) * 8) - 1));
- long value = (long)((ulong)longArray[index] >> bitPosAtIndex);
+ long value = longArray[index].TripleShift(bitPosAtIndex);
if ((bitPosAtIndex + numBits) > (sizeof(long) * 8))
{
value |= (longArray[index + 1] << ((sizeof(long) * 8) - bitPosAtIndex));
@@ -190,8 +190,8 @@ namespace Lucene.Net.Util.Packed
return false;
}
setBitForIndex += 1;
- int highIndex = (int)((long)((ulong)setBitForIndex >> LOG2_INT64_SIZE));
- curHighLong = (long)((ulong)efEncoder.upperLongs[highIndex] >> CurrentRightShift);
+ int highIndex = (int)(setBitForIndex.TripleShift(LOG2_INT64_SIZE));
+ curHighLong = efEncoder.upperLongs[highIndex].TripleShift(CurrentRightShift);
return true;
}
@@ -205,7 +205,7 @@ namespace Lucene.Net.Util.Packed
{
setBitForIndex += (sizeof(long) * 8) - (setBitForIndex & ((sizeof(long) * 8) - 1));
//assert getCurrentRightShift() == 0;
- int highIndex = (int)((long)((ulong)setBitForIndex >> LOG2_INT64_SIZE));
+ int highIndex = (int)(setBitForIndex.TripleShift(LOG2_INT64_SIZE));
curHighLong = efEncoder.upperLongs[highIndex];
}
@@ -304,12 +304,12 @@ namespace Lucene.Net.Util.Packed
}
setBitForIndex += 1; // the high bit at setBitForIndex belongs to the unary code for efIndex
- int highIndex = (int)((long)((ulong)setBitForIndex >> LOG2_INT64_SIZE));
+ int highIndex = (int)(setBitForIndex.TripleShift(LOG2_INT64_SIZE));
long upperLong = efEncoder.upperLongs[highIndex];
- curHighLong = (long)((ulong)upperLong >> ((int)(setBitForIndex & ((sizeof(long) * 8) - 1)))); // may contain the unary 1 bit for efIndex
+ curHighLong = upperLong.TripleShift(((int)(setBitForIndex & ((sizeof(long) * 8) - 1)))); // may contain the unary 1 bit for efIndex
// determine index entry to advance to
- long highTarget = (long)((ulong)target >> efEncoder.numLowBits);
+ long highTarget = target.TripleShift(efEncoder.numLowBits);
long indexEntryIndex = (highTarget / efEncoder.indexInterval) - 1;
if (indexEntryIndex >= 0) // not before first index entry
@@ -324,9 +324,9 @@ namespace Lucene.Net.Util.Packed
{
setBitForIndex = UnPackValue(efEncoder.upperZeroBitPositionIndex, efEncoder.nIndexEntryBits, indexEntryIndex, indexMask);
efIndex = setBitForIndex - indexHighValue; // the high bit at setBitForIndex belongs to the unary code for efIndex
- highIndex = (int)(((ulong)setBitForIndex >> LOG2_INT64_SIZE));
+ highIndex = (int)setBitForIndex.TripleShift(LOG2_INT64_SIZE);
upperLong = efEncoder.upperLongs[highIndex];
- curHighLong = (long)((ulong)upperLong >> ((int)(setBitForIndex & ((sizeof(long) * 8) - 1)))); // may contain the unary 1 bit for efIndex
+ curHighLong = upperLong.TripleShift((int)(setBitForIndex & ((sizeof(long) * 8) - 1))); // may contain the unary 1 bit for efIndex
}
if (Debugging.AssertsEnabled) Debugging.Assert(efIndex < numEncoded); // there is a high value to be found.
}
@@ -344,7 +344,7 @@ namespace Lucene.Net.Util.Packed
}
setBitForIndex += (sizeof(long) * 8) - (setBitForIndex & ((sizeof(long) * 8) - 1));
// highIndex = (int)(setBitForIndex >>> LOG2_LONG_SIZE);
- if (Debugging.AssertsEnabled) Debugging.Assert((highIndex + 1) == (int)((long)((ulong)setBitForIndex >> LOG2_INT64_SIZE)));
+ if (Debugging.AssertsEnabled) Debugging.Assert((highIndex + 1) == (int)(setBitForIndex.TripleShift(LOG2_INT64_SIZE)));
highIndex += 1;
upperLong = efEncoder.upperLongs[highIndex];
curHighLong = upperLong;
@@ -355,7 +355,7 @@ namespace Lucene.Net.Util.Packed
while (curHighLong == 0L)
{
setBitForIndex += (sizeof(long) * 8) - (setBitForIndex & ((sizeof(long) * 8) - 1));
- if (Debugging.AssertsEnabled) Debugging.Assert((highIndex + 1) == (int)((ulong)setBitForIndex >> LOG2_INT64_SIZE));
+ if (Debugging.AssertsEnabled) Debugging.Assert((highIndex + 1) == setBitForIndex.TripleShift(LOG2_INT64_SIZE));
highIndex += 1;
upperLong = efEncoder.upperLongs[highIndex];
curHighLong = upperLong;
@@ -379,22 +379,22 @@ namespace Lucene.Net.Util.Packed
if ((setBitForIndex & ((sizeof(long) * 8) - 1)) == 0L) // exhausted curHighLong
{
- if (Debugging.AssertsEnabled) Debugging.Assert((highIndex + 1) == (int)((ulong)setBitForIndex >> LOG2_INT64_SIZE));
+ if (Debugging.AssertsEnabled) Debugging.Assert((highIndex + 1) == setBitForIndex.TripleShift(LOG2_INT64_SIZE));
highIndex += 1;
upperLong = efEncoder.upperLongs[highIndex];
curHighLong = upperLong;
}
else
{
- if (Debugging.AssertsEnabled) Debugging.Assert(highIndex == (int)((ulong)setBitForIndex >> LOG2_INT64_SIZE));
- curHighLong = (long)((ulong)upperLong >> ((int)(setBitForIndex & ((sizeof(long) * 8) - 1))));
+ if (Debugging.AssertsEnabled) Debugging.Assert(highIndex == setBitForIndex.TripleShift(LOG2_INT64_SIZE));
+ curHighLong = upperLong.TripleShift(((int)(setBitForIndex & ((sizeof(long) * 8) - 1))));
}
// curHighLong has enough clear bits to reach highTarget, and may not have enough set bits.
while (curHighLong == 0L)
{
setBitForIndex += (sizeof(long) * 8) - (setBitForIndex & ((sizeof(long) * 8) - 1));
- if (Debugging.AssertsEnabled) Debugging.Assert((highIndex + 1) == (int)((ulong)setBitForIndex >> LOG2_INT64_SIZE));
+ if (Debugging.AssertsEnabled) Debugging.Assert((highIndex + 1) == setBitForIndex.TripleShift(LOG2_INT64_SIZE));
highIndex += 1;
upperLong = efEncoder.upperLongs[highIndex];
curHighLong = upperLong;
@@ -425,7 +425,7 @@ namespace Lucene.Net.Util.Packed
public virtual void ToAfterSequence()
{
efIndex = numEncoded; // just after last index
- setBitForIndex = ((long)((ulong)efEncoder.lastEncoded >> efEncoder.numLowBits)) + numEncoded;
+ setBitForIndex = (efEncoder.lastEncoded.TripleShift(efEncoder.numLowBits)) + numEncoded;
}
/// <returns> the number of bits in a long before (<see cref="setBitForIndex"/> modulo <c>sizeof(long)</c>) </returns>
@@ -450,7 +450,7 @@ namespace Lucene.Net.Util.Packed
return false;
}
setBitForIndex -= 1;
- int highIndex = (int)((ulong)setBitForIndex >> LOG2_INT64_SIZE);
+ int highIndex = (int)setBitForIndex.TripleShift(LOG2_INT64_SIZE);
curHighLong = efEncoder.upperLongs[highIndex] << CurrentLeftShift;
return true;
}
@@ -465,7 +465,7 @@ namespace Lucene.Net.Util.Packed
{
setBitForIndex -= (setBitForIndex & ((sizeof(long) * 8) - 1)) + 1;
//assert getCurrentLeftShift() == 0;
- int highIndex = (int)((ulong)setBitForIndex >> LOG2_INT64_SIZE);
+ int highIndex = (int)setBitForIndex.TripleShift(LOG2_INT64_SIZE);
curHighLong = efEncoder.upperLongs[highIndex];
}
@@ -549,7 +549,7 @@ namespace Lucene.Net.Util.Packed
{
return NO_MORE_VALUES;
}
- long highTarget = (long)((ulong)target >> efEncoder.numLowBits);
+ long highTarget = target.TripleShift(efEncoder.numLowBits);
long highValue = BackToHighValue(highTarget);
if (highValue == NO_MORE_VALUES)
{
diff --git a/src/Lucene.Net/Util/Packed/EliasFanoEncoder.cs b/src/Lucene.Net/Util/Packed/EliasFanoEncoder.cs
index 6457e84..0d438c1 100644
--- a/src/Lucene.Net/Util/Packed/EliasFanoEncoder.cs
+++ b/src/Lucene.Net/Util/Packed/EliasFanoEncoder.cs
@@ -1,4 +1,4 @@
-using J2N.Numerics;
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Support;
using System;
@@ -81,7 +81,7 @@ namespace Lucene.Net.Util.Packed
///
/// <para/>The articles originally describing the Elias-Fano representation are:
/// <para/>Peter Elias, "Efficient storage and retrieval by content and address of static files",
- /// J. Assoc. Comput. Mach., 21(2):246�"260, 1974.
+ /// J. Assoc. Comput. Mach., 21(2):246â€"260, 1974.
/// <para/>Robert M. Fano, "On the number of bits required to implement an associative memory",
/// Memorandum 61, Computer Structures Group, Project MAC, MIT, Cambridge, Mass., 1971.
/// <para/>
@@ -169,7 +169,7 @@ namespace Lucene.Net.Util.Packed
}
}
this.numLowBits = nLowBits;
- this.lowerBitsMask = (long)(unchecked((ulong)long.MaxValue) >> (sizeof(long) * 8 - 1 - this.numLowBits));
+ this.lowerBitsMask = long.MaxValue.TripleShift(sizeof(long) * 8 - 1 - this.numLowBits);
long numLongsForLowBits = NumInt64sForBits(numValues * numLowBits);
if (numLongsForLowBits > int.MaxValue)
@@ -178,7 +178,7 @@ namespace Lucene.Net.Util.Packed
}
this.lowerLongs = new long[(int)numLongsForLowBits];
- long numHighBitsClear = (long)((ulong)((this.upperBound > 0) ? this.upperBound : 0) >> this.numLowBits);
+ long numHighBitsClear = ((this.upperBound > 0) ? this.upperBound : 0).TripleShift(this.numLowBits);
if (Debugging.AssertsEnabled) Debugging.Assert(numHighBitsClear <= (2 * this.numValues));
long numHighBitsSet = this.numValues;
@@ -193,7 +193,7 @@ namespace Lucene.Net.Util.Packed
throw new ArgumentException("indexInterval should at least 2: " + indexInterval);
}
// For the index:
- long maxHighValue = (long)((ulong)upperBound >> this.numLowBits);
+ long maxHighValue = upperBound.TripleShift(this.numLowBits);
long nIndexEntries = maxHighValue / indexInterval; // no zero value index entry
this.numIndexEntries = (nIndexEntries >= 0) ? nIndexEntries : 0;
long maxIndexEntry = maxHighValue + numValues - 1; // clear upper bits, set upper bits, start at zero
@@ -223,7 +223,7 @@ namespace Lucene.Net.Util.Packed
private static long NumInt64sForBits(long numBits) // Note: int version in FixedBitSet.bits2words()
{
if (Debugging.AssertsEnabled) Debugging.Assert(numBits >= 0, "{0}", numBits);
- return (long)((ulong)(numBits + (sizeof(long) * 8 - 1)) >> LOG2_INT64_SIZE);
+ return (numBits + (sizeof(long) * 8 - 1)).TripleShift(LOG2_INT64_SIZE);
}
/// <summary>
@@ -249,7 +249,7 @@ namespace Lucene.Net.Util.Packed
{
throw new ArgumentException(x + " larger than upperBound " + upperBound);
}
- long highValue = (long)((ulong)x >> numLowBits);
+ long highValue = x.TripleShift(numLowBits);
EncodeUpperBits(highValue);
EncodeLowerBits(x & lowerBitsMask);
lastEncoded = x;
@@ -269,7 +269,7 @@ namespace Lucene.Net.Util.Packed
private void EncodeUpperBits(long highValue)
{
long nextHighBitNum = numEncoded + highValue; // sequence of unary gaps
- upperLongs[(int)((long)((ulong)nextHighBitNum >> LOG2_INT64_SIZE))] |= (1L << (int)(nextHighBitNum & ((sizeof(long) * 8) - 1)));
+ upperLongs[(int)(nextHighBitNum.TripleShift(LOG2_INT64_SIZE))] |= (1L << (int)(nextHighBitNum & ((sizeof(long) * 8) - 1)));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -284,12 +284,12 @@ namespace Lucene.Net.Util.Packed
if (numBits != 0)
{
long bitPos = numBits * packIndex;
- int index = (int)((long)((ulong)bitPos >> LOG2_INT64_SIZE));
+ int index = (int)(bitPos.TripleShift(LOG2_INT64_SIZE));
int bitPosAtIndex = (int)(bitPos & ((sizeof(long) * 8) - 1));
longArray[index] |= (value << bitPosAtIndex);
if ((bitPosAtIndex + numBits) > (sizeof(long) * 8))
{
- longArray[index + 1] = ((long)((ulong)value >> ((sizeof(long) * 8) - bitPosAtIndex)));
+ longArray[index + 1] = value.TripleShift((sizeof(long) * 8) - bitPosAtIndex);
}
}
}
diff --git a/src/Lucene.Net/Util/Packed/MonotonicAppendingLongBuffer.cs b/src/Lucene.Net/Util/Packed/MonotonicAppendingLongBuffer.cs
index ffb8afb..a59a619 100644
--- a/src/Lucene.Net/Util/Packed/MonotonicAppendingLongBuffer.cs
+++ b/src/Lucene.Net/Util/Packed/MonotonicAppendingLongBuffer.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Support;
using System;
@@ -36,7 +37,7 @@ namespace Lucene.Net.Util.Packed
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static long ZigZagDecode(long n)
{
- return (((long)((ulong)n >> 1)) ^ -(n & 1));
+ return (n.TripleShift(1) ^ -(n & 1));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
diff --git a/src/Lucene.Net/Util/Packed/MonotonicBlockPackedReader.cs b/src/Lucene.Net/Util/Packed/MonotonicBlockPackedReader.cs
index 3acd831..cca6ea4 100644
--- a/src/Lucene.Net/Util/Packed/MonotonicBlockPackedReader.cs
+++ b/src/Lucene.Net/Util/Packed/MonotonicBlockPackedReader.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Store;
using System;
@@ -79,7 +80,7 @@ namespace Lucene.Net.Util.Packed
public override long Get(long index)
{
if (Debugging.AssertsEnabled) Debugging.Assert(index >= 0 && index < valueCount);
- int block = (int)((long)((ulong)index >> blockShift));
+ int block = (int)(index.TripleShift(blockShift));
int idx = (int)(index & blockMask);
// LUCENENET NOTE: IMPORTANT: The cast to float is critical here for it to work in x86
return minValues[block] + (long)(float)(idx * averages[block]) + BlockPackedReaderIterator.ZigZagDecode(subReaders[block].Get(idx));
diff --git a/src/Lucene.Net/Util/Packed/Packed16ThreeBlocks.cs b/src/Lucene.Net/Util/Packed/Packed16ThreeBlocks.cs
index a19570e..e22793a 100644
--- a/src/Lucene.Net/Util/Packed/Packed16ThreeBlocks.cs
+++ b/src/Lucene.Net/Util/Packed/Packed16ThreeBlocks.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Support;
using System;
@@ -89,8 +90,8 @@ namespace Lucene.Net.Util.Packed
public override void Set(int index, long value)
{
int o = index * 3;
- blocks[o] = (short)((long)((ulong)value >> 32));
- blocks[o + 1] = (short)((long)((ulong)value >> 16));
+ blocks[o] = (short)(value.TripleShift(32));
+ blocks[o + 1] = (short)(value.TripleShift(16));
blocks[o + 2] = (short)value;
}
@@ -107,8 +108,8 @@ namespace Lucene.Net.Util.Packed
for (int i = off, o = index * 3, end = off + sets; i < end; ++i)
{
long value = arr[i];
- blocks[o++] = (short)((long)((ulong)value >> 32));
- blocks[o++] = (short)((long)((ulong)value >> 16));
+ blocks[o++] = (short)(value.TripleShift(32));
+ blocks[o++] = (short)(value.TripleShift(16));
blocks[o++] = (short)value;
}
return sets;
@@ -116,8 +117,8 @@ namespace Lucene.Net.Util.Packed
public override void Fill(int fromIndex, int toIndex, long val)
{
- short block1 = (short)((long)((ulong)val >> 32));
- short block2 = (short)((long)((ulong)val >> 16));
+ short block1 = (short)(val.TripleShift(32));
+ short block2 = (short)(val.TripleShift(16));
short block3 = (short)val;
for (int i = fromIndex * 3, end = toIndex * 3; i < end; i += 3)
{
diff --git a/src/Lucene.Net/Util/Packed/Packed64.cs b/src/Lucene.Net/Util/Packed/Packed64.cs
index 9c21f70..ef57134 100644
--- a/src/Lucene.Net/Util/Packed/Packed64.cs
+++ b/src/Lucene.Net/Util/Packed/Packed64.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Support;
using System;
@@ -75,7 +76,7 @@ namespace Lucene.Net.Util.Packed
PackedInt32s.Format format = PackedInt32s.Format.PACKED;
int longCount = format.Int64Count(PackedInt32s.VERSION_CURRENT, valueCount, bitsPerValue);
this.blocks = new long[longCount];
- maskRight = (long)((ulong)(~0L << (BLOCK_SIZE - bitsPerValue)) >> (BLOCK_SIZE - bitsPerValue));
+ maskRight = (~0L << (BLOCK_SIZE - bitsPerValue)).TripleShift(BLOCK_SIZE - bitsPerValue);
bpvMinusBlockSize = bitsPerValue - BLOCK_SIZE;
}
@@ -109,7 +110,7 @@ namespace Lucene.Net.Util.Packed
}
blocks[blocks.Length - 1] = lastLong;
}
- maskRight = (long)((ulong)(~0L << (BLOCK_SIZE - bitsPerValue)) >> (BLOCK_SIZE - bitsPerValue));
+ maskRight = (~0L << (BLOCK_SIZE - bitsPerValue)).TripleShift(BLOCK_SIZE - bitsPerValue);
bpvMinusBlockSize = bitsPerValue - BLOCK_SIZE;
}
@@ -120,16 +121,16 @@ namespace Lucene.Net.Util.Packed
// The abstract index in a bit stream
long majorBitPos = (long)index * m_bitsPerValue;
// The index in the backing long-array
- int elementPos = (int)(((ulong)majorBitPos) >> BLOCK_BITS);
+ int elementPos = (int)majorBitPos.TripleShift(BLOCK_BITS);
// The number of value-bits in the second long
long endBits = (majorBitPos & MOD_MASK) + bpvMinusBlockSize;
if (endBits <= 0) // Single block
{
- return ((long)((ulong)blocks[elementPos] >> (int)-endBits)) & maskRight;
+ return (blocks[elementPos].TripleShift((int)-endBits)) & maskRight;
}
// Two blocks
- return ((blocks[elementPos] << (int)endBits) | ((long)((ulong)blocks[elementPos + 1] >> (int)(BLOCK_SIZE - endBits)))) & maskRight;
+ return ((blocks[elementPos] << (int)endBits) | (blocks[elementPos + 1].TripleShift((int)(BLOCK_SIZE - endBits)))) & maskRight;
}
public override int Get(int index, long[] arr, int off, int len)
@@ -159,7 +160,7 @@ namespace Lucene.Net.Util.Packed
// bulk get
if (Debugging.AssertsEnabled) Debugging.Assert(index % decoder.Int64ValueCount == 0);
- int blockIndex = (int)((ulong)((long)index * m_bitsPerValue) >> BLOCK_BITS);
+ int blockIndex = (int)(((long)index * m_bitsPerValue).TripleShift(BLOCK_BITS));
if (Debugging.AssertsEnabled) Debugging.Assert((((long)index * m_bitsPerValue) & MOD_MASK) == 0);
int iterations = len / decoder.Int64ValueCount;
decoder.Decode(blocks, blockIndex, arr, off, iterations);
@@ -186,7 +187,7 @@ namespace Lucene.Net.Util.Packed
// The abstract index in a contiguous bit stream
long majorBitPos = (long)index * m_bitsPerValue;
// The index in the backing long-array
- int elementPos = (int)((long)((ulong)majorBitPos >> BLOCK_BITS)); // / BLOCK_SIZE
+ int elementPos = (int)(majorBitPos.TripleShift(BLOCK_BITS)); // / BLOCK_SIZE
// The number of value-bits in the second long
long endBits = (majorBitPos & MOD_MASK) + bpvMinusBlockSize;
@@ -196,8 +197,10 @@ namespace Lucene.Net.Util.Packed
return;
}
// Two blocks
- blocks[elementPos] = blocks[elementPos] & ~((long)((ulong)maskRight >> (int)endBits)) | ((long)((ulong)value >> (int)endBits));
- blocks[elementPos + 1] = blocks[elementPos + 1] & ((long)(unchecked((ulong)~0L) >> (int)endBits)) | (value << (int)(BLOCK_SIZE - endBits));
+ blocks[elementPos] = blocks[elementPos] & ~(maskRight.TripleShift((int)endBits))
+ | (value.TripleShift((int)endBits));
+ blocks[elementPos + 1] = blocks[elementPos + 1] & (~0L).TripleShift((int)endBits)
+ | (value << (int)(BLOCK_SIZE - endBits));
}
public override int Set(int index, long[] arr, int off, int len)
@@ -227,7 +230,7 @@ namespace Lucene.Net.Util.Packed
// bulk set
if (Debugging.AssertsEnabled) Debugging.Assert(index % encoder.Int64ValueCount == 0);
- int blockIndex = (int)((ulong)((long)index * m_bitsPerValue) >> BLOCK_BITS);
+ int blockIndex = (int)(((long)index * m_bitsPerValue).TripleShift(BLOCK_BITS));
if (Debugging.AssertsEnabled) Debugging.Assert((((long)index * m_bitsPerValue) & MOD_MASK) == 0);
int iterations = len / encoder.Int64ValueCount;
encoder.Encode(arr, off, blocks, blockIndex, iterations);
@@ -308,8 +311,8 @@ namespace Lucene.Net.Util.Packed
nAlignedValuesBlocks = values.blocks;
if (Debugging.AssertsEnabled) Debugging.Assert(nAlignedBlocks <= nAlignedValuesBlocks.Length);
}
- int startBlock = (int)((ulong)((long)fromIndex * m_bitsPerValue) >> 6);
- int endBlock = (int)((ulong)((long)toIndex * m_bitsPerValue) >> 6);
+ int startBlock = (int)(((long)fromIndex * m_bitsPerValue).TripleShift(6));
+ int endBlock = (int)(((long)toIndex * m_bitsPerValue).TripleShift(6));
for (int block = startBlock; block < endBlock; ++block)
{
long blockValue = nAlignedValuesBlocks[block % nAlignedBlocks];
diff --git a/src/Lucene.Net/Util/Packed/Packed64SingleBlock.cs b/src/Lucene.Net/Util/Packed/Packed64SingleBlock.cs
index 29de919..9ad4d5f 100644
--- a/src/Lucene.Net/Util/Packed/Packed64SingleBlock.cs
+++ b/src/Lucene.Net/Util/Packed/Packed64SingleBlock.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Support;
using System;
@@ -309,15 +310,15 @@ namespace Lucene.Net.Util.Packed
public override long Get(int index)
{
- int o = (int)((uint)index >> 6);
+ int o = index.TripleShift(6);
int b = index & 63;
int shift = b << 0;
- return ((long)((ulong)blocks[o] >> shift)) & 1L;
+ return (blocks[o].TripleShift(shift)) & 1L;
}
public override void Set(int index, long value)
{
- int o = (int)((uint)index >> 6);
+ int o = index.TripleShift(6);
int b = index & 63;
int shift = b << 0;
blocks[o] = (blocks[o] & ~(1L << shift)) | (value << shift);
@@ -333,15 +334,15 @@ namespace Lucene.Net.Util.Packed
public override long Get(int index)
{
- int o = (int)((uint)index >> 5);
+ int o = index.TripleShift(5);
int b = index & 31;
int shift = b << 1;
- return ((long)((ulong)blocks[o] >> shift)) & 3L;
+ return (blocks[o].TripleShift(shift)) & 3L;
}
public override void Set(int index, long value)
{
- int o = (int)((uint)index >> 5);
+ int o = index.TripleShift(5);
int b = index & 31;
int shift = b << 1;
blocks[o] = (blocks[o] & ~(3L << shift)) | (value << shift);
@@ -360,7 +361,7 @@ namespace Lucene.Net.Util.Packed
int o = index / 21;
int b = index % 21;
int shift = b * 3;
- return ((long)((ulong)blocks[o] >> shift)) & 7L;
+ return (blocks[o].TripleShift(shift)) & 7L;
}
public override void Set(int index, long value)
@@ -381,15 +382,15 @@ namespace Lucene.Net.Util.Packed
public override long Get(int index)
{
- int o = (int)((uint)index >> 4);
+ int o = index.TripleShift(4);
int b = index & 15;
int shift = b << 2;
- return ((long)((ulong)blocks[o] >> shift)) & 15L;
+ return (blocks[o].TripleShift(shift)) & 15L;
}
public override void Set(int index, long value)
{
- int o = (int)((uint)index >> 4);
+ int o = index.TripleShift(4);
int b = index & 15;
int shift = b << 2;
blocks[o] = (blocks[o] & ~(15L << shift)) | (value << shift);
@@ -408,7 +409,7 @@ namespace Lucene.Net.Util.Packed
int o = index / 12;
int b = index % 12;
int shift = b * 5;
- return ((long)((ulong)blocks[o] >> shift)) & 31L;
+ return (blocks[o].TripleShift(shift)) & 31L;
}
public override void Set(int index, long value)
@@ -432,7 +433,7 @@ namespace Lucene.Net.Util.Packed
int o = index / 10;
int b = index % 10;
int shift = b * 6;
- return ((long)((ulong)blocks[o] >> shift)) & 63L;
+ return (blocks[o].TripleShift(shift)) & 63L;
}
public override void Set(int index, long value)
@@ -456,7 +457,7 @@ namespace Lucene.Net.Util.Packed
int o = index / 9;
int b = index % 9;
int shift = b * 7;
- return ((long)((ulong)blocks[o] >> shift)) & 127L;
+ return (blocks[o].TripleShift(shift)) & 127L;
}
public override void Set(int index, long value)
@@ -477,15 +478,15 @@ namespace Lucene.Net.Util.Packed
public override long Get(int index)
{
- int o = (int)((uint)index >> 3);
+ int o = index.TripleShift(3);
int b = index & 7;
int shift = b << 3;
- return ((long)((ulong)blocks[o] >> shift)) & 255L;
+ return (blocks[o].TripleShift(shift)) & 255L;
}
public override void Set(int index, long value)
{
- int o = (int)((uint)index >> 3);
+ int o = index.TripleShift(3);
int b = index & 7;
int shift = b << 3;
blocks[o] = (blocks[o] & ~(255L << shift)) | (value << shift);
@@ -504,7 +505,7 @@ namespace Lucene.Net.Util.Packed
int o = index / 7;
int b = index % 7;
int shift = b * 9;
- return ((long)((ulong)blocks[o] >> shift)) & 511L;
+ return (blocks[o].TripleShift(shift)) & 511L;
}
public override void Set(int index, long value)
@@ -528,7 +529,7 @@ namespace Lucene.Net.Util.Packed
int o = index / 6;
int b = index % 6;
int shift = b * 10;
- return ((long)((ulong)blocks[o] >> shift)) & 1023L;
+ return (blocks[o].TripleShift(shift)) & 1023L;
}
public override void Set(int index, long value)
@@ -552,7 +553,7 @@ namespace Lucene.Net.Util.Packed
int o = index / 5;
int b = index % 5;
int shift = b * 12;
- return ((long)((ulong)blocks[o] >> shift)) & 4095L;
+ return (blocks[o].TripleShift(shift)) & 4095L;
}
public override void Set(int index, long value)
@@ -573,15 +574,15 @@ namespace Lucene.Net.Util.Packed
public override long Get(int index)
{
- int o = (int)((uint)index >> 2);
+ int o = index.TripleShift(2);
int b = index & 3;
int shift = b << 4;
- return ((long)((ulong)blocks[o] >> shift)) & 65535L;
+ return (blocks[o].TripleShift(shift)) & 65535L;
}
public override void Set(int index, long value)
{
- int o = (int)((uint)index >> 2);
+ int o = index.TripleShift(2);
int b = index & 3;
int shift = b << 4;
blocks[o] = (blocks[o] & ~(65535L << shift)) | (value << shift);
@@ -600,7 +601,7 @@ namespace Lucene.Net.Util.Packed
int o = index / 3;
int b = index % 3;
int shift = b * 21;
- return ((long)((ulong)blocks[o] >> shift)) & 2097151L;
+ return (blocks[o].TripleShift(shift)) & 2097151L;
}
public override void Set(int index, long value)
@@ -621,15 +622,15 @@ namespace Lucene.Net.Util.Packed
public override long Get(int index)
{
- int o = (int)((uint)index >> 1);
+ int o = index.TripleShift(1);
int b = index & 1;
int shift = b << 5;
- return ((long)((ulong)blocks[o] >> shift)) & 4294967295L;
+ return (blocks[o].TripleShift(shift)) & 4294967295L;
}
public override void Set(int index, long value)
{
- int o = (int)((uint)index >> 1);
+ int o = index.TripleShift(1);
int b = index & 1;
int shift = b << 5;
blocks[o] = (blocks[o] & ~(4294967295L << shift)) | (value << shift);
diff --git a/src/Lucene.Net/Util/Packed/Packed8ThreeBlocks.cs b/src/Lucene.Net/Util/Packed/Packed8ThreeBlocks.cs
index 4ea8619..7539500 100644
--- a/src/Lucene.Net/Util/Packed/Packed8ThreeBlocks.cs
+++ b/src/Lucene.Net/Util/Packed/Packed8ThreeBlocks.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Support;
using System;
@@ -86,8 +87,8 @@ namespace Lucene.Net.Util.Packed
public override void Set(int index, long value)
{
int o = index * 3;
- blocks[o] = (byte)((long)((ulong)value >> 16));
- blocks[o + 1] = (byte)((long)((ulong)value >> 8));
+ blocks[o] = (byte)(value.TripleShift(16));
+ blocks[o + 1] = (byte)(value.TripleShift(8));
blocks[o + 2] = (byte)value;
}
@@ -104,8 +105,8 @@ namespace Lucene.Net.Util.Packed
for (int i = off, o = index * 3, end = off + sets; i < end; ++i)
{
long value = arr[i];
- blocks[o++] = (byte)((long)((ulong)value >> 16));
- blocks[o++] = (byte)((long)((ulong)value >> 8));
+ blocks[o++] = (byte)(value.TripleShift(16));
+ blocks[o++] = (byte)(value.TripleShift(8));
blocks[o++] = (byte)value;
}
return sets;
@@ -113,8 +114,8 @@ namespace Lucene.Net.Util.Packed
public override void Fill(int fromIndex, int toIndex, long val)
{
- var block1 = (byte)((long)((ulong)val >> 16));
- var block2 = (byte)((long)((ulong)val >> 8));
+ var block1 = (byte)(val.TripleShift(16));
+ var block2 = (byte)(val.TripleShift(8));
var block3 = (byte)val;
for (int i = fromIndex * 3, end = toIndex * 3; i < end; i += 3)
{
diff --git a/src/Lucene.Net/Util/Packed/PackedDataInput.cs b/src/Lucene.Net/Util/Packed/PackedDataInput.cs
index 3a64ffd..c859f25 100644
--- a/src/Lucene.Net/Util/Packed/PackedDataInput.cs
+++ b/src/Lucene.Net/Util/Packed/PackedDataInput.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using System;
using System.Runtime.CompilerServices;
@@ -63,7 +64,7 @@ namespace Lucene.Net.Util.Packed
remainingBits = 8;
}
int bits = Math.Min(bitsPerValue, remainingBits);
- r = (r << bits) | (((long)((ulong)current >> (remainingBits - bits))) & ((1L << bits) - 1));
+ r = (r << bits) | ((current.TripleShift((remainingBits - bits))) & ((1L << bits) - 1));
bitsPerValue -= bits;
remainingBits -= bits;
}
diff --git a/src/Lucene.Net/Util/Packed/PackedDataOutput.cs b/src/Lucene.Net/Util/Packed/PackedDataOutput.cs
index 6c9e390..48e193a 100644
--- a/src/Lucene.Net/Util/Packed/PackedDataOutput.cs
+++ b/src/Lucene.Net/Util/Packed/PackedDataOutput.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Diagnostics;
+using J2N.Numerics;
+using Lucene.Net.Diagnostics;
using System;
using System.Runtime.CompilerServices;
@@ -63,7 +64,7 @@ namespace Lucene.Net.Util.Packed
remainingBits = 8;
}
int bits = Math.Min(remainingBits, bitsPerValue);
- current = current | ((((long)((ulong)value >> (bitsPerValue - bits))) & ((1L << bits) - 1)) << (remainingBits - bits));
+ current = current | (((value.TripleShift((bitsPerValue - bits))) & ((1L << bits) - 1)) << (remainingBits - bits));
bitsPerValue -= bits;
remainingBits -= bits;
}
diff --git a/src/Lucene.Net/Util/Packed/PackedInts.cs b/src/Lucene.Net/Util/Packed/PackedInts.cs
index 579d963..d6dcabb 100644
--- a/src/Lucene.Net/Util/Packed/PackedInts.cs
+++ b/src/Lucene.Net/Util/Packed/PackedInts.cs
@@ -1,4 +1,4 @@
-using J2N.Numerics;
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using Lucene.Net.Support;
using System;
@@ -1385,7 +1385,7 @@ namespace Lucene.Net.Util.Packed
Debugging.Assert(srcPos + len <= src.Count);
Debugging.Assert(destPos + len <= dest.Count);
}
- int capacity = (int)((uint)mem >> 3);
+ int capacity = mem.TripleShift(3);
if (capacity == 0)
{
for (int i = 0; i < len; ++i)
diff --git a/src/Lucene.Net/Util/PriorityQueue.cs b/src/Lucene.Net/Util/PriorityQueue.cs
index f2270a3..f331ae2 100644
--- a/src/Lucene.Net/Util/PriorityQueue.cs
+++ b/src/Lucene.Net/Util/PriorityQueue.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Support;
using System;
using System.Collections.Generic;
@@ -291,12 +292,12 @@ namespace Lucene.Net.Util
{
int i = size;
T node = heap[i]; // save bottom node
- int j = (int)((uint)i >> 1);
+ int j = i.TripleShift(1);
while (j > 0 && LessThan(node, heap[j]))
{
heap[i] = heap[j]; // shift parents down
i = j;
- j = (int)((uint)j >> 1);
+ j = j.TripleShift(1);
}
heap[i] = node; // install saved node
}
diff --git a/src/Lucene.Net/Util/RamUsageEstimator.cs b/src/Lucene.Net/Util/RamUsageEstimator.cs
index 6252b31..860ed5f 100644
--- a/src/Lucene.Net/Util/RamUsageEstimator.cs
+++ b/src/Lucene.Net/Util/RamUsageEstimator.cs
@@ -1,4 +1,4 @@
-using J2N.Numerics;
+using J2N.Numerics;
using J2N.Runtime.CompilerServices;
using Lucene.Net.Diagnostics;
using Lucene.Net.Support;
@@ -929,7 +929,7 @@ namespace Lucene.Net.Util
if (Debugging.AssertsEnabled)
{
Debugging.Assert(current > 0 && ((current & (current - 1)) == 0), "Capacity must be a power of two.");
- Debugging.Assert((current << 1) > 0, "Maximum capacity exceeded ({0}).", ((int)((uint)0x80000000 >> 1)));
+ Debugging.Assert((current << 1) > 0, "Maximum capacity exceeded ({0}).", ((int)(0x80000000 >> 1))); // LUCENENET: No need to cast to uint because it already is
}
if (current < MIN_CAPACITY / 2)
@@ -945,9 +945,9 @@ namespace Lucene.Net.Util
private int RoundCapacity(int requestedCapacity) // LUCENENET NOTE: made private, since protected is not valid in a sealed class
{
// Maximum positive integer that is a power of two.
- if (requestedCapacity > ((int)((uint)0x80000000 >> 1)))
+ if (requestedCapacity > ((int)(0x80000000 >> 1))) // LUCENENET: No need to cast to uint because it already is
{
- return ((int)((uint)0x80000000 >> 1));
+ return ((int)(0x80000000 >> 1)); // LUCENENET: No need to cast to uint because it already is
}
int capacity = MIN_CAPACITY;
diff --git a/src/Lucene.Net/Util/Sorter.cs b/src/Lucene.Net/Util/Sorter.cs
index 3c116d0..f26ad62 100644
--- a/src/Lucene.Net/Util/Sorter.cs
+++ b/src/Lucene.Net/Util/Sorter.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using System;
using System.Runtime.CompilerServices;
@@ -86,14 +87,14 @@ namespace Lucene.Net.Util
int len11, len22;
if (mid - from > to - mid)
{
- len11 = (int)((uint)(mid - from) >> 1);
+ len11 = (mid - from).TripleShift(1);
first_cut = from + len11;
second_cut = Lower(mid, to, first_cut);
len22 = second_cut - mid;
}
else
{
- len22 = (int)((uint)(to - mid) >> 1);
+ len22 = (to - mid).TripleShift(1);
second_cut = mid + len22;
first_cut = Upper(from, mid, second_cut);
//len11 = first_cut - from; // LUCENENET: Unnecessary assignment
@@ -110,7 +111,7 @@ namespace Lucene.Net.Util
int len = to - from;
while (len > 0)
{
- int half = (int)((uint)len >> 1);
+ int half = len.TripleShift(1);
int mid = from + half;
if (Compare(mid, val) < 0)
{
@@ -131,7 +132,7 @@ namespace Lucene.Net.Util
int len = to - from;
while (len > 0)
{
- int half = (int)((uint)len >> 1);
+ int half = len.TripleShift(1);
int mid = from + half;
if (Compare(val, mid) < 0)
{
@@ -255,7 +256,7 @@ namespace Lucene.Net.Util
int h = i - 1;
while (l <= h)
{
- int mid = (int)((uint)(l + h) >> 1);
+ int mid = (l + h).TripleShift(1);
int cmp = Compare(i, mid);
if (cmp < 0)
{
@@ -348,7 +349,7 @@ namespace Lucene.Net.Util
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static int HeapParent(int from, int i)
{
- return ((int)((uint)(i - 1 - from) >> 1)) + from;
+ return ((i - 1 - from).TripleShift(1)) + from;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
diff --git a/src/Lucene.Net/Util/StringHelper.cs b/src/Lucene.Net/Util/StringHelper.cs
index 862efbe..50aff05 100644
--- a/src/Lucene.Net/Util/StringHelper.cs
+++ b/src/Lucene.Net/Util/StringHelper.cs
@@ -1,4 +1,4 @@
-using J2N.Numerics;
+using J2N.Numerics;
using J2N.Text;
using System;
using System.Collections.Generic;
@@ -248,11 +248,11 @@ namespace Lucene.Net.Util
h1 ^= len;
// fmix(h1);
- h1 ^= (int)((uint)h1 >> 16);
+ h1 ^= h1.TripleShift(16);
h1 *= unchecked((int)0x85ebca6b);
- h1 ^= (int)((uint)h1 >> 13);
+ h1 ^= h1.TripleShift(13);
h1 *= unchecked((int)0xc2b2ae35);
- h1 ^= (int)((uint)h1 >> 16);
+ h1 ^= h1.TripleShift(16);
return h1;
}
diff --git a/src/Lucene.Net/Util/TimSorter.cs b/src/Lucene.Net/Util/TimSorter.cs
index c950e38..66f960a 100644
--- a/src/Lucene.Net/Util/TimSorter.cs
+++ b/src/Lucene.Net/Util/TimSorter.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using Lucene.Net.Diagnostics;
using System;
using System.Runtime.CompilerServices;
@@ -74,7 +75,7 @@ namespace Lucene.Net.Util
while (n >= 64)
{
r |= n & 1;
- n = (int)((uint)n >> 1);
+ n = n.TripleShift(1);
}
int minRun = n + r;
if (Debugging.AssertsEnabled) Debugging.Assert(minRun >= MINRUN && minRun <= THRESHOLD);
@@ -401,7 +402,7 @@ namespace Lucene.Net.Util
int len = to - from;
while (len > 0)
{
- int half = (int)((uint)len >> 1);
+ int half = len.TripleShift(1);
int mid = from + half;
if (CompareSaved(val, mid) > 0)
{
@@ -422,7 +423,7 @@ namespace Lucene.Net.Util
int len = to - from;
while (len > 0)
{
- int half = (int)((uint)len >> 1);
+ int half = len.TripleShift(1);
int mid = from + half;
if (CompareSaved(val, mid) < 0)
{
diff --git a/src/Lucene.Net/Util/ToStringUtils.cs b/src/Lucene.Net/Util/ToStringUtils.cs
index be6074e..a53c093 100644
--- a/src/Lucene.Net/Util/ToStringUtils.cs
+++ b/src/Lucene.Net/Util/ToStringUtils.cs
@@ -1,3 +1,4 @@
+using J2N.Numerics;
using System.Globalization;
using System.Text;
@@ -59,7 +60,7 @@ namespace Lucene.Net.Util
public static string Int64Hex(long x)
{
char[] asHex = new char[16];
- for (int i = 16; --i >= 0; x = (long)((ulong)x >> 4))
+ for (int i = 16; --i >= 0; x = x.TripleShift(4))
{
asHex[i] = HEX[(int)x & 0x0F];
}
diff --git a/src/Lucene.Net/Util/WAH8DocIdSet.cs b/src/Lucene.Net/Util/WAH8DocIdSet.cs
index 7ebe22c..432e05b 100644
--- a/src/Lucene.Net/Util/WAH8DocIdSet.cs
+++ b/src/Lucene.Net/Util/WAH8DocIdSet.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Diagnostics;
+using J2N.Numerics;
+using Lucene.Net.Diagnostics;
using Lucene.Net.Support;
using System;
using System.Collections.Generic;
@@ -257,7 +258,7 @@ namespace Lucene.Net.Util
internal static int WordNum(int docID)
{
if (Debugging.AssertsEnabled) Debugging.Assert(docID >= 0);
- return (int)((uint)docID >> 3);
+ return docID.TripleShift(3);
}
/// <summary>
@@ -327,11 +328,11 @@ namespace Lucene.Net.Util
@out.WriteByte((byte)token);
if (cleanLengthMinus2 > 0x03)
{
- @out.WriteVInt32((int)((uint)cleanLengthMinus2 >> 2));
+ @out.WriteVInt32(cleanLengthMinus2.TripleShift(2));
}
if (dirtyLength > 0x07)
{
- @out.WriteVInt32((int)((uint)dirtyLength >> 3));
+ @out.WriteVInt32(dirtyLength.TripleShift(3));
}
}
@@ -611,7 +612,7 @@ namespace Lucene.Net.Util
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static int ReadCleanLength(ByteArrayDataInput @in, int token)
{
- int len = ((int)((uint)token >> 4)) & 0x07;
+ int len = (token.TripleShift(4)) & 0x07;
int startPosition = @in.Position;
if ((len & 0x04) != 0)
{
@@ -792,7 +793,7 @@ namespace Lucene.Net.Util
// we found a window containing our target, let's binary search now
while (lo <= hi)
{
- int mid = (int)((uint)(lo + hi) >> 1);
+ int mid = (lo + hi).TripleShift(1);
int midWordNum = (int)wordNums.Get(mid);
if (midWordNum <= targetWordNum)
{
@@ -865,7 +866,7 @@ namespace Lucene.Net.Util
if (bitList != 0) // there are remaining bits in the current word
{
docID = (wordNum << 3) | ((bitList & 0x0F) - 1);
- bitList = (int)((uint)bitList >> 4);
+ bitList = bitList.TripleShift(4);
return docID;
}
NextWord();
@@ -876,7 +877,7 @@ namespace Lucene.Net.Util
bitList = BitUtil.BitList(word);
if (Debugging.AssertsEnabled) Debugging.Assert(bitList != 0);
docID = (wordNum << 3) | ((bitList & 0x0F) - 1);
- bitList = (int)((uint)bitList >> 4);
+ bitList = bitList.TripleShift(4);
return docID;
}