Balanced ternary: Difference between revisions

Line 29:

<~~lang~~ 11l>F py_idiv(a, b)

<syntaxhighlight lang=11l>F py_idiv(a, b)

I a >= 0

R a I/ b

Line 119:

V r = a * (b - c)

print(‘a * (b - c): ’r.to_int()‘ ’r)</~~lang~~>

print(‘a * (b - c): ’r.to_int()‘ ’r)</syntaxhighlight>

Line 131:

=={{header|Ada}}==

Specifications (bt.ads):

<~~lang~~ Ada>with Ada.Finalization;

<syntaxhighlight lang=Ada>with Ada.Finalization;

package BT is

Line 177:

procedure Finalize (Object : in out Balanced_Ternary);

end BT;</~~lang~~>

end BT;</syntaxhighlight>

Implementation (bt.adb):

<~~lang~~ Ada>with Ada.Unchecked_Deallocation;

<syntaxhighlight lang=Ada>with Ada.Unchecked_Deallocation;

package body BT is

Line 360:

end Initialize;

end BT;</~~lang~~>

end BT;</syntaxhighlight>

Test task requirements (testbt.adb):

<~~lang~~ Ada>with Ada.Text_Io; use Ada.Text_Io;

<syntaxhighlight lang=Ada>with Ada.Text_Io; use Ada.Text_Io;

with Ada.Integer_Text_Io; use Ada.Integer_Text_Io;

with BT; use BT;

Line 381:

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

Put_Line (" " & To_String(Result));

end TestBT;</~~lang~~>

end TestBT;</syntaxhighlight>

Output:

<pre>

Line 399:

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.

<~~lang~~ applescript>-- Build a balanced ternary, as text, from an integer value or acceptable AppleScript substitute.

<syntaxhighlight lang=applescript>-- Build a balanced ternary, as text, from an integer value or acceptable AppleScript substitute.

on BTFromInteger(n)

try

Line 566:

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

return line1 & linefeed & line2 & linefeed & line3 & linefeed & line4</~~lang~~>

return line1 & linefeed & line2 & linefeed & line3 & linefeed & line4</syntaxhighlight>

<~~lang~~ applescript>"a = 523

<syntaxhighlight lang=applescript>"a = 523

b = -436

c = 65

a * (b - c) = ----0+--0++0 or -262023"</~~lang~~>

a * (b - c) = ----0+--0++0 or -262023"</syntaxhighlight>

=={{header|ATS}}==

<~~lang~~ ATS>

(*

** This one is

Line 789:

//

} (* end of [main0] *)

</syntaxhighlight>

</lang>

Output:

<pre>

Line 799:

=={{header|AutoHotkey}}==

<~~lang~~ AutoHotkey>BalancedTernary(n){

<syntaxhighlight lang=AutoHotkey>BalancedTernary(n){

k = 0

if abs(n)<2

Line 820:

}

return r

}</~~lang~~>

}</syntaxhighlight>

Examples:<~~lang~~ AutoHotkey>data =

Examples:<syntaxhighlight lang=AutoHotkey>data =

(

523

Line 831:

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

MsgBox % result

return</~~lang~~>

return</syntaxhighlight>

Outputs:<pre>

523 : +-0++0+

Line 840:

=={{header|C}}==

<~~lang~~ c>#include <stdio.h>

<syntaxhighlight lang=c>#include <stdio.h>

#include <string.h>

Line 1,041:

return 0;

}</~~lang~~>

}</syntaxhighlight>

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

Line 1,049:

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

<~~lang~~ csharp>using System;

<syntaxhighlight lang=csharp>using System;

using System.Text;

using System.Collections.Generic;

Line 1,279:

return result;

}

}</~~lang~~>

}</syntaxhighlight>

output:

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

Line 1,287:

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

<~~lang~~ cpp>#include <iostream>

<syntaxhighlight lang=cpp>#include <iostream>

#include <string>

#include <climits>

Line 1,499:

return 0;

}

</syntaxhighlight>

</lang>

Output

Line 1,511:

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

<~~lang~~ lisp>;;; balanced ternary

<syntaxhighlight lang=lisp>;;; balanced ternary

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

Line 1,603:

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

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

(bt-integer d) (bt-string d)))</~~lang~~>output<lang>a 523 +-0++0+

(bt-integer d) (bt-string d)))</syntaxhighlight>output<syntaxhighlight lang=text>a 523 +-0++0+

b -436 -++-0--

c 65 +-++-

a × (b − c) = -262023 ----0+--0++0</~~lang~~>

a × (b − c) = -262023 ----0+--0++0</syntaxhighlight>

=={{header|D}}==

<~~lang~~ d>import std.stdio, std.bigint, std.range, std.algorithm;

<syntaxhighlight lang=d>import std.stdio, std.bigint, std.range, std.algorithm;

struct BalancedTernary {

Line 1,753:

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

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

}</~~lang~~>

}</syntaxhighlight>

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

Line 1,762:

=={{header|Elixir}}==

<~~lang~~ elixir>defmodule Ternary do

<syntaxhighlight lang=elixir>defmodule Ternary do

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

Line 1,835:

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

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

IO.puts "a x (b - c) = #{rs} -> #{r}"</~~lang~~>

IO.puts "a x (b - c) = #{rs} -> #{r}"</syntaxhighlight>

Line 1,846:

=={{header|Erlang}}==

<~~lang~~ erlang>

-module(ternary).

-compile(export_all).

Line 1,936:

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

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

</syntaxhighlight>

</lang>

'''Output'''

<~~lang~~ erlang>

234> ternary:test().

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

Line 1,945:

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

ok

</syntaxhighlight>

</lang>

Line 1,953:

<~~lang~~ factor>USING: kernel combinators locals formatting lint literals

<syntaxhighlight lang=factor>USING: kernel combinators locals formatting lint literals

sequences assocs strings arrays

math math.functions math.order ;

Line 2,015:

"c" c bt>integer c bt>string "%s: %d, %s\n" printf

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

]</~~lang~~>

]</syntaxhighlight>

<lang>a: 523, +-0++0+

<syntaxhighlight lang=text>a: 523, +-0++0+

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

c: 65, +-++-

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

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

=={{header|FreeBASIC}}==

<~~lang~~ freebasic>

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

Dim Shared As Integer pow, signo

Line 2,151:

Print "a*(b-c): ", a * (b - c)

Sleep

</syntaxhighlight>

</lang>

<pre>

Line 2,280:

</pre>

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

<~~lang~~ algol68>PROGRAM Setun+;

<syntaxhighlight lang=algol68>PROGRAM Setun+;

USES

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

Line 2,392:

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

Remove.Memory

END Setun.</~~lang~~>

END Setun.</syntaxhighlight>

=={{header|Go}}==

<~~lang~~ go>package main

<syntaxhighlight lang=go>package main

import (

Line 2,618:

fmt.Println("int overflow")

}

}</~~lang~~>

}</syntaxhighlight>

<pre>

Line 2,629:

=={{header|Groovy}}==

Solution:

<~~lang~~ groovy>enum T {

<syntaxhighlight lang=groovy>enum T {

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

Line 2,788:

String toString() { value }

}</~~lang~~>

}</syntaxhighlight>

Test:

<~~lang~~ groovy>BalancedTernaryInteger a = new BalancedTernaryInteger('+-0++0+')

<syntaxhighlight lang=groovy>BalancedTernaryInteger a = new BalancedTernaryInteger('+-0++0+')

BalancedTernaryInteger b = new BalancedTernaryInteger(-436)

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

Line 2,806:

println "\nDemonstrate failure:"

assert (a * (b-c)) == a</~~lang~~>

assert (a * (b-c)) == a</syntaxhighlight>

Output:

Line 2,831:

=={{header|Haskell}}==

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

<~~lang~~ haskell>data BalancedTernary = Bt [Int]

<syntaxhighlight lang=haskell>data BalancedTernary = Bt [Int]

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

Line 2,888:

print $ map btInt [a,b,c]

print $ r

print $ btInt r</~~lang~~>

print $ btInt r</syntaxhighlight>

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

Line 2,895:

Works in both languages:

<~~lang~~ unicon>procedure main()

<syntaxhighlight lang=unicon>procedure main()

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

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

Line 2,984:

}

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

end</~~lang~~>

end</syntaxhighlight>

Output:

Line 3,000:

Implementation:

<~~lang~~ j>trigits=: 1+3 <.@^. 2 * 1&>.@|

<syntaxhighlight lang=j>trigits=: 1+3 <.@^. 2 * 1&>.@|

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

nOfTrin=: p.&3 :. trinOfN

Line 3,011:

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

neg=: -

mul=: trimLead0@carry@(+//.@(*/))</~~lang~~>

mul=: trimLead0@carry@(+//.@(*/))</syntaxhighlight>

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

Line 3,029:

Definitions for example:

<~~lang~~ j>a=: trinOfStr '+-0++0+'

<syntaxhighlight lang=j>a=: trinOfStr '+-0++0+'

b=: trinOfN -436

c=: trinOfStr '+-++-'</~~lang~~>

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

Required example:

<~~lang~~ j> nOfTrin&> a;b;c

<syntaxhighlight lang=j> nOfTrin&> a;b;c

523 _436 65

Line 3,041:

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

nOfTrin a mul b (add -) c

_262023</~~lang~~>

_262023</syntaxhighlight>

=={{header|Java}}==

<~~lang~~ java>

/*

* Test case

Line 3,256:

}

</syntaxhighlight>

</lang>

Output:

Line 3,271:

<~~lang~~ julia>struct BalancedTernary <: Signed

<syntaxhighlight lang=julia>struct BalancedTernary <: Signed

digits::Vector{Int8}

end

Line 3,355:

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

@assert Int(r) == Int(a) * (Int(b) - Int(c))</~~lang~~>

@assert Int(r) == Int(a) * (Int(b) - Int(c))</syntaxhighlight>

Line 3,365:

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

<~~lang~~ scala>// version 1.1.3

<syntaxhighlight lang=scala>// version 1.1.3

import java.math.BigInteger

Line 3,508:

val iResult = bResult.toBigInteger()

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

}</~~lang~~>

}</syntaxhighlight>

Line 3,519:

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

global tt$

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

Line 3,657:

wend

end function

</syntaxhighlight>

</lang>

Line 3,672:

=={{header|Lua}}==

<~~lang~~ lua>function to_bt(n)

<syntaxhighlight lang=lua>function to_bt(n)

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

local v = { 0, 1, -1 }

Line 3,817:

end

main()</~~lang~~>

main()</syntaxhighlight>

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

Line 3,825:

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

<~~lang~~ mathematica>frombt = FromDigits[StringCases[#, {"+" -> 1, "-" -> -1, "0" -> 0}],

<syntaxhighlight lang=mathematica>frombt = FromDigits[StringCases[#, {"+" -> 1, "-" -> -1, "0" -> 0}],

3] &;

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

Line 3,846:

btnegate@#1],

If[StringLength@#2 == 1,

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

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

Examples:

<~~lang~~ mathematica>frombt[a = "+-0++0+"]

<syntaxhighlight lang=mathematica>frombt[a = "+-0++0+"]

b = tobt@-436

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

btmultiply[a, btsubtract[b, c]]</~~lang~~>

btmultiply[a, btsubtract[b, c]]</syntaxhighlight>

Outputs:

<pre>523

Line 3,863:

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

<~~lang~~ mk-61>ЗН П2 Вx |x| П0 0 П3 П4 1 П5

<syntaxhighlight lang=mk-61>ЗН П2 Вx |x| П0 0 П3 П4 1 П5

ИП0 /-/ x<0 80

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

Line 3,874:

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

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

8 + ИП5 * ИП4 + П4 ИП5 1 0 * П5 В/О</~~lang~~>

8 + ИП5 * ИП4 + П4 ИП5 1 0 * П5 В/О</syntaxhighlight>

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

=={{header|Nim}}==

<~~lang~~ Nim>import strformat

<syntaxhighlight lang=Nim>import strformat

import tables

Line 4,056:

echo "a × (b - c):"

echo fmt"– in ternary: {x}"

echo fmt"– in decimal: {x.toInt}"</~~lang~~>

echo fmt"– in decimal: {x.toInt}"</syntaxhighlight>

Line 4,074:

=={{header|OCaml}}==

<~~lang~~ ocaml>type btdigit = Pos | Zero | Neg

<syntaxhighlight lang=ocaml>type btdigit = Pos | Zero | Neg

type btern = btdigit list

Line 4,125:

let _ =

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

(to_int a) (to_int b) (to_int c) (to_string d) (to_int d);</~~lang~~>

(to_int a) (to_int b) (to_int c) (to_string d) (to_int d);</syntaxhighlight>

Output:

<pre>a = 523

Line 4,133:

=={{header|Perl}}==

<~~lang~~ perl>use strict;

<syntaxhighlight lang=perl>use strict;

use warnings;

Line 4,207:

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

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

</syntaxhighlight>

</lang>

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

Line 4,218:

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.

with javascript_semantics

function bt2dec(string bt)

Line 4,311:

printf(1,"%7s: %12s %9d\n",{"c",c,bt2dec(c)})

printf(1,"%7s: %12s %9d\n",{"a*(b-c)",res,bt2dec(res)})

<pre>

Line 4,323:

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!

with javascript_semantics

atom t0 = time()

Line 4,341:

end while

printf(1,"It took %d subtractions to reach 0. (%3.2fs)\n",{count,time()-t0})

<pre>

Line 4,349:

=={{header|PicoLisp}}==

<~~lang~~ PicoLisp>(seed (in "/dev/urandom" (rd 8)))

<syntaxhighlight lang=PicoLisp>(seed (in "/dev/urandom" (rd 8)))

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

Line 4,470:

(println 'R (trih R) R) )

(bye)</~~lang~~>

(bye)</syntaxhighlight>

=={{header|Prolog}}==

Line 4,477:

'''The conversion.'''

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

<~~lang~~ Prolog>:- module('bt_convert.pl', [bt_convert/2,

<syntaxhighlight lang=Prolog>:- module('bt_convert.pl', [bt_convert/2,

op(950, xfx, btconv),

btconv/2]).

Line 4,544:

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

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

</~~lang~~>

</syntaxhighlight>

'''The addition.'''

The same predicate is used for addition and substraction.

<~~lang~~ Prolog>:- module('bt_add.pl', [bt_add/3,

<syntaxhighlight lang=Prolog>:- module('bt_add.pl', [bt_add/3,

bt_add1/3,

op(900, xfx, btplus),

Line 4,670:

strip_nombre(L) -->

L.

</syntaxhighlight>

</lang>

'''The multiplication.'''

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

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

<~~lang~~ Prolog>:- module('bt_mult.pl', [op(850, xfx, btmult),

<syntaxhighlight lang=Prolog>:- module('bt_mult.pl', [op(850, xfx, btmult),

btmult/2,

multiplication/3

Line 4,845:

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

</syntaxhighlight>

</lang>

Example of output :

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

Line 4,864:

=={{header|Python}}==

<~~lang~~ python>class BalancedTernary:

<syntaxhighlight lang=python>class BalancedTernary:

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

Line 4,958:

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

main()</~~lang~~>

main()</syntaxhighlight>

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

Line 4,966:

=={{header|Racket}}==

<~~lang~~ racket>#lang racket

<syntaxhighlight lang=racket>#lang racket

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

Line 5,041:

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

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

</syntaxhighlight>

</lang>

Line 5,054:

(formerly Perl 6)

<lang ~~perl6~~>class BT {

<syntaxhighlight lang=raku lines>class BT {

has @.coeff;

Line 5,116:

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

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

say "a × (b − c) == ", ~$x, ' == ', $x.Int;</~~lang~~>

say "a × (b − c) == ", ~$x, ' == ', $x.Int;</syntaxhighlight>

<pre>a == 523

Line 5,125:

=={{header|REXX}}==

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

<~~lang~~ rexx>/*REXX program converts decimal ◄───► balanced ternary; it also performs arithmetic. */

<syntaxhighlight lang=rexx>/*REXX program converts decimal ◄───► balanced ternary; it also performs arithmetic. */

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

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

Line 5,175:

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

btShow: say center( arg(1), 9) right( arg(2), 20) @@ right( bt2d(arg(2)), 9) @; return</~~lang~~>

btShow: say center( arg(1), 9) right( arg(2), 20) @@ right( bt2d(arg(2)), 9) @; return</syntaxhighlight>

<pre>

Line 5,186:

=={{header|Ruby}}==

<~~lang~~ ruby>class BalancedTernary

<syntaxhighlight lang=ruby>class BalancedTernary

include Comparable

def initialize(str = "")

Line 5,308:

val = eval(exp)

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

end</~~lang~~>

end</syntaxhighlight>

Line 5,319:

=={{header|Rust}}==

<~~lang~~ rust>use std::{

<syntaxhighlight lang=rust>use std::{

cmp::min,

convert::{TryFrom, TryInto},

Line 5,576:

}

</syntaxhighlight>

</lang>

Output

Line 5,588:

=={{header|Scala}}==

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

<~~lang~~ scala>

object TernaryBit {

val P = TernaryBit(+1)

Line 5,675:

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

}

</syntaxhighlight>

</lang>

Then these classes can be used in the following way:

<~~lang~~ scala>

object Main {

Line 5,693:

}

</syntaxhighlight>

</lang>

<pre>

Line 5,703:

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

<~~lang~~ scala>

object TernarySpecification extends Properties("Ternary") {

Line 5,719:

}

</syntaxhighlight>

</lang>

<pre>

Line 5,729:

=={{header|Tcl}}==

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

<~~lang~~ tcl>package require Tcl 8.5

<syntaxhighlight lang=tcl>package require Tcl 8.5

proc bt-int b {

Line 5,785:

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

}

}</~~lang~~>

}</syntaxhighlight>

Demonstration code:

<~~lang~~ tcl>for {set i 0} {$i<=10} {incr i} {puts "$i = [int-bt $i]"}

<syntaxhighlight lang=tcl>for {set i 0} {$i<=10} {incr i} {puts "$i = [int-bt $i]"}

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

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

Line 5,796:

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

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

puts "a*(b-c) = $abc (== [bt-int $abc])"</~~lang~~>

puts "a*(b-c) = $abc (== [bt-int $abc])"</syntaxhighlight>

Output:

<pre>

Line 5,818:

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

<~~lang~~ vbnet>Imports System.Text

<syntaxhighlight lang=vbnet>Imports System.Text

Module Module1

Line 6,005:

End Class

End Module</~~lang~~>

End Module</syntaxhighlight>

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

Line 6,016:

<~~lang~~ ecmascript>import "/big" for BigInt

<syntaxhighlight lang=ecmascript>import "/big" for BigInt

import "/trait" for Comparable

Line 6,140:

var bResult = a * (b - c)

var iResult = bResult.toBigInt

System.print("a * (b - c) = %(bResult) = %(iResult)")</~~lang~~>

System.print("a * (b - c) = %(bResult) = %(iResult)")</syntaxhighlight>