Talk:Multiplication algorithm

message: The example given is I'm sure great, but I have no idea what caml is, and it's kinda confusing to read. A C or pseudocode example would convey the meaning of the code far more clearly to the majority of the reader base. Could someone translate the example to C/Pseudocode for us? AdamSebWolf 09:09, 30 May 2006 (UTC)
thread_title: Example in Objective Caml

message: I've excerpted the following comment made at Wikipedia:Pages needing attention/Mathematics concerning this article:
 
:The article … contains a false statement: "The fastest known method based on this idea was described in 1971 by Schönhage and Strassen (Schönhage-Strassen algorithm) and has a time complexity of Θ(n ln(n) ln(ln(n)))". (About multiplying long integers - Θ(nln(n)) is evidently enough). The part "A simple improvement to the basic recursive multiplication algorithm..." contains warmup example and shouldn't be in the end. Discussion about complexity is mixed with the discussion about rounding errors and the GIMPS project. (Unsigned entry at 08:06, May 10, 2005 (UTC) by 212.193.10.2. Paul August  ☎ 18:54, Jun 5, 2005 (UTC))
Some of the above user's comments may no longer apply because of subsequent edits, but I thought I would copy this here for the editors of this page to consider. Paul August  ☎ 19:28, Jun 5, 2005 (UTC)
To be more clear, the commentor above was the same person who added the "article needs attention" msg. So if we think all of that persons issues have been adequately addressed then, we can remove the tag, and it's entry on Wikipedia:Pages needing attention/Mathematics. What concerns me most is the alleged factual error. I don't know enough to confirm or fix this. Paul August  ☎ 19:48, Jun 5, 2005 (UTC)
In fact the article is correct, the complexity of S-S multiplication is O(n log n log log n), and is the best known.  Often FFT multiplication is quoted as having complexity O(n log n), because it is assumed the "double" data type on a computer is sufficiently accurate to perform the convolution (which is almost always true in practice).  In fact, when you take into account the number of bits needed of the base data type to guarantee sufficiently small error, FFT multiplication has complexity O(n log^2 n).--Luke Gustafson 07:24, 1 January 2006 (UTC)
thread_title: Article needs attention tag

message: Is it correct to say the finite field should have at least characteristic m ? -- Nic Roets 12:24, 21 July 2005 (UTC)
thread_title:  Number theoretic transform 

message: Note that it's possible to implement any of these in Combinatorial logic hardware. Is there a reference to show that long multiplication is the dominant implementation in silicon ? -- Nic Roets 12:22, 21 July 2005 (UTC)
thread_title:  Hardware 

message: Seems like a more thorough walkthrough of long multiplication should be given, to parallel the long division article. The example doesn't explain the process at all.
:Is there a corresponding "short multiplication"? — Omegatron 03:36, 29 November 2005 (UTC)
replies: text:  I think the name 'long multiplication' was given to distinguish it from multiplication that uses tricks such as lookup tables -- Nic Roets 11:12, 12 August 2006 (UTC)
replies: text:  Should the algorithm be labeled as "fairly accurate"? The algorithm is accurate and will produce a correct answer if used correctly. Any algorithm is subject to operator error --  EconProf86 19:09, 1 July 2007 (UTC)
thread_title: Long Multiplication

message: the lattice isn't explained very well.  it should also be converted into an image, like this: 
http://online.edfac.unimelb.edu.au/485129/wnproj/multiply/images/lattice4.gif
I started to convert it to table markup, but then saw that the examples on other sites draw diagonal lines.  it might be possible to draw it in tex, too?  but an image is probably the best method. — Omegatron 03:32, 29 November 2005 (UTC)
thread_title:  lattice multiplication 

message: I thought this section could use more references and more in the way of practical application -- what ranges it's efficient in and so forth.  Since the section was already too long, I spun this out into its own article: Karatsuba multiplication.  As a result, I've shortened the explanation here by making the example less explicit and technical and removing the Objective Caml example (both of which were moved over).  CRGreathouse (talk • contribs) 00:13, 12 August 2006 (UTC)
thread_title: Karatsuba

message: Are there proven lower bounds on how long any general multiplication algorithm of n-bit numbrs must take?  It's trivially Ω(n), and S-S shows it's O(n log n log log n), but are any better bounds known? CRGreathouse (t | c) 03:42, 22 September 2006 (UTC)
replies: text: I think the article summary should list the lower possible/known bounds. ~ Booya Bazooka 14:46, 17 November 2010 (UTC)

text: Furer's algorithm is asymptotically better than S-S. I'm not aware of any nontrivial lower bounds on serial multiplication - however multiplication is known to lie outside of AC0, meaning it can't be solved with bounded fan-in constant-depth logical circuits, because there is a constant-depth reduction from parity to multiplication, and parity is not in AC0 (see e.g. ). This is the best lower bound I know of, and I will add it. Dcoetzee 23:21, 19 November 2010 (UTC)
thread_title:  Lower bounds? 

message: Can someone explain why this is true (in the section regarding FFTs): "We choose the largest integer w that will not cause overflow during the process outlined below. Then we split the two numbers into groups of w bits"?
I haven't messed around with my own examples (and I'm only in high school, so I probably am just missing a point somewhere), but why does it make sense to have the integer w be the size of the groups? Shouldn't the size of w be the size of the groups?
The most watered down example I could come up with to prove this (to myself) is this:
Say we want to do FFT multiplication to multiply 6 by 9 (I know this is pointless in actuality, stick with me),
the largest integer w that will not cause overflow is 3.
The size of 3 in bits is 2, but we are going to group the numbers into 3 bit pieces, with a maximum value for each of 7. Would 7 not cause errors due to overflow?
I just think there's one or two words amiss in the quoted text; but, again, I don't really have a clue what I'm talking about (dd you notice? :D) — KyleP 07:33, 24 February 2007 (UTC)
replies: text: Hi Kyle - the short answer is, w is already a size in bits, not the number of values possible for each group, which would be 2w. I don't quite follow your example but this may be your source of confusion. Dcoetzee 08:37, 7 April 2009 (UTC)

text: Oops, just realized it's defined as 0 later on. sorry.  —Preceding unsigned comment added by 46.116.195.141 (talk) 17:18, 14 February 2011 (UTC)
thread_title:  FFT 

message: There is reference to a Leonardo but there is no acute way of knowing who Leonardo really is. 129.32.94.123 (talk) 17:43, 19 February 2010 (UTC)
replies: text: Leonardo was the author Fibonacci's first name. Dmcq (talk) 18:19, 19 February 2010 (UTC)
thread_title: Leonardo

message: I think there is an error in the section "Linear time multiplication". In the reference, Knuth discusses that in the model described in this article, multiplication can be done in O(n log n), not O(n). After that he leaves as an exercise to prove that in the pointer machine model it can be done in O(n).  — Preceding unsigned comment added by 181.28.64.87 (talk) 04:15, 28 August 2012 (UTC)
thread_title:  Linear time multiplication 

message: There seems to be some edit warring about this. Please discuss on this talk page first if still insistent on including it.
Personally I see no reason to include it at present. There does not seem to be any general interest that I can see. Also if there was some interest I believe mental calculation would eb more appropriate.
As to the actual system as described personally I think it is silly. I can make up better myself in a couple of minutes, for instance using the symbolism there
:A= (t_1-u_1)\times(u_2-t_2)
:B=t_1\times t_2
:C=(u_1 \times u_2) + t_{u_1 \times u_2}
:D= (A+B+C)@u_{u_1 \times u_2}
:\operatorname{Answer} = (B+\operatorname{hundreds of} D)@\operatorname{tens and units of} D
Which also possibly has negative numbers and adds up to something positive. I don't specially feel inclined to write a book about that though. Dmcq (talk) 12:02, 4 January 2013 (UTC)
replies: text: I agree with Dmcq. One can remark that the algorithm presented by Dmcq is well known (up some changes of signs) as Karatsuba algorithm, and has the great advantage to use only 3 multiplications of digits instead of 4 in the classical algorithm and in the so called "Cheprasov Algorithm". D.Lazard (talk) 12:53, 4 January 2013 (UTC)

text: Yes, the proposed algorithm has no particular advantages in time complexity or for mental calculation, which is precisely why it hasn't gotten published in any peer-reviewed venue. Dcoetzee 05:56, 5 January 2013 (UTC)
thread_title:  Cheprasov Algorithm 

message: IMO the explanation
: If x+y is odd then x-y will also be odd, this means any fraction will cancel out so no accuracy is lost by discarding the remainders.
is not valid as it stands. It is not immediately obvious (without "writing out" (2n-1)²=4n²-4n+1) that the remainders could not add up their effects rather than cancel out; at least the argumentation much be changed. I'd rather suggest
: We know that the result is an integer, so any possible fractional part of +/- 1/4 in either (x+y)²/4 or (x-y)²/4 (in case the squares are of the form (2n+1)²=4n²+4n+1) must necessarily cancel.
This argumentation leads (IMO) more obviously to the correct result. — MFH:Talk 14:40, 19 March 2013 (UTC)
replies: text: The statement is true. You never get a -1/4 remainder when squaring. It isn't a textbook and checking is fairly easy for a reader if they want to do so. Dmcq (talk) 18:01, 19 March 2013 (UTC)
thread_title:  justification for taking remainders in quarter squaring 

message: i think there is a chance that purely creative paradigm approaching way of 1->K data length extrapolation could lead us to an algo that is derived from common algo O(N*N) n that is kinda trading memory O(N) complexity 4 an Sqrt(N) time factor demultiplied from N*N time complexity. Take this as a challange... it looks to me that idea can not b (at least not easily) extrapolated for recursivity so better algo using this only suggested idea seems harder to b obtained. Good Luck, Yankees !! Florin Matei, Romania. 93.118.212.93 (talk) 14:15, 5 May 2013 (UTC)
thread_title:  A possible memory trade for time gaining 4 the common O(N*N) multiplications 

message: qsort might use small sorting in order to partitionate the datas practically forcing some D&C solution, i wonder if there is a similary idea 4 multiplyings: heres the pure creative aproach: we got a rectangle we know the lengths of the edges but we dont know its surface (probably surface area) we might use some both sides splitting in such a way that we might b forming a square or...(a more "docile" rectangle)
... the formed square might help as using algebra taking advantages of its equals borders... its not quite easy to get this to an end but, again, it might worth a try. Florin Matei, Romania... 93.118.212.93 (talk) 17:16, 13 June 2013 (UTC)
replies: text: I don't understand what you are saying. I think you are proposing some of your own ideas. We only put things into articles which have been written about in books and magazines and suchlike and not editors own ideas. See WP:Verifiability. Dmcq (talk) 18:36, 13 June 2013 (UTC)

text: Please stop copying stuff into different talk pages. You have been told what is needed. What you are doing is wasting your time and anybody's who reads this. Please stop. Also if you cannot be bothered to try and write understandably and correctly others will not bother trying to make out what you say. Your time is not worth more than mine. Dmcq (talk) 21:20, 13 June 2013 (UTC)
thread_title:  ok, purely creative part 4 finding similarities with quicksort paradigm 

message: What is the complexity of this algorithm? 31.42.233.14 (talk) 15:08, 10 January 2014 (UTC)
thread_title: Ancient Indian algorithm for multiplying numbers close to a round number

message: It is necessary to say that only one column is added. If this is not specified, the reader will follow the recipe "add numbers which are not scratched out" and that is most of them, i.e. 7 of them in the example of 11 x 3.
It is also necessary to say that it is the column of numbers formed by doubling which is added. Adding the OTHER column will give garbage.
If this is not specified, the reader will not know which column should be added.
Neither of the above is obvious from just an example.
46.64.255.189 (talk) 22:45, 10 January 2014 (UTC)
thread_title:  Peasant Multiplication 

message: ' Method developed by albert_redditt@yahoo.com
' Written in FreeBasic for Windows http://www.freebasic.net
' best to use FBIDE and copy and paste and press F5
' First we set up r_botom and l_bottom
' Then we double those two numbers for r_top and l_top
' then we average each side.
' If l_avg is higher than num2 then we set l_top to l_avg and r_top to r_avg
' if l_avg is lower than num2 then we set l_bottom to l_avg and r_bottom to r_avg
 
' eventually l_top and l_bottom are straddling num2 and l_avg = num2
' at this point r_avg = multplied answer
' if you divide (l_top / num2) the answer is the same as (r_top / mul answer)
'
do
    
    dim as ulongint num1 = int(rnd*1e7)
    dim as ulongint num2 = int(rnd*1e7)
    if num2 > num1 then swap num1 , num2
    '===============================================================================
    'during averaging,
    'if the l_avg ends in .5 then we add .5 to it and
    'the point_5 var (half of num1 ) to the r_avg
    dim as double point_5 = num1/2
    
    dim as string str1 = str(num1)
    dim as string str2 = str(num2)
    
    dim as double l_bottom , l_avg , l_top
    dim as double r_bottom , r_avg , r_top
    '===============================================================================
    'r_bottom = num1* leftmost digit of num2 + zero padding to make it the right length
    r_bottom = val(str( val(str1) * (val(left(str2,1))) ) + string(len(str2)-1,"0"))
    r_avg = r_bottom
    r_top = r_bottom + r_bottom
    '===============================================================================
    'l_bottom = left most digit of num2 + zero padding to make it right length
    l_bottom = val( str(val(left(str2,1))) + string( len(str2)-1,"0") )
    l_avg = l_bottom
    l_top = l_bottom + l_bottom
    '===============================================================================
    'for each unit on the left side there's a num1 on the right side
    'So if l_top minus l_bottom = 1000 units, then 
    'r_top minus r_bottom = (1000 * num1) units..
    
    dim as ulongint count = 0
    
    do
        count = count + 1
        
        l_avg = (l_top + l_bottom) / 2
        r_avg = (r_top + r_bottom) / 2
        
        if l_avg = num2 then exit do
        
        if right(str(l_avg),2) = ".5" then 
            l_avg = l_avg + .5
            r_avg = r_avg + point_5
        end if
        
        if l_avg = num2 then exit do
        
        if l_avg > num2 then 
            l_top = l_avg
            r_top = r_avg
        elseif l_avg < num2 then 
            l_bottom = l_avg
            r_bottom = r_avg
        end if
    
    loop until l_avg = num2
    
    print
    locate ,1  : print "loop req = " ; count
    locate ,1  : print "n1       = " ; num1 
    locate ,1  : print "n2       = " ; num2 
    locate ,1  : print "l_avg   = " ; l_avg
    locate ,1  : print "r_avg   = " ; r_avg
    locate ,1  : print "n1 * n2  = " ; num1*num2
    
    print
    print "Press a key to continue.."
    sleep
loop until inkey = chr(27)
sleep
end
'===============================================================================
Method takes aprox 3.3 averages per digit , so 10,000 x 10,000 digits = 33,000 averages  — Preceding unsigned comment added by Albert redditt (talk • contribs) 21:03, 18 February 2014 (UTC)
replies: text: This method appears to be original research, being developed by the author of the post and not published in any reliable journal. As such Wikipedia policy is to forbid the insertion of the method in any article. Sorry, Wikipedia is not a media for publishing your work. D.Lazard (talk) 22:08, 18 February 2014 (UTC)
thread_title: Multiply by averaging

message: Inspired by the article here, I implemented quarter-square multiplication for the old school CP-1600 processor family, used in the Intellivision.  I implemented unsigned 8-bit × unsigned 8-bit => unsigned 16-bit, 16-bit × 16-bit => 16-bit (signed/unsigned doesn't matter), and a funky fixed point implementation that did signed 8.8 × signed 8.8, where the RHS was constrained to the range -1.00 to 1.00.  You can read all about it here: http://atariage.com/forums/topic/236848-quarter-square-multiplication-blindingly-fast-multiplies/  Mr z (talk) 05:13, 15 April 2015 (UTC)
thread_title: Quarter Square on the CP-1600 (Intellivision)

message: A user said the first line of the Grid method
:The grid method (or box method) is an introductory method for multiple-digit multiplication that is often taught to pupils at primary school or elementary school level.  It has been a standard part of the national primary-school mathematics curriculum in England and Wales since the late 1990s.Gary Eason, Back to school for parents, BBC News, 13 February 2000Rob Eastaway, Why parents can't do maths today, BBC News, 10 September 2010
:
failed verification 'Grid method: The first citation talks about maths from 2000 onwards. The second one is over a decade later. Nothing supports this utterly irrelevant point.'. It seems pretty evident to me from the source but if someone can point out why they think it fails or can provide some more explicit maybe that would help. The citation from 2000 is talking about recently introduced methods for doing arithmetic and talks about the grid method for multiplication. The second says 'The revolution in the teaching of maths at primary school kicked in with the National Numeracy Strategy in 1999' Dmcq (talk) 20:35, 12 January 2016 (UTC)
thread_title:  Grid method citation 

message: Maybe it is nice to add a section about multiplying with help of (general) Fibonacci sequences. 
Like Binary multiplication the Fibonacci way also code a number in 0 and 1 digits. The code is Phinary in stead of Binary. 
The Phinary number is used to look up values from a general Fibonacci sequence. This is analogous to "Peasant or binary multiplication" where the binary number is used to look up value's from a sequence of powers of 2 times an initial value. 
 Binary multiplication example
decimal sequence	Binary 11	lookup
3*powers of 2   	1011     	
3               	1        	3
6               	1        	6
12              	0        	
24              	1        	24
Total           	         	33
	
 Two analogous Phinary example's
Fibonacci sequence	Phinary 11		lookup		Alt-fib sequence		Phinary 11		lookup
center at 3       			10101.0101		center at 3	10101.0101	
	0                				1      			0		-6        				1      			-6
	1                				0      			5         				0      	
	1                				1      			1		-1        				1      			-1
	2                				0      			4         				0      	
	3                				1.     			3		3         				1.     			3
	5                				0      			7         				0      	
	8                				1      			8		10        				1      			10
	13               				0      			17        				0      	
	21               				1      			21		27        				1      			27
	TOTAL            	          			33	           	          			33
At first impression both methods share the same  Big-O (classification), but figuring out the Phinary notation is more time consuming than a Binary notation. A classical computation of a fibonacci sequence is more complex than generating a sequence based on bit-shift operations. 
From the computation point of view, the positive thing is the amount of freedom to figure out creative optimizations. Phinary 11 (10101.0101) for example, can also be written as 100000.0000-1. 
The computation become than: fibonacci(9) - fibonacci(-1) = 34 - 1 = 33 , or from the non-standard fibonacci swquence: 27 - -6 = 33, a lot less computations to make. Swiersma (talk) 12:06, 28 February 2016 (UTC)
replies: text: It hasn't anywhere near the weight or relevance to go in this article but a link to Golden ratio base would probably be okay. Dmcq (talk) 14:32, 28 February 2016 (UTC)
thread_title:  Phinary multiplication. 

message: Are there any reliable source explaining why people think Gauss knew this? The reference to [11]  Knuth, Donald E. (1988), The Art of Computer Programming volume 2: Seminumerical algorithms, Addison-Wesley, pp. 519, 706 is misleading in several aspects. Technical: it is not clear which edition is meant, third edition seems to be around 1998, the second around 1981. Important: -- The Karatsuba multiplication algorithm (with reference to Karatsuba, of course) is mention in Section 4.3.3., p. 294 (p.278 of the second edition), with no references to Gauss. On p. 519 and 706 of the third edition indeed the complex multiplication is mentioned. On p.519 (p.501 of the second edition) there is an exercise nuber 41 for section 4.6.4 asking to provide a compex multiplication with 3 read multiplications and 5 real additions, and p.706 (p.647 of the second edition) gives an answer to this exercise, "41. 𝑎(𝑐 + 𝑑) − (𝑎 + 𝑏)𝑑 + 𝑖(𝑎(𝑐 + 𝑑) + (𝑏 − 𝑎)𝑐). ⟨…⟩ Without the restriction on additions there are other possibilities. For example, the symmetric formula 𝑎𝑐 − 𝑏𝑑 + 𝑖((𝑎 + 𝑏)(𝑐 + 𝑑) − 𝑎𝑐 − 𝑏𝑑) was suggested by Peter Ungar in 1963. See I. Munro, STOC 3 (1971), 40–44; S. Winograd, Linear Algebra and its Applications, 4 (1971), 381–388." There are no explicit reference to any work of Ungar. Winograd and Munro do not say anything about Gauss (or Ungar) either. Knuth (in the index) says that Gauss is mentioned on pp.20, 101, 363, 417, 422, 449, 578, 679, 685, 688, 701; none of these pages says something about complex multiplication. There are several places where Gauss is claimed to know the Gauss multiplication trick (e.g., Dasgupta et al. classical textbook), but I did not manage to find any sources explaining why this is said...  — Preceding unsigned comment added by Alexander.shen (talk • contribs) 10:12, 20 January 2017 (UTC)
thread_title:  "Gauss multiplication trick??" 

message: Hello fellow Wikipedians,
I have just modified one external link on Multiplication algorithm. Please take a moment to review my edit. If you have any questions, or need the bot to ignore the links, or the page altogether, please visit this simple FaQ for additional information. I made the following changes:
*Added archive https://web.archive.org/web/20140529212847/http://math.berkeley.edu/~strain/273.F10/duhamel.vetterli.fft.review.pdf to http://math.berkeley.edu/~strain/273.F10/duhamel.vetterli.fft.review.pdf
When you have finished reviewing my changes, you may follow the instructions on the template below to fix any issues with the URLs.
Cheers.—InternetArchiveBot (Report bug) 04:45, 8 February 2018 (UTC)
thread_title:  External links modified (February 2018) 

message: The 2014 Paper "Even Faster Integer Multiplication" by Harvey, David ; Van Der Hoeven, Joris ; Lecerf, Grégoire is not mentioned, that I can tell. It claims to improve the complexity over Fürer's algorithm by a factor of 2^(log*n), where log* is the iterated logarithm. Has the paper not been validated by the mathematical community? If it is indeed faster than Fürer's algorithm, then it deserves a mention (and also other articles such as Schönhage–Strassen algorithm and Fürer's algorithm would need to be updated to reflect that there is a new algorithm with the lowest known asymptotic complexity). I thought I would mention it here and let those more mathematically qualified than me make the decision.  — Preceding unsigned comment added by Karatekid430 (talk • contribs) 04:27, 10 September 2018 (UTC)
thread_title:  Even Faster Integer Multiplication 

message: Formulation of the indices j and k, and j+k=i as the running variable of the summation appears incorrect. 
When j and k are the right most digits of the operands, e.g. when they are both 1, the summation does not compute the right most resulting digit r1 but r2.
The assertion "A simple inductive argument shows that the carry can never exceed n" is certainly wrong.  Let two two digit numbers be 99 and 99. Multiply any two digits 9*9=81. The carry 8 is greater than 2 (digits).  I think the sentence is worded incorrectly, while the concept may be right.  — Preceding unsigned comment added by 24.46.146.12 (talk) 03:53, 11 October 2018 (UTC)
thread_title:  Optimizing space complexity 

message: Shouldn't the article be updated to mention the discovery of an O(n\log n) integer multiplication algorithm (https://hal.archives-ouvertes.fr/hal-02070778/document)? -- Meni Rosenfeld (talk) 11:03, 16 April 2019 (UTC)
replies: text: Normally, we must wait for secondary sources, or at least for acceptance by a notable journal; this is needed for verifying the correctness of the result. However, because of the importance of the result, a sentence such as "In March 2019, an algorithm has been presented with a claimed complexity of O(n \log n)" could be acceptable. D.Lazard (talk) 12:14, 16 April 2019 (UTC)
replies: text: I've added a sentence about it. Feel free to modify or update. Wqwt (talk) 20:20, 3 May 2019 (UTC)
thread_title:  O(n logn) 

message: I've been looking around for content about the computer computational advantage of multiplication lookup tables.  For example, to create a fast base 256 lookup table, one can precalculate:
int16 multiplybase256[256*256];
where 
multiplybase256[ (a<<8) | b ] = a*b;
then
x = a*b;
becomes 
x = multiplybase256[ (a<<8) | b ];
which is much faster versus simple single instruction multiplication and in small loops frequently executes in one or less CPU clock cycles since there isn't much math involved with the low overhead SHIFT and OR operations.  In many applications, small integers get multiplied repeatedly which is unnecessary stalling since small read only tables fit in the CPU memory caches which are faster.
Essentially, the fastest math operations are the ones you don't do, or only do once.
Youjaes (talk) 06:00, 13 November 2019 (UTC)
thread_title:  Fast base 256 lookup tables 

message: I'm not sure if it's notable, but a new multiplication algorithm based on Collatz's function has emerged:
* https://rdcu.be/b4c3M
--DaBler (talk) 08:15, 16 May 2020 (UTC)
replies: text: For being notable, it must be mentioned in secondary sources. This is not the case here, as it is very recent original research. So, at time, not suitable for WP. D.Lazard (talk) 08:23, 16 May 2020 (UTC)
thread_title:  Multiplication Algorithm Based on Collatz Function 

message: N×M multiplication can be done in terms of calculating N÷(1÷M). 2A01:119F:253:7000:694A:A3D8:66A5:C4B2 (talk) 11:52, 28 January 2022 (UTC)
thread_title:  N÷(1÷M) 

message: Please change all instances of * and the letter x used as multiplication operators to ×, except in the computers section.|Please remove excess vertical whitespace in the computers section. — Preceding unsigned comment added by 109.70.40.55 (talk) 
: Not done: According to the page's protection level you should be able to edit the page yourself. If you seem to be unable to, please reopen the request with further details. ‑‑ElHef (Meep?) 20:26, 9 April 2022 (UTC)
thread_title:  x, * 

message: In the lattice multiplication section of this article, it is claimed that the first known appearance of the lattice method in Europe was in a book of Fibonacci, and that in Arab mathematics, the first known appearance of the method is due to Al-Khawarizmi.
However, the history section of the article on lattice multiplication says that this is totally false and that neither of the two authors mentioned the lattice method in his book.
As such, there are contradictory statements in two different articles on the same topic. Someone should look into the sources and see which one is correct (I might get around to it once I have more time but no guarantee) المبتدئ18 (talk) 20:35, 21 November 2023 (UTC)
thread_title:  Lattice multiplication inconsistency