2  Graphic Library

2.1   Graphics Graphic library for Scilab

2.2   Matplot 2D plot of a matrix using colors

Matplot(A,[strf,rect,nax])

• A : real matrix of size (n1,n2).
• strf,rect,nax : optional arguments, ( see plot2d)

 
Matplot([1,2,3;4,5,6])
// draw the colormap 
Matplot((1:xget("lastpattern")))

2.3   Sfgrayplot 2D plot with gray levels

Sfgrayplot(x,y,f,[strf,rect,nax])

    ______ 
    | /| /| 
    |/_|/_|  
    | /| /|
    |/_|/_|

Sfgrayplot()

2.4   Sgrayplot 2D plot of a surface using gray levels

Sgrayplot(x,y,z,[strf,rect,nax])

    ______ 
    | /| /| 
    |/_|/_|  
    | /| /|
    |/_|/_|

Sgrayplot()

2.5   addcolor add new colors to current colormap

new=addcolor(c)

• c : matrix with 3 column, RGB color definition
• new : index of the colors defined in c in the new color table

2.6   black Black's diagram (Nichols chart)

black( sl,[fmin,fmax] [,step] [,comments] )
black( sl,frq [,comments] )
black(frq,db,phi [,comments])
black(frq,repf  [,comments]) 

• sl : list ( linear system syslin)
• fmin,fmax : real scalars (frequency bounds)
• frq : row vector or matrix (frequencies)
• db,phi : row vectors or matrices (modulus, phase)
• repf : row vectors or matrices (complex frequency response)
• step : real
• comments : string

s=poly(0,'s')
h=syslin('c',(s^2+2*0.9*10*s+100)/(s^2+2*0.3*10.1*s+102.01))
chart();
sstr='(s^2+2*0.9*10*s+100)/(s^2+2*0.3*10.1*s+102.01)';
black(h,0.01,100,sstr);
h1=h*syslin('c',(s^2+2*0.1*15.1*s+228.01)/(s^2+2*0.9*15*s+225))
xbasc()
black([h1;h],0.01,100,['h1';'h'])

2.7   bode Bode plot

bode(sl,[fmin,fmax] [,step] [,comments] )
bode(sl,frq [,comments] )
bode(frq,db,phi [,comments])
bode(frq, repf  [,comments])

• sl : syslin list (SISO or SIMO linear system) in continuous or discrete time.
• fmin,fmax : real (frequency bounds (in Hz))
• step : real (logarithmic step.)
• comments : vector of character strings (captions).
• frq : row vector or matrix (frequencies (in Hz) ) (one row for each SISO subsystem).
• db : row vector or matrix ( magnitudes (in Db)). (one row for each SISO subsystem).
• phi : row vector or matrix ( phases (in degree)) (one row for each SISO subsystem).
• repf : row vector or matrix of complex numbers (complex frequency response).

s=poly(0,'s')
h=syslin('c',(s^2+2*0.9*10*s+100)/(s^2+2*0.3*10.1*s+102.01))
title='(s^2+2*0.9*10*s+100)/(s^2+2*0.3*10.1*s+102.01)';
bode(h,0.01,100,title);
h1=h*syslin('c',(s^2+2*0.1*15.1*s+228.01)/(s^2+2*0.9*15*s+225))
xbasc()
bode([h1;h],0.01,100,['h1';'h'])

2.8   champ draw a 2d vector field

champ(x,y,fx,fy [,arfact,rect,strf])
champ1(x,y,fx,fy [,arfact,rect,strf])

• x,y : two vectors which define the grid.
• fx : a matrix which describes the x component of the vector field. fx(i,j) is the x component of the vector field at point (x(i),y(j)).
• fy : a matrix which describes the y component of the vector field. fy(i,j) is the y component of the vector field at point (x(i),y(j)).
• arfact : an optional argument of type real which gives a scale factor for the display of the arrow heads on the plot (default value is 1.0)
• rect : a vector rect=[xmin,ymin,xmax,ymax] which gives the boundaries of the graphic frame to use.
• strf : is a string of length 3 "xyz" which has the same meaning as the strf parameter of plot2d. The parameter "x" has no effect with champ.

 
// using rect has graphic boundaries 
champ(-5:5,-5:5,rand(11,11),rand(11,11),1,[-10,-10,10,10],"011");
xgrid();
xbasc();
// using (x,y) to get boundaries 
champ(-5:5,-5:5,rand(11,11),rand(11,11),2,[-10,-10,10,10],"021");
// using coloured arrows
xset("use color",1)
champ1(-5:5,-5:5,rand(11,11),rand(11,11),2,[-10,-10,10,10],"021");

2.9   champ1 draw a 2d vector field

champ1(x,y,fx,fy [,arfact,rect,strf])

2.10   chart Nichols chart

chart([flags])
chart(gain [,flags])
chart(gain,phase [,flags])

• gain : real vector ( gains (in DB))
• phase : real vector (phases (in degree))
• flags : a list of at most 4 flags list(sup [,leg [,cm [,cphi]]])
  
  1
• sup : 1 indicates superposition on the previous plot 0 no superposition is done
• leg : 1 indicates that legends are drawn, o: no legends
• cm : color number (see plot2d) for gain curves
• cphi : color number (see plot2d) for phase curves
  
  0

s=poly(0,'s')
h=syslin('c',(s^2+2*0.9*10*s+100)/(s^2+2*0.3*10.1*s+102.01))
black(h,0.01,100,'(s^2+2*0.9*10*s+100)/(s^2+2*0.3*10.1*s+102.01)')
chart(list(1,0,2,3));

xbasc()
h1=h*syslin('c',(s^2+2*0.1*15.1*s+228.01)/(s^2+2*0.9*15*s+225))
black([h1;h],0.01,100,['h1';'h'])
chart([-8 -6 -4],[80 120],list(1,0));

2.11   colormap Using colors in Scilab

m=228;
n = fix(3/8*m);
r = [(1:n)'/n; ones(m-n,1)];
g = [zeros(n,1); (1:n)'/n; ones(m-2*n,1)];
b = [zeros(2*n,1); (1:m-2*n)'/(m-2*n)];
h = [r g b];
xset('colormap',h);
plot3d1()

2.12   contour level curves of surface

contour(x,y,z,nz,[theta,alpha,caption,flag,bbox,zlev])
contour2d(x,y,z,nz,[style,strf,leg,rect,nax])

• x,y : two real vectors of size respectively (1,n1) and (1,n2).
• z : real matrix of size (n1,n2) (values)
• nz : real vector of size > 1 (the level values) or an integer ( the number of level curves ).
• flag : is a real vector of size three [mode,type,box]
• zlev : real number
• [theta,alpha,caption,flag,bbox,zlev] : see plot3d
• [style,strf,leg,rect,nax] : (see plot2d). The argument style gives the dash styles or colors which are to be used for level curves. It must have the same size as the requested level curves. The other arguments follows the rules given in plot2d.

• mode=0 : the level curves are drawn on the surface defined by (x,y,z)
• mode=1 : the level curves are drawn on a 3D plot and on the plan defined by equation z=zlev
• mode=2 : The level curves are drawn on a 2D plot.
  
  0 Enter the command contour() to see a demo.

contour2d(1:10,1:10,rand(10,10),5,1:5,"011"," ",[0,0,11,11]);

2.13   contour2d level curves of surface on a 2D graphics

contour2d(x,y,z,nz,[style,strf,leg,rect,nax])

contour2d(1:10,1:10,rand(10,10),5,1:5,"011"," ",[0,0,11,11]);

2.14   driver select a driver for plotting

driver(driver_name)
current_driver=driver()

• driver_name : string (driver to be selected).

• "X11" : an X Window driver.
• "Pos" : a Postscript driver.
• "Rec" : an X Window driver (X11) which also records all the graphic commands. this is the default driver.
• "Fig" : an XFig driver. (Clipping of objects is not provided in XFig).

2.15   edit_curv interactive graphic curve editor

[x,y,ok,gc] = edit_curv(y)
[x,y,ok,gc] = edit_curv(x,y)
[x,y,ok,gc] = edit_curv(x,y,job)
[x,y,ok,gc] = edit_curv(x,y,job,tit)
[x,y,ok,gc] = edit_curv(x,y,job,tit,gc)

• x : vector of x coordinates
• y : vector of y coordinates
• job : a character string formed by one to three of the characters 'a','x','y'
  
  1
• 'a' : to add points to the edited curve
• 'x' : to modify x coordinates of the edited curve points
• 'y' : to modify y coordinates of the edited curve points
  
  0
• tit : a vector of three character strings which give the curve legend
• gc : a list of graphic window parameters: gc=list(rect,nax)
  
  1
• rect : bounds of the graphics (see plot2d for details)
• nax : graduation parameters (see plot2d for details)
  
  0
• ok : indicator if ok==%t user as returned with 'ok' menu else user as returned with 'abort' menu : list (graphical objects created under edit_curv

2.16   errbar add error tic on a graphic

errbar(x,y,em,ep)

• x,y,em,ep : four matrices of the same size.

x=0:0.1:2*%pi;
y=[sin(x);cos(x)]';x=[x;x]';plot2d(x,y);
errbar(x,y,0.05*ones(x),0.03*ones(x));

2.17   eval3d values of a function on a grid

[z]=eval3d(fun,x,[y])

• fun : function accepting vectors as arguments.
• x,y : 2 vectors of size (1,n1) and (1,n2). (default value for y : y=x).
• z : matrix of size (n1,n2).

  x=-5:5;y=x;
  deff('[z]=f(x,y)',['z= x.*y']);
  z=eval3d(f,x,y);
  plot3d(x,y,z);
// 
  deff('[z]=f(x,y)',['z= x*y']);
  z=feval(x,y,f);
  plot3d(x,y,z);

2.18   eval3dp computes facets of a 3D parametrized surface

[x,y,z]=eval3dp(fun,p1,p2)

• fun : a Scilab function.
• p1 : a vector of size n
• p2 : a vector of size m
• x,y,z : return value.Four 4x(n-1*m-1) matrices.

  p1=linspace(0,2*%pi,10);
  p2=linspace(0,2*%pi,10);
  deff('[x,y,z]=scp(p1,p2)',['x=p1.*sin(p1).*cos(p2)';
                             'y=p1.*cos(p1).*cos(p2)';
                             'z=p1.*sin(p2)'])
  [x,y,z]=eval3dp(scp,p1,p2);
  plot3d(x,y,z)

2.19   evans Evans root locus

evans(H [,kmax])

• H : list (linear system syslin )
• kmax : real (maximum gain desired for the plot )

H=syslin('c',352*poly(-5,'s')/poly([0,0,2000,200,25,1],'s','c'));
evans(H,100)
P=3.0548543 - 8.8491842*%i;    //P=selected point
k=-1/real(horner(H,P));
Ns=H('num');Ds=H('den');
roots(Ds+k*Ns)     //contains P as particular root
// Another one
xbasc();s=poly(0,'s');n=1+s;
d=real(poly([-1 -2 -%i %i],'s'));
evans(n,d,100);
//
xbasc();n=real(poly([0.1-%i 0.1+%i,-10],'s'));
evans(n,d,80);

2.20   fac3d complex 3D surface plotting

fac3d(x,y,z[,theta,alpha,leg,flag,ebox])
fac3d1(x,y,z[,theta,alpha,leg,flag,ebox])

• x,y,z : matrices of sizes (nf,n1) (facets coordinates). nf :facets size, n1: number of facets
• rest : see plot3d.

2.21   fchamp draw a 2d vector field

fchamp(f,t,xr,yr,[arfact,brect,strf])

• f : a function which describes the vector field.
  
  1
• - It can be a function name f, where f is supposed to be a function of type [y]=f(t,x,[u]) ( f returns a column vector of dimension 2, y, which gives the value of the vector field f at point x and time t.
• - It can also be an object of type list, list(f1,u1) where f1 is a function (f [y]=f1(t,x,u) ) and u1 gives the value of the parameter u.
  
  0
• t : The selected time.
• xr,yr : two vectors of size (1,n1) (1,n2) which specifies the grid on which the vector field is to be computed.
• arfact,brect,strf : optional arguments, see champ.

 deff('[xdot] = derpol(t,x)',['xd1 = x(2)';
           "xd2 = -x(1) + (1 - x(1)**2)*x(2)";
           "xdot = [ xd1 ; xd2 ]"]);
 xf= -1:0.1:1;
 yf= -1:0.1:1;
 fchamp(derpol,0,xf,yf);
 xbasc();
 fchamp(derpol,0,xf,yf,1,[-2,-2,2,2],"011");

2.22   fcontour level curves

fcontour(xr,yr,f,nz,[theta,alpha,caption,flag,bbox,zlev])
fcontour2d(x,y,z,nz,[style,strf,leg,rect,nax])

• xr,yr : two real vectors of size respectively (1,n1) and (1,n2).
• f : is an external which gives the analytic expression of the surface. z=f(x,y) is first computed on the grid specified by xr.yr. Then, control is passed to the routine contour.
• nz : specifies the level values or number.
  
  1
• - If nz is of size 1, its value considered as an integer gives the number of level curves equally spaced from zmin to zmax.
• - If nz is a vector, nz(j) gives the value of the jth level curve.
  
  0
• [rest] : for theta,alpha,caption, bbox see plot3d
• flag : real vector of size 3 ; flag=[mode,type,box]; flag(2) and flag(3) are the same as in plot3d; flag(1) has the following meaning :
  
  1
• flag(1)=0 : the level curves are drawn on the surface defined by (x,y,z)
• flag(1)=1 : the level curves are drawn on a 3D plot and on the plan defined by equation z=zlev
• flag(1)=2 : The level curves are drawn on a 2D plot.
  
  0

2.23   fcontour2d level curves of surface on a 2D graphics

fcontour2d(x,y,z,nz,[style,strf,leg,rect,nax])

2.24   fec contour level of a function defined on a triangular mesh

fec(x,y,triangles,func,no,Ntr,strflag,legend,brect,aaint) 

• x,y : two vectors of size no, (x(i),y(i)) gives the coordinates of node i
• func : a vector of size no : func(i) gives the value of the function for which we want the level curves.
• triangles : is a [Ntr,5] matrix. Each line of triangles specifies a triangle of the mesh triangle(j) = [number,node1,node2,node3,flag]. node1,node2,node3 are the number of the nodes which constitutes the triangle. number is the number of the triangle and flag is an integer not used in the fec function
• rest : for the remaining arguments strflag,legend,brect,aint, see plot2d

2.25   fgrayplot 2D plot with gray levels

fgrayplot(x,y,f,[strf,rect,nax])

• x,y : real vectors of size respectively (1,n1) and (1,n2).
• f : an external (analytic expression of the surface)
• strf,rect,nax : optional arguments, ( see plot2d)

 
deff('[z]=surf(x,y)','z=x**2+y**2');
fgrayplot(-1:0.1:1,-1:0.1:1,surf,"111",[-2,-2,2,2]);

2.26   fplot2d 2D plot of a curve defined by an external

fplot2d(xr,f,[style,strf,leg,rect,nax])

• xr : vector of size (n1,1).
• f : external (of type [y]=f(x))
• [rest] : see plot2d

deff("[y]=f(x)","y=sin(x)+cos(x)");
fplot2d((0:0.1:10)*%pi/10,f);
fplot2d((0:0.1:10)*%pi/10,f,5);

2.27   fplot3d 3D plot of a surface defined by an external

fplot3d(xr,yr,f,[theta,alpha,leg,flag,ebox])

• xr : matrix of size (1,n1)
• yr : matrix of size (1,n2).
• f : external (z=f(x,y))
• theta, alpha : real (spherical coordinates in degrees of the observation point)
• leg : string (caption for each axis. @ is a field separator e.g. "X@Y@Z")
• flag : real vector of size three flag=[mode,type,box]
  
  1
• mode : integer (treatment of hidden parts)
  
  2
• mode >=2 the hidden parts of the surface are removed and the surface is painted in gray (from low gray to black according to the value of mode)
• mode = 1 The hidden parts of the surface are drawn
• mode <= 0 Only the shadow of the surface is painted with a gray level depending on mode
  
  1
• type : Scaling
  
  2
• if type = 0 the plot is made using the current 3D scaling ( set by a previous call to param3d, plot3d, contour, plot3d1
• if type = 1, the value of ebox=[xmin,xmax,ymin,ymax,zmin,zmax] specifies the boundaries
• else the boundaries are computed with the given datas.
  
  1
• box : frame display around the plot.
  
  2
• box=0 : Nothing is drawn around the plot
• box=1 :not implemented
• box=2 : only the axes behind the surface are drawn
• box=3 : a box surrounding the surface is drawn and captions are added
  
  1
  
  0

2.28   fplot3d1 gray level plotting of a surface

fplot3d1(xr,yr,f [,theta,alpha,leg,flag,ebox])

2.29   gainplot magnitude plot

gainplot(sl,fmin,fmax [,step] [,comments] )
gainplot(frq,db,phi [,comments])
gainplot(frq, repf  [,comments])

• sl : list (syslin SIMO linear system).
• fmin,fmax : real scalars (frequency interval).
• step : real (discretization step (logarithmic scale))
• comments : string
• frq : matrix (row by row frequencies)
• db,phi : matrices (magnitudes and phases corresponding to frq)
• repf : complex matrix. One row for each frequency response.

s=poly(0,'s')
h=syslin('c',(s^2+2*0.9*10*s+100)/(s^2+2*0.3*10.1*s+102.01))
gainplot(h,0.01,100,'(s^2+2*0.9*10*s+100)/(s^2+2*0.3*10.1*s+102.01)')
xbasc()
h1=h*syslin('c',(s^2+2*0.1*15.1*s+228.01)/(s^2+2*0.9*15*s+225))
gainplot([h1;h],0.01,100,['h1';'h'])

2.30   genfac3d convert 3d datas to four sided facets

[xx,yy,zz]=genfac3d(x,y,zmat [,mask])

• zmat : a (mxn) matrix.
• x :x axis coordinates vector ( size m )
• y :y axis coordinates vector ( size n )
• mask : boolean optional matrix with same size as zmat used to select entries of zmat to be represented by facets.
• xx,yy,zz : Three 4x(n-1xm-1) matrices. xx(:,i),yy(:,i),zz(:,i) are respectively the x-axis,y-axis and z-axis coordinates of the ith facet

t = linspace(0,2*%pi,10);
zmat=sin(t')*cos(t);
plot3d(t,t,zmat)
[xx,yy,zz]=genfac3d(t,t,zmat);
plot3d(xx,yy,zz)
plot3d([xx xx],[yy yy],[zz 4+zz])

2.31   geom3d projection from 3D on 2D

[x,y]=geom3d(x1,y1,z1)

• x1,y1,z1 : real matrices of the same size (points in R3)
• x,y : real matrices of the same size as x1,y1 or z1

deff("[z]=surf(x,y)","z=sin(x)*cos(y)");
t=%pi*(-10:10)/10;
fplot3d(t,t,surf,35,45,"X@Y@Z");
    //Gives a plot3d
    //now  (t,t,sin(t).*cos(t) ) is a curve on the surface
    //which can be drawn using param3d or the following code
[x,y]=geom3d(t,t,sin(t).*cos(t));
xpoly(x,y,"lines")
    //adding a comment 
[x,y]=geom3d([0,0],[0,0],[5,0]);
xsegs(x,y);
xstring(x(1),y(1)," The point (0,0,0)");

2.32   getcolor dialog to select color(s) in the current colormap

c=getcolor(title [,cini])
c=getcolor()

• title : string, dialog title
• cini : vector of initial color indexes. Default value is xget('pattern')
• c : Vector of selected color indexes, or [] if user has clicked on "Cancel" button

2.33   getsymbol dialog to select a symbol an its size

c=getsymbol(title)

• title : string, dialog title
• c : Vector with 2 entries [n,sz].

2.34   gr_menu simple interactive graphic editor

[sd1]=gr_menu([sd,flag,no_frame])

• sd : list (output of gr_menu), or vector of length four [xmin,ymin,xmax,ymax] (boundaries of the plot).
• sd1 : list (graphical objects created under gr_menu
• flag,noframe : integers with 0, 1 value. Use flag=1 for non interactive mode (i.e to redraw saved gr_menu graphics) and no_frame=1 to avoid a frame around gr_menu graphics.

• [sd]=gr_menu([xmin,ymin,xmax,ymax]) : enters gr_menu with a fixed frame
• [sd]=gr_menu(); : enters gr_menu with the fixed frame [0 0 100 100].
• [sd]=gr_menu(sd) : redraws the graphics stored in sd and enters interactive mode
• [sd]=gr_menu(sd,1) : only draws the graphics stored in sd.
• [sd]=gr_menu(sd,1,1) : only draws the graphics stored in sd and no frame is added.

2.35   graduate pretty axis graduations

[xi,xa,np]=graduate( xmi, xma,n1,n2)        
[xi,xa,np]=graduate( xmi, xma)

• xmi,xma : real scalars
• n1, n2 : integers with default values 3,10
• xi, xa :real scalars
• np : integer

  y=(0:0.33:145.78)';
  xbasc();plot2d1('enn',0,y)
  [ymn,ymx,np]=graduate(mini(y),maxi(y))
  rect=[1,ymn,prod(size(y)),ymx];
  xbasc();plot2d1('enn',0,y,1,'011',' ',rect,[10,3,10,np])

2.36   graycolormap Linear gray colormap

cmap=graycolormap(n)

• n : an integer greater or equal than 1, the "colormap" size
• cmap : matrix with 3 column, [R,G,B] color definition

xset('colormap',graycolormap(32))
plot3d1() 

2.37   grayplot 2D plot of a surface using colors

grayplot(x,y,z,[strf,rect,nax])

• x,y : real vectors of size respectively (1,n1) and (1,n2).
• z : real matrix of size (n1,n2) (values of f)
• strf,rect,nax : optional arguments, ( see plot2d)

 
x=-10:10;y=-10:10;m=rand(21,21);
grayplot(x,y,m,"111",[-20,-20,20,20]);

2.38   hist3d 3D representation of an histogram

hist3d(f [,theta,alpha,leg,flag,ebox])

• f : matrix or list :
  
  1
• - matrix f(i,j)= F(x(i),y(j)), x and y taken as 0:m and 0:n, ( (m,n) is the size of f).
• - list of size 3; list(f,x,y) where f is a matrix of size (m,n) and x and y two vectors of size (1,n+1) and (1,m+1)
  
  0
• rest : see plot3d

2.39   histplot plot an histogram

histplot(npoint,data,[style,strf,leg,rect,nax])

• npoint : integer or a vector of increasing values of size (1,n1)
• data : real vector
• [rest ] : see plot2d

• - if npoint is an integer, plots an histogram of the values stored in data using npoint-equally spaced classes.
• - if npoint is a vector plots an histogram of the values stored in data using the classes ]xi(k) xi(k+1)].

2.40   hotcolormap Yellow to red RGB colormap

cmap=hotcolormap(n)

• n : an integer greater or equal than 3, the "colormap" size
• cmap : matrix with 3 column, [R,G,B] color definition

xset('colormap',hotcolormap(32))
plot3d1() 

2.41   isoview set scales for isometric plot

isoview(xmin,xmax,ymin,ymax)

• xmin,xmax,ymin,ymax : four real values

xbasc();
t=(0:0.1:2*%pi)';
isoview(-1,1,-1,1);
plot2d(sin(t),cos(t),1,'001')

2.42   locate mouse selection of a set of points

[x]=locate([n,flag])

• n, flag : two integer values
• x : vector (2,n1) ( n1=n if the parameter n is given)

• x=locate(n) : if n>0, n points are selected and their coordinates are returned in x(2,n)
• x=locate(n) : If n<=0 points are selected until the user click with the left button which stands for stop. The last point ( clicked with the left button) is not returned.
• x=locate() : same as x=locate(-1)

2.43   m_circle M-circle plot

 m_circle()
 m_circle(gain)

• gain : vector of gains (in DB). The default value is
  
  1
• gain =[-12 -8 -6 -5 -4 -3 -2 -1.4 -1 -.5 0.25 0.5 0.7 1 1.4 2 2.3 3 4 5 6 8 12]
  
  0

//Example 1 :
  s=poly(0,'s')
  h=syslin('c',(s^2+2*0.9*10*s+100)/(s^2+2*0.3*10.1*s+102.01))
  nyquist(h,0.01,100,'(s^2+2*0.9*10*s+100)/(s^2+2*0.3*10.1*s+102.01)')
  m_circle();
//Example 2:
  xbasc();
  h1=h*syslin('c',(s^2+2*0.1*15.1*s+228.01)/(s^2+2*0.9*15*s+225))
  nyquist([h1;h],0.01,100,['h1';'h'])
  m_circle([-8 -6 -4]);

2.44   milk_drop test for plot3d

[z]=milk_drop(x,y)

• x,y : two vectors of size (1,n1) and (1,n2)
• z : matrix of size (n1,n2)

2.45   nyquist nyquist plot

nyquist( sl,[fmin,fmax] [,step] [,comments] )
nyquist( sl, frq [,comments] )
nyquist(frq,db,phi [,comments])
nyquist(frq, repf  [,comments])

• sl : syslin list (SIMO linear system in continuous or discrete time )
• fmin,fmax : real scalars (frequency bounds (in Hz))
• step : real (logarithmic discretization step)
• comments : string vector (captions).
• frq : vector or matrix of frequencies (in Hz) (one row for each output of sl).
• db,phi : real matrices of modulus (in Db) and phases (in degree) (one row for each output of sl).
• repf : matrix of complex numbers. Frequency response (one row for aech output of sl)

xbasc();
s=poly(0,'s');
h=syslin('c',(s^2+2*0.9*10*s+100)/(s^2+2*0.3*10.1*s+102.01));
comm='(s^2+2*0.9*10*s+100)/(s^2+2*0.3*10.1*s+102.01)';
nyquist(h,0.01,100,comm);
h1=h*syslin('c',(s^2+2*0.1*15.1*s+228.01)/(s^2+2*0.9*15*s+225))
xbasc();
nyquist([h1;h],0.01,100,['h1';'h'])
xbasc();nyquist([h1;h])

2.46   param3d set of points or parametric curves in 3-D

param3d(x,y,z,[theta,alpha,leg,flag,ebox]

• x,y,z : three matrices of the same size (considered as vectors with the Fortran storage convention) (points of the parametric curve)
• theta, alpha : gives the coordinates in spherical angle of the observation point
• leg : string describing the caption for each axis, the different fields in the string are separated by the symbol @, for example : "X@Y@Z"
• flag =[type,box] : where type and box have the same meaning as in plot3d
• ebox : a vector of size (1,6) which gives the boundaries of the plot [xmin,xmax,ymin,ymax,zmin,zmax] when the value of type is 1

t=0:0.1:5*%pi;
param3d(sin(t),cos(t),t/10,35,45,"X@Y@Z",[2,3])
xbasc();
xset("dashes",3)
param3d(rand(1,100),rand(1,100),rand(1,100),35,45,"X@Y@Z",[2,3])

2.47   param3d1 set of points or parametric curves in 3-D

param3d1(x,y,z,[theta,alpha,leg,flag,ebox]
param3d1(x,y,list(z,colors),[theta,alpha,leg,flag,ebox]

• x,y,z : three matrices of the same size [nl,nc]. Each column of the matrix code one curve except when nl=1 and nc>0 in which case It is assumed that there's only one curve. If colors is specified, it must be a vector of size nc which gives for each curve its color ( if color[i] >0 ) or the mark which is to be used ( if color[i] <= 0 ).
• theta, alpha : gives the coordinates in spherical angle of the observation point
• leg : string describing the caption for each axis, the different fields in the string are separated by the symbol @, for example : "X@Y@Z"
• flag =[type,box] : where type and box have the same meaning as in plot3d
• ebox : a vector of size (1,6) which gives the boundaries of the plot [xmin,xmax,ymin,ymax,zmin,zmax] when the value of type is 1

t=0:0.1:5*%pi; t=t';
param3d1([sin(t),sin(2*t)],[cos(t),cos(2*t)],...
        list([t/10,sin(t)],[3,2]),35,45,"X@Y@Z",[2,3])

2.48   param3di parametric curves in 3-D with interactive view selection

param3di(x,y,z,[theta,alpha,leg,flag,ebox]

• x,y,z : three matrices of the same size (considered as vectors with the Fortran storage convention) (points of the parametric curve)
• theta, alpha : gives the coordinates in spherical angle of the observation point
• leg : string describing the caption for each axis, the different fields in the string are separated by the symbol @, for example : "X@Y@Z"
• flag =[type,box] : where type and box have the same meaning as in plot3d
• ebox : a vector of size (1,6) which gives the boundaries of the plot [xmin,xmax,ymin,ymax,zmin,zmax] when the value of type is 1

2.49   plot simple plot

plot(x,y,[xcap,ycap,caption])
plot(y,[xcap,ycap,caption])

• x,y : two vectors.
• caption, xcap, ycap : character strings or string matrices

2.50   plot2d multiple plot of functions

plot2d(x,y,[style,strf,leg,rect,nax])
plot2d(y);

• x,y : two matrices of the same size [nl,nc]. nc gives the number of curves and nl gives the number of points for each curve. If nl=1, it's assumed that there's only one curve of nc points.
  
  1
• nc : is the number of curves
• nl : is the number of points of each curve for example : x=[ 1:10;1:10]',y= [ sin(1:10);cos(1:10)]'
  
  0
• style : is a real vector of size (1,nc). the style to use for curve j is defined by size(j).
  
  1
• - if style[i] is negative the curve is plotted using the mark of Id style[i],
• - if style[i] is strictly positive a dashed or plain line of id (or color)abs(style[i]) is used.
• - When only one curve is drawn style can be of size (1,2) [style,pos] where style is used to specify the style and pos is an integer in the range 1,6 which specifies a position to use for the caption (this can be useful when a user wants to draw multiple curves on a plot by calling the function plot several times and wants to give a caption for each curve)
  
  0
• strf : is a string of length 3 "xyz"
  
  1
• x : captions are displayed if x is the character 1. Captions are given by the string leg "leg1@leg2@...."
• y : controls the computation of the frame
  
  2
• y=0 : the current boundaries ( set by a previous call to an other high level plotting function ) are used.
• y=1 : the argument rect is used to specify the boundaries of the plot. rect=[xmin,ymin,xmax,ymax]
• y=2 : the boundaries of the plot are computed using max and min values of x and y.
• y=3 : like y=1 but produces isoview scaling
• y=4 : like y=2 but produces isoview scaling
• y=5 : like y=1 but the boundaries and nax can be changed to produce pretty graduations. This mode is used when the zoom button is activated.
• y=6 : like y=2 but the boundaries and nax can be changed to produce pretty graduations. This mode is used when the zoom button is activated.
  
  1
• z : controls the display of information on the frame around the plot
  
  2
• z=1 : an axis is drawn the number of tics can be specified by the nax argument. nax is a vector with four entries [nx,Nx,ny,Ny] where nx (ny) is the number of subgrads on the x (y) axis and Nx (Ny) is the number of graduations on the x (y) axis
  
  
• z=2 : the plot is only surrounded by a box
• other value Nothing around the plot
  
  1
  
  0

x=0:0.1:2*%pi;
//simple plot
plot2d(sin(x));
//multiple plot
xbasc();
plot2d([x;x;x]',[sin(x);sin(2*x);sin(3*x)]');
//multiple plot with captions
xbasc();
plot2d([x;x;x]',[sin(x);sin(2*x);sin(3*x)]',...
[1,2,3],"111","L1@L2@L3",[0,-2,2*%pi,2],[2,10,2,10]);
// isoview
xbasc(); 
plot2d(x',sin(x)',1,'041')
// auto scale 
xbasc();
plot2d(x',sin(x)',1,'061') 

2.51   plot2d1 multiple plot of functions

plot2d1(str,x,y,[style,strf,leg,rect,nax])

• str : is a string of length three "abc"
  
  1
• a : can have the following values : e | o | g
  
  2
• e : means empty and specifies the fact that the value of x won't be used ( the x values are supposed to be regularly spaced) . The user must anyway give a value to the x parameter when calling plot2d1, for example plot2d1("enn",1,y).
• o : stands for one. if there are many curves, they all have the same x-values ( x is of size x(n,1) and y of size y(n,n1). for example : plot2d1("onn",(1:10)',[sin(1:10);cos(1:10)]')
• g : stands for general. x and y must then have the same size
  
  1
• b,c : can have the values n or l.
  
  2
• b=l : a logarithmic axis is used on the X-axis
• c=l : a logarithmic axis is used on the Y-axis
  
  1
  
  0

2.52   plot2d2 multiple plot of functions (step function)

plot2d2(str,x,y,[style,strf,leg,rect,nax])

 
plot2d2("gnn",(1:4)',(1:4)',1,'111','step function',[0,0,5,5])

2.53   plot2d3 multiple plot of functions (vertical bars)

plot2d3(str,x,y,[style,strf,leg,rect,nax])

2.54   plot2d4 multiple plot of functions

plot2d4(str,x,y,[style,strf,leg,rect,nax])

2.55   plot3d surface plotting

plot3d(x,y,z [,theta,alpha,leg [,flag,ebox]])
plot3d(xf,yf,zf [,theta,alpha,leg [,flag,ebox]])
plot3d(xf,yf,list(zf,colors) [,theta,alpha,leg [,flag,ebox]])

• x,y : matrices of sizes (1,n1) and (1,n2) (point coordinates). These coordinates must be monotone.
• z : matrix of size (n1,n2) ( z(i,j) : value of f at the point (x(i),y(j))
• xf,yf,zf : (nf,n) matrices. xf(:,i),yf(:,i),zf(:,i) are respectively the x-axis,y-axis and z-axis coordinates of the ith facet. Where nf is the size of the facets (nf must be greater than 2) and n the number of facets. One can use list(zf,colors), with colors a vector of size n in order to give specific colors for each facet.
• theta, alpha : real values giving in degree the spherical coordinates of the observation point
• leg : string (captions for each axis. this is string with @ as a field separator, for example : "X@Y@Z")
• flag : is a real vector of size three flag=[mode,type,box]
  
  1
• mode : string (treatment of hidden parts)
  
  2
• mode > 0 the hidden parts of the surface are removed and the surface is painted with color mode.
• mode = 0 the hidden parts of the surface are drawn.
• mode < 0 only the shadow of the surface is painted with color or pattern -mode.
  
  1
• type : scaling
  
  2
• if type = 0 the plot is made using the current 3D scaling ( set by a previous call to param3d, plot3d, contour, plot3d1)
• if type = 1 the boundaries are specified by the value of the parameter

• else the boundaries are computed with the given datas.
  
  1
• box : frame display around the plot.
  
  2
• box=0 nothing is drawn around the plot
• box=1 unimplemented ( like box=0 )
• box=2 only the axes behind the surface are drawn
• box=3 a box surrounding the surface is drawn and captions are added
• box=4 a box surrounding the surface is drawn, captions are added and axes too.
  
  1
  
  0

plot3d(1:10,1:20,10*rand(10,20),35,45,"X@Y@Z",[2,2,3])
xbasc();
t=(0:0.3:2*%pi)';zmat=sin(t)*cos(t');
[xx,yy,zz]=genfac3d(t,t,zmat);
plot3d([xx xx],[yy yy],[zz 4+zz]);
xbasc();
plot3d([xx xx],[yy yy],list([zz zz+4],[4*ones(1,400) 5*ones(1,400)]))

2.56   plot3d1 gray or color level plotting of a surface.

plot3d1(x,y,z,[theta,alpha,leg,flag,ebox])
plot3d1(xf,yf,zf [,theta,alpha,leg [,flag,ebox]])

plot3d1(1:10,1:20,10*rand(10,20),35,45,"X@Y@Z",[2,2,3]);
xbasc();
plot3d1(1:10,1:20,10*rand(10,20),35,45,"X@Y@Z",[-2,2,3]);
xbasc();
t=(0:0.3:2*%pi)';zmat=sin(t)*cos(t');
[xx,yy,zz]=genfac3d(t,t,zmat);
plot3d1([xx xx],[yy yy],[zz 4+zz]);
xbasc();
plot3d1([xx xx],[yy yy],list([zz zz+4],[4*ones(1,400) 5*ones(1,400)]))

2.57   plotframe graphic frame with scaling and grids

plotframe(rect,tics [,arg_opt1,arg_opt2,arg_opt3])

• rect : vector [xmin,ymin,xmax,ymax] made of x and y bounds.
• tics : vector [nx,mx,ny,my] where mx, nx (resp. my, ny) are the number of x-axis (resp. y-axis) intervals and subintervals.
• arg_optX : optional arguments up to three and choosen among.
  
  1
• flags : vector [wantgrids,findbounds] where wantgrids is a boolean variable (%t or %f) which indicates gridding. findbounds is a boolean variable. If findbounds is %t, the bounds given in rect are allowed to be slightly modified ( in fact always increased ) in order to have simpler graduations (then tics(2),tics(4) are ignored).
• captions : vector of 3 character strings [title, x-leg, y-leg].
• subwin : a vector of size 4 (sub window definition) The sub window is specified with the parameter subwwin=[x,y,w,h] ( Upper-Left Width Height ). The values in subwin are specified using proportion of the width or height of the current graphic window ( See xsetech ).
  
  0

x=[-0.3:0.8:27.3]';
y=rand(x);
rect=[min(x),min(y),max(x),max(y)];
tics=[4,10,2,5];    //4 x-intervals and 2 y-intervals
plotframe(rect,tics,[%f,%f],['My plot','x','y'],[0,0,0.5,0.5]);
plot2d(x,y,2,'000')
plotframe(rect,tics,[%t,%f],['My plot with grids','x','y'],[0.5,0,0.5,0.5]);
plot2d(x,y,3,'000')
plotframe(rect,tics,[%t,%t],...
['My plot with grids and automatic bounds','x','y'],[0,0.5,0.5,0.5]);
plot2d(x,y,4,'000')
plotframe(rect,tics,[%f,%t],...
        ['My plot without grids but with automatic bounds','x','y'],...
        [0.5,0.5,0.5,0.5]);
plot2d(x,y,5,'000');
xset('default');

2.58   plzr pole-zero plot

plzr(sl) 

• sl : list ( syslin)

 
s=poly(0,'s');
n=[1+s   2+3*s+4*s^2        5; 0        1-s             s];
d=[1+3*s   5-s^3           s+1;1+s     1+s+s^2      3*s-1];
h=syslin('c',n./d); 
plzr(h);

2.59   printing printing scilab graphics

Blatexpr xscale yscale filename.ps
BEpsf filename.ps 
Blpr "Title" filename1.ps filename2.ps ... filenamen.ps | lpr 

 
        xbasimp(xx,'des.ps',0)

• BEpsf : The BEpsf command will create an Epsf file from your des.ps.xx under the name des.epsf, this Epsf file can be printed on a Postscript printer or inserted into an other Postscript document.
• Blatexpr : The Blatexpr command will create an Epsf file from your des.ps.xx

   
    mv des.ps.xx des.ps
    Blatexpr 1.0 1.0 des.ps
  

  under the name des.epsf and a LaTeX file des.tex. The file des.tex can be inserted in a LaTeX file in order to get the latex figure as follows ( the postscript file is inserted with the special command of LaTeX )

   
          \input des.tex 
          \dessin{caption}{label}
  

• Blpr : The Blpr command is used to print a set of graphics on a same sheet of paper. For example to print two graphics on a unique page, one can use :

   
  Blpr "Two graphics" file1.ps.0 file2.ps.1 | lpr 
  

• Blatexprs : The Blatexprs command is used to insert in a single LaTeX figure a set of Scilab Graphics

   
  Blatexprs res file1.ps.0 file2.ps.1
  

  will create two files res.ps and res.tex. The file res.tex is used as in the Blatexpr command in order to get the figure.

2.60   rotate geometric rotation of a set of points

[xy1]=rotate(xy,[theta,orig])

• xy,xy1 : matrices of size (2,.)
• theta : real (angle en radian) , (default value=0)
• orig : center of the rotation [0;0] if omitted

 
xsetech([0,0,1,1],[-1,-1,1,1])
xy=[(0:0.1:10);sin(0:0.1:10)]/10;
for i=2*%pi*(0:10)/10,[xy1]=rotate(xy,i);
        xpoly(xy1(1,:),xy1(2,:),"lines")
end

2.61   scaling affine transform of a set of points

[xy1]=scaling(xy,factor,orig)

• xy,xy1 : matrices of size (2,.)
• factor : real scalar (linear transform coef)
• orig : shift vector (default value =[0;0] )

2.62   sd2sci gr_menu structure to scilab instruction convertor

txt=sd2sci(sd [,sz [,orig]])

• sd : data structure build by gr_menu.
• sz : vector of number or strings with two components, give the x and y zoom factors
• orig : vector of number or strings with two components, give the origin translation vector

2.63   secto3d 3D surfaces conversion

[m[,x]]=secto3d(seclist,npas)
[m]=secto3d(seclist ,x) 

• seclist : a list whose elements are (2,.) matrices
• npas : an integer
• m : a matrix
• x : a vector

• - The i-th row of the matrix m corresponds to the i-th section
• - The j-th column of m corresponds to the x(j)

2.64   sgrid s-plane grid lines.

sgrid()
sgrid('new')
sgrid(zeta,wn [,color])

• sgrid() : add a grid over an existing continuous s-plane root with default values for zeta and wn.
• sgrid('new') : clears the graphic screen and then plots a default s-plane grid
• sgrid(zeta,wn [,color]) : same as sgrid() but uses the provided damping ratio and natural frequency.
  
  0

H=syslin('c',352*poly(-5,'s')/poly([0,0,2000,200,25,1],'s','c'));
evans(H,100)
sgrid()
sgrid(0.6,2,7)

2.65   square sets scales for isometric graphics

square(xmin,ymin,xmax,ymax)

• xmin,xmax,ymin,ymax : four real values

2.66   titlepage display a matrix of strings

titlepage(str)

• str : matrix of strings

2.67   winsid return the list of graphic windows id

[x]=winsid()

• x : a row vector

2.68   xarc draws a part of an ellipsis

xarc(x,y,w,h,a1,a2)

• x,y,w,h : real (rectangle def)
• a1,a2 : real (angle def)

// isoview scaling 
plot2d(0,0,-1,"031"," ",[-2,-2,2,2])
xset("dashes",3);
xarc(-1,1,2,2,0,90*64)
xarc(-1.5,1.5,3,3,0,360*64)

2.69   xarcs drawing a set of ellipsis

[]=xarcs(arcs,[style])

• arcs : matrix of size (6,n) (ellipsis description)
• style : vector of size (1,n) giving the style to use ( set xset("dashes",...).

 
plot2d(0,0,-1,"031",' ',[-1,-1,1,1])
set_arcs=[ -1.0 0.0 0.5 // upper left x
            1.0 0.0 0.5 // upper left y
            0.5 0.5 0.5 // widths 
            0.5 0.5 0.5 // height 
            0.0 0.0 0.0 // angle 1
            360*64 360*64 360*64] // angle 2
xarcs(set_arcs,[1,2,3])

2.70   xarrows draw a set of arrows

[]=xarrows(nx,ny,[arsize,style])

• nx : real matrix of size (n1,n2)
• ny : real matrix of size (n1,n2)
• arsize : real scalar (size of the arrow head). The default value can be obtained by setting arsize to value -1.0.
• style : a matrix of size n or a scalar. If style is a positive scalar it gives the dash style to use for all arrows, if it is a negative scalar then current dash style is used, if it is a vector style[i] gives the style to use for arrow i.

nx=[ xi_1,x1_2,...; xf_1,xf_2,...]
ny=[ yi_1,y1_2,...; yf_1,yf_2,...]

x=2*%pi*(0:9)/8;
x1=[sin(x);9*sin(x)];
y1=[cos(x);9*cos(x)];
plot2d([-10,10],[-10,10],[-1,-1],"022");
xset('clipgrf')
xarrows(x1,y1,1,1:10);
xset('clipoff')

2.71   xaxis draws an axis

[]=xaxis(alpha,nsteps,size,init)

• alpha : real (slope in degree of the axis)
• nsteps : real vector of size 2 (number of big and small intervals)
• size : a real vector of size 3 (size of the intervals, the small and big tics)

 
            ex : n1=3,n2=2,alpha =0
                                               (s2*c1) 
            |     (s2)   |            |           |
            |______|_____|_____|______|_____|_____|
               s1

 
plot2d((1:0.1:10),sin(1:0.1:10))
xaxis(-90,[2,5],[0.1,0.1,2],[8,0])
xaxis(0,[2,3],[0.5,0.1,2],[5,0])

2.72   xbasc clear a graphic window and erase associated recorded graphics

xbasc([win_num])

• win_num : integer scalar or vector

2.73   xbasimp send graphics to a postscript printer or in a file

xbasimp(win_num,[filen,printer])

• win_num : an integer scalar or vector
• filen : string (Postscript file name). (default value=file). The window number is appended to the filen.
• printer : string (Printer name). if printer is present or if there's only one argument in the calling sequence, the created file is printed on printer printer.

2.74   xbasr redraw a graphic window

xbasr(win_num)

2.75   xchange coordinates transform

[x1,y1,rect]=xchange(x,y,dir)

• x,y : two matrices of size (n1,n2) (coordinates of a set of points)
• x1,y1 : two matrices of size (n1,n2) (coordinates of the set of points )
• rect : a vector of size 4 (values in pixel of the coordinates of the rectangle in which the scale was fixed)

2.76   xclea erase a rectangle on a graphic window

xclea(x,y,w,h)

• x,y,w,h : four real values (rectangle def)

2.77   xclear clear a graphic window

xclear([window-id])

• window-id : integer vector

2.78   xclick wait for a mouse click

[c_i,c_x,c_y]=xclick([flag])
[c_i,c_x,c_y,c_w]=xclick([flag])
[c_i,c_x,c_y,c_w,c_m]=xclick([flag])

• c_i : integer (button number)
• c_x,c_y : real scalars (position)
• c_w : integer (window number)
• c_m : Character string (menu callback)
• flag : an integer. If present, the click event queue is not cleared when entering xclick

• c_i : an integer which gives the number of the mouse button that was pressed [0,1,2] (for [left,middle,right]) or i=-1 in case of problems with xclick.
• c_x,c_y : the coordinates in the current graphic scale of the position of the mouse click.
• c_w : the window number where the click has occurred
• c_m : Character string associated with a dynamic menu. If xclick returns due to a click on a menu, c_i, c_x, c_y, c_w take arbitrary values.