Scilab Function
Last update : 14/12/2005

intg - intégration numérique adaptative

### Calling Sequence

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

### Parameters

- `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)`.

### Examples

        //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
        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,TMPDIR+'/ffun.f')
        // compilation du code Fortran
        l=ilib_for_link('ffun','ffun.o',[],'f',TMPDIR+'/Makefile');
        // 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,TMPDIR+'/cfun.c')
        // compilation du code C
        l=ilib_for_link('cfun','cfun.o',[],'c',TMPDIR+'/Makefile');
        // incremental linking
        link(l,'cfun','c')
        // integration de la fonction
        I=intg(0,2*%pi,'cfun')
        abs(exact-I)

### See Also

`intc`, `intl`, `inttrap`, `intsplin`, `ode`,

### Used Function

Les programmes correspondants (dqag0.f et dqags.f de quadpack) se trouvent dabs le repertoire routines/integ :