Balanced ternary: Difference between revisions

'''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.

<br><br>

 

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

To demonstrate the possibility, the ''integerFromBT'' and ''negateBT'' handlers here work by being tricksy with the characters' Unicode numbers. It's a more efficient way to deal with the characters. But I'm not sure how this'll be taken ''vis-à-vis'' not converting to native integers first, so the remaining handlers use a strictly if-then string comparison approach. Applescript's quite happy to convert automatically between integers, reals, numeric strings, and single-item lists containing numbers, so ''BTFromInteger'' accepts any of these forms, but the numbers represented must be whole-number values and must be small enough not to error AppleScript's ''as integer'' coercion. This coercion is error free for numbers in the range -(2 ^ 31) to 2 ^ 31 - 1, although actual integer class objects can only represent numbers in the range -(2 ^ 29) to 2 ^ 29 - 1. ''IntegerFromBT'' doesn't currently impose any integer-class size limit on its output.

 

on BTFromInteger(n)

try

set line4 to "a * (b - c) = " & it & " or " & my integerFromBT(it)

 

 

{{output}}

b = -436

c = 65

 

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

65 : +-++-

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

 

=={{header|C}}==

{{trans|Perl}}

#include <string.h>

 

 

return 0;

{{out}}

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

 

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

using System.Text;

using System.Collections.Generic;

return result;

}

output:

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

 

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

#include <string>

#include <climits>

return 0;

}

 

Output

 

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

 

{{trans|Python}}

 

digits::Vector{Int8}

end

println("a * (b - c): $(Int(r)), $r")

 

 

{{out}}

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

 

=={{header|Kotlin}}==

This is based on the Java entry. However, I've added 'BigInteger' support as this is a current requirement of the task description even though it's not actually needed to process the test case:

 

import java.math.BigInteger

val iResult = bResult.toBigInteger()

println("a * (b - c) = $bResult = $iResult")

 

{{out}}

 

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

global tt$

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

wend

end function

 

{{out}}

=={{header|Lua}}==

{{trans|C}}

local d = { '0', '+', '-' }

local v = { 0, 1, -1 }

end

 

{{out}}

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

 

=={{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 /-/ x<0 80

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

ИП2 /-/ ПП 88 1 П3 БП 10

ИП3 x#0 86 ИП2 ПП 88 ИП4 С/П

 

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

 

=={{header|Nim}}==

 

type

 

func `*`*(a, b: BTernary): BTernary =

 

var start: BTernary

echo "a × (b - c):"

echo fmt"– in ternary: {x}"

 

{{out}}

 

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

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+".

=={{header|Python}}==

{{trans|Common Lisp}}

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

(formerly Perl 6)

{{Works with|rakudo|2017.01}}

has @.coeff;

 

say 'b == ', $b.Int;

say 'c == ', $c.Int;

{{out}}

<pre>a == 523

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

numeric digits 10000 /*be able to handle gihugic numbers. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

btAdd: procedure; parse arg x,y; rx= reverse(x); ry= reverse(y); carry= 0

/*──────────────────────────────────────────────────────────────────────────────────────*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

btNorm: _= strip(arg(1), 'L', 0); if _=='' then _=0; return _ /*normalize the number.*/

btSub: return btAdd( arg(1), btNeg( arg(2) ) ) /*subtract two BT args.*/

{{out|output|text=&nbsp; when using the default input:}}

<pre>

 

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

 

=={{header|Rust}}==

cmp::min,

convert::{TryFrom, TryInto},

}

}

 

Output

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

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

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

{{trans|C#}}

 

Module Module1

End Class

 

{{out}}

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

{{libheader|Wren-big}}

{{libheader|Wren-trait}}

 

class BTernary is Comparable {

var bResult = a * (b - c)

var iResult = bResult.toBigInt

 

{{out}}