Vector

Vector is an OISC invented by User:None1, it uses a 3-dimensional vector.

Data

As said above, Vector uses a 3D vector called A, it is initially (0,0,0).

A vector literal is represented by 3 real numbers separated by spaces.

Command

B c D

B and D are 3D vectors, c is a real number. The command means: If A·B equals to c, then (add A by D and jump to the start of program).

There is an output command, it is not required so it does not count in the number of commands:

B c D E

(Print the value of A·E then add A by D and jump to the start of program) if A·B equals to c. Whether as number or as character depends on implementation.

Examples

Print HI

1 0 0 0 72 0 0
1 0 0 72 1 0 0 1 0 0
1 0 0 73 1 0 0 1 0 0

Infinite loop

0 0 0 0 0 0 0

nVector

Of course, we can use other dimensions instead of 3 dimensions, that gives us nVector (n is the dimension number).

Command(s) are the same as vector except that a vector literal uses n numbers instead of three.

Computational class

Two-counter machines can be implemented in Vector (n≥3). The first two elements are the counters, with the third being the instruction pointer. Two counter machines have increment and decrement instructions for both counters, with the decrement jumping to another point depending on the state of the counter after decrementation. Two counter machines can also be represented as having three operations; a dumb increment, dumb decrement, and a check operation which determines if a counter is zero and takes one of two branches.

Since every instruction in the program is executed, each instruction must check to see if it's supposed to affect the accumulator. Basic increments and decrements can be done like so:

(0, 0, 1) k (m, n, 1)

Where k is the instruction number for this operation, and m, n is (1, 0), (0, 1), (-1, 0), or (0, -1) for the corresponding increment or decrement to counter 1 or 2. Note that this increases the instruction pointer always.

To check if a counter is zero, jumping if so:

(m, n, 1) k (0, 0, j)

For instruction number k, where (m, n) is (∞, 0) to check counter 1, or (0, ∞) for counter 2, and j is the difference between k and the target. While ∞ is not a real number, this method also works for corresponding m, n where the ∞ term is equal to max(k) + 1 for the program (i.e. one more than the instruction count). There are six cases to consider to ensure this works:

	IP < k	IP = k	IP > k
counter = 0	not k	k	not k
counter ≥ 1	∞	∞	∞

Meaning that the dot product with the check vector is only ever k when the IP is correct and the counter is 0. To handle the branch for if the counter is nonzero, an instruction of the form:

(0, 0, 1) k (0, 0, j)

Is placed immediately after the first jump instruction, with this j being calculated in the same manner for the nonzero jump target.

Initial arguments to the counters can be given by an initial instruction 0 in the form (0, 0, 1) 0 (m, n, 1) for the initial values m, n, with all true instructions then being 1-indexed. Halting can be done by adding the appropriate ∞ value to the IP, (0, 0, 1) k (0, 0, ∞). Since no instructions are numbered ∞, the accumulator will never change again.

Interpreters

Badly written by author in Python, 3D only but can be modified to support other dimensions:

import sys
k=sys.stdin.read().strip().split('\n')
acc=(0.0,0.0,0.0)
p=0
while p<len(k):
 kp=k[p]
 if len(kp.split())==7:
  a,b,c,d,e,f,g=list(map(float,kp.split()))
  if acc[0]*a+acc[1]*b+acc[2]*c==d:
   acc=(acc[0]+e,acc[1]+f,acc[2]+g)
   p=0
   continue
 else:
  a,b,c,d,e,f,g,h,i,j=list(map(float,kp.split()))
  if acc[0]*a+acc[1]*b+acc[2]*c==d:
   print(chr(int(acc[0]*h+acc[1]*i+acc[2]*j)),end='')
   acc=(acc[0]+e,acc[1]+f,acc[2]+g)
   p=0
   continue
 p+=1