subleq 中的按位运算

Question

许多页面展示了如何从单个 subleq 指令中合成更复杂的算术和逻辑运算。我还没有找到任何讨论按位运算实现的页面，例如 NAND、XOR ... 等

就我个人而言，我还没有找到不使用循环来实现任何这些操作（NOT 除外）的方法。有没有一种简洁的方法？

Answer 1

我写了一个小演示程序。我确实使用循环来实现一些运算符。

"""
This program demonstrates that you can write the bit operators AND, OR and XOR
in terms of the subtract and branch if equal or lower (subleq) operator.
https://en.wikipedia.org/wiki/One_instruction_set_computer

C.M. Punter 2016
"""
import random


def my_sub(a: int, b: int) -> int:
    return a - b


def my_leq(a: int, b: int) -> bool:
    return a <= b


# now we write all other functions in terms of the above two functions

def my_add(a: int, b: int) -> int:
    return my_sub(a, my_sub(0, b))


def my_mul(a: int, b: int) -> int:

    c = 0

    while my_leq(1, b):
        c = my_add(c, a)
        b = my_sub(b, 1)

    return c


def my_div(a: int, b: int) -> int:

    c = 0

    while my_leq(b, a):
        c = my_add(c, 1)
        a = my_sub(a, b)

    return c


def my_mod(a: int, b: int) -> int:

    while my_leq(b, a):
        a = my_sub(a, b)

    return a


def my_and(a: int, b: int) -> int:

    c = 0
    d = 1

    while my_leq(1, my_mul(a, b)):

        # we look at the first bit of a and b by checking if the number is odd or even
        # for this we use the modulo operator (a mod 2 and b mod 2)
        # this results in a 1 if the number is odd (which means the first bit is 1)
        # and 0 if the number is even (which means the first bit is 0)
        # multiplying those two numbers gives the and-operator for the first bit of a and b
        # the other bits are handled by bit-shifting a and b
        # this is equivalent to multiplying (left-shift) or dividing (right-shift) by 2

        c = my_add(c, my_mul(my_mul(my_mod(a, 2), my_mod(b, 2)), d))
        d = my_mul(d, 2)
        a = my_div(a, 2)
        b = my_div(b, 2)

    return c


def my_or(a: int, b: int) -> int:

    c = 0
    d = 1

    while my_leq(1, my_add(a, b)):
        if my_leq(1, my_add(my_mod(a, 2), my_mod(b, 2))):
            c = my_add(c, d)

        d = my_mul(d, 2)
        a = my_div(a, 2)
        b = my_div(b, 2)

    return c


def my_xor(a: int, b: int) -> int:

    c = 0
    d = 1

    while my_leq(1, my_add(a, b)):
        e = my_add(my_mod(a, 2), my_mod(b, 2))
        if my_leq(e, 1):
            c = my_add(c, my_mul(e, d))

        d = my_mul(d, 2)
        a = my_div(a, 2)
        b = my_div(b, 2)

    return c


def test(a: int, b: int):
    assert a & b == my_and(a, b)
    assert a | b == my_or(a, b)
    assert a ^ b == my_xor(a, b)

for i in range(1000):
    test(random.randint(0, 1024), random.randint(0, 1024))

Answer 2

有一种更有效的方法来执行此操作，这需要使用循环运算符并构造一个小于（但不等于）零的函数，您必须自己提供这些函数。这个想法是您可以检查单个位（最高位）是否为负，然后您可以使用它来构造 OR、AND 或 XOR。

/* Author: Richard James Howe
 * Email:  howe.r.j.89@gmail.com 
 * Using primitives available in SUBLEQ to perform bitwise operations */
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>

#define N   (16)
#define TST (9999)

typedef int16_t uword_t;
typedef int16_t  word_t;

static uword_t zlt(uword_t z) {
    return ((word_t)z) < 0 ? 0xFFFFu : 0;
}

static uword_t add(uword_t a, uword_t b) {
    return a - (uword_t)((uword_t)0 - b);
}

static uword_t lshift1(uword_t a) {
    return add(a, a);
}

static uword_t b_or(uword_t a, uword_t b) {
    uword_t r = 0;
    for (size_t i = 0; i < N; i++) {
        r = lshift1(r);
        if ((uword_t)(zlt(a) + zlt(b)) != (uword_t)0u)
            r++;
        a = lshift1(a);
        b = lshift1(b);
    }
    return r;
}

static uword_t b_xor(uword_t a, uword_t b) {
    uword_t r = 0;
    for (size_t i = 0; i < N; i++) {
        r = lshift1(r);
        if ((uword_t)(zlt(a) + zlt(b)) == (uword_t)0xFFFFu)
            r++;
        a = lshift1(a);
        b = lshift1(b);
    }
    return r;
}

static uword_t b_and(uword_t a, uword_t b) {
    uword_t r = 0;
    for (size_t i = 0; i < N; i++) {
        r = lshift1(r);
        if ((uword_t)(zlt(a) + zlt(b)) == (uword_t)0xFFFEu)
            r++;
        a = lshift1(a);
        b = lshift1(b);
    }
    return r;
}

static uword_t rnd(void) {
    return rand();
}

int main(void) {
    int pass_or = 1, pass_xor = 1, pass_and = 1;
    for (long i = 0; i < TST; i++) {
        uword_t a = rnd(), b = rnd();
        uword_t rn = a | b;
        uword_t rb = b_or(a, b);
        if (rb != rn) {
            printf("or fail %x %x -- expected %x got %x\n", a, b, rn, rb);
            pass_or = 0;
        }
    }
    printf("or %s\n", pass_or ? "pass" : "FAIL");
    for (long i = 0; i < TST; i++) {
        uword_t a = rnd(), b = rnd();
        uword_t rn = a ^ b;
        uword_t rb = b_xor(a, b);
        if (rb != rn) {
            printf("xor fail %x %x -- expected %x got %x\n", a, b, rn, rb);
            pass_xor = 0;
        }
    }
    printf("xor %s\n",  pass_xor ? "pass" : "FAIL");
    for (long i = 0; i < TST; i++) {
        uword_t a = rnd(), b = rnd();
        uword_t rn = a & b;
        uword_t rb = b_and(a, b);
        if (rb != rn) {
            printf("and fail %x %x -- expected %x got %x\n", a, b, rn, rb);
            pass_and = 0;
        }
    }
    printf("and %s\n",  pass_and ? "pass" : "FAIL");
    printf("done %s\n", pass_or && pass_xor && pass_and ? "pass" : "FAIL");
    return 0;
}

另见：

• https://gist.github.com/howerj/a08b127e944df30deaf0a4fec1a6d5be（此代码来自哪里）
• https://github.com/howerj/subleq（此代码用于 Forth 解释器）