Existe-t-il une structure HashTable dans Wolfram Mathematica?

Question

Je veux utiliser une structure comme HashTable. Y a-t-il une structure similaire dans Wolfram Mathematica?

Answer 1

Mise à jour: La version 10 de Mathematica a introduit la structure de données Association (tutorial).

---

Il existe un certain nombre de possibilités. La possibilité la plus simple, qui fonctionne bien si vous n'avez pas besoin d'ajouter ou de supprimer des clés de votre table ou de modifier leurs valeurs associées, est de construire une liste de règles avec la clé sur le côté gauche et la valeur sur la droite côté, et utilisez Dispatch dessus.

Si vous avez besoin de modifier les entrées de votre table, vous pouvez utiliser le DownValues d'un symbole comme table de hachage. Cela supportera toutes les opérations que l'on utilise couramment avec les tables de hachage. Voici la façon la plus simple de le faire:

(* Set some values in your table.*) 
In[1]:= table[a] = foo; table[b] = bar; table[c] = baz; 

(* Test whether some keys are present. *) 
In[2]:= {ValueQ[table[a]], ValueQ[table[d]]} 
Out[2]:= {True, False} 

(* Get a list of all keys and values, as delayed rules. *) 
In[3]:= DownValues[table] 
Out[3]:= {HoldPattern[table[a]] :> foo, HoldPattern[table[b]] :> bar, 
HoldPattern[table[c]] :> baz} 

(* Remove a key from your table. *) 
In[4]:= Unset[table[b]]; ValueQ[table[b]] 
Out[4]:= False 

Answer 2

Je dirais que la structure la plus similaire que vous pouvez obtenir sortie de la boîte sont sparse arrays.

Answer 3

Je suis d'accord avec Pillsy, mais aussi voir cette réponse:

Mathematica Downvalue Lhs

Il comprend une fonction pratique pour obtenir les clés d'une table de hachage.

Answer 4

J'ai fait le module Dictionary.m, qui contenait:

DictHasKey = Function[ 
    { 
     dict, 
     key 
    }, 
    ValueQ[dict[key]] 
] 

DictAddKey = Function[ 
    { 
     dict, 
     key, 
     value 
    }, 
    If[ 
     DictHasKey[dict,key], 
     Print["Warning, Dictionary already has key " <> ToString[key]] 
    ]; 
    dict[key] = value; 
] 

DictKeys = Function[ 
    { 
     dict 
    }, 
    res = {}; 
    ForEach[DownValues[dict], Function[{dictKeyDescr}, 
     res = Append[res, ((dictKeyDescr[[1]]) /. dict -> neverUsedSymbolWhatever)[[1, 1]]]; 
    ]]; 
    res 
] 

DictValues = Function[ 
    { 
     dict 
    }, 
    res = {}; 
    ForEach[DownValues[dict], Function[{dictKeyDescr}, 
     res = Append[res, dictKeyDescr[[2]]]; 
    ]]; 
    res 
] 

DictKeyValuePairs = Function[ 
    { 
     dict 
    }, 
    res = {}; 
    ForEach[DownValues[dict], Function[{dictKeyDescr}, 
     res = Append[res, {((dictKeyDescr[[1]]) /. dict -> neverUsedSymbolWhatever)[[1, 1]], dictKeyDescr[[2]]}]; 
    ]]; 
    res 
] 

ForEach = Function[ 
    { 
     list, 
     func 
    }, 
    len = Length[list]; 
    For[i = 1, i <= len, i++, 
     func[ 
      list[[i]] 
     ]; 
    ]; 
] 

Answer 5

Mathematica 10 présente Association, <| k -> v |>,

<|a -> x, b -> y, c -> z|> 
%[b] 
y 

Ce qui est essentiellement une enveloppe pour une liste de règles: Convert une liste de règles à une association:

Association[{a -> x, b -> y, c -> z}] 
<|a -> x, b -> y, c -> z|> 

Convertir une association en une liste de règles:

Normal[<|a -> x, b -> y, c -> z|>] 
{a -> x, b -> y, c -> z}