Zeckendorf arithmetic: Difference between revisions

 

;Division

<pre>

1000101 -

1 so 1000101 divided by 101 is d + a (1001) remainder 1

</pre>

 

=={{header|C++}}==

{{works with|C++11}}

// I define an increment operation ++()

// I define a comparison operation <=(other N)

return os;

}

===Testing===

The following tests addtition:

N G;

G = 10N;

std::cout << G << std::endl;

return 0;

{{out}}

<pre>

</pre>

The following tests subtraction:

N G;

G = 1000N;

std::cout << G << std::endl;

return 0;

{{out}}

<pre>

</pre>

The following tests multiplication:

int main(void) {

N G = 1001N;

std::cout << G << std::endl;

return 0;

{{out}}

<pre>

</pre>

 

This is a somewhat limited implementation of Zeckendorf arithmetic operators. They only handle positive integer values. There are no actual calculations, everything is done with string manipulations, so it doesn't matter what glyphs you use for 1 and 0.

 

Implemented arithmetic operators:

 

Comparison operators:

 

my $z0 = '0'; # glyph to use for a '0'

 

 

######## Zeckendorf comparison operators #########

 

# less than

 

# greater than

 

# equal

 

# not equal

 

######## Operators for Zeckendorf arithmetic ########

# post increment

sub postfix:<++z>($a is rw) {

$a ~~ s/^$z0+//;

$a

# post decrement

sub postfix:<--z>($a is rw) {

$a ~~ s/^$z0+(.+)$/$0/;

$a

 

# addition

 

# subtraction

 

# multiplication

return $z0 if $a eqz $z0 or $b eqz $z0;

return $a if $b eqz $z1;

} until $d eqz $b;

$c

 

# division (really more of a div mod)

my $d = $b +z ($z1 ~ $z0);

$c++z;

$a--z while $d--z nez $z0

} until $a ltz $b;

$c ~= " remainder $a" if $a nez $z0;

$c

 

###################### Testing ######################

 

# helper sub to translate constants into the particular glyphs you used

 

say "Using the glyph '$z1' for 1 and '$z0' for 0\n";

printf $fmt, "$zeck -z {z('100')}", $zeck -z= z('100'), '# subtraction';

 

 

printf $fmt, "$zeck /z {z('100')}", $zeck /z= z('100'), '# division';

printf( $fmt, "$zeck--z", $zeck--z, '# decrement' ) for 1 .. 5;

 

 

 

'''Testing Output'''

10001++z = 10010 # increment

10010++z = 10100 # increment

100001000001 /z 100 = 101010001 # division

101010001--z = 101010000 # decrement

101001001--z = 101001000 # decrement

101001000--z = 101000101 # decrement

<pre>

Using the glyph 'X' for 1 and 'O' for 0

XOOOX++z = XOOXO # increment

XOOXO++z = XOXOO # increment

XOOOOXOOOOOX /z XOO = XOXOXOOOX # division

XOXOXOOOX--z = XOXOXOOOO # decrement

XOXOOXOOX--z = XOXOOXOOO # decrement

XOXOOXOOO--z = XOXOOOXOX # decrement