ALU底层方法及计算机整数加减乘除模拟

ALU是计算机CPU的核心，即 算术逻辑单元(arithmetic and logic unit)
ALU有几大功能，是计算机计算最基础的功能：
1.算术运算：包含加法、减法等
2.逻辑运算：主要是布尔运算，逻辑和、或、非、异或等
3.求补器：计算机中，二进制补码极其重要，可以求一个二进制的补码（源码取反得反码，反码加一得补码）
4.移位器：主要有 算术右移、逻辑右移、左移
5.状态标志：一个记录状态的标志。

 
/**
 5 以下加法减法等都默认是相同长度的，如果长度不同会报错，当然，我只是懒得处理。 20  */

public class ALU {  23 
    /**
 * 返回一个整数的定长二进制字符串（补码）  26  *  27  * @param len 指定长度  28      */
    public String Int2Binary(int n, int len) {  30 // return Integer.toBinaryString(n);//注意，这个方法返回的是无符号的二进制，而且长度随参数而变的,故不可行,但是负数是可行的,负数返回32位
        String s = "";  32         for (int i = len - 1; i >= 0; i--) {  33             s += ((n >> i) & 1) == 1 ? "1" : "0";  34  }  35         return s;  36  }  37 
    /**
 * 默认长度，即可以满足的最小长度  40      */
    public String Int2Binary(int n) {  42         if (n == 0) return "0";  43         if (n > 0) {  44             return "0" + Integer.toBinaryString(n);  45         } else {  46             return getNegative("0" + Integer.toBinaryString(-n));  47  }  48  }  49 
    public int binary2Int(String binary) {  51         if(binary.charAt(0)=='0'）
 return Integer.valueOf(binary,2);
 else return -Integer.valueOf(getNegative(binary));  52  }  53 
    /**
 * 加法器：计算两个二进制的和  56  *  57  * @param binary1  58  * @param binary2 必须相同长度  59  * @return 返回len+1长度： 最高位进位+和  60      */
    public String add(String binary1, String binary2) {  62         int[] res = new int[binary1.length()];  63         int carry = 0;  64         for (int i = binary1.length() - 1; i >= 0; i--) {  65             res[i] = binary1.charAt(i) - '0' + binary2.charAt(i) - '0' + carry;  66             if (res[i] == 2) {  67                 carry = 1;  68                 res[i] = 0;  69             } else if (res[i] == 3) {  70                 carry = 1;  71                 res[i] = 1;  72             } else carry = 0;//无进位，前面一个进位置0
 }  74         String result = "";  75         for (int i = 0; i < res.length; i++) {//res中存放的是正的顺序，没有反
            result += res[i];  77  }  78         return carry + result;  79  }  80 
    public String substract(String a, String b) {//a-b = a+(-b) ,注意，多了一个最高位
        return add(a, getNegative(b));  83  }  84 
    public String get01(int n, String zeroORone) {  86         String res = "";  87         for (int i = 0; i < n; i++) {  88             res += zeroORone;  89  }  90         return res;  91  }  92 
    public String shiftRightLogically(String binary) {  94         return "0" + binary.substring(0, binary.length() - 1);  95  }  96 
    public String shiftLeft(String binary) {  98         return binary.substring(1) + "0";  99  } 100 
    /**
 * 算术右移 103      */
    public String shiftRight(String binary) { 105         return binary.charAt(0) + binary.substring(0, binary.length() - 1); 106  } 107 
    /**
 * 取补码（相反数） 110      */
    public String getNegative(String binary) { 112         return add(getComplement(binary), get01(binary.length() - 1, "0") + "1").substring(1);//add有一个最高位进位判断，去掉;
 } 114 
    /**
 * 取反码 117      */
    public String getComplement(String binary) { 119         String res = ""; 120         for (int i = 0; i < binary.length(); i++) { 121             res += (binary.charAt(i) == '1' ? "0" : "1"); 122  } 123         return res; 124  } 125 
    /**
 * 整数乘法，布思算法 128      */
    public String multiply(String Q, String M) { 130         char Q0 = '0'; 131         String A = get01(Q.length(), "0"); 132         for (int i = 0; i < Q.length(); i++) { 133             String QQ0 = Q.charAt(Q.length() - 1) + "" + Q0;//不能把两个char字符放在一起，会变成加
 System.out.println(QQ0); 135             if (QQ0.equals("10")) { 136                 A = substract(A, M).substring(1); 137             } else if (QQ0.equals("01")) { 138                 A = add(A, M).substring(1); 139  } 140             String temp = shiftRight(A + Q + Q0); 141             A = temp.substring(0, A.length()); 142             Q = temp.substring(A.length(), 2 * A.length()); 143             Q0 = temp.charAt(temp.length() - 1); 144  } 145         return A + Q; 146  } 147 
    public String[] divide(String a, String b) { // a/b
        String A = get01(a.length(), a.substring(0, 1));//附加寄存器，存放Q的扩展位，初始化为等位的被除数左扩位（1/0）
        String Q =  a; //被除数算术左扩为2n然后存到寄存器Q,注意A就是扩展位，扩展位不存在Q中，即AQM三个都等长
        String M = b;//除数放到寄存器M
        for (int i = 0; i < a.length(); i++) { 153             char A_sign = A.charAt(0); 154 
            //A Q 左移1位
            String temp = shiftLeft(A + Q); 157             A = temp.substring(0, a.length()); 158             Q = temp.substring(a.length()); 159 
            //判断ＭＡ是否同号
            if (M.charAt(0) == A.charAt(0)) {// A M has same sign
                A = substract(A, M).substring(1); 163  } 164             else { 165                 A = add(A, M).substring(1); 166  } 167 
            //判断A的符号变化没有；
            if (A_sign == A.charAt(0) || !A.contains("1")) {//A符号没变，或者A=0（不含“1”即全0）；
                Q = Q.substring(0, Q.length() - 1) + "1"; //Q0=1
 } 172             else {//A的符号变了，且A!=0
                Q = Q.substring(0, Q.length() - 1) + "0"; //Q0=0
                A = add(A, M).substring(1); //A =A+M 恢复;
 } 176  } 177         String[] res = new String[2]; //返回0：商，1：余数
        res[0] = (a.charAt(0) == b.charAt(0)) ? Q : getNegative(Q);//商在Q中，如果除数被除数不同号，则取补码 179         res[1] = A;//余数在A中 180         return res; 181  } 182 
    public static void main(String[] args) { 184         ALU s = new ALU(); 185         System.out.println(s.Int2Binary(5, 12)); 186         System.out.println(s.add("111", "111")); 187         System.out.println(s.get01(12, "1")); 188         System.out.println(s.shiftLeft("111111")); 189         System.out.println(s.shiftRight("011111")); 190         System.out.println(s.shiftRightLogically("111111")); 191         System.out.println(s.getComplement("111111100011")); 192         System.out.println(s.getNegative("1000100")); 193         System.out.println(s.Int2Binary(-12)); 194         System.out.println(s.multiply("011", "011"));//3X3=9
        System.out.println(s.multiply("1001", "0101"));//-7X3=-35

        System.out.println(s.divide("01111","00010")[0]+"..."+s.divide("01111","00010")[1]);//15/2=7...1 198  } 199 }

output:

000000000101
1110
111111111111
111110
001111
011111
000000011100
0111100
10100
10
11
01
001001
10
01
00
10
11011101
00111...00001

 

 

 

 

妈的，考完上机，刚才考得差不多都是上面这些内容，只有一个让人看不太懂的加法器，不过还好可以推理出来。

皇天不负有心人啊