Zeckendorf arithmetic: Difference between revisions

 

[http://arxiv.org/pdf/1207.4497.pdf Efficient algorithms for Zeckendorf arithmetic] is interesting. The sections on addition and subtraction are particularly relevant for this task.

 

=={{header|C}}==

{{trans|D}}

#include <stdio.h>

#include <string.h>

 

return 0;

{{out}}

<pre>Addition:

1000100</pre>

 

{{trans|Java}}

using System.Text;

 

}

}

{{out}}

<pre>Addition:

1000100

1000100</pre>

 

=={{header|D}}==

{{trans|Kotlin}}

 

int inv(int a) {

g += "101".Z;

writeln(g);

{{out}}

<pre>Addition:

1000100

1000100</pre>

 

=={{header|Elena}}==

{{trans|C++}}

 

 

sealed struct ZeckendorfNumber

};

0 { ^ self }

1 { ^ self }

2 {

{

^ self

3 {

int tmp := 3 $shl (i * 2);

self.b((i+1)*2)

if (pos == 0) { ^ self.inc() };

{

dVal += (1 $shl pos);

else

{

self.b(pos + 1);

int arg := pos - ((pos > 1) ? 2 : 1);

private c(int pos)

{

{

int tmp := 1 $shl pos;

^ self

int mLen := 0;

m.readContent(ref mVal, ref mLen);

{

{

self.b(GN)

int mLen := 0;

m.readContent(ref mVal, ref mLen);

{

{

self.c(GN)

};

{

dLen -= 1

internal constructor product(ZeckendorfNumber n, ZeckendorfNumber m)

{

ZeckendorfNumber Na := m;

ZeckendorfNumber Nt := 0n;

{

{

Nr += Nb

};

}

}

{

if (dVal == 0)

{ ^ "0" };

int i := dLen - 1;

while (i >= 0)

{

i-=1

n += 101n;

console.printLine(n)

{{out}}

<pre>

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

g.PlusAssign(NewZeck("101"))

fmt.Println(g)

 

{{out}}

1000100

</pre>

 

=={{header|Java}}==

{{trans|Kotlin}}

{{works with|Java|9}}

 

public class Zeckendorf implements Comparable<Zeckendorf> {

System.out.println(g);

}

{{out}}

<pre>Addition:

 

=={{header|Julia}}==

 

const z0 = "0"

 

zeckendorftest()

Addition:

101

=={{header|Kotlin}}==

{{trans|C++}}

 

class Zeckendorf(x: String = "0") : Comparable<Zeckendorf> {

g += "101".Z

println(g)

 

{{out}}

</pre>

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

{{out}}

<pre>

 

=={{header|PicoLisp}}==

 

(de unpad (Lst)

(test (numz (- X 1)) (decz (numz X))) ) )

 

 

=={{header|Python}}==

 

class Zeckendorf:

g = Zeckendorf("101010")

g = g + Zeckendorf("101")

{{out}}

<pre>Addition:

1000100

1000100</pre>

 

=={{header|Racket}}==

This implementation only handles natural (non-negative numbers). The algorithms for addition and subtraction use the techniques explained in the paper "Efficient algorithms for Zeckendorf arithmetic" (http://arxiv.org/pdf/1207.4497.pdf).

 

 

(define sqrt5 (sqrt 5))

(example '/ zeck-quotient 9876 1000)

(example '% zeck-remainder 9876 1000)

 

{{output}}

</pre>

 

=={{header|Scala}}==

The addition is an implementation of an algorithm suggested in http[:]//arxiv.org/pdf/1207.4497.pdf: Efficient Algorithms for Zeckendorf Arithmetic.

 

 

 

}

 

import Z._

 

 

}

}

}

}

 

}

}

}

}

}

 

 

}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Output:

<pre style="height: 30ex; overflow: scroll">101Z(i:4) + 10100Z(i:11) = 100010Z(i:15)

 

=={{header|Tcl}}==

# Want to use alternate symbols? Change these

variable zero "0"

namespace export \[a-y\]*

namespace ensemble create

Demonstrating:

puts [zeckendorf sub "10100" "1010"]

puts [zeckendorf mul "10100" "1010"]

puts [zeckendorf div "10100" "1010"]

{{out}}

<pre>

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Module Module1

End Sub

 

{{out}}

<pre>Addition:

1000100

1000100</pre>

 

{{omit from|Brlcad}}