Question

我有以下问题，代码说明了一切：

In[1]:= f[1][{1, 2}] = 112
Out[1]= 112
In[2]:= f[1][{3, 4}] = 114
Out[2]= 114
In[3]:= f[2][{1, 6}] = 216
Out[3]= 216
In[4]:= f[2][{2, 7}] = 227
Out[4]= 227
In[5]:= DownValues[f]
Out[5]= {}
In[6]:= SubValues[f]
Out[6]= {HoldPattern[f[1][{1, 2}]] :> 112, 
 HoldPattern[f[1][{3, 4}]] :> 114, HoldPattern[f[2][{1, 6}]] :> 216, 
 HoldPattern[f[2][{2, 7}]] :> 227}
In[7]:= SubValues[f[1]]
During evaluation of In[7]:= SubValues::sym: Argument f[1] at position 1 is expected to be a symbol. >>
Out[7]= SubValues[f[1]]

编辑：上面的值不是硬编码的。它们在运行时逐步构建。它们使用以下算法构建：

f[_Integer][{_Integer..}] :=0
...
someplace later in the code, e.g.,
index = get index;
c = get random configuration (i.e. a pair of integers) = {n1, n2}; 
f[index][c] = f[index][c] + 1;
which tags that configuration c has occured once more in the simulation at time instance index

请注意，最后一行中发生的情况是左侧未评估，右侧是，首先查找f [index] [c]的值，如果未找到，则使用defult规则给出0 + 1，如果发现旧值增加1并存储。所有这些应该是恒定的时间。如果使用数组，则它将是二次复杂度（因为在添加一个元素时需要复制整个数组）。

问题在于，稍后，我希望SubValues [f 1]提供与f 1相关的定义列表，这些定义是无模式的，但SubValues的语法强迫我检索所有这些。当然，这后来对速度有影响，因为必须提取感兴趣的f 1（例如在这个例子中f 1 [{1,2}] = 112和f {{3 } {[3,4}] = 114）可能是一个非常长的列表。

Ultimatelly问题是收集f 1数据，以便返回以下结构：

{list1, list2}

，其中

list1 = {{1,2}, {3,4}}
list2 = {112, 134}

我知道可以使用个案[SubValues [f]，properPattern]并对结果进行处理以获得所需的结果，但我想以更有效的方式更直接地执行此操作（因为重复该过程）在运行时很多次。）

此致卓然

编辑：似乎问题没有得到很好的解决。可以在这里找到相同问题的更好版本：

1

所以请“放弃这艘船”并为不清楚从头开始道歉。

Answer 1

为什么要使用SubValues？如果您将信息放在矩阵中，它总是最快的，例如：

m = { 
        {   {{1, 2}, {3, 4}}, {112, 114}   },
        {   {{1, 6}, {2, 7}}, {216, 227}   } 
     };

然后：

f[i_] := m[[i]];
f[1]

给出

{{{1, 2}, {3, 4}}, {112, 114}}

有选择地以最有效的方式选择模式自由下降值：速度是一个问题

1 个答案: