Mathematica 中有什么简单的机制可以使模块具有持久状态吗？

Question

在 C 中，如果我希望在调用之间保存局部变量值，当我在函数内定义局部变量时，我常常在变量旁边添加“static”一词。

这给了我变量名的局部范围保护，但同时变量值是持久的。对于模拟保存其私有状态的简单对象非常有用。

http://en.wikipedia.org/wiki/Local_variable#Static_local_variables

可能吗使用 Module[] 在 Mathematica 中模拟这一点？或DynamicModule[]？

（我们知道 Module[] 默认情况下不保存局部变量状态，但是使用 DynamicModule[] 怎么样？）

不使用包。使用它的上下文位于 Manipulate[] 内。

Module[] 不能位于 Manipulate 之外。因此，一切都必须是这样的：

Manipulate[

    foo[]:=Module[{a,b,c},....];
    boo[]:=Module[{a,b,c},....];

      ... foo[] ..
      ... boo[]...
    ..,

    control_variables...,

    Initialization:>
    (
     .... global area....
    )
]

我尝试使用 DynamicModule 代替上面的 Module[] 来执行此操作，但是 DynamicModules 不能被称为函数？我不知道该怎么做。

问题是：是否有可能让函数在调用之间记住其局部变量的值，例如使用 C 语言和局部静态变量可以做到这一点？

当然，无法保存状态在全局变量中，这就是我问这个问题的全部意义。我希望将模块状态保存在仅属于该模块的上下文中。

我并不要求任何高级的面向对象模拟。只是想将模块使用的一些局部变量保存在属于该模块的名称范围中，而不是保存在全局上下文中，并让它们在模块调用之间保持不变。

更新

需要明确的是，这是一个非常基本的 C 示例

#include <stdio.h>     

void my_add(void)  
{
 static int total = 0;

 total = total + 1;

 printf("current total %d\n",total);     
}

int main()
{
  int i;
  for(i = 1; i<=3; i++)
       my_add();

    return 0;
}

$ gcc ex.c
$ ./a.exe
current total 1
current total 2
current total 3
$

更新 8:45 AM

这是针对 WReach 解决方案的。这是我尝试过的：

 Manipulate[
 n;
 Module[{total = 0},
  processA[] :=
   (
    total = total + 1
    )
  ];
 Module[{total = 0},
  processB[] :=
   (
    total = total + 1
    )
  ];

 Grid[{
   {"module A total=", processA[]},
   {"module B total=", processB[]}
   }],

 Button["press to update state", n++],
 {{n, 0}, None},
 TrackedSymbols :> {n}
 ]

每次我点击按钮时，总数仍为 1。它不保存最后一个值。

上午 9:13 更新

对于 Manipulate 中的 WReach 解决方案：

这是一个测试：

Manipulate[

 n;

 Grid[{
   {"module A result=", aResult}
   }],

 Button["press to update process A", {n++; aResult = processA[n]}],
 {{n, 0}, None},
 {{aResult, {}}, None},
 TrackedSymbols :> {n},
 Initialization :>
  (
   Module[{total = 0},
    processA[n_] :=
     (
      total = total + 1;
      {n, total}
      )
    ]
   )
 ]

就其本身而言，它似乎有效。但是当我复制单元格并将其粘贴到新单元格时。然后运行第二个 Manipulate，更新那里的总数，然后返回第一个 Manipulate 更新那里的总数，我看到它正在使用第二个 Manipulate 更新的总数。因此它是全球性的。

这在演示中是不允许的。拍摄快照，并且它们不能共享状态（演示中不允许使用全局变量。初始化部分不得包含全局共享数据。但可以包含仅从 Manipulate 表达式通过参数调用的函数，没问题

更新9:40 AM

回复Mr Wizard 下面的第二个例子，他展示的模式如下：

Manipulate[
  {x, myAdd[]},
  {x, 1, 10},
  {{total, 0}, None},
  {{myAdd, (total += 1; total) &}, None}
]

这个问题是，名称total 可以。不能被 2 个不同的函数使用。 total 的命名空间横跨整个 Manipulate。我想要的，使用这种模式是这样的：

Manipulate[
 ctrl;
 Grid[{
   {"processA result=", processA[]},
   {"processB result=", processB[]}
   }],

 Button["step", ctrl++],

 {{ctrl, 0}, None},

 {{processA, Module[{total = 0}, total++] &}, None},
 {{processB, Module[{total = 0}, total++] &}, None},

 TrackedSymbols :> {ctrl}
 ]

你看，在上面，processA 有它自己的本地总计，processB 也是如此。相同的本地名称。如果我用以下内容替换上面的内容以使其“工作”，

Manipulate[
 ctrl;
 Grid[{
   {"processA result=", processA[]},
   {"processB result=", processB[]}
   }],

 Button["step", ctrl++],

 {{ctrl, 0}, None},
 {{total, 0}, None},

 {{processA, Module[{}, total++] &}, None},
 {{processB, Module[{}, total++] &}, None},

 TrackedSymbols :> {ctrl}
 ]

那么 processA 和 processB 现在共享相同的总变量，这违背了每个都位于单独的名称空间中的全部意义。但在整个通话过程中始终坚持 。

上午 10 点更新

Opps，我在上面的示例中编写 Module[] 的方法很糟糕 这就是它不起作用的原因。请忽略我上午 9:40 的更新。我现在正在纠正它，并将在几分钟内更新。它可能真的有效。

更新10:08 AM

好吧，这是独家新闻：在我上午9:40，当我说“以上不起作用”时，是因为我的设置错误，()的位置错误。我纠正了这一点。我现在展示了 WReach 在避免全局定义标题下提到的解决方案。

消息是它适用于 ONE 操作。一旦我将操作复制到另一个单元格，计数器就会在两个操作之间共享。

这是一个示例：（我在上午 9:40 得到的上述内容的更正版本）

Manipulate[
 ctrl;
 Print["in top of Manipulate"];
 Grid[{
   {"processA current total=", aResult},
   {"processA current total=", bResult}
   }],

 Button["update A process", {ctrl++; aResult = processA[]}],
 Button["update B process", {ctrl++; bResult = processB[]}],

 {{ctrl, 0}, None},
 {{aResult, 0}, None},
 {{bResult, 0}, None},

 {{processA, Module[{total = 0}, ( total = total + 1; total) &]}, 
  None},
 {{processB, Module[{total = 0}, (total = total + 1; total) &]}, None},

 TrackedSymbols :> {ctrl}
 ]

设置只要有一份 Manipulate 副本，就可以工作。一旦我将 Manipulate 本身复制到新单元格并对其进行修改，第一个单元格就会更新。计数器是全局的：

所以，太糟糕了，这些解决方案对我不起作用。稍后会尝试函数上下文的事情。但首先需要对其进行更多了解。

更新 12 PM

为了说明我现在所做的，在下面回复 MrWizard 时，对于我拥有的每个“求解器”，我通过 pn，其中 n 是求解器 ID 号。所以我有 p1StepNumber、p2StepNumber、p3StepNumber、p1Solution、p2Solution、p3Solution 等...

然后当我想调用求解器 1 时，我将 p1* 参数传递给它，并在返回时返回解和任何更新以保存在Manipulate Control->None区域中供以后调用，依此类推。

因此，每个解算器的状态在 Manipulate 内部保留/保存为 Control->None 变量。由于 Manipulate 是 DynamicModule，因此它们会在调用之间保存，甚至当我关闭 M 并重新打开它时也是如此。

下面是 Control-None 区域中 Manipulate 参数的部分列表的屏幕截图，以进行说明。所有这些以及更多内容都在一个 Manipulate 中。当用户更改解算器时，整个 UI 也会发生变化，并使用特定于该解算器的新布局。

感谢 Leonid Macro 方法的使用，我现在能够轻松地做到这一点:)。

如果我可以将这些保存在每个解算器“内部”，并且让每个解算器成为一个单独的模块，其中每个解算器将保存自己的状态，并且 Manipulate 每次需要刷新时都会将 UI 参数传递给它，那么效果会更好其他所有内容都保存在它们所属的解算器中。

甚至没有一个结构来管理它，这意味着我所做的每个调用都有超过 20-30 个参数。因为我每次都需要向求解器传递其所有状态，并通过返回将其取回。还不错，我只是要习惯每次调用 30 个参数，这是我不习惯的。但到目前为止我还没有看到其他干净的方法。这就是我问这个问题的原因。

更新时间：2011 年 12 月 24 日下午 6 点 以下是对 Szabolcs 和 telefunkenvf14 使用函数上下文名称的建议的回应。

我发现的结论是这个方法也行不通。与其他方法相同的问题。

一旦我制作了 Manipulate 本身的副本，变量就会在 Manipulate 的 2 个副本之间共享。

下面是显示问题的示例：

Remove["Global`*"]
Manipulate[
 ctrl;
 Print["in top of Manipulate"];
 Grid[{
   {"processA current total=", aResult},
   {"processA current total=", bResult}
   }],

 Button["update A process", {ctrl++; aResult = processA[]}],
 Button["update B process", {ctrl++; bResult = processB[]}],

 {{ctrl, 0}, None},
 {{aResult, 0}, None},
 {{bResult, 0}, None},

 {{processA, Module[{},
    (
      If[! ValueQ[processA`total], processA`total = 0];
       processA`total = processA`total + 1; 
      processA`total
      ) &]}, None},

 {{processB, Module[{},
    (
      If[! ValueQ[processB`total], processB`total = 0];
       processB`total = processB`total + 1; 
      processB`total
      ) &]}, None},

 TrackedSymbols :> {ctrl}
 ]

现在，我将上述内容复制到新单元格中，然后单击按钮，我看到计数器现在比 Manipulate 的上一个副本中的值提前。所以进程`A是共享的。它对于每个特定功能来说都是本地的。

与尝试的其他方法完全相同的问题，因此此方法对我不起作用。

Answer 1

试试这个：

Module[{total = 0}
, myAdd[] := (total += 1; Print["current total ", total])
]

使用：

In[2]:= myAdd[]

        current total 1

In[3]:= myAdd[]

        current total 2

In[4]:= myAdd[]

        current total 3

出于实际目的，模块变量 total 仅对 myAdd 可见。 Module 通过创建一个新的唯一符号来实现此功能，该符号的名称是根据提供的符号生成的（在本例中为 total）。您可以通过计算表达式来看到这一点，例如：

In[5]:= Module[{total}, total]

Out[5]= total$562

我们实际上可以访问 myAdd 使用的符号：

In[6]:= Names["total*"]

Out[6]= {"total", "total$557", "total$562"}

In[7]:= total$557

Out[7]= 3

我们还可以通过检查 myAdd 的定义来查看重命名的效果：

In[8]:= ??myAdd

Global`myAdd
myAdd[]:=(total$557+=1; Print[current total, total$557])

在 Manipulate 中使用

我们可以在 Manipulate 中使用这种技术，因此：

Manipulate[
  {x, myAdd[]}
, {x, 1, 10}
, Initialization :>
    Module[{total = 0}
    , myAdd[] := (total += 1; total)
    ]
]

避免全局定义

如果我们迫切希望避免 myAdd 的全局定义，我们可以这样做：

Manipulate[
  {x, myAdd[]}
, {x, 1, 10}
, { myAdd
  , Module[{total = 0}, (total += 1; total) &]
  , None
  }
]

这样，myAdd 的定义就被本地化了在Manipulate 中。但请注意，符号 myAdd 仍然是全局的，x 和 total 也是如此。这是因为整个 Manipulate 表达式被读入全局上下文。如果这不能令人满意，那么我们就必须将整个表达式放入另一个上下文中——无法避免符号必须存在于某些上下文中的事实。

再次进入漏洞

好的，这是解决附加要求的另一种尝试：

Manipulate[
  Module[{f, g}
  , Module[{total = 0}, f[] := ++total]
  ; Module[{total = 0}, g[] := --total]
  ; Dynamic[{x, f[], g[]}]
  ]
, {x, 1, 10}
]

该解决方案具有以下功能：

• f 和 g 的定义> 本地化到单元格
• total 的两次出现彼此隔离，并且本地化到单元格，
• 每当您操作 时，total 变量都不会重置为零x
• 如果您复制结果输出单元格，副本不与第一个单元格共享任何状态

Answer 2

如果我了解您的需求，但我不确定我是否了解，那么我在这篇文章中建议的表单可能会满足您的需求：

https: //stackoverflow.com/a/8552728/618728

也就是说，使用如下控件： {{x, 0}, None}

调整附加示例，可以执行以下操作 工作？

Manipulate[
 n;
 processA[] := (total = total + 1);
 processB[] := (total = total + 1);
 Grid[{{"module A total=", processA[]}, {"module B total=", processB[]}}], 
 Button["press to update state", n++],
 {{n, 0}, None},
 {{total, 0}, None},
 TrackedSymbols :> {n}
]

改编 WReach 的最新示例：

Manipulate[
  {x, myAdd[]},
  {x, 1, 10},
  {{total, 0}, None},
  {{myAdd, (total += 1; total) &}, None}
]

以下是使用您最新问题更新的示例。据我所知，这是有效的。我建议您找到一种方法来解决对单独符号的需求。

Manipulate[ctrl;
 Grid[{
   {"processA current total=", aResult},
   {"processA current total=", bResult}
 }], 
 Button["update A process", {ctrl++; aResult = processA[]}],
 Button["update B process", {ctrl++; bResult = processB[]}],
 {{ctrl, 0}, None},
 {{aResult, 0}, None},
 {{bResult, 0}, None},
 {{total1, 0}, None},
 {{total2, 0}, None},
 {{processA, (++total1) &}, None},
 {{processB, (++total2) &}, None},
 TrackedSymbols :> {ctrl}
]