User:Eml4500.f08.bottle.vitello/HW 1

Homework 1 Material

Homework 1 is an exploration of a MATLAB tutorial written by Kermit Sigmon of the University of Florida.

Lecture Notes
Finite Element Analysis is a method of solving partial differential equations (PDE’s) and integral equations by approximating solutions. The PDE’s and integrals are reduced into less complex equations and solved using common methods. It is typically used in engineering to perform complex computer analysis on materials and designs. The item being analyzed is broken down into a series of matrices and analyzed on a smaller scale. It was first applied to vibration systems in 1943 by R. Courant. Since then it has been used in a wide variety of fields and industries from manufacturing to biomedical research.

The Finite Element Analysis and Design (FEAD) class at the University of Florida, EML 4500, is offered on Monday, Wednesday, and Friday’s this fall. It meets from 3:00-3:50 in the Florida gym beginning on August 25th and ending on December 10th. The class is composed of lectures, group projects, and three exams. These exams are scheduled for Wednesday September 24th, Wednesday October 22nd, and Wednesday December 3rd. These dates are none negotiable and the policy is no make-up exams. A wide variety of material will be covered in class, including but not limited to trusses, beams, solid structures, linear stability, mixed algebra, and design analysis.

The book used in the current fall semester is Finite Element Analysis With Mathematica and Matlab Computations and Practical Applications: Fundamental Concepts by M. Asghar Bhatti and MATLAB software will be used extensively. MATLAB is an integral part of this course. The first assignment for the class is to explore and attempt the University of Florida’s MATLAB primer tutorial, as seen below. It is imperative that students begin the class with a solid foundation in the software that will be used in later analyses.

A large portion of the course will be used to encourage group work and utilize cooperative learning techniques. Students will submit reports containing a summary of the week’s lecture notes and a problem or two exemplifying the theories explained in lecture. Wikiversity software will be used to submit the assignment. This is advantageous to the student in several ways. First, it will allow the student to learn a new form of communication /idea sharing or allow a student already familiar with Wikiversity to gain a better understanding of the software. A second advantage is that is accessible from any place that has an internet connection. This allows students to contribute to the group project at any time and allows all group members to oversee the final report. It also allows the instructor to see the individual contributions of each group member and ensures that all members are participating.

To submit a report each group member must create an individual Wikipedia account. From there work can be uploaded to individual pages or the group page and can be accessed by all. In addition to the principles of cooperative learning, Wikipedia allows for the communication of ideas across a larger community. This community comprises the entire global network of internet users, thus refining the education and knowledge pool of the human race. The standards for Wiki use allow each member of this global community to observe and reflect on the previous efforts of singular contributions and internalize these principles when formulating their own additions to this incredible wealth of electronic knowledge. A pitfall to this open-source and easily accessible framework is that it can become subject to vandalism. To curb the occurrence of this unfortunate phenomenon, the history for each page is recorded and can be used to override the vandalized version whenever necessary. It is the ultimate goal that the Wikipedia and Wikiversity interface will be used with noble intentions with the idea of a modern categorical imperative in place, hence providing a unique tool to communicate knowledge to the rest of mankind for the greater good of the world. It is this modern categorical imperative that is at the heart of Professor Loc Vu-Quoc's vision of the power of Wikipedia and Wikiversity.

For additional resources related to the course, Professor Vu-Quoc's course website offers its own wealth of helpful information including exam dates.

Chapter 4 of the textbook Finite Element Analysis With Mathematica and Matlab Computations visits the Finite Element Method approach to understanding trusses, beams, and frame systems. Often, engineers and other problem solvers are faced with statically indeterminate systems. In other words, using standard knowledge of statics and mechanics of materials will not be able to understand these systems. The Finite Element Method is a different way of understanding these systems with the use of matrix algebra. Basically, the method rather than analyzing the system as a whole, parts of the system are analyzed separately. This chapter first treats plane truss systems. Unlike beams and frames, trusses are only subjected to axial loads. It is assumed that they are elastic bars that are deformable.

When faced with a problem dealing with truss systems, it is important to clearly understand the background of the problem and what is being asked. Diagrams are especially useful in visualizing the problem when they are properly labeled. Starting with the entire system itself, a clearly and properly marked global free body diagram (FBD) is necessary. Included in this diagram would be the global coordinate system, loads, reactions, degrees of freedom, and labels for each node and member of the system. Examples of degrees of freedom are the known, fixed degrees of freedom and constraints, or the unknown, often displacements. It is standard to label the global nodes using numbers with circles encircling the numbers. The members of the system should be labeled with numbers encircled by triangles. From this, one can determine whether or not the system is statically indeterminate.

Once the system has been determined statically indeterminate, one may proceed with Finite Element Analysis. Since the members of the system will be analyzed separately, element free body diagrams should be created for each of the members of the system. This process also has its own standard labeling method. Although the nodes should already have been labeled encircled by circles, labeling the local nodes encircled with a square helps clarify the diagram. The reactions, loads, and degrees of freedom should be written the same except for the global nodes that experience the loads, once should choose one member of the system that undergoes the load while the other member doesn't. The local coordinate system may be the same as the global coordinate system, or one may be chosen to further simplify the problem.

Recalling back to fundamental physics, the equation that describes the force (F) of a spring with a spring constant (k) where one end is fixed and the other goes through a displacement (x) is F=kx. However, this single equation can not describe the motion of a spring where both ends are not fixed. This is a statically indeterminate system, therefore the Finite Element Method must be used. The motion of this scenario can be described

$$\begin{Bmatrix} F_1 \\ F_2 \end{Bmatrix} = \begin{bmatrix} k & -k \\ -k & k \end{bmatrix}\begin{Bmatrix} d_1 \\ d_2 \end{Bmatrix}$$

where Fi is the force of node i=1,2, k is the stiffness matrix, and di is the displacement of node i=1,2. This can also be applied to truss systems in a similar manner. However many degrees of freedom determines the size of the matrix. In the spring scenario, there were two degrees of freedom creating a 2X1 force matrix, a 2X1 displacement matrix and a 2X2 stiffness matrix. In truss systems that are unconstrained the stiffness matrix will be of dimensions mXn, where m is the number of unknown displacement degrees of freedom and n is the number of both known and unknown degrees of freedom. Once the known degrees of freedom are eliminated the force and displacement matrix will be mX1, and the stiffness matrix will be mXm. For consistency purposes, the element stiffness and force matrices will be situated in the global coordinate system. Once the stiffness and displacement matrices are established, one may calculate the reactions (the unknown forces).

Entering Matrices
Matrices can be introduced into MATLAB as exampled in the following statements:

M = [1 0 0; 0 1 0; 0 0 1]

or

M = [ 1 0 0 0 1 0 0 0 1]

where both result in the MATLAB output of

M =

1    0     0     0     1     0     0     0     1

To reference an entry within the introduced matrix, entering a command such as the following will result in that entry being displayed:

M(1,2)

results in

ans =

0

This corresponds to the element found in the first row and second column.

If, for example, M(2,2) was entered, the result would be

ans =

1

Matrix Operations, Array Operations
For Matrix Operations, the following commands can be used:

For Array Operations, addition and subtraction are implicitly performed on corresponding matrix elements. Note that these operations must be performed on matrices of the same dimension. However, for the operations of multiplication, power, left division, and right division, element-wise operation is not implicit. MATLAB allows these operations to be performed element-wise by introducing a period before the operator as in the following example:

[1 -1 2 4; 9 1 0 0] .* [5 2 -4 6; 0 1 3 8]

resulting in

ans =

5   -2    -8    24     0     1     0     0

as opposed to the matrix multiplication operator *

[1 -1 2 4; 9 1 0 0] * [5 2 -4 6; 0 1 3 8]

resulting in

??? Error using ==> mtimes Inner matrix dimensions must agree.

This result occurred because the matrices were not of the proper corresponding dimensions that would allow the multiplication operation to be performed.

Statements, Expressions, and Variables; Saving a Session
MATLAB is considered an expression language as its assignment of values to variables can be written as

variable = expression

Expressions here are defined as operators, functions, values, or variable names themselves. MATLAB will store these assigned values to the specified variable for later reference. If a variable name is not explicitly entered, MATLAB will default to assigning the expression values to the temporary variable ans.

A statement is typically entered on a single line and ended by hitting return or enter. However, statements are able to continue to additional lines provided three or more periods are entered, as in the following example:

EDU>> A = 5

A =

5

which is equivalent to

EDU>> A =... 5

A =

5

Further, multiple statements can be entered onto a single line if separated by commas or semicolons as in the following example:

EDU>> B = 6, C = -1; D = B

B =

6

D =

6

EDU>> C

C =

-1

As seen above, if the last character of a statement is a semicolon, that particular statement does not print to screen. Here, the variable C required explicitly typing C to confirm its variable assignment.

Additional things to note with MATLAB are that variables are case-sensitive and that the commands who and whos can be used to list the currently defined variables. Using the variables in the above examples, typing whos results in:

Name     Size                    Bytes  Class A        1x1                         8  double array B        1x1                         8  double array C        1x1                         8  double array D        1x1                         8  double array Grand total is 4 elements using 32 bytes

Entering eps outputs the unit roundoff for your computer, while pressing CTRL-C or CTRL-BREAK will stop a runaway computation.

If a MATLAB session is saved using the save command, it will preserve the values of the variables in a file called matlab.mat. Using the load command upon reentering MATLAB, the defined variables and their respective values will reappear.

Matrix Building Functions
MATLAB includes the following intrinsic functions for construction of matrices: Each of these functions requires the specification of matrix row and column dimensions unless the matrices are assumed square.

For example, specifying a square matrix M, the operation diag(M) results in the generation of a vector consisting of the diagonal of M.

M = [5 4 3; 1 0 9; -1 2 3]

M =

5    4     3     1     0     9    -1     2     3

such that diag(M) results in

ans =

5    0     3

If diag(diag(M)) is entered the result is

ans =

5    0     0     0     0     0     0     0     3

Matrices can also be built from "blocks". If M is the same as above and N = [M, zeros(3,2); zeros(2,3), eye(2)] is entered, the result is the following 5 x 5 matrix

N =

5    4     3     0     0     1     0     9     0     0    -1     2     3     0     0     0     0     0     1     0     0     0     0     0     1

For, While, If -- and Relations
FOR It is possible generate a vector using a FOR loop in MATLAB as in the following example where 5 is the specified vector dimension

x = []; for i=1:5 x=[x, i^2] end

resulting in

x =

1

x =

1    4

x =

1    4     9

x =

1    4     9    16

x =

1    4     9    16    25

It is also possible to generate the same vector in reverse order by typing the following

x=[]; for i=5:-1:1 x=[x,i^2] end

resulting in

x =

25

x =

25   16

x =

25   16     9

x =

25   16     9     4

x =

25   16     9     4     1

WHILE

The WHILE loop can also be used in MATLAB to perform a repeated action so long as the condition within the WHILE loop remains true. The following example demonstrates the implementation of a WHILE loop:

n = 0; while 2 ^ n < 5 n = n + 1; end n

resulting in

n =

3

IF

MATLAB also uses the IF statement which allows an action to occur if a specified condition is satisfied. The following example demonstrates the implementation of the IF statement:

n = - 1; if n < 0 m = 10; m end

resulting in

m =

10

Relations

MATLAB makes use of the following relational operators:

It is important to realize that "=" and "==" are not equivalent, as "=" is used in an assignment statement while "==" is used in a relation.

It is also possible to connect or quantify relations using the following logical operators:

When relations are used on scalars, the scalar takes on either the value of 1 or 0 depending on whether the specified relation is true or false as in the following examples:

3 < 5

ans =

1

3 > 5

ans =

0

3 == 5

ans =

0

3 == 3

ans =

1

Relations can also be applied to matrices of the same dimensions. The matrix takes on values of 1's and 0's as elements if the element-wise relationship is either true or false. This is seen in the following example:

a = rand(5), b = triu(a), a==b

a =

0.8147   0.0975    0.1576    0.1419    0.6557    0.9058    0.2785    0.9706    0.4218    0.0357    0.1270    0.5469    0.9572    0.9157    0.8491    0.9134    0.9575    0.4854    0.7922    0.9340    0.6324    0.9649    0.8003    0.9595    0.6787

b =

0.8147   0.0975    0.1576    0.1419    0.6557         0    0.2785    0.9706    0.4218    0.0357         0         0    0.9572    0.9157    0.8491         0         0         0    0.7922    0.9340         0         0         0         0    0.6787

ans =

1    1     1     1     1     0     1     1     1     1     0     0     1     1     1     0     0     0     1     1     0     0     0     0     1

Note that the values in matrix a were randomly selected; however, given that b is a function of a, the final matrix generated will always be the same unless matrix a contains 0's in its lower triangular section.

Scalar Functions
MATLAB has intrinsic functions that can operate directly on scalars or will operate element-wise on matrices. These functions are:

The following examples illustrate the use of these functions:

sin(pi/2)

ans =

1

asin(pi)

ans =

1.5708 - 1.8115i

exp(2)

ans =

7.3891

abs(-4)

ans =

4

round(4.5)

ans =

5

cos(0)

ans =

1

acos(pi)

ans =

0 + 1.8115i

log(2.7183)

ans =

1.0000

sqrt(100)

ans =

10

floor(3.6)

ans =

3

tan(.7071)

ans =

0.8545

atan(.7071)

ans =

0.6155

rem(100,7)

ans =

2

sign(-100)

ans =

-1

ceil(2.1)

ans =

3

Vector Functions
MATLAB also includes functions which operate directly on vectors. When applied to a matrix, they operate on each column resulting in a row vector with the results of the column by column operation. To apply vector functions to the rows of a matrix, it is necessary to take the transpose of the matrix so that the rows and columns are effectively swapped. Taking the transpose again will result in the matrix reverting back to its original orientation.

Examples of vector functions within MATLAB include:

As an example, to find the maximum value of the entries within a specified matrix, the use of the vector function max(max(n)) can be used where n is the following matrix:

n=rand(3)

n =

0.2760   0.1626    0.9597    0.6797    0.1190    0.3404    0.6551    0.4984    0.5853

such that max(max(n)) results in

ans =

0.9597

If max(n) is entered, the result is the column by column maximum values. This is observed in the following row output:

ans =

0.6797   0.4984    0.9597

Matrix Functions
Intrinsic in MATLAB are the following matrix functions:

MATLAB functions can have single or multiple output arguments as seen in the following examples:

a = magic(4)

a =

16    2     3    13     5    11    10     8     9     7     6    12     4    14    15     1

y = eig(a)

y =

34.0000   8.9443   -8.9443    0.0000

This is a column vector containing the eigen values for matrix a.

For the same matrix a, entering [U,D] = eig(a) will result in a matrix U with its columns as the eigenvectors of matrix a and a diagonal matrix D whose diagonal values are the eigenvalues of matrix a. This is seen in the following:

[U,D] = eig(a)

U =

-0.5000  -0.8236    0.3764   -0.2236   -0.5000    0.4236    0.0236   -0.6708   -0.5000    0.0236    0.4236    0.6708   -0.5000    0.3764   -0.8236    0.2236

D =

34.0000        0         0         0         0    8.9443         0         0         0         0   -8.9443         0         0         0         0    0.0000

Command Line Editing and Recall
The left and right arrow keys can be used to move the cursor and the Backspace key can be used to delete a character. On a PC, hitting the Home key will position the cursor at the beginning of the command line, while the End key will position it at the end of the line.

The up and down arrow keys can be used to move through previous commands. A previous command can be recalled, edited and executed over again. For example, typing

a=rand(8)

in the command line yields:

a =

0.8909   0.8143    0.3517    0.3804    0.5688    0.1656    0.2290    0.1067    0.9593    0.2435    0.8308    0.5678    0.4694    0.6020    0.9133    0.9619    0.5472    0.9293    0.5853    0.0759    0.0119    0.2630    0.1524    0.0046    0.1386    0.3500    0.5497    0.0540    0.3371    0.6541    0.8258    0.7749    0.1493    0.1966    0.9172    0.5308    0.1622    0.6892    0.5383    0.8173    0.2575    0.2511    0.2858    0.7792    0.7943    0.7482    0.9961    0.8687    0.8407    0.6160    0.7572    0.9340    0.3112    0.4505    0.0782    0.0844    0.2543    0.4733    0.7537    0.1299    0.5285    0.0838    0.4427    0.3998

Rather than having to move between MATLAB and the editor, the line can be directly recalled yielding a new set of random numbers:

a =

0.2599   0.8693    0.4018    0.9027    0.7803    0.5752    0.6491    0.6868    0.8001    0.5797    0.0760    0.9448    0.3897    0.0598    0.7317    0.1835    0.4314    0.5499    0.2399    0.4909    0.2417    0.2348    0.6477    0.3685    0.9106    0.1450    0.1233    0.4893    0.4039    0.3532    0.4509    0.6256    0.1818    0.8530    0.1839    0.3377    0.0965    0.8212    0.5470    0.7802    0.2638    0.6221    0.2400    0.9001    0.1320    0.0154    0.2963    0.0811    0.1455    0.3510    0.4173    0.3692    0.9421    0.0430    0.7447    0.9294    0.1361    0.5132    0.0497    0.1112    0.9561    0.1690    0.1890    0.7757

Submatrices and Colon Notation
Using “Colon notation” in MATLAB allows for both the generation of vectors and the referencing of submatrices. This along with subscripting by integral vectors are tools that allow the user to cut down on the use of loops, which slows the program and makes it harder to read.

For example, typing in something as simple as:

x=[0.0:0.2:4.0]'; y=sin(x); [x y]

produces a table of sines:

ans =

0        0    0.2000    0.1987    0.4000    0.3894    0.6000    0.5646    0.8000    0.7174    1.0000    0.8415    1.2000    0.9320    1.4000    0.9854    1.6000    0.9996    1.8000    0.9738    2.0000    0.9093    2.2000    0.8085    2.4000    0.6755    2.6000    0.5155    2.8000    0.3350    3.0000    0.1411    3.2000   -0.0584    3.4000   -0.2555    3.6000   -0.4425    3.8000   -0.6119    4.0000   -0.7568

To access particular submatrices of a matrix, colon notation can be used as follows:

x(1:3,1)

produces the first three entries in the first column:

ans =

0   0.2000    0.4000

A single colon refers to an entire row or column: x(:,2) refers to the second column of x, for example.

Integral vectors such as: x(:,[1 2]) includes columns 1 and 2 of x as subscripts.

To replace columns of a matrix, typing: x(:, [1 2]) = B(:,1:2) overwrites the first and second column of x with the first and second column of B producing:

x =

0.4868   0.2305    0.4359    0.8443    0.4468    0.1948    0.3063    0.2259    0.5085    0.1707    0.5108    0.2277    0.8176    0.4357    0.7948    0.3111    0.6443    0.9234    0.3786    0.4302    0.8116    0.1848    0.5328    0.9049    0.3507    0.9797    0.9390    0.4389    0.8759    0.1111    0.5502    0.2581    0.6225    0.4087    0.5870    0.5949    0.2077    0.2622    0.3012    0.6028    0.4709    0.7112

When x is and n-vector typing:

x=x(n:-1:1)

produces:

x =

0.4468   0.4359    0.4868

Entering:

y=fliplr(x) and y=flipud(x’)

yields:

y =

0.4868   0.4359    0.4468

and y=flipud(x) flips the matrix vertically.

M-Files
M-files are sections of MATLAB code that are saved to a disk for later use. M-files have the file extension “.m” at the end of their file name. M-files can be created using the built in editor or a word processor such as Notepad.

M-files are broken up into two different categories, script files and function files.

Script Files Script files consist of a series of statements. When a script file is called within MATLAB the commands within that script file are executed, changing the values of any variables called in the sequence. A script file can execute other M-files, including itself, within its code.

Function Files Function files can be used to extend the capability of MATLAB. User created functions can be added by saving the file to the MATLAB directory. The following is an example of a simple function file.

function r=mod(a,d) % r=mod(a,d). If a and d are integers, then % r is the integer remainder of a after % division by d. If a and b are integer matrices, % then r is the matrix of remainders after division % by corresponding entries. Compare with REM. r=a-d.*floor(a./d);

The MATLAB statement r = mod(20,3) would call this function, assuming it has been saved to a disk file, and assign 20 and 3 to the variables a and d, respectively, in the function. Variables in a function are by default local variables, so the previous statement would not change the values of variables a or d in the global MATLAB interface, only in the function itself. Functions can have multiple outputs, as in the following example:

function [mean, stdev] = stat(x) % STAT Mean and standard deviation %     For a vector x, stat(x) returns the %     mean and standard deviation of  x.     %      For a matrix x, stat(x) returns two row vectors containing, %     respectively, the mean and standard deviation of each column. [m n] = size(x); if m == 1 m = n;    % handle case of a row vector end mean = sum(x)/m; stdev = sqrt(sum(x.^ 2)/m - mean.^2);

With this function file saved, the statement [mn, dev] = stat(q) would call the stat function and assign the standard deviation of vector q to the global variable dev, and the mean of vector q to the global variable mn. MATLAB function are either built in or saved as M-files. To discover the type of file, built in or user-created, simply command type functionname.

Text Strings
To enter a text string into MATLAB, simply surround the string with single quotes. An example of this is:

string1 = ‘this is a text string’

This statement assigns the text “this is a text string” to the variable string1. To display a given text string the MATLAB function disp is used. For example:

disp (‘this string will be shown’)

The MATLAB function error is used to display a text string that explains to the user that an error has been committed and aborts the M-file.

To prompt the user to enter data, the function input is used. For example the statement

iter = input('Enter average test score: ')

would cause MATLAB to display the text asking for a number until the user has entered in data.

Managing M-files
MATLAB makes it possible to easily edit or add M-files while remaining in the MATLAB user interface. The symbol ! is used to denote a command concerning directory files. To edit any existing M-file, use the command !ed. For example, the statement

!ed stat.m

would open the MATLAB file editor with the code for the function stat. In many cases, it is preferable to run the editor and MATLAB running simultaneously, with the application not in use suspended in the background.

To see the files saved in your set MATLAB directory, the command dir is used to list all files saved to that folder. The command what displays only the M-files saved in that folder. To change the working directory, use the command chdir. To delete an M-file, use the command delete. As noted all these commands should be preceded by a ! to avoid system confusion.

Comparing Efficiency of Algorithms
To determine the efficiency of an algorithm within MATLAB, two measures can be employed. The function flops keeps track of the number of floating point operations performed in an algorithm. The command flops(0) resets this count to 0. The other measure is the total elapsed time to execute a task. The function etime(t2,t1) gives the time elapsed between two times. The function clock gives an extremely accurate gauge of the current time. To measure the time to perform the function stat the following command could be used.

t = clock; [mn, dev] = stat(q) time = etime(clock,t)

The measure of flops is considered much more accurate as the time required to complete a task depends greatly on the number of processes currently running on the system.

Output Format
Using the format command the user can change the format of the displayed output. Here are some choices with data from the help command:

Hardcopy
In order to obtain a hardcopy one's work, the easiest command to use is diary filename. This will begin writing everything that appears on the screen until the command diary off is entered. The command diary on will resume writing. This file can be viewed later and printed. The diary command will not record graphics.

Graphics
A user can plot different types of graphs using the primary commands plot, plot3, mesh, and surf. The plot command is used for creating linear x-y plots, such as a sine curve or an exponential. To graph a sine wave from -pi to pi a user can enter the following command: x = -pi:.01:pi; y = sin(x); plot(x,y) It is possible to plot multiple curves on the same graph by adding more arguments into the parentheses, like so: x = -pi:.01:pi; y1 = sin(x); y2=cos(x); plot(x,y1,x,y2) Changing the color and linetype of the lines being plotted is also possible by adding arguments into the plot command. For example: x = -pi:.01:pi; y1 = sin(x); y2=cos(x); plot(x,y1,'b--',x,y2,'y:') Will produce a sine curve with a blue dashed line and a cosine curve with a yellow dotted line. Graphs can be labeled by the following commands: The hold command will allow the next plot to be superimposed on top of the old plot until the command "hold off" is used. To save a graph the command print filename is useful. It will automatically save as a *.ps PostScript file unless a file extension is specified. Adding to the command, print -append filename, one can add multiple images to the same image file. A 3-D line plot can be displayed with the command plot3(x,y,z) by including 3 vectors of the same size. A mesh plot or a surface plot can be displayed with the commands mesh(x) or surf(x). Shading on surfaces can be controlled with the "shading" command. The commands "set(1)" and "gca,set(ans)" can be used to control properties of graphs.

Sparse Matrix Computations
In the event that a user must perform many calculations with matrices containing a large amount of zeros, the "sparse" command can be used to ignore the zeros and save time and storage space. With matrix B containing a large amount of zeros, matrix S can save space by entering the command S = sparse(B). The process can be reversed by entering the command B=full(S).

The function spdiags can create a sparse banded matrix by specifying diagonals.

Individual Contributions
The following links include the individual contributions by group members responsible for portions of the MATLAB tutorial or course notes. The remaining members were responsible for checking the presented material for coherency, rhetoric, and aesthetics. The contributions of the team leader can be found by following the history records of this page.

User:Eml4500.f08.bottle.butler/HW 1 21:28, 17 September 2008 (UTC) user:Eml4500.f08.bottle.barnes/HW1 Braden Barnes Eml4500.f08.bottle.barnes 20:23, 17 September 2008 (UTC) User:Eml4500.f08.bottle.ranto/HW_1_My_section Eml4500.f08.bottle.ranto 15:23, 17 September 2008 (UTC) User:Eml4500.f08.bottle.loschak User:Eml4500.f08.bottle.vitello/HW 1  Eml4500.f08.bottle.vitello 06:16, 17 September 2008 (UTC) Eml4500.f08.bottle.brockmiller 21:15, 17 September 2008 (UTC) Eml4500.f08.bottle.loschak 07:05, 17 September 2008 (UTC)