Discussion :

[le fab]

Hello

je précise que je tourne sous matlab 2011b
j'ai besoin d'utiliser la fonction interp3 dans un bloc "matlab function" (ex embedded)

en 2011b cette fonction n'est pas compilable (elle l'est en 2014a), du coup je suis obligé d'utiliser l'instruction "coder.extrinsic"

problème : les aller retours simulink matlab induits rendent la simulation extrement lente
je cherche donc à accélérer tout ca (et sans utiliser de bloc look up table)

pour donner des ordres de grandeurs, 10000 interpolations durent :
- 1 seconde avec un bloc look up table
- 124 sec avec interp3
- 81 sec avec interp3 et '*linear' comme méthode d'interpolation

mon but est donc d'avoir qqch de compilable, cela me parait nécessaire pour retrouver de la rapidité

j'ai regardé du coté d'une fonction "rapide" d'interpolation 3d dispo sur matlab central : lininterp3
même en modifiant ce qui est nécessaire (suppression des warnings et modification des conditions sur vecteurs logiques) je n'arrive pas à faire tourner cette fonction simple sans l'instruction "coder.extrinsic" : erreur dans les multiplications de matrice en mode "compilé"
(pour info en mode extrinsic elle dure 80sec pour 10000 interpolations)

bref, je sèche

une idée ?

merci
Fabien

[duf42]

Salut,

Pour information, quel est le message d'erreur que tu obtiens?

Duf

[le fab]

yop

c'est bon je m'en suis sorti, j'ai réussi à rendre compilable la fonction lininterp3 dispo sur matlab centrale
je met le code modifié pour ceux que ca interesse

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
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
function v = lininterp3_bis(X, Y, Z, V, x, y, z)
% linear interpolation, given set of X, Y, Z, and V values, and an x, y, z query
% assumes X, Y, and Z values are in strictly increasing order
%
% Differences from matlab built-in :
%       order of arguments switched
%       much, much faster
%       if coordinate is exactly on the spot, doesn't look at neighbors.  e.g. interpolate([blah, blah2], [0, NaN], blah) returns 0 instead of NaN
%       extends values off the ends instead of giving NaN
%       
% modifiée 13/06/2014 Fabien GRand-Perret : focntion rendu compilable

% if ((length(X) ~= size(V, 1)) || (length(Y) ~= size(V, 2)) || (length(Z) ~= size(V, 3))), error('[length(X), length(Y), length(Z)] does not match size(V)'); end

%%
%#codegen

%% init
pindexx = nan;
indexx = nan;
pindexy = nan;
indexy = nan;
pindexz = nan;
indexz = nan;

slopex = nan;
slopey = nan;
slopez = nan;

Xp = nan;
Yp = nan;
Zp = nan;

%%
pindexx = find((x >= X), 1, 'last');
indexx = find((x <= X), 1, 'first');

if isempty(pindexx)
%     warning('interpolating x value before beginning');
    pindexx = indexx;
    slopex = 0;
elseif isempty(indexx)
%     warning('interpolating x value after end');
    indexx = pindexx;
    slopex = 0;
elseif all(pindexx == indexx)
    slopex = 0;
else
    Xp = X(pindexx);
    slopex = (x - Xp) / (X(indexx) - Xp);
end

pindexy = find((y >= Y), 1, 'last');
indexy = find((y <= Y), 1, 'first');

if isempty(pindexy)
%     warning('interpolating y value before beginning');
    pindexy = indexy;
    slopey = 0;
elseif isempty(indexy)
%     warning('interpolating y value after end');
    indexy = pindexy;
    slopey = 0;
elseif all(pindexy == indexy)
    slopey = 0;
else
    Yp = Y(pindexy);
    slopey = (y - Yp) / (Y(indexy) - Yp);
end

pindexz = find((z >= Z), 1, 'last');
indexz = find((z <= Z), 1, 'first');

if isempty(pindexz)
%     warning('interpolating z value before beginning');
    pindexz = indexz;
    slopez = 0;
elseif isempty(indexz)
%     warning('interpolating z value after end');
    indexz = pindexz;
    slopez = 0;
elseif all(pindexz == indexz)
    slopez = 0;
else
    Zp = Z(pindexz);
    slopez = (z - Zp) / (Z(indexz) - Zp);
end

v = V(pindexx(1), pindexy(1), pindexz(1)) * (1 - slopex(1)) * (1 - slopey(1)) * (1 - slopez(1)) + V(indexx(1), pindexy(1), pindexz(1)) * slopex(1) * (1 - slopey(1)) * (1 - slopez(1)) ... 
  + V(pindexx(1),  indexy(1), pindexz(1)) * (1 - slopex(1)) *       slopey(1) * (1 - slopez(1)) + V(indexx(1),  indexy(1), pindexz(1)) * slopex(1) *       slopey(1) * (1 - slopez(1)) ... 
  + V(pindexx(1), pindexy(1),  indexz(1)) * (1 - slopex(1)) * (1 - slopey(1)) *       slopez(1) + V(indexx(1), pindexy(1),  indexz(1)) * slopex(1) * (1 - slopey(1)) *       slopez(1) ... 
  + V(pindexx(1),  indexy(1),  indexz(1)) * (1 - slopex(1)) *       slopey(1) *       slopez(1) + V(indexx(1),  indexy(1),  indexz(1)) * slopex(1) *       slopey(1) *       slopez(1) ;

end

le problème venait du dernier calcul, qui est juste une additions de multiplications scalaires
mais la fonction multiplier (mtimes) me retournait une erreur lors de l'appel depuis la matlab fonction (et seulement depuis matlab function)

cela venait du fait que l’interpréteur de matlab function n'était pas sur que tous les termes de ces multiplication était bien scalaire (alors que moi j'en étais sur ! )
du coup j'ai rajouter les index (1) à chaque variable, comme ca il est content, c'est forcement des scalaires
(y a peut être plus propre, mais ça marche)

Fabien