NumericUtils.cs

Go to the documentation of this file.

/* 
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

using System;
using Lucene.Net.Documents;
using Lucene.Net.Search;
using Lucene.Net.Support;
using NumericTokenStream = Lucene.Net.Analysis.NumericTokenStream;

namespace Lucene.Net.Util
{
    
    public sealed class NumericUtils
    {
        
        private NumericUtils()
        {
        } // no instance!
        
        public const int PRECISION_STEP_DEFAULT = 4;
        
        public static char SHIFT_START_LONG = (char) 0x20;
        
        public const int BUF_SIZE_LONG = 63 / 7 + 2;
        
        public static char SHIFT_START_INT = (char) 0x60;
        
        public const int BUF_SIZE_INT = 31 / 7 + 2;
        
        public static int LongToPrefixCoded(long val, int shift, char[] buffer)
        {
            if (shift > 63 || shift < 0)
                throw new System.ArgumentException("Illegal shift value, must be 0..63");
            int nChars = (63 - shift) / 7 + 1, len = nChars + 1;
            buffer[0] = (char) (SHIFT_START_LONG + shift);
            ulong sortableBits = BitConverter.ToUInt64(BitConverter.GetBytes(val), 0) ^ 0x8000000000000000L;
            sortableBits = sortableBits >> shift;
            while (nChars >= 1)
            {
                // Store 7 bits per character for good efficiency when UTF-8 encoding.
                // The whole number is right-justified so that lucene can prefix-encode
                // the terms more efficiently.
                buffer[nChars--] = (char) (sortableBits & 0x7f);
                sortableBits = sortableBits >> 7;
            }
            return len;
        }
        
        public static System.String LongToPrefixCoded(long val, int shift)
        {
            char[] buffer = new char[BUF_SIZE_LONG];
            int len = LongToPrefixCoded(val, shift, buffer);
            return new System.String(buffer, 0, len);
        }
        
        public static System.String LongToPrefixCoded(long val)
        {
            return LongToPrefixCoded(val, 0);
        }
        
        public static int IntToPrefixCoded(int val, int shift, char[] buffer)
        {
            if (shift > 31 || shift < 0)
                throw new System.ArgumentException("Illegal shift value, must be 0..31");
            int nChars = (31 - shift) / 7 + 1, len = nChars + 1;
            buffer[0] = (char) (SHIFT_START_INT + shift);
            int sortableBits = val ^ unchecked((int) 0x80000000);
            sortableBits = Number.URShift(sortableBits, shift);
            while (nChars >= 1)
            {
                // Store 7 bits per character for good efficiency when UTF-8 encoding.
                // The whole number is right-justified so that lucene can prefix-encode
                // the terms more efficiently.
                buffer[nChars--] = (char) (sortableBits & 0x7f);
                sortableBits = Number.URShift(sortableBits, 7);
            }
            return len;
        }
        
        public static System.String IntToPrefixCoded(int val, int shift)
        {
            char[] buffer = new char[BUF_SIZE_INT];
            int len = IntToPrefixCoded(val, shift, buffer);
            return new System.String(buffer, 0, len);
        }
        
        public static System.String IntToPrefixCoded(int val)
        {
            return IntToPrefixCoded(val, 0);
        }
        
        public static long PrefixCodedToLong(System.String prefixCoded)
        {
            int shift = prefixCoded[0] - SHIFT_START_LONG;
            if (shift > 63 || shift < 0)
                throw new System.FormatException("Invalid shift value in prefixCoded string (is encoded value really a LONG?)");
            ulong sortableBits = 0UL;
            for (int i = 1, len = prefixCoded.Length; i < len; i++)
            {
                sortableBits <<= 7;
                char ch = prefixCoded[i];
                if (ch > 0x7f)
                {
                    throw new System.FormatException("Invalid prefixCoded numerical value representation (char " + System.Convert.ToString((int) ch, 16) + " at position " + i + " is invalid)");
                }
                sortableBits |= (ulong) ch;
            }
            return BitConverter.ToInt64(BitConverter.GetBytes((sortableBits << shift) ^ 0x8000000000000000L), 0);
        }
        
        public static int PrefixCodedToInt(System.String prefixCoded)
        {
            int shift = prefixCoded[0] - SHIFT_START_INT;
            if (shift > 31 || shift < 0)
                throw new System.FormatException("Invalid shift value in prefixCoded string (is encoded value really an INT?)");
            int sortableBits = 0;
            for (int i = 1, len = prefixCoded.Length; i < len; i++)
            {
                sortableBits <<= 7;
                char ch = prefixCoded[i];
                if (ch > 0x7f)
                {
                    throw new System.FormatException("Invalid prefixCoded numerical value representation (char " + System.Convert.ToString((int) ch, 16) + " at position " + i + " is invalid)");
                }
                sortableBits |= (int) ch;
            }
            return (sortableBits << shift) ^ unchecked((int) 0x80000000);
        }
        
        public static long DoubleToSortableLong(double val)
        {
            long f = BitConverter.DoubleToInt64Bits(val);   // {{Aroush-2.9}} will this work the same as 'java.lang.Double.doubleToRawLongBits()'?
            if (f < 0)
                f ^= 0x7fffffffffffffffL;
            return f;
        }
        
        public static System.String DoubleToPrefixCoded(double val)
        {
            return LongToPrefixCoded(DoubleToSortableLong(val));
        }
        
        public static double SortableLongToDouble(long val)
        {
            if (val < 0)
                val ^= 0x7fffffffffffffffL;
            return BitConverter.Int64BitsToDouble(val);
        }
        
        public static double PrefixCodedToDouble(System.String val)
        {
            return SortableLongToDouble(PrefixCodedToLong(val));
        }
        
        public static int FloatToSortableInt(float val)
        {
            int f = BitConverter.ToInt32(BitConverter.GetBytes(val), 0);
            if (f < 0)
                f ^= 0x7fffffff;
            return f;
        }
        
        public static System.String FloatToPrefixCoded(float val)
        {
            return IntToPrefixCoded(FloatToSortableInt(val));
        }
        
        public static float SortableIntToFloat(int val)
        {
            if (val < 0)
                val ^= 0x7fffffff;
            return BitConverter.ToSingle(BitConverter.GetBytes(val), 0);
        }
        
        public static float PrefixCodedToFloat(System.String val)
        {
            return SortableIntToFloat(PrefixCodedToInt(val));
        }
        
        public static void  SplitLongRange(LongRangeBuilder builder, int precisionStep, long minBound, long maxBound)
        {
            SplitRange(builder, 64, precisionStep, minBound, maxBound);
        }
        
        public static void  SplitIntRange(IntRangeBuilder builder, int precisionStep, int minBound, int maxBound)
        {
            SplitRange(builder, 32, precisionStep, (long) minBound, (long) maxBound);
        }
        
        private static void  SplitRange(System.Object builder, int valSize, int precisionStep, long minBound, long maxBound)
        {
            if (precisionStep < 1)
                throw new System.ArgumentException("precisionStep must be >=1");
            if (minBound > maxBound)
                return ;
            for (int shift = 0; ; shift += precisionStep)
            {
                // calculate new bounds for inner precision
                long diff = 1L << (shift + precisionStep);
                long mask = ((1L << precisionStep) - 1L) << shift;
                bool hasLower = (minBound & mask) != 0L;
                bool hasUpper = (maxBound & mask) != mask;
                long nextMinBound = (hasLower?(minBound + diff):minBound) & ~ mask;
                long nextMaxBound = (hasUpper?(maxBound - diff):maxBound) & ~ mask;
                bool lowerWrapped = nextMinBound < minBound,
                     upperWrapped = nextMaxBound > maxBound;
      
                if (shift+precisionStep>=valSize || nextMinBound>nextMaxBound || lowerWrapped || upperWrapped) 
                {
                    // We are in the lowest precision or the next precision is not available.
                    AddRange(builder, valSize, minBound, maxBound, shift);
                    // exit the split recursion loop
                    break;
                }
                
                if (hasLower)
                    AddRange(builder, valSize, minBound, minBound | mask, shift);
                if (hasUpper)
                    AddRange(builder, valSize, maxBound & ~ mask, maxBound, shift);
                
                // recurse to next precision
                minBound = nextMinBound;
                maxBound = nextMaxBound;
            }
        }
        
        private static void  AddRange(System.Object builder, int valSize, long minBound, long maxBound, int shift)
        {
            // for the max bound set all lower bits (that were shifted away):
            // this is important for testing or other usages of the splitted range
            // (e.g. to reconstruct the full range). The prefixEncoding will remove
            // the bits anyway, so they do not hurt!
            maxBound |= (1L << shift) - 1L;
            // delegate to correct range builder
            switch (valSize)
            {
                
                case 64: 
                    ((LongRangeBuilder) builder).AddRange(minBound, maxBound, shift);
                    break;
                
                case 32: 
                    ((IntRangeBuilder) builder).AddRange((int) minBound, (int) maxBound, shift);
                    break;
                
                default: 
                    // Should not happen!
                    throw new System.ArgumentException("valSize must be 32 or 64.");
                
            }
        }
        
        public abstract class LongRangeBuilder
        {
            
            public virtual void  AddRange(System.String minPrefixCoded, System.String maxPrefixCoded)
            {
                throw new System.NotSupportedException();
            }
            
            public virtual void  AddRange(long min, long max, int shift)
            {
                AddRange(Lucene.Net.Util.NumericUtils.LongToPrefixCoded(min, shift), Lucene.Net.Util.NumericUtils.LongToPrefixCoded(max, shift));
            }
        }
        
        public abstract class IntRangeBuilder
        {
            
            public virtual void  AddRange(System.String minPrefixCoded, System.String maxPrefixCoded)
            {
                throw new System.NotSupportedException();
            }
            
            public virtual void  AddRange(int min, int max, int shift)
            {
                AddRange(Lucene.Net.Util.NumericUtils.IntToPrefixCoded(min, shift), Lucene.Net.Util.NumericUtils.IntToPrefixCoded(max, shift));
            }
        }
    }
}