# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.40
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

package Math::GSL::Eigen;
use base qw(Exporter);
use base qw(DynaLoader);
package Math::GSL::Eigenc;
bootstrap Math::GSL::Eigen;
package Math::GSL::Eigen;
@EXPORT = qw();

# ---------- BASE METHODS -------------

package Math::GSL::Eigen;

sub TIEHASH {
    my ($classname,$obj) = @_;
    return bless $obj, $classname;
}

sub CLEAR { }

sub FIRSTKEY { }

sub NEXTKEY { }

sub FETCH {
    my ($self,$field) = @_;
    my $member_func = "swig_${field}_get";
    $self->$member_func();
}

sub STORE {
    my ($self,$field,$newval) = @_;
    my $member_func = "swig_${field}_set";
    $self->$member_func($newval);
}

sub this {
    my $ptr = shift;
    return tied(%$ptr);
}


# ------- FUNCTION WRAPPERS --------

package Math::GSL::Eigen;

*gsl_eigen_symm_alloc = *Math::GSL::Eigenc::gsl_eigen_symm_alloc;
*gsl_eigen_symm_free = *Math::GSL::Eigenc::gsl_eigen_symm_free;
*gsl_eigen_symm = *Math::GSL::Eigenc::gsl_eigen_symm;
*gsl_eigen_symmv_alloc = *Math::GSL::Eigenc::gsl_eigen_symmv_alloc;
*gsl_eigen_symmv_free = *Math::GSL::Eigenc::gsl_eigen_symmv_free;
*gsl_eigen_symmv = *Math::GSL::Eigenc::gsl_eigen_symmv;
*gsl_eigen_herm_alloc = *Math::GSL::Eigenc::gsl_eigen_herm_alloc;
*gsl_eigen_herm_free = *Math::GSL::Eigenc::gsl_eigen_herm_free;
*gsl_eigen_herm = *Math::GSL::Eigenc::gsl_eigen_herm;
*gsl_eigen_hermv_alloc = *Math::GSL::Eigenc::gsl_eigen_hermv_alloc;
*gsl_eigen_hermv_free = *Math::GSL::Eigenc::gsl_eigen_hermv_free;
*gsl_eigen_hermv = *Math::GSL::Eigenc::gsl_eigen_hermv;
*gsl_eigen_francis_alloc = *Math::GSL::Eigenc::gsl_eigen_francis_alloc;
*gsl_eigen_francis_free = *Math::GSL::Eigenc::gsl_eigen_francis_free;
*gsl_eigen_francis_T = *Math::GSL::Eigenc::gsl_eigen_francis_T;
*gsl_eigen_francis = *Math::GSL::Eigenc::gsl_eigen_francis;
*gsl_eigen_francis_Z = *Math::GSL::Eigenc::gsl_eigen_francis_Z;
*gsl_eigen_nonsymm_alloc = *Math::GSL::Eigenc::gsl_eigen_nonsymm_alloc;
*gsl_eigen_nonsymm_free = *Math::GSL::Eigenc::gsl_eigen_nonsymm_free;
*gsl_eigen_nonsymm_params = *Math::GSL::Eigenc::gsl_eigen_nonsymm_params;
*gsl_eigen_nonsymm = *Math::GSL::Eigenc::gsl_eigen_nonsymm;
*gsl_eigen_nonsymm_Z = *Math::GSL::Eigenc::gsl_eigen_nonsymm_Z;
*gsl_eigen_nonsymmv_alloc = *Math::GSL::Eigenc::gsl_eigen_nonsymmv_alloc;
*gsl_eigen_nonsymmv_free = *Math::GSL::Eigenc::gsl_eigen_nonsymmv_free;
*gsl_eigen_nonsymmv = *Math::GSL::Eigenc::gsl_eigen_nonsymmv;
*gsl_eigen_nonsymmv_Z = *Math::GSL::Eigenc::gsl_eigen_nonsymmv_Z;
*gsl_eigen_gensymm_alloc = *Math::GSL::Eigenc::gsl_eigen_gensymm_alloc;
*gsl_eigen_gensymm_free = *Math::GSL::Eigenc::gsl_eigen_gensymm_free;
*gsl_eigen_gensymm = *Math::GSL::Eigenc::gsl_eigen_gensymm;
*gsl_eigen_gensymm_standardize = *Math::GSL::Eigenc::gsl_eigen_gensymm_standardize;
*gsl_eigen_gensymmv_alloc = *Math::GSL::Eigenc::gsl_eigen_gensymmv_alloc;
*gsl_eigen_gensymmv_free = *Math::GSL::Eigenc::gsl_eigen_gensymmv_free;
*gsl_eigen_gensymmv = *Math::GSL::Eigenc::gsl_eigen_gensymmv;
*gsl_eigen_genherm_alloc = *Math::GSL::Eigenc::gsl_eigen_genherm_alloc;
*gsl_eigen_genherm_free = *Math::GSL::Eigenc::gsl_eigen_genherm_free;
*gsl_eigen_genherm = *Math::GSL::Eigenc::gsl_eigen_genherm;
*gsl_eigen_genherm_standardize = *Math::GSL::Eigenc::gsl_eigen_genherm_standardize;
*gsl_eigen_genhermv_alloc = *Math::GSL::Eigenc::gsl_eigen_genhermv_alloc;
*gsl_eigen_genhermv_free = *Math::GSL::Eigenc::gsl_eigen_genhermv_free;
*gsl_eigen_genhermv = *Math::GSL::Eigenc::gsl_eigen_genhermv;
*gsl_eigen_gen_alloc = *Math::GSL::Eigenc::gsl_eigen_gen_alloc;
*gsl_eigen_gen_free = *Math::GSL::Eigenc::gsl_eigen_gen_free;
*gsl_eigen_gen_params = *Math::GSL::Eigenc::gsl_eigen_gen_params;
*gsl_eigen_gen = *Math::GSL::Eigenc::gsl_eigen_gen;
*gsl_eigen_gen_QZ = *Math::GSL::Eigenc::gsl_eigen_gen_QZ;
*gsl_eigen_genv_alloc = *Math::GSL::Eigenc::gsl_eigen_genv_alloc;
*gsl_eigen_genv_free = *Math::GSL::Eigenc::gsl_eigen_genv_free;
*gsl_eigen_genv = *Math::GSL::Eigenc::gsl_eigen_genv;
*gsl_eigen_genv_QZ = *Math::GSL::Eigenc::gsl_eigen_genv_QZ;
*gsl_eigen_symmv_sort = *Math::GSL::Eigenc::gsl_eigen_symmv_sort;
*gsl_eigen_hermv_sort = *Math::GSL::Eigenc::gsl_eigen_hermv_sort;
*gsl_eigen_nonsymmv_sort = *Math::GSL::Eigenc::gsl_eigen_nonsymmv_sort;
*gsl_eigen_gensymmv_sort = *Math::GSL::Eigenc::gsl_eigen_gensymmv_sort;
*gsl_eigen_genhermv_sort = *Math::GSL::Eigenc::gsl_eigen_genhermv_sort;
*gsl_eigen_genv_sort = *Math::GSL::Eigenc::gsl_eigen_genv_sort;
*gsl_schur_gen_eigvals = *Math::GSL::Eigenc::gsl_schur_gen_eigvals;
*gsl_schur_solve_equation = *Math::GSL::Eigenc::gsl_schur_solve_equation;
*gsl_schur_solve_equation_z = *Math::GSL::Eigenc::gsl_schur_solve_equation_z;
*gsl_eigen_jacobi = *Math::GSL::Eigenc::gsl_eigen_jacobi;
*gsl_eigen_invert_jacobi = *Math::GSL::Eigenc::gsl_eigen_invert_jacobi;

############# Class : Math::GSL::Eigen::gsl_eigen_symm_workspace ##############

package Math::GSL::Eigen::gsl_eigen_symm_workspace;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( Math::GSL::Eigen );
%OWNER = ();
%ITERATORS = ();
*swig_size_get = *Math::GSL::Eigenc::gsl_eigen_symm_workspace_size_get;
*swig_size_set = *Math::GSL::Eigenc::gsl_eigen_symm_workspace_size_set;
*swig_d_get = *Math::GSL::Eigenc::gsl_eigen_symm_workspace_d_get;
*swig_d_set = *Math::GSL::Eigenc::gsl_eigen_symm_workspace_d_set;
*swig_sd_get = *Math::GSL::Eigenc::gsl_eigen_symm_workspace_sd_get;
*swig_sd_set = *Math::GSL::Eigenc::gsl_eigen_symm_workspace_sd_set;
sub new {
    my $pkg = shift;
    my $self = Math::GSL::Eigenc::new_gsl_eigen_symm_workspace(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        Math::GSL::Eigenc::delete_gsl_eigen_symm_workspace($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : Math::GSL::Eigen::gsl_eigen_symmv_workspace ##############

package Math::GSL::Eigen::gsl_eigen_symmv_workspace;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( Math::GSL::Eigen );
%OWNER = ();
%ITERATORS = ();
*swig_size_get = *Math::GSL::Eigenc::gsl_eigen_symmv_workspace_size_get;
*swig_size_set = *Math::GSL::Eigenc::gsl_eigen_symmv_workspace_size_set;
*swig_d_get = *Math::GSL::Eigenc::gsl_eigen_symmv_workspace_d_get;
*swig_d_set = *Math::GSL::Eigenc::gsl_eigen_symmv_workspace_d_set;
*swig_sd_get = *Math::GSL::Eigenc::gsl_eigen_symmv_workspace_sd_get;
*swig_sd_set = *Math::GSL::Eigenc::gsl_eigen_symmv_workspace_sd_set;
*swig_gc_get = *Math::GSL::Eigenc::gsl_eigen_symmv_workspace_gc_get;
*swig_gc_set = *Math::GSL::Eigenc::gsl_eigen_symmv_workspace_gc_set;
*swig_gs_get = *Math::GSL::Eigenc::gsl_eigen_symmv_workspace_gs_get;
*swig_gs_set = *Math::GSL::Eigenc::gsl_eigen_symmv_workspace_gs_set;
sub new {
    my $pkg = shift;
    my $self = Math::GSL::Eigenc::new_gsl_eigen_symmv_workspace(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        Math::GSL::Eigenc::delete_gsl_eigen_symmv_workspace($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : Math::GSL::Eigen::gsl_eigen_herm_workspace ##############

package Math::GSL::Eigen::gsl_eigen_herm_workspace;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( Math::GSL::Eigen );
%OWNER = ();
%ITERATORS = ();
*swig_size_get = *Math::GSL::Eigenc::gsl_eigen_herm_workspace_size_get;
*swig_size_set = *Math::GSL::Eigenc::gsl_eigen_herm_workspace_size_set;
*swig_d_get = *Math::GSL::Eigenc::gsl_eigen_herm_workspace_d_get;
*swig_d_set = *Math::GSL::Eigenc::gsl_eigen_herm_workspace_d_set;
*swig_sd_get = *Math::GSL::Eigenc::gsl_eigen_herm_workspace_sd_get;
*swig_sd_set = *Math::GSL::Eigenc::gsl_eigen_herm_workspace_sd_set;
*swig_tau_get = *Math::GSL::Eigenc::gsl_eigen_herm_workspace_tau_get;
*swig_tau_set = *Math::GSL::Eigenc::gsl_eigen_herm_workspace_tau_set;
sub new {
    my $pkg = shift;
    my $self = Math::GSL::Eigenc::new_gsl_eigen_herm_workspace(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        Math::GSL::Eigenc::delete_gsl_eigen_herm_workspace($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : Math::GSL::Eigen::gsl_eigen_hermv_workspace ##############

package Math::GSL::Eigen::gsl_eigen_hermv_workspace;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( Math::GSL::Eigen );
%OWNER = ();
%ITERATORS = ();
*swig_size_get = *Math::GSL::Eigenc::gsl_eigen_hermv_workspace_size_get;
*swig_size_set = *Math::GSL::Eigenc::gsl_eigen_hermv_workspace_size_set;
*swig_d_get = *Math::GSL::Eigenc::gsl_eigen_hermv_workspace_d_get;
*swig_d_set = *Math::GSL::Eigenc::gsl_eigen_hermv_workspace_d_set;
*swig_sd_get = *Math::GSL::Eigenc::gsl_eigen_hermv_workspace_sd_get;
*swig_sd_set = *Math::GSL::Eigenc::gsl_eigen_hermv_workspace_sd_set;
*swig_tau_get = *Math::GSL::Eigenc::gsl_eigen_hermv_workspace_tau_get;
*swig_tau_set = *Math::GSL::Eigenc::gsl_eigen_hermv_workspace_tau_set;
*swig_gc_get = *Math::GSL::Eigenc::gsl_eigen_hermv_workspace_gc_get;
*swig_gc_set = *Math::GSL::Eigenc::gsl_eigen_hermv_workspace_gc_set;
*swig_gs_get = *Math::GSL::Eigenc::gsl_eigen_hermv_workspace_gs_get;
*swig_gs_set = *Math::GSL::Eigenc::gsl_eigen_hermv_workspace_gs_set;
sub new {
    my $pkg = shift;
    my $self = Math::GSL::Eigenc::new_gsl_eigen_hermv_workspace(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        Math::GSL::Eigenc::delete_gsl_eigen_hermv_workspace($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : Math::GSL::Eigen::gsl_eigen_francis_workspace ##############

package Math::GSL::Eigen::gsl_eigen_francis_workspace;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( Math::GSL::Eigen );
%OWNER = ();
%ITERATORS = ();
*swig_size_get = *Math::GSL::Eigenc::gsl_eigen_francis_workspace_size_get;
*swig_size_set = *Math::GSL::Eigenc::gsl_eigen_francis_workspace_size_set;
*swig_max_iterations_get = *Math::GSL::Eigenc::gsl_eigen_francis_workspace_max_iterations_get;
*swig_max_iterations_set = *Math::GSL::Eigenc::gsl_eigen_francis_workspace_max_iterations_set;
*swig_n_iter_get = *Math::GSL::Eigenc::gsl_eigen_francis_workspace_n_iter_get;
*swig_n_iter_set = *Math::GSL::Eigenc::gsl_eigen_francis_workspace_n_iter_set;
*swig_n_evals_get = *Math::GSL::Eigenc::gsl_eigen_francis_workspace_n_evals_get;
*swig_n_evals_set = *Math::GSL::Eigenc::gsl_eigen_francis_workspace_n_evals_set;
*swig_compute_t_get = *Math::GSL::Eigenc::gsl_eigen_francis_workspace_compute_t_get;
*swig_compute_t_set = *Math::GSL::Eigenc::gsl_eigen_francis_workspace_compute_t_set;
*swig_H_get = *Math::GSL::Eigenc::gsl_eigen_francis_workspace_H_get;
*swig_H_set = *Math::GSL::Eigenc::gsl_eigen_francis_workspace_H_set;
*swig_Z_get = *Math::GSL::Eigenc::gsl_eigen_francis_workspace_Z_get;
*swig_Z_set = *Math::GSL::Eigenc::gsl_eigen_francis_workspace_Z_set;
sub new {
    my $pkg = shift;
    my $self = Math::GSL::Eigenc::new_gsl_eigen_francis_workspace(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        Math::GSL::Eigenc::delete_gsl_eigen_francis_workspace($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : Math::GSL::Eigen::gsl_eigen_nonsymm_workspace ##############

package Math::GSL::Eigen::gsl_eigen_nonsymm_workspace;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( Math::GSL::Eigen );
%OWNER = ();
%ITERATORS = ();
*swig_size_get = *Math::GSL::Eigenc::gsl_eigen_nonsymm_workspace_size_get;
*swig_size_set = *Math::GSL::Eigenc::gsl_eigen_nonsymm_workspace_size_set;
*swig_diag_get = *Math::GSL::Eigenc::gsl_eigen_nonsymm_workspace_diag_get;
*swig_diag_set = *Math::GSL::Eigenc::gsl_eigen_nonsymm_workspace_diag_set;
*swig_tau_get = *Math::GSL::Eigenc::gsl_eigen_nonsymm_workspace_tau_get;
*swig_tau_set = *Math::GSL::Eigenc::gsl_eigen_nonsymm_workspace_tau_set;
*swig_Z_get = *Math::GSL::Eigenc::gsl_eigen_nonsymm_workspace_Z_get;
*swig_Z_set = *Math::GSL::Eigenc::gsl_eigen_nonsymm_workspace_Z_set;
*swig_do_balance_get = *Math::GSL::Eigenc::gsl_eigen_nonsymm_workspace_do_balance_get;
*swig_do_balance_set = *Math::GSL::Eigenc::gsl_eigen_nonsymm_workspace_do_balance_set;
*swig_n_evals_get = *Math::GSL::Eigenc::gsl_eigen_nonsymm_workspace_n_evals_get;
*swig_n_evals_set = *Math::GSL::Eigenc::gsl_eigen_nonsymm_workspace_n_evals_set;
*swig_francis_workspace_p_get = *Math::GSL::Eigenc::gsl_eigen_nonsymm_workspace_francis_workspace_p_get;
*swig_francis_workspace_p_set = *Math::GSL::Eigenc::gsl_eigen_nonsymm_workspace_francis_workspace_p_set;
sub new {
    my $pkg = shift;
    my $self = Math::GSL::Eigenc::new_gsl_eigen_nonsymm_workspace(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        Math::GSL::Eigenc::delete_gsl_eigen_nonsymm_workspace($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : Math::GSL::Eigen::gsl_eigen_nonsymmv_workspace ##############

package Math::GSL::Eigen::gsl_eigen_nonsymmv_workspace;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( Math::GSL::Eigen );
%OWNER = ();
%ITERATORS = ();
*swig_size_get = *Math::GSL::Eigenc::gsl_eigen_nonsymmv_workspace_size_get;
*swig_size_set = *Math::GSL::Eigenc::gsl_eigen_nonsymmv_workspace_size_set;
*swig_work_get = *Math::GSL::Eigenc::gsl_eigen_nonsymmv_workspace_work_get;
*swig_work_set = *Math::GSL::Eigenc::gsl_eigen_nonsymmv_workspace_work_set;
*swig_work2_get = *Math::GSL::Eigenc::gsl_eigen_nonsymmv_workspace_work2_get;
*swig_work2_set = *Math::GSL::Eigenc::gsl_eigen_nonsymmv_workspace_work2_set;
*swig_work3_get = *Math::GSL::Eigenc::gsl_eigen_nonsymmv_workspace_work3_get;
*swig_work3_set = *Math::GSL::Eigenc::gsl_eigen_nonsymmv_workspace_work3_set;
*swig_Z_get = *Math::GSL::Eigenc::gsl_eigen_nonsymmv_workspace_Z_get;
*swig_Z_set = *Math::GSL::Eigenc::gsl_eigen_nonsymmv_workspace_Z_set;
*swig_nonsymm_workspace_p_get = *Math::GSL::Eigenc::gsl_eigen_nonsymmv_workspace_nonsymm_workspace_p_get;
*swig_nonsymm_workspace_p_set = *Math::GSL::Eigenc::gsl_eigen_nonsymmv_workspace_nonsymm_workspace_p_set;
sub new {
    my $pkg = shift;
    my $self = Math::GSL::Eigenc::new_gsl_eigen_nonsymmv_workspace(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        Math::GSL::Eigenc::delete_gsl_eigen_nonsymmv_workspace($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : Math::GSL::Eigen::gsl_eigen_gensymm_workspace ##############

package Math::GSL::Eigen::gsl_eigen_gensymm_workspace;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( Math::GSL::Eigen );
%OWNER = ();
%ITERATORS = ();
*swig_size_get = *Math::GSL::Eigenc::gsl_eigen_gensymm_workspace_size_get;
*swig_size_set = *Math::GSL::Eigenc::gsl_eigen_gensymm_workspace_size_set;
*swig_symm_workspace_p_get = *Math::GSL::Eigenc::gsl_eigen_gensymm_workspace_symm_workspace_p_get;
*swig_symm_workspace_p_set = *Math::GSL::Eigenc::gsl_eigen_gensymm_workspace_symm_workspace_p_set;
sub new {
    my $pkg = shift;
    my $self = Math::GSL::Eigenc::new_gsl_eigen_gensymm_workspace(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        Math::GSL::Eigenc::delete_gsl_eigen_gensymm_workspace($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : Math::GSL::Eigen::gsl_eigen_gensymmv_workspace ##############

package Math::GSL::Eigen::gsl_eigen_gensymmv_workspace;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( Math::GSL::Eigen );
%OWNER = ();
%ITERATORS = ();
*swig_size_get = *Math::GSL::Eigenc::gsl_eigen_gensymmv_workspace_size_get;
*swig_size_set = *Math::GSL::Eigenc::gsl_eigen_gensymmv_workspace_size_set;
*swig_symmv_workspace_p_get = *Math::GSL::Eigenc::gsl_eigen_gensymmv_workspace_symmv_workspace_p_get;
*swig_symmv_workspace_p_set = *Math::GSL::Eigenc::gsl_eigen_gensymmv_workspace_symmv_workspace_p_set;
sub new {
    my $pkg = shift;
    my $self = Math::GSL::Eigenc::new_gsl_eigen_gensymmv_workspace(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        Math::GSL::Eigenc::delete_gsl_eigen_gensymmv_workspace($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : Math::GSL::Eigen::gsl_eigen_genherm_workspace ##############

package Math::GSL::Eigen::gsl_eigen_genherm_workspace;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( Math::GSL::Eigen );
%OWNER = ();
%ITERATORS = ();
*swig_size_get = *Math::GSL::Eigenc::gsl_eigen_genherm_workspace_size_get;
*swig_size_set = *Math::GSL::Eigenc::gsl_eigen_genherm_workspace_size_set;
*swig_herm_workspace_p_get = *Math::GSL::Eigenc::gsl_eigen_genherm_workspace_herm_workspace_p_get;
*swig_herm_workspace_p_set = *Math::GSL::Eigenc::gsl_eigen_genherm_workspace_herm_workspace_p_set;
sub new {
    my $pkg = shift;
    my $self = Math::GSL::Eigenc::new_gsl_eigen_genherm_workspace(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        Math::GSL::Eigenc::delete_gsl_eigen_genherm_workspace($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : Math::GSL::Eigen::gsl_eigen_genhermv_workspace ##############

package Math::GSL::Eigen::gsl_eigen_genhermv_workspace;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( Math::GSL::Eigen );
%OWNER = ();
%ITERATORS = ();
*swig_size_get = *Math::GSL::Eigenc::gsl_eigen_genhermv_workspace_size_get;
*swig_size_set = *Math::GSL::Eigenc::gsl_eigen_genhermv_workspace_size_set;
*swig_hermv_workspace_p_get = *Math::GSL::Eigenc::gsl_eigen_genhermv_workspace_hermv_workspace_p_get;
*swig_hermv_workspace_p_set = *Math::GSL::Eigenc::gsl_eigen_genhermv_workspace_hermv_workspace_p_set;
sub new {
    my $pkg = shift;
    my $self = Math::GSL::Eigenc::new_gsl_eigen_genhermv_workspace(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        Math::GSL::Eigenc::delete_gsl_eigen_genhermv_workspace($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : Math::GSL::Eigen::gsl_eigen_gen_workspace ##############

package Math::GSL::Eigen::gsl_eigen_gen_workspace;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( Math::GSL::Eigen );
%OWNER = ();
%ITERATORS = ();
*swig_size_get = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_size_get;
*swig_size_set = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_size_set;
*swig_work_get = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_work_get;
*swig_work_set = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_work_set;
*swig_n_evals_get = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_n_evals_get;
*swig_n_evals_set = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_n_evals_set;
*swig_max_iterations_get = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_max_iterations_get;
*swig_max_iterations_set = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_max_iterations_set;
*swig_n_iter_get = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_n_iter_get;
*swig_n_iter_set = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_n_iter_set;
*swig_eshift_get = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_eshift_get;
*swig_eshift_set = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_eshift_set;
*swig_needtop_get = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_needtop_get;
*swig_needtop_set = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_needtop_set;
*swig_atol_get = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_atol_get;
*swig_atol_set = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_atol_set;
*swig_btol_get = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_btol_get;
*swig_btol_set = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_btol_set;
*swig_ascale_get = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_ascale_get;
*swig_ascale_set = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_ascale_set;
*swig_bscale_get = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_bscale_get;
*swig_bscale_set = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_bscale_set;
*swig_H_get = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_H_get;
*swig_H_set = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_H_set;
*swig_R_get = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_R_get;
*swig_R_set = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_R_set;
*swig_compute_s_get = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_compute_s_get;
*swig_compute_s_set = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_compute_s_set;
*swig_compute_t_get = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_compute_t_get;
*swig_compute_t_set = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_compute_t_set;
*swig_Q_get = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_Q_get;
*swig_Q_set = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_Q_set;
*swig_Z_get = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_Z_get;
*swig_Z_set = *Math::GSL::Eigenc::gsl_eigen_gen_workspace_Z_set;
sub new {
    my $pkg = shift;
    my $self = Math::GSL::Eigenc::new_gsl_eigen_gen_workspace(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        Math::GSL::Eigenc::delete_gsl_eigen_gen_workspace($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : Math::GSL::Eigen::gsl_eigen_genv_workspace ##############

package Math::GSL::Eigen::gsl_eigen_genv_workspace;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( Math::GSL::Eigen );
%OWNER = ();
%ITERATORS = ();
*swig_size_get = *Math::GSL::Eigenc::gsl_eigen_genv_workspace_size_get;
*swig_size_set = *Math::GSL::Eigenc::gsl_eigen_genv_workspace_size_set;
*swig_work1_get = *Math::GSL::Eigenc::gsl_eigen_genv_workspace_work1_get;
*swig_work1_set = *Math::GSL::Eigenc::gsl_eigen_genv_workspace_work1_set;
*swig_work2_get = *Math::GSL::Eigenc::gsl_eigen_genv_workspace_work2_get;
*swig_work2_set = *Math::GSL::Eigenc::gsl_eigen_genv_workspace_work2_set;
*swig_work3_get = *Math::GSL::Eigenc::gsl_eigen_genv_workspace_work3_get;
*swig_work3_set = *Math::GSL::Eigenc::gsl_eigen_genv_workspace_work3_set;
*swig_work4_get = *Math::GSL::Eigenc::gsl_eigen_genv_workspace_work4_get;
*swig_work4_set = *Math::GSL::Eigenc::gsl_eigen_genv_workspace_work4_set;
*swig_work5_get = *Math::GSL::Eigenc::gsl_eigen_genv_workspace_work5_get;
*swig_work5_set = *Math::GSL::Eigenc::gsl_eigen_genv_workspace_work5_set;
*swig_work6_get = *Math::GSL::Eigenc::gsl_eigen_genv_workspace_work6_get;
*swig_work6_set = *Math::GSL::Eigenc::gsl_eigen_genv_workspace_work6_set;
*swig_Q_get = *Math::GSL::Eigenc::gsl_eigen_genv_workspace_Q_get;
*swig_Q_set = *Math::GSL::Eigenc::gsl_eigen_genv_workspace_Q_set;
*swig_Z_get = *Math::GSL::Eigenc::gsl_eigen_genv_workspace_Z_get;
*swig_Z_set = *Math::GSL::Eigenc::gsl_eigen_genv_workspace_Z_set;
*swig_gen_workspace_p_get = *Math::GSL::Eigenc::gsl_eigen_genv_workspace_gen_workspace_p_get;
*swig_gen_workspace_p_set = *Math::GSL::Eigenc::gsl_eigen_genv_workspace_gen_workspace_p_set;
sub new {
    my $pkg = shift;
    my $self = Math::GSL::Eigenc::new_gsl_eigen_genv_workspace(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        Math::GSL::Eigenc::delete_gsl_eigen_genv_workspace($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : Math::GSL::Eigen::gsl_complex_long_double ##############

package Math::GSL::Eigen::gsl_complex_long_double;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( Math::GSL::Eigen );
%OWNER = ();
%ITERATORS = ();
*swig_dat_get = *Math::GSL::Eigenc::gsl_complex_long_double_dat_get;
*swig_dat_set = *Math::GSL::Eigenc::gsl_complex_long_double_dat_set;
sub new {
    my $pkg = shift;
    my $self = Math::GSL::Eigenc::new_gsl_complex_long_double(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        Math::GSL::Eigenc::delete_gsl_complex_long_double($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : Math::GSL::Eigen::gsl_complex ##############

package Math::GSL::Eigen::gsl_complex;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( Math::GSL::Eigen );
%OWNER = ();
%ITERATORS = ();
*swig_dat_get = *Math::GSL::Eigenc::gsl_complex_dat_get;
*swig_dat_set = *Math::GSL::Eigenc::gsl_complex_dat_set;
sub new {
    my $pkg = shift;
    my $self = Math::GSL::Eigenc::new_gsl_complex(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        Math::GSL::Eigenc::delete_gsl_complex($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : Math::GSL::Eigen::gsl_complex_float ##############

package Math::GSL::Eigen::gsl_complex_float;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( Math::GSL::Eigen );
%OWNER = ();
%ITERATORS = ();
*swig_dat_get = *Math::GSL::Eigenc::gsl_complex_float_dat_get;
*swig_dat_set = *Math::GSL::Eigenc::gsl_complex_float_dat_set;
sub new {
    my $pkg = shift;
    my $self = Math::GSL::Eigenc::new_gsl_complex_float(@_);
    bless $self, $pkg if defined($self);
}

sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        Math::GSL::Eigenc::delete_gsl_complex_float($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


# ------- VARIABLE STUBS --------

package Math::GSL::Eigen;

*GSL_MAJOR_VERSION = *Math::GSL::Eigenc::GSL_MAJOR_VERSION;
*GSL_MINOR_VERSION = *Math::GSL::Eigenc::GSL_MINOR_VERSION;
*GSL_POSZERO = *Math::GSL::Eigenc::GSL_POSZERO;
*GSL_NEGZERO = *Math::GSL::Eigenc::GSL_NEGZERO;
*GSL_EIGEN_SORT_VAL_ASC = *Math::GSL::Eigenc::GSL_EIGEN_SORT_VAL_ASC;
*GSL_EIGEN_SORT_VAL_DESC = *Math::GSL::Eigenc::GSL_EIGEN_SORT_VAL_DESC;
*GSL_EIGEN_SORT_ABS_ASC = *Math::GSL::Eigenc::GSL_EIGEN_SORT_ABS_ASC;
*GSL_EIGEN_SORT_ABS_DESC = *Math::GSL::Eigenc::GSL_EIGEN_SORT_ABS_DESC;


@EXPORT_OK = qw/
                gsl_eigen_symm_alloc gsl_eigen_symm_free 
                gsl_eigen_symm gsl_eigen_symmv_alloc gsl_eigen_symmv_free gsl_eigen_symmv 
                gsl_eigen_herm_alloc gsl_eigen_herm_free gsl_eigen_herm gsl_eigen_hermv_alloc 
                gsl_eigen_hermv_free gsl_eigen_hermv gsl_eigen_francis_alloc gsl_eigen_francis_free 
                gsl_eigen_francis_T gsl_eigen_francis gsl_eigen_francis_Z gsl_eigen_nonsymm_alloc 
                gsl_eigen_nonsymm_free gsl_eigen_nonsymm_params gsl_eigen_nonsymm 
                gsl_eigen_nonsymm_Z gsl_eigen_nonsymmv_alloc gsl_eigen_nonsymmv_free 
                gsl_eigen_nonsymmv gsl_eigen_nonsymmv_Z gsl_eigen_gensymm_alloc 
                gsl_eigen_gensymm_free gsl_eigen_gensymm gsl_eigen_gensymm_standardize 
                gsl_eigen_gensymmv_alloc gsl_eigen_gensymmv_free gsl_eigen_gensymmv 
                gsl_eigen_genherm_alloc gsl_eigen_genherm_free gsl_eigen_genherm 
                gsl_eigen_genherm_standardize gsl_eigen_genhermv_alloc gsl_eigen_genhermv_free 
                gsl_eigen_genhermv gsl_eigen_gen_alloc gsl_eigen_gen_free 
                gsl_eigen_gen_params gsl_eigen_gen gsl_eigen_gen_QZ 
                gsl_eigen_genv_alloc gsl_eigen_genv_free gsl_eigen_genv 
                gsl_eigen_genv_QZ gsl_eigen_symmv_sort gsl_eigen_hermv_sort 
                gsl_eigen_nonsymmv_sort gsl_eigen_gensymmv_sort gsl_eigen_genhermv_sort 
                gsl_eigen_genv_sort gsl_schur_gen_eigvals gsl_schur_solve_equation 
                gsl_schur_solve_equation_z gsl_eigen_jacobi gsl_eigen_invert_jacobi 
                $GSL_EIGEN_SORT_VAL_ASC $GSL_EIGEN_SORT_VAL_DESC 
                $GSL_EIGEN_SORT_ABS_ASC $GSL_EIGEN_SORT_ABS_DESC 
            /;
%EXPORT_TAGS = ( all => [ @EXPORT_OK ] );

__END__

=head1 NAME

Math::GSL::Eigen - Functions for computing eigenvalues and eigenvectors of matrices

=head1 SYNOPSIS

use Math::GSL::Eigen qw/:all/;

=head1 DESCRIPTION

Here is a list of all the functions included in this module :

=over

=item gsl_eigen_symm_alloc($n) - This function returns a workspace for computing eigenvalues of n-by-n real symmetric matrices.

=item gsl_eigen_symm_free($w) - This function frees the memory associated with the workspace $w.  

=item gsl_eigen_symm($A, $eval, $w) - This function computes the eigenvalues of the real symmetric matrix $A. Additional workspace of the appropriate size must be provided in $w. The diagonal and lower triangular part of $A are destroyed during the computation, but the strict upper triangular part is not referenced. The eigenvalues are stored in the vector $eval and are unordered. 

=item gsl_eigen_symmv_alloc($n) - This function returns a workspace for computing eigenvalues and eigenvectors of n-by-n real symmetric matrices.

=item gsl_eigen_symmv_free($w) - This function frees the memory associated with the workspace $w. 

=item gsl_eigen_symmv($A, $eval, $evec, $w) - This function computes the eigenvalues and eigenvectors of the real symmetric matrix $A. Additional workspace of the appropriate size must be provided in $w. The diagonal and lower triangular part of $A are destroyed during the computation, but the strict upper triangular part is not referenced. The eigenvalues are stored in the vector $eval and are unordered. The corresponding eigenvectors are stored in the columns of the matrix $evec. 

=item gsl_eigen_herm_alloc($n) - This function returns a workspace for computing eigenvalues of n-by-n complex hermitian matrices.

=item gsl_eigen_herm_free($w) - This function frees the memory associated with the workspace $w.  

=item gsl_eigen_herm($A, $eval, $w) - This function computes the eigenvalues of the complex hermitian matrix $A. Additional workspace of the appropriate size must be provided in $w. The diagonal and lower triangular part of $A are destroyed during the computation, but the strict upper triangular part is not referenced. The imaginary parts of the diagonal are assumed to be zero and are not referenced. The eigenvalues are stored in the vector $eval and are unordered. 

=item gsl_eigen_hermv_alloc($n) - This function returns a workspace for computing eigenvalues and eigenvectors of n-by-n complex hermitian matrices. 

=item gsl_eigen_hermv_free($w) - This function frees the memory associated with the workspace $w. 

=item gsl_eigen_hermv($A, $eval, $evec, $w) - This function computes the eigenvalues and eigenvectors of the complex hermitian matrix $A. Additional workspace of the appropriate size must be provided in $w. The diagonal and lower triangular part of $A are destroyed during the computation, but the strict upper triangular part is not referenced. The imaginary parts of the diagonal are assumed to be zero and are not referenced. The eigenvalues are stored in the vector $eval and are unordered. The corresponding complex eigenvectors are stored in the columns of the matrix $evec.

=item gsl_eigen_francis_alloc($n) - 

=item gsl_eigen_francis_free($w) - This function frees the memory associated with the workspace $w. 

=item gsl_eigen_francis_T

=item gsl_eigen_francis

=item gsl_eigen_francis_Z

=item gsl_eigen_nonsymm_alloc($n) - This function returns a workspace for computing eigenvalues of n-by-n real nonsymmetric matrices. 

=item gsl_eigen_nonsymm_free($w) - This function frees the memory associated with the workspace $w. 

=item gsl_eigen_nonsymm_params($compute_t, $balance, $w) - This function sets some parameters which determine how the eigenvalue problem is solved in subsequent calls to gsl_eigen_nonsymm. If $compute_t is set to 1, the full Schur form T will be computed by gsl_eigen_nonsymm. If it is set to 0, T will not be computed (this is the default setting). If balance is set to 1, a balancing transformation is applied to the matrix prior to computing eigenvalues. This transformation is designed to make the rows and columns of the matrix have comparable norms, and can result in more accurate eigenvalues for matrices whose entries vary widely in magnitude. 

=item gsl_eigen_nonsymm($A, $eval, $w) - This function computes the eigenvalues of the real nonsymmetric matrix $A and stores them in the vector $eval. If T is desired, it is stored in the upper portion of $A on output. Otherwise, on output, the diagonal of $A will contain the 1-by-1 real eigenvalues and 2-by-2 complex conjugate eigenvalue systems, and the rest of $A is destroyed. In rare cases, this function may fail to find all eigenvalues. If this happens, an error code is returned (1) and the number of converged eigenvalues is stored in $w->{n_evals}. The converged eigenvalues are stored in the beginning of $eval.

=item gsl_eigen_nonsymm_Z($A, $eval, $Z, $w) - This function is identical to gsl_eigen_nonsymm except it also computes the Schur vectors and stores them into the $Z matrix. 

=item gsl_eigen_nonsymmv_alloc($n) - This function allocates a workspace for computing eigenvalues and eigenvectors of n-by-n real nonsymmetric matrices.

=item gsl_eigen_nonsymmv_free($w) - This function frees the memory associated with the workspace $w. 

=item gsl_eigen_nonsymmv($A, $eval, $evec, $w) - This function computes eigenvalues and right eigenvectors of the n-by-n real nonsymmetric matrix $A. It first calls gsl_eigen_nonsymm to compute the eigenvalues, Schur form T, and Schur vectors. Then it finds eigenvectors of T and backtransforms them using the Schur vectors. The Schur vectors are destroyed in the process, but can be saved by using gsl_eigen_nonsymmv_Z. The computed eigenvectors are normalized to have unit magnitude. On output, the upper portion of $A contains the Schur form T. If gsl_eigen_nonsymm fails, no eigenvectors are computed, and an error code is returned (1). $eval is a complex vector and $evec is a complex matrix.

=item gsl_eigen_nonsymmv_Z($A, $eval, $evec, $Z, $w) - This function is identical to gsl_eigen_nonsymmv except it also saves the Schur vectors into the $Z matrix. 

=item gsl_eigen_gensymm_alloc($n) - This function allocates a workspace for computing eigenvalues of n-by-n real generalized symmetric-definite eigensystems.

=item gsl_eigen_gensymm_free($w) - This function frees the memory associated with the workspace $w. 

=item gsl_eigen_gensymm($A, $B, $eval, $w) - This function computes the eigenvalues of the real generalized symmetric-definite matrix pair ($A, $B), and stores them in the vector $eval. On output, $B contains its Cholesky decomposition and $A is destroyed. 

=item gsl_eigen_gensymm_standardize 

=item gsl_eigen_gensymmv_alloc($n) - This function allocates a workspace for computing eigenvalues and eigenvectors of n-by-n real generalized symmetric-definite eigensystems.

=item gsl_eigen_gensymmv_free($w) - This function frees the memory associated with the workspace $w. 

=item gsl_eigen_gensymmv($A, $B, $eval, $evec, $w) - This function computes the eigenvalues and eigenvectors of the real generalized symmetric-definite matrix pair ($A, $B), and stores them in $eval vector and $evec matrix respectively. The computed eigenvectors are normalized to have unit magnitude. On output, $B contains its Cholesky decomposition and A is destroyed.  

=item gsl_eigen_genherm_alloc($n) - This function allocates a workspace for computing eigenvalues of n-by-n complex generalized hermitian-definite eigensystems.

=item gsl_eigen_genherm_free($w) - This function frees the memory associated with the workspace $w. 

=item gsl_eigen_genherm($A, $B, $eval, $w) - This function computes the eigenvalues of the complex generalized hermitian-definite matrix pair ($A, $B), and stores them in the $eval vector. On output, $B contains its Cholesky decomposition and $A is destroyed. 

=item gsl_eigen_genherm_standardize

=item gsl_eigen_genhermv_alloc($n) - This function allocates a workspace for computing eigenvalues and eigenvectors of n-by-n complex generalized hermitian-definite eigensystems. 

=item gsl_eigen_genhermv_free($w) - This function frees the memory associated with the workspace $w. 

=item gsl_eigen_genhermv($A, $B, $eval, $evec, $w) - This function computes the eigenvalues and eigenvectors of the complex generalized hermitian-definite matrix pair ($A, $B), and stores them in $eval vector and $evec matrix respectively. The computed eigenvectors are normalized to have unit magnitude. On output, $B contains its Cholesky decomposition and $A is destroyed.

=item gsl_eigen_gen_alloc($n) - This function allocates a workspace for computing eigenvalues of n-by-n real generalized nonsymmetric eigensystems.

=item gsl_eigen_gen_free($w) - This function frees the memory associated with the workspace $w.  

=item gsl_eigen_gen_params($compute_s, $compute_t, $balance, $w) - This function sets some parameters which determine how the eigenvalue problem is solved in subsequent calls to gsl_eigen_gen. If $compute_s is set to 1, the full Schur form S will be computed by gsl_eigen_gen. If it is set to 0, S will not be computed (this is the default setting). S is a quasi upper triangular matrix with 1-by-1 and 2-by-2 blocks on its diagonal. 1-by-1 blocks correspond to real eigenvalues, and 2-by-2 blocks correspond to complex eigenvalues. If $compute_t is set to 1, the full Schur form T will be computed by gsl_eigen_gen. If it is set to 0, T will not be computed (this is the default setting). T is an upper triangular matrix with non-negative elements on its diagonal. Any 2-by-2 blocks in S will correspond to a 2-by-2 diagonal block in T. The $balance parameter is currently ignored, since generalized balancing is not yet implemented. 

=item gsl_eigen_gen($A, $B, $alpha, $beta, $w) - This function computes the eigenvalues of the real generalized nonsymmetric matrix pair ($A, $B), and stores them as pairs in ($alpha, $beta), where $alpha is complex and $beta is real, both are vectors. The elements of $beta are normalized to be non-negative. If S is desired, it is stored in $A on output. If T is desired, it is stored in $B on output. The ordering of eigenvalues in ($alpha, $beta) follows the ordering of the diagonal blocks in the Schur forms S and T. In rare cases, this function may fail to find all eigenvalues. If this occurs, an error code is returned (1). 

=item gsl_eigen_gen_QZ($A, $B, $alpha, $beta, $Q, $Z, $w) - This function is identical to gsl_eigen_gen except it also computes the left and right Schur vectors and stores them into $Q matrix and $Z matrix respectively.  

=item gsl_eigen_genv_alloc($n) - This function allocates a workspace for computing eigenvalues and eigenvectors of n-by-n real generalized nonsymmetric eigensystems.

=item gsl_eigen_genv_free($w) - This function frees the memory associated with the workspace $w. 

=item gsl_eigen_genv($A, $B, $alpha, $beta, $evec, $w) - This function computes eigenvalues and right eigenvectors of the n-by-n real generalized nonsymmetric matrix pair ($A, $B). The eigenvalues are stored in ($alpha, $beta) where $alpha is a complex vector and $beta a real vector and the eigenvectors are stored in $evec complex matrix. It first calls gsl_eigen_gen to compute the eigenvalues, Schur forms, and Schur vectors. Then it finds eigenvectors of the Schur forms and backtransforms them using the Schur vectors. The Schur vectors are destroyed in the process, but can be saved by using gsl_eigen_genv_QZ. The computed eigenvectors are normalized to have unit magnitude. On output, ($A, $B) contains the generalized Schur form (S, T). If gsl_eigen_gen fails, no eigenvectors are computed, and an error code is returned (1). 

=item gsl_eigen_genv_QZ($A, $B, $alpha, $beta, $evec, $Q, $Z, $w) - This function is identical to gsl_eigen_genv except it also computes the left and right Schur vectors and stores them into $Q and $Z matrices respectively.

=item gsl_eigen_symmv_sort($eval, $evec, $sort_type) - This function simultaneously sorts the eigenvalues stored in the vector $eval and the corresponding real eigenvectors stored in the columns of the matrix $evec according to the value of the parameter $sort_type which is one of the constant included in this module.

=item gsl_eigen_hermv_sort($eval, $evec, $sort_type) - This function simultaneously sorts the eigenvalues stored in the vector $eval and the corresponding real eigenvectors stored in the columns of the matrix $evec according to the value of the parameter $sort_type which is one of the constant included in this module. 

=item gsl_eigen_nonsymmv_sort($eval, $evec, $sort_type) - This function simultaneously sorts the eigenvalues stored in the vector $eval and the corresponding complex eigenvectors stored in the columns of the complex matrix $evec into ascending or descending order according to the value of the parameter $sort_type. Only $GSL_EIGEN_SORT_ABS_ASC and $GSL_EIGEN_SORT_ABS_DESC are supported due to the eigenvalues being complex. 

=item gsl_eigen_gensymmv_sort($eval, $evec, $sort_type) - This function simultaneously sorts the eigenvalues stored in the vector $eval and the corresponding real eigenvectors stored in the columns of the matrix $evec according to the value of the parameter $sort_type which is one of the constant included in this module.

=item gsl_eigen_genhermv_sort($eval, $evec, $sort_type) - This function simultaneously sorts the eigenvalues stored in the vector $eval and the corresponding real eigenvectors stored in the columns of the matrix $evec according to the value of the parameter $sort_type which is one of the constant included in this module.

=item gsl_eigen_genv_sort($eval, $evec, $sort_type) - This function simultaneously sorts the eigenvalues stored in the vector $eval and the corresponding complex eigenvectors stored in the columns of the complex matrix $evec into ascending or descending order according to the value of the parameter $sort_type. Only $GSL_EIGEN_SORT_ABS_ASC and $GSL_EIGEN_SORT_ABS_DESC are supported due to the eigenvalues being complex. 

=item gsl_schur_gen_eigvals

=item gsl_schur_solve_equation 

=item gsl_schur_solve_equation_z

=item gsl_eigen_jacobi

=item gsl_eigen_invert_jacobi

=back 

This module also includes these constants : 

=over

=item $GSL_EIGEN_SORT_VAL_ASC - ascending order in numerical value

=item $GSL_EIGEN_SORT_VAL_DESC - descending order in numerical value 

=item $GSL_EIGEN_SORT_ABS_ASC - ascending order in magnitude 

=item $GSL_EIGEN_SORT_ABS_DESC - descending order in magnitude 

=back

For more informations on the functions, we refer you to the GSL offcial documentation: 
L<http://www.gnu.org/software/gsl/manual/html_node/>

Tip : search on google: site:http://www.gnu.org/software/gsl/manual/html_node/ name_of_the_function_you_want

=head1 EXAMPLES

This example shows how to use the gsl_eigen_symmv functions to find the eigenvalues and eigenvectors of a matrix.

 use Math::GSL::Vector qw/:all/;
 use Math::GSL::Matrix qw/:all/;
 use Math::GSL::Eigen qw/:all/;
 my $w = gsl_eigen_symmv_alloc(2);
 my $m = gsl_matrix_alloc(2,2);
 gsl_matrix_set($m, 0, 0, 2);
 gsl_matrix_set($m, 0, 1, 1);
 gsl_matrix_set($m, 1, 0, 1);
 gsl_matrix_set($m, 1, 1, 2);
 my $eval = gsl_vector_alloc(2);
 my $evec = gsl_matrix_alloc(2,2);
 gsl_eigen_symmv($m, $eval, $evec, $w);
 gsl_eigen_gensymmv_sort($eval, $evec, $GSL_EIGEN_SORT_ABS_ASC);
 print "The first eigenvalue is : " . gsl_vector_get($eval, 0) . "\n";
 print "The second eigenvalue is : " . gsl_vector_get($eval, 1) . "\n";
 my $x = gsl_matrix_get($evec, 0, 0);
 my $y = gsl_matrix_get($evec, 0, 1);
 print "The first eigenvector is [$x, $y] \n";
 $x = gsl_matrix_get($evec, 1, 0);
 $y = gsl_matrix_get($evec, 1, 1);
 print "The second eigenvector is [$x, $y] \n";

=head1 AUTHORS

Jonathan Leto <jonathan@leto.net> and Thierry Moisan <thierry.moisan@gmail.com>

=head1 COPYRIGHT AND LICENSE

Copyright (C) 2008-2009 Jonathan Leto and Thierry Moisan

This program is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.

=cut
1;
