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.

 

{{out}}

<pre>

101

1001

100101

1010000

</pre>

{{out}}

1

1000000

 

1000100

 

{{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++}}

 

 

while (i >= 0)

while (true)

if (dLen < i)

private b(int pos)

^ self

if (pos > 0)

internal constructor sum(ZeckendorfNumber n, ZeckendorfNumber m)

internal constructor difference(ZeckendorfNumber n, ZeckendorfNumber m)

internal constructor product(ZeckendorfNumber n, ZeckendorfNumber m)

Nr += Nb

internal constructor newInternal(int v, int l)

if (dVal == 0)

while (i >= 0)

i-=1

add(ZeckendorfNumber n)

subtract(ZeckendorfNumber n)

multiply(ZeckendorfNumber 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"

tolen(x::Z, n::Int) = (s = x.s; while length(s) < n s = z0 * s end; s)

 

==(x::Z, y::Z) = (l = pairlen(x, y); tolen(x, l) == tolen(y, l))

!=(x::Z, y::Z) = (l = pairlen(x, y); tolen(x, l) != tolen(y, l))

 

 

zeckendorftest()

Addition:

Subtraction:

Multiplication:

Division:

</pre>

 

=={{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|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._

 

 

}

}

}

}

 

}

}

}

}

}

 

 

}