S'il existe un contexte numérique entre l'index et la valeur comme dans votre exemple, vous pouvez simplement l'utiliser comme une fonction au lieu d'une table de recherche:

function idx=angle2i(angle)
idx=angle/5+1;
end

Mais Je ne sais pas si cela résout votre problème, car je ne connais pas votre problème spécifique.

Vous recherchez des containers.Map .

Vous pouvez faire:

th = [0 5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90];
angle2i = containers.Map(th,1:numel(th));
index = angle2i(55)

Si th est garanti trié, alors des solutions à cette autre question pourraient également être utiles.

Bien sûr, s'il existe une relation mathématique simple (comme dans le cas de l'exemple e , puis la solution O (1) par @mattesyo de calcul de l'index a > ne peut pas être battu.

Si vos clés sont des entiers, vous pourriez peut-être utiliser un tableau fragmenté! Considérez la situation suivante:

function t = q55725607
%% Define the mapping(s):
keys = (1:60).*5; % Keys must be integers!
values = 1:numel(keys); 
% Construct an array such that `map(key) == value`
map = sparse(ones(numel(keys),1), keys, values);

% Compare to containers.Map:
hashmap = containers.Map(keys, values);

%% Try this out:
queryKeys = randi(60,5000000,1).*5;
queryKeysCell = num2cell(queryKeys);

t = [timeit(@f1,1), timeit(@f2,1)];

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
function queryVals = f1()
  queryVals = reshape(full(map(queryKeys)), size(queryKeys));
end

function queryVals = f2
  queryVals = hashmap.values(queryKeysCell);
end

end

Je ne sais pas si la comparaison que j'ai faite est juste, mais si c'est le cas, l'approche clairsemée est un ordre de grandeur plus rapide sur mon système ( 0.1549 vs 1.5685).

BTW, au cas où ce ne serait pas clair, la raison de l'utilisation d'un tableau sparse est parce qu'il ne prend de la place que pour les valeurs non nulles (donc même si vous avez des indices comme 1 et 10E5, vous ne stockeriez que 2 valeurs, en gros ).

Si vous disposez de toutes les (plusieurs millions) valeurs de angle , vous pouvez utiliser ismember :

[~, idx] = ismember(angle, th);

Benchmark

En commençant par le benchmark de Dev-iL , j'ai ajouté la find d'OP et la méthode ismember de rahnema1, et regardez comment les méthodes évoluent avec la taille des données (nombre de clés). Je compare également deux cas d'utilisation différents: trouver 5000 clés à la fois et trouver 5000 clés une à la fois.

Voici les résultats:

function t = so(N)
% Define the mapping(s):
keys = (1:N).*5; % Keys must be positive integers!
values = 1:N; 

% Sparse lookup table
sparseMap = sparse(ones(numel(keys),1), keys, values);

% containers.Map lookup table
hashMap = containers.Map(keys, values);

% Try this out:
queryKeys = keys(randi(numel(keys),5000,1));
queryKeysCell = num2cell(queryKeys); % trick to read many values from the hashMap at once

t = [timeit(@f1,1), timeit(@f2,1), timeit(@f3,1), timeit(@f4,1), ...
     timeit(@f1q,1), timeit(@f2q,1), timeit(@f3q,1), timeit(@f4q,1)] * 1000;

% Functions that do the lookup one at the time:

   function queryVals = f1
      queryVals = zeros(size(queryKeys));
      for ii=1:numel(queryKeys)
         queryVals(ii) = full(sparseMap(queryKeys(ii)));
      end
   end

   function queryVals = f2
      queryVals = zeros(size(queryKeys));
      for ii=1:numel(queryKeys)
         queryVals(ii) = hashMap(queryKeys(ii));
      end
   end

   function queryVals = f3
      queryVals = zeros(size(queryKeys));
      for ii=1:numel(queryKeys)
         queryVals(ii) = find(keys==queryKeys(ii));
      end
   end

   function queryVals = f4
      queryVals = zeros(size(queryKeys));
      for ii=1:numel(queryKeys)
         [~, queryVals(ii)] = ismember(queryKeys(ii), keys);
      end
   end

% Functions that do the lookup all at once:

   function queryVals = f1q
      queryVals = reshape(full(sparseMap(queryKeys)), size(queryKeys));
   end

   function queryVals = f2q
      queryVals = hashMap.values(queryKeysCell);
   end

   function queryVals = f3q
      [queryVals,~] = find(keys.'==queryKeys);
   end

   function queryVals = f4q
      [~,queryVals] = ismember(queryKeys, keys);
   end

end

[ Horaires sur MATLAB R2017a, sur un iMac de 3 ans. Votre kilométrage variera. ]

Contrairement à mes attentes, containers.Map a beaucoup de frais généraux et ne convient pas vraiment à cette fin fort>. Même avec un tableau de 5000 clés, la méthode O (n) find est en fait plus rapide que la carte de hachage O (log n). containers.Map est une classe personnalisée, et le MATLAB JIT n'est toujours pas aussi efficace pour optimiser ce type de code. Cependant, on peut clairement voir l'effet de la mise à l'échelle ici, car la méthode find est la seule dont le temps d'exécution augmente considérablement avec l'augmentation de la taille des données.

Fait intéressant, la méthode "sparse "est environ 50 fois plus rapide lorsqu'elle est vectorisée. Ce n'est généralement plus le cas avec la vectorisation. Par exemple, la méthode find n'est qu'environ 1x-2x plus rapide lorsqu'elle est vectorisée (pour des tailles de données plus importantes, la vectorisation nécessite trop de mémoire et finira par s'avérer très lente).

La plus grande différence ici entre le code vectorisé et le code en boucle concerne la fonction ismember . Celui-ci trie les données d'entrée, et nous voyons donc ici la différence entre le faire une fois et le faire 5000 fois. Cette méthode ne convient vraiment que lorsqu'elle est appelée quelques fois. Mais dans ce cas, ismember est aussi facilement la méthode la plus rapide .

Lors de la récupération d'une clé à la fois, la méthode fragmentée est la plus rapide , sauf si la taille des données est très petite, auquel cas la méthode find l'emporte . Cependant, la méthode creuse est la seule qui nécessite que les clés soient des entiers positifs (elle ne fonctionnera pas avec 0, des valeurs négatives ou des valeurs non entières). Les autres méthodes fonctionnent toutes avec des valeurs de types arbitraires (y compris des chaînes).

---

Code de référence:

                One key at the time                      Many keys at once
       -------------------------------------   -------------------------------------
size    sparse     c.Map      find  ismember    sparse     c.Map      find  ismember  
----   -------   -------   -------   -------   -------   -------   -------   -------
  50    5.1681   54.3091    3.7766   28.8590    0.0956    1.2973    0.5578    0.0537
 500    5.0864   54.7872    6.9310   32.5554    0.0977    1.6847    3.6726    0.0499
5000    5.2052   56.4472   35.1449   60.6480    0.1140    2.0886   38.7444    0.0789