File Coverage

blib/lib/Statistics/PCA.pm

Criterion	Covered	Total	%
statement	30	329	9.1
branch	0	38	0.0
condition	0	12	0.0
subroutine	10	47	21.2
pod	3	8	37.5
total	43	434	9.9

#!/usr/bin/perl -w
package Statistics::PCA;
#package Statistics::PCA;
use strict;
use warnings;
use Carp;
use Math::Cephes::Matrix qw(mat);
use List::Util qw(sum);
use Math::MatrixReal;
use Text::SimpleTable;
use Math::Cephes qw(:utils);
use Contextual::Return;
=head1 NAME

Statistics::PCA - A simple Perl implementation of Principal Component Analysis.

=cut
=head1 VERSION

This document describes Statistics::PCA version 0.0.1

=cut
=head1 SYNOPSIS

    use Statistics::PCA;

    # Create new Statistics::PCA object.
    my $pca = Statistics::PCA->new;

    #                  Var1    Var2    Var3    Var4...
    my @Obs1 = (qw/    32      26      51      12    /);
    my @Obs2 = (qw/    17      13      34      35    /);
    my @Obs3 = (qw/    10      94      83      45    /);
    my @Obs4 = (qw/    3       72      72      67    /);
    my @Obs5 = (qw/    10      63      35      34    /);

    # Load data. Data is loaded as a LIST-of-LISTS (LoL) pointed to by a named argument 'data'. Requires argument for format (see METHODS).
    $pca->load_data ( { format => 'table', data => [ \@Obs1, \@Obs2, \@Obs3, \@Obs4, \@Obs5 ], } ) ;

    # Perform the PCA analysis. Takes optional argument 'eigen' (see METHODS).
    #$pca->pca( { eigen => 'C' } );
    $pca->pca();

    # Access results. The return value of this method is context-dependent (see METHODS). To print a report to STDOUT call in VOID-context.
    $pca->results();

=cut
=head1 DESCRIPTION

Principal component analysis (PCA) transforms higher-dimensional data consisting of a number of possibly correlated variables into a smaller number of
uncorrelated variables termed principal components (PCs). The higher the ranking of the PCs the greater the amount of
variability that the PC accounts for. This PCA procedure involves the calculation of the eigenvalue decomposition using either the Math::Cephes::Matrix or
Math::MatrixReal modules (see METHODS) from a data covariance matrix after mean centering the data. See
http://en.wikipedia.org/wiki/Principal_component_analysis for more details.

=cut
=head1 METHODS

=cut
use version; our $VERSION = qv('0.0.1');


#y////////////////////////////////////////////// CONSTRUCTOR AND DATA LOADING /////////////////////////////////////////
#=fs CONSTRUCTOR AND DATA LOADING

#sub diag {
#    my $self = shift;
#    print Dumper $self;
#    return;
#}

=head2 new

Create a new Statistics::PCA object.

    my $pca = Statistics::PCA->new;

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

#/ this will work for a matrix of values where ALL data is complete - i.e.
=head2 load_data

Used for loading data into object. Data is fed as a reference to a LoL within an anonymous hash using the
named argument 'data'. Data may be entered in one of two forms specified by the obligatory named argument 'format'.
Data may either be entered in standard 'table' fashion (with rows corresponding to observations and columns corresponding
to variables). Thus to enter the following table of data:

            Var1    Var2    Var3    Var4

    Obs1    32      26      51      12
    Obs2    17      13      34      35
    Obs3    10      94      83      45
    Obs4    3       72      72      67
    Obs5    10      63      35      34 ...

The data is passed as an LoL with the with each nested ARRAY reference corresponding to a row of observations in the
data table and the 'format' argument value 'table' as follows:

    #                       Var1    Var2    Var3    Var4 ...
    my $data  =   [
                    [qw/    32      26      51      12    /],     # Obs1
                    [qw/    17      13      34      35    /],     # Obs2
                    [qw/    10      94      83      45    /],     # Obs3
                    [qw/    3       72      72      67    /],     # Obs4
                    [qw/    10      63      35      34    /],     # Obs5 ...
                ];

    $pca->load_data ( { format => 'table', data => $data, } );

Alternatively you may enter the data in a variable-centric fashion where each nested ARRAY reference corresponds to a
single variable within the data (i.e. the transpose of the above table-fashion). To pass the above data in this fashion
use the 'format' argument with value 'variable' as follows:

    #                           Obs1    Obs2    Obs3    Obs4    Obs5 ...
    my $transpose = [
                        [qw/    32      17      10      3       10    /],   # Var1
                        [qw/    26      13      94      72      63    /],   # Var2
                        [qw/    51      34      83      72      35    /],   # Var3
                        [qw/    12      35      45      67      34    /],   # Var4 ...
                    ];

    $pca->load_data ( { format => 'variable', data => $transpose, } ) ;

=cut
sub load_data {
    #my ( $self, $data ) = @_;
    my ( $self, $h_ref ) = @_;
    croak qq{\nArguments must be passed as HASH reference.} if ( ( $h_ref ) && ( ref $h_ref ne q{HASH} ) );

    my $data_dirty = $h_ref->{data};

    #y clean it now to stop strange internal references
    my $data = _deep_copy_references($data_dirty);

    croak qq{\nYou must specify a data format} if ( !exists $h_ref->{format} );
    my $format_val = $h_ref->{format};

    my %formating = (   table       =>  sub {   $self->_transpose($data);                           },
                        #y no point in have direct method its so short just put it here
                        #variable    =>  sub {   $self->_direct              },      # just do the calculations directly and put the data in
                        variable    =>  sub {
                                                $self->{summaries}{var_num} = scalar ( @{$data} );
                                                $self->{summaries}{var_length} = scalar ( @{$data->[0]} );
                                                $self->{data}{transpose_temp} = $data; return;     },
                    );

    my $format = $formating{$format_val};
    croak qq{\nYou must pass a recognised option: \"table\", \"variable\"} if ( !defined $format );

    #y &{$cd}() = &$cd() = &$cd = $cd->();
    $format->();

    $self->_data_checks;

    #y adjust flag
    $self->{flags}{data_loaded} = 1;

    return;

}

sub _direct {
    my ( $self, $a_ref ) = @_;

    my $var_num = scalar ( @{$a_ref} );

    my $var_length = scalar ( @{$a_ref->[0]} );

    $self->{data}{transpose_temp} = $a_ref;
    $self->{summaries}{var_num} = $var_num;
    $self->{summaries}{var_length} = $var_length;

    return;
}

sub _transpose {

    my ( $self, $a_ref ) = @_;

    my $var_length = scalar ( @{$a_ref} );

    my $done = [];
    for my $col ( 0..$#{$a_ref->[0]} ) {
        push @{$done}, [ map { $_->[$col] } @{$a_ref} ];
        }

    my $var_num = scalar ( @{$done} );

    $self->{data}{transpose_temp} = $done;
    $self->{summaries}{var_num} = $var_num;
    $self->{summaries}{var_length} = $var_length;

    return;
}

sub _data_checks {

    my $self = shift;

    my $data_a_ref = $self->{data}{transpose_temp};

    my $rows = $self->{summaries}{var_num};
    croak qq{\nI need some data - there are too few rows in your data.\n} if ( !$rows || $rows == 1 );

    my $cols = $self->{summaries}{var_length};
    croak qq{\nI need some data - there are too few columns in your data.\n} if ( !$cols || $cols == 1 );

    for my $row (@{$data_a_ref}) {

        croak qq{\n\nData set must be passed as ARRAY references.\n} if ( ref $row ne q{ARRAY} );
        croak qq{\n\nAll rows must have the same number of columns.\n} if ( scalar( @{$row} ) != $cols );

    }

    #/ all fine and dandy.
    print qq{\nData has $rows variables and $cols observations. Passing data to object.};
    $self->{data}{transpose} = $data_a_ref;
    delete $self->{data}{transpose_temp};

    return;
}

#=fe


#y/////////////////////////////////////////////////////// ANALYSIS ////////////////////////////////////////////////////
#=fs ANALYSIS

=head2 pca

To perform the PCA analysis. This method takes the optional named argument 'eigen' that takes the values 'M' or 'C' to
calculate the eigenvalue decomposition using either the Math::MatrixReal or Math::Cephes::Matrix modules respectively
(defaults to 'M' without argument).

    $pca->pca();
    $pca->pca( { eigen => 'M' } );
    $pca->pca( { eigen => 'C' } );

=cut
sub pca {

    my ( $self, $h_ref ) = @_;
    croak qq{\nArguments must be passed as HASH reference.} if ( ( $h_ref ) && ( ref $h_ref ne q{HASH} ) );

    exists $h_ref->{eigen} || print qq{\nUsing default option of Math::MatrixReal to calculate eigen values.};

    my $eigen = exists $h_ref->{eigen} ? $h_ref->{eigen} : q{M};

    croak qq{\nI don\'t recognise that value for the \'eigen\' option - requires \'M\' or \'C\' (defaults to \'M\' without option).}
          if ( $eigen !~ /\A[MC]\z/xms );

    $self->_calculate_averages;
    $self->_calculate_adjustment;
    $self->_calculate_CVs;

    if ( $eigen eq q{M} ) { $self->_calculate_eigens_matrixreal; }
    # overkill here
    elsif ( $eigen eq q{C} ) { $self->_calculate_eigens_cephes; }

    #y re-orders eigenvalues and eigenvectors according to eigenvalue - thus everything from here is in correct order
    $self->_rank_eigenvalues;

    #y we have ranked data - should put in new positions? so now we do the calculations
    $self->_calculate_components;

    #y generates the prcomp eigenvectors calculation - returns it as an object and also stores the raw data as self->{self}{eigen}
    $self->_transform;

    return;
}

sub _calculate_averages {
    my $self = shift;
    my $new_data = $self->{data}{transpose};

    my $totals_ref = [];

    for my $row ( 0..($self->{summaries}{var_num}-1) ) {

       my $sum = sum @{$new_data->[$row]};
       my $length = scalar ( @{$new_data->[$row]} );
       my $average = $sum / $length;

       push @{$totals_ref}, { sum => $sum, length => $length, average => $average};

   }

       $self->{summaries}{totals} = $totals_ref;
       return;
}

sub _calculate_adjustment {
    my $self = shift;

    my $trans = $self->{data}{transpose};

    my $totals = $self->{summaries}{totals};

    my $adjust = [];

    for my $row ( 0..($self->{summaries}{var_num}-1) ) {

        @{$adjust->[$row]} = map { $_ - $totals->[$row]{average} } @{$trans->[$row]};

    }

    $self->{data}{adjusted} = $adjust;
}

sub _calculate_CVs {
    my $self = shift;

    my $adjusted = $self->{data}{adjusted};
    my $var_num = $self->{summaries}{var_num};
    my $length = $self->{summaries}{var_length};
    my $sum = 0;
    my $covariance_matrix_ref = [];

    for my $row ( 0..($var_num-1) ) {

        for my $col ( 0..($var_num-1) ) {

            my $sum = 0;
            for my $iteration (0..$#{$adjusted->[0]}) {

                my $val = $adjusted->[$col][$iteration] * $adjusted->[$row][$iteration];

                $sum += $val;
            }

            my $cv = $sum / ($length-1);

            $covariance_matrix_ref->[$col][$row] = $cv;
        }
    }

    $self->{summaries}{covariate_matrix} = $covariance_matrix_ref;
    return;

}

sub _calculate_eigens_matrixreal {
    my $self = shift;

    my $covariance_matrix_ref = $self->{summaries}{covariate_matrix};

    my $covariance_matrix_perl = Math::MatrixReal->new_from_cols ( $covariance_matrix_ref ) ;
    my ($eigen_val_perl, $eigen_vec_perl) = $covariance_matrix_perl->sym_diagonalize();
    my $eigen_vec_perl_T = ~$eigen_vec_perl;
    my $eigen_val_perl_T = ~$eigen_val_perl;

    my $overall_alt = [];
    @{$overall_alt} = map { +{ solution => $_+1, eigenvalue => $eigen_val_perl_T->[0][0][$_], eigenvector => $eigen_vec_perl_T->[0][$_] } } (0..$#{$eigen_val_perl_T->[0][0]});

    $self->{summaries}{eigen}{raw} = $overall_alt;

    return;
}

sub _calculate_eigens_cephes {
    my $self = shift;

    my $covariance_matrix_ref = $self->{summaries}{covariate_matrix};
    my $covariance_matrix = mat ( $covariance_matrix_ref ) ;

    my ($eigen_val, $eigen_vec) = $covariance_matrix->eigens();
    my $eigen_vec_ref = $eigen_vec->coef;

#print Dumper       $eigen_val,                       $eigen_vec_ref;
#print Dumper       $eigen_val_perl_T->[0][0],        $eigen_vec_perl_T->[0];

    #y we don´t need it but we will force perl to intepret {} as anon HASH and not BATCH with '+'
    my $overall = [];

    #@{$overall} = map { +{ solution => $_, eigenvalue => $eigen_val->[$_], eigenvector => $eigen_vec_ref->[$_] } } (0..$#{$eigen_val});
    @{$overall} = map { +{ solution => $_+1, eigenvalue => $eigen_val->[$_], eigenvector => $eigen_vec_ref->[$_] } } (0..$#{$eigen_val});

    $self->{summaries}{eigen}{raw} = $overall;
    return;
}

sub _deep_copy_references {
     my $ref = shift;
     if (!ref $ref) { $ref; }
     #y/ this check for a_refs in which case we will access the whole thing as @{$a_ref}
     elsif (ref $ref eq q{ARRAY} ) {
       [ map { _deep_copy_references($_) } @{$ref} ];
    }
    #y/ this checks for hash refs - in which case it will be handled by fully derferencing: %{$ref}
    elsif (ref $ref eq q{HASH} )  {
    #y intepreter forced to read this as an anon HASH and not BATCH  by prepending +
    + {   map { $_ => _deep_copy_references($ref->{$_}) } (keys %{$ref})    };
    }
    else { die "what type is $_?" }
}

sub _rank_eigenvalues {
    my $self = shift;
    my $overall = $self->{summaries}{eigen}{raw};

    #/ deep copy to stop fuss!
    my $overall_clean = _deep_copy_references($overall);

    my $overall_sorted = [];
    #/ Can't use "my $a" in sort comparison at The_PCA_method.pl line 255 - cos $a was declared as lexical and $a/$b are globals...
    @{$overall_sorted} = sort { $b->{eigenvalue} <=> $a->{eigenvalue} } @{$overall_clean};

    $self->{summaries}{eigen}{sorted} = $overall_sorted;

    $self->_add_rank;
    return;
}

sub _add_rank {
    my $self = shift;
    my $overall_sorted = $self->{summaries}{eigen}{sorted};

#@{$overall_sorted} = sort { $b->{eigenvalue} <=> $a->{eigenvalue} } map { my $temp = $_; $overall_sorted->[$temp]{rank} = $temp+1 } (0..$#{$overall_clean});

    for my $pos ( (0..$#{$overall_sorted}) ) {
                #my $overall_sorted->[$pos]{rank} = $pos;
    $overall_sorted->[$pos]{PC} = $pos+1;
    }
    return;
}

sub _calculate_components {
    my $self = shift;
    my $sorted_eigen = $self->{summaries}{eigen}{sorted};

# we will calculate stdev - this is EITHER stdev of the transformed data OR more generally the stdev of the eigenvalue of the solution.

    my $total_variance = sum map { $_->{eigenvalue} } @{$sorted_eigen};

    my $cumulative_variance = 0;

    for my $hash_ref (@{$sorted_eigen}) {

        # use this twice to unpack it
        my $variance_aka_eigenvalue = $hash_ref->{eigenvalue};

        #my $stdev = sqrt($variance_aka_eigenvalue);
        $hash_ref->{stdev} = sqrt($variance_aka_eigenvalue);

        # use this twice so put it in variable
        #$hash_ref->{proportion_of_variance} = ( $variance_aka_eigenvalue / $total_variance );
        my $proportion_of_variance = ($variance_aka_eigenvalue / $total_variance);
        $hash_ref->{proportion_of_variance} = $proportion_of_variance;

        $cumulative_variance += $proportion_of_variance;
        $hash_ref->{cumulative_variance} = $cumulative_variance;
    }

    $self->{summaries}{total_variance} = $total_variance;

    return;
}

sub _create_row_matrix_of_eigenvectors {

    my $self = shift;

    my $sorted_eigen = $self->{summaries}{eigen}{sorted};
    my $eigen_vectors = [];

    @{$eigen_vectors} = map { $_->{eigenvector} } @{$sorted_eigen};

    #y we turn it into a matrix object - should use _from_rows?
    my $eigen_matrix_object = Math::MatrixReal->new_from_cols( $eigen_vectors );

    #y we take the transpose which will be multiplied by the row_adjusted_matrix_object - i.e. transpose
    my $row_eigen_matrix_object = ~$eigen_matrix_object;

    my $eigen_vectors_copy = _deep_copy_references ($eigen_vectors);
    $self->{pca}{eigenvectors} = $eigen_vectors_copy;

    return $row_eigen_matrix_object;
}

sub _create_row_matrix_of_adjusted {
    my $self = shift;

    # unpack adjusted data
    my $adjusted = $self->{data}{adjusted};

    #my $adjusted_data_m = Math::MatrixReal->new_from_cols( $pca->{data}{adjusted} );
    my $adjusted_data_matrix_object = Math::MatrixReal->new_from_cols( $adjusted );

    #y take transpose
    my $row_adjusted_data_matrix = ~$adjusted_data_matrix_object;

    return $row_adjusted_data_matrix;

}

sub _transform {

    my $self = shift;
    my $row_mat_Eigen_object = $self->_create_row_matrix_of_eigenvectors;
    my $row_mat_Adjust_object = $self->_create_row_matrix_of_adjusted;

    #y this is the actual pca output - but needs to be transposed
    my $product_matrix = $row_mat_Eigen_object->multiply($row_mat_Adjust_object);

        #y/ code from MatrixReal: map { $this->[0][$_] = [ @$empty ] } ( 0 .. $rows-1);
        #y/ i.e. all matrix data is put into ->[0]
    $self->{pca}{transform} = $product_matrix->[0];

    return;

}

#=fe


#y/////////////////////////////////////////////////////// RESULTS /////////////////////////////////////////////////////
#=fs RESULTS

=head2 results

Used to access the results of the PCA analysis. This method is context-dependent and will return a variety of different
values depending on whether it is called in VOID or LIST context and the arguments its passed.
In VOID-context it prints a formated table of the computed results to STDOUT.

    $pca->results;

In LIST context this method takes an obligatory argument that determines its return values. To return an ordered list
(ordered by PC ranking) of the proportions of total variance of each PC pass 'proportion' to the method.

    my @list = $pca->results('proportion');
    print qq{\nOrdered list of individual proportions of variance: @list};

To return an ordered list of the cumulative variance of the PCs pass argument 'cumulative'.

    @list = $pca->results('cumulative');
    print qq{\nOrdered list of cumulative variance of the PCs: @list};

To return an ordered list of the individual standard deviations of the PCs pass argument 'stdev'.

    @list = $pca->results('stdev');
    print qq{\nOrdered list of individual standard deviations of the PCs: @list};

To return an ordered list of the individual eigenvalues of the PCs pass argument 'eigenvalue'.

    @list = $pca->results('eigenvalue');
    print qq{\nOrdered list of individual eigenvalues of the PCs: @list};

To return an ordered list of ARRAY references containing the eigenvectors of the PCs pass argument 'eigenvector'.

    # Returns an ordered list of array references containing the eigenvectors for the components
    @list = $pca->results('eigenvector');
    use Data::Dumper;
    print Dumper \@list;

To return an ordered list of ARRAY references containing more detailed information about each PC use the 'full'
argument. Each nested ARRAY reference consists of an ordered list of: PC rank, PC stdev, PC proportion of variance,
PC cumulative_variance, PC eigenvalue and a further nested ARRAY reference containing the PC eigenvector.

    @list = $pca->results('full');
    for my $i (@list) {
        print qq{\nPC rank: $i->[0]}
              . qq{\nPC stdev $i->[1]}
              . qq{\nPC proportion of variance $i->[2]}
              . qq{\nPC cumulative variance $i->[3]}
              . qq{\nPC eigenvalue $i->[4]}
        }

To return an ordered LoL of the transformed data for each of the PCs pass 'transformed' to the method.

    @list = $pca->results('transformed');
    print qq{\nThe transformed data for 'the' principal component (first PC): @{$list[0]} };

=cut
sub results {
    my ( $self, $arg ) = @_;
    return  (
    VOID    { $self->_print           }
    # either have specific methods for type of return! or simply have this and an arguement
    LIST    { $self->_results_in_list($arg) }
    #y total variance is popintless without individual and if you´ve got individual total is trivial so leave these returns are they are.
    # nao faz sentido - nao eh uma teste
    #BOOL    { $F > $standard_F ? 1 : undef;    }
            );
}

sub _print {

    my $self = shift;
    print qq{\n=======================\nRESULTS OF PCA ANALYSIS\n=======================\n};

    $self->print_total_variance;
    $self->print_variance;
    $self->print_eigenvectors;
    $self->print_transform;

    return;
}

#/ should really get the vectors directly from summaries and not re-enter them in the object!!! - especially now that you can just use rank for PC number
sub print_eigenvectors {
    my $self = shift;
    $self->_print_private(q{eigenvectors});
}

sub print_transform {
    my $self = shift;
    $self->_print_private(q{transform});
}

sub print_total_variance {
    my $self = shift;
    print qq{\nTotal Variance = }, sprintf (q{%.8f}, $self->{summaries}{total_variance}), qq{\n};
    return;
}

sub print_variance {
    my $self = shift;

    my $sorted_eigen = $self->{summaries}{eigen}{sorted};

    print qq{\nTable of Standard Deviations and Variances:\n};

    # just create a first columnm that´s empty for names of rows
    my @config_full = ( [22, q{}] );

    # column calculations...
    #/ really ought to get PC name from rank attribute
    #my @config = map { [ 12, q{PC_}.$_ ] } ( 1..(scalar (@{$sorted_eigen})) );
    #my @config = map { [ 12, q{PC_}.$_->{rank} ] } ( 0..(scalar ($#{$sorted_eigen})) );

    #r/ PC is rank - i.e. it is the 'principal' compoenent
    my @config = map { [ 12, q{PC_}.$_->{PC} ] } (@{$sorted_eigen});

    # make the actual configuring array
    push @config_full, @config;

    my $table = Text::SimpleTable->new(@config_full);

    my @row1 = (); # no need to initialise, but whatever...
    for my $hash_ref (@{$sorted_eigen}) { push @row1, sprintf (q{%.8f}, $hash_ref->{stdev}); }
    $table->row( q{Standard Deviation}, @row1 );
    $table->hr;

    my @row2 = (); # no need to initialise, but whatever...
    for my $hash_ref (@{$sorted_eigen}) { push @row2, sprintf (q{%.8f}, $hash_ref->{proportion_of_variance}); }
    $table->row( q{Proportion of Variance}, @row2 );
    $table->hr;

    my @row3 = (); # no need to initialise, but whatever...
    for my $hash_ref (@{$sorted_eigen}) { push @row3, sprintf (q{%.8f}, $hash_ref->{cumulative_variance}); }
    $table->row( q{Cumulative Variance}, @row3 );

    print $table->draw;
    return;
}

sub _print_private {
    my ( $self, $arg ) = @_;

    #/ twat used numeric ==
    $arg eq q{eigenvectors} and print qq{\nTable of vectors:\n};
    $arg eq q{transform} and print qq{\nTable of Transformed data:\n};

    my $blah = $self->{pca}{$arg};

    my @config_full = ( [5, q{}] );
    #y column calculations...
    my @config = map { [ 12, q{PC_}.$_ ] } ( 1..(scalar (@{$blah})) );
    push @config_full, @config;

    my $t2 = Text::SimpleTable->new(@config_full);

    #y all have same component number so who gives a shit
    for my $row (0..$#{$blah->[0]}) {
        my @data;
        for my $col (0..$#{$blah}) {
            push @data, sprintf (q{%.8f}, $blah->[$col][$row] );
        }
            $t2->row( $row+1, @data );
    }
    print $t2->draw;
    return;
}

sub _results_in_list {
    my ( $self, $arg ) = @_;

    #/ twat need to make ALL of sorted an array and dereference each for key using map
    #y really need to re-write the first ref of these due to code re-usage
    my %options = ( cumulative  =>  sub { ( map { $_->{cumulative_variance}     } @{$self->{summaries}{eigen}{sorted}} )   },
                    proportion  =>  sub { ( map { $_->{proportion_of_variance}  } @{$self->{summaries}{eigen}{sorted}} )   },
                    stdev       =>  sub { ( map { $_->{stdev}                   } @{$self->{summaries}{eigen}{sorted}} )   },
                    eigenvalue  =>  sub { ( map { $_->{eigenvalue}              } @{$self->{summaries}{eigen}{sorted}} )   },
                    #y these are already in the form of array refs
                    #eigenvector =>  sub { ( map { $_->{eigenvector}             } @{$self->{summaries}{eigen}{sorted}} )   },
                    eigenvector =>  sub { ( @{$self->{pca}{eigenvectors}} )                                                 },
                    #y put it into ordered list
                    # to convert this one we need to convert the whole thing to a numeric iterator and dereference each accordingly - not worth it
                    full        =>  sub { ( map { [ $_->{PC}, $_->{stdev}, $_->{proportion_of_variance},
                                                    $_->{cumulative_variance}, $_->{eigenvalue}, $_->{eigenvector}, ]
                                                                                } @{$self->{summaries}{eigen}{sorted}} )   },
                    transformed =>  sub { ( @{$self->{pca}{transform}} )                                                   },

                 );

   #/ either use exists on the key value - OR - assign it to a variable and check the variable for defindness... e.g. my $setting =....
    #croak qq{\nYou must pass a recognised option: \"cumulative\", \"proportion\"} if ( !exists
    my $setting = $options{$arg};
    croak qq{\nYou must pass a recognised option: \"cumulative\", \"proportion\", \"stdev\", \"eigenvalue\"...} if ( !defined $setting );

    #y &{$cd}();
    #y &$cd();
    #y &$cd;
    #y $cd->();

    $setting->();
    # return;
}

#=fe


1; # Magic true value required at end of module

__END__