Bitmap

Bitmap is a computing system by Esolang wiki user User:Mia Boudreau that performs computations by mapping bits.

System explanation

Since $2$ base-$2$ digits can form $2^{2}=4$ possible numbers, any bitwise operation with two inputs and one output can be described as a $4$-bit number.

For example, $6_{10}=0110_{2}$, so $0\mapsto 0,1\mapsto 1,2\mapsto 1,3\mapsto 0$, which is equivalent to a XOR gate.

Applying sequential operations with different input/output addresses and maps is able to perform larger computations.

The interpreter for a single command can be viewed as a single operation:

1. Copy bit from map at index formed from bits at addresses src_a and src_b to bit at address dest.

Compiler

This C compiler uses a $32$ bit integer as the array. It is worth noting it only uses bitwise operations.

int run(int n, char map, char src_a, char src_b, char dest){
 int look = get_bit(map, get_bit(n,src_a)|get_bit(n,src_b)<<1),
 out_bit = 1<<dest;
 look ? n |= out_bit : (n &= ~out_bit);
 return n;
}
int get_bit(int n, int i){return n>>i&1;}

Variations are obvious for arrays of any size:

long long run(long long n, char map, char src_a, char src_b, char dest){
 int look = get_bit(map, get_bit(n,src_a)|get_bit(n,src_b)<<1),
 out_bit = 1<<dest;
 return look ? n|out_bit : (n&~out_bit);
}
int get_bit(long long n, int i){return n>>i&1;}

An economical system is to have a separate read-only array for sequentially read instructions. This allows for the data array to only be used for memory.

int run_str(int n, int *c, int L){
 for(int x = 0; x < L; x += 4){
  n = run(n,c[x],c[x+1],c[x+2],c[x+3]);
 }
 return n;
}

Working code example

#include <stdio.h>
#include <stdlib.h>

int run(int n, char map, char src_a, char src_b, char dest);
int get_bit(int n, int i);
int xor(int n, char src_a, char src_b, char dest);

int main(){
 int n = 01; // Input is 01; output of XOR will be 1
 for(int i = 0; i < 3; i++){
  printf("%d", get_bit(n, i)); // Initial array is '100'
 }
 printf("\n");
 
 n = xor(n, 0, 1, 2); // [0] XOR [1] -> [2]
 
 for(int i = 0; i < 3; i++){
  printf("%d", get_bit(n, i)); // Resultant array is '101'
 }
 return 0;
}

int run(int n, char map, char src_a, char src_b, char dest){
 int look = get_bit(map, get_bit(n,src_a)|get_bit(n,src_b)<<1),
 out_bit = 1<<dest;
 return look ? n|out_bit : (n&~out_bit);
}
int get_bit(int n, int i){return n>>i&1;}

int xor(int n, char src_a, char src_b, char dest){
 run(n, 6, src_a, src_b, dest);
}

Example functions

The machine language is in the format (map, src_a, src_b, dest).

set(dest):
 15, 0, 0, dest

clear(dest):
 0, 0, 0, dest

or(src_a, src_b, dest):
 14, src_a, src_b, dest

or_4bit(src_a, src_b, dest):
 or(src_a, src_b, dest)
 or(src_a+1, src_b+1, dest+1)
 or(src_a+2, src_b+2, dest+2)
 or(src_a+3, src_b+3, dest+3)

copy(src, dest):
 or(src, src, dest)

copy_4bit(src, dest):
 or_4bit(src, src, dest) 

shift_right_4bit(src, dest)
 copy(src+1, dest)
 copy(src+2, dest+1)
 copy(src+3, dest+2)
 clear(dest+3)

shift_left_4bit(src, dest)
 copy(src+2, dest+3)
 copy(src+1, dest+2)
 copy(src, dest+1)
 clear(dest)

swap(src_a, src_b):
 copy(src_a, 0)
 copy(src_b, src_a)
 copy(0, src_b)

swap_4bit(src_a, src_b):
 swap(src_a, src_b)
 swap(src_a+1, src_b+1)
 swap(src_a+2, src_b+2)
 swap(src_a+3, src_b+3)

nor(src_a, src_b, dest):
 1, src_a, src_b, dest

nor_4bit(src_a, src_b, dest):
 nor(src_a, src_b, dest)
 nor(src_a+1, src_b+1, dest+1)
 nor(src_a+2, src_b+2, dest+2)
 nor(src_a+3, src_b+3, dest+3)

not(src, dest):
 nor(src, src, dest)

not_4bit(src, dest):
 not(src, dest)
 not(src+1, dest+1)
 not(src+2, dest+2)
 not(src+3, dest+3)

and(src_a, src_b, dest):
 8, src_a, src_b, dest

and_4bit(src_a, src_b, dest):
 and(src_a, src_b, dest)
 and(src_a+1, src_b+1, dest+1)
 and(src_a+2, src_b+2, dest+2)
 and(src_a+3, src_b+3, dest+3)

nand(src_a, src_b, dest):
 7, src_a, src_b, dest

nand_4bit(src_a, src_b, dest):
 nand(src_a, src_b, dest)
 nand(src_a+1, src_b+1, dest+1)
 nand(src_a+2, src_b+2, dest+2)
 nand(src_a+3, src_b+3, dest+3)
 
xor(src_a, src_b, dest):
 6, src_a, src_b, dest

xor_4bit(src_a, src_b, dest):
 xor(src_a, src_b, dest)
 xor(src_a+1, src_b+1, dest+1)
 xor(src_a+2, src_b+2, dest+2)
 xor(src_a+3, src_b+3, dest+3)

nxor(src_a, src_b, dest):
 9, src_a, src_b, dest

nxor_4bit(src_a, src_b, dest):
 nxor(src_a, src_b, dest)
 nxor(src_a+1, src_b+1, dest+1)
 nxor(src_a+2, src_b+2, dest+2)
 nxor(src_a+3, src_b+3, dest+3)

half_adder(src_a, src_b, dest_a, dest_b):
 xor(src_a, src_b, dest_a)
 and(src_a, src_b, dest_b) 

increment_4bit(src, dest):
 set(0)
 half_adder(0, src, dest, 0)
 half_adder(0, src+1, dest+1, 0)
 half_adder(0, src+2, dest+2, 0)
 half_adder(0, src+3, dest+3, 0)