lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [05/53] [abbrv] lucenenet git commit: Lucene.Net.Core: Renamed all type-derived properties and methods from Short, Int, Long, and Float to match CLR types Int16, Int32, Int64, and Single, respectively.
Date Wed, 08 Feb 2017 14:31:44 GMT
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Core/Util/Packed/PackedInts.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Packed/PackedInts.cs b/src/Lucene.Net.Core/Util/Packed/PackedInts.cs
index e04d916..6b2997a 100644
--- a/src/Lucene.Net.Core/Util/Packed/PackedInts.cs
+++ b/src/Lucene.Net.Core/Util/Packed/PackedInts.cs
@@ -248,7 +248,10 @@ namespace Lucene.Net.Util.Packed
             {
             }
 
-            public override int LongCount(int packedIntsVersion, int valueCount, int bitsPerValue)
+            /// <summary>
+            /// NOTE: This was longCount() in Lucene
+            /// </summary>
+            public override int Int64Count(int packedIntsVersion, int valueCount, int bitsPerValue)
             {
                 int valuesPerBlock = 64 / bitsPerValue;
                 return (int)Math.Ceiling((double)valueCount / valuesPerBlock);
@@ -308,10 +311,13 @@ namespace Lucene.Net.Util.Packed
             public virtual long ByteCount(int packedIntsVersion, int valueCount, int bitsPerValue)
             {
                 // assume long-aligned
-                return 8L * LongCount(packedIntsVersion, valueCount, bitsPerValue);
+                return 8L * Int64Count(packedIntsVersion, valueCount, bitsPerValue);
             }
 
-            public virtual int LongCount(int packedIntsVersion, int valueCount, int bitsPerValue) // LUCENENET TODO: Rename Int64Count ?
+            /// <summary>
+            /// NOTE: This was longCount() in Lucene
+            /// </summary>
+            public virtual int Int64Count(int packedIntsVersion, int valueCount, int bitsPerValue)
             {
                 long byteCount = ByteCount(packedIntsVersion, valueCount, bitsPerValue);
 
@@ -447,14 +453,18 @@ namespace Lucene.Net.Util.Packed
             /// <summary>
             /// The minimum number of long blocks to encode in a single iteration, when
             /// using long encoding.
+            /// <para/>
+            /// NOTE: This was longBlockCount() in Lucene
             /// </summary>
-            int LongBlockCount { get; } // LUCENENET TODO: Rename Int64BlockCount ?
+            int Int64BlockCount { get; }
 
             /// <summary>
             /// The number of values that can be stored in <seealso cref="#longBlockCount()"/> long
             /// blocks.
+            /// <para/>
+            /// NOTE: This was longValueCount() in Lucene
             /// </summary>
-            int LongValueCount { get; } // LUCENENET TODO: Rename Int64ValueCount ?
+            int Int64ValueCount { get; }
 
             /// <summary>
             /// The minimum number of byte blocks to encode in a single iteration, when
@@ -525,14 +535,18 @@ namespace Lucene.Net.Util.Packed
             /// <summary>
             /// The minimum number of long blocks to encode in a single iteration, when
             /// using long encoding.
+            /// <para/>
+            /// NOTE: This was longBlockCount() in Lucene
             /// </summary>
-            int LongBlockCount { get; } // LUCENENET TODO: Rename Int64BlockCount ?
+            int Int64BlockCount { get; }
 
             /// <summary>
             /// The number of values that can be stored in <seealso cref="#longBlockCount()"/> long
             /// blocks.
+            /// <para/>
+            /// NOTE: This was longValueCount() in Lucene
             /// </summary>
-            int LongValueCount { get; } // LUCENENET TODO:  Rename Int64ValueCount ?
+            int Int64ValueCount { get; }
 
             /// <summary>
             /// The minimum number of byte blocks to encode in a single iteration, when
@@ -711,7 +725,7 @@ namespace Lucene.Net.Util.Packed
             {
                 LongsRef nextValues = Next(1);
                 Debug.Assert(nextValues.Length > 0);
-                long result = nextValues.Longs[nextValues.Offset];
+                long result = nextValues.Int64s[nextValues.Offset];
                 ++nextValues.Offset;
                 --nextValues.Length;
                 return result;
@@ -943,9 +957,9 @@ namespace Lucene.Net.Util.Packed
             {
                 Debug.Assert(m_valueCount != -1);
                 CodecUtil.WriteHeader(m_out, CODEC_NAME, VERSION_CURRENT);
-                m_out.WriteVInt(m_bitsPerValue);
-                m_out.WriteVInt(m_valueCount);
-                m_out.WriteVInt(Format.Id);
+                m_out.WriteVInt32(m_bitsPerValue);
+                m_out.WriteVInt32(m_valueCount);
+                m_out.WriteVInt32(Format.Id);
             }
 
             /// <summary>
@@ -1087,10 +1101,10 @@ namespace Lucene.Net.Util.Packed
         public static Reader GetReader(DataInput @in)
         {
             int version = CodecUtil.CheckHeader(@in, CODEC_NAME, VERSION_START, VERSION_CURRENT);
-            int bitsPerValue = @in.ReadVInt();
+            int bitsPerValue = @in.ReadVInt32();
             Debug.Assert(bitsPerValue > 0 && bitsPerValue <= 64, "bitsPerValue=" + bitsPerValue);
-            int valueCount = @in.ReadVInt();
-            Format format = Format.ById(@in.ReadVInt());
+            int valueCount = @in.ReadVInt32();
+            Format format = Format.ById(@in.ReadVInt32());
 
             return GetReaderNoHeader(@in, format, version, valueCount, bitsPerValue);
         }
@@ -1126,10 +1140,10 @@ namespace Lucene.Net.Util.Packed
         public static IReaderIterator GetReaderIterator(DataInput @in, int mem)
         {
             int version = CodecUtil.CheckHeader(@in, CODEC_NAME, VERSION_START, VERSION_CURRENT);
-            int bitsPerValue = @in.ReadVInt();
+            int bitsPerValue = @in.ReadVInt32();
             Debug.Assert(bitsPerValue > 0 && bitsPerValue <= 64, "bitsPerValue=" + bitsPerValue);
-            int valueCount = @in.ReadVInt();
-            Format format = Format.ById(@in.ReadVInt());
+            int valueCount = @in.ReadVInt32();
+            Format format = Format.ById(@in.ReadVInt32());
             return GetReaderIteratorNoHeader(@in, format, version, valueCount, bitsPerValue, mem);
         }
 
@@ -1246,10 +1260,10 @@ namespace Lucene.Net.Util.Packed
         public static Reader GetDirectReader(IndexInput @in)
         {
             int version = CodecUtil.CheckHeader(@in, CODEC_NAME, VERSION_START, VERSION_CURRENT);
-            int bitsPerValue = @in.ReadVInt();
+            int bitsPerValue = @in.ReadVInt32();
             Debug.Assert(bitsPerValue > 0 && bitsPerValue <= 64, "bitsPerValue=" + bitsPerValue);
-            int valueCount = @in.ReadVInt();
-            Format format = Format.ById(@in.ReadVInt());
+            int valueCount = @in.ReadVInt32();
+            Format format = Format.ById(@in.ReadVInt32());
             return GetDirectReaderNoHeader(@in, format, version, valueCount, bitsPerValue);
         }
 
@@ -1512,10 +1526,10 @@ namespace Lucene.Net.Util.Packed
         public static Header ReadHeader(DataInput @in)
         {
             int version = CodecUtil.CheckHeader(@in, CODEC_NAME, VERSION_START, VERSION_CURRENT);
-            int bitsPerValue = @in.ReadVInt();
+            int bitsPerValue = @in.ReadVInt32();
             Debug.Assert(bitsPerValue > 0 && bitsPerValue <= 64, "bitsPerValue=" + bitsPerValue);
-            int valueCount = @in.ReadVInt();
-            Format format = Format.ById(@in.ReadVInt());
+            int valueCount = @in.ReadVInt32();
+            Format format = Format.ById(@in.ReadVInt32());
             return new Header(format, valueCount, bitsPerValue, version);
         }
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Core/Util/Packed/PackedReaderIterator.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Packed/PackedReaderIterator.cs b/src/Lucene.Net.Core/Util/Packed/PackedReaderIterator.cs
index 9dd90c9..27a0680 100644
--- a/src/Lucene.Net.Core/Util/Packed/PackedReaderIterator.cs
+++ b/src/Lucene.Net.Core/Util/Packed/PackedReaderIterator.cs
@@ -43,7 +43,7 @@ namespace Lucene.Net.Util.Packed
             Debug.Assert(valueCount == 0 || iterations > 0);
             nextBlocks = new byte[iterations * bulkOperation.ByteBlockCount];
             nextValues = new LongsRef(new long[iterations * bulkOperation.ByteValueCount], 0, 0);
-            nextValues.Offset = nextValues.Longs.Length;
+            nextValues.Offset = nextValues.Int64s.Length;
             position = -1;
         }
 
@@ -62,7 +62,7 @@ namespace Lucene.Net.Util.Packed
         {
             Debug.Assert(nextValues.Length >= 0);
             Debug.Assert(count > 0);
-            Debug.Assert(nextValues.Offset + nextValues.Length <= nextValues.Longs.Length);
+            Debug.Assert(nextValues.Offset + nextValues.Length <= nextValues.Int64s.Length);
 
             nextValues.Offset += nextValues.Length;
 
@@ -73,7 +73,7 @@ namespace Lucene.Net.Util.Packed
             }
             count = Math.Min(remaining, count);
 
-            if (nextValues.Offset == nextValues.Longs.Length)
+            if (nextValues.Offset == nextValues.Int64s.Length)
             {
                 long remainingBlocks = format.ByteCount(packedIntsVersion, remaining, m_bitsPerValue);
                 int blocksToRead = (int)Math.Min(remainingBlocks, nextBlocks.Length);
@@ -83,11 +83,11 @@ namespace Lucene.Net.Util.Packed
                     Arrays.Fill(nextBlocks, blocksToRead, nextBlocks.Length, (byte)0);
                 }
 
-                bulkOperation.Decode(nextBlocks, 0, nextValues.Longs, 0, iterations);
+                bulkOperation.Decode(nextBlocks, 0, nextValues.Int64s, 0, iterations);
                 nextValues.Offset = 0;
             }
 
-            nextValues.Length = Math.Min(nextValues.Longs.Length - nextValues.Offset, count);
+            nextValues.Length = Math.Min(nextValues.Int64s.Length - nextValues.Offset, count);
             position += nextValues.Length;
             return nextValues;
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Core/Util/RecyclingIntBlockAllocator.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/RecyclingIntBlockAllocator.cs b/src/Lucene.Net.Core/Util/RecyclingIntBlockAllocator.cs
index b2b3648..19e7537 100644
--- a/src/Lucene.Net.Core/Util/RecyclingIntBlockAllocator.cs
+++ b/src/Lucene.Net.Core/Util/RecyclingIntBlockAllocator.cs
@@ -79,7 +79,10 @@ namespace Lucene.Net.Util
         {
         }
 
-        public override int[] GetIntBlock() // LUCENENET TODO: Rename GetInt32Block() ?
+        /// <summary>
+        /// NOTE: This was getIntBlock() in Lucene
+        /// </summary>
+        public override int[] GetInt32Block()
         {
             if (freeBlocks == 0)
             {
@@ -91,7 +94,10 @@ namespace Lucene.Net.Util
             return b;
         }
 
-        public override void RecycleIntBlocks(int[][] blocks, int start, int end) // LUCENENET TODO: Rename RecycleInt32Blocks ?
+        /// <summary>
+        /// NOTE: This was recycleIntBlocks in Lucene
+        /// </summary>
+        public override void RecycleInt32Blocks(int[][] blocks, int start, int end)
         {
             int numBlocks = Math.Min(maxBufferedBlocks - freeBlocks, end - start);
             int size = freeBlocks + numBlocks;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Core/Util/SmallFloat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/SmallFloat.cs b/src/Lucene.Net.Core/Util/SmallFloat.cs
index 5053bcf..ca87e46 100644
--- a/src/Lucene.Net.Core/Util/SmallFloat.cs
+++ b/src/Lucene.Net.Core/Util/SmallFloat.cs
@@ -37,13 +37,15 @@ namespace Lucene.Net.Util
         /// <br>Values less than zero are all mapped to zero.
         /// <br>Values are truncated (rounded down) to the nearest 8 bit value.
         /// <br>Values between zero and the smallest representable value
-        ///  are rounded up.
+        /// are rounded up.
+        /// <para/>
+        /// NOTE: This was floatToByte() in Lucene
         /// </summary>
         /// <param name="f"> the 32 bit float to be converted to an 8 bit float (byte) </param>
         /// <param name="numMantissaBits"> the number of mantissa bits to use in the byte, with the remainder to be used in the exponent </param>
         /// <param name="zeroExp"> the zero-point in the range of exponent values </param>
         /// <returns> the 8 bit float representation </returns>
-        public static sbyte FloatToByte(float f, int numMantissaBits, int zeroExp) // LUCENENET TODO: rename SingleToByte ? can we remove the sbyte?
+        public static sbyte SingleToByte(float f, int numMantissaBits, int zeroExp) // LUCENENET TODO: can we remove the sbyte?
         {
             // Adjustment from a float zero exponent to our zero exponent,
             // shifted over to our exponent position.
@@ -65,8 +67,11 @@ namespace Lucene.Net.Util
         }
 
         /// <summary>
-        /// Converts an 8 bit float to a 32 bit float. </summary>
-        public static float ByteToFloat(sbyte b, int numMantissaBits, int zeroExp) // LUCENENET TODO: rename ByteToSingle ? can we remove the sbyte?
+        /// Converts an 8 bit float to a 32 bit float. 
+        /// <para/>
+        /// NOTE: This was byteToFloat() in Lucene
+        /// </summary>
+        public static float ByteToSingle(sbyte b, int numMantissaBits, int zeroExp) // LUCENENET TODO: can we remove the sbyte?
         {
             // on Java1.5 & 1.6 JVMs, prebuilding a decoding array and doing a lookup
             // is only a little bit faster (anywhere from 0% to 7%)
@@ -90,8 +95,10 @@ namespace Lucene.Net.Util
         /// <br>smallest non-zero value = 5.820766E-10
         /// <br>largest value = 7.5161928E9
         /// <br>epsilon = 0.125
+        /// <para/>
+        /// NOTE: This was floatToByte315() in Lucene
         /// </summary>
-        public static sbyte FloatToByte315(float f) // LUCENENET TODO: rename SingleToByte315 ? can we remove the sbyte?
+        public static sbyte SingleToByte315(float f) // LUCENENET TODO: can we remove the sbyte?
         {
             int bits = BitConverter.ToInt32(BitConverter.GetBytes(f), 0);
             int smallfloat = bits >> (24 - 3);
@@ -107,8 +114,11 @@ namespace Lucene.Net.Util
         }
 
         /// <summary>
-        /// byteToFloat(b, mantissaBits=3, zeroExponent=15) </summary>
-        public static float Byte315ToFloat(sbyte b) // LUCENENET TODO: rename Byte315ToSingle ? can we remove the sbyte?
+        /// byteToFloat(b, mantissaBits=3, zeroExponent=15) 
+        /// <para/>
+        /// NOTE: This was byte315ToFloat() in Lucene
+        /// </summary>
+        public static float Byte315ToSingle(sbyte b) // LUCENENET TODO: can we remove the sbyte?
         {
             // on Java1.5 & 1.6 JVMs, prebuilding a decoding array and doing a lookup
             // is only a little bit faster (anywhere from 0% to 7%)
@@ -126,8 +136,10 @@ namespace Lucene.Net.Util
         /// <br>smallest nonzero value = 0.033203125
         /// <br>largest value = 1984.0
         /// <br>epsilon = 0.03125
+        /// <para/>
+        /// NOTE: This was floatToByte52() in Lucene
         /// </summary>
-        public static sbyte FloatToByte52(float f) // LUCENENET TODO: rename SingleToByte52 ? can we remove the sbyte?
+        public static sbyte SingleToByte52(float f) // LUCENENET TODO: can we remove the sbyte?
         {
             int bits = BitConverter.ToInt32(BitConverter.GetBytes(f), 0);
             int smallfloat = bits >> (24 - 5);
@@ -143,8 +155,11 @@ namespace Lucene.Net.Util
         }
 
         /// <summary>
-        /// byteToFloat(b, mantissaBits=5, zeroExponent=2) </summary>
-        public static float Byte52ToFloat(sbyte b) // LUCENENET TODO: rename Byte52ToSingle ? can we remove the sbyte?
+        /// byteToFloat(b, mantissaBits=5, zeroExponent=2) 
+        /// <para/>
+        /// NOTE: This was byte52ToFloat() in Lucene
+        /// </summary>
+        public static float Byte52ToSingle(sbyte b) // LUCENENET TODO: can we remove the sbyte?
         {
             // on Java1.5 & 1.6 JVMs, prebuilding a decoding array and doing a lookup
             // is only a little bit faster (anywhere from 0% to 7%)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Core/Util/ToStringUtils.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/ToStringUtils.cs b/src/Lucene.Net.Core/Util/ToStringUtils.cs
index 0cce51d..af1e127 100644
--- a/src/Lucene.Net.Core/Util/ToStringUtils.cs
+++ b/src/Lucene.Net.Core/Util/ToStringUtils.cs
@@ -57,7 +57,10 @@ namespace Lucene.Net.Util
 
         private static readonly char[] HEX = "0123456789abcdef".ToCharArray();
 
-        public static string LongHex(long x)
+        /// <summary>
+        /// NOTE: This was longHex() in Lucene
+        /// </summary>
+        public static string Int64Hex(long x)
         {
             char[] asHex = new char[16];
             for (int i = 16; --i >= 0; x = (long)((ulong)x >> 4))

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Core/Util/UnicodeUtil.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/UnicodeUtil.cs b/src/Lucene.Net.Core/Util/UnicodeUtil.cs
index 797d5e1..a9d1e34 100644
--- a/src/Lucene.Net.Core/Util/UnicodeUtil.cs
+++ b/src/Lucene.Net.Core/Util/UnicodeUtil.cs
@@ -539,13 +539,13 @@ namespace Lucene.Net.Util
             // TODO: broken if incoming result.offset != 0
             // pre-alloc for worst case
             // TODO: ints cannot be null, should be an assert
-            if (utf32.Ints == null || utf32.Ints.Length < utf8.Length)
+            if (utf32.Int32s == null || utf32.Int32s.Length < utf8.Length)
             {
-                utf32.Ints = new int[utf8.Length];
+                utf32.Int32s = new int[utf8.Length];
             }
             int utf32Count = 0;
             int utf8Upto = utf8.Offset;
-            int[] ints = utf32.Ints;
+            int[] ints = utf32.Int32s;
             var bytes = utf8.Bytes;
             int utf8Limit = utf8.Offset + utf8.Length;
             while (utf8Upto < utf8Limit)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Core/Util/WAH8DocIdSet.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/WAH8DocIdSet.cs b/src/Lucene.Net.Core/Util/WAH8DocIdSet.cs
index 3540399..f6ac44a 100644
--- a/src/Lucene.Net.Core/Util/WAH8DocIdSet.cs
+++ b/src/Lucene.Net.Core/Util/WAH8DocIdSet.cs
@@ -330,11 +330,11 @@ namespace Lucene.Net.Util
                 @out.WriteByte((byte)(sbyte)token);
                 if (cleanLengthMinus2 > 0x03)
                 {
-                    @out.WriteVInt((int)((uint)cleanLengthMinus2 >> 2));
+                    @out.WriteVInt32((int)((uint)cleanLengthMinus2 >> 2));
                 }
                 if (dirtyLength > 0x07)
                 {
-                    @out.WriteVInt((int)((uint)dirtyLength >> 3));
+                    @out.WriteVInt32((int)((uint)dirtyLength >> 3));
                 }
             }
 
@@ -616,7 +616,7 @@ namespace Lucene.Net.Util
             int startPosition = @in.Position;
             if ((len & 0x04) != 0)
             {
-                len = (len & 0x03) | (@in.ReadVInt() << 2);
+                len = (len & 0x03) | (@in.ReadVInt32() << 2);
             }
             if (startPosition != 1)
             {
@@ -630,7 +630,7 @@ namespace Lucene.Net.Util
             int len = token & 0x0F;
             if ((len & 0x08) != 0)
             {
-                len = (len & 0x07) | (@in.ReadVInt() << 3);
+                len = (len & 0x07) | (@in.ReadVInt32() << 3);
             }
             return len;
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Facet/FacetsConfig.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/FacetsConfig.cs b/src/Lucene.Net.Facet/FacetsConfig.cs
index 1d5cb52..adb1af0 100644
--- a/src/Lucene.Net.Facet/FacetsConfig.cs
+++ b/src/Lucene.Net.Facet/FacetsConfig.cs
@@ -425,11 +425,11 @@ namespace Lucene.Net.Facet
 
                     CheckTaxoWriter(taxoWriter);
                     int ordinal = taxoWriter.AddCategory(cp);
-                    if (ordinals.Length == ordinals.Ints.Length)
+                    if (ordinals.Length == ordinals.Int32s.Length)
                     {
                         ordinals.Grow(ordinals.Length + 1);
                     }
-                    ordinals.Ints[ordinals.Length++] = ordinal;
+                    ordinals.Int32s[ordinals.Length++] = ordinal;
                     //System.out.println("ords[" + (ordinals.length-1) + "]=" + ordinal);
                     //System.out.println("  add cp=" + cp);
 
@@ -440,11 +440,11 @@ namespace Lucene.Net.Facet
                         int parent = taxoWriter.GetParent(ordinal);
                         while (parent > 0)
                         {
-                            if (ordinals.Ints.Length == ordinals.Length)
+                            if (ordinals.Int32s.Length == ordinals.Length)
                             {
                                 ordinals.Grow(ordinals.Length + 1);
                             }
-                            ordinals.Ints[ordinals.Length++] = parent;
+                            ordinals.Int32s[ordinals.Length++] = parent;
                             parent = taxoWriter.GetParent(parent);
                         }
 
@@ -538,13 +538,13 @@ namespace Lucene.Net.Facet
         /// </summary>
         protected virtual BytesRef DedupAndEncode(IntsRef ordinals)
         {
-            Array.Sort(ordinals.Ints, ordinals.Offset, ordinals.Length);
+            Array.Sort(ordinals.Int32s, ordinals.Offset, ordinals.Length);
             byte[] bytes = new byte[5 * ordinals.Length];
             int lastOrd = -1;
             int upto = 0;
             for (int i = 0; i < ordinals.Length; i++)
             {
-                int ord = ordinals.Ints[ordinals.Offset + i];
+                int ord = ordinals.Int32s[ordinals.Offset + i];
                 // ord could be == lastOrd, so we must dedup:
                 if (ord > lastOrd)
                 {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Facet/Range/DoubleRange.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Range/DoubleRange.cs b/src/Lucene.Net.Facet/Range/DoubleRange.cs
index 3bdb9fc..3f3d034 100644
--- a/src/Lucene.Net.Facet/Range/DoubleRange.cs
+++ b/src/Lucene.Net.Facet/Range/DoubleRange.cs
@@ -107,7 +107,7 @@ namespace Lucene.Net.Facet.Range
 
         internal LongRange ToLongRange()
         {
-            return new LongRange(Label, NumericUtils.DoubleToSortableLong(minIncl), true, NumericUtils.DoubleToSortableLong(maxIncl), true);
+            return new LongRange(Label, NumericUtils.DoubleToSortableInt64(minIncl), true, NumericUtils.DoubleToSortableInt64(maxIncl), true);
         }
 
         public override string ToString()

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Facet/Range/DoubleRangeFacetCounts.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Range/DoubleRangeFacetCounts.cs b/src/Lucene.Net.Facet/Range/DoubleRangeFacetCounts.cs
index b5ba376..c37f999 100644
--- a/src/Lucene.Net.Facet/Range/DoubleRangeFacetCounts.cs
+++ b/src/Lucene.Net.Facet/Range/DoubleRangeFacetCounts.cs
@@ -91,7 +91,7 @@ namespace Lucene.Net.Facet.Range
             for (int i = 0; i < ranges.Length; i++)
             {
                 DoubleRange range = ranges[i];
-                longRanges[i] = new LongRange(range.Label, NumericUtils.DoubleToSortableLong(range.minIncl), true, NumericUtils.DoubleToSortableLong(range.maxIncl), true);
+                longRanges[i] = new LongRange(range.Label, NumericUtils.DoubleToSortableInt64(range.minIncl), true, NumericUtils.DoubleToSortableInt64(range.maxIncl), true);
             }
 
             LongRangeCounter counter = new LongRangeCounter(longRanges);
@@ -135,7 +135,7 @@ namespace Lucene.Net.Facet.Range
                     // Skip missing docs:
                     if (fv.Exists(doc))
                     {
-                        counter.Add(NumericUtils.DoubleToSortableLong(fv.DoubleVal(doc)));
+                        counter.Add(NumericUtils.DoubleToSortableInt64(fv.DoubleVal(doc)));
                     }
                     else
                     {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Facet/Taxonomy/CachedOrdinalsReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/CachedOrdinalsReader.cs b/src/Lucene.Net.Facet/Taxonomy/CachedOrdinalsReader.cs
index a63e5da..a3dd984 100644
--- a/src/Lucene.Net.Facet/Taxonomy/CachedOrdinalsReader.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/CachedOrdinalsReader.cs
@@ -116,7 +116,7 @@ namespace Lucene.Net.Facet.Taxonomy
 
             public override void Get(int docID, IntsRef ordinals)
             {
-                ordinals.Ints = cachedOrds.Ordinals;
+                ordinals.Int32s = cachedOrds.Ordinals;
                 ordinals.Offset = cachedOrds.Offsets[docID];
                 ordinals.Length = cachedOrds.Offsets[docID + 1] - ordinals.Offset;
             }
@@ -166,7 +166,7 @@ namespace Lucene.Net.Facet.Taxonomy
                         }
                         ords = ArrayUtil.Grow(ords, (int)nextLength);
                     }
-                    Array.Copy(values.Ints, 0, ords, (int)totOrds, values.Length);
+                    Array.Copy(values.Int32s, 0, ords, (int)totOrds, values.Length);
                     totOrds = nextLength;
                 }
                 Offsets[maxDoc] = (int)totOrds;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs b/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs
index 44bccb8..c8fcbd6 100644
--- a/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs
@@ -1047,13 +1047,13 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
 
             public void AddMapping(int origOrdinal, int newOrdinal)
             {
-                @out.WriteInt(origOrdinal);
-                @out.WriteInt(newOrdinal);
+                @out.WriteInt32(origOrdinal);
+                @out.WriteInt32(newOrdinal);
             }
 
             public void SetSize(int taxonomySize)
             {
-                @out.WriteInt(taxonomySize);
+                @out.WriteInt32(taxonomySize);
             }
 
             public void AddDone()
@@ -1077,14 +1077,14 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
 
                 var ifs = new FileStream(tmpfile, FileMode.OpenOrCreate, FileAccess.Read);
                 var @in = new InputStreamDataInput(ifs);
-                map = new int[@in.ReadInt()];
+                map = new int[@in.ReadInt32()];
                 // NOTE: The current code assumes here that the map is complete,
                 // i.e., every ordinal gets one and exactly one value. Otherwise,
                 // we may run into an EOF here, or vice versa, not read everything.
                 for (int i = 0; i < map.Length; i++)
                 {
-                    int origordinal = @in.ReadInt();
-                    int newordinal = @in.ReadInt();
+                    int origordinal = @in.ReadInt32();
+                    int newordinal = @in.ReadInt32();
                     map[origordinal] = newordinal;
                 }
                 @in.Dispose();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Facet/Taxonomy/DocValuesOrdinalsReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/DocValuesOrdinalsReader.cs b/src/Lucene.Net.Facet/Taxonomy/DocValuesOrdinalsReader.cs
index cc8137c..22ac0e5 100644
--- a/src/Lucene.Net.Facet/Taxonomy/DocValuesOrdinalsReader.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/DocValuesOrdinalsReader.cs
@@ -97,9 +97,9 @@
             // grow the buffer up front, even if by a large number of values (buf.length)
             // that saves the need to check inside the loop for every decoded value if
             // the buffer needs to grow.
-            if (ordinals.Ints.Length < buf.Length)
+            if (ordinals.Int32s.Length < buf.Length)
             {
-                ordinals.Ints = ArrayUtil.Grow(ordinals.Ints, buf.Length);
+                ordinals.Int32s = ArrayUtil.Grow(ordinals.Int32s, buf.Length);
             }
 
             ordinals.Offset = 0;
@@ -116,9 +116,9 @@
                 byte b = buf.Bytes[offset++];
                 if ((sbyte)b >= 0)
                 {
-                    ordinals.Ints[ordinals.Length] = ((value << 7) | b) + prev;
+                    ordinals.Int32s[ordinals.Length] = ((value << 7) | b) + prev;
                     value = 0;
-                    prev = ordinals.Ints[ordinals.Length];
+                    prev = ordinals.Int32s[ordinals.Length];
                     ordinals.Length++;
                 }
                 else

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Facet/Taxonomy/FloatAssociationFacetField.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/FloatAssociationFacetField.cs b/src/Lucene.Net.Facet/Taxonomy/FloatAssociationFacetField.cs
index dbcf615..67026cc 100644
--- a/src/Lucene.Net.Facet/Taxonomy/FloatAssociationFacetField.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/FloatAssociationFacetField.cs
@@ -46,7 +46,7 @@ namespace Lucene.Net.Facet.Taxonomy
         /// </summary>
         public static BytesRef FloatToBytesRef(float v)
         {
-            return IntAssociationFacetField.IntToBytesRef(Number.FloatToIntBits(v));
+            return IntAssociationFacetField.IntToBytesRef(Number.SingleToInt32Bits(v));
         }
 
         /// <summary>
@@ -54,7 +54,7 @@ namespace Lucene.Net.Facet.Taxonomy
         /// </summary>
         public static float BytesRefToFloat(BytesRef b)
         {
-            return Number.IntBitsToFloat(IntAssociationFacetField.BytesRefToInt(b));
+            return Number.Int32BitsToSingle(IntAssociationFacetField.BytesRefToInt(b));
         }
 
         public override string ToString()

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetCounts.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetCounts.cs b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetCounts.cs
index f6c4ca4..3c5ce9e 100644
--- a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetCounts.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetCounts.cs
@@ -60,7 +60,7 @@ namespace Lucene.Net.Facet.Taxonomy
                     ords.Get(doc, scratch);
                     for (int i = 0; i < scratch.Length; i++)
                     {
-                        m_values[scratch.Ints[scratch.Offset + i]]++;
+                        m_values[scratch.Int32s[scratch.Offset + i]]++;
                     }
                 }
             }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumFloatAssociations.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumFloatAssociations.cs b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumFloatAssociations.cs
index 9a4612a..b36474e 100644
--- a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumFloatAssociations.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumFloatAssociations.cs
@@ -85,7 +85,7 @@ namespace Lucene.Net.Facet.Taxonomy
                         int value = ((bytes[offset] & 0xFF) << 24) | ((bytes[offset + 1] & 0xFF) << 16) | 
                             ((bytes[offset + 2] & 0xFF) << 8) | (bytes[offset + 3] & 0xFF);
                         offset += 4;
-                        m_values[ord] += Number.IntBitsToFloat(value);
+                        m_values[ord] += Number.Int32BitsToSingle(value);
                     }
                 }
             }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumValueSource.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumValueSource.cs b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumValueSource.cs
index eee089d..ae5c251 100644
--- a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumValueSource.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumValueSource.cs
@@ -146,7 +146,7 @@ namespace Lucene.Net.Facet.Taxonomy
                     float value = (float)functionValues.DoubleVal(doc);
                     for (int i = 0; i < scratch.Length; i++)
                     {
-                        m_values[scratch.Ints[i]] += value;
+                        m_values[scratch.Int32s[i]] += value;
                     }
                 }
             }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Highlighter/VectorHighlight/FieldPhraseList.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Highlighter/VectorHighlight/FieldPhraseList.cs b/src/Lucene.Net.Highlighter/VectorHighlight/FieldPhraseList.cs
index a664b54..136cb82 100644
--- a/src/Lucene.Net.Highlighter/VectorHighlight/FieldPhraseList.cs
+++ b/src/Lucene.Net.Highlighter/VectorHighlight/FieldPhraseList.cs
@@ -418,7 +418,7 @@ namespace Lucene.Net.Search.VectorHighlight
                 int result = 1;
                 result = prime * result + StartOffset;
                 result = prime * result + EndOffset;
-                long b = Number.DoubleToLongBits(Boost);
+                long b = Number.DoubleToInt64Bits(Boost);
                 result = prime * result + (int)(b ^ TripleShift(b, 32));
                 return result;
             }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs b/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs
index 3553d01..2be3ad6 100644
--- a/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs
+++ b/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs
@@ -533,14 +533,14 @@ namespace Lucene.Net.Index.Memory
                     Debug.Assert(!sliceReader.EndOfSlice(), " stores offsets : " + startOffset_Renamed);
                     if (outerInstance.outerInstance.storeOffsets)
                     {
-                        int pos = sliceReader.ReadInt();
-                        startOffset_Renamed = sliceReader.ReadInt();
-                        endOffset_Renamed = sliceReader.ReadInt();
+                        int pos = sliceReader.ReadInt32();
+                        startOffset_Renamed = sliceReader.ReadInt32();
+                        endOffset_Renamed = sliceReader.ReadInt32();
                         return pos;
                     }
                     else
                     {
-                        return sliceReader.ReadInt();
+                        return sliceReader.ReadInt32();
                     }
                 }
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Memory/MemoryIndex.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Memory/MemoryIndex.cs b/src/Lucene.Net.Memory/MemoryIndex.cs
index cd4a284..2923214 100644
--- a/src/Lucene.Net.Memory/MemoryIndex.cs
+++ b/src/Lucene.Net.Memory/MemoryIndex.cs
@@ -458,13 +458,13 @@ namespace Lucene.Net.Index.Memory
                     sumTotalTermFreq++;
                     if (!storeOffsets)
                     {
-                        postingsWriter.WriteInt(pos);
+                        postingsWriter.WriteInt32(pos);
                     }
                     else
                     {
-                        postingsWriter.WriteInt(pos);
-                        postingsWriter.WriteInt(offsetAtt.StartOffset + offset);
-                        postingsWriter.WriteInt(offsetAtt.EndOffset + offset);
+                        postingsWriter.WriteInt32(pos);
+                        postingsWriter.WriteInt32(offsetAtt.StartOffset + offset);
+                        postingsWriter.WriteInt32(offsetAtt.EndOffset + offset);
                     }
                     sliceArray.end[ord] = postingsWriter.CurrentOffset;
                 }
@@ -672,7 +672,7 @@ namespace Lucene.Net.Index.Memory
 
                         for (int k = 0; k < iters; k++)
                         {
-                            result.Append(postingsReader.ReadInt());
+                            result.Append(postingsReader.ReadInt32());
                             if (k < iters - 1)
                             {
                                 result.Append(", ");

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs b/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs
index 32e7783..6b4e60d 100644
--- a/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs
+++ b/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs
@@ -682,7 +682,7 @@ namespace Lucene.Net.Index.Sorter
             internal virtual void AddPositions(DocsAndPositionsEnum @in, IndexOutput @out)
             {
                 int freq = @in.Freq;
-                @out.WriteVInt(freq);
+                @out.WriteVInt32(freq);
                 int previousPosition = 0;
                 int previousEndOffset = 0;
                 for (int i = 0; i < freq; i++)
@@ -692,19 +692,19 @@ namespace Lucene.Net.Index.Sorter
                     // The low-order bit of token is set only if there is a payload, the
                     // previous bits are the delta-encoded position. 
                     int token = (pos - previousPosition) << 1 | (payload == null ? 0 : 1);
-                    @out.WriteVInt(token);
+                    @out.WriteVInt32(token);
                     previousPosition = pos;
                     if (storeOffsets) // don't encode offsets if they are not stored
                     {
                         int startOffset = @in.StartOffset;
                         int endOffset = @in.EndOffset;
-                        @out.WriteVInt(startOffset - previousEndOffset);
-                        @out.WriteVInt(endOffset - startOffset);
+                        @out.WriteVInt32(startOffset - previousEndOffset);
+                        @out.WriteVInt32(endOffset - startOffset);
                         previousEndOffset = endOffset;
                     }
                     if (payload != null)
                     {
-                        @out.WriteVInt(payload.Length);
+                        @out.WriteVInt32(payload.Length);
                         @out.WriteBytes(payload.Bytes, payload.Offset, payload.Length);
                     }
                 }
@@ -744,7 +744,7 @@ namespace Lucene.Net.Index.Sorter
                     return DocIdSetIterator.NO_MORE_DOCS;
                 }
                 postingInput.Seek(offsets[docIt]);
-                currFreq = postingInput.ReadVInt();
+                currFreq = postingInput.ReadVInt32();
                 // reset variables used in nextPosition
                 pos = 0;
                 endOffset = 0;
@@ -753,17 +753,17 @@ namespace Lucene.Net.Index.Sorter
 
             public override int NextPosition()
             {
-                int token = postingInput.ReadVInt();
+                int token = postingInput.ReadVInt32();
                 pos += (int)((uint)token >> 1);
                 if (storeOffsets)
                 {
-                    startOffset = endOffset + postingInput.ReadVInt();
-                    endOffset = startOffset + postingInput.ReadVInt();
+                    startOffset = endOffset + postingInput.ReadVInt32();
+                    endOffset = startOffset + postingInput.ReadVInt32();
                 }
                 if ((token & 1) != 0)
                 {
                     payload.Offset = 0;
-                    payload.Length = postingInput.ReadVInt();
+                    payload.Length = postingInput.ReadVInt32();
                     if (payload.Length > payload.Bytes.Length)
                     {
                         payload.Bytes = new byte[ArrayUtil.Oversize(payload.Length, 1)];

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs b/src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs
index 851f7cb..bf5a057 100644
--- a/src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs
+++ b/src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs
@@ -112,13 +112,13 @@ namespace Lucene.Net.Util.Fst
         {
             if (!(output is IList))
             {
-                @out.WriteVInt(1);
+                @out.WriteVInt32(1);
                 outputs.Write((T)output, @out);
             }
             else
             {
                 IList outputList = (IList)output;
-                @out.WriteVInt(outputList.Count);
+                @out.WriteVInt32(outputList.Count);
                 foreach (var eachOutput in outputList)
                 {
                     outputs.Write((T)eachOutput, @out);
@@ -133,7 +133,7 @@ namespace Lucene.Net.Util.Fst
 
         public override object ReadFinalOutput(DataInput @in)
         {
-            int count = @in.ReadVInt();
+            int count = @in.ReadVInt32();
             if (count == 1)
             {
                 return outputs.Read(@in);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs b/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs
index 1e4cb0f..c4db55a 100644
--- a/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs
+++ b/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs
@@ -215,19 +215,19 @@ namespace Lucene.Net.Util.Fst
             if (output is long?)
             {
                 long? output2 = (long?)output;
-                @out.WriteVLong(output2.GetValueOrDefault() << 1);
+                @out.WriteVInt64(output2.GetValueOrDefault() << 1);
             }
             else
             {
                 TwoLongs output3 = (TwoLongs)output;
-                @out.WriteVLong((output3.First << 1) | 1);
-                @out.WriteVLong(output3.Second);
+                @out.WriteVInt64((output3.First << 1) | 1);
+                @out.WriteVInt64(output3.Second);
             }
         }
 
         public override object Read(DataInput @in)
         {
-            long code = @in.ReadVLong();
+            long code = @in.ReadVInt64();
             if ((code & 1) == 0)
             {
                 // single long
@@ -245,7 +245,7 @@ namespace Lucene.Net.Util.Fst
             {
                 // two longs
                 long first = (long)((ulong)code >> 1);
-                long second = @in.ReadVLong();
+                long second = @in.ReadVInt64();
                 return new TwoLongs(first, second);
             }
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Queries/BoostingQuery.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/BoostingQuery.cs b/src/Lucene.Net.Queries/BoostingQuery.cs
index 364bfc5..57c9bd9 100644
--- a/src/Lucene.Net.Queries/BoostingQuery.cs
+++ b/src/Lucene.Net.Queries/BoostingQuery.cs
@@ -107,7 +107,7 @@ namespace Lucene.Net.Queries
         {
             const int prime = 31;
             int result = base.GetHashCode();
-            result = prime * result + Number.FloatToIntBits(boost);
+            result = prime * result + Number.SingleToInt32Bits(boost);
             result = prime * result + ((context == null) ? 0 : context.GetHashCode());
             result = prime * result + ((match == null) ? 0 : match.GetHashCode());
             return result;
@@ -134,7 +134,7 @@ namespace Lucene.Net.Queries
             }
 
             var other = (BoostingQuery)obj;
-            if (Number.FloatToIntBits(boost) != Number.FloatToIntBits(other.boost))
+            if (Number.SingleToInt32Bits(boost) != Number.SingleToInt32Bits(other.boost))
             {
                 return false;
             }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Queries/CommonTermsQuery.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/CommonTermsQuery.cs b/src/Lucene.Net.Queries/CommonTermsQuery.cs
index de2382b..8735514 100644
--- a/src/Lucene.Net.Queries/CommonTermsQuery.cs
+++ b/src/Lucene.Net.Queries/CommonTermsQuery.cs
@@ -390,13 +390,13 @@ namespace Lucene.Net.Queries
             const int prime = 31;
             int result = base.GetHashCode();
             result = prime * result + (m_disableCoord ? 1231 : 1237);
-            result = prime * result + Number.FloatToIntBits(m_highFreqBoost);
+            result = prime * result + Number.SingleToInt32Bits(m_highFreqBoost);
             result = prime * result + /*((highFreqOccur == null) ? 0 :*/ m_highFreqOccur.GetHashCode()/*)*/;
-            result = prime * result + Number.FloatToIntBits(m_lowFreqBoost);
+            result = prime * result + Number.SingleToInt32Bits(m_lowFreqBoost);
             result = prime * result + /*((lowFreqOccur == null) ? 0 :*/ m_lowFreqOccur.GetHashCode()/*)*/;
-            result = prime * result + Number.FloatToIntBits(m_maxTermFrequency);
-            result = prime * result + Number.FloatToIntBits(m_lowFreqMinNrShouldMatch);
-            result = prime * result + Number.FloatToIntBits(m_highFreqMinNrShouldMatch);
+            result = prime * result + Number.SingleToInt32Bits(m_maxTermFrequency);
+            result = prime * result + Number.SingleToInt32Bits(m_lowFreqMinNrShouldMatch);
+            result = prime * result + Number.SingleToInt32Bits(m_highFreqMinNrShouldMatch);
             result = prime * result + ((m_terms == null) ? 0 : m_terms.GetValueHashCode());
             return result;
         }
@@ -420,7 +420,7 @@ namespace Lucene.Net.Queries
             {
                 return false;
             }
-            if (Number.FloatToIntBits(m_highFreqBoost) != Number.FloatToIntBits(other.m_highFreqBoost))
+            if (Number.SingleToInt32Bits(m_highFreqBoost) != Number.SingleToInt32Bits(other.m_highFreqBoost))
             {
                 return false;
             }
@@ -428,7 +428,7 @@ namespace Lucene.Net.Queries
             {
                 return false;
             }
-            if (Number.FloatToIntBits(m_lowFreqBoost) != Number.FloatToIntBits(other.m_lowFreqBoost))
+            if (Number.SingleToInt32Bits(m_lowFreqBoost) != Number.SingleToInt32Bits(other.m_lowFreqBoost))
             {
                 return false;
             }
@@ -436,7 +436,7 @@ namespace Lucene.Net.Queries
             {
                 return false;
             }
-            if (Number.FloatToIntBits(m_maxTermFrequency) != Number.FloatToIntBits(other.m_maxTermFrequency))
+            if (Number.SingleToInt32Bits(m_maxTermFrequency) != Number.SingleToInt32Bits(other.m_maxTermFrequency))
             {
                 return false;
             }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Queries/CustomScoreQuery.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/CustomScoreQuery.cs b/src/Lucene.Net.Queries/CustomScoreQuery.cs
index 2fef745..decceea 100644
--- a/src/Lucene.Net.Queries/CustomScoreQuery.cs
+++ b/src/Lucene.Net.Queries/CustomScoreQuery.cs
@@ -179,7 +179,7 @@ namespace Lucene.Net.Queries
         public override int GetHashCode()
         {
             return (this.GetType().GetHashCode() + subQuery.GetHashCode() + Arrays.GetHashCode(scoringQueries)) ^
-                   Number.FloatToIntBits(Boost) ^ (strict ? 1234 : 4321);
+                   Number.SingleToInt32Bits(Boost) ^ (strict ? 1234 : 4321);
         }
 
         /// <summary>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Queries/Function/BoostedQuery.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/Function/BoostedQuery.cs b/src/Lucene.Net.Queries/Function/BoostedQuery.cs
index 7afdd5c..1cd591e 100644
--- a/src/Lucene.Net.Queries/Function/BoostedQuery.cs
+++ b/src/Lucene.Net.Queries/Function/BoostedQuery.cs
@@ -243,7 +243,7 @@ namespace Lucene.Net.Queries.Function
             h ^= (h << 17) | ((int)((uint)h >> 16));
             h += boostVal.GetHashCode();
             h ^= (h << 8) | ((int)((uint)h >> 25));
-            h += Number.FloatToIntBits(Boost);
+            h += Number.SingleToInt32Bits(Boost);
             return h;
         }
     }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Queries/Function/FunctionQuery.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/Function/FunctionQuery.cs b/src/Lucene.Net.Queries/Function/FunctionQuery.cs
index 0b088e2..a82ec72 100644
--- a/src/Lucene.Net.Queries/Function/FunctionQuery.cs
+++ b/src/Lucene.Net.Queries/Function/FunctionQuery.cs
@@ -231,7 +231,7 @@ namespace Lucene.Net.Queries.Function
         /// </summary>
         public override int GetHashCode()
         {
-            return func.GetHashCode() * 31 + Number.FloatToIntBits(Boost);
+            return func.GetHashCode() * 31 + Number.SingleToInt32Bits(Boost);
         }
     }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Queries/Function/ValueSources/ByteFieldSource.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/ByteFieldSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/ByteFieldSource.cs
index b040454..e915d36 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/ByteFieldSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/ByteFieldSource.cs
@@ -24,7 +24,7 @@ namespace Lucene.Net.Queries.Function.ValueSources
     
     /// <summary>
     /// Obtains <see cref="int"/> field values from the <see cref="Search.FieldCache"/>
-    /// using <see cref="IFieldCache.GetInts"/>
+    /// using <see cref="IFieldCache.GetInt32s"/>
     /// and makes those values available as other numeric types, casting as needed. *
     /// </summary>
     [Obsolete]

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Queries/Function/ValueSources/ConstValueSource.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/ConstValueSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/ConstValueSource.cs
index 1aee2db..bd9a8aa 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/ConstValueSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/ConstValueSource.cs
@@ -88,7 +88,7 @@ namespace Lucene.Net.Queries.Function.ValueSources
 
         public override int GetHashCode()
         {
-            return Number.FloatToIntBits(constant) * 31;
+            return Number.SingleToInt32Bits(constant) * 31;
         }
 
         public override bool Equals(object o)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Queries/Function/ValueSources/DoubleConstValueSource.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/DoubleConstValueSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/DoubleConstValueSource.cs
index 2003dab..73407ae 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/DoubleConstValueSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/DoubleConstValueSource.cs
@@ -96,7 +96,7 @@ namespace Lucene.Net.Queries.Function.ValueSources
 
         public override int GetHashCode()
         {
-            long bits = Lucene.Net.Support.Number.DoubleToRawLongBits(constant);
+            long bits = Lucene.Net.Support.Number.DoubleToRawInt64Bits(constant);
             return (int)(bits ^ ((long)((ulong)bits >> 32)));
         }
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Queries/Function/ValueSources/EnumFieldSource.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/EnumFieldSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/EnumFieldSource.cs
index 4e4f32b..a642ab8 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/EnumFieldSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/EnumFieldSource.cs
@@ -28,7 +28,7 @@ namespace Lucene.Net.Queries.Function.ValueSources
      */
 
     /// <summary>
-    /// Obtains <see cref="int"/> field values from <see cref="IFieldCache.GetInts"/> and makes
+    /// Obtains <see cref="int"/> field values from <see cref="IFieldCache.GetInt32s"/> and makes
     /// those values available as other numeric types, casting as needed.
     /// StrVal of the value is not the <see cref="int"/> value, but its <see cref="string"/> (displayed) value
     /// </summary>
@@ -114,7 +114,7 @@ namespace Lucene.Net.Queries.Function.ValueSources
 
         public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
         {
-            var arr = m_cache.GetInts(readerContext.AtomicReader, m_field, parser, true);
+            var arr = m_cache.GetInt32s(readerContext.AtomicReader, m_field, parser, true);
             var valid = m_cache.GetDocsWithField(readerContext.AtomicReader, m_field);
 
             return new IntDocValuesAnonymousInnerClassHelper(this, this, arr, valid);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Queries/Function/ValueSources/FloatFieldSource.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/FloatFieldSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/FloatFieldSource.cs
index 5143b5c..3207939 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/FloatFieldSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/FloatFieldSource.cs
@@ -50,7 +50,7 @@ namespace Lucene.Net.Queries.Function.ValueSources
 
         public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
         {
-            var arr = m_cache.GetFloats(readerContext.AtomicReader, m_field, m_parser, true);
+            var arr = m_cache.GetSingles(readerContext.AtomicReader, m_field, m_parser, true);
             var valid = m_cache.GetDocsWithField(readerContext.AtomicReader, m_field);
             return new FloatDocValuesAnonymousInnerClassHelper(this, arr, valid);
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Queries/Function/ValueSources/IntFieldSource.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/IntFieldSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/IntFieldSource.cs
index 5d13611..e4af2e0 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/IntFieldSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/IntFieldSource.cs
@@ -26,7 +26,7 @@ namespace Lucene.Net.Queries.Function.ValueSources
      */
 
     /// <summary>
-    /// Obtains <see cref="int"/> field values from <see cref="IFieldCache.GetInts"/> and makes those
+    /// Obtains <see cref="int"/> field values from <see cref="IFieldCache.GetInt32s"/> and makes those
     /// values available as other numeric types, casting as needed.
     /// </summary>
     public class IntFieldSource : FieldCacheSource
@@ -51,7 +51,7 @@ namespace Lucene.Net.Queries.Function.ValueSources
 
         public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
         {
-            FieldCache.Ints arr = m_cache.GetInts(readerContext.AtomicReader, m_field, parser, true);
+            FieldCache.Ints arr = m_cache.GetInt32s(readerContext.AtomicReader, m_field, parser, true);
             IBits valid = m_cache.GetDocsWithField(readerContext.AtomicReader, m_field);
 
             return new IntDocValuesAnonymousInnerClassHelper(this, this, arr, valid);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Queries/Function/ValueSources/LinearFloatFunction.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/LinearFloatFunction.cs b/src/Lucene.Net.Queries/Function/ValueSources/LinearFloatFunction.cs
index d7cf53f..df56910 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/LinearFloatFunction.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/LinearFloatFunction.cs
@@ -82,9 +82,9 @@ namespace Lucene.Net.Queries.Function.ValueSources
 
         public override int GetHashCode()
         {
-            int h = Number.FloatToIntBits(m_slope);
+            int h = Number.SingleToInt32Bits(m_slope);
             h = ((int)((uint)h >> 2)) | (h << 30);
-            h += Number.FloatToIntBits(m_intercept);
+            h += Number.SingleToInt32Bits(m_intercept);
             h ^= (h << 14) | ((int)((uint)h >> 19));
             return h + m_source.GetHashCode();
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Queries/Function/ValueSources/LongFieldSource.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/LongFieldSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/LongFieldSource.cs
index d13862a..c057651 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/LongFieldSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/LongFieldSource.cs
@@ -26,7 +26,7 @@ namespace Lucene.Net.Queries.Function.ValueSources
      */
 
     /// <summary>
-    /// Obtains <see cref="long"/> field values from <see cref="IFieldCache.GetLongs"/> and makes those
+    /// Obtains <see cref="long"/> field values from <see cref="IFieldCache.GetInt64s"/> and makes those
     /// values available as other numeric types, casting as needed.
     /// </summary>
     public class LongFieldSource : FieldCacheSource
@@ -66,7 +66,7 @@ namespace Lucene.Net.Queries.Function.ValueSources
 
         public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
         {
-            var arr = m_cache.GetLongs(readerContext.AtomicReader, m_field, m_parser, true);
+            var arr = m_cache.GetInt64s(readerContext.AtomicReader, m_field, m_parser, true);
             var valid = m_cache.GetDocsWithField(readerContext.AtomicReader, m_field);
             return new LongDocValuesAnonymousInnerClassHelper(this, this, arr, valid);
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Queries/Function/ValueSources/RangeMapFloatFunction.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/RangeMapFloatFunction.cs b/src/Lucene.Net.Queries/Function/ValueSources/RangeMapFloatFunction.cs
index d510257..a3f1f19 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/RangeMapFloatFunction.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/RangeMapFloatFunction.cs
@@ -101,9 +101,9 @@ namespace Lucene.Net.Queries.Function.ValueSources
         {
             int h = m_source.GetHashCode();
             h ^= (h << 10) | ((int)((uint)h >> 23));
-            h += Number.FloatToIntBits(m_min);
+            h += Number.SingleToInt32Bits(m_min);
             h ^= (h << 14) | ((int)((uint)h >> 19));
-            h += Number.FloatToIntBits(m_max);
+            h += Number.SingleToInt32Bits(m_max);
             h += m_target.GetHashCode();
             if (m_defaultVal != null)
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Queries/Function/ValueSources/ReciprocalFloatFunction.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/ReciprocalFloatFunction.cs b/src/Lucene.Net.Queries/Function/ValueSources/ReciprocalFloatFunction.cs
index 70032c8..02de918 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/ReciprocalFloatFunction.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/ReciprocalFloatFunction.cs
@@ -96,9 +96,9 @@ namespace Lucene.Net.Queries.Function.ValueSources
 
         public override int GetHashCode()
         {
-            int h = Number.FloatToIntBits(m_a) + Number.FloatToIntBits(m_m);
+            int h = Number.SingleToInt32Bits(m_a) + Number.SingleToInt32Bits(m_m);
             h ^= (h << 13) | ((int)((uint)h >> 20));
-            return h + (Number.FloatToIntBits(m_b)) + m_source.GetHashCode();
+            return h + (Number.SingleToInt32Bits(m_b)) + m_source.GetHashCode();
         }
 
         public override bool Equals(object o)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Queries/Function/ValueSources/ScaleFloatFunction.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/ScaleFloatFunction.cs b/src/Lucene.Net.Queries/Function/ValueSources/ScaleFloatFunction.cs
index a321258..2be917d 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/ScaleFloatFunction.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/ScaleFloatFunction.cs
@@ -73,7 +73,7 @@ namespace Lucene.Net.Queries.Function.ValueSources
                 {
 
                     float val = vals.FloatVal(i);
-                    if ((Number.FloatToRawIntBits(val) & (0xff << 23)) == 0xff << 23)
+                    if ((Number.SingleToRawInt32Bits(val) & (0xff << 23)) == 0xff << 23)
                     {
                         // if the exponent in the float is all ones, then this is +Inf, -Inf or NaN
                         // which don't make sense to factor into the scale function
@@ -154,9 +154,9 @@ namespace Lucene.Net.Queries.Function.ValueSources
 
         public override int GetHashCode()
         {
-            int h = Number.FloatToIntBits(m_min);
+            int h = Number.SingleToInt32Bits(m_min);
             h = h * 29;
-            h += Number.FloatToIntBits(m_max);
+            h += Number.SingleToInt32Bits(m_max);
             h = h * 29;
             h += m_source.GetHashCode();
             return h;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Queries/Function/ValueSources/ShortFieldSource.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/ShortFieldSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/ShortFieldSource.cs
index d2d7c23..7419010 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/ShortFieldSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/ShortFieldSource.cs
@@ -50,7 +50,7 @@ namespace Lucene.Net.Queries.Function.ValueSources
 
         public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
         {
-            var arr = m_cache.GetShorts(readerContext.AtomicReader, m_field, parser, false);
+            var arr = m_cache.GetInt16s(readerContext.AtomicReader, m_field, parser, false);
             return new FunctionValuesAnonymousInnerClassHelper(this, arr);
         }
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Queries/Mlt/MoreLikeThisQuery.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/Mlt/MoreLikeThisQuery.cs b/src/Lucene.Net.Queries/Mlt/MoreLikeThisQuery.cs
index 0aaa4de..62fd903 100644
--- a/src/Lucene.Net.Queries/Mlt/MoreLikeThisQuery.cs
+++ b/src/Lucene.Net.Queries/Mlt/MoreLikeThisQuery.cs
@@ -145,7 +145,7 @@ namespace Lucene.Net.Queries.Mlt
             result = prime * result + minDocFreq;
             result = prime * result + minTermFrequency;
             result = prime * result + Arrays.GetHashCode(moreLikeFields);
-            result = prime * result + Number.FloatToIntBits(percentTermsToMatch);
+            result = prime * result + Number.SingleToInt32Bits(percentTermsToMatch);
             result = prime * result + ((stopWords == null) ? 0 : stopWords.GetValueHashCode());
             return result;
         }
@@ -214,7 +214,7 @@ namespace Lucene.Net.Queries.Mlt
             {
                 return false;
             }
-            if (Number.FloatToIntBits(percentTermsToMatch) != Number.FloatToIntBits(other.percentTermsToMatch))
+            if (Number.SingleToInt32Bits(percentTermsToMatch) != Number.SingleToInt32Bits(other.percentTermsToMatch))
             {
                 return false;
             }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.QueryParser/Classic/QueryParserBase.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Classic/QueryParserBase.cs b/src/Lucene.Net.QueryParser/Classic/QueryParserBase.cs
index f2a9798..0f0521d 100644
--- a/src/Lucene.Net.QueryParser/Classic/QueryParserBase.cs
+++ b/src/Lucene.Net.QueryParser/Classic/QueryParserBase.cs
@@ -544,7 +544,7 @@ namespace Lucene.Net.QueryParsers.Classic
             // FuzzyQuery doesn't yet allow constant score rewrite
             string text = term.Text();
 #pragma warning disable 612, 618
-            int numEdits = FuzzyQuery.FloatToEdits(minimumSimilarity,
+            int numEdits = FuzzyQuery.SingleToEdits(minimumSimilarity,
                 text.CodePointCount(0, text.Length));
 #pragma warning restore 612, 618
             return new FuzzyQuery(term, numEdits, prefixLength);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/FuzzyQueryNodeBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/FuzzyQueryNodeBuilder.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/FuzzyQueryNodeBuilder.cs
index 3fa9c06..6ae4c99 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/FuzzyQueryNodeBuilder.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/FuzzyQueryNodeBuilder.cs
@@ -38,7 +38,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Builders
             string text = fuzzyNode.GetTextAsString();
 
 #pragma warning disable 612, 618
-            int numEdits = FuzzyQuery.FloatToEdits(fuzzyNode.Similarity,
+            int numEdits = FuzzyQuery.SingleToEdits(fuzzyNode.Similarity,
                 text.CodePointCount(0, text.Length));
 #pragma warning restore 612, 618
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/NumericRangeQueryNodeBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/NumericRangeQueryNodeBuilder.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/NumericRangeQueryNodeBuilder.cs
index 52a8eb0..dffcd8b 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/NumericRangeQueryNodeBuilder.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/NumericRangeQueryNodeBuilder.cs
@@ -64,16 +64,16 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Builders
             switch (numberType)
             {
                 case NumericType.LONG:
-                    return NumericRangeQuery.NewLongRange(field, precisionStep,
+                    return NumericRangeQuery.NewInt64Range(field, precisionStep,
                         (long?)lowerNumber, (long?)upperNumber, minInclusive, maxInclusive);
 
                 case NumericType.INT:
-                    return NumericRangeQuery.NewIntRange(field, precisionStep,
+                    return NumericRangeQuery.NewInt32Range(field, precisionStep,
                         (int?)lowerNumber, (int?)upperNumber, minInclusive,
                         maxInclusive);
 
                 case NumericType.FLOAT:
-                    return NumericRangeQuery.NewFloatRange(field, precisionStep,
+                    return NumericRangeQuery.NewSingleRange(field, precisionStep,
                         (float?)lowerNumber, (float?)upperNumber, minInclusive,
                         maxInclusive);
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.QueryParser/Xml/Builders/NumericRangeFilterBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Xml/Builders/NumericRangeFilterBuilder.cs b/src/Lucene.Net.QueryParser/Xml/Builders/NumericRangeFilterBuilder.cs
index d7d4130..d37193b 100644
--- a/src/Lucene.Net.QueryParser/Xml/Builders/NumericRangeFilterBuilder.cs
+++ b/src/Lucene.Net.QueryParser/Xml/Builders/NumericRangeFilterBuilder.cs
@@ -121,12 +121,12 @@ namespace Lucene.Net.QueryParsers.Xml.Builders
                 Filter filter;
                 if (type.Equals("int", StringComparison.OrdinalIgnoreCase))
                 {
-                    filter = NumericRangeFilter.NewIntRange(field, precisionStep, Convert.ToInt32(lowerTerm), Convert.ToInt32(upperTerm), lowerInclusive,
+                    filter = NumericRangeFilter.NewInt32Range(field, precisionStep, Convert.ToInt32(lowerTerm), Convert.ToInt32(upperTerm), lowerInclusive,
                         upperInclusive);
                 }
                 else if (type.Equals("long", StringComparison.OrdinalIgnoreCase))
                 {
-                    filter = NumericRangeFilter.NewLongRange(field, precisionStep, Convert
+                    filter = NumericRangeFilter.NewInt64Range(field, precisionStep, Convert
                         .ToInt64(lowerTerm), Convert.ToInt64(upperTerm), lowerInclusive,
                         upperInclusive);
                 }
@@ -138,7 +138,7 @@ namespace Lucene.Net.QueryParsers.Xml.Builders
                 }
                 else if (type.Equals("float", StringComparison.OrdinalIgnoreCase))
                 {
-                    filter = NumericRangeFilter.NewFloatRange(field, precisionStep, Convert
+                    filter = NumericRangeFilter.NewSingleRange(field, precisionStep, Convert
                         .ToSingle(lowerTerm), Convert.ToSingle(upperTerm), lowerInclusive,
                         upperInclusive);
                 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.QueryParser/Xml/Builders/NumericRangeQueryBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Xml/Builders/NumericRangeQueryBuilder.cs b/src/Lucene.Net.QueryParser/Xml/Builders/NumericRangeQueryBuilder.cs
index 4b4b128..668f56e 100644
--- a/src/Lucene.Net.QueryParser/Xml/Builders/NumericRangeQueryBuilder.cs
+++ b/src/Lucene.Net.QueryParser/Xml/Builders/NumericRangeQueryBuilder.cs
@@ -99,13 +99,13 @@ namespace Lucene.Net.QueryParsers.Xml.Builders
                 Query filter;
                 if (type.Equals("int", StringComparison.OrdinalIgnoreCase))
                 {
-                    filter = NumericRangeQuery.NewIntRange(field, precisionStep, Convert
+                    filter = NumericRangeQuery.NewInt32Range(field, precisionStep, Convert
                         .ToInt32(lowerTerm), Convert.ToInt32(upperTerm), lowerInclusive,
                         upperInclusive);
                 }
                 else if (type.Equals("long", StringComparison.OrdinalIgnoreCase))
                 {
-                    filter = NumericRangeQuery.NewLongRange(field, precisionStep, Convert
+                    filter = NumericRangeQuery.NewInt64Range(field, precisionStep, Convert
                         .ToInt64(lowerTerm), Convert.ToInt64(upperTerm), lowerInclusive,
                         upperInclusive);
                 }
@@ -117,7 +117,7 @@ namespace Lucene.Net.QueryParsers.Xml.Builders
                 }
                 else if (type.Equals("float", StringComparison.OrdinalIgnoreCase))
                 {
-                    filter = NumericRangeQuery.NewFloatRange(field, precisionStep, Convert
+                    filter = NumericRangeQuery.NewSingleRange(field, precisionStep, Convert
                         .ToSingle(lowerTerm), Convert.ToSingle(upperTerm), lowerInclusive,
                         upperInclusive);
                 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Sandbox/Queries/FuzzyLikeThisQuery.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Sandbox/Queries/FuzzyLikeThisQuery.cs b/src/Lucene.Net.Sandbox/Queries/FuzzyLikeThisQuery.cs
index 48c2b3e..b833083 100644
--- a/src/Lucene.Net.Sandbox/Queries/FuzzyLikeThisQuery.cs
+++ b/src/Lucene.Net.Sandbox/Queries/FuzzyLikeThisQuery.cs
@@ -136,7 +136,7 @@ namespace Lucene.Net.Sandbox.Queries
                 int result = 1;
                 result = prime * result
                     + ((fieldName == null) ? 0 : fieldName.GetHashCode());
-                result = prime * result + Number.FloatToIntBits(minSimilarity);
+                result = prime * result + Number.SingleToInt32Bits(minSimilarity);
                 result = prime * result + prefixLength;
                 result = prime * result
                     + ((queryString == null) ? 0 : queryString.GetHashCode());
@@ -159,8 +159,8 @@ namespace Lucene.Net.Sandbox.Queries
                 }
                 else if (!fieldName.Equals(other.fieldName, StringComparison.Ordinal))
                     return false;
-                if (Number.FloatToIntBits(minSimilarity) != Number
-                    .FloatToIntBits(other.minSimilarity))
+                if (Number.SingleToInt32Bits(minSimilarity) != Number
+                    .SingleToInt32Bits(other.minSimilarity))
                     return false;
                 if (prefixLength != other.prefixLength)
                     return false;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Sandbox/Queries/SlowFuzzyQuery.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Sandbox/Queries/SlowFuzzyQuery.cs b/src/Lucene.Net.Sandbox/Queries/SlowFuzzyQuery.cs
index 77ec159..9a068f1 100644
--- a/src/Lucene.Net.Sandbox/Queries/SlowFuzzyQuery.cs
+++ b/src/Lucene.Net.Sandbox/Queries/SlowFuzzyQuery.cs
@@ -182,7 +182,7 @@ namespace Lucene.Net.Sandbox.Queries
         {
             int prime = 31;
             int result = base.GetHashCode();
-            result = prime * result + Number.FloatToIntBits(minimumSimilarity);
+            result = prime * result + Number.SingleToInt32Bits(minimumSimilarity);
             result = prime * result + prefixLength;
             result = prime * result + ((m_term == null) ? 0 : m_term.GetHashCode());
             return result;
@@ -197,8 +197,8 @@ namespace Lucene.Net.Sandbox.Queries
             if (GetType() != obj.GetType())
                 return false;
             SlowFuzzyQuery other = (SlowFuzzyQuery)obj;
-            if (Number.FloatToIntBits(minimumSimilarity) != Number
-                .FloatToIntBits(other.minimumSimilarity))
+            if (Number.SingleToInt32Bits(minimumSimilarity) != Number
+                .SingleToInt32Bits(other.minimumSimilarity))
                 return false;
             if (prefixLength != other.prefixLength)
                 return false;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Sandbox/Queries/SlowFuzzyTermsEnum.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Sandbox/Queries/SlowFuzzyTermsEnum.cs b/src/Lucene.Net.Sandbox/Queries/SlowFuzzyTermsEnum.cs
index 05121db..ef44345 100644
--- a/src/Lucene.Net.Sandbox/Queries/SlowFuzzyTermsEnum.cs
+++ b/src/Lucene.Net.Sandbox/Queries/SlowFuzzyTermsEnum.cs
@@ -124,7 +124,7 @@ namespace Lucene.Net.Sandbox.Queries
                 if (StringHelper.StartsWith(term, prefixBytesRef))
                 {
                     UnicodeUtil.UTF8toUTF32(term, utf32);
-                    int distance = CalcDistance(utf32.Ints, outerInstance.m_realPrefixLength, utf32.Length - outerInstance.m_realPrefixLength);
+                    int distance = CalcDistance(utf32.Int32s, outerInstance.m_realPrefixLength, utf32.Length - outerInstance.m_realPrefixLength);
 
                     //Integer.MIN_VALUE is the sentinel that Levenshtein stopped early
                     if (distance == int.MinValue)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Spatial/Util/DistanceToShapeValueSource.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Spatial/Util/DistanceToShapeValueSource.cs b/src/Lucene.Net.Spatial/Util/DistanceToShapeValueSource.cs
index c5c0125..b0a6de1 100644
--- a/src/Lucene.Net.Spatial/Util/DistanceToShapeValueSource.cs
+++ b/src/Lucene.Net.Spatial/Util/DistanceToShapeValueSource.cs
@@ -122,7 +122,7 @@ namespace Lucene.Net.Spatial.Util
             long temp;
             result = shapeValueSource.GetHashCode();
             result = 31 * result + queryPoint.GetHashCode();
-            temp = Number.DoubleToLongBits(multiplier);
+            temp = Number.DoubleToInt64Bits(multiplier);
             result = 31 * result + (int)(temp ^ ((long)((ulong)temp) >> 32));
             return result;
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Suggest/Spell/JaroWinklerDistance.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/JaroWinklerDistance.cs b/src/Lucene.Net.Suggest/Spell/JaroWinklerDistance.cs
index c17f7cd..bc29dc3 100644
--- a/src/Lucene.Net.Suggest/Spell/JaroWinklerDistance.cs
+++ b/src/Lucene.Net.Suggest/Spell/JaroWinklerDistance.cs
@@ -142,7 +142,7 @@ namespace Lucene.Net.Search.Spell
 
         public override int GetHashCode()
         {
-            return 113 * Number.FloatToIntBits(threshold) * this.GetType().GetHashCode();
+            return 113 * Number.SingleToInt32Bits(threshold) * this.GetType().GetHashCode();
         }
 
         public override bool Equals(object obj)
@@ -157,7 +157,7 @@ namespace Lucene.Net.Search.Spell
             }
 
             JaroWinklerDistance o = (JaroWinklerDistance)obj;
-            return (Number.FloatToIntBits(o.threshold) == Number.FloatToIntBits(this.threshold));
+            return (Number.SingleToInt32Bits(o.threshold) == Number.SingleToInt32Bits(this.threshold));
         }
 
         public override string ToString()

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Suggest/Spell/LuceneLevenshteinDistance.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/LuceneLevenshteinDistance.cs b/src/Lucene.Net.Suggest/Spell/LuceneLevenshteinDistance.cs
index 2867150..ab0c9b7 100644
--- a/src/Lucene.Net.Suggest/Spell/LuceneLevenshteinDistance.cs
+++ b/src/Lucene.Net.Suggest/Spell/LuceneLevenshteinDistance.cs
@@ -103,15 +103,15 @@ namespace Lucene.Net.Search.Spell
 
             for (j = 1; j <= m; j++)
             {
-                t_j = otherPoints.Ints[j - 1];
+                t_j = otherPoints.Int32s[j - 1];
 
                 for (i = 1; i <= n; i++)
                 {
-                    cost = targetPoints.Ints[i - 1] == t_j ? 0 : 1;
+                    cost = targetPoints.Int32s[i - 1] == t_j ? 0 : 1;
                     // minimum of cell to the left+1, to the top+1, diagonally left and up +cost
                     d[i][j] = Math.Min(Math.Min(d[i - 1][j] + 1, d[i][j - 1] + 1), d[i - 1][j - 1] + cost);
                     // transposition
-                    if (i > 1 && j > 1 && targetPoints.Ints[i - 1] == otherPoints.Ints[j - 2] && targetPoints.Ints[i - 2] == otherPoints.Ints[j - 1])
+                    if (i > 1 && j > 1 && targetPoints.Int32s[i - 1] == otherPoints.Int32s[j - 2] && targetPoints.Int32s[i - 2] == otherPoints.Int32s[j - 1])
                     {
                         d[i][j] = Math.Min(d[i][j], d[i - 2][j - 2] + cost);
                     }
@@ -127,7 +127,7 @@ namespace Lucene.Net.Search.Spell
             int utf16Len = s.Length;
             for (int i = 0, cp = 0; i < utf16Len; i += Character.CharCount(cp))
             {
-                cp = @ref.Ints[@ref.Length++] = Character.CodePointAt(s, i);
+                cp = @ref.Int32s[@ref.Length++] = Character.CodePointAt(s, i);
             }
             return @ref;
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs
index 8eef805..be3d918 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs
@@ -339,13 +339,13 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
                 // First by analyzed form:
                 readerA.Reset(a.Bytes, a.Offset, a.Length);
-                scratchA.Length = (ushort)readerA.ReadShort();
+                scratchA.Length = (ushort)readerA.ReadInt16();
                 scratchA.Bytes = a.Bytes;
                 scratchA.Offset = readerA.Position;
 
                 readerB.Reset(b.Bytes, b.Offset, b.Length);
                 scratchB.Bytes = b.Bytes;
-                scratchB.Length = (ushort)readerB.ReadShort();
+                scratchB.Length = (ushort)readerB.ReadInt16();
                 scratchB.Offset = readerB.Position;
 
                 int cmp = scratchA.CompareTo(scratchB);
@@ -357,8 +357,8 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 readerB.SkipBytes(scratchB.Length);
 
                 // Next by cost:
-                long aCost = readerA.ReadInt();
-                long bCost = readerB.ReadInt();
+                long aCost = readerA.ReadInt32();
+                long bCost = readerB.ReadInt32();
                 Debug.Assert(DecodeWeight(aCost) >= 0);
                 Debug.Assert(DecodeWeight(bCost) >= 0);
                 if (aCost < bCost)
@@ -373,8 +373,8 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 // Finally by surface form:
                 if (hasPayloads)
                 {
-                    scratchA.Length = (ushort)readerA.ReadShort();
-                    scratchB.Length = (ushort)readerB.ReadShort();
+                    scratchA.Length = (ushort)readerA.ReadInt16();
+                    scratchB.Length = (ushort)readerB.ReadInt16();
                     scratchA.Offset = readerA.Position;
                     scratchB.Offset = readerB.Position;
                 }
@@ -462,11 +462,11 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
                         output.Reset(buffer);
 
-                        output.WriteShort((short)analyzedLength);
+                        output.WriteInt16((short)analyzedLength);
 
                         output.WriteBytes(scratch.Bytes, scratch.Offset, scratch.Length);
 
-                        output.WriteInt(EncodeWeight(iterator.Weight));
+                        output.WriteInt32(EncodeWeight(iterator.Weight));
 
                         if (hasPayloads)
                         {
@@ -478,7 +478,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                                         "surface form cannot contain unit separator character U+001F; this character is reserved");
                                 }
                             }
-                            output.WriteShort((short)surfaceForm.Length);
+                            output.WriteInt16((short)surfaceForm.Length);
                             output.WriteBytes(surfaceForm.Bytes, surfaceForm.Offset, surfaceForm.Length);
                             output.WriteBytes(payload.Bytes, payload.Offset, payload.Length);
                         }
@@ -524,17 +524,17 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 while (reader.Read(scratch))
                 {
                     input.Reset(scratch.Bytes, scratch.Offset, scratch.Length);
-                    ushort analyzedLength = (ushort)input.ReadShort();
+                    ushort analyzedLength = (ushort)input.ReadInt16();
                     analyzed.Grow(analyzedLength + 2);
                     input.ReadBytes(analyzed.Bytes, 0, analyzedLength);
                     analyzed.Length = analyzedLength;
 
-                    long cost = input.ReadInt();
+                    long cost = input.ReadInt32();
 
                     surface.Bytes = scratch.Bytes;
                     if (hasPayloads)
                     {
-                        surface.Length = (ushort)input.ReadShort();
+                        surface.Length = (ushort)input.ReadInt16();
                         surface.Offset = input.Position;
                     }
                     else
@@ -584,7 +584,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                     analyzed.Bytes[analyzed.Offset + analyzed.Length + 1] = (byte)dedup;
                     analyzed.Length += 2;
 
-                    Util.Fst.Util.ToIntsRef(analyzed, scratchInts);
+                    Util.Fst.Util.ToInt32sRef(analyzed, scratchInts);
                     //System.out.println("ADD: " + scratchInts + " -> " + cost + ": " + surface.utf8ToString());
                     if (!hasPayloads)
                     {
@@ -626,23 +626,23 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
         public override bool Store(DataOutput output)
         {
-            output.WriteVLong(count);
+            output.WriteVInt64(count);
             if (fst == null)
             {
                 return false;
             }
 
             fst.Save(output);
-            output.WriteVInt(maxAnalyzedPathsForOneInput);
+            output.WriteVInt32(maxAnalyzedPathsForOneInput);
             output.WriteByte((byte)(hasPayloads ? 1 : 0));
             return true;
         }
 
         public override bool Load(DataInput input)
         {
-            count = input.ReadVLong();
+            count = input.ReadVInt64();
             this.fst = new FST<PairOutputs<long?, BytesRef>.Pair>(input, new PairOutputs<long?, BytesRef>(PositiveIntOutputs.Singleton, ByteSequenceOutputs.Singleton));
-            maxAnalyzedPathsForOneInput = input.ReadVInt();
+            maxAnalyzedPathsForOneInput = input.ReadVInt32();
             hasPayloads = input.ReadByte() == 1;
             return true;
         }


Mime
View raw message