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 <[email protected]> Authored: Wed Feb 8 16:54:19 2017 +0700 Committer: Shad Storhaug <[email protected]> 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); } }
