File Coverage

blib/lib/Geometry/Formula.pm

Criterion	Covered	Total	%
statement	9	146	6.1
branch	0	44	0.0
condition			n/a
subroutine	3	27	11.1
pod	21	21	100.0
total	33	238	13.8

package Geometry::Formula;

use strict;
use warnings;
use Carp qw(croak);
my $PI = 3.1415926;

our $VERSION = 0.02;

sub new {
    my $class = shift;
    my $self  = {};
    bless $self, $class;
    return $self;
}

sub annulus {
    my ( $self, %param, $x ) = @_;
    _param_check( 'annulus', %param );

    $x = $PI *
      ( $self->_squared( $param{'outer_radius'} ) - $self->_squared( $param{'inner_radius'} ) );

    return $x;
}

sub circle {
    my ( $self, %param, $x ) = @_;
    _param_check( 'circle', %param );

    if ( $param{'formula'} eq 'area' ) {
        $x = $PI * $self->_squared( $param{'radius'} );
    }
    elsif ( $param{'formula'} eq 'circumference' ) {
        $x = ( 2 * $PI ) * $param{'radius'};
    }
    else {
        $x = $param{'radius'} * 2;
    }

    return $x;
}

sub cone {
    my ( $self, %param, $x ) = @_;
    _param_check( 'cone', %param );

    $x = ( 1 / 3 ) * ( $param{'base'} * $param{'height'} );

    return $x;
}

sub cube {
    my ( $self, %param, $x ) = @_;
    _param_check( 'cube', %param );

    if ( $param{'formula'} eq 'surface_area' ) {
        $x = 6 * ( $param{'a'} * 2 );
    }
    else {
        $x = $self->_cubed( $param{'a'} );
    }

    return $x;
}

sub ellipse {
    my ( $self, %param, $x ) = @_;
    _param_check( 'ellipse', %param );

    if ( $param{'formula'} eq 'area' ) {
        $x = $PI * ( $param{'a'} * $param{'b'} );
    }
    else {
        $x = 2 * $PI *
          sqrt( ( $self->_squared( $param{'a'} ) + $self->_squared( $param{'b'} ) ) / 2 );
    }

    return $x;
}

sub ellipsoid {
    my ( $self, %param, $x ) = @_;
    _param_check( 'ellipsoid', %param );

    $x = ( 4 / 3 ) * $PI * $param{'a'} * $param{'b'} * $param{'c'};

    return $x;
}

sub equilateral_triangle {
    my ( $self, %param, $x ) = @_;
    _param_check( 'equilateral_triangle', %param );

    $x = $self->_squared( $param{'side'} ) * ( sqrt(3) / 4 );

    return $x;
}

sub frustum_of_right_circular_cone {
    my ( $self, %param, $x ) = @_;
    _param_check( 'frustum_of_right_circular_cone', %param );

    if ( $param{'formula'} eq 'lateral_surface_area' ) {
        $x =
          $PI *
          ( $param{'large_radius'} + $param{'small_radius'} ) *
          sqrt( $self->_squared( $param{'large_radius'} - $param{'small_radius'} ) +
              $self->_squared( $param{'slant_height'} ) );
    }
    elsif ( $param{'formula'} eq 'total_surface_area' ) {
        my $slant_height =
          sqrt( $self->_squared( $param{'large_radius'} - $param{'small_radius'} ) +
              $self->_squared( $param{'height'} ) );

        $x =
          $PI *
          ( $param{'small_radius'} *
              ( $param{'small_radius'} + $slant_height )
              + $param{'large_radius'} *
              ( $param{'large_radius'} + $slant_height ) );

    }
    else {
        $x = (
            $PI * (
                $self->_squared( $param{'small_radius'} ) +
                  ( $param{'small_radius'} * $param{'large_radius'} ) +
                  $self->_squared( $param{'large_radius'} )
              ) * $param{'height'}
        ) / 3;
    }

    return $x;
}

sub parallelogram {
    my ( $self, %param, $x ) = @_;
    _param_check( 'parallelogram', %param );

    if ( $param{'formula'} eq 'area' ) {
        $x = $param{'base'} * $param{'height'};
    }
    else {
        $x = ( 2 * $param{'a'} ) + ( 2 * $param{'b'} );
    }

    return $x;
}

sub rectangle {
    my ( $self, %param, $x ) = @_;
    _param_check( 'rectangle', %param );

    if ( $param{'formula'} eq 'area' ) {
        $x = $param{'length'} * $param{'width'};
    }
    else {
        $x = ( 2 * $param{'length'} ) + ( 2 * $param{'width'} );
    }

    return $x;
}

sub rectangular_solid {
    my ( $self, %param, $x ) = @_;
    _param_check( 'rectangular_solid', %param );

    if ( $param{'formula'} eq 'volume' ) {
        $x = $param{'length'} * $param{'width'} * $param{'height'};
    }
    else {
        $x =
          2 *
          ( ( $param{'length'} * $param{'width'} ) +
              ( $param{'width'} * $param{'height'} ) +
              ( $param{'length'} * $param{'height'} ) );
    }

    return $x;
}

sub rhombus {
    my ( $self, %param, $x ) = @_;
    _param_check( 'rhombus', %param );

    $x = ( $param{'a'} * $param{'b'} ) / 2;

    return $x;
}

sub right_circular_cone {
    my ( $self, %param, $x ) = @_;
    _param_check( 'right_circular_cone', %param );

    if ( $param{'formula'} eq 'lateral_surface_area' ) {
        $x =
          $PI *
          $param{'radius'} *
          ( sqrt( $self->_squared( $param{'radius'} ) + $self->_squared( $param{'height'} ) ) );
    }
    else {
        $x = ( 1 / 3 ) * $PI * $self->_squared( $param{'radius'} ) * $param{'height'};
    }

    return $x;
}

sub right_circular_cylinder {
    my ( $self, %param, $x ) = @_;
    _param_check( 'right_circular_cylinder', %param );

    if ( $param{'formula'} eq 'lateral_surface_area' ) {
        $x = 2 * $PI * $param{'radius'} * $param{'height'};
    }
    elsif ( $param{'formula'} eq 'total_surface_area' ) {
        $x =
          2 * $PI * $param{'radius'} * ( $param{'radius'} + $param{'height'} );
    }
    else {
        $x = $PI * ( $self->_squared( $param{'radius'} ) * $param{'height'} );
    }

    return $x;
}

sub sector_of_circle {
    my ( $self, %param, $x ) = @_;
    _param_check( 'sector_of_circle', %param );

    $x = ( $param{'theta'} / 360 ) * $PI * $self->_squared( $param{'radius'} );

    return $x;
}

sub sphere {
    my ( $self, %param, $x ) = @_;
    _param_check( 'sphere', %param );

    if ( $param{'formula'} eq 'surface_area' ) {
        $x = 4 * $PI * $self->_squared( $param{'radius'} );
    }
    else {
        $x = ( 4 / 3 ) * $PI * $self->_cubed( $param{'radius'} );
    }

    return $x;
}

sub square {
    my ( $self, %param, $x ) = @_;
    _param_check( 'square', %param );

    if ( $param{'formula'} eq 'area' ) {
        $x = $self->_squared( $param{'side'} );
    }
    else {
        $x = $param{'side'} * 4;
    }

    return $x;
}

sub torus {
    my ( $self, %param, $x ) = @_;
    _param_check( 'torus', %param );

    if ( $param{'formula'} eq 'surface_area' ) {
        $x = 4 * $self->_squared($PI) * $param{'a'} * $param{'b'};
    }
    else {
        $x = 2 * $self->_squared($PI) * $self->_squared( $param{'a'} ) * $param{'b'};
    }

    return $x;
}

sub trapezoid {
    my ( $self, %param, $x ) = @_;
    _param_check( 'trapezoid', %param );

    if ( $param{'formula'} eq 'area' ) {
        $x = ( ( $param{'a'} + $param{'b'} ) / 2 ) * $param{'height'};
    }
    else {
        $x = $param{'a'} + $param{'b'} + $param{'c'} + $param{'d'};
    }

    return $x;
}

sub triangle {
    my ( $self, %param, $x ) = @_;
    _param_check( 'triangle', %param );

    if ( $param{'formula'} eq 'area' ) {
        $x = .5 * $param{'base'} * $param{'height'};
    }
    else {
        $x = $param{'a'} + $param{'b'} + $param{'c'};
    }

    return $x;
}

sub _squared {
    my ( $self, $num ) = @_;

    return $num ** 2;
}

sub _cubed {
    my ( $self, $num ) = @_;

    return $num ** 3;
}

sub _param_check {
    my ( $method, %param ) = @_;

    my %valid_params = (
        annulus => { area => [ 'inner_radius', 'outer_radius' ] },
        circle  => {
            area          => ['radius'],
            circumference => ['radius'],
            diameter      => ['radius']
        },
        cone => { volume => [ 'base', 'height' ] },
        cube => {
            surface_area => ['a'],
            volume       => ['a']
        },
        ellipse => {
            area      => [ 'a', 'b' ],
            perimeter => [ 'a', 'b' ]
        },
        ellipsoid                      => { volume => [ 'a', 'b', 'c' ] },
        equilateral_triangle           => { area   => ['side'] },
        frustum_of_right_circular_cone => {
            lateral_surface_area =>
              [ 'slant_height', 'small_radius', 'large_radius' ],
            total_surface_area => [ 'height', 'small_radius', 'large_radius' ],
            volume             => [ 'height', 'small_radius', 'large_radius' ]
        },
        parallelogram => {
            area      => [ 'base', 'height' ],
            perimeter => [ 'a',    'b' ]
        },
        rectangle => {
            area      => [ 'length', 'width' ],
            perimeter => [ 'length', 'width' ]
        },
        rectangular_solid => {
            surface_area => [ 'length', 'width', 'height' ],
            volume       => [ 'length', 'width', 'height' ]
        },
        rhombus             => { area => [ 'a', 'b' ] },
        right_circular_cone => {
            lateral_surface_area => [ 'radius', 'height' ],
            volume               => [ 'radius', 'height' ]
        },
        right_circular_cylinder => {
            total_surface_area   => [ 'radius', 'height' ],
            lateral_surface_area => [ 'radius', 'height' ],
            volume               => [ 'radius', 'height' ]
        },
        sector_of_circle => { area => [ 'theta', 'radius' ] },
        sphere           => {
            surface_area => ['radius'],
            volume       => ['radius']
        },
        square => {
            area      => ['side'],
            perimeter => ['side']
        },
        torus => {
            surface_area => [ 'a', 'b' ],
            volume       => [ 'a', 'b' ]
        },
        trapezoid => {
            area      => [ 'a', 'b', 'height' ],
            perimeter => [ 'a', 'b', 'c', 'd' ]
        },
        triangle => {
            area      => [ 'base', 'height' ],
            perimeter => [ 'a',    'b', 'c' ]
        },
    );

    # validate that parameter values are defined and numeric
    foreach ( @{ $valid_params{$method}{ $param{'formula'} } } ) {
        croak "required parameter '$_' not defined"
          if !$param{$_};

        croak "parameter '$_' requires a numeric value"
          if $param{$_} !~ m/^\d+$/;
    }

    # validate parameter is a valid constructor/component of formula
    foreach my $param ( keys %param ) {
        next if $param eq 'formula';

        my @constructors = @{ $valid_params{$method}{ $param{'formula'} } };

        if ( !@constructors ) {
            croak "invalid formula name: $param{'formula'} specified";
        }

        if ( grep { $_ eq $param } @constructors ) {
            next;
        }
        else {
            croak "invalid parameter '$param' specified for $method";
        }
    }

    return 0;
}

1;

__END__