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

```
$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)`

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)`

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)`

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

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.

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,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

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