NAME

PDL::GSL::INTEG - PDL interface to numerical integration routines in GSL

DESCRIPTION

This is an interface to the numerical integration package present in the GNU Scientific Library, which is an implementation of QUADPACK.

Functions are named gslinteg_{algorithm} where {algorithm} is the QUADPACK naming convention. The available functions are:

gslinteg_qng: Non-adaptive Gauss-Kronrod integration
gslinteg_qag: Adaptive integration
gslinteg_qags: Adaptive integration with singularities
gslinteg_qagp: Adaptive integration with known singular points
gslinteg_qagi: Adaptive integration on infinite interval of the form (-\infty,\infty)
gslinteg_qagiu: Adaptive integration on infinite interval of the form (a,\infty)
gslinteg_qagil: Adaptive integration on infinite interval of the form (-\infty,b)
gslinteg_qawc: Adaptive integration for Cauchy principal values
gslinteg_qaws: Adaptive integration for singular functions
gslinteg_qawo: Adaptive integration for oscillatory functions
gslinteg_qawf: Adaptive integration for Fourier integrals

Each algorithm computes an approximation to the integral, I, of the function f(x)w(x), where w(x) is a weight function (for general integrands w(x)=1). The user provides absolute and relative error bounds (epsabs,epsrel) which specify the following accuracy requirement:

|RESULT - I| <= max(epsabs, epsrel |I|)

The routines will fail to converge if the error bounds are too stringent, but always return the best approximation obtained up to that stage

All functions return the result, and estimate of the absolute error and an error flag (which is zero if there were no problems). You are responsible for checking for any errors, no warnings are issued unless the option {Warn => 'y'} is specified in which case the reason of failure will be printed.

You can nest integrals up to 20 levels. If you find yourself in the unlikely situation that you need more, you can change the value of 'max_nested_integrals' in the first line of the file 'FUNC.c' and recompile.

Please check the GSL documentation for more information.

SYNOPSIS

use PDL;
use PDL::GSL::INTEG;

my $a = 1.2;
my $b = 3.7;
my $epsrel = 0;
my $epsabs = 1e-6;

# Non adaptive integration
my ($res,$abserr,$ierr,$neval) = gslinteg_qng(\&myf,$a,$b,$epsrel,$epsabs);
# Warnings on
my ($res,$abserr,$ierr,$neval) = gslinteg_qng(\&myf,$a,$b,$epsrel,$epsabs,{Warn=>'y'});

# Adaptive integration with warnings on
my $limit = 1000;
my $key = 5;
my ($res,$abserr,$ierr) = gslinteg_qag(\&myf,$a,$b,$epsrel,
                                  $epsabs,$limit,$key,{Warn=>'y'});

sub myf{
  my ($x) = @_;
  return exp(-$x**2);
}

FUNCTIONS

qng_meat

Signature: (double a(); double b(); double epsabs();
                 double epsrel(); double [o] result(); double [o] abserr(); 
                 int [o] neval(); int [o] ierr(); int gslwarn(); SV* function)

info not available

qng_meat does not process bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

qag_meat

  Signature: (double a(); double b(); double epsabs();double epsrel(); int limit();
	           int key(); double [o] result(); double [o] abserr();int n();int [o] ierr();int gslwarn();; SV* function)

info not available

qag_meat does not process bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

qags_meat

  Signature: (double a(); double b(); double epsabs();double epsrel(); int limit();
	           double [o] result(); double [o] abserr();int n();int [o] ierr();int gslwarn();; SV* function)

info not available

qags_meat does not process bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

qagp_meat

  Signature: (double pts(l); double epsabs();double epsrel();int limit();
		   double [o] result(); double [o] abserr();int n();int [o] ierr();int gslwarn();; SV* function)

info not available

qagp_meat does not process bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

qagi_meat

  Signature: (double epsabs();double epsrel(); int limit();
		   double [o] result(); double [o] abserr(); int n(); int [o] ierr();int gslwarn();; SV* function)

info not available

qagi_meat does not process bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

qagiu_meat

  Signature: (double a(); double epsabs();double epsrel();int limit();
		   double [o] result(); double [o] abserr();int n();int [o] ierr();int gslwarn();; SV* function)

info not available

qagiu_meat does not process bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

qagil_meat

  Signature: (double b(); double epsabs();double epsrel();int limit();
		   double [o] result(); double [o] abserr();int n();int [o] ierr();int gslwarn();; SV* function)

info not available

qagil_meat does not process bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

qawc_meat

  Signature: (double a(); double b(); double c(); double epsabs();double epsrel();int limit();
	           double [o] result(); double [o] abserr();int n();int [o] ierr();int gslwarn();; SV* function)

info not available

qawc_meat does not process bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

qaws_meat

  Signature: (double a(); double b();double epsabs();double epsrel();int limit();
	         double [o] result(); double [o] abserr();int n();
		 double alpha(); double beta(); int mu(); int nu();int [o] ierr();int gslwarn();; SV* function)

info not available

qaws_meat does not process bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

qawo_meat

  Signature: (double a(); double b();double epsabs();double epsrel();int limit();
	         double [o] result(); double [o] abserr();int n();
		 int sincosopt(); double omega(); double L(); int nlevels();int [o] ierr();int gslwarn();; SV* function)

info not available

qawo_meat does not process bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

qawf_meat

  Signature: (double a(); double epsabs();int limit();
		 double [o] result(); double [o] abserr();int n();
		 int sincosopt(); double omega(); int nlevels();int [o] ierr();int gslwarn();; SV* function)

info not available

qawf_meat does not process bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

gslinteg_qng

Non-adaptive Gauss-Kronrod integration

This function applies the Gauss-Kronrod 10-point, 21-point, 43-point and 87-point integration rules in succession until an estimate of the integral of f over ($a,$b) is achieved within the desired absolute and relative error limits, $epsabs and $epsrel. It is meant for fast integration of smooth functions. It returns an array with the result, an estimate of the absolute error, an error flag and the number of function evaluations performed.

Usage:

($res,$abserr,$ierr,$neval) = gslinteg_qng($function_ref,$a,$b,
                                           $epsrel,$epsabs,[{Warn => $warn}]);

Example:

my ($res,$abserr,$ierr,$neval) = gslinteg_qng(\&f,0,1,0,1e-9);
# with warnings on
my ($res,$abserr,$ierr,$neval) = gslinteg_qng(\&f,0,1,0,1e-9,{Warn => 'y'});

sub f{
  my ($x) = @_;
  return ($x**2.6)*log(1.0/$x);
}

gslinteg_qag

Adaptive integration

This function applies an integration rule adaptively until an estimate of the integral of f over ($a,$b) is achieved within the desired absolute and relative error limits, $epsabs and $epsrel. On each iteration the adaptive integration strategy bisects the interval with the largest error estimate; the maximum number of allowed subdivisions is given by the parameter $limit. The integration rule is determined by the value of $key, which has to be one of (1,2,3,4,5,6) and correspond to the 15, 21, 31, 41, 51 and 61 point Gauss-Kronrod rules respectively. It returns an array with the result, an estimate of the absolute error and an error flag.

Please check the GSL documentation for more information.

Usage:

($res,$abserr,$ierr) = gslinteg_qag($function_ref,$a,$b,$epsrel,
                                    $epsabs,$limit,$key,[{Warn => $warn}]);

Example:

my ($res,$abserr,$ierr) = gslinteg_qag(\&f,0,1,0,1e-10,1000,1);
# with warnings on
my ($res,$abserr,$ierr) = gslinteg_qag(\&f,0,1,0,1e-10,1000,1,{Warn => 'y'});

sub f{
   my ($x) = @_;
   return ($x**2.6)*log(1.0/$x);
 }

gslinteg_qags

Adaptive integration with singularities

This function applies the Gauss-Kronrod 21-point integration rule adaptively until an estimate of the integral of f over ($a,$b) is achieved within the desired absolute and relative error limits, $epsabs and $epsrel. The algorithm is such that it accelerates the convergence of the integral in the presence of discontinuities and integrable singularities. The maximum number of allowed subdivisions done by the adaptive algorithm must be supplied in the parameter $limit.

Please check the GSL documentation for more information.

Usage:

($res,$abserr,$ierr) = gslinteg_qags($function_ref,$a,$b,$epsrel,
                                     $epsabs,$limit,[{Warn => $warn}]);

Example:

my ($res,$abserr,$ierr) = gslinteg_qags(\&f,0,1,0,1e-10,1000);
# with warnings on 
($res,$abserr,$ierr) = gslinteg_qags(\&f,0,1,0,1e-10,1000,{Warn => 'y'});

sub f{
   my ($x) = @_;
   return ($x)*log(1.0/$x);
 }

gslinteg_qagp

Adaptive integration with known singular points

This function applies the adaptive integration algorithm used by gslinteg_qags taking into account the location of singular points until an estimate of the integral of f over ($a,$b) is achieved within the desired absolute and relative error limits, $epsabs and $epsrel. Singular points are supplied in the piddle $points, whose endpoints determine the integration range. So, for example, if the function has singular points at x_1 and x_2 and the integral is desired from a to b (a < x_1 < x_2 < b), $points = pdl(a,x_1,x_2,b). The maximum number of allowed subdivisions done by the adaptive algorithm must be supplied in the parameter $limit.

Please check the GSL documentation for more information.

Usage:

($res,$abserr,$ierr) = gslinteg_qagp($function_ref,$points,$epsabs,
                                     $epsrel,$limit,[{Warn => $warn}])

Example:

my $points = pdl(0,1,sqrt(2),3);
my ($res,$abserr,$ierr) = gslinteg_qagp(\&f,$points,0,1e-3,1000);
# with warnings on
($res,$abserr,$ierr) = gslinteg_qagp(\&f,$points,0,1e-3,1000,{Warn => 'y'});

sub f{
  my ($x) = @_;
  my $x2 = $x**2;
  my $x3 = $x**3;
  return $x3 * log(abs(($x2-1.0)*($x2-2.0)));
}

gslinteg_qagi

Adaptive integration on infinite interval

This function estimates the integral of the function f over the infinite interval (-\infty,+\infty) within the desired absolute and relative error limits, $epsabs and $epsrel. After a transformation, the algorithm of gslinteg_qags with a 15-point Gauss-Kronrod rule is used. The maximum number of allowed subdivisions done by the adaptive algorithm must be supplied in the parameter $limit.

Please check the GSL documentation for more information.

Usage:

($res,$abserr,$ierr) = gslinteg_qagi($function_ref,$epsabs,
                                     $epsrel,$limit,[{Warn => $warn}]);

Example:

my ($res,$abserr,$ierr) = gslinteg_qagi(\&myfn,1e-7,0,1000);
# with warnings on
($res,$abserr,$ierr) = gslinteg_qagi(\&myfn,1e-7,0,1000,{Warn => 'y'});

sub myfn{    
  my ($x) = @_;
  return exp(-$x - $x*$x) ;
}

gslinteg_qagiu

Adaptive integration on infinite interval

This function estimates the integral of the function f over the infinite interval (a,+\infty) within the desired absolute and relative error limits, $epsabs and $epsrel. After a transformation, the algorithm of gslinteg_qags with a 15-point Gauss-Kronrod rule is used. The maximum number of allowed subdivisions done by the adaptive algorithm must be supplied in the parameter $limit.

Please check the GSL documentation for more information.

Usage:

($res,$abserr,$ierr) = gslinteg_qagiu($function_ref,$a,$epsabs,
                                      $epsrel,$limit,[{Warn => $warn}]);

Example:

my $alfa = 1;
my ($res,$abserr,$ierr) = gslinteg_qagiu(\&f,99.9,1e-7,0,1000);
# with warnings on
($res,$abserr,$ierr) = gslinteg_qagiu(\&f,99.9,1e-7,0,1000,{Warn => 'y'});

sub f{
  my ($x) = @_;
  if (($x==0) && ($alfa == 1)) {return 1;}
  if (($x==0) && ($alfa > 1)) {return 0;}
  return ($x**($alfa-1))/((1+10*$x)**2);
}

gslinteg_qagil

Adaptive integration on infinite interval

This function estimates the integral of the function f over the infinite interval (-\infty,b) within the desired absolute and relative error limits, $epsabs and $epsrel. After a transformation, the algorithm of gslinteg_qags with a 15-point Gauss-Kronrod rule is used. The maximum number of allowed subdivisions done by the adaptive algorithm must be supplied in the parameter $limit.

Please check the GSL documentation for more information.

Usage:

($res,$abserr,$ierr) = gslinteg_qagl($function_ref,$b,$epsabs,
                                     $epsrel,$limit,[{Warn => $warn}]);

Example:

my ($res,$abserr,$ierr) = gslinteg_qagil(\&myfn,1.0,1e-7,0,1000);
# with warnings on
($res,$abserr,$ierr) = gslinteg_qagil(\&myfn,1.0,1e-7,0,1000,{Warn => 'y'});

sub myfn{
  my ($x) = @_;
  return exp($x);
}

gslinteg_qawc

Adaptive integration for Cauchy principal values

This function computes the Cauchy principal value of the integral of f over (a,b), with a singularity at c, I = \int_a^b dx f(x)/(x - c). The integral is estimated within the desired absolute and relative error limits, $epsabs and $epsrel. The maximum number of allowed subdivisions done by the adaptive algorithm must be supplied in the parameter $limit.

Please check the GSL documentation for more information.

Usage:

($res,$abserr,$ierr) = gslinteg_qawc($function_ref,$a,$b,$c,$epsabs,$epsrel,$limit)

Example:

my ($res,$abserr,$ierr) = gslinteg_qawc(\&f,-1,5,0,0,1e-3,1000);
# with warnings on
($res,$abserr,$ierr) = gslinteg_qawc(\&f,-1,5,0,0,1e-3,1000,{Warn => 'y'});

sub f{
  my ($x) = @_;
  return 1.0 / (5.0 * $x * $x * $x + 6.0) ;
}

gslinteg_qaws

Adaptive integration for singular functions

The algorithm in gslinteg_qaws is designed for integrands with algebraic-logarithmic singularities at the end-points of an integration region. Specifically, this function computes the integral given by I = \int_a^b dx f(x) (x-a)^alpha (b-x)^beta log^mu (x-a) log^nu (b-x). The integral is estimated within the desired absolute and relative error limits, $epsabs and $epsrel. The maximum number of allowed subdivisions done by the adaptive algorithm must be supplied in the parameter $limit.

Please check the GSL documentation for more information.

Usage:

($res,$abserr,$ierr) = 
    gslinteg_qawc($function_ref,$alpha,$beta,$mu,$nu,$a,$b,
                  $epsabs,$epsrel,$limit,[{Warn => $warn}]);

Example:

my ($res,$abserr,$ierr) = gslinteg_qaws(\&f,0,0,1,0,0,1,0,1e-7,1000);
# with warnings on
($res,$abserr,$ierr) = gslinteg_qaws(\&f,0,0,1,0,0,1,0,1e-7,1000,{Warn => 'y'});

sub f{
  my ($x) = @_;
  if($x==0){return 0;}
  else{
    my $u = log($x);
    my $v = 1 + $u*$u;
    return 1.0/($v*$v);
  }
}

gslinteg_qawo

Adaptive integration for oscillatory functions

This function uses an adaptive algorithm to compute the integral of f over (a,b) with the weight function sin(omega*x) or cos(omega*x) -- which of sine or cosine is used is determined by the parameter $opt ('cos' or 'sin'). The integral is estimated within the desired absolute and relative error limits, $epsabs and $epsrel. The maximum number of allowed subdivisions done by the adaptive algorithm must be supplied in the parameter $limit.

Please check the GSL documentation for more information.

Usage:

($res,$abserr,$ierr) = gslinteg_qawo($function_ref,$omega,$sin_or_cos,
                              $a,$b,$epsabs,$epsrel,$limit,[opt])

Example:

my $PI = 3.14159265358979323846264338328;
my ($res,$abserr,$ierr) = PDL::GSL::INTEG::gslinteg_qawo(\&f,10*$PI,'sin',0,1,0,1e-7,1000);
# with warnings on
($res,$abserr,$ierr) = PDL::GSL::INTEG::gslinteg_qawo(\&f,10*$PI,'sin',0,1,0,1e-7,1000,{Warn => 'y'});

sub f{
  my ($x) = @_;
  if($x==0){return 0;}
  else{ return log($x);} 
}

gslinteg_qawf

Adaptive integration for Fourier integrals

This function attempts to compute a Fourier integral of the function f over the semi-infinite interval [a,+\infty). Specifically, it attempts tp compute I = \int_a^{+\infty} dx f(x)w(x), where w(x) is sin(omega*x) or cos(omega*x) -- which of sine or cosine is used is determined by the parameter $opt ('cos' or 'sin'). The integral is estimated within the desired absolute error limit $epsabs. The maximum number of allowed subdivisions done by the adaptive algorithm must be supplied in the parameter $limit.

Please check the GSL documentation for more information.

Usage:

gslinteg_qawf($function_ref,$omega,$sin_or_cos,$a,$epsabs,$limit,[opt])

Example:

my ($res,$abserr,$ierr) = gslinteg_qawf(\&f,$PI/2.0,'cos',0,1e-7,1000);
# with warnings on
($res,$abserr,$ierr) = gslinteg_qawf(\&f,$PI/2.0,'cos',0,1e-7,1000,{Warn => 'y'});

sub f{
  my ($x) = @_;
  if ($x == 0){return 0;}
  return 1.0/sqrt($x)    
}

BUGS

Feedback is welcome. Log bugs in the PDL bug database (the database is always linked from http://pdl.perl.org).

AUTHOR

This file copyright (C) 2003,2005 Andres Jordan <ajordan@eso.org> All rights reserved. There is no warranty. You are allowed to redistribute this software documentation under certain conditions. For details, see the file COPYING in the PDL distribution. If this file is separated from the PDL distribution, the copyright notice should be included in the file.

The GSL integration routines were written by Brian Gough. QUADPACK was written by Piessens, Doncker-Kapenga, Uberhuber and Kahaner.

To install PDL, copy and paste the appropriate command in to your terminal.

cpanm

cpanm PDL

CPAN shell

perl -MCPAN -e shell
install PDL

For more information on module installation, please visit the detailed CPAN module installation guide.

	Global
`s`	Focus search bar
`?`	Bring up this help dialog

	GitHub
`g` `p`	Go to pull requests
`g` `i`	go to github issues (only if github is preferred repository)

	POD
`g` `a`	Go to author
`g` `c`	Go to changes
`g` `i`	Go to issues
`g` `d`	Go to dist
`g` `r`	Go to repository/SCM
`g` `s`	Go to source
`g` `b`	Go to file browse

	Search terms
module: (e.g. module:Plugin)
distribution: (e.g. distribution:Dancer auth)
author: (e.g. author:SONGMU Redis)
version: (e.g. version:1.00)

NAME

DESCRIPTION

SYNOPSIS

FUNCTIONS

qng_meat

qag_meat

qags_meat

qagp_meat

qagi_meat

qagiu_meat

qagil_meat

qawc_meat

qaws_meat

qawo_meat

qawf_meat

gslinteg_qng

gslinteg_qag

gslinteg_qags

gslinteg_qagp

gslinteg_qagi

gslinteg_qagiu

gslinteg_qagil

gslinteg_qawc

gslinteg_qaws

gslinteg_qawo

gslinteg_qawf

BUGS

SEE ALSO

AUTHOR

Module Install Instructions