小编Jan*_*nus的帖子

我是一个糟糕的人:有时,当没有人在观看时,我会缓存结果而不包括完整的上下文,如下所示:

f[x_]:=f[x]=x+a;
a=2; f[1];
DownValues[f]

Out[2]= {HoldPattern[f[1]]:>3,HoldPattern[f[x_]]:>(f[x]=x+a)}

这会导致可怕的细微错误,更重要的是,当我更改上下文时需要清除缓存.清除缓存的一种方法是完全Clear符号并重复定义,但这不是一个真正的解决方案.

我真正想要的是一种清除与符号相关的所有无模式DownValues的方法.
为清楚起见,我将把我目前的解决方案作为答案包括在内,但如果两个方面都失败了

• 它只使用全数字参数清除DownValues
• 出于美学原因,我想避免使用Block抓住DownValues.

关于如何改进的任何想法ClearCache？

什么是连续的改进异步应用到一个最简单的方式Graphics在动态设定目标(并中止不需要的结果的评价,如果他们被计算,而输入的变化)？

举个简单的例子,考虑一下:

speed[r_] := Graphics@{Red, Circle[{0, 0}, r]}
qualityA[r_] := (Pause[1]; Graphics@{Red, Disk[{0, 0}, r]})
qualityB[r_] := (Pause[1]; Graphics@{Black, Circle[{0, 0}, r]})
Manipulate[Show[
  ControlActive[speed[r], {qualityA[r], qualityB[r]}],
  PlotRange -> {{-1, 1}, {-1, 1}}
  ], {{r, .5}, 0, 1}] 

如何评估qualityA和qualityB连续,并且其输出追加到显示器时,它已经准备好？

奖励点用于Abort评估不需要的结果,并允许多次计算结果的一部分,以便在释放控制后我会看到,{qualityA[r]}然后 {qualityA[r],qualityB[r]},最后{qualityA2[r],qualityB[r]}.

假设我有一个测试表示为带有assert-statements的简单脚本（请参阅背景以了解原因），例如

import foo
assert foo(3) == 4

我如何将这个脚本包含在我的 pytest 测试套件中——以一种很好的方式？

我尝试了两种有效但不太好的方法：

一种方法是将脚本命名为测试，但这会使整个 pytest 发现在测试失败时失败。

我目前的方法是从测试函数中导入脚本：

def test_notebooks():
    notebook_folder = Path(__file__).parent / 'notebooks'
    for notebook in notebook_folder.glob('*.py'):
        import_module(f'{notebook_folder.name}.{notebook.stem}')

这是有效的，但脚本不会单独报告，并且测试失败有一个长而蜿蜒的堆栈跟踪：

__________________________________________________ test_notebooks ___________________________________________________

    def test_notebooks():
        notebook_folder = Path(__file__).parent / 'notebooks'
        for notebook in notebook_folder.glob('*.py'):
>           import_module(f'{notebook_folder.name}.{notebook.stem}')

test_notebooks.py:7:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ …

将任意时髦的嵌套列表映射expr到函数的最简单方法unflatten是expr==unflatten@@Flatten@expr什么？

动机: Compile只能处理完整的数组(我刚刚学到的东西 - 但不是来自错误信息),所以我的想法是unflatten与flattened表达式的编译版本一起使用:

fPrivate=Compile[{x,y},Evaluate@Flatten@expr];
f[x_?NumericQ,y_?NumericQ]:=unflatten@@fPrivate[x,y] 

针对不太普遍的问题的解决方案的示例: 我实际需要做的是计算给定多变量函数的所有导数,直到某个顺序.在这种情况下,我像这样破解我的方式:

expr=Table[D[x^2 y+y^3,{{x,y},k}],{k,0,2}];
unflatten=Module[{f,x,y,a,b,sslot,tt},
  tt=Table[D[f[x,y],{{x,y},k}],{k,0,2}] /. 
    {Derivative[a_,b_][_][__]-> x[a,b], f[__]-> x[0,0]};
  (Evaluate[tt/.MapIndexed[#1->sslot[#2[[1]]]&, 
            Flatten[tt]]/. sslot-> Slot]&) ] 

Out[1]= {x^2 y + y^3, {2 x y, x^2 + 3 y^2}, {{2 y, 2 x}, {2 x, 6 y}}}
Out[2]= {#1, {#2, #3}, {{#4, #5}, {#5, #7}}} &

这有效,但既不优雅也不一般.

编辑:这是aaz提供的解决方案的"工作安全"版本:

makeUnflatten[expr_List]:=Module[{i=1},
    Function@Evaluate@ReplaceAll[
        If[ListQ[#1],Map[#0,#1],i++]&@expr,
        i_Integer-> Slot[i]]]

它有魅力:

In[2]= makeUnflatten[expr]
Out[2]= {#1,{#2,#3},{{#4,#5},{#6,#7}}}&

我在使用NestWhileList的情况下经常达到"最大评估次数".在得到一些古玩结果之后,我仔细研究了如何NestWhileList对指定的最大结果数作出反应:

Table[{nmax,
   Length@NestWhileList[
     (* f: nesting function *) Identity,
     (* initial state *) 1,
     (* test function *) False &,
     (* m: of arguments for test *) 1,
     (* nmax: max # applications of f *) nmax,
     (* n: extra evaluations *) 1]}, {nmax, 0, 2}];
ToString[TableForm[%, 
  TableHeadings -> {None, {"nmax", "output length"}}]]

令人惊讶的部分是nmax=1单挑:这里f应用2次,而对于所有其他值,它只应用一次:

 nmax   output length
 0      2
 1      3
 2      2

"额外评估"似乎是问题的一部分.离开该选项会产生更合理的结果:

Table[{nmax,
  Length@NestWhileList[
    (* f: nesting function *) Identity, …

我正在对以下示例函数中的"渐变极值"进行强力搜索

fv[{x_, y_}] = ((y - (x/4)^2)^2 + 1/(4 (1 + (x - 1)^2)))/2;

这涉及找到以下零

gecond = With[{g = D[fv[{x, y}], {{x, y}}], h = D[fv[{x, y}], {{x, y}, 2}]},
 g.RotationMatrix[Pi/2].h.g == 0]

这Reduce愉快地做对我来说:

geyvals = y /. Cases[List@ToRules@Reduce[gecond, {x, y}], {y -> _}];

geyvals 是三次多项式的三个根,但表达式有点大.

现在我的问题:对于不同的值x,这些根的不同数量是真实的,我想挑选x解决方案分支的位置的值,以便沿着谷底(of fv)拼接梯度极值.在目前的情况下,由于多项式只是立方体,我可以手工完成 - 但我正在寻找一种让Mathematica为我做的简单方法吗？

编辑:澄清:渐变极值的东西只是背景 - 并且是设置难题的简单方法.我对这个问题的具体解决方案不是那么感兴趣,因为在一般的切换方式中找到多项式根的分支点.在下面添加了一个工作方法的答案.

编辑2:因为看起来实际问题比根分支更有趣:rcollyer建议ContourPlot直接使用gecond以获得渐变极值.为了完成这一点,我们需要分离山谷和山脊,这是通过观察垂直于梯度的Hessian的特征值来完成的.检查"valleynes",RegionFunction我们只剩下谷线:

valleycond = With[{
    g = D[fv[{x, y}], {{x, y}}], 
    h = …

内置的实现OptionValue包含了一些魔术

OptionValue[name]相当于 OptionValue[f, name],其中出现f的转换规则的左侧的头部 在哪里OptionValue[name].

有没有人知道如何实现类似的东西Options,即实现一个autoOptions[]可以解决为autoOptions[]出现的转换规则左侧的符号定义的选项？为清楚起见,我正在寻找的是一种方法

Options[foo]={bar->1};
foo[OptionsPattern[]]:=autoOptions[]
foo[]

产量 {bar->1}

最终的目标是在这个问题中做出类似的事情,而不必改变定义的RHS.

我想定义一个符号pt来保持一个点(并最终缓存一些与该点相关的数据):

pt::"usage" = "pt[{x,y}] represents a point at {x,y}";

我希望能够pt尽可能多地使用这些对象作为点,特别是,我希望能够写出来

{a0,a1}+pt[{b0,b1}]

并让它返回pt[{a0+b0,a1+b1}]而不是{a0+pt[{b0,b1}],a1+pt[{b0,b1}]}.我最初的想法是使用:

pt /: Plus[pt[p0_], p1 : {_, _}] = pt[p0 + p1];

但这不起作用(因为Plus是Listable？).有没有办法在没有取消保护的情况下做到这一点Plus？

更新: 正如Leonid所指出的,如果没有全局或本地黑客攻击,这是不可能的Plus,因为Listable在任何*值之前都会考虑该属性.这在评估教程中实际上非常精确地描述.

我与一家大型可再生能源公司的土木工程师一起构建结构设计优化软件。按照我们的设置方式，领域专家将完成他们自己的大部分代码（想想钢部件的结构验证、地球物理响应模型……），我的团队负责整合所有这些并在此基础上构建优化算法.

目前一切都是matlab，因为这是工程师在学校教的。我们开始考虑从头开始重建系统，弹出的一个问题是使用什么语言。

我的优先检查清单是：

• 对于没有 CS 意识的土木工程师来说很容易学习
• 非常适合线性代数计算、大型代数表达式和一般的数值工作
• 现有的具有根查找、基本优化器等功能的数值库——或对 C/Fortran 集成的坚实支持。

到目前为止，我最喜欢的是 Python，我已经看到几个工程师在几周内加快了速度，但我想知道 Julia 是否也符合要求。

您是否有使用 Julia 作为领域专家语言的经验，您会为此目的推荐它吗？

（保持这个特定于 Julia 以使其成为一个可回答的问题——但请随意加入其他语言选项！）