PDL::Ops

Ops(3pm)              User Contributed Perl Documentation             Ops(3pm)



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.

       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.

       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.

       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.

       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.

       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.

       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.

       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.

       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.

       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.

       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.

       shiftright

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

       leftshift "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.

       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.

       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.

       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.

       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.

       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.

       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 argu-
       ment that should generally be zero (see first example).  This restric-
       tion is expected to go away in future releases.

       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.

       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.

       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.

       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.

       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.

       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.

       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.

       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.

       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.

       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.

       assgn

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

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

AUTHOR
       Tuomas J. Lukka (lukka AT fas.edu), Karl Glazebrook
       (kgb AT aaoepp.au), Doug Hunt (dhunt AT ucar.edu), Christian Soeller
       (c.soeller AT auckland.nz), Doug Burke (burke AT ifa.edu), and
       Craig DeForest (deforest AT boulder.edu).



perl v5.8.8                       2007-01-14                          Ops(3pm)