GSP
Quick Navigator

Search Site

Unix VPS
A - Starter
B - Basic
C - Preferred
D - Commercial
MPS - Dedicated
Previous VPSs
* Sign Up! *

Support
Contact Us
Online Help
Handbooks
Domain Status
Man Pages

FAQ
Virtual Servers
Pricing
Billing
Technical

Network
Facilities
Connectivity
Topology Map

Miscellaneous
Server Agreement
Year 2038
Credits
 

USA Flag

 

 

Man Pages
Math::GSL::Deriv(3) User Contributed Perl Documentation Math::GSL::Deriv(3)
 

Math::GSL::Deriv - Numerical Derivatives

    use Math::GSL::Deriv qw/:all/;
    use Math::GSL::Errno qw/:all/;
    my ($x, $h) = (1.5, 0.01);
    my ($status, $val,$err) = gsl_deriv_central ( sub {  sin($_[0]) }, $x, $h);
    my $res = abs($val - cos($x));
    if ($status == $GSL_SUCCESS) {
        printf "deriv(sin((%g)) = %.18g, max error=%.18g\n", $x, $val, $err;
        printf "       cos(%g)) = %.18g, residue=  %.18g\n"  , $x, cos($x), $res;
    } else {
        my $gsl_error = gsl_strerror($status);
        print "Numerical Derivative FAILED, reason:\n $gsl_error\n\n";
    }

This module allows you to take the numerical derivative of a Perl subroutine. To find a numerical derivative you must also specify a point to evaluate the derivative and a "step size". The step size is a knob that you can turn to get a more finely or coarse grained approximation. As the step size $h goes to zero, the formal definition of a derivative is reached, but in practive you must choose a reasonable step size to get a reasonable answer. Usually something in the range of 1/10 to 1/10000 is sufficient.
So long as your function returns a single scalar value, you can differentiate as complicated a function as your heart desires.
"gsl_deriv_central($function, $x, $h)"
    use Math::GSL::Deriv qw/gsl_deriv_central/;
    my ($x, $h) = (1.5, 0.01);
    sub func { my $x=shift; $x**4 - 15 * $x + sqrt($x) };
    my ($status, $val,$err) = gsl_deriv_central ( \&func , $x, $h);
    
This method approximates the central difference of the subroutine reference $function, evaluated at $x, with "step size" $h. This means that the function is evaluated at $x-$h and $x+h.
"gsl_deriv_backward($function, $x, $h)"
    use Math::GSL::Deriv qw/gsl_deriv_backward/;
    my ($x, $h) = (1.5, 0.01);
    sub func { my $x=shift; $x**4 - 15 * $x + sqrt($x) };
    my ($status, $val,$err) = gsl_deriv_backward ( \&func , $x, $h);
    
This method approximates the backward difference of the subroutine reference $function, evaluated at $x, with "step size" $h. This means that the function is evaluated at $x-$h and $x.
"gsl_deriv_forward($function, $x, $h)"
    use Math::GSL::Deriv qw/gsl_deriv_forward/;
    my ($x, $h) = (1.5, 0.01);
    sub func { my $x=shift; $x**4 - 15 * $x + sqrt($x) };
    my ($status, $val,$err) = gsl_deriv_forward ( \&func , $x, $h);
    
This method approximates the forward difference of the subroutine reference $function, evaluated at $x, with "step size" $h. This means that the function is evaluated at $x and $x+$h.
For more informations on the functions, we refer you to the GSL offcial documentation: <http://www.gnu.org/software/gsl/manual/html_node/>

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

Copyright (C) 2008-2011 Jonathan "Duke" Leto and Thierry Moisan
This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.
2019-01-01 perl v5.28.1

Search for    or go to Top of page |  Section 3 |  Main Index

Powered by GSP Visit the GSP FreeBSD Man Page Interface.
Output converted with ManDoc.