¿Hay una estructura HashTable en Wolfram Mathematica?

Question

Quiero usar una estructura como HashTable. ¿Hay una estructura similar en Wolfram Mathematica?

Answer 1

Actualización: Mathematica versión 10 introdujo la estructura de datos Association (tutorial).

---

Existen varias posibilidades. La posibilidad más sencilla, que funciona bien si no necesita agregar o eliminar claves de su tabla, o cambiar sus valores asociados, es construir una lista de reglas con la clave en el lado izquierdo y el valor en el derecho lado derecho, y use Dispatch en él.

Si necesita cambiar las entradas en su tabla, puede usar el DownValues de un símbolo como una tabla hash. Esto soportará todas las operaciones que comúnmente se usan con las tablas hash. Esta es la forma más sencilla de hacerlo:

(* 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

Yo diría que la estructura más similar que puede obtener fuera de la caja es sparse arrays.

Answer 3

Estoy de acuerdo con Pillsy, pero ver también esta respuesta:

Mathematica Downvalue Lhs

Incluye una función muy útil para obtener las claves de una tabla hash.

Answer 4

he hecho módulo Dictionary.m, que contenía:

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 introduce Asociación, <| k -> v |>,

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

que es básicamente un contenedor para una lista de reglas: Convertir una lista de reglas para una asociación:

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

Convierta una asociación a una lista de reglas:

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