Balanced ternary: Difference between revisions

{{task}}

 

 

# Support arbitrarily large integers, both positive and negative;

# Provide ways to convert to and from text strings, using digits '+', '-' and '0' (unless you are already using strings to represent balanced ternary; but see requirement 5).

# Provide ways to perform addition, negation and multiplication directly on balanced ternary integers; do ''not'' convert to native integers first.

# Make your implementation efficient, with a reasonable definition of "efficient" (and with a reasonable definition of "reasonable").

 

'''Test case''' With balanced ternaries ''a'' from string "+-0++0+", ''b'' from native integer -436, ''c'' "+-++-":

* write out ''a'', ''b'' and ''c'' in decimal notation;

* calculate ''a'' × (''b'' − ''c''), write out the result in both ternary and decimal notations.

 

'''Note:''' The pages [[generalised floating point addition]] and [[generalised floating point multiplication]] have code implementing [[wp:arbitrary precision|arbitrary precision]] [[wp:floating point|floating point]] balanced ternary.

 

 

=={{header|Ada}}==

Specifications (bt.ads):

 

package BT is

procedure Finalize (Object : in out Balanced_Ternary);

 

Implementation (bt.adb):

 

package body BT is

end Initialize;

 

 

Test task requirements (testbt.adb):

with Ada.Integer_Text_Io; use Ada.Integer_Text_Io;

with BT; use BT;

Put("a * (b - c) = "); Put(To_integer(Result), 4);

Put_Line (" " & To_String(Result));

Output:

<pre>

a * (b - c) = -262023 ----0+--0++0

</pre>

 

=={{header|ATS}}==

(*

** This one is

//

} (* end of [main0] *)

Output:

<pre>

 

=={{header|AutoHotkey}}==

k = 0

if abs(n)<2

}

return r

(

523

result .= A_LoopField " : " BalancedTernary(A_LoopField) "`n"

MsgBox % result

Outputs:<pre>

523 : +-0++0+

-262023 : ----0+--0++0</pre>

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

}

 

 

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

using System.Text;

using System.Collections.Generic;

return result;

}

output:

<pre>a: +-0++0+ = 523

c: +-++- = 65

a * (b - c): ----0+--0++0 = -262023</pre>

 

=={{header|Common Lisp}}==

;;; represented as a list of 0, 1 or -1s, with least significant digit first

(bt-integer b) (bt-string b)

(bt-integer c) (bt-string c)

b -436 -++-0--

c 65 +-++-

 

=={{header|D}}==

{{trans|Python}}

 

struct BalancedTernary {

const /*immutable*/ r = a * (b - c);

writeln("a * (b - c): ", r.toBint, ' ', r);

{{out}}

<pre>a: 523 +-0++0+

=={{header|Elixir}}==

{{trans|Erlang}}

def to_string(t), do: ( for x <- t, do: to_char(x) ) |> List.to_string

IO.puts "b = #{bs} -> #{b}"

IO.puts "c = #{cs} -> #{c}"

 

{{out}}

 

=={{header|Erlang}}==

-module(ternary).

-compile(export_all).

add_util(1) -> [0,1];

add_util(0) -> [0,0].

'''Output'''

234> ternary:test().

A = +-0++0+ -> 523

A x (B - C) = 0----0+--0++0 -> -262023

ok

 

=={{header|Glagol}}==

</pre>

'''A crude English/Pidgin Algol translation of the above [[:Category:Glagol]] code.'''

USES

Parameter IS "...\Departments\Exchange\"

Output.ChTarget(" = %d.", InNumber(), 0, 0, 0);

Remove.Memory

 

=={{header|Go}}==

 

import (

fmt.Println("int overflow")

}

{{out}}

<pre>

=={{header|Groovy}}==

Solution:

m('-', -1), z('0', 0), p('+', 1)

 

 

String toString() { value }

 

Test:

BalancedTernaryInteger b = new BalancedTernaryInteger(-436)

BalancedTernaryInteger c = new BalancedTernaryInteger(T.p, T.m, T.p, T.p, T.m)

 

println "\nDemonstrate failure:"

 

Output:

=={{header|Haskell}}==

BTs are represented internally as lists of digits in integers from -1 to 1, but displayed as "+-0" strings.

 

zeroTrim a = if null s then [0] else s where

print $ map btInt [a,b,c]

print $ r

 

=={{header|Icon}} and {{header|Unicon}}==

 

Works in both languages:

a := "+-0++0+"

write("a = +-0++0+"," = ",cvtFromBT("+-0++0+"))

}

return (\negate,map(mul,"+-","-+")) | mul

 

Output:

Implementation:

 

trinOfN=: |.@((_1 + ] #: #.&1@] + [) #&3@trigits) :. nOfTrin

nOfTrin=: p.&3 :. trinOfN

add=: carry@(+/@,:)

neg=: -

 

trinary numbers are represented as a sequence of polynomial coefficients. The coefficient values are limited to 1, 0, and -1. The polynomial's "variable" will always be 3 (which happens to illustrate an interesting absurdity in the terminology we use to describe polynomials -- one which might be an obstacle for learning, for some people).

<code>trimLead0</code> removes leading zeros from a sequence of polynomial coefficients.

 

 

Definitions for example:

 

b=: trinOfN -436

 

Required example:

 

523 _436 65

 

----0+--0++0

nOfTrin a mul b (add -) c

 

=={{header|Java}}==

/*

* Test case

}

}

 

Output:

 

result= ----0+--0++0 -262023

</pre>

 

=={{header|Liberty BASIC}}==

global tt$

tt$="-0+" '-1 0 1; +2 -> 1 2 3, instr

wend

end function

 

{{out}}

a * (b - c) -262023

</pre>

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

3] &;

tobt = If[Quotient[#, 3, -1] == 0,

btnegate@#1],

If[StringLength@#2 == 1,

Examples:

b = tobt@-436

frombt[c = "+-++-"]

Outputs:

<pre>523

=={{header|МК-61/52}}==

{{trans|Glagol}}

ИП0 ^ ^ 3 / [x] П0 3 * - П1

 

''Note: the "-", "0", "+" denotes by digits, respectively, the "7", "8", "9".''

 

=={{header|OCaml}}==

type btern = btdigit list

 

let _ =

Printf.printf "a = %d\nb = %d\nc = %d\na * (b - c) = %s = %d\n"

Output:

<pre>a = 523

 

=={{header|Perl}}==

use warnings;

 

printf " c: %14s %10d\n", $c, from_bt( $c );

printf "a*(b-c): %14s %10d\n", $d, from_bt( $d );

{{out}}

<pre> a: +-0++0+ 523

a*(b-c): ----0+--0++0 -262023

</pre>

 

=={{header|Phix}}==

Using strings to represent balanced ternary. Note that as implemented dec2bt and bt2dec are limited to Phix integers (~+/-1,000,000,000),

but it would probably be pretty trivial (albeit quite a bit slower) to replace them with (say) ba2bt and bt2ba which use/yield bigatoms.

{{out}}

<pre>

</pre>

Proof of arbitrary large value support is provided by calculating 1000! and 999! and using a naive subtraction loop to effect division.

show it manages a 5000+digit multiplication and subtraction in about 0.2s, which I say is "reasonable", given that I didn't try very hard,

as evidenced by that daft addition lookup table!

{{out}}

<pre>

 

=={{header|PicoLisp}}==

 

(setq *G '((0 -1) (1 -1) (-1 0) (0 0) (1 0) (-1 1) (0 1)))

(println 'R (trih R) R) )

 

 

=={{header|Prolog}}==

'''The conversion.'''<br>

Library '''clpfd''' is used so that '''bt_convert''' works in both ways Decimal => Ternary and Ternary ==> Decimal.

op(950, xfx, btconv),

btconv/2]).

R1 #= R - 3 * C1, % C1 #= 1,

convert(N1, C1, [R1 | LC], LF).

'''The addition.''' <br>

The same predicate is used for addition and substraction.

bt_add1/3,

op(900, xfx, btplus),

strip_nombre(L) -->

L.

'''The multiplication.''' <br>

We give a predicate '''euclide(?A, +B, ?Q, ?R)''' which computes both the multiplication and the division, but it is very inefficient.<br>

The predicates '''multiplication(+B, +Q, -A)''' and '''division(+A, +B, -Q, -R)''' are much more efficient.

btmult/2,

multiplication/3

; mult_(B, Q1, A1, R, Resultat, Ajout)) .

 

Example of output :

<pre> ?- A btconv "+-0++0+".

Z = -262023 .

</pre>

=={{header|Python}}==

# Represented as a list of 0, 1 or -1s, with least significant digit first.

 

print "a * (b - c):", r.to_int(), r

 

{{out}}

<pre>a: 523 +-0++0+

 

=={{header|Racket}}==

 

;; Represent a balanced-ternary number as a list of 0's, 1's and -1's.

[description (list 'a 'b 'c "a×(b−c)")])

(printf "~a = ~a or ~a\n" description (bt->integer bt) (bt->string bt))))

 

{{output}}

a×(b−c) = -262023 or ----0+--0++0

</pre>

 

=={{header|REXX}}==

The REXX program could be optimized by using &nbsp; (procedure) with &nbsp; '''expose''' &nbsp; and having the &nbsp; <big>'''$.'''</big> &nbsp; and &nbsp; <big>'''@.'''</big> &nbsp; variables set only once.

<pre>

[a] +-0++0+ balanced ternary = 523 (decimal)

 

[a*(b-c)] ----0+--0++0 balanced ternary = -262023 (decimal)

</pre>

 

=={{header|Ruby}}==

include Comparable

def initialize(str = "")

val = eval(exp)

puts "%8s :%13s,%8d" % [exp, val, val.to_i]

 

{{out}}

c : +-++-, 65

a*(b-c) : ----0+--0++0, -262023

</pre>

 

=={{header|Scala}}==

This implementation represents ternaries as a reversed list of bits. Also, there are plenty of implicit convertors

object TernaryBit {

val P = TernaryBit(+1)

implicit def intToTernary(i: Int): Ternary = valueOf(i)

}

 

Then these classes can be used in the following way:

object Main {

 

 

}

{{out}}

<pre>

 

Besides, we can easily check, that the code works for any input. This can be achieved with ScalaCheck:

object TernarySpecification extends Properties("Ternary") {

 

 

}

{{out}}

<pre>

+ Ternary.multiply: OK, passed 100 tests.

</pre>

=={{header|Tcl}}==

This directly uses the printable representation of the balanced ternary numbers, as Tcl's string operations are reasonably efficient.

 

proc bt-int b {

- { return [bt-sub $sub $b] }

}

Demonstration code:

puts "'+-+'+'+--' = [bt-add +-+ +--] = [bt-int [bt-add +-+ +--]]"

puts "'++'*'++' = [bt-mul ++ ++] = [bt-int [bt-mul ++ ++]]"

puts "a = [bt-int $a], b = [bt-int $b], c = [bt-int $c]"

set abc [bt-mul $a [bt-sub $b $c]]

Output:

<pre>

a = 523, b = -436, c = 65

a*(b-c) = ----0+--0++0 (== -262023)

</pre>