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 $x, $y, 0;     # explicit call with trailing 0
          $c = $x + $y;           # overloaded call
          $x->inplace->plus($y,0);  # modify $x inplace

       It can be made to work inplace with the "$x->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 $x, $y, 0;     # explicit call with trailing 0
          $c = $x * $y;           # overloaded call
          $x->inplace->mult($y,0);  # modify $x inplace

       It can be made to work inplace with the "$x->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 $x, $y, 0;     # explicit call with trailing 0
          $c = $x - $y;           # overloaded call
          $x->inplace->minus($y,0);  # modify $x inplace

       It can be made to work inplace with the "$x->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 $x, $y, 0;     # explicit call with trailing 0
          $c = $x / $y;           # overloaded call
          $x->inplace->divide($y,0);  # modify $x inplace

       It can be made to work inplace with the "$x->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 $x, $y, 0;     # explicit call with trailing 0
          $c = $x > $y;           # overloaded call
          $x->inplace->gt($y,0);  # modify $x inplace

       It can be made to work inplace with the "$x->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 $x, $y, 0;     # explicit call with trailing 0
          $c = $x < $y;           # overloaded call
          $x->inplace->lt($y,0);  # modify $x inplace

       It can be made to work inplace with the "$x->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 $x, $y, 0;     # explicit call with trailing 0
          $c = $x <= $y;           # overloaded call
          $x->inplace->le($y,0);  # modify $x inplace

       It can be made to work inplace with the "$x->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 $x, $y, 0;     # explicit call with trailing 0
          $c = $x >= $y;           # overloaded call
          $x->inplace->ge($y,0);  # modify $x inplace

       It can be made to work inplace with the "$x->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 $x, $y, 0;     # explicit call with trailing 0
          $c = $x == $y;           # overloaded call
          $x->inplace->eq($y,0);  # modify $x inplace

       It can be made to work inplace with the "$x->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 $x, $y, 0;     # explicit call with trailing 0
          $c = $x != $y;           # overloaded call
          $x->inplace->ne($y,0);  # modify $x inplace

       It can be made to work inplace with the "$x->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 $x, $y, 0;     # explicit call with trailing 0
          $c = $x << $y;           # overloaded call
          $x->inplace->shiftleft($y,0);  # modify $x inplace

       It can be made to work inplace with the "$x->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 $x, $y, 0;     # explicit call with trailing 0
          $c = $x >> $y;           # overloaded call
          $x->inplace->shiftright($y,0);  # modify $x inplace

       It can be made to work inplace with the "$x->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 $x, $y, 0;     # explicit call with trailing 0
          $c = $x | $y;           # overloaded call
          $x->inplace->or2($y,0);  # modify $x inplace

       It can be made to work inplace with the "$x->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 $x, $y, 0;     # explicit call with trailing 0
          $c = $x & $y;           # overloaded call
          $x->inplace->and2($y,0);  # modify $x inplace

       It can be made to work inplace with the "$x->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 $x, $y, 0;     # explicit call with trailing 0
          $c = $x ^ $y;           # overloaded call
          $x->inplace->xor($y,0);  # modify $x inplace

       It can be made to work inplace with the "$x->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

          $y = ~ $x;
          $x->inplace->bitnot;  # modify $x inplace

       It can be made to work inplace with the "$x->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 = $x->power($y,0); # explicit function call
          $c = $a ** $b;    # overloaded use
          $x->inplace->power($y,0);     # modify $x inplace

       It can be made to work inplace with the "$x->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 = $x->atan2($y,0); # explicit function call
          $c = atan2 $a, $b;    # overloaded use
          $x->inplace->atan2($y,0);     # modify $x inplace

       It can be made to work inplace with the "$x->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 = $x->modulo($y,0); # explicit function call
          $c = $a % $b;    # overloaded use
          $x->inplace->modulo($y,0);     # modify $x inplace

       It can be made to work inplace with the "$x->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 = $x->spaceship($y,0); # explicit function call
          $c = $a <=> $b;    # overloaded use
          $x->inplace->spaceship($y,0);     # modify $x inplace

       It can be made to work inplace with the "$x->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

          $y = sqrt $x;
          $x->inplace->sqrt;  # modify $x inplace

       It can be made to work inplace with the "$x->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

          $y = abs $x;
          $x->inplace->abs;  # modify $x inplace

       It can be made to work inplace with the "$x->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

          $y = sin $x;
          $x->inplace->sin;  # modify $x inplace

       It can be made to work inplace with the "$x->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

          $y = cos $x;
          $x->inplace->cos;  # modify $x inplace

       It can be made to work inplace with the "$x->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

          $y = ! $x;
          $x->inplace->not;  # modify $x inplace

       It can be made to work inplace with the "$x->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

          $y = exp $x;
          $x->inplace->exp;  # modify $x inplace

       It can be made to work inplace with the "$x->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

          $y = log $x;
          $x->inplace->log;  # modify $x inplace

       It can be made to work inplace with the "$x->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

          $y = log10 $x;
          $x->inplace->log10;  # modify $x inplace

       It can be made to work inplace with the "$x->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

       If "a" is a child piddle (e.g., the result of a slice) and bad values are generated in "b", the bad value
       flag is set in "b", but it is NOT automatically propagated back to the parent of "a".  The following
       idiom ensures that the badflag is propagated back to the parent of "a":

        $pdl->slice(":,(1)") .= PDL::Bad_aware_func();
        $pdl->badflag(1);
        $pdl->check_badflag();

       This is unnecessary if $pdl->badflag is known to be 1 before the slice is performed.

       See http://pdl.perl.org/PDLdocs/BadValues.html#dataflow_of_the_badflag for details.

   ipow
         Signature: (a(); b(); [o] ans())

       raise piddle $a to integer power $b

          $c = $x->ipow($y,0);     # explicit function call
          $c = ipow $x, $y;
          $x->inplace->ipow($y,0);  # modify $x inplace

       It can be made to work inplace with the "$x->inplace" syntax.  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.

       Algorithm from Wikipedia <http://en.wikipedia.org/wiki/Exponentiation_by_squaring>

       ipow 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).

perl v5.30.0                                       2020-01-18                                           Ops(3pm)