MMA 的不完全指南

凉凉

Make Function by Program

需求: 程序化地生成函数 $\prod_i f(x_i, y_i, \dots, z_i)$

不难注意到:

函数参数可以用 Table 迭代生成:

ClearAll[makeRepeatedArgs];
makeRepeatedArgs[args_List, repeat_Integer] :=
  Table[Symbol[ToString[#] <> ToString[i]] & /@ args, {i, 1, repeat}];

(* Example *)
makeRepeatedArgs[{x, y, z}, 2] (* => {{x1, y1, z1}, {x2, y2, z2}} *)

这里使用 Symbol 函数从字符串构造符号
<> 将两个字符串连接在一起

于是可以不困难地构造出 $f(x_i, y_i, \dots, z_i)$:

f @@@ makeRepeatedArgs[{ x, y, z }, 2] (* => {f[x1, y1, z1], f[x2, y2, z2]} *)

其中:

@@@ 为 MapApply, 等价于 f @@ # & /@ makeRepeatedArgs[{x, y, z}, 2]

综上, 我们有组合函数:

makeFnWithNInputBasedOnFn[compose_, baseFn_, baseFnArgs_List, repeatTimes_] :=
  Module[{args = makeRepeatedArgs[baseFnArgs, repeatTimes]},
   Function @@ { Flatten @ args, compose @@ (baseFn @@@ args)}];

(* Example *)
makeFnWithNInputBasedOnFn[Plus, f, {x, y}, 3] (* => Function[{x1, y1, x2, y2, x3, y3}, f[x1, y1] + f[x2, y2] + f[x3, y3]] *)
makeFnWithNInputBasedOnFn[Times, f, {x, y}, 3] (* => Function[{x1, y1, x2, y2, x3, y3}, f[x1, y1] f[x2, y2] f[x3, y3]] *)

理论说明:

我们构造了一个 $n \times m$ 输入 (arity) 的函数 $F$
$F$ 先将自己得到的输入分配给 baseFn $f$, 将所有 $f$ 的计算结果通过 compose 函数组合在一起作为返回值
该过程可以保留用于其他的程序的构建, 伪代码如下:

(defun split-by-arity (args fns)
  (dolist-collect (fn fns)
    (pop-to-list args (arity fns))))

(defun parallel-combine (combine &rest fns)
  (lambda (&rest args) 
    (apply combine (mapcar #'apply fns (split-by-arity args fns))))

Aluria

Define Functions with arg list, or Sequence

如凉老师上文所述, 我们可以通过 MyFun @@ {arg0, arg1, ..., argn} 的方式调用函数 MyFun[arg0, arg1, ..., argn]
以及通过 Symbol["arg" <> ToString[i]] 的方式从字符串产生变量 argi
于是我们可以向函数中传入一长串的参数, 而不使用列表:

In[1]:= MyFun @@ Table[Symbol["arg" <> ToString[i]], {i, 5}]
Out[1]= MyFun[arg1, arg2, arg3, arg4, arg5]

下面我们还需要定义一个可以处理任意输入的函数, 不然我们只能盯着这个函数干瞪眼, 什么也运行不了.
定义方式很简单, 直接使用 MyFun[args___]:= (参数名后面加三个下划线) 就可以定义一个有参数列表的函数. 如果除了一个可变长度的参数列表, 还需要几个固定参数, 我们还可以通过在args前后指定一些固定参数来实现混合模式如

In[2]:= MyFun1[args___, a_, b_] := {"...ab", {args}, {a, b}}
        MyFun1[args___, a_, b_, c_] := {"...abc", {args}, {a, b, c}}
        MyFun1[1, 2, 3, 4, 5, 6]
        MyFun1[1, 2, 3]
        MyFun1[1, 2]
Out[2]= {"...abc", {1, 2, 3}, {4, 5, 6}}
        {"...abc", {}, {1, 2, 3}}
        {"...ab", {}, {1, 2}}

In[3]:= MyFun1[a_, args___] := {"a...", {args}, {a}}
        MyFun1[a_, args___, b_] := {"a...b", {args}, {a, b}}
        MyFun1[a_, b_, args___] := {"ab...", {args}, {a, b}}
        MyFun1[1, 2, 3, 4, 5, 6]
        MyFun1[1, 2]
        MyFun1[1]
Out[3]= {"a...b", {2, 3, 4, 5}, {1, 6}}
        {"a...b", {}, {1, 2}}
        {"a...", {}, {1}}

上面的例子说明, Mathematica 选择带参数列表的函数时, 优先级顺序从上到下:

排除固定参数数量大于输入参数数量的函数 (输入参数数量不足的函数重载不处理)
尽可能选择不以参数列表开头的函数
除参数列表外, 固定参数最多的函数
若固定参数长度相同, 使用先定义的函数

关于 args 的形式

上面的定义中我都使用了 {args] 的呈现形式, 它会被转为 {arg1, arg2,...} , 这其中是什么过程呢.
我们可以直接使用 MyFun[args___]:=args 这种不使用花括号的形式, 它会产生 Sequence[1, 2, 3] 这种样式的输出. 这说明 args 的类型是 Sequence.
Sequence[expr1,expr2,…] 表示将参数序列自动拼接到函数. 我认为它可以被看出是一种临时数据类型, 只能在函数调用时自动生效, 它会将逗号拼接起来 MyFun[1, Sequence[2, 3, 4], 5] 变成 MyFun[1, 2, 3, 4, 5] 再调用. 当未发生函数调用时, 它如同一个基本类型一样不可分解.
因此, 我们上面使用的 {args} 本质上是进行了一次列表构造函数调用, {args} 等效于 List[args] 等效于 List[Sequence[arg0, arg1, ...]] 等效于 List[arg0, arg1, ...] 最后会获得一个列表 {arg0, arg1, ...}

简单的用法

我们可以定义简单的函数

In[4]:= MyArray[1] := {1}
        MyArray[n_] := {n}~Join~MyArray[n - 1]
        MyReduce[f_, a_] := a
        MyReduce[f_, a_, args___] := f[a, MyReduce[f, args]]
        MyReduce[Plus, Sequence @@ MyArray[10]]
        MyReduce[f, Sequence @@ MyArray[10]]
Out[4]= 55
        f[10, f[9, f[8, f[7, f[6, f[5, f[4, f[3, f[2, 1]]]]]]]]]

或者一些复杂的公式(例如这种多项式推导)

In[5]:= MyPolynomials[n_] := MyReduce @@ {D[(x^#1 - 1)/#1*#2, x] &}~Join~MyArray[n]~Join~{Sin[x]/(x^2 + 1)};
        MyReduce @@ {Hold[D[(x^#1 - 1)/#1*#2, x]] &}~Join~MyArray[4]~Join~{Sin[x]/(x^2 + 1)} (* 打印形式 *)
        Plot[Evaluate[MyPolynomials /@ MyArray[7]], {x, -1, 1}, PlotLegends -> ("MyPolynomials_" <> ToString[#] & /@ MyArray[7])]

Image description

利用函数调用, 整一些好玩的.

比如, 我们可以搞一个混乱的二分递归计算 (因为你也不知道哪些数字被略过了...)

In[6]:= Remove[BinHalf, BinReduce]
        BinHalf[args___] := Partition[{args}, Floor[Length[{args}]/2]]
        (* 将参数列表分成一样大的两半, 如果长度不是 2 的倍数, 忽略最后一个 *)
        BinReduce[f_, a_] := a
        (* 当参数只有一个时, 直接返回该参数 *)
        BinReduce[f_, a_, b_] := f[a, b]
        BinReduce[f_, a_, b_, c_] := f[a, b]
        (* 当恰有两或三个参数时, 返回 f[a, b] *)
        BinReduce[f_, args___] :=  f @@ (BinReduce[f, Sequence @@ #] & /@ BinHalf[args])
        (* 当参数大于两个时, 分成两半, 各自作为参数递归调用, 然后计算两个结果的 f[res1, res2] *)
In[7]:= BinReduce @@ {Plus}~Join~Table[i, {i, 11}]
        (* = (((1+2)+(3+4))!5)+((6+7)+(8+9))!10)!11  其中, 感叹号后的数字是被扔掉的 *)
        BinReduce @@ {NIntegrate[x^(1/(2 + #1)), {x, 0, #2}] &}~Join~Table[i, {i, 23}]
        BinReduce @@ {f}~Join~Table[i, {i, 23}] (* 可以通过这种未定义f的形式打印调用结构 *)
Out[7]= 40
        31.0691
        f[f[f[f[1, 2], f[3, 4]], f[f[6, 7], f[8, 9]]], f[f[f[12, 13], f[14, 15]], f[f[17, 18], f[19, 20]]]]

Aluria

函数的可选参数

最简单的可选参数是为参数设定默认值, 通过在下划线后用冒号标记默认值, 如

In[1]:= MyFun2[a_ : 10, b_, f_ : Plus] := f[a, b]
        MyFun2[1, 2, Times]
        MyFun2[2, Times]
        MyFun2[2]
Out[1]= 2
        2 + Times
        12

可以看到, 当参数长度一致时, 使用输入值代替默认值, 当长度小于输入长度时, 会自动填入最后一个作为默认值, 于是就出现了 MyFun2[2, Times, (*default*)Plus] => 2 + Times 的奇特现象. 当输入参数和required参数数量一致时, 可以自动对齐到这些参数, 也就是 10 + 2 => 12.
如果想要让 Mathematica 自动识别参数类型并对应, 可以强制指定所有参数的类型, 如:

In[2]:= MyFun3[a_Integer : 10, b_Integer, f_Function : Plus] := f[a, b]
        MyFun3[2, Function[{a, b}, a - b]]
Out[2]= 8

这样就可以根据类型自动指定填入位置了.

明确给出可选变量的名称，然后可用变量规则对其赋值

我们在使用很多库函数时, 会用到形如 Attribute -> Value 的控制选项, 我们在自己定义函数时, 也可以设置任意的选单.
通过使用 Option[MyFun] = {Attribute1 -> DefaultValue1, Attribute2 -> DefaultValue2, ...} 来实现自定义可选参数, 并在形参列表中加入一个 OptionsPattern[] 以启用可选, 在函数定义中使用 OptionValue[Attribute] 来获取参数值. 如下

In[3]:= Options[MyFun4] = {Method -> Plus, Reversed -> False};
        (* 定义可选参数 *)
        MyFun4[a_, b_, OptionsPattern[]] := OptionValue[Method] @@ If[OptionValue[Reversed], {b, a}, {a, b}]
        (* 添加可选参数到形参, 获取可选参数的值 *)
In[4]:= MyFun4[a1, a2]
        (* 使用默认参数 *)
        MyFun4[a1, a2, Method -> Divide]
        MyFun4[a1, a2, Reversed -> True, Method -> (#1^#2 &)]
        (* 使用任意可选参数 *)
Out[4]= a1 + a2
        a1 / a2
        a2 ^ a1

更详细的内容可以参见 Wolfram 官方文档

Aluria

函数的文档描述

当我们使用库函数时, 可以看到下拉选单如下:
Image description

它包含了函数的一些调用形式和说明, 如何给我们自己定义的函数设置这样的选单呢? 可以使用 SOPackage 来给自己的函数添加说明, 比如我们定义一个 SumInts 函数, 计算输入的整数的求和:

BeginPackage["SOPackage`"];
Remove[SumInts]
SumInts::usage = "SumInts[] 返回 0.\n" <>
   "SumInts[\!\(\*StyleBox[\"a\", \"TI\"]\)] 返回 \!\(\*StyleBox[\"a\", \"TI\"]\).\n" <>
   "SumInts[\!\(\*StyleBox[\"a\", \"TI\"]\), \!\(\*StyleBox[\"b\", \"TI\"]\), \!\(\*StyleBox[\"\[Ellipsis]\", \"TR\"]\)] 计算 \!\(\*StyleBox[\"a\", \"TI\"]\)+\!\(\*StyleBox[\"b\", \"TI\"]\)+.... 的结果\n";
SumInts::invalidtype = "Arguments should be of type Integer! Should not be `1`.";
Begin["`Private`"];
SumInts[] := 0
SumInts[a_Integer] := a
SumInts[args__Integer] := Total[{args}]
SumInts[invalid___] := (Message[SumInts::invalidtype, ToString[TypeOf[#][[1]] & /@ {invalid}]]; $Failed)
End[];
EndPackage[];

首先, 使用 SOPackage, 在此状态下, 定义函数的用法 ::usage (还可以定义一些别的文本如 ::invalidtype)
然后我们继续定义它的几个调用方式, 无参数, 单参数, 多参数, 最后再定义一个非法输入时的报错消息, 也是一个函数的形式.

我们现在可以在输入 SumI... 时, 弹出窗口中发现 SumInts, 并且可以通过下拉选单找出它的定义. 和库函数的样式基本一致!
Image description

我们定义的这个函数用起来是这样的:

In[2]:= SumInts[]
        SumInts[2]
        SumInts[1, 2, 3, 4]
        SumInts[1, 2, 2.5, 3]
Out[2]= 0
        2
        10
        $Failed

Image description

最后一个报错是我们输入了非整数类型的数, 提示报错消息(也是我们自己定义的输出消息).

函数定义文本的逻辑

关于 SumInts::usage = "..." 这一长串的定义, 看似复杂, 其实比较易于分析的.其中一大部分都被转义字符占据了, 所有看起来很怪. 我们仔细分析可以看到它的原始形式

SumInts[] 返回 0.
SumInts[a] 返回 a.
SumInts[a, b, ...] 计算 a+b+... 的结果.

在此基础上, 我们将变量名用 StyleBox["name", "TI"] 框出来, 然后将其转为 !(* 与 )括起来的形式, 不要忘了对 "!*() 这些符号都加上(伪)转义字符, 就会得到一个变量的最终形式 \!\$\*StyleBox[\"a\", \"TI\"]$ , 用这种奇怪的东西代替所有的变量, 保留其它文本, 即可得到我们一开始的 SumInts::usage = "..." 内的复杂的形式.

如果你不知道某些参数样式的写法是什么样的, 你可以通过 ?库函数名 查看它的定义, 然后将输出的内容复制出来(变成我下面的这个样子), 你会发现它除了多了好多 RowBox 外, 其余的内容和我们的是一致的.

Aluria

Wolfram Mathematica 14.2 新功能：大数据与计算和人工智能的结合

不知不觉中 14.2 已经推出一个月了, 结果我现在才发现. 正好说一下它更新的重要功能吧!

Wolfram Notebook Assistant

此版本引入了 聊天单元格 , 也就是将新推出的 'Wolfram Notebook Assistant' 集成在了单元格内, 通过 ' (单引号) 将单元格转为 AI 助手. 可以根据聊天输出代码, 并插入到单元格中.
AI Assistant

这项功能需要开启 LLM Kit 订阅 ($20 / mo) , 不过可以在设置中使用其它大模型的 api (如 Google 的免费模型, ~~缺点是在生成 MMA 代码上可能比较废物~~)
Other Provider

更新了配色方案 !!! (重要)

老版的配色方案有一种年代感, 在如今的时代已经不再是先进的色彩搭配科学了. 新版本将默认使用的颜色进行了微调, 使它们更鲜活, 有辨识度, 且明度更为均一化.

上面一行的展示的是过去的默认配色, 下面一行是新的配色 ~~这个示例中的代码似乎不能跑~~
Image description
通过两个版本绘制的图线可以明显的看出来, 右侧的更美观, 左侧则显得暗淡

~~当然, 还有一些借鉴了 mma 配色方案的绘图库也需要更新了 (bushi~~, 好在流行的绘图库其实早换成了现代配色方案

我们刚刚注意到，有些奇怪的是，在这些的年里，许多图形和可视化库似乎都在抄袭我们的做法！

Select 选择器

以前的筛选器只能保留符合判定的元素, 但是会丢弃位置等信息, 现在可以将判定条件改为替换规则, 以得到指定信息:
Image description

Mac 图标预览内容

Mac 又赢 ! 目前 macOS 还特有一项功能，即增强了对图标预览（以及快速查看）的支持, 这是独有的特性. (是又怎样!)

Mac Icon

Tabular 高效的表格

TODO: 这是 14.2 更新的重点, 这个表格更易于机器学习等大数据应用的计算, 但具体的内容我不太懂, 期待有心人的经验分享. (还有 Dataset 等数据结构也可以顺便介绍)

凉凉

Aluria 其实都是一些旧版本里都有的功能

Tabular 和 Dataset 可以参考 Multiparadigm Data Science 的官方课程，个人的体验是不如直接读一个vector of vector ( list of list ) 来得快。

Select 之类的函数，在功能上也可以考虑使用 Sow 和 Reap 来自己写，假如对 python 中的 yield 关键词比较熟的话，估计可以很快地上手，例如：

Reap[MapIndexed[If[testFn[#1], Sow[{#1, #2}]]&, data]]

估计里面最有用的是图标预览，毕竟如果有一堆的MMA文件的话，只看文件名还是很难知道自己之前写得是啥。

[Update: 2-28]: 重新写了一个示例:

ClearAll[select];
Options[select] = {"Key" -> Identity, "Collect" -> (#1 &)};
select[testFn_, data_, opts : OptionsPattern[]] :=
  Module[{keyFn, collectFn},
   keyFn = OptionValue["Key"];
   collectFn = Switch[OptionValue["Collect"],
     "Index", (If[Length[#2] > 1, #2, #2[[1]]] &),
     "Value", (#1 &),
     "IndexAndValue", ({If[Length[#2] > 1, #2, #2[[1]]], #1} &),
     _, OptionValue["Collect"]];
   
   Flatten[
    Reap[
      MapIndexed[
       If[testFn[keyFn[#1]], Sow[collectFn[#1, #2], select]] &, data],
       select][[2]],
    1]];

现在的使用方法如下:

select[#[[1]] == 0 &, RandomInteger[{0, 2}, {20, 2}], 
 "Collect" -> "IndexAndValue"] 
(* => {{1, {0, 2}}, {2, {0, 1}}, {3, {0, 0}}, {5, {0, 0}}, {13, {0, 
   1}}, {16, {0, 1}}, {17, {0, 2}}, {19, {0, 0}}, {20, {0, 0}}} *)

select[# == 0 &, RandomInteger[{0, 2}, {20, 2}], 
  "Collect" -> "Index",
  "Key" -> First] 
(* => {0, 4, 0, 5, 8, 0, 0, 18, 19} *)

select[# == 0 &, RandomInteger[{0, 2}, {20, 2}], 
 "Collect" -> (Total[#1]*#2[[1]] &), "Key" -> First]
(* => {0, 12, 0, 0, 26, 0, 17, 18} *)

凉凉

MMA 扫描不全能王

效果如下:

Image description

核心函数说明:

图像的二值化的增强使用了:
- ImageAdjust: 加强对比度 (先变换为 GrayScale)
- Binarize: 二值化
图像的畸变修正使用了:
- FindGeometricTransform: 利用四个角 (手动选择的) 映射回图片的四个角生成图像的矫正函数
- ImagePerspectiveTransformation: 利用前面矫正函数对图像进行矫正

MMA 的可交互的说明:

MMA 的代码中其实有 Dynamic, ClickPane, Location 等一系列可交互的 GUI 元素, 而更重要的是, 和其他所有 MMA 中的元素一样, 这些玩意都是可计算的
享受自己的代码 Notebook 是动态更新, 且完全可交互的体验吧

Notebook 可以见: mma-scanner.nb

祝大家提交文件快乐 (不了一点)

凉凉

TrivialSplitDataset

一个简单的用来分割数据集和测试集的小函数:

ClearAll[TrivialSplitDataset];

(* Default train data ratio is 0.7 *)
TrivialSplitDataset[dataset_] := TrivialSplitDataset[dataset, 0.7]; 
TrivialSplitDataset[dataset_, ratio_] := Module[{
    size = Length[dataset],
    idx  = RandomSample[Range[Length[dataset]]]
  },
  { (* train *)
    dataset[[ idx[[;; Round[size * ratio]] ] ]],
    dataset[[ idx[[Round[size * ratio] + 1;;]] ]]
  }];

一个简单的例子:

data = Join[(# -> "a")& /@ dataA, (# -> "b")& /@ dataB];
{ train, test } = TrivialSplitDataset[data, 0.7];
cls = Classify[train];

凉凉

声之刑 (bushi

是给 “笔记本乐队” 这门公选课折腾的一个好玩的东西: 把图片转换为声音, 用来作为采样. (示波器音乐了属于是)

总的原理比较简单:

给一张图片 (做一下大小, 降噪之类的前处理)
提取边缘
对提取的边缘像素, 找到一条全历遍的路线
转换为 $x(t)$, $y(t)$ 坐标变成音频信号

先看最终的效果吧:

Image description

(请忽略这肮脏的屏幕)

1. 图片的预处理

在 Mathematica 中, 使用 ImageResize 来将图片的大小进行缩放, 例如:

downscale = ImageResize[orig, width]; (* => 将图片等比例缩小为宽度为 `width` 的尺寸 *)

同时, 对于存在噪点的图片, 可以通过 GaussianFilter 来平滑图片 (相当于加上高斯模糊)

2. 提取边缘

在 Mathematica 中, 使用 EdgeDetect 的来踢去图片中元素的边缘 (颜色梯度变化剧烈的地方等等, 可以参考 Method 中的说明).

EdgeDetect[
 ImageResize[GaussianFilter[orig, blur], width], 5]
(* => 返回值是一个二值化的图片, 其中图中白色的部分是边缘像素, 背景为黑色的部分. *)

3. 对边缘像素的提取和全历遍

使用 PixelValuePositions 来获取图片中特定像素的位置, 比如想要得到边缘提取后的二值化的图片中边缘 (白色) 的部分, 就可以使用:

pos = PixelValuePositions[EdgeDetect[
     ImageResize[GaussianFilter[orig, blur], width], 5], 1] // N;
(* => 返回一个列表, 里面的元素是 {x, y} 为值为 1 的像素在图片中的位置 *)

然后, 使用 FindShortestTour 可以找到连接这些像素点位置的最短路径. (当然你也可以自己写)

path = pos[[FindShortestTour[pos][[2]]]];
(* => 得到的 `path` 是一个类似于 `{ {x1, y1}, {x2, y2}, ... }` 的一个点的路径. *)

4. 转换为 $x(t)$, $y(t)$ 并变为音频信号

想象自己是一只小乌龟, 在 path 上爬, 每爬一段路, 就记下自己出发的时候爬了多少, 比如爬了 1m, 记录 {1}, 又爬了一米 {1, 2}, 依次类推.

在 Mathematica 中, 实现这样的累加功能的函数叫做 Accumulate, 比如

Accumulate[{1, 1, 1, 1}] (* => {1, 2, 3, 4} *)

那么如何计算 path 中相邻两个点之间的距离呢? 思路如下:

将 path 中的元素, 相邻配对 (Partition)
计算配对后的元素 (两个点向量) 之间的距离 (EuclideanDistance)

既:

ts = Accumulate[EuclideanDistance @@ # & /@ Partition[path, 2, 1]];

再做一下归一化和从零开始

ts = ts / ts[[-1]];
ts = PrependTo[ts, 0]; (* PrependTo[lst, elem] -> { elem, ... lst } *)

至于如何求函数插值, 就简单介绍了:

xs = path[[All, 1]]/width; (* 表示 axis 1 全部取, axis 2 只取第一个, 既 {{xi, yi}} -> {xi} *)
ys = path[[All, 2]]/width; (* 同上, 得到 {{xi, yi}} -> {yi} *)

(* Transpose 将 {{t1, t2, ... }, {x1, x2, ... }} -> {{t1, x1}, {t2, x2}, ... } *)
(* Interpolation 用于返回一个插值函数 *)
xf = Interpolation[Transpose[{ts, xs}]]; 
yf = Interpolation[Transpose[{ts, ys}]];

于是使用 ListPlay 产生音频信号:

sound = Module[{period = 500},
   ListPlay[{
     Table[yf[Mod[t, period]/period // N], {t, 50000}],
     Table[xf[Mod[t, period]/period // N], {t, 50000}]
     },
    SampleDepth -> 16,
    SampleRate -> 2048]];

用 EmitSound 来播放音频, 或是用 Export["...", Sound[sound]] 来保存输出.

Appendix

本文所用的 Notebook 可以在 img2wav.nb 这个链接中体验.

其实感觉这个还可以玩得更花, 比如和视频进行结合, 或者和摄像头进行结合, 用人的舞蹈来播放声音. 然后加入滤波, 比如用生成的信号的频谱做陷波或是带通, 实现对基础声音信号的控制.

Aluria

自定义 Paclet 程序包 (预告)(大概无限延期)

我们可以将一大堆常用的带单位的物理量存起来, 使用时只要 << Phy` 即可一键导入. 这样就可以省去很多与 Quantity 与 UnitConvert 以及 Entity["PhysicalConstant", name] 或 AstronomicalData[name, property] 的斗争
Image description

然而, 问题是, 我们希望能在输入时, 有一个很好的自动补全体验, 而不是全部显示 (Phy`) 这个包名.
Image description

通过 ::usage 可以定义其函数说明文本, 但无法在自动补全时生效. 因此, 我们需要自定义 Paclet 程序包, 将功能做出系统函数的样子, 就可以自定义许多功能啦!

但是 Paclet 是很高级的功能, 我需要学学怎么弄...... 因此, 就先放个预告在这 ! ~~将来我学明白了再把坑填了~~
程序包概述: (https://reference.wolfram.com/language/tutorial/Paclets.html.zh)

P.S. 如果谁本来就会, 或者花了半分钟看了下学会了, 欢迎抢先发布, 供我学习.

凉凉

Aluria 嘻嘻, 如果只是物理学单位的话, 可以用:

<< Units`

对于简单的函数或者简单的包, 不考虑过于麻烦的依赖关系和过于复杂的外部库, 那么可以直接使用 Wolfram Language Package (.wl). 不过坏处就是用 Mathematica 的编辑器来写代码有点坐牢, ~~我之后会想办法写一个 mathematica-mode 的 Emacs 插件~~.

可以参考: Particles.wl, FunctionalMMA.wl.

例:

Get["https://gist.githubusercontent.com/li-yiyang/e2a9654db0e926d1f9fe35af0e05f705/raw/c859219741ecdc27321a7a38a88ab0de4b2c7a7d/Particles.wl"];

Get["https://gist.githubusercontent.com/li-yiyang/8b2a1a5112d817a17a28709df87d1777/raw/e9737f7d24fd71fe865bccfe4eefe633996d6ee2/FunctionalMMA.wl"];

FnAndWhy[ChargeConservationQ, LeptonNumberConservationQ] /@ {
  "pi0" -> { "e+", "e-" },
  "mu-" -> { "e-", "anti-nu_e", "nu_mu", "gamma" },
  { "e-", "mu-" } -> { "e-", "mu-" },
  "tau-" -> {"e-", "omega"},
  "p" -> { "e+", "gamma" },
  "n" -> { "p", "e-", "nu_e", "gamma" },
  "tau+" -> { "mu+", "nu_mu", "anti-nu_tau" },
  "n" -> { "e-", "pi+" }
} // TableForm

Aluria

非常不幸, 程序包好写, 但功能不常有 Aluria

关于为什么自定义提示的功能不能实现

我原以为下图中类似 Integrate (积分) 的说明文字是可以自定义的, 只不过 普通的MMA代码 不能直接定义(没有对应函数), 需要通过程序包注入等方式(是我本以为). 因此我才希望学习 Paclet 的用法, 并定义自定义提示.

如果可以显示提示, 我们就能在输入两个字母的简称的物理量或单位时, 可以快速了解它是什么, 防止错误的输入成 其它简写相似的物理量.

但我找了一晚上也没有找到设置方法, 翻了一些参考范例, 问了各种AI, 都是设置 ::usage 或写成函数文档, 而没有说明怎么设置它.

...... 直到, 我在测试不同的方法时, 将默认语言切成英文, 然后我震惊了: f**英文界面竟没有后面的括号! 合着括号里的压根不是提示, 而是中文名.
Example in En
顿时, 思路就打开了: 不就是设置函数的别名吗, 肯定有的吧.

结果是没有. 包括系统自带的一些可导入的库, 如果你测试一下, 会发现它也都是显示包名.
Image description

另外一种方法则指向脚注, 我不能在输入时设置补全, 输入完总能给我显示个提示, 让我确认没打成别的的符号吧.
Image description
图中的角标叫做 Code Captions , 是 Mathematica 11 专门为其它语言用户做的系统. 我在网上除了一个帖子, (没几个回复, 总之就一个结论用户界面的事, 计算系统管不了. 然后就不了了之了)之外, 我再没有找到更多关于设置这个的内容了, Wolfram 也一直没有跟进(可能已经停止更新维护了吧).

大概也许是 Wolfram 公司觉得大家都想打又臭又长的函数名, 没有人有简写的需求, 熟练使用自家产品的人英语也都很好, 完全不存在记不住外部包里的函数名和作用吧.

总之, 改不了, 没救了, 只能输入完后鼠标移上去展开函数说明来检查了

一个简要的 Paclet 指(南)北

这也是多半我近未来不会更新 Paclet 教程的原因了. 就在此简单说一下怎么用(学)吧:

Wolfram 似乎正在尝试推广它的 Paclet, 你可以创建自定义 Wolfram 函数, 链接 C/Java 等语言的代码, 创建指南, 技术文档和函数文档, 并打包到不同平台, 发布到互联网上和别人分享.
遗憾的是, 为什么你正好有一个 MMA 库, 而我正好有一模一样的需求? 大多数情况下, 我的需求和你有微妙的差别, 我顶多复制你一些核心代码, 但框架还是我的, 而不是选择导入一个臃肿的库. MMA 不是 专业的 ~~(讽刺意味)~~ 数据处理软件, 需要专门分析数据的人一般会统一用一些独特~~(奇怪)~~的专业软件, 并有着自己的一套生态. 他们可能不太会编程, 更不了解 MMA.
对 MMA 高度依赖的人, 大多也都倾向于自己写代码, 而不是 ~~vibe coding~~(最近好像又出了个新词, 忘了叫啥了, 搞 AI 的就是会造词哈, 这都多少新词新概念了! ).
废话有点多, 总之就是: 虽然你想让我们都用, 但你系统不甚成熟, 生态约等于没有, 我们为什么要用? 要知道 Rust 从出生到现在已经19年了, 且前6年无人问津, 2012年才发布了第一个公开版本. 近两年是因为对底层安全性重视的日益提升才逐渐被推上台面的.

又: 抱歉搞错了, 还是有一些别人发布的包的, 有些很有意思. 是我之前不该用 PacletSites[] 获取社区库的链接.

言归正传, 如何上手 Paclet 呢
Paclet 其实就是附带了参考文档的, 可以一键安装的Package库, 没啥特别的地方, 我发现官方文档介绍的更详细...

我之前写的
Mathematica提供了一个自己的构建工具, ~~并标注 (Under devleopment)~~, 你只需要新建一个 程序包资源, 然后就会有简答的提示引导你创建一个项目. 最后会打开一个如下的界面
Image description
如图, 左侧是你刚创建的新的模板 Paclet(我命名为 LearnPaclet), 右侧会出现文档工具. 这个模板展示了一个最小的原型, 包括一个 PacletInfo.wl 定义项目结构, 和 Kernel 下的文件定义你的函数....... ~~不写了, 有官方文档我还费这劲 ?~~
Image description

一些可参考的官方文档

你可以先快速阅读程序包概述了解程序包的结构, 再跟随另一份 Get Started 简单操作一下.
我们假定你此前已经掌握了 Package 的用法, 那么学习完 Get Started , ~~下面我们要自己构建一个复杂功能的程序包并发布了~~
还可以参考 Wolfram Research 官方Github库提供的两年前的代码 https://github.com/orgs/WolframResearch/repositories?q=paclet
前几个是 CICD 的教程(用于 Github Actions自动构建测试), 后面还提供了若干正确/错误示例, 因为是完整的程序包, 你可以根据 readme 指令下载到你的电脑上好好研读.

当然, 你也可以下载别人发布的程序包, 然后利用Mathematica本身提供的构建工具加载它(我没试过, 也许可以), 这也是一种很好的学习方式(虽然不知道你能学到啥).

P.S. AI 傻傻分不清 1.10 和 1.9 的原因找到了

这确实需要 1.10 > 1.9 才对

凉凉

Aluria 如果想要得到补全提示的话, 在 Mathematica 的编辑器中中最接近的功能估计是:

Image description

但是这需要你动一下鼠标, 默认的行为并不是默认展开的, 很不优雅. 尽管通过 ::usage 的方法可以实现对不同的 pattern match 的结果进行匹配, 但是仍然不是一个优雅的结果.

但是不管怎么说, 这都应该是 Wolfram Notebook 的锅, 为什么不换一个编辑器呢? 比如通过 LSP (LSPServer, 或者 lsp-wl, 虽然感觉都没怎么在更新就是了) 在 VSCode 或者其他支持 LSP 的编辑器中编写 Mathematica 代码呢?

凉凉

凉凉在写代码的时候发现了 ::usage 的规则:

fn::usage = "fn[x] 使用说明需要写在一行里面. 

fn[x, y] 另一个调用形式需要这样写. ";

这样就能够保证在使用函数的时候弹出补全提示和对应的补全文档.

至于 Code Caption ... 还是没有啥办法.

注: Mathematica 的 function tool calling 做的挺不错的, 可以实现 Notebook 的环境的感知. 但是 LLM 对 Mathematica 的语料支持也太差了. 不知道 Wolfram 自己的 AI 会不会好一些 (学校什么时候买那个

凉凉

KernelTeXForm

Kernel 中的 LaTeX 的输入因为 Markdown 语法的解析有限度导致会因为 ^ 和 _ 而出错, 之前给了一个 JS 的注入的修改 [1], 现在可以用 Mathematica 来写一个自动把公式/表达式拷贝为 Kernel 支持的 LaTeX:

ClearAll[KernelTeXForm];
SetAttributes[KernelTeXForm, HoldFirst];
Options[KernelTeXForm] = {Hold -> True, CopyToClipboard -> True};
KernelTeXForm::usage = 
  "Convert ``expr`` as ucaskernel supported LaTeX form. 
Return values are string of LaTeX expression. 

Parameters: 
``expr``: Mathematica expressions

The optional flags are: 
+ Hold: (default True)
  + if set to False, the ``expr`` will be evaluated
  + if set to True, the ``expr`` will be hold
  + if set to Equal, the ``expr`` will be hold == evaluated
  + if set to LeftArrow, the ``expr`` will be hold -> evaluated
  + fallback to True
+ CopyToClipboard: if set to non-False, the result LaTeX string will \
be copied into clipboard, (default True)
";
KernelTeXForm[expr_, OptionsPattern[]] := Module[{
    tex = StringReplace[
      ToString@TeXForm[
        Switch[OptionValue[Hold],
         False, expr,
         True, HoldForm[expr],
         Equal, HoldForm[expr] == expr,
         LeftArrow, HoldForm[expr] -> expr,
         _, HoldForm[expr]]],
      {
       "^" -> "\\^",
       "_" -> "\\_",
       "\\{" -> "\\\\{",
       "\\}" -> "\\\\}"
       }]
    },
   If[OptionValue[CopyToClipboard], CopyToClipboard[tex]];
   tex];

解释:

SetAttributes: 设置符号的属性, 比如在这里设置的属性为 HoldFirst, 即第一个输入的参数是不被执行的, 输入的表达式就是表达式本身.
这是为了支持 Hold -> True 和 Hold -> False 的操作. 即当参数 Hold 为非否的时候, 就会用 HoldForm 的方式来保持表达式为输入的状态而不会计算 [2]
StringReplace: 核心的代码就是文本替换: 将 ^ 和 _ 替换为 \^ 和 \_.

实际的效果

KernelTeXForm[Limit[Sum[1/n, {n, 1, max}] - Log[max], max -> Infinity], Hold -> True]

$$\underset{\max \to \infty }{\text{lim}}\left(\sum _{n=1}^{\max } \frac{1}{n}-\log (\max )\right)$$

KernelTeXForm[Sum[1/n^2, {n, 2, Infinity, 2}], Hold -> False]

$$\frac{\pi ^2}{24}$$

KernelTeXForm[Sum[1/n^2, {n, 2, Infinity, 2}], Hold -> Equal]

$$\text{Sum}\left[\frac{1}{n^2},\{n,2,\infty ,2\}\right]=\frac{\pi ^2}{24}$$

Citation

[1] LaTeX 输入的 Patch, 凉凉 https://ucaskernel.com/d/178/24

[2] 计算顺序, 凉凉 https://ucaskernel.com/d/679-mma/25

凉凉

村通网, MMA 也能上论坛了 (并不能)

引言

我, 在论坛里面写 Mathematica 代码, 反复从 Notebook 里面拷贝东西, 虽然有 KernelTeXForm, 但是还是很麻烦 (懒), 所以这是一个简单的小脚本来让 Mathematica 代码可以一键生成适合 Kernel 的 Markdown.

思路

在 Mathematica 里面 Notebook 也是一个可以运算的对象. 于是我们只需要构造简单的 Notebook Style -> Markdown 映射规则集, 并递归地历遍 Cell (Mathematica Notebook 的最小元素) 即可实现 Notebook 到 Markdown 的转换.

以下是具体的一些技术细节:

Structure of Cell

使用 Cells 可以获得对应 Notebook (默认是当前的 Notebook) 中的所有的 Cell 元素:

Cells[]

{CellObject[Title],CellObject[Section],CellObject[Text],CellObject[Section],CellObject[Text],CellObject[Text],CellObject[Subsection],CellObject[Text],CellObject[Input],CellObject[...],CellObject[Text],CellObject[Text],CellObject[Item],CellObject[Input],CellObject[Output],CellObject[Item],CellObject[Input],CellObject[Output],CellObject[Text],CellObject[Input],CellObject[Output],CellObject[Text],CellObject[Text],CellObject[Input],CellObject[Output],CellObject[Text],CellObject[Subsection],CellObject[Text],CellObject[Input],CellObject[Text],CellObject[Input],CellObject[Text],CellObject[Input],CellObject[Text],CellObject[Input],CellObject[Section],CellObject[Text]}

注: 实际上得到的是 CellObject, 一个到对应 Cell 的链接. 因为实际上 Cell 的值是会发生变化的, 所以通过链接而不是直接获取值的方式来保证同步.

Cell 可以看作是 Cell[content, style]:

读取 Cell 的样式类型 (类似 HTML 的 tag):

ClearAll[CellStyleName];
CellStyleName[cell_CellObject]:=CurrentValue[cell,"CellStyleName"];
CellStyleName[cell_Cell]:=cell[[2]];

CellStyleName[First@Cells[]]

"Title"

读取 Cell 中的元素 (类似 HTML 的 childrens):

ClearAll[CellContent];
CellContent[cell_CellObject]:=CellContent[NotebookRead[cell]];
CellContent[cell_Cell]:=cell[[1]];

CellContent[First@Cells[]]

"村通网, MMA 也能上论坛了 (并不能)"

于是问题就看起来变得非常简单了? 比如可以定义一个样式转换规则表:

ClearAll[KernelMDRule];
KernelMDRule[style_String] := KernelMDRule[style,#]&;
KernelMDRule[any_String,raw_]:=KernelMDRule[any,ToString[InputForm[raw]]];
KernelMDRule[any_String,raw_String]:=raw;
KernelMDRule["Title",raw_String]:="# "<>raw<>"\n";

KernelMDRule[CellStyleName[cell]][CellContent[cell]]/.cell->First@Cells[]

"# 村通网, MMA 也能上论坛了 (并不能)\n"

那么 MD 转换的大厦已经建立, 剩下的就只是缝缝补补了吗?

其实只要把测试的对象增加一些, 就会发现事情好像并没有那么简单:

KernelMDRule[CellStyleName[cell]][CellContent[cell]]/.cell->First@Cells[CellStyle->"Text"]

"TextData[{\"我, 在论坛里面写 Mathematica 代码, 反复从 Notebook 里面拷贝东西, 虽然有 \", ButtonBox[\"KernelTeXForm\", BaseStyle -> \"Hyperlink\", ButtonData -> {URL[\"https://gist.github.com/li-yiyang/3f5d0ce2ef6767e8194dde1286dd434a\"], None}, ButtonNote -> \"https://gist.github.com/li-yiyang/3f5d0ce2ef6767e8194dde1286dd434a\"], \", 但是还是很麻烦 (懒), 所以这是一个简单的小脚本来让 Mathematica 代码可以一键生成适合 Kernel 的 Markdown. \"}]"

嗯...

Rule-based Pattern Transform

不过如果仔细观察, 会发现得到的仍然是可以处理的 Mathematica 表达式, 使用, 于是就可以根据不同的规则进行匹配:

KernelMDString[Cell[content_, style_, ignore___]] := 
  KernelMDForm[style][KernelMDString[content]];

KernelMDString[any_] := ToString[InputForm[any]];
KernelMDString[str_String] := str;

KernelMDString[TextData[texts_]] := StringJoin[KernelMDString/@texts, " "];

(* ... *)

在这里可以充分利用 Mathematica 的模式匹配功能来定义函数, 这样可以让匹配 Cell 表达式的工作变得非常简单容易实现, 比如:

KernelMDString[TemplateBox[data_, "TeXAssistantTemplate"]] := 
  "$"<>EscapeKernelTeX[data["input"]]<>"$";

或者:

KernelMDString[BoxData[boxes_List]] := StringJoin[KernelMDString/@boxes, " "];
KernelMDString[BoxData[box_]] := KernelMDString[box];

于是现在的问题变成了根据不同类型的 Mathematica 表达式编写转换规则然后生成 Markdown 代码.

User Interface

于是你只需要在 Notebook 中运行:

Notebook2KernelMD[]

即可将 Notebook 以 Markdown 格式粘贴到剪贴板中. (还没想好更好的交互), 总之目前能跑. 具体的代码可以参考 KernelTeXForm.wl.

后话

本文使用 Notebook2KernelMD 转换得到

那么为什么不用 AI 呢...

« 上一页