# Copyright (c) 2024 Yuki Kimoto
# MIT License
class R::OP::Long {
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 Complex_2d;
use LongList;
# Class Methods
static method c : R::NDArray::Long ($data : object of Long|long[]|R::NDArray::Long, $dim : int[] = undef) {
if ($data) {
if ($data is_type Long) {
$data = [(long)$data->(Long)];
}
elsif ($data is_type long[]) {
# Do nothing
}
elsif ($data is_type R::NDArray::Long) {
unless ($dim) {
$dim = $data->(R::NDArray::Long)->dim;
}
$data = $data->(R::NDArray::Long)->data;
}
else {
die "The type of the data \$data must be Long, long[], or R::NDArray::Long.";
}
}
my $ndarray = R::NDArray::Long->new({dim => $dim, data => $data});
return $ndarray;
}
precompile static method add : R::NDArray::Long ($x_ndarray : R::NDArray::Long, $y_ndarray : R::NDArray::Long) {
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] = $x_data->[$i] + $y_data->[0];
}
}
else {
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = $x_data->[$i] + $y_data->[$i];
}
}
return $ret_ndarray;
}
precompile static method sub : R::NDArray::Long ($x_ndarray : R::NDArray::Long, $y_ndarray : R::NDArray::Long) {
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] = $x_data->[$i] - $y_data->[0];
}
}
else {
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = $x_data->[$i] - $y_data->[$i];
}
}
return $ret_ndarray;
}
precompile static method mul : R::NDArray::Long ($x_ndarray : R::NDArray::Long, $y_ndarray : R::NDArray::Long) {
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] = $x_data->[$i] * $y_data->[0];
}
}
else {
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = $x_data->[$i] * $y_data->[$i];
}
}
return $ret_ndarray;
}
precompile static method div : R::NDArray::Long ($x_ndarray : R::NDArray::Long, $y_ndarray : R::NDArray::Long) {
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] = $x_data->[$i] / $y_data->[0];
}
}
else {
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = $x_data->[$i] / $y_data->[$i];
}
}
return $ret_ndarray;
}
precompile static method div_u : R::NDArray::Long ($x_ndarray : R::NDArray::Long, $y_ndarray : R::NDArray::Long) {
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] = $x_data->[$i] div_ulong $y_data->[0];
}
}
else {
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = $x_data->[$i] div_ulong $y_data->[$i];
}
}
return $ret_ndarray;
}
precompile static method mod : R::NDArray::Long ($x_ndarray : R::NDArray::Long, $y_ndarray : R::NDArray::Long) {
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] = $x_data->[$i] % $y_data->[0];
}
}
else {
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = $x_data->[$i] % $y_data->[$i];
}
}
return $ret_ndarray;
}
precompile static method mod_u : R::NDArray::Long ($x_ndarray : R::NDArray::Long, $y_ndarray : R::NDArray::Long) {
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] = $x_data->[$i] mod_ulong $y_data->[0];
}
}
else {
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = $x_data->[$i] mod_ulong $y_data->[$i];
}
}
return $ret_ndarray;
}
precompile static method neg : R::NDArray::Long ($x_ndarray : R::NDArray::Long) {
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] = -$x_data->[$i];
}
return $ret_ndarray;
}
precompile static method abs : R::NDArray::Long ($x_ndarray : R::NDArray::Long) {
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] = Fn->labs($x_data->[$i]);
}
return $ret_ndarray;
}
static method rep : R::NDArray::Long ($x_ndarray : R::NDArray::Long, $times : int) {
return (R::NDArray::Long)R::OP->rep($x_ndarray, $times);
}
static method rep_length : R::NDArray::Long ($x_ndarray : R::NDArray::Long, $length : int) {
return (R::NDArray::Long)R::OP->rep_length($x_ndarray, $length);
}
static method seq : R::NDArray::Long ($begin : long, $end : long, $by : long = 1) {
if ($by == 0) {
die "\$by must not be 0.";
}
elsif ($by > 0) {
unless ($end >= $begin) {
die "\$end must be greater than or equal to \$begin if \$by is greater than 0.";
}
}
else {
unless ($end <= $begin) {
die "\$end must be less than or equal to \$begin if \$by is less than 0.";
}
}
my $ret_data_list = LongList->new;
my $current = $begin;
while (1) {
if ($by >= 0) {
if ($current > $end) {
last;
}
}
else {
if ($current < $end) {
last;
}
}
$ret_data_list->push($current);
$current += $by;
}
my $ret_data = $ret_data_list->to_array;
my $ret_ndarray = R::OP::Long->c($ret_data);
return $ret_ndarray;
}
precompile static method eq : R::NDArray::Int ($x_ndarray : R::NDArray::Long, $y_ndarray : R::NDArray::Long) {
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] == $y_data->[$i];
}
return $ret_ndarray;
}
precompile static method ne : R::NDArray::Int ($x_ndarray : R::NDArray::Long, $y_ndarray : R::NDArray::Long) {
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] == $y_data->[$i]);
}
return $ret_ndarray;
}
precompile static method gt : R::NDArray::Int ($x_ndarray : R::NDArray::Long, $y_ndarray : R::NDArray::Long) {
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] > $y_data->[$i];
}
return $ret_ndarray;
}
precompile static method ge : R::NDArray::Int ($x_ndarray : R::NDArray::Long, $y_ndarray : R::NDArray::Long) {
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] >= $y_data->[$i];
}
return $ret_ndarray;
}
precompile static method lt : R::NDArray::Int ($x_ndarray : R::NDArray::Long, $y_ndarray : R::NDArray::Long) {
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] < $y_data->[$i];
}
return $ret_ndarray;
}
precompile static method le : R::NDArray::Int ($x_ndarray : R::NDArray::Long, $y_ndarray : R::NDArray::Long) {
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] <= $y_data->[$i];
}
return $ret_ndarray;
}
precompile static method sum : R::NDArray::Long ($x_ndarray : R::NDArray::Long) {
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 = 0L;
for (my $i = 0; $i < $length; $i++) {
$sum += $x_data->[$i];
}
$ret_data->[0] = $sum;
return $ret_ndarray;
}
precompile static method cumsum : R::NDArray::Long ($x_ndarray : R::NDArray::Long) {
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 = (long)0;
for (my $i = 0; $i < $length; $i++) {
$sum += $x_data->[$i];
$ret_data->[$i] = $sum;
}
return $ret_ndarray;
}
precompile static method prod : R::NDArray::Long ($x_ndarray : R::NDArray::Long) {
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 = 1L;
for (my $i = 0; $i < $length; $i++) {
$prod *= $x_data->[$i];
}
$ret_data->[0] = $prod;
return $ret_ndarray;
}
precompile static method cumprod : R::NDArray::Long ($x_ndarray : R::NDArray::Long) {
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 = (long)1;
for (my $i = 0; $i < $length; $i++) {
$prod *= $x_data->[$i];
$ret_data->[$i] = $prod;
}
return $ret_ndarray;
}
precompile static method diff : R::NDArray::Long ($x_ndarray : R::NDArray::Long) {
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] = $x_data->[$i + 1] - $x_data->[$i];
}
return $ret_ndarray;
}
precompile static method max : R::NDArray::Long ($x_ndarray : R::NDArray::Long) {
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 $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 $max = $x_data->[0];
for (my $i = 0; $i < $length; $i++) {
my $current = $x_data->[$i];
if ($current > $max) {
$max = $current;
}
}
$ret_data->[0] = $max;
return $ret_ndarray;
}
precompile static method min : R::NDArray::Long ($x_ndarray : R::NDArray::Long) {
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 $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 $min = $x_data->[0];
for (my $i = 0; $i < $length; $i++) {
my $current = $x_data->[$i];
if ($current < $min) {
$min = $current;
}
}
$ret_data->[0] = $min;
return $ret_ndarray;
}
precompile static method bit_and : R::NDArray::Long ($x_ndarray : R::NDArray::Long, $y_ndarray : R::NDArray::Long) {
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 = R::OP::Long->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] = $x_data->[$i] & $y_data->[0];
}
}
else {
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = $x_data->[$i] & $y_data->[$i];
}
}
return $ret_ndarray;
}
precompile static method bit_or : R::NDArray::Long ($x_ndarray : R::NDArray::Long, $y_ndarray : R::NDArray::Long) {
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 = R::OP::Long->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] = $x_data->[$i] | $y_data->[0];
}
}
else {
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = $x_data->[$i] | $y_data->[$i];
}
}
return $ret_ndarray;
}
precompile static method bit_not : R::NDArray::Long ($x_ndarray : R::NDArray::Long) {
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::Long->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];
}
return $ret_ndarray;
}
precompile static method left_shift : R::NDArray::Long ($x_ndarray : R::NDArray::Long, $y_ndarray : R::NDArray::Int) {
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 = R::OP::Long->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] = $x_data->[$i] << $y_data->[0];
}
}
else {
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = $x_data->[$i] << $y_data->[$i];
}
}
return $ret_ndarray;
}
precompile static method arithmetic_right_shift : R::NDArray::Long ($x_ndarray : R::NDArray::Long, $y_ndarray : R::NDArray::Int) {
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 = R::OP::Long->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] = $x_data->[$i] >> $y_data->[0];
}
}
else {
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = $x_data->[$i] >> $y_data->[$i];
}
}
return $ret_ndarray;
}
precompile static method logical_right_shift : R::NDArray::Long ($x_ndarray : R::NDArray::Long, $y_ndarray : R::NDArray::Int) {
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 = R::OP::Long->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] = $x_data->[$i] >>> $y_data->[0];
}
}
else {
for (my $i = 0; $i < $length; $i++) {
$ret_data->[$i] = $x_data->[$i] >>> $y_data->[$i];
}
}
return $ret_ndarray;
}
}