Baixe tutorial de Scilab e outras Notas de estudo em PDF para Engenharia Química, somente na Docsity!
Scilab
A Hands on Introduction
by
Satish Annigeri Ph.D.
Professor of Civil Engineering
B.V. Bhoomaraddi College of Engineering & Technology, Hubli
Department of Civil Engineering
B.V. Bhoomaraddi College of Engineering & Technology, Hubli
17 & 18 April, 2004
Preface
Scilab is a software for numerical mathematics and scientific visualization. It is capable of
interactive calculations as well as automation of computations through programming. It provides
all basic operations on matrices through built-in functions so that the trouble of developing and
testing code for basic operations are completely avoided. Its ability to plot 2D and 3D graphs
helps in visualizing the data we work with. All these make Scilab an excellent tool for teaching,
especially those subjects that involve matrix operations. Further, the numerous toolboxes that are
available for various specialized applications make it an important tool for research. Being
compatible with Matlab®, all available Matlab M-files can be directly used in Scilab. Scicos, a
hybrid dynamic systems modeler and simulator for Scilab, simplifies simulations. The greatest
features of Scilab are that it is multi-platform and is free. It is available for many operating
systems including Windows, Linux and MacOS X. More information about the features of
Scilab are given in the Introduction.
Scilab can help a student understand all intermediate steps in solving even complicated
problems, as easily as using a calculator. In fact, it is a calculator that is capable of matrix
algebra computations. Once the student is sure of having mastered the steps, they can be
converted into functions and whole problems can be solved by simply calling a few functions.
Scilab is an invaluable tool as solved problems need not be restricted to simple examples to suit
hand calculations.
Scilab is the outcome of years of development and continues to be improved and developed.
Having a rich set of features and being in wide use, its developers could very well have chosen
to commercialize it. But they have chosen to make it a 'free' software. Free, as in 'free of cost' as
well as in 'freedom', because the source code is also available for those who wish to modify and
improve it. You can visit the following websites to see some definitions of software freedom
and licensing issues:
http://www.fsf.org/licenses/licenses.html and
Open Source Initiative ( http://www.opensource.org/licenses
You can also read the Scilab software license at the following website:
http://scilabsoft.inria.fr/license.txt
The Scilab license is included in the Appendix at the end of this document.
When its developers have been so generous, we as users must contribute to this movement
by learning to use it and applying it to solve problems. This tutorial is an attempt to introduce
students to the basics of Scilab. The next part of the tutorial is aimed at teaching students of
Civil Engineering to the basics of Scilab by applying it to the problem of matrix analysis of
plane frames. I hope this motivates students to learn and apply Scilab to solve a wider range of
problems.
This is the first version of this document and will certainly contain errors, typographical as
well as factual. You can help improve this document by reporting all errors you find and by
suggesting modifications and additions. Your views are always welcome. I can be reached at the
email address given on the cover page.
Acknowledgments
It goes without saying that my first indebtedness is to the developers of Scilab and the
consortium that continues to develop it. I must also thank Dr. A.B. Raju, E&EE Department,
BVBCET who first introduced me to Scilab and forever freed me from using Matlab.
April 2004 Satish Annigeri
Scilab Tutorial ii
Introduction
Scilab is a scientific software package for numerical computations providing a powerful
open computing environment for engineering and scientific applications. Developed since 1990
by researchers from INRIA (French National Institute for Research in Computer Science and
Control, http://www.inria.fr/index.en.html ) and ENPC (National School of Bridges and
Roads, http://www.enpc.fr/english/int_index.htm ), it is now maintained and developed
by Scilab Consortium ( http://scilabsoft.inria.fr/consortium/consortium.html ) since
its creation in May 2003.
Distributed freely and open source through the Internet since 1994, Scilab is currently being
used in educational and industrial environments around the world.
Scilab includes hundreds of mathematical functions with the possibility to add interactively
programs from various languages (C, Fortran...). It has sophisticated data structures (including
lists, polynomials, rational functions, linear systems...), an interpreter and a high level
programming language.
Scilab has been designed to be an open system where the user can define new data types and
operations on these data types by using overloading.
A number of toolboxes are available with the system:
- 2-D and 3-D graphics, animation
- Linear algebra, sparse matrices
- Polynomials and rational functions
- Simulation: ODE solver and DAE solver
- Scicos: a hybrid dynamic systems modeler and simulator
- Classic and robust control, LMI optimization
- Differentiable and non-differentiable optimization
- Signal processing
- Metanet: graphs and networks
- Parallel Scilab using PVM
- Statistics
- Interface with Computer Algebra (Maple, MuPAD)
- Interface with Tcl/Tk
- And a large number of contributions for various domains.
Scilab works on most Unix systems including GNU/Linux and on Windows
9X/NT/2000/XP. It comes with source code, on-line help and English user manuals. Binary
versions are available.
Some of its features are listed below:
- Basic data type is a matrix, and all matrix operations are available as built-in operations.
- Has a built-in interpreted high-level programming language.
- Graphics such as 2D and 3D graphs can be generated and exported to various formats so
that they can be included into documents.
To the left is a 3D graph generated in Scilab and
exported to GIF format and included in the
document for presentation. Scilab can export to
Postscript and GIF formats as well as to Xfig
(popular free software for drawing figures) and
LaTeX (free scientific document preparation
system) file formats.
Scilab Tutorial Introduction | 1
Tutorial 2 – The Workspace and Working Directory
While the Scilab environment is the visible face of Scilab, there is another that is not
visible. It is the memory space where all variables and functions are stored, and is called the
Workspace. Many a times it is necessary to inspect the workspace to check whether a variable
or a function has been defined or not. The following commands help the user in inspecting the
memory space: who , whos a nd who_user(). Use the online help to learn more about these
commands.
The who command lists the names of variables in the Scilab workspace. Note the variable
names preceded by the “%” symbol. These are special variables that are used often and therefore
predefined by Scilab. It includes %pi ( ), %e ( e^ ), %i ( (^) − 1 ), %inf ( ∞^ ), %nan (NaN) and
others.
The whos command lists the variables along with the amount of memory they take up in
the workspace. The variables to be listed can be selected based on either their type or name.
Some examples are:
-->whos()
Lists entire contents of the workspace, including functions,
libraries, constants
-->whos -type constants
Lists only variables that can store real or complex constants.
Other types are boolean, string, function, library, polynomial
etc. For a complete list use the command -->help typeof.
-->whos -name nam Lists all variables whose name begins with the letters nam
To understand how Scilab deals with numbers, try out the following commands and use the
whos command as follows:
-->a1=5; Defines a real number variable with name ' a1'
-->a2=sqrt(-4) Defines a complex number variable with name ' a2'
-->a3=[1, 2; 3, 4] Defines a 2x2 matrix with name ' a3 '
-->whos -name a Lists all variables with name starting with the letter ' a '
Name Type Size Bytes
a3 constant 2 by 2 48
a2 constant 1 by 1 32
a1 constant 1 by 1 24
Now try the following commands:
-->a1=sqrt(-9) Converts ' a1 ' to a complex number
-->whos -name a Note that ' a ' is now a complex number
-->a1=a3 Converts ' a1 ' to a matrix
-->whos -name a Note that ' a ' is now a matrix
-->save('ex01.dat') Saves all variables in the workspace to a disk file ex01.dat
-->load('ex01.dat') Loads all variables from a disk file ex01.dat to workspace
Note the following points:
Scilab treats a scalar number as a matrix of size 1x1 (and not as a simple number)
because the basic data type in Scilab is a matrix.
Scilab automatically converts the type of the variable as the situation demands. There is
no need to specifically define the type for the variable.
Scilab Tutorial Tutorial 2 – The Workspace and Working Directory | 3
Tutorial 3 – Matrix Operations
Matrix operations that are built-in into Scilab are addition, subtraction, multiplication,
transpose, inversion, determinant, trigonometric, logarithmic, exponential functions and many
others. Study the following examples:
-->a=[1 2 3; 4 5 6; 7 8 9]; Define a 3x3 matrix
-->b=a'; Transpose a and store it in b.
-->c=a+b Add^ a^ to^ b^ and store the result in^ c.^ a^ and^ b^ must be of the
same size.
-->d=a-b Subtract b from a and store the result in d.
-->e=a*b
Multiply a with b and store the result in e. a and b must be
comptible for matrix multiplication.
-->f=[3 1 2; 1 5 3; 2 3 6]; Define a 3x3 matrix with name f.
-->g=inv(f)
Invert matrix f and store the result in g. f must be square
and positive definite. A warning will be displayed if it is ill
conditioned.
-->f*g The answer must be an identity matrix
-->det(f) Determinant of f.
-->log(a) Matrix of log of each element of a.
-->a .* b Element by element multiplication.
-->a^2 Same as a*a.
-->a .^2 Element by element square.
There are some handy functions to generate commonly used matrices, such as zero matrices,
identity matrices etc.
-->a=zeros(5,8) Creates a 5x8 matrix with all elements zero.
-->b=ones(4,6) Creates a 4x6 matrix with all elements 1
-->c=eye(3,3) Creates a 3x3 identity matrix
-->d=eye(3,3)*10 Creates a 3x3 diagonal matrix
It is possible to generate a range of numbers to form a vector. Study the following
command:
-->a=[1:5] Creates a vector with 5 elements as follows [1, 2, 3, 4, 5]
-->b=[0:0.5:5]
Creates a vector with 11 elements as follows [0, 0.5, 1.0,
1.5, ... 4.5, 5.0]
A range requires a start value, an increment and an ending value, separated by colons (:). If
only two values are given (separated by only one colon), they are taken to be the start and end
values and incremented is assumed to be 1.
You can create an empty matrix with the command a=[].
Scilab Tutorial Tutorial 3 – Matrix Operations | 4
Tutorial 5 – Statistics
Scilab can perform all basic statistical calculations. The data is assumed to be contained in a
matrix and calculations can be performed treating rows (or columns) as the observations and the
columns (or rows) as the parameters. To choose rows as the observations, the indicator is ' r ' or
1. To choose columns as the observations, the indicator is ' c ' or 2. If no indicator is furnished,
the operation is applied to the entire matrix element by element. The available statistical
functions are sum() , mean() , stdev() , st_deviation() , median().
Let us first generate a matrix of 5 observations on 3 parameters. Let the elements be random
numbers. This is done using the following command:
-->a=rand(5,3) Creates a 5x3 matrix of random numbers.
Assuming rows to be observations and columns to be parameters, the sum, mean and
standard deviation are calculated as follows:
-->s=sum(a, 'r') Sum of columns of a.
-->m=mean(a,1) Mean value of each column of a.
-->sd=stdev(a, 1) Standard deviation of a.
-->sd2=st_deviation(a, 'r') Standard deviation of a. Sample size std.
-->mdn=median(a,'r') Median of columns of a.
The same operations can be performed treating columns as observations by replacing the ' r '
or 1 with ' c ' or 2.
When neither ' r ' (or 1) nor ' c ' (or 2) is supplied, the operations are carried out treating the
entire matrix as a set of observations on a single parameter.
The maximum and minimum values in a column, row or matrix can be obtained with the
max() and min() functions respectively in the same way as the above statistical functions,
except that you must use ' r ' or ' c ' but not 1 or 2.
Scilab Tutorial Tutorial 5 – Statistics | 6
Tutorial 6 – Plotting Graphs
Let us learn to plot simple graphs. We first have to generate the data to be used for the
graph. Let us assume we want to draw the graph of cos^ x ^ and sin^ x^ ^ for one full cycle ( 2
radians). Let us first generate the values for the x-axis with the following command:
-->x=[0:%pi/16:2*%pi];
In the above command, note that %pi is a predefined constant representing the value of .
The command to create a range of values, 0:%pi/16:2*%pi , requires a starting value, an
increment and an ending value. In the above example, they are 0, / 16 and 2 respectively.
The increment is optional and when not given, it is taken to be 1. Thus, ' x ' is a vector with 33
elements.
Next, let us create the values for the y-axis, first column representing cosine and the second
sine. They are created by the following commands:
-->y=[cos(x) sin(x)]
Note that cos(x) and sin(x) are the two columns of a new matrix which is first created
and then stored in y. We can now plot the graph with the command:
-->plot2d(x,y)
The graph generated by this command is shown below. The graph can be enhanced and
annotated. You can add grid lines, labels for x- and y-axes, legend for the different lines etc.
Fig. 2 Graph of sin(x) and cos(x) using function plot2d()
You can learn more about the plot2d and other related functions from the online help.
Scilab Tutorial Tutorial 6 – Plotting Graphs | 7
Tutorial 8 – Functions in Scilab
Functions serve the same purpose in Scilab as in other programming languages. They are
independent blocks of code, with their own input and output parameters that can be associated
with variables at the time of calling the function. They modularize a program and encapsulate a
series of statements and associate them with the name of the function.
Scilab provides a built in editor, called as SciPad within Scilab wherein the user can type the
code for functions and compile and load it into the workspace. SciPad can be invoked by
clicking on 'Editor' choice on the main menu at the top of the Scilab work environment.
Let us write a simple function to calculate the length of a line in the x-y plane, given the
coordinates of its two ends (x1, y1) and (x2, y2). The length of such a line is given by the
expression (^) l = x 2 − x 1 ^2 y 2 − y 1 ^2. Before defining the function in SciPad, let us try it out in
Scilab.
-->x1=1; y1=4; x2=10; y2=6;
-->dx=x2-x1; dy=y2-y1;
-->l=sqrt(dx^2 + dy^2)
l =
Studying the above statements to be put into the functions, notice that x1 , y1 , x2 and y2 are
input values and the length ' l ' is the output parameter. Define the code as described below:
1. Open SciPad by clicking on Editor on the main menu.
2. Type the lines of code to define the function.
3. Save the contents of the file to a disk file by clicking File > Save in SciPad and choosing
a name for the file.
4. Load the function into Scilab by clicking on 'Load into Scilab' on the SciPad main menu.
type the following code into SciPad:
function [l] = len(x1, y1, x2, y2)
dx=x2-x1; dy=y2-y1;
l=sqrt(dx^2 + dy^2);
endfunction
In the above code, function and endfunction are Scilab keywords and must be typed
exactly as shown. They signify the start and end of a function definition.
The variable enclosed between square brackets is an output parameter, and will be returned
to Scilab workspace (or to the parent function from where it was invoked). The name of the
function has been chosen as ' len ' (short for length, as the name length is already used by Scilab
for another purpose). The input parameters x1 , y1 , x2 and y2 are the variables bringing in input
from the Scilab workspace (or the parent function from where it is called). This function will be
invoked as ll = len(xx1,yy1,xx2,yy2) where ll is the output variable and xx1 , yy1 ,
xx2 and yy2 are the input variables. Note that their names need not match the corresponding
names in the function definition.
Note the semicolons (;) used at the end of the executable statements which suppress the
echo of intermediate results. You can remove them if you need to debug the function when the
results are not matching the expected results. Alternately, use the function disp() to print out
intermediate results within a function to debug it and remove it once the bug is eliminated.
To try out the function, load it into Scilab by first saving the contents to a disk file (File >
Save) and then clicking on 'Load into Scilab'. If there are no syntax errors in your function
definition, it will be loaded into Scilab workspace and this can be verified with the command
whos -type function and searching for the name of your function, namely, len. To use the
function enter the following command: l=len(1,4,10,6).
However, if there are syntax errors, the line on which the error occurs is displayed and you
will have to remove the syntax errors and repeat the above steps.
Scilab Tutorial Tutorial 8 – Functions in Scilab | 9
Tutorial 9 – Miscellaneous Commands
Some commands related to operations on disks are important and they are listed below.
They are important when you want to change the directory in which your function files are stored
or from where they are they are to be read.
pwd Prints the name of the current working directory
getcwd() Same as pwd.
chdir('dir') Changes the working directory to a different disk location named dir.
It is possible to save all the variables in the Scilab Workspace to a disk file so that you can
quickly reload all the variables and functions from a previous session and continue from where
you left off. The commands used for this purpose are:
save('pf.bin')
Saves entire contents of the Scilab workspace (variables and functions)
in the file pf.bin in the current working directory.
load('pf.bin')
Restores contents of the Scilab workspace from the file pf.bin in the
current working directory.
save('pf.bin', xy)
Saves only the variable xy of the Scilab workspace in the file pf.bin
in the current working directory.
It is possible to determine the size of variables in the Scilab workspace with the following
command:
size(xy)
Returns a 1x2 matrix containing the number of rows and columns in the
variable xy.
length(xy) Returns the number of elements in xy (rows multiplied by columns).
Scilab can open files on disk and a number of functions are available for opening, closing
reading and writing disk files. The following lines of code illustrate how this can be
accomplished:
-->n=10; x=25.5; xy=[100 75;0 75; 200, 0];
-->fd=file(“ex01.dat”, “w”); // Opens a file ex01.dat for writing
-->mfprintf(fd, “n=%d, x=%f\n”, n, x);
-->mfprintf(fd, “%12.4f\t%12,4f\n”, xy);
-->mclose(fd);
You can now open the file ex01.dat in a text editor, such as notepad and see its contents.
You will notice that the commands are similar to the corresponding commands in C, namely,
fopen() , fprintf() and fclose(). Note that in the second command, the format string
must be sufficient to print one full row of the matrix xy. The sequence of operations must
always be, open the file and obtain a file descriptor, write to the file using the file descriptor and
close the file using the file descriptor.
Scilab Tutorial Tutorial 9 – Miscellaneous Commands | 10
- the DERIVED SOFTWARE is distributed under a name other than SCILAB. d) Any commercial use or circulation of the DERIVED SOFTWARE shall have been previously authorized by INRIA and ENPC. 5- Object and conditions of the license concerning COMPOSITE SOFTWARE
a) INRIA and ENPC authorize you to reproduce and interface all or part of the SOFTWARE with all or part of other software, application packages or toolboxes of which you are owner or entitled beneficiary in order to obtain COMPOSITE SOFTWARE. b) INRIA and ENPC authorize you free, of charge, to use the SOFTWARE source and/or object code included in the COMPOSITE SOFTWARE, without restriction, providing the following statement appears in all the copies: "composite software using Scilab (c)INRIA-ENPC functionality". c) INRIA and ENPC authorize you, free of charge, to circulate and distribute for no charge, for purposes other than commercial, the source and/or object code of COMPOSITE SOFTWARE on any present and future support, providing:
- the following reference is prominently mentioned: "composite software using Scilab (c)INRIA-ENPC functionality ";
- the SOFTWARE included in COMPOSITE SOFTWARE is distributed under the present license ;
- recipients of the distribution have access to the SOFTWARE source code;
- the COMPOSITE SOFTWARE is distributed under a name other than SCILAB. e) Any commercial use or distribution of COMPOSITE SOFTWARE shall have been previously authorized by INRIA and ENPC. 6- Limitation of the warranty
Except when mentioned otherwise in writing, the SOFTWARE is supplied as is, with no explicit or implicit warranty, including warranties of commercialization or adaptation. You assume all risks concerning the quality or the effects of the SOFTWARE and its use. If the SOFTWARE is defective, you will bear the costs of all required services, corrections or repairs. 7- Consent
When you access and use the SOFTWARE, you are presumed to be aware of and to have accepted all the rights and obligations of the present license. 8- Binding effect
This license has the binding value of a contract. You are not responsible for respect of the license by a third party. 9- Applicable law
The present license and its effects are subject to French law and the competent French courts.
Scilab Tutorial Appendix | 12
Notes
Scilab Tutorial
