# 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.

none

# FUNCTIONS

## plus

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

``````   \$c = \$x + \$y;        # overloaded call
\$c = plus \$x, \$y;     # explicit call with default swap of 0
\$c = plus \$x, \$y, 1;  # explicit call with trailing 1 to swap args
\$x->inplace->plus(\$y); # modify \$x inplace``````

It can be made to work inplace with the `\$x->inplace` syntax. This function is used to overload the binary `+` operator. As of 2.065, when calling this function explicitly you can omit the third argument (see second example), or supply it (see third one).

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

## mult

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

multiply two ndarrays

``````   \$c = \$x * \$y;        # overloaded call
\$c = mult \$x, \$y;     # explicit call with default swap of 0
\$c = mult \$x, \$y, 1;  # explicit call with trailing 1 to swap args
\$x->inplace->mult(\$y); # modify \$x inplace``````

It can be made to work inplace with the `\$x->inplace` syntax. This function is used to overload the binary `*` operator. As of 2.065, when calling this function explicitly you can omit the third argument (see second example), or supply it (see third one).

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

## minus

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

subtract two ndarrays

``````   \$c = \$x - \$y;        # overloaded call
\$c = minus \$x, \$y;     # explicit call with default swap of 0
\$c = minus \$x, \$y, 1;  # explicit call with trailing 1 to swap args
\$x->inplace->minus(\$y); # modify \$x inplace``````

It can be made to work inplace with the `\$x->inplace` syntax. This function is used to overload the binary `-` operator. As of 2.065, when calling this function explicitly you can omit the third argument (see second example), or supply it (see third one).

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

## divide

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

divide two ndarrays

``````   \$c = \$x / \$y;        # overloaded call
\$c = divide \$x, \$y;     # explicit call with default swap of 0
\$c = divide \$x, \$y, 1;  # explicit call with trailing 1 to swap args
\$x->inplace->divide(\$y); # modify \$x inplace``````

It can be made to work inplace with the `\$x->inplace` syntax. This function is used to overload the binary `/` operator. As of 2.065, when calling this function explicitly you can omit the third argument (see second example), or supply it (see third one).

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

## gt

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

the binary > (greater than) operation

``````   \$c = \$x > \$y;        # overloaded call
\$c = gt \$x, \$y;     # explicit call with default swap of 0
\$c = gt \$x, \$y, 1;  # explicit call with trailing 1 to swap args
\$x->inplace->gt(\$y); # modify \$x inplace``````

It can be made to work inplace with the `\$x->inplace` syntax. This function is used to overload the binary `>` operator. As of 2.065, when calling this function explicitly you can omit the third argument (see second example), or supply it (see third one).

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

## lt

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

the binary < (less than) operation

``````   \$c = \$x < \$y;        # overloaded call
\$c = lt \$x, \$y;     # explicit call with default swap of 0
\$c = lt \$x, \$y, 1;  # explicit call with trailing 1 to swap args
\$x->inplace->lt(\$y); # modify \$x inplace``````

It can be made to work inplace with the `\$x->inplace` syntax. This function is used to overload the binary `<` operator. As of 2.065, when calling this function explicitly you can omit the third argument (see second example), or supply it (see third one).

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

## le

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

the binary <= (less equal) operation

``````   \$c = \$x <= \$y;        # overloaded call
\$c = le \$x, \$y;     # explicit call with default swap of 0
\$c = le \$x, \$y, 1;  # explicit call with trailing 1 to swap args
\$x->inplace->le(\$y); # modify \$x inplace``````

It can be made to work inplace with the `\$x->inplace` syntax. This function is used to overload the binary `<=` operator. As of 2.065, when calling this function explicitly you can omit the third argument (see second example), or supply it (see third one).

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

## ge

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

the binary >= (greater equal) operation

``````   \$c = \$x >= \$y;        # overloaded call
\$c = ge \$x, \$y;     # explicit call with default swap of 0
\$c = ge \$x, \$y, 1;  # explicit call with trailing 1 to swap args
\$x->inplace->ge(\$y); # modify \$x inplace``````

It can be made to work inplace with the `\$x->inplace` syntax. This function is used to overload the binary `>=` operator. As of 2.065, when calling this function explicitly you can omit the third argument (see second example), or supply it (see third one).

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

## eq

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

binary equal to operation (`==`)

``````   \$c = \$x == \$y;        # overloaded call
\$c = eq \$x, \$y;     # explicit call with default swap of 0
\$c = eq \$x, \$y, 1;  # explicit call with trailing 1 to swap args
\$x->inplace->eq(\$y); # modify \$x inplace``````

It can be made to work inplace with the `\$x->inplace` syntax. This function is used to overload the binary `==` operator. As of 2.065, when calling this function explicitly you can omit the third argument (see second example), or supply it (see third one).

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

## ne

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

binary not equal to operation (`!=`)

``````   \$c = \$x != \$y;        # overloaded call
\$c = ne \$x, \$y;     # explicit call with default swap of 0
\$c = ne \$x, \$y, 1;  # explicit call with trailing 1 to swap args
\$x->inplace->ne(\$y); # modify \$x inplace``````

It can be made to work inplace with the `\$x->inplace` syntax. This function is used to overload the binary `!=` operator. As of 2.065, when calling this function explicitly you can omit the third argument (see second example), or supply it (see third one).

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

## shiftleft

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

leftshift `\$a` by `\$b`

``````   \$c = \$x << \$y;        # overloaded call
\$c = shiftleft \$x, \$y;     # explicit call with default swap of 0
\$c = shiftleft \$x, \$y, 1;  # explicit call with trailing 1 to swap args
\$x->inplace->shiftleft(\$y); # modify \$x inplace``````

It can be made to work inplace with the `\$x->inplace` syntax. This function is used to overload the binary `<<` operator. As of 2.065, when calling this function explicitly you can omit the third argument (see second example), or supply it (see third one).

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

## shiftright

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

rightshift `\$a` by `\$b`

``````   \$c = \$x >> \$y;        # overloaded call
\$c = shiftright \$x, \$y;     # explicit call with default swap of 0
\$c = shiftright \$x, \$y, 1;  # explicit call with trailing 1 to swap args
\$x->inplace->shiftright(\$y); # modify \$x inplace``````

It can be made to work inplace with the `\$x->inplace` syntax. This function is used to overload the binary `>>` operator. As of 2.065, when calling this function explicitly you can omit the third argument (see second example), or supply it (see third one).

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

## or2

``  Signature: (a(); b(); [o]c(); int \$swap; SV *\$ign; int \$ign2)``

binary or of two ndarrays

``````   \$c = \$x | \$y;        # overloaded call
\$c = or2 \$x, \$y;     # explicit call with default swap of 0
\$c = or2 \$x, \$y, 1;  # explicit call with trailing 1 to swap args
\$x->inplace->or2(\$y); # modify \$x inplace``````

It can be made to work inplace with the `\$x->inplace` syntax. This function is used to overload the binary `|` operator. As of 2.065, when calling this function explicitly you can omit the third argument (see second example), or supply it (see third one).

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

## and2

``  Signature: (a(); b(); [o]c(); int \$swap; SV *\$ign; int \$ign2)``

binary and of two ndarrays

``````   \$c = \$x & \$y;        # overloaded call
\$c = and2 \$x, \$y;     # explicit call with default swap of 0
\$c = and2 \$x, \$y, 1;  # explicit call with trailing 1 to swap args
\$x->inplace->and2(\$y); # modify \$x inplace``````

It can be made to work inplace with the `\$x->inplace` syntax. This function is used to overload the binary `&` operator. As of 2.065, when calling this function explicitly you can omit the third argument (see second example), or supply it (see third one).

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

## xor

``  Signature: (a(); b(); [o]c(); int \$swap; SV *\$ign; int \$ign2)``

binary exclusive or of two ndarrays

``````   \$c = \$x ^ \$y;        # overloaded call
\$c = xor \$x, \$y;     # explicit call with default swap of 0
\$c = xor \$x, \$y, 1;  # explicit call with trailing 1 to swap args
\$x->inplace->xor(\$y); # modify \$x inplace``````

It can be made to work inplace with the `\$x->inplace` syntax. This function is used to overload the binary `^` operator. As of 2.065, when calling this function explicitly you can omit the third argument (see second example), or supply it (see third one).

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

## 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 ndarrays if the flag is set for any of the input ndarrays.

## power

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

raise ndarray `\$a` to the power `\$b`

``````   \$c = \$x->power(\$y);    # explicit call with default swap of 0
\$c = \$x->power(\$y, 1); # explicit call with trailing 1 to swap args
\$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. As of 2.065, when calling this function explicitly you can omit the third argument (see first example), or supply it (see second one).

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

## atan2

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

elementwise `atan2` of two ndarrays

``````   \$c = \$x->atan2(\$y);    # explicit call with default swap of 0
\$c = \$x->atan2(\$y, 1); # explicit call with trailing 1 to swap args
\$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. As of 2.065, when calling this function explicitly you can omit the third argument (see first example), or supply it (see second one).

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

## modulo

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

elementwise `modulo` operation

``````   \$c = \$x->modulo(\$y);    # explicit call with default swap of 0
\$c = \$x->modulo(\$y, 1); # explicit call with trailing 1 to swap args
\$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. As of 2.065, when calling this function explicitly you can omit the third argument (see first example), or supply it (see second one).

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

## spaceship

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

elementwise "<=>" operation

``````   \$c = \$x->spaceship(\$y);    # explicit call with default swap of 0
\$c = \$x->spaceship(\$y, 1); # explicit call with trailing 1 to swap args
\$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. As of 2.065, when calling this function explicitly you can omit the third argument (see first example), or supply it (see second one).

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

## 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 ndarrays if the flag is set for any of the input ndarrays.

## 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 ndarrays if the flag is set for any of the input ndarrays.

## 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 ndarrays if the flag is set for any of the input ndarrays.

## 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 ndarrays if the flag is set for any of the input ndarrays.

## 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 ndarrays if the flag is set for any of the input ndarrays.

## 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 ndarrays if the flag is set for any of the input ndarrays.

## re

``  Signature: (complexv(); real [o]b())``

Returns the real part of a complex number. Flows data back & forth.

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

## im

``  Signature: (complexv(); real [o]b())``

Returns the imaginary part of a complex number. Flows data back & forth.

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

## _cabs

``  Signature: (complexv(); real [o]b())``

Returns the absolute (length) of a complex number.

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

## 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 ndarrays if the flag is set for any of the input ndarrays.

## assgn

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

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

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

## carg

``  Signature: (complexv(); real [o]b())``

Returns the polar angle of a complex number.

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

## conj

``  Signature: (complexv();  [o]b())``

complex conjugate.

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

## czip

``  Signature: (r(); i(); complex [o]c())``

convert real, imaginary to native complex, (sort of) like LISP zip function. Will add the `r` ndarray to "i" times the `i` ndarray. Only takes real ndarrays as input.

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

## ipow

``  Signature: (a(); indx b(); [o] ans())``

raise ndarray `\$a` to integer power `\$b`

``````   \$c = \$x->ipow(\$y);     # as method
\$c = ipow \$x, \$y;
\$x->inplace->ipow(\$y);  # modify \$x inplace``````

It can be made to work inplace with the `\$x->inplace` syntax.

Algorithm from Wikipedia

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

## abs

Returns the absolute value of a number.

## abs2

Returns the square of the absolute value of a number.

## r2C

``  Signature: (r(); complex [o]c())``

convert real to native complex, with an imaginary part of zero

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

## i2C

``  Signature: (i(); complex [o]c())``

convert imaginary to native complex, with a real part of zero

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

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