Long multiplication: Difference between revisions

{{trans|Python}}

 

L

L result.len < addendpos + 1

 

V sixtyfour = ‘18446744073709551616’

 

{{out}}

=={{header|360 Assembly}}==

For maximum compatibility, we use only the basic 370 instruction set (use of MVCL). Pseudo-macro instruction XPRNT can be replaced by a WTO.

USING LONGINT,R13

SAVEAREA B PROLOG-SAVEAREA(R15)

LL EQU 94

YREGS

{{out}}

<pre>

18446744073709551616

340282366920938463463374607431768211456

</pre>

 

 

First we specify the required operations and declare our number type as an array of digits (in base 2^16):

type Number (<>) is private;

 

Result : out Number;

Remainder : out Digit);

Some of the operations declared above are useful helper operations for the conversion of numbers to and from base 10 digit strings.

 

Then we implement the operations:

function Value (Item : in String) return Number is

subtype Base_Ten_Digit is Digit range 0 .. 9;

return Zero;

end Trim;

 

And finally we have the requested test application:

with Long_Multiplication;

 

begin

Put_Line (Image (N) & " * " & Image (N) & " = " & Image (M));

 

{{out}}

 

The following implementation uses representation of a long number by an array of 32-bit elements:

 

function "*" (Left, Right : Long_Number) return Long_Number is

end loop;

return (0 => 0);

 

The task requires conversion into decimal base. For this we also need division to short number with a remainder. Here it is:

( Dividend : in out Long_Number;

Last : in out Natural;

Remainder := Unsigned_32 (Accum);

Last := Size;

 

With the above the test program:

with Ada.Text_IO; use Ada.Text_IO;

with Interfaces; use Interfaces;

begin

Put (X);

 

Sample output:

 

=={{header|Aime}}==

integer d, e, i, j, s;

 

}

 

 

=={{header|ALGOL 68}}==

[[ALGOL 68G]] allows any precision for '''long long int''' to be defined

when the program is run, e.g. 200 digits.

MODE INTEGER = LONG LONG INT;

 

INTEGER neg two to the power of 64 = -(LONG 2 ** 64);

print(("2 ** 64 * -(2 ** 64) = ", whole(two to the power of 64*neg two to the power of 64,width), new line))

Output:

<pre>

{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386}}

<!-- {{does not works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386 - translator throws and assert. I'm not sure why.}} -->

MODE INTEGER = FLEX[0]DIGIT; # an arbitary number of digits #

 

# finally return the semi-normalised result #

IF leading zeros = UPB out THEN "0" ELSE sign + out[leading zeros+1:] FI

 

# Finally Define the required INTEGER multiplication OPerator. #

################################################################

OD;

NORMALISE ab

 

OP - = (INTEGER a)INTEGER: raise integer not implemented error("monadic minus"),

ABS = (INTEGER a)INTEGER: raise integer not implemented error("ABS"),

INTEGER neg two to the power of 64 = INTEGERINIT(-(LONG 2 ** 64));

print(("2 ** 64 * -(2 ** 64) = ", REPR (two to the power of 64 * neg two to the power of 64), new line))

 

Output:

 

=={{header|ALGOL W}}==

% long multiplication of large integers %

% large integers are represented by arrays of integers whose absolute %

writeonLargeInteger( twoTo128, ELEMENT_COUNT )

end

{{out}}

<pre>

2^128: 340282366920938463463374607431768211456

</pre>

 

=={{header|AutoHotkey}}==

ahk [http://www.autohotkey.com/forum/viewtopic.php?t=44657&postdays=0&postorder=asc&start=149 discussion]

MsgBox % x := mul(x,x)

MsgBox % x := mul(x,x) ; 18446744073709551616

}

Return cy ? a : SubStr(a,2)

 

=={{header|AWK}}==

{{works with|nawk|20100523}}

{{trans|Tcl}}

DEBUG = 0

n = 2^64

print "===="

}

outputs:

<pre>2^64 * 2^64 = 340282366920938463463374607431768211456

 

===Version 1===

'LRCVS 01.01.2010

'THIS PROGRAM SIMPLY MAKES A MULTIPLICATION

CLS

PRINT "THE SOLUTION IN THE FILE: R"

 

===Version 2===

<!-- I'm not sure what the difference is; don't feel like reading through them, I was just making sure they work and bughunting. -->

'LRCVS 01/01/2010

'THIS PROGRAM SIMPLY MAKES A BIG MULTIPLICATION

NEXT N

PRINT "END"

 

==={{header|Applesoft BASIC}}===

110 B$ = A$

120 GOSUB 400

680 NEXT J

700 IF E THEN V = VAL ( MID$ (D$,E,1)) + C:C = V > 9:V = V - 10 * C:E$ = STR$ (V) + E$:E = E - 1: GOTO 700

 

=={{header|Batch File}}==

Based on the JavaScript iterative code.

::Batch File Implementation

 

for /l %%F in (0,1,%length%) do set "prod=!digit%%F!!prod!"

endlocal & set "%3=%prod%"

{{Out}}

<pre>340282366920938463463374607431768211456</pre>

{{works with|BBC BASIC for Windows}}

Library method:

MAPM_DllPath$ = @lib$+"BB4WMAPM.DLL"

PROCMAPM_Init

twoto64$ = "18446744073709551616"

Explicit method:

PRINT "2^64 * 2^64 = " ; FNlongmult(twoto64$, twoto64$)

END

num3&(S%) = 0

IF num3&(0) = &30 THEN = $$^num3&(1)

 

=={{header|C}}==

Doing it as if by hand.

#include <string.h>

 

 

return 0;

 

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

{{works with|C sharp|C#|4+}}If you strip out the ''BigInteger'' checking, it will work with lesser versions.<br/><br/>This uses the '''decimal''' type, (which has a '''MaxValue''' of 79,228,162,514,264,337,593,543,950,335). By limiting it to '''10^28''', it allows 28 decimal digits for the ''hi'' part, and 28 decimal digits for the ''lo'' part, '''56 decimal digits''' total. A side computation of ''BigInteger'' assures that the results are accurate.

using static System.Console;

using BI = System.Numerics.BigInteger;

BS.ToString() == toStr(y) ? "does" : "fails to"); } }

 

{{out}}

<pre>The square of (2^64): 18,446,744,073,709,551,616

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

===Version 1===

#include <iostream>

#include <sstream>

}

//--------------------------------------------------------------------------------------------------

{{out}}

<pre>340282366920938463463374607431768211456

 

===Version 2===

#include <iostream>

#include <vector>

}

return 0;

 

<pre>

 

=={{header|Ceylon}}==

 

shared void run() {

print("The actual result is ``result``");

print("Do they match? ``expectedResult == result then "Yes!" else "No!"``");

 

=={{header|COBOL}}==

identification division.

program-id. long-mul.

 

end program long-mul.

 

<pre>

 

=={{header|CoffeeScript}}==

# This very limited BCD-based collection of functions

# allows for long multiplication. It works for positive

square = BcdInteger.product x, x

console.log BcdInteger.to_string square # 340282366920938463463374607431768211456

 

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

(do ((digits '())) ((zerop number) digits)

(multiple-value-bind (quotient remainder) (floor number 10)

(let* ((bi (pop b))

(row (mapcar #'(lambda (ai) (* ai bi)) a)))

 

> (long-multiply (expt 2 64) (expt 2 64))

=={{header|Crystal}}==

 

 

a = 2.to_big_i ** 64

 

puts "#{a} * #{a} = #{a*a}"

{{out}}

<pre>

=={{header|D}}==

Using the standard library:

import std.stdio, std.bigint;

 

writeln(2.BigInt ^^ 64 * 2.BigInt ^^ 64);

{{out}}

<pre>340282366920938463463374607431768211456</pre>

Long multiplication, same output:

{{trans|JavaScript}}

 

auto longMult(in string x1, in string x2) pure nothrow @safe {

immutable two64 = "18446744073709551616";

longMult(two64, two64).writeln;

 

=={{header|Dc}}==

{{incorrect|Dc|Code does not explicitly implement long multiplication}}

Since Dc has arbitrary precision built-in, the task is no different than a normal multiplication:

{{incorrect|Dc|A Dc solution might be: Represent bignums as numerical strings and implement arithmetic functions on them.}}

 

=={{header|EchoLisp}}==

We implement long multiplication by multiplying polynomials, knowing that the number 1234 is the polynomial x^3 +2x^2 +3x +4 at x=10. As we assume no bigint library is present, long-mul operates on strings.

(lib 'math) ;; for poly multiplication

 

 

 

 

=={{header|Euphoria}}==

 

function atom_to_long(atom a)

 

c = long_mult(b,b)

 

Output:

{{incorrect|F#|The problem is to implement long multiplication, not to demonstrate bignum support.}}

 

 

val X : System.Numerics.BigInteger = 340282366920938463463374607431768211456

 

=={{header|Factor}}==

 

: longmult-seq ( xs ys -- zs )

: digits->integer ( xs -- x ) 0 [ swap 10 * + ] reduce ;

 

340282366920938463463374607431768211456

( scratchpad ) 2 64 ^ dup * .

 

=={{header|Fortran}}==

{{works with|Fortran|95 and later}}

implicit none

 

end subroutine longmolt_print

 

 

use LongMoltiplication

 

write(*,*)

 

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>2 ^ 2 = 4

 

=={{header|Go}}==

// That is, multiplicand is multiplied by single digits of multiplier

// to form intermediate results. Intermediate results are accumulated

func main() {

fmt.Println(mul(n, n))

Output:

<pre>

 

=={{header|Haskell}}==

import Data.Char (digitToInt)

 

 

main :: IO ()

{{out}}

<pre>340282366920938463463374607431768211456</pre>

 

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

Large integers are native to Icon and Unicon. Neither libraries nor special programming is required.

write(2^64*2^64)

{{output}}<pre>340282366920938463463374607431768211456</pre>

 

=={{header|J}}==

'''Solution:'''

polymult =: +//.@(*/)

buildDecimal=: 10x&#.

 

'''Example:'''

 

'''Alternatives:'''<br>

<code>longmult</code> could have been defined concisely:

Or, of course, the task may be accomplished without the verb definitions:

Or using the code <code>(+ 10x&*)/@|.</code> instead of <code>#.</code>:

Or you could use the built-in language support for arbitrary precision multiplication:

 

'''Explaining the component verbs:'''

* <code>digits</code> translates a number to a corresponding list of digits;

* <code>polymult</code> (multiplies polynomials): '''ref.''' [http://www.jsoftware.com/help/dictionary/samp23.htm]

* <code>buildDecimal</code> (translates a list of decimal digits - possibly including "carry" - to the corresponding extended precision number):

 

=={{header|Java}}==

This version of the code keeps the data in base ten. By doing this, we can avoid converting the whole number to binary and we can keep things simple, but the runtime will be suboptimal.

 

 

private static byte[] stringToDigits(String num) {

}

}

 

===Binary version===

This version tries to be as efficient as possible, so it converts numbers into binary before doing any calculations. The complexity is higher because of the need to convert to and from base ten, which requires the implementation of some additional arithmetic operations beyond long multiplication itself.

 

 

public class LongMultBinary {

 

}

 

=={{header|JavaScript}}==

This means that to handle larger inputs, the multiplication function needs to have string parameters:

 

 

var a1 = strNum1.split("").reverse();

 

 

 

{{Out}}

For the same reason, the output always takes the form of an arbitrary precision integer string, rather than a native integer data type. (See the '''largeIntegerString()''' helper function below)

 

'use strict';

 

)

};

{{Out}}

<pre>{"fromIntegerStrings":"340282366920938463463374607431768211456",

{{Works with|jq|1.4}}

Since the task description mentions 2^64, the following includes "long_power(i)" for computing n^i.

def long_multiply(num1; num2):

 

elif $a2[1] == "1" then $a1[1]|adjustsign( $a1[0] * $a2[0] )

else mult($a1[1]; $a2[1]) | adjustsign( $a1[0] * $a2[0] )

# represented as numbers and/or strings.

def long_power(i):

| ($i - $j*$j) as $k

| long_multiply( power($j) | power($j) ; power($k) )

'''Example''':

{{Out}}

$ jq -n -f Long_multiplication.jq

 

'''Module''':

 

using Compat

end

 

 

'''Main''':

 

{{out}}

=={{header|Kotlin}}==

{{trans|Java}}

if (!c.isDigit())

throw IllegalArgumentException("Invalid digit $c found at position $i")

fun main(args: Array<out String>) {

println("18446744073709551616" * "18446744073709551616")

 

=={{header|Lambdatalk}}==

 

Natural positive numbers are defined as strings, for instance 123 -> "123".

{lambda talk} has a small set of primitives working on strings, [equal?, empty?, chars, charAt, substring]

 

This can be tested in http://lambdaway.free.fr/lambdaspeech/?view=numbers8

 

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

'[RC] long multiplication

 

 

 

=={{header|Lobster}}==

{{trans|Java}} Translation of Java binary version, but with base 1000000000

 

// Very basic arbitrary-precision integers

var pro = one.bign_multiply(two)

print(bign2str(pro))

{{out}}

<pre>

 

=={{header|Maple}}==

longmult := proc(a::integer,b::integer)

local A,B,m,n,i,j;

> longmult( 2^64, 2^64 );

340282366920938463463374607431768211456

 

We define the long multiplication function:

d1=IntegerDigits[a]//Reverse;

d2=IntegerDigits[b]//Reverse;

Sum[d1[[i]]d2[[j]]*10^(i+j-2),{i,1,Length[d1]},{j,1,Length[d2]}]

 

Example:

n2 = 2^64;

 

gives back:

 

To check the speed difference between built-in multiplication (which is already arbitrary precision) we multiply two big numbers (2^8000 has '''2409''' digits!) and divide their timings:

n2=2^8000;

Timing[LongMultiplication[n1,n2]][[1]]

Timing[n1 n2][[1]]

 

gives back:

7.*10^-6

 

So our custom function takes about 73 second, the built-in function a couple of millionths of a second, so the long multiplication is about 10.5 million times slower! Mathematica uses Karatsuba multiplication for large integers, which is several magnitudes faster for really big numbers. Making it able to multiply <math>3^{(10^7)}\times3^{(10^7)}</math> in about a second; the final result has 9542426 digits; result omitted for obvious reasons.

{{trans|REXX}}

A reworking of the example at Rexx Version 2.

options replace format comments java crossref symbols nobinary

 

 

return

{{out}}

<pre>

 

{{trans|C}}

 

 

proc longmulti(a, b: string): string =

var

k = false

 

return

 

 

for i in countdown(a.high, 0):

result[0..result.high-1] = result[1..result.high]

 

Output:

<pre>3402823669209384634633746074317682114566</pre>

Just multiplication is implemented here.

 

Natural method: initialize := v ;

| i |

@v last <<

 

{{out}}

Ol already supports long numbers "out-of-the-box".

 

(define x (* 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)) ; 2^64

 

(print (* x x))

<pre>

340282366920938463463374607431768211456

 

=={{header|PARI/GP}}==

a=eval(Vec(a));

b=eval(Vec(b));

"0"

};

Output:

<pre>%1 = "340282366920938463463374607431768211456"</pre>

=={{header|Pascal}}==

Extracted from a programme to calculate and factor the number (two versions) in Frederick Pohl's book ''The Gold at the Starbow's End'', and compute Godel encodings of text. Compiles with the Free Pascal Compiler. The original would compile with Turbo Pascal (and used pointers to allow access to the "heap" storage scheme) except that does not allow functions to return a "big number" data aggregate, and it is so much nicer to be able to write X:=BigMult(A,B); The original has a special "square" calculation but this task is to exhibit long multiplication. However, raising to a power by iteration is painful, so a special routine for that.

Program TwoUp; Uses DOS, crt;

{Concocted by R.N.McLean (whom God preserve), Victoria university, NZ.}

Write ('x*x = ');BigShow(X); {Can't have Write('x*x = ',BigShow(BigMult(X,X))), after all. Oh well.}

END.

 

Output:

 

=={{header|Perl}}==

use strict;

 

 

my $onetwentyeight = &longhand_multiplication($sixtyfour, $sixtyfour);

 

=={{header|Phix}}==

If bcd1 is a number split into digits 0..9, bcd9 is a number split into "digits" 000,000,000..999,999,999, which fit in an integer.<br>

They are held lsb-style mainly so that trimming a trailing 0 does not alter their value.

{{out}}

<pre>

 

=== string ===

{{out}}

<pre>

 

=== builtin ===

(same output as immediately above)

 

=={{header|PHP}}==

 

function longMult($a, $b)

{

}; // 2^64 * 2^64

 

 

=={{header|PicoLisp}}==

(de multi (A B)

(setq A (format A) B (reverse (chop B)))

(for (I . X) B

(setq Result (+ Result (* (format X) A (** 10 (dec I)))))) ) )

 

=={{header|PL/I}}==

multiply: procedure (a, b, c);

declare (a, b, c) (*) fixed decimal (1);

a(i) = s;

end;

Calling sequence:

a(60) = 1;

do i = 1 to 64; /* Generate 2**64 */

call multiply (a, b, c);

put skip;

Final output:

<pre>

 

=={{header|PL/M}}==

ELSE DO;

END;

C( CPOS ) = CDIGIT;

CPOS = CPOS + 1;

{{out}}

<pre>

=={{header|PowerShell}}==

===Implementation===

# LongAddition only supports Unsigned Integers represented as Strings/Character Arrays

Function LongAddition ( [Char[]] $lhs, [Char[]] $rhs )

}

 

===Library Method===

{{works with|PowerShell|4.0}}

[BigInt]$n = [Math]::Pow(2,64)

[BigInt]::Multiply($n,$n)

<b>Output:</b>

<pre>

=={{header|Prolog}}==

Arbitrary precision arithmetic is native in most Prolog implementations.

 

=={{header|PureBasic}}==

===Explicit Implementation===

Array Digit.b(0) ;contains each digit of number, right-most digit is index 0

digitCount.i ;zero based

Print(#crlf$ + #crlf$ + "Press ENTER to exit"): Input()

CloseConsole()

Output:

<pre>The result of 2^64 * 2^64 is 340282366920938463463374607431768211456</pre>

 

Using [http://www.purebasic.fr/english/viewtopic.php?p=309763#p309763 Decimal.pbi] by Stargåte allows for calculation with long numbers, this is useful since version 4.41 of PureBasic mostly only supporter data types native to x86/x64/PPC etc processors.

 

Define.Decimal *a, *b

*b=TimesDecimal(*a,*a,#NoDecimal)

 

 

'''Outputs

(Note that Python comes with arbitrary length integers).

 

 

{{works with|Python|3.0}}

{{trans|Perl}}

 

def add_with_carry(result, addend, addendpos):

 

onetwentyeight = longhand_multiplication(sixtyfour, sixtyfour)

 

Shorter version:

{{trans|Haskell}}

{{Works with|Python|3.7}}

 

from functools import reduce

print(

longmult(2 ** 64, 2 ** 64)

 

 

In addition to the specified task, we were always encouraged to show our workings.

 

[ char 0 -

swap join ] ] is $->long ( $ --> L )

[ reverse behead

swap witheach

 

[ reverse

witheach echo ] is echolong ( L --> )

 

 

[ [ table

[ dip add add dip [ add nip ] swap ] is addc ( n n c --> n c )

 

temp take

addc

iff join else drop ] is shortmult ( L n --> L )

 

[ 0 swap join ] ] is timesten ( L --> L )

 

timesten ]

drop ] is longmult ( L L --> L )

 

( ------------------------ additional to task ------------------------ )

[ linelength share

over size - times sp

 

[ over size

rot longadd swap

timesten ]

 

 

say "Using long multiplication: "

cr cr

say "(Show your workings.)" cr cr

 

{{out}}

===Using GMP===

{{libheader|gmp}}

a <- as.bigz("18446744073709551616")

"340282366920938463463374607431768211456"

===A native implementation===

This code is more verbose than necessary, for ease of understanding.

{

#get the number described in each string

 

a <- "18446744073709551616"

<pre>

"340282366920938463463374607431768211456"

 

=={{header|Racket}}==

#lang racket

 

;; 340282366920938463463374607431768211456

;; 340282366920938463463374607431768211456

 

=={{header|Raku}}==

{{works with|rakudo|2015-09-17}}

For efficiency (and novelty), this program explicitly implements long multiplication, but in base 10000. That base was chosen because multiplying two 5-digit numbers can overflow a 32-bit integer, but two 4-digit numbers cannot.

sub groups_to_num ( @g ) { [~] flat @g.pop, @g.reverse».fmt('%04d') };

 

 

# cross-check with native implementation

 

{{out}}

 

Programming note: &nbsp; <big>&&</big> &nbsp; is REXX's &nbsp; '''exclusive or''' &nbsp; operand.

numeric digits 300 /*be able to handle gihugeic input #s. */

parse arg x y . /*obtain optional arguments from the CL*/

if x<0 && y<0 then sign= '-' /*there only a single negative number? */

else sign= /*no, then result sign must be positive*/

numeric digits max(digits(), Lx + Ly) /*use a new decimal digits precision.*/

do j=Ly by -1 for Ly /*almost like REXX does it, ··· but no.*/

end /*j*/

if f<0 then $=copies(0, abs(f) + 1)$ /*Negative? Add leading 0s for INSERT.*/

say 'long mult:' xx "*" yy '──►' sign || strip( insert(., $, length($) - #), 'T', .)

<pre>

long mult: 18446744073709551616 * 18446744073709551616 ──► 340282366920938463463374607431768211456

built─in: 18446744073709551616 * 18446744073709551616 ──► 340282366920938463463374607431768211456

</pre>

<pre>

long mult: 123 * -456789000 ──► -56185047000

built─in: 123 * -456789000 ──► -56185047000

</pre>

<pre>

long mult: -123.678 * +456789000 ──► -56494749942.000

 

===version 2===

* While REXX can multiply arbitrary large integers

* here is the algorithm asked for by the task description

ol=ol||value(name'.z')

End

Output:

<pre>soll = 15129

=={{header|Ring}}==

{{Incorrect|Ring|Task is "Implement long multiplication" not "Multiply two numbers using native operators"}}

decimals(0)

see pow(2,64)*pow(2,64) + nl

Output:

<pre>

340282366920938463463374607431768211456

</pre>

 

=={{header|Ruby}}==

{{trans|Tcl}}

result = [0]

j = 0

n=2**64

printf " %d * %d = %d\n", n, n, n*n

<pre> 18446744073709551616 * 18446744073709551616 = 340282366920938463463374607431768211456

longmult(18446744073709551616, 18446744073709551616) = 340282366920938463463374607431768211456</pre>

 

=={{header|Scala}}==

are ever multiplied or added, and all partial results are kept as string.

 

val padSize = x.length max y.length

val paddedX = "0" * (padSize - x.length) + x

 

def mult(x: String, y: String) =

 

Sample:

Scala 2.8 introduces `scanLeft` and `scanRight` which can be used to simplify this further:

 

result

.map(_ % 10) // remove carry from each digit

def mult(x: String, y: String) =

y.foldLeft("")((acc, digit) => addNums(acc + "0", multByDigit(x, digit.asDigit)))

 

=={{header|Scheme}}==

Since Scheme already supports arbitrary precision arithmetic, build it out of church numerals. Don't try converting these to native integers. You will die waiting for the answer.

 

(define (add a b) (lambda (f) (lambda (x) ((a f) ((b f) x)))))

(define (mult a b) (lambda (f) (lambda (x) ((a (b f)) x))))

(define six (add two (add two two)))

(define sixty-four (expo two six))

{{out}}

<small>(as run on Chicken Scheme on tio)</small>

[http://seed7.sourceforge.net/libraries/bigint.htm#%28in_bigInteger%29*%28in_bigInteger%29 *]:

 

include "bigint.s7i";

 

begin

writeln(2_**64 * 2_**64);

 

Output:

The multiplication example below uses the requested inferior implementation:

 

 

const func string: (in string: a) * (in string: b) is func

begin

writeln("-18446744073709551616" * "-18446744073709551616");

 

The output is the same as with the superior solution.

=={{header|Sidef}}==

(Note that arbitrary precision arithmetic is native in Sidef).

{{trans|Python}}

loop {

while (result.len < addendpos+1) {

}

 

 

{{out}}

 

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

Note that arbitrary precision arithmetic is native in Smalltalk, and no-one would reinvent the wheel.

or, to display it:

{{out}}

340282366920938463463374607431768211456

(not that I know of any Smalltalk ever ported to a Zuse 1 :-)

 

"/ as the language does not specify, how many bits are used to represent

"/ SmallIntegers, and when the VM uses LargeInts.

"/ verify...

printedString := String streamContents:[:s | printOn value:rslt value:s].

{{out}}

3402823669293846346337467431768211456

The above code does not really integrate into the Smalltalk class library. For example, it will not allow mixed mode arithmetic between regular integers and ''Rosetta integers''.

Here is a full example in portable chunk file format which makes mixed mode arithmetic completely transparent (I implemented only addition and multiplication):

subclass: #RosettaInteger

instanceVariableNames:'digitArray'

Transcript show:'once again: '.

result := (2 asRosettaInteger raisedTo:64) squared.

{{out}}

<pre>a is: 124 (RosettaInteger)

{{works with|Tcl|8.5}}

Tcl 8.5 supports arbitrary-precision integers, which improves math operations on large integers. It is easy to define our own by following rules for long multiplication; we can then check this against the built-in's result:

 

proc longmult {x y} {

puts [set n [expr {2**64}]]

puts [longmult $n $n]

outputs

<pre>18446744073709551616

340282366920938463463374607431768211456

340282366920938463463374607431768211456</pre>

 

=={{header|UNIX Shell}}==

In real shell scripts, I would use either `bc` or `dc` for this:

 

 

But you can also do it with bash's built-in arithmetic:

 

local a="$1" b="$2" sum= carry=0

if (( ${#a} < ${#b} )); then

done

echo "$product"

 

Output is the same either way:<pre>$ multiply 18446744073709551616 18446744073709551616

them in decimal.

 

 

sum = ~&B^?a\~&Y@a ~&B?abh/successor@alh2fabt2RC ~&Yabh2Ofabt2RC

#show+

 

output:

<pre>340282366920938463463374607431768211456</pre>

=={{header|Vedit macro language}}==

This example multiplies the value on current line with the value on next line and stores result on the 3rd line.

#11 = EOL_Pos-Cur_Pos

#12 = EOL_Pos-1

}

}

Sample input and output:

<pre>

{{trans|C#}}<br/>

This uses the '''decimal''' type, (which has a '''MaxValue''' of 79,228,162,514,264,337,593,543,950,335). By limiting it to '''10^28''', it allows 28 decimal digits for the ''hi'' part, and 28 decimal digits for the ''lo'' part, '''56 decimal digits''' total. A side computation of ''BigInteger'' assures that the results are accurate.

Imports System.Console

Imports BI = System.Numerics.BigInteger

End Sub

 

{{out}}Shown are the prescribed output and the maximum power of two that can be squared by this '''''bd''''' structure without overflowing.

<pre>The square of (2^64): 18,446,744,073,709,551,616

{{trans|Go}}

{{libheader|Wren-fmt}}

 

// argument validation

 

var n = "18446744073709551616"

 

{{out}}

 

=={{header|XPL0}}==

char Two64, Product(40);

[Two64:= "18446744073709551616";

Product(39):= Product(39)!$80; \terminate string

Text(0, Product+1); \skip leading zero

 

Output:

=={{header|zkl}}==

[gnu] BigNums are supported via an extension library

BN(2).pow(64) * BN(2).pow(64)

340282366920938463463374607431768211456

//42!, also BN(42).factorial()

[2..42].reduce(fcn(p,n){p*n},BN(1)) : "%,d".fmt(_)

 

{{omit from|Erlang|Erlang has this built in}}