Method and apparatus for finding induction variables for use in compiling computer instructions

Claim 1

A method for determining induction variables comprising the steps of: accessing a file stored in computer memory, the file containing several program statements wherein a plurality of the program statements are to be executed in a looping execution flow by a central processing unit (CPU); parsing the file to produce a representation of the program statements contained in the file, the representation being stored in computer memory; identifying, from the representation in computer memory, the plurality of program statements which is to be executed in a looping execution flow; identifying a set of potential induction variables within the plurality of the program statements within the looping execution flow; reducing the set of potential induction variables to a reduced set of potential induction variables wherein a potential induction variable in the reduced set of potential induction variables has a value at the end of any execution of the loop which is representable as a sum of constant integer coefficients multiplied by the values of other potential induction variables in the reduced set of potential induction variables at the start of that execution of the loop; creating a transfer matrix A in computer memory which represents the relationships of the values of the potential induction variables in the reduced set of potential induction variables at the end of an execution of the loop to the values of the potential induction variables in the reduced set of potential induction variables at the start of that execution; transforming the transfer matrix A from computer memory to a transformed matrix A' in computer memory wherein the transformed matrix A' is easier to analyze for induction variables than the transfer matrix A, the transforming being performed by using an integer unimodular transformation, the reduced set of potential induction variables being transformed to a set of potential transformed induction variables by the same integer unimodular transformation; analyzing the matrix A' to find transformed induction variables and transformed non-induction variables wherein the value of a transformed induction variable at the beginning of the Nth execution of the loop is a linear combination of a predetermined set of functions of N and wherein each non-induction variable defines an undetermined independent function of N; and applying the inverse of the transformation to the sets of transformed induction variables and transformed non-induction variables thereby expressing each of the variables in the reduced set of potential induction variables as a linear combination of the predetermined functions of N and the undetermined independent functions of N.

Claim 2

A method for determining induction variables comprising the steps of: accessing a file stored in computer memory, the file containing several program statements wherein a plurality of the program statements are to be executed in a looping execution flow by a central processing unit (CPU); parsing the file to produce a representation of the program statements contained in the file, the representation being stored in computer memory; identifying, from the representation in computer memory, the plurality of program statements which is to be executed in a looping execution flow; identifying a set of potential induction variables within the plurality of the program statements within the looping execution flow; reducing the set of potential induction variables to a reduced set of potential induction variables wherein a potential induction variable in the reduced set of potential induction variables has a value at the end of any execution of the loop which is representable as a sum of constant integer coefficients multiplied by the values of other potential induction variables in the reduced set of potential induction variables at the start of that execution of the loop; creating a transfer matrix A in computer memory which represents the relationships of the values of the potential induction variables in the reduced set of potential induction variables at the end of an execution of the loop to the values of the potential induction variables in the reduced set of potential induction variables at the start of that execution; transforming the transfer matrix A from computer memory to a transformed matrix A' in computer memory wherein the transformed matrix A' is easier to analyze for induction variables than the transfer matrix A, the transforming being performed by using an integer unimodular transformation, the reduced set of potential induction variables being transformed to a set of potential transformed induction variables by the same integer unimodular transformation; analyzing the matrix A' to find transformed induction variables and transformed non-induction variables wherein the value of a transformed induction variable at the beginning of the Nth execution of the loop is a linear combination of a predetermined set of functions of N and wherein each non-induction variable defines an undetermined independent function of N; and applying the inverse of the transformation to the sets of transformed induction variables and transformed non-induction variables thereby expressing each of the variables in the reduced set of potential induction variables as a linear combination of the predetermined functions of N and the undetermined independent functions of N.

Claim 12

A method for processing induction variables, the method comprising the steps of: (a) providing a user source code in computer memory; (b) parsing the user source code via means for parsing which is stored in computer memory to find a loop in the user source code, the loop being a portion of the user source code which selectively executes several times in sequence via a central processing unit (CPU) depending upon evaluation of an loop termination condition, the loop having a beginning and an end; (c) scanning the loop to find assignments to a set of N variables S i within the loop which are of the form: S.sub.i =ΣC.sub.ij S.sub.j +d.sub.i ; (d) constructing in computer memory a transfer matrix A and a vector b relating the values of the variables S i at the end of loop to the values of the variables S i at the beginning of the loop, the matrix A having a size which is N×N wherein: S.sub.i (end)=ΣA.sub.ij S.sub.j (beginning)+a.sub.i ; (e) initializing a working transfer matrix A 0 to A; (f) initializing p to 0 and m to N; (g) initializing a matrix U 0 having an inverse matrix U 0 -1 to an identity matrix; (h) selecting an eigenvalue λ from an eigenvalue list stored in computer memory; (i) finding a number e of eigenvectors corresponding to the eigenvalue λ in an m×m submatrix of the matrix A p , if no eigenvectors are found then continue with step (k); (j) decrementing m by e, transforming A p to A p+1 to form a new transfer matrix A p+1 , transforming U p to form a new unimodular matrix U p+1 , transforming U p -1 to a new inverse unimodular matrix U p+1 -1 , and incrementing p by one and then repeating step (i); (k) repeating steps (h) through (k) until all eigenvalues λ in the eigenvalue list stored in computer memory have been selected in step (h); (l) multiplying the vector a by the U p -1 to form a vector a p ; (m) analyzing the matrix A p and the vector a p to find N-m transformed induction variables and m transformed non-induction variables; and (n) transforming the N-m transformed induction variables and m transformed non-induction variables using the matrix U p to determine induction properties of the variables S i .

Claim 13

A method for processing induction variables, the method comprising the steps of: (a) providing a user source code in computer memory; (b) parsing the user source code via means for parsing which is stored in computer memory to find a loop in the user source code, the loop being a portion of the user source code which selectively executes several times in sequence via a central processing unit (CPU) depending upon evaluation of an loop termination condition, the loop having a beginning and an end; (c) scanning the loop to find assignments to a set of N variables S i within the loop which are of the form: S.sub.i =ΣC.sub.ij S.sub.j +d.sub.i ; (d) constructing in computer memory a transfer matrix A and a vector b relating the values of the variables S i at the end of loop to the values of the variables S i at the beginning of the loop, the matrix A having a size which is N×N wherein: S.sub.i (end)=ΣA.sub.ij S.sub.j (beginning)+a.sub.i ; (e) initializing a working transfer matrix A 0 to A; (f) initializing p to 0 and m to N; (g) initializing a matrix U 0 having an inverse matrix U 0 -1 to an identity matrix; (h) selecting an eigenvalue λ from an eigenvalue list stored in computer memory; (i) finding a number e of eigenvectors corresponding to the eigenvalue λ in an m×m submatrix of the matrix A p , if no eigenvectors are found then continue with step (k); (j) decrementing m by e, transforming A p to A p+1 to form a new transfer matrix A p+1 , transforming U p to form a new unimodular matrix U p+1 , transforming U p -1 to a new inverse unimodular matrix U p+1 -1 , and incrementing p by one and then repeating step (i); (k) repeating steps (h) through (k) until all eigenvalues λ in the eigenvalue list stored in computer memory have been selected in step (h); (l) multiplying the vector a by the U p -1 to form a vector a p ; (m) analyzing the matrix A p and the vector a p to find N-m transformed induction variables and m transformed non-induction variables; and (n) transforming the N-m transformed induction variables and m transformed non-induction variables using the matrix U p to determine induction properties of the variables S i .

Claim 24

A method for transforming a first matrix A to a second matrix A' to expose an eigenvalue, the method comprising the steps of: providing the first matrix A having a diagonal stored on a computer memory and accessible by a central processing unit (CPU), the first matrix A being an integer matrix having a size of N×N, an m×m submatrix in the first matrix A containing integer values where m≦N, the last N-m rows of the first matrix A having zero values to the left of the diagonal of the first matrix A, the matrix A being stored in computer memory; transforming the first matrix A to the second matrix A' in the computer memory by executing computer instructions via the CPU wherein the second matrix A' is an integer matrix having a size of N×N, an upper left m'×m' submatrix in the second matrix A' containing integer values wherein m'<m, the last N-m rows of the matrix A' being the same as the last N-m rows of the matrix A, the rows m'+1 to m of the second matrix A' having zero values to the left of the diagonal of the second matrix A' wherein a diagonal element in each of these m'-m rows contains the eigenvalue; and using the eigenvalue to compile computer code located in computer memory, wherein the computer code is compiled into an executable form which is then manufactured onto computer-readable medium.

Claim 25

A method for transforming a first matrix A to a second matrix A' to expose an eigenvalue, the method comprising the steps of: providing the first matrix A having a diagonal stored on a computer memory and accessible by a central processing unit (CPU), the first matrix A being an integer matrix having a size of N×N, an m×m submatrix in the first matrix A containing integer values where m≦N, the last N-m rows of the first matrix A having zero values to the left of the diagonal of the first matrix A, the matrix A being stored in computer memory; transforming the first matrix A to the second matrix A' in the computer memory by executing computer instructions via the CPU wherein the second matrix A' is an integer matrix having a size of N×N, an upper left m'×m' submatrix in the second matrix A' containing integer values wherein m'<m, the last N-m rows of the matrix A' being the same as the last N-m rows of the matrix A, the rows m'+1 to m of the second matrix A' having zero values to the left of the diagonal of the second matrix A' wherein a diagonal element in each of these m'-m rows contains the eigenvalue; and using the eigenvalue to compile computer code located in computer memory, wherein the computer code is compiled into an executable form which is then manufactured onto computer-readable medium.

Claim 28

A method for transforming a first matrix A to a second matrix A' to expose an eigenvalue, the method comprising the steps of: providing the first matrix A having a diagonal stored on a computer memory and accessible by a central processing unit (CPU), the first matrix A being an integer matrix having a size of N×N, an m×m submatrix in the first matrix A containing integer values wherein m≦N, the last N-m columns of the first matrix A having zero values to the right of the diagonal of the first matrix A, the matrix A being stored in computer memory; transforming the first matrix A to the second matrix A' in the computer memory by executing computer instructions via the CPU wherein the second matrix A' is an integer matrix having a size of N×N, an upper left m'×m' submatrix in the second matrix A' containing integer values wherein m'<m, the last N-m columns of the matrix A' being the same as the last N-m columns of the matrix A, the columns m'+1 to m of the second matrix A' having zero values to the right of the diagonal of the second matrix A' wherein the diagonal in each of these m'-m columns contains the eigenvalue; and using the eigenvalue to compile computer code located in computer memory, wherein the computer code is compiled into an executable form which is then manufactured onto computer-readable medium.

Claim 29

A method for transforming a first matrix A to a second matrix A' to expose an eigenvalue, the method comprising the steps of: providing the first matrix A having a diagonal stored on a computer memory and accessible by a central processing unit (CPU), the first matrix A being an integer matrix having a size of N×N, an m×m submatrix in the first matrix A containing integer values wherein m≦N, the last N-m columns of the first matrix A having zero values to the right of the diagonal of the first matrix A, the matrix A being stored in computer memory; transforming the first matrix A to the second matrix A' in the computer memory by executing computer instructions via the CPU wherein the second matrix A' is an integer matrix having a size of N×N, an upper left m'×m' submatrix in the second matrix A' containing integer values wherein m'<m, the last N-m columns of the matrix A' being the same as the last N-m columns of the matrix A, the columns m'+1 to m of the second matrix A' having zero values to the right of the diagonal of the second matrix A' wherein the diagonal in each of these m'-m columns contains the eigenvalue; and using the eigenvalue to compile computer code located in computer memory, wherein the computer code is compiled into an executable form which is then manufactured onto computer-readable medium.

Claim 32

A method for solving an induction variable problem associated with a matrix A, the method comprising the steps of: (a) providing the matrix A and an integer vector a in computer memory, the matrix A being an integer matrix having a size of N×N, an upper left m×m submatrix in the matrix A containing integer values, the last N-m rows of the matrix A having zero values to the left of the diagonal of the matrix A, the matrix A; (b) providing a set of variables y i .sup.(t) in computer memory such that: y.sub.i.sup.(t+1) =ΣA.sub.ij y.sub.j.sup.(t) +ai; where t is a loop iteration count value; (c) initializing p to N; (d) selecting a method for finding induction variables depending upon the value of A pp which is a diagonal value in the matrix A; (e) using the method and zero or more previously determined induction variables to determine y p .sup.(t) as a linear combination of a set of predetermined functions of t; (f) decrementing p by one; (g) performing steps (d) through (g) while p>m; (h) assigning for any p≦m an independent undetermined function of t to y p .sup.(t) ; and (i) using the steps (a) through (h) to compile computer code to executable code and storing the executable code onto computer readable medium.

Claim 33

A method for solving an induction variable problem associated with a matrix A, the method comprising the steps of: (a) providing the matrix A and an integer vector a in computer memory, the matrix A being an integer matrix having a size of N×N, an upper left m×m submatrix in the matrix A containing integer values, the last N-m rows of the matrix A having zero values to the left of the diagonal of the matrix A, the matrix A; (b) providing a set of variables y i .sup.(t) in computer memory such that: y.sub.i.sup.(t+1) =ΣA.sub.ij y.sub.j.sup.(t) +ai; where t is a loop iteration count value; (c) initializing p to N; (d) selecting a method for finding induction variables depending upon the value of A pp which is a diagonal value in the matrix A; (e) using the method and zero or more previously determined induction variables to determine y p .sup.(t) as a linear combination of a set of predetermined functions of t; (f) decrementing p by one; (g) performing steps (d) through (g) while p>m; (h) assigning for any p≦m an independent undetermined function of t to y p .sup.(t) ; and (i) using the steps (a) through (h) to compile computer code to executable code and storing the executable code onto computer readable medium.

Claim 34

A method for solving an induction variable problem associated with a matrix A, the method comprising the steps of: (a) providing the matrix A and an integer vector a in computer memory, the matrix A being an integer matrix having a size of N×N, an upper left m×m submatrix in the matrix A containing integer values, the last N-m columns of the matrix A having zero values to the left of the diagonal of the matrix A, the matrix A; (b) providing a set of variables y i .sup.(t) in computer memory such that: y.sub.i.sup.(t+1) =ΣA.sub.ij y.sub.j.sup.(t) +ai; where t is a loop iteration count value; (c) initializing p to N; (d) selecting a method for finding induction variables depending upon the value of A pp which is a diagonal value in the matrix A; (e) using the method and zero or more previously determined induction variables to determine y p .sup.(t) as a linear combination of a set of predetermined functions of t; (f) decrementing p by one; (g) performing steps (d) through (g) while p>m; (h) assigning for any p≦m an independent undetermined function of t to y p .sup.(t) ; and (i) using the steps (a) through (h) to compile computer code to executable code and storing the executable code onto computer readable medium.

Claim 35

A method for solving an induction variable problem associated with a matrix A, the method comprising the steps of: (a) providing the matrix A and an integer vector a in computer memory, the matrix A being an integer matrix having a size of N×N, an upper left m×m submatrix in the matrix A containing integer values, the last N-m columns of the matrix A having zero values to the left of the diagonal of the matrix A, the matrix A; (b) providing a set of variables y i .sup.(t) in computer memory such that: y.sub.i.sup.(t+1) =ΣA.sub.ij y.sub.j.sup.(t) +ai; where t is a loop iteration count value; (c) initializing p to N; (d) selecting a method for finding induction variables depending upon the value of A pp which is a diagonal value in the matrix A; (e) using the method and zero or more previously determined induction variables to determine y p .sup.(t) as a linear combination of a set of predetermined functions of t; (f) decrementing p by one; (g) performing steps (d) through (g) while p>m; (h) assigning for any p≦m an independent undetermined function of t to y p .sup.(t) ; and (i) using the steps (a) through (h) to compile computer code to executable code and storing the executable code onto computer readable medium.

Claim 36

A method for determining induction variables comprising the steps of: accessing a file stored in computer memory, the file containing several program statements wherein a plurality of the program statements are to be executed in a looping execution flow; parsing the file to produce a representation of the program statements contained in the file; identifying, from the representation, the plurality of program statements which is to be executed in a looping execution flow; identifying a set of potential induction variables within the plurality of the program statements within the looping execution flow; reducing the set of potential induction variables to a reduced set of potential induction variables wherein the number of potential induction variables in the reduced set is ≦ the number of potential induction variables in the set of potential induction variables; creating a transfer matrix A in computer memory which represents the relationships of the values of the potential induction variables in the reduced set of potential induction variables at the end of an execution of the loop to the values of the potential induction variables in the reduced set of potential induction variables at the start of that execution; transforming the transfer matrix A to a transformed matrix A' wherein the transformed matrix A' is easier to analyze for induction variables than the transfer matrix A, the transforming being performed by using a unimodular integer transformation; analyzing the matrix A' to find transformed induction variables and transformed non-induction variables wherein the value of a transformed induction variable at the beginning of the Nth execution of the loop is a linear combination of a predetermined set of functions of N; and applying the inverse of the unimodular transformation to the transformed induction variables and transformed non-induction variables thereby expressing a plurality of the variables in the reduced set of potential induction variables as a linear combination of the predetermined functions of N.

Claim 37

A method for determining induction variables comprising the steps of: accessing a file stored in computer memory, the file containing several program statements wherein a plurality of the program statements are to be executed in a looping execution flow; parsing the file to produce a representation of the program statements contained in the file; identifying, from the representation, the plurality of program statements which is to be executed in a looping execution flow; identifying a set of potential induction variables within the plurality of the program statements within the looping execution flow; reducing the set of potential induction variables to a reduced set of potential induction variables wherein the number of potential induction variables in the reduced set is ≦ the number of potential induction variables in the set of potential induction variables; creating a transfer matrix A in computer memory which represents the relationships of the values of the potential induction variables in the reduced set of potential induction variables at the end of an execution of the loop to the values of the potential induction variables in the reduced set of potential induction variables at the start of that execution; transforming the transfer matrix A to a transformed matrix A' wherein the transformed matrix A' is easier to analyze for induction variables than the transfer matrix A, the transforming being performed by using a unimodular integer transformation; analyzing the matrix A' to find transformed induction variables and transformed non-induction variables wherein the value of a transformed induction variable at the beginning of the Nth execution of the loop is a linear combination of a predetermined set of functions of N; and applying the inverse of the unimodular transformation to the transformed induction variables and transformed non-induction variables thereby expressing a plurality of the variables in the reduced set of potential induction variables as a linear combination of the predetermined functions of N.

Claim 38

A method for processing induction variables, the method comprising the steps of: (a) providing a user source code in computer memory; (b) parsing the user source code via means for parsing which is stored in computer memory to find a loop in the user source code, the loop being a portion of the user source code which selectively executes several times in sequence, the loop having a beginning and an end; (c) scanning the loop to find assignments to a set of N variables S i within the loop; (d) constructing in computer memory a transfer matrix A and a vector a relating the values of the variables S i at the end of loop to the values of the variables S i at the beginning of the loop, the matrix A having a size which is N×N; (e) initializing a working transfer matrix A 0 to A; (f) initializing m to N and p to zero; (g) initializing a matrix U 0 having an inverse matrix U 0 -1 to a predetermined configuration; (h) selecting an eigenvalue λ from an eigenvalue list which is stored in computer memory; (i) finding a number e of eigenvectors corresponding to the eigenvalue λ in an m×m submatrix of the matrix A p , if no eigenvectors are found then continue with step (k); (j) decrementing m by e, transforming A p to A p+1 to form a new transfer matrix A p+1 , transforming U p to form a new unimodular matrix U p+1 , transforming U p -1 to a new inverse unimodular matrix U p+1 -1 , and incrementing p by one and then repeating step (i); (k) repeating steps (h) through (k) until all eigenvalues λ in the eigenvalue list stored in computer memory have been selected in step (h); (l) multiplying the vector a by the U p -1 to form a vector a p ; (m) analyzing the matrix A p and the vector a p to find N-m transformed induction variables and m transformed non-induction variables; (n) transforming the N-m transformed induction variables and m transformed non-induction variables using the matrix U p to determine induction properties of the variables S i ; and (o) using the induction properties to compile the user source code into executable code stored in computer memory and mass manufacturing a plurality of computer readable means containing the executable code.

Claim 39

A method for processing induction variables, the method comprising the steps of: (a) providing a user source code in computer memory; (b) parsing the user source code via means for parsing which is stored in computer memory to find a loop in the user source code, the loop being a portion of the user source code which selectively executes several times in sequence, the loop having a beginning and an end; (c) scanning the loop to find assignments to a set of N variables S i within the loop; (d) constructing in computer memory a transfer matrix A and a vector a relating the values of the variables S i at the end of loop to the values of the variables S i at the beginning of the loop, the matrix A having a size which is N×N; (e) initializing a working transfer matrix A 0 to A; (f) initializing m to N and p to zero; (g) initializing a matrix U 0 having an inverse matrix U 0 -1 to a predetermined configuration; (h) selecting an eigenvalue λ from an eigenvalue list which is stored in computer memory; (i) finding a number e of eigenvectors corresponding to the eigenvalue λ in an m×m submatrix of the matrix A p , if no eigenvectors are found then continue with step (k); (j) decrementing m by e, transforming A p to A p+1 to form a new transfer matrix A p+1 , transforming U p to form a new unimodular matrix U p+1 , transforming U p -1 to a new inverse unimodular matrix U p+1 -1 , and incrementing p by one and then repeating step (i); (k) repeating steps (h) through (k) until all eigenvalues λ in the eigenvalue list stored in computer memory have been selected in step (h); (l) multiplying the vector a by the U p -1 to form a vector a p ; (m) analyzing the matrix A p and the vector a p to find N-m transformed induction variables and m transformed non-induction variables; (n) transforming the N-m transformed induction variables and m transformed non-induction variables using the matrix U p to determine induction properties of the variables S i ; and (o) using the induction properties to compile the user source code into executable code stored in computer memory and mass manufacturing a plurality of computer readable means containing the executable code.

Claim 42

A method for determining induction variables within a plurality of computer instructions, the method comprising the steps of: accessing computer code from computer memory; identifying the plurality of computer instructions in the computer code, the plurality of instructions being executed in a loop and containing at least one assignment statement which assigns a numerical value to at least one variable within the loop; representing the at least one assignment statement in a transfer matrix format in computer memory wherein the values of the at least one variables at the end of an execution of the loop are expressed in terms of the values of the at least one variables at the beginning of the execution of the loop; performing multiplication operations on the transfer matrix by multiplying the transfer matrix with an integer unimodular matrix stored in computer memory to determine if the at least one assignment statement includes any induction variables; and analyzing the induction variables to allow for compilation of the computer code to executable code which can be executed by a data processing system comprising a central processing unit (CPU).

Claim 43

A method for determining induction variables within a plurality of computer instructions, the method comprising the steps of: accessing computer code from computer memory; identifying the plurality of computer instructions in the computer code, the plurality of instructions being executed in a loop and containing at least one assignment statement which assigns a numerical value to at least one variable within the loop; representing the at least one assignment statement in a transfer matrix format in computer memory wherein the values of the at least one variables at the end of an execution of the loop are expressed in terms of the values of the at least one variables at the beginning of the execution of the loop; performing multiplication operations on the transfer matrix by multiplying the transfer matrix with an integer unimodular matrix stored in computer memory to determine if the at least one assignment statement includes any induction variables; and analyzing the induction variables to allow for compilation of the computer code to executable code which can be executed by a data processing system comprising a central processing unit (CPU).

Claim 45

A method for determining induction variables within a plurality of computer instructions, the method comprising the steps of: accessing computer code from computer memory; identifying the plurality of computer instructions in the computer code, the plurality of instructions being executed in a loop and containing at least one assignment statement which assigns a numerical value to at least one variable within the loop; representing the at least one assignment statement in a matrix format in computer memory and analyzing the matrix by performing eigenvalue analysis on linear combinations of the at least one variable to determine if any linear combination of the at least one variable are induction variables; and analyzing the any linear combination of the at least one variable are induction variables to compile the computer code to executable code which can be executed by a data processing system comprising a central processing unit (CPU).

Claim 46

A method for determining induction variables within a plurality of computer instructions, the method comprising the steps of: accessing computer code from computer memory; identifying the plurality of computer instructions in the computer code, the plurality of instructions being executed in a loop and containing at least one assignment statement which assigns a numerical value to at least one variable within the loop; representing the at least one assignment statement in a matrix format in computer memory and analyzing the matrix by performing eigenvalue analysis on linear combinations of the at least one variable to determine if any linear combination of the at least one variable are induction variables; and analyzing the any linear combination of the at least one variable are induction variables to compile the computer code to executable code which can be executed by a data processing system comprising a central processing unit (CPU).

Claim 47

A method for determining induction variables within a plurality of computer instructions, the method comprising the steps of: accessing computer code from computer memory; identifying the plurality of computer instructions in the computer code, the plurality of instructions being executed in a loop and containing at least one assignment statement which assigns a numerical value to at least one variable within the loop; accessing a plurality of eigenvalues stored by a user in computer memory wherein the eigenvalues in the plurality of eigenvalues are a plurality of values which are within the range of -∞ and +∞; representing the at least one assignment statement in a matrix format in computer memory and analyzing the matrix by performing eigenvalue analysis on linear combinations of the at least one variable by using the plurality of eigenvalues to determine induction variable properties from the at least one variable; and analyzing the induction variable properties to compile the computer code to executable code which can be executed by a data processing system comprising a central processing unit (CPU).

Claim 48

A method for determining induction variables within a plurality of computer instructions, the method comprising the steps of: accessing computer code from computer memory; identifying the plurality of computer instructions in the computer code, the plurality of instructions being executed in a loop and containing at least one assignment statement which assigns a numerical value to at least one variable within the loop; accessing a plurality of eigenvalues stored by a user in computer memory wherein the eigenvalues in the plurality of eigenvalues are a plurality of values which are within the range of -∞ and +∞; representing the at least one assignment statement in a matrix format in computer memory and analyzing the matrix by performing eigenvalue analysis on linear combinations of the at least one variable by using the plurality of eigenvalues to determine induction variable properties from the at least one variable; and analyzing the induction variable properties to compile the computer code to executable code which can be executed by a data processing system comprising a central processing unit (CPU).