lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [44/53] [abbrv] lucenenet git commit: Lucene.Net.Core.Util.SmallFloat refactor: Renamed sbyte overloads SByte instead of Byte, and added overloads for Byte (for CLS compliance)
Date Wed, 08 Feb 2017 14:32:23 GMT
Lucene.Net.Core.Util.SmallFloat refactor: Renamed sbyte overloads SByte instead of Byte, and
added overloads for Byte (for CLS compliance)


Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/8ca0267c
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/8ca0267c
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/8ca0267c

Branch: refs/heads/api-work
Commit: 8ca0267c89d1410628da2eaa4bfe2f9d3cf67d16
Parents: 73cb5b2
Author: Shad Storhaug <shad@shadstorhaug.com>
Authored: Wed Feb 8 16:54:19 2017 +0700
Committer: Shad Storhaug <shad@shadstorhaug.com>
Committed: Wed Feb 8 21:08:24 2017 +0700

----------------------------------------------------------------------
 .../Search/Similarities/BM25Similarity.cs       |   4 +-
 .../Search/Similarities/DefaultSimilarity.cs    |   4 +-
 .../Search/Similarities/SimilarityBase.cs       |   4 +-
 src/Lucene.Net.Core/Util/SmallFloat.cs          | 122 ++++++++++++++++---
 .../core/Util/TestSmallFloat.cs                 |  32 ++---
 5 files changed, 125 insertions(+), 41 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8ca0267c/src/Lucene.Net.Core/Search/Similarities/BM25Similarity.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Search/Similarities/BM25Similarity.cs b/src/Lucene.Net.Core/Search/Similarities/BM25Similarity.cs
index 86ae76f..584640b 100644
--- a/src/Lucene.Net.Core/Search/Similarities/BM25Similarity.cs
+++ b/src/Lucene.Net.Core/Search/Similarities/BM25Similarity.cs
@@ -108,7 +108,7 @@ namespace Lucene.Net.Search.Similarities
         /// </summary>
         protected internal virtual sbyte EncodeNormValue(float boost, int fieldLength) //
LUCENENET TODO: Can we use byte?
         {
-            return SmallSingle.SingleToByte315(boost / (float)Math.Sqrt(fieldLength));
+            return SmallSingle.SingleToSByte315(boost / (float)Math.Sqrt(fieldLength));
         }
 
         /// <summary>
@@ -151,7 +151,7 @@ namespace Lucene.Net.Search.Similarities
         {
             for (int i = 0; i < 256; i++)
             {
-                float f = SmallSingle.Byte315ToSingle((sbyte)i);
+                float f = SmallSingle.SByte315ToSingle((sbyte)i);
                 NORM_TABLE[i] = 1.0f / (f * f);
             }
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8ca0267c/src/Lucene.Net.Core/Search/Similarities/DefaultSimilarity.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Search/Similarities/DefaultSimilarity.cs b/src/Lucene.Net.Core/Search/Similarities/DefaultSimilarity.cs
index b2a84a9..e96f2c8 100644
--- a/src/Lucene.Net.Core/Search/Similarities/DefaultSimilarity.cs
+++ b/src/Lucene.Net.Core/Search/Similarities/DefaultSimilarity.cs
@@ -54,7 +54,7 @@ namespace Lucene.Net.Search.Similarities
         {
             for (int i = 0; i < 256; i++)
             {
-                NORM_TABLE[i] = SmallSingle.Byte315ToSingle((sbyte)i);
+                NORM_TABLE[i] = SmallSingle.SByte315ToSingle((sbyte)i);
             }
         }
 
@@ -93,7 +93,7 @@ namespace Lucene.Net.Search.Similarities
         /// <seealso cref= Lucene.Net.Util.SmallSingle </seealso>
         public override sealed long EncodeNormValue(float f)
         {
-            return SmallSingle.SingleToByte315(f);
+            return SmallSingle.SingleToSByte315(f);
         }
 
         /// <summary>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8ca0267c/src/Lucene.Net.Core/Search/Similarities/SimilarityBase.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Search/Similarities/SimilarityBase.cs b/src/Lucene.Net.Core/Search/Similarities/SimilarityBase.cs
index 4ddaeb6..d0c4e18 100644
--- a/src/Lucene.Net.Core/Search/Similarities/SimilarityBase.cs
+++ b/src/Lucene.Net.Core/Search/Similarities/SimilarityBase.cs
@@ -235,7 +235,7 @@ namespace Lucene.Net.Search.Similarities
         {
             for (int i = 0; i < 256; i++)
             {
-                float floatNorm = SmallSingle.Byte315ToSingle((sbyte)i);
+                float floatNorm = SmallSingle.SByte315ToSingle((sbyte)i);
                 NORM_TABLE[i] = 1.0f / (floatNorm * floatNorm);
             }
         }
@@ -268,7 +268,7 @@ namespace Lucene.Net.Search.Similarities
         /// Encodes the length to a byte via SmallFloat. </summary>
         protected internal virtual sbyte EncodeNormValue(float boost, float length) // LUCENENET
TODO: Can this be byte?
         {
-            return SmallSingle.SingleToByte315((boost / (float)Math.Sqrt(length)));
+            return SmallSingle.SingleToSByte315((boost / (float)Math.Sqrt(length)));
         }
 
         // ----------------------------- Static methods ------------------------------

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8ca0267c/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 2bff9ff..7eb3b07 100644
--- a/src/Lucene.Net.Core/Util/SmallFloat.cs
+++ b/src/Lucene.Net.Core/Util/SmallFloat.cs
@@ -35,19 +35,37 @@ namespace Lucene.Net.Util
         }
 
         /// <summary>
-        /// Converts a 32 bit float to an 8 bit float.
+        /// Converts a 32 bit <see cref="float"/> to an 8 bit <see cref="float"/>.
         /// <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.
+        /// </summary>
+        /// <param name="f"> the 32 bit <see cref="float"/> to be converted to
an 8 bit <see cref="float"/> (<see cref="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>
+        // LUCENENET specific overload for CLS compliance
+        public static byte SingleToByte(float f, int numMantissaBits, int zeroExp)
+        {
+            return (byte)SingleToSByte(f, numMantissaBits, zeroExp);
+        }
+
+        /// <summary>
+        /// Converts a 32 bit <see cref="float"/> to an 8 bit <see cref="float"/>.
+        /// <para/>Values less than zero are all mapped to zero.
+        /// <para/>Values are truncated (rounded down) to the nearest 8 bit value.
+        /// <para/>Values between zero and the smallest representable value
+        /// 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="f"> the 32 bit <see cref="float"/> to be converted to
an 8 bit <see cref="float"/> (<see cref="sbyte"/>) </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 SingleToByte(float f, int numMantissaBits, int zeroExp) // LUCENENET
TODO: can we remove the sbyte?
+        [CLSCompliant(false)]
+        public static sbyte SingleToSByte(float f, int numMantissaBits, int zeroExp)
         {
             // Adjustment from a float zero exponent to our zero exponent,
             // shifted over to our exponent position.
@@ -69,11 +87,23 @@ namespace Lucene.Net.Util
         }
 
         /// <summary>
-        /// Converts an 8 bit float to a 32 bit float. 
+        /// Converts an 8 bit <see cref="float"/> to a 32 bit <see cref="float"/>.

+        /// <para/>
+        /// NOTE: This was byteToFloat() in Lucene
+        /// </summary>
+        // LUCENENET specific overload for CLS compliance
+        public static float ByteToSingle(byte b, int numMantissaBits, int zeroExp)
+        {
+            return SByteToSingle((sbyte)b, numMantissaBits, zeroExp);
+        }
+
+        /// <summary>
+        /// Converts an 8 bit <see cref="float"/> to a 32 bit <see cref="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?
+        [CLSCompliant(false)]
+        public static float SByteToSingle(sbyte b, int numMantissaBits, int zeroExp)
         {
             // 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%)
@@ -93,14 +123,29 @@ namespace Lucene.Net.Util
         //
 
         /// <summary>
-        /// floatToByte(b, mantissaBits=3, zeroExponent=15)
-        /// <br>smallest non-zero value = 5.820766E-10
-        /// <br>largest value = 7.5161928E9
-        /// <br>epsilon = 0.125
+        /// SingleToSByte((byte)b, mantissaBits=3, zeroExponent=15)
+        /// <para/>smallest non-zero value = 5.820766E-10
+        /// <para/>largest value = 7.5161928E9
+        /// <para/>epsilon = 0.125
+        /// <para/>
+        /// NOTE: This was floatToByte315() in Lucene
+        /// </summary>
+        // LUCENENET specific overload for CLS compliance
+        public static byte SingleToByte315(float f)
+        {
+            return (byte)SingleToSByte315(f);
+        }
+
+        /// <summary>
+        /// SingleToSByte(b, mantissaBits=3, zeroExponent=15)
+        /// <para/>smallest non-zero value = 5.820766E-10
+        /// <para/>largest value = 7.5161928E9
+        /// <para/>epsilon = 0.125
         /// <para/>
         /// NOTE: This was floatToByte315() in Lucene
         /// </summary>
-        public static sbyte SingleToByte315(float f) // LUCENENET TODO: can we remove the
sbyte?
+        [CLSCompliant(false)]
+        public static sbyte SingleToSByte315(float f) 
         {
             int bits = BitConverter.ToInt32(BitConverter.GetBytes(f), 0);
             int smallfloat = bits >> (24 - 3);
@@ -116,11 +161,23 @@ namespace Lucene.Net.Util
         }
 
         /// <summary>
-        /// byteToFloat(b, mantissaBits=3, zeroExponent=15) 
+        /// ByteToSingle(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?
+        // LUCENENET specific overload for CLS compliance
+        public static float Byte315ToSingle(byte b)
+        {
+            return SByte315ToSingle((sbyte)b);
+        }
+
+        /// <summary>
+        /// SByteToSingle(b, mantissaBits=3, zeroExponent=15) 
+        /// <para/>
+        /// NOTE: This was byte315ToFloat() in Lucene
+        /// </summary>
+        [CLSCompliant(false)]
+        public static float SByte315ToSingle(sbyte b)
         {
             // 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%)
@@ -134,14 +191,29 @@ namespace Lucene.Net.Util
         }
 
         /// <summary>
-        /// floatToByte(b, mantissaBits=5, zeroExponent=2)
-        /// <br>smallest nonzero value = 0.033203125
-        /// <br>largest value = 1984.0
-        /// <br>epsilon = 0.03125
+        /// SingleToByte(b, mantissaBits=5, zeroExponent=2)
+        /// <para/>smallest nonzero value = 0.033203125
+        /// <para/>largest value = 1984.0
+        /// <para/>epsilon = 0.03125
+        /// <para/>
+        /// NOTE: This was floatToByte52() in Lucene
+        /// </summary>
+        // LUCENENET specific overload for CLS compliance
+        public static byte SingleToByte52(float f)
+        {
+            return (byte)SingleToSByte315(f);
+        }
+
+        /// <summary>
+        /// SingleToSByte(b, mantissaBits=5, zeroExponent=2)
+        /// <para/>smallest nonzero value = 0.033203125
+        /// <para/>largest value = 1984.0
+        /// <para/>epsilon = 0.03125
         /// <para/>
         /// NOTE: This was floatToByte52() in Lucene
         /// </summary>
-        public static sbyte SingleToByte52(float f) // LUCENENET TODO: can we remove the
sbyte?
+        [CLSCompliant(false)]
+        public static sbyte SingleToSByte52(float f)
         {
             int bits = BitConverter.ToInt32(BitConverter.GetBytes(f), 0);
             int smallfloat = bits >> (24 - 5);
@@ -157,11 +229,23 @@ namespace Lucene.Net.Util
         }
 
         /// <summary>
-        /// byteToFloat(b, mantissaBits=5, zeroExponent=2) 
+        /// ByteToFloat(b, mantissaBits=5, zeroExponent=2) 
+        /// <para/>
+        /// NOTE: This was byte52ToFloat() in Lucene
+        /// </summary>
+        // LUCENENET specific overload for CLS compliance
+        public static float Byte52ToSingle(byte b)
+        {
+            return SByte52ToSingle((sbyte)b);
+        }
+
+        /// <summary>
+        /// SByteToFloat(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?
+        [CLSCompliant(false)]
+        public static float SByte52ToSingle(sbyte b)
         {
             // 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/8ca0267c/src/Lucene.Net.Tests/core/Util/TestSmallFloat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Util/TestSmallFloat.cs b/src/Lucene.Net.Tests/core/Util/TestSmallFloat.cs
index 0fe0e8a..34d9b9b 100644
--- a/src/Lucene.Net.Tests/core/Util/TestSmallFloat.cs
+++ b/src/Lucene.Net.Tests/core/Util/TestSmallFloat.cs
@@ -106,13 +106,13 @@ namespace Lucene.Net.Util
             for (int i = 0; i < 256; i++)
             {
                 float f1 = Orig_byteToFloat((sbyte)i);
-                float f2 = SmallSingle.ByteToSingle((sbyte)i, 3, 15);
-                float f3 = SmallSingle.Byte315ToSingle((sbyte)i);
+                float f2 = SmallSingle.SByteToSingle((sbyte)i, 3, 15);
+                float f3 = SmallSingle.SByte315ToSingle((sbyte)i);
                 Assert.AreEqual(f1, f2, 0.0);
                 Assert.AreEqual(f2, f3, 0.0);
 
-                float f4 = SmallSingle.ByteToSingle((sbyte)i, 5, 2);
-                float f5 = SmallSingle.Byte52ToSingle((sbyte)i);
+                float f4 = SmallSingle.SByteToSingle((sbyte)i, 5, 2);
+                float f5 = SmallSingle.SByte52ToSingle((sbyte)i);
                 Assert.AreEqual(f4, f5, 0.0);
             }
         }
@@ -122,19 +122,19 @@ namespace Lucene.Net.Util
         {
             Assert.AreEqual(0, Orig_floatToByte_v13(5.8123817E-10f)); // verify the old bug
(see LUCENE-2937)
             Assert.AreEqual(1, Orig_floatToByte(5.8123817E-10f)); // verify it's fixed in
this test code
-            Assert.AreEqual(1, SmallSingle.SingleToByte315(5.8123817E-10f)); // verify it's
fixed
+            Assert.AreEqual(1, SmallSingle.SingleToSByte315(5.8123817E-10f)); // verify it's
fixed
 
             // test some constants
-            Assert.AreEqual(0, SmallSingle.SingleToByte315(0));
+            Assert.AreEqual(0, SmallSingle.SingleToSByte315(0));
             //Java's Float.MIN_VALUE equals C#'s float.Epsilon
-            Assert.AreEqual(1, SmallSingle.SingleToByte315(float.Epsilon)); // underflow
rounds up to smallest positive
-            Assert.AreEqual(255, SmallSingle.SingleToByte315(float.MaxValue) & 0xff);
// overflow rounds down to largest positive
-            Assert.AreEqual(255, SmallSingle.SingleToByte315(float.PositiveInfinity) &
0xff);
+            Assert.AreEqual(1, SmallSingle.SingleToSByte315(float.Epsilon)); // underflow
rounds up to smallest positive
+            Assert.AreEqual(255, SmallSingle.SingleToSByte315(float.MaxValue) & 0xff);
// overflow rounds down to largest positive
+            Assert.AreEqual(255, SmallSingle.SingleToSByte315(float.PositiveInfinity) &
0xff);
 
             // all negatives map to 0
-            Assert.AreEqual(0, SmallSingle.SingleToByte315(-float.Epsilon));
-            Assert.AreEqual(0, SmallSingle.SingleToByte315(-float.MaxValue));
-            Assert.AreEqual(0, SmallSingle.SingleToByte315(float.NegativeInfinity));
+            Assert.AreEqual(0, SmallSingle.SingleToSByte315(-float.Epsilon));
+            Assert.AreEqual(0, SmallSingle.SingleToSByte315(-float.MaxValue));
+            Assert.AreEqual(0, SmallSingle.SingleToSByte315(float.NegativeInfinity));
 
             // up iterations for more exhaustive test after changing something
             int num = AtLeast(100000);
@@ -146,13 +146,13 @@ namespace Lucene.Net.Util
                     continue;
                 }
                 sbyte b1 = Orig_floatToByte(f);
-                sbyte b2 = SmallSingle.SingleToByte(f, 3, 15);
-                sbyte b3 = SmallSingle.SingleToByte315(f);
+                sbyte b2 = SmallSingle.SingleToSByte(f, 3, 15);
+                sbyte b3 = SmallSingle.SingleToSByte315(f);
                 Assert.AreEqual(b1, b2);
                 Assert.AreEqual(b2, b3);
 
-                sbyte b4 = SmallSingle.SingleToByte(f, 5, 2);
-                sbyte b5 = SmallSingle.SingleToByte52(f);
+                sbyte b4 = SmallSingle.SingleToSByte(f, 5, 2);
+                sbyte b5 = SmallSingle.SingleToSByte52(f);
                 Assert.AreEqual(b4, b5);
             }
         }


Mime
View raw message