《计算机科学导论》第四章数据运算

炼钢的柯察金

已于 2022-10-17 15:23:03 修改

阅读量271

点赞数

分类专栏：计算机基础·计算机科学导论文章标签：程序人生

于 2022-10-14 10:28:09 首次发布

本文链接：https://blog.csdn.net/cemaine/article/details/127315496

版权

计算机基础·计算机科学导论专栏收录该内容

4 篇文章 0 订阅

订阅专栏

第四章数据运算

4.1 逻辑运算

4.1.1 位层次上的逻辑运算

1.与

2.或

3.非

4.异或

4.1.2 模式层次上的逻辑运算

要点：

1.输入数字的位数必须相同

2.n位的逻辑运算，实际上是各个位的逻辑运算。

例1：计算：
$110110010\quad AND\quad 110110101$
$\begin{array}{r} 110110010\\ AND\quad 110110101\\ \hline 110110000 \end{array}$

例2：计算：
$10101110\quad XOR\quad 10111010010$
$\begin{array}{r} 00010101110\\ XOR\quad 10111010010\\ \hline 10101111110 \end{array}$
应用：掩码

1.输入一串掩码，且设定为原数据与掩码进行AND运算，则可将原数据指定位变0。

2.输入一串掩码，且设定为原数据与掩码进行OR运算，则可将原数据指定位变1。

3.输入一串掩码，且设定为原数据与掩码进行XOR运算，则可将原数据指定位反转。

4.2 移位运算

4.2.1 逻辑移位

1.单向移位：将数据所有位向左或向右移动一位，最高位或最低位丢弃，空位补0。

2.循环移位：将数据所有位向左或向右移动一位，空位补最高位或最低位。

4.2.2 算数移位

符号位不动，其他位进行逻辑移位。相当于整体被乘2或除以2取整。

4.3 算术运算

1.加法。除符号位外进行异或运算。

2.减法。取两数的补码进行异或运算。

例如：对 96-117 进行二进制移码运算
$(96)_2=1100000\\ 取移码为：01100000\\ (117)_2=1110101\\ 取原码为：11110101\\ 取反码为：10001010\\ 取移码为：10001011\\ 则：\\ \begin{aligned} (96)_{10}-(117)_{10}=\\ & =(1100000)_2-(11110101)_2\\ & =01100000+10001011\\ & =11101011 \end{aligned}\\ 上式结果11101011为结果真值的移码，下面进行还原：\\ 移码：11101011\\ 反码：11101010\\ 原码：10010101\\ 转化为十进制为：-21\\ 因此原式为：96-117=-21$
3.乘法与除法是多次使用加法和减法，配合计数器的结果。

4.浮点数的加法先将指数位对其，在进行相加，比较简单，不再赘述。

这里放出一个简单的数制、编码转化python小程序（bug很多，但我懒得改了🤡）：

#!这段程序用与实现前端GUI

import PySimpleGUI as sg
import Calculate as ca


def main():
    layout = [
        [sg.Text('八位数制、编码转换器，高位将被丢弃')],
        [sg.Text('请选择数制：')],
        [sg.Radio('二进制', 'NumSys', key='NumSysBIN'),
         sg.Radio('八进制', 'NumSys', key='NumSysOCT'),
         sg.Radio('十进制', 'NumSys', key='NumSysDEC'),
         sg.Radio('十六进制', 'NumSys', key='NumSysHEX'),
         ],
        [sg.Text('请选择编码：')],
        [sg.Radio('原码', 'Code', key='OCode'),
         sg.Radio('反码', 'Code', key='ICode'),
         sg.Radio('补码', 'Code', key='CCode'),
         ],
        [sg.Text("请输入数值：")],
        [sg.Input('', key='Num')],
        [sg.Button('确定')],
        [sg.Text("二进制原码："), sg.Text(key='BINOC')],
        [sg.Text("二进制反码："), sg.Text(key='BINIC')],
        [sg.Text("二进制补码："), sg.Text(key='BINCC')],
        [sg.Text("八进制原码："), sg.Text(key='OCTOC')],
        [sg.Text("八进制反码："), sg.Text(key='OCTIC')],
        [sg.Text("八进制补码："), sg.Text(key='OCTCC')],
        [sg.Text("十进制原码："), sg.Text(key='DECOC')],
        [sg.Text("十进制反码："), sg.Text(key='DECIC')],
        [sg.Text("十进制补码："), sg.Text(key='DECCC')],
        [sg.Text("十六进制原码："), sg.Text(key='HEXOC')],
        [sg.Text("十六进制反码："), sg.Text(key='HEXIC')],
        [sg.Text("十六进制补码："), sg.Text(key='HEXCC')],
        [sg.Text("注意：")],
        [sg.Text("二进制原码、反码、补码是按照编码规则转换的来")],
        [sg.Text("其他数制原码、反码、补码实际上是二进制数制转化得到的")]
    ]
    window = sg.Window('八位数制、编码转换器', layout)

    while True:
        event, values = window.read()
        if event == sg.WIN_CLOSED:
            break

        if event == '确定':
            updated = True

            if(updated):
                num = values['Num']
                if(values['NumSysOCT']):
                    num = bin(int(num, 8))[2::]
                if(values['NumSysDEC']):
                    num = bin(int(num, 10))[2::]
                if(values['NumSysHEX']):
                    num = bin(int(num, 16))[2::]
                if(values['OCode']):
                    BINOC = num
                if(values['ICode']):
                    BINOC = ca.BINICtoBINOC(num)
                if(values['CCode']):
                    BINOC = ca.BINCCtoBINOC(num)

                result = ca.BINOC(BINOC, 2)
                if(result != None):
                    window['BINOC'].update(result[0])
                    window['BINIC'].update(result[1])
                    window['BINCC'].update(result[2])
                    window['OCTOC'].update(result[3])
                    window['OCTIC'].update(result[4])
                    window['OCTCC'].update(result[5])
                    window['DECOC'].update(result[6])
                    window['DECIC'].update(result[7])
                    window['DECCC'].update(result[8])
                    window['HEXOC'].update(result[9])
                    window['HEXIC'].update(result[10])
                    window['HEXCC'].update(result[11])
                else:
                    sg.popup_error('存在错误，请检查')



if __name__ == '__main__':
    main()

#!这段程序实现后端运算

def BINadd1(BINIC):
    BINCC = [0, 0, 0, 0, 0, 0, 0, 0]
    carry = 1
    BINIC = list(BINIC)
    for i in range(8):
        BINCC[7-i] = eval(BINIC[7-i]) ^ carry
        carry = eval(BINIC[7-i]) and carry
    return "".join('%s' % id for id in BINCC)


def check(num, code):
    for i in range(len(num)):
        if(type(eval(num[i])) != int or eval(num[i]) >= code):
            print(type(eval(num[i])))
            return False
    return True


def checkbits(BINCode):
    if(BINCode != None and len(BINCode) >= 8):
        return BINCode[len(BINCode)-8:len(BINCode)+1]

    else:
        zero = "00000000"
        BINCode = zero + BINCode
        return checkbits(BINCode)


def BINOC(BINOC, code):
    BINOC = checkbits(BINOC)
    result = list()
    BINIC = [0, 0, 0, 0, 0, 0, 0, 0]
    BINCC = ""
    if(check(BINOC, code)):
        result.append(BINOC)
        if(BINOC[0] == '1'):
            BINIC[0] = 1
            for i in range(len(BINOC)-1):
                if(BINOC[i+1] == '0'):
                    BINIC[i+1] = 1
                else:
                    BINIC[i+1] = 0
            BINIC = "".join('%s' % id for id in BINIC)
            BINCC = BINadd1(BINIC)
        else:
            BINIC = BINOC
            BINCC = BINOC
        result.append(BINIC)
        result.append(BINCC)
        result.append(oct(int(BINOC, 2))[2::])
        result.append(oct(int(BINIC, 2))[2::])
        result.append(oct(int(BINCC, 2))[2::])
        result.append(int(BINOC, 2))
        result.append(int(BINIC, 2))
        result.append(int(BINCC, 2))
        result.append(hex(int(BINOC, 2))[2::])
        result.append(hex(int(BINIC, 2))[2::])
        result.append(hex(int(BINCC, 2))[2::])

        return result


def BINICtoBINOC(BINIC):
    BINIC = checkbits(BINIC)
    BINOC = [0 for i in range(8)]
    if(BINIC[0] == '1'):
        BINOC[0] = 1
        for i in range(len(BINIC)-1):
            if(BINIC[i+1] == '0'):
                BINOC[i+1] = 1
            else:
                BINOC[i+1] = 0
        BINOC = "".join('%s' % id for id in BINOC)
        return BINOC
    else:
        BINOC = BINIC
        return BINOC


def BINCCtoBINOC(BINCC):
    BINCC = checkbits(BINCC)
    if(BINCC[0] == '0'):
        BINOC = BINCC
        return BINOC
    else:
        BINIC = [0, 0, 0, 0, 0, 0, 0, 0]
        carry = 1
        BINCC = list(BINCC)
        for i in range(8):
            BINIC[7-i] = eval(BINCC[7-i]) ^ carry
            if(BINCC[7-i] == '0' and carry == 1):
                carry = 1
            else:
                carry = 0
        return BINICtoBINOC("".join('%s' % id for id in BINIC))