Zeckendorf arithmetic: Difference between revisions

{{trans|Python}}

 

Int dLen

dVal = 0

g = Zeckendorf(‘101010’)

g = g + Zeckendorf(‘101’)

 

{{out}}

=={{header|C}}==

{{trans|D}}

#include <stdio.h>

#include <string.h>

 

return 0;

{{out}}

<pre>Addition:

=={{header|C sharp|C#}}==

{{trans|Java}}

using System.Text;

 

}

}

{{out}}

<pre>Addition:

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

=={{header|D}}==

{{trans|Kotlin}}

 

int inv(int a) {

g += "101".Z;

writeln(g);

{{out}}

<pre>Addition:

{{trans|C++}}

ELENA 5.0 :

 

const dig = new string[]{"00","01","10"};

n += 101n;

console.printLine(n)

{{out}}

<pre>

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

g.PlusAssign(NewZeck("101"))

fmt.Println(g)

 

{{out}}

Addition and subtraction are done using cellular automata. Conversion from integers, multiplication and division are implemented via generalized Fibonacci series (Zeckendorf tables).

 

import Data.List (find, mapAccumL)

import Control.Arrow (first, second)

go res as [] = ((`f` 0) <$> reverse as) ++ res

go res [] bs = ((0 `f`) <$> reverse bs) ++ res

 

<pre>λ> 15 :: Fib

 

=={{header|J}}==

zinc=: {{ carry ({.,2}.])carry 1,y }}

zdec=: {{ (|.k$0 1),y }.~k=. 1+y i.1 }}

if. 2=s do. y,1 else. y end.

}}

 

For example, we use the decimal number 10100 to represent 11 in base 10, and 1010 would represent 7. We convert these numbers to an internal zeckendorf representation and add them, then convert the result back to decimal 101000 which represents 18 in base 10.

 

10

10 zadd&.zform 10

100101

100001000001 zdiv&.zform 100101

 

=={{header|Java}}==

{{trans|Kotlin}}

{{works with|Java|9}}

 

public class Zeckendorf implements Comparable<Zeckendorf> {

System.out.println(g);

}

{{out}}

<pre>Addition:

=={{header|Julia}}==

Influenced by the format of the Tcl and Raku versions, but added other functionality.

 

const z0 = "0"

 

zeckendorftest()

Addition:

101

=={{header|Kotlin}}==

{{trans|C++}}

 

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

g += "101".Z

println(g)

 

{{out}}

=={{header|Nim}}==

{{trans|Go}}

dVal: Natural

dLen: Natural

g = initZeckendorf("101010")

g += initZeckendorf("101")

 

{{out}}

 

=={{header|Perl}}==

 

use strict; # https://rosettacode.org/wiki/Zeckendorf_arithmetic

++$z for 1 .. $value;

return $z;

{{out}}

<pre>

They are however (and not all that surprisingly) pulled apart into individual bits for addition/subtraction, etc.<br>

Does not handle negative numbers or anything >139583862445 (-ve probably doable but messy, >1.4e12 requires a total rewrite, probably using string representation).

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #004080;">integer</span> <span style="color: #000000;">m</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">zmul</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0b10100</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0b1010</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #000000;">m</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"/"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0b1010</span><span style="color: #0000FF;">,</span><span style="color: #000000;">zdiv</span><span style="color: #0000FF;">(</span><span style="color: #000000;">m</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0b1010</span><span style="color: #0000FF;">),</span><span style="color: #008000;">"10100 rem 0"</span><span style="color: #0000FF;">)</span>

{{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:

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

less than '''ltz'''

 

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

 

printf $fmt, "$zeck *z {z('101001')}", $zeck *z= z('101001'), '# multiplication';

 

 

'''Testing Output'''

{{works with|Scala|2.13.1}}

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

import scala.collection.mutable.ListBuffer

 

 

}

Output:

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

=={{header|Tcl}}==

{{trans|Raku}}<!-- mostly for the technique of using incr/decr -->

# 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:

=={{header|Vlang}}==

{{trans|Go}}

const (

dig = ["00", "01", "10"]

g.plus_assign(new_zeck("101"))

println(g)

 

{{out}}

{{trans|Kotlin}}

{{libheader|Wren-trait}}

 

class Zeckendorf is Comparable {

g = Z.new("101010")

g.plusAssign(Z.new("101"))

 

{{out}}