Talk:Gaussian elimination

message: Who put up the goofy picture of a black (actually, green) board and why?  I is hard to read and does not add much. Jfgrcar (talk) 09:11, 5 December 2011 (UTC)
thread_title:  Picture of Blackboard 

message: Can somebody clean up the algorithm, its poorly done as is. That and maybe a version in C and FORTRAN which are formal languages. That way clarity is enhanced.
Ideally the algorithm should be able to deal with m by n matrices, so that some who have a square matrix and others with a column augmented matrix can all be accommodated.
I also suggest some links to open textbooks that have details on the topic.
—Preceding unsigned comment added by Veganfanatic (talk • contribs) 01:22, 21 June 2010 (UTC)
replies: text: An over-determined system; that is, m≥n, need not be considered, for an over-determined system may not have a solution. Treatment of an m≤n system is the same as that of an m×m system. One can move n−m variables into the augmented term. The elimination algorithm can be made more systematic by: (a) Normalizing the leading element in each row to unity; (b) Subtracting the first row from every other row to eliminate the leading element in every other row; (c) Repeating the above two steps by moving down to the second row, and then to the third row, etc., one row at a time, until an echelon form is reached. 70.31.163.151 (talk) 15:11, 3 August 2015 (UTC)
thread_title:  Algorithm 

message: Under the section "General algorithm to compute ranks and bases" the article states:
 This echelon matrix T contains a wealth of information about A: ... the vector space spanned  by the columns of A
 has as basis the first, third, fourth, seventh and ninth column of A (the columns of the ones in T),
 and the *'s tell you how the other columns of A can be written as linear combinations of the basis columns.
This must be an error. The operations in the algorithm preserve the row space, not the column space of A. The column space of T is always spanned by a standard base, and this is not true for an arbitrary matrix A.SanderEvers 08:25, 29 June 2007 (UTC)
thread_title:  Mathematical error 

message: The page Gauss-Jordan elimination currently redirects here, with many backlinks, but this article makes no mention of this name except to use it with no explanation about half way down. Does anyone know anything about this term - is it a synonym, an extension, a misnomer? And, as my subject heading says, where does the Jordan bit come from? - IMSoP 13:35, 19 Apr 2004 (UTC)
replies: text: A Google search reveals that it refers to the geodesist Wilhelm Jordan (1842 - 1899), "who applied the method to finding squared errors to work on surveying". Not to be confused with either Marie Ennemond Camille Jordan or Pascual Jordan. -- Dissident 13:58, 19 Apr 2004 (UTC)

text: Gauss-Jordan elimination computes a diagonal matrix, rather than the triangular matrices usually found in Gaussian elimination.  G-J elimination should probably be a separate page, with a mention/comparison here. —The preceding unsigned comment was added by 24.236.179.177 (talk) 17:31, 8 April 2007 (UTC)
thread_title:  Who or what is or was Jordan? 

message: This article currently mentions reduced row echelon form, but not row echelon form, which it should because the two are not the same thing and because row echelon form redirects to this article. —Lowellian (talk) 21:36, Oct 8, 2004 (UTC)
It should also be noted that when I learned this, they said proper row echelon form was in the form:
1  n1  n2  |  n3
0  1  n4  |  n5
0  0  1  |  n6
In other words, it is the same as the row echelon form currently used, but it is reduced so that the first non-zero number in each row is a 1.  However, the numbers to the right of the 1s are not reduced, as they would be in reduced row echelon form.  —Preceding unsigned comment added by 99.153.132.151 (talk) 03:19, 12 February 2009 (UTC)
thread_title:  Row echelon form 

message: As far as I know (but I'm not an expert on numerical analysis), one major reason why Gaussian elimination is never used for solving large systems in floating-point arithmetic is that it is quite unstable. Any error you commit at any point gets propagated. Iterative method, working on attractive fixed points, are much better in that respect. David.Monniaux 20:37, 15 Dec 2004 (UTC)
replies: text: Gaussian elimination can indeed be unstable, even when using pivoting. Theoretical studies shows that it can be very unstable, but it is generally not a problem in practice. This discrepancy is not well understood. Gaussian elimination is not used for large systems because of its n^3 price tag; the instability may also be a reason but it is not often mentioned. A lot can (and should) be written in the current article about stability problems. Unfortunately, numerical linear algebra is not quite my speciality and I have no time at the moment, so somebody else has to do this. -- Jitse Niesen 21:32, 15 Dec 2004 (UTC)

text: I would assume that the Gaussian elimination uses partial pivoting for FEM (Finite Element Method?) codes, since that's the standard way of doing things.  Many large systems are sparse, which is why iterative methods (which exploit the sparseness) can be cheaper.Eweinber (talk) 06:59, 14 April 2012 (UTC)
thread_title:  Instability 

message: The matrices should really be in []s, not ()s.  129.44.216.105 02:24, 9 March 2006 (UTC)
thread_title:  Formatting 

message: I've edited the rules that determine whether a matrix is in REF/RREF, as they were wrong. Specifically, the article (before my edit) stated that every leading coefficient must be 1 for a matrix to be in REF; This is actually a requirement for RREF. I've also cleaned up the formatting in that area to make the rules clearer. My source for the rules is:
Lay, David C. "Linear Algebra And its Applications". Third Edition - Low Price Edition, Page 30.
If anyone finds a source to the contrary, I would be interested - I don't know where the original information on the page came from.
Braveorca 23:30, 24 May 2006 (UTC)
replies: text: According to Talk:Row echelon form, Larson and Hostetler, Precalculus, 7th edition, states that the leading coefficients has to be one for row echelon form. -- Jitse Niesen (talk) 13:51, 2 December 2006 (UTC)
thread_title:  REF and RREF requirements 

message: i've been working on a huge rewrite of this (and the split-offs it spawned, heh) for a couple of days, and it's now done. I think it's all consistent and correct, but I haven't checked the source code examples and proofread very thoroughly (because my head hurts from too much of this). Any changes to fix stuff would be greatly appreciated. I think the rewrite fixes some major problems of the old one (no offence :)), making it more modular and, most importantly, noting that gaussian elimination is not the same as gauss-jordan (though there are other "fixes" as well). -- Braveorca 02:01, 27 July 2006 (UTC)
thread_title:  Rewritten 

message: I'm not a numerical specialist, but I do know that, although in general you shouldn't compare two floating-point numbers for equality, zero is a special case; it has an exact representation. Is there an algorithmic reason a small epsilon should be used instead of zero?
:The problem is with the way in which numbers are stored and manipulated in a computer.  Numbers are represented internally as binary numbers, and all mathematical operations are done in binary arithmetic, usually floating point.  Internal numbers are limited in size, so rounding errors occur.  Numbers are then displayed in decimal form.  As an illustration, I just did the following calculation, using perl: (11/7)*(7/11)-(13/5)*(5/13) The result clearly should be zero, but in fact is 5.42101086242752217e-20 That is less than 0.000000000000000000006,  obviously very small, but not zero, so comparing against zero would show inequality.
:I usually compare against 1e-18, instead of zero, when using floating point numbers, however that is machine and platform dependent.
----
I think that some of the above statements and the remark in the article are the result of some misunderstanding or fuzzy thinking regarding how floating point works.  There's some belief that floating point is a little random or uncertain or imprecise, but this isn't really any more true for floating point than fixed point, such as their special case, the integers.  It is true that rounding errors and the lack of an exact representation for most real numbers often requires using a comparison band.  However, it isn't true that floating point numbers will always be slightly off, or that they are incapable of exact representation of a particular number--and it isn't true that exact equality should never be used with floating point, which seems to be what is implied here.
I beleive the remark in the article is one of these misstakes, and should be removed.  It is essential that the leading coefficient in each row be 1, not just something that is close to 1.  And yes, in any sane non-broken fp implementation, dividing a number by itself will yield exactly 1.  And yes, any sane non-broken fp implementation has an exact representation of 1.  FP implementations don't just produce random imprecisions for no good reason, contrary to popular belief.  Also, what specifically does testing for a narrow band around 1 instead of 1 itself add, even if this were a valid test?  Dividing the row by a number very close to 1 is unlikely to have any significant negative effect on the result, unless the matrix is ill-conditioned, in which case other sources of error will probably be more significant anyway.  Is this supposed to be some sort of ill-conceived performance optimisation suggestion, perhaps?
In fact, I think I'm going to remove the fp eps comment from the article.  If you feel it needs to be re-added, please discuss it here. AaronWL 05:47, 10 November 2006 (UTC)
replies: text: I'm sorry, but I've no idea what you're talking about. We're not talking about comparing to 1, but about comparing to 0. Surely, it can happen that a matrix which in exact arithmetic would give a zero pivot, gives a small but nonzero pivot in floating point. If not, why not? -- Jitse Niesen (talk) 06:38, 10 November 2006 (UTC)

text: You seem to have misunderstood the statement that floating point should not be thought of as random. Floating-point arithmetic is certainly not random, but it is not generally exact either. Floating-point arithmetic is exact only when the result of an operation can be exactly represented as a floating-point number, for example when both inputs are integer-valued and the result is integer value (for small integers), but this is not generally the case. It is definitely not the case for Gaussian elimination, even if the input matrix has small integer entries since Gaussian elimination relies heavily on division. Also, comparing against 1e-18 often doesn't make sense since it is smaller than the machine epsilon in double precision arithmetic. It may work with with 80-bit extended doubles, but they are not supported everywhere. Also be careful to distinguish between absolute and relative differences when comparing. Fredrik Johansson 11:24, 11 November 2006 (UTC)
thread_title:  Floating-point numbers to zero 

message: Gaussian Elimination article:
 Equivalently, the algorithm takes an arbitrary matrix and reduces it to
 row echelon form.
 A related but less-efficient algorithm, Gauss–Jordan elimination,
 brings a matrix to reduced row echelon form, whereas Gaussian elimination takes
 it only as far as row echelon form.
 Stated equivalently for matrices, the first part reduces a matrix to
 row echelon form using elementary operations while the second reduces
 it to reduced row echelon form, or row canonical form.
 At the end of the algorithm, we are left with
 
 \begin{bmatrix}
 1 & 0 & 0 & 2 \\
 0 & 1 & 0 & 3 \\
 0 & 0 & 1 & -1
 \end{bmatrix}
 
 
 That is, it is in reduced row echelon form, or row canonical form.
Gauss-Jordan elimination article:
 In other words, Gauss-Jordan elimination brings a matrix to
 reduced row echelon form, whereas Gaussian elimination takes it only as far
 as row echelon form.
Sorry guys you haven't convinced me that these contradictions are non-existent.
I am getting tired of people ignoring blatant contradictions.  Please open your
eyes and fix it or I will (someday).  --ANONYMOUS COWARD0xC0DE 02:10, 18 May 2007 (UTC)
replies: text: What makes you think that we disagree? If you think you can improve the article, go ahead and fix it. We're all volunteers with limited time, so it won't help to get frustrated about it. -- Jitse Niesen (talk) 12:56, 19 May 2007 (UTC)

text: I think the reality is that the article describes Gaussian Elimination with Backsubstitution, but mistakenly refers to this whole process as Gaussian Elimination (GE). GE is the process of reducing a matrix to upper-triangular form (see section 2.2, Press, Teukolsky, Vetterling, and Flannery, Numerical Recipes in C++, 2nd edition). Following GE, backsubstitution may be used in order to solve for the unknowns in a system of linear equations.Bekant 20:31, 17 August 2007 (UTC)
thread_title:  As of 2007-05-17 

message: See headline —The preceding unsigned comment was added by 63.243.91.254 (talk) 18:36, 9 February 2007 (UTC)
replies: text: Thanks. -- Jitse Niesen (talk) 08:37, 11 February 2007 (UTC)
thread_title:  Too many END_IF statements in the pseudocode!  1 more than there are IF statements...  (#) 

message: Why is the citecheck tag on this article? Which citations need support? What citations would you like added? Would you like to see a reference to a layman (undergrad) introduction to Gaussian elimination or to some more advanced material in numerical linear algebra? I could not find any information about it in the talk page. Maybe I could help. Fph 13:31, 19 March 2007 (UTC)
replies: text: It's about the difference between reduced row echelon form and row echelon form, see the Section "contradiction" above. Actually, I think the  article needs a complete overhaul (addressing the pivoting issue you mention below), so I don't feel like doing all sorts of small corrections. -- Jitse Niesen (talk) 00:23, 20 March 2007 (UTC)
thread_title:  Citecheck tag 

message: I think more information about partial pivoting should be added. As the page is now, pivoting is only explained through a pseudo-code algorithm, and is never properly introduced. I suggest adding an appropriate section. Fph 13:36, 19 March 2007 (UTC)
thread_title:  Pivoting 

message: Reading over the intro paragraph to this article, it struck me as taking a long time to get around to revealing exactly what Gaussian elimination is, so I fixed it.  Now, I'm an English person, not a math person, so please check over it and fix any factual errors I may have inserted. I just felt the textual style could be cleaned up a bit.  Thanks, Applejuicefool 14:24, 10 May 2007 (UTC)
thread_title:  Intro cleanup 

message: I would like to post comments on this article. In general, I have found Wiki to be exceptional and outstanding in its content. However, this particular article has left me quite perplexed. Please take my comments with a grain of salt, I do not know everything about matrix algebra. The first source of confusion is that in textbooks, online course notes (from professors), and hundreds of online references, most people today think of Gaussian elimination as an algorithm that, essentially, computes PA = LU. While this is mentioned in the article, the article seems to actively support the notion that the correct way of thinking about Gaussian elimination is as a factorization into ST. This is perplexing given that the three textbooks I have describe GE as a factorization into P, L, and U. As I mentioned, searching online provides the same discussion, be it class notes, theses, etc. Further, the general GE algorithm most practitioners are familiar with is only one "part", not two parts as the article claims. This one part computes the familiar LU decomposition that we would all find in textbooks, online pseudo-code, etc. It struck me that perhaps the author found the one textbook that truthfully proved that Gauss actually thought of both parts. All the textbooks I have describe only the first part. Considering the algorithm as a two-part entity thus seems to me to be highly likely to cause confusion for many other individuals besides myself.
(You are correct. The article uses nonstandard notation. The proper notation is LU. Jfgrcar (talk) 06:34, 18 February 2012 (UTC)
thread_title:  Is this article confusing? 

message: I was looking for this page for a class I'm taking and had trouble finding it because I was typing "Gausian" instead of "Gaussian".  This seems like a fairly common misspelling; shouldn't there be a redirect for this spelling? 207.233.124.3 21:19, 15 May 2007 (UTC)
replies: text: Yes, there probably should. I added a redirect. Thanks. -- Jitse Niesen (talk) 01:08, 16 May 2007 (UTC)
thread_title:  Possible redirect 

message: This article sais that in practice, matrix inversion is rarely used since we really want to solve the system of linear equations. But this is exactly it!! Solving a system of linear equations is nothing but inverting its matrix...  —Preceding unsigned comment added by 89.3.223.27 (talk) 21:54, 16 April 2008 (UTC)
replies: text: For the most part, although technically it is x=A^{-1}b, with the system of equations being Ax=b. Computationally, the difference is slight, but the inversion method will require about n^3 multiplications and divisions, whereas the Gaussian elimination method will require about n^3/3 (the actual equations are more intricate but this is the essence). Both are complexity \mathcal{O}(n^3)\,, so on a grand scale it may not matter (is it going to take one century or three centuries to finish calculating...?). However, what you are looking at essentially is 3 times the operations being required for taking the inversion route. This, I believe, is why people usually avoid trying to solve x=A^{-1}b by calculating the inverse. WDavis1911 (talk) 20:11, 18 April 2008 (UTC)

text: Despite the citations I don't believe the second part of this statement is true.  The second part of the statement may be true for students in an introductory linear algebra class, however, at least in applications of process control the inverse matrix is often of greater interest than a single solution.  Any application where you are solving Ax=b repeatedly in real time with a new b vector at each time instance, calculating A inverse ONCE and calculating x=A^-1 b (which is order 2 if you already have A^-1) over and over is more economical than solving Ax=b by Gaussian elimination over and over at order 3...  The "rarely" and "most of the time" weasel words weaken this statement enough that even if the statement were true it fails notability.86.169.24.214 (talk) 20:11, 22 April 2009 (UTC)
replies: text: In your application, you should compute and store the LU decomposition of A. Solving LUx=b takes as many operations as calculating x=A^-1 b if you already have A^-1, but it's more stable. Nevertheless, there are some situations in which the matrix inverse is required (e.g., the Denman–Beavers square root iteration for computing the square root of a matrix). I think the statement plays an important role in warning readers against a mistake often made. The statement is sufficiently notable that it's in many (if not all) textbooks on numerical analysis that mention the matrix inverse. -- Jitse Niesen (talk) 17:46, 23 April 2009 (UTC)
thread_title:  Matrix inversion 

message: I didn't really understand this article. I'm not a math genius or anything, but isn't that the point of Wikipedia, to make information accessible to laypeople? I mean we've got textbooks to teach the technical details to math students and so on. --98.214.255.102 (talk) 05:51, 1 July 2008 (UTC)
thread_title:  Too technical? 

message: The parallel psuedocode section actually just contains C code that's not exactly newbie friendly.  I think this section is too complex to be "obviously correct," therefore needs to be cited.  There's an implementation that we could link to on google code that makes a bit more sense to my mind [although in pivot column selection, abs isn't used, and it's not really commented any better].
At first glance, the issues with the code that's there now are that curly braces are missing (as written, k = matrix_demention will be used for the main body of gauss, although it appears the body was intended to be contained within the if (thread_id== body) and that dimension is misspelled as demention.  There are also more minor errors (barrier_t not described, no mention of pthread_attr_init, the barrier is hit twice without explanation, and I don't see the pivot column selection so I'm not sure if the algorithm described actually is Gaussian).
Can someone with more math knowledge review this section?  Does it even belong here? rev where it was added
Thatch (talk) 22:39, 11 October 2009 (UTC)
thread_title:  Parallel psuedocode 

message: This code is barely readable and should be corrected. 
1. The comment at the top explains what the text following it does, while the rest of the comments explain what code should be implemented in that spot (but the code itself is neglected). This is inconsistent and confusing.
2. We shouldn't have words explaining what the code does (that is what the rest of the article is for!). We should have an implementation of the code instead. It would be ideal if the words in the code only served to describe what the code is doing, instead of replacing the code.
3. In most languages, you start counting at zero, not one, yet this convention is broken here. I think it would be best if we tried to make it as close to real-world code as possible.
4. I think the code would be easier to read if it was constructed in for loops like the parallel code below it. This way, the two can be more easily compared. They should also use the same variable names where applicable, and access the contents of a 2D array the same as well i.e. use this notation matrix[a][b] not A[i,j]. I think the problem lies primarily with the first code while the second is a lot easier to read.
Well, I guess if you are used to code written in Fortran, this might be more tolerable to you. However, I think that most people don't know Fortran and thus aren't used to its weird conventions AND of those who do know it, they tend to agree that it is difficult code to read and maintain in the first place. So, why don't we try moving this code into something a little more user-friendly?
159.242.229.96 (talk) 19:02, 16 December 2009 (UTC)
thread_title:  Non-Parallel Pseudocode 

message: May I change it from "Top priority" (seems not appropriate to me) to "High priority" and from "Start class" to "C"? Franp9am (talk) 21:16, 28 August 2011 (UTC)
replies: text: Seconded; I'm going to go ahead and update the quality rating to C-class; I support lowering its priority to High, but I'll leave that step to someone else. -Bryanrutherford0 (talk) 03:38, 18 July 2013 (UTC)
thread_title:  Math-rating 

message: The History section clearly indicates that the method of Row Reduction had little to do with Gauss.  Why should we continue to emphasize this historical misunderstanding (the Chinese discovered the method more than 2000 years ago!!!)?  Shouldn't we reduce the role of the name 'Gaussian Elimination' to a synonym that is in common usage?  The name 'Row Reduction' is also more descriptive of the process and is in common usage as well.  Therefore, I recommend changing almost all occurrences of the name 'Gaussian Elimination' with the name 'Row Reducation' while adding appropriate text to indicate that the name 'Gaussian Elimination' is a common synonym that is historically false and inaccurate. Cjfsyntropy (talk) 22:32, 15 November 2011 (UTC)
replies: text: Well, I call it "row reduction". In fact, I find the distinction between "Gaussian elimination" and "Gauss-Jordan elimination" quite superficial, since the process really is the same (row operations on matrices). I would suggest merging these two articles to clarify the situation. I would also favour renaming a merged article to "Row reduction". Mark M (talk) 08:56, 25 December 2012 (UTC)
replies: text:  I would suggest to merge also these two articles with Row echelon form. In fact, row echelon forms are defined independently of any algorithm and Gaussian and Gauss-Jordan eliminations are the most natural algorithms to compute them. Without such a merge, I do not see how to explain that "the result of Gauss-Jordan elimination is independent of the way of doing Gauss-Jordan elimination". By the way, properly speaking, Gauss-Jordan elimination is not Gaussian elimination followed by a further reduction; this "further reduction" is mixed with Gaussian reduction. It is only the unicity of the result that allows to call Gauss-Jordan elimination these two different algorithms. D.Lazard (talk) 10:27, 9 February 2013 (UTC)
replies: text:  I would like to keep the articles separate. Under echelon form it is already a hyperlink to the article about row echelon form and the reduced echelon form. The linked article ( Row echelon form ) supplements this article by providing an example that would be redundant in this article, but is in my opinion more easy to read and understand quickly ( see figure ). The Row echelon form article is more a description of how to do the reduction by hand, and the practical maths of it, while this article is more about the algorithm-based approach. Merging would make this article more cluttered, and less readable. This, in my view, makes the two articles incompatible for merging without a major re-write. --Magnus0re (talk) 12:06, 14 July 2015 (UTC)
thread_title:  Shouldn't the article emphasize the name 'Row Reduction' not Gaussian Elimination? 

message: I've finished merging on Gauss-Jordan elimination. There were a few sourced claims that I haven't checked the sources for (because I don't have them), so I just copied them over directly.. hopefully in the process I didn't introduce too many mistakes. Mark M (talk) 09:44, 1 March 2013 (UTC)
thread_title:  [[Gauss-Jordan elimination]] now merged 

message: Could someone maybe change the matrix in the example to one that has a unique solution?  It's been awhile since I've tried to solve a system of equations but since that's what this is used for most of the time (?) wouldn't it be useful to have an example people could work themselves?  If the point of reducing the matrix to row echelon form is to make the system easier to solve it would be helpful for people to see that the system has a solution, or at least to point out that the system has no unique solution (and explain why given the form of the matrix).  I'd do it myself but like I said, I'm a bit rusty.  Lime in the Coconut 17:14, 14 June 2013 (UTC)
replies: text: One of the main interest of Gaussian elimination is that it works well with non invertible matrices, contrarily to many other algorithms, like Cramer's rule or inverting the matrix. As it is, the example emphasizes this property. Changing the example to an example with a unique solution would thus decrease the amount of information provided to the reader. D.Lazard (talk) 18:29, 14 June 2013 (UTC)
thread_title:  Introduction Example 

message: Row echelon form should never be merged with Gauss elimination as both are completely different ways.As Gauss elimination is the first step of Gauss Jordan method which is used to find system of equations.Row echelon is used only for finding Rank of a matrix.If any confusion then please consult me.  — Preceding unsigned comment added by Praveen.ujjain (talk • contribs) 07:48, 25 August 2013 (UTC)
replies: text: You are wrong when asserting that row echelon form is used only for rank computation. Row echelon form is the result of Gaussian elimination, and reduced echelon form is the result of Gauss-Jordan algorithm. Thus the merge is perfectly justified. D.Lazard (talk) 10:44, 25 August 2013 (UTC)

text: I know that it's result of Gauss Jordan algorithm but putting it under any topic make it loose it's independent identity.We got it as result but initials are different.As if i misinterpreted it for rank sorry for that.  — Preceding unsigned comment added by Praveen.ujjain (talk • contribs) 15:22, 25 August 2013 (UTC)
thread_title:  Row echelon form (August 2013) 

message: The article says: "This algorithm can be used on a computer for systems with thousands of equations and unknowns. However, the cost becomes prohibitive for systems with millions of equations. These large systems are generally solved using iterative methods."  That link to iterative methods isn't very specific.  Can we get a reference about using iterative methods (or a better link)?  RJFJR (talk) 01:12, 11 February 2014 (UTC)
thread_title:  Iterative methods 

message: Plese, someone fix that  — Preceding unsigned comment added by 200.129.202.130 (talk) 19:30, 10 April 2014 (UTC)
thread_title:  Link to Java Applet leads is dangerous 

message: Substituted at 02:08, 5 May 2016 (UTC)
thread_title: Assessment comment

message: The article states that the bit complexity is exponential, based on cited paper [9], i.e., "On the worst-case complexity of integer Gaussian elimination" by Fang and Havas (pdf). After looking over this paper, I realized their Gauss elimination pseudo-code is not very similar to the one provided in the article. Instead of multiplying the pivot row for iteration k by A[i, k] / A[k, k] like in the article, they use something like A[i, k] DIV A[k, k], using modulo arithmetics. After subtracting this multiplied by row k from row i, the value A[i,k] does not become zero but A[i, k] MOD  A[k, k]. Next, they can change the pivot for column k, by searching for the row j with the lowest A[j,k]. This j can be i, because A[i, k] MOD  A[k, k]<A[k,k] (using the initial A[i, k]).  
However, I wonder what is the bit complexity for the pseudo-code from the article. I heard it is O(n^4), because the Gauss elimination process can encounter numbers stored on O(n) bits. Daniel.porumbel (talk) 18:50, 27 July 2017 (UTC)
replies: text: The reference may be a wrong one. The idea is that at each step (each pivot), rational fraction are added, and this generally double the size of the integers. Thus, near the end of the algorithm one has integers of exponential size. As far as I remember, Hilbert matrix is an explicit case where this exponential complexity is reached. D.Lazard (talk) 08:55, 28 July 2017 (UTC)

text: Thanks for the idea with the Hilbert matrix; indeed, it seems very plausible that this matrix leads to fractions of exponential size. I let you see if the article needs modification.Daniel.porumbel (talk) 17:13, 29 August 2017 (UTC)
thread_title:  On the exponential bit string complexity? 

message: It's easy to modify to handle arbitrary matrices. If everything in col k below row k is 0, try the col to the right and continue pivoting. I haven't found a pseudo-code reference for this but I'm confident it's correct in theory. If anyone can find a reference and update the page I'd be grateful. Here is an example:
        1 0 0 0
 row k  * * 1 0
        * * * 1
       col l^
Wqwt (talk) 18:48, 13 March 2018 (UTC)
replies: text: You are right. But it is not so easy, because, in the case singular matrices you must have two different variables, one for the pivot row and the other for the pivot column (here, both are called k). Moreover, the stopping test is when one of these two variables reaches its maximum, that is, a "for" loop cannot be used; a "while" or "repeat" loop must be used instead. D.Lazard (talk) 20:54, 13 March 2018 (UTC)

text: . I have fixed the code (and the surrounding text) D.Lazard (talk) 15:15, 14 March 2018 (UTC)
replies: text:  I appreciate the effort. I wish it could be cited authoritatively. (I wouldn't be surprised if it's in TAOCP) All I can find are papers that introduce more complex methods or slides from universities (potentially of interest: almost 700 slides? http://www.pitt.edu/~trenchea/MATH1080/MATH1080.pdf) Wqwt (talk) 05:21, 17 March 2018 (UTC)
thread_title:  Pseudocode only handles invertible matrices 

message: In the Generalizations sections, there is this quote: "Computing the rank of a tensor of order greater than 2 is NP-hard.[12] Therefore, there cannot be a polynomial time analog of Gaussian elimination for higher-order tensors (matrices are array representations of order-2 tensors). " The second sentence follows from the first only under the assumption P≠NP. Either that or the linked article proves something stronger than stated (i.e., proves that this problem is strictly harder than NP). The best ideals are radical (talk) 19:35, 5 November 2019 (UTC)
replies: text: . D.Lazard (talk) 20:54, 5 November 2019 (UTC)
thread_title:  Complexity of tensor rank 

message: I know multiplying one row with -1 and then adding it to another is the same as subtraction. The objective is to make things as clear as possible to the novice. Hope you have no objection to including an explanation in brackets.--Sahir 15:08, 6 January 2022 (UTC)
thread_title:  Clarity 

message: Pseudocode is very Python-ish and uses operator-soup Python-ish notation for ranges and loops, which makes it rather obscure. Would benefit from a more verbose and explicit version. 86.194.93.118 (talk) 21:46, 12 January 2023 (UTC)
thread_title:  Pseudocode is obscure 

message: Viewing this page in the iPad app with appearance set to dark or black causes the equations in the "Example of the algorithm" section to be white-on-white. SESteve (talk) 08:17, 23 March 2024 (UTC)
thread_title:  Equations are not legible in dark or black mode in app. 

message: The French Wikipedia has an entry for :fr:Élimination de Gauss-Jordan, which is linked to Gauss-Jordan elimination but not Gaussian elimination; however, the former redirects to an anchor within the latter, so AFAIK there is no way to discover the French entry without guessing that it is called Gauss-Jordan there.
I'm not sure how this should be solved, but maybe Gaussian elimination and Gauss-Jordan elimination should be unified in Wikidata, like they are unified in Wikipedia? — ncfavier 17:58, 17 April 2024 (UTC)
thread_title:  Linking to French Wikipedia