如何在 Erlang 中编写模拟？

Question

我想在 Erlang 中做一些数字操作，如下所示：

你有一个包含以下值的数组：

[2,3,4]

在每次迭代中，你计算

0.1 * [n-1] + 0.7 *[n] + 0.2 * [n+1]

这将成为 new [n]。

If n == 0 then [n-1] = 0. If [n] == length of array then [n] = 0.

所以我尝试举个例子：

[2,3,4]

计算：

0.1 * 0 + 0.7 * 2 + 0.2 * 3 = 2

0.1 * 2 + 0.7 * 3 + 0.2 * 4 = 3.1

0.1 * 3 + 0.7 * 4 + 0.2 * 0 = 3.1

所以<代码>[2,3,4]一次迭代后， 变为 [2, 3.1, 3.1]。

我知道如何用 C 等非函数式语言编写此代码。 但我很难想象，这如何在 Erlang 中完成。 我找到了一些关于如何将文件读取到列表的教程。所以这个 不是问题。

如何生成不同的 Erlang 进程，每个进程都有列表中的一个元素？ 我如何通过与“邻居”通信来进行计算，以便邻居知道他们的邻居一般在哪里，而不需要指定每个邻居？ 如何将数据收集到列表中？

最终，有可能在 Erlang 中解决这个问题吗？

感谢您的帮助。

Answer 1

原始问题的答案：

-module(simulation).
-export([start/0]).

f([N0, N1, N2]) ->
    M0 =            0.7 * N0 + 0.2 * N1,
    M1 = 0.1 * N0 + 0.7 * N1 + 0.2 * N2,
    M2 = 0.1 * N1 + 0.7 * N2,
    [M0, M1, M2].

iterate(List, Iterations) ->
    iterate(1, List, Iterations).

iterate(_Iteration, List, 0) ->
    List;
iterate(Iteration, List = [N0, N1, N2], MoreIterations) ->
    io:format("~.5f  ~.5f  ~.5f~n", [N0, N1, N2]),
    NextList = f(List),
    iterate(Iteration + 1, NextList, MoreIterations-1).

start() ->
    iterate([2.0, 3.0, 4.0], 10),
    ok.

任意列表长度的通用答案：

-module(simulation2).
-export([start/0]).

f(Prev, Current, Next) ->
    0.1 * Prev + 0.7 * Current + 0.2 * Next.

transform(List) ->
    transform(0.0, List, 0.0).

transform(_First, [], _Last) ->
    [];
transform(First, [X], Last) ->
    Y = f(First, X, Last),
    [Y];
transform(First, [X1, X2 | More], Last) ->
    Y1 = f(First, X1, X2),
    [Y1 | transform(X1, [X2 | More], Last)].

iterate(List, Iterations) ->
    iterate(1, List, Iterations).

iterate(_Iteration, List, 0) ->
    List;
iterate(Iteration, List, MoreIterations) ->
    io:format("~p~n", [List]),
    NextList = transform(List),
    iterate(Iteration + 1, NextList, MoreIterations-1).

start() ->
    iterate([1.0, 2.0, 3.0, 4.0, 5.0], 10),
    ok.

Answer 2

这种迭代模式很棒。但是，如果列表的元素多于三个并且每个成员都需要他的邻居，你该怎么办？这个例子会更加动态。
函数式编程是一种不同的思维方式。但我认为 - 作为一个新手 - 它具有与 C 相同的潜力。
当我想写的时候我该怎么办：

start() ->
    iterate([2.0, 3.0, 4.0, 5.0, ...], 10),
    ok.

谢谢你的所有提示。他们真的很有帮助。
我做这个模拟只是为了好玩:)。我用 C 语言进行了这样的模拟。我只是想知道它是否可以在 Erlang 中动态地工作。

Answer 3

这绝对是可能的（但如果您想做的是纯数值计算，您可能需要重新考虑，除非这是您追求的智力练习 - 或者您可以考虑使用像 http://discoproject.org/）。

然而，您似乎还没有完全掌握在 Erlang 中进行进程编程的基本技术，所以我建议您从这里开始。 （例如，获取乔·阿姆斯特朗（Joe Armstrong）的书并尝试其中的示例。）一旦您进入其中（这不会花费很长时间），您应该不会遇到太多困难来找出构建此类程序的一些不同方法。

Answer 4

我会尝试使用标准函数模式来处理列表

iter([], Acc) ->
    lists:reverse(Acc);
iter([H|Tail], Acc) ->
    iter(Tail, [do_something_with(H)|Acc]).

，并将其扩展为在适当的模式中使用三个值，以将公式处理的三个值处理为新值：

...
iter([H1,H2,H3|Tail], Acc) ->
    iter([H2,H3|Tail], [do_something_with(H1,H2,H3)|Acc]);
...

当然，这需要一些额外的函数子句来正确处理与列表的开头和结尾。

Answer 5

我尝试了一些东西，但失败了。下面的代码应该为每个列表元素生成一个进程，但不知何故，如果我给它一个包含 4 个元素的列表，它不会停止创建进程并崩溃。我认为发生错误的部分用 %BUG 标记。
模拟：模拟/ 2开始一切，即模拟：模拟（[1,2,3,4],7），其中7是迭代次数。数字为 0 的元素是单独创建的，因为它永远不应该改变它的值。进程应该获取前一个和下一个邻居的 PID，以便它们可以交换它们的值。我尝试使用调试器 im() 对其进行调试。但它崩溃了。我看到创建了太多进程。不知怎的，我现在没有发现错误。也许你注意到一些完全错误的事情？

-module(simulation).
-compile(export_all).
%-export().

f(Prev, Current, Next) ->
    0.1 * Prev + 0.7 * Current + 0.2 * Next.

simulate([], _Iteration) -> [];
simulate([X], 0) -> [X];
simulate([X], Iteration) -> simulate([f(0.0, X, 0.0)], Iteration - 1);
simulate(Liste, 0) -> Liste;
simulate(Liste, Iteration) ->
    PidStarter = self(),
    {Number, ProcList} = startProcesses(Liste, Iteration, PidStarter), %BUG
    Connector = spawn(fun() -> simProcessStarter(0.0, PidStarter, Iteration, 0) end), %untested
    [H1, H2 | _] = ProcList,
    H1 ! {startinformation, Connector, H2}, %untested
    ReversedProcList = lists:reverse(ProcList),
    [L1, L2 | _] = ReversedProcList,
    L1 ! {startinformation, L2, Connector},%untested
    fold(ProcList),%untested
    evaluate(Number, []).%untested

fold([]) -> ready;
fold([_X1]) -> ready;
fold([_X1, _X2]) -> ready;
fold([X1, X2, X3 | Tail]) ->
    X2 ! {statusinformation, X1, X3},
    fold([X2, X3 | Tail]).

evaluate(0, List) ->
    List;
evaluate(N, List) ->
    receive 
        {N, Current} -> 
            Result = [Current | List]
    end,
    evaluate(N-1, Result).

% returns {number of processes, list of processes started}
startProcesses(Liste, Iteration, PidStarter) -> startProcesses(Liste, 0, Iteration, [], PidStarter).

startProcesses([], N, _Iteration, List, _PidStarter) -> {N, lists:reverse(List)};
startProcesses([H | T], N, Iteration, List, PidStarter) ->
    startProcesses([T], N + 1, Iteration, [spawn(fun() -> simProcessStarter(H, PidStarter, Iteration, N + 1) end) | List], PidStarter).

simProcessStarter(Current, PidStarter, Iteration, Number) ->
    receive 
        {startinformation, PidPrev, PidNext} -> 
            Result = simProcess(Current, PidPrev, self(), PidNext, Iteration, Number)
    end,
    PidStarter ! Result.

simProcess(Current, _PidPrev, _PidCurrent, _PidNext, 0, Number) ->
    {Number, Current};
simProcess(Current, PidPrev, PidCurrent, PidNext, Iteration, Number) ->
    PidNext ! {prev, PidCurrent, Current, Iteration},
    receive
        {prev, PidPrev, Prev, Iteration} -> Prev
    end,
    PidPrev ! {next, PidCurrent, Current, Iteration},
    receive
        {next, PidNext, Next, Iteration} -> Next
    end,
    New = f(Prev, Current, Next),
    simProcess(New, PidPrev, PidCurrent, PidNext, Iteration-1, Number).