1  Programming

1.1   abort interrupt evaluation.

1.2   addinter new functions interface incremental linking at run time

addinter(files,spname,fcts)

• files : a character string or a vector of character string contain object files used to define the new Scilab interface routine (interface code, user routines or libraries, system libraries).
• spname : a character string. Name of interface routine entry point
• fcts : vector of character strings. The name of new Scilab function implemented in the new interface (in fin the order ).

1.3   and - logical and

b=and(A),  b=and(A,'*')
b=and(A,'r'), b=and(A,1)
b=and(A,'c'), b=and(A,2)
A&B

1.4   ans answer

1.5   apropos searches keywords in Scilab help

apropos word
apropos 'string'

apropos '+'
apropos ode 
apropos 'list of'

1.6   argn number of arguments in a function call

[lhs [,rhs] ]=argn(0)

1.7   backslash - left matrix division.

x=A\\b

A=rand(3,2);b=[1;1;1]; x=A\\b; y=pinv(A)*b;  x-y
A=rand(2,3);b=[1;1]; x=A\\b; y=pinv(A)*b; x-y, A*x-b, A*y-b
A=rand(3,1)*rand(1,2); b=[1;1;1]; x=A\\b; y=pinv(A)*b; A*x-b, A*y-b
A=rand(2,1)*rand(1,3); b=[1;1]; x=A\\b; y=pinv(A)*b; A*x-b, A*y-b 

1.8   binary binary file management

[fd,err]=mopen('file-name' [, mode,  swap ])
[err]=mclose([fd])
[x]=mget([n,type,fd])       // default values n=1,type='l',fd=-1
[err]=mput(x [,type,fd])    // default values type='l',fd=-1
str=mgetstr([n,fd])         // default values n=1, fd=-1
[err]=mputstr(str [, fd]);  // default value  fd = -1 
[err]=meof([fd])            // default value  fd = -1 
mclearerr([fd])            // default value  fd = -1 
mseek(n [,fd, flag])            // default values fd = -1, flag = 'set'
mtell([fd])                    // default value  fd = -1

• mode,type : strings.
• n,err,fd : scalar
• x : vector

• "l","s","ul","us","d","f","c","uc" : for reading or writing respectively a long, a short, an unsigned long, an unsigned short, a double, a float, a char and an unsigned char. The bytes which are read are automatically swapped if necessary (by checking little-endian status) in order to produce machine independent binary files ( in little-endian mode).

• "ull","uls","ubl","ubs", : can be used for reading or writing respectively unsigned little-endian long or short and unsigned big-endian long or short.
• "dx","fx","lx","sx" : with x=b or x=l can be used for reading or writing double, float, long or short as big or little endian.
  
  0

• fd : The fd parameter returned by the function mopen is used as a file descriptor (it's a positive integer). When specifying the fd parameter, the value -1 refers to the default file ( i.e the last opened file).

• mode : The mode parameter can be "rb" for read binary or "wb" for write binary or "ab" for append.
• mseek : The function mseek() sets the position of the next input or output operation on the stream fd. The new position is at the signed distance given by n bytes from the beginning, from the current position, or from the end of the file, according to the flag value which can be 'set', 'cur' or 'end'.
  
  mseek() allows the file position indicator to be set beyond the end of the existing data in the file. If data is later written at this point, subsequent reads of data in the gap will return zero until data is actually written into the gap. mseek(), by itself, does not extend the size of the file.
• mtell : The function mtell() returns the offset of the current byte relative to the beginning of the file associated with the named stream fd.
• mget : The function mget is used to get n object of type type. If end of file is reached before read completion, only the properly read values will be returned.
• mgetstr : used to get an array of characters. If EOF is reached before read completion only the properly read values will be returned.
• meof,clearerr : The function meof will return a non null value if end of file has been reached in a previous call to mget or mgetstr. The function clearerr is used to resets the error indicator and EOF indicator to zero.

 
filen = 'test.bin'
mopen(filen,'wb');
mput(1996,'ull');mput(1996,'uls');mput(1996,'ubl');mput(1996,'ubs');
mput(1996,'l');mput(1996,'s');mput(98,'uc');mput(98,'c');
mput(1996,'d');mput(1996,'f');mput(1996,'ul');mput(1996,'us');
mclose();

mopen(filen,'rb')
if 1996<>mget(1,'ull') ;write(%io(2),'Bug');end;
if 1996<>mget(1,'uls') ;write(%io(2),'Bug');end;
if 1996<>mget(1,'ubl') ;write(%io(2),'Bug');end;
if 1996<>mget(1,'ubs') ;write(%io(2),'Bug');end;
if 1996<>mget(1,'l') ;write(%io(2),'BUG');end;
if 1996<>mget(1,'s') ;write(%io(2),'Bug');end;
if 98<>mget(1,'uc') ;write(%io(2),'Bug');end;
if 98<>mget(1,'c') ;write(%io(2),'Bug');end;
// with eventuel swap 
if 1996<>mget(1,'d') ;write(%io(2),'Bug');end;
if 1996<>mget(1,'f') ;write(%io(2),'Bug');end;
if 1996<>mget(1,'ul') ;write(%io(2),'Bug');end;
if 1996<>mget(1,'us') ;write(%io(2),'Bug');end;
mclose();

// an example with two files 

file1 = 'test1.bin';
file2 = 'test2.bin';
fd1=mopen(file1,'wb');
fd2=mopen(file2,'wb');
mput(1996,'ull',fd1);
mput(1996,'ull',fd2);
mclose(fd1);
mclose(fd2);

fd1=mopen(file1,'rb');
if 1996<>mget(1,'ull',fd1) ;write(%io(2),'Bug');end;
fd2=mopen(file2,'rb');
if 1996<>mget(1,'ull',fd2) ;write(%io(2),'Bug');end;
mclose(fd1);
mclose(fd2);

// and example with mseek 
file3='test3.bin'
fd1= mopen(file3,'wb');
for i=1:10, mput(i,'d'); end 
mseek(0);
mput(678,'d');
mseek(0,fd1,'end');
mput(932,'d');
mclose(fd1)
fd1= mopen(file3,'rb');
res=mget(11,'d')
res1=[1:11]; res1(1)=678;res1($)=932;
if res1<>res ;write(%io(2),'Bug');end;
mseek(0,fd1,'set');
// trying to read more than stored data 
res1=mget(100,'d',fd1);
if res1<>res ;write(%io(2),'Bug');end;
meof(fd1)
mclearerr(fd1)
mclose(fd1);

1.9   bool2s convert boolean matrix to a zero one matrix.

bool2s(x)

• x : a boolean vector or a boolean matrix or a constant matrix

bool2s([%t %t %f %t])
bool2s([2.3 0 10 -1])

1.10   boolean Scilab Objects, boolean variables and operators & | ~

• ~b : is the element wise negation of boolean b (matrix).
• b1&b2 : is the element wise logical and of b1 and b2 (matrices).
• b1|b2 : is the element wise logical or of b1 and b2 (matrices).
• Boolean variables can be used for indexing matrices or vectors. For instance a([%T,%F,%T],:) returns the submatrix made of rows 1 and 3 of a. Boolean sparse matrices are supported.

[1,2]==[1,3]
[1,2]==1
a=1:5; a(a>2)

1.11   brackets - left and right brackets

[a11,a12,...;a21,a22,...;...]
[s1,s2,...]=func(...)

• a11,a12,... : any matrix (real, polynomial, rational,syslin list ...) with appropriate dimensions
• s1,s2,... : any possible variable name

[6.9,9.64; sqrt(-1) 0]
[1 +%i  2 -%i  3]
[]
['this is';'a string';'vector']
s=poly(0,'s');[1/s,2/s]
[tf2ss(1/s),tf2ss(2/s)]

[u,s]=schur(rand(3,3))

1.12   break keyword to interrupt loops

k=0; while 1==1, k=k+1; if k > 100 then  break,end; end

1.13   call Fortran or C user routines call

 
// long form 'out' is present 
[y1,...,yk]=call("ident",x1,px1,"tx1",...,xn,pxn,"txn",
                 "out",[ny1,my1],py1,"ty1",...,[nyl,myl],pyl,"tyl")
// short form : no 'out' parameter 
[y1,....,yk]=call("ident",x1,...,xn) 

• "ident" : string.
• xi : real matrix or string
• pxi, pyi : integers
• txi, tyi : character string "d", "r", "i" or "c".

• - with Scilab "link" command (incremental "soft" linking) during the Scilab session.(see link)
• - by "hard" re-linking. Writing the routine call within Scilab routine default/Ex-fort.f, adding the entry point in the file default/Flist and then re_linking Scilab with the command make bin/scilex in main Scilab directory.
  
  0 There are two forms of calling syntax, a short one and a long one. The short one will give faster code and an easier calling syntax but one has to write a small (C or Fortran) interface in order to make the short form possible. The long one make it possible to call a Fortran routine (or a C one) whitout modification of the code but the syntax is more complex and the interpreted code slower.

• "ident" is the name of the called subroutine.
• x1,...,xn are input variables (real matrices or strings) sent to the routine,
• px1,...,pxn are the respective positions of these variables in the calling sequence of the routine "ident" and
• tx1,...,txn are their types ("r", "i", "d" and "c" for real (float) , integer, double precision and strings)
• "out" is a keyword used to separate input variables from output variables. when this key word is present it is assumes that the long form will be used and when it is not prsent, the short form is used.
• [ny1, my1] are the size (# of rows and columns. For 'c' arguments,m1*n1 is the number of charaters ) of output variables and
• py1, ... are the positions of output variables (possibly equal to pxi ) in the calling sequence of the routine. The pyi's integers must be in increasing order.
• "ty1", ... are the Fortran types of output variables. The k first output variables are put in y1,..., yk.
  
  0

        subroutine foof(c,a,b,n,m)
        integer n,m
        double precision a(*),b,c(*)
        do 10 i=1,m*n 
          c(i) = sin(a(i))+b
 10        continue
        end

link("foof.o","foof")
a=[1,2,3;4,5,6];b= %pi;
[m,n]=size(a);
// Inputs:
// a is in position 2 and double
// b                3     double
// n                4     integer
// m                5     integer
// Outputs:
// c is in position 1 and double with size [m,n]
c=call("foof",a,2,"d",b,3,"d",n,4,"i",m,5,"i","out",[m,n],1,"d");

link('foof.o -lfor -lm -lc','foof').
link('foof.o -lftn -lm -lc','foof').
link('foof.o -L/opt/SUNWspro/SC3.0/lib/lib77 -lm -lc','foof').

  void fooc(c,a,b,m,n) 
        double a[],*b,c[];
        int *m,*n;
      { double sin();
        int i;
        for ( i =0 ; i < (*m)*(*n) ; i++) 
               c[i] = sin(a[i]) + *b;        
        }

link("fooc.o","fooc","C") // note the third argument 
a=[1,2,3;4,5,6];b= %pi;
[m,n]=size(a);
c=call("fooc",a,2,"d",b,3,"d",m,4,"i",n,5,"i","out",[m,n],1,"d");

1.14   case keyword used in select

select expr0,
 case expr1 then instructions1,
 case expr2 then instructions2,
 ...
 case exprn then instructionsn,
 [else instructions],
end

1.15   ceil rounding up

[y]=ceil(x)

• x : a real matrix
• y : integer matrix

1.16   chdir changes Scilab current directory

ierr=chdir('path-name')

• ierr : an integer, 1 if chdir failed to change directory and 0 elsewhere.

chdir(TMPDIR);
if MSDOS then
  unix_w("dir");
else
  unix_w("ls");
end

1.17   clear kills variables

clear a

1.18   clearfun remove primitive.

clearfun('name')

1.19   code2str returns character string associated with Scilab integer codes.

str=code2str(c)

• str : a character string
• c : vector of character integer codes

code2str([-28 12 18 21 10 11])

1.20   coeff coefficients of matrix polynomial

 
[C]=coeff(Mp [,v])

• Mp : polynomial matrix
• v : integer (row or column) vector of selected degrees
• C : big matrix of the coefficients

1.21   colon - colon operator

• : : Colon. Used in subscripts and loops.

• j:k is the vector [j, j+1, ..., k] (empty if J>K).
• j:d:k is the vector [j, j+d, ..., j+m*d]

• A(:) is the vector of all the elements of A regarded as a single column.
• A(:,j) is the j-th column of A
• A(j:k) is [A(j),A(j+1),...,A(k)]
• A(:,j:k) is [A(:,j),A(:,j+1),...,A(:,k)]
• A(:)=w fills the matrix A with entries of w (taken column by column if w is a matrix).

1.22   comma - column, instruction, argument separator

a=[1,2,3;4,5,6];
a=1,b=1;c=2

1.23   comments comments

1.24   comp scilab function compilation

comp(function [,opt])

• function : an not compiled scilab function (type 11)
• opt : integer flag with value 0 (default) or 1.

1.25   deff on-line definition of function

deff('[s1,s2,...]=newfunction(e1,e2,....)',text [,opt])

• e1,e2,..., : input variables.
• s1,s2,..., : output variables.
• text : matrix of character strings
• opt : optional character string
  
  1
• 'c' : function is "compiled" to be more efficient (default)
• 'n' : function is not "compiled"
  
  0

deff('[x]=myplus(y,z)','x=y+z')
//
deff('[x]=mymacro(y,z)',['a=3*y+1'; 'x=a*z+y'])

1.26   degree degree of polynomial matrix

[D]=degree(M) 

• M : polynomial matrix
• D : integer matrix

1.27   delbpt delete breakpoint

delbpt('macroname' [,linenumb]) 

setbpt('foo',1),setbpt('foo',10),delbpt('foo',10),dispbpt()

1.28   diary diary of session

diary('file-name')

1.29   disp displays variables

disp(x1,[x2,...xn]) 

disp([1 2],3)
deff('[]=%t_p(l)','disp(l(3),l(2))')
disp(tlist('t',1,2))

1.30   dispbpt display breakpoints

dispbpt()

1.31   dot - symbol

 
123.33
a.*b
[123,..
 456]
.SH DESCRIPTION
.TP 6
. 
Dot is used to mark decimal point for numbers : 3.25 and 0.001
.TP
.<op>
used in cunjunction with other operator symbols (* / \\ ^ ') to form
other operators.  Element-by-element multiplicative operations are
obtained using .* , .^ , ./ , .\\ or .'.  For example, C = A ./ B is
the matrix with elements c(i,j) = a(i,j)/b(i,j). Kronecker product is
noted .*. .

Note that when dot follows a number it is alway prt of the number so 2.*x is evaluated as 2.0*x and 2 .*x is evaluated as (2).*x
.TP
.. 
Continuation.  Two or more decimal points at the end of
a line causes the following line to be a continuation.
.SH EXAMPLE
.nf
1.345
x=[1 2 3];x.^2 .*x // a space is required between 2 and dot
[123,..
 456]

1.32   else keyword in if-then-else

1.33   elseif keyword in if-then-else

1.34   empty - empty matrix

s=poly(0,'s'); A = [s, s+1]; 
A+[], A*[]
A=rand(2,2); AA=A([],1), size(AA)
svd([])
w=ssrand(2,2,2); wr=[]*w; size(wr), w1=ss2tf(wr), size(w1)

1.35   end end keyword

1.36   equal - affectation, comparison equal sign

a=sin(3.2)
[u,s]=schur(rand(3,3))
[1:10]==4
1~=2

1.37   errcatch error trapping

errcatch(n [,'action'] [,'option']) 

• n : integer
• action, option : strings

• "pause" : a pause is executed when trapping the error. This option is useful for debugging purposes.
• "continue" : next instruction in the function or exec files is executed, current instruction is ignored. This option is useful for error recovery.
• "kill" : default mode, all intermediate functions are killed, scilab goes back to the level 0 prompt.
• "stop" : interrupts the current Scilab session (useful when Scilab is called from an external program).
  
  1
  
  0

1.38   errclear error clearing

errclear([n])

1.39   error error messages

error('string' [,n])
error(m)

1.40   evstr evaluation of expressions

H=evstr(Z)
[H,ierr]=evstr(Z)

• Z : matrix of character strings M or list(M,Subexp)
  
  1
• M : matrix of character strings
• Subexp : vector of character strings
  
  0
• H : matrix
• ierr : integer, error indicator

a=1; b=2; Z=['a','b'] ; evstr(Z) 

a=1; b=2; Z =list(['%(1)','%(1)-%(2)'],['a+1','b+1']);
evstr(Z)

1.41   exec script file execution

exec('file-name' [,mode])

• 0 : the default value
• -1 : nothing is printed
• 1 : echo of each command line
• 2 : prompt --> is printed
• 3 : echoes + prompts
• 4 : stops before each prompt
• 7 : stops + prompts + echoes : useful mode for demos.

1.42   exists checks variable existence

exists(name [,where])

• name : a character string
• where : an optional character string with default value 'all'

deff('foo(x)',..
['disp([exists(''a12''),exists(''a12'',''local'')])'
 'disp([exists(''x''),exists(''x'',''local'')])'])
foo(1)
a12=[];foo(1)

1.43   exit Ends the current Scilab session

1.44   external Scilab Object, external function or routine

optim(costfunc,...)

[f,g,ind]=costfunc(x,ind,a,b,c) 

optim(list(costfunc,a1,b1,c1),....

1.45   extraction matrix and list entry extraction

x(i,j)
x(i)
[...]=l(i)
[...]=l(k1)...(kn)(i) or [...]=l(list(k1,...,kn,i))
l(k1)...(kn)(i,j)   or l(list(k1,...,kn,list(i,j))

• x : matrix of any possible types
• l : list variable
• i,j : indices
• k1,...kn : indices

• MATRIX CASE i and j, can be:
  
  1
• - real scalars or vectors or matrices with positive elements.
  
  2
• * r=x(i,j) designs the matrix r such as r(l,k)=x(int(i(l)),int(j(k))) for l from 1 to size(i,'*') and k from 1 to size(j,'*').
  
  i (j) Maximum value must be less or equal to size(x,1) (size(x,2)).
• * r=x(i) with x a 1x1 matrix designs the matrix r such as r(l,k)=x(int(i(l)),int(i(k))) for l from 1 to size(i,1) and k from 1 to size(i,2).
  
  Note that in this case index i is valid only if all its entries are equal to one.
• * r=x(i) with x a row vector designs the row vector r such as r(l)=x(int(i(l))) for l from 1 to size(i,'*') i Maximum value must be less or equal to size(x,'*').
• * r=x(i) with x a matrix with one or more columns designs the column vector r such as r(l) (l from 1 to size(i,'*')) designs the int(i(l)) entry of the column vector formed by the concatenation of the x's columns.
  
  i Maximum value must be less or equal to size(x,'*').
  
  1
  
  
• - the : symbol which stands for "all elements".
  
  2
• * r=x(i,:) designs the matrix r such as r(l,k)=x(int(i(l)),k)) for l from 1 to size(i,'*') and k from 1 to size(x,2)
• * r=x(:,j) designs the matrix r such as r(l,k)=x(l,int(j(k))) for l from 1 to size(r,1) and k from 1 to size(j,'*').
• * r=x(:) designs the column vector r formed by the column concatenations of x columns. It is equivalent to matrix(x,size(x,'*'),1).
  
  1
  
  
• - vector of boolean. If an index (i or j )is a vector of booleans it is interpreted as find(i) or respectively find(j)
• - a polynomial. If an index (i or j )is a vector of polynomials or implicit polynomial vector it is interpreted as horner(i,m) or respectively horner(j,n) where m and n are associated x dimensions.
  
  Even if this feature works for all polynomials, it is recommended to use polynomials in $ for readability.
  
  0
• LIST OR TLIST CASE
  
  If they are present the ki give the path to a sub-list entry of l data structure. They allow a recursive extraction without intermediate copies.
  
  The [...]=l(k1)...(kn)(i) and [...]=l(list(k1,...,kn,i)) instructions are interpreted as:
  
  lk1 = l(k1) .. = .. lkn = lkn-1(kn) [...] = lkn(i) And the l(k1)...(kn)(i,j) and l(list(k1,...,kn,list(i,j)) instructions are interpreted as:
  
  lk1 = l(k1) .. = .. lkn = lkn-1(kn) lkn(i,j) i and j, can be:
  
  When path points on more than one list component the instruction must have as many left hand side arguments as selected components. But if the extraction syntax is used within a function input calling sequence each returned list component is added to the function calling sequence.
  
  1
• - real scalar or vector or matrix with positive elements.
  
  [r1,...rn]=l(i) extracts the i(k) elements from the list l and store them in rk variable for k from 1 to size(i,'*')
• - the : symbol which stands for "all elements".
• - a vector of booleans. If i is a vector of booleans it is interpreted as find(i).
• - a polynomial. If i is a vector of polynomials or implicit polynomial vector it is interpreted as horner(i,m) where m=size(l).
  
  Even if this feature works for all polynomials, it is recommended to use polynomials in $ for readability.
  
  0
• k1,..kn may be :
  
  1
• - real positive scalar.
  
  
• - a polynomial,interpreted as horner(ki,m) where m is the corresponding sub-list size.
  
  
• - a character string associated with a sub-list entry name.
  
  0

// MATRIX CASE
a=[1 2 3;4 5 6]
a(1,2)
a([1 1],2)
a(:,1)
a(:,3:-1:1)
a(1)
a(6)
a(:)
a([%t %f %f %t])
a([%t %f],[2 3])
a(1:2,$-1)
a($:-1:1,2)
a($)
//
x='test'
x([1 1;1 1;1 1])
//
b=[1/%s,(%s+1)/(%s-1)]
b(1,1)
b(1,$)
b(2) // the numerator
// LIST OR TLIST CASE
l=list(1,'qwerw',%s)
l(1)
[a,b]=l([3 2])
l($)
x=tlist(l(2:3)) //form a tlist with the last 2 components of l
//
dts=list(1,tlist(['x';'a';'b'],10,[2 3]));
dts(2)('a')
dts(2)('b')(1,2)
[a,b]=dts(2)(['a','b'])

1.46   eye identity matrix

X=eye(m,n)
X=eye(A)
X=eye()

• A,X : matrices or syslin lists
• m,n : integers

eye(2,3)
A=rand(2,3);eye(A)
s=poly(0,'s');A=[s,1;s,s+1];eye(A)
A=[1/s,1;s,2];eye(A);
A=ssrand(2,2,3);eye(A)
[1 2;3 4]+2*eye()

1.47   feval multiple evaluation

[z]=feval(x,y,f)
[z]=feval(x,f)

• x,y : two vectors
• f : function or character string (for Fortran call)

• z=feval(x,f) returns the vector z defined by z(i)=f(x(i))
• z=feval(x,y,f) returns the matrix z, z(i,j)=f(x(i),y(j))

deff('[z]=f(x,y)','z=x^2+y^2');
feval(1:10,1:5,f)
deff('[z]=f(x,y)','z=x+%i*y');
feval(1:10,1:5,f)
feval(1:10,1:5,'parab')   //See ffeval.f file
feval(1:10,'parab')
// For dynamic link (see example ftest in ffeval.f)
// you can use the link command (the parameters depend on the machine):
// unix('make ftest.o');link('ftest.o','ftest); feval(1:10,1:5,'ftest') 

1.48   file file management

[unit [,err]]=file('open', file-name [,status] [,access [,recl]] [,format])
file(action,unit)

• file-name : string, file name of the file to be opened
• status : string, The status of the file to be opened
  
  1
• "new" : file must not exist new file (default)
• "old" : file must already exists.
• "unknown" : unknown status
• "scratch" : file is to be deleted at end of session
  
  0
• access : string, The type of access to the file
  
  1
• "sequential" : sequential access (default)
• "direct" : direct access.
  
  0
• format : string,
  
  1
• "formatted" : for a formatted file (default)
• "unformatted" : binary record.
  
  0
• recl : integer,is the size of records in bytes when access="direct"
• unit : integer, logical unit descriptor of the opened file
• err : integer, error message number (see error), if open fails. If err is omitted an error message is issued.
• action : is one of the following strings:
  
  1
• "close" : closes the file
• "rewind" : puts the pointer at beginning of file
• "backspace" : puts the pointer at beginning of last record.
• "last" : puts the pointer after last record.
  
  0

u=file('open',TMPDIR+'/foo','unknown')
for k=1:4
  a=rand(1,4)
  write(u,a)
end
file('rewind',u)
x=read(u,2,4)
file('close',u)

1.49   find find indices of boolean vector or matrix true elements

[ii]=find(x)
[ir,ic]=find(x)

• x : a boolean vector or a boolean matrix or a "standard" matrix
• ii, ir, ic : integer vectors of indices or empty matrices

A=rand(1,20);
w=find(A<0.5);
A(w)
w=find(A>100);

1.50   fix rounding towards zero

[y]=fix(x)

• x : a real matrix
• y : integer matrix

1.51   floor rounding down

[y]=floor(x)

• x : a real matrix
• y : integer matrix

1.52   for language keyword for loops

n=5;
for i = 1:n, for j = 1:n, a(i,j) = 1/(i+j-1);end;end
for j = 2:n-1, a(j,j) = j; end; a
for  e=eye(3,3),e,end  
for v=a, write(6,v),end        
for j=1:n,v=a(:,j), write(6,v),end 
for l=list(1,2,'example'); l,end 

1.53   format printing format

format([type],[long])

• type : character string
• long : integer ( max number of digits (default 10))

• "v" : for a variable format (default)
• "e" : for the e-format.

1.54   fort Fortran or C user routines call

 
// long form 'out' is present 
[y1,...,yk]=fort("ident",x1,px1,"tx1",...,xn,pxn,"txn",
                 "out",[ny1,my1],py1,"ty1",...,[nyl,myl],pyl,"tyl")
// short form : no 'out' parameter 
[y1,....,yk]=fort("ident",x1,...,xn) 

• "ident" : string.
• xi : real matrix or string
• pxi, pyi : integers
• txi, tyi : character string "d", "r", "i" or "c".

• - with Scilab "link" command (incremental "soft" linking) during the Scilab session.(see link)
• - by "hard" re-linking. Writing the routine call within Scilab routine default/Ex-fort.f, adding the entry point in the file default/Flist and then re_linking Scilab with the command make bin/scilex in main Scilab directory.
  
  0 There are two forms of calling syntax, a short one and a long one. The short one will give faster code and an easier calling syntax but one has to write a small (C or Fortran) interface in order to make the short form possible. The long one make it possible to call a Fortran routine (or a C one) whitout modification of the code but the syntax is more complex and the interpreted code slower.

• "ident" is the name of the called subroutine.
• x1,...,xn are input variables (real matrices or strings) sent to the routine,
• px1,...,pxn are the respective positions of these variables in the calling sequence of the routine "ident" and
• tx1,...,txn are their types ("r", "i", "d" and "c" for real (float) , integer, double precision and strings)
• "out" is a keyword used to separate input variables from output variables. when this key word is present it is assumes that the long form will be used and when it is not prsent, the short form is used.
• [ny1, my1] are the size (# of rows and columns. For 'c' arguments,m1*n1 is the number of charaters ) of output variables and
• py1, ... are the positions of output variables (possibly equal to pxi ) in the calling sequence of the routine. The pyi's integers must be in increasing order.
• "ty1", ... are the Fortran types of output variables. The k first output variables are put in y1,..., yk.
  
  0

        subroutine foof(c,a,b,n,m)
        integer n,m
        double precision a(*),b,c(*)
        do 10 i=1,m*n 
          c(i) = sin(a(i))+b
 10        continue
        end

link("foof.o","foof")
a=[1,2,3;4,5,6];b= %pi;
[m,n]=size(a);
// Inputs:
// a is in position 2 and double
// b                3     double
// n                4     integer
// m                5     integer
// Outputs:
// c is in position 1 and double with size [m,n]
c=fort("foof",a,2,"d",b,3,"d",n,4,"i",m,5,"i","out",[m,n],1,"d");

link('foof.o -lfor -lm -lc','foof').
link('foof.o -lftn -lm -lc','foof').
link('foof.o -L/opt/SUNWspro/SC3.0/lib/lib77 -lm -lc','foof').

  void fooc(c,a,b,m,n) 
        double a[],*b,c[];
        int *m,*n;
      { double sin();
        int i;
        for ( i =0 ; i < (*m)*(*n) ; i++) 
               c[i] = sin(a[i]) + *b;        
        }

link("fooc.o","fooc","C") // note the third argument 
a=[1,2,3;4,5,6];b= %pi;
[m,n]=size(a);
c=fort("fooc",a,2,"d",b,3,"d",m,4,"i",n,5,"i","out",[m,n],1,"d");

1.55   fprintf Emulator of C language fprintf function

fprintf(file,format,value_1,..,value_n)

• format : a Scilab string. Specifies a character string combining literal characters with conversion specifications.
• value_i : Specifies the data to be converted according to the format parameter.
• str : column vector of character strings
• file : a Scilab string specifying a file name or a logical unit number (see file)

• Literal characters : which are copied to the output stream.
• Conversion specifications : each of which causes zero or more items to be fetched from the value parameter list. see printf_conversion for details

u=file('open','results','unknown') //open the result file
t=0:0.1:2*%pi;
for tk=t
 fprintf(u,'time = %6.3f value = %6.3f',tk,sin(tk)) // write a line
end
file('close',u) //close the result file

1.56   fscanf Converts formatted input read on a file

 [v_1,...v_n]=fscanf (file,format)

• format :Specifies the format conversion.
• file :Specifies the input file name or file number.

• - Any character except % (percent sign), which must match the next character of the input stream.
• - A conversion specification that directs the conversion of the next input field. see scanf_conversion for details.

1.57   funcprot switch scilab functions protection mode

prot=funcprot()
funcprot(prot)

• prot : integer with possible values 0,1,2

• * If prot==0 nothing special is done
• * If prot==1 scilab issues a warning message when a function is redefined (default mode)
• * If prot==1 scilab issues an error when a function is redefined
  
  0

1.58   function Scilab procedure and Scilab object

 
function [y1,...,yn]=foo(x1,...,xm)

function [x,y]=myfct(a,b)
x=a+b
y=a-b

getf('pathname/myfct.sci','c')
[a,b]=myfct(1,2)

1.59   funptr coding of primitives ( wizard stuff )

1.60   getcwd get Scilab current directory

path=getcwd()
pwd

• path : a string

p=getcwd();
pwd

1.61   getd getting function defined in a directory .sci files

getd(path)

• path : Scilab string. The directory pathname

getd('SCI/macros/auto')

1.62   getenv get the value of an environment variable

env=getenv(str [, rep] )

• str : character string specifying environment variable name rep : an optional character string. When this optional value is used, the function getenv returns the value rep when the environment variable str is not found.
• env : character string which contain the environment variable value

        getenv('SCI')
        getenv('FOO','foo') 

1.63   getf loading function

getf(file-name [,opt])

• filename : Scilab string.
• opt : optional character string
  
  1
• "c" : loaded functions are "compiled" to be more efficient (default)
• "n" : loaded functions are not "compiled"
  
  0

function [s1,s2,..,slhs]=macr(e1,e2,...,erhs)  

        getf('SCI/macros/xdess/plot.sci')

1.64   getpid get Scilab process identificator

id=getpid()

d='SD_'+string(getpid())+'_'

1.65   hat - exponentiation

A^b

2^4
[1 2;2 4]^(1+%i)
s=poly(0,"s");
[1 2 s]^4
[s 1;1  s]^(-1)

1.66   help on-line help command

        help word

word - quick description

chapter_path    chapter_title

1.67   host shell (sh) command execution

stat=host(command-name)

• command-name : A character string containing Unix sh instruction
• stat : An integer flag

host("ls $SCI/demos");
host("emacs $SCI/demos/wheel2/Makefile");
deff('wd=pwd()','if MSDOS then host(''cd>''+TMPDIR+''\path'');..
                 else host(''pwd>''+TMPDIR+''/path'');end..
      wd=read(TMPDIR+''/path'',1,1,''(a)'')')
wd=pwd()

1.68   hypermat initialize an N dimensional matrices

M=hypermat(dims [,v])

• dims : vector of hypermatrix dimensions
• v : vector of hypermatrix entries (default value zeros(prod(dims),1))

M=hypermat([2 3 2 2],1:24)

1.69   hypermatrices Scilab object, N dimensional matrices in Scilab

a(1,1,1,1:2)=[1 2]
a=[1 2;3 4];a(:,:,2)=rand(2,2)
a(1,1,:)
[a a]

1.70   ieee set floating point exception mode

mod=ieee()
ieee(mod)

• mod : integer scalar whose possible values are 0,1,or 2

• 0: floating point exception produce an error 1: floating point exception produce a warning 2: floating point exception procudes Inf or Nan
  
  -1
  
  ieee(mod) sets the current floating point exception mode.

ieee(1);1/0
ieee(2);1/0,log(0)

1.71   if else - conditional execution

if expr1 then statements
elseif expri then statements
  ....
else  statements
end

• - The only constraint is that each then keyword must be on the same line line as its corresponding if or elseif keyword.
• - The keyword then can be replaced by a carriage return or a comma.

   i=2
   for j = 1:3, 
      if i == j then
        a(i,j) = 2; 
      elseif abs(i-j) == 1 then 
        a(i,j) = -1; 
      else a(i,j) = 0;
      end,
   end

1.72   imag imaginary part

[y]=imag(x)

• x : real or complex vector or matrix.
• y : real vector or matrix.

1.73   insertion matrix and list insertion or modification

x(i,j)=a
x(i)=a
l(i)=a
l(k1)...(kn)(i)=a or l(list(k1,...,kn,i))=a
l(k1)...(kn)(i,j)=a   or l(list(k1,...,kn,list(i,j))=a

• x : matrix of any kind (constant, sparse, polynomial,...)
• l : list
• i,j : indices
• k1,...kn : indices with integer value
• a : new entry value

• MATRIX CASE i and j, may be:
  
  1
• - real scalars or vectors or matrices with positive elements.
  
  2
• * if a is a matrix with dimensions (size(i,'*'),size(j,'*')) x(i,j)=a returns a new x matrix such as x(int(i(l)),int(j(k)))=a(l,k) for l from 1 to size(i,'*') and k from 1 to size(j,'*'), other initial entries of x are unchanged.

• * x(i,j)=[] kills rows specified by i if j matches all columns of x or kills columns specified by j if i matches all rows of x. In other cases x(i,j)=[] produce an error.
• * x(i)=a with a a vector returns a new x matrix such as x(int(i(l)))=a(l) for l from 1 to size(i,'*') , other initial entries of x are unchanged.

• if x is a 1x1 matrix a may be a row (respectively a column) vector with dimension size(i,'*'). Resulting x matrix is a row (respectively a column) vector
• if x is a row vector a must be a row vector with dimension size(i,'*')
• if x is a column vector a must be a column vector with dimension size(i,'*')
• if x is a general matrix a must be a row or column vector with dimension size(i,'*') and i maximum value cannot exceed size(x,'*'),
  
  2
• * x(i)=[] kills entries specified by i.
  
  1 - the : symbol which stands for "all elements".
  
  2
• * x(i,:)=a is interpreted as x(i,1:size(x,2))=a
• * x(:,j)=a is interpreted as x(1:size(x,1),j)=a
• * x(:)=a returns in x the a matrix reshaped according to x dimensions. size(x,'*') must be equal to size(a,'*')
  
  1
  
  
• - vector of boolean. If an index (i or j )is a vector of booleans it is interpreted as find(i) or respectively find(j)
• - a polynomial. If an index (i or j )is a vector of polynomials or implicit polynomial vector it is interpreted as horner(i,m) or respectively horner(j,n) where m and n are associated x dimensions.
  
  Even if this feature works for all polynomials, it is recommended to use polynomials in $ for readability.
  
  0
• LIST OR TLIST CASE If they are present the ki give the path to a sub-list entry of l data structure. They allow a recursive extraction without intermediate copies.
  
  The l(k1)...(kn)(i)=a and l(list(k1,...,kn,i)=a) instructions are interpreted as:
  
  lk1 = l(k1) .. = .. lkn = lkn-1(kn) lkn(i) = a lkn-1(kn) = lkn .. = .. l(k1) = lk1 And the l(k1)...(kn)(i,j)=a and l(list(k1,...,kn,list(i,j))=a instructions are interpreted as:
  
  lk1 = l(k1) .. = .. lkn = lkn-1(kn) lkn(i,j) = a lkn-1(kn) = lkn .. = .. l(k1) = lk1
  
  1
• i may be :
  
  2
• - a real non negative scalar. l(0)=a adds an entry on the "left" of the list
  
  l(i)=a sets the i entry of the list l to a. if i>size(l), l is previously extended with zero length entries (undefined).
  
  l(i)=null() suppress the ith list entry.
• - a polynomial. If i is a polynomial it is interpreted as horner(i,m) where m=size(l).
  
  Even if this feature works for all polynomials, it is recommended to use polynomials in $ for readability.
  
  1 k1,..kn may be :
  
  
• - real positive scalar.
  
  
• - a polynomial,interpreted as horner(ki,m) where m is the corresponding sub-list size.
  
  
• - a character string associated with a sub-list entry name.
  
  0

// MATRIX CASE
a=[1 2 3;4 5 6]
a(1,2)=10
a([1 1],2)=[-1;-2]
a(:,1)=[8;5]
a(1,3:-1:1)=[77 44 99]
a(1)=%s
a(6)=%s+1
a(:)=1:6
a([%t %f],1)=33
a(1:2,$-1)=[2;4]
a($:-1:1,1)=[8;7]
a($)=123
//
x='test'
x([4 5])=['4','5']
//
b=[1/%s,(%s+1)/(%s-1)]
b(1,1)=0
b(1,$)=b(1,$)+1
b(2)=[1 2] // the numerator
// LIST OR TLIST CASE
l=list(1,'qwerw',%s)
l(1)='Changed'
l(0)='Added'
l(6)=['one more';'added']
//
//
dts=list(1,tlist(['x';'a';'b'],10,[2 3]));
dts(2)('a')=33
dts(2)('b')(1,2)=-100

1.74   int integer part

[y]=int(X)

• X : real matrix
• y : integer matrix

1.75   intersci scilab tool to interface C of Fortran functions with scilab

1.76   iserror error test

iserror([n])

1.77   keyboard keyboard commands

• C-l clears the Scilab window
• C-d deletes the current character
• C-p calls back the preceding command
• C-n go to next command line
• C-a moves the cursor to the beginning of command line.
• C-b backspace, moves the cursor one character to the left
• C-f forwards, moves the cursor one character to the right
• C-k kills command line from cursor to the end.
• C-y yank, retrieves killed line.
• !beg looks for last command line which begins by beg.
• C-c interrupts Scilab and pause after carriage return. (Only functions can be interrupted). Clicking on the stop button enters a C-C.

1.78   left - left bracket

[a11,a12,...;a21,a22,...;...]
[s1,s2,...]=func(...)

• a11,a12,... : matrix of any compatibles types with compatibles dimensions s1,s2,... : any possible variable name

[6.9,9.64; sqrt(-1) 0]
[1 +%i  2 -%i  3]
[]
['this is';'a string';'vector']

[u,s]=schur(rand(3,3))

1.79   length length of object

n=length(M) 

• M : matrix (usual or polynomial or character string) or list
• n : integer or integer matrix

1.80   less - lower than comparison

• <> means "different" (same as ~=)
• < means "lower than"
• > means "larger than"
• <= means lower than or equal to.
• >= means larger than or equal to

1.81   lib library definition

[xlib]=lib('lib_path')

• lib_path : character string

 deff('[z]=myplus(x,y)','z=x+y')
 deff('[z]=yourplus(x,y)','x=x-y')

 save(lib_path+'/myplus.bin',myplus)
 save(lib_path+'/yourplus.bin',yourplus)

 xlib=lib(lib_path+'/')

1.82   lines rows and columns used for display

[nl,nc]=lines([n [,nc]])

1.83   link dynamic link

link(files, sub-name)
link(files, sub-name, flag)
lst=link('show')
// Link extensions for machines using ``dlopen'' 
// (sun-solaris/linux-elf/alpha/hppa)
x=link(files [, sub-names,flag]);
link(x , sub-names [, flag]);
ulink(x)

• files : a character string or a vector of character strings. ld files used to define the new entry point (compiled routines, user libraries, system libraries,..)
• sub-name : a character string. Name of the entry point in files to be linked.
• sub-names : a character string or a vector of character strings . Name of the entry points in files to be linked.
• x : an integer which gives the id of a shared library linked into Scilab with a previous call to link.
• flag : character string 'f' or 'c' for Fortran (default) or C code.
• names : a vector of character string. Names of dynamically linked entry points.

link('foo.o','foo').
link('foo.o -lm -lc','foo','c').
link('foo.o -lfor -lm -lc','foo').
link('foo.o -lftn -lm -lc','foo').
link('foo.o -L/opt/SUNWspro/SC3.0/lib/lib77 -lm -lc','foo')

• IBM: For IBM-RS6000 only one program can be dynamically linked.
  
  
• Demo: When running a demo, you may have some trouble with the link due to slight differences between systems. In this case, you modify the demo by adding the needed libraries in the link command.
  
  
• dlopen: For machines using dlopen functionality extended command can be used. a call to link returns an integer which gives the id of the shared library which is loaded into Scilab. This number can then be used as the first argument of the link function in order to link additional function from the linked shared library. The shared library is removed with the ulink command.
  
  for example to link functions f and g form binary file test.o the two following command can be used :

   
  link('test.o',['f','g'])
  

  or

   
  x=link('test.o','f');
  link(x,'g');
  

  But

   
  link('test.o','f');
  link('test.o','g');
  

  will also work but f and g will be loaded from two different shared libraries and won't be able to share data.
  
  
• show: The command lst=link('show') will report information about linked shared libraries and linked functions. The return value of the function lst is 1 or 0. If the return value is 1 then the extended calling sequence described as Link extensions for machines using ``dlopen'' are accepted.
  
  
• unlink : (dlopen version) If the function f is changed and one wants to link the new version, it is necessary to use unlink to get rid of previous loaded versions of the function f

   
  x=link('test.o','f');
  // if I need to reload a new definition of f a call to unlink
  // is necessary.
  ulink(x);
  link('test.o','f');
  

• scilab symbols: In order to load a symbol from the Scilab code on can use

   
  link("Scilab",['Scilab-entry-point'])
  

  This does not work on all architectures. On some machines, on can link a Scilab internal function after a first call to link ( with a default binary file )

  link("test.o",['Scilab-entry-point'])
  

  Note that with dld (Linux machine aout) you can use an empty string

  link(" ",['Scilab-entry-point'])