Génération de plusieurs fichiers * .oct * à partir d'un seul fichier source * .cc * pour interfacer une bibliothèque C avec Octave

Le but du deuxième lien est que vous ne chargez pas un fichier .oct contenant plusieurs fonctions - du moins pas du point de vue d'octave. C'est à cela que servent les liens symboliques - vous avez des symboles A , B et C ? Créez des liens symboliques A.oct , B.oct et C.oct qui pointent vers ce fichier et vous pouvez les utiliser comme si chacun contenait seulement le symbole qui vous tient à cœur.

Si vous avez plusieurs définitions de fonctions dans un seul fichier oct, vous utilisez autoload () . Donc, si vous avez foo.oct qui a les fonctions foo et bar , alors vous faites:

autoload ("bar", "path-to-foo.oct");

p >

Je vais commencer par clarifier la deuxième fenêtre de citation dans votre question. Cela ne fait pas spécifiquement référence aux fonctions définies par .oct. Ce que cela implique, c'est la différence entre une fonction définie par fichier m canonique et des fonctions «sur place» définies directement dans la console ou dans le cadre d'un script.

En ce qui concerne la première fenêtre de guillemets, en ce qui concerne les fonctions définies dans les fichiers .oct, la situation est différente. Ce qu'il dit, c'est que vous pouvez créer un fichier .oct qui définit de nombreuses fonctions, mais pour appeler ces fonctions, il doit y avoir un fichier du même nom dans ton chemin. Donc, si un fichier .oct définit les fonctions "foo" et "bar", vous devez avoir une copie du fichier .oct appelée "foo.oct", et une autre (ou, plus réaliste, comme lien symbolique vers l'original) renommée comme "bar.oct".

De même, vous pouvez également définir un fichier "foo.m" et "bar.m" dans votre espace de travail, qui ne contient que la documentation de ces fonctions, de sorte que si vous faites ensuite "help foo" ou "help bar" vous obtenez la documentation prévue.

Vous pouvez également utiliser autoload , comme l'a suggéré carandraug.

Une autre possibilité de générer une interface C à Octave consiste à utiliser SWIG qui peut générer un seul fichier .oct avec toutes vos fonctions. Reportez-vous à ici lorsque vous utilisez des pointeurs et des tableaux.

Voici un exemple:

header

% File test.m
swigexample;
fact(5)
fact2(4,4)
% ==============
a = new_intp();
intp_assign(a, 37);
b = new_intp();
intp_assign(b, 22);
c = new_intp();
add(a,b,c);
r = intp_value(c);
delete_intp(a);
delete_intp(b);
delete_intp(c);
r

source

swig -octave -o swigexample.cpp example.i
mkoctfile -I. -I/usr/include/octave-4.2.2/ -Iswiglib swigexample.cpp example.c

interface

/* File example.i */
%module swigexample
%include "cpointer.i"

%{
#include "example.h"
%}

%pointer_functions(int, intp)

%include "example.h"

compile

/* File: example.c */

#include "example.h"

int fact(int n) {
    if (n < 0){ /* This should probably return an error, but this is simpler */
        return 0;
    }
    if (n == 0) {
        return 1;
    }
    else {
        /* testing for overflow would be a good idea here */
        return n * fact(n-1);
    }
}

int fact2(int n1, int n2) {
    return fact(n1)*fact(n2);
}

void add(int *x, int *y, int *r) {
    *r = *x + *y;
}

test

/* File: example.h */

int fact(int n);

int fact2(int n1, int n2);

void add(int *x, int *y, int *r);