Copyright: 1993 The MathWorks Inc.


ABS

 Absolute value and string to numeric conversion.

  ABS(X) is the absolute value of the elements of X. When

  X is complex, ABS(X) is the complex modulus (magnitude) of

  the elements of X.

  See also ANGLE, UNWRAP.

  ABS(S), where S is a MATLAB string variable, returns the

  numeric values of the ASCII characters in the string.

  It does not change the internal representation, only the

  way it prints.

  See also SETSTR.


ACOS

 Inverse cosine.

  ACOS(X) is the arccosine of the elements of X. Complex

  results are obtained if ABS(x) > 1.0 for some element.


ACOSH

 Inverse hyperbolic cosine.

  ACOSH(X) is the inverse hyperbolic cosine of the elements of X.


ACOT

 Inverse cotangent.

  ACOT(X) is the inverse cotangent of the elements of X.


ACOTH

 Inverse hyperbolic cotangent.

  ACOTH(X) is the inverse hyperbolic cotangent of the elements of X.


ACSC

 Inverse cosecant.

  ACSC(X) is the inverse cosecant of the elements of X.


ACSCH

 Inverse hyperbolic cosecant.

  ACSCH(X) is the inverse hyperbolic cosecant of the elements of X.


AIRFOIL

 Display sparse matrix from NASA airfoil.


ALL

 True if all elements of a vector are true.

  For vectors, ALL(V) returns 1 if all of the elements of the

  vector are non-zero. Otherwise it returns 0. For matrices,

  ALL(X) operates on the columns of X, returning a row vector

  of 1's and 0's.


ANDREW

  Demo for andrew hurricane.


ANGLE

 Phase angle.

  ANGLE(H) returns the phase angles, in radians, of a matrix with

  complex elements.

  See also ABS, UNWRAP.


ANS

 The most recent answer.

  ANS is the variable created automatically when expressions

  are not assigned to anything else. ANSwer.


ANY

 True if any element of a vector is true.

  For vectors, ANY(V) returns 1 if any of the elements of the

  vector are non-zero. Otherwise it returns 0. For matrices,

  ANY(X) operates on the columns of X, returning a row vector

  of 1's and 0's.


ARITH

  +   Plus.

       X + Y adds matrices X and Y.  X and Y must have the same

       dimensions unless one is a scalar (a 1-by-1 matrix).

       A scalar can be added to anything.

   -   Minus.

       X - Y subtracts matrix X from Y.  X and Y must have the same

       dimensions unless one is a scalar.  A scalar can be subtracted

       from anything.

   *   Matrix multiplication.

       X*Y is the matrix product of X and Y.  Any scalar (a 1-by-1 matrix)

       may multiply anything.  Otherwise, the number of columns of X must

       equal the number of rows of Y.

   .*  Array multiplication

       X.*Y denotes element-by-element multiplication.  X and Y

       must have the same dimensions unless one is a scalar.

       A scalar can be multiplied into anything.

   ^   Matrix power.

       Z = X^y is X to the y power if y is a scalar and X is square. If y is an

       integer greater than one, the power is computed by repeated

       multiplication. For other values of y the calculation

       involves eigenvalues and eigenvectors.

       Z = x^Y is x to the Y power, if Y is a square matrix and x is a scalar,

       computed using eigenvalues and eigenvectors.

       Z = X^Y, where both X and Y are matrices, is an error.

   .^  Array power.

       Z = X.^Y denotes element-by-element powers.  X and Y

       must have the same dimensions unless one is a scalar.

       A scalar can operate into anything.

  Copyright (c) 1984-93 by The MathWorks, Inc.


ASEC

 Inverse secant.

  ASEC(X) is the inverse secant of the elements of X.


ASECH

 Inverse hyperbolic secant.

  ASECH(X) is the inverse hyperbolic secant of the elements of X.


ASIN

 Inverse sine.

  ASIN(X) is the arcsine of the elements of X. Complex

  results are obtained if ABS(x) > 1.0 for some element.


ASINH

 Inverse hyperbolic sine.

  ASINH(X) is the inverse hyperbolic sine of the elements of X.


ATAN

 Inverse tangent.

  ATAN(X) is the arctangent of the elements of X.

  See also ATAN2.


ATAN2

 Four quadrant inverse tangent.

  ATAN2(Y,X) is the four quadrant arctangent of the real parts of the

  elements of X and Y.  -pi <= ATAN2(Y,X) <= pi.

  See also ATAN.


ATANH

 Inverse hyperbolic tangent.

  ATANH(X) is the inverse hyperbolic tangent of the elements of X.


AUREAD

 Read mu-law encoded audio file.

  Y = AUREAD('filename') reads the audio file in 'filename'

  and converts the data from mu-law encoded bytes to a signal

  in the range -1 <= Y <= 1.


AUWRITE

 Write mu-law encoded audio file.

  AUWRITE(Y,'filename') converts Y to mu-law encoded bytes

  and writes it to the specified audio file.

  /dev/audio is used if the file name is not given.


AXES

 Create axis at arbitrary positions.

  AXES('position', RECT) opens up an axis at the specified location

  and returns a handle to it.

  RECT = [left, bottom, width, height] specifies the location and

  size of the side of the axis box, relative to the lower-left

  corner of the Figure window, and in in normalized units where (0,0)

  is the lower-left corner and (1.0,1.0) is the upper-right.

  AXES, by itself, creates the default full-window axis and returns

  a handle to it.

  AXES(H) makes the axis with handle H current.

         Execute GET(H) to see a list of axes object properties and

         their current values. Execute SET(H) to see a list of axes

         object properties and legal property values.

  See also SUBPLOT, FIGURE, GCA, CLA.


AXIS

 Plot axis scaling and appearance.

  AXIS([XMIN XMAX YMIN YMAX]) sets scaling for the x- and y-axes

  on the current plot.

  AXIS([XMIN XMAX YMIN YMAX ZMIN ZMAX]) sets the scaling for the

  x-, y- and z-axes on the current 3-D plot.

  AXIS('auto') returns the axis scaling to its default, automatic

  mode where, for each plot, xmin = min(x), xmax = max(x), etc.

  V = AXIS returns a row vector containing the scaling for the

  current plot.  If the current plot is two-dimensional, V has

  four components; if it is three-dimensional, V has six components.

  AXIS(AXIS) freezes the scaling at the current limits, so that if

  HOLD is turned on, subsquent plots will use the same limits.

  AXIS('ij') puts MATLAB into its "matrix" axes mode.  The coordinate

  system origin is at the upper left corner.  The i axis is vertical

  and is numbered from top to bottom.  The j axis is horizontal and

  is numbered from left to right.

  AXIS('xy') puts MATLAB into its default "Cartesian" axes mode.

  The coordinate system origin is at the lower left corner.  The x axis

  is horizontal and is numbered from left to right.  The y axis is

  vertical and is numbered from bottom to top.

  AXIS('equal') changes the current axis box size so that equal tick

  mark increments on the x- and y-axis are equal in size. This makes

  PLOT(SIN(X),COS(X)) look like a circle, instead of an oval.

  AXIS('square') makes the current axis box square in size.

  AXIS('image'), for images, makes the aspect ratio the same size as

  the image.

  AXIS('normal') restores the current axis box to full size and

  removes any restrictions on the scaling of the units.

  This undoes the effects of AXIS('square') and AXIS('equal').

  AXIS('image') sets the aspect ratio and the axis limits so the

  image in the current axes has square pixels.

  AXIS('off') turns off all axis labeling and tick marks.

  AXIS('on') turns axis labeling and tick marks back on.

  [S1,S2,S3] = AXIS('state') returns strings indicating the

  current setting of three axis properties.

     S1 = 'auto' or 'manual'.

     S2 = 'on' or 'off'.

     S3 = 'xy' or 'ij'.


BALANCE

 Diagonal scaling to improve eigenvalue accuracy.

  [T,B] = BALANCE(A) finds a similarity transformation T such

  that B = T\A*T has approximately equal row and column norms.

  BALANCE(A), by itself, returns the balanced matrix B.


BAR

 Bar graph.

  BAR(Y) draws a bar graph of the elements of vector Y.

  BAR(X,Y) draws a bar graph of the elements of vector Y at

  the locations specified in vector X.  The X-values must

  be in ascending order.  If the X-values are not evenly spaced, the

  interval chosen is not symmetric about each data point.  Instead,

  the bars are drawn midway between adjacent X-values.  The endpoints

  simply adopt the internal intervals for the external ones needed.

  If X and Y are matrices the same size, one bar graph per column

  is drawn.

  [XX,YY] = BAR(X,Y) does not draw a graph, but returns vectors

  X and Y such that PLOT(XX,YY) is the bar chart.

  See also STAIRS, HIST.

  BAR(X,'linetype') or BAR(X,Y,'linetype') uses the plot linetype

  specified.  See PLOT for details.


BENCH

 MATLAB Benchmark

  BENCH times five different MATLAB tasks and compares the

  execution speed with the speed of several other computers.

  The problem sizes are chosen so that each task requires about

  one second on a Sun SPARC-2. The five tasks are:

   Loops     For loops and "zeros".   Strings and "malloc".

   LU        MATLAB's "LINPACK".      Primarily floating point.

   Sparse    Solve sparse system.     Mixed integer and floating point.

   3-D       Surf plot of "peaks".    3-D polygonal fill graphics.

   2-D       plot(fft(eye)).          2-D line drawing graphics.

  BENCH runs each of the five tasks 10 times.

  BENCH(N) runs each of the five tasks N times.

  TIMES = BENCH(N) returns a vector with the five execution times.

  On a Sun SPARC-2, BENCH(N) would nominally produce [N N N N N].

  Smaller values are faster, larger are slower.

  A final bar chart shows speed, which is inversely proportional to

  time.  Here, longer bars are faster machines, shorter bars are slower.

  CAVEAT: Fluctuations of five or 10 percent in the measured times

  of repeated runs on a single machine are not uncommon.

  Your own mileage may vary.


BESSEL

 Bessel functions of various kinds.

  The suite of M-files for Bessel functions has been modified and

  extended since the reference manuals for MATLAB 3.5 and 4.0 were

  printed.  The underlying algorithms have been substantially

  improved.  There are now four primary functions for real X.

      BESSELJ(ALPHA,X)  Bessel functions of the first kind,

      BESSELY(ALPHA,X)  Bessel functions of the second kind,

      BESSELI(ALPHA,X)  Modified Bessel functions of the first kind,

      BESSELK(ALPHA,X)  Modified Bessel functions of the second kind.

  An old function, BESSELA(ALPHA,X), accepts complex X, but may

  produce inaccurate results for large ALPHA or large X.

  This M-file, BESSEL(ALPHA,X), calls BESSELJ(ALPHA,X) if X is real,

  BESSELI(ALPHA,X) if X is imaginary, and BESSELA(ALPHA,X) if X

  is complex.  The auxilliary routine BESSELN is no longer used.

  BESSELH has been superceded by BESSELY.


BESSELA

 Fractional order Bessel functions and accuracy estimate.

  Warning: May be inaccurate for large arguments.  See below.

  J = bessela(nu,X) = Bessel function, J-sub-nu (X).

  Bessel functions are solutions to Bessel's differential

  equation of order nu:

           2                    2    2

          x * y'' +  x * y' + (x - nu ) * y = 0

  The function is evaluated for every point in the array X.

  The order, nu, must be a nonnegative scalar.

  See also BESSEL, BESSELJ, BESSELI.

  For some values of the arguments, this computation is

  severely contaminated by roundoff error.  Consequently

  [J,digits] = bessela(nu,x) returns an estimate of the

  number of correct significant digits in the computed

  result.  digits is the log10 of the estimated relative error,

  so digits = 14 or 15 corresponds to nearly full accuracy

  in IEEE or VAX arithmetic, while digits = 1 or 2 indicates

  nearly useless results.  Any negative value of digits is

  replaced by zero, the corresponding J set to NaN and a

  division by zero warning message is generated.

  If either nu or x is less than 50, digits will be at least 8.

  In the (nu,x) plane, the region of least accuracy is near

  the line nu = x, so small values of nu and large values of x,

  or vice versa, give the most accurate results.

  Here some representative values of digits:

                                    nu

                                25      75

 	                          --------------

                   x   25   |  11.8    14.4

                       75   |  14.5     1.9


BESSELI

 Modified Bessel functions of the first kind.

  I = BESSELI(ALPHA,X) computes modified Bessel functions of the

  first kind, I_sub_alpha(X) for real, non-negative order ALPHA

  and argument X.  In general, both ALPHA and X may be vectors.

  The output I is m-by-n with m = lenth(X), n = length(ALPHA) and

      I(k,j) = I_sub_alpha(j)(X(k)).

  The elements of X can be any nonnegative real values in any order.

  For ALPHA there are two important restrictions: the increment

  in ALPHA must be one, i.e. ALPHA = alpha:1:alpha+n-1, and the

  elements must also be in the range 0 <= ALPHA(j) <= 1000.

  E = BESSELI(ALPHA,X,1) computes I_sub_alpha(X)*EXP(-X).

  The relationship between the Bessel functions of the first kind is

      I_sub_alpha(x) = i^(-alpha) * J_sub_alpha(i*x)

  Examples:

      besseli(3:9,[0:.2:9.8 10:.5:20],1) generates the entire

      71-by-7 table on page 423 of Abramowitz and Stegun,

      "Handbook of Mathematical Functions."

  See also: BESSELJ, BESSELY, BESSELK.


BESSELJ

 Bessel functions of the first kind.

  J = BESSELJ(ALPHA,X) computes Bessel functions of the first kind,

  J_sub_alpha(X) for real, non-negative order ALPHA and argument X.

  In general, both ALPHA and X may be vectors.  The output J is

  an m-by-n matrix with m = lenth(X), n = length(ALPHA) and

      J(i,k) = J_sub_alpha(k)(X(i)).

  The elements of X can be any nonnegative real values in any order.

  For ALPHA, however, there are two important restrictions: the

  increment in ALPHA must be one, i.e. ALPHA = alpha:1:alpha+n-1,

  and the values must satisfy 0 <= alpha(k) <= 1000.

  Examples:

      besselj(3:9,(10:.2:20)') generates the 51-by-7 table on page 400

      of Abramowitz and Stegun, "Handbook of Mathematical Functions."

      besselj(2/3:1:98/3,r) generates the fractional order Bessel

      functions used by the MathWorks Logo, the L-shaped membrane.

      J_sub_2/3(r) matches the singularity at the interior corner

      where the angle is pi/(2/3).

  See also: BESSELY, BESSELI, BESSELK.


BESSELK

 Modified Bessel functions of the second kind.

  K = BESSELK(ALPHA,X) computes modified Bessel functions of the

  second kind, K_sub_alpha(X) for real, non-negative order ALPHA

  and argument X.  In general, both ALPHA and X may be vectors.

  The output I is m-by-n with m = lenth(X), n = length(ALPHA) and

      I(k,j) = I_sub_alpha(j)(X(k)).

  The elements of X can be any nonnegative real values in any order.

  For ALPHA there are two important restrictions: the increment

  in ALPHA must be one, i.e. ALPHA = alpha:1:alpha+n-1, and the

  elements must also be in the range 0 <= ALPHA(j) <= 1000.

  E = BESSELK(ALPHA,X,1) computes K_sub_alpha(X)*EXP(X).

  The relationship to unmodified Bessel functions with imaginary

  argument:

      K_sub_alpha(x) = pi/2 * i^(-alpha) * (J_sub_alpha(i*x) +

                       Y_sub_alpha(i*x))

  Examples:

      besselk(3:9,[0:.2:9.8 10:.5:20],1) generates the entire

      71-by-7 table on page 424 of Abramowitz and Stegun,

      "Handbook of Mathematical Functions."

  See also: BESSELJ, BESSELY, BESSELI.


BESSELY

 Bessel functions of the second kind.

  Y = BESSELY(ALPHA,X) calculates Bessel functions of the second kind,

  Y_sub_alpha(X) for real, non-negative order ALPHA and argument X.

  In general, both ALPHA and X may be vectors.  The output Y is

  an m-y-n matrix with m = lenth(X), n = length(ALPHA) and

      Y(i,k) = Y_sub_alpha(k)(X(i)).

  The elements of X can be any nonnegative real values in any order.

  For ALPHA, however, there are two important restrictions: the

  increment in ALPHA must be one, i.e. ALPHA = alpha:1:alpha+n-1,

  and the values must satisfy 0 <= alpha(k) <= 1000.

  Examples:

      bessely(3:9,(10:.2:20)') generates the 51-by-7 table on page 401

      of Abramowitz and Stegun, "Handbook of Mathematical Functions."

  See also: BESSELJ, BESSELI, BESSELK.


BETA

 Beta function.

  y = beta(z,w).

  y = integral from 0 to 1 of t.^(z-1) .* (1-t).^(w-1) dt.

  z and w must be compatible for addition.

  Incomplete beta function.

         y = beta(x,a,b).

         The elements of x must be in the interval [0,1].

         a and b must be scalars.

  See also BETAINC, BETALN.


BETACORE

 Core algorithm for the incomplete beta function.

  BETACORE(x,a,b) is used twice by BETAINC(X,A,B).

  See also BETAINC.


BETAINC

 Incomplete beta function.

  y = betainc(x,a,b).

  The elements of x must be in the interval [0,1].

  a and b must be scalars.

  See also BETA.


BETALN

 Logarithm of beta function.

  y = betaln(z,w).

  z and w must be compatible for addition.

  See also BETAINC, BETA.

  Ref: Abramowitz & Stegun, sec. 6.2.


BLANKS

 A string of blanks.

  BLANKS(n) is a string of n blanks.

  Use with DISP, eg.  DISP(['xxx' BLANKS(20) 'yyy']).

  DISP(BLANKS(n)') moves the cursor down n lines.

  See also CLC, HOME, FORMAT COMPACT.


BLT

 Set line and text objects to Black or White.

  BLT is an M-file that will recursively change the color

  properties of the given object, or the current Figure window by

  default, and its children to give proper black on white or white

  on blackhardcopy output. The color of the line/text object depends

  on the contrastColor RGB triplet supplied, or the Figure's color

  attribute if none is supplied.

  Returned are the colors of all line and text objects found while

  traversing the tree of objects. This can be used to restore the

  previous colors to all line and text objects.

  See also PRINT.


BONE

 Gray-scale with a tinge of blue color map.

  BONE(M) returns an M-by-3 matrix containing a "bone" colormap.

  BONE, by itself, is the same length as the current colormap.

  For example, to reset the colormap of the current figure:

            colormap(bone)

  See also HSV, GRAY, HOT, COOL, COPPER, PINK, FLAG,

  COLORMAP, RGBPLOT.


BREAK

 Terminate the execution of a loop.

  BREAK terminates the execution of loops.

  In nested loops, BREAK exits from the

  innermost loop only.


BRIGHTEN

 Brighten or darken color map.

  BRIGHTEN(beta) replaces the current color map with a brighter

  or darker map involving essentially the same colors.  The map is

  brighter if 0 < beta <= 1 and darker if -1 <= beta < 0.

  BRIGHTEN(beta), followed by BRIGHTEN(-beta) restores the

  original map.

  map = BRIGHTEN(beta) returns a brighter or darker version of the

  color map currently being used without changing the display.

  newmap = BRIGHTEN(map,beta) returns a brighter or darker version

  of the specified color map without changing the display.


BUCKY

 Connectivity graph of the Buckminister Fuller geodesic dome.

  B = BUCKY is the 60-by-60 sparse adjacency matrix of the

      connectivity graph of the geodesic dome, the soccer ball,

      and the carbon-60 molecule.

  [B,V] = BUCKY also returns xyz coordinates of the vertices.

  BUCKY, with no output arguments, demonstrates itself.


BUTTONV

 Vector of buttons.  Used by CENSUS demo.

  BUTTONV([xmin ymin],k1:k2,ks,'callback', ... )

  The lower left corner is [xmin ymin] in figure normalized coordinates.

  The buttons are labeled with integers k1:k2.

  Initially, button ks is highlighted.

  After each button push, a variable named button is set to the

  button index and the string 'callback' is evaluated.

  Up to 3 additional optional arguments are extra button labels.


CART2POL

 Transform Cartesian coordinates to polar.

  [TH,R] = CART2POL(X,Y) transforms data stored in Cartesian

  coordinates to polar coordinates. If [M,N] = SIZE(X), then

  Y must be also be the same size. TH is returned in radians.

  [TH,R,Z] = CART2POL(X,Y,Z) transforms data stored in Cartesian

  coordinates to cylindrical coordinates. If [M,N] = SIZE(X), then

  Y and Z must be the same size.

  See also CART2SPH, SPH2CART, POL2CART.


CART2SPH

 Transform Cartesian coordinates to spherical.

  [AZ,EL,R] = CART2SPH(X,Y,Z) transforms data stored in Cartesian

  coordinates to spherical coordinates. If [M,N] = SIZE(X), then

  Y and Z must be also be the same size.  AZ and EL are in radians.

  See also CART2POL, SPH2CART, POL2CART.


CAXIS

 Pseudocolor axis scaling.

  CAXIS(V), where V is the two element vector [cmin cmax], sets manual

  scaling of pseudocolor for the SURFACE and PATCH objects created by

  commands like MESH, PCOLOR, and SURF.  cmin and cmax are assigned

  to the first and last colors in the current colormap.  Colors for PCOLOR

  and SURF are determined by table lookup within this range.  Values

  outside the range are clipped by making them transparent.

  CAXIS('auto') sets axis scaling back to autoranging.

  CAXIS, by itself, returns the two element row vector containing the

  [cmin cmax] currently in effect.

  CAXIS is an M-file that sets the axes properties CLim and CLimMode.

  See also COLORMAP, AXES, AXIS.


CD

 Change current working directory.

  CD directory-spec sets the current directory to the one specified.

  CD .. moves to the directory above the current one.

  CD, by itself, prints out the current directory.


CDF2RDF

 Complex diagonal form to real block diagonal form.

  [V,D] = CDF2RDF(V,D) transforms the outputs of EIG from complex

  diagonal form to a real diagonal form.  In complex diagonal form,

  D has complex eigenvalues down the diagonal.  In real diagonal

  form, the complex eigenvalues are in 2-by-2 blocks on the

  diagonal.  Complex eigenvalue pairs are assumed to be next

  to one another.


CEDIT

 Set command line edit/recall facility parameters.

  CEDIT('off') turns off command line recall/edit.

  CEDIT('on') turns command line recall/edit back on.

  CEDIT('vms') chooses VMS key definitions.

  CEDIT('emacs') returns to the default Emacs key definitions.

  Here is a table that shows which keystrokes are available

  using the command line editor:

  Previous line: ^p

  Next line: ^n

  One character left: ^b

  One character right: ^f

  Cursor word left: esc b, ^l

  Cursor word right: esc f, ^r

  Cursor to beginning of line: ^a

  Cursor to end of line: ^e

  Cancel line: ^u

  In place delete: ^d

  Insert toggle: ^t

  Delete to end of line: ^k

  Type CEDIT.M for more information.

  The 'emacs' option is always in effect for MS-Windows, in

  addition to its normal fixed key bindings.


CEIL

 Round towards plus infinity.

  CEIL(X) rounds the elements of X to the nearest integers

  towards infinity.

  See also FLOOR, ROUND, FIX.


CENSUS

 Try to predict the US population in the year 2000.


CENSUSEX

 Callback script involked by the buttons in CENSUS demo.


CHOICES

 Create a list of choices with uicontrols and callbacks.

  CHOICES('NAME',HEADER,BUTTONLABELS,CALLBACKS) creates

  a window with registered name NAME.  The window contains

  the string HEADER and buttons labeled with BUTTONLABELS.

  These buttons register callback strings from CALLBACKS.

  An additional button, labeled 'Close', is added to each

  choicelist.

  CHOICES is useful for constructing demo menus.

  Use CHOICES in conjunction with CHOICEX, as in

  this example.

      header = 'Easy Example';

      labels = str2mat('Choice 1','Choice 2','Choice 3');

      callbacks = str2mat('image(magic(1))','image(magic(2))', ...

          'image(magic(3))');

      choices('EXAMPLE', header, labels, callbacks);


CHOICEX

 Close a list of choices.

  CHOICEX('NAME') closes the choice window with name 'NAME' and

  removes this name from the registration list.

  CHOICEX is used as the callback for the Close button in a choice list

  created using CHOICES.

  See also CHOICES.


CHOL

 Cholesky factorization.

  CHOL(X) uses only the diagonal and upper triangle of X.

  The lower triangular is assumed to be the (complex conjugate)

  transpose of the upper.  If X is positive definite, then

  R = CHOL(X) produces an upper triangular R so that R'*R = X.

  If X is not positive definite, an error message is printed.

  With two output arguments, [R,p] = CHOL(X) never produces an

  error message.  If X is positive definite, then p is 0 and R

  is the same as above.   But if X is not positive definite, then

  p is a positive integer and R is an upper triangular matrix of

  order q = p-1 so that R'*R = X(1:q,1:q).


CINVERT

 Invert black and white objects for nice printer output.

  CINVERT is an M-file that will recursively change the color

  properties of the given object, or the current Figure window by

  default, and its children to give proper black on white hardcopy

  output.

  When printing on white paper it looks nicer, and uses less

  ink/toner, to plot MATLAB graphics on a white background; instead

  of the default black background used on screen. Since the background

  changes, some children of the Figure also need to be inverted

  to stay visible. Non black or white objects will not have their

  colors changed.

  See value of 'params' in this M-file for list of what properties

  of the different object types are to be inverted.

  See also PRINT.


CLA

 Clear axis.

  CLA deletes all objects (lines, text, patches, surfaces, and

  images) from the current axes.

  CLA RESET deletes everything and also resets all axis properties,

  except position, to their default values.

  See also CLF, RESET, HOLD.


CLABEL

 Add contour labels to a contour plot.

  CLABEL(CS) adds height labels to the current contour plot

  using the contour structure CS output from the CONTOUR routine.

  The label positions are selected randomly.  For example:

     cs = contour(rand(10)); clabel(cs)

  CLABEL(CS,V) labels just those contour levels given in

  vector V.  The default action is to label all known contours.

  CLABEL(CS,'manual') places contour labels at the locations

  clicked on with a mouse.  Pressing the return key terminates

  labeling.  Use the space bar to enter contours and the arrow

  keys to move the crosshair if no mouse is available.

  See also CONTOUR, GINPUT.


CLC

 Clear command window.

  CLC clears the command window and homes the cursor.

  See also HOME.


CLEAR

 Clear various quantities from the workspace.

  CLEAR removes all variables from the workspace.

  CLEAR VARIABLES does the same thing.

  CLEAR X removes variable or function X from the workspace.

  CLEAR FUNCTIONS removes all compiled M-functions.

  CLEAR MEX removes all links to MEX-files.

  CLEAR ALL removes all variables, functions and MEX links.

  If X is global, CLEAR X removes X from the current workspace,

  but leaves it accessible to any functions declaring it global.

  CLEAR GLOBAL X completely removes the global variable X.

  CLEAR GLOBAL removes all global variables.


CLF

 Clear Figure.

  CLF deletes all objects from the current figure.

  CLF RESET deletes everything and also resets all figure properties,

  except position, to their default values.

  See also CLA, RESET, HOLD.


CLG

 Clear Figure (graph window).

  CLG is a pseudonym for CLF, provided for upward compatibility

  from MATLAB 3.5.

  See also CLF.


CLOCK

 Wall clock.

  CLOCK returns a six element row vector containing the

  current time and date in decimal form:

     CLOCK = [year month day hour minute seconds]

  The first five elements are integers. The seconds element

  is accurate to several digits beyond the decimal point.

  FIX(CLOCK) rounds to integer display format.

  See also ETIME, TIC, TOC, CPUTIME.


CLOSE

 Close specified window.

  CLOSE(H) closes the window with handle H.

  CLOSE, by itself, closes the current figure window.

  CLOSE closes the window unconditionally and without

  confirmation.

  CLOSE('name') closes the named window.

  See also DELETE.


COLMMD

 Column minimum degree.

  p = COLMMD(S).  Column minimum degree ordering of S.

  For an asymmetric matrix S, this returns a column permutation p

  such that S(:,p) tends to have sparser LU factors than S.

  See also SYMMMD, SYMRCM, COLPERM.


COLON

  :   Colon. Used in subscripts, FOR iterations and possibly elsewhere.

       J:K  is the same as [J, J+1, ..., K]

       J:K  is empty if J > K.

       J:D:K  is the same as [J, J+D, ..., J+m*D] where m = fix((K-J)/D).

       J:D:K  is empty if D > 0 and J > K or if D < 0 and J < K.

       The colon notation can be used to pick out selected rows,

       columns and elements of vectors and matrices.

       A(:) is all the elements of A, regarded as a single

       column. On the left side of an assignment statement, A(:)

       fills A, preserving its shape from before.

       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) and so on.

       For the use of the colon in the FOR statement, See FOR.

  Copyright (c) 1984-93 by The MathWorks, Inc.


COLORMAP

 Set the color look-up table.

  COLORMAP(MAP) sets the current figure's colormap to MAP.

  COLORMAP('default') sets the current figure's colormap to

  the root's default, whose factory setting is HSV.

  MAP = COLORMAP retrieves the current colormap. The values

  are in the range from 0 to 1.

  A color map matrix may have any number of rows, but it must have

  exactly 3 columns.  Each row is interpreted as a color, with the

  first element specifying the intensity of red light, the second

  blue, and the third green.  Color intensity can be specified on the

  interval 0.0 to 1.0.

  For example, [0 0 0] is black, [1 1 1] is white,

  [1 0 0] is pure red, [.5 .5 .5] is gray, and

  [127/255 1 212/255] is aquamarine.

  Graphics objects that use pseudocolor  -- SURFACE and PATCH objects,

  which are created by the functions MESH, SURF, and PCOLOR -- map

  a color matrix, C, whose values are in the range [Cmin, Cmax],

  to an array of indices, k, in the range [1, m].

  The values of Cmin and Cmax are either min(min(C)) and max(max(C)),

  or are specified by CAXIS.  The mapping is linear, with Cmin

  mapping to index 1 and Cmax mapping to index m.  The indices are

  then used with the colormap to determine the color associated

  with each matrix element.  See CAXIS for details.

  Type HELP COLOR to see a number of useful colormaps.

  COLORMAP is an M-file that sets the Colormap property of the current

  figure.

  See also COLOR, HSV, CAXIS, SPINMAP, BRIGHTEN, RGBPLOT, FIGURE.


COLORMENU

 Add a color map menu to the current figure.

  Each of the menu choices operates on the colormap:

  HOT, PINK, COOL, BONE, JET, COPPER, FLAG and PRISM are names of

  functions which generate color maps.

  RAND is a random color map.

  BRIGHTEN increases the brightness.

  DARKEN decreases the brightness.

  FLIPUD inverts the order of the colormap entries.

  FLIPLR interchanges the red and blue components.

  PERMUTE cyclic permuations: red -> blue, blue -> green, green -> red.

  SPIN spins the colormap, which is a rapid sequence of FLIPUD's.

  REMEMBER pushes a copy of the current color map onto a stack.

  RESTORE pops a map from the stack (initially, the stack contains the

     map in use when COLORMENU was invoked.)


COLPERM

 Order columns based on nonzero count.

  p = COLPERM(S) generate a permutation that reorders the

  columns of the sparse (or full) matrix S in nondecreasing

  order of nonzero count.  Useful as a preordering for LU

  factorization: lu(S(:,p)).

  Not the best ordering in the world, but it's fast to

  compute, it does a pretty good job, and it shows that

  we, too, can write tricky one-liners.

  See also COLMMD, SYMMMD, SYMRCM.


COLSTYLE

 Parse color and style from string for graphics.


COMET

 Comet plot.

  COMET(Y) displays an animated comet plot of the vector Y.

  COMET(X,Y) displays an animated comet plot of vector Y vs. X.

  COMET(X,Y,p) uses a comet of length p*length(Y).  Default is p = 0.10.

  COMET, by itself, is self demonstrating.

  Example:

      t = -pi:pi/200:pi;

      comet(t,tan(sin(t))-sin(tan(t)))

  See also QUAKEDEMO, COMET3.


COMET3

 3-D Comet plot.

  COMET3(Z) displays an animated three dimensional plot of the vector Z.

  COMET3(X,Y,Z) displays an animated comet plot of the curve through the

  points [X(i),Y(i),Z(i)].

  COMET3(X,Y,Z,p) uses a comet of length p*length(Z). Default is p = 0.1.

  COMET3, by itself, is self demonstrating.

  Example:

      t = -pi:pi/500:pi;

      comet3(sin(5*t),cos(3*t),t)

  See also QUAKEDEMO, COMET.


COMPAN

 Companion matrix.

  COMPAN(P) is a companion matrix of the polynomial

  with coefficients P.


COMPASS

 Compass plot.

  COMPASS(Z) draws a graph that displays the angle and magnitude

  of the complex elements of Z as arrows emanating from the origin.

  COMPASS(X,Y) is equivalent to COMPASS(X+i*Y).  It displays the

  compass plot for the angles and magnitudes of the elements of

  matrices X and Y.

  COMPASS(Z,'S') and COMPASS(X,Y,'S') use line style 'S' where

  'S' is any legal linetype as described under the PLOT command.

  See also ROSE, FEATHER, QUIVER.


COMPUTER

 Inquire computer type.

  COMPUTER returns a string containing the name of the computer

  on which MATLAB is executing. Possibilities are:

  PC - PC-MATLAB                 DEC_RISC - DecStation

  PCAT - AT-MATLAB               HP300 - HP 9000/Series 300

  PC386 - 386- or Weitek-MATLAB  HP700 - HP 9000/Series 700

  PCWIN - MS-Windows MATLAB      APOLLO - Apollo Workstations

  MAC - Edu-MATLAB               VAX_UNIX - VAX/Ultrix

  MACII - Mac II-MATLAB          VAXVMSD - VAX/VMS D_float

  SUN4 - Sun-4                   VAXVMSG - VAX/VMS G_float

  SGI - Silicon Graphics         CRAY - CRAY XMP or YMP

  [C,MAXSIZE] = COMPUTER returns also integer MAXSIZE which

  contains the maximum number of elements allowed in a matrix

  on this version of MATLAB.

  See also ISIEEE.


COND

 Matrix condition number.

  COND(X) is the ratio of the largest singular value of X

  to the smallest, which is the condition number of X in 2-norm.

  See also RCOND, NORM, CONDEST, NORMEST.


CONDEST

 Estimate the 1-norm condition number.

  Higham's modification of Hager's method.

  [C, V] = CONDEST(A) computes a lower bound C for the 1-norm condition

  number of A, and a vector V such that NORM(A*V)=NORM(A)*NORM(V)/C.

  V is an approximate null vector if C is large.


CONJ

 Complex conjugate.

  CONJ(X) is the complex conjugate of X.


cont_0
Color control and lighting model functions.

   Color controls.

     colormap   	Color look-up table.

     caxis      	Pseudocolor axis scaling.

     shading    	Color shading mode.

   Color maps.

     hsv        	Hue-saturation-value color map.

     gray       	Linear gray-scale color map.

     hot        	Black-red-yellow-white color map.

     cool       	Shades of cyan and magenta color map.

     bone       	Gray-scale with a tinge of blue color map.

     copper     	Linear copper-tone color map.

     pink       	Pastel shades of pink color map.

     prism      	Prism color map.

     jet        	A variant of HSV.

     flag       	Alternating red, white, blue, and black color map.

   Color map related functions.

     hsv2rgb    	Hue-saturation-value to red-green-blue conversion.

     rgb2hsv    	Red-green-blue to hue-saturation-value conversion.

     contrast   	Gray scale color map to enhance image contrast.

     brighten   	Brighten or darken color map.

     spinmap    	Spin color map.

     rgbplot    	Plot color map.

   Lighting models.

     surfl      	3-D shaded surface with lighting.

     specular   	Specular reflectance.

     diffuse    	Diffuse reflectance.

     surfnorm   	Surface normals.


cont_1
Data analysis and Fourier transform functions.

   Basic operations.

     max         	Largest component.

     min         	Smallest component.

     mean        	Average or mean value.

     median      	Median value.

     std         	Standard deviation.

     sort        	Sort in ascending order.

     sum         	Sum of elements.

     prod        	Product of elements.

     cumsum      	Cumulative sum of elements.

     cumprod     	Cumulative product of elements.

     trapz       	Numerical integration using trapezoidal method.

   Finite differences.

     diff        	Difference function and approximate derivative.

     gradient    	Approximate gradient.

     del2        	Five-point discrete Laplacian.

   Correlation.

     corrcoef    	Correlation coefficients.

     cov         	Covariance matrix.

     subspace    	Angle between subspaces.

   Filtering and convolution.

     filter      	One-dimensional digital filter.

     filter2     	Two-dimensional digital filter.

     conv        	Convolution and polynomial multiplication.

     conv2       	Two-dimensional convolution.

     deconv      	Deconvolution and polynomial division.

   Fourier transforms.

     fft         	Discrete Fourier transform.

     fft2        	Two-dimensional discrete Fourier transform.

     ifft        	Inverse discrete Fourier transform.

     ifft2       	Two-dimensional inverse discrete Fourier transform.

     abs         	Magnitude.

     angle       	Phase angle.

     unwrap      	Remove phase angle jumps across 360 degree boundaries.

     fftshift    	Move zeroth lag to center of spectrum.

     cplxpair    	Sort numbers into complex conjugate pairs.

     nextpow2    	Next higher power of 2.


cont_2
Demonstrations and samples.

   Introduction.

     demo        	Demonstrate some of MATLAB's capabilities.

     intro       	Introduction to MATLAB.

     bench       	MATLAB Benchmark.

   MathWorks Specials.

     vibes       	Vibrating L-shaped membrane.

     life        	MATLAB's version of Conway's Game of Life.

     penny       	Several views of the penny data.

     lorenz      	Plot the orbit around the Lorenz chaotic attractor.

     earthmap    	View Earth's topography.

     sqdemo      	Superquadrics using UIControls.

   Data Analysis.

     fftdemo     	Use of the fast finite Fourier transform.

     quake       	Loma Prieta Earthquake.

     sigdemo1    	Discrete-time Fourier transforms, with GUI.

     sigdemo2    	Continuous-timeFourier transforms, with GUI.

     census      	Try to predict the US population in the year 2000.

     spline2d    	Demonstrate GINPUT and SPLINE in two dimensions.

     sunspots    	The answer is 11.08, what is the question?

   Numerical analysis.

     odedemo     	Ordinary differential equations.

     quaddemo    	Adaptive quadrature.

     zerodemo    	Zerofinding with fzero.

     fplotdemo   	Plot a function.

     fitdemo     	Nonlinear minimization with Nelder-Meade search.

     eigmovie    	Symmetric eigenvalue movie.

     rrefmovie   	Computation of Reduced Row Echelon Form

   Mathematical Examples.

     fourier     	Graphics demo of Fourier series expansion.

     cplxdemo    	Maps of functions of a complex variable.

     peaks       	A sample function of two variables.

     knot        	Tube surrounding a three-dimensional knot.

     membrane    	Generate MathWorks's logo.

   Images and color maps.

     imagedemo   	Demonstrate MATLAB V4's image capability.

     colormenu   	Select color map.

   Sound.

     sounddemo   	Demonstrate MATLAB V4's sound capability.

   Sparse matrices.

     bucky       	The graph of the Buckminister Fuller geodesic dome.

     delsqdemo   	Finite difference Laplacian on various domains.

     sepdemo     	Separators for a finite element mesh.

     sparsity    	Demonstrate effect of sparsity orderings.

     airfoil     	Display sparse matrix from NASA airfoil.


cont_3
Elementary math functions.

   Trigonometric.

     sin         	Sine.

     sinh        	Hyperbolic sine.

     asin        	Inverse sine.

     asinh       	Inverse hyperbolic sine.

     cos         	Cosine.

     cosh        	Hyperbolic cosine.

     acos        	Inverse cosine.

     acosh       	Inverse hyperbolic cosine.

     tan         	Tangent.

     tanh        	Hyperbolic tangent.

     atan        	Inverse tangent.

     atan2       	Four quadrant inverse tangent.

     atanh       	Inverse hyperbolic tangent.

     sec         	Secant.

     sech        	Hyperbolic secant.

     asec        	Inverse secant.

     asech       	Inverse hyperbolic secant.

     csc         	Cosecant.

     csch        	Hyperbolic cosecant.

     acsc        	Inverse cosecant.

     acsch       	Inverse hyperbolic cosecant.

     cot         	Cotangent.

     coth        	Hyperbolic cotangent.

     acot        	Inverse cotangent.

     acoth       	Inverse hyperbolic cotangent.

   Exponential.

     exp         	Exponential.

     log         	Natural logarithm.

     log10       	Common logarithm.

     sqrt        	Square root.

   Complex.

     abs         	Absolute value.

     angle       	Phase angle.

     conj        	Complex conjugate.

     imag        	Complex imaginary part.

     real        	Complex real part.

   Numeric.

     fix         	Round towards zero.

     floor       	Round towards minus infinity.

     ceil        	Round towards plus infinity.

     round       	Round towards nearest integer.

     rem         	Remainder after division.

     sign        	Signum function.


cont_4
Elementary matrices and matrix manipulation.

   Elementary matrices.

     zeros       	Zeros matrix.

     ones        	Ones matrix.

     eye         	Identity matrix.

     rand        	Uniformly distributed random numbers.

     randn       	Normally distributed random numbers.

     linspace    	Linearly spaced vector.

     logspace    	Logarithmically spaced vector.

     meshgrid    	X and Y arrays for 3-D plots.

     :           	Regularly spaced vector.

   Special variables and constants.

     ans         	Most recent answer.

     eps         	Floating point relative accuracy.

     realmax     	Largest floating point number.

     realmin     	Smallest positive floating point number.

     pi          	3.1415926535897....

     i, j        	Imaginary unit.

     inf         	Infinity.

     NaN         	Not-a-Number.

     flops       	Count of floating point operations.

     nargin      	Number of function input arguments.

     nargout     	Number of function output arguments.

     computer    	Computer type.

     isieee      	True for computers with IEEE arithmetic.

     why         	Succinct answer.

     version     	MATLAB version number.

   Time and dates.

     clock       	Wall clock.

     cputime     	Elapsed CPU time.

     date        	Calendar.

     etime       	Elapsed time function.

     tic, toc    	Stopwatch timer functions.

   Matrix manipulation.

     diag        	Create or extract diagonals.

     fliplr      	Flip matrix in the left/right direction.

     flipud      	Flip matrix in the up/down direction.

     reshape     	Change size.

     rot90       	Rotate matrix 90 degrees.

     tril        	Extract lower triangular part.

     triu        	Extract upper triangular part.

     :           	Index into matrix, rearrange matrix.


cont_5
Function functions - nonlinear numerical methods.

     ode23       	Solve differential equations, low order method.

     ode23p      	Solve and plot solutions.

     ode45       	Solve differential equations, high order method.

     quad        	Numerically evaluate integral, low order method.

     quad8       	Numerically evaluate integral, high order method.

     fmin        	Minimize function of one variable.

     fmins       	Minimize function of several variables.

     fzero       	Find zero of function of one variable.

     fplot       	Plot function.

   See also The Optimization Toolbox, which has a comprehensive

   set of function functions for optimizing and minimizing functions.


cont_6
General purpose commands.

   Managing commands and functions.

     help        	On-line documentation.

     what        	Directory listing of M-, MAT- and MEX-files.

     type        	List M-file.

     lookfor     	Keyword search through the HELP entries.

     which       	Locate functions and files.

     demo        	Run demos.

     path        	Control MATLAB's search path.

   Managing variables and the workspace.

     who         	List current variables.

     whos        	List current variables, long form.

     load        	Retrieve variables from disk.

     save        	Save workspace variables to disk.

     clear       	Clear variables and functions from memory.

     pack        	Consolidate workspace memory.

     size        	Size of matrix.

     length      	Length of vector.

     disp        	Display matrix or text.

   Working with files and the operating system.

     cd          	Change current working directory.

     dir         	Directory listing.

     delete      	Delete file.

     getenv      	Get environment value.

     !           	Execute operating system command.

     unix        	Execute operating system command & return result.

     diary       	Save text of MATLAB session.

   Controlling the command window.

     cedit       	Set command line edit/recall facility parameters.

     clc         	Clear command window.

     home        	Send cursor home.

     format      	Set output format.

     echo        	Echo commands inside script files.

     more        	Control paged output in command window.

   Starting and quitting from MATLAB.

     quit        	Terminate MATLAB.

     startup     	M-file executed when MATLAB is invoked.

     matlabrc    	Master startup M-file.

   General information.

     info        	Information about MATLAB and The MathWorks, Inc.

     subscribe   	Become subscribing user of MATLAB.

     hostid      	MATLAB server host identification number.

     whatsnew    	Information about new features not yet documented.

     ver         	MATLAB, SIMULINK, and TOOLBOX version information.


cont_7
General purpose graphics functions.

   Figure window creation and control.

     figure     	Create Figure (graph window).

     gcf        	Get handle to current figure.

     clf        	Clear current figure.

     close      	Close figure.

   Axis creation and control.

     subplot    	Create axes in tiled positions.

     axes       	Create axes in arbitrary positions.

     gca        	Get handle to current axes.

     cla        	Clear current axes.

     axis       	Control axis scaling and appearance.

     caxis      	Control pseudocolor axis scaling.

     hold       	Hold current graph.

   Handle Graphics objects.

     figure    	Create figure window.

     axes      	Create axes.

     line      	Create line.

     text      	Create text.

     patch     	Create patch.

     surface   	Create surface.

     image     	Create image.

     uicontrol 	Create user interface control.

     uimenu    	Create user interface menu.

   Handle Graphics operations.

     set        	Set object properties.

     get        	Get object properties.

     reset      	Reset object properties.

     delete     	Delete object.

     drawnow    	Flush pending graphics events.

     newplot    	M-file preamble for NextPlot property.

   Hardcopy and storage.

     print      	Print graph or save graph to file.

     printopt   	Configure local printer defaults.

     orient     	Set paper orientation.

   Movies and animation.

     moviein    	Initialize movie frame memory.

     getframe   	Get movie frame.

     movie      	Play recorded movie frames.

   Miscellaneous.

     ginput     	Graphical input from mouse.

     rbbox      	Rubberband box.

     ishold     	Return hold state.

     whitebg    	Set graphics window defaults for white background.

     graymon    	Set graphics window defaults for gray-scale monitors.

     terminal   	Set graphics terminal type.

     uiputfile  	Put up dialog box for saving files.

     uigetfile  	Put up dialog box which queries for file names.

     uisetcolor 	Put up dialog box which returns an RGB value.

     uisetfont  	Put up dialog box which queries for a font.

   See also PLOTXY, PLOTXYZ, COLOR.


cont_8
Low-level file I/O functions.

   File opening and closing.

     fopen       	Open file.

     fclose      	Close file.

   Unformatted I/O.

     fread       	Read binary data from file.

     fwrite      	Write binary data to file.

   Formatted I/O.

     fscanf      	Read formatted data from file.

     fprintf     	Write formatted data to file.

     fgetl       	Read line from file, discard newline character.

     fgets       	Read line from file, keep newline character.

   File positioning.

     ferror      	Inquire file I/O error status.

     feof        	Test for end-of-file.

     fseek       	Set file position indicator.

     ftell       	Get file position indicator.

     frewind     	Rewind file.

   String conversion.

     sprintf     	Write formatted data to string.

     sscanf      	Read string under format control.


cont_9
Language constructs and debugging.

   MATLAB as a programming language.

     script      	About MATLAB scripts and M-files.

     function    	Add new function.

     eval        	Execute string with MATLAB expression.

     feval       	Execute function specified by string.

     global      	Define global variable.

     nargchk     	Validate number of input arguments.

     lasterr     	Last error message.

   Control flow.

     if          	Conditionally execute statements.

     else        	Used with IF.

     elseif      	Used with IF.

     end         	Terminate the scope of FOR, WHILE and IF statements.

     for         	Repeat statements a specific number of times.

     while       	Repeat statements an indefinite number of times.

     break       	Terminate execution of loop.

     return      	Return to invoking function.

     error       	Display message and abort function.

   Interactive input.

     input       	Prompt for user input.

     keyboard    	Invoke keyboard as if it were a Script-file.

     menu        	Generate menu of choices for user input.

     pause       	Wait for user response.

     uimenu      	Create user interface menu.

     uicontrol   	Create user interface control.

   Debugging commands.

     dbstop     	Set breakpoint.

     dbclear    	Remove breakpoint.

     dbcont     	Resume execution.

     dbdown     	Change local workspace context.

     dbstack    	List who called whom.

     dbstatus   	List all breakpoints.

     dbstep     	Execute one or more lines.

     dbtype     	List M-file with line numbers.

     dbup       	Change local workspace context.

     dbquit     	Quit debug mode.


cont_10
Matrix functions - numerical linear algebra.

   Matrix analysis.

     cond        	Matrix condition number.

     norm        	Matrix or vector norm.

     rcond       	LINPACK reciprocal condition estimator.

     rank        	Number of linearly independent rows or columns.

     det         	Determinant.

     trace       	Sum of diagonal elements.

     null        	Null space.

     orth        	Orthogonalization.

     rref        	Reduced row echelon form.

   Linear equations.

     \ and /     	Linear equation solution; use "help slash".

     chol        	Cholesky factorization.

     lu          	Factors from Gaussian elimination.

     inv         	Matrix inverse.

     qr          	Orthogonal-triangular decomposition.

     qrdelete    	Delete a column from the QR factorization.

     qrinsert    	Insert a column in the QR factorization.

     nnls        	Non-negative least-squares.

     pinv        	Pseudoinverse.

     lscov       	Least squares in the presence of known covariance.

   Eigenvalues and singular values.

     eig         	Eigenvalues and eigenvectors.

     poly        	Characteristic polynomial.

     hess        	Hessenberg form.

     qz          	Generalized eigenvalues.

     rsf2csf     	Real block diagonal form to complex diagonal form.

     cdf2rdf     	Complex diagonal form to real block diagonal form.

     schur       	Schur decomposition.

     balance     	Diagonal scaling to improve eigenvalue accuracy.

     svd         	Singular value decomposition.

   Matrix functions.

     expm        	Matrix exponential.

     expm1       	M-file implementation of expm.

     expm2       	Matrix exponential via Taylor series.

     expm3       	Matrix exponential via eigenvalues and eigenvectors.

     logm        	Matrix logarithm.

     sqrtm       	Matrix square root.

     funm        	Evaluate general matrix function.


cont_ops
Operators and special characters.

    Char    Name                         HELP topic

     +      Plus                         arith

     -      Minus                        arith

     *      Matrix multiplication        arith

     .*     Array multiplication         arith

     ^      Matrix power                 arith

     .^     Array power                  arith

     \      Backslash or left division   slash

     /      Slash or right division      slash

     ./     Array division               slash

     kron   Kronecker tensor product     kron

     :      Colon                        colon

     ( )    Parentheses                  paren

     [ ]    Brackets                     paren

     .      Decimal point                punct

     ..     Parent directory             punct

     ...    Continuation                 punct

     ,      Comma                        punct

     ;      Semicolon                    punct

     %      Comment                      punct

     !      Exclamation point            punct

     '      Transpose and quote          punct

     =      Assignment                   punct

     ==     Equality                     relop

     < >    Relational operators         relop

     &      Logical AND                  relop

     |      Logical OR                   relop

     ~      Logical NOT                  relop

     xor    Logical EXCLUSIVE OR         xor

   Logical characteristics.

     exist       	Check if variables or functions are defined.

     any         	True if any element of vector is true.

     all         	True if all elements of vector are true.

     find        	Find indices of non-zero elements.

     isnan       	True for Not-A-Number.

     isinf       	True for infinite elements.

     finite      	True for finite elements.

     isempty     	True for empty matrix.

     issparse    	True for sparse matrix.

     isstr       	True for text string.

     isglobal    	True for global variables.


cont_11
Two dimensional graphics.

   Elementary X-Y graphs.

     plot      	Linear plot.

     loglog    	Log-log scale plot.

     semilogx  	Semi-log scale plot.

     semilogy  	Semi-log scale plot.

     fill      	Draw filled 2-D polygons.

   Specialized X-Y graphs.

     polar     	Polar coordinate plot.

     bar       	Bar graph.

     stem      	Discrete sequence or "stem" plot.

     stairs    	Stairstep plot.

     errorbar  	Error bar plot.

     hist      	Histogram plot.

     rose      	Angle histogram plot.

     compass   	Compass plot.

     feather   	Feather plot.

     fplot     	Plot function.

     comet     	Comet-like trajectory.

   Graph annotation.

     title     	Graph title.

     xlabel    	X-axis label.

     ylabel    	Y-axis label.

     text      	Text annotation.

     gtext     	Mouse placement of text.

     grid      	Grid lines.

   See also PLOTXYZ, GRAPHICS.


cont_12
Three dimensional graphics.

   Line and area fill commands.

     plot3      	Plot lines and points in 3-D space.

     fill3      	Draw filled 3-D polygons in 3-D space.

     comet3     	3-D comet-like trajectories.

   Contour and other 2-D plots of 3-D data.

     contour    	Contour plot.

     contour3   	3-D contour plot.

     clabel     	Contour plot elevation labels.

     contourc   	Contour plot computation (used by contour).

     pcolor     	Pseudocolor (checkerboard) plot.

     quiver     	Quiver plot.

   Surface and mesh plots.

     mesh       	3-D mesh surface.

     meshc      	Combination mesh/contour plot.

     meshz      	3-D Mesh with zero plane.

     surf       	3-D shaded surface.

     surfc      	Combination surf/contour plot.

     surfl      	3-D shaded surface with lighting.

     waterfall  	Waterfall plot.

   Volume visualization.

     slice      	Volumetric visualization plots.

   Graph appearance.

     view       	3-D graph viewpoint specification.

     viewmtx    	View transformation matrices.

     hidden     	Mesh hidden line removal mode.

     shading    	Color shading mode.

     axis       	Axis scaling and appearance.

     caxis      	Pseudocolor axis scaling.

     colormap   	Color look-up table.

   Graph annotation.

     title      	Graph title.

     xlabel     	X-axis label.

     ylabel     	Y-axis label.

     zlabel     	Z-axis label for 3-D plots.

     text       	Text annotation.

     gtext      	Mouse placement of text.

     grid       	Grid lines.

   3-D objects.

     cylinder   	Generate cylinder.

     sphere     	Generate sphere.

   See also COLOR, PLOTXY, GRAPHICS.


cont_13
Polynomial and interpolation functions.

   Polynomials.

     roots       	Find polynomial roots.

     poly        	Construct polynomial with specified roots.

     polyval     	Evaluate polynomial.

     polyvalm    	Evaluate polynomial with matrix argument.

     residue     	Partial-fraction expansion (residues).

     polyfit     	Fit polynomial to data.

     polyder     	Differentiate polynomial.

     conv        	Multiply polynomials.

     deconv      	Divide polynomials.

   Data interpolation.

     interp1     	1-D interpolation (1-D table lookup).

     interp2     	2-D interpolation (2-D table lookup).

     interpft    	1-D interpolation using FFT method.

     griddata    	Data gridding.


cont_14
Sound processing functions.

   General sound functions.

     sound       	Convert vector into sound.

     saxis       	Sound axis scaling.

   Computer-specific sound functions.

     auwrite     	Write mu-law encloded audio file.

     auread      	Read mu-law encloded audio file.

     mu2lin      	Mu-law to linear conversion.

     lin2mu      	Linear to mu-law conversion.


cont_15
Sparse matrix functions.

   Elementary sparse matrices.

     speye       	Sparse identity matrix.

     sprandn     	Sparse random matrix.

     sprandsym   	Sparse symmetric random matrix.

     spdiags     	Sparse matrix formed from diagonals.

   Full to sparse conversion.

     sparse      	Create sparse matrix from nonzeros and indices.

     full        	Convert sparse matrix to full matrix.

     find        	Find indices of nonzero entries.

     spconvert   	Convert from sparse matrix external format.

   Working with nonzero entries of sparse matrices.

     nnz         	Number of nonzero entries.

     nonzeros    	Nonzero entries.

     nzmax       	Amount of storage allocated for nonzero entries.

     spones      	Replace nonzero entries with ones.

     spalloc     	Allocate memory for nonzero entries.

     issparse    	True if matrix is sparse.

     spfun       	Apply function to nonzero entries.

   Visualizing sparse matrices.

     spy         	Visualize sparsity structure.

     gplot       	Plot graph, as in "graph theory".

   Reordering algorithms.

     colmmd      	Column minimum degree.

     symmmd      	Symmetric minimum degree.

     symrcm      	Reverse Cuthill-McKee ordering.

     colperm     	Order columns based on nonzero count.

     randperm    	Random permutation vector.

     dmperm      	Dulmage-Mendelsohn decomposition.

   Norm, condition number, and rank.

     normest     	Estimate 2-norm.

     condest     	Estimate 1-norm condition.

     sprank      	Structural rank.

   Operations on trees.

     treelayout  	Lay out a tree or forest.

     treeplot    	Plot a picture of a tree.

     etree       	Elimination tree of a matrix.

     etreeplot   	Plot the elimination tree.

   Miscellaneous.

     symbfact    	Symbolic factorization analysis.

     spparms     	Set parameters for sparse matrix routines.

     spaugment   	Form least squares augmented system.


cont_16
Specialized math functions.

     besselj     	Bessel function of the first kind.

     bessely     	Bessel function of the second kind.

     besseli     	Modified Bessel function of the first kind.

     besselk     	Modified Bessel function of the second kind.

     beta        	Beta function.

     betainc     	Incomplete beta function.

     betaln      	Logarithm of beta function.

     ellipj      	Jacobi elliptic functions.

     ellipke     	Complete elliptic integral.

     erf         	Error function.

     erfc        	Complementary error function.

     erfcx       	Scaled complementary error function.

     erfinv      	Inverse error function.

     gamma       	Gamma function.

     gcd         	Greatest common divisor.

     gammainc    	Incomplete gamma function.

     lcm         	Least common multiple.

     gammaln     	Logarithm of gamma function.

     log2        	Dissect floating point numbers.

     pow2        	Scale floating point numbers.

     rat         	Rational approximation.

     rats        	Rational output.

     cart2sph    	Transform from Cartesian to spherical coordinates.

     cart2pol    	Transform from Cartesian to polar coordinates.

     pol2cart    	Transform from polar to Cartesian coordinates.

     sph2cart    	Transform from spherical to Cartesian coordinates.


cont_17
Specialized matrices.

     compan      	Companion matrix.

     gallery     	Several small test matrices.

     hadamard    	Hadamard matrix.

     hankel      	Hankel matrix.

     hilb        	Hilbert matrix.

     invhilb     	Inverse Hilbert matrix.

     kron        	Kronecker tensor product.

     magic       	Magic square.

     pascal      	Pascal matrix.

     rosser      	Classic symmetric eigenvalue test problem.

     toeplitz    	Toeplitz matrix.

     vander      	Vandermonde matrix.

     wilkinson   	Wilkinson's eigenvalue test matrix.


cont_18
Character string functions.

   General.

     strings     	About character strings in MATLAB.

     abs         	Convert string to numeric values.

     setstr      	Convert numeric values to string.

     isstr       	True for string.

     blanks      	String of blanks.

     deblank     	Remove trailing blanks.

     str2mat     	Form text matrix from individual strings.

     eval        	Execute string with MATLAB expression.

   String comparison.

     strcmp      	Compare strings.

     findstr     	Find one string within another.

     upper       	Convert string to uppercase.

     lower       	Convert string to lowercase.

     isletter    	True for letters of the alphabet.

   String to number conversion.

     num2str     	Convert number to string.

     int2str     	Convert integer to string.

     str2num     	Convert string to number.

     sprintf     	Convert number to string under format control.

     sscanf      	Convert string to number under format control.

   Hexadecimal to number conversion.

     hex2num     	Convert hex string to IEEE floating point number.

     hex2dec     	Convert hex string to decimal integer.

     dec2hex     	Convert decimal integer to hex string.


CONTOUR

  CONTOUR Contour plot.

  CONTOUR(Z) is a contour plot of matrix Z treating the values in Z

  as heights above a plane.

  CONTOUR(X,Y,Z), where X and Y are vectors, specifies the X- and Y-

  axes used on the plot.

  CONTOUR(Z,N) and CONTOUR(X,Y,Z,N) draw N contour lines,

  overriding the default automatic value.

  CONTOUR(Z,V) and CONTOURC(X,Y,Z,V) draw LENGTH(V) contour lines

  at the values specified in vector V.

  CONTOUR(...,'linetype') draws with the color and linetype specified,

  as in the PLOT command.

  C = CONTOUR(...) returns contour matrix C as described in CONTOURC

  and used by CLABEL.

  [C,H] = CONTOUR(...) returns a column vector H of handles to LINE

  objects, one handle per line.

  See also CLABEL, CONTOURC, CONTOUR3, GRADIENT, QUIVER, PRISM.


CONTOUR3

 3-D contour plot.

  CONTOUR3(Z) plots the contour lines of Z in 3-D.

  CONTOUR3(Z,N) plots N contour lines in 3-D.  The default is N=10.

  CONTOUR3(X,Y,Z) or CONTOUR3(X,Y,Z,N) uses the matrices X and Y

  to define the axis limits.

  C = CONTOUR3(...) returns contour matrix C as described in CONTOURC.

  [C,H] = CONTOUR3(...) returns a column vector H of handles to LINE

  objects, one handle per line.

  See also CONTOURC, CONTOUR.


CONTOURC

 Contour computation.

  CONTOURC calculates the contour matrix C for use by CONTOUR

  to draw the actual contour plot.

  C = CONTOURC(Z) computes the contour matrix for a contour plot

  of matrix Z treating the values in Z as heights above a plane.

  C = CONTOURC(X,Y,Z), where X and Y are vectors, specifies the X-

  and Y-axes for the contour computation.

  CONTOURC(Z,N) and CONTOURC(X,Y,Z,N) compute N contour lines,

  overriding the default automatic value.

  CONTOURC(Z,V) and CONTOURC(X,Y,Z,V) compute LENGTH(V) contour

  lines at the values specified in vector V.

  The contour matrix C is a two row matrix of contour lines. Each

  contiguous drawing segment contains the value of the contour,

  the number of (x,y) drawing pairs, and the pairs themselves.

  The segments are appended end-to-end as

      C = [level1 x1 x2 x3 ... level2 x2 x2 x3 ...;

           pairs1 y1 y2 y3 ... pairs2 y2 y2 y3 ...]

  See also CONTOUR.


CONTRAST

 Gray scale color map to enhance image contrast.

  CMAP = CONTRAST(X,M) returns a gray scale color map,

  that is a M-by-3 matrix with 3 identical columns, so that

      IMAGE(X)

      COLORMAP(CMAP)

  has a roughly equi-distributed gray scale histogram.

  If M is omitted, the default length 64 is used.


CONV

 Convolution and polynomial multiplication.

  C = CONV(A, B) convolves vectors A and B.  The resulting

  vector is length LENGTH(A)+LENGTH(B)-1.

  If A and B are vectors of polynomial coefficients, convolving

  them is equivalent to multiplying the two polynomials.

  See also XCORR, DECONV, CONV2.


CONV2

 Two dimensional convolution.

  C = CONV2(A, B) performs the 2-D convolution of matrices

  A and B.   If [ma,na] = size(A) and [mb,nb] = size(B), then

  size(C) = [ma+mb-1,na+nb-1].

  C = CONV2(A,B,'shape') returns a subsection of the 2-D

  convolution with size specified by 'shape':

    'full'  - (default) returns the full 2-D convolution,

    'same'  - returns the central part of the convolution

              that is the same size as A.

    'valid' - returns only those parts of the convolution

              that are computed without the zero-padded

              edges, size(C) = [ma-mb+1,na-nb+1] when

              size(A) > size(B).

  CONV2 is fastest when size(A) > size(B).

  See also XCORR2, CONV, XCORR, DECONV, FILTER2.


COOL

 Shades of cyan and magenta color map.

  COOL(M) returns an M-by-3 matrix containing a "cool" colormap.

  COOL, by itself, is the same length as the current colormap.

  For example, to reset the colormap of the current figure:

            colormap(cool)

  See also HSV, GRAY, HOT, BONE, COPPER, PINK, FLAG,

  COLORMAP, RGBPLOT.


COPPER

 Linear copper-tone color map.

  COPPER(M) returns an M-by-3 matrix containing a "copper" colormap.

  COPPER, by itself, is the same length as the current colormap.

  For example, to reset the colormap of the current figure:

            colormap(copper)

  See also HSV, GRAY, HOT, COOL, BONE, PINK, FLAG,

  COLORMAP, RGBPLOT.


CORRCOEF

 Correlation coefficients.

  CORRCOEF(X) is a matrix of correlation coefficients formed

  from array X whose each row is an observation, and each

  column is a variable.

  CORRCOEF(X,Y) is the same as CORRCOEF([X Y]).

  If C is the covariance matrix, C = COV(X), then CORRCOEF(X) is

  the matrix whose (i,j)'th element is

              C(i,j)/SQRT(C(i,i)*C(j,j)).

  See also COV, STD.


COS

 Cosine.

  COS(X) is the cosine of the elements of X.


COSH

 Hyperbolic cosine.

  COSH(X) is the hyperbolic cosine of the elements of X.


COT

 Cotangent.

  COT(X) is the cotangent of the elements of X.


COTH

 Hyperbolic cotangent.

  COTH(X) is the hyperbolic cotangent of the elements of X.


COV

 Covariance matrix.

  COV(X), if X is a vector, returns the variance.  For matrices,

  where each row is an observation, and each column a variable,

  COV(X) is the covariance matrix.  DIAG(COV(X)) is a vector of

  variances for each column, and SQRT(DIAG(COV(X))) is a vector

  of standard deviations.   COV(X,Y) is COV([X Y]).

  See also CORRCOEF, STD.


CPLXDEMO

 Maps of functions of a complex variable.


CPLXGRID

 Polar coordinate complex grid.

  Z = CPLXGRID(m) is an (m+1)-by-(2*m+1) complex polar grid.

  See CPLXMAP.


CPLXMAP

 Plot a function of a complex variable.

  CPLXMAP(z,f(z),(optional bound))

  Used by CPLXSHOW.

  See also CPLXGRID.


CPLXPAIR

 Sort numbers into complex conjugate pairs.

  Y = CPLXPAIR(X) rearranges the elements of vector X so that

  complex numbers are collected into matched pairs of complex

  conjugates.  The pairs are ordered by increasing real part.

  Any purely real elements are placed after all the complex pairs.

  Y = CPLXPAIR(X,TOL) uses a relative tolerance of TOL for

  comparison purposes.  The default is TOL = 100*EPS.


CPLXROOT

 Riemann surface for the n-th root.

  CPLXROOT(n) renders the Riemann surface for the n-th root.

  CPLXROOT, by itself, renders the Riemann surface for the cube root.

  CPLXROOT(n,m) uses an m-by-m grid.  Default m = 20.


CPUTIME

 CPU time in seconds.

  CPUTIME returns the CPU time in seconds that has been used

  by the MATLAB process since MATLAB started.

  For example:

      t=cputime; your_operation; cputime-t

  returns the cpu time used to run your_operation.

  The return value may overflow the internal representation

  and wrap around.

  See also ETIME, TIC, TOC, CLOCK


CROSS

 Vector cross product.

  z = cross(x,y).  x and y are usually vectors with 3 components.


CSC

 Cosecant.

  CSC(X) is the cosecant of the elements of X.


CSCH

 Hyperbolic cosecant.

  CSCH(X) is the hyperbolic cosecant of the elements of X.


CUMPROD

 Cumulative product of the elements.

  For vectors, CUMPROD(X) is the cumulative product of the

  elements of X.  For matrices, CUMPROD(X) is a matrix

  containing the cumulative products over each column.

  See also CUMSUM, SUM, PROD.


CUMSUM

 Cumulative sum of the elements.

  For vectors, CUMSUM(X) is the cumulative sum of the elements

  of X. For matrices, CUMSUM(X) is a matrix containing

  the cumulative sums over each column.

  See also CUMPROD, SUM, PROD.


CYLINDER

 Generate cylinder.

  [X,Y,Z] = CYLINDER(R,N) forms the unit cylinder based on the generator

  curve in the vector R. Vector R contains the radius at equally

  spaced points along the unit height of the cylinder. The cylinder

  has N points around the circumference. SURF(X,Y,Z) displays the

  cylinder.

  [X,Y,Z] = CYLINDER(R), and [X,Y,Z] = CYLINDER default to N = 20

  and R = [1 1].

  Omitting output arguments causes the cylinder to be displayed with

  a SURF command and no outputs to be returned.

  See also SPHERE.


DATALIST

 List of data analysis examples.

  DATALIST, by itself, presents a list of data analysis examples.

  Used by DEMO.


DATE

 Calendar.

  S = DATE returns a string containing the date in dd-mmm-yy format.


DBCLEAR

 Remove an M-file breakpoint set by the DBSTOP command.

  The DBCLEAR command removes the breakpoint set by a corresponding

  DBSTOP command.  There are six forms to this command.  They are:

  DBCLEAR AT lineno IN Mfilename

  DBCLEAR ALL IN Mfilename

  DBCLEAR IN Mfilename

  DBCLEAR ALL

  DBCLEAR IF ERROR

  DBCLEAR IF NANINF  or  DBCLEAR IF INFNAN

  where lineno is a line number in M-file function Mfilename.

  The AT, IN and IF keywords are optional.

  The first form removes the breakpoint at line lineno in M-file

  function Mfilename.  The second form removes all breakpoints in

  Mfilename.  The third form removes the breakpoint set at the first

  executable line in Mfilename. The fourth form removes all breakpoints

  in all M-files.  The fifth form clears the DBSTOP IF ERROR statement,

  if set.  If a run-time error occurs after this command, MATLAB

  terminates the current operation and returns to the base workspace.

  The sixth form clears the DBSTOP on infinities and NaNs.

  See also DBSTEP, DBSTOP, DBCONT, DBTYPE, DBSTACK, DBUP,

  DBDOWN, DBSTATUS, and DBQUIT.


DBCONT

 Resume execution from the current breakpoint.

  The DBCONT command resumes execution of an M-file following a stop in

  execution caused by either a DBSTOP or DBSTEP command.  Execution will

  continue until either another breakpoint is encountered, an error

  occurs, or MATLAB returns to the base workspace prompt.

  See also DBSTEP, DBSTOP, DBCLEAR, DBTYPE, DBSTACK, DBUP,

  DBDOWN, DBSTATUS.


DBDOWN

 Change the local workspace context to the called M-file function.

  The DBDOWN command is used in conjunction with the DBUP command to

  change the workspace context when in the debug mode.  The DBDOWN

  command reverses the context shift done by DBUP.

  See also DBSTEP, DBSTOP, DBCONT, DBCLEAR, DBTYPE, DBSTACK, DBUP,

         and DBSTATUS.


DBQUIT

 Quit debug mode.

  The DBQUIT command immediately terminates debug mode and returns

  control to the base workspace prompt.  The M-file being processed

  is NOT completed and no results are returned.

  See also DBSTOP, DBCONT, DBSTEP, DBCLEAR, DBTYPE, DBSTACK, DBUP,

  DBDOWN, and DBSTATUS.


DBSTACK

 List who called whom from M-file breakpoint to base workspace.

  The DBSTACK command displays the M-file function name and line number

  where the breakpoint occurred, the name and line number of the M-file

  caller, the caller's caller, etc., until the top-most M-file function

  is reached.

  See also DBSTEP, DBSTOP, DBCONT, DBCLEAR, DBTYPE, DBUP, DBDOWN,

  and DBSTATUS.


DBSTATUS

 List all the breakpoints in an M-file function.

  The DBSTATUS command has the form:

  DBSTATUS Mfilename

  where Mfilename is the name of an M-file function.  All

  breakpoints are listed.

  See also DBSTEP, DBSTOP, DBCONT, DBCLEAR, DBTYPE, DBSTACK,

  DBUP, and DBDOWN.


DBSTEP

 Execute one or more MATLAB lines of code when in MATLAB debug mode.

  The DBSTEP command allows the user to execute one or more lines of

  executable MATLAB code and upon their completion revert back to the

  debug mode.  There are three forms to this command.  They are:

  DBSTEP

  DBSTEP nlines

  DBSTEP IN

  where nlines is the number of executable lines to step.

  The first form causes the execution of the next executable line.

  The second form causes the execution of the next nlines executable

  lines.  When the next executable line is a call to another M-file

  function, the third form allows the user to step to the first

         executable line in the called M-file function.

  See also DBCONT, DBSTOP, DBCLEAR, DBTYPE, DBSTACK, DBUP, DBDOWN,

  and DBSTATUS.


DBSTOP

 Set breakpoint in MATLAB M-file function.

  The DBSTOP command is used to temporarily stop the execution of an

  M-file function and give the user an opportunity to examine the local

  workspace.  Issuing a DBSTOP command is equivalent to editing the

  M-file function and inserting a KEYBOARD command in front of the line

  number specified.  There are four forms to this command.  They are:

  DBSTOP AT lineno IN Mfilename

  DBSTOP IN Mfilename

  DBSTOP IF ERROR

  DBSTOP IF NANINF  or  DBSTOP IF INFNAN

  where lineno is a line number within M-file function Mfilename.

  The AT, IN and IF keywords are optional.

  The first form stops at the specified line number in the M-file.

  The second form stops at the first executable line in the M-file.

  The third form causes a stop in any M-file function causing a

  run-time error.  (Syntax errors are not handled by the debugger.)

  You cannot resume M-file execution after a run-time error.

  The fourth form causes a stop in any M-file function where an

  an infinite value (Inf) or Not-a-Number (NaN) is detected.

  The DBSTOP command is the only way to enter MATLAB's debug mode.

  In MATLAB's debug mode, any MATLAB command is allowed at the prompt.

  See also DBCONT, DBSTEP, DBCLEAR, DBTYPE, DBSTACK, DBUP, DBDOWN,

  DBSTATUS, and DBQUIT.


DBTYPE

 List an M-file with line numbers.

  The DBTYPE command is used to list an M-file function with

  line numbers to aid the user in setting breakpoints.  There are

  two forms to this command.  They are:

  DBTYPE Mfilename

  DBTYPE Mfilename start:end

  where Mfilename is the name of the M-file function in question and

  start and end are line numbers.

  See also DBSTEP, DBSTOP, DBCONT, DBCLEAR, DBSTACK, DBUP, DBDOWN,

  and DBSTATUS.


DBUP

 Change the local workspace context to the M-file function caller.

  The DBUP command allows the user to change the workspace context,

  while the user is in the debug mode, to that of the calling M-file

  or the base workspace.

  See also DBSTEP, DBSTOP, DBCONT, DBCLEAR, DBTYPE, DBSTACK,

  DBDOWN, and DBSTATUS.


DC2SC

 Data-coordinate to figure-coordinate conversion.

  DC2SC is obsolete, but provided for upward compatibility from

  MATLAB 3.5.

  [Xs,Ys] = DC2SC(Xd,Yd) converts vectors or matrices Xd and Yd from

  data-coordinates to normalized figure coordinates.  In

  figure-coordinates, (0.0,0.0) is the lower-left corner of the figure

  and (1.0,1.0) is the upper-right corner.  For a 2-D plot, (Xmin,Ymin)

  is the lower-left corner of the axis box and (Xmax,Ymax) is the upper-

  right corner in data coordinates.  [Xmin Xmax Ymin Ymax] are the

  current axis settings as returned by AXIS.

  See also SC2DC.


DEBLANK

 Strip trailing blanks from end of a string.

  DEBLANK(S) removes the trailing blanks and any null characters from

  the string S.  A null character is one that has an absolute value of 0.


DEBUG

  Debugging commands.

     dbstop     - Set breakpoint.

     dbclear    - Remove breakpoint.

     dbcont     - Resume execution.

     dbdown     - Change local workspace context.

     dbstack    - List who called whom.

     dbstatus   - List all breakpoints.

     dbstep     - Execute one or more lines.

     dbtype     - List M-file with line numbers.

     dbup       - Change local workspace context.

     dbquit     - Quit debug mode.


DEC2HEX

 Decimal to hexadecimal number conversion.

  DEC2HEX(D) returns decimal integer D in hexadecimal form.

  For example, DEC2HEX(2748) returns 'ABC'.

  See also HEX2DEC, HEX2NUM.


DECONV

 Deconvolution and polynomial division.

  [Q,R] = DECONV(B,A) deconvolves vector A out of vector B.  The result

  is returned in vector Q and the remainder in vector R such that

  B = conv(Q,A) + R.

  If A and B are vectors of polynomial coefficients, deconvolution

  is equivalent to polynomial division.  The result of dividing B by

  A is quotient Q and remainder R.

  See also CONV.


DEL2

 Five-point discrete Laplacian.

  V = del2(U) is a matrix the same size as U with each element

  equal to the difference between an element of U and the average

  of its four neighbors.  For the "corners" and "edges", only two

  or three neighbors are used.

  See also GRADIENT, DIFF.


DELETE

 Delete a file or graphics object.

  DELETE file_name  deletes the named file from disk.

  DELETE(H) deletes the graphics object with handle H.

  If the object is a window, the window is closed and

  deleted without confirmation.


DELSQ

 Construct five-point finite difference Laplacian.

  delsq(G) is the sparse form of the two-dimensional,

  5-point discrete negative Laplacian on the grid G.

  The grid G can be generated by NUMGRID or NESTED.

  See also NUMGRID, DEL2, DELSQDEMO.


DELSQDEMO

 Finite difference Laplacian on various domains.


DELSQSHOW

 Show discrete Laplacian on various grids.

  delsqshow(n,Rlist)

  Rectangular grid is n-by-n.

  Rlist is a string of letters denoting regions, taken

  from the list 'SNLCDAHB'.  See numgrid.


DEMO

 Demonstrate some of MATLAB's capabilities.

  DEMO, by itself, presents a menu of demos.


DET

 Determinant.

  DET(X) is the determinant of the square matrix X.


DIAG

 Create or extract diagonals.

  If V is a row or column vector with N components,

  DIAG(V,K) is a square matrix of order N+ABS(K) with the

  elements of V on the K-th diagonal. K = 0 is the main

  diagonal, K > 0 is above the main diagonal and K < 0 is

  below the main diagonal. DIAG(V) simply puts V on the

  main diagonal. For example,

  DIAG(-M:M) + DIAG(ONES(2*M,1),1) + DIAG(ONES(2*M,1),-1)

  produces a tridiagonal matrix of order 2*M+1.

  If X is a matrix, DIAG(X,K) is a column vector formed from

  the elements of the K-th diagonal of X. DIAG(X) is the main

  diagonal of X. DIAG(DIAG(X)) is a diagonal matrix.


DIARY

 Save the text of a MATLAB session.

  DIARY file_name  causes a copy of all subsequent terminal input

  and most of the resulting output to be written on the named

  file. DIARY OFF suspends it. DIARY ON turns it back on.

  DIARY, by itself, toggles the diary state.


DIFF

 Differentiate or difference.

  DIFF may be called with either numeric or symbolic arguments.

  For a numeric vector argument, DIFF computes differences.

  DIFF(X), for a vector X, is [X(2)-X(1)  X(3)-X(2) ... X(n)-X(n-1)].

  DIFF(X), for a matrix X, is the matrix of column differences,

     [X(2:n,:) - X(1:n-1,:)].

  DIFF(X,n) is the n-th difference function.

  For a symbolic (string) argument, DIFF uses the Maple Symbolic Toolbox

  to compute derivatives.

  DIFF(S) differentiates S with respect to its free variable.

  DIFF(S,'v') differentiates S with respect to 'v'.

  DIFF(S,n) and DIFF(S,'v',n) differentiate S n times.

  DIFF, with no arguments, differentiates the previous expression.

  Examples;

      With numeric arguments:

      h = .001; x = 0:h:pi;

      diff(sin(x.^2))/h is an approximation to 2*cos(x.^2).*x

      diff((1:10).^2) is 3:2:19

      With symbolic arguments and the Maple Symbolic Toolbox:

      diff('sin(x^2)') is '2*cos(x^2)*x'

      diff sin(x^2) is also '2*cos(x^2)*x'

      diff('t^6',6) is '720'.

  See also GRADIENT, DEL2, INT, SYMVAR.


DIFFUSE

 Diffuse reflectance.

  R = DIFFUSE(Nx,Ny,Nz,S) returns the reflectance for a surface with

  normal vector components [Nx,Ny,Nz].  S is a three vector that

  defines the direction to the light source. S can also be a two vector

  S = [Az,El] specifying the direction with azimuth and elevation.

  Lambert's Law: R = cos(theta) where theta is the angle between the

  surface normal and light source.

  See also SPECULAR, SURFNORM, SURFL.


DIR

 Directory listing.

  DIR directory_name lists the files in a directory.

  Pathnames and wildcards may be used.

  See also WHAT, CD, TYPE.


DISP

 Displays a matrix as text.

  DISP(X) displays the matrix, without printing the matrix name.

  If X contains text, the text is displayed.


DMPERM

 Dulmage-Mendelsohn decomposition of matrix A.

  p = DMPERM(A) returns a maximum matching; if A has full

  column rank then A(p,:) is square with nonzero diagonal.

  [p,q,r,s] = DMPERM(A) returns permutations to put A(p,q)

  in block upper triangular form:

  For square full-rank A, A(p,q) has nonzero diagonal

  and the i'th strong Hall component is block (bi,bi)

  of A(p,q), where bi = r(i):r(i+1)-1.

  For general rectangular A, the i'th strong Hall

  component is block (r(i):r(i+1)-1, s(i):s(i+1)-1).

  See also SRANK.


DOS

 Execute DOS command

  DOS('command'), for Windows systems, calls upon the DOS shell

  to execute the given command.  This causes a DOS Window to open

  and the program, command or batch file is run within that window.

  When the process is done executing, the window is automatically

  closed and control returns to the MATLAB Command Window.

  The following trailing characters have special meaning:

  	'|' - Run the DOS command iconically.

  	'&' - Return immediately to MATLAB, do not wait for process

  	      to finish.

  Examples:

      dos('edit')

  opens the DOS 5.0 editor in a DOS Window.

      dos('edit file.m &')

  opens the DOS 5.0 editor in a DOS Window, and returns control

  immediately to MATLAB.

      dos('type file.txt | sort > file.srt |')

  pipes file.txt through the sort command and creates an output

  file, file.srt.  The only thing that is seen on the screen,

  however, is a DOS icon.

  See also ! (exclamation point) under PUNCT.


DRAWNOW

 Complete any pending drawing.

  DRAWNOW "flushes the event queue" and forces MATLAB to

  update the screen.

  There are four events that cause MATLAB to flush the event

  queue and draw the screen:

  - a return to the MATLAB prompt

  - hitting a PAUSE statement

  - executing a GETFRAME command

  - executing a DRAWNOW command

  DRAWNOW('DISCARD') causes the information to be updated as if

  the queued events were flushed, but doesn't actually flush

  them.  This is needed for printing hardcopy when the figure

  property InvertHardcopy is on.


EARTHEX

 Used by EARTHMAP to generate relief view.


EARTHMAP

 View Earth's topography


ECHO

 Echo commands inside script files.

  ECHO ON turns on echoing of commands inside Script-files.

  ECHO OFF turns off echoing.

  ECHO file ON where 'file' is a function name causes the

  named Function-file to be echoed when it is used.

  ECHO file OFF turns it off.

  ECHO file toggles it.

  ECHO ON ALL turns on the echoing of commands inside all

  Function-files. ECHO OFF ALL turns them all off.

  See also FUNCTION, SCRIPT.


EIG

 Eigenvalues and eigenvectors.

  EIG(X) is a vector containing the eigenvalues of a square

  matrix X.

  [V,D] = EIG(X) produces a diagonal matrix D of

  eigenvalues and a full matrix V whose columns are the

  corresponding eigenvectors so that X*V = V*D.

  [V,D] = EIG(X,'nobalance') performs the computation with

  balancing disabled, which sometimes gives more accurate results

  for certain problems with unusual scaling.

  Generalized eigenvalues and eigenvectors.

  EIG(A,B) is a vector containing the generalized eigenvalues

  of square matrices A and B.

  [V,D] = EIG(A,B) produces a diagonal matrix D of general-

  ized eigenvalues and a full matrix V whose columns are the

  corresponding eigenvectors so that A*V = B*V*D.


EIGMOVIE

 Symmetric eigenvalue movie.

  EIGMOVIE(A) shows a "movie" that depicts the computation of

  the eigenvalues of a symmetric matrix.

  EIGMOVIE, by itself, uses A = pascal(6)/2.


ELLIPJ

 Jacobi elliptic functions SN, CN and DN.

  [Sn,Cn,Dn] = ELLIPJ(U,M) returns the values of the Jacobi

  elliptic functions SN, CN and DN, evaluated at argument U

  and parameter M.  As currently implemented, M is limited

  to 0 < M < 1.

  ELLIPJ(U,M) are accurate to EPS.

  U and M must either be matrices of the same size or either

  one may be a scalar.

  Be sure you don't confuse the modulus K with the parameter M -

  they are related in the following way:  M = K^2


ELLIPK

 Complete elliptic integrals.


ELLIPKE

 Complete elliptic integrals.

  [K,E] = ELLIPKE(M) returns the value of the complete elliptic

  integrals of the first and second kinds, evaluated at M.  As currently

  implemented, M is limited to 0 < M < 1.

  The accuracy of ELLIPKE(M) is EPS.

  Be sure you don't confuse the modulus K with the parameter M -

  they are related in the following way:  M = K^2


ELSE

 Used with IF.

  ELSE is used with IF.

  See also IF.


ELSEIF

 Used with IF.

  ELSEIF is used with IF.

  ELSEIF does not need a matching END, while ELSE IF does.

  See also IF, ELSE, END.


END

 Terminates the scope of FOR, WHILE and IF statements.

  Without END's, FOR, WHILE, and IF wait for further input.

  Each END is paired with the closest previous unpaired

  FOR, WHILE, or IF and serves to terminate its scope.


EPS

 Floating point relative accuracy.

  EPS is a permanent variable whose value is initially the distance

  from 1.0 to the next largest floating point number.  EPS may be

  reassigned any value.  EPS is used as a default tolerance by PINV

  and RANK.


ERF

 The error function.

  y = erf(x).

  y = 2/sqrt(pi) * integral from 0 to x of exp(-t^2) dt.

  See also ERFC, ERFCX, ERFINV.


ERFC

 The complementary error function.

  y = erfc(x).

  y = 2/sqrt(pi) * integral from x to inf of exp(-t^2) dt.

    = 1 - erf(x).

  See also ERF, ERFCX.


ERFCORE

 This function is used by erf, erfc, and erfcx.

  erf(x) = erfcore(x,0)

  erfc(x) = erfcore(x,1)

  erfcx(x) = exp(x^2)*erfc(x) = erfcore(x,2)


ERFCX

 Scaled complementary error function.

  y = erfcx(x).

  y = exp(x^2) * erfc(x) ~ (1/sqrt(pi)) * 1/x for large x.

  See also ERF, ERFC.


ERFINV

 Inverse of the error function.

  x = erfinv(y) satisfies y = erf(x),

      -1 <= y < 1, -inf <= x <= inf.

  See also ERF.


ERROR

 Display message and abort function.

  ERROR('MSG') displays the text MSG and causes an error exit

  from an M-file to the keyboard. If the string is an empty

  matrix, no action is taken.


ERRORBAR

 Plot graph with error bars.

  ERRORBAR(X,Y,E) plots the graph of vector X vs. vector Y with

  error bars specified by the vector E.  The vectors X,Y and E must

  be the same length.  If X,Y, and E are matrices then each column

  produces a separate line.  The error bars are each drawn a distance

  of E(i) above and below the points in (X,Y) so that each bar

  is 2*E(i) long.

  ERRORBAR(Y,E) plots Y with error bars E.

  For example,

     x = 1:10;

     y = sin(x);

     e = std(y)*ones(size(x));

     errorbar(x,y,e)

  draws error bars of unit standard deviation.


ETIME

 Elapsed time.

  ETIME(T1,T0) returns the time in seconds that has elapsed between

  vectors T1 and T0.  The two vectors must be six elements long, in

  the format returned by CLOCK:

      T = [Year Month Day Hour Minute Second]

  Here's an example of using ETIME to time an operation:

    t0 = clock;

    operation

    etime(clock,t0)

  Caution: As currently implemented, it won't work across month or year

  boundaries.  It is an M-file, so it can be fixed if you require this.

  See also TIC, TOC, CLOCK, CPUTIME.


ETREE

 Elimination tree of a matrix.

  p = etree(A) returns an elimination tree for the square

  symmetric matrix whose upper triangle is that of A.

  p(j) is the parent of column j in the tree,

  or 0 if j is a root.

  p = etree(A,'col') returns the elimination tree of A'*A.

  p = etree(A,'sym') is the same as p = etree(A).

  [p,q] = etree(...) also returns a postorder permutation q on the tree.

  See also TREELAYOUT, TREEPLOT, ETREEPLOT.


ETREEPLOT

 Plot the elimination tree.

  etreeplot(A):  Plot the elimination tree of A (or A+A', if asymmetric).

  etreeplot(A,c,d):  See treeplot for optional parameters c and d.

  See also TREEPLOT, ETREE, TREELAYOUT.


EVAL

 Execute string containing MATLAB expression.

  EVAL(s), where s is a string, causes MATLAB to execute

  the string as an expression or statement.

  EVAL(s1,s2) provides the ability to catch errors.  It

  executes string s1 and returns if the operation was

  successful. If the operation generates an error,

  string s2 is evaluated before returning. Think of this

  as EVAL('try','catch')

  [X,Y,Z,...] = EVAL(s) returns output arguments from the

  expression in string s.

  The input strings to EVAL are often created by

  concatenating substrings and variables inside square

  brackets. For example:

  Generate a sequence of matrices named M1 through M12:

      for n = 1:12

         eval(['M' num2str(n) ' = magic(n)'])

      end

  Run a selected M-file script.  The strings making up

  the rows of matrix D must all have the same length.

      D = ['odedemo '

           'quaddemo'

           'fitdemo '];

      n = input('Select a demo number: ');

      eval(D(n,:))

  Read and process files with names data1.dat, data2.dat, ...

      k = 0;

      while 1

         k = k+1;

         datak = ['data' int2str(k)];

         filename = [datak '.dat'];

         if ~exist(filename), break, end

         eval(['load ' filename]);

         X = eval(datak);

         % Process data in matrix X.

      end

  See also LASTERR, FEVAL.


EXIST

 Check if variables or functions exist.

  EXIST('A') returns:

    0 if A does not exist

    1 if A is a variable in the workspace

    2 if A is an M-file on MATLAB's search path

    3 if A is a MEX-file on MATLAB's search path

    4 if A is a compiled SIMULINK function

    5 if A is a built-in MATLAB function

  Note: EXIST('A') also returns 2 if a file named

  just 'A' is on MATLAB's search path.


EXP

 Exponential.

  EXP(X) is the exponential of the elements of X, e to the X.

  See also LOG, LOG10, EXPM, ARITH, POW2.


EXPM

 Matrix exponential.

  EXPM(X) is the matrix exponential of X.  EXPM is computed using

  a scaling and squaring algorithm with a Pade approximation.

  Although it is not computed this way, if X has a full set

  of eigenvectors V with corresponding eigenvalues D, then

  [V,D] = EIG(X) and EXPM(X) = V*diag(exp(diag(D)))/V.

  See EXPM1, EXPM2 and EXPM3 for alternative methods.

  EXP(X) (that's without the M) does it element-by-element.


EXPM1

 Matrix exponential via Pade approximation.

  E = EXPM1(A) is an M-file implementation of the built-in

  algorithm used by MATLAB for the matrix exponential.

  See Golub and Van Loan, Matrix Computations, Algorithm 11.3-1.

  See also EXPM, EXPM2, EXPM3.


EXPM2

 Matrix exponential via Taylor series.

  E = expm2(A) illustrates the classic definition for the

  matrix exponential.  As a practical numerical method,

  this is often slow and inaccurate.

  See also EXPM, EXPM1, EXMP3.


EXPM3

 Matrix exponential via eigenvalues and eigenvectors.

  E = expm3(A) illustrates one possible way to compute the matrix

  exponential.  As a practical numerical method, the accuracy

  is determined by the condition of the eigenvector matrix.

  See also EXPM, EXPM1, EXPM2.


EYE

 Identity matrix.

  EYE(N) is the N-by-N identity matrix.

  EYE(M,N) or EYE([M,N]) is an M-by-N matrix with 1's on

  the diagonal and zeros elsewhere.

  EYE(SIZE(A)) is the same size as A.


FCLOSE

 Close a file.

  FCLOSE(FID) closes the file with file identifier FID,

  which is an integer obtained from an earlier FOPEN().

  FCLOSE('all') closes all open files, except 0, 1 and 2.

  FCLOSE() returns 0 if successful, -1 if not.

  See also FOPEN, FREAD, FWRITE.


FEATHER

 Feather plot.

  FEATHER(Z) draws a graph that displays the angle and magnitude

  of the complex elements of Z as arrows emanating from equally

  spaced points along a horizontal axis.

  FEATHER(X,Y) is equivalent to FEATHER(X+i*Y).  It displays the

  feather plot for the angles and magnitudes of the elements of

  matrices X and Y.

  FEATHER(Z,'S') and FEATHER(X,Y,'S') use line style 'S' where

  'S' is any legal linetype as described under the PLOT command.

  See also COMPASS, ROSE, QUIVER.


FEOF

 Test for end-of-file.

  FEOF(FID) tests whether the end-of-file indicator for the

  file with file identifier FID has been set.

  FEOF(FID) returns 1 if the end-of-file indicator is set, or 0 if

  it is not set.

  See also FOPEN.


FERROR

 Query errors in file input or output.

  MESSAGE = FERROR(FID,'clear') returns the error message for the

  most recent file I/O operation associated with the specified file.

  The string 'clear' is optional.  If present, it clears the error

  indicator for the specified file.

  [MESSAGE, ERRNUM] = FERROR(FID) also returns the error number.

  FID is an integer file identifier obtained from FOPEN, or 0 for

  standard input, 1 for standard output or 2 for standard error.


FEVAL

 Function evaluation.

  If F is a string containing the name of a function (usually

  defined by an M-file), then  FEVAL(F,x1,...,xn)  evaluates

  that function at the given arguments.  For example,

  F = 'foo',  FEVAL(F,9.64) is the same as  foo(9.64).

  FEVAL is usually used inside functions which have the names

  of other functions as arguments.


FFT

 Discrete Fourier transform.

  FFT(X) is the discrete Fourier transform of vector X.  If the

  length of X is a power of two, a fast radix-2 fast-Fourier

  transform algorithm is used.  If the length of X is not a

  power of two, a slower non-power-of-two algorithm is employed.

  FFT(X,N) is the N-point FFT, padded with zeros if X has less

  than N points and truncated if it has more.

  If X is a matrix, the FFT operation is applied to each column.

  See also IFFT, FFT2, IFFT2, FFTSHIFT.


FFT2

 Two-dimensional Fast Fourier Transform.

  FFT2(X) returns the two-dimensional Fourier transform of matrix X.

  If X is a vector, the result will have the same orientation.

  FFT2(X,MROWS,NCOLS) pads matrix X with zeros to size MROWS-by-NCOLS

  before transforming.

  See also IFFT2, FFT, IFFT, FFTSHIFT.


FFTDEMO

 Demonstrate use of FFT for spectral analysis.


FFTSHIFT

 Move zeroth lag to center of spectrum.

  Shift FFT.  For vectors FFTSHIFT(X) returns a vector with the

  left and right halves swapped.  For matrices, FFTSHIFT(X) swaps

  the first and third quadrants and the second and fourth quadrants.

  FFTSHIFT is useful for FFT processing, moving the zeroth lag to

  the center of the spectrum.


FGETL

 Return the next line of the file as a string.

         FGETL(FID) returns the next line of a file associated with file

         identifier fid as a MATLAB string. The newline and a carriage return

  if it preceeds it are NOT included. Use FGETS() to get the next line

  with those characters INCLUDED. If just an end-of-file is encountered

  then -1 is returned.

         IMPORTANT: Please note that this is intended to be used ONLY with

                    text files. If by mistake you read a "binary" file

                    without newline characters this routine may take a

  	   long time for large files.

  Example: (equivalent to 'type fgetl.m')

      fid=fopen('fgetl.m');

      while 1

          line = fgetl(fid);

  	if ~isstr(line), break, end

  	disp(line)

      end

      fclose(fid);


FGETS

 Return the next line of the file as a string.

         FGETS(FID) returns the next line of a file associated with file

         identifier fid as a MATLAB string. The newline IS included.

         Use FGETL() to get the next line WITHOUT the newline included.

  If just an end-of-file is encountered then -1 is returned.

         IMPORTANT: Please note that this is intended to be used ONLY with

                    text files. If by mistake you read a "binary" file

                    without newline characters this routine may take a

  	   long time for large files.


FIGTEXT

 Place text in figure window.

  FIGTEXT(x,y,T) writes T, left justified, with the lower left

  corner at figure normalized coordinates (x,y).

  FIGTEXT(x,y,T,'center') and FIGTEXT(x,y,T,'right') are also possible.

  H = FIGTEXT(...) returns a vector of handles to the lines of text.


FIGURE

 Create Figures (graph windows).

  FIGURE, by itself, opens a new Figure (graph window), and returns

  an integer handle.

  FIGURE(H) makes the H'th Figure the current Figure for

  subsequent plotting commands.  If Figure H does not exist, a new

  one is created using the first available Figure handle.

  GCF returns the handle to the current figure.

  Execute GET(H) to see a list of figure object properties and

  their current values. Execute SET(H) to see a list of figure

  object properties and legal property values.

  See also SUBPLOT, AXES, GCF, CLF.


FILL

 Draw filled 2-D polygons.

  FILL(X,Y,C) fills the 2-D polygon defined by vectors X and Y

  with the color specified by C.  The vertices of the polygon

  are specified by pairs of components of X and Y.  If necessary,

  the polygon is closed by connecting the last vertex to the first.

  If C is a single character string chosen from the list 'r','g','b',

  'c','m','y','w','k', or an RGB row vector triple, [r g b], the

  polygon is filled with the constant specified color.

  If C is a vector the same length as X and Y, its elements are

  scaled by CAXIS and used as indices into the current COLORMAP to

  specify colors at the vertices; the color within the polygon is

  obtained by bilinear interpolation in the vertex colors.

  If X and Y are matrices the same size, one polygon per column

  is drawn. In this case, C is a row vector for "flat" polygon

  colors, and C is a matrix for "interpolated" polygon colors.

  If either of X or Y is a matrix, and the other is a column vector

  with the same number of rows, the column vector argument is

  replicated to produce a matrix of the required size.

  FILL(X1,Y1,C1,X2,Y2,C2,...) is another way of specifying

  multiple filled areas.

  FILL sets the PATCH object FaceColor property to 'flat', 'interp',

  or a colorspec depending upon the value of the C matrix.

  FILL returns a column vector of handles to PATCH objects, one handle

  per patch. The X,Y,C triples can be followed by parameter/value pairs

  to specify additional properties of the patches. FILL does not respond

  to the NextPlot axis property.

  See also PATCH, FILL3, COLORMAP.


FILL3

 Draw filled 3-D polygons in 3-space.

  FILL3(X,Y,Z,C) fills the 3-D polygon defined by vectors X, Y and Z

  with the color specified by C.  The vertices of the polygon

  are specified by triples of components of X, Y and Z.  If necessary,

  the polygon is closed by connecting the last vertex to the first.

  If C is a single character string chosen from the list 'r','g','b',

  'c','m','y','w','k', or an RGB row vector triple, [r g b], the

  polygon is filled with the constant specified color.

  If C is a vector the same length as X, Y and Z, its elements are

  scaled by CAXIS and used as indices into the current COLORMAP to

  specify colors at the vertices; the color within the polygon is

  obtained by bilinear interpolation in the vertex colors.

  If X, Y and Z are matrices the same size, one polygon per column

  is drawn. In this case, C is a row vector for "flat" polygon

  colors, and C is a matrix for "interpolated" polygon colors.

  If any of X, Y or Z is a matrix, and the others are column vectors

  with the same number of rows, the column vector arguments are

  replicated to produce matrices of the required size.

  FILL3(X1,Y1,Z1,C1,X2,Y2,Z2,C2,...) is another way of specifying

  multiple filled areas.

  FILL3 sets the PATCH object FaceColor property to 'flat', 'interp',

  or a colorspec depending upon the value of the C matrix.

  FILL3 returns a column vector of handles to PATCH objects, one handle

  per patch. The X,Y,Z,C quads can be followed by parameter/value pairs

  to specify additional properties of the patches. FILL3 does not respond

  to the NextPlot axis property.

  See also PATCH, FILL, COLORMAP.


FILTER

 Digital filter.

  Y = FILTER(B, A, X) filters the data in vector X with the

  filter described by vectors A and B to create the filtered

  data Y.  The filter is a "Direct Form II Transposed"

  implementation of the standard difference equation:

  y(n) = b(1)*x(n) + b(2)*x(n-1) + ... + b(nb+1)*x(n-nb)

                   - a(2)*y(n-1) - ... - a(na+1)*y(n-na)

  [Y,Zf] = FILTER(B,A,X,Zi) gives access to initial and final

  conditions, Zi and Zf, of the delays.

  See also FILTFILT in the Signal Processing Toolbox.


FILTER2

 Two-dimensional filtering.

  Y = FILTER2(B,X) filters the data in X with the 2-D FIR

  filter in the matrix B.  The result, Y, is computed

  using 2-D convolution and is the same size as X.

  Y = FILTER2(B,X,'shape') returns Y computed via 2-D

  convolution with size specified by 'shape':

    'same'  - (default) returns the central part of the

              convolution that is the same size as X.

    'valid' - returns only those parts of the convolution

              that are computed without the zero-padded

              edges, size(Y) < size(X).

    'full'  - returns the full 2-D convolution,

              size(Y) > size(X).

  See also CONV2.


FIND

 Find indices of the non-zero elements.

  I = FIND(X) returns the indices of the vector X that are

  non-zero. For example, I = FIND(A>100), returns the indices

  of A where A is greater than 100. See RELOP.

  [I,J] = FIND(X) returns the row and column indices of

  the nonzero entries in the matrix X.  This is often used

  with sparse matrices.

  [I,J,V] = FIND(X) also returns a column vector of the

  nonzero entries in X.  Note that find(X) and find(X~=0)

  will produce the same I and J, but the latter will produce

  a V with all 1's.


FINDSTR

 Find one string within another.

  K = FINDSTR(S1,S2) returns the starting indices of any occurrences

  of the shorter of the two strings in the longer.

  Example:

      s = 'How much wood would a woodchuck chuck?';

      findstr(s,'a')    returns  21

      findstr(s,'wood') returns  [10 23]

      findstr(s,'Wood') returns  []

      findstr(s,' ')    returns  [4 9 14 20 22 32]

  See also STRCMP.


FINITE

 True for finite elements.

  FINITE(X) returns 1's where the elements of X are finite

  and 0's where they are not.  For example FINITE([pi NaN Inf -Inf])

  is [1 0 0 0].

  See also ISNAN, ISINF.


FITDEMO

 Nonlinear curve fit with simplex algorithm.


FITFUN

 Used by FITDEMO.

  FITFUN(lambda) returns the error between the data and the

  values computed by the current function of lambda.

  FITFUN assumes a function of the form

    y =  c(1)*exp(-lambda(1)*t) + ... + c(n)*exp(-lambda(n)*t)

  with n linear parameters and n nonlinear parameters.


FIX

 Round towards zero.

  FIX(X) rounds the elements of X to the nearest integers

  towards zero.

  See also FLOOR, ROUND, CEIL.


FLAG

 Alternating red, white, blue, and black color map.

  FLAG(M) returns an M-by-3 matrix containing a "flag" colormap.

  Increasing M increases the granularity emphasized by the map.

  FLAG, by itself, is the same length as the current colormap.

  For example, to reset the colormap of the current figure:

            colormap(flag)

  See also HSV, GRAY, HOT, COOL, COPPER, PINK, BONE,

  COLORMAP, RGBPLOT.


FLIPLR

 Flip matrix in the left/right direction.

  FLIPLR(X) returns X with row preserved and columns flipped

  in the left/right direction.

  X = 1 2 3     becomes  3 2 1

      4 5 6              6 5 4

  See also FLIPUD, ROT90.


FLIPUD

 Flip matrix in the up/down direction.

  FLIPUD(X) returns X with columns preserved and rows flipped

  in the up/down direction.  For example,

  X = 1 4      becomes  3 6

      2 5               2 5

      3 6               1 4

  See also FLIPLR, ROT90.


FLOOR

 Round towards minus infinity.

  FLOOR(X) rounds the elements of X to the nearest integers

  towards minus infinity.

  See also ROUND, CEIL, FIX.


FLOPS

 Count of floating point operations.

  FLOPS returns the cumulative number of floating point

  operations. FLOPS(0) resets the count to zero.

  It is not feasible to count absolutely all floating point

  operations, but most of the important ones are counted.

  Additions and subtractions are one flop if real and two if

  complex. Multiplications and divisions count one flop each

  if the result is real and six flops if it is not.

  Elementary functions count one if real and more if complex.

  Some examples. If A and B are real N-by-N matrices, then

          A + B   counts N^2 flops,

          A * B   counts 2*N^3 flops,

          A ^ 100 counts 99*2*N^3 flops,

          LU(A)   counts roughly (2/3)*N^3 flops.


FMIN

 Minimize a function of one variable.

  FMIN('F',x1,x2) attempts to return a value of x which is a local

  minimizer of F(x) in the interval x1 < x < x2.  'F' is a string

  containing the name of the objective function to be minimized.

  FMIN('F',x1,x2,OPTIONS) uses a vector of control parameters.

  If OPTIONS(1) is nonzero, intermediate steps in the solution are

  displayed; the default is OPTIONS(1) = 0.  OPTIONS(2) is the termination

  tolerance for x; the default is 1.e-4.  OPTIONS(14) is the maximum

  number of steps; the default is OPTIONS(14) = 500.  The other components

  of OPTIONS are not used as input control parameters by FMIN.  For more

  information, see FOPTIONS.

  FMIN('F',x1,x2,OPTIONS,P1,P2,...) provides for up to 10 additional

  arguments which are passed to the objective function, F(X,P1,P2,...)

  Example:

      fmin('cos',3,4) computes pi to a few decimal places.

      fmin('cos',3,4,[1,1.e-12]) displays the steps taken

      to compute pi to about 12 decimal places.


FMINS

 Minimize a function of several variables.

  FMINS('F',X0) attempts to return a vector x which is a local minimizer

  of F(x) near the starting vector X0.  'F' is a string containing the

  name of the objective function to be minimized.  F(x) should be a

  scalar valued function of a vector variable.

  FMINS('F',X0,OPTIONS) uses a vector of control parameters.

  If OPTIONS(1) is nonzero, intermediate steps in the solution are

  displayed; the default is OPTIONS(1) = 0.  OPTIONS(2) is the termination

  tolerance for x; the default is 1.e-4.  OPTIONS(3) is the termination

  tolerance for F(x); the default is 1.e-4.  OPTIONS(14) is the maximum

  number of steps; the default is OPTIONS(14) = 500.  The other components

  of OPTIONS are not used as input control parameters by FMIN.  For more

  information, see FOPTIONS.

  FMINS('F',X0,OPTIONS,[],P1,P2,...) provides for up to 10 additional

  arguments which are passed to the objective function, F(X,P1,P2,...)

  FMINS uses a Simplex search method.

  See also FMIN.


FOPEN

 Open file.

  FID = FOPEN('filename',permission) opens the specified file with

  the specified permission. Permission is one of the strings:

      'r'	    read

      'w'	    write (create if necessary)

      'a'	    append (create if necessary)

      'r+'    read and write (do not create)

      'w+'    truncate or create for read and write

      'a+'    read and append (create if necessary)

      'W'     write without automatic flushing

      'A'     append without automatic flushing

  By default, files are opened in binary mode. To open a text file,

  add 't' to the permission string, for example 'rt' and 'wt+'. (On

  Unix systems, text and binary files are the same so this has no

  effect. But on PC, Macintosh, and VMS systems this is critical.)

  FID = FOPEN('filename') assumes a permission of 'r'.

  If the open is successful, FID gets a scalar MATLAB integer, the

  file identifier, to be used as the first argument to other FileIO

  routines. If the open was not successful, -1 is returned for FID.

  Three file identifiers are automatically available and need not be

  opened.  They are fid=0 (standard input), fid=1 (standard output),

  and fid=2 (standard error).

  [FID, MESSAGE] = FOPEN('filename',permission) returns a system

  dependent error message if the open is not successful.

  FOPEN('all') returns a row vector, the file identifiers for all the

  files currently opened by the user. (But not 0, 1, and 2.)

  [FILENAME,PERMISSION] = FOPEN(FID) returns the filename and

  permission associated with the given file identifier.

  If the file is opened in 'r' mode and it is not found in the current

  working directory, FOPEN searches down MATLAB's search path.

  [FID, MESSAGE] = FOPEN('filename',permission, machineformat) opens the

  specified file with the specified permission and treats data read

  using FREAD or data written using FWRITE as having a format given

  by machineformat. machineformat is one of the following strings:

  'native'  or 'n' - local machine format - the default

  'ieee-le' or 'l' - IEEE floating point with little-endian byte ordering

  'ieee-be' or 'b' - IEEE floating point with big-endian byte ordering

  'vaxd'    or 'd' - VAX D floating point and VAX ordering

  'vaxg'    or 'g' - VAX G floating point and VAX ordering

  'cray'	  or 'c' - Cray floating point with big-endian byte ordering

  [FILENAME,PERMISSION,MACHINEFORMAT] = FOPEN(FID) returns the filename,

  permission, and machineformat associated with the given file

  identifier.

         The 'W' and 'A' permissions are designed for use with tape drives and

  do not automatically perform a flush of the current output buffer

  after output operations. For example, open a 1/4" cartridge tape on a

  SPARCstation for writing with no auto-flush:

                 fid = fopen('/dev/rst0','W')

  See also FCLOSE, FREAD, FWRITE, FPRINTF.


FOPTIONS

 Default parameters used by the optimization routines.

  In MATLAB itself:

      FMIN and FMINS.

  In the Optimization Toolbox:

      FMINU, CONSTR, ATTGOAL, MINIMAX, LEASTSQ, FSOLVE.

  The parameters are:

  OPTIONS(1)-Display parameter (Default:0). 1 displays some results

  OPTIONS(2)-Termination tolerance for X.(Default: 1e-4).

  OPTIONS(3)-Termination tolerance on F.(Default: 1e-4).

  OPTIONS(4)-Termination criterion on constraint violation.(Default: 1e-6)

  OPTIONS(5)-Algorithm: Strategy:  Not always used.

  OPTIONS(6)-Algorithm: Optimizer: Not always used.

  OPTIONS(7)-Algorithm: Line Search Algorithm. (Default 0)

  OPTIONS(8)-Function value. (Lambda in goal attainment. )

  OPTIONS(9)-Set to 1 if you want to check user-supplied gradients

  OPTIONS(10)-Number of Function and Constraint Evaluations.

  OPTIONS(11)-Number of Function Gradient Evaluations.

  OPTIONS(12)-Number of Constraint Evaluations

  OPTIONS(13)-Number of equality constraints.

  OPTIONS(14)-Maximum number of iterations. (Default 100*no. of variables)

  OPTIONS(15)-Used in goal attainment for special objectives.

  OPTIONS(16)-Minimum change in variables for finite difference gradients.

  OPTIONS(17)-Maximum change in variables for finite difference gradients.

  OPTIONS(18)- Step length. (Default 1 or less).


FOR

 Repeat statements a specific number of times.

  The general form of a FOR statement is:

     FOR variable = expr, statement, ..., statement END

  The columns of the expression are stored one at a time in

  the variable and then the following statements, up to the

  END, are executed. The expression is often of the form X:Y,

  in which case its columns are simply scalars. Some examples

  (assume N has already been assigned a value).

       FOR I = 1:N,

           FOR J = 1:N,

               A(I,J) = 1/(I+J-1);

           END

       END

  FOR S = 1.0: -0.1: 0.0, END steps S with increments of -0.1

  FOR E = EYE(N), ... END  sets E to the unit N-vectors.


FORMAT

 Set output format.

  All computations in MATLAB are done in double precision.

  FORMAT may be used to switch between different output

  display formats as follows:

    FORMAT         Default. Same as SHORT.

    FORMAT SHORT   Scaled fixed point format with 5 digits.

    FORMAT LONG    Scaled fixed point format with 15 digits.

    FORMAT SHORT E Floating point format with 5 digits.

    FORMAT LONG E  Floating point format with 15 digits.

    FORMAT HEX     Hexadecimal format.

    FORMAT +       Compact format. The symbols +, - and blank

                   are printed for positive, negative and zero

                   elements. Imaginary parts are ignored.

    FORMAT BANK    Fixed format for dollars and cents.

    FORMAT COMPACT Suppress extra line-feeds.

    FORMAT LOOSE   Puts the extra line-feeds back in.

    FORMAT RAT     Approximation by ratio of small integers.


FOURIER

 Graphics demo of Fourier series expansion.

  Execute FOURIER to run it.


FPLOT

 Plot a function.

  FPLOT(FNAME,LIMS) plots the function specified by the text variable

  FNAME between the x-axis limits specified by LIMS = [XMIN XMAX].

  For example, FPLOT('sin',[0 10]) is a plot of the sine function.

  FPLOT(FNAME,LIMS,N) plots the function with a minimum of N samples.

  The default value for N is 25.

  FPLOT(FNAME,LIMS,N,ANGLE) plots the function with a minimum of N

  samples and samples more if contiguous segments are at an angle

  larger than ANGLE (in degrees).  The default for ANGLE is 10 degrees.

  FPLOT(FNAME,LIMS,N,ANGLE,SUBDIV) plots the function with a minimum

  of N samples, no more than ANGLE degrees bends in the curve, but no

  more than SUBDIV iterations to fill in the rapidly changing portions.

  The default for SUBDIV is 20.

  [X,Y] = fplot(FNAME,LIMS,...) returns the abscissae and ordinates for

  FNAME in the column vectors X and Y.  Plot X versus Y to see the picture.


FPLOTDEMO

 Demonstrate how to plot a function.


FPRINTF

 Write formatted data to file.

  COUNT = FPRINTF(FID,FORMAT,A,...) formats the data in matrix A (and in

  any additional matrix arguments), under control of the specified FORMAT

  string, and writes it to the file associated with file identifier FID.

  COUNT is an optional output argument that returns the number of bytes

  successfully written.

  FID is an integer file identifier obtained from FOPEN. It can also

  be 1 for standard output (the screen) or 2 for standard error.

  FORMAT is a string containing C language conversion specifications.

  Conversion specifications involve the character %, optional flags,

  optional width and precision fields, optional subtype specifier, and

  conversion characters d, i, o, u, x, X, f, e, E, g, G, c, and s.

  See a C manual for complete details.

  FPRINTF behaves like ANSI C with certain exceptions and extensions.

  These include:

  1. If the MATLAB double doesn't convert exactly to the datatype

     associated with the conversion specifier then e format is used.

     You must explicitly convert non-integral MATLAB values to

     integral values if you plan to use an integral conversion

     specifier like d and get the expected ANSI C behavior.

  2. The following non-standard subtype specifiers are supported for

     conversion characters o, u, x, and X.

     t	- The underlying C datatype is a float rather than an

  	  unsigned integer.

     b	- The underlying C datatype is a double rather than an

  	  unsigned integer.

     For example, to print out in hex a double value use a format like

     '%bx'.

  FPRINTF also differs from its C language namesake in an important

  respect - it is "vectorized" for the case when A is nonscalar. The

  format string is recycled through the elements of A (columnwise) until

  all the elements are used up. It is then recycled in a similar manner,

  without reinitializing, through any additional matrix arguments.

  For example, the statements

      x = 0:.1:1; y = [x; exp(x)];

      fid = fopen('exp.txt','w');

      fprintf(fid,'%6.2f  %12.8f\n',y);

  create a text file containing a short table of the exponential function:

      0.00    1.00000000

      0.10    1.10517092

 	         ...

      1.00    2.71828183

  See also FSCANF, SPRINTF, FWRITE, DIARY, SAVE.


FREAD

 Read binary data from file.

  [A, COUNT] = FREAD(FID,SIZE,PRECISION) reads binary data from the

  specified file and writes it into matrix A.  If COUNT is used,

  FREAD returns the number of elements successfully read.

  FID is an integer file identifier obtained from FOPEN, or 0 for

  standard input.

  The size argument is optional; if not specified, the entire

  file is read; if specified, valid entries are:

      N      read N elements into a column vector.

      inf    read to the end of the file.

      [M,N]  read elements to fill an M-by-N matrix, in column order.

  The precision argument controls the number of bits read for each value

  and the interpretation of those bits as character, integer or floating

  point values.  Any of the following strings, either the MATLAB

  versions, or their C or Fortran equivalents, may be used.  If not

  specified, the default is 'uchar'.  In all cases, the resulting matrix

  elements are stored as long floating point values, as is all other

  MATLAB data.

      MATLAB    C or Fortran      Description

      'char'    'char'            character,  8 bits

      'schar'   'signed char'     signed character,  8 bits

      'short'   'short'           integer,  16 bits

      'int'     'int'             integer,  16 or 32 bits

      'long'    'long'            integer,  32 bits

      'float'   'float'           floating point,  32 bits

      'double'  'double'          long floating point,  64 bits

      'uchar'   'unsigned char'   unsigned character,  8 bits

      'ushort'  'unsigned short'  unsigned integer,  16 bits

      'uint'    'unsigned int'    unsigned integer,  16 or 32 bits

      'ulong'   'unsigned long'   unsigned integer,  32 bits

      'char'    'char*1'          character,  8 bits

      'float32' 'real*4'          32 bit floating point

      'float64' 'real*8'          64 bit floating point

      'int8'    'integer*1'       integer, 8 bits.

      'int16'   'integer*2'       integer, 16 bits.

      'int32'   'integer*4'       integer, 32 bits.

       'intN'                     signed integer, N bits wide

       'uintN'                    unsigned integer, N bits wide

       where N represents any value between 1 and 32.

  Example:

      fid = fopen('fread.m','r');

      F = fread(fid);

      s = setstr(F')

  opens the file containing this HELP entry, then reads and displays

  the entire file, using default size = inf and precision = 'uchar'.

  The resulting length(F) is the number of characters in the file.

  NOTE: The only supported precisions for Cray data are

        'char', 'schar', 'uchar', 'float', 'double', and 'float64'.

  See also FSCANF, LOAD.


FREWIND

 Rewind an open file.

  FREWIND(FID) sets the file pointer to the beginning of the

  file associated with file identifier fid.

  WARNING: Rewinding a fid associated with a tape device may not work

  	 even though no error message is generated!


FSCANF

 Read formatted data from file.

  [A,COUNT] = FSCANF(FID,FORMAT,SIZE) reads data from the file specified

  by file identifier FID, converts it according to the specified FORMAT

  string, and returns it in matrix A. COUNT is an optional output

  argument that returns the number of elements successfully read.

  FID is an integer file identifier obtained from FOPEN.

         SIZE is optional; it puts a limit on the number of elements that

         can be read from the file; if not specified, the entire file

         is considered; if specified, valid entires are:

             N      read at most N elements into a column vector.

             inf    read at most to the end of the file.

             [M,N]  read at most M * N elements filling at least an

                    M-by-N matrix, in column order. N can be inf, but not M.

  FORMAT is a string containing C language conversion specifications.

  Conversion specifications involve the character %, optional

  assignment-suppressing asterisk and width field, and conversion

  characters d, i, o, u, x, e, f, g, s, c, and [. . .] (scanset).

  Complete ANSI C support for these conversion characters is

  provided consistent with 'expected' MATLAB behavior. For a complete

  conversion character specification, see a C manual.

         If a conversion character s is used an element read may cause

         several MATLAB matrix elements to be used, each holding one

  character.

         Mixing character and numeric conversion specifications will cause

         the resulting matrix to be numeric and any characters read to show

         up as their ASCII values one character per MATLAB matrix element.

  FSCANF differs from its C language namesake in an important respect -

  it is "vectorized" in order to return a matrix argument. The format

  string is recycled through the file until an end-of-file is reached

  or the amount of data specified by SIZE is read in.

  Examples:

      S = fscanf(fid,'%s')   reads (and returns) a character string.

      A = fscanf(fid,'%5d')  reads 5-digit decimal integers.

  See also FPRINTF, SSCANF, FREAD.


FSEEK

 Change the position indicator in a file.

  STATUS = FSEEK(FID, OFFSET, ORIGIN) repositions the file position

  indicator in the specified file to the specified byte offset with

  respect to the specified origin.

  FID is an integer file identifier obtained from FOPEN.

  OFFSET values are interpreted as follows:

      > 0    Move toward the end of the file.

      = 0    Do not change position.

      < 0    Move toward the beginning of the file.

  ORIGIN values are interpreted as follows:

      'bof' or -1   Beginning of file

      'cof' or  0   Current position in file

      'eof' or  1   End of file

  STATUS is 0 on success and -1 on failure.

  Example:

      fseek(fid,0,-1)

  "rewinds" the file.

  See also FOPEN, FTELL.


FTELL

 Location of the position indicator in a file.

  POSITION = FTELL(FID) returns the location of the file position

  indicator in the specified file.  Position is indicated in bytes

  from the beginning of the file.  If -1 is returned, it indicates

  that the query was unsuccessful; use FERROR to determine the nature

  of the error.

  FID is an integer file identifier obtained from FOPEN, or 0 for

  standard input, 1 for standard output or 2 for standard error.

  See also FOPEN, FSEEK.


FULL

 Convert sparse matrix to full storage.

  A = FULL(X) is a built-in function which converts a sparse matrix

  to full storage organization and leaves a full matrix unchanged.

  See also SPARSE.


FUNCTION

 Function M-files.

  New functions may be added to MATLAB's vocabulary if they

  are expressed in terms of other existing functions. The

  commands and functions that comprise the new function must

  be put in a file whose name defines the name of the new

  function, with a filename extension of '.m'. At the top of

  the file must be a line that contains the syntax definition

  for the new function. For example, the existence of a file

  on disk called STAT.M with:

          function [mean,stdev] = stat(x)

          n = length(x);

          mean = sum(x) / n;

          stdev = sqrt(sum((x - mean).^2)/n);

  defines a new function called STAT that calculates the

  mean and standard deviation of a vector. The variables

  within the body of the function are all local variables.

  See SCRIPT for procedures that work globally on the work-

  space.

  See also ECHO, SCRIPT.


FUNM

 Evaluate function of a matrix.

  F = FUNM(A,'fun') for a matrix argument A evaluates the matrix

  function specified by 'fun'.   For example, FUNM(A,'sin') is

  the matrix sine.  For matrix exponentials, logarithms and

  square roots, use EXPM(A), LOGM(A) and SQRTM(A) instead.

  FUNM uses a potentially unstable algorithm.  If A is close to a

  matrix with multiple eigenvalues and poorly conditioned eigenvectors,

  FUNM may produce inaccurate results.  An attempt is made to detect

  this situation and print a warning message.  The error detector is

  sometimes too sensitive and a message is printed even though the

  the computed result is accurate.

  [F,ESTERR] = FUNM(A,'fun') does not print any message, but returns

  a very rough estimate of the relative error in the computed result.

  If A is symmetric or Hermitian, then its Schur form is diagonal and

  FUNM will be able to produce an accurate result.

  S = SQRTM(A) and L = LOGM(A) use FUNM to do their computations,

  but they can get more reliable error estimates by comparing S*S

  and EXPM(L) with A.  E = EXPM(A) uses a completely different

  algorithm.

  See also EXPM, SQRTM, LOGM.


FWRITE

 Write binary data to a file.

  COUNT = FWRITE(FID,A,PRECISION) writes the elements of matrix A

  to the specified file, translating MATLAB values to the specified

  precision. The data are written in column order.  COUNT is the number

  of elements successfully written.

  FID is an integer file identifier obtained from FOPEN, or 1 for

  standard output or 2 for standard error.

  PRECISION controls the form and size of the result.  See the list

  of allowed precisions under FREAD.

  Example:

      fid = fopen('magic5.bin','wb')

      fwrite(fid,magic(5),'integer*4')

  creates a 100-byte binary file, containing the 25 elements of the

  5-by-5 magic square, stored as 4-byte integers.

  See also FPRINTF, SAVE, DIARY.


FZERO

 Find a zero of a function of one variable.

  FZERO(F,X) finds a zero of f(x).  F is a string containing the

  name of a real-valued function of a single real variable.   X is

  a starting guess.  The value returned is near a point where F

  changes sign.  For example, FZERO('sin',3) is pi.  Note the

  quotes around sin.  Ordinarily, functions are defined in M-files.

  An optional third argument sets the relative tolerance for the

  convergence test.   The presence of an nonzero optional fourth

  argument triggers a printing trace of the steps.


GALLERY

 A couple of small test matrices.

  GALLERY(3) is a badly conditioned 3-by-3 matrix.

  GALLERY(5) is an interesting eigenvalue problem.  Try to find

  its EXACT eigenvalues and eigenvectors.

  See also MAGIC, HILB, INVHILB, HADAMARD, ROSSER, WILKINSON.


GAMMA

 The gamma function.

  Y = GAMMA(X) evaluates the gamma function at all the elements of X.

  X must be real.

  gamma(x) = integral from 0 to inf of t^(x-1) exp(-t) dt.

  gamma(n+1) = n! = n factorial = prod(1:n).

  See also GAMMALN, GAMMAINC.


GAMMAINC

 The incomplete gamma function.

  Y = GAMMAINC(X,A) evaluates the incomplete gamma function at all

  the elements of X.  X must be real.  A must be a real scalar.

  gammainc(x,a) = (integral from 0 to x of t^(a-1) exp(-t) dt)/gamma(a).

  Note that gammainc(x,a) approaches 1 as x approaches infinity.

  See also GAMMA, GAMMALN.


GAMMALN

 The loggamma function.

  Y = GAMMALN(X) is LOG(GAMMA(X)), avoiding underflow and overflow.

  See also GAMMA.


GCA

 Get current axis handle.

  H = GCA returns the handle to the current axis. The current

  axis is the axis that graphics commands like PLOT, TITLE,

  SURF, etc. draw to if issued.

  Use the commands AXES or SUBPLOT to change the current axis

  to a different axis, or to create new ones.

  See also AXES,SUBPLOT,DELETE,CLA,HOLD,GCF.


GCD

 Greatest common divisor.

  G = GCD(A,B) is the greatest common divisor of integers A and B.

  G = GCD(0,0) is 0 by convention; all other GCDs are positive integers.

  [G,C,D] = GCD(A,B) also returns C and D with G = A*C + B*D.


GCF

 Get current figure handle.

  H = GCF returns the handle to the current figure. The current

  figure is the figure (graphics window) that graphics commands

  like PLOT, TITLE, SURF, etc. draw to if issued.

  Use the commands FIGURE to change the current figure

  to a different figure, or to create new ones.

  See also FIGURE, CLOSE, CLF, GCA.


GET

 Get object properties.

  V = GET(H,'PropertyName') returns the value of the specified

  property for the graphics object with handle H.

  GET(H) displays all property names and their current values for

  the graphics object with handle H.

  See also SET, RESET, DELETE, GCF, GCA, FIGURE, AXES.


GETENV

 Get environment value.

  GETENV('NAME'), where NAME is a text string, searches

  the environment list for a string of the form NAME=VALUE

  and returns the string VALUE if such a string is present.

  If the specified name cannot be found, an empty matrix

  is returned.


GETFRAME

 Get movie frame.

  GETFRAME returns a column vector with one movie frame. The

  frame is a snapshot (pixmap) of the current axis. GETFRAME

  is usually used in a FOR loop to assemble movie matrix M

  for playback using MOVIE.  For example:

     M = moviein(n);

     for j=1:n

        plot_command

        M(:,j) = getframe

     end

     movie(M)

  It is important to preallocate movie matrix M before building the

  movie in order to prevent excessive memory use. The function

  MOVIEIN is available for this purpose.

  GETFRAME(H) gets a frame from object H, where H is a handle

  to the root, a figure, or an axis.

  GETFRAME(H,RECT) specifies the rectangle to copy the bitmap

  from, relative to the lower-left corner of object H and in

  the units of its Units property.

  See also MOVIE, MOVIEIN.


GINPUT

 Graphical input from a mouse or cursor.

  [X,Y] = GINPUT(N) gets N points from the current axes and returns

  the X- and Y-coordinates in length N vectors X and Y.  The cursor

  can be positioned using a mouse (or by using the Arrow Keys on some

  systems).  Data points are entered by pressing a mouse button

  or any key on the keyboard.  A carriage return terminates the

  input before N points are entered.

  [X,Y] = GINPUT gathers an unlimited number of points until the

  return key is pressed.

  [X,Y,BUTTON] = GINPUT(N) returns a third result, BUTTON, that

  contains a vector of integers specifying which mouse button was

  used (1,2,3 from left) or ASCII numbers if a key on the keyboard

  was used.


GLOBAL

 Define global variables.

  GLOBAL X Y Z defines X, Y, and Z as global in scope.

  Ordinarily, each MATLAB function, defined by an M-file, has its

  own local variables, which are separate from those of other functions,

  and from those of the base workspace and non-function scripts.

  However, if several functions, and possibly the base workspace,

  all declare a particular name as GLOBAL, then they all share

  a single copy of that variable.  Any assignment to that variable,

  in any function, is available to all the other functions declaring

  it GLOBAL.

  Stylistically, global variables often have long names with all

  capital letters, but this is not required.

  For an example, see the functions TIC and TOC.

  See also ISGLOBAL, CLEAR, WHO.


GPLOT

 Plot a "graph theoretic" graph.

  GPLOT(A,xy) plots the graph specified by A and xy.

  A graph, G, is a set of nodes numbered from 1 to n,

  and a set of connections, or edges, between them.

  In order to plot G, two matrices are needed.

  The adjacency matrix, A, has a(i,j) nonzero if and

  only if node i is connected to node j.  The coordinates

  array, xy, is an n-by-2 matrix with the position for

  node i in the i-th row, xy(i,:) = [x(i) y(i)].

  GPLOT(A,xy,lc) uses line type and color instead of the

  default, 'r-'.   For example, lc = 'g:'.  See PLOT.

  [X,Y] = GPLOT(A,xy) returns the NaN-punctuated vectors

  X and Y without actually generating a plot. These vectors

  can be used to generate the plot at a later	time if desired.

  See also SPY, TREEPLOT, SUBMESH, UNMESH.


GRADIENT

 Approximate gradient.

  [PX,PY] = GRADIENT(Z,DX,DY) returns the numerical partial derivatives

  of matrix Z in matrices PX = dZ/dx and PY = dZ/dy.   DX and DY

  may be scalars containing the sample spacing in the X and Y

  directions, or they may be vectors containing all the explicit

  locations.

  [PX,PY] = GRADIENT(Z) assumes DX = DY = 1.

  If Y is a vector, GRADIENT(Y) and GRADIENT(Y,DX) return the one

  dimensional numerical derivative dY/dX.

  For example, try

     [x,y] = meshgrid(-2:.2:2, -2:.2:2);

     z = x .* exp(-x.^2 - y.^2);

     [px,py] = gradient(z,.2,.2);

     contour(z),hold on, quiver(px,py), hold off

  See also DIFF, DEL2, QUIVER, CONTOUR.


GRAY

 Linear gray-scale color map.

  GRAY(M) returns an M-by-3 matrix containing a gray-scale colormap.

  GRAY, by itself, is the same length as the current colormap.

  For example, to reset the colormap of the current figure:

            colormap(gray)

  See also HSV, HOT, COOL, BONE, COPPER, PINK, FLAG,

  COLORMAP, RGBPLOT.


GRAYMON

 Graphics figure defaults set for gray-scale monitor.

  GRAYMON changes the default graphics properties to produce

  legible displays for gray-scale monitors.


GRID

 Grid lines for 2-D and 3-D plots.

  GRID ON adds grid lines to the current axes.

  GRID OFF takes them off.

  GRID, by itself, toggles the grid state.

  GRID sets the XGrid, YGrid, and ZGrid properties of

  the current axes.

  See also TITLE, XLABEL, YLABEL, ZLABEL, AXES, PLOT.


GRIDDATA

 Data gridding.

  ZI = GRIDDATA(X,Y,Z,XI,YI) returns matrix ZI containing elements

  corresponding to the elements of matrices XI and YI and determined by

  interpolation within the 2-D function described by the (usually)

  nonuniformly-spaced vectors (X,Y,Z).

  XI can be a row vector, in which case it specifies a matrix with

  constant columns. Similarly, YI can be a column vector and it

  specifies a matrix with constant rows.

  [XI,YI,ZI] = GRIDDATA(X,Y,Z,XI,YI) returns the XI and YI formed

  this way, which are the same as the matrices returned by MESHGRID.

  GRIDDATA uses an inverse distance method.

  See also INTERP2, INTERP1.


GTEXT

 Place text on a 2-D graph using a mouse.

  GTEXT('string') displays the graph window, puts up a

  cross-hair, and waits for a mouse button or keyboard key to be

  pressed.  The cross-hair can be positioned with the mouse (or

  with the arrow keys on some computers).  Pressing a mouse button

  or any key writes the text string onto the graph at the selected

  location.

  See also TEXT, GINPUT.


HADAMARD

 HADAMARD(N) is a Hadamard matrix of order N, that is,

  a matrix H with elements 1 or -1 such that H'*H = N*EYE(N).

  An N-by-N Hadamard matrix with N > 2 exists only if REM(N,4)=0.

  This function handles only the cases where N, N/12 or N/20

  is a power of 2.


HANKEL

 Hankel matrix.

  HANKEL(C) is a square Hankel matrix whose first column is C and

  whose elements are zero below the first anti-diagonal.

  HANKEL(C,R) is a Hankel matrix whose first column is C and whose

  last row is R.

  Hankel matrices are symmetric, constant across the anti-diagonals,

  and have elements H(i,j) = R(i+j-1).

  See also TOEPLITZ.


HARDCOPY

 Save figure window to file.

  HARDCOPY(H,'filename','format') saves the figure window

  with handle H to the designated filename in the

  specified format.

  Legal formats are -dps,-deps,-dps2,-deps2. See

  PRINT for more information.

  Do NOT use this function directly. Use PRINT instead.

  This function is temporary and will be replaced with

  a different mechanism in future releases of MATLAB.


HELP

 On-line documentation.

  HELP, by itself, lists all primary help topics.  Each primary topic

  corresponds to a directory name on MATLABPATH.

  "HELP topic" gives help on the specified topic.  The topic can be

  a command name or a directory name.  If it is a command name, HELP

  displays information on that command.  If it is a directory name,

  HELP displays the Table-Of-Contents for the specified directory.

  It is not necessary to give the full pathname of the directory;

  the last component, or last several components, are sufficient.

  For example, "help general" and "help matlab/general" both list

  the Table-Of-Contents for the directory toolbox/matlab/general.

  LOOKFOR XYZ looks for the string XYZ in the first comment line

  of the HELP text in all M-files found on MATLABPATH.  For all files

  in which a match occurs, LOOKFOR displays the matching lines.

  MORE ON causes HELP to pause between screenfuls if the help text

  runs to several screens.

  See also LOOKFOR, WHAT, WHICH, DIR, MORE.


HESS

 Hessenberg form.

  The Hessenberg form of a matrix is zero below the first

  subdiagonal. If the matrix is symmetric or Hermitian,

  the form is tridiagonal.  [P,H] = HESS(A) produces a unitary

  matrix P and a Hessenberg matrix H so that A = P*H*P' and

  P'*P = EYE(P).  By itself, HESS(A) returns H.


HEX2DEC

 Hexadecimal to decimal number conversion.

  HEX2DEC(D) returns hexadecimal number D in decimal form.

  For example, HEX2DEC('12B') and HEX2DEC('12b') both return 299.

  See also DEC2HEX, HEX2NUM.


HEX2NUM

 IEEE hexadecimal to double precision number conversion.

  HEX2NUM(S), where S is a 16 character string containing

  a hexadecimal number, returns the IEEE double precision

  floating point number it represents.  Fewer than 16

  characters are padded on the right with zeros.

  For example, HEX2NUM('400921fb54442d18') returns Pi.

               HEX2NUM('bff') returns -1.

  NaNs, infinities and denorms are handled correctly.  See

  also FORMAT HEX.


HIDDEN

 Mesh hidden line removal mode.

  HIDDEN ON sets hidden line removal on for the current mesh.

  HIDDEN OFF sets hidden line removal off so you can see through

  the current mesh.

  HIDDEN by itself toggles the state of hidden line removal.

  See also MESH.


HIGHLIGHT

 Plot a mesh with subgraph highlighted.

  highlight(A,xy,sep) plots a picture of the mesh A with

  coordinates xy, highlighting the subgraph induced

  by the vertices in sep.


HILB

 Hilbert matrix.

  HILB(N) is the N by N matrix with elements 1/(i+j-1),

  which is a famous example of a badly conditioned matrix.

  See INVHILB for the exact inverse.

  This is also a good example of efficient MATLAB programming

  style where conventional FOR or DO loops are replaced by

  vectorized statements.  This approach is faster, but uses

  more storage.


HINT

 Puzzle hints.

  The command "hint" with no arguments gives a

  little help with the answer to the current puzzle.

  You can also "type puzzle".

  See also PUZZLE, MEMBRANE, GLOBAL.


HIST

 Plot histograms.

  HIST(Y) plots a histogram with 10 equally spaced bins between

  the minimum and maximum values in Y, showing the distribution

  of the elements in vector Y.

  HIST(Y,N), where N is a scalar, uses N bins.

  HIST(Y,X), where X is a vector, draws a histogram using the

  bins specified in X.

  [N,X] = HIST(...) does not draw a graph, but returns vectors

  X and N such that BAR(X,N) is the histogram.

  See also BAR.


HOLD

 Hold the current graph.

  HOLD ON holds the current plot and all axis properties so that

  subsequent graphing commands add to the existing graph.

  HOLD OFF returns to the default mode whereby PLOT commands erase

  the previous plots and reset all axis properties before drawing

  new plots.

  HOLD, by itself, toggles the hold state.

  HOLD does not affect axis autoranging properties.

  Algorithm note:

  HOLD ON sets the NextPlot property of the current figure and

  axes to "add".

  HOLD OFF sets the NextPlot property of the current axes to

  "replace".

  See also ISHOLD, NEWPLOT, FIGURE, AXES.


HOME

 Send the cursor home.

  HOME returns the cursor to the upper left corner of the screen.

  See also CLC.


HOSTID

 MATLAB server host identification number.


HOT

 Black-red-yellow-white color map.

  HOT(M) returns an M-by-3 matrix containing a "hot" colormap.

  HOT, by itself, is the same length as the current colormap.

  For example, to reset the colormap of the current figure:

            colormap(hot)

  See also HSV, GRAY, PINK, COOL, BONE, COPPER, FLAG,

  COLORMAP, RGBPLOT.


HSV

 Hue-saturation-value (HSV) color map.

  HSV(M) returns an M-by-3 matrix containing an HSV colormap.

  HSV, by itself, is the same length as the current colormap.

  An HSV colormap varies the hue component of the hue-saturation-value

  color model.  The colors begin with red, pass through yellow, green,

  cyan, blue, magenta, and return to red.  The map is particularly

  useful for displaying periodic functions.

  For example, to reset the colormap of the current figure:

            colormap(hsv)

  See also GRAY, HOT, COOL, BONE, COPPER, PINK, FLAG, PRISM, JET,

  COLORMAP, RGBPLOT, HSV2RGB, RGB2HSV.


HSV2RGB

 Hue-saturation-value to red-green-blue conversion.

  M = HSV2RGB(H) converts an HSV color map to an RGB color map.

  Each map is a matrix with any number of rows, exactly three columns,

  and elements in the interval 0 to 1.  The columns of the input matrix,

  H, represent hue, saturation and value, respectively.  The columns of

  the resulting output matrix, M, represent intensity of red, blue and

  green, respectively.

  As H(:,1), the hue, varies from 0 to 1, the resulting color varies

  from red, through yellow, green, cyan, blue and magenta, back to red.

  When H(:,2), the saturation, is 0, the colors are unsaturated; they

  are simply shades of gray.  When H(:,2) is 1, the colors are fully

  saturated; they contain no white component.  When H(:,3), the color

  value, varies from 0 to 1, the brightness increases.

  The default colormap, HSV, is hsv2rgb([h s v]) where

  h is a linear ramp from 0 to 1 and both s and v are all 1's.

  See also RGB2HSV, COLORMAP, RGBPLOT.


HUMPS

 A function used by QUADDEMO, ZERODEMO and FPLOTDEMO.

  HUMPS(X) is a function with strong maxima near x = .3 and x = .9.

  See QUADDEMO, ZERODEMO and FPLOTDEMO.


I

 Imaginary unit.

  The variables i and j both initially have the value sqrt(-1)

  for use in forming complex quantities.  For example, the

  expressions 3+2i, 3+2*i, 3+2i, 3+2*j and 3+2*sqrt(-1).

  all have the same value.  However, both i and j may be

  assigned other values, often in FOR loops and as subscripts.

  See also J.


ICUBIC

 Cubic Interpolation of a 1-D function.

  YI=ICUBIC(Y,XI) returns the value of the 1-D function Y at the

  points XI using cubic interpolation. length(YI)=length(XI). XI is

  an index into the vector Y. Y is the value of the function

  evaluated uniformly on a interval. If Y is a matrix, then

  the interpolation is performed for each column of Y.

  If Y is of length N then XI must contain values between 1 and N.

  The value NaN is returned if this is not the case.

  YI = ICUBIC(X,Y,XI) uses the vector X to specify the coordinates

  of the underlying interval. X must be equally spaced and

  monotonic. XI must lie within the coordinates in X.


IF

 Conditionally execute statements.

  The general form of an IF statement is:

          IF variable, statements, END

  The statements are executed if the real part of the variable

  has all non-zero elements. The variable is usually the result of

  expr rop expr where rop is ==, <, >, <=, >=, or ~=.

  For example:

         IF I == J

            A(I,J) = 2;

         ELSEIF ABS(I-J) == 1

            A(I,J) = -1;

         ELSE

            A(I,J) = 0;

         END


IFFT

 Inverse discrete Fourier transform.

  IFFT(X) is the inverse discrete Fourier transform of vector X.

  IFFT(X,N) is the N-point inverse transform.

  See also FFT, FFT2, IFFT2, FFTSHIFT.


IFFT2

 Two-dimensional inverse discrete Fourier transform.

  IFFT2(F) returns the two-dimensional inverse Fourier transform

  of matrix F.  If F is a vector, the result will have the same

  orientation.

  IFFT2(F,MROWS,NCOLS) pads matrix F with zeros to size MROWS-by-NCOLS

  before transforming.

  See also FFT2, FFTSHIFT.


IMAG

 Complex imaginary part.

  IMAG(X) is the imaginary part of X.

  See I or J to enter complex numbers.

  See also REAL, CONJ, ANGLE, ABS.


IMAGE

 Display image (create image object).

  IMAGE(C) displays matrix C as an image.  Each element of C

  specifies the color of a rectilinear patch in the image. The

  elements of C are used as indices into the current COLORMAP

  to determine the color.

  IMAGE(X,Y,C), where X and Y are vectors, specifies the labeling of

  X- and Y-axes, but produces the same image as IMAGE(C). Only the

  first and last elements of X and Y are used for the axis limits.

  IMAGE returns a handle to an IMAGE object.

  C or the X,Y,C triple can be followed by parameter/value

  pairs to specify additional properties of the image.

  C or the X,Y,C triple can be omitted entirely, and all

  properties specified using parameter/value pairs.

  IMAGE sets the YDir axis property to 'reverse', and the View

  axis property to [0 90].  The image object will not render at other

         View angles.  To get a similar effect to rotating an image, use

         SURF with texture mapping or PCOLOR.

         Execute GET(H), where H is an image handle, to see a list of image

         object properties and their current values. Execute SET(H) to see a

         list of image object properties and legal property values.

  See also COLORMAP, PCOLOR, SURF.


IMAGEDEMO

 Demonstrate V4's image capability.


IMAGEEXT

 Demonstrate MATLAB V4's image capability.


IMAGESC

 Scale data and display as image.

  IMAGESC(...) is the same as IMAGE(...) except the data is scaled

  to use the full colormap.

  See also IMAGE.


IMREAD

 Read an image file.

  IMREAD('imagefile.raw') reads a "raw" image file produced by the

  Image Alchemy program from Handmade Software, Inc.

  [X,map] = IMREAD('imagefile.raw') returns both the image and a

  color map, so that

          [X,map] = imread('imagefile.raw');

          image(X)

          colormap(map)

  will display the result with the proper colors.

  Image Alchemy can be used to convert a GIF file, for example, with

          alchemy -r -c 128 -z 4 imagefile.gif

  The relevant options are:

          -r      Produce a "raw" file.

          -c 128  Limit the color map length to 128 colors.

          -z 4    Sort color map by luminance, so colormap(gray)

                  works pretty well.

  See also IMWRITE, IMAGE, COLORMAP.


IMTEXT

 Place possibly multi-line text as xlabel.

  IMTEXT(x,y,T) writes T, center justified, with the lower left

  corner at axis normalized coordinates (x,y).

  IMTEXT(x,y,T,'center') and FIXTEXT(x,y,T,'right) are also possible.

  H = IMTEXT(...) returns a vector of handles to the lines of text.


IMWRITE

 Write an image file.

  IMWRITE(X,map,'filename.raw') writes a "raw" image file used

  by the Image Alchemy program from Handmade Software, Inc.

  The image is in X and its colormap is in map.

  See also IMREAD, IMAGE, COLORMAP.


INF

 Infinity.

  INF is a permanent variable representing IEEE arithmetic positive

  infinity.  Infinity is obtained from operations like dividing by

  zero, eg. 1.0/0.0, or from overflow, eg. exp(1000).

  See also NaN.


INFO

 Information about MATLAB and The MathWorks.


INPUT

 Prompt for user input.

  INPUT('How many apples') gives the user the prompt in the

  text string and then waits for input from the keyboard.

  The input can be any MATLAB expression, which is evaluated,

  using the variables in the current workspace, and the result

  returned as the value of the function.

  INPUT('What is your name','s') gives the prompt in the text

  string and waits for character string input.  The typed input

  is not evaluated; the characters are simply returned as a

  MATLAB string.


INQUIRE

 MATLAB internal states.

  INQUIRE('echo') returns 1 if ECHO is on, 0 if ECHO is off.

  INQUIRE('casesen') returns 1 if CASESEN is on, 0 if off.

  INQUIRE('hold') returns 1 if HOLD is on, 0 if HOLD is off.

  [S,V] = INQUIRE('axis') returns S=0 if AXIS is autoranging,

  S=1 if the AXIS is frozen.  Vector V contains the current

  axis limits, V = [Xmin Xmax Ymin Ymax].

  INQUIRE('subplot') returns the current SUBPLOT state, e.g.

  111, 211, 223, etc.

  [F,D] = INQUIRE('format') returns strings F and D such that

  EVAL(F),EVAL(D) would restore the current format state.

  F is a string like 'format short e' or 'format hex'.

  D is either 'format compact' or 'format loose'.

  [S,FNAME] = INQUIRE('diary') returns S=0 if the diary is

  off, S=1 if the diary is on, and the name of the current

  diary file in FNAME.  FNAME is empty if no file is named.

  This function is obsolete.  Please use GET to inquire

  state values.


INT2STR

 Integer to string conversion.

  S = INT2STR(N)  converts the integer valued scalar number  N

         into a string representation.

  See also NUM2STR, SPRINTF, FPRINTF.


INTERP1

 1-D data interpolation (table lookup).

  YI = INTERP1(X,Y,XI) returns vector YI containing elements

  corresponding to the elements of XI and determined by interpolation

  within vectors X and Y.

  Interpolation is the same operation as "table lookup".  Described in

  "table lookup" terms, the "table" is [X,Y] and INTERP1 "looks-up"

  the elements of XI in X, and, based upon their location, returns

  values YI interpolated within the elements of Y.

  INTERP1 performs multiple output table lookup if Y is a matrix.

  If Y is a matrix with length(X) rows, and N columns, INTERP1

  returns a length(XI)-by-N matrix YI containing the multi-output

  table lookup results.

  By default, INTERP1 uses linear interpolation.

  YI = INTERP1(X,Y,XI,'method') specifies alternate methods.

  Available methods are:

    'linear' - linear interpolation

    'spline' - cubic spline interpolation

    'cubic' - cubic interpolation

  All the interpolation methods require that X be monotonic. The

  'cubic' method also requires that the points in X be equally-spaced.

  For example, generate a coarse sine curve and interpolate over a

  finer abscissa:

                   x = 0:10; y = sin(x);

                   xi = 0:.25:10;

                   yi = interp1(x,y,xi);

                   plot(x,y,'o',xi,yi)

  See also INTERPFT, INTERP2, GRIDDATA.


INTERP2

 2-D data interpolation (table lookup).

  ZI = INTERP2(X,Y,Z,XI,YI) returns matrix ZI containing elements

  corresponding to the elements of XI and YI and determined by

  interpolation within the 2-D function described by matrices X, Y,

  and Z.  Out of range values are returned as NaN.

  X can be a row vector, in which case the elements are assumed to

  apply to the columns of Z. Similarly, Y can be a column vector

  and its elements are assumed to apply across the rows of Z.

  Interpolation is the same operation as "table lookup".  Described in

  "table lookup" terms, the "table" is TAB = [NaN,Y; X,Z] and INTERP2

  "looks-up" the elements of XI in X, YI in Y, and, based upon their

  location, returns values ZI interpolated within the elements of Z.

  By default, INTERP2 uses bilinear interpolation.

  ZI = INTERP2(X,Y,Z,XI,YI,'method') specifies alternate methods.

  Available methods are:

    'linear' - bilinear interpolation

    'cubic'  - bicubic interpolation

  All the interpolation methods require that X and Y be monotonic.

  The 'cubic' method also requires that the points in X and Y be

  equally-spaced.

  See also INTERP1, GRIDDATA.


INTERP3

 2-D biharmonic data interpolation and gridding.

  ZI = INTERP3(X,Y,Z,XI,YI) uses biharmonic interpolation to

  find ZI, the values of the underlying 2-D function in Z at the points

  in matrices XI and YI.  Matrices X and Y specify the points at which

  the data Z is given.  X and Y can also be vectors specifying the

  abscissae for the matrix Z as for MESHGRID. In both cases, X

  and Y must be equally spaced and monotonic.

  If X, Y, and Z are all vectors, INTERP3 interpolates within the

  data given by the (possibly irregularly spaced) ordered triplets

  (X,Y,Z) to return matrix ZI.

  ZI = INTERP3(Z,M,N) returns an M-by-N matrix ZI whose values

  are interpolated within matrix Z.

  [ZI,WEIGHTS]=INTERP3(X,Y,Z,XI,YI) also returns the computed

  interpolation WEIGHTS, which can be reused as follows:

  INTERP3(X,Y,Z,XI,YI,WEIGHTS) uses the given WEIGHTS vector,

  instead of recalculating them from X, Y, and Z.

  INTERP4 and INTERP5 are much faster than INTERP3 for

  data interpolation and should be used unless irregularly

  spaced vector triplet gridding is required.

  See also INTERP4, INTERP5, INTERP2, SPLINE, INTERP1.


INTERP4

 2-D bilinear data interpolation.

  ZI = INTERP4(X,Y,Z,XI,YI) uses bilinear interpolation to

  find ZI, the values of the underlying 2-D function in Z at the points

  in matrices XI and YI.  Matrices X and Y specify the points at which

  the data Z is given.  X and Y can also be vectors specifying the

  abscissae for the matrix Z as for MESHGRID. In both cases, X

  and Y must be equally spaced and monotonic.

  Values of NaN are returned in ZI for values of XI and YI that are

  outside of the range of X and Y.

  If XI and YI are vectors, INTERP4 returns vector ZI containing

  the interpolated values at the corresponding points (XI,YI).

  ZI = INTERP4(Z,XI,YI) assumes X = 1:N and Y = 1:M, where

  [M,N] = SIZE(Z).

  F = INTERP4(Z,NTIMES) returns the matrix Z expanded by interleaving

  bilinear interpolates between every element, working recursively

  for NTIMES.  INTERP4(Z) is the same as INTERP4(Z,1).

  See also INTERP5, INTERP3.


INTERP5

 2-D bicubic data interpolation.

  INTERP5(...) is the same as INTERP4(....) except that it uses

  bicubic interpolation.

  See also INTERP4.


INTERPFT

 1-D interpolation using a FFT method.

  Y = INTERPFT(X,N) returns a length N vector Y obtained by

  interpolation in the Fourier transform of X.  N must be larger

  than the length of X.  The result has circular periodicity.

  See also INTERP1, INTERP2, GRIDDATA.


INTRO

 MATDEMO Introduction to MATLAB.


INV

 Matrix inverse.

  INV(X) is the inverse of the square matrix X.

  A warning message is printed if X is badly scaled or

  nearly singular.


INVERF

 Inverse Error function.


INVHILB

 Inverse Hilbert matrix.

  INVHILB(N) is the inverse of the N by N matrix with elements

  1/(i+j-1), which is a famous example of a badly conditioned

  matrix.  The result is exact for  N  less than about 15.

  See also HILB.


ISEMPTY

 True for empty matrices.

  ISEMPTY(X) returns 1 if X is an empty matrix and 0 otherwise.

  An empty matrix has a zero size in at least one dimension,

  for example 0-by-0, 0-by-5, etc.


ISGLOBAL

 True for global variables

  ISGLOBAL(A) is 1 if A is a global variable, 0 otherwise.


ISHOLD

 Return 1 if hold is on.

  ISHOLD returns 1 if hold is on, and 0 if it is off.

  When HOLD is ON, the current plot and all axis properties

  are held so that subsequent graphing commands add to the

  existing graph.

  Hold on means the NextPlot property of both figure

  and axes is set to "add".

  See also HOLD, NEWPLOT, FIGURE, AXES.


ISIEEE

 True for computers with IEEE arithmetic.

  ISIEEE returns 1 on machines with IEEE arithmetic

  and 0 on machines without IEEE arithmetic.

  Machines with IEEE:  IBM PC, most UNIX workstations, Macintosh.

  Machines without: VAX, Cray.

  See also COMPUTER.


ISINF

 True for infinite elements.

  ISINF(X) returns 1's where the elements of X are +Inf or -Inf

  and 0's where they are not.  For example ISINF([pi NaN Inf -Inf])

  is [0 0 1 1].

  See also FINITE, ISNAN.


ISLETTER

 True for letters of the alphabet.

  For a string S, ISLETTER(S) is 1 for letters of the alphabet

  and 0 otherwise.


ISNAN

 True for Not-A-Number.

  ISNAN(X) returns 1's where the elements of X are NaN's and

  0's where they are not.  For example ISNAN([pi NaN Inf -Inf])

  is [0 1 0 0].

  See also FINITE, ISINF.


ISSPARSE

 True if matrix is sparse.

  ISSPARSE(S) is 1 if the storage class of S is sparse

  and 0 otherwise.


ISSTR

 True for text string.

  ISSTR(S) returns 1 if S is a text string and 0 otherwise.

  See also SETSTR, STRING.


ISUNIX

 True for UNIX operating systems.


J

 Imaginary unit.

  The variables i and j both initially have the value sqrt(-1)

  for use in forming complex quantities.  For example, the

  expressions 3+2i, 3+2*i, 3+2i, 3+2*j and 3+2*sqrt(-1).

  all have the same value.  However, both i and j may be

  assigned other values, often in FOR loops and as subscripts.

  See also I.

  Built-in function.

  Copyright (c) 1984-93 by The MathWorks, Inc.


JET

 Variant of HSV.

  JET(M), a variant of HSV(M), is the colormap used with the

  NCSA fluid jet image.

  JET, by itself, is the same length as the current colormap.

  Use COLORMAP(JET).

  See also HSV, HOT, PINK, FLAG, COLORMAP, RGBPLOT.


KEYBOARD

 Invoke the keyboard as if it were a Script-file.

  KEYBOARD invokes the keyboard as if it were a Script-file.

  When placed in an M-file, KEYBOARD stops execution of the

  file and gives control to the user's keyboard. The special

  status is indicated by a double prompt. Variables may be

  examined or changed - all MATLAB commands are valid. The

  keyboard mode is terminated by executing the command RETURN

  (i.e. typing the six letters R-E-T-U-R-N and pressing the

  return key).  Control returns to the invoking M-file.


KNOT

 Tube surrounding a three-dimensional knot.

   KNOT computes the parametric representation of tube-like

   surfaces and displays the tube with SURF.


KRON

 Kronecker tensor product.

  KRON(X,Y) is the Kronecker tensor product of X and Y.

  The result is a large matrix formed by taking all possible

  products between the elements of X and those of Y.   For

  example, if X is 2 by 3, then KRON(X,Y) is

     [ X(1,1)*Y  X(1,2)*Y  X(1,3)*Y

       X(2,1)*Y  X(2,2)*Y  X(2,3)*Y ]


LALALA

 Modern version of LALA.

  See also LAUGH, SOUNDDEMO.


LASTERR

 Last error message.

  LASTERR, by itself, returns a string containing the last

  error message issued by MATLAB.

  LASTERR('') resets the LASTERR function so that it will

  return an empty matrix until the next error is encountered.

  LASTERR is usually used in conjunction with the two

  argument form of EVAL: EVAL('try','catch').  The 'catch'

  action can examine the LASTERR string to determine the

  cause of the error and take appropriate action.

  See also EVAL, ERROR.


LCM

 Least common multiple.

  LCM(A,B) is the least common multiple of positive integers A and B.

  See also GCD.


LENGTH

 Number of components of a vector.

  LENGTH(X) returns the length of vector X.  It is equivalent

  to MAX(SIZE(X)).


LIFE

 MATLAB's version of Conway's Game of Life.

  Demonstrates sparse matrices and Handle Graphics.


LIFELOOP

  Inner loop for life.


LIN2MU

 Linear to mu-law conversion.

  MU = LIN2MU(Y) converts linear audio signal amplitudes

  in the range  -1 <= Y <= 1 to mu-law encoded "flints"

  in the range 0 <= MU <= 255.

  See also MU2LIN, AUWRITE for more details and references.


LINE

 Create line low-level objects.

  LINE(X,Y) adds the line in vectors X and Y to the current axes.

  If X and Y are matrices the same size, one line per column is added.

  LINE(X,Y,Z) creates lines in 3-D coordinates.

  LINE returns a column vector of handles to LINE objects,

  one handle per line. LINEs are children of AXES objects.

  The X,Y pair (X,Y,Z triple for 3-D) can be followed by

  parameter/value pairs to specify additional properties of the lines.

  The X,Y pair (X,Y,Z triple for 3-D) can be omitted entirely, and

  all properties specified using parameter/value pairs.

         Execute GET(H), where H is a line handle, to see a list of line

  object properties and their current values. Execute SET(H) to see a

  list of line object properties and legal property values.

  See also PATCH, TEXT, PLOT, PLOT3.


LINSPACE

 Linearly spaced vector.

  LINSPACE(x1, x2) generates a row vector of 100 linearly

  equally spaced points between x1 and x2.

  LINSPACE(x1, x2, N) generates N points between x1 and x2.

  See also LOGSPACE, :.


LOAD

 Retrieve variables from disk.

  LOAD fname  retrieves the variables from the MAT-file 'fname.mat'.

  LOAD, by itself, loads from the file named 'matlab.mat'.

  LOAD xxx.yyy  reads the ASCII file xxx.yyy, which must contain a

  rectangular array of numeric data, arranged in m lines with n values

  in each line.  The result is an m-by-n matrix named xxx.

  To load an ASCII file that does not have a filename extension, use

  LOAD fname -ascii. Otherwise MATLAB adds the extension '.mat' and

  tries to load it as a MAT-file. To load a MAT-file that does NOT

  have a '.mat' extension, use LOAD fname.ext -mat.

  If fname is "stdio", LOAD reads from standard input.

  See also SAVE, SPCONVERT, FSCANF, FPRINTF.


LOADWAVE

 Load Microsoft Windows 3.1 .WAV format sound files.

     [y]=LOADWAVE(wavefile) loads a .WAV format file specified by "wavefile",

         returning the sampled data in variable "y". The .WAV extension

         in the filename is optional.

     [y,Fs]=LOADWAVE(wavefile) loads a .WAV format file specified by

         "wavefile", returning the sampled data in variable "y" and the

         sample rate in variable "Fs".

     [y,Fs,Format]=LOADWAVE(wavefile) loads a .WAV format file specified by

         "wavefile",returning the sampled data in variable "y", the sample

         rate in variable "Fs", and the .WAV file format information in

         variable "Format". The format information is returned as a 6 element

         vector with the following order:

                 Format(1)       Data format (always PCM)

                 Format(2)       Number of channels

                 Format(3)       Sample Rate (Fs)

                 Format(4)       Average bytes per second (sampled)

                 Format(5)       Block alignment of data

                 Format(6)       Bits per sample

     Note: LOADWAVE currently supports only 8-bit single channel data.

     See also, SAVEWAVE .


LOG

 Natural logarithm.

  LOG(X) is the natural logarithm of the elements of X.

  Complex results are produced if X is not positive.

  See also LOG10, EXP, LOGM.


LOG10

 Common logarithm.

  LOG10(X)  is  the  logarithm  base 10 of the  elements of X.

  Complex results are produced if X  is not positive.

  See also LOG, EXP, LOGM.


LOG2

 Dissect floating point numbers.   IEEE logb().

  y = LOG2(x) computes the logarithm base 2 of the elements of x.

  [f,e] = LOG2(x) for a real matrix x, returns a matrix f of real

  numbers, usually in the range 0.5 <= abs(f) < 1, and a matrix

  e of integers, so that  x = f .* 2.^e.  Any zeros in x produce

  f = 0 and e = 0.  This corresponds to the ANSI C function frexp()

  and the IEEE floating point standard function logb().

  See also POW2, NEXTPOW2, REALMAX, REALMIN.


LOGLOG

 Plot using log-log scales.

  LOGLOG(...) is the same as PLOT(...), except logarithmic

  scales are used for both the X- and Y- axes.

  See also PLOT.


LOGM

 Matrix logarithm.

  L = LOGM(A) is the matrix logarithm of A.

  Complex results are produced if A has negative eigenvalues.

  A warning message is printed if the computed expm(L) is not close to A.

  [L,esterr] = logm(A) does not print any warning message, but

  returns an estimate of the relative residual, norm(expm(L)-A)/norm(A).

  If A is real symmetric or complex Hermitian, then so is LOGM(A).

  Some matrices, like A = [0 1; 0 0], do not have any logarithms,

  real or complex, and LOGM cannot be expected to produce one.

  See also EXPM, SQRTM, FUNM.


LOGSPACE

 Logarithmically spaced vector.

  LOGSPACE(d1, d2) generates a row vector of 50 logarithmically

  equally spaced points between decades 10^d1 and 10^d2.  If d2

  is pi, then the points are between 10^d1 and pi.

  LOGSPACE(d1, d2, N) generates N points.

  See also LINSPACE, :.


LOOKFOR

 Keyword search through the HELP entries.

  LOOKFOR XYZ looks for the string XYZ in the first comment line

  (the H1 line) of the HELP text in all M-files found on MATLABPATH.

  For all files in which a match occurs, LOOKFOR displays the H1 line.

  For example, "lookfor inverse" finds at least a dozen matches,

  including the H1 lines containing "inverse hyperbolic cosine"

  "two-dimensional inverse FFT", and "pseudoinverse".

  Contrast this with "which inverse" or "what inverse", which run

  more quickly, but which probably fail to find anything because

  MATLAB does not ordinarily have a function "inverse".

  In summary, WHAT lists the functions in a given directory,

  WHICH finds the directory containing a given function, and

  LOOKFOR finds all functions in all directories that might have

  something to do with a given key word.

  See also DIR, HELP, WHO, WHAT, WHICH.


LORENZ

 Plot the orbit around the Lorenz chaotic attractor.


LORENZEQ

 Equation of the Lorenz chaotic attractor.

  ydot = lorenzeq(t,y).

  The differential equation is written in almost linear form.


LOTKA

 Lotka-Volterra predator-prey model.


LOWER

 Convert string to lower case.

  b = lower(A) converts any upper case characters in A to

  the corresponding lower case character and leaves all

  other characters unchanged.

  See also UPPER.


LS

 Directory listing.


LSCOV

 Least squares solution in the presence of known covariance.

  X = LSCOV(A,b,V) returns the vector X that minimizes

  (A*X-b)'*inv(V)*(A*X-b) for the case in which length(b) > length(X).

  This is the over-determined least squares problem with covariance V.

  The solution is found without needing to invert V which is a square

  symmetric matrix with dimensions equal to length(b).

  The classical linear algebra solution to this problem is:

      x = inv(A'*inv(V)*A)*A'*inv(V)*b

  See also SLASH, NNLS, QR.


LU

 Factors from Gaussian elimination.

  [L,U] = LU(X) stores a upper triangular matrix in U and a

  "psychologically lower triangular matrix", i.e. a product

  of lower triangular and permutation matrices, in L , so

  that X = L*U.

  [L,U,P] = LU(X) returns lower triangular matrix L, upper

  triangular matrix U, and permutation matrix P so that

  P*X = L*U.

  By itself, LU(X) returns the output from LINPACK'S ZGEFA routine.


MAGIC

 Magic square.

  MAGIC(N) is an N-by-N matrix constructed from the integers

  1 through N^2 with equal row and column sums.


MAN

 On-line documentation.


MATHLIST

 List of mathematical examples.

  MATHLIST, by itself, presents a list of mathematical examples.

  Used by DEMO.


MATLABRO

 Root directory of MATLAB installation.


MAX

 Largest component.

  For vectors, MAX(X) is the largest element in X. For

  matrices, MAX(X) is a vector containing the maximum element

  from each column. [Y,I] = MAX(X) stores the indices of the

  maximum values in vector I. MAX(X,Y) returns a matrix the

  same size as X and Y with the largest elements taken from X

  or Y. When complex, the magnitude MAX(ABS(X)) is used.

  See also MIN, MEDIAN, MEAN, SORT.


MEAN

 Average or mean value.

  For vectors,  MEAN(X)  is the mean value of the elements in X.

  For matrices,  MEAN(X) is a row vector containing the mean value

  of each column.

  See also MEDIAN, STD, MIN, MAX.


MEDIAN

 Median value.

  For vectors,  MEDIAN(X)  is the median value of the elements in X.

  For matrices, MEDIAN(X) is a row vector containing the median value

  of each column.

  See also MEAN, STD, MAX, MIN.


MEMBRANE

 Generate MathWorks's logos.

  L = MEMBRANE(k), for k <= 12, is the k-th eigenfunction of

  the L-shaped membrane.  The first three eigenfunctions have

  been shown on the covers of various MathWorks publications.

  MEMBRANE(k), with no output parameters, plots the k-th eigenfunction.

  MEMBRANE, with no input or output parameters, plots MEMBRANE(1).

  L = MEMBRANE(k,m,n,np) also sets some mesh and accuracy parameters:

    k = index of eigenfunction, default k = 1.

    m = number of points on 1/3 of boundary.  The size of

        the output is 2*m+1-by-2*m+1.  The default m = 15.

    n = number of terms in sum, default n = min(m,9).

    np = number of terms in partial sum, default np = min(n,2).

    With np = n, the eigenfunction is nearly zero on the boundary.

    With np < n, like np = 2, the boundary is not tied down.


MEMORY

 MATLAB memory limitations.

  If the OUT OF MEMORY error message is encountered, there is

  no more room in memory for new variables. You must free up

  some space before you may proceed. One way to free up space

  is to delete some variables (see CLEAR). Another is to

  issue the command PACK (See PACK). PACK compresses the data

  in memory, opening up larger contiguous blocks.

  Here are some additional system specific tips:

  MS-Windows: Increase the swap space by opening the Control

              Panel, double-clicking on the 386 Enhanced icon,

              and pressing the Virtual Memory button.

  Macintosh:  Under Multi-Finder, change the application memory

              size by using 'Get Info' on the program icon.

              Under Single-Finder, install more memory.

  VAX/VMS:    Ask your system manager to increase your Working Set.

  Unix:       Ask your system manager to increase your Swap Space.


MENU

 Generate a menu of choices for user input.

  K = MENU('Choose a color','Red','Blue','Green') displays on

  the screen:

  ----- Choose a color -----

     1) Red

     2) Blue

     3) Green

     Select a menu number:

  The number entered by the user in response to the prompt is

  returned.  On machines that support it, the local menu system

  is used.  The maximum number of menu items is 32.


MESH

 3-D mesh surface.

  MESH(X,Y,Z,C) plots the colored parametric mesh defined by

  four matrix arguments.  The view point is specified by VIEW.

  The axis labels are determined by the range of X, Y and Z,

  or by the current setting of AXIS.  The color scaling is determined

  by the range of C, or by the current setting of CAXIS.  The scaled

  color values are used as indices into the current COLORMAP.

  MESH(X,Y,Z) uses C = Z, so color is proportional to mesh height.

  MESH(x,y,Z) and MESH(x,y,Z,C), with two vector arguments replacing

  the first two matrix arguments, must have length(x) = n and

  length(y) = m where [m,n] = size(Z).  In this case, the vertices

  of the mesh lines are the triples (x(j), y(i), Z(i,j)).

  Note that x corresponds to the columns of Z and y corresponds to

  the rows.

  MESH(Z) and MESH(Z,C) use x = 1:n and y = 1:m.  In this case,

  the height, Z, is a single-valued function, defined over a

  geometrically rectangular grid.

  MESH returns a handle to a SURFACE object.

  AXIS, CAXIS, COLORMAP, HOLD, SHADING and VIEW set figure, axes, and

  surface properties which affect the display of the mesh.

  See also SURF, MESHC, MESHZ, WATERFALL.


MESHC

 Combination MESH/CONTOUR plot.

  MESHC(...) is the same as MESH(...) except that a contour plot

  is drawn beneath the mesh.

  Because CONTOUR does not handle irregularly spaced data, this

  routine only works for surfaces defined on a rectangular grid.

  The matrices or vectors X and Y define the axis limits only.

  See also MESH.


MESHDOM

 Generate X and Y arrays for 3-d plots.

  This is an obsolete routine.  Use the new MESHGRID instead.

  Note: The MESHGRID with MATLAB Version 4.0 produces a Y which is

  flipud(Y) of the Y from MESHDOM.

  The usage remains the same and the mesh plots are the same if

  Version 4.0 has been set to axis('ij').

  [X,Y] = MESHDOM(x,y)  transforms the domain specified by vectors

  x and y into arrays X and Y that can be used for the evaluation

  of functions of two variables and 3-d mesh and surface plots.

  The rows of the output array X are copies of the vector x and

  the columns of the output array Y are copies of the vector y.

  For example, to evaluate and plot the function  x*exp(-x^2-y^2)

  over the range  -2 < x < 2, -2 < y < 2,

      [X,Y] = meshdom(-2:.2:2, -2:.2:2);

      Z = X .* exp(-X.^2 - Y.^2);

      mesh(Z)


MESHGRID

 Generation of X and Y arrays for 3-D plots.

  [X,Y] = MESHGRID(x,y) transforms the domain specified by vectors

  x and y into arrays X and Y that can be used for the evaluation

  of functions of two variables and 3-D surface plots.

  The rows of the output array X are copies of the vector x and

  the columns of the output array Y are copies of the vector y.

  For example, to evaluate the function  x*exp(-x^2-y^2) over the

  range  -2 < x < 2,  -2 < y < 2,

  	[X,Y] = meshgrid(-2:.2:2, -2:.2:2);

  	Z = X .* exp(-X.^2 - Y.^2);

  	mesh(Z)

  [X,Y] = MESHGRID(x) is an abbreviation for [X,Y] = MESHGRID(x,x).

  [X,Y,Z] = MESHGRID(x,y,z) produces packed 3-D arrays that can

  be used to evaluate functions of three variables and 3-D

  volumetric plots.

  See also SURF, SLICE.


MESHZ

 3-D mesh with reference plane.

  MESHZ(...) is the same as MESH(...) except that a "curtain" or

  reference plane is drawn beneath.

  This routine only works for surfaces defined on a rectangular

  grid.  The matrices X and Y define the axis limits only.

  See also MESH.


META

 PostScript hardcopy.

     The command is obsolete but grandfathered for users of

     earlier versions of MATLAB. Use PRINT instead.

     Under MS-Windows(tm), META does nothing.

     If you wish to print to a file, choose the FILE: option

     on the ports list box in the printer driver installation

     dialog box.  The system will then prompt you for a filename

     when to make a print request.

     META <filename> opens the file named 'filename.ps' and saves

     the current Figure to it in PostScript form. Subsequent

     META commands may omit the filename, in which case the

     plots are appended to the previously named file.

     By default, META uses the PostScript driver '-dps'.

     META <filename> -ddevice specifies a different device driver.

     Available device options are:

        -dps    - PostScript

        -dpsc   - Color PostScript

        -dps2   - Level 2 PostScript

        -dpsc2  - Level 2 Color PostScript

     Note, some devices are not supported with META because

     they do not support multiple page file formats. For example

     Encapsulated PostScript (EPS). Use PRINT instead.

     See also PRINT.


MIN

 Smallest component.

  For vectors, MIN(X) is the smallest element in X. For

  matrices, MIN(X) is a vector containing the minimum element

  from each column. [Y,I] = MIN(X) stores the indices of the

  minimum values in vector I. MIN(X,Y) returns a matrix the

  same size as X and Y with the smallest elements taken from X

  or Y. When complex, the magnitude MIN(ABS(X)) is used.

  See also MAX, MEDIAN, MEAN, SORT.


MKPP

 Make piecewise polynomial.

    pp = mkpp(breaks,coefs)

  puts together a pp function from the breaks and coefficients input or

  requested. The number  l  of polynomial pieces is determined as

    l := length(breaks)-1 .

  The  order  k  of the pp is obtained as

    k := length(coefs)/l ,

  and this ratio had better be an integer.

  See also UNMKPP, PPVAL, SPLINE.


MMOVE2

  function mmove2

  CallBack for WindowButtonMotionFcn, signal demo 2


MORE

 Control paged output for the command window.

  MORE OFF disables paging of the output in the MATLAB command window.

  MORE ON enables paging of the output in the MATLAB command window.

  MORE(N) specifies the size of the page to be N lines.

  The defaults are OFF and N = 23.

  When MORE is enabled and output is being paged, advance to the next

  line of output by hitting the RETURN key;  get the next page of

  output by hitting the spacebar. Press the "q" key to exit out

  of displaying the current item.


MOVIE

 Play recorded movie frames.

  MOVIE(M) plays the movie in matrix M once. M must be a matrix

  whose columns are movie frames (usually from GETFRAME).

  MOVIE(M,N) plays the movie N times. If N is negative, each

  "play" is once forward and once backward. If N is a vector,

  elements 2 and above specify the order in which to play the

  frames. For example, if M has three columns, F = [10 3 2 1]

  plays the movie ten times backwards.

  MOVIE(M,N,FPS) plays the movie at FPS frames per second. The

  default if FPS is omitted is 12 frames per second. Machines

  that can't achieve the specified FPS play as fast as they can.

  MOVIE(H,...) plays the movie in object H, where H is a handle

  to the root, a figure, or an axis.

  MOVIE(H,M,N,FPS,LOC) specifies the location to play the movie

  at, relative to the lower-left corner of object H and in

  the units of its Units property. LOC = [X Y].

  See also GETFRAME, MOVIEIN.


MOVIEIN

 Initialize memory for saving movie frames.

  M = MOVIEIN(N) creates a matrix large enough to hold N frames

  of a movie based on the current figure window.  The matrix has

  enough rows to store N copies of the output from GETFRAME, one

  in each column.  MOVIEIN is a simple M-file that contains the

  single line: M = zeros(length(getframe),n).

  Example:  To generate a movie with n frames,

      M = moviein(n);

      for j=1:n

         plot_command

         M(:,j) = getframe

      end

      movie(M)

  See also MOVIE, GETFRAME.


MU2LIN

 Mu-law to linear conversion.

  Y = MU2LIN(MU) converts mu-law encoded 8-bit audio signals,

  stored as "flints" in the range 0 <= MU <= 255, to

  linear signal amplitude in the range -s < Y < s where

  s = 32124/32768 ~= .9803.  The input MU is often obtained

  using fread(...,'uchar') to read byte-encoded audio files.

  "Flints" are MATLAB's integers -- floating point numbers

  whose values are integers.

  See also LIN2MU, AUREAD.


NALIST

 Numerical analysis demonstrations.


NAN

 Not-a-Number.

  NaN is the IEEE arithmetic representation for Not-a-Number.

  A NaN is obtained as a result of mathematically undefined

  operations like 0.0/0.0  and inf-inf.

  See also INF.


NARGCHK

 Check number of input arguments.

  Return error message if	not between low and high.

  If it is, return empty matrix.


NARGIN

 Number of input arguments to a function.

  Inside the body of a user-defined function, the permanent

  variable NARGIN indicates the number of input arguments

  that were used to call the function, and NARGOUT indicates

  the number of output arguments.


NARGOUT

 Number of output arguments for a function.

  Inside the body of a user-defined function, the permanent

  variable NARGIN indicates the number of input arguments

  that were used to call the function, and NARGOUT indicates

  the number of output arguments.


NESTDISS

 Resursive function used by NESTED.

  Generates a nested dissection numbering of a rectangular grid.

  Do not use directly; see NESTED instead.


NESTED

 Nested dissection ordering.

  G = nested(n) generates a nested dissection numbering of an n-by-n grid.

  See also DELSQ, NUMGRID.


NEWPLOT

 Graphics M-file preamble to handle the NextPlot property.

  H = NEWPLOT is a standard preamble command that is put at

  the beginning of graphics M-file functions that draw graphs

  using only low-level object creation commands. NEWPLOT

  "does the right thing" in terms of determining which axes and/or

  figure to draw the plot in, based upon the setting of the

  NextPlot property of axes and figure objects, and returns a

  handle to the appropriate axes.

  The "right thing" is:

  Open a new figure if the figure NextPlot is "New",

  Clear and reset the current figure if figure NextPlot is "Replace",

  Open a new axes if the axes NextPlot is "New",

  Clear and reset the current axes if axes NextPlot is "Replace".

  See also HOLD, ISHOLD, FIGURE, AXES.


NEXTPOW2

 Next power of two.

  NEXTPOW2(N) returns the first P such that 2^P >= abs(N).  It is

  often useful for finding the nearest power of two sequence

  length for FFT operations.

  NEXTPOW2(X), if X is a vector, is the same as NEXTPOW2(LENGTH(X)).

  See also LOG2.


NNLS

 Non-negative least-squares.

  X = NNLS(A,b) returns the vector X that solves A*x = b

  in a least squares sense, subject to x >= 0.

  A default tolerance of TOL = MAX(SIZE(A)) * NORM(A,1) * EPS

  is used for deciding when elements of X are less than zero.

  This can be overridden with X = NNLS(A,b,TOL).

  [X,W] = NNLS(A,b) also returns dual vector W where

  w(i) < 0 where x(i) = 0 and w(i) = 0 where x(i) > 0.

  See also LSCOV, SLASH.


NNZ

 Number of Nonzeros.

  nz = NNZ(S) is the number of nonzeros in S.

  See also NONZEROS, SIZE.


NONZEROS

 Nonzero elements.

  NONZEROS(S) is a full column vector of the nonzeros in S.

  This gives the s, but not the i and j, from [i,j,s] = find(S).

  See also NNZ, FIND.


NORM

 Matrix or vector norm.

  For matrices..

   NORM(X) is the largest singular value of X, max(svd(X)).

   NORM(X,2) is the same as NORM(X).

   NORM(X,1) is the 1-norm of X, the largest column sum,

                    = max(sum(abs((X)))).

   NORM(X,inf) is the infinity norm of X, the largest row sum,

                    = max(sum(abs((X')))).

   NORM(X,'inf') is same as NORM(X,inf).

   NORM(X,'fro') is the F-norm, sqrt(sum(diag(X'*X))).

   NORM(X,P) is available for matrix X only if P is 1, 2, inf or 'fro'.

  For vectors..

   NORM(V,P) = sum(abs(V)^P)^(1/P).

   NORM(V) = norm(V,2).

   NORM(V,inf) = max(abs(V)).

   NORM(V,-inf) = min(abs(V)).

  In MATLAB 4.0, if X has complex components, z, then

  abs(z) = sqrt(z*conj(z)), not abs(real(z)) + abs(imag(z)),

  which was used in some earlier versions of MATLAB.

  See also COND, RCOND, CONDEST, NORMEST.


NORMEST

 Estimate the 2-norm.

  NORMEST(S) is an estimate of the 2-norm of the matrix S.

  NORMEST(S,tol) uses relative error tol instead of 1.e-6.

  [nrm,cnt] = NORMEST(S) also gives the number of power iterations used.


NULL

 Null space.

  Q = null(A) is an orthonormal basis for the null space of A.

  Q'*Q = I, A*Q = 0, and the number of columns of Q is the

  nullity of A.

  See also QR, ORTH.


NUM2STR

 Number to string conversion.

  T = NUM2STR(X)  converts the scalar number  X into a string

  representation  T  with about  4  digits and an exponent if

  required.   This is useful for labeling plots with the

  TITLE, XLABEL, YLABEL, and TEXT commands.

  See also INT2STR, SPRINTF, FPRINTF.


NUMGRID

 Number the grid points in a two dimensional region.

  G = NUMGRID('R',n) numbers the points on an n-by-n grid in

  the subregion of -1<=x<=1 and -1<=y<=1 determined by 'R'.

  SPY(NUMGRID('R',n)) plots the points.

  DELSQ(NUMGRID('R',n)) generates the 5-point discrete Laplacian.

  The regions currently available are:

     'S' - the entire square.

     'L' - the L-shaped domain made from 3/4 of the entire square.

     'C' - like the 'L', but with a quarter circle in the 4-th square.

     'D' - the unit disc.

     'A' - an annulus.

     'H' - a heart-shaped cardioid.

     'B' - the exterior of a "Butterfly".

     'N' - a nested dissection ordering of the square.

  To add other regions, edit toolbox/matlab/demos/numgrid.m.

  See also: DELSQ, DELSQSHOW, DELSQDEMO.


NZMAX

 Amount of storage allocated for nonzeros.

  For a sparse matrix, NZMAX(S) is the number of storage locations

  allocated for the nonzero elements in S.

  For a full matrix, NZMAX(S) is prod(size(S)).

  In both cases, nnz(S) <= nzmax(S) <= prod(size(S)).

  See also NNZ, NONZEROS, SPALLOC.


ODE23

 Solve differential equations, low order method.

  ODE23 integrates a system of ordinary differential equations using

  2nd and 3rd order Runge-Kutta formulas.

  [T,Y] = ODE23('yprime', T0, Tfinal, Y0) integrates the system of

  ordinary differential equations described by the M-file YPRIME.M,

  over the interval T0 to Tfinal, with initial conditions Y0.

  [T, Y] = ODE23(F, T0, Tfinal, Y0, TOL, 1) uses tolerance TOL

  and displays status while the integration proceeds.

  INPUT:

  F     - String containing name of user-supplied problem description.

          Call: yprime = fun(t,y) where F = 'fun'.

          t      - Time (scalar).

          y      - Solution column-vector.

          yprime - Returned derivative column-vector; yprime(i) = dy(i)/dt.

  t0    - Initial value of t.

  tfinal- Final value of t.

  y0    - Initial value column-vector.

  tol   - The desired accuracy. (Default: tol = 1.e-3).

  trace - If nonzero, each step is printed. (Default: trace = 0).

  OUTPUT:

  T  - Returned integration time points (column-vector).

  Y  - Returned solution, one solution column-vector per tout-value.

  The result can be displayed by: plot(tout, yout).

  See also ODE45, ODEDEMO.


ODE23P

 Solve differential equations, low order method, displaying plot.

  Integrate a system of ordinary differential equations using

  2nd and 3rd order Runge-Kutta formulas and plot the time evolution

  of the first three components of the solution.

  [T,Y] = ODE23('yprime', T0, Tfinal, Y0) integrates the system

  of ordinary differential equations described by the M-file

  YPRIME.M over the interval T0 to Tf and using initial

  conditions Y0.

  INPUT:

  F     - String containing name of user-supplied problem description.

          Call: yprime = fun(t,y) where F = 'fun'.

          t      - Time (scalar).

          y      - Solution column-vector.

          yprime - Returned derivative column-vector; yprime(i) = dy(i)/dt.

  t0    - Initial value of t.

  tfinal- Final value of t.

  y0    - Initial value column-vector.

  tol   - The desired accuracy. (Default: tol = 1.e-3).

  In addition, setup the graphics with:

     axis([y1min y1max y2min y2max y3min y3max]);

     hold

  INTERMEDIATE RESULTS:

  A 3-D plot of the orbit of y(1:3) as functions of t.

  FINAL OUTPUT:

  y     - The solution at tfinal.


ODE45

 Solve differential equations, higher order method.

  ODE45 integrates a system of ordinary differential equations using

  4th and 5th order Runge-Kutta formulas.

  [T,Y] = ODE45('yprime', T0, Tfinal, Y0) integrates the system of

  ordinary differential equations described by the M-file YPRIME.M,

  over the interval T0 to Tfinal, with initial conditions Y0.

  [T, Y] = ODE45(F, T0, Tfinal, Y0, TOL, 1) uses tolerance TOL

  and displays status while the integration proceeds.

  INPUT:

  F     - String containing name of user-supplied problem description.

          Call: yprime = fun(t,y) where F = 'fun'.

          t      - Time (scalar).

          y      - Solution column-vector.

          yprime - Returned derivative column-vector; yprime(i) = dy(i)/dt.

  t0    - Initial value of t.

  tfinal- Final value of t.

  y0    - Initial value column-vector.

  tol   - The desired accuracy. (Default: tol = 1.e-6).

  trace - If nonzero, each step is printed. (Default: trace = 0).

  OUTPUT:

  T  - Returned integration time points (column-vector).

  Y  - Returned solution, one solution column-vector per tout-value.

  The result can be displayed by: plot(tout, yout).

  See also ODE23, ODEDEMO.


ODEDEMO

 Demonstrate numerical integration of differential equations.


ONES

 All ones.

  ONES(N) is an N-by-N matrix of ones.

  ONES(M,N) or ONES([M,N]) is an M-by-N matrix of ones.

  ONES(SIZE(A)) is the same size as A and all ones.


ORIENT

 Hardcopy paper orientation.

  ORIENT LANDSCAPE causes subsquent PRINT operations from the current

  figure window to generate output in full-page landscape orientation

  on the paper.

  ORIENT PORTRAIT returns to the default PORTRAIT orientation with

  the figure window occupying a rectangle with aspect ration 4/3 in

  the middle of the page.

  ORIENT TALL causes the figure window to map to the whole page

  in portrait orientation.

  ORIENT, by itself, returns a string containing the current paper

  orientation, either PORTRAIT, LANDSCAPE or TALL.

  ORIENT is an M-file that sets the PaperOrientation and PaperPosition

  properties of the current figure window.

  See also PRINT.


ORTH

 Orthogonalization.

  Q = orth(A) is an orthonormal basis for the range of A.

  Q'*Q = I, the columns of Q span the same space as the columns

  of A and the number of columns of Q is the rank of A.

  See also QR, NULL.


PACK

 Consolidate workspace memory.

  PACK performs memory garbage collection. Extended MATLAB

  sessions may cause memory to become fragmented, preventing

  large variables from being stored. PACK is a command that

  saves all variables on disk, clears the memory, and then

  reloads the variables.

  See also MEMORY.


PAREN

  ( ) Parentheses are used to indicate precedence in arithmetic

       expressions and to enclose arguments of functions in the

       usual way. They are used to enclose subscripts of vectors

       and matrices in a manner somewhat more general than the

       usual way. If X and V are vectors, then X(V) is

       [X(V(1)), X(V(2)), ..., X(V(N))]. The components of V

       are rounded to nearest integers and used as subscripts. An

       error occurs if any such subscript is less than 1 or

       greater than the dimension of X. Some examples:

       X(3) is the third element of X.

       X([1 2 3]) is the first three elements of X. So is

       X([SQRT(2), SQRT(3), 4*ATAN(1)]).

       If X has N components, X(N:-1:1) reverses them.

       The same indirect subscripting is used in matrices. If V

       has M components and W has N components, then A(V,W)

       is the M-by-N matrix formed from the elements of A whose

       subscripts are the elements of V and W. For example...

       A([1,5],:) = A([5,1],:) interchanges rows 1 and 5 of A.

   [ ] Brackets are used in forming vectors and matrices.

       [6.9 9.64 SQRT(-1)] is a vector with three elements

       separated by blanks. [6.9, 9.64, sqrt(-1)] is the same

       thing. [1+I 2-I 3] and [1 +I 2 -I 3] are not the same.

       The first has three elements, the second has five.

       [11 12 13; 21 22 23] is a 2-by-3 matrix. The semicolon

       ends the first row.

       Vectors and matrices can be concatenated with [ ] brackets.

       [A B; C] is allowed if the number of rows of A equals

       the number of rows of B and the number of columns of A

       plus the number of columns of B equals the number of

       columns of C. This rule generalizes in a hopefully

       obvious way to allow fairly complicated constructions.

       A = [ ] stores an empty matrix in A. See CLEAR to remove

       variables from the current workspace.

       For the use of [ and ] on the left of the = in multiple

       assignment statements, see LU, EIG, SVD and so on.

  Copyright (c) 1984-93 by The MathWorks, Inc.


PASCAL

 Pascal matrix.

  PASCAL(N) is the Pascal matrix of order N: a symmetric positive

  definite matrix with integer entries, made up from Pascal's

  triangle.  Its inverse has integer entries.

  PASCAL(N,1) is the lower triangular Cholesky factor (up to signs

  of columns) of the Pascal matrix.  It is involutary (is its own

  inverse).

  PASCAL(N,2) is a transposed and permuted version of PASCAL(N,1)

  which is a cube root of the identity.


PATCH

 Create patch low-level objects.

  PATCH(X,Y,C) adds the "patch" or filled 2-D polygon defined by

  vectors X and Y to the current axes. C specifies the color

  index into the colormap. If it is a scalar, it simply specifies

  the color of the polygon ("flat" coloring). If it is a vector the

  same length as X and Y, it specifies the color of each vertex and

  bilinear interpolation is used to determine the interior color of

  the polygon ("interpolated" coloring).

  If C is a string, the polygon is filled with 'color'.

  'color' can be 'r','g','b','c','m','y', 'w', or 'k'.

  If X, Y, and C are matrices the same size, one patch per column

  is added. In this case, C is a row vector for "flat" polygon

  colors, and C is a matrix for "interpolated" polygon colors.

  PATCH sets its FaceColor property to 'flat', 'interp', or a

  colorspec depending upon the value of the C matrix.

  PATCH(X,Y,Z,C) creates patches in 3-D coordinates.

  PATCH returns a column vector of handles to PATCH objects, one

  handle per patch. PATCHes are children of AXES objects.

  The X,Y,C triple (X,Y,Z,C quad for 3-D) can be followed by

  parameter/value pairs to specify additional properties of the

  patches. The X,Y,Z triple (X,Y,Z quad for 3-D) can be omitted

  entirely, and all properties specified using parameter/value

   pairs.

         Execute GET(H), where H is a patch handle, to see a list of patch

         object properties and their current values. Execute SET(H) to see

         a list of patch object properties and legal property values.

  See also LINE, TEXT, FILL, FILL3.


PATH

 Control MATLAB's directory search path.

  PATH, by itself, prettyprints MATLAB's current search path.

  The search path list originates as the environment variable

  MATLABPATH in the underlying operating system, or is set by

  MATLABRC, and is perhaps individualized by STARTUP.

  P = PATH returns a string containing the path in P.

  PATH(P) changes the path to P.

  PATH(P1,P2) changes the path to the concatenation of the

  two path strings P1 and P2.  Thus PATH(PATH,P) appends

  a new directory to the current path and PATH(P,PATH)

  prepends a new path.

  For example, the following statements add another directory

  to MATLAB's search path on various operating systems:

    Unix: path(P,'/home/myfriend/goodstuff')

    VMS:  path(P,'DISKS1:[MYFRIEND.GOODSTUFF]')

    DOS:  path(P,'TOOLS\GOODSTUFF')

    Mac:  path(P,'Tools:GoodStuff')

  See also GETENV, WHAT, CD, DIR.


PAUSE

 Wait for user response.

  PAUSE causes a procedure to stop and wait for the user to

  strike any key before continuing.

  PAUSE(n) pauses for n seconds before continuing.

  PAUSE OFF indicates that any subsequent PAUSE or PAUSE(n)

  commands should not actually pause.  This allows normally

  interactive scripts to run unattended.

  PAUSE ON indicates that subsequent PAUSE commands should pause.


PCOLOR

 Pseudocolor (checkerboard) plot.

  PCOLOR(C) is a pseudocolor plot of matrix C.  The screen is broken

  into a rectangular "checkerboard" the same size as C.  The value of

  each element of C specifies the color in its corresponding rectangle.

  The smallest and largest elements of C are assigned the first and

  last colors given in the color table; colors for the remainder of the

  elements in C are determined by table-lookup within the remainder of

  the color table.

  PCOLOR(X,Y,C), where X and Y are vectors or matrices, makes a

  pseudocolor plot on the grid defined by X and Y.  X and Y could

  define the grid for a "disk", for example.

  PCOLOR is really a SURF with its view set to directly above.

  PCOLOR returns a handle to a SURFACE object.

  See also CAXIS, SURF, MESH, IMAGE.


PEAKS

 A sample function of two variables.

  PEAKS is a function of two variables, obtained by translating and

  scaling Gaussian distributions, which is useful for demonstrating

  MESH, SURF, PCOLOR, CONTOUR, etc.

  There are several variants of the calling sequence:

      Z = PEAKS;

      Z = PEAKS(N);

      Z = PEAKS(V);

      Z = PEAKS(X,Y);

      PEAKS;

      PEAKS(N);

      PEAKS(V);

      PEAKS(X,Y);

      [X,Y,Z] = PEAKS;

      [X,Y,Z] = PEAKS(N);

      [X,Y,Z] = PEAKS(V);

  The first variant produces a 49-by-49 matrix.

  The second variant produces an N-by-N matrix.

  The third variant produces an N-by-N matrix where N = length(V).

  The fourth variant evaluates the function at the given X and Y,

  which must be the same size.  The resulting Z is also that size.

  The next four variants, with no output arguments, do a SURF

  plot of the result.

  The last three variants also produce two matrices, X and Y, for

  use in commands such as PCOLOR(X,Y,Z) or SURF(X,Y,Z,DEL2(Z)).

  If not given as input, the underlying matrices X and Y are

      [X,Y] = MESHGRID(V,V)

  where V is a given vector, or V is a vector of length N with

  elements equally spaced from -3 to 3.  If no input argument is

  given, the default N is 49.


PENNY

 Several views of the penny data.


PI

 3.1415926535897....

  PI = 4*atan(1) = imag(log(-1)) = 3.1415926535897....


PINK

 Pastel shades of pink color map.

  PINK(M) returns an M-by-3 matrix containing a "pink" colormap.

  PINK, by itself, is the same length as the current colormap.

  For example, to reset the colormap of the current figure:

            colormap(pink)

  See also HSV, GRAY, HOT, COOL, BONE, COPPER, FLAG,

  COLORMAP, RGBPLOT.


PINV

 Pseudoinverse.

  X = PINV(A) produces a matrix X of the same dimensions

  as A' so that A*X*A = A, X*A*X = X and AX and XA

  are Hermitian. The computation is based on SVD(A) and any

  singular values less than a tolerance are treated as zero.

  The default tolerance is MAX(SIZE(A)) * NORM(A) * EPS.

  This tolerance may be overridden with X = PINV(A,tol).

  See also RANK.


PLANEROT

 Generate a Givens plane rotation.

  [G,Y] = PLANEROT(X), where X is a 2-component column vector,

  returns a 2-by-2 orthogonal matrix G so that Y = G*X has Y(2) = 0.

  See also QRINSERT, QRDELETE.


PLOT

 Plot vectors or matrices.

  PLOT(X,Y) plots vector X versus vector Y. If X or Y is a matrix,

  then the vector is plotted versus the rows or columns of the matrix,

  whichever line up.

  PLOT(Y) plots the columns of Y versus their index.

  If Y is complex, PLOT(Y) is equivalent to PLOT(real(Y),imag(Y)).

  In all other uses of PLOT, the imaginary part is ignored.

  Various line types, plot symbols and colors may be obtained with

  PLOT(X,Y,S) where S is a 1, 2 or 3 character string made from

  the following characters:

         y     yellow        .     point

         m     magenta       o     circle

         c     cyan          x     x-mark

         r     red           +     plus

         g     green         -     solid

         b     blue          *     star

         w     white         :     dotted

         k     black         -.    dashdot

                             --    dashed

  For example, PLOT(X,Y,'c+') plots a cyan plus at each data point.

  PLOT(X1,Y1,S1,X2,Y2,S2,X3,Y3,S3,...) combines the plots defined by

  the (X,Y,S) triples, where the X's and Y's are vectors or matrices

  and the S's are strings.

  For example, PLOT(X,Y,'y-',X,Y,'go') plots the data twice, with a

  solid yellow line interpolating green circles at the data points.

  The PLOT command, if no color is specified, makes automatic use of

  the colors in the above table.  The default is yellow for one line,

  and for multiple lines, to cycle through the first six colors

  in the table.

  PLOT returns a column vector of handles to LINE objects, one

  handle per line.

  The X,Y pairs, or X,Y,S triples, can be followed by

  parameter/value pairs to specify additional properties

  of the lines.

  See also SEMILOGX, SEMILOGY, LOGLOG, GRID, CLF, CLC, TITLE,

  XLABEL, YLABEL, AXIS, AXES, HOLD, and SUBPLOT.


PLOT3

 Plot lines and points in 3-D space.

  PLOT3() is a three-dimensional analogue of PLOT().

  PLOT3(x,y,z), where x, y and z are three vectors of the same length,

  plots a line in 3-space through the points whose coordinates are the

  elements of x, y and z.

  PLOT3(X,Y,Z), where X, Y and Z are three matrices of the same size,

  plots several lines obtained from the columns of X, Y and Z.

  Various line types, plot symbols and colors may be obtained with

  PLOT3(X,Y,Z,s) where s is a 1, 2 or 3 character string made from

  the characters listed under the PLOT command.

  PLOT3(x1,y1,z1,s1,x2,y2,z2,s2,x3,y3,z3,s3,...) combines the plots

  defined by the (x,y,z,s) fourtuples, where the x's, y's and z's are

  vectors or matrices and the s's are strings.

  Example: A helix:

      t = 0:pi/50:10*pi;

      plot3(sin(t),cos(t),t);

  PLOT3 returns a column vector of handles to LINE objects, one

  handle per line. The X,Y,Z triples, or X,Y,Z,S quads, can be

  followed by parameter/value pairs to specify additional

  properties of the lines.

  See also PLOT, LINE, AXIS, VIEW, MESH, SURF.


POL2CART

 Transform polar coordinates to Cartesian.

  [X,Y] = POL2CART(TH,R) transforms data stored in polar

  coordinates to Cartesian coordinates. If [M,N] = SIZE(TH), then

  R must be also be the same size. TH must be in radians.

         [X,Y,Z] = POL2CART(TH,R,Z) transforms data stored in cylindrical

         coordinates to Cartesian coordinates. If [M,N] = SIZE(TH), then

         R and Z must be the same size.

  See also CART2SPH, CART2POL, SPH2CART.


POLAR

 Polar coordinate plot.

  POLAR(THETA, RHO) makes a plot using polar coordinates of

  the angle THETA, in radians, versus the radius RHO.

  POLAR(THETA,RHO,S) uses the linestyle specified in string S.

  See PLOT for a description of legal linestyles.

  See also PLOT, LOGLOG, SEMILOGX, SEMILOGY.


POLY

 Characteristic polynomial.

  If A is an N by N matrix, POLY(A) is a row vector with

  N+1 elements which are the coefficients of the

  characteristic polynomial, DET(lambda*EYE(A) - A) .

  If V is a vector, POLY(V) is a vector whose elements are

  the coefficients of the polynomial whose roots are the

  elements of V . For vectors, ROOTS and POLY are inverse

  functions of each other, up to ordering, scaling, and

  roundoff error.

  ROOTS(POLY(1:20)) generates Wilkinson's famous example.

  See also ROOTS, POLYVAL.


POLYDER

 Polynomial derivative.

  POLYDER(P) returns the derivative of the polynomial whose

  coefficients are the elements of vector P.

  POLYDER(A,B) returns the derivative of polynomial A*B.

  [Q,D] = POLYDER(B,A) returns the derivative of the

  polynomial ratio B/A, represented as Q/D.


POLYFIT

 Polynomial curve fitting.

  POLYFIT(x,y,n) finds the coefficients of a polynomial

  p(x) of degree n that fits the data, p(x(i)) ~= y(i),

  in a least-squares sense.

  See also POLY, POLYVAL, ROOTS.


POLYLINE

 Basic line drawing primitive.

         POLYLINE is obsolete, but provided for upward compatibility from

         MATLAB 3.5.

  POLYLINE(X,Y) draws the polyline whose X- and Y-coordinates

  are in vectors X and Y.

  POLYLINE(X,Y,'type') draws the line with the style and color

  indicated by the text string.  See PLOT for a list of

  style and color attributes.

  POLYLINE(X,Y,'sc') interprets X and Y in screen-coordinates

  where (0.0,0.0) is the lower-left corner of the screen and

  (1.0,1.0) is the upper-right corner.  Otherwise, data-

  coordinates are used.


POLYMARK

 Basic marker drawing primitive.

         POLYMARK is obsolete, but provided for upward compatibility from

         MATLAB 3.5.

  POLYMARK(X,Y) draws polymarkers at the X- and Y-coordinates

  in vectors X and Y.

  POLYMARK(X,Y,'type') uses the marker style and color

  indicated by the text string.  See PLOT for a list of

  style and color attributes.

  POLYMARK(X,Y,'sc') interprets X and Y in screen-coordinates

  where (0.0,0.0) is the lower-left corner of the screen and

  (1.0,1.0) is the upper-right corner.  Otherwise, data-

  coordinates are used.


POLYVAL

 Polynomial evaluation.

  If V is a vector whose elements are the coefficients of a

  polynomial, then POLYVAL(V,s) is the value of the

  polynomial evaluated at s.  If S is a matrix or vector,

  the polynomial is evaluated at all points in S.

  See POLYVALM for evaluation in a matrix sense.


POLYVALM

 Matrix polynomial evaluation.

  If  V  is a vector whose elements are the coefficients of a

  polynomial,  then   POLYVALM(V,X)   is  the   value  of  the

  polynomial evaluated with matrix argument X.  See POLYVAL

  for polynomial evaluation in the regular or array sense.


POW2

 Scale floating point numbers.  IEEE scalbn().

  x = pow2(y) computes 2 to the power y.

  x = pow2(f,e) for a real matrix f and a matrix of integers e

  computes x = f .* (2 .^ e).  The result is computed quickly

  by simply adding e to the floating point exponent of f.

  This corresponds to the ANSI C function ldexp() and the IEEE

  floating point standard function scalbn().

  See also LOG2, REALMAX, REALMIN.


PPVAL

 Evaluate piecewise polynomial.

    v = ppval(pp,xx)

  returns the value of the pp function  pp  at  xx.

  See also MKPP, UNMKPP, SPLINE.


PRINT

 Print graph or save graph to file.

         PRINT <filename> saves the current Figure window as PostScript

         or a printer specific format, as specified by PRINTOPT. If

         a filename is specified, the output is written to the designated file,

         overwriting it if it already exists. If the specified filename does not

         include an extension, an appropriate one is appended.

         If the filename is omitted, the Figure is sent directly to the

         printer as specified in PRINTOPT.

         PRINT <filename> -f<system name> prints the specified SIMULINK

  system.

         Syntax: PRINT [ -ddevice] [ -options ] <filename>

         Available Windows device options are:

            -dwin    - Send figure to currently installed printer in monochrome

            -dwinc   - Send figure to currently installed printer in color

            -dmeta   - Send figure to clipboard in Metafile format

            -dbitmap - Send figure to clipboard in bitmap format

            -dsetup  - Bring up Print Setup dialog box, but do not print

         Other Windows options are:

            -v       - Verbose mode, bring up the Print dialog box

                       which is normally suppressed.

         Available Postscript devices are:

            -dps    - PostScript for black and white printers

            -dpsc   - PostScript for color printers

            -dps2   - Level 2 PostScript for black and white printers

            -dpsc2  - Level 2 PostScript for color printers

            -deps   - Encapsulated PostScript (EPSF)

            -depsc  - Encapsulated Color PostScript (EPSF)

            -deps2  - Encapsulated Level 2 PostScript (EPSF)

            -depsc2 - Encapsulated Level 2 Color PostScript (EPSF)

         Additional GhostScript devices are:

            -dlaserjet - HP LaserJet

            -dljetplus - HP LaserJet+

            -dljet2p   - HP LaserJet IIP

            -dljet3    - HP LaserJet III

            -dcdeskjet - HP DeskJet 500C with 1 bit/pixel color

            -dcdjcolor - HP DeskJet 500C with 24 bit/pixel color and

                             high-quality color (Floyd-Steinberg) dithering

            -dcdjmono  - HP DeskJet 500C printing black only

            -ddeskjet  - HP DeskJet and DeskJet Plus

            -dpaintjet - HP PaintJet color printer

            -dpjetxl   - HP PaintJet XL color printer

            -dbj10e    - Canon BubbleJet BJ10e

            -dln03     - DEC LN03 printer

            -depson    - Epson-compatible dot matrix printers (9- or 24-pin)

            -deps9high - Epson-compatible 9-pin, interleaved lines

                            (triple resolution)

            -depsonc   - Epson LQ-2550 and Fujitsu 3400/2400/1200 color printers

            -dgif8     - 8-bit color GIF file format

            -dpcx16    - Older color PCX file format (EGA/VGA, 16-color)

            -dpcx256   - Newer color PCX file format (256-color)

         Other options are:

            -append   - Append the graph to file, rather than overwriting

            -epsi     - Add 1-bit deep bitmap preview (EPSI format)

            -Pprinter - Specfiy the printer to use

            -fhandle  - Handle Graphics handle of figure to print

            -fname    - Name of SIMULINK system window to print

         See also PRINTOPT, ORIENT.


PRINTOPT

 Configure local printer defaults.

  PRINTOPT is an M-file that you or your system manager can

  edit to indicate your default printer type and destination.

  [PCMD,DEV] = PRINTOPT returns two strings, PCMD and DEV.

  PCMD is a string containing the print command that PRINT

  uses to spool a file to the printer. Its default is:

     Unix:      lpr -r

     Windows:   PRINT

     Macintosh: unused

     VMS:       PRINT/DELETE

     SGI:       lp

  DEV is a string containing the default device option for

  the PRINT command. Its default is:

     Unix & VMS: -dps

     Windows:    -dwin

     Macintosh:  -dmac

  See also PRINT.


PRISM

 Colormap of prism colors.

  PRISM(M) returns an M-by-3 matrix containing repeated use

  of six colors: red, orange, yellow, green, blue, violet.

  The default value of M is the length of the current colormap.

  PRISM, with no input or output arguments, changes the colors

  of any line objects in the current axes to the prism colors.

  This is particularly useful with a CONTOUR plot, eg.

      contour(data,20)

      prism

  The colors in the PRISM map are also present, in the same order,

  in the HSV map.  However, PRISM uses repeated copies of its six

  colors, whereas HSV varies its colors smoothly.

  See also HSV, FLAG, HOT, COOL, COLORMAP, RGBPLOT, CONTOUR.


PROD

 Product of the elements.

  For vectors, PROD(X) is the product of the elements of X.

  For matrices, PROD(X) is a row vector with the product over

  each column.

  See also SUM, CUMPROD, CUMSUM.


PUNCT

  .   Decimal point. 325/100, 3.25 and .325e1 are all the same.

   .   Array operations.  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).

   ..  Parent directory.  See CD or CHDIR.

   ... Continuation.  Three or more decimal points at the end of

       a line causes the following line to be a continuation.

   ,   Comma.  The comma is used to separate matrix subscripts

       and arguments to functions.  It is also used to separate

       statements in multi-statement lines. In this situation,

       it may be replaced by a semicolon to suppress printing.

   ;   Semicolon.  The semicolon is used inside brackets to indicate

       the ends of the rows of a matrix.  It is also used after an

       expression or statement to suppress printing.

   %   Percent.  The percent symbol is used to begin comments.

       Logically, it serves as an end-of-line character.  Any

       following text on the line is ignored or printed by the

       HELP system.

   !   Exclamation point.  Any text following the '!' is issued

       as a command to the underlying computer operating system.

       (not available on Macintosh).

   '   Transpose.   X' is the complex conjugate transpose of X.

       X.' is the non-conjugate transpose.

   '   Quote. 'ANY TEXT' is a vector whose components are the

       ASCII codes for the characters. A quote within the text

       is indicated by two quotes.  For example: 'Don''t forget.'

   =   Assignment.  B = A stores the elements of A in B.

       See also RELOP.


PUZZLE

 Mathematical riddles and MATLAB puzzles.

  puzzle(n) is the n-th puzzle.

  puzzle with no arguments picks a random one.

  All the answers can be obtained with MATLAB commands

  and functions, but we hope some are a challenge to find.

  See also HINT.


PWD

 Show current working directory.


QR

 Orthogonal-triangular decomposition.

  [Q,R] = QR(X) produces an upper triangular matrix R of

  the same dimension as X and a unitary matrix Q so that

  X = Q*R.

  [Q,R,E] = QR(X) produces a permutation matrix E , an

  upper triangular R with decreasing diagonal elements and

  a unitary Q so that X*E = Q*R.

  By itself, QR(X) returns the output of LINPACK'S ZQRDC

  routine.  TRIU(QR(X)) is R.

  See also QRDELETE, QRINSERT.


QRDELETE

 Delete a column from the QR factorization.

  If [Q,R] = qr(A) is the original QR factorization of A,

  then [Q,R] = qrdelete(Q,R,j) changes Q and R to be the

  factorization of the matrix with A(:,j) removed.

  See also QR, QRINSERT, PLANEROT.


QRINSERT

 Insert a column in the QR factorization.

  If [Q,R] = qr(A) is the original QR factorization of A,

  then [Q,R] = qrinsert(Q,R,j,x) changes Q and R to be the

  factorization of the matrix obtained by inserting an extra

  column, x, before A(:,j).  (If A has n columns and j = n+1,

  then x is inserted after the last column of A.)

  See also QR, QRDELETE, PLANEROT.


QUAD

 Numerical evaluation of an integral, low order method.

  Q = QUAD('f',a,b) approximates the integral of f(x) from a to b

  to within a relative error of 1e-3.  'f' is a string

  containing the name of the function.  Function f must return a

  vector of output values if given a vector of input values.

  Q = QUAD(F,a,b,tol) integrates to a relative error of tol.

  Q = Inf is returned if an excessive recursion level is reached,

  indicating a possibly singular integral.

  Q = QUAD(F,a,b,tol,trace) integrates to a relative error of tol and

  traces the function evaluations with a point plot of the integrand.

  QUAD uses an adaptive recursive Simpson's rule.

  See also QUAD8.


QUAD8

 Numerical evaluation of an integral, higher order method.

  Q = QUAD8('f',a,b) approximates the integral of f(x) from a

  to b to within a relative error of 1e-3.  'f' is a string

  containing the name of the function.  The function must return

  a vector of output values if given a vector of input values.

  Q = QUAD8(F,a,b,tol) integrates to a relative error of tol.

  Q = Inf is returned if an excessive recursion level is reached,

  indicating a possibly singular integral.

  Q = QUAD8(F,a,b,tol,trace) integrates to a relative error of tol and

  traces the function evaluations with a point plot of the integrand.

  QUAD8 uses an adaptive recursive Newton Cotes 8 panel rule.  See

  also QUAD.


QUAD8STP

 Recursive function used by QUAD8.

  [Q,cnt] = quad8stp(F,a,b,tol,lev,w,f,Q0) tries to approximate

  the integral of f(x) from a to b to within a relative error of tol.

  F is a string containing the name of f.  The remaining arguments are

  generated by quad8 or by the recursion.  lev is the recursion level.

  w is the weights in the 8 panel Newton Cotes formula.

  x0 is a vector of 9 equally spaced abscissa is the interval.

  f0 is a vector of the 9 function values at x.

  Q0 is an approximate value of the integral.

  See also QUAD8 and QUAD.


QUADDEMO

 Demonstrate adaptive numerical quadrature.


QUADSTP

 Recursive function used by QUAD.

  [Q,cnt] = quadstp(F,a,b,tol,lev,fa,fc,fb,Q0) tries to

  approximate the integral of f(x) from a to b to within a

  relative error of tol.  F is a string containing the name

  of f.  The remaining arguments are generated by quad or by

  the recursion.  lev is the recursion level.

  fa = f(a). fc = f((a+b)/2). fb = f(b).

  Q0 is an approximate value of the integral.

  See also QUAD and QUAD8.


QUAKE

 Loma Prieta Earthquake.


QUIT

 Terminate MATLAB.

  QUIT terminates MATLAB.


QUIVER

 Quiver plot.

  QUIVER(X,Y,DX,DY) draws little arrows at every (X,Y) pair in

  matrices X and Y. The (DX,DY) pairs in matrices DX and DY

  determine the direction and magnitude of the arrows.

  QUIVER(x,y,DX,DY), with two vector arguments replacing the first

  two matrix arguments, must have length(x) = n and

  length(y) = m where [m,n] = size(DX) = size(DY).  In this case, the

  arrows are the quads (x(j), y(i), DX(i,j), DY(i,j)).

  Note that x corresponds to the columns of DX and DY and y corresponds

  to the rows.

  QUIVER(DX,DY) uses x = 1:n and y = 1:m. In this case DX and DY

  are defined over a geometrically rectangular grid.

  QUIVER(X,Y,DX,DY,S) and QUIVER(DX,DY,S) apply scalar S as a scale

  factor to the lengths of the arrow. For example, S = 2 doubles

  their relative length and S = 0.5 halves them.

  A final trailing string argument specifies linetype and color using

  any legal line specification as described under the plot command.

  For example, try

     xord = -2:.2:2;

     yord = -2:.2:2;

     [x,y] = meshgrid(xord,yord);

     z = x .* exp(-x.^2 - y.^2);

     [px,py] = gradient(z,.2,.2);

     contour(x,y,z),hold on, quiver(x,y,px,py), hold off

  See also GRADIENT, COMPASS, FEATHER, ROSE.


QZ

 Generalized eigenvalues.

  [AA, BB, Q, Z, V] = QZ(A,B) for square matrices A and B,

  produces upper triangular matrices AA and BB, matrices Q

  and Z containing the products of the left and right trans-

  formations, such that Q*A*Z = AA, and Q*B*Z = BB, and the

  generalized eigenvector matrix V.

  The alphas and betas comprising the generalized eigenvalues

  are the diagonal elements of AA and BB so that

  A*V*diag(BB) = B*V*diag(AA).


RAND

 Uniformly distributed random numbers and matrices.

  RAND(N) is an N-by-N matrix with random entries, ordinarily

  chosen from a uniform distribution on the interval (0.0,1.0).

  RAND(M,N) or RAND([M,N]) is an M-by-N matrix with random entries.

  RAND(SIZE(A)) is the same size as A.

  RAND with no arguments is a scalar whose value changes each time

  it is referenced.

  RAND('seed') returns the current seed of the uniform generator.

  RAND('seed',s) sets the uniform generator seed to s.

  RAND('seed',0) resets the seed its startup value.

  RAND('seed',sum(100*clock)) sets it to a different value each time.

  By default, RAND samples a uniform distribution.  The function

  RANDN generates normally distributed random matrices.

  RAND and RANDN have separate generators, each with its own seed.

  Previous versions of MATLAB allowed RAND('normal') to switch

  the prevailing distribution to normal, RAND('uniform') to switch

  back to uniform distribution, and RAND('dist') to return a string

  containing the prevailing distribution, either 'uniform' or 'normal'.

  MATLAB Version 4.0 continues to allow this switch, but

  issues a warning message discouraging its use.

  See also RANDN, SPRANDN.


RANDN

 Normally distributed random numbers and matrices.

  RANDN(N) is an N-by-N matrix with random entries, chosen

  from a normal distribution with mean 0.0 and variance 1.0.

  RANDN(M,N) or RANDN([M,N]) is an M-by-N matrix with random entries.

  RANDN(SIZE(A)) is the same size as A.

  RANDN with no arguments is a scalar whose value changes each time

  it is referenced.

  RANDN('seed') returns the current seed of the normal generator.

  RANDN('seed',s) sets the normal generator seed to s.

  RANDN('seed',0) resets the seed its startup value.

  RANDN('seed',sum(100*clock)) sets it to a different value each time.

  RANDN and RAND have separate generators, each with its own seed.

  See also RAND, SPRANDN.


RANDPERM

 Random permutation vector.

  RANDPERM(n) is a random permutation of the integers from 1 to n.

  For example, RANDPERM(6) might be [2 4 5 6 1 3].

  Note that RANDPERM calls RAND and therefore changes RAND's

  seed value.


RANK

 Number of linearly independent rows or columns.

  K = RANK(X) is the number of singular values of X

  that are larger than MAX(SIZE(X)) * NORM(X) * EPS.

  K = RANK(X,tol) is the number of singular values of X that

  are larger than tol.


RAT

 Rational approximation.

  [N,D] = RAT(X,tol) returns two integer matrices so that N./D

  is close to X in the sense that abs(N./D - X) <= tol*abs(X).

  The rational approximations are generated by truncating continued

  fraction expansions.   tol = 1.e-6*norm(X(:),1) is the default.

  RAT(X) or RAT(X,tol) displays the continued fraction representation.

  The same algorithm, with the default tol, is used internally

  by MATLAB for FORMAT RAT.

  See also FORMAT, RATS.


RATS

 Rational output.

  RATS(X,LENS) uses RAT to display rational approximations to

  the elements of X.  The string length for each element is LENS.

  The default is LENS = 13, which allows 6 elements in 78 spaces.

  Asterisks are used for elements which can't be printed in the

  alloted space, but which are not negligible compared to the other

  elements in X.

  The same algorithm, with the default LENS, is used internally

  by MATLAB for FORMAT RAT.

  See also FORMAT, RAT.


RBBOX

 Rubberband box.

  RECTF = RBBOX(RECTI, XY) tracks a rubberband box in the current

  figure, initialized with box RECTI, and starting the tracking at

  the point XY.  The mouse button must be help down when RBBOX is

  called.  RBBOX returns with the mouse up button event.  As a

  result, RBBOX can be used in an M-file, along with

  WAITFORBUTTONPRESS, to control dynamic behavior.

  RECTF is the rect specified by the initial point of RECTI and its

  extent is determined by where the mouse up event occurs.

  RECTI, XY, RECTF are in units of the current figure.


RCOND

 LINPACK reciprocal condition estimator.

  RCOND(X) is an estimate for the reciprocal of the

  condition of X in the 1-norm obtained by the LINPACK

  condition estimator. If X is well conditioned, RCOND(X)

  is near 1.0. If X is badly conditioned, RCOND(X) is

  near 0.0.

  See also COND, NORM, CONDEST, NORMEST.


README

  README file for MATLAB

   6 March 1993

   New MATLAB M-files.

   Here are some M-files that are NOT described in the Reference

   and User's Guides because they were added after printing:

   General MATLAB commands.

    cedit      - Set command line edit/recall facility parameters.

    ls         - Directory listing.

    pwd        - Show current working directory.

    subscribe  - Become a subscribing MATLAB user.

    whatsnew   - Display toolbox README files.

    version    - MATLAB version.

    lasterr    - Last error message.

   Special matrices.

    gallery    - A couple of small test matrices.

    pascal     - Pascal matrix.

   Special functions.

    gcd        - Greatest common divisor.

    lcm        - Least common multiple.

    cart2pol   - Transform Cartesian coordinates to polar.

    cart2sph   - Transform Cartesian coordinates to spherical.

    pol2cart   - Transform polar coordinates to Cartesian.

    sph2cart   - Transform Cartesian coordinates to spherical.

   Matrix functions.

    qrdelete   - Delete a column from the QR factorization.

    qrinsert   - Insert a column in the QR factorization.

   Data functions.

    gradient   - Approximate gradient.

    subspace   - Angle between two subspaces.

   Polynomial functions.

    polyder    - Polynomial derivative.

   Function functions.

    ode23p     - Solve differential equations, displaying plot.

   2-D graphics.

    comet      - Comet plot.

    stem       - Plot discrete sequence data.

   3-D graphics.

    comet3     - 3-D Comet plot.

    slice      - Volumetric slice plot.

    waterfall  - Waterfall plot.

   General purpose graphics.

    imagesc    - Scale data and display as image.

    ishold     - Return 1 if hold is on.

    newplot    - Graphics M-file preamble to handle the NextPlot property.

    whitebg    - Set default figure background color to white.

    graymon    - Set default figure properties for gray-scale monitor.

   Low-level file I/O functions.

    feof       - Test for end-of-file.

    fgetl      - Return the next line of the file as a string, without newline.

    fgets      - Return the next line of the file as a string, with newline.

    frewind    - Rewind an open file.

   Use HELP on these files or TYPE them for more information.


REAL

 Complex real part.

  REAL(X) is the real part of X.

  See also IMAG, CONJ, ANGLE, ABS.


REALMAX

 Largest positive floating point number.

  x = realmax is the largest floating point number representable

  on this computer.  Anything larger overflows.

  See also EPS, REALMIN, POW2.


REALMIN

 Smallest positive floating point number.

  x = realmin is the smallest positive normalized floating point

  number on this computer.  Anything smaller underflows or is

  an IEEE "denormal".

  See also EPS, REALMAX, POW2.


RELOP

  < > Relational operators.

       The six relational operators are <, <=, >, >=, ==, and ~=.

       A < B does element by element comparisons between A and B

       and returns a matrix of the same size with elements set to one

       where the relation is true and elements set to zero where it is

       not.  A and B must have the same dimensions unless one is a

       scalar. A scalar can be compared with anything.

   &   Logical AND.

       A & B is a matrix whose elements are 1's where both A and B

       have non-zero elements, and 0's where either has a zero element.

       A and B must have the same dimensions unless one is a scalar.

       A scalar can be operate with anything.

   |   Logical OR.

       A | B is a matrix whose elements are 1's where either A or B

       has a non-zero element, and 0's where both have zero elements.

       A and B must have the same dimensions unless one is a scalar.

       A scalar can be operate with anything.

   ~   Logical complement (NOT).

       ~A is a matrix whose elements are 1's where A has zero

       elements, and 0's where A has non-zero elements.

   xor Exclusive OR.

       xor(A,B) is 1 where either A or B, but not both, is non-zero.

  See also XOR.

  Copyright (c) 1984-93 by The MathWorks, Inc.


REM

 Remainder after division.

  The remainder REM(x,y) is x - n.*y where n = fix(x./y)

  is the integer part of the elementwise quotient x./y .


RESET

 Reset axis or figure.

  RESET(H) resets all properties, except position, of the object

  with handle H to their default values.  For example,

  RESET(GCA) resets the properties of the current axis.

  RESET(GCF) resets the properties of the current figure.

  See also CLF, CLA, HOLD.


RESHAPE

 Change size.

  RESHAPE(X,M,N) returns the M-by-N matrix whose elements

  are taken columnwise from X.  An error results if X does

  not have M*N elements.


RESI2

 Residue of a repeated pole.

  RESI2(U,V,POLE,N,K) returns the residue of a repeated pole

  of order N and the K-th power denominator of [1 -pole], where

  U and V represent the original polynomial ratio U/V.

  For example, if P is a pole of multiplicity 2,

  then this routine should be called twice with N = 2,

  first using K = 1, then K = 2.  If K is not provided,

  it defaults to N.  If N is not provided, it defaults to 1.

  See also RESIDUE, POLYDER


RESIDUE

 Partial-fraction expansion or residue computation.

  [R,P,K] = RESIDUE(B,A) finds the residues, poles and direct term of

  a partial fraction expansion of the ratio of two polynomials,

  B(s) and A(s).  If there are no multiple roots,

     B(s)       R(1)       R(2)             R(n)

     ----  =  -------- + -------- + ... + -------- + K(s)

     A(s)     s - P(1)   s - P(2)         s - P(n)

  Vectors B and A specify the coefficients of the polynomials in

  descending powers of s.  The residues are returned in the column

  vector R, the pole locations in column vector P, and the direct

  terms in row vector K.  The number of poles is

     n = length(A)-1 = length(R) = length(P)

  The direct term coefficient vector is empty if length(B) < length(A);

  otherwise

     length(K) = length(B)-length(A)+1

  If P(j) = ... = P(j+m-1) is a pole of multplicity m, then the

  expansion includes terms of the form

               R(j)        R(j+1)                R(j+m-1)

 	           -------- + ------------   + ... + ------------

             s - P(j)   (s - P(j))^2           (s - P(j))^m

  [B,A] = RESIDUE(R,P,K), with 3 input arguments and 2 output arguments,

  converts the partial fraction expansion back to the polynomials with

  coefficients in B and A.

  Warning:

  Numerically, the partial fraction expansion of a ratio of polynomials

  represents an ill-posed problem.  If the denominator polynomial, A(s),

  is near a polynomial with multiple roots, then small changes in the

  data, including roundoff errors, can make arbitrarily large changes

  in the resulting poles and residues.  Problem formulations making use

  of state-space or zero-pole representations are preferable.


RETURN

 Return to invoking function.

  RETURN causes a return to the invoking function or to the keyboard.


RGB2HSV

 Red-green-blue to hue-saturation-value conversion.

  H = RGB2HSV(M) converts an RGB color map to an HSV color map.

  Each map is a matrix with any number of rows, exactly three columns,

  and elements in the interval 0 to 1.  The columns of the input matrix,

  M, represent intensity of red, blue and green, respectively.  The

  columns of the resulting output matrix, H, represent hue, saturation

  and color value, respectively.

  See also HSV2RGB, COLORMAP, RGBPLOT.


RGBPLOT

 Plot color map.

  RGBPLOT(MAP) plots a color map, i.e. an m-by-3 matrix which

  is appropriate input for COLORMAP. The three columns of the

  colormap matrix are plotted in red, green, and blue lines.

  See also COLORMAP, RGB2HSV.


RJR

 Random Jacobi Rotation.

  B = RJR(A) applies a random symmetry and condition

  preserving Jacobi rotation.


ROOTS

 Find polynomial roots.

  ROOTS(C) computes the roots of the polynomial whose coefficients

  are the elements of the vector C. If C has N+1 components,

  the polynomial is C(1)*X^N + ... + C(N)*X + C(N+1).

  See also POLY.


ROSE

 Plot rose or angle histogram.

  ROSE(THETA) plots the angle histogram for the angles in THETA.

  The angles in the vector THETA must be specified in radians.

  ROSE(THETA,N) where N is a scalar, uses N equally spaced bins

  from 0 to 2*PI.  The default value for N is 20.

  ROSE(THETA,X) where X is a vector, draws the histogram using the

  bins specified in X.

  [T,R] = ROSE(...) returns the vectors T and R such that

  POLAR(T,R) is the histogram.  No plot is drawn.


ROSSER

 A classic symmetric eigenvalue test problem.

  This matrix was a challenge for many matrix eigenvalue algorithms.

  But the Francis QR algorithm, as perfected by Wilkinson and

  implemented in EISPACK and MATLAB has no trouble with it.

  The matrix is 8-by-8 with integer elements.

  It has:

      * A double eigenvalue.

      * Three nearly equal eigenvalues.

      * Dominant eigenvalues of opposite sign.

      * A zero eigenvalue.

      * A small, nonzero eigenvalue.


ROT90

 Rotate matrix 90 degrees.

  rot90(A) is the 90 degree rotation of m x n matrix A.

  rot90(A,k) is the k*90 degree rotation of A, k = +-1,+-2,...

  For example,

        A = [1 2 3      B = rot90(A) = [ 3 6

             4 5 6 ]                     2 5

                                         1 4 ]

  mesh(B) then shows a 90 degree counter-clockwise rotation

  of mesh(A).

  See also VIEW, FLIPUD, FLIPLR.


ROUND

 Round towards nearest integer.

  ROUND(X) rounds the elements of X to the nearest integers.

  See also FLOOR, CEIL, FIX.


RREF

 Reduced row echelon form.

  R = RREF(A) produces the reduced row echelon form of A.

  [R,jb] = RREF(A) also returns a vector, jb, so that:

      r = length(jb) is this algorithm's idea of the rank of A,

      x(jb) are the bound variables in a linear system, Ax = b,

      A(:,jb) is a basis for the range of A,

      R(1:r,jb) is the r-by-r identity matrix.

  [R,jb] = RREF(A,TOL) uses the given tolerance in the rank tests.

  See also RREFMOVIE, RANK, ORTH, NULL, QR, SVD.


RREFMOVIE

 Movie of the computation of the reduced row echelon form.

  RREFMOVIE(A) produces the reduced row echelon form of A.

  RREFMOVIE, by itself, supplies its own 8-by-6 matrix with rank 4.

  RREFMOVIE(A,tol) uses the given tolerance in the rank tests.


RSF2CSF

 Real block diagonal form to complex diagonal form.

  [U,T] = RSF2CSF(U,T) converts a real, upper quasi-triangular

  Schur form to a complex, upper triangular Schur form.


SAVE

 Save workspace variables on disk.

  SAVE fname saves all workspace variables to the binary "MAT-file"

  named fname.mat. The data may be retrieved with LOAD. Omitting the

  filename causes SAVE to use the default filename "matlab.mat".

  SAVE fname X  saves only X.

  SAVE fname X Y Z  saves X, Y, and Z.

  SAVE fname X Y Z  -ascii  uses 8-digit ASCII form instead of binary.

  SAVE fname X Y Z  -ascii -double  uses 16-digit ASCII form.

  SAVE fname X Y Z  -ascii -double -tabs  delimits with tabs.

  If fname is "stdio", SAVE sends the data to standard output.

  The binary formats used in MAT-files depend upon the size and type of

  each matrix.  Small matrices and matrices with any noninteger entries

  are saved in floating point format requiring 8 bytes per real element.

  Large, integer matrices may be saved in compact formats requiring

  only 1, 2 or 4 bytes per element.  See the External Interface Library

  for more details, including C and Fortran routines to read and write

  MAT-files from external programs.

  See also LOAD, DIARY, FWRITE, FPRINTF, IMWRITE.


SAVEWAVE

 Saves Microsoft Windows 3.1 .WAV format sound files.

     SAVEWAVE(wavefile,y,Fs) saves a .WAV format file specified by "wavefile".

     The input arguments for SAVEWAVE are as follows:

         wavefile    A string containing the name of the .WAV file to create

         y           The sampled data to save (8 bit max)

         Fs          The rate at which the data was sampled

     Note: SAVEWAVE will create an 8-bit, simgle channel wave file. Non 8-bit

     sample data will be truncated.

     See also, LOADWAVE .


SAXIS

 Sound axis scaling.

  The SOUND function ordinarily scales its input vector Y so that the

  maximum and minimum values in Y correspond to the maximum and

  minimum input ranges allowed by the sound hardware.

  SAXIS(V), where V is the two element vector V = [SMIN SMAX], disables

  SOUND's automatic scaling and sets the scaling so that SMIN and SMAX

  correspond to the minimum and input maximum ranges allowed by the

  sound hardware. Values outside this range are clipped.

  SAXIS('auto') sets sound axis scaling back to automatic.

  SAXIS, by itself, returns the two element row vector containing the

  [SMIN SMAX] currently in effect.

  SAXIS is entirely analogous to CAXIS and AXIS, only its scaling applies

  to sounds rather than graphical limits.

  See also SOUND, CAXIS, AXIS.


SC2DC

 Figure-coordinate to data-coordinate conversion.

         SC2DC is obsolete, but provided for upward compatibility from

         MATLAB 3.5.

  [Xd,Yd] = SC2DC(Xs,Ys) converts vectors or matrices Xs and Ys from

  figure-coordinates to data-coordinates.  In figure-coordinates,

  (0.0,0.0) is the lower-left corner of the figure and (1.0,1.0) is

  the upper-right corner.  For a 2-D plot, (Xmin,Ymin) is the

  lower-left corner of the axis box and (Xmax,Ymax) is the upper-

  right corner in data coordinates.  [Xmin Xmax Ymin Ymax] are the

  current axis settings as returned by AXIS.

  See also DC2SC.


SCHUR

 Schur decomposition.

  [U,T] = SCHUR(X) produces a Schur matrix T and a unitary

  matrix U so that X = U*T*U' and U'*U = EYE(U).

  By itself, SCHUR(X) returns T.

  If X is complex, the Complex Schur Form is returned in matrix T.

  The Complex Schur Form is upper triangular with the eigenvalues

  of X on the diagonal.

  If X is real, the Real Schur Form is returned.  The Real Schur

  Form has the real eigenvalues on the diagonal and the complex

  eigenvalues in 2-by-2 blocks on the diagonal.

  See RSF2CSF to convert from Real to Complex Schur form.


SCRIPT

 Scripts M-files.

  A  SCRIPT file is an external file that contains a sequence

  of MATLAB statements.  By typing the filename, subsequent

  MATLAB input is obtained from the file.  SCRIPT files have

  a filename extension of ".m" and are often called "M-files".

  To make a SCRIPT file into a function, see FUNCTION.

  See also TYPE, ECHO.

  Copyright (c) 1984-93 by The MathWorks, Inc.


SEC

 Secant.

  SEC(X) is the secant of the elements of X.


SECH

 Hyperbolic secant.

  SECH(X) is the hyperbolic secant of the elements of X.


SEMILOGX

 Semi-log scale plot.

  SEMILOGX(...) is the same as PLOT(...), except a

  logarithmic (base 10) scale is used for the X-axis.

  See also PLOT.


SEMILOGY

 Semi-log scale plot.

  SEMILOGY(...) is the same as PLOT(...), except a

  logarithmic (base 10) scale is used for the Y-axis.

  See also PLOT.


SEPDEMO

 Orderings and separators for a finite element mesh.


SEPPLOT

 Used by SEPDEMO to show the separators.

   sepplot(A,xy,lname,sname): plot a mesh, a matrix, a tree, a factor,

   highlighting the top-level separator.

       A:  the matrix

      xy: the xy coordinates of the mesh

   lname: the text of the name of the permutation (long)

   sname: the text of the name of the permutation (short)


SET

 Set object properties.

  SET(H,'PropertyName',PropertyValue) sets the value of the

  specified property for the graphics object with handle H.

  H can be a vector of handles, in which case SET sets the

  properties values for all the objects.

  SET(H,'PropertyName1',PropertyValue1,'PropertyName2',PropertyValue2,...)

  sets multiple property values with a single statement.

  SET(H,'PropertyName') displays the possible values for the specified

  property of the object with handle H.

  SET(H) displays all property names and their possible values for

  the object with handle H.

  The default value for an object type can be set in an object's parent,

  grandparent, or great-grandparent by setting the PropertyName formed

  by concatenating the string 'Default', the object type, and the

  property name.  For example, to set the default color of text objects

  to red in the current figure window:

     set(gcf,'DefaultTextColor','red')

  Three strings have special meaning for PropertyValues:

    'default' - use default value (from parents)

    'factory' - use factory default value

    'remove'  - remove default value.

  See also GET, RESET, DELETE, GCF, GCA, FIGURE, AXES.


SETSTR

 Regard numeric values as character string.

  X = SETSTR(X) can be used on vectors that contain integers

  between 0 and 255 representing the ASCII code for text. It

  returns a vector that is displayed as text and not as

  integers in the usual way.

  See also ABS, ISSTR, STRINGS.


SHADING

 Color shading mode.

  SHADING controls the color shading of SURFACE and PATCH objects.

  SURFACE and PATCH objects are created by the functions SURF, MESH,

  PCOLOR, FILL, and FILL3.

  SHADING FLAT sets the shading of the current graph to flat.

  SHADING INTERP sets the shading to interpolated.

  SHADING FACETED sets the shading to faceted, which is the default.

  Flat shading is piecewise constant; each mesh line segment or

  surface patch has a constant color determined by the color value

  at the end point of the segment or the corner of the patch which

  has the smallest index or indices.

  Interpolated shading, which is also known as Gouraud shading, is

  piecewise bilinear; the color in each segment or patch varies linearly

  and interpolates the end or corner values.

  Faceted shading is flat shading with superimposed black mesh lines.

  This is often the most effective and is the default.

  SHADING is an M-file that sets the EdgeColor and FaceColor properties

  of all SURFACE objects in the current axes. It sets them to the

  correct values that depend upon whether the SURFACE objects are

  representing meshes or surfaces.

  See also SURF, MESH, PCOLOR, FILL, FILL3, SURFACE, PATCH.


SHG

 Show graph window.

  SHG does nothing, but is provided for upward compatibility

  from MATLAB 3.5.


SHOWWIND

  showwind script

  Called by sigdemo1 if the signal processing toolbox is present


SIG1HELP

                         INTERACTIVE SIGNAL DEMO

      You are seeing discrete samples of a periodic waveform (above) and the

      absolute value of its discrete Fourier transform (DFT), obtained using

      a fast Fourier transform (FFT) algorithm (below).

      In the lower plot, frequencies from 0 to 100 Hertz are displayed.

      The DFT at negative frequencies is a mirror image of the DFT at positive

      frequencies.  The sampling rate is 200 Hertz which means the "Nyquist

      frequency" is 100 Hertz.  The DFT at frequencies above the Nyquist

      frequency is the same as the DFT at lower (negative) frequencies.

      Click and drag a point on the waveform displayed in the upper plot

      to move that point to a new location, thereby setting a new fundamental

      frequency and amplitude.

      Use the pop-up menu in the bottom left of the figure window to change

      the shape of the waveform.  The possible wave shapes are sinusoidal,

      square, and sawtooth.

      The fundamental frequency of the waveform is given in the editable

      text box in the middle of the bottom row.  You can change this

      fundamental frequency by clicking in the text box and editing

      the number there, and then pressing RETURN.  The fundamental is also

      changed when the waveform is altered by clicking and dragging.

      If the Signal Processing Toolbox is installed, then the menu entitled

      "Window" allows you to select a window function.  This window is

      multiplied by the time waveform prior to taking the DFT.  To display

      the current window function in another figure window, select the menu

      item "Show window...".


SIG2HELP

                          INTERACTIVE SIGNAL DEMO - 2

      You are seeing a representation of a continuous function (above) and its

      Fourier transform (below).  The function is a Gaussian pulse multiplied,

      or "modulated," by a cosine of a particular frequency.  This demonstration

      allows you to change the modulation frequency, as well as the amplitude of

      the function, and immediately observe those changes in both domains.

      Click and drag a point on the waveform displayed in either plot

      to move that point to a new location, thereby setting a new modulation

      frequency and amplitude.

      The modulation frequency of the waveform is specified in the editable

      text box beneath the plots.  This number is updated when you click and

      drag either waveform.  You can also change the modulation frequency by

      clicking in the text box and editing the number there, and then pressing

      the RETURN key or moving the pointer outside of the box.  The sliding

      control above the text box monitors changes in the modulation

      frequency.  By clicking and dragging the control you can set the

      modulation frequency.


SIGDEMO1

 Interactive signal demo - 1 : DFT of a signal

  Demonstrates MATLAB's graphic user interface using Handle Graphics

         while illustrating some basic signal processing concepts, such as

  sampling, aliasing, and windowing.


SIGDEMO2

 Interactive signal demo - 2 : continuous FT of a signal

  Demonstrates MATLAB's graphic user interface using Handle Graphics

         while illustrating basic Fourier transform (FT) properties,

  including modulation.


SIGN

 Signum function.

  For each element of X, SIGN(X) returns 1 if the element

  is greater than zero, 0 if it equals zero and -1 if it is

  less than zero.  For complex X, SIGN(X) = X ./ ABS(X).


SIN

 Sine.

  SIN(X) is the sine of the elements of X.


SINH

 Hyperbolic sine.

  SINH(X) is the hyperbolic sine of the elements of X.


SIZE

 Matrix dimensions.

  D = SIZE(X), for M-by-N matrix X, returns the two-element

  row vector D = [M, N] containing the number of rows and columns

  in the matrix.

  [M,N] = SIZE(X) returns the number of rows and columns

  in separate output variables.

  M = SIZE(X,1) returns just the number of rows.

  N = SIZE(X,2) returns just the number of columns.


SLASH

  \   Backslash or left division.

       A\B is the matrix division of A into B, which is roughly the

       same as INV(A)*B , except it is computed in a different way.

       If A is an N-by-N matrix and B is a column vector with N

       components, or a matrix with several such columns, then

       X = A\B is the solution to the equation A*X = B computed by

       Gaussian elimination. A warning message is printed if A is

       badly scaled or nearly singular.  A\EYE(SIZE(A)) produces the

       inverse of A.

       If A is an M-by-N matrix with M < or > N and B is a column

       vector with M components, or a matrix with several such columns,

       then X = A\B is the solution in the least squares sense to the

       under- or overdetermined system of equations A*X = B. The

       effective rank, K, of A is determined from the QR decomposition

       with pivoting. A solution X is computed which has at most K

       nonzero components per column. If K < N this will usually not

       be the same solution as PINV(A)*B.  A\EYE(SIZE(A)) produces a

       generalized inverse of A.

   /   Slash or right division.

       B/A is the matrix division of A into B, which is roughly the

       same as B*INV(A) , except it is computed in a different way.

       More precisely, B/A = (A'\B')'. See \.

   ./  Array division.

       B./A denotes element-by-element division.  A and B

       must have the same dimensions unless one is a scalar.

       A scalar can be divided with anything.


SLICE

 Volumetric slice plot.

  SLICE(V,sx,sy,sz,nx) draws slices of volume V at the locations specified

  in the index vectors sx, sy, and sz.  nx is the number of rows in

  volume array V.

  SLICE(X,Y,Z,V,sx,sy,sz,nx) draws the slices for the volume locations

  specified by the triples (X(i),Y(i),Z(i)).

  For example, to evaluate the function  x*exp(-x^2-y^2-z^2) over the

  range  -2 < x < 2,  -2 < y < 2,- 2 < z < 2,

     [x,y,z] = meshgrid(-2:.2:2, -2:.2:2, -2:.2:2);

     v = x .* exp(-x.^2 - y.^2 - z.^2);

     slice(v,[5 15 21],21,[1 10],21)

  SLICE returns a vector of handles to SURFACE objects.


SORT

 Sort in ascending order.

  SORT(X) sorts each column of X in ascending order.

  When X is complex, the elements are sorted by ABS(X).

  [Y,I] = SORT(X) also returns an index matrix I.

  If X is a vector, then Y = X(I).

  If X is an m-by-n matrix, then

      for j = 1:n, Y(:,j) = X(I(:,j),j).

  See also MIN, MAX.


SOUND

 Convert vector into sound.

  SOUND(Y) sends the signal in vector Y out the speaker on SPARC, HP,

         SGI and Macintosh computers. The vector is autoscaled to provide

         maximum amplitude.

  The sound is played at the default sample rate. On the SPARC, the

  sample rate is fixed at 8192 Hz. On the Macintosh, the default

  sample rate is 22.255K Hz.

  SOUND(Y,FS), on the Macintosh and on SGI, plays the sound at a sample

  frequency of FS Hz.

  Vector Y is automatically scaled so that the maximum and minimum values

  in Y correspond to the maximum and minimum input ranges allowed by the

  sound hardware. On the Macintosh and the SGI, the volume control on the

         Control Panel determines the final sound level.

  See also SAXIS, AUWRITE, AUREAD.


SOUNDDEMO

 Demonstrate MATLAB V4's sound capability.


SOUNDEXT

 Demonstrate MATLAB V4's sound capability.  (SPARC only.)


SPALLOC

 Alloc memory for nonzero entries.

  s = SPALLOC(m,n,nzmax) creates an m-by-n all zero sparse matrix

  with room to eventually hold nzmax nonzeros.

  For example:

      s = spalloc(n,n,3*n);

      for j = 1:n

          s(:,j) = (a sparse column vector with 3 nonzero entries);

      end

  See also SPONES, SPDIAGS, SPRANDN, SPRANDSYM, SPEYE, SPARSE.


SPARLIST

 List of sparse matrix demos.

  SPARLIST, by itself, presents a list of sparse matrix demos.

  Used by DEMO.


SPARSE

 Build sparse matrix from nonzeros and indices.

  S = SPARSE(...) is the built-in function which generates matrices

  in MATLAB's sparse storage organization.  It can be called with

  1, 2, 3, 5 or 6 arguments.

  S = SPARSE(X) converts a sparse or full matrix to sparse form by

  squeezing out any zero elements.

  S = SPARSE(i,j,s,m,n,nzmax) uses the rows of [i,j,s] to generate

  an m-by-n sparse matrix with space allocated for nzmax nonzeros.

  The two integer index vectors, i and j, and the real or complex

  entries vector, s, all have the same length, nnz, which is the

  number of nonzeros in the resulting sparse matrix S .

  There are several simplifications of this six argument call.

  S = SPARSE(i,j,s,m,n) uses nzmax = length(s).

  S = SPARSE(i,j,s) uses m = max(i) and n = max(j).

  S = SPARSE(m,n) abbreviates SPARSE([],[],[],m,n,0).  This

  generates the ultimate sparse matrix, an m-by-n all zero matrix.

  The argument s and one of the arguments i or j may be scalars,

  in which case they are expanded so that the first three arguments

  all have the same length.

  For example, this dissects and then reassembles a sparse matrix:

             [i,j,s] = find(S);

             [m,n] = size(S);

             S = sparse(i,j,s,m,n);

  So does this, if the last row and column have nonzero entries:

             [i,j,s] = find(S);

             S = sparse(i,j,s);

  All of MATLAB's built-in arithmetic, logical and indexing operations

  can be applied to sparse matrices, or to mixtures of sparse and

  full matrices.  Operations on sparse matrices return sparse matrices

  and operations on full matrices return full matrices.  In most cases,

  operations on mixtures of sparse and full matrices return full

  matrices.  The exceptions include situations where the result of

  a mixed operation is structurally sparse, eg.  A .* S is at least

  as sparse as S .  Some operations, such as S >= 0, generate

  "Big Sparse", or "BS", matrices -- matrices with sparse storage

  organization but few zero elements.

  See also FULL, FIND and the sparfun directory.


SPARSFUN

 Sparse auxiliary functions and parameters.

  Several MATLAB functions, defined in M-files, use this built-in

  function with a text keyword as the first argument to access the

  internal sparse data structure.

  eg. nnz = sparsfun('nnz',S) and p = sparsfun('colmmd',S).


SPARSITY

 Demonstrate effect of sparsity orderings.


SPAUGMENT

 Express a least squares problem as a larger linear system.

  S = SPAUGMENT(A,c) creates the sparse, square, symmetric indefinite

  matrix S = [c*I A; A' 0].  This matrix is related to the least

  squares problem

          min norm(b - A*x)

  by

          r = b - A*x

          S * [r/c; x] = [b; 0].

  The optimum value of the residual scaling factor c, involves

  min(svd(A)) and norm(r), which are usually too expensive to compute.

  S = SPAUGMENT(A), without a specified value of c, uses the

  default set by SPPARMS, which is usually max(max(abs(A)))/1000.

  The augmented matrix is used automatically by the sparse

  linear equation solvers, \ and /, for nonsquare problems.

  See also SPPARMS.


SPCONVERT

 Convert from sparse external format.

  S = SPCONVERT(D) converts an nnz or nnz+1 by 3 or 4 array

  with rows containing [i,j,s] or [i,j,real(s(i,j)),imag(s(i,j))]

  to the corresponding sparse matrix.  A row of the form [m n 0]

  or [m n 0 0] anywhere in D may be used to specify size(S).

  If D is already sparse no conversion is done, so SPCONVERT can

  be used after D is loaded from either a MAT or an ASCII file.

  See also SPARSE, FULL.


SPDIAGS

  SPDIAGS Extract and create sparse band and diagonal matrices.

  SPDIAGS, which generalizes the builtin function "diag", deals with

  three matrices, in various combinations, as both input and output.

  A is an m-by-n matrix, usually (but not necessarily) sparse,

  with its nonzero, or specified, elements located on p diagonals.

  B is a min(m,n)-by-p matrix, usually (but not necessarily) full,

  whose columns are the diagonals of A.

  d is a vector of length p whose integer components specify

  the diagonals in A.

  Roughly, A, B and d are related by

      for k = 1:p

          B(:,k) = diag(A,d(k))

      end

  Four different operations, distinguished by the number of

  input arguments, are possible with SPDIAGS:

  Extract all nonzero diagonals:

      [B,d] = spdiags(A);

  Extract specified diagonals:

      B = spdiags(A,d);

  Replace specified diagonals:

      A = spdiags(B,d,A);

  Create a sparse matrix from its diagonals:

      A = spdiags(B,d,m,n);

  The precise relationship among A, B and d is:

     if m >= n

        for k = 1:p

           for j = max(1,1+d(k)):min(n,m+d(k))

              B(j,k) = A(j-d(k),j);

           end

        end

     if m < n

        for k = 1:p

           for i = max(1,1-d(k)):min(m,n-d(k))

              B(i,k) = A(i,i+d(k));

           end

        end

     end

  Some elements of B, corresponding to positions "outside" of A,

  are not defined by these loops.  They are not referenced when

  B is input and are set to zero when B is output.

  For example, this generates a sparse tridiagonal representation

  of the classic second difference operator on n points.

      e = ones(n,1);

      A = spdiags([e -2*e e], -1:1, n, n)

  This turns it into Wilkinson's test matrix (see WILKINSON(n)).

      A = spdiags(abs(-(n-1)/2:(n-1)/2)',0,A)

  Finally, this recovers the 3 diagonals.

      B = spdiags(A)

  The second example is not square.

      A = [ 11    0   13    0

             0   22    0   24

             0    0   33    0

            41    0    0   44

             0   52    0    0

             0    0   63    0

             0    0    0   74]

  has m = 7, n = 4 and p = 3.

  The statement [B,d] = spdiags(A)  produces d = [-3 0 2]'  and

      B = [ 41   11    0

            52   22    0

            63   33   13

            74   44   24 ]

  Conversely, with the above B and d, the expression

  spdiags(B,d,7,4) reproduces the original A.

  See also DIAG.


SPECIALS

 List of special demonstrations.

  SPECIALS, by itself, presents a list of special demonstrations.


SPECULAR

 Specular reflectance.

  R = SPECULAR(Nx,Ny,Nz,S,V) returns the reflectance of a surface with

  normal vector components [Nx,Ny,Nz].  S and V specify the direction

  to the light source and to the viewer, respectively. They can be

  three vectors [x,y,z] or two vectors [Az, El] with azimuth and

  elevation.

  The specular highlight is strongest when the normal vector is in the

  direction of (S+V)/2 where S is the source direction, and V is the

  view direction.

  The surface spread exponent can be specified by including a sixth

  argument as in specular(Nx,Ny,Nz,S,V,spread).

  See also DIFFUSE, SURFNORM, SURFL.


SPEYE

 Sparse identity matrix.

  SPEYE(M,N) forms an M-by-N sparse matrix with 1's on

  the main diagonal.  SPEYE(N) abbreviates SPEYE(N,N).

  SPEYE(SIZE(A)) is a space-saving SPARSE(EYE(SIZE(A))).


SPFUN

 Apply a function only to the nonzero entries.

  F = SPFUN('fun',S) evaluates fun(s) on the nonzero elements of S.

  e.g. F = SPFUN('exp',S) has the same sparsity pattern as S

  (except for underflow), whereas EXP(S) has 1's where S has 0's.


SPH2CART

 Transform spherical coordinates to Cartesian.

  [X,Y,Z] = SPH2CART(AZ,EL,R) transforms data stored in spherical

  coordinates to Cartesian coordinates. If [M,N] = SIZE(AZ), then

  EL and R must be also be the same size. AZ and EL must be in radians.

  See also CART2SPH, CART2POL, POL2CART.


SPHERE

 Generate sphere.

  [X,Y,Z] = SPHERE(N) generates three (n+1)-by-(n+1)

  matrices so that SURF(X,Y,Z) produces a unit sphere.

  [X,Y,Z] = SPHERE uses N = 20.

  SPHERE(N) and just SPHERE graph the sphere as a SURFACE

  and do not return anything.

  See also CYLINDER.


SPINMAP

 Spin the colormap.

  SPINMAP cyclically rotates the color map for about 3 seconds.

  SPINMAP(T) rotates it for about T seconds.

  SPINMAP(inf) is an infinite loop, break with <ctrl-C>.

  SPINMAP(T,inc) uses the specified increment.  The default is

  inc = 2, so inc = 1 is a slower rotation, inc = 3 is faster,

  inc = -2 is the other direction, etc.

  To avoid multiple redraws, set(gcf,'sharecolors','no').

  See also COLORMAP, RGBPLOT.


SPIRAL

 SPIRAL(n) is an n-by-n matrix with elements ranging

  from 1 to n^2 in a rectangular spiral pattern.


SPLINE

 Cubic spline data interpolation.

  Given data vectors X and Y, and a new abscissa vector XI, the

  function YI = SPLINE(X,Y,XI) uses cubic spline interpolation

  to find a vector YI corresponding to XI.

  Here's an example that generates a coarse sine curve, then

  interpolates over a finer abscissa:

      x = 0:10;  y = sin(x);

      xi = 0:.25:10;

      yi = spline(x,y,xi);

      plot(x,y,'o',xi,yi)

  PP = spline(x,y) returns the pp-form of the cubic spline interpolant

  instead, for later use with  ppval, etc.

  See also INTERP1, INTERP2, PPVAL, MKPP, UNMKPP, the Spline Toolbox.


SPLINE2D

 Demonstrate GINPUT and SPLINE in two dimensions.


SPONES

 Replace nonzero entries with ones.

  R = SPONES(S) generates a matrix with the same sparsity

  structure as S, but with ones in the nonzero positions.


SPPARMS

 Set parameters for sparse matrix routines.

  SPPARMS('key',value) sets one or more of the "tunable" parameters

  used in the sparse linear equation operators, \ and /, and the

  minimum degree orderings, COLMMD and SYMMMD.

  SPPARMS, by itself, prints a description of the current settings.

  If no input argument is present, values = SPPARMS returns a

  vector whose components give the current settings.

  [keys,values] = SPPARMS returns that vector, and also returns

  a character matrix whose rows are the keywords for the parameters.

  SPPARMS(values), with no output argument, sets all the parameters

  to the values specified by the argument vector.

  value = SPPARMS('key') returns the current setting of one parameter.

  SPPARMS('default') sets all the parameters to their default settings.

  SPPARMS('tight') sets the minimum degree ordering parameters to their

  "tight" settings, which may lead to orderings with less fill-in, but

  which makes the ordering functions themselves use more execution time.

  The parameters with the default and "tight" values are:

                   keyword       default       tight

     values(1)     'spumoni'      0

     values(2)     'thr_rel'      1.1          1.0

     values(3)     'thr_abs'      1.0          0.0

     values(4)     'exact_d'      0            1

     values(5)     'supernd'      3            1

     values(6)     'rreduce'      3            1

     values(7)     'wh_frac'      0.5          0.5

     values(8)     'autommd'      1

     values(9)     'aug_rel'      0.001

     values(10)    'aug_abs'      0

  The meanings of the parameters are

     spumoni:  The Sparse Monitor Flag controls diagnostic output;

               0 means none, 1 means some, 2 means too much.

     thr_rel,

     thr_abs:  Minimum degree threshold is thr_rel*mindegree + thr_abs.

     exact_d:  Nonzero to use exact degrees in minimum degree,

               Zero to use approximate degrees.

     supernd:  If > 0, MMD amalgamates supernodes every supernd stages.

     rreduce:  If > 0, MMD does row reduction every rreduce stages.

     wh_frac:  Rows with density > wh_frac are ignored in COLMMD.

     autommd:  Nonzero to use minimum degree orderings with \ and /.

     aug_rel,

     aug_abs: Residual scaling parameter for augmented equations is

              aug_rel*max(max(abs(A))) + aug_abs.

              For example, aug_rel = 0, aug_abs = 1 puts an unscaled

              identity matrix in the (1,1) block of the augmented matrix.

  See also COLMMD, SYMMMD, SPAUGMENT.


SPRANDN

 Random sparse matrices.

  R = SPRANDN(S) has the same sparsity structure as S, but normally

      distributed random entries.

  R = SPRANDN(m,n,density) is a random, m-by-n, sparse matrix with

      approximately density*m*n normally distributed nonzero entries.

  R = SPRANDN(m,n,density,rc) also has reciprocal condition number

      approximately equal to rc.  R is constructed from a sum of

      matrices of rank one.

      If rc is a vector of length lr <= min(m,n), then R has

      rc as its first lr singular values, all others are zero.

      In this case, R is generated by random plane rotations

      applied to a diagonal matrix with the given singular values

      It has a great deal of topological and algebraic structure.

  See also SPRANDSYM.


SPRANDSYM

 Random sparse symmetric matrices

  R = SPRANDSYM(S) is a symmetric random matrix whose lower triangle

      and diagonal have the same structure as S.  The elements are

      normally distributed, with mean 0 and variance 1.

  R = SPRANDSYM(n,density) is a symmetric random, n-by-n, sparse

      matrix with approximately density*n*n nonzeros; each entry is

      the sum of one or more normally distributed random samples.

  R = SPRANDSYM(n,density,rcond) also has a reciprocal condition number

      equal to rcond.  The distribution of entries is

      nonuniform; it is roughly symmetric about 0; all are in [-1,1].

      If rcond is a VECTOR of length n, then R has eigenvalues rcond.

      Thus, if rcond is a positive (nonnegative) vector then R will

      be positive (nonnegative) definite

      In either case, R is generated by random Jacobi rotations

      applied to a diagonal matrix with the given eigenvalues or

      condition number.  It has a great deal of topological and

      algebraic structure.

  R = SPRANDSYM(n, density, rcond, kind) is positive definite.

      If kind = 1, R is generated by random Jacobi rotation of

         a positive definite diagonal matrix.

         R has the desired condition number exactly.

      If kind = 2, R is a shifted sum of outer products.

         R has the desired condition number only

         approximately, but has less structure.

      If R = SPRANDSYM(S, density, rcond, 3),

         then R has the same structure as the MATRIX S and

         approximate condition number 1/rcond.  density is ignored.

  See also SPRANDN.


SPRANK

 Sparse structural rank.

  r = SPRANK(A) is the structural rank of the sparse matrix A.

  Also known as maximum traversal, maximum assignment, and

  size of a maximum matching in the bipartite graph of A.

  Always sprank(A) >= rank(A), and in exact arithmetic

  sprank(A) == rank(sprandn(A)) with probability one.

  See also DMPERM.


SPRINTF

 Write formatted data to a string.

  [S,ERRMSG] = SPRINTF(FORMAT,A,...) formats the data in matrix A

  (and in any additional matrix arguments), under control of the

  specified FORMAT string, and returns it in the MATLAB string variable

  S. ERRMSG is an optional output argument that returns an error

  message string if an error occurred or an empty matrix if an error

  did not occur.

  SPRINTF is the same as FPRINTF except that it returns the data in

  a MATLAB string variable rather than writing it to a file.

         FORMAT is a string containing C language conversion specifications.

         Conversion specifications involve the character %, optional flags,

         optional width and precision fields, optional subtype specifier, and

         conversion characters d, i, o, u, x, X, f, e, E, g, G, c, and s.

         See a C manual for complete details.

         SPRINTF behaves like ANSI C with certain exceptions and extensions.

         These include:

         1. If the MATLAB double doesn't convert exactly to the datatype

            associated with the conversion specifier then e format is used.

            You must explicitly convert non-integral MATLAB values to

            integral values if you plan to use an integral conversion

            specifier like d and get the expected ANSI C behavior.

         2. The following non-standard subtype specifiers are supported for

            conversion characters o, u, x, and X.

            t    - The underlying C datatype is a float rather than an

                   unsigned integer.

            b    - The underlying C datatype is a double rather than an

                   unsigned integer.

            For example, to print out in hex a double value use a format like

            '%bx'.

  SPRINTF differs from its C language namesake in an important

  respect - it is "vectorized" for the case when A is nonscalar. The

  format string is recycled through the elements of A (columnwise) until

  all the elements are used up. It is then recycled in a similar manner,

  without reinitializing, through any additional matrix arguments.

  For example, the statement

      S = sprintf('rho is %5.3f',(1+sqrt(5))/2)

  produces the string

      S = 'rho is 1.618'

  See also FPRINTF, SSCANF, FWRITE, NUM2STR, INT2STR.


SPY

 Visualize the sparsity structure.

  SPY(S) plots the sparsity pattern of any matrix S.

  SPY(S,color) uses the specified marker color instead of yellow.

  SPY(S,marksize) uses the specified marker size instead of

  a size which depends upon the figure size and the matrix order.

  SPY(S,color,marksize) and SPY(S,marksize,color) are allowed.


SPYPART

 Spy plot with partitioning.

  SPYPART(S,rp,cp) plots the sparsity pattern of a matrix S,

  with lines marking a block partition described by

  rp (rows) and cp (columns).

  If S is square, cp may be omitted and defaults to rp.

  Partitions are specified as in the output of DMPERM:

  There are length(rp)-1 row blocks, of sizes diff(rp), with rp(1)=1.


SQDEMO

 Demonstrate UIControls with Superquadrics.

  Click "help" to see this preamble.

  Vary the superquadric shape parameters with the "roundness" sliders.

  Click "first" to select the current shape as the first one in a movie.

  Click "make" to select the current shape as the last one, and make a

     movie, interpolating between the shapes, and rotating 1/4 turn.

  Click "play" to play the movie.  If the first and last shapes are

     the same, play the movie forward to get a spinning effect.

     Otherwise, play the movie back and forth to get a pulsing effect.

  Click "done" to clear the window.

  The pulldown menu, colormaps, offers several color maps.

  *  WARNING: When a button is green, work is in progress.  *

  *  Do not click another button.                           *

  Other parameters can be altered by typing in the command window.

     nf = number of frames, initially 12.

     dt = rotation increment, initially pi/24, so 12 frames is 1/4 turn.

     np = number of plays, initially 10.

  See also: SUPERQUAD.


SQRT

 Square root.

  SQRT(X) is the square root of X. Complex results are

  produced if X is not positive.

  See also SQRTM.


SQRTM

 Matrix square root.

  S = SQRTM(A) is the matrix square root of A.

  Complex results are produced if A has negative eigenvalues.

  A warning message is printed if the computed S*S is not close to A.

  [S,esterr] = sqrtm(A) does not print any warning message, but

  returns an estimate of the relative residual, norm(S*S-A)/norm(A).

  If A is real, symmetric and positive definite, or complex, Hermitian

  and positive definite, then so is the computed matrix square root.

  Some matrices, like A = [0 1; 0 0], do not have any square roots,

  real or complex, and SQRTM cannot be expected to produce one.

  See also EXPM, LOGM, FUNM.


SSCANF

 Read string under format control.

  [A,COUNT,ERRMSG,NEXTINDEX] = SSCANF(S,FORMAT,SIZE) reads data from

  MATLAB string variable S, converts it according to the specified

  FORMAT string, and returns it in matrix A. COUNT is an optional output

  argument that returns the number of elements successfully read.

         ERRMSG is an optional output argument that returns an error message

  string if an error occurred or an empty matrix if an error did not

  occur. NEXTINDEX is an optional output argument specifyiny one more

  than the number of characters scanned in S.

  SSCANF is the same as FSCANF except that it reads the data from

  a MATLAB string variable rather than reading it from a file.

  SIZE is optional; it puts a limit on the number of elements that

  can be scanned from the string; if not specified, the entire string

  is considered; if specified, valid entires are:

      N      read at most N elements into a column vector.

      inf    read at most to the end of the string.

      [M,N]  read at most M * N elements filling at least an

             M-by-N matrix, in column order. N can be inf, but not M.

         FORMAT is a string containing C language conversion specifications.

         Conversion specifications involve the character %, optional

         assignment-suppressing asterisk and width field, and conversion

         characters d, i, o, u, x, e, f, g, s, c, and [. . .] (scanset).

         Complete ANSI C support for these conversion characters is

         provided consistent with 'expected' MATLAB behavior. For a complete

         conversion character specification, see a C manual.

         If a conversion character s is used, an element read may cause

         several MATLAB matrix elements to be used, each holding one

         character.

  Mixing character and numeric conversion specifications will cause

  the resulting matrix to be numeric and any characters read to show

  up as their ASCII values one character per MATLAB matrix element.

  Scanning to end-of-string occurs when NEXTINDEX is greater than the

  size of S.

  SSCANF differs from its C language namesake in an important respect -

  it is "vectorized" in order to return a matrix argument. The format

  string is recycled through the the string until its end is reached

  or the amount of data specified by SIZE is converted in.

  For example, the statements

      S = '2.7183  3.1416';

      A = sscanf(S,'%f')

  create a two element vector containing approximations to e and pi.

  See also FSCANF, SPRINTF, FREAD.


STAIRS

 Stairstep graph (bar graph without internal lines).

  Stairstep plots are useful for drawing time history plots of

  digital sampled-data systems.

  STAIRS(Y) draws a stairstep graph of the elements of vector Y.

  STAIRS(X,Y) draws a stairstep graph of the elements in vector Y at

  the locations specified in X.  The X-values must be in

  ascending order and evenly spaced.

  [XX,YY] = STAIRS(X,Y) does not draw a graph, but returns vectors

  X and Y such that PLOT(XX,YY) is the stairstep graph.

  See also BAR, HIST.


STD

 Standard deviation.

  For vectors, STD(x) returns the standard deviation.

  For matrices, STD(X) is a row vector containing the

  standard deviation of each column.

  STD computes the "sample" standard deviation, that

  is, it is normalized by N-1, where N is the sequence

  length.

  See also COV, MEAN, MEDIAN.


STEM

 Plot discrete sequence data.

  STEM(Y) plots the data sequence Y as stems from the x-axis

  terminated with circles for the data value.

  STEM(X,Y) plots the data sequence Y at the values specfied

  in X.

  There is an optional final string argument to specify a line-type

  for the stems of the data sequence.  E.g. STEM(X,Y,'-.') or

  STEM(Y,':').

  See also PLOT, BAR, STAIRS.


STR2MAT

 Form text matrix from individual strings.

  S = STR2MAT(T1,T2,T3,..) forms the matrix S containing the text

  strings T1,T2,T3,... as rows.  Automatically pads each string with

  spaces in order to form a valid matrix.  Up to 10 text strings

  can be used to form S.  Each text parameter, Ti, can itself be a

  string matrix.  This allows the creation of arbitarily large

  string matrices.


STR2NUM

 String to number conversion.

  X = STR2NUM(S)  converts the string S, which should be an

  ASCII character representation of a numeric value, to MATLAB's

  numeric representation.  The string may contain digits, a decimal

  point, a leading + or - sign, an 'e' preceeding a power of 10 scale

  factor, and an 'i' for a complex unit.

  If the string S does not represent a valid number, STR2NUM(S)

  returns the empty matrix.

  See also NUM2STR, HEX2NUM.


STRCMP

 String comparison.

  STRCMP(S1,S2) returns 1 if strings S1

  and S2 are the same and 0 otherwise.

  See also FINDSTR.


STRINGS

 Character strings in MATLAB.

  X = 'Any Characters' is a vector whose components are the ASCII codes

  for the characters.  The length of X is the number of characters.

  X = ABS(X) sets the vector to its decimal ASCII representation.

  X = SETSTR(X) sets it back to a string.

  A quote within the string is indicated by two quotes.

  ISSTR(X) tells if X is a string variable.


SUBPLOT

 Create axes in tiled positions.

  SUBPLOT(m,n,p), or SUBPLOT(mnp), breaks the Figure window into

  an m-by-n matrix of small axes, selects the p-th axes for

  for the current plot, and returns the axis handle.  The axes

  are counted along the top row of the Figure window, then the

  second row, etc.  For example,

      SUBPLOT(2,1,1), PLOT(income)

      SUBPLOT(2,1,2), PLOT(outgo)

  plots income on the top half of the window and outgo on the

  bottom half.

  SUBPLOT(m,n,p), if the axis already exists, makes it current.

  SUBPLOT(H), where H is an axis handle, is another way of making

  an axis current for subsequent plotting commands.

  If a SUBPLOT specification causes a new axis to overlap an

  existing axis, the existing axis is deleted.  For example,

  the statement SUBPLOT(1,1,1) deletes all existing smaller

  axes in the Figure window and creates a new full-figure axis.


SUBSCRIBE

 Become a subscribing user of MATLAB.

  Execute SUBSCRIBE to become a subscribing user of

  MATLAB.  This command will prompt you for your name

  and address.  If you are on a Unix system, it will

  email your subscription to MathWorks.  If you are not,

  it will create a log file that you can print out and

  FAX or mail to MathWorks.


SUBSPACE

 Angle between two subspaces.

  SUBSPACE(A,B) finds the angle between two subspaces specified

  by the columns of A and B.  If A and B are vectors of unit

  length, this is the same as ACOS(A'*B).

  If the angle is small, the two spaces are nearly linearly

  dependent.  In a physical experiment described by some

  observations A, and a second realization of the experiment

  described by B, SUBSPACE(A,B) gives a measure of the amount

  of new information afforded by the second experiment not

  associated with statistical errors of fluctuations.


SUM

 Sum of the elements.

  For vectors, SUM(X) is the sum of the elements of X.

  For matrices, SUM(X) is a row vector with the sum over

  each column. SUM(DIAG(X)) is the trace of X.

  See also PROD, CUMPROD, CUMSUM.


SUNSPOTS

 The answer is 11.08, what is the question?


SUPERQUAD

 Barr's "superquadrics" ellipsoid.

  [x,y,z] = SUPERQUAD(n,e,m) is a generalized ellipsoid with

  n = vertical roundness, e = horizontal roundness and m facets.

  If values of n and e are not given, random values are supplied.

  The default value of m is 24.

  SUPERQUAD(...) , with no output arguments, does a SURF plot.

  Ref: A. H. Barr, IEEE Computer Graphics and Applications, 1981,

       or, Graphics Gems III, David Kirk, editor, 1992.

  See also: SQDEMO.


SURF

 3-D shaded surface graph.

  SURF(X,Y,Z,C) plots the colored parametric surface defined by

  four matrix arguments.  The view point is specified by VIEW.

  The axis labels are determined by the range of X, Y and Z,

  or by the current setting of AXIS.  The color scaling is determined

  by the range of C, or by the current setting of CAXIS.  The scaled

  color values are used as indices into the current COLORMAP.

  The shading model is set by SHADING.

  SURF(X,Y,Z) uses C = Z, so color is proportional to surface height.

  SURF(x,y,Z) and SURF(x,y,Z,C), with two vector arguments replacing

  the first two matrix arguments, must have length(x) = n and

  length(y) = m where [m,n] = size(Z).  In this case, the vertices

  of the surface patches are the triples (x(j), y(i), Z(i,j)).

  Note that x corresponds to the columns of Z and y corresponds to

  the rows.

  SURF(Z) and SURF(Z,C) use x = 1:n and y = 1:m.  In this case,

  the height, Z, is a single-valued function, defined over a

  geometrically rectangular grid.

  SURF returns a handle to a SURFACE object.

  AXIS, CAXIS, COLORMAP, HOLD, SHADING and VIEW set figure, axes, and

  surface properties which affect the display of the surface.

  See also SURFC, SURFL, MESH.


SURFACE

 Create surface low-level objects.

  SURFACE(X,Y,Z,C) adds the surface in X,Y,Z,C to the current axes.

  SURFACE(X,Y,Z) uses C = Z, so color is proportional to surface height.

  See SURF for a complete description of the various forms that X,Y,Z,C

  can take.

  SURFACE returns a handle to a SURFACE object. SURFACEs are children of

  AXES objects.

  The arguments to SURFACE can be followed by parameter/value pairs

  to specify additional properties of the surface. The X,Y,Z,C arguments

  to SURFACE can be omitted entirely, and all properties specified using

  parameter/value pairs.

  AXIS, CAXIS, COLORMAP, HOLD, SHADING and VIEW set figure, axes, and

  surface properties which affect the display of the SURFACE.

         Execute GET(H), where H is a surface handle, to see a list of surface

         object properties and their current values. Execute SET(H) to see a

         list of surface object properties and legal property values.

  See also SURF, LINE, PATCH, TEXT.


SURFC

 Combination SURF/CONTOUR plot.

  SURFC(...) is the same as SURF(...) except that a contour plot

  is drawn beneath the surface.

  Because CONTOUR does not handle irregularly spaced data, this

  routine only works for surfaces defined on a rectangular grid.

  The matrices or vectors X and Y define the axis limits only.

  See also SURF.


SURFL

 3-D shaded surface with lighting.

  SURFL(...) is the same as SURF(...) except that it draws the surface

  with highlights from a light source.

  SURFL(Z), SURFL(X,Y,Z), SURFL(Z,S), and SURFL(X,Y,Z,S) are all

  legal. S, if specified, is the three vector S = [Sx,Sy,Sz]

  that specifies the direction of the light source. S can also be

  specified in spherical coordinates, S = [AZ,EL].

  The shading is based on a combination of diffuse, specular and

  ambient lighting models.

  The default value for S is 45 degrees counterclockwise from

  the current view direction.  Use CLA, HOLD ON, VIEW(AZ,EL),

  SURFL(...), HOLD OFF to plot the lighted surface with view

  direction (AZ,EL).

  The relative contributions due to ambient light, diffuse

  reflection, specular reflection, and the specular spread

  coefficient can be set by using five arguments

  SURFL(X,Y,Z,S,K) where K=[ka,kd,ks,spread].

  Relies on the ordering of points in the X,Y, and Z matrices

  to define the inside and outside of parametric surfaces.

  Try SURFL(X',Y',Z') if you don't like the results of

  this function.  Due to the way surface normal vectors are

  computed, SURFL requires matrices that are at least 3-by-3.

  See also SURF.


SURFNORM

 3-D surface normals.

  [Nx,Ny,Nz] = SURFNORM(X,Y,Z) returns the components of the 3-D

  surface normal for the surface with components (X,Y,Z).  The

  normal is unnormalized.

  [Nx,Ny,Nz] = SURFNORM(Z) returns the surface normal components

  for the surface Z.

  Without lefthand arguments, SURFNORM(X,Y,Z) or SURFNORM(Z)

  plots the surface with the normals emanating from it.  Normals

  are not shown for surface elements that face away from the viewer.

  The surface normals returned are based on a bicubic fit of

  the data.


SVD

 Singular value decomposition.

  [U,S,V] = SVD(X) produces a diagonal matrix S, of the same

  dimension as X and with nonnegative diagonal elements in

  decreasing order, and unitary matrices U and V so that

  X = U*S*V'.

  By itself, SVD(X) returns a vector containing diag(S).

  [U,S,V] = SVD(X,0) produces the "economy size"

  decomposition. If X is m-by-n with m > n, then only the

  first n columns of U are computed and S is n-by-n.


SWAPPREV

 Merge EPSI and EPS files.

  Used to extract the preview bitmap from an EPSI file and

  mate it with the Setup and script from an EPS file. Needed to

  fix a bug with MATLAB v4.0 and v4.0a.

  See also 8 Febuary 93 version of PRINT


SYMBFACT

 Symbolic factorization analysis.

  count = SYMBFACT(A) returns the vector of row counts for the upper

  triangular Cholesky factor of a symmetric matrix whose upper triangle

  is that of A, assuming no cancellation during the factorization.

  This routine should be much faster than chol(A).

  count = SYMBFACT(A,'col') analyzes A'*A (without forming it explicitly).

  count = SYMBFACT(A,'sym') is the same as p = symbfact(A).

  There are several optional return values:

  [count,h,parent,post,R] = symbfact(...) also returns

       the height of the elimination tree,

       the elimination tree itself,

       a postordering permutation of the elimination tree,

       and a 0-1 matrix R whose structure is that of chol(A).

  See also CHOL, ETREE, TREELAYOUT.


SYMMMD

 Symmetric minimum degree.

  p = SYMMMD(S), for a symmetric positive definite matrix S,

  returns a permutation p such that S(p,p) tends to have a

  sparser Cholesky factor than S.  Sometimes SYMMMD works well

  for symmetric indefinite matrices too.

  See also COLMMD, COLPERM, SYMRCM.


SYMRCM

 Reverse Cuthill-McKee ordering.

  p = SYMRCM(S) returns a permutation p such that S(p,p)

  tends to have smaller profile than S.  This is a

  good preordering for LU or Cholesky factorization

  of matrices that come from "long, skinny" problems.

  It works for both symmetric and asymmetric S.

  See also SYMMMD, COLMMD, COLPERM.


TABLE1

 Table look-up.

  Y = TABLE1(TAB,X0) returns a table of linearly interpolated rows from

  table TAB, looking up X0 in the first column of TAB.

  See also INTERP2, TABLE2.


TABLE2

 Two-dimensional table look-up.

  Z = TABLE2(TAB,X0,Y0) returns a linearly interpolated

  intersection from table TAB, looking up X0 in the first

  column and Y0 in the first row of TAB.

  See also INTERP3, INTERP4, INTERP5, TABLE1.


TAN

 Tangent.

  TAN(X) is the tangent of the elements of X.


TANH

 Hyperbolic tangent.

  TANH(X) is the hyperbolic tangent of the elements of X.


TEMPDIR

 Returns the name of the temporary directory if one exists


TEMPNAME

 Returns a unique name suitable for use as a temporary file


TERMINAL

 Set graphics terminal type.

  TERMINAL puts up a menu of graphics terminal types and prompts for

  a choice.  It then configures MATLAB. You can also specify the

  terminal type as the first parameter.

  You can add any terminal settings you may need for your specific

  emulators/terminals to this file.

  The graphics terminals that are currently supported are:

  tek401x - Tektronix 4010/4014

  tek4100 - Tektronix 4100

  tek4105 - Tektronix 4105

  retro - retrographics card

  sg100 - Selanar graphics 100

  sg200 - Selanar graphics 200

  vt240tek - VT240 & VT340 Tek mode

  ergo - ergo terminal

  graphon - graphon terminal

  citoh - C.Itoh terminal

  xtermtek - xterm, Tektronix graphics

  wyse - Wyse WY-99GT

  kermit - MS-DOS Kermit 2.23

  hp2647 - Hewlett-Packard 2647

  versa - Macintosh with VersaTerm (Tektronics 4010/4014)

  versa4100 - Macintosh with VersaTerm (Tektronics 4100)

  versa4105 - Color/Grayscale Macintosh with VersaTerm (Tektronics 4105)

  hds - Human Designed Systems


TEXT

 Add Text to the current plot.

  TEXT(X,Y,'string') adds the text in the quotes to location (X,Y)

  on the current axes, where (X,Y) is in units from the current

  plot. If X and Y are vectors, TEXT writes the text at all locations

  given. If 'string' is an array the same number of rows as the

  length of X and Y, TEXT marks each point with the corresponding row

  of the 'string' array.

  TEXT(X,Y,Z,'string') adds text in 3-D coordinates.

  TEXT returns a column vector of handles to TEXT objects, one

  handle per text object. TEXT objects are children of AXES objects.

  The X,Y pair (X,Y,Z triple for 3-D) can be followed by

  parameter/value pairs to specify additional properties of the text.

  The X,Y pair (X,Y,Z triple for 3-D) can be omitted entirely, and

  all properties specified using parameter/value pairs.

         Execute GET(H), where H is a text handle, to see a list of text

         object properties and their current values. Execute SET(H) to see a

         list of text object properties and legal property values.

  See also XLABEL, YLABEL, ZLABEL, TITLE, GTEXT, LINE, PATCH.


TFFUNC

 time and frequency domain versions of a cosine modulated Gaussian pulse.

  For use in Signal demo 2.


TIC

 Start a stopwatch timer.

  The sequence of commands

      TIC

      any stuff

      TOC

  prints the time required for the stuff.

  See also TOC, CLOCK, ETIME, CPUTIME.


TITLE

 Titles for 2-D and 3-D plots.

  TITLE('text') adds text at the top of the current axis.

  See also XLABEL, YLABEL, ZLABEL, TEXT.


TOC

 Read the stopwatch timer.

  TOC, by itself, prints the elapsed time since TIC was used.

  t = TOC; saves the elapsed time in t, instead of printing it out.

  See also TIC, ETIME, CLOCK, CPUTIME.


TOEPLITZ

 Toeplitz matrix.

  TOEPLITZ(C,R) is a non-symmetric Toeplitz matrix having C as its

  first column and R as its first row.   TOEPLITZ(C) is a symmetric

  (or Hermitian) Toeplitz matrix.

  See also HANKEL.


TRACE

 Sum of diagonal elements.

  TRACE(A) is the sum of the diagnonal elements of A, which is

  also the sum of the eigenvalues of A.


TRAPZ

 Trapezoidal numerical integration.

  Z = TRAPZ(X,Y) computes the integral of Y with respect to X using

  trapezoidal integration.  X and Y must be vectors of the same length,

  or X must be a column vector and Y a matrix with as many rows as X.

  TRAPZ computes the integral of each column of Y separately.

  The resulting Z is a scalar or a row vector.

  Z = TRAPZ(Y) computes the trapezoidal integral of Y assuming unit

  spacing between the data points.  To compute the integral for

  spacing different from one, multiply Z by the spacing increment.

  See also SUM, CUMSUM.


TREELAYOUT

 Lay out a tree or forest.

  [x,y,h,s] = treelayout(parent,post)

      parent is the vector of parent pointers, with 0 for a root.

      post is a postorder permutation on the the tree nodes.

      (If post is omitted we compute it here.)

      x and y are vectors of coordinates in the unit square at which

      to lay out the nodes of the tree to make a nice picture.

      Optionally, h is the height of the tree and s is the

      number of vertices in the top-level separator.

  See also ETREE, TREEPLOT, ETREEPLOT.


TREEPLOT

 Plot a picture of a tree.

  TREEPLOT(p,c,d)

      p is a vector of parent pointers, with p(i) == 0 for a root.

      c is a color and character for nodes, or '' to not plot nodes.

      d is a color and character for edges, or '' to not plot edges.

      c or d may be omitted, and reasonable defaults are used.

  See also ETREE, TREELAYOUT, ETREEPLOT.


TRIL

 Lower triangle.

  TRIL(X) is the lower triangular part of X.

  TRIL(X,K) is the elements on and below the K-th diagonal

  of X .  K = 0 is the main diagonal, K > 0 is above the

  main diagonal and K < 0 is below the main diagonal.


TRIU

 Upper triangle.

  TRIU(X) is the upper triangular part of X.

  TRIU(X,K) is the elements on and above the K-th diagonal of

  X.  K = 0 is the main diagonal, K > 0 is above the main

  diagonal and K < 0 is below the main diagonal.


TYPE

 Show the contents of a text file.

  TYPE foo.bar lists the ascii file called foo.bar.

  TYPE foo lists the ascii file called foo.m.


UICONTROL

 Create user interface control.

  UICONTROL('PropertyName1',value1,'PropertyName2,'value2,...)

  creates a user interface control in the current figure

  window and returns a handle to it.

         UICONTROL properties can be set at object creation time using

         PropertyName/PropertyValue pair arguments to UICONTROL, or

  changed later using the SET command.

         Execute GET(H) to see a list of UICONTROL object properties and

         their current values. Execute SET(H) to see a list of UICONTROL

         object properties and legal property values. See a reference

  guide for more information.

  See also SET, GET, UIMENU.


UIGETFILE

 Interactively retrieve a filename by displaying a dialog box.

  [FILENAME, PATHNAME] = UIGETFILE('filterSpec', 'dialogTitle', X, Y)

  displays a dialog box for the user to fill in, and returns the

  filename and path strings.  A successful return occurs only if

  the file exists.  If the user selects a file that does not exist,

  an error message is displayed, and control returns to the dialog box.

  The user may then enter another filename, or press the Cancel button.

  All parameters are optional, but if one is used, all previous

  parameters must also be used.

  The filterSpec parameter determines the initial display of files in

  the dialog box.  For example '*.m' lists all the MATLAB M-files.

  Parameter 'dialogTitle' is a string containing the title of the dialog

  box.

  The X and Y parameters define the initial position of the dialog

  box in units of pixels.  Some systems may not support this option.

  The output variable FILENAME is a string containing the name of the

  file selected in the dialog box.  If the user presses the Cancel button

  or if any error occurs, it is set to 0.

  The output parameter PATHNAME is a string containing the path of

  the file selected in the dialog box.  If the user presses the Cancel

  button or if any error occurs, it is set to 0.

  See also UIPUTFILE.


UIMENU

 Create user interface menu.

  UIMENU('PropertyName1',value1,'PropertyName2,'value2,...) creates

  a menu on the menu bar at the top of the current figure window,

  and returns a handle to it.

  UIMENU(H,...) creates a new menu with H as a parent. H must be a

  figure handle or a menu handle. If H is a figure handle, UIMENU

  creates a menu on the menu bar at the top of the window. If H is

  handle to a menu on the menu bar, the new menu is a menu item

  beneath the parent item on the menu bar.  If H is a handle to a

  menu item, UIMENU creates a walking menu beneath the menu item.

  Menu properties can be set at object creation time using

  PropertyName/PropertyValue pair arguments to UIMENU, or changed

  later using the SET command.

         Execute GET(H) to see a list of UIMENU object properties and

         their current values. Execute SET(H) to see a list of UIMENU

         object properties and legal property values. See a reference

  guide for more information.

  See also SET, GET, UICONTROL.


UIPUTFILE

 Interactively retrieve a filename by displaying a dialog box.

  [FILENAME, PATHNAME] = UIPUTFILE('initFile', 'dialogTitle', X, Y)

  displays a dialog box for the user to fill in, and returns the

  filename and path strings.  A successful return occurs only if

  the file does not exist or if the user has given explicit permission

  to delete the file.

  If the user selects a file that exists,	a prompt is issued asking

  whether the user wishes to delete the file.  A 'YES' response

  successfully returns but does NOT delete the file (which is the

  responsibility of the calling routine).  A 'NO' response will

  simply return control back to the dialog box. The user may then

  enter another filename, or press the Cancel button.

  All parameters are optional, but if one is used, all previous

  parameters must also be used.

  The initFile parameter determines the initial display of files

  in the dialog box.  Full file name specifications as well as wildcards

  are allowed.  For example, 'newfile.m' initializes the display to

  that particular file and lists all other existing.m files.  This may

  be used to provide a default file name.  A wildcard specification such

  as '*.m' lists all the existing MATLAB M-files.

  Parameter 'dialogTitle' is a string containing the title of the dialog

  box.

  The X and Y parameters define the initial position of the dialog

  box in units of pixels.  Not all systems may support this option.

  The output variable FILENAME is a string containing the name of the

  file selected in the dialog box.  If the user presses the Cancel button

  or if any error occurs, it is set to 0.

  The output variable PATH is a string containing the name of the path

  selected in the dialog box.  If the user presses the Cancel button

  or if any error occurs, it is set to 0.

  Example:

  	[newmatfile, newpath] = uiputfile('*.mat', 'Save As');

  See also UIGETFILE.


UISETCOLOR

 Interactively set a ColorSpec by displaying a dialog box.

  C = UISETCOLOR(ARG, 'dialogTitle') displays a dialog box for the

  user to fill in, and applies the selected color to the input

  graphics object.

  The parameters are optional and may be specified in any order.

  ARG may be either a handle to a graphics object or an RGB triple.

  If a handle is used, it must specify a graphics object that supports

  color.  If RGB is used, it must be a valid RGB triple (e.g., [1 0 0]

  for red).  In both cases, the color specified is used to initialize

  the dialog box.  If no initial RGB is specified, the dialog box

  initializes the color to black.

  If parameter 'dialogTitle' is used, it is a string containing the

  title of the dialog box.

  The output value C is the selected RGB triple.  If the input parameter

  is a handle, the graphics object's color is set to the RGB color

  selected.

  If the user presses Cancel from the dialog box, or if any error

  occurs, the output value is set to the input RGB triple, if provided;

  otherwise, it is set to 0.

  Example:

  	C = uisetcolor(hText, 'Set Text Color')


UISETFONT

 Interactively set a font by displaying a dialog box.

  H = UISETFONT(HIN, 'dialogTitle') displays a dialog box for the

  user to fill in, and applies the selected font to the input

  graphics object.

  The parameters are optional and may be specified in any order.

  If parameter HIN is used, it must specify a handle to a text or

  axis graphics object.  The font properties currently assigned to this

  object are used to initialize the font dialog box.

  If parameter 'dialogTitle' is used, it is a string containing the

  title of the dialog box.

  The output H is is a handle to a graphics object.  If HIN is specified,

  H is identical to HIN.  If HIN is not specified, a new text object

  is created with the selected font properties, and its handle is

  returned.

  If the user presses Cancel from the dialog box, or if any error

  occurs, the output value is set to the input handle, if provided;

  otherwise, it is set to 0.

  Example:

  	uisetfont(hText, 'Update Font')


UNIX

 Execute UNIX operating system command.

  [status,result] = UNIX('command'), for UNIX systems, calls upon

  the operating system to execute the given command.  The resulting

  status and standard output are returned.

  Examples:

      [s,w] = unix('who')

  returns s = 0 and, in w, a MATLAB string containing a list of

  the users currently logged in.

      [s,w] = unix('why')

  returns a nonzero value in s to indicate failure and sets w to

  the null matrix because "why" is not a UNIX command.

      [s,m] = unix('matlab')

  never returns because running the second copy of MATLAB requires

  interactive user input which cannot be provided.

  See also ! (exclamation point) under PUNCT.


UNMESH

 Convert a list of mesh edges to a graph or matrix.

  [A,xy] = UNMESH(M)

  Input:

    Each row of M is a mesh edge in two dimensions, [x1 y1 x2 y2].

  Output:

    A is the Laplacian matrix of the mesh (the symmetric adjacency matrix

         with -1 for edges and degrees on diagonal).

    Each row of xy is a coordinate [x y] of a mesh point.

  See also MPLOT, GPLOT, SUBMESH.


UNMKPP

 Unmake piecewise polynomial.

      [breaks,coefs,l,k] = unmkpp(pp)

  takes apart the  pp  function into its pieces.

  See also MKPP, SPLINE, PPVAL.


UNWRAP

 Unwrap phase angle in radians.

  UNWRAP(P) unwraps radian phases P by changing absolute

  jumps greater than pi to their 2*pi complement.  It

  unwraps columnwise with matrices.

  UNWRAP(P,TOL) uses a jump tolerance of TOL rather

  than the default TOL = pi.

  See also ANGLE, ABS.


UPPER

 Convert string to upper case.

  A = upper(a) converts any lower case characters in a to

  the corresponding upper case character and leaves all

  other characters unchanged.

  See also LOWER.


VANDER

 Vandermonde matrix.

  VANDER(C) returns the Vandermonde matrix whose second to

  last column is C.  The j-th column of a Vandermonde

  matrix is given by A(:,j) = C^(n-j).


VER

 MATLAB version number.

  VER displays the current MATLAB and toolbox version numbers.

  VER(TBX) displays the current version information for the

  toolbox specified by the string TBX.


VERSION

 MATLAB version.

  VERSION returns a string containing the MATLAB version number.

  See also VER, README, HELP.


VIBES

 Movie of the vibrating L-shaped membrane.


VIEW

 3-D graph viewpoint specification.

  VIEW(AZ,EL) and VIEW([AZ,EL]) set the angle of the view from which an

  observer sees the current 3-D plot.  AZ is the azimuth or horizontal

  rotation and EL is the vertical elevation (both in degrees). Azimuth

  revolves about the z-axis, with positive values indicating counter-

  clockwise rotation of the viewpoint. Positive values of elevation

  correspond to moving above the object; negative values move below.

  VIEW([X Y Z]) sets the view angle in cartesian coordinates. The

  magnitude of vector X,Y,Z is ignored.

  Here are some examples:

  AZ = -37.5, EL = 30 is the default 3-D view.

  AZ = 0, EL = 90 is directly overhead and the default 2-D view.

  AZ = EL = 0 looks directly up the first column of the matrix.

  AZ = 180 is behind the matrix.

  VIEW(2) sets the default 2-D view, AZ = 0, EL = 90.

  VIEW(3) sets the default 3-D view, AZ = -37.5, EL = 30.

  [AZ,EL] = VIEW returns the current azimuth and elevation.

  VIEW(T) accepts a 4-by-4 transformation matrix, such as

  the perspective transformations generated by VIEWMTX.

  T = VIEW returns the current general 4-by-4 transformation matrix.

  See also VIEWMTX, the AXES properties View, Xform.


VIEWMTX

 Generate view transformation matrices.

  A=VIEWMTX(AZ,EL) returns the 4x4 orthographic transformation

  matrix, A, used to project 3-D vectors onto the 2-D plot surface.

  Uses the same definition for azumith and elevation as VIEW, in

  particular, AZ and EL must be in degrees.  Returns the same

  transformation matrix as the commands

  	VIEW(AZ,EL)

  	A = VIEW

  but doesn't change the current VIEW.

  A=VIEWMTX(AZ,EL,PHI) returns a 4x4 perspective transformation

  matrix used to project 3-D vectors onto the 2-D plot surface.

  PHI is the subtended view angle of the normalized plot cube

  (in degrees) and controls the amount of perspective distortion:

  	PHI =  0 degrees is orthographic projection

  	PHI = 10 degrees is like a telephoto lens

  	PHI = 25 degrees is like a normal lens

  	PHI = 60 degrees is like a wide angle lens

  The matrix A can be used to set the view transformation using

  VIEW(A).

  A=VIEWMTX(AZ,EL,PHI,XC) returns the perspective transformation

  matrix using XC as the target (or look-at) point within

  the normalized plot cube.  XC=[xc,yc,zc] specifies the

  point (xc,yc,zc) in the plot cube.  The default value is

  the closest point in the plot cube,

  XC = 0.5+sqrt(3)/2*[cos(EL)*sin(AZ),-cos(EL)*cos(AZ),sin(EL)].

  See also VIEW.


WATERFALL

 Waterfall plot.

  WATERFALL(...) is the same as MESH(...) except that the column lines of

  the mesh are not drawn - thus producing a "waterfall" plot, and the

  matrices are transposed so that they are oriented correctly for

  column-oriented data analysis.

  See also MESH.


WHAT

 List M-, MAT- and MEX-files.

  The command WHAT, by itself, lists the M-files, MAT-files

  and MEX-files in the current working directory.

  The command WHAT DIRNAME lists the files in directory dirname

  on the MATLABPATH.  It is not necessary to give the full path

  name of the directory; the last component, or last several

  components, are sufficient.

  For example, "what general" and "what matlab/general" both

  list the M-files in directory toolbox/matlab/general.

  See also DIR, WHO, WHICH, LOOKFOR.


WHATSNEW

 Display Readme files for MATLAB and toolboxes.

  WHATSNEW <toolboxpath> displays the Readme file for the toolbox

  with the specified toolbox path.  For example,

  whatsnew matlab    - Display MATLAB's Readme file.

  whatsnew signal    - Display Signal Processing Toolbox Readme file.

  whatsnew control   - Display Control Toolbox Readme file.

  The Readme files, if they exist for each product, contain descriptions

  of new functionality that is not described in the documentation.

  See also VER, HELP, WHICH, PATH, LOOKFOR.


WHICH

 Locate functions and files.

  WHICH FCN displays the full pathname of the specified function.

  The function can be an M-file, MEX-file, SIMULINK Graphical function,

  or built in.  Built in functions and SIMULINK functions display a

  message indicating that they are built in or part of SIMULINK.

  For example, "which inv" reveals that INV is a built in function and

  "which pinv" indicates that PINV is in directory toolbox/matlab/linalg.

  On the other hand "which inverse" probably says "inverse cannot be

  found" because there is no file "inverse.m" on the default MATLABPATH.

  Contrast this with "lookfor inverse" which takes longer to run, but

  which finds several matches to the keyword "inverse" in its search

  through all the HELP entries.  (If "inverse.m" does exist in the

  current directory, or in some private directory that has been added

  to MATLABPATH, "which inverse" would find it.)

  See also DIR, HELP, WHO, WHAT, EXIST, LOOKFOR.


WHILE

 Repeat statements an indefinite number of times.

  The general form of a WHILE statement is:

     WHILE variable, statement, ..., statement, END

  The statements are executed while the variable has all

  non-zero elements. The variable is usually the result of

  expr rop expr where rop is ==, <, >, <=, >=, or ~=.

  For example (assuming A already defined):

          E = 0*A; F = E + EYE(E); N = 1;

          WHILE NORM(E+F-E,1) > 0,

             E = E + F;

             F = A*F/N;

             N = N + 1;

          END


WHITE

 All white monochrome color map.

  WHITE(M) returns an M-by-3 matrix containing a white colormap.

  WHITE, by itself, is the same length as the current colormap.

  For example, to reset the colormap of the current figure:

            colormap(white)

  See also HSV, GRAY, HOT, COOL, COPPER, PINK, FLAG,

  COLORMAP, RGBPLOT.


WHITEBG

 Graphics figure default background color changed to white.

  WHITEBG changes the current figure's default background color

  to white as well as other properties so graphs look good.

  In addition, the root's default properties are set so

  subsequent plots in the current figure and new figures use

  the white background.


WHO

 List current variables.

  WHO lists the variables in the current workspace.

  WHOS lists more information about each variable.

  WHO GLOBAL and WHOS GLOBAL list the variables in the global workspace.


WHOS

 List information about current variables.

  WHOS is a long form of WHO.  It lists all the variables in

  the current workspace, together with information about their

  size, density, complexity, etc.


WHY

 Provides succinct answers to any questions.


WILKINSON

 Wilkinson's eigenvalue test matrix.

  WILKINSON(n) is J. H. Wilkinson's eigenvalue test matrix, Wn+.

  It is a symmetric, tridiagonal matrix with pairs of nearly,

  but not exactly, equal eigenvalues.

  The most frequently used case is WILKINSON(21).

  For example, WILKINSON(7) is

         3  1  0  0  0  0  0

         1  2  1  0  0  0  0

         0  1  1  1  0  0  0

         0  0  1  0  1  0  0

         0  0  0  1  1  1  0

         0  0  0  0  1  2  1

         0  0  0  0  0  1  3


XLABEL

 X-axis labels for 2-D and 3-D plots.

  XLABEL('text') adds text below the X-axis on the current axis.

  See also YLABEL, ZLABEL, TITLE, TEXT.


XOR

 Exclusive "or".

  xor(S,T) is the symmetric difference of the nonzero

  structures of S and T.  The result is one where

  either S or T, but not both, is nonzero.


XYZCHK

 Check arguments to 3-D data routines.

  [MSG,X,Y,Z] = XYZCHK(X,Y,Z)

    or

  [MSG,X,Y,Z,XI,YI] = XYZCHK(X,Y,Z,XI,YI)


YLABEL

 Y-axis labels for 2-D and 3-D plots.

  YLABEL('text') adds text beside the Y-axis on the current axis.

  See also XLABEL, ZLABEL, TITLE, TEXT.


ZERODEMO

 This demo shows how to find the zero of a function.


ZEROS

 All zeros.

  ZEROS(N) is an N-by-N matrix of zeros.

  ZEROS(M,N) or ZEROS([M,N]) is an M-by-N matrix of zeros.

  ZEROS(SIZE(A)) is the same size as A and all zeros.


ZLABEL

 Z-axis labels for 3-D plots.

  ZLABEL('text') adds text above the Z-axis on the current axis.

  See also XLABEL, YLABEL, TITLE, TEXT.


index
Function Index

 ABS	ACOS	ACOSH	ACOT

  ACOTH	ACSC	ACSCH	AIRFOIL

  ALL	ANDREW	ANGLE	ANS

  ANY	ARITH	ASEC	ASECH

  ASIN	ASINH	ATAN	ATAN2

  ATANH	AUREAD	AUWRITE	AXES

  AXIS	BALANCE	BAR	BENCH

  BESSEL	BESSELA	BESSELI	BESSELJ

  BESSELK	BESSELY	BETA	BETACORE

  BETAINC	BETALN	BLANKS	BLT

  BONE	BREAK	BRIGHTEN	BUCKY

  BUTTONV	CART2POL	CART2SPH	CAXIS

  CD	CDF2RDF	CEDIT	CEIL

  CENSUS	CENSUSEX	CHOICES	CHOICEX

  CHOL	CINVERT	CLA	CLABEL

  CLC	CLEAR	CLF	CLG

  CLOCK	CLOSE	COLMMD	COLON

  COLORMAP	COLORMENU	COLPERM	COLSTYLE

  COMET	COMET3	COMPAN	COMPASS

  COMPUTER	COND	CONDEST	CONJ

  CONTOUR	CONTOUR3	CONTOURC	CONTRAST

  CONV	CONV2	COOL	COPPER

  CORRCOEF	COS	COSH	COT

  COTH	COV	CPLXDEMO	CPLXGRID

  CPLXMAP	CPLXPAIR	CPLXROOT	CPUTIME

  CROSS	CSC	CSCH	CUMPROD

  CUMSUM	CYLINDER	DATALIST	DATE

  DBCLEAR	DBCONT	DBDOWN	DBQUIT

  DBSTACK	DBSTATUS	DBSTEP	DBSTOP

  DBTYPE	DBUP	DC2SC	DEBLANK

  DEBUG	DEC2HEX	DECONV	DEL2

  DELETE	DELSQ	DELSQDEMO	DELSQSHOW

  DEMO	DET	DIAG	DIARY

  DIFF	DIFFUSE	DIR	DISP

  DMPERM	DOS	DRAWNOW	EARTHEX

  EARTHMAP	ECHO	EIG	EIGMOVIE

  ELLIPJ	ELLIPK	ELLIPKE	ELSE

  ELSEIF	END	EPS	ERF

  ERFC	ERFCORE	ERFCX	ERFINV

  ERROR	ERRORBAR	ETIME	ETREE

  ETREEPLOT	EVAL	EXIST	EXP

  EXPM	EXPM1	EXPM2	EXPM3

  EYE	FCLOSE	FEATHER	FEOF

  FERROR	FEVAL	FFT	FFT2

  FFTDEMO	FFTSHIFT	FGETL	FGETS

  FIGTEXT	FIGURE	FILL	FILL3

  FILTER	FILTER2	FIND	FINDSTR

  FINITE	FITDEMO	FITFUN	FIX

  FLAG	FLIPLR	FLIPUD	FLOOR

  FLOPS	FMIN	FMINS	FOPEN

  FOPTIONS	FOR	FORMAT	FOURIER

  FPLOT	FPLOTDEMO	FPRINTF	FREAD

  FREWIND	FSCANF	FSEEK	FTELL

  FULL	FUNCTION	FUNM	FWRITE

  FZERO	GALLERY	GAMMA	GAMMAINC

  GAMMALN	GCA	GCD	GCF

  GET	GETENV	GETFRAME	GINPUT

  GLOBAL	GPLOT	GRADIENT	GRAY

  GRAYMON	GRID	GRIDDATA	GTEXT

  HADAMARD	HANKEL	HARDCOPY	HELP

  HESS	HEX2DEC	HEX2NUM	HIDDEN

  HIGHLIGHT	HILB	HINT	HIST

  HOLD	HOME	HOSTID	HOT

  HSV	HSV2RGB	HUMPS	I

  ICUBIC	IF	IFFT	IFFT2

  IMAG	IMAGE	IMAGEDEMO	IMAGEEXT

  IMAGESC	IMREAD	IMTEXT	IMWRITE

  INF	INFO	INPUT	INQUIRE

  INT2STR	INTERP1	INTERP2	INTERP3

  INTERP4	INTERP5	INTERPFT	INTRO

  INV	INVERF	INVHILB	ISEMPTY

  ISGLOBAL	ISHOLD	ISIEEE	ISINF

  ISLETTER	ISNAN	ISSPARSE	ISSTR

  ISUNIX	J	JET	KEYBOARD

  KNOT	KRON	LALALA	LASTERR

  LCM	LENGTH	LIFE	LIFELOOP

  LIN2MU	LINE	LINSPACE	LOAD

  LOADWAVE	LOG	LOG10	LOG2

  LOGLOG	LOGM	LOGSPACE	LOOKFOR

  LORENZ	LORENZEQ	LOTKA	LOWER

  LS	LSCOV	LU	MAGIC

  MAN	MATHLIST	MATLABRO	MAX

  MEAN	MEDIAN	MEMBRANE	MEMORY

  MENU	MESH	MESHC	MESHDOM

  MESHGRID	MESHZ	META	MIN

  MKPP	MMOVE2	MORE	MOVIE

  MOVIEIN	MU2LIN	NALIST	NAN

  NARGCHK	NARGIN	NARGOUT	NESTDISS

  NESTED	NEWPLOT	NEXTPOW2	NNLS

  NNZ	NONZEROS	NORM	NORMEST

  NULL	NUM2STR	NUMGRID	NZMAX

  ODE23	ODE23P	ODE45	ODEDEMO

  ONES	ORIENT	ORTH	PACK

  PAREN	PASCAL	PATCH	PATH

  PAUSE	PCOLOR	PEAKS	PENNY

  PI	PINK	PINV	PLANEROT

  PLOT	PLOT3	POL2CART	POLAR

  POLY	POLYDER	POLYFIT	POLYLINE

  POLYMARK	POLYVAL	POLYVALM	POW2

  PPVAL	PRINT	PRINTOPT	PRISM

  PROD	PUNCT	PUZZLE	PWD

  QR	QRDELETE	QRINSERT	QUAD

  QUAD8	QUAD8STP	QUADDEMO	QUADSTP

  QUAKE	QUIT	QUIVER	QZ

  RAND	RANDN	RANDPERM	RANK

  RAT	RATS	RBBOX	RCOND

  README	REAL	REALMAX	REALMIN

  RELOP	REM	RESET	RESHAPE

  RESI2	RESIDUE	RETURN	RGB2HSV

  RGBPLOT	RJR	ROOTS	ROSE

  ROSSER	ROT90	ROUND	RREF

  RREFMOVIE	RSF2CSF	SAVE	SAVEWAVE

  SAXIS	SC2DC	SCHUR	SCRIPT

  SEC	SECH	SEMILOGX	SEMILOGY

  SEPDEMO	SEPPLOT	SET	SETSTR

  SHADING	SHG	SHOWWIND	SIG1HELP

  SIG2HELP	SIGDEMO1	SIGDEMO2	SIGN

  SIN	SINH	SIZE	SLASH

  SLICE	SORT	SOUND	SOUNDDEMO

  SOUNDEXT	SPALLOC	SPARLIST	SPARSE

  SPARSFUN	SPARSITY	SPAUGMENT	SPCONVERT

  SPDIAGS	SPECIALS	SPECULAR	SPEYE

  SPFUN	SPH2CART	SPHERE	SPINMAP

  SPIRAL	SPLINE	SPLINE2D	SPONES

  SPPARMS	SPRANDN	SPRANDSYM	SPRANK

  SPRINTF	SPY	SPYPART	SQDEMO

  SQRT	SQRTM	SSCANF	STAIRS

  STD	STEM	STR2MAT	STR2NUM

  STRCMP	STRINGS	SUBPLOT	SUBSCRIBE

  SUBSPACE	SUM	SUNSPOTS	SUPERQUAD

  SURF	SURFACE	SURFC	SURFL

  SURFNORM	SVD	SWAPPREV	SYMBFACT

  SYMMMD	SYMRCM	TABLE1	TABLE2

  TAN	TANH	TEMPDIR	TEMPNAME

  TERMINAL	TEXT	TFFUNC	TIC

  TITLE	TOC	TOEPLITZ	TRACE

  TRAPZ	TREELAYOUT	TREEPLOT	TRIL

  TRIU	TYPE	UICONTROL	UIGETFILE

  UIMENU	UIPUTFILE	UISETCOLOR	UISETFONT

  UNIX	UNMESH	UNMKPP	UNWRAP

  UPPER	VANDER	VER	VERSION

  VIBES	VIEW	VIEWMTX	WATERFALL

  WHAT	WHATSNEW	WHICH	WHILE

  WHITE	WHITEBG	WHO	WHOS

  WHY	WILKINSON	XLABEL	XOR

  XYZCHK	YLABEL	ZERODEMO	ZEROS

  ZLABEL


CONTENTS

 Help is available for MATLAB functions in the following areas. The

  subject names also correspond to the directory names in which the

  corresponding M-files are stored.

      COLOR	-  Color control and lighting model functions.

      DATAFUN	-  Data analysis and Fourier transform functions.

      DEMOS	-  Demonstrations and samples.

      ELFUN	-  Elementary math functions.

      ELMAT	-  Elementary matrices and matrix manipulation.

      FUNFUN	-  Function functions - nonlinear numerical methods.

      GENERAL	-  General purpose commands.

      GRAPHICS	-  General purpose graphics functions.

      IOFUN	-  Low-level file I/O functions.

      LANG	-  Language constructs and debugging.

      MATFUN	-  Matrix functions - numerical linear algebra.

      OPS	-  Operators and special characters.

      PLOTXY	-  Two dimensional graphics.

      PLOTXYZ	-  Three dimensional graphics.

      POLYFUN	-  Polynomial and interpolation functions.

      SOUNDS	-  Sound processing functions.

      SPARFUN	-  Sparse matrix functions.

      SPECFUN	-  Specialized math functions.

      SPECMAT	-  Specialized matrices.

      STRFUN	-  Character string functions.

  You can also refer to the function INDEX for a complete listing of

  all the functions for which help is available.