Discussion :

[link66]

Bonjour,

Pour simplifier mes scripts, je cherche à passer par des constantes. Par exemple, la variable 'pi' est défini de base dans matlab, et est accessible par n'importe quelle fonction.

Je veut donc rajouter des nouvelles variables sans avoir à les déclarer dans 50 fichiers différents pour des question de praticité.

Vous connaissez une méthode permettant de faire celà, un peu comme un #define en C?

Merci d'avance

[tanguy4724]

Je vois ce que tu veux dire. je ne sais pas si c'est possible directement. Par contre, tu peux contourner le problème :

tu peux créer un script (initcste.m) dans lequel tu définis tes variables et constantes. Si tu ne veux pas avoir 50 constantes dans ton workspace, tu peux les mettre sous la forme de structure :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
initvar.m :
 
init.cste1 = valeur1;
init.cste2 = valeur2;
...

tu ajoutes la fonction dans ton path, et ensuite, dès que tu as besoin de tes constantes (dans un script ou une fonction), tu n'as qu'à appeler initcste. Tu auras donc sous la main tes constantes init.cste1, init.cste2, ... et tu ne seras pas obligé de les redéfinir à chaque fois.

[ol9245]

Je ne crois pas que ce que tu souhaites soit possible avec une portée générale dans touts les espaces de variables de Matlab.

Par contre tu peux écrire tes constantes dans un script (un fichier .m simple = qui n'est pas une fonction) puis tu peux en une seule ligne (dans tous tes programmes) exécuter ce script. Ca marchera comme un #include en C

Edit : @tanguy : grillé

[link66]

Je viens de faire la solution proposée par Tanguy, ça marche comme je veut. Les performances ne sont pas vraiment affectées (je suis passé de 291 à 295 secondes pour exécuter mon script...).

Merci!

[ol9245]

Je suis content que tu aie trouvé une solution proche de ce que tu cherchais.

Quand je suis confronté à ce genre de chose à faire (passer des informations +/- constantes à plein de fonctions), je fais différemment :

1/ une fonction qui construit les constantes et éventuellement les modifie (si ce ne sont pas des constantes constamment constantes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
function E = build_environnement (E, varargin)
p = inputParser ;
p.addParamValue('filename', [], @ischar) ;
p.addParamValue('Project_folder', '.', @isdir) ;
p.addParamValue('maxfiles', 50000, @(x)validateattributes(x, {'numeric'}, {'scalar', 'positive', 'integer', 'nonempty'}))
p.addParamValue('a', 1, @(x)validateattributes(x, {'numeric'}, {'scalar', 'positive', 'integer', 'nonempty'}) ;
p.addParamValue('b', 2, @(x)validateattributes(x, {'numeric'}, {'scalar', 'positive', 'integer', 'nonempty'}) ;
p.addParamValue('c', 3, @(x)validateattributes(x, {'numeric'}, {'scalar', 'positive', 'integer', 'nonempty'}) ;
 
p.parse(varargin{:}) ;
P = p.Results ;
 
% merge fields from E & P into E
f = fieldnames(P);
for i = 1:length(f)
   E.(f{i}) = P.(f{i});
end

2/ passer E systématiquement comme argument à toutes les fonctions

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
function faire_qqchose(E, param1, param2, param3, ...)
disp(E.filename)
disp(E.a)
disp(E.b)
...

L'utilisation se fait comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
% crée les constantes
E = build_environnement ([], 'filename', 'toto.txt', 'a', 100, 'b', 2000) ;

% utilise les constantes
% comme E n'est pas modifié dans la fonction, il est passé par référence donc pas cher en temps et en espace.
faire_qqchose(E, param1, param2, param3, ...)

% modifie une des constantes.
E = build_environnement (E, 'filename', 'tata.txt') ;

[tanguy4724]

@link66 : ravi d'avoir pu t'être utile

@ol9245 : à 9 min près c'était l'inverse


ps : j'utilise beaucoup cette méthode pour ne pas avoir à entrer 50 attributs dans mes fonctions. Je leur donne juste en entrée mon script .m que je modifie selon mes besoins, et le tour est joué !

[link66]

@ol9245 : je pensais au cas où je ne trouverai pas de solution faire une classe ou structure dans mon script principal, et la rajouter dans arguments des fonctions en ayant besoin.

Mais ca ne ralentirai pas le programme de passer tout un tas de paramètres en plus? Après la technique donnée par Tanguy n'est peut être pas plus performante (ou moins), mais je la trouve 'transparente' à utiliser, à part qu'il faille appeler le fichier au début de chaque fonction.

[ol9245]

@ol9245 : à 9 min près c'était l'inverse

ben oui, le temps de m'occuper de mon stagiaire qui galère juste à côté et voila comment on perd bêtement du temps sur les choses importantes

si tu utilises beaucoup cette technique de scripts, jette un oeuil sur la méthode alternative que j'ai proposée et dis moi si ça t'inspire.

[ol9245]

@ol9245 : je pensais au cas où je ne trouverai pas de solution faire une classe ou structure dans mon script principal, et la rajouter dans arguments des fonctions en ayant besoin.

Mais ca ne ralentirai pas le programme de passer tout un tas de paramètres en plus? Après la technique donnée par Tanguy n'est peut être pas plus performante (ou moins), mais je la trouve 'transparente' à utiliser, à part qu'il faille appeler le fichier au début de chaque fonction.

Comme je le dis dans le post, ça ralentira moins que de réinitialiser toutes les variables à chaque fois. En effet, tes constantes ne seront pas recopiées à chaque fonction : seule la ré&férence de l'instance originale de E (un pointeur) est passée à la fonction. Moralité, pas de temps perdu à initialiser à chaque fois des constantes qui ne servent pas.


Côté transparence c'est plus propre : dès la lecture du code tu sais que les costates prooviennent de la structure E et que celle-ci est passée en argument de la fonction.