| 1 | package Sidef::Types::Array::Vector; | ||
| 2 | |||
| 3 | use utf8; | ||
| 4 | use 5.016; | ||
| 5 | |||
| 6 | use parent qw(Sidef::Types::Array::Array); | ||
| 7 | |||
| 8 | use overload q{""} => \&_dump; | ||
| 9 | |||
| 10 | use List::Util qw(); | ||
| 11 | use Scalar::Util qw(); | ||
| 12 | |||
| 13 | sub _is_vector { | ||
| 14 | my ($self) = @_; | ||
| 15 | |||
| 16 | my $ref = ref($self); | ||
| 17 | |||
| 18 | if ($ref eq __PACKAGE__ or $ref eq 'Sidef::Types::Array::Array') { | ||
| 19 | return 1; | ||
| 20 | } | ||
| 21 | |||
| 22 | $ref and UNIVERSAL::isa($self, 'Sidef::Types::Array::Array'); | ||
| 23 | } | ||
| 24 | |||
| 25 | sub new { | ||
| 26 | my (undef, @vals) = @_; | ||
| 27 | bless \@vals; | ||
| 28 | } | ||
| 29 | |||
| 30 | *call = \&new; | ||
| 31 | |||
| 32 | sub zero { | ||
| 33 | my (undef, $n) = @_; | ||
| 34 | bless [(Sidef::Types::Number::Number::ZERO) x CORE::int($n)]; | ||
| 35 | } | ||
| 36 | |||
| 37 | sub neg { | ||
| 38 | my ($v1) = @_; | ||
| 39 | bless($v1->scalar_operator('neg')); | ||
| 40 | } | ||
| 41 | |||
| 42 | sub not { | ||
| 43 | my ($v1) = @_; | ||
| 44 | bless($v1->scalar_operator('not')); | ||
| 45 | } | ||
| 46 | |||
| 47 | sub norm { | ||
| 48 | my ($v) = @_; | ||
| 49 | Sidef::Types::Number::Number::sum(map { $_->mul($_) } @$v); | ||
| 50 | } | ||
| 51 | |||
| 52 | sub abs { | ||
| 53 | my ($v) = @_; | ||
| 54 | $v->norm->sqrt; | ||
| 55 | } | ||
| 56 | |||
| 57 | sub manhattan_norm { | ||
| 58 | my ($v) = @_; | ||
| 59 | Sidef::Types::Number::Number::sum(map { $_->abs } @$v); | ||
| 60 | } | ||
| 61 | |||
| 62 | sub manhattan_dist { | ||
| 63 | my ($v1, $v2) = @_; | ||
| 64 | my $end = List::Util::min($#{$v1}, $#{$v2}); | ||
| 65 | Sidef::Types::Number::Number::sum(map { $v1->[$_]->sub($v2->[$_])->abs } 0 .. $end); | ||
| 66 | } | ||
| 67 | |||
| 68 | sub chebyshev_dist { | ||
| 69 | my ($v1, $v2) = @_; | ||
| 70 | my $end = List::Util::min($#{$v1}, $#{$v2}); | ||
| 71 | Sidef::Types::Number::Number::max(Sidef::Types::Number::Number::ZERO, map { $v1->[$_]->sub($v2->[$_])->abs } 0 .. $end); | ||
| 72 | } | ||
| 73 | |||
| 74 | sub dist_norm { | ||
| 75 | my ($v1, $v2) = @_; | ||
| 76 | my $end = List::Util::min($#{$v1}, $#{$v2}); | ||
| 77 | Sidef::Types::Number::Number::sum(map { my $t = $v1->[$_]->sub($v2->[$_]); $t->mul($t) } 0 .. $end); | ||
| 78 | } | ||
| 79 | |||
| 80 | sub dist { | ||
| 81 | my ($v1, $v2) = @_; | ||
| 82 | $v1->dist_norm($v2)->sqrt; | ||
| 83 | } | ||
| 84 | |||
| 85 | sub normalize { | ||
| 86 | my ($v) = @_; | ||
| 87 | my $mag = $v->abs; | ||
| 88 | $mag->is_zero and return $v; | ||
| 89 | $v->div($mag); | ||
| 90 | } | ||
| 91 | |||
| 92 | sub lerp { | ||
| 93 | my ($v1, $v2, $t) = @_; | ||
| 94 | $v1->add($v2->sub($v1)->mul($t)); | ||
| 95 | } | ||
| 96 | |||
| 97 | sub atan2 { | ||
| 98 | my ($v1, $v2) = @_; | ||
| 99 | |||
| 100 | my $end = List::Util::min($#{$v1}, $#{$v2}); | ||
| 101 | |||
| 102 | if ($end == 1) { | ||
| 103 | my $dot = $v1->[0]->mul($v2->[0])->add($v1->[1]->mul($v2->[1])); | ||
| 104 | my $cross = $v1->[0]->mul($v2->[1])->sub($v1->[1]->mul($v2->[0])); | ||
| 105 | return $cross->atan2($dot); | ||
| 106 | } | ||
| 107 | |||
| 108 | my $a1 = $v1->abs; | ||
| 109 | return Sidef::Types::Number::Number::ZERO if $a1->is_zero; | ||
| 110 | my $u1 = $v1->div($a1); | ||
| 111 | my $p = $v2->mul($u1); | ||
| 112 | |||
| 113 | $v2->sub($p->mul($u1))->abs->atan2($p); | ||
| 114 | } | ||
| 115 | |||
| 116 | sub project { | ||
| 117 | my ($v1, $onto) = @_; | ||
| 118 | my $scale = $v1->mul($onto)->div($onto->mul($onto)); | ||
| 119 | $onto->mul($scale); | ||
| 120 | } | ||
| 121 | |||
| 122 | sub reject { | ||
| 123 | my ($v1, $onto) = @_; | ||
| 124 | $v1->sub($v1->project($onto)); | ||
| 125 | } | ||
| 126 | |||
| 127 | sub add { | ||
| 128 | my ($v1, $v2) = @_; | ||
| 129 | |||
| 130 | if (_is_vector($v2)) { | ||
| 131 | return bless($v1->wise_operator('+', $v2)); | ||
| 132 | } | ||
| 133 | |||
| 134 | bless($v1->scalar_operator('+', $v2)); | ||
| 135 | } | ||
| 136 | |||
| 137 | sub sub { | ||
| 138 | my ($v1, $v2) = @_; | ||
| 139 | |||
| 140 | if (_is_vector($v2)) { | ||
| 141 | return bless($v1->wise_operator('-', $v2)); | ||
| 142 | } | ||
| 143 | |||
| 144 | bless($v1->scalar_operator('-', $v2)); | ||
| 145 | } | ||
| 146 | |||
| 147 | sub div { | ||
| 148 | my ($v1, $v2) = @_; | ||
| 149 | |||
| 150 | if (_is_vector($v2)) { | ||
| 151 | return $v1->mul($v2->scalar_operator('inv')); | ||
| 152 | } | ||
| 153 | |||
| 154 | bless($v1->scalar_operator('/', $v2)); | ||
| 155 | } | ||
| 156 | |||
| 157 | sub mul { | ||
| 158 | my ($v1, $v2) = @_; | ||
| 159 | |||
| 160 | if (_is_vector($v2)) { | ||
| 161 | return $v1->wise_operator('*', $v2)->sum; | ||
| 162 | } | ||
| 163 | |||
| 164 | bless($v1->scalar_operator('*', $v2)); | ||
| 165 | } | ||
| 166 | |||
| 167 | sub pow { | ||
| 168 | my ($v1, $v2) = @_; | ||
| 169 | |||
| 170 | if (_is_vector($v2)) { | ||
| 171 | my @matrix; | ||
| 172 | foreach my $x (@$v1) { | ||
| 173 | |||
| 174 | my @row; | ||
| 175 | foreach my $y (@$v2) { | ||
| 176 | push @row, $x->pow($y); | ||
| 177 | } | ||
| 178 | |||
| 179 | push @matrix, bless(\@row, 'Sidef::Types::Array::Array'); | ||
| 180 | } | ||
| 181 | |||
| 182 | return Sidef::Types::Array::Matrix->new(@matrix); | ||
| 183 | } | ||
| 184 | |||
| 185 | bless($v1->scalar_operator('**', $v2)); | ||
| 186 | } | ||
| 187 | |||
| 188 | sub and { | ||
| 189 | my ($v1, $v2) = @_; | ||
| 190 | |||
| 191 | if (_is_vector($v2)) { | ||
| 192 | return bless($v1->wise_operator('&', $v2)); | ||
| 193 | } | ||
| 194 | |||
| 195 | bless($v1->scalar_operator('&', $v2)); | ||
| 196 | } | ||
| 197 | |||
| 198 | sub or { | ||
| 199 | my ($v1, $v2) = @_; | ||
| 200 | |||
| 201 | if (_is_vector($v2)) { | ||
| 202 | return bless($v1->wise_operator('|', $v2)); | ||
| 203 | } | ||
| 204 | |||
| 205 | bless($v1->scalar_operator('|', $v2)); | ||
| 206 | } | ||
| 207 | |||
| 208 | sub xor { | ||
| 209 | my ($v1, $v2) = @_; | ||
| 210 | |||
| 211 | if (_is_vector($v2)) { | ||
| 212 | return bless($v1->wise_operator('^', $v2)); | ||
| 213 | } | ||
| 214 | |||
| 215 | bless($v1->scalar_operator('^', $v2)); | ||
| 216 | } | ||
| 217 | |||
| 218 | sub floor { | ||
| 219 | my ($self) = @_; | ||
| 220 | bless [map { $_->floor } @$self]; | ||
| 221 | } | ||
| 222 | |||
| 223 | sub ceil { | ||
| 224 | my ($self) = @_; | ||
| 225 | bless [map { $_->ceil } @$self]; | ||
| 226 | } | ||
| 227 | |||
| 228 | sub round { | ||
| 229 | my ($self, $digits) = @_; | ||
| 230 | bless [map { $_->round($digits) } @$self]; | ||
| 231 | } | ||
| 232 | |||
| 233 | sub to_array { | ||
| 234 | my ($v) = @_; | ||
| 235 | Sidef::Types::Array::Array->new(@$v); | ||
| 236 | } | ||
| 237 | |||
| 238 | *to_a = \&to_array; | ||
| 239 | |||
| 240 | sub _dump { | ||
| 241 | "Vector(" . substr($_[0]->SUPER::_dump, 1, -1) . ")"; | ||
| 242 | } | ||
| 243 | |||
| 244 | sub dump { | ||
| 245 | Sidef::Types::String::String->new($_[0]->_dump); | ||
| 246 | } | ||
| 247 | |||
| 248 | *to_s = \&dump; | ||
| 249 | *to_str = \&dump; | ||
| 250 | |||
| 251 | { | ||
| 252 | no strict 'refs'; | ||
| 253 | |||
| 254 | *{__PACKAGE__ . '::' . '*'} = \&mul; | ||
| 255 | *{__PACKAGE__ . '::' . '**'} = \&pow; | ||
| 256 | *{__PACKAGE__ . '::' . '+'} = \&add; | ||
| 257 | *{__PACKAGE__ . '::' . '-'} = \⊂ | ||
| 258 | *{__PACKAGE__ . '::' . '/'} = \÷ | ||
| 259 | *{__PACKAGE__ . '::' . 'รท'} = \÷ | ||
| 260 | *{__PACKAGE__ . '::' . '&'} = \∧ | ||
| 261 | *{__PACKAGE__ . '::' . '|'} = \∨ | ||
| 262 | *{__PACKAGE__ . '::' . '^'} = \&xor; | ||
| 263 | } | ||
| 264 | |||
| 265 | 1 |