I've designed some classes. Strategy implementing processor instruction jmp, to coords (x,y,z). Memory is cube addressed by coords (x,y,z). That is, this is 3d graph processor.

Object oriented processor might seem slow, but only if standard solutions are used. With proper design of hardware, new possibilities unfold. We can model reality faster, software is cheaper to develop, for on very low level it reflects programming language. No more tedious translations from language to language and again..

There's ALU (Arithmetic-Logic Unit), node where data meets with code, and where it is executed. It's also called 'processing unit' (this is alternative definition to ALU).

There are 12 general purpose registers (Reg0 ... Reg11) around processing unit, Instruction Pointer Register (Ipr), inside processing unit (for security and speed). It works on coords. There's also Clock Register (Creg).

You can see code: stable and unstable connection (it's graph not svn tree), comments and questions are welcome.

I've decided to allow for low level tricks without any security harness. This means that low level programmers will be able to design any MachineForm. Later there will be higher level programming language (for final product), called 'Ola', because it is too expensive to program everything in low level language. 'Ola' language will have 'Ah' level (Anti-hack). There will be Ah instruction for assembler code, which will allow for proper tools design.

Pi Number will be counted from equation:

2/Pi = (sqr(2)/2) * (sqr(2+sqr(2))/2) * ...

We'll create Finite State Automaton in 3D in Stitie Space, then iterate.

We'll use Object Oriented Notation of Numbers for this. See this post.

We'll count square root (sqr) using Newton's Method. I'll need to investigate this method properly (as part of **this** exercise) and implement this code in Java and Go and Ola independently.

There will be support for Groups and Bodies, so Pi number can be counted using higher algebra, perhaps more efficiently than using simpler methods.

(removed requirement for strange State organization... it's too complex, bizzare, slow and expensive).

CURRENTLY WORKING ON:

* Splitting and joining information flow (see this post in this blog). It will be optional. In processor it can be used to send register __state__ (value) or mnemonic (code can also be represented as value, or state) to processing unit (ALU, or place where code meets with data and is executed).

* There will be MATEN mnemonic, from 'Matrix Enhanced'. It will speed up processor instructions and flow information from registers at cost of other operations and registers. In runtime.) How it will work? There will be reorganizable topology of nodes and connections. MATEN will invoke certain forms (see this post and this post). This Method is called *polyformic programming* (it's something different than polymorphic programming, but not opposite). There will be *transition function* (method) that will transform one Machine Form into another. There will be Machine Form called Default Machine Form but it would not be mandatory to use it as transitory stage. This way we'll avoid bottlenecks (there can be faster transformations).

* Researching Mathematical instructions. See this post and this post.

* Researching Randezvous/Petri Net concurrency system. Multiple processes do something, then send tokens with results (partial or not) that are joined at *join node*. When *join node* finishes collecting all tokens (also called preconditions) it can join them in complete result and program can proceed. It's similar to Petri Net Transition Node behaviour but not neccessarily the same.

* Researching inner and outer layers, connected with *interface points*. It's used for 3d polymorphism and perhaps more (see this post). Outer layer contains subclasses, outer layer space is partitioned, each part contains subclass.

* Researching Jne mnemonic.

* Integrating Memory Adressing into MachineForm.

* Adressing state (done what's required for Jne).

Mathematical operations supported:

* computing sine (see this post).

* computing PI number.

* more to come later (for sure).

DONE:

* Jmp mnemonic. ( jump to 3d coords: to (x,y,z), not to address pointed by spherical angle. )

* Clock. (first try)

* Registers in 3D (close to processing unit).

* Modified Direction enum to use sane names.

* Routing information from Registers in 3D, not via single bottleneck array. Routing via different nodes can be done as needed.

* Jump if Not Equal mnemonic (Jne). Reconsidering mnemonic name for bcr [basic conditional redirect], because of Higher Algebra and 3d space. It's still conditional jump instruction. See also: this post.

* Basic Unicode support (UTF-32 only).

* ROT mnemonic.

* Maneuvers, that will be used in MATEN mnemonic.

Arithmetical / Logical mnemonics done:

* Add. (add long integers)

* Mul. (multiply long integers)

* Addp. (add arbitrary precision numbers. implemented operation with 3d coords.)

* Mulp. (multiply arbitrary precision numbers. implemented operation with 3d coords.) See: this post.

TODO:

Arithmetical / Logical mnemonics to be done:

* Addc. (add arbitrary precision numbers, changing base in process)

* Mulc. (multiply arbitrary precision numbers, changing base in process)

* Nbc. (number base change)

(... much more ...)

Need to use proper number notation, see this post. Note that arithmetical operation will depend on numbers being witten in the same form, more precisely, use the same base. For example, to add number written as base-2 number to number written as base-10 number, one of these numbers must be converted to other form. That is, both must have same base. Most supported types will be: base-2, base-3, base-4, base-6, base-8, base-10, base-12, base-16, base-84 and base-108.

Other things to do:

* Adressing state (done what's required for Jne). See this post.

* Logical and Mathematical mnemonics. Including Geometry with Linear Algebry, somehow. Including Matrix computations. See also: this post.

* 'Blum Blum Shub' Random number generator (first try). See also: this post.

* Basic concurrency support.

* Considering using reflection as part of processor services.

* Regular Expressions.

Feature list closed for this exercise. Perhaps in next it will be more or less, or differently.

This exercise and everything related is for Her, she can do anything she wishes or as she pleases. Sell, use, scrap, anything. Talk with her if you want to use it. Wherever she is.

Planned for future (not for this exercise):

* Complementary Forms. Arithmetic-Logic Unit (ALU), or point from which Form originates can have complementary Forms nearby. Forms can communicate with each other, independently from ALU. ALU will oversee and recreate missing forms. There's possibility for using multiple ALU. Communication with ALU is single-directional (from ALU to Complementary Form). This is just one of many possible ways of thinking, solutions. Complementary forms paradigm. Please note that ALU (seed of system, this is perhaps new meaning of word ALU) can move, and that objects can have aspects, including security aspects.

More information will be added later, perhaps.

Deadline for this project was: 06.06.2015, now is cancelled.