Nth root algorithm - Revision history

en>Loraof: See also

2014-10-19T18:09:50Z

See also

← Older revision		Revision as of 20:09, 19 October 2014
Line 1:		Line 1:
	~~In computing, '''row-major order''' and '''column-major order''' describe methods for storing multidimensional [[array (computing)\|arrays]] in linear [[RAM\|memory]]~~. Following standard [[matrix (mathematics)\|matrix]] notation, rows are numbered by the first index of a two-dimensional array and columns by the second index. Array layout is critical for correctly passing arrays between programs written in different languages. It is also important for performance when traversing an array because accessing array elements that ~~are contiguous in memory is usually faster than accessing elements which are not, due~~ to ~~[[Cache (computing)\|caching]]~~.		Hello! I am Rose. I am pleased that I can unify to the entire globe. I live in Italy, in the south region. I dream to go to the different nations, to obtain acquainted with appealing people.<br><br>Here is my web-site [http://parusa.kh.ua/index.php/component/datsogallery/?func=detail&catid=5&id=438 Fifa 15 coin generator]

	~~Row-major order is used in [[C (programming language)\|C]]/[[C++]], [[Mathematica]], [[PL/~~I~~]], [[Pascal (programming_language) \| Pascal]], [[Python (programming language)\|Python]], [[Speakeasy (computational environment) \| Speakeasy]], [[SAS]] and others. Column-major order is used~~ in ~~[[Fortran]], [[MATLAB]], [[GNU Octave]], [[R (programming language)\|R]], [[Julia (programming language) \| Julia]], [[Rasdaman]], and [[Scilab]].~~

	~~==Row-major order==~~
	~~In row-major storage~~, ~~a multidimensional array~~ in ~~linear memory is organized such that rows are stored one after~~ the ~~other~~. ~~It is the approach used by the [[C (programming language)\|C programming language]], among others.~~

	~~For example, consider this 2×3 array:~~

	~~:<math> \begin{bmatrix}~~
	~~1 & 2 & 3 \\~~
	~~4 & 5 & 6 \end{bmatrix}</math>~~

	~~An array declared in C as~~

	~~<source lang="c">int A[2][3] = { {1, 2, 3}, {4, 5, 6} };</source>~~

	~~is laid out [[contiguous#Computer science\|contiguously]] in linear memory as:~~

	~~1 2 3 4 5 6~~

	~~To traverse this array in the order in which it is laid out in memory, one would use the following nested loop:~~

	~~<source lang="c">~~
	~~for (row = 0; row < 2; row++)~~
	~~for (column = 0; column < 3; column++)~~
	~~printf("%d\n", A[row][column]);~~
	~~</source>~~

	~~The difference in offset from one column~~ to ~~the next is 1 and from one row~~ to the ~~next is 3 (zero-based indexing). The linear offset from the beginning of the array to any given element A[row][column] can then be computed as:~~
	~~<!-- The   code doesn't seem to be working~~, ~~so I have~~ to ~~put this on a separate line and center it -->~~
	~~<center>'''offset = row*NUMCOLS + column'''</center>~~
	~~where NUMCOLS is the number of columns in the array.~~

	~~The above formula only works when using the C convention of labeling the first element 0~~. ~~In other words, row 1, column 2 in matrix A, is represented as A[0][1].~~

	~~This technique generalizes to higher dimensions, so a 2×3×4 array looks like:~~

	<~~source lang="c"~~>~~int A[2][3][4] = {{{1,2,3,4}, {5,6,7,8}, {9,10,11,12}}, {{13,14,15,16}, {17,18,19,20}, {21,22,23,24}}};~~<~~/source~~>

	~~and the array~~ is ~~laid out in linear memory as:~~

	~~1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24~~

	~~==Column~~-~~major order==~~
	'''Column-major order''' is a similar method of flattening arrays onto linear memory, but the columns are listed in sequence. The scientific programming languages [[Fortran]] and [[Julia (programming language) \| Julia]], the matrix-oriented languages [[MATLAB]],<ref>MATLAB documentation, [http://~~www~~.~~mathworks~~.co.~~uk/help/matlab~~/~~matlab_external~~/~~matlab-data.html#f22019 MATLAB Data Storage] (retrieved from Mathworks.co.uk, January 2014).<~~/~~ref> [[GNU Octave\|Octave]] and [[Scilab]], the statistical languages [[S-Plus]]<ref name="WinBUGS" >{{harvtxt\|Spiegelhalter\|Thomas\|Best\|Lunn\|2003\|p~~=~~17}}: {{citation\|title=WinBUGS User~~ Manual\|edition=Version 1.4\|date=January 2003\|first=David\|last=Spiegelhalter\|authorlink=David Spiegelhalter\|first2=Andrew\|last2=Thomas\|first3=Nicky\|last3=Best\|first4=Dave\|last4=Lunn\|publisher=MRC Biostatistics Unit, Institute of Public Health\|location=Robinson Way, Cambridge CB2 2SR, UK\|url=http://www.mrc-bsu.cam.ac.uk/bugs\|ref=harv\|chapter=Formatting of data: S-Plus format\|id=[http://www.mrc-bsu.cam.ac.uk/bugs/winbugs/manual14.pdf PDF document]}}</ref> and [[R (programming language)\|R]],<ref>''An Introduction to R'', [http://cran.r-project.org/doc/manuals/R-intro.html#Arrays Section 5.1: Arrays] (retrieved March 2010).</ref> the shading languages [[GLSL]] and [[HLSL]] (but not [[Cg_(programming_language)\|Cg]]), and the array database [[Rasdaman]] use column-major ordering. The array

	~~:<math> \begin{bmatrix}~~
	~~1 & 2 & 3 \\~~
	~~4 &~~ 5 & ~~6 \end{bmatrix}</math>~~

	~~if stored [[Contiguous#Computer science\|contiguously]] in linear memory with column-major order looks like the following:~~

	~~1 4 2 5 3 6~~

	~~The memory offset could then be computed as:~~
	~~<!-- The   code doesn't seem to be working, so I have to put this on a separate line and center it -->~~
	~~<center>'''offset ~~=~~ row + column*NUMROWS'''</center>~~
	~~where NUMROWS represents the number of rows in the array—in this case, 2.~~

	Treating a row-major array as a column-major array is the same as [[transpose\|transposing]] it. Because performing a transpose requires data movement, and is quite difficult to do [[in-place matrix transposition\|in-place for non-square matrices]], such transpositions are rarely performed explicitly. For example, [[software libraries]] for [[linear algebra]], such as the [[BLAS]], typically provide options to specify that certain matrices are to be interpreted in transposed order to avoid the necessity of data movement.

	~~== Generalization to higher dimensions ==~~

	It is possible to generalize both of these concepts to arrays with greater than two dimensions. For higher-dimensional arrays, the ordering determines which dimensions of the array are more consecutive in memory. Any of the dimensions could be consecutive, just as a two-dimensional array could be listed column-first or row-first. The difference in offset between listings of that dimension would then be determined by a product of other dimensions. It is uncommon, however, to have any variation except ordering dimensions first to last or last to first. These two variations correspond to row-major and column-major, respectively.

	More explicitly, consider a ''d''-dimensional <math>N_1 \times N_2 \times \cdots \times N_d</math> array with dimensions ''N''<sub>''k''</sub> (''k''=1...''d''). A given element of this array is specified by a [[tuple]] <math>(n_1, n_2, \ldots, n_d)</math> of ''d'' (zero-based) indices <math>n_k \in [0,N_k - 1]</math>.

	~~In '''row-major order''', the ''last'' dimension is contiguous, so that the memory-offset of this element is given by:~~

	~~:<math>n_d + N_d \cdot (n_{d-1} + N_{d-1} \cdot (n_{d-2} + N_{d-2} \cdot (\cdots + N_2 n_1)\cdots)))~~
	~~= \sum_{k=1}^d \left( \prod_{\ell=k+1}^d N_\ell \right) n_k~~
	~~</math>~~

	~~In '''column-major order''', the ''first'' dimension is contiguous, so that the memory-offset of this element is given by:~~

	~~:<math>n_1 + N_1 \cdot (n_2 + N_2 \cdot (n_3 + N_3 \cdot (\cdots + N_{d-1} n_d)\cdots)))~~
	~~= \sum_{k=1}^d \left( \prod_{\ell=1}^{k-1} N_\ell \right) n_k~~
	~~</math>~~

	Note that the difference between row-major and column-major order is simply that the order of the dimensions is reversed. Equivalently, in row-major order the rightmost indices vary faster as one steps through consecutive memory locations, while in column-major order the leftmost indices vary faster.

	~~== See also ==~~
	* [[Matrix representation]]
	* [[Vectorization (mathematics)]], the equivalent of turning a matrix into the corresponding column-major vector.

	~~==References==~~
	~~<references/>~~
	* Donald E. Knuth, ''[[The Art of Computer Programming]] Volume 1: Fundamental Algorithms'', third edition, section 2.2.6 (Addison-Wesley: New York, 1997).

	~~[[Category:Arrays]~~]

en>Ninney: Reverted good faith edits by 194.63.239.231 (talk): Why? (TW)

2014-01-24T09:51:30Z

Reverted good faith edits by 194.63.239.231 (talk): Why? (TW)

← Older revision		Revision as of 11:51, 24 January 2014
Line 1:		Line 1:
	~~Myrtle Benny is how I~~'~~m called~~ and ~~I really feel comfortable when individuals use~~ the ~~full title~~. ~~Puerto Rico~~ is ~~exactly where he's~~ usually ~~been living but she needs~~ to ~~transfer because of her family~~. He is ~~truly fond of performing ceramics but he~~ is ~~struggling~~ to ~~find time for it~~. ~~For years he~~'~~s been~~ working as a ~~receptionist~~.<br><br>~~My web~~-~~site~~ :: [~~https~~://~~Www~~.~~Tumblr~~.~~com~~/~~blog~~/~~mmattchuu https~~://~~Www~~.~~Tumblr~~.~~com~~/~~blog~~/~~mmattchuu~~]		In computing, '''row-major order''' and '''column-major order''' describe methods for storing multidimensional [[array (computing)\|arrays]] in linear [[RAM\|memory]]. Following standard [[matrix (mathematics)\|matrix]] notation, rows are numbered by the first index of a two-dimensional array and columns by the second index. Array layout is critical for correctly passing arrays between programs written in different languages. It is also important for performance when traversing an array because accessing array elements that are contiguous in memory is usually faster than accessing elements which are not, due to [[Cache (computing)\|caching]].

			Row-major order is used in [[C (programming language)\|C]]/[[C++]], [[Mathematica]], [[PL/I]], [[Pascal (programming_language) \| Pascal]], [[Python (programming language)\|Python]], [[Speakeasy (computational environment) \| Speakeasy]], [[SAS]] and others. Column-major order is used in [[Fortran]], [[MATLAB]], [[GNU Octave]], [[R (programming language)\|R]], [[Julia (programming language) \| Julia]], [[Rasdaman]], and [[Scilab]].

			==Row-major order==
			In row-major storage, a multidimensional array in linear memory is organized such that rows are stored one after the other. It is the approach used by the [[C (programming language)\|C programming language]], among others.

			For example, consider this 2×3 array:

			:<math> \begin{bmatrix}
			1 & 2 & 3 \\
			4 & 5 & 6 \end{bmatrix}</math>

			An array declared in C as

			<source lang="c">int A[2][3] = { {1, 2, 3}, {4, 5, 6} };</source>

			is laid out [[contiguous#Computer science\|contiguously]] in linear memory as:

			1 2 3 4 5 6

			To traverse this array in the order in which it is laid out in memory, one would use the following nested loop:

			<source lang="c">
			for (row = 0; row < 2; row++)
			for (column = 0; column < 3; column++)
			printf("%d\n", A[row][column]);
			</source>

			The difference in offset from one column to the next is 1 and from one row to the next is 3 (zero-based indexing). The linear offset from the beginning of the array to any given element A[row][column] can then be computed as:
			<!-- The   code doesn't seem to be working, so I have to put this on a separate line and center it -->
			<center>'''offset = row*NUMCOLS + column'''</center>
			where NUMCOLS is the number of columns in the array.

			The above formula only works when using the C convention of labeling the first element 0. In other words, row 1, column 2 in matrix A, is represented as A[0][1].

			This technique generalizes to higher dimensions, so a 2×3×4 array looks like:

			<source lang="c">int A[2][3][4] = {{{1,2,3,4}, {5,6,7,8}, {9,10,11,12}}, {{13,14,15,16}, {17,18,19,20}, {21,22,23,24}}};</source>

			and the array is laid out in linear memory as:

			1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

			==Column-major order==
			'''Column-major order''' is a similar method of flattening arrays onto linear memory, but the columns are listed in sequence. The scientific programming languages [[Fortran]] and [[Julia (programming language) \| Julia]], the matrix-oriented languages [[MATLAB]],<ref>MATLAB documentation, [http://www.mathworks.co.uk/help/matlab/matlab_external/matlab-data.html#f22019 MATLAB Data Storage] (retrieved from Mathworks.co.uk, January 2014).</ref> [[GNU Octave\|Octave]] and [[Scilab]], the statistical languages [[S-Plus]]<ref name="WinBUGS" >{{harvtxt\|Spiegelhalter\|Thomas\|Best\|Lunn\|2003\|p=17}}: {{citation\|title=WinBUGS User Manual\|edition=Version 1.4\|date=January 2003\|first=David\|last=Spiegelhalter\|authorlink=David Spiegelhalter\|first2=Andrew\|last2=Thomas\|first3=Nicky\|last3=Best\|first4=Dave\|last4=Lunn\|publisher=MRC Biostatistics Unit, Institute of Public Health\|location=Robinson Way, Cambridge CB2 2SR, UK\|url=http://www.mrc-bsu.cam.ac.uk/bugs\|ref=harv\|chapter=Formatting of data: S-Plus format\|id=[http://www.mrc-bsu.cam.ac.uk/bugs/winbugs/manual14.pdf PDF document]}}</ref> and [[R (programming language)\|R]],<ref>''An Introduction to R'', [http://cran.r-project.org/doc/manuals/R-intro.html#Arrays Section 5.1: Arrays] (retrieved March 2010).</ref> the shading languages [[GLSL]] and [[HLSL]] (but not [[Cg_(programming_language)\|Cg]]), and the array database [[Rasdaman]] use column-major ordering. The array

			:<math> \begin{bmatrix}
			1 & 2 & 3 \\
			4 & 5 & 6 \end{bmatrix}</math>

			if stored [[Contiguous#Computer science\|contiguously]] in linear memory with column-major order looks like the following:

			1 4 2 5 3 6

			The memory offset could then be computed as:
			<!-- The   code doesn't seem to be working, so I have to put this on a separate line and center it -->
			<center>'''offset = row + column*NUMROWS'''</center>
			where NUMROWS represents the number of rows in the array—in this case, 2.

			Treating a row-major array as a column-major array is the same as [[transpose\|transposing]] it. Because performing a transpose requires data movement, and is quite difficult to do [[in-place matrix transposition\|in-place for non-square matrices]], such transpositions are rarely performed explicitly. For example, [[software libraries]] for [[linear algebra]], such as the [[BLAS]], typically provide options to specify that certain matrices are to be interpreted in transposed order to avoid the necessity of data movement.

			== Generalization to higher dimensions ==

			It is possible to generalize both of these concepts to arrays with greater than two dimensions. For higher-dimensional arrays, the ordering determines which dimensions of the array are more consecutive in memory. Any of the dimensions could be consecutive, just as a two-dimensional array could be listed column-first or row-first. The difference in offset between listings of that dimension would then be determined by a product of other dimensions. It is uncommon, however, to have any variation except ordering dimensions first to last or last to first. These two variations correspond to row-major and column-major, respectively.

			More explicitly, consider a ''d''-dimensional <math>N_1 \times N_2 \times \cdots \times N_d</math> array with dimensions ''N''<sub>''k''</sub> (''k''=1...''d''). A given element of this array is specified by a [[tuple]] <math>(n_1, n_2, \ldots, n_d)</math> of ''d'' (zero-based) indices <math>n_k \in [0,N_k - 1]</math>.

			In '''row-major order''', the ''last'' dimension is contiguous, so that the memory-offset of this element is given by:

			:<math>n_d + N_d \cdot (n_{d-1} + N_{d-1} \cdot (n_{d-2} + N_{d-2} \cdot (\cdots + N_2 n_1)\cdots)))
			= \sum_{k=1}^d \left( \prod_{\ell=k+1}^d N_\ell \right) n_k
			</math>

			In '''column-major order''', the ''first'' dimension is contiguous, so that the memory-offset of this element is given by:

			:<math>n_1 + N_1 \cdot (n_2 + N_2 \cdot (n_3 + N_3 \cdot (\cdots + N_{d-1} n_d)\cdots)))
			= \sum_{k=1}^d \left( \prod_{\ell=1}^{k-1} N_\ell \right) n_k
			</math>

			Note that the difference between row-major and column-major order is simply that the order of the dimensions is reversed. Equivalently, in row-major order the rightmost indices vary faster as one steps through consecutive memory locations, while in column-major order the leftmost indices vary faster.

			== See also ==
			* [[Matrix representation]]
			* [[Vectorization (mathematics)]], the equivalent of turning a matrix into the corresponding column-major vector.

			==References==
			<references/>
			* Donald E. Knuth, ''[[The Art of Computer Programming]] Volume 1: Fundamental Algorithms'', third edition, section 2.2.6 (Addison-Wesley: New York, 1997).

			[[Category:Arrays]]

en>Helpful Pixie Bot: ISBNs (Build KE)

2012-05-09T21:50:56Z

ISBNs (Build KE)

New page

Myrtle Benny is how I'm called and I really feel comfortable when individuals use the full title. Puerto Rico is exactly where he's usually been living but she needs to transfer because of her family. He is truly fond of performing ceramics but he is struggling to find time for it. For years he's been working as a receptionist.<br><br>My web-site :: [https://Www.Tumblr.com/blog/mmattchuu https://Www.Tumblr.com/blog/mmattchuu]