Je veux utiliser une structure comme HashTable. Y a-t-il une structure similaire dans Wolfram Mathematica?Existe-t-il une structure HashTable dans Wolfram Mathematica?
Répondre
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
Je dirais que la structure la plus similaire que vous pouvez obtenir sortie de la boîte sont sparse arrays.
Je suis d'accord avec Pillsy, mais aussi voir cette réponse:
Il comprend une fonction pratique pour obtenir les clés d'une table de hachage.
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]]
];
];
]
oublièrent: ForEach = Fonction [ { liste, func }, len = Longueur [liste]; Pour [i = 1, i <= len, i ++, func [liste [[i]]]; ]; ] – Fiard
vous pouvez modifier votre réponse pour l'inclure. –
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}
Cette réponse mérite plusieurs votes de plus. À mon humble avis, il est presque toujours préférable d'utiliser des structures prêtes à l'emploi plutôt que de construire les siennes. Mais 'Pillsy' a également donné une très bonne réponse. – Shredderroy