To Michael,

Thanks for being willing to look this over and perhaps pass it along.  It's particularly good for me to address someone who is partial to C++ because my project involves numbers which can be converted among various formats and operated on in various methods.  I'll try walking you through some of them and I think you'll see the fit with OOP.  Where I define something that could be a program object or method, I'll put it in bold print.

Algorithms:

The Golden Mean, ~1.618034, is the exponential base for this number format.  So where in base-2 we add 1 and 1 and get 10, in base-G since 1 plus G equals G squared, then 1 plus 10 equals 100.  This can be visualized in the equation which has G as its root:   (G is just my shorthand for the Golden Mean)
               x(sqr) - x - 1 = 0    
so the sum of 1's in two adjacent positions gives a 1 in the next position.

(I am not the only one to have worked with this numeric format; it was 
the subject of a book by Oleksiy Stakhov and also written about under the name "phigitals" in a web page of Dr. Ron Knott at the University of Surrey, England.  There are web sites for each of them: goldenmuseum.com and mcs.surrey.ac.uk/Personal/R.Knott/Fibonacci/ ). 

I have explored the relationships between bit representations and recursive sequences which correspond to them; if we look at the powers of G we can express them as binomials with coefficients coming from the Fibonacci sequence.  These exponential powers are the values of 1's in each position of a bit representation:

5G + 3     3G + 2    2G + 1    1G + 1    1G + 0   0G+1  1G - 1  -1G+2    2G - 3   -3G + 5
~11.09    ~6.854    ~4.236    ~2.618    ~1.618   ~1.0    ~0.618  ~0.382 ~0.236    ~0.146  ...
G^5            G^4         G^3        G^2          G^1      G^0     G^-1    G^-2     G^-3      G^-4  ...

So if we take an arbitrary bit representation, 1001.0101 (note there are never adjacent one's in a bitrep) we can scale the 1's against the table above to get its binomial equivalent:

          1     0     0     1   .  0     1      0     1
        G^3     +       G^0    +  G^-2   +   G^-4
or    2G+1   +       0G+1  + -1G+2  + -3G+5  we get the sum -2G+9.

Putting these coefficients in the context of a recursive sequence, 
....  75  46  29  17  12  5  7  -2  9  -11  20  -31  51  -82  ....
then moving left and right along the sequence (to promote or demote its value) gives us pairs of coefficients for the same value multiplied or divided by G; the equivalent of moving the bitrep's radix point (the dot at G^0, analogous to a decimal point) to the right or left:

.... 17G+12  12G+5    5G+7    7G-2    -2G+9    9G-11    -11G+20    20G-31    -31G+51  .... 

It turns out that any arbitrary bitrepresentation like this can be assigned a pair of ordinal keys which are members of its sequence, by the following method of scaling against the Fibonacci sequence with the 1 at the right end anchored at Fibonacci[0] or 0:

            1     0     0     1     0     1     0     1
   ....    13    8     5     3     2     1     1     0

and by adding the 1's we get 17; this is in fact the ordinal position of the bitrep 10010101 if the possible bitreps are listed starting with the smallest (1 or #0) and adding legal 1's to the left without any adjacent 1's:
# 0                               1
# 1                           101
# 2                         1001
# 3                       10001
# 4                       10101
# 5                     100001
# 6                     100101
# 7                     101001
# 8                   1000001
# 9                   1000101
# 10                 1001001
# 11                 1010001
# 12                 1010101
# 13               10000001
# 14               10000101
# 15               10001001
# 16               10010001
# 17               10010101

So the scaling operation above demonstrates that a given sequence contains its own ordinal key as a member.

If we reverse the direction of addition with the same sequence, so:
     ....  82   51   31   20   11    9    2    7   -5  12  -17   29  -46   75  ....  
we get a different bit representation which is #31 or 101001001.  I call a sequence like this asymmetrical because it has different members on the left and right wings, and different keys for each wing.
 
A symmetrical sequence by contrast is one whose members mirror each other on the left and right wings; the only symmetrical sequences are the Fibonacci and Lucas sequences (and multiples of those sequences):
    ....  47  29  18  11  7  4  3  1  2  -1  3  -4  7  -11  18  -29  47  ....
    ....  21  13   8    5   3   2  1  1  0  1  -1  2  -3    5    -8   13  -21  ....

(Observe that adding alternate members of the Fibonacci sequence, say 8 and 3, gives a member of the Lucas sequence, here 11.  Corresponding members of these two sequences are related by a quotient of the square root of 5.)

If we derive the representations for integers, we find their sequences are simple multiples of the Fibonacci sequence, while the Lucas sequence gives values including Q, the square root of 5 (10.1 or 2G-1), and its multiples. I will demonstrate this by another use of scaling, where to get the representation for the integer 5, we successively subtract from 5 the powers of G until it is reduced to 0:

5.0    -    G^3  ~4.236    -    G^-1 ~.618    -    G^-4 ~.146   =  0,     so we spell out the bit representation 1000.1001 or #15.  Here are the first few integers and their ordinals:

1  =        1.  #0
2  =        10.01 #2 
3  =        100.01 #3
4  =        101.01 #4
5  =        1000.1001 #15
6  =        1010.0001 #18
7  =        10000.0001 #21
8  =        10001.0001 #24
                    
Interleaved with these patterns are the bit representations for the multiples of the Lucas sequence:

Q =     10.1  #1
2Q =   1000.001 #8
3Q =   1010.101 #12
4Q =   10010.01001  #44

There is a feature of asymmetrical sequences which I was surprised to find which I think is very important in a number-theoretical sense: by multiplying binomials of conjugate sequences, such as #17 and #31, you get products including all the prime integers ending in 1 and 9, and their composites. Here is the demonstration of long-multiplying #17 and #31:

                                     7G    - 2
                                  X 7G   - 5
                                 -35G   + 10
                    49G^2 -14G 
equals        49G^2  -49G  + 10;  then we simplify the G^2 term because G^2 = G + 1 ...
equals                                    59.

So the field of numbers defined here include the integers (from symmetric sequences),  include numbers which are asymmetric ffactors of sequence products as demonstrated above, and with the Lucas sequence and its multiples, include the square root of 5 (bitrep 10.1 being 2G-1 from sequence #1) and its integer multiples, so this format might be described as a unified representation of integers and a class of floating-point numbers, what you might call granular integers.  

I made a hand-mapping of bitreps color-grouped by their bit length, in which binomial coefficients give the row and columns of each cell; so row -2 and column 9 is where we find #17 for example.  The map helps to visualize the features of sequences and I could send you a scanned copy if you wish.  

I have also worked with hypersequences or multi-dimensional sequences to find objects analogous to the ones we see in 1D sequences, also with recursive sequences using different rules and giving different sets of internal products.

Applications

I am looking to implement these algorithms in a way that could provide tools for many kinds of possible applications.  Some examples:
-- Building a "black box" numeric processor that takes standard numeric input and internally uses recursive algorithms to perform arithmetic.  
-- Modeling and/or building alternative hardware implementations of recursive arithmetic
-- There is much study of the Golden Mean in nature (look for example at the Wikipedia page on phyllotaxis), in crystal structure, in geometry (as in the pentagon) and other areas.  It could be that these systems could be modeled most directly using an arithmetic that followed the same rules.
--  I think the features and complexity of recursive arithmetic are of compelling interest in themselves, and would like to see a program that allowed users to manipulate and convert representations as a learning experience.

I hope this seems like an adequate introduction for you or others to do your own explorations.  If there is any interest in implementing these methods I would very much like to contribute and I think an open source approach will be the most productive way to involve a community approach.

Thanks, Brian Cartwright (briancartwright2 at gmail.com)