# intg

intégration numérique adaptative

## Séquence d'appel

    [v,err]=intg(a,b,f [,ea [,er])

## Paramètres

a, b

  nombres réels.

f

  fonction externe (fonction Scilab ou chaîne de caractères ou liste).

ea, er

  nombres réels.

ea

  erreur absolue désirée (1.d-14 par défaut).

er

  erreur relative (1.d-8 par défaut).

err

  estimation de l'erreur absolue sur le résultat.

## Description

`intg(a,b,f)` approche l'intégrale de `a` à `b` de `f(t)dt`. La fonction `f` doit être continue.

L'évaluation satisfait si possible `abs(I-v)<= max(ea,er*abs(I))` où `I` représente la valeur exacte de l'intégrale.

`f` est une fonction externe :

Si `f` est une fonction Scilab elle doit avoir la liste d'appel : `y = f(t)`

Si `f` est une liste, cette liste doit avoir la structure suivante : `list(f,x1,x2,...)` où `f` est une fonction Scilab avec la liste d'appel : `f(t,x1,x2,...)`.

Si `f` est une chaîne de caractères, ce paramètre désigne le nom d'un fonction Fortran ou d'une procédure C ayant une liste d'appel fixée:

Dans le cas Fortran la liste d'appel doit être: `double precision function f(x)` où `x` est aussi un nombre double precision.

Dans la cas C la liste d'appel doit être: `double f(double *x)` .

## Exemples

    //External écrit en Scilab
    function y=f(x),y=x*sin(30*x)/sqrt(1-((x/(2*%pi))^2)),endfunction
    exact=-2.5432596188;
    I=intg(0,2*%pi,f)
    abs(exact-I)

    //External écrit en Scilab avec un argument
    function y=f1(x,w),y=x*sin(w*x)/sqrt(1-((x/(2*%pi))^2)),endfunction
    I=intg(0,2*%pi,list(f1,30))
    abs(exact-I)

    // External écrit en Fortran (un compilateur Fortran est nécessaire)
    // Ecriture du code fortran
    cd TMPDIR;
    F=['      double precision function ffun(x)'
       '      double precision x,pi'
       '      pi=3.14159265358979312d+0'
       '      ffun=x*sin(30.0d+0*x)/sqrt(1.0d+0-(x/(2.0d+0*pi))**2)'
       '      return'
       '      end'];
    mputl(F,fullfile(TMPDIR,'ffun.f'))

    // compilation du code Fortran
    l=ilib_for_link('ffun',fullfile(TMPDIR,'ffun.f'),[],'f');

    // link incrémental
    link(l,'ffun','f')

    // integration de la fonction
    I=intg(0,2*%pi,'ffun')
    abs(exact-I)

    // External écrit en C (un compilateur C est nécessaire)
    // Ecriture du code C
    C=['#include <math.h>'
       'double cfun(double *x)'
       '{'
       '  double y,pi=3.14159265358979312;'
       '  y=*x/(2.0e0*pi);'
       '  return *x*sin(30.0e0**x)/sqrt(1.0e0-y*y);'
       '}'];
    mputl(C,fullfile(TMPDIR,'cfun.c'))

    // compilation du code C
    l=ilib_for_link('cfun',fullfile(TMPDIR,'cfun.c'),[],'c');

    // incremental linking
    link(l,'cfun','c')

    // integration de la fonction
    I=intg(0,2*%pi,'cfun')
    abs(exact-I)

## Voir aussi

- intc
- intl
- inttrap
- intsplin
- ode

## Fonctions Utilisées

Les programmes correspondants (dqag0.f et dqags.f de quadpack) se trouvent dans le répertoire SCI/modules/differential_equations/src/fortran/.