File Coverage

blib/lib/Math/Shape/Vector.pm

Criterion	Covered	Total	%
statement	85	89	95.5
branch	48	58	82.7
condition	8	9	88.8
subroutine	23	23	100.0
pod	17	17	100.0
total	181	196	92.3

use strict;
use warnings;
package Math::Shape::Vector;
$Math::Shape::Vector::VERSION = '0.13';
use 5.008;
use Carp;
use Math::Shape::Utils;
use Math::Trig;

# ABSTRACT: A 2d vector library in cartesian space


sub new {
    croak 'incorrect number of arguments' unless @_ == 3;
    return bless { x => $_[1],
                   y => $_[2] }, $_[0];
}


sub add_vector {
    croak 'must pass a vector object' unless $_[1]->isa('Math::Shape::Vector');
    my ($self, $v2) = @_;

    Math::Shape::Vector->new(
        $self->{x} + $v2->{x},
        $self->{y} + $v2->{y},
    );
}


sub subtract_vector {
    croak 'must pass a vector object' unless $_[1]->isa('Math::Shape::Vector');
    my ($self, $v2) = @_;

    Math::Shape::Vector->new(
        $self->{x} - $v2->{x},
        $self->{y} - $v2->{y},
    );
}


sub negate {
    my $self = shift;

    Math::Shape::Vector->new(
        - $self->{x},
        - $self->{y},
    );
}


sub is_equal {
    croak 'must pass a vector object' unless $_[1]->isa('Math::Shape::Vector');
    my ($self, $v2) = @_;
    $self->{x} == $v2->{x} && $self->{y} == $v2->{y}
        ? 1 : 0;
}


sub multiply {
    croak 'incorrect number of args' unless @_ == 2;
    my ($self, $multiplier) = @_;

    Math::Shape::Vector->new(
        $self->{x} * $multiplier,
        $self->{y} * $multiplier,
    );
}


sub divide {
    croak 'incorrect number of args' unless @_ == 2;
    my ($self, $divisor) = @_;

    # avoid division by zero
    Math::Shape::Vector->new(
        ($divisor ? $self->{x} / $divisor : 0),
        ($divisor ? $self->{y} / $divisor : 0),
    );
}


sub rotate {
    croak 'incorrect number of args' unless @_ == 2;
    my ($self, $radians) = @_;

    Math::Shape::Vector->new(
        $self->{x} * cos($radians) - $self->{y} * sin($radians),
        $self->{x} * sin($radians) + $self->{y} * cos($radians),
    );
}


sub rotate_90
{
    my $self = shift;

    Math::Shape::Vector->new(
        - $self->{y},
        $self->{x},
    );
}


sub dot_product {
    croak 'must pass a vector object' unless $_[1]->isa('Math::Shape::Vector');
    my ($self, $v2) = @_;
    $self->{x} * $v2->{x} + $self->{y} * $v2->{y};
}


sub length {
    my $self = shift;
    # avoid division by zero for null vectors
    my $sum_of_squares = $self->{x} ** 2 + $self->{y} ** 2;

    return 0 unless $sum_of_squares;
    sqrt $sum_of_squares;
}


sub convert_to_unit_vector {
    my $self = shift;

    my $length = $self->length;

    # if the vector length is zero (or lower?) return self
    return $self if $length < 0;

    # else return unit vector
    $self->divide($length);
}


sub project {
    croak 'must pass a vector object' unless $_[1]->isa('Math::Shape::Vector');
    my ($self, $v2) = @_;

    my $d = $v2->dot_product($v2);

    if ($d > 0) {
        $v2->multiply( $self->dot_product($v2) / $d );
    }
    else {
        $v2;
    }
}


sub is_parallel
{
    croak 'must pass a vector object' unless $_[1]->isa('Math::Shape::Vector');
    my ($self, $v2) = @_;
    my $vector_na = $self->rotate_90;
    equal_floats(0, $vector_na->dot_product($v2));
}


sub enclosed_angle
{
    croak 'must pass a vector object' unless $_[1]->isa('Math::Shape::Vector');
    my ($self, $v2) = @_;

    my $ua = $self->convert_to_unit_vector;
    my $ub = $v2->convert_to_unit_vector;

    acos( $ua->dot_product($ub) );
}



sub collides
{
    my ($self, $other_obj) = @_;

    if ($other_obj->isa('Math::Shape::Vector'))
    {
        $self->{x} == $other_obj->{x} && $self->{y} == $other_obj->{y} ? 1 : 0;
    }
    elsif ($other_obj->isa('Math::Shape::LineSegment'))
    {
        # test collision of nearest point on LineSegment with vector
        my $d  = $other_obj->{end}->subtract_vector($other_obj->{start});
        my $lp = $self->subtract_vector($other_obj->{start});
        my $pr  = $lp->project($d);

        $lp->is_equal($pr)
            && $pr->length <= $d->length
            && 0 <= $pr->dot_product($d)
            ? 1 : 0;
    }
    elsif ($other_obj->isa('Math::Shape::Line'))
    {
        # test if vector collides with base
        return 1 if $self->collides($other_obj->{base});

        # test if vector lies on the direction
        my $lp = $self->subtract_vector($other_obj->{base});
        $lp->is_parallel($other_obj->{direction});
    }
    elsif ($other_obj->isa('Math::Shape::OrientedRectangle'))
    {
        $other_obj->collides($self);
    }
    elsif ($other_obj->isa('Math::Shape::Circle'))
    {
        $other_obj->collides($self);
    }
    elsif ($other_obj->isa('Math::Shape::Rectangle'))
    {
        $other_obj->collides($self);
    }
    else
    {
        croak 'collides must be called with a Math::Shape::Vector library object';
    }
}


sub distance
{
    my ($self, $other_obj) = @_;

    if ($other_obj->isa('Math::Shape::Vector'))
    {
        $self->subtract_vector($other_obj)->length;
    }
    elsif ($other_obj->isa('Math::Shape::Circle'))
    {
        $self->subtract_vector($other_obj->{center})->length
        - $other_obj->{radius};
    }
    elsif ($other_obj->isa('Math::Shape::OrientedRectangle'))
    {
        my $circle_hull = $other_obj->circle_hull;
        $self->subtract_vector($circle_hull->{center})->length
        - $circle_hull->{radius};
    }
    else
    {
        croak 'distance() must be called with a Math::Shape::Vector library object';
    }
}


1;

__END__