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); }
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; }
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); }
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"); } }
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"); } }
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"); } }
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"); } }
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))); }
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"); }
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); }
/// <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))); }