Go to main content

man pages section 1: User Commands

Exit Print View

Updated: Thursday, March 14, 2019
 
 

mathop (1t)

Name

mathop - Mathematical operators as Tcl commands

Synopsis

package require Tcl 8.5

::tcl::mathop::! number
::tcl::mathop::~ number
::tcl::mathop::+ ?number ...?
::tcl::mathop::- number ?number ...?
::tcl::mathop::* ?number ...?
::tcl::mathop::/ number ?number ...?
::tcl::mathop::% number number
::tcl::mathop::** ?number ...?
::tcl::mathop::& ?number ...?
::tcl::mathop::| ?number ...?
::tcl::mathop::^ ?number ...?
::tcl::mathop::<< number number
::tcl::mathop::>> number number
::tcl::mathop::== ?arg ...?
::tcl::mathop::!= arg arg
::tcl::mathop::< ?arg ...?
::tcl::mathop::<= ?arg ...?
::tcl::mathop::>= ?arg ...?
::tcl::mathop::> ?arg ...?
::tcl::mathop::eq ?arg ...?
::tcl::mathop::ne arg arg
::tcl::mathop::in arg list
::tcl::mathop::ni arg list

Description

Tcl Mathematical Operator Commands                                  mathop(1t)



______________________________________________________________________________

NAME
       mathop - Mathematical operators as Tcl commands

SYNOPSIS
       package require Tcl 8.5

       ::tcl::mathop::! number
       ::tcl::mathop::~ number
       ::tcl::mathop::+ ?number ...?
       ::tcl::mathop::- number ?number ...?
       ::tcl::mathop::* ?number ...?
       ::tcl::mathop::/ number ?number ...?
       ::tcl::mathop::% number number
       ::tcl::mathop::** ?number ...?
       ::tcl::mathop::& ?number ...?
       ::tcl::mathop::| ?number ...?
       ::tcl::mathop::^ ?number ...?
       ::tcl::mathop::<< number number
       ::tcl::mathop::>> number number
       ::tcl::mathop::== ?arg ...?
       ::tcl::mathop::!= arg arg
       ::tcl::mathop::< ?arg ...?
       ::tcl::mathop::<= ?arg ...?
       ::tcl::mathop::>= ?arg ...?
       ::tcl::mathop::> ?arg ...?
       ::tcl::mathop::eq ?arg ...?
       ::tcl::mathop::ne arg arg
       ::tcl::mathop::in arg list
       ::tcl::mathop::ni arg list

______________________________________________________________________________

DESCRIPTION
       The  commands  in the ::tcl::mathop namespace implement the same set of
       operations as supported by the expr command. All are exported from  the
       namespace,  but  are  not imported into any other namespace by default.
       Note that renaming, reimplementing or deleting any of the  commands  in
       the namespace does not alter the way that the expr command behaves, and
       nor does defining any new commands in the ::tcl::mathop namespace.

       The following operator commands are supported:

              ~       !       +       -      *
              /       %       **      &      |
              ^       >>      <<      ==     eq
              !=      ne      <       <=     >
              >=      in      ni


   MATHEMATICAL OPERATORS
       The behaviors of the mathematical operator commands are as follows:

       ! boolean
              Returns the boolean negation of boolean, where  boolean  may  be
              any  numeric  value  or any other form of boolean value (i.e. it
              returns truth if the argument is falsity or zero, and falsity if
              the argument is truth or non-zero).

       + ?number ...?
              Returns the sum of arbitrarily many arguments. Each number argu-
              ment may be any numeric value. If no arguments  are  given,  the
              result will be zero (the summation identity).

       - number ?number ...?
              If  only a single number argument is given, returns the negation
              of that numeric value. Otherwise returns the number that results
              when all subsequent numeric values are subtracted from the first
              one. All number arguments must be numeric values. At  least  one
              argument must be given.

       * ?number ...?
              Returns  the  product of arbitrarily many arguments. Each number
              may be any numeric value. If no arguments are given, the  result
              will be one (the multiplicative identity).

       / number ?number ...?
              If  only a single number argument is given, returns the recipro-
              cal of that numeric value (i.e. the value obtained  by  dividing
              1.0  by  that value).  Otherwise returns the number that results
              when the first numeric argument is  divided  by  all  subsequent
              numeric  arguments. All number arguments must be numeric values.
              At least one argument must be given.

              Note that when the leading values in the list of  arguments  are
              integers,  integer division will be used for those initial steps
              (i.e. the intermediate results will be as if the functions floor
              and  int  are  applied to them, in that order). If all values in
              the operation are integers, the result will be an integer.

       % number number
              Returns the integral modulus  (i.e.,  remainder)  of  the  first
              argument  with  respect to the second.  Each number must have an
              integral value.  Also, the sign of the result will be  the  same
              as the sign of the second number, which must not be zero.

              Note  that  Tcl defines this operation exactly even for negative
              numbers, so that the following  command  returns  a  true  value
              (omitting the namespace for clarity):

                     == [* [/ x y] y] [- x [% x y]]

       ** ?number ...?
              Returns  the  result  of  raising each value to the power of the
              result of recursively operating on the result of processing  the
              following  arguments,  so  "** 2 3 4" is the same as "** 2 [** 3
              4]".  Each number may be any numeric value,  though  the  second
              number  must  not  be fractional if the first is negative. If no
              arguments are given, the result will be one,  and  if  only  one
              argument  is given, the result will be that argument. The result
              will have an integral value only when all arguments are integral
              values.

   COMPARISON OPERATORS
       The  behaviors of the comparison operator commands (most of which oper-
       ate preferentially on numeric arguments) are as follows:

       == ?arg ...?
              Returns whether each argument is equal to the arguments on  each
              side  of  it in the sense of the expr == operator (i.e., numeric
              comparison if possible, exact string comparison  otherwise).  If
              fewer  than  two  arguments  are  given,  this  operation always
              returns a true value.

       eq ?arg ...?
              Returns whether each argument is equal to the arguments on  each
              side  of  it  using  exact  string comparison. If fewer than two
              arguments are given, this operation always returns a true value.

       != arg arg
              Returns whether the two arguments are not equal to  each  other,
              in  the  sense of the expr != operator (i.e., numeric comparison
              if possible, exact string comparison otherwise).

       ne arg arg
              Returns whether the two arguments are not equal  to  each  other
              using exact string comparison.

       < ?arg ...?
              Returns whether the arbitrarily-many arguments are ordered, with
              each argument after the first having to be  strictly  more  than
              the  one preceding it.  Comparisons are performed preferentially
              on the numeric values, and are otherwise performed using UNICODE
              string comparison. If fewer than two arguments are present, this
              operation always returns a true value. When  the  arguments  are
              numeric  but  should  be compared as strings, the string compare
              command should be used instead.

       <= ?arg ...?
              Returns whether the arbitrarily-many arguments are ordered, with
              each argument after the first having to be equal to or more than
              the one preceding it.  Comparisons are performed  preferentially
              on the numeric values, and are otherwise performed using UNICODE
              string comparison. If fewer than two arguments are present, this
              operation  always  returns  a true value. When the arguments are
              numeric but should be compared as strings,  the  string  compare
              command should be used instead.

       > ?arg ...?
              Returns whether the arbitrarily-many arguments are ordered, with
              each argument after the first having to be  strictly  less  than
              the  one preceding it.  Comparisons are performed preferentially
              on the numeric values, and are otherwise performed using UNICODE
              string comparison. If fewer than two arguments are present, this
              operation always returns a true value. When  the  arguments  are
              numeric  but  should  be compared as strings, the string compare
              command should be used instead.

       >= ?arg ...?
              Returns whether the arbitrarily-many arguments are ordered, with
              each argument after the first having to be equal to or less than
              the one preceding it.  Comparisons are performed  preferentially
              on the numeric values, and are otherwise performed using UNICODE
              string comparison. If fewer than two arguments are present, this
              operation  always  returns  a true value. When the arguments are
              numeric but should be compared as strings,  the  string  compare
              command should be used instead.

   BIT-WISE OPERATORS
       The  behaviors  of  the  bit-wise  operator commands (all of which only
       operate on integral arguments) are as follows:

       ~ number
              Returns the bit-wise negation of number. Number may be an  inte-
              ger  of  any  size.  Note that the result of this operation will
              always have the opposite sign to the input number.

       & ?number ...?
              Returns the bit-wise AND of each of the arbitrarily  many  argu-
              ments.  Each number must have an integral value. If no arguments
              are given, the result will be minus one.

       | ?number ...?
              Returns the bit-wise OR of each of the  arbitrarily  many  argu-
              ments.  Each number must have an integral value. If no arguments
              are given, the result will be zero.

       ^ ?number ...?
              Returns the bit-wise XOR of each of the arbitrarily  many  argu-
              ments.  Each number must have an integral value. If no arguments
              are given, the result will be zero.

       << number number
              Returns the result of bit-wise shifting the first argument  left
              by  the  number  of  bits specified in the second argument. Each
              number must have an integral value.

       >> number number
              Returns the result of bit-wise shifting the first argument right
              by  the  number  of  bits specified in the second argument. Each
              number must have an integral value.

   LIST OPERATORS
       The behaviors of the list-oriented operator commands are as follows:

       in arg list
              Returns whether the value  arg  is  present  in  the  list  list
              (according to exact string comparison of elements).

       ni arg list
              Returns  whether  the  value arg is not present in the list list
              (according to exact string comparison of elements).

EXAMPLES
       The simplest way to use the operators is often by using namespace  path
       to make the commands available. This has the advantage of not affecting
       the set of commands defined by the current namespace.

              namespace path {::tcl::mathop ::tcl::mathfunc}

              # Compute the sum of some numbers
              set sum [+ 1 2 3]

              # Compute the average of a list
              set list {1 2 3 4 5 6}
              set mean [/ [+ {*}$list] [double [llength $list]]]

              # Test for list membership
              set gotIt [in 3 $list]

              # Test to see if a value is within some defined range
              set inRange [<= 1 $x 5]

              # Test to see if a list is sorted
              set sorted [<= {*}$list]


ATTRIBUTES
       See attributes(7) for descriptions of the following attributes:


       +---------------+------------------+
       |ATTRIBUTE TYPE | ATTRIBUTE VALUE  |
       +---------------+------------------+
       |Availability   | runtime/tcl-8    |
       +---------------+------------------+
       |Stability      | Uncommitted      |
       +---------------+------------------+
SEE ALSO
       expr(n), mathfunc(n), namespace(n)

KEYWORDS
       command, expression, operator



NOTES
       This    software    was    built    from    source     available     at
       https://github.com/oracle/solaris-userland.    The  original  community
       source was downloaded from  http://prdownloads.sourceforge.net/tcl/tcl-
       core8.6.7-src.tar.gz

       Further information about this software can be found on the open source
       community website at https://www.tcl.tk/.



Tcl                                   8.5                           mathop(1t)