# call

chamada a rotinas de usuário FORTRAN ou C

## Seqüência de Chamamento

    // forma longa: 'out' está presente
                [y1,...,yk] = call("ident",x1,px1,"tx1",...,xn,pxn,"txn","out",[ny1,my1],py1,"ty1",...,[nyl,myl],pyl,"tyl")
                // forma curta : nenhum parâmetro 'out'
                [y1,....,yk] = call("ident",x1,...,xn)

## Parâmetros

"ident"

  string.

xi

  real matrix or string

pxi, pyi

  inteiro

txi, tyi

  string `"d"`, `"r"`, `"i"` ou `"c"`.

## Descrição

Chamada interativa ao programa do usuário FORTRAN (ou C) do Scilab. A rotina deve estar previamente linkada ("ligada") ao Scilab. Este link pode ser feito:

- Com o comando "`link`" do Scilab (linkagem "suave" ("soft") incremental) durante a sessão Scilab. (ver `link`)

Há duas formas de sintaxe de chamamento, uma curta e uma longa. A curta fornece um código mais rápido e uma sintaxe de chamamento mais fácil, mas deve-se escrever uma pequena interface (C ou FORTRAN) para que esta forma seja possível. A forma longa torna possível uma chamada a uma rotina FORTRAN (ou C) sem modificação do código, mas a sintaxe é mais complexa e o código interpretado mais devagar.

O significado de cada parâmetro é descrito abaixo:

"ident"

  é o nome da subrotina chamada.

x1,...,xn

  são as variáveis de entrada (strings ou matrizes de reais) enviados à rotina

px1,...,pxn

  são as respectivas posições destas variáveis na seqüência de chamamento da rotina `"ident"` e

tx1,...,txn

  são seus tipos (`"r"`, `"i"`, `"d"` e `"c"` para ponto flutuante real , inteiro, dupla precisão e strings)

"out"

  é a palavra-chave usada para separar variáveis de entrada das variáveis de saída. Quando esta palavra-chave está presente, ela indica que a forma longa será usada e quando não está presente, indica que a forma curta será usada.

[ny1, my1]

  são os tamanhos (número de linhas e colunas. Para argumentos 'c',`m1*n1` é o número de caracteres) das variáveis de saída e

py1, ...

  são as posições das variáveis de saída (possivelmente iguais a `pxi` ) na seqüência de chamamento da rotina. Os inteiros `pyi`'s devem estar em ordem crescente.

"ty1", ...

  são os tipos FORTRAN das variáveis de saída. As `k` primeiras variáveis de saída são postas em `y1,..., yk`.

Se uma variável de saída coincide com uma variável de entrada (i.e., `pyi=pxj` ) pode-se apenas passar sua posição `pyi` . O tamanho e tipo de `yi` são então os mesmos que os de`xi`. Se uma variável de saída coincide com uma variável de entrada e são especificadas as dimensões da variável de saída, `[myl,nyl]` deve satisfazer a condição de compatibilidade `mxk*nxk >= myl*nyl`.

## Exemplos

    //Exemplo 1 com um código C simples
    f1=['#include <math.h>;'
        'void fooc(c,a,b,m,n)'
        'double a[],*b,c[];'
        'int *m,*n;'
        '{'
        '   int i;'
        '   for ( i =0 ; i < (*m)*(*n) ; i++) '
        '     c[i] = sin(a[i]) + *b; '
        '}'];

    mputl(f1,'fooc.c')

    //criando a biblioteca compartilhada (um gateway (ligação), um Makefile e um loader (carregador) são
    //gerados.)

    ilib_for_link('fooc','fooc.c',[],"c")

    // carregando a biblioteca compartilhada

    exec loader.sce

    //usando a nova primitiva
    a=[1,2,3;4,5,6];b= %pi;
    [m,n]=size(a);

    // Entradas:
    // a está na posição 2 e double
    // b                3     double
    // n                4     integer
    // m                5     integer
    // Saídas:
    // c está na posição 1 e double com tamanho [m,n]
    c=call("fooc",a,2,"d",b,3,"d",m,4,"i",n,5,"i","out",[m,n],1,"d");

    //Exemplo 2 com um código FORTRAN simples
    f1=['      subroutine foof(c,a,b,n,m)'
        '      integer n,m'
        '      double precision a(*),b,c(*)'
        '      do 10 i=1,m*n '
        '        c(i) = sin(a(i))+b'
        '   10 continue'
        '      end'];
    mputl(f1,'foof.f')

    //criando a biblioteca compartilhada (um gateway, um Makefile e um loader são
    //gerados.)

    ilib_for_link('foof','foof.f',[],"f")

    // carrega a biblioteca compartilhada

    exec loader.sce

    //usando a nova primitiva
    a=[1,2,3;4,5,6];b= %pi;
    [m,n]=size(a);
    c=call("foof",a,2,"d",b,3,"d",m,4,"i",n,5,"i","out",[m,n],1,"d");

## Ver Também

- link
- c_link
- intersci
- addinter