We present now some simple commands. At the carriage return all the commands typed since the last prompt are interpreted.
-->a=1;
-->A=2;
-->a+A
ans =
3.
-->//Two commands on the same line
-->c=[1 2];b=1.5
b =
1.5
-->//A command on several lines
-->u=1000000.000000*(a*sin(A))^2+...
--> 2000000.000000*a*b*sin(A)*cos(A)+...
--> 1000000.000000*(b*cos(A))^2
u =
81268.994
Give the values of 1 and 2 to the variables a and A . The semi-colon at the end of the command suppresses the display of the result. Note that Scilab is case-sensitive. Then two commands are processed and the second result is displayed because it is not followed by a semi-colon. The last command shows how to write a command on several lines by using ``...''. This sign is only needed in the on-line typing for avoiding the effect of the carriage return. The chain of characters which follow the // is not interpreted (it is a comment line).
-->a=1;b=1.5;
-->2*a+b^2
ans =
4.25
-->//We have now created variables and can list them by typing:
-->who
your variables are...
ans b a bugmes MSDOS home PWD
TMPDIR percentlib fraclablib soundlib xdesslib
utillib tdcslib siglib s2flib roblib optlib metalib
elemlib commlib polylib autolib armalib alglib mtlblib
SCI %F %T %z %s %nan %inf
old newstacksize $ %t %f %eps
%io %i %e %pi
using 3975 elements out of 1000000.
and 43 variables out of 1023
We get the list of previously defined variables a b c A together with the initial environment composed of the different libraries and some specific ``permanent'' variables.
Below is an example of an expression which mixes constants with existing variables. The result is retained in the standard default variable ans .
-->I=1:3
I =
! 1. 2. 3. !
-->W=rand(2,4);
-->W(1,I)
ans =
! 0.2113249 0.0002211 0.6653811 !
-->W(:,I)
ans =
! 0.2113249 0.0002211 0.6653811 !
! 0.7560439 0.3303271 0.6283918 !
-->W($,$-1)
ans =
0.6283918
Defining I, a vector of indices, W a random 2 x 4 matrix,
and extracting submatrices from W. The $ symbol stands
for the last row or last column index of a matrix or vector. The colon
symbol stands for ``all rows'' or ``all columns''.
-->sqrt([4 -4]) ans = ! 2. 2.i !
Calling a function (or primitive) with a vector argument. The response is a complex vector.
-->p=poly([1 2 3],'z','coeff')
p =
2
1 + 2z + 3z
-->//p is the polynomial in z with coefficients 1,2,3.
-->//p can also be defined by :
-->s=poly(0,'s');p=1+2*s+s^2
p =
2
1 + 2s + s
A more complicated command which creates a polynomial.
-->M=[p, p-1; p+1 ,2]
M =
! 2 2 !
! 1 + 2s + s 2s + s !
! !
! 2 !
! 2 + 2s + s 2 !
-->det(M)
ans =
2 3 4
2 - 4s - 4s - s
Definition of a polynomial matrix. The syntax for polynomial matrices is the same as for constant matrices. Calculation of the determinant of the polynomial matrix by the det function.
-->F=[1/s ,(s+1)/(1-s)
--> s/p , s^2 ]
F =
! 1 1 + s !
! - ----- !
! s 1 - s !
! !
! 2 !
! s s !
! --------- - !
! 2 !
! 1 + 2s + s 1 !
-->F('num')
ans =
! 1 1 + s !
! !
! 2 !
! s s !
-->F('den')
ans =
! s 1 - s !
! !
! 2 !
! 1 + 2s + s 1 !
-->F('num')(1,2)
ans =
1 + s
Definition of a matrix of rational polynomials. (The internal representation of F is a typed list of the form tlist('the type',num,den) where num and den are two matrix polynomials). Retrieving the numerator and denominator matrices of F by extraction operations in a typed list. Last command is the direct extraction of entry 1,2 of the numerator matrix F('num').
-->pause
-1->pt=return(s*p)
-->pt
pt =
2 3
s + 2s + s
Here we move into a new environment using the command pause and we obtain the new prompt -1-> which indicates the level of the new environment (level 1). All variables that are available in the first environment are also available in the new environment. Variables created in the new environment can be returned to the original environment by using return . Use of return without an argument destroys all the variables created in the new environment before returning to the old environment. The pause facility is very useful for debugging purposes.
-->F21=F(2,1);v=0:0.01:%pi;frequencies=exp(%i*v);
-->response=freq(F21('num'),F21('den'),frequencies);
-->plot2d(v',abs(response)',[-1],'011',' ',[0,0,3.5,0.7],[5,4,5,7]);
-->xtitle(' ','radians','magnitude');
Definition of a rational polynomial by extraction of an entry of the matrix F defined above. This is followed by the evaluation of the rational polynomial at the vector of complex frequency values defined by frequencies. The evaluation of the rational polynomial is done by the primitive freq. F12('num') is the numerator polynomial and F12('den') is the denominator polynomial of the rational polynomial F12. Note that the polynomial F12('num') can be also obtained by extraction from the matrix F using the syntax F('num')(1,2). The visualization of the resulting evaluation is made by using the basic plot command plot2d (see Figure 1.1).
-->w=(1-s)/(1+s);f=1/p
f =
1
---------
2
1 + 2s + s
-->horner(f,w)
ans =
2
1 + 2s + s
----------
4
The function horner performs a (possibly symbolic) change of variables for a polynomial (for example, here, to perform the bilinear transformation f(w(s))).
-->A=[-1,0;1,2];B=[1,2;2,3];C=[1,0];
-->Sl=syslin('c',A,B,C);
-->ss2tf(Sl)
ans =
! 1 2 !
! ----- ----- !
! 1 + s 1 + s !
Definition of a linear system in state-space representation. The function syslin defines here the continuous time ('c') system Sl with state-space matrices (A,B,C). The function ss2tf transforms Sl into transfer matrix representation.
-->s=poly(0,'s');
-->R=[1/s,s/(1+s),s^2]
R =
! 2 !
! 1 s s !
! - ----- - !
! s 1 + s 1 !
-->Sl=syslin('c',R);
-->tf2ss(Sl)
ans =
ans(1) (state-space system:)
!lss A B C D X0 dt !
ans(2) = A matrix =
! - 0.5 - 0.5 !
! - 0.5 - 0.5 !
ans(3) = B matrix =
! - 1. 1. 0. !
! 1. 1. 0. !
ans(4) = C matrix =
! - 1. 0. !
ans(5) = D matrix =
! 2 !
! 0 1 s !
ans(6) = X0 (initial state) =
! 0. !
! 0. !
ans(7) = Time domain =
c
Definition of the rational matrix R. Sl is the continuous-time linear system with (improper) transfer matrix R. tf2ss puts Sl in state-space representation with a polynomial D matrix. Note that linear systems are represented by specific typed lists (with 7 entries).
-->sl1=[Sl;2*Sl+eye()] sl1 = ! 2 ! ! 1 s s ! ! - ----- - ! ! s 1 + s 1 ! ! ! ! 2 ! ! 2 + s 2s 2s ! ! ----- ---- --- ! ! s 1 + s 1 ! -->size(sl1) ans = ! 2. 3. ! -->size(tf2ss(sl1)) ans = ! 2. 3. !
sl1 is the linear system in transfer matrix representation obtained by the parallel inter-connection of Sl and 2*Sl +eye(). The same syntax is valid with Sl in state-space representation.
-->deff('[Cl]=compen(Sl,Kr,Ko)',[ '[A,B,C,D]=abcd(Sl);';
--> 'A1=[A-B*Kr ,B*Kr; 0*A ,A-Ko*C]; Id=eye(A);';
--> 'B1=[B; 0*B];';
--> 'C1=[C ,0*C];Cl=syslin(''c'',A1,B1,C1)' ])
On-line definition of a function, called compen which calculates the state space representation (Cl) of a linear system (Sl) controlled by an observer with gain Ko and a controller with gain Kr. Note that matrices are constructed in block form using other matrices.
-->A=[1,1 ;0,1];B=[0;1];C=[1,0];Sl=syslin('c',A,B,C);
-->Cl=compen(Sl,ppol(A,B,[-1,-1]),...
--> ppol(A',C',[-1+%i,-1-%i])');
-->Aclosed=Cl('A'),spec(Aclosed)
Aclosed =
! 1. 1. 0. 0. !
! - 4. - 3. 4. 4. !
! 0. 0. - 3. 1. !
! 0. 0. - 5. 1. !
ans =
! - 1. !
! - 1. !
! - 1. + i !
! - 1. - i !
Call to the function compen defined above where the gains were calculated by a call to the primitive ppol which performs pole placement. The resulting Aclosed matrix is displayed and the placement of its poles is checked using the primitive spec which calculates the eigenvalues of a matrix. (The function compen is defined here on-line by deff as an example of function which receive a linear system (Sl) as input and returns a linear system (Cl) as output. In general Scilab functions are defined in files and loaded in Scilab by getf).
-->//Saving the environment in a file named : myfile
-->save('myfile')
-->//Request to the host system to perform a system command
-->unix_s('rm myfile')
-->//Request to the host system with output in this Scilab window
-->unix_w('date')
Thu Nov 12 15:54:58 MET 1998
Relation with the Unix environment.
-->foo=['void foo(a,b,c)';
--> 'double *a,*b,*c;'
--> '{ *c = *a + *b;}']
foo =
!void foo(a,b,c) !
! !
!double *a,*b,*c; !
! !
!{ *c = *a + *b;} !
-->write('foo.c',foo);
-->unix_s('make foo.o')
-->link('foo.o','foo','C');
-->deff('[c]=myplus(a,b)',...
--> 'c=fort(''foo'',a,1,''d'',b,2,''d'',''out'',[1,1],3,''d'')')
-->myplus(5,7)
ans =
12.
Definition of a column vector of character strings used for defining a C function file. The routine is compiled (needs a compiler), dynamically linked to Scilab by the link command, and interactively called by the function myplus.
-->deff('[ydot]=f(t,y)','ydot=[a-y(2)*y(2) -1;1 0]*y')
-->a=1;y0=[1;0];t0=0;instants=0:0.02:20;
-->y=ode(y0,t0,instants,f);
-->plot2d(y(1,:)',y(2,:)',[-1],'011',' ',[-3,-3,3,3],[10,2,10,2])
-->xtitle('Van der Pol')
Definition of a function which calculates a first order vector differential
f(t,y). This is followed by the definition of the constant a
used in the function. The primitive ode
then integrates the differential equation defined by the Scilab
function f(t,y)
for y0=[1;0] at t=0 and where the solution is given
at the time values
.
(Function f can
be defined as a C or Fortran program). The result is plotted in
Figure 1.2 where the first element of the integrated vector is
plotted against the second element of this vector.
-->m=['a' 'cos(b)';'sin(a)' 'c']
m =
!a cos(b) !
! !
!sin(a) c !
-->//m*m' --> error message : not implemented in scilab
-->deff('[x]=%c_m_c(a,b)',['[l,m]=size(a);[m,n]=size(b);x=[];';
--> 'for j=1:n,y=[];';
--> 'for i=1:l,t='' '';';
--> 'for k=1:m;';
--> 'if k>1 then t=t+''+(''+a(i,k)+'')*''+''(''+b(k,j)+'')'';';
--> 'else t=''('' + a(i,k) + '')*'' + ''('' + b(k,j) + '')'';';
--> 'end,end;';
--> 'y=[y;t],end;';
--> 'x=[x y],end,'])
-->m*m'
ans =
!(a)*(a)+(cos(b))*(cos(b)) (a)*(sin(a))+(cos(b))*(c) !
! !
!(sin(a))*(a)+(c)*(cos(b)) (sin(a))*(sin(a))+(c)*(c) !
Definition of a matrix containing character strings. By default, the
operation of symbolic multiplication of two matrices of character
strings is not defined in Scilab. However, the (on-line)
function definition for %cmc defines the multiplication of
matrices of character strings (note that the double quote is necessary
because the body of the deff contains quotes inside of quotes).
The % which begins the function definition for %cmc
allows the definition of an operation which did not previously
exist in Scilab, and the name cmc means ``chain multiply chain''.
This example is not very useful: it is simply given to show
how operations such as * can be defined on complex data
structures by mean of scpecific Scilab functions.
-->deff('[y]=calcul(x,method)','z=method(x),y=poly(z,''x'')')
-->deff('[z]=meth1(x)','z=x')
-->deff('[z]=meth2(x)','z=2*x')
-->calcul([1,2,3],meth1)
ans =
2 3
- 6 + 11x - 6x + x
-->calcul([1,2,3],meth2)
ans =
2 3
- 48 + 44x - 12x + x
A simple example which illustrates the passing of a function as an argument to another function. Scilab functions are objects which may be defined, loaded, or manipulated as other objects such as matrices or lists.
-->quit
Exit from Scilab.
