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:35 UTC
[lucenenet] 03/05: SWEEP: Replaced 2 casts with call to TripleShift
method for unsigned right shift
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;
}