public static sbyte SetBitAt(this sbyte data, int pos)
        {
#if BITSTACK_DEBUG
            if (pos < 0 || pos > 7)
            {
                BitDebug.Exception("sbyte.SetBitAt(int) - position must be between 0 and 7 but was " + pos);
            }
#endif
            return((sbyte)((byte)data | 1 << pos));
        }
        public static sbyte SetByteAt(this sbyte data, byte newData, int pos)
        {
#if BITSTACK_DEBUG
            if (pos != 0)
            {
                BitDebug.Exception("sbyte.SetByteAt(int) - position must be between 0 and 0 but was " + pos);
            }
#endif
            return((sbyte)newData);
        }
        public static int BitInvAt(this sbyte data, int pos)
        {
#if BITSTACK_DEBUG
            if (pos < 0 || pos > 7)
            {
                BitDebug.Exception("sbyte.BitInvAt(int) - position must be between 0 and 7 but was " + pos);
            }
#endif
            return(1 - ((data >> pos) & 1));
        }
        public static int BitInvAt(this uint data, int pos)
        {
#if BITSTACK_DEBUG
            if (pos < 0 || pos > 31)
            {
                BitDebug.Exception("uint.BitInvAt(int) - position must be between 0 and 31 but was " + pos);
            }
#endif
            return(1 - (int)((data >> pos) & 1));
        }
        public static uint SetBitAt(this uint data, int pos)
        {
#if BITSTACK_DEBUG
            if (pos < 0 || pos > 31)
            {
                BitDebug.Exception("uint.SetBitAt(int) - position must be between 0 and 31 but was " + pos);
            }
#endif
            return(data | 1u << pos);
        }
        public static byte ByteAt(this uint data, int pos)
        {
#if BITSTACK_DEBUG
            if (pos < 0 || pos > 3)
            {
                BitDebug.Exception("uint.ByteAt(int) - position must be between 0 and 3 but was " + pos);
            }
#endif
            return((byte)(data >> (24 - (pos * 8))));
        }
Beispiel #7
0
        public static short SetBitAt(this short data, int pos)
        {
#if BITSTACK_DEBUG
            if (pos < 0 || pos > 15)
            {
                BitDebug.Exception("short.SetBitAt(int) - position must be between 0 and 15 but was " + pos);
            }
#endif
            return((short)((ushort)data | 1u << pos));
        }
Beispiel #8
0
        public static int BitAt(this short data, int pos)
        {
#if BITSTACK_DEBUG
            if (pos < 0 || pos > 15)
            {
                BitDebug.Exception("short.BitAt(int) - position must be between 0 and 15 but was " + pos);
            }
#endif
            return((data >> pos) & 1);
        }
 public static long SetBitAt(this long data, int pos)
 {
                 #if BITSTACK_DEBUG
     if (pos < 0 || pos > 63)
     {
         BitDebug.Exception("long.SetBitAt(int) - position must be between 0 and 63 but was " + pos);
     }
                 #endif
     return(data | 1L << pos);
 }
 public static byte ByteAt(this long data, int pos)
 {
                 #if BITSTACK_DEBUG
     if (pos < 0 || pos > 7)
     {
         BitDebug.Exception("long.ByteAt(int) - position must be between 0 and 7 but was " + pos);
     }
                 #endif
     return((byte)(data >> (56 - (pos * 8))));
 }
Beispiel #11
0
        public LinearKey3(int linearKey)
        {
#if BITSTACK_DEBUG
            if (linearKey < 0)
            {
                BitDebug.Exception("LinearKey3(int) - linear key must be positive");
            }
#endif

            this.linearKey = (uint)linearKey;
        }
Beispiel #12
0
        public MortonKey3(int mortonKey)
        {
                        #if BITSTACK_DEBUG
            if (mortonKey < 0)
            {
                BitDebug.Exception("MortonKey3(int) - morton key must be positive");
            }
                        #endif

            this.mortonKey = (uint)mortonKey;
        }
Beispiel #13
0
        public static long SetByteAt(this long data, byte newData, int pos)
        {
#if BITSTACK_DEBUG
            if (pos < 0 || pos > 7)
            {
                BitDebug.Exception("long.SetByteAt(int) - position must be between 0 and 7 but was " + pos);
            }
#endif
            int  shift = 56 - (pos * 8);
            long mask  = (long)0xFF << shift;
            long m1    = ((long)newData << shift) & mask;
            long m2    = data & ~mask;

            return(m2 | m1);
        }
Beispiel #14
0
        public static ushort SetByteAt(this ushort data, byte newData, int pos)
        {
                        #if BITSTACK_DEBUG
            if (pos < 0 || pos > 1)
            {
                BitDebug.Exception("ushort.SetByteAt(int) - position must be between 0 and 1 but was " + pos);
            }
                        #endif
            int shift = 8 - (pos * 8);
            int mask  = 0xFF << shift;
            int m1    = (newData << shift) & mask;
            int m2    = data & ~mask;

            return((ushort)(m2 | m1));
        }
        public static uint SetByteAt(this uint data, byte newData, int pos)
        {
                        #if BITSTACK_DEBUG
            if (pos < 0 || pos > 3)
            {
                BitDebug.Exception("uint.SetByteAt(int) - position must be between 0 and 3 but was " + pos);
            }
                        #endif
            int  shift = 24 - (pos * 8);
            uint mask  = (uint)(0xFF << shift);
            uint m1    = ((uint)newData << shift) & mask;
            uint m2    = data & ~mask;

            return(m2 | m1);
        }
        public static uint UIntFromBitString(this string data, int readIndex)
        {
                        #if BITSTACK_DEBUG
            if ((readIndex + 32) > data.Length)
            {
                BitDebug.Exception("string.UIntFromBitString(int) - read index and uint length is less than the string size");
            }
                        #endif
            uint value = 0;

            for (int i = readIndex, j = 31; i < 32; i++, j--)
            {
                value = data[i] == '1' ? value.SetBitAt(j) : value.UnsetBitAt(j);
            }

            return(value);
        }
Beispiel #17
0
        public static byte ByteFromBitString(this string data, int readIndex)
        {
#if BITSTACK_DEBUG
            if ((readIndex + 8) > data.Length)
            {
                BitDebug.Exception("string.ByteFromBitString(int) - read index and byte length is less than the string size");
            }
#endif
            byte value = 0;

            for (int i = readIndex, j = 7; i < 8; i++, j--)
            {
                value = data[i] == '1' ? value.SetBitAt(j) : value.UnsetBitAt(j);
            }

            return(value);
        }
        public static ulong ULongFromBitString(this string data, int readIndex)
        {
#if BITSTACK_DEBUG
            if ((readIndex + 64) > data.Length)
            {
                BitDebug.Exception("string.ULongFromBitString(int) - read index and ulong length is less than the string size");
            }
#endif
            ulong value = 0;

            for (int i = readIndex, j = 63; i < 64; i++, j--)
            {
                value = data[i] == '1' ? value.SetBitAt(j) : value.UnsetBitAt(j);
            }

            return(value);
        }
        public static uint SetBit(this uint data, int pos, int bit)
        {
                        #if BITSTACK_DEBUG
            if (pos < 0 || pos > 31)
            {
                BitDebug.Exception("uint.SetBit(int, int) - position must be between 0 and 31 but was " + pos);
            }

            if (bit != 0 && bit != 1)
            {
                BitDebug.Exception("uint.SetBit(int, int) - bit value must be either 0 or 1 but was " + bit);
            }
                        #endif
            uint mask = 1u << pos;
            uint m1   = ((uint)bit << pos) & mask;
            uint m2   = data & ~mask;

            return(m2 | m1);
        }
        public static int PopCount(this uint[] data)
        {
                        #if BITSTACK_DEBUG
            if (data == null)
            {
                BitDebug.Exception("uint[].PopCount() - array is null");
            }
                        #endif

            int counter = 0;
            int length  = data.Length;

            for (int i = 0; i < length; i++)
            {
                counter += data[i].PopCount();
            }

            return(counter);
        }
Beispiel #21
0
        public static long SetBit(this long data, int pos, long bit)
        {
#if BITSTACK_DEBUG
            if (pos < 0 || pos > 63)
            {
                BitDebug.Exception("long.SetBit(int, int) - position must be between 0 and 63 but was " + pos);
            }

            if (bit != 0 && bit != 1)
            {
                BitDebug.Exception("long.SetBit(int, int) - bit value must be either 0 or 1 but was " + bit);
            }
#endif
            long mask = 1L << pos;
            long m1   = (bit << pos) & mask;
            long m2   = data & ~mask;

            return(m2 | m1);
        }
Beispiel #22
0
        public static sbyte SetBit(this sbyte data, int pos, int bit)
        {
                        #if BITSTACK_DEBUG
            if (pos < 0 || pos > 7)
            {
                BitDebug.Exception("sbyte.SetBit(int, int) - position must be between 0 and 7 but was " + pos);
            }

            if (bit != 0 && bit != 1)
            {
                BitDebug.Exception("sbyte.SetBit(int, int) - bit value must be either 0 or 1 but was " + bit);
            }
                        #endif
            int mask = 1 << pos;
            int m1   = (bit << pos) & mask;
            int m2   = data & ~mask;

            return((sbyte)(m2 | m1));
        }
Beispiel #23
0
        public LinearKey3(uint x, uint y, uint z)
        {
#if BITSTACK_DEBUG
            if (x > 1024 || x < 0)
            {
                BitDebug.Exception("LinearKey3(uint, uint, uint) - linear key x component must be between 0-1023 (10 bits), was " + x);
            }

            if (y > 1024 || y < 0)
            {
                BitDebug.Exception("LinearKey3(uint, uint, uint) - linear key y component must be between 0-1023 (10 bits), was " + y);
            }

            if (z > 1024 || z < 0)
            {
                BitDebug.Exception("LinearKey3(uint, uint, uint) - linear key z component must be between 0-1023 (10 bits), was " + z);
            }
#endif
            this.linearKey = EncodeLinearKey(x, y, z);
        }
Beispiel #24
0
        public MortonKey3(int x, int y, int z)
        {
                        #if BITSTACK_DEBUG
            if (x > 1024 || x < 0)
            {
                BitDebug.Exception("MortonKey3(int, int, int) - morton key x component must be between 0-1023 (10 bits), was " + x);
            }

            if (y > 1024 || y < 0)
            {
                BitDebug.Exception("MortonKey3(int, int, int) - morton key y component must be between 0-1023 (10 bits), was " + y);
            }

            if (z > 1024 || z < 0)
            {
                BitDebug.Exception("MortonKey3(int, int, int) - morton key z component must be between 0-1023 (10 bits), was " + z);
            }
                        #endif
            mortonKey = BitMath.EncodeMortonKey((uint)x, (uint)y, (uint)z);
        }
Beispiel #25
0
        public static void SetByteAt(this byte[] data, byte newData, int pos)
        {
#if BITSTACK_DEBUG
            if (pos < 0)
            {
                BitDebug.Exception("byte[].SetByteAt(byte, int) - byte position must not be less than 0 was " + pos);
            }

            if (data == null)
            {
                BitDebug.Exception("byte[].SetByteAt(byte, int) - array is null");
            }

            if (pos > data.Length)
            {
                BitDebug.Exception("byte[].SetByteAt(byte, int) - byte bucket must not be greater than array " + data.Length + " was " + pos);
            }
#endif

            data[pos] = newData;
        }
        public static byte ByteAt(this sbyte[] data, int pos)
        {
                        #if BITSTACK_DEBUG
            if (pos < 0)
            {
                BitDebug.Exception("sbyte[].ByteAt(int) - byte position must not be less than 0 was " + pos);
            }

            if (data == null)
            {
                BitDebug.Exception("sbyte[].ByteAt(int) - array is null");
            }

            if (pos > data.Length)
            {
                BitDebug.Exception("sbyte[].ByteAt(int) - byte bucket must not be greater than array " + data.Length + " was " + pos);
            }
                        #endif

            return((byte)data[pos]);
        }
        public static byte ByteAt(this long[] data, int pos)
        {
            int byteIndex = pos / BYTE_LEN;

#if BITSTACK_DEBUG
            if (pos < 0)
            {
                BitDebug.Exception("long[].ByteAt(int) - byte position must not be less than 0 was " + pos);
            }

            if (data == null)
            {
                BitDebug.Exception("long[].ByteAt(int) - array is null");
            }

            if (byteIndex > data.Length)
            {
                BitDebug.Exception("long[].ByteAt(int) - byte bucket must not be greater than array " + data.Length + " was " + byteIndex);
            }
#endif

            return(data[byteIndex].ByteAt(pos % BYTE_LEN));
        }
        public static void SetByteAt(this uint[] data, byte newData, int pos)
        {
            int byteIndex = pos / BYTE_LEN;

                        #if BITSTACK_DEBUG
            if (pos < 0)
            {
                BitDebug.Exception("uint[].SetByteAt(byte, int) - byte position must not be less than 0 was " + pos);
            }

            if (data == null)
            {
                BitDebug.Exception("uint[].SetByteAt(byte, int) - array is null");
            }

            if (byteIndex > data.Length)
            {
                BitDebug.Exception("uint[].SetByteAt(byte, int) - byte bucket must not be greater than array " + data.Length + " was " + byteIndex);
            }
                        #endif

            data[byteIndex] = data[byteIndex].SetByteAt(newData, pos % BYTE_LEN);
        }
        public static void SetBit(this long[] data, int pos, int bit)
        {
            int bitIndex = pos / BIT_LEN;

#if BITSTACK_DEBUG
            if (pos < 0)
            {
                BitDebug.Exception("long[].SetBit(int, int) - bit position must not be less than 0 was " + pos);
            }

            if (data == null)
            {
                BitDebug.Exception("long[].SetBit(int, int) - array is null");
            }

            if (bitIndex > data.Length)
            {
                BitDebug.Exception("long[].SetBit(int, int) - bit bucket must not be greater than array " + data.Length + " was " + bitIndex);
            }
#endif

            // pipe into the single value type
            data[bitIndex] = data[bitIndex].SetBit(pos % BIT_LEN, bit);
        }
        public static int BitInvAt(this uint[] data, int pos)
        {
            int bitIndex = pos / BIT_LEN;

                        #if BITSTACK_DEBUG
            if (pos < 0)
            {
                BitDebug.Exception("uint[].BitInvAt(int) - bit position must not be less than 0 was " + pos);
            }

            if (data == null)
            {
                BitDebug.Exception("uint[].BitInvAt(int) - array is null");
            }

            if (bitIndex > data.Length)
            {
                BitDebug.Exception("uint[].BitInvAt(int) - bit bucket must not be greater than array " + data.Length + " was " + bitIndex);
            }
                        #endif

            // pipe into the single value type
            return(data[bitIndex].BitInvAt(pos % BIT_LEN));
        }