# Copyright (c) 2024 Yuki Kimoto
# MIT License
class R::OP::FloatComplex {
version_from R;
use R::NDArray::Int;
use R::NDArray::Long;
use R::NDArray::Float;
use R::NDArray::Double;
use R::NDArray::FloatComplex;
use R::NDArray::DoubleComplex;
use R::NDArray::String;
use R::OP;
use R::OP::Int;
use R::OP::Long;
use R::OP::Float;
use R::OP::Double;
use R::OP::FloatComplex;
use R::OP::DoubleComplex;
use R::OP::String;
use Fn;
use Complex_2f;
use Math;
# Class Methods
static method c : R::NDArray::FloatComplex ($data : object of float[]|Complex_2f[]|R::NDArray::FloatComplex, $dim : int[] = undef) {
if ($data) {
if ($data is_type float[]) {
my $pairs = (float[])$data;
my $pairs_length = @$pairs;
unless ($pairs_length % 2 == 0) {
die "The length of pairs \$data must be an even number if the type of \$data is float[].";
}
my $length = $pairs_length / 2;
$data = new Complex_2f[$length];
Fn->memcpy($data, 0, $pairs, 0, 4 * 2 * $length);
}
elsif ($data is_type Complex_2f[]) {
# Do nothing
}
elsif ($data is_type R::NDArray::FloatComplex) {
unless ($dim) {
$dim = $data->(R::NDArray::FloatComplex)->dim;
}
$data = $data->(R::NDArray::FloatComplex)->data;
}
else {
die "The type of the data \$data must be float[], Complex_2f[] or R::NDArray::FloatComplex.";
}
}
my $ndarray = R::NDArray::FloatComplex->new({dim => $dim, data => $data});
return $ndarray;
}
precompile static method add : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex, $y_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
unless ($y_ndarray) {
die "The n-dimensional array \$y_ndarray must be defined.";
}
unless ($y_ndarray->is_scalar) {
my $equals_dim = R::OP->equals_dim($x_ndarray, $y_ndarray);
unless ($equals_dim) {
die "The dimensions of \$x_ndarray must be the same as the dimensions of \$y_ndarray.";
}
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_data = new Complex_2f[$length];
my $ret_ndarray = &c($ret_data, $x_dim);
my $x_data = $x_ndarray->data;
my $y_data = $y_ndarray->data;
if ($y_ndarray->is_scalar) {
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->caddf($x_data->[$i], $y_data->[0]);
}
}
else {
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->caddf($x_data->[$i], $y_data->[$i]);
}
}
return $ret_ndarray;
}
precompile static method sub : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex, $y_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
unless ($y_ndarray) {
die "The n-dimensional array \$y_ndarray must be defined.";
}
unless ($y_ndarray->is_scalar) {
my $equals_dim = R::OP->equals_dim($x_ndarray, $y_ndarray);
unless ($equals_dim) {
die "The dimensions of \$x_ndarray must be the same as the dimensions of \$y_ndarray.";
}
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_data = new Complex_2f[$length];
my $ret_ndarray = &c($ret_data, $x_dim);
my $x_data = $x_ndarray->data;
my $y_data = $y_ndarray->data;
if ($y_ndarray->is_scalar) {
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->csubf($x_data->[$i], $y_data->[0]);
}
}
else {
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->csubf($x_data->[$i], $y_data->[$i]);
}
}
return $ret_ndarray;
}
precompile static method mul : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex, $y_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
unless ($y_ndarray) {
die "The n-dimensional array \$y_ndarray must be defined.";
}
unless ($y_ndarray->is_scalar) {
my $equals_dim = R::OP->equals_dim($x_ndarray, $y_ndarray);
unless ($equals_dim) {
die "The dimensions of \$x_ndarray must be the same as the dimensions of \$y_ndarray.";
}
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_data = new Complex_2f[$length];
my $ret_ndarray = &c($ret_data, $x_dim);
my $x_data = $x_ndarray->data;
my $y_data = $y_ndarray->data;
if ($y_ndarray->is_scalar) {
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->cmulf($x_data->[$i], $y_data->[0]);
}
}
else {
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->cmulf($x_data->[$i], $y_data->[$i]);
}
}
return $ret_ndarray;
}
precompile static method div : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex, $y_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
unless ($y_ndarray) {
die "The n-dimensional array \$y_ndarray must be defined.";
}
unless ($y_ndarray->is_scalar) {
my $equals_dim = R::OP->equals_dim($x_ndarray, $y_ndarray);
unless ($equals_dim) {
die "The dimensions of \$x_ndarray must be the same as the dimensions of \$y_ndarray.";
}
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_data = new Complex_2f[$length];
my $ret_ndarray = &c($ret_data, $x_dim);
my $x_data = $x_ndarray->data;
my $y_data = $y_ndarray->data;
if ($y_ndarray->is_scalar) {
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->cdivf($x_data->[$i], $y_data->[0]);
}
}
else {
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->cdivf($x_data->[$i], $y_data->[$i]);
}
}
return $ret_ndarray;
}
precompile static method neg : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_ndarray = &c(undef, $x_dim);
my $x_data = $x_ndarray->data;
my $ret_data = $ret_ndarray->data;
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->cnegf($x_data->[$i]);
}
return $ret_ndarray;
}
precompile static method abs : R::NDArray::Float ($x_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_ndarray = R::OP::Float->c(undef, $x_dim);
my $x_data = $x_ndarray->data;
my $ret_data = $ret_ndarray->data;
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->cabsf($x_data->[$i]);
}
return $ret_ndarray;
}
precompile static method re : R::NDArray::Float ($x_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_ndarray = R::OP::Float->c(undef, $x_dim);
my $x_data = $x_ndarray->data;
my $ret_data = $ret_ndarray->data;
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = $x_data->[$i]{re};
}
return $ret_ndarray;
}
precompile static method im : R::NDArray::Float ($x_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_ndarray = R::OP::Float->c(undef, $x_dim);
my $x_data = $x_ndarray->data;
my $ret_data = $ret_ndarray->data;
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = $x_data->[$i]{im};
}
return $ret_ndarray;
}
static method i : R::NDArray::FloatComplex () {
my $x = Math->complexf(0f, 1f);
my $ret_ndarray = &c([$x]);
return $ret_ndarray;
}
precompile static method conj : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_ndarray = &c(undef, $x_dim);
my $x_data = $x_ndarray->data;
my $ret_data = $ret_ndarray->data;
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->conjf($x_data->[$i]);
}
return $ret_ndarray;
}
precompile static method arg : R::NDArray::Float ($x_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_ndarray = R::OP::Float->c(undef, $x_dim);
my $x_data = $x_ndarray->data;
my $ret_data = $ret_ndarray->data;
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->cargf($x_data->[$i]);
}
return $ret_ndarray;
}
precompile static method eq : R::NDArray::Int ($x_ndarray : R::NDArray::FloatComplex, $y_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
unless ($y_ndarray) {
die "The n-dimensional array \$y_ndarray must be defined.";
}
my $equals_dim = R::OP->equals_dim($x_ndarray, $y_ndarray);
unless ($equals_dim) {
die "The dimensions of \$x_ndarray must be the same as the dimensions of \$y_ndarray.";
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_ndarray = R::OP::Int->c(undef, $x_dim);
my $ret_data = $ret_ndarray->data;
my $x_data = $x_ndarray->data;
my $y_data = $y_ndarray->data;
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = $x_data->[$i]{re} == $y_data->[$i]{re} && $x_data->[$i]{im} == $y_data->[$i]{im};
}
return $ret_ndarray;
}
precompile static method ne : R::NDArray::Int ($x_ndarray : R::NDArray::FloatComplex, $y_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
unless ($y_ndarray) {
die "The n-dimensional array \$y_ndarray must be defined.";
}
my $equals_dim = R::OP->equals_dim($x_ndarray, $y_ndarray);
unless ($equals_dim) {
die "The dimensions of \$x_ndarray must be the same as the dimensions of \$y_ndarray.";
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_ndarray = R::OP::Int->c(undef, $x_dim);
my $ret_data = $ret_ndarray->data;
my $x_data = $x_ndarray->data;
my $y_data = $y_ndarray->data;
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = !($x_data->[$i]{re} == $y_data->[$i]{re} && $x_data->[$i]{im} == $y_data->[$i]{im});
}
return $ret_ndarray;
}
static method rep : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex, $times : int) {
return (R::NDArray::FloatComplex)R::OP->rep($x_ndarray, $times);
}
static method rep_length : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex, $length : int) {
return (R::NDArray::FloatComplex)R::OP->rep_length($x_ndarray, $length);
}
precompile static method sin : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_ndarray = &c(undef, $x_dim);
my $x_data = $x_ndarray->data;
my $ret_data = $ret_ndarray->data;
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->csinf($x_data->[$i]);
}
return $ret_ndarray;
}
precompile static method cos : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_ndarray = &c(undef, $x_dim);
my $x_data = $x_ndarray->data;
my $ret_data = $ret_ndarray->data;
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->ccosf($x_data->[$i]);
}
return $ret_ndarray;
}
precompile static method tan : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_ndarray = &c(undef, $x_dim);
my $x_data = $x_ndarray->data;
my $ret_data = $ret_ndarray->data;
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->ctanf($x_data->[$i]);
}
return $ret_ndarray;
}
precompile static method sinh : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_ndarray = &c(undef, $x_dim);
my $x_data = $x_ndarray->data;
my $ret_data = $ret_ndarray->data;
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->csinhf($x_data->[$i]);
}
return $ret_ndarray;
}
precompile static method cosh : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_ndarray = &c(undef, $x_dim);
my $x_data = $x_ndarray->data;
my $ret_data = $ret_ndarray->data;
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->ccoshf($x_data->[$i]);
}
return $ret_ndarray;
}
precompile static method tanh : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_ndarray = &c(undef, $x_dim);
my $x_data = $x_ndarray->data;
my $ret_data = $ret_ndarray->data;
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->ctanhf($x_data->[$i]);
}
return $ret_ndarray;
}
precompile static method acos : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_ndarray = &c(undef, $x_dim);
my $x_data = $x_ndarray->data;
my $ret_data = $ret_ndarray->data;
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->cacosf($x_data->[$i]);
}
return $ret_ndarray;
}
precompile static method asin : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_ndarray = &c(undef, $x_dim);
my $x_data = $x_ndarray->data;
my $ret_data = $ret_ndarray->data;
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->casinf($x_data->[$i]);
}
return $ret_ndarray;
}
precompile static method atan : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_ndarray = &c(undef, $x_dim);
my $x_data = $x_ndarray->data;
my $ret_data = $ret_ndarray->data;
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->catanf($x_data->[$i]);
}
return $ret_ndarray;
}
precompile static method asinh : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_ndarray = &c(undef, $x_dim);
my $x_data = $x_ndarray->data;
my $ret_data = $ret_ndarray->data;
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->casinhf($x_data->[$i]);
}
return $ret_ndarray;
}
precompile static method acosh : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_ndarray = &c(undef, $x_dim);
my $x_data = $x_ndarray->data;
my $ret_data = $ret_ndarray->data;
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->cacoshf($x_data->[$i]);
}
return $ret_ndarray;
}
precompile static method atanh : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_ndarray = &c(undef, $x_dim);
my $x_data = $x_ndarray->data;
my $ret_data = $ret_ndarray->data;
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->catanhf($x_data->[$i]);
}
return $ret_ndarray;
}
precompile static method exp : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_ndarray = &c(undef, $x_dim);
my $x_data = $x_ndarray->data;
my $ret_data = $ret_ndarray->data;
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->cexpf($x_data->[$i]);
}
return $ret_ndarray;
}
precompile static method log : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_ndarray = &c(undef, $x_dim);
my $x_data = $x_ndarray->data;
my $ret_data = $ret_ndarray->data;
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->clogf($x_data->[$i]);
}
return $ret_ndarray;
}
precompile static method sqrt : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_ndarray = &c(undef, $x_dim);
my $x_data = $x_ndarray->data;
my $ret_data = $ret_ndarray->data;
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->csqrtf($x_data->[$i]);
}
return $ret_ndarray;
}
precompile static method pow : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex, $y_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
unless ($y_ndarray) {
die "The n-dimensional array \$y_ndarray must be defined.";
}
unless ($y_ndarray->is_scalar) {
my $equals_dim = R::OP->equals_dim($x_ndarray, $y_ndarray);
unless ($equals_dim) {
die "The dimensions of \$x_ndarray must be the same as the dimensions of \$y_ndarray.";
}
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_ndarray = &c(undef, $x_dim);
my $ret_data = $ret_ndarray->data;
my $x_data = $x_ndarray->data;
my $y_data = $y_ndarray->data;
if ($y_ndarray->is_scalar) {
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->cpowf($x_data->[$i], $y_data->[0]);
}
}
else {
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = Math->cpowf($x_data->[$i], $y_data->[$i]);
}
}
return $ret_ndarray;
}
precompile static method sum : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_ndarray = &c(undef, [1]);
my $x_data = $x_ndarray->data;
my $ret_data = $ret_ndarray->data;
my $sum : Complex_2f;
for (my $i = 0; $i < $length; $i++) {
$sum = Math->caddf($sum, $x_data->[$i]);
}
$ret_data->[0] = $sum;
return $ret_ndarray;
}
precompile static method cumsum : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
unless ($x_ndarray->is_vector) {
die "The n-dimensional array \$x_ndarray must be a vector.";
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_ndarray = &c(undef, [$length]);
my $x_data = $x_ndarray->data;
my $ret_data = $ret_ndarray->data;
my $sum : Complex_2f;
for (my $i = 0; $i < $length; $i++) {
$sum = Math->caddf($sum, $x_data->[$i]);
$ret_data->[$i] = $sum;
}
return $ret_ndarray;
}
precompile static method prod : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_ndarray = &c(undef, [1]);
my $x_data = $x_ndarray->data;
my $ret_data = $ret_ndarray->data;
my $prod = Math->complexf(1, 0);
for (my $i = 0; $i < $length; $i++) {
$prod = Math->cmulf($prod, $x_data->[$i]);
}
$ret_data->[0] = $prod;
return $ret_ndarray;
}
precompile static method cumprod : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
unless ($x_ndarray->is_vector) {
die "The n-dimensional array \$x_ndarray must be a vector.";
}
my $length = $x_ndarray->length;
my $x_dim = $x_ndarray->dim;
my $ret_ndarray = &c(undef, [$length]);
my $x_data = $x_ndarray->data;
my $ret_data = $ret_ndarray->data;
my $prod = Math->complexf(1, 0);
for (my $i = 0; $i < $length; $i++) {
$prod = Math->cmulf($prod, $x_data->[$i]);
$ret_data->[$i] = $prod;
}
return $ret_ndarray;
}
precompile static method diff : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
my $x_dim = $x_ndarray->dim;
unless ($x_ndarray->is_vector) {
die "The n-dimensional array \$x_ndarray must be a vector.";
}
my $length = $x_ndarray->length;
unless ($length > 0) {
die "The length of \$x_ndarray must be greater than 0.";
}
my $ret_ndarray = &c(undef, [$length - 1]);
my $x_data = $x_ndarray->data;
my $ret_data = $ret_ndarray->data;
for (my $i = 0; $i < $length - 1; $i++) {
$ret_data->[$i] = Math->csubf($x_data->[$i + 1], $x_data->[$i]);
}
return $ret_ndarray;
}
static method mean : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
unless ($x_ndarray->length > 0) {
die "The length of n-dimensional array \$x_ndarray must be greater than 0.";
}
my $sum_ndarray = &sum($x_ndarray);
my $sum = $sum_ndarray->data->[0];
my $length = $x_ndarray->length;
my $mean = Math->cdivf($sum, Math->complexf($length, 0));
my $ret_ndarray = &c([$mean]);
return $ret_ndarray;
}
precompile static method dot : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex, $y_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
unless ($x_ndarray->is_vector) {
die "The n-dimensional array \$x_ndarray must be a vector.";
}
unless ($y_ndarray) {
die "The n-dimensional array \$y_ndarray must be defined.";
}
unless ($y_ndarray->is_vector) {
die "The n-dimensional array \$y_ndarray must be a vector.";
}
my $equals_dropped_dim = R::OP->equals_dim($x_ndarray, $y_ndarray);
my $x_length = $x_ndarray->length;
my $y_length = $y_ndarray->length;
unless ($x_length == $y_length) {
die "The length of the n-dimensional array \$x_ndarray must be equal to the length of the n-dimensional array \$y_ndarray.";
}
my $length = $x_ndarray->length;
my $ret_dim = [1];
my $ret_ndarray = &c(undef, $ret_dim);
my $ret_data = $ret_ndarray->data;
my $x_data = $x_ndarray->data;
my $y_data = $y_ndarray->data;
my $inner_product = Math->complexf(0, 0);
for (my $data_index = 0; $data_index < $length; $data_index++) {
$inner_product = Math->caddf($inner_product, Math->cmulf(Math->conjf($x_data->[$data_index]), $y_data->[$data_index]));
}
$ret_data->[0] = $inner_product;
return $ret_ndarray;
}
precompile static method outer : R::NDArray::FloatComplex ($x_ndarray : R::NDArray::FloatComplex, $y_ndarray : R::NDArray::FloatComplex) {
unless ($x_ndarray) {
die "The n-dimensional array \$x_ndarray must be defined.";
}
unless ($x_ndarray->is_vector) {
die "The n-dimensional array \$x_ndarray must be a vector.";
}
unless ($y_ndarray) {
die "The n-dimensional array \$y_ndarray must be defined.";
}
unless ($y_ndarray->is_vector) {
die "The n-dimensional array \$y_ndarray must be a vector.";
}
my $x_length = $x_ndarray->length;
my $y_length = $y_ndarray->length;
my $ret_length = $x_length * $y_length;
my $ret_dim = [$x_length, $y_length];
my $ret_ndarray = &c(undef, $ret_dim);
my $ret_data = $ret_ndarray->data;
my $x_data = $x_ndarray->data;
my $y_data = $y_ndarray->data;
for (my $y_index = 0; $y_index < $y_length; $y_index++) {
for (my $x_index = 0; $x_index < $x_length; $x_index++) {
my $data_index = $x_length * $y_index + $x_index;
$ret_data->[$data_index] = Math->cmulf($x_data->[$x_index], $y_data->[$y_index]);
}
}
return $ret_ndarray;
}
static method pi : R::NDArray::FloatComplex () {
my $x = (float)Math->PI;
my $ret_ndarray = &c([$x,0]);
return $ret_ndarray;
}
}