NAME
       expr - Evaluate an expression

SYNOPSIS
       expr arg ?arg arg ...?


DESCRIPTION
       Concatenates arg's (adding separator spaces between them),
       evaluates the result as a Tcl expression, and returns  the
       value.   The  operators permitted in Tcl expressions are a
       subset of the operators permitted in  C  expressions,  and
       they  have  the  same meaning and precedence as the corre-
       sponding C operators.   Expressions  almost  always  yield
       numeric  results  (integer or floating-point values).  For
       example, the expression
              expr 8.2 + 6
       evaluates to 14.2.  Tcl expressions differ from C  expres-
       sions  in  the way that operands are specified.  Also, Tcl
       expressions support non-numeric operands and  string  com-
       parisons.

OPERANDS
       A  Tcl  expression  consists of a combination of operands,
       operators, and  parentheses.   White  space  may  be  used
       between  the operands and operators and parentheses; it is
       ignored by  the  expression  processor.   Where  possible,
       operands  are interpreted as integer values.  Integer val-
       ues may be specified in  decimal  (the  normal  case),  in
       octal  (if the first character of the operand is 0), or in
       hexadecimal (if the first two characters  of  the  operand
       are  0x).   If an operand does not have one of the integer
       formats given above, then it is  treated  as  a  floating-
       point  number if that is possible.  Floating-point numbers
       may be specified in any of the ways accepted by  an  ANSI-
       compliant C compiler (except that the ``f'', ``F'', ``l'',
       and ``L'' suffixes will not be permitted in most installa-
       tions).   For  example,  all  of  the  following are valid
       floating-point numbers:  2.1, 3., 6e4,  7.91e+16.   If  no
       numeric  interpretation  is  possible,  then an operand is
       left as a string (and only a limited set of operators  may
       be applied to it).

       Operands may be specified in any of the following ways:

       [1]    As  an  numeric  value, either integer or floating-
              point.

       [2]    As a Tcl variable, using standard $ notation.   The
              variable's value will be used as the operand.

       [3]    As a string enclosed in double-quotes.  The expres-
              sion parser will perform backslash,  variable,  and
              command  substitutions  on  the information between
              the quotes, and use  the  resulting  value  as  the
              operand

       [4]    As  a  string  enclosed  in braces.  The characters
              between the open brace  and  matching  close  brace
              will  be  used as the operand without any substitu-
              tions.

       [5]    As a Tcl command enclosed in brackets.  The command
              will be executed and its result will be used as the
              operand.

       [6]    As a mathematical function whose arguments have any
              of   the   above   forms   for  operands,  such  as
              ``sin($x)''.  See below for a list of defined func-
              tions.

       Where   substitutions  occur  above  (e.g.  inside  quoted
       strings), they are performed by the expression  processor.
       However,  an  additional layer of substitution may already
       have been performed  by  the  command  parser  before  the
       expression  processor  was called.  As discussed below, it
       is usually best to enclose expressions in braces  to  pre-
       vent  the  command parser from performing substitutions on
       the contents.

       For some examples of simple expressions, suppose the vari-
       able a has the value 3 and the variable b has the value 6.
       Then the command on the left side of  each  of  the  lines
       below  will  produce  the  value  on the right side of the
       line:
              expr 3.1 + $a           6.1
              expr 2 + "$a.$b"        5.6
              expr 4*[llength "6 2"]  8
              expr {{word one} < "word $a"}0

OPERATORS
       The valid operators are listed below, grouped in  decreas-
       ing order of precedence:

       -  +  ~  !          Unary minus, unary plus, bit-wise NOT,
                           logical NOT.  None of  these  operands
                           may be applied to string operands, and
                           bit-wise NOT may be  applied  only  to
                           integers.

       *  /  %             Multiply,  divide, remainder.  None of
                           these  operands  may  be  applied   to
                           string  operands, and remainder may be
                           applied only to integers.  The remain-
                           der  will always have the same sign as
                           the  divisor  and  an  absolute  value
                           smaller than the divisor.
       +  -                Add   and  subtract.   Valid  for  any
                           numeric operands.

       <<  >>              Left and right shift.  Valid for inte-
                           ger  operands  only.   A  right  shift
                           always propagates the sign bit.

       <  >  <=  >=        Boolean less, greater,  less  than  or
                           equal,  and  greater  than  or  equal.
                           Each operator produces 1 if the condi-
                           tion  is  true,  0  otherwise.   These
                           operators may be applied to strings as
                           well  as  numeric  operands,  in which
                           case string comparison is used.

       ==  !=              Boolean equal  and  not  equal.   Each
                           operator  produces  a zero/one result.
                           Valid for all operand types.

       &                   Bit-wise  AND.   Valid   for   integer
                           operands only.

       ^                   Bit-wise   exclusive  OR.   Valid  for
                           integer operands only.

       |                   Bit-wise  OR.    Valid   for   integer
                           operands only.

       &&                  Logical  AND.   Produces a 1 result if
                           both operands are non-zero,  0  other-
                           wise.  Valid for numeric operands only
                           (integers or floating-point).

       ||                  Logical OR.  Produces a  0  result  if
                           both  operands  are zero, 1 otherwise.
                           Valid for numeric operands only (inte-
                           gers or floating-point).

       x?y:z               If-then-else, as in C.  If x evaluates
                           to non-zero, then the  result  is  the
                           value  of  y.  Otherwise the result is
                           the value of z.  The  x  operand  must
                           have a numeric value.

       See  the C manual for more details on the results produced
       by each operator.  All of the binary operators group left-
       to-right  within  the same precedence level.  For example,
       the command
              expr 4*2 < 7
       returns 0.

       The &&, ||, and ?:  operators  have  ``lazy  evaluation'',
       just  as in C, which means that operands are not evaluated
       if they are not needed  to  determine  the  outcome.   For
       example, in the command
              expr {$v ? [a] : [b]}
       only one of [a] or [b] will actually be evaluated, depend-
       ing on the value of $v.  Note, however, that this is  only
       true if the entire expression is enclosed in braces;  oth-
       erwise the Tcl parser  will  evaluate  both  [a]  and  [b]
       before invoking the expr command.

MATH FUNCTIONS
       Tcl  supports  the  following  mathematical  functions  in
       expressions:

              acos        cos         hypot      sinh
              asin        cosh        log        sqrt
              atan        exp         log10      tan
              atan2       floor       pow        tanh
              ceil        fmod        sin

       Each of these functions invokes the math library  function
       of  the same name;  see the manual entries for the library
       functions for details on what they do.   Tcl  also  imple-
       ments the following functions for conversion between inte-
       gers and floating-point numbers:

       abs(arg)
              Returns the absolute value  of  arg.   Arg  may  be
              either integer or floating-point, and the result is
              returned in the same form.

       double(arg)
              If arg is a floating value, returns arg,  otherwise
              converts  arg to floating and returns the converted
              value.

       int(arg)
              If arg is an integer value, returns arg,  otherwise
              converts  arg  to integer by truncation and returns
              the converted value.

       round(arg)
              If arg is an integer value, returns arg,  otherwise
              converts arg to integer by rounding and returns the
              converted value.

       In addition to these  predefined  functions,  applications
       may       define      additional      functions      using
       Tcl_CreateMathFunc().

TYPES, OVERFLOW, AND PRECISION
       All internal computations involving integers are done with
       the  C  type long, and all internal computations involving
       floating-point are done with the C type double.  When con-
       verting  a  string to floating-point, exponent overflow is
       detected and results in a Tcl error.   For  conversion  to
       integer  from string, detection of overflow depends on the
       behavior of some routines in the local C  library,  so  it
       should  be  regarded  as unreliable.  In any case, integer
       overflow and underflow are generally not detected reliably
       for  intermediate  results.   Floating-point  overflow and
       underflow are detected to  the  degree  supported  by  the
       hardware, which is generally pretty reliable.

       Conversion  among  internal  representations  for integer,
       floating-point, and string operands is done  automatically
       as needed.  For arithmetic computations, integers are used
       until some  floating-point  number  is  introduced,  after
       which floating-point is used.  For example,
              expr 5 / 4
       returns 1, while
              expr 5 / 4.0
              expr 5 / ( [string length "abcd"] + 0.0 )
       both   return  1.25.   Floating-point  values  are  always
       returned with a ``.''  or an ``e'' so that they  will  not
       look like integer values.  For example,
              expr 20.0/5.0
       returns   ``4.0'',   not   ``4''.    The  global  variable
       tcl_precision determines the  the  number  of  significant
       digits  that  are  retained  when floating values are con-
       verted to strings (except that trailing zeroes  are  omit-
       ted).   If  tcl_precision is unset then 6 digits of preci-
       sion are used.  To retain all of the significant  bits  of
       an IEEE floating-point number set tcl_precision to 17;  if
       a value is converted to string with 17 digits of precision
       and  then converted back to binary for some later calcula-
       tion, the resulting binary value is guaranteed to be iden-
       tical to the original one.


STRING OPERATIONS
       String  values  may  be used as operands of the comparison
       operators, although the expression evaluator tries  to  do
       comparisons  as integer or floating-point when it can.  If
       one of the operands of a comparison is a  string  and  the
       other  has  a  numeric  value, the numeric operand is con-
       verted back to a string using the C sprintf format  speci-
       fier  %d  for  integers  and %g for floating-point values.
       For example, the commands
              expr {"0x03" > "2"}
              expr {"0y" < "0x12"}
       both return 1.  The first comparison is done using integer
       comparison, and the second is done using string comparison
       after the  second  operand  is  converted  to  the  string
       ``18''.  Because of Tcl's tendency to treat values as num-
       bers whenever possible, it isn't generally a good idea  to
       use operators like == when you really want string compari-
       son and the values of the  operands  could  be  arbitrary;
       it's  better in these cases to use the string compare com-
       mand instead.
KEYWORDS
       arithmetic, boolean, compare, expression
