Long multiplication: Difference between revisions

return (0 => 0);

end "*";</lang>

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

<lang ada>procedure Div

Last := Size;

end Div;</lang>

With the above the test program:

<lang ada>with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;

Put (X);

end Long_Multiplication;</lang>

Sample output:

<pre>

340282366920938463463374607431768211456

</pre>

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

The long multiplication for the golden ratio has been included as half the digits

cancel and end up as being zero. This is useful for testing.

===Built in or standard distribution routines===

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

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

);</lang>

<lang algol68>################################################################

# Finally Define the required INTEGER multiplication OPerator. #

NORMALISE ab

);</lang>

<lang algol68># The following standard operators could (potentially) also be defined #

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

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

)</lang>

Output:

<pre>

2 ** 64 * -(2 ** 64) = -340,282,366,920,938,463,463,374,607,431,768,211,456

</pre>

===Other libraries or implementation specific extensions===

As of February 2009 no open source libraries to do this task have been located.

=={{header|AutoHotkey}}==

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

=={{Header|AWK}}==

{{works with|gawk|3.1.0}}

{{trans|Tcl}}

<lang awk>BEGIN {

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

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

=={{Header|Basic}}==

{{works with|QBasic|}}

 

<lang qbasic>'PROGRAM : BIG MULTIPLICATION VER #1

'LRCVS 01.01.2010

END SUB</lang>

 

<lang qbasic>'PROGRAM: BIG MULTIPLICATION VER # 2

'LRCVS 01/01/2010

 

=={{Header|C}}==

<lang c>#include <stdio.h>

#include <stdlib.h>

 

===Using GMP (GNU Multi Precision library)===

{{libheader|GMP}}

<lang c>#include <stdio.h>

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

using the Class Library for Numbers , CLN, and g++

#include <cln/integer_io.h>//for input/output of long integers

#include <iostream>

return 0 ;

}</lang>

</pre>

 

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

<code>System.Numerics.BigInteger</code> was added with C# 4.

{{works with|C sharp|C#|4+}}

<lang csharp>using System;

using System.Numerics;

 

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

<lang lisp>(defun number->digits (number)

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

 

=={{header|Haskell}}==

<lang haskell>digits :: Integer -> [Integer]

digits = map (fromIntegral.digitToInt) . show

340282366920938463463374607431768211456</lang>

 

<lang Icon>procedure main()

write(2^64*2^64)

end</lang>

 

=={{header|J}}==

This is a straight-forward implementation of Long multiplication.

It works with numbers of any length since it uses BigInteger.

 

public class LongMult {

return a.multiply(b);

}

Output:

340282366920938463463374607431768211456

 

=={{header|JavaScript}}==

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

var a2 = num2.split("").reverse();

}

return aResult.reverse().join("");

 

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

=={{header|Mathematica}}==

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.

 

 

In any case, integers are specced to be arbitrarily large, which at least one implementation supports already:

 

=={{header|PicoLisp}}==

 

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

18446744073709551616

340282366920938463463374607431768211456

 

=={{header|PureBasic}}==

(Note that Python comes with arbitrary length integers).

 

 

{{works with|Python|3.0}}

{{trans|Perl}}

<lang python>#!/usr/bin/env python

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

=={{header|REXX}}==

numeric digits 100

 

=={{header|Ruby}}==

 

=={{header|Smalltalk}}==

 

=={{header|Tcl}}==