Example #1
0
        public void BitwiseOperators(BitOperator op)
        {
            var seed = new Random().Next();
            var r    = new Random(seed);
            var a    = RandomBitString(r, 104);
            var b    = RandomBitString(r, 100);

            CreateBitString("a", a);
            Assert.True(Equals(a, "a"));
            CreateBitString("b", b);
            Assert.True(Equals(b, "b"));
            var result = DoBitOperation(op, a, b);

            if (op != BitOperator.Not)
            {
                _target.BitOp(op, "c", "a", "b");
            }
            else
            {
                _target.BitOp(op, "c", "a");
            }

            Console.WriteLine(op);
            Console.WriteLine(a);
            Console.WriteLine(b);
            Console.WriteLine(result);

            Assert.True(Equals(result, "c"), "failed with seed " + seed);
        }
Example #2
0
        private string DoBitOperation(BitOperator op, string a, string b)
        {
            var regex = new Regex("^[01]+$");

            if (!regex.IsMatch(a) || !regex.IsMatch(b))
            {
                throw new ArgumentException("string must contain only zeros and ones");
            }
            StringBuilder result = new StringBuilder(Math.Max(a.Length, b.Length));

            for (int i = 0; i < Math.Max(a.Length, b.Length); i++)
            {
                switch (op)
                {
                case BitOperator.And:
                    result.Append(BitAt(a, i) && BitAt(b, i) ? "1" : "0");
                    break;

                case BitOperator.Or:
                    result.Append(BitAt(a, i) || BitAt(b, i) ? "1" : "0");
                    break;

                case BitOperator.Xor:
                    result.Append(BitAt(a, i) ^ BitAt(b, i) ? "1" : "0");
                    break;

                case BitOperator.Not:
                    result.Append(BitAt(a, i) ? "0" : "1");
                    break;
                }
            }
            return(result.ToString());
        }
 public void Test1()
 {
     Assert.AreEqual(4, BitOperator.GetCountOfBitOne(0x1111));
     Assert.AreEqual(60, BitOperator.GetCountOfBitZero((long)0x1111));
     Assert.AreEqual(32, BitOperator.GetCountOfBitZero(0));
     Assert.AreEqual(64, BitOperator.GetCountOfBitZero((long)0));
 }
 public BitOperation(short _targetAddress, short _bitNumber, BitOperator _op, Register.RegisterFileMap _registerFileMap, short _address)
     : base(_registerFileMap, CYCLES, _address)
 {
     this.targetAddress = _targetAddress;
     this.bitNumber = _bitNumber;
     this.op = _op;
 }
Example #5
0
        public int BitOp(BitOperator op, string key, params string[] sourceKeys)
        {
            var sources = sourceKeys.Select(k => GetBitArray(k)).ToList();

            if (sources.Any(x => x == null))
            {
                // TODO: OrigoDB used CommandAbortedException
                throw new ArgumentException("one or more source keys do not exists", nameof(sourceKeys));
            }

            if (op == BitOperator.Not && sources.Count > 1)
            {
                // TODO: OrigoDB used CommandAbortedException
                throw new ArgumentException("BitOperator.Not requires a single source", nameof(sourceKeys));
            }

            if (op != BitOperator.Not && sources.Count < 2)
            {
                // TODO: OrigoDB used CommandAbortedException
                throw new ArgumentException("BitOperator requires at least 2 source sets");
            }

            // Ensure all sources is of the same length
            var maxLength = sources.Max(s => s.Length);

            sources.ForEach(s => s.Length = maxLength);

            var result = new BitArray(sources[0]);

            if (op == BitOperator.Not)
            {
                result = result.Not();
            }
            else
            {
                foreach (var bits in sources.Skip(1))
                {
                    switch (op)
                    {
                    case BitOperator.And:
                        result.And(bits);
                        break;

                    case BitOperator.Or:
                        result.Or(bits);
                        break;

                    case BitOperator.Xor:
                        result.Xor(bits);
                        break;
                    }
                }
            }

            _structures[key] = result;

            return(result.Length);
        }
Example #6
0
 protected override string BitOperation(string val1, string val2, BitOperator opt)
 {
     switch (opt)
     {
         case BitOperator.And:
             return string.Concat(val1, " & ", val2);
         case BitOperator.Or:
             return string.Concat(val1, " | ", val2);
         case BitOperator.Xor:
             return string.Concat(val1, " ^ ", val2);
         default:
             throw new ArgumentOutOfRangeException("opt");
     }
 }
Example #7
0
 protected override string BitOperation(string val1, string val2, BitOperator opt)
 {
     switch (opt)
     {
         case BitOperator.And:
             return string.Concat("BITAND(", val1, ", ", val2, ")");
         case BitOperator.Or:
             return string.Concat("((", val1, " + ", val2, ") - BITAND(", val1, ", ", val2, "))");
         case BitOperator.Xor:
             return string.Concat("((", val1, " + ", val2, ") - BITAND(", val1, ", ", val2, ") * 2)");
         default:
             throw new ArgumentOutOfRangeException("opt");
     }
 }
Example #8
0
        protected override string BitOperation(string val1, string val2, BitOperator opt)
        {
            switch (opt)
            {
            case BitOperator.And:
                return(string.Concat("BITAND(", val1, ", ", val2, ")"));

            case BitOperator.Or:
                return(string.Concat("((", val1, " + ", val2, ") - BITAND(", val1, ", ", val2, "))"));

            case BitOperator.Xor:
                return(string.Concat("((", val1, " + ", val2, ") - BITAND(", val1, ", ", val2, ") * 2)"));

            default:
                throw new ArgumentOutOfRangeException("opt");
            }
        }
Example #9
0
        protected override string BitOperation(string val1, string val2, BitOperator opt)
        {
            switch (opt)
            {
            case BitOperator.And:
                return(string.Concat(val1, " & ", val2));

            case BitOperator.Or:
                return(string.Concat(val1, " | ", val2));

            case BitOperator.Xor:
                return(string.Concat(val1, " ^ ", val2));

            default:
                throw new ArgumentOutOfRangeException("opt");
            }
        }
Example #10
0
        public bool GetAbility()
        {
            int haveCount    = BitOperator.GetBinaryCount(this.Ability);
            int ablitity     = AbilityEnum.RandomAbility();
            int abilityCount = BitOperator.GetBinaryCount(ablitity);

            if (this.MaxAbilityCount >= (haveCount + abilityCount) && !this.IsHaveAbility(ablitity))
            {
                this.Ability |= ablitity;
                GameMessage.AddMsg(new AbilityMessage()
                {
                    触发单位 = this, 获得的技能 = ablitity
                });
                return(true);
            }

            return(false);
        }
        public static ulong Sqrt(ulong x)
        {
            if (x <= 1)
            {
                return(x);
            }
            int s = 32 - (BitOperator.GetNumberOfLeadingZero(x - 1) >> 1);

            ulong g0 = ((ulong)1) << s;
            ulong g1 = (g0 + (x >> s)) >> 1;

            while (g1 < g0)
            {
                g0 = g1;
                g1 = (g0 + x / g0) >> 1;
            }
            return(g0);
        }
        public static uint Sqrt(uint x)
        {
            if (x <= 1)
            {
                return(x);
            }
            int s = (16 - (BitOperator.GetNumberOfLeadingZero(x - 1) >> 1));

            uint g0 = (uint)(1 << s);
            uint g1 = ((g0 + (x >> s)) >> 1);

            while (g1 < g0)
            {
                g0 = g1;
                g1 = (g0 + x / g0) >> 1;
            }
            return(g0);
        }
        public static ushort Sqrt(ushort x)
        {
            if (x <= 1)
            {
                return(x);
            }
            ushort s = (ushort)(4 - (BitOperator.GetNumberOfLeadingZero(x - 1) >> 1));

            ushort g0 = (ushort)(1 << s);
            ushort g1 = (ushort)((g0 + (x >> s)) >> 1);

            while (g1 < g0)
            {
                g0 = g1;
                g1 = (ushort)((g0 + x / g0) >> 1);
            }
            return(g0);
        }
        public static byte Sqrt(byte x)
        {
            if (x <= 1)
            {
                return(x);
            }
            byte s = (byte)(4 - (BitOperator.GetNumberOfLeadingZero(x - 1) >> 1));

            byte g0 = (byte)(1 << s);
            byte g1 = (byte)((g0 + (x >> s)) >> 1);

            while (g1 < g0)
            {
                g0 = g1;
                g1 = (byte)((g0 + x / g0) >> 1);
            }
            return(g0);
        }
 public static byte Log2(byte x)
 {
     return((byte)(7 - BitOperator.GetNumberOfLeadingZero(x)));
 }
Example #16
0
        public BaseOperation getNextOperation(short _codeAdress)
        {
            this.address = _codeAdress;

            // mask Operation-Byte --> xxxx xxxx 0000 0000
            short operation = (short)((short)programMemory[_codeAdress] & 0xFF00);
            // mask Parameter-Byte --> 0000 0000 xxxx xxxx
            short parameter = (short)((short)programMemory[_codeAdress] & 0x00FF);

            if (parameter < 0)
                throw new Exception("negative parameter");

            switch (operation)
            {
                /* ------------------------------------------------------ */
                /* -------- ARITHMETIC OPERATIONS ----------------------- */
                case ParserConstants.ADDWF:
                    // arithmetical operator
                    ArithOp = ArithmeticOperator.PLUS;
                    // target address
                    target = getTargetAddress(parameter);
                    // operating bytes
                    byte1 = registerFileMap.Get(RegisterConstants.WORKING_REGISTER_ADDRESS);
                    byte2 = registerFileMap.Get(getAddressFromParameter(parameter));
                    return new ArithmeticOperation(byte1, byte2, ArithOp, target, registerFileMap, address);
                case ParserConstants.ADDLW_1:
                case ParserConstants.ADDLW_2:
                    ArithOp = ArithmeticOperator.PLUS;
                    target = RegisterConstants.WORKING_REGISTER_ADDRESS;
                    byte1 = registerFileMap.Get(RegisterConstants.WORKING_REGISTER_ADDRESS);
                    byte2 = getLiteralFromParameter(parameter);
                    return new ArithmeticOperation(byte1, byte2, ArithOp, target, registerFileMap, address);
                case ParserConstants.INCF:
                    ArithOp = ArithmeticOperator.PLUS;
                    target = getTargetAddress(parameter);
                    byte1 = 0x01;
                    byte2 = registerFileMap.Get(getAddressFromParameter(parameter));
                    return new ArithmeticOperation(byte1, byte2, ArithOp, target, registerFileMap, address);
                case ParserConstants.SUBWF:
                    ArithOp = ArithmeticOperator.MINUS;
                    target = getTargetAddress(parameter);
                    byte1 = registerFileMap.Get(getAddressFromParameter(parameter));
                    byte2 = registerFileMap.Get(RegisterConstants.WORKING_REGISTER_ADDRESS);
                    return new ArithmeticOperation(byte1, byte2, ArithOp, target, registerFileMap, address);
                case ParserConstants.SUBLW_1:
                case ParserConstants.SUBLW_2:
                    ArithOp = ArithmeticOperator.MINUS;
                    target = RegisterConstants.WORKING_REGISTER_ADDRESS;
                    byte1 = getLiteralFromParameter(parameter);
                    byte2 = registerFileMap.Get(RegisterConstants.WORKING_REGISTER_ADDRESS);
                    return new ArithmeticOperation(byte1, byte2, ArithOp, target, registerFileMap, address);
                case ParserConstants.DECF:
                    ArithOp = ArithmeticOperator.MINUS;
                    target = getTargetAddress(parameter);
                    byte1 = registerFileMap.Get(getAddressFromParameter(parameter));
                    byte2 = 0x01;
                    return new ArithmeticOperation(byte1, byte2, ArithOp, target, registerFileMap, address);
                /* ------------------------------------------------------ */

                /* ------------------------------------------------------ */
                /* -------- BIT OPERATIONS ------------------------------ */
                case ParserConstants.BCF_1:
                case ParserConstants.BCF_2:
                case ParserConstants.BCF_3:
                case ParserConstants.BCF_4:
                    // bit operator
                    BitOp = BitOperator.BITCLEAR;
                    // target address
                    target = getAddressFromParameter(parameter);
                    // bit-number
                    bit = getBitNumberFromOperationCall(operation, parameter);
                    return new BitOperation(target, bit, BitOp, registerFileMap, address);
                case ParserConstants.BSF_1:
                case ParserConstants.BSF_2:
                case ParserConstants.BSF_3:
                case ParserConstants.BSF_4:
                    BitOp = BitOperator.BITSET;
                    target = getAddressFromParameter(parameter);
                    bit = getBitNumberFromOperationCall(operation, parameter);
                    return new BitOperation(target, bit, BitOp, registerFileMap, address);
                /* ------------------------------------------------------ */

                /* ------------------------------------------------------ */
                /* -------- CALL OPERATIONS ----------------------------- */
                case ParserConstants.CALL_1:
                case ParserConstants.CALL_2:
                case ParserConstants.CALL_3:
                case ParserConstants.CALL_4:
                case ParserConstants.CALL_5:
                case ParserConstants.CALL_6:
                case ParserConstants.CALL_7:
                case ParserConstants.CALL_8:
                    target = getTargetAddress(operation, parameter);
                    return new CallOperation(target, operationStack, programCounter, registerFileMap, address);
                /* ------------------------------------------------------ */

                /* ------------------------------------------------------ */
                /* -------- GOTO OPERATION ------------------------------ */
                case ParserConstants.GOTO_1:
                case ParserConstants.GOTO_2:
                case ParserConstants.GOTO_3:
                case ParserConstants.GOTO_4:
                case ParserConstants.GOTO_5:
                case ParserConstants.GOTO_6:
                case ParserConstants.GOTO_7:
                case ParserConstants.GOTO_8:
                    target = getTargetAddress(operation, parameter);
                    return new GotoOperation(target, programCounter, registerFileMap, address);
                /* ------------------------------------------------------ */

                /* ------------------------------------------------------ */
                /* -------- CLEAR OPERATIONS ---------------------------- */
                case ParserConstants.CLRF_CLRW:
                    target = getTargetAddress(parameter);
                    return new ClearOperation(target, registerFileMap, address);
                /* ------------------------------------------------------ */

                /* ------------------------------------------------------ */
                /* -------- COMPLEMENT OPERATIONS ----------------------- */
                case ParserConstants.COMF:
                    target = getTargetAddress(parameter);
                    if (target == RegisterConstants.WORKING_REGISTER_ADDRESS)
                        return new ComplementOperation(getAddressFromParameter(parameter), target, registerFileMap, address);
                    else
                        return new ComplementOperation(target, registerFileMap, address);
                /* ------------------------------------------------------ */

                /* ------------------------------------------------------ */
                /* -------- LOGIC OPERATIONS ---------------------------- */
                case ParserConstants.ANDWF:
                    LogOp = LogicOperator.AND;
                    target = getTargetAddress(parameter);
                    byte1 = registerFileMap.Get(getAddressFromParameter(parameter));
                    byte2 = registerFileMap.Get(RegisterConstants.WORKING_REGISTER_ADDRESS);
                    return new LogicOperation(byte1, byte2, LogOp, target, registerFileMap, address);
                case ParserConstants.ANDLW:
                    LogOp = LogicOperator.AND;
                    target = RegisterConstants.WORKING_REGISTER_ADDRESS;
                    byte1 = getLiteralFromParameter(parameter);
                    byte2 = registerFileMap.Get(RegisterConstants.WORKING_REGISTER_ADDRESS);
                    return new LogicOperation(byte1, byte2, LogOp, target, registerFileMap, address);
                case ParserConstants.IORWF:
                    LogOp = LogicOperator.IOR;
                    target = getTargetAddress(parameter);
                    byte1 = registerFileMap.Get(getAddressFromParameter(parameter));
                    byte2 = registerFileMap.Get(RegisterConstants.WORKING_REGISTER_ADDRESS);
                    return new LogicOperation(byte1, byte2, LogOp, target, registerFileMap, address);
                case ParserConstants.IORLW:
                    LogOp = LogicOperator.IOR;
                    target = RegisterConstants.WORKING_REGISTER_ADDRESS;
                    byte1 = getLiteralFromParameter(parameter);
                    byte2 = registerFileMap.Get(RegisterConstants.WORKING_REGISTER_ADDRESS);
                    return new LogicOperation(byte1, byte2, LogOp, target, registerFileMap, address);
                case ParserConstants.XORWF:
                    LogOp = LogicOperator.XOR;
                    target = getTargetAddress(parameter);
                    byte1 = registerFileMap.Get(getAddressFromParameter(parameter));
                    byte2 = registerFileMap.Get(RegisterConstants.WORKING_REGISTER_ADDRESS);
                    return new LogicOperation(byte1, byte2, LogOp, target, registerFileMap, address);
                case ParserConstants.XORLW:
                    LogOp = LogicOperator.XOR;
                    target = RegisterConstants.WORKING_REGISTER_ADDRESS;
                    byte1 = getLiteralFromParameter(parameter);
                    byte2 = registerFileMap.Get(RegisterConstants.WORKING_REGISTER_ADDRESS);
                    return new LogicOperation(byte1, byte2, LogOp, target, registerFileMap, address);
                /* ------------------------------------------------------ */

                /* ------------------------------------------------------ */
                /* -------- MOVE OPERATIONS ----------------------------- */
                case ParserConstants.MOVF:
                    target = getTargetAddress(parameter);
                    source = getAddressFromParameter(parameter);
                    return new MoveOperation(source, target, registerFileMap, address);
                case ParserConstants.MOVLW_1:
                case ParserConstants.MOVLW_2:
                case ParserConstants.MOVLW_3:
                case ParserConstants.MOVLW_4:
                    byte1 = getLiteralFromParameter(parameter);
                    target = RegisterConstants.WORKING_REGISTER_ADDRESS;
                    return new MoveOperation(byte1, target, registerFileMap, address);
                /* ------------------------------------------------------ */

                /* ------------------------------------------------------ */
                /* -------- ROTATE OPERATIONS --------------------------- */
                case ParserConstants.RLF:
                    RotDir = RotationDirection.LEFT;
                    target = getTargetAddress(parameter);
                    source = getAddressFromParameter(parameter);
                    return new RotateOperation(source, target, RotDir, registerFileMap, address);
                case ParserConstants.RRF:
                    RotDir = RotationDirection.RIGHT;
                    target = getTargetAddress(parameter);
                    source = getAddressFromParameter(parameter);
                    return new RotateOperation(source, target, RotDir, registerFileMap, address);
                /* ------------------------------------------------------ */

                /* ------------------------------------------------------ */
                /* -------- SWAP OPERATIONS ----------------------------- */
                case ParserConstants.SWAPF:
                    target = getTargetAddress(parameter);
                    source = getAddressFromParameter(parameter);
                    return new SwapOperation(source, target, registerFileMap, address);
                /* ------------------------------------------------------ */

                /* ------------------------------------------------------ */
                /* -------- BIT TEST OPERATIONS ----------------------------- */
                case ParserConstants.DECFSZ:
                    TestOp = TestOperator.DECFSZ;
                    target = getTargetAddress(parameter);
                    source = getAddressFromParameter(parameter);
                    return new TestOperation(source, TestOp, target, programCounter, registerFileMap, address);
                case ParserConstants.INCFSZ:
                    TestOp = TestOperator.INCFSZ;
                    target = getTargetAddress(parameter);
                    source = getAddressFromParameter(parameter);
                    return new TestOperation(source, TestOp, target, programCounter, registerFileMap, address);
                case ParserConstants.BTFSC_1:
                case ParserConstants.BTFSC_2:
                case ParserConstants.BTFSC_3:
                case ParserConstants.BTFSC_4:
                    BitTestOp = BitTestOperator.BTFSC;
                    source = getAddressFromParameter(parameter);
                    bit = getBitNumberFromOperationCall(operation, parameter);
                    return new BitTestOperation(source, bit, BitTestOp, programCounter, registerFileMap, address);
                case ParserConstants.BTFSS_1:
                case ParserConstants.BTFSS_2:
                case ParserConstants.BTFSS_3:
                case ParserConstants.BTFSS_4:
                    BitTestOp = BitTestOperator.BTFSS;
                    source = getAddressFromParameter(parameter);
                    bit = getBitNumberFromOperationCall(operation, parameter);
                    return new BitTestOperation(source, bit, BitTestOp, programCounter, registerFileMap, address);
                /* ------------------------------------------------------ */

                /* ------------------------------------------------------ */
                /* -------- RETURN OPERATIONS --------------------------- */
                case ParserConstants.RETLW_1:
                case ParserConstants.RETLW_2:
                case ParserConstants.RETLW_3:
                case ParserConstants.RETLW_4:
                    RetOp = ReturnOperator.RETLW;
                    byte1 = getLiteralFromParameter(parameter);
                    return new ReturnOperation(programCounter, operationStack, RetOp, byte1, registerFileMap, address);
                /* ------------------------------------------------------ */

                case 0x0000:
                    if(parameter > 127)
                    {
                        // MOVWF
                        target = getAddressFromParameter(parameter);
                        byte1 = registerFileMap.Get(RegisterConstants.WORKING_REGISTER_ADDRESS);
                        return new MoveOperation(byte1, target, registerFileMap, address);
                    }
                    switch (parameter)
                    {
                        case ParserConstants.CLRWDT:
                            return new ClearWdtOperation(pic, registerFileMap, address);
                        case ParserConstants.RETFIE:
                            RetOp = ReturnOperator.RETFIE;
                            return new ReturnOperation(programCounter, operationStack, RetOp, registerFileMap, address);
                        case ParserConstants.RETURN:
                            RetOp = ReturnOperator.RETURN;
                            return new ReturnOperation(programCounter, operationStack, RetOp, registerFileMap, address);
                        case ParserConstants.SLEEP:
                            return new SleepOperation(pic, registerFileMap, address);
                        case ParserConstants.NOP_1:
                        case ParserConstants.NOP_2:
                        case ParserConstants.NOP_3:
                        case ParserConstants.NOP_4:
                            return new NopOperation(registerFileMap, address);
                        default:
                            break;
                    }
                    break;

                default:
                    throw new Exception("unknown operation");
            }

            throw new Exception("unknown error");
        }
Example #17
0
        private static OperatorToken OperatorToken(string token, int index)
        {
            OperatorToken t = null;

            if (token.StartsWith(CONST_AND))
            {
                t = new OperatorToken();
            }
            else if (token.StartsWith(CONST_OR))
            {
                t = new OperatorToken();
            }
            else if (token.StartsWith(CONST_BIT_LEFT))
            {
                t = new BitOperator();
            }
            else if (token.StartsWith(CONST_BIT_RIGHT))
            {
                t = new BitOperator();
            }
            else if (token.StartsWith(CONST_NOT_EQUALS))
            {
                t = new ConditionToken();
            }
            else if (token.StartsWith(CONST_GREATER_EQUALS))
            {
                t = new ConditionToken();
            }
            else if (token.StartsWith(CONST_LESS_EQUALS))
            {
                t = new ConditionToken();
            }
            else if (token.StartsWith(CONST_EQUALS))
            {
                t = new ConditionToken();
            }
            else if (token.StartsWith(CONST_GREATER))
            {
                t = new ConditionToken();
            }
            else if (token.StartsWith(CONST_LESS))
            {
                t = new ConditionToken();
            }
            else if (token.StartsWith(CONST_PLUS))
            {
                t = new MathOperator();
            }
            else if (token.StartsWith(CONST_MINUS))
            {
                t = new MathOperator();
            }
            else if (token.StartsWith(CONST_MULT))
            {
                t = new MathOperator();
            }
            else if (token.StartsWith(CONST_DIVD))
            {
                t = new MathOperator();
            }
            else if (token.StartsWith(CONST_MOD))
            {
                t = new MathOperator();
            }
            else if (token.StartsWith(CONST_BIT_AND))
            {
                t = new BitOperator();
            }
            else if (token.StartsWith(CONST_BIT_LEFT))
            {
                t = new BitOperator();
            }
            else if (token.StartsWith(CONST_BIT_NOT))
            {
                t = new BitOperator();
            }
            else if (token.StartsWith(CONST_BIT_OR))
            {
                t = new BitOperator();
            }
            else if (token.StartsWith(CONST_BIT_RIGHT))
            {
                t = new BitOperator();
            }
            else if (token.StartsWith(CONST_BIT_XOR))
            {
                t = new BitOperator();
            }
            t.Value  = token;
            t.Index  = index;
            t.Length = token.Length;

            return(t);
        }
Example #18
0
 /// <summary> 解释按位运算 与,或,非
 /// </summary>
 /// <param name="val1">操作数1</param>
 /// <param name="val2">操作数2</param>
 /// <param name="opt">按位操作符</param>
 protected virtual string BitOperation(string val1, string val2, BitOperator opt)
 {
     throw new NotImplementedException("不支持当前操作,或请重新实现 BitOperation");
 }
 public static ulong Log2(ulong x)
 {
     return((ulong)(63 - BitOperator.GetNumberOfLeadingZero(x)));
 }
 public static uint Log2(uint x)
 {
     return((uint)(31 - BitOperator.GetNumberOfLeadingZero(x)));
 }
 public static ushort Log2(ushort x)
 {
     return((ushort)(15 - BitOperator.GetNumberOfLeadingZero(x)));
 }