Reading Text File in Matlab as Matrix
MATLAB
Contents:
- Introduction
- MATLAB Versions
- Matrices every bit Fundamental Objects
- Matrix Operations
- Assignment Statements
- Case Sensitivity
- Firsthand and Deferred Execution
- Showing Values
- Initializing Matrices
- Making Matrices from Matrices
- Using Portions of Matrices
- Text Strings
- Matrix and Array Operations
- Using Functions
- Logical and Relational Operations on Matrices
- Sorting Matrices
- Controlling Execution Flow
- Writing Functions
- Comments and Assist
- Information Input and Output
- MATLAB Office Library
Introduction
MATLAB stands for Matrix Laboratory. Co-ordinate to The Mathworks, its producer, it is a "technical calculating environment". Nosotros will take the more mundane view that information technology is a programming linguistic communication.
This section covers much of the language, but by no means all. We aspire to at the least to promote a reasonable proficiency in reading procedures that nosotros will write in the language but choose to address this material to those who wish to use our procedures and write their ain programs.
MATLAB Versions
Versions of MATLAB are bachelor for almost all major computing platforms. Our material was produced and tested on the version designed for the Microsoft Windows environment. The vast majority of information technology should work with other versions, but no guarantees tin can be offered.
Of item interest are the Pupil Versions of MATLAB. Prices are by and large below $100. These systems include most of the features of the language, merely no matrix can have more 8,192 elements, with either the number of rows or columns limited to 32. For many applications this proves to be of no result. At the very to the lowest degree, one tin can use a student version to experiment with the language.
The Educatee Editions are sold as books with disks enclosed. They are published by Prentice-Hall and can be ordered through bookstores.
In add-on to the MATLAB organization itself, Mathworks offers sets of Toolboxes, containing MATLAB functions for solving a number of important types of problems. Of item interest to us is the optimization toolbox, which will be discussed in a later section.
Matrices equally Cardinal Objects
MATLAB is one of a few languages in which each variable is a matrix (broadly construed) and "knows" how big it is. Moreover, the fundamental operators (e.g. improver, multiplication) are programmed to deal with matrices when required. And the MATLAB environment handles much of the bothersome housekeeping that makes all this possible. Since and so many of the procedures required for Macro-Investment Assay involve matrices, MATLAB proves to be an extremely efficient language for both communication and implementation.
Matrix Operations
Consider the following MATLAB expression:
C = A + B
If both A and B are scalars (1 by one matrices), C volition be a scalar equal to their sum. If A and B are row vectors of identical length, C will be a row vector of the same length, with each chemical element equal to the sum of the corresponding elements of A and B. Finally, if A and B are, say, {3*4} matrices, so will C, with each element equal to the sum of the respective elements of A and B.
In curt the symbol "+" means "perform a matrix addition". But what if A and B are of incompatible sizes? Non surprisingly, MATLAB will complain with a statement such every bit:
??? Error using ==> + Matrix dimensions must agree.
Then the symbol "+" means "perform a matrix add-on if you tin and allow me know if y'all can't".
Assignment Statements
MATLAB uses a pattern common in many programming languages for assigning the value of an expression to a variable. The variable proper noun is placed on the left of an equal sign and the expression on the right. The expression is evaluated and the result assigned to the variable name. In MATLAB, there is no need to declare a variable before assigning a value to it. If a variable has previously been assigned a value, the new value overrides the predecessor.
This may sound obvious, but consider that the term "value" now includes information concerning the size of matrix also every bit its contents. Thus if A and B are of size {20*xxx} the statement:
C = A + B
Creates a variable named C that is also {20*30} and fills it with the advisable values. If C already existed and was, say {20*15} information technology would be replaced with the required {20*30} matrix. In MATLAB, unlike some languages, there is no need to "pre-dimension" or "re-dimension" variables. It all happens without whatsoever explicit action on the part of the user.
Case Sensitivity
MATLAB variable names are ordinarily case-sensitive. Thus variable C is different from variable c. A variable name can accept up to 19 characters, including messages, numbers and underscores. While it is tempting to use names such as FundReturns it is safer to choose instead fund_returns or to use the convention from the C language of capitalizing only 2nd and subsequent words, equally in fundReturns. In whatsoever consequence, a\Adopt a simple set of naming conventions so that you won't write one version of a proper name in one identify and another later. If you do so, you may get lucky (e.thou. the system will complain that you have asked for the value of an undefined variable) or y'all may not (e.g. y'all will assign the new value to a newly-created variable instead of the quondam one desired). In programming languages there are always tradeoffs. You don't have to declare variables in advance in MATLAB. This avoids a great deal of effort, but it allows nasty, hard-to-detect errors to creep into your programs.
Firsthand and Deferred Execution
When MATLAB is invoked, the user is presented with an interactive surround. Enter a argument, press the railroad vehicle return ("ENTER") and the argument is immediately executed. Given the power that can be packed into 1 MATLAB statement, this is no minor accomplishment. Notwithstanding, for many purposes it is desirable to shop a set of MATLAB statements for use when needed.
The simplest form of this approach is the creation of a script file: a set of commands in a file with a name ending in .m (e.chiliad. do_it.m). Once such a file exists and is stored on disk in a directory that MATLAB knows about (i.e. ane on the "MATLAB path"), the user can just type:
do_it
at the prompt in interactive manner. The statements volition then be executed.
Even more powerful is the part file; this is also a file with an .m extension, only i that stores a function. For example, assume that the file val_port.m, stored in an appropriate directory, contains a function to produce the value of a portfolio, given a vector of holdings and a vector of prices. In interactive style, one tin and so simply type:
v = val_port(holdings, prices);
MATLAB will realize that information technology doesn't accept a born function named val_port and search the relevant directories for a file named val_port.m, then employ the part contained in it.
Whenever possible, yous should endeavour to create "yard-files" to do your work, since they can easily exist re-used.
Showing Values
If at any time you wish to run into the contents of a variable, just blazon its name. MATLAB will do its best, although the upshot may take some infinite if the variable is a large matrix.
MATLAB likes to practise this and volition tell yous what it has produced afterward an consignment statement unless you lot request otherwise. Thus if you type:
C = A + B
MATLAB will show yous the value of C. This may exist a bit daunting if C is, say, a 20 past 30 matrix. To surpress this, put a semicolon at the terminate of any consignment statement. For example:
C = A + B;
Initializing Matrices
If a matrix is small plenty, 1 tin can provide initial values past but typing them in. For example:
a = three; b = [ 1 2 3]; c = [ iv ; 5 ; 6]; d = [ 1 2 3 ; 4 5 vi];
Here, a is a scalar, b is a {1*3} row vector, c a {3*ane} column vector, and d is a {2*three} matrix. Thus, typing "d" produces:
d = 1 2 iii 4 5 6
The system for indicating matrix contents is very simple. Values separated by spaces are to exist on the aforementioned row; those separated by semicolons are on to be on separate rows. All values are enclosed in square brackets.
Making Matrices from Matrices
The full general scheme for initializing matrices can be extended to include matrices as components. For example:
a = [1 2 three]; b = [4 v 6]; c = [a b];
gives:
c = ane ii 3 4 5 vi
While:
d = [a ; b]
gives:
d = 1 two three 4 5 half dozen
Matrices tin can easily be "pasted" together in this manner -- a process that is both simple and easily understood by anyone reading a procedure (including its author). Of class, the sizes of the matrices must be uniform. If they are non, MATLAB will tell you.
Using Portions of Matrices
Frequently ane wishes to reference only a portion of a matrix. MATLAB provides unproblematic and powerful ways to do so.
To reference a part of a matrix, give the matrix name followed past parentheses with expressions indicating the portion desired. The simplest case arises when only i element is wanted. For case, using d in the previous section:
d(1,2) equals 2 d(2,ane) equals 4
In every case the first parenthesized expression indicates the row (or rows), while the second expression indicates the column (or columns). If a matrix is, in fact, a vector, a unmarried expression may be given to indicate the desired chemical element, but it is ofttimes wise to give both row and cavalcade information explicitly, even in such cases.
MATLAB's real power comes into play when more than a single element of a matrix is wanted. To point "all the rows" use a colon for the beginning expression. To indicate "all the columns", use a colon for the 2nd expression. Thus, with:
d = i ii 3 iv 5 6 d(1,:) equals ane 2 3 d(:,2) equals ii 5
In fact, you may utilize any expression in this mode as long as it evaluates to a vector of valid row or column numbers. For example:
d(2,[ii 3]) equals five six d(two, [three 2]) equals 6 five
Variables may also exist used as "subscripts". Thus:
if z = [two 3] so d(2,z) equals 5 6
Particularly useful in this context (and others) is the construct that uses a colon to produce a string of consecutive integers. For example:
the statement: ten = 3:5 produces x = iii 4 5
Thus:
d(1, 1:2) equals 1 2
Text Strings
MATLAB is wonderful with numbers. Information technology deals with text only you lot can tell that its heart isn't in it.
A variable in MATLAB is one of ii types: numeric or string. A string matrix is similar whatever other, except the elements in it are interpreted every bitASCII numbers. Thus the number 32 represents a space, the number 65 a capital letter A, etc.. To create a string variable, enclose a string of characters in "single" quotation marks (actually, apostrophes), thus:
stg = 'This is a cord';
Since a string variable is in fact a row vector of numbers, information technology is possible to create a list of strings past creating a matrix in which each row is a divide string. As with all standard matrices, the rows must be of the aforementioned length. Thus:
the statement x = ['ab' ; 'cd'] produces: x = ab cd while x = ['ab' 'cd'] produces: x = abcd as always.
Matrix and Array Operations
The Mathworks uses the term matrix operation to refer to standard procedures such equally matrix multiplication. The term array operation is reserved for element-by-chemical element computations.
Matrix Operations
Matrix transposition is as easy as calculation a prime (apostrophe) to the proper noun of the matrix. Thus:
if: ten = 1 ii three so: 10' = one 2 3
To add together two matrices of the same size, utilize the plus (+) sign. To decrease 1 matrix from another of the same size, use a minus (-) sign. If a matrix needs to be "turned around" to arrange, use its transpose. Thus, if A is {3*4} and B is {4*3}, the statement:
C = A + B
volition get yous the bulletin:
??? Error using ==> + Matrix dimensions must agree.
while:
C = A + B'
volition get you a new matrix.
There is one case in which addition or subtraction works when the components are of different sizes. If one is a scalar, it is added to or subtracted from all the elements in the other.
Matrix multiplication is indicated by an asterisk (*), commonly regarded in programming languages equally a "times sign". With i exception the usual rules apply: the inner dimensions of the two operands must be the same. If they are not, you will be told and so. The 1 allowed exception covers the example in which one of the components is a scalar. In this instance, the scalar value is multiplied past every element in the matrix, resulting in a new matrix of the same size.
MATLAB provides 2 notations for "matrix division" that provide rapid solutions to simultaneous equation or linear regression problems. They are better discussed in the context of such problems.
Array Operations
To bespeak an array (element-by-element) operation, precede a standard operator with a period (dot). Thus:
if x = 1 two 3 and y = 4 5 6 so: ten.*y = 4 ten 18 the "dot product" of ten and y.
You lot may carve up all the elements in one matrix by the corresponding elements in another, producing a matrix of the same size, as in:
C = A ./ B
In each example, i of the operands may be a scalar. This proves handy when you wish to raise all the elements in a matrix to a power. For example:
if ten = ane 2 three then: x.^2 = 1 4 9
MATLAB array operations include multiplication (.*), division (./) and exponentiation (.^). Array addition and subtraction are not needed (and in fact are non allowed), since they would only duplicate the operations of matrix addition and subtraction.
Using Functions
MATLAB has a number of congenital-in functions -- many of which are very powerful. Some provide one (matrix) answer; others provide two or more.
Y'all may use whatsoever function in an expression. If information technology returns 1 answer, that answer volition exist used. The sum part provides an case:
if ten = one 2 3 and so the argument: y =sum(x) + 10 will produce: y = 16
Some functions, such as max provide more than one respond. If such a role is included in an expression, only the offset answer will be used. For example:
if x = 1 iv three the statement: z = 10 + max(x) volition produce: z = 14
To get all the answers from a function that provides more than than 1, use a multiple assignment statement in which the variables that are to receive the answers are listed to the left of the equal sign, enclosed in square brackets, and the role is on the right. For example:
if ten = i iv iii the argument: [y northward] = max(x) will produce: y = 4 n = two
In this case, y is the maximum value in ten, and n indicates the position in which information technology was establish.
Many of MATLAB's born functions, such equally sum, min, max, and mean have natural interpretations when applied to a vector. If a matrix is given as an argument to such a function, its process is applied separately to each column, and a row vector of results returned. Thus:
if ten = 1 2 3 4 5 6 then : sum(x) = 5 7 9
Some functions provide no answers per se. For example, to plot a vector y confronting a vector x, simply employ the statement:
plot(ten,y)
which will produce the desired cross-plot.
Note that in this case, 2 arguments (the items in the parentheses after the part name) were provided as inputs to the role. Each function needs a specific number of inputs. However, some have been programmed to react appropriately when fewer are given. For example, to plot y against (1,2,3...), you can apply the argument:
plot(y)
There are many built-in functions in MATLAB. Among them, the following are particularly useful for Macro-Investment Analysis:
- ones
ones matrix - zeros
zeros matrix - size
size of a matrix - diag
diagonal elements of a matrix - inv
matrix inverse - rand
uniformly distributed random numbers - randn
normally distributed random numbers - cumprod
cumulative product of elements - cumsum
cumulative sum of elements - max
largest component - min
smallest component - sum
sum of elements - mean
average or hateful value - median
median value - std
standard deviation - sort
sort in ascending lodge - find
find indices of nonzero entries - corrcoef
correlation coefficients - cov
covariance matrix
Non listed, simply of great employ, are the many functions that provide plots of data in either ii or iii dimensions, besides equally a number of more than specialized functions. Notwithstanding, this list should serve to whet the Analyst's appetite. The full list of functions and information on each one can exist obtained via MATLAB's on-line help organisation.
Logical and Relational Operations on Matrices
MATLAB offers six relational operators:
- < : less than
- <= : less than or equal to
- > : greater than
- >= : greater than or equal to
- == : equal
- ~= : not equal
Note carefully the difference between the double equality and the single equality. Thus A==B should be read "A is equal to B", while A=B should exist read "A should be assigned the value of B". The former is a logical relation, the latter an assignment statement.
Whenever MATLAB encounters a relational operator, it produces a i if the expression is true and a nada if the expression is false. Thus:
the statement: x = 1 < 3 produces: x=1, while x = 1 > 3 produces: x=0
Relational operators can be used on matrices, as long as they are of the same size. Operations are performed element-by-element, resulting a matrix with ones in positions for which the relation was truthful and zeros in positions for which the relation was fake. Thus:
if A = 1 2 iii four and B = iii 1 2 2 the statement: C = A > B produces: C = 0 1 1 1
One or both of the operands connected past a relational operator can be a scalar. Thus:
if A = 1 2 three 4 the statement: C = A > 2 produces: C = 0 0 one i
One may also use logical operators of which there are three:
- & : and
- | : or
- ~ : not
Each works with matrices on an chemical element-by-element basis and conforms to the ordinary rules of logic, treating whatever non-aught element equally true and any goose egg element as fake.
Relational and logical operators are used oft with If statements (described below) and scalar variables, as in more mundane programming languages. But the ability to use them with matrices offers major advantages in some Investment applications.
Sorting Matrices
To sort a matrix in ascending lodge, use the sort part. If the statement is a vector, the consequence volition be a new vector with the items in the desired order. If information technology is a matrix, the event volition be a new matrix in which each column will contain the contents of the corresponding cavalcade from the one-time matrix, in ascending order. Note that in the latter instance, each column is, in upshot, sorted separately. Thus:
if x = i v 3 2 2 viii the statement: y=sort(x) will produce: y = 1 ii 2 5 three 8
To obtain a record of the rows from which each of the sorted elements came, employ a multiple assignment to go the second output of the part. For the case higher up:
the statement: [y r] = sort(10) would produce y as earlier and r = i ii 3 1 2 3
Thus the second item in the sorted list in column 1 came from row three, etc..
Controlling Execution Flow
It is possible to do a smashing bargain in MATLAB by simply executing statements involving matrix expressions, 1 after the other, Withal, there are cases in which ane just must substitute some not-sequential order. To facilitate this, MATLAB provides three relatively standard methods for controlling program menstruum: For Loops, While Loops, and If statements
For Loops
The most common use of a For Loop arises when a set of statements is to be repeated a stock-still number of times, every bit in:
for j= 1:n ....... end
There are fancier ways to apply For Loops, but for our purposes, the standard i suffices.
While Loops
A While Loop contains statements to be executed every bit long every bit a stated condition remains true, as in:
while x > 0.5 ....... end
It is, of course, crucial that at some point a statement will be executed that will crusade the condition in the While statement to be false. If this is non the case, you have created an infinite loop -- one that will go merrily on until yous pull the plug.
For readability, information technology is sometimes useful to create variables for TRUE and FALSE, then use them in a While Loop. For example:
true = i==1; false = i==0; ..... done = imitation; while non washed ........ end
Of course, somewhere in the While loop there should be a argument that will at some point set washed equal to true.
If Statements
A If Statement provides a method for executing certain statements if a condition is true and other statements (or none) if the condition is false. For example:
If 10 > 0.v ........ else ....... end
In this case, if ten is greater than 0.5 the get-go set of statements will exist executed; if not, the second set will be executed.
A simpler version omits the "else section", equally in:
If ten > 0.five ........ terminate
Here, the statements will be executed if (just but if) x exceeds 0.five.
Nesting
All three of these structures allow nesting, in which i type of construction lies within some other. For instance:
for j = i:north for k = ane:n if x(j,one thousand) > 0.5 x(j,k) = 1.v; end end end
The indentation is for the reader'southward benefit, just highly recommended in this and other situations. MATLAB will pair up end statements with preceding for, while, or if statements in a concluding-come up-first-served mode. It is upwards to the developer to ensure that this will give the desired results. Indenting can help, but hardly guarantees success on every occasion.
While it is tempting for those with experience in traditional programming languages to take the easy mode out, using For and While loops for mathematical operations, this temptation should be resisted strenuously. For instance, instead of:
port_val = 0; for j = 1:n port_val = port_val + ( holdings(j) * prices(j)); finish
write:
port_val = holdings*prices;
The latter is more succinct, far clearer, and will run much faster. MATLAB performs matrix operations at blinding speed, but can exist downright glacial at times when loops are to exist executed a great many times, since it must do a sure amount of translation of each statement every time it is encountered.
Writing Functions
The power of MATLAB really comes into play when yous add your own functions to heighten the language. Once a function m-file is written, debugged, and placed in an appropriate directory, it is for all applied purposes role of your version of MATLAB.
A role file starts with a line declaring the part, its arguments and its outputs. There follow the statements required to produce the outputs from the inputs (arguments). That'south information technology.
Here is a unproblematic example:
function y = port_val(holdings,prices) y = holdings*prices;
Of course, this will just work if the holdings and prices vectors or matrices are uniform for matrix multiplication. A more complex version could examine the sizes of these two matrices, so employ transposes, etc. as required.
Information technology is important to note that the argument and output names used in a function file are strictly local variables that be only inside the function itself. Thus in a program, one could write the statement:
v = port_val(h,p);
The first matrix in the argument list in this calling argument (here, h) would be assigned to the beginning argument in the office (here, holdings) while the second matrix in the calling statement (p) would be assigned to the 2d matrix in the office (prices). There is no demand for the names to be the same in any respect. Moreover, the function cannot change the original arguments in whatsoever manner. Information technology tin only return data via its output.
This function returns simply one output, called y internally. However, the resultant matrix will be substituted for the unabridged argument "call" in whatever expression.
If a function is to return two or more arguments, merely assign them names in the declaration line, as in:
function [total_val, avg_val] = port_val(holdings,prices) total_val = holdings*prices; avg_val = total_val/size(holdings,2);
This can still be used as in the earlier case if simply the total value is desired. To get both the total value and the average value per position, a program could use a argument such as:
[tval aval] = port_val( h,p);
Annotation that as with inputs, the correspondence between outputs in the calling argument and the office itself is strictly by guild. When the office has finished its work, its output values are assigned to the variables in the calling argument.
Variables other than inputs and arguments may be included in functions, as needed. They are strictly local to the role and accept no existence outside it. Indeed, a variable in a role may take the same proper noun as ane in some other identify; the two will coexist with neither bothering the other. While MATLAB provides for the utilise of "global variables", their use is widely discouraged and volition non exist treated here.
Comments and Help
It is an splendid thought to include comments throughout any m-file. To do so, use the percent (%) sign. Everything later it up to the end of the line will be ignored past MATLAB.
The first several lines afterwards each function header should provide a brief description of the function and its use. Once the part has been placed in an appropriate directory, a user demand just type help followed by the function proper name to be shown all the initial comment lines (up to the first not-comment or totally blank line). Thus if there is a function named port_val, the user can become this information by typing:
aid port_val
To provide even more help, create a script file with nothing merely annotate lines, each giving the proper name and a brief description of all your functions and scripts. If this were named mia_fun, the user could but blazon:
assist mia_fun
to get a list of your functions, then blazon help office proper name to get more details on any specific function.
Information Input and Output
There are many ways to get data into and out of the MATLAB environment. We will cover only the simpler ones here.
Data Input
The most straightforward way to get information into MATLAB is to blazon it in "command manner". For case:
prices = [ 12.50 37.875 12.25]; assets = ['greenbacks ';'bonds ' ; 'stocks'];
MATLAB even makes information technology piece of cake to enter matrices in a more normal form by treating carriage returns as semicolons within brackets. Thus:
holdings = [ 100 200 300 400 500 600 ]
will create a {three*two} matrix, as desired.
A 2d way to get data into MATLAB is to create a script file with the required statements, such as the one above. This can exist done with whatsoever text processor. Large matrices of data can even exist "cut out" of databases, spreadsheets, etc. then edited to include the desired variable names, square brackets and the like. One time the file or files are saved with .thou names they only have to be invoked to bring the information into MATLAB.
Next up the chain of complication is the utilize of a flat file which stores data for a matrix. Such a file should accept numeric ascii text characters, with each element in a row separated from its neighbor with a space and each row on a separate line. Say, for example, that yous take stored the elements of a matrix in a file named test.txt in a directory on the MATLAB path. So the argument:
load test.txt
will create a matrix named test containing the data.
Data Output
A simple mode to output data is to display a matrix. This can be achieved past either giving its name (without a semicolon) in interactive mode. Alternatively y'all tin can utilize the disp function, which shows values without the variable name, every bit in:
disp(test);
For prettier output, MATLAB has various functions for creating strings from numbers, formatting data, etc.. Function pmat can produce small tables with string identifiers on the borders.
If you desire to save well-nigh everything that appears on your screen, issue the command:
diary filename
where filename represents the name of a new file that volition receive the subsequent output. When you are through, issue the command:
diary off
Afterward, at your leisure, you may use a text editor to excerpt data, commands, etc. to data files, script or office files, and then on.
There are, of course, other alternatives. If you are in an surroundings (such as a Windows arrangement) that allows textile to be copied from one program and pasted into some other, this may suffice.
To create a flat file containing the data from a matrix use the -ascii version of the salvage command. For example:
relieve newdata.txt test -ascii
will save the matrix named test in the file named newdata.txt.
Finally, y'all may save all or part of the material from a MATLAB session in MATLAB'due south ain mat file format. To save all the variables in a file named temp.mat, upshot the command:
relieve temp
At some later on session you may load all this data by only issuing the control:
load temp
To relieve only one or more matrices in this manner, list their names afterward the file name. Thus:
relieve temp prices holdings portval
would save only these three matrices in file temp.mat. Subsequent use of the command:
load temp
would restore the three named matrices, with their values intact.
At that place are more sophisticated ways to motility information into and out of MATLAB, but they can exist left to others.
MATLAB Role Library
Nosotros provide a number of MATLAB functions that may show of value to the Macro-Investment Analyst and, possibly, others. The user is advised to proceed with caution when using whatever of them.
Reading Text File in Matlab as Matrix
Source: https://web.stanford.edu/~wfsharpe/mia/mat/mia_mat3.htm
0 Response to "Reading Text File in Matlab as Matrix"
Post a Comment