File Coverage

blib/lib/PDLA/Ops.pm

Criterion	Covered	Total	%
statement	20	20	100.0
branch	6	6	100.0
condition			n/a
subroutine	4	4	100.0
pod	0	1	0.0
total	30	31	96.7

#
# GENERATED WITH PDLA::PP! Don't modify!
#
package PDLA::Ops;

@EXPORT_OK  = qw(  PDLA::PP log10 PDLA::PP assgn PDLA::PP ipow );
%EXPORT_TAGS = (Func=>[@EXPORT_OK]);

use PDLA::Core;
use PDLA::Exporter;
use DynaLoader;




   @ISA    = ( 'PDLA::Exporter','DynaLoader' );
   push @PDLA::Core::PP, __PACKAGE__;
   bootstrap PDLA::Ops ;





=head1 NAME

PDLA::Ops - Fundamental mathematical operators

=head1 DESCRIPTION

This module provides the functions used by PDLA to
overload the basic mathematical operators (C<+ - / *>
etc.) and functions (C etc.)

It also includes the function C, which should
be a perl function so that we can overload it!

Matrix multiplication (the operator C) is handled
by the module L.

=head1 SYNOPSIS

none

=cut







=head1 FUNCTIONS



=cut






=head2 plus

=for sig

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

=for ref

add two piddles

=for example

   $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 C<$x-Einplace> syntax.
This function is used to overload the binary C<+> 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.



=for bad

plus processes bad values.
The state of the bad-value flag of the output piddles is unknown.


=cut






*plus = \&PDLA::plus;





=head2 mult

=for sig

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

=for ref

multiply two piddles

=for example

   $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 C<$x-Einplace> syntax.
This function is used to overload the binary C<*> 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.



=for bad

mult processes bad values.
The state of the bad-value flag of the output piddles is unknown.


=cut






*mult = \&PDLA::mult;





=head2 minus

=for sig

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

=for ref

subtract two piddles

=for example

   $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 C<$x-Einplace> syntax.
This function is used to overload the binary C<-> 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.



=for bad

minus processes bad values.
The state of the bad-value flag of the output piddles is unknown.


=cut






*minus = \&PDLA::minus;





=head2 divide

=for sig

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

=for ref

divide two piddles

=for example

   $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 C<$x-Einplace> syntax.
This function is used to overload the binary C 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.



=for bad

divide processes bad values.
The state of the bad-value flag of the output piddles is unknown.


=cut






*divide = \&PDLA::divide;





=head2 gt

=for sig

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

=for ref

the binary E (greater than) operation

=for example

   $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 C<$x-Einplace> syntax.
This function is used to overload the binary C> 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.



=for bad

gt processes bad values.
The state of the bad-value flag of the output piddles is unknown.


=cut






*gt = \&PDLA::gt;





=head2 lt

=for sig

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

=for ref

the binary E (less than) operation

=for example

   $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 C<$x-Einplace> syntax.
This function is used to overload the binary C> 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.



=for bad

lt processes bad values.
The state of the bad-value flag of the output piddles is unknown.


=cut






*lt = \&PDLA::lt;





=head2 le

=for sig

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

=for ref

the binary E= (less equal) operation

=for example

   $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 C<$x-Einplace> syntax.
This function is used to overload the binary C=> 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.



=for bad

le processes bad values.
The state of the bad-value flag of the output piddles is unknown.


=cut






*le = \&PDLA::le;





=head2 ge

=for sig

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

=for ref

the binary E= (greater equal) operation

=for example

   $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 C<$x-Einplace> syntax.
This function is used to overload the binary C=> 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.



=for bad

ge processes bad values.
The state of the bad-value flag of the output piddles is unknown.


=cut






*ge = \&PDLA::ge;





=head2 eq

=for sig

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

=for ref

binary I operation (C<==>)

=for example

   $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 C<$x-Einplace> syntax.
This function is used to overload the binary C<==> 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.



=for bad

eq processes bad values.
The state of the bad-value flag of the output piddles is unknown.


=cut






*eq = \&PDLA::eq;





=head2 ne

=for sig

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

=for ref

binary I operation (C)

=for example

   $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 C<$x-Einplace> syntax.
This function is used to overload the binary C 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.



=for bad

ne processes bad values.
The state of the bad-value flag of the output piddles is unknown.


=cut






*ne = \&PDLA::ne;





=head2 shiftleft

=for sig

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

=for ref

leftshift C<$a> by C<$b>

=for example

   $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 C<$x-Einplace> syntax.
This function is used to overload the binary CE> 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.



=for bad

shiftleft processes bad values.
The state of the bad-value flag of the output piddles is unknown.


=cut






*shiftleft = \&PDLA::shiftleft;





=head2 shiftright

=for sig

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

=for ref

rightshift C<$a> by C<$b>

=for example

   $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 C<$x-Einplace> syntax.
This function is used to overload the binary CE> 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.



=for bad

shiftright processes bad values.
The state of the bad-value flag of the output piddles is unknown.


=cut






*shiftright = \&PDLA::shiftright;





=head2 or2

=for sig

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

=for ref

binary I of two piddles

=for example

   $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 C<$x-Einplace> syntax.
This function is used to overload the binary C<|> 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.



=for bad

or2 processes bad values.
The state of the bad-value flag of the output piddles is unknown.


=cut






*or2 = \&PDLA::or2;





=head2 and2

=for sig

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

=for ref

binary I of two piddles

=for example

   $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 C<$x-Einplace> syntax.
This function is used to overload the binary C<&> 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.



=for bad

and2 processes bad values.
The state of the bad-value flag of the output piddles is unknown.


=cut






*and2 = \&PDLA::and2;





=head2 xor

=for sig

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

=for ref

binary I of two piddles

=for example

   $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 C<$x-Einplace> syntax.
This function is used to overload the binary C<^> 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.



=for bad

xor processes bad values.
The state of the bad-value flag of the output piddles is unknown.


=cut






*xor = \&PDLA::xor;





=head2 bitnot

=for sig

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

=for ref

unary bit negation

=for example

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

It can be made to work inplace with the C<$x-Einplace> syntax.
This function is used to overload the unary C<~> operator/function.



=for bad

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.


=cut






*bitnot = \&PDLA::bitnot;





=head2 power

=for sig

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

=for ref

raise piddle C<$a> to the power C<$b>

=for example

   $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 C<$x-Einplace> syntax.
This function is used to overload the binary C<**> 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.



=for bad

power processes bad values.
The state of the bad-value flag of the output piddles is unknown.


=cut






*power = \&PDLA::power;





=head2 atan2

=for sig

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

=for ref

elementwise C of two piddles

=for example

   $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 C<$x-Einplace> syntax.
This function is used to overload the binary C 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.



=for bad

atan2 processes bad values.
The state of the bad-value flag of the output piddles is unknown.


=cut






*atan2 = \&PDLA::atan2;





=head2 modulo

=for sig

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

=for ref

elementwise C operation

=for example

   $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 C<$x-Einplace> syntax.
This function is used to overload the binary C<%> 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.



=for bad

modulo processes bad values.
The state of the bad-value flag of the output piddles is unknown.


=cut






*modulo = \&PDLA::modulo;





=head2 spaceship

=for sig

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

=for ref

elementwise "<=>" operation

=for example

   $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 C<$x-Einplace> syntax.
This function is used to overload the binary C=E> 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.



=for bad

spaceship processes bad values.
The state of the bad-value flag of the output piddles is unknown.


=cut






*spaceship = \&PDLA::spaceship;





=head2 sqrt

=for sig

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

=for ref

elementwise square root

=for example

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

It can be made to work inplace with the C<$x-Einplace> syntax.
This function is used to overload the unary C operator/function.



=for bad

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.


=cut






*sqrt = \&PDLA::sqrt;





=head2 abs

=for sig

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

=for ref

elementwise absolute value

=for example

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

It can be made to work inplace with the C<$x-Einplace> syntax.
This function is used to overload the unary C operator/function.



=for bad

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.


=cut






*abs = \&PDLA::abs;





=head2 sin

=for sig

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

=for ref

the sin function

=for example

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

It can be made to work inplace with the C<$x-Einplace> syntax.
This function is used to overload the unary C operator/function.



=for bad

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.


=cut






*sin = \&PDLA::sin;





=head2 cos

=for sig

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

=for ref

the cos function

=for example

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

It can be made to work inplace with the C<$x-Einplace> syntax.
This function is used to overload the unary C operator/function.



=for bad

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.


=cut






*cos = \&PDLA::cos;





=head2 not

=for sig

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

=for ref

the elementwise I operation

=for example

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

It can be made to work inplace with the C<$x-Einplace> syntax.
This function is used to overload the unary C operator/function.



=for bad

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.


=cut






*not = \&PDLA::not;





=head2 exp

=for sig

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

=for ref

the exponential function

=for example

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

It can be made to work inplace with the C<$x-Einplace> syntax.
This function is used to overload the unary C operator/function.



=for bad

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.


=cut






*exp = \&PDLA::exp;





=head2 log

=for sig

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

=for ref

the natural logarithm

=for example

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

It can be made to work inplace with the C<$x-Einplace> syntax.
This function is used to overload the unary C operator/function.



=for bad

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.


=cut






*log = \&PDLA::log;





=head2 log10

=for sig

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

=for ref

the base 10 logarithm

=for example

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

It can be made to work inplace with the C<$x-Einplace> syntax.
This function is used to overload the unary C operator/function.



=for bad

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.


=cut





sub PDLA::log10 {
    my $x = shift;
    if ( ! UNIVERSAL::isa($x,"PDLA") ) { return log($x) / log(10); }
    my $y;
    if ( $x->is_inplace ) { $x->set_inplace(0); $y = $x; }
    elsif( ref($x) eq "PDLA"){
    	#PDLA Objects, use nullcreate:
	$y = PDLA->nullcreate($x);
    }else{
    	#PDLA-Derived Object, use copy: (Consistent with
	#  Auto-creation docs in Objects.pod)
	$y = $x->copy;
    }
    &PDLA::_log10_int( $x, $y );
    return $y;
};


*log10 = \&PDLA::log10;





=head2 assgn

=for sig

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

=for ref

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

=for bad

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

 $pdl->slice(":,(1)") .= PDLA::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/PDLAdocs/BadValues.html#dataflow_of_the_badflag for details.

=cut






*assgn = \&PDLA::assgn;





=head2 ipow

=for sig

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


=for ref

raise piddle C<$a> to integer power C<$b>

=for example

   $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 C<$x-Einplace> 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 L



=for bad

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.


=cut






*ipow = \&PDLA::ipow;



;


=head1 AUTHOR

Tuomas J. Lukka ([e-mail]),
Karl Glazebrook ([e-mail]),
Doug Hunt ([e-mail]),
Christian Soeller ([e-mail]),
Doug Burke ([e-mail]),
and Craig DeForest ([e-mail]).

=cut





# Exit with OK status

1;