Balanced ternary: Difference between revisions

{{trans|Python}}

 

I a >= 0

R a I/ b

=={{header|Ada}}==

Specifications (bt.ads):

 

package BT is

 

Implementation (bt.adb):

 

package body BT is

 

Test task requirements (testbt.adb):

with Ada.Integer_Text_Io; use Ada.Integer_Text_Io;

with BT; use BT;

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

 

{{output}}

b = -436

c = 65

 

=={{header|ATS}}==

(*

** This one is

 

=={{header|AutoHotkey}}==

k = 0

if abs(n)<2

return r

}</syntaxhighlight>

(

523

=={{header|C}}==

{{trans|Perl}}

#include <string.h>

 

 

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

using System.Text;

using System.Collections.Generic;

 

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

#include <string>

#include <climits>

 

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

=={{header|Elixir}}==

{{trans|Erlang}}

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

 

=={{header|Erlang}}==

-module(ternary).

-compile(export_all).

</syntaxhighlight>

'''Output'''

234> ternary:test().

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

{{trans|Common Lisp}}

{{works with|Factor|0.98}}

sequences assocs strings arrays

math math.functions math.order ;

"a*(b-c)" d bt>integer d bt>string "%s: %d, %s\n" printf

]</syntaxhighlight>

b: -436, -++-0--

c: 65, +-++-

=={{header|FreeBASIC}}==

{{trans|Liberty BASIC}}

#define MAX(a, b) iif((a) > (b), (a), (b))

Dim Shared As Integer pow, signo

</pre>

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

USES

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

 

=={{header|Go}}==

 

import (

=={{header|Groovy}}==

Solution:

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

 

 

Test:

BalancedTernaryInteger b = new BalancedTernaryInteger(-436)

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

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

 

Works in both languages:

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

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

Implementation:

 

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

nOfTrin=: p.&3 :. trinOfN

Definitions for example:

 

b=: trinOfN -436

c=: trinOfStr '+-++-'</syntaxhighlight>

Required example:

 

523 _436 65

 

 

=={{header|Java}}==

/*

* Test case

{{trans|Python}}

 

digits::Vector{Int8}

end

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

 

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

global tt$

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

=={{header|Lua}}==

{{trans|C}}

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

local v = { 0, 1, -1 }

 

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

3] &;

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

"0", #0[#1, StringDrop[#2, -1]] <> "0"]] &;</syntaxhighlight>

Examples:

b = tobt@-436

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

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

{{trans|Glagol}}

ИП0 /-/ x<0 80

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

 

=={{header|Nim}}==

import tables

 

 

=={{header|OCaml}}==

type btern = btdigit list

 

 

=={{header|Perl}}==

use warnings;

 

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.

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

<span style="color: #008080;">function</span> <span style="color: #000000;">bt2dec</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">bt</span><span style="color: #0000FF;">)</span>

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!

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

<span style="color: #004080;">atom</span> <span style="color: #000000;">t0</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()</span>

 

=={{header|PicoLisp}}==

 

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

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

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

The same predicate is used for addition and substraction.

bt_add1/3,

op(900, xfx, btplus),

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

=={{header|Python}}==

{{trans|Common Lisp}}

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

 

 

=={{header|Racket}}==

 

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

(formerly Perl 6)

{{Works with|rakudo|2017.01}}

has @.coeff;

 

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

Ao = '+-0++0+' ; Abt = Ao /* [↓] 2 literals used by subroutine*/

 

=={{header|Ruby}}==

include Comparable

def initialize(str = "")

 

=={{header|Rust}}==

cmp::min,

convert::{TryFrom, TryInto},

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

 

Then these classes can be used in the following way:

object Main {

 

 

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

object TernarySpecification extends Properties("Ternary") {

 

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

}</syntaxhighlight>

Demonstration code:

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

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

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

{{trans|C#}}

 

Module Module1

{{libheader|Wren-big}}

{{libheader|Wren-trait}}

import "/trait" for Comparable