sourCEntral - mobile manpages

pdf

Ops

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 does handle 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 does handle 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 does handle 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 does handle 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 does handle 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 does handle 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 does handle 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 does handle 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 does handle 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 does handle 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 does handle bad values. The state of the bad-value flag of the output piddles is unknown.

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.

shiftright does handle 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 does handle 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 does handle 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 does handle 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 does handle 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 does handle 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 does handle 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 does handle 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 does handle 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 does handle 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 does handle 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 does handle 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 does handle 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 does handle 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 does handle 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 does handle 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 does handle 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 AT fas DOT harvard DOT edu), Karl Glazebrook (kgb AT aaoepp DOT aao DOT gov DOT au), Doug Hunt (dhunt AT ucar DOT edu), Christian Soeller (c DOT soeller AT auckland DOT ac DOT nz), Doug Burke (burke AT ifa DOT hawaii DOT edu), and Craig DeForest (deforest AT boulder DOT swri DOT edu).

pdf