Logiciels de calcul et Mensura

Freemat, Julia, Pari/GP, logiciel R, Scilab.

Voir aussi la page spéciale sur le logiciel de statistiques PAST

Freemat (logiciel libre pour Linux et Windows, mais la version Linux semble ne pas gérer les bibliothèques dynamiques)

Téléchargeable en : http://freemat.sourceforge.net/
La syntaxe est en principe assez simple.
import('nom_dll','nom_fonction','nom_fonction','type_resultat','type_parametre n');
Ensuite, on peut utiliser la fonction avec son nom (le 3e paramètre).
Freemat ne fonctionne directement qu'avec les fonctions numériques de ce système de pilotes (cead, csad, ceb, csb), mais non avec les fonctions renvoyant une chaîne de caractères. Pour utiliser toutes les fonctions du système (cdetail, ctitre, cnead, cnsad, cneb, cnsb), il faut réaliser une adaptation par une bibliothèque dynamique spéciale ("adaptateur").
La version 3.6 de Freemat accepte les appels de paramètres de type cdecl et stdcall, mais la version 4 n'accepte que les fonctions de type cdecl.
Si on suppose que le nom de la bibliothèque dynamique est dans la variable nompilote, on peut charger les fonctions par le script suivant :
import(nompilote,'cead','cead','double','int32 n');
import(nompilote,'cea','cea','int32','int32 n');
import(nompilote,'ceb','ceb','int32','int32 n');
import(nompilote,'csa','csa','int32','int32 n, int32 v');
import(nompilote,'csad','csad','double','int32 n, double v');
import(nompilote,'csb','csb','int32','int32 n, int32 v');
disp('vous pouvez utiliser les fonctions :');
disp('cea, cead, ceb, csa, csad, csb')

Pour les fonctions travaillant avec des chaînes de caractères, voir les fonctions de nommage numérique.

Julia (logiciel libre pour Linux et Windows)

(http://julialang.org)
C'est un langage de calcul numérique, mais beaucoup plus proche des langages de programmation "normaux" que Matlab, Freemat ou Scilab.
Il peut charger sans difficultés les bibliothèques dynamiques du système Mensurasoft :
bibdyn=dlopen("bibdyn_systeme_delphi.dll")

function cea(n::Int32)
   res=ccall(dlsym(bibdyn,:cea),Int32,(Int32,),n)
   end
function cnea(n::Int32)
n1=ccall(dlsym(bibdyn,:cnea),Ptr{Uint8},(Int32,),n)
return bytestring(n1)
   end
function cead(n::Int32)
   res=ccall(dlsym(bibdyn,:cead),Float64,(Int32,),n)
   end

function cnead(n::Int32)
   n1=ccall(dlsym(mylib,:cnead),Ptr{Uint8},(Int32,),n)
   return bytestring(n1)
   end
function cdetail()
   d=ccall(dlsym(bibdyn,:cdetail),Ptr{Uint8},())
   return bytestring(d)
   end
function ctitre()
   return bytestring(ccall(dlsym(bibdyn,:ctitre),Ptr{Uint8},()))
   end
function csa(n::Int32,valeur::Int32)
    return ccall(dlsym(bibdyn,:csa),Int32,(Int32,Int32,),n,valeur)
    end
function cnsa(n::Int32)
    return bytestring(ccall(dlsym(bibdyn,:cnsa),Ptr{Uint8},(Int32,),n))
    end
function csad(n::Int32,valeur::Float64)
    return ccall(dlsym(bibdyn,:csad),Float64,(Int32,Float64,),n,valeur)
    end
function cnsad(n::Int32)
    return bytestring(ccall(dlsym(bibdyn,:cnsad),Ptr{Uint8},(Int32,),n))
    end
function ceb(n::Int32)
   res=ccall(dlsym(bibdyn,:ceb),Int32,(Int32,),n)
   end
function cneb(n::Int32)
n1=ccall(dlsym(bibdyn,:cneb),Ptr{Uint8},(Int32,),n)
return bytestring(n1)
   end
function csb(n::Int32,valeur::Int32)
    return ccall(dlsym(bibdyn,:csb),Int32,(Int32,Int32,),n,valeur)
    end
function cnsb(n::Int32)
    return bytestring(ccall(dlsym(bibdyn,:cnsb),Ptr{Uint8},(Int32,),n))
    end

PARI/GP (logiciel de calcul formel)

https://pari.math.u-bordeaux.fr/
L'appel de bibliothèque dynamique est simple et rapide, mais la documentation est difficile à comprendre pour ce qui concerne l'indication des types de paramètres.
Lorsque les paramètres sont des entiers, c'est très facile. Supposons qu'on veuille appeler la fonction cea (entrée analogique, avec paramètres entiers transmis en mode cdecl), d'une bibliothèque bibdynsyst.dll qui se trouve dans le même répertoire que l'exécutable de Pari/GP.
install("cea","iL","cea","./bibdynsyst.dll")
La fonction install a comme dernier paramètre la localisation de la bibliothèque dynamique (ici, le répertoire de l'exécutable).
Auparavant, "cea" est le nom de la fonction à utiliser, dans le fichier de bibliothèque dynamique et dans la future programmation en Pari/GP.
Le paramètre "iL" indique que le paramètre de sortie i (la valeur renvoyée par la fonction cea) est un entier, et que le paramètre d'entrée L est aussi un entier (le numéro de l'entrée analogique). Ce n'est pas simple à comprendre.
Ensuite, il suffit d'appeler la fonction par print(cea(0)).
Malheureusement, il n'y a pas d'explications claires pour les fonctions qui doivent renvoyer des nombres réels, ni pour celles qui doivent renvoyer des chaînes de caractères. On peut néanmoins utiliser cea (« iL »), csa (« iLL »), ceb (« iL »), csb (« iLL »).
Pour les chaînes de caractères, on peut utiliser les fonctions de nommage numériques : cdetailnum et ctitrenum (avec le paramètre « iL »), cneanum, cnsanum, cnebnum, cnsbnum (avec le paramètre « iLL »), etc.

R (langage de programmation et environnement de statistiques)

(http://www.r-project.org/)
Wikipedia indique : « R est un logiciel libre de traitement des données et d'analyse statistiques mettant en œuvre le langage de programmation S. C'est un projet GNU fondé sur l'environnement développé dans les laboratoires Bell par John Chambers et ses collègues. ». Des versions existent pour Linux, Windows, MacOS.
R est capable d'appeler les bibliothèques dynamiques, où les paramètres sont transmis par « référence » (= par variable).

eadouble <- function(n=0)
{x<-0
xr<-.C("ceadoubleref",as.numeric(n),as.numeric(x),package=nombibdyn)
return (xr[[2]])
}

ead <- function(n=0)
{x<-0
xr<-.C("ceadref",as.integer(n),as.numeric(x),package=nombibdyn)
return (xr[[2]])
}

neadouble <- function(n=0)
{x<-" "
xr<-.C("cneadoubleref",as.double(n),as.character(x),package=nombibdyn)
return (xr[[2]])
}
nead <- function(n=0)
{x<-" "
xr<-.C("cneadref",as.integer(n),as.character(x),package=nombibdyn)
return (xr[[2]])
}

detail <-function()
{x<-" "
xr<-" "
xr<-.C("cdetailref",xr)
return (xr[1])
}
detailrefnum <-function(n=0)
{x<-0
xr<-" "
xr<-.C("cdetailrefnum",as.integer(n),as.integer(x),package=nombibdyn)
return (xr[[2]])
}

nombibdyn<-"bibdynsyst_fb2016.dll"
#nombibdyn<-"bibdynsyst_pb2016.dll"

dyn.load(nombibdyn)
print(ead(1));
print(eadouble(1));
print(nead(0));
print(neadouble(1));
print(detail());
print(detailrefnum());
print("Fin du programme !")
#dyn.unload(nombibdyn)

Scilab (logiciel libre pour Linux et Windows)

Téléchargeable en : http://scilab.org
Scilab utilise des bibliothèques dynamiques avec des fonctions où les paramètres doivent être passés par variable et être transmis dans le mode cdecl.

Les fonctions numériques Mensurasoft sont donc du groupe « ref » : ceadref, csadref, cebref, csbref. Les fonctions de nommage ne semblent pas possibles en renvoyant directement une chaîne de caractères, donc il faut employer les fonction ayant le suffixe « num » : cneadrefnum, cnsadrefnum, cnebrefnum, cnsbrefnum, cdetailrefnum, ctitrerefnum.
Exemple :
nomfich='bibdynsyst_fb2016.dll';
disp('début du programme');
infolist = dllinfo(nomfich,'exports');
numh=link(nomfich,['ceadref','ceadoubleref','cneadrefnum','cnsadrefnum','csadref','cdetailrefnum','ctitrerefnum' ],'c');
numh=link(nomfich,['cebref','cnebrefnum','csbref','cnsbrefnum', 'ccalibration' ],'c');

function res=ead(numvoie);
res=call('ceadref',numvoie,1,'i','out',[1,1],2,'d'); endfunction;
function res=eadouble(numvoie);
res=call('ceadoubleref',numvoie,1,'d','out',[1,1],2,'d');endfunction;

function ch=nead(numvoie);
ch='';rloc=44;pos=0;
while rloc>0 ;
     rloc=call('cneadrefnum',numvoie,1,'i',pos,2,'i','out',[1,1],3,'i');
if rloc>0 then ch=ch+ascii(rloc);end;
    pos=pos+1;
end;
endfunction;

function res=sad(numvoie,valeur);
res=call('csadref',numvoie,1,'i',valeur,2,'d','out',[1,1],3,'d');
endfunction;

function ch=nsad(numvoie);
ch='';rloc=44;pos=0;
while rloc>0
rloc=call('cnsadrefnum',numvoie,1,'i',pos,2,'i','out',[1,1],3,'i');
if rloc>0 then ch=ch+ascii(rloc);end;
     pos=pos+1;
end;
endfunction;

Dernière modification le 10/03/2018