NAME

       PDL::Ops - Fundamental mathematical operators

DESCRIPTION

       This module provides the functions used by PDL to overload the basic mathematical
       operators ("+ - / *" etc.) and functions ("sin sqrt" etc.)

       It also includes the function "log10", which should be a perl function so that we can
       overload it!

       Matrix multiplication (the operator "x") is handled by the module PDL::Primitive.

SYNOPSIS

       none

FUNCTIONS

   plus
         Signature: (a(); b(); [o]c(); int swap)

       add two piddles

          $c = plus $a, $b, 0;     # explicit call with trailing 0
          $c = $a + $b;           # overloaded call
          $a->inplace->plus($b,0);  # modify $a inplace

       It can be made to work inplace with the "$a->inplace" syntax.  This function is used to
       overload the binary "+" operator.  Note that when calling this function explicitly you
       need to supply a third argument that should generally be zero (see first example).  This
       restriction is expected to go away in future releases.

       plus processes bad values.  The state of the bad-value flag of the output piddles is
       unknown.

   mult
         Signature: (a(); b(); [o]c(); int swap)

       multiply two piddles

          $c = mult $a, $b, 0;     # explicit call with trailing 0
          $c = $a * $b;           # overloaded call
          $a->inplace->mult($b,0);  # modify $a inplace

       It can be made to work inplace with the "$a->inplace" syntax.  This function is used to
       overload the binary "*" operator.  Note that when calling this function explicitly you
       need to supply a third argument that should generally be zero (see first example).  This
       restriction is expected to go away in future releases.

       mult processes bad values.  The state of the bad-value flag of the output piddles is
       unknown.

   minus
         Signature: (a(); b(); [o]c(); int swap)

       subtract two piddles

          $c = minus $a, $b, 0;     # explicit call with trailing 0
          $c = $a - $b;           # overloaded call
          $a->inplace->minus($b,0);  # modify $a inplace

       It can be made to work inplace with the "$a->inplace" syntax.  This function is used to
       overload the binary "-" operator.  Note that when calling this function explicitly you
       need to supply a third argument that should generally be zero (see first example).  This
       restriction is expected to go away in future releases.

       minus processes bad values.  The state of the bad-value flag of the output piddles is
       unknown.

   divide
         Signature: (a(); b(); [o]c(); int swap)

       divide two piddles

          $c = divide $a, $b, 0;     # explicit call with trailing 0
          $c = $a / $b;           # overloaded call
          $a->inplace->divide($b,0);  # modify $a inplace

       It can be made to work inplace with the "$a->inplace" syntax.  This function is used to
       overload the binary "/" operator.  Note that when calling this function explicitly you
       need to supply a third argument that should generally be zero (see first example).  This
       restriction is expected to go away in future releases.

       divide processes bad values.  The state of the bad-value flag of the output piddles is
       unknown.

   gt
         Signature: (a(); b(); [o]c(); int swap)

       the binary > (greater than) operation

          $c = gt $a, $b, 0;     # explicit call with trailing 0
          $c = $a > $b;           # overloaded call
          $a->inplace->gt($b,0);  # modify $a inplace

       It can be made to work inplace with the "$a->inplace" syntax.  This function is used to
       overload the binary ">" operator.  Note that when calling this function explicitly you
       need to supply a third argument that should generally be zero (see first example).  This
       restriction is expected to go away in future releases.

       gt processes bad values.  The state of the bad-value flag of the output piddles is
       unknown.

   lt
         Signature: (a(); b(); [o]c(); int swap)

       the binary < (less than) operation

          $c = lt $a, $b, 0;     # explicit call with trailing 0
          $c = $a < $b;           # overloaded call
          $a->inplace->lt($b,0);  # modify $a inplace

       It can be made to work inplace with the "$a->inplace" syntax.  This function is used to
       overload the binary "<" operator.  Note that when calling this function explicitly you
       need to supply a third argument that should generally be zero (see first example).  This
       restriction is expected to go away in future releases.

       lt processes bad values.  The state of the bad-value flag of the output piddles is
       unknown.

   le
         Signature: (a(); b(); [o]c(); int swap)

       the binary <= (less equal) operation

          $c = le $a, $b, 0;     # explicit call with trailing 0
          $c = $a <= $b;           # overloaded call
          $a->inplace->le($b,0);  # modify $a inplace

       It can be made to work inplace with the "$a->inplace" syntax.  This function is used to
       overload the binary "<=" operator.  Note that when calling this function explicitly you
       need to supply a third argument that should generally be zero (see first example).  This
       restriction is expected to go away in future releases.

       le processes bad values.  The state of the bad-value flag of the output piddles is
       unknown.

   ge
         Signature: (a(); b(); [o]c(); int swap)

       the binary >= (greater equal) operation

          $c = ge $a, $b, 0;     # explicit call with trailing 0
          $c = $a >= $b;           # overloaded call
          $a->inplace->ge($b,0);  # modify $a inplace

       It can be made to work inplace with the "$a->inplace" syntax.  This function is used to
       overload the binary ">=" operator.  Note that when calling this function explicitly you
       need to supply a third argument that should generally be zero (see first example).  This
       restriction is expected to go away in future releases.

       ge processes bad values.  The state of the bad-value flag of the output piddles is
       unknown.

   eq
         Signature: (a(); b(); [o]c(); int swap)

       binary equal to operation ("==")

          $c = eq $a, $b, 0;     # explicit call with trailing 0
          $c = $a == $b;           # overloaded call
          $a->inplace->eq($b,0);  # modify $a inplace

       It can be made to work inplace with the "$a->inplace" syntax.  This function is used to
       overload the binary "==" operator.  Note that when calling this function explicitly you
       need to supply a third argument that should generally be zero (see first example).  This
       restriction is expected to go away in future releases.

       eq processes bad values.  The state of the bad-value flag of the output piddles is
       unknown.

   ne
         Signature: (a(); b(); [o]c(); int swap)

       binary not equal to operation ("!=")

          $c = ne $a, $b, 0;     # explicit call with trailing 0
          $c = $a != $b;           # overloaded call
          $a->inplace->ne($b,0);  # modify $a inplace

       It can be made to work inplace with the "$a->inplace" syntax.  This function is used to
       overload the binary "!=" operator.  Note that when calling this function explicitly you
       need to supply a third argument that should generally be zero (see first example).  This
       restriction is expected to go away in future releases.

       ne processes bad values.  The state of the bad-value flag of the output piddles is
       unknown.

   shiftleft
         Signature: (a(); b(); [o]c(); int swap)

       leftshift $a by $b

          $c = shiftleft $a, $b, 0;     # explicit call with trailing 0
          $c = $a << $b;           # overloaded call
          $a->inplace->shiftleft($b,0);  # modify $a inplace

       It can be made to work inplace with the "$a->inplace" syntax.  This function is used to
       overload the binary "<<" operator.  Note that when calling this function explicitly you
       need to supply a third argument that should generally be zero (see first example).  This
       restriction is expected to go away in future releases.

       shiftleft processes bad values.  The state of the bad-value flag of the output piddles is
       unknown.

   shiftright
         Signature: (a(); b(); [o]c(); int swap)

       rightshift $a by $b

          $c = shiftright $a, $b, 0;     # explicit call with trailing 0
          $c = $a >> $b;           # overloaded call
          $a->inplace->shiftright($b,0);  # modify $a inplace

       It can be made to work inplace with the "$a->inplace" syntax.  This function is used to
       overload the binary ">>" operator.  Note that when calling this function explicitly you
       need to supply a third argument that should generally be zero (see first example).  This
       restriction is expected to go away in future releases.

       shiftright processes bad values.  The state of the bad-value flag of the output piddles is
       unknown.

   or2
         Signature: (a(); b(); [o]c(); int swap)

       binary or of two piddles

          $c = or2 $a, $b, 0;     # explicit call with trailing 0
          $c = $a | $b;           # overloaded call
          $a->inplace->or2($b,0);  # modify $a inplace

       It can be made to work inplace with the "$a->inplace" syntax.  This function is used to
       overload the binary "|" operator.  Note that when calling this function explicitly you
       need to supply a third argument that should generally be zero (see first example).  This
       restriction is expected to go away in future releases.

       or2 processes bad values.  The state of the bad-value flag of the output piddles is
       unknown.

   and2
         Signature: (a(); b(); [o]c(); int swap)

       binary and of two piddles

          $c = and2 $a, $b, 0;     # explicit call with trailing 0
          $c = $a & $b;           # overloaded call
          $a->inplace->and2($b,0);  # modify $a inplace

       It can be made to work inplace with the "$a->inplace" syntax.  This function is used to
       overload the binary "&" operator.  Note that when calling this function explicitly you
       need to supply a third argument that should generally be zero (see first example).  This
       restriction is expected to go away in future releases.

       and2 processes bad values.  The state of the bad-value flag of the output piddles is
       unknown.

   xor
         Signature: (a(); b(); [o]c(); int swap)

       binary exclusive or of two piddles

          $c = xor $a, $b, 0;     # explicit call with trailing 0
          $c = $a ^ $b;           # overloaded call
          $a->inplace->xor($b,0);  # modify $a inplace

       It can be made to work inplace with the "$a->inplace" syntax.  This function is used to
       overload the binary "^" operator.  Note that when calling this function explicitly you
       need to supply a third argument that should generally be zero (see first example).  This
       restriction is expected to go away in future releases.

       xor processes bad values.  The state of the bad-value flag of the output piddles is
       unknown.

   bitnot
         Signature: (a(); [o]b())

       unary bit negation

          $b = ~ $a;
          $a->inplace->bitnot;  # modify $a inplace

       It can be made to work inplace with the "$a->inplace" syntax.  This function is used to
       overload the unary "~" operator/function.

       bitnot processes bad values.  It will set the bad-value flag of all output piddles if the
       flag is set for any of the input piddles.

   power
         Signature: (a(); b(); [o]c(); int swap)

       raise piddle $a to the power $b

          $c = $a->power($b,0); # explicit function call
          $c = $a ** $b;    # overloaded use
          $a->inplace->power($b,0);     # modify $a inplace

       It can be made to work inplace with the "$a->inplace" syntax.  This function is used to
       overload the binary "**" function.  Note that when calling this function explicitly you
       need to supply a third argument that should generally be zero (see first example).  This
       restriction is expected to go away in future releases.

       power processes bad values.  The state of the bad-value flag of the output piddles is
       unknown.

   atan2
         Signature: (a(); b(); [o]c(); int swap)

       elementwise "atan2" of two piddles

          $c = $a->atan2($b,0); # explicit function call
          $c = atan2 $a, $b;    # overloaded use
          $a->inplace->atan2($b,0);     # modify $a inplace

       It can be made to work inplace with the "$a->inplace" syntax.  This function is used to
       overload the binary "atan2" function.  Note that when calling this function explicitly you
       need to supply a third argument that should generally be zero (see first example).  This
       restriction is expected to go away in future releases.

       atan2 processes bad values.  The state of the bad-value flag of the output piddles is
       unknown.

   modulo
         Signature: (a(); b(); [o]c(); int swap)

       elementwise "modulo" operation

          $c = $a->modulo($b,0); # explicit function call
          $c = $a % $b;    # overloaded use
          $a->inplace->modulo($b,0);     # modify $a inplace

       It can be made to work inplace with the "$a->inplace" syntax.  This function is used to
       overload the binary "%" function.  Note that when calling this function explicitly you
       need to supply a third argument that should generally be zero (see first example).  This
       restriction is expected to go away in future releases.

       modulo processes bad values.  The state of the bad-value flag of the output piddles is
       unknown.

   spaceship
         Signature: (a(); b(); [o]c(); int swap)

       elementwise "<=>" operation

          $c = $a->spaceship($b,0); # explicit function call
          $c = $a <=> $b;    # overloaded use
          $a->inplace->spaceship($b,0);     # modify $a inplace

       It can be made to work inplace with the "$a->inplace" syntax.  This function is used to
       overload the binary "<=>" function.  Note that when calling this function explicitly you
       need to supply a third argument that should generally be zero (see first example).  This
       restriction is expected to go away in future releases.

       spaceship processes bad values.  The state of the bad-value flag of the output piddles is
       unknown.

   sqrt
         Signature: (a(); [o]b())

       elementwise square root

          $b = sqrt $a;
          $a->inplace->sqrt;  # modify $a inplace

       It can be made to work inplace with the "$a->inplace" syntax.  This function is used to
       overload the unary "sqrt" operator/function.

       sqrt processes bad values.  It will set the bad-value flag of all output piddles if the
       flag is set for any of the input piddles.

   abs
         Signature: (a(); [o]b())

       elementwise absolute value

          $b = abs $a;
          $a->inplace->abs;  # modify $a inplace

       It can be made to work inplace with the "$a->inplace" syntax.  This function is used to
       overload the unary "abs" operator/function.

       abs processes bad values.  It will set the bad-value flag of all output piddles if the
       flag is set for any of the input piddles.

   sin
         Signature: (a(); [o]b())

       the sin function

          $b = sin $a;
          $a->inplace->sin;  # modify $a inplace

       It can be made to work inplace with the "$a->inplace" syntax.  This function is used to
       overload the unary "sin" operator/function.

       sin processes bad values.  It will set the bad-value flag of all output piddles if the
       flag is set for any of the input piddles.

   cos
         Signature: (a(); [o]b())

       the cos function

          $b = cos $a;
          $a->inplace->cos;  # modify $a inplace

       It can be made to work inplace with the "$a->inplace" syntax.  This function is used to
       overload the unary "cos" operator/function.

       cos processes bad values.  It will set the bad-value flag of all output piddles if the
       flag is set for any of the input piddles.

   not
         Signature: (a(); [o]b())

       the elementwise not operation

          $b = ! $a;
          $a->inplace->not;  # modify $a inplace

       It can be made to work inplace with the "$a->inplace" syntax.  This function is used to
       overload the unary "!" operator/function.

       not processes bad values.  It will set the bad-value flag of all output piddles if the
       flag is set for any of the input piddles.

   exp
         Signature: (a(); [o]b())

       the exponential function

          $b = exp $a;
          $a->inplace->exp;  # modify $a inplace

       It can be made to work inplace with the "$a->inplace" syntax.  This function is used to
       overload the unary "exp" operator/function.

       exp processes bad values.  It will set the bad-value flag of all output piddles if the
       flag is set for any of the input piddles.

   log
         Signature: (a(); [o]b())

       the natural logarithm

          $b = log $a;
          $a->inplace->log;  # modify $a inplace

       It can be made to work inplace with the "$a->inplace" syntax.  This function is used to
       overload the unary "log" operator/function.

       log processes bad values.  It will set the bad-value flag of all output piddles if the
       flag is set for any of the input piddles.

   log10
         Signature: (a(); [o]b())

       the base 10 logarithm

          $b = log10 $a;
          $a->inplace->log10;  # modify $a inplace

       It can be made to work inplace with the "$a->inplace" syntax.  This function is used to
       overload the unary "log10" operator/function.

       log10 processes bad values.  It will set the bad-value flag of all output piddles if the
       flag is set for any of the input piddles.

   assgn
         Signature: (a(); [o]b())

       Plain numerical assignment. This is used to implement the ".=" operator

       assgn does not process bad values.  It will set the bad-value flag of all output piddles
       if the flag is set for any of the input piddles.

AUTHOR

       Tuomas J. Lukka (lukka@fas.harvard.edu), Karl Glazebrook (kgb@aaoepp.aao.gov.au), Doug
       Hunt (dhunt@ucar.edu), Christian Soeller (c.soeller@auckland.ac.nz), Doug Burke
       (burke@ifa.hawaii.edu), and Craig DeForest (deforest@boulder.swri.edu).