Yi's Blog

LLM and (Math) Education

2026-06-16T00:00:00Z

Abstract: This article empirically asserts a lower bound of human effort required to learn a mathematical (or any other abstraction-heavy subject) regardless of LLM.

TODO

三年LLM：过去和未来

2026-03-27T00:00:00Z

OpenAI的ChatGPT于2022年年底发布。得益于境外手机号接码渠道，我第一时间就用上并惊叹于人工智能的突破。一转眼，LLM在过去的三年里已无可辩驳地渗透至千家万户。

一小段历史

Transformer模型最早于2017年由谷歌提出，核心思路是通过Self-Attention机制显式地表达词语之间语义联系^[1]。OpenAI在2018年首次发布GPT-1模型，将架构简化为Decoder-only的Autoregressive词语预测^[2]。自此，LLM的总体架构尘埃落定，后续的GPT-2、GPT-3等皆在此基础上扩展模型大小和数据集的规模。不仅局限于文字，Transformer在视觉领域表现也很好^[3]。为何大模型能够涌现出强大的能力仍不得而知。Anthropic于2021年在一个极度简化的模型中发现了Induction Heads结构^[4]，但如同生物学第一次发现红细胞，我们离真正理解LLM的工作原理相差甚远。

我的经历

朴素文本生成与搜索引擎

记忆中，初代GPT-3.5尚且幻觉频发，其输出往往需人工核查事实。那些本身不具严肃意义、亦无需严格验证的作文任务，最宜交由GPT处理，这也算是回归了其文本续写的本质功能。

GPT在联网后实用性显著提升。比起传统搜索引擎，GPT的优势在于：其一，迅速地总结和提炼信息。谷歌在搜索引擎中嵌入了AI Overview，实际体验确实更加方便；其二，也是最重要的——解决了搜索引擎“不知道搜什么关键字”的问题。比如我想知道“3D游戏中角色自适应动画如何实现”，LLM会直接告诉我我应该搜索“Inverse Kinematics”。这是传统基于关键词的搜索引擎难以企及的。

LLM即老师

LLM在教学方面潜力巨大。教学任务与LLM高度契合：不仅模型本身具备大量先验的初等知识（训练集中反复），教材也能提供充足的上下文，学生的问题大多也是小规模良定义的，只需要LLM重新解释一遍即可。

常规问答必不多言。拿到Claude Code后，我试着将哈佛的The Annotated Transformer和Karpathy的nanoGPT投喂进Claude Code，令其对照两份材料，撰写一份从零构建GPT的教程。第一版完成度尚可，但是作为教材未能妥善处理读者的阅读顺序和知识背景。我顺序阅读并学习，遇见觉得不通顺的地方就给予明确指示如何重写，最终两天完成一份在我认为质量不错的教程。可见虽LLM仍需人类引导，效率提升非常显著。

若使用不当，LLM也会带来意料之中的麻烦——倘若只知复制粘贴，知识终究未曾过脑^[5]。這種成績，使人汗顏！（发自我的手机）

多模态和Agent

Agent概念虽被外界炒作得天花乱坠，思路其实非常朴素：在prompt中教LLM以固定的格式引用外部工具（如读取文件、爬取网页等），确定性代码结果加入LLM上下文。Agent刚被引入时看上去能大幅度提升LLM智力，究其根本还是提供了正确充分的上下文，与人类手动提供上下文（如将一个框架的文档粘贴进对话框）本质没有区别，Agent只是自动化了这个过程。程序员是Agent的最大受益者，因其需频繁与代码仓库交互。LLM代码能力已被多次探讨过，同样的，在缺乏显式引导下LLM喜欢写毫无设计且充斥着不必要冗余的代码。有软工水平的人可以通过LLM大幅提升效率，反之则大概率误入歧途。

多模态能力很有用，但相较于文字稍不稳定一些。我试图用Claude Code将我糟糕的手写数学笔记转化为整齐编排的\(\LaTeX\)文档。效果相当好，文字几无人工干预需要，TikZ画图有大概50%成功率，大多需要人工调整。我注意到有些输出数学上正确，却和我原有笔记不一致。合理猜测LLM只是从图片大致概括得我的笔记内容，对于一些细节都采用了先验知识猜测和补全。

未来展望

AI存在泡沫吗？

LLM爆发后，两类产品尤为惹人生厌。其一，大公司为取悦短视股东，生硬地在产品中植入AI大粪，如Windows自带Copilot，臭不可闻。再者是一些小团队或者个人写的灾难级产品，哪怕是猪，站在风口上也能飞起来，荣誉提名OpenClaw。两者都证明了搞金融和做新闻的人非蠢即坏。

不仅如此，即使对有真才实学的AI公司（Google、OpenAI、Anthropic、阿里等，好歹是干实事的），盈利仍非常困难，OpenAI至今都在烧投资人的本金。高杠杆加上总体的经济停滞/下行趋势并不是一个好兆头。考虑到AI仍是有用的（不像前阵子Web3和Meta纯粹的骗局），我更倾向于AI会像互联网泡沫一样，大浪淘沙留下有价值的产品，只是中间泡沫破裂不知会软着陆还是硬着陆。

LLM真的理解吗？

现有LLM智能已足够好，但和人类智能还有本质上的区别^[6]。从端到端的角度看，LLM只是概率拟合，无可避免的会给似是而非的东西，上下文对输出的影响非常显著。早期Prompt Engineering就意图解决这个问题，尽管本身噱头大于技术。一部分，LLM听风是雨，对Prompt内容深信不疑。这点在自动化流程中比较灾难，如一个联网的LLM Agent在搜得网页中获取了错误信息，它会以看上去非常可信的方式总结和呈现。上下文也有更微妙的影响方式。LLM会尽力模仿上下文，后果是若代码里有隐藏的bug或不良的架构，LLM会继续沿用错误的方式，将问题越堆得积重难返。

简而言之：LLM的输出与输入强相关，且很多知识仍需后验提供。人类提供正确上下文和对大方向的“品味”反而更加的重要。

大家都会失业吗？

据上述，LLM与人类显然仍具不少差距。更恰当的类比为，LLM是脑力劳动领域的纺织机——取代trivial的脑力劳动，如水文字。自然的，若之后有全球范围的失业潮和经济下行，LLM充其量也只是引火线而已：总生产力提升了，为何生活水平反而下降？那必然是分配问题，大可不必因LLM感到存在危机。

有趣的副作用是，LLM祛魅了如教师、科学家、程序员等职业的神秘性。（并不是说这些职业不值得被尊重。且不必沮丧：AI能做是因为我们（在训练数据里）反复做过太多次，是时候休息一下了）新工具揭露了这些职业大部分工作内容同样的trivial，在现有技术下易于自动化。坐办公室的白领再也没有理由看不起工厂的蓝领，大家本质都是讨辛苦饭的牛马打工人。

LLM有瓶颈吗？

个人的猜测是LLM将会遇到瓶颈，原因是训练数据的劣化。互联网上愈发的充斥着LLM洗稿低质量内容，之后的LLM训练要么不引入新的数据，要么会逐渐退化为蒸馏前代LLM。但蒸馏只是面向小模型的特化技巧，用劣化的数据训练模型只能得到劣化的结果^[7]。模型本身的架构上限尚不明确，毕竟人类连Transformer为何涌现出如此多的智能还不清楚。

我还有一些闲杂的思绪：近来有很多试图拓展LLM上下文的研究。但仔细审视人类的记忆和思维，短时工作记忆并没有那么高，更重要的能力是抽象和直觉——一个抽象中（如一个数学公理）下层细节对我是透明（transparent）的，我只需要知道条件和结果之间的关系，并一定程度依靠直觉判断何时调用哪种抽象来解决问题。

Color Recreation from First Principles

2025-12-07T00:00:00Z

Abstract: This article provides a gentle derivation showing the existence of a simple, measurable linear relationship between the LMS color model as in human vision and RAW camera sensor data and the RGB values as in displays and jpg/png/etc. images.

Real world colors are continuous spectra, such as the sunlight spectrum. We can describe it as a continuous function \(J(\lambda)\) where \(\lambda\) is the wavelength and \(J(\lambda)\) is the intensity at that wavelength.

Human eyes have three types of color receptors (cone cells) that are sensitive to different ranges of wavelengths, named L, M, S for long, medium and short wavelengths respectively, loosely corresponding to red, green and blue colors. Represent the responsiveness of these three types of cells as functions \(s(\lambda)\) at wavelength \(\lambda\), then the perceived intensity of a type of cone cell can be expressed as (take L as an example):

\[L = \int_{-\infty}^\infty J(\lambda) s_L(\lambda) d\lambda\]

and same goes for M and S cells. As long as \(\begin{bmatrix} L & M & S \end{bmatrix}\) are the same, the perception will be the same. It is significant not only because it is the basis of human color vision, but also because camera sensors, utilizing Bayer filter or similar technologies, mimic this mechanism to capture colors.

It can be noted that for the same perceived color (fixed \(\begin{bmatrix} L_0 & M_0 & S_0 \end{bmatrix}\)), there are infinite possible spectra \(J(\lambda)\) that can produce the same perception. This is called metamerism which enables modern displays to reproduce or approximate colors with a spectra different from the real world ones. It is also, in fact, true that modern displays (such as LCD, OLED, etc.) work by exploiting this method, namely, they have three kinds of primary color lights red, green and blue that have artificial but fixed spectra, and the ability to adjust the intensity of each primary color. Namely, let \(r\), \(g\) and \(b\) be the intensities of the RGB lights respectively (which happens to be the RGB values we usually read in digital images) and let \(J_R(\lambda)\), \(J_G(\lambda)\) and \(J_B(\lambda)\) be the fixed, artificial spectra of the RGB lights, the overall spectrum emitted by the display can be expressed as:

\[J_\text{display}(\lambda) = r J_R(\lambda) + g J_G(\lambda) + b J_B(\lambda)\]

Consider one kind of cone cell, say L, to recreate \(L_0\), we have:

\begin{align*} L_0 &= \int_{-\infty}^\infty J_\text{display}(\lambda) s_L(\lambda) d\lambda \\ L_0 &= \int_{-\infty}^\infty \left( r J_R(\lambda) + g J_G(\lambda) + b J_B(\lambda) \right) s_L(\lambda) d\lambda \\ L_0 &= r \int_{-\infty}^\infty J_R(\lambda) s_L(\lambda) d\lambda + g \int_{-\infty}^\infty J_G(\lambda) s_L(\lambda) d\lambda + b \int_{-\infty}^\infty J_B(\lambda) s_L(\lambda) d\lambda \end{align*}

Notice how \(L_0\) is a linear combination of \(\int_{-\infty}^\infty J_R(\lambda) s_L(\lambda) d\lambda\), \(\int_{-\infty}^\infty J_G(\lambda) s_L(\lambda) d\lambda\) and \(\int_{-\infty}^\infty J_B(\lambda) s_L(\lambda) d\lambda\) with coefficients \(r\), \(g\) and \(b\). These integrals are named as sensitivities of the display primaries to the L cone cell, denoted as \(S_{L,R}\), \(S_{L,G}\) and \(S_{L,B}\) respectively so that \(L = r S_{L,R} + g S_{L,G} + b S_{L,B}\). Thus, we can represent the color perception for L, M and S cone cells caused by RGB light intensities in matrix form regarding the sensitivities \(\mathbf{S}\):

\[\begin{bmatrix} L \\ M \\ S \end{bmatrix} = \begin{bmatrix} S_{L,R} & S_{L,G} & S_{L,B} \\ S_{M,R} & S_{M,G} & S_{M,B} \\ S_{S,R} & S_{S,G} & S_{S,B} \end{bmatrix} \begin{bmatrix} r \\ g \\ b \end{bmatrix}\]

so that to recreate color perceptions, we only need to calculate:

\[\begin{bmatrix} r \\ g \\ b \end{bmatrix} = \mathbf{S}^{-1} \begin{bmatrix} L \\ M \\ S \end{bmatrix}\]

which is trivial now. And sometimes, the values of \(r\), \(g\) and \(b\) may exceed the display's capability (for example, negative values or values larger than the maximum intensity), in which case we need to go creative with color management techniques such as tone mapping and gamut mapping to find the best visually-pleasing color that the display can produce.

《死亡搁浅》玩后感及艺术评论思考

2025-11-15T00:00:00Z

今日通关了《死亡搁浅》，不得不提，在游玩时我本以为这是后疫情作品在反思疫情隔离，没想到实际上游戏刚好于19年发售，真是巧合。

《死亡搁浅》最独到的地方，在于实现了作者表达、剧情和游戏性的统一。小岛秀夫的主要创作意图是体现人与人之间互帮互助的重要性，游戏的剧情便是Sam作为“送货人”将后末日世界中支离破碎的美国重新连接。创新点在于，游戏的核心玩法——送货——直接服务于这一主题。它无时无刻不在用“送货的艰辛”与“其他玩家留下的建筑所带来的帮助”形成鲜明对比，点赞系统也让玩家在帮助他人时获得反馈，大多数玩家都有类似的情感经验（举例^[1]）。

《死亡搁浅》的评价不出意料地出现分歧，主要集中在游戏性不强，玩法单一。^[2]^[3]Sylvester在他的《游戏设计》中提出，游戏是“体验生成引擎”^[4]，也就是用游戏独有的交互性（机制、系统）生成特定的体验（experience）。《死亡搁浅》的游戏性争议来源于玩家并没有期待它的交互（游戏性）部分被刻意地设计为无聊、困难和恐怖以衬托其主题。但若是以体验传递的角度分析，玩家成功感受到了情感——小岛秀夫所希望玩家体验到的“艰苦”、“孤独”和“互助”——这便是游戏设计成功的体现。传统观点认为游戏必须“好玩”，但好玩也是一种情感体验，具体可以细分为成就感（沙盒、竞技常见）、爽感（精美画面、大场面等（爆米花电影中也频繁使用，是惯常的懒惰套路））等。传统游戏评论期望游戏可以且仅可以在“交互”中带来“好玩”，却忽略了其它的排列组合，也就是动态交互（游戏机制）和传统艺术（过场动画、美术、剧情）可以表达传统艺术的表达，如作者的喜怒哀乐、对社会问题的反思。

此评价框架可以被进一步泛化：游戏与传统文娱的区别在于，传统文娱产品（文学、电影、绘画等）运用叙事和/或视听手段，而游戏则运用交互手段，但他们的目标都为将情感体验传递给受众。评价一段文学、音乐、电影、游戏“好”，所指应为作者成功使读者体验到了他设计过的情感。人与人交流信息会需要证明一些命题，证明本身定然是理性（logos）或者感性（pathos）二选一，晓之以理便是论文，动之以情便是艺术。

2025/12/07追加：本文混淆了“艺术评价”和“艺术家创作评价”，前者不是良定义的/尚存争议。

《星际拓荒》玩后感

2025-09-02T00:00:00Z

以下内容包含对Outer Wilds剧情的剧透。

Outer Wilds是一部以探索的方式，献给探索者的赞歌。

自伊始以来，人类祖先天然对远处充满好奇。对“那边”的好奇驱使我们走出非洲大陆，在地球上开枝散叶。Outer Wilds直指人类天然的好奇，游戏没有目标，只有开始天文台的些许指引，剩下的道路需要玩家顺着一个个未知现象自己走出。一开始，玩家急于知道面具是什么；然后地面上零零星星的遗迹吸引着玩家的兴趣；而Nomai文物上字里行间透出的零碎信息又将玩家带入更深的地方。“我发现了！”这一古老的欣喜不断驱动着玩家，给予各种不同的经历。

Outer Wilds中，没有传统意义上的成长：玩家不会获得新的道具，取得更高的数值。每一个循环结束，改变的只有玩家掌握的知识。但神奇之处就在于一次次的循环里，这些知识真切地带来了改变。玩家渐渐理解了过去，通晓宇宙的规律。玩家需要的不是一个数值，一个钥匙，只是一段信息。所有或简单或复杂，乃至可以帮助宇宙脱离循环的结构，从第一次在篝火睁开双眼以来，就一直躺在那里，等待着玩家用一系列特定的动作将其发掘。

很多游戏都给谜题套上叙事的外皮，而Outer Wilds则用谜题叙事。游戏的高潮发生于破碎的故事串联在一起，描绘出一部悲壮的史诗。我最为震撼的经历在轨道探测器追踪站：电脑显示出Nomai文明为了绕过超新星只爆发一次（显而易见）的限制，利用时间循环保留数据；通过反复随机地探测9M+次，遍历了整个星系的空间，找到了Eye of the Universe。每次循环的开始，主角睁开眼睛就可以看到探测器被随机地射入深空，其实就是Nomai在几十万年后仍在苦苦寻找答案。在若干关键节点，玩家都可以感受到所谓Aha Moment。因所有线索都由玩家经历万难拼凑出，这些“突然醒悟”带来了无比强烈的冲击力。

游戏结局给这部史诗画上了圆满而富有哲理的句号：我握着高级跃迁核心——Nomai的科技结晶——冒着结束太阳系的风险，重启了废弃的飞船。Final Voyage主旋律与循环结束音乐一样，却多了额外的频率，讲述着Nomai持续几十万年却被意外停止的狂奔，最后一块拼图被玩家合上，也暗示了“这次有所不同”。Eye幻化出博物馆和树林，在其中旧宇宙走向热寂；Nomai骸骨前一刻还在望向星空，一眨眼的功夫飞船就向未知奔去；量子态的探索者们围在一起，用最后一曲勾勒出新的宇宙。一代代探索者的坚持与牺牲才托举着现代文明在巨人肩膀上到达了如此的高度。

Outer Wilds有且只有探索这一个玩法，但这就够了，因探索是人类最古老最宝贵的本能。

Review on ASUS Zenbook S14 Laptop (LNL) with Linux

2025-05-02T00:00:00Z

I am trying to pick a laptop that is as close to Macbook Mx Airs as possible - light, low power consumption and long battery life, with the only exception of not being an Apple device^[1]^[2]^[3] - for the upcoming coursework. As for the chip itself, the closest I can get is Intel's Lunar Lake CPUs whose successor unfortunatelly Intel will not develop due to their management incompetentness. Among all LNL laptops, it seems that ASUS Zenbook S14 is of top quality, has a reasonable price and does not repulse Linux like Lenovo's counterpart Yoga^[4].

According to a GitHub repo (more on this repo later), LNL is well-supported on Linux 6.12.5+, which is not a problem on my OpenSUSE TW. It mostly works out of the box, has nice secure boot and TPM2.0 support, with the need to install sof-firmware for the audio to work. Surprisingly, the NPU card has its driver intel_vpu loaded. I've yet to test it, which Intel promotes as having 47 TOPS; I was really tempted to try out the NPU in the pre-installed Windows but gave up when copilot forced me to login my Microsoft Account.

The battery life is as good as it promoted. As the writing of this post, which happens to be my expected workflow with this laptop, I am working on my Emacs with some trivial packages and the built-in Mozilla Firefox with about 20 pages loaded (no heavy media); in the background there is a syncthing daemon running, a Mozilla Thunderbird, a Libreoffice Writer and an Akregator; my desktop is KDE and has no special customization. Under a battery of 70%, screen brightness 20% and power profile set to powersave, the estimated battery life reaches 8 hours. Expect a charger-free day when your job only involves light office-work or light development. The laptop is also quite pleasantly chilly, whose CPU sits under 40C in the room temperature of 25C. One can barely feel any heat on the chasis.

It does have some quirks, though, with the first being KDE seemingly not recognizing my graphics card. It kept telling me it's using llvmpipe while actually utilizing the GPU. The information is fixed by installing intel-vaapi-driver. The second counter-intuitive point is that intel_gpu_top doesn't work on such xe GPUs. It's an easy fix as nvtop is a nice replacement to it.

The last issue was not trivial and took me three days to find the cause. The laptop occasionally slowed down until I reboot and cpupower frequency-info showed me that CPU frequency policy was randomly throttled to only 400MHz max and changing the governer had zero help. I suspected on BD_PROCHOT, even a faulty sensor in my laptop, but rdmsr showed no signs of error. I asked for help on OpenSUSE forum, Tom's Hardware forum and even Reddit. The issue is eventually clarified by a dude met in the previously mentioned repo. It seems that powertop has some iffy interaction with the firmware and randomly throttles max frequency even if I only use the monitor part of it. The issue has never occured after stopping using powertop.

That's all for now, and I'm overall pretty satisfied with this machine and consider it a pretty close approximation of the Macbook M1 Air.

LLM will NEVER be AGI: The Proof

2024-08-20T00:00:00Z

The proof is trivial with a little help of a necessary condition of complexity theories. All LLM runs under the complexity of \(O(n)\), where \(n\) is the length of the output.

Suppose LLM is AGI, then it is able to solve any problem that a human can solve. Consider the following problem:

Given a string \(s\) of length \(n\), determine whether \(s\) is a palindrome. Answer "Y" if it is and "N" if it isn't.

Apprently, a human can solve this problem, and it is easy to prove that the problem must be solved in at least \(O(n)\) time.

Since the output of this problem is of a constant length, LLM must solve this problem in \(O(1)\) time, which is a contradiction. Thus LLM cannot solve a problem that a human can solve. Therefore LLM is not AGI. \(\blacksquare\)

EDIT: Chain of Thoughts breaks the proof, allowing LLM to solve the problem in arbitrary time.

On Programming Languages

2024-05-01T00:00:00Z

While it is true that most of the time while developing software, we just pick either C++, Java, Python, etc. and start coding simply because A these languages are already well-established and have a lot of libraries and B we are already familiar with them. Yet new languages still emerge from time to time, such as Rust, TypeScript, and Julia, which are happily adopted (and hated) by developers. But few have thought about what are we actually creating.

By computation, you mean...

Computers, by definition, compute. And we utilize programming languages to instruct the computer to compute. However, we actually have no idea what computing means. You may simply argue against this stating that "Well I know Turing Machine!" Indeed, Turing machine is a great computational model. Along with it also comes the \(\lambda\)-calculus (also my blog post), \(\mu\)-recursive functions, etc. Surprisingly, these intuitively vastly different models are actually equivalent in terms of computability, which is known as Turing equivalent. We also have created problems that are undecidable and uncomputable. But what makes Turing machine / \(\lambda\)-calculus special? Why do these (fundamentally identical) computational models decide what is computable? Back to the question, what is computation? It turns out that we have no idea. The Turing-Church Conjecture states that these computational models are identical because they all capture the essence of computation. But what is the essence of computation? It's never formally defined. (You can't define it by stating that Turing machine means computation, after all the concept "essence of computation" is there because we have so many coincidentally equivalent models and that may imply some deeper meaning of being computable.) Maybe there exist some other models that have different computational power (in terms of computationability) that we have never thought of. Maybe some problems are computable but not by Turing machine. We simply don't know.

That's enough metaphysics nonsense. Why would I care?

The fact is while these models are the same in terms of Math, they still differ in terms of mind and what's more, performance. Functional guys trying to lure you into their nasty world of \(\lambda\)-calculus because most of the time functional stuff is more expressive and concise. But you may fight back saying their code going Stack Overflow because of using lazy evaluation wrong is hilarious and absurd. Modern languages no longer base themselves on Turing machine or \(\lambda\)-calculus but RAM-access machines simply because the model approximates real-world computers. (It would be great if LISP machines still exist.) While it holds that a Turing machine emulates a RAM-access machine, it does so in polynomial time, which is stopping you from coding like this.

But I don't code using `JMP` and `LOAD`/`STORE` either!

Indeed. Our poor little brains (except theirs) have already been proven to not have the ability to code in assembly, and Haskell isn't just about \(\lambda\)-calculus. Abstraction comes into place to free our tiny RAM. By abstraction, I would like to elaborate on it as "working on partial information". For example, I know that whichever input \(f\) always gives the same output if the input is the same simply because \(f\) is a function. In the C language, we define functions to hide away actual procedures working solely on the underlying meaning. Good languages free our brains and less-en the information we are working on. It's abstraction all the way down.

And by creating languages you mean...

Abstractions are great, but (in terms of software engineering) when it comes to abstraction there are no underlying metaphysics implications (thank god) nor formal definitions. It's about doing whatever the cuss a developer would like to. In Golang you have interfaces, in C you have functions, in C++ you have classes, in Haskell, you have functions all over the place. For the expression problem, some choose to dispatch methods vertically while some do it horizontally. Types are not primitives but abstractions too. Everything is just bits and bytes, interpreting an IEEE double as a short won't cause any fundamental troubles, and sometimes we do it intentionally. Types present because most of the time we want to keep it consistent. All of these show that abstraction is largely ruled by relativism. That's where LISP comes into place. It, again I'd like to elaborate as, abstracts abstraction by using macros. Consider the following program:

(define-syntax unless
  (syntax-rules ()
    ((_ condition body ...)
     (if (not condition) (begin body ...)))))

(unless (= x 0)
  (display "x is not zero")
  (newline))

It defines a macro that expands to

(if (not (= x 0))
    (begin
      (display "x is not zero")
      (newline)))

at compile time. One thing that is truly great about LISP macros is that you can do arbitrary computation at compile time. For example, for C++ guys who love classes, there exists CLOS (Common Lisp Object System) that is written in LISP itself, without going into your indeed-turing-complete-but-all-cluttered-together-only-god-can-understand-CPP-templating-nonsense.

Don't you play tricks on me

Indeed, a compiler, by its definition, does calculations at compile time. What LISP provides can be seen as a well-designed, modular compiler framework. It blurs the line between a language and the tech behind a language. I think we can happily conclude that by creating languages, we are creating new ways of abstracting data and procedures that fit our needs. PLs will just keep evolving. It's not a proven fact, it's some kind of art created by humans.

GPT fond of LISP

And it also turns out that even GPT is fond of LISP, so you'd better check it out.

Simulating Gravitational Lensing

2023-09-03T00:00:00Z

Ever wondered why the black hole in Interstellar looks like two rings intersecting each other orthogonally? It's because of the gravitational lensing effect.

Physics behind this phenomenon comes from Einstein's general relativity and is quite complicated. (If you are interested, this Quora post has an in-depth walk-through.) However, There is an important clue that light travels in the same way as a non-zero mass particle does. This means that we can simulate the gravitational lensing effect by simulating the trajectory of a particle in a gravitational field since we don't have to worry about the speed of light, etc. in this simplified model.

The model starts like ray tracing. We start with a screen and a virtual camera. The screen is divided into a grid of pixels. For each pixel, we shoot a virtual particle from the camera to the pixel. The position of the camera becomes the initial position of the particle. The velocity of the particle is set to be the unit vector pointing from the camera to the pixel.

The particle is then calculated regarding the gravitational field, that is:

\[\vec{F} = m\vec{a} = \sum_{M, \vec{d} \in \text{mass-points}} \frac{GMm}{\vec{d}^2}\hat{d}\](1)

Where \(d\) is the distance between the particle and the mass point, \(M\) is the mass of the mass point, \(m\) is the virtual mass of the particle, \(G\) is the gravitational constant, and \(\hat{d}\) is the unit vector pointing from the mass point to the particle.

Since \(m\) cancels out (the mass of an object doesn't affect its acceleration in a gravitational field), we can simplify (1) to:

\[\vec{a} = \frac{\mathrm{d}^2 \vec{x}}{\mathrm{d}t^2} = \sum_{M, \vec{d} \in \text{mass-points}} \frac{GM}{\vec{d}^2}\hat{d}\]

An analytical solution might exist but it is too complicated to be useful when it comes to calculate the collision of the trajectory and the visible objects.

Instead, we can use a numerical method to solve this equation. The movement of the particle can be calculated in a discrete manner. For each time step \(\Delta t\), the model checks if the segment \(x(t) \rightarrow x(t+\Delta t)\) bumps into any visible object. If so, the model stops the particle at the point of collision and paints the pixel with the color of the object.

Although the method seems dumb, it actually completes calculation in reasonable time. You can find my implementation glens at GitHub. The software is developed in Rust and outputs images in PPM format.

With a bit of scripting (or meta-scripting?) even videos can be generated.

In the video above, an invisible black hole passes two visible stars. The gravitational lensing effect is clearly visible. Stars behind the black hole are distorted and duplicated. For example, in this image:

Blackhole passes stars

The yellow star is actually behind the black hole. However, due to the gravitational lensing effect, the light is redirected into a ring (known as the Einstein ring) around the black hole. The left blue star is a duplicated version of the original one. Light is bent by the black hole and redirected to the actual position of the star, passing the back of the black hole.

The video below shows two black holes with accretion disk dancing around each other. The gravitational lensing effect is even more obvious.

Visiting NASA Goddard Space Flight Center

2023-08-01T00:00:00Z

I have visited NASA Goddard Space Flight Center on August 1st, 2023. It's a great experience to see the real spacecrafts and the people behind them. What's more exciting is that photos are allowed in the visitor center, so I can share some of them here.

Dustless Clean Room

This is the dustless clean room where the spacecrafts are assembled. The air is filtered to remove dust and other particles. The temperature and humidity are also controlled to prevent corrosion and other problems.

The big frame structure in the left upper corner is a model for engineers to see if parts fit the final spacecraft.

Indicator Light

Engineers Assembling

Another important part of the space center is the testing facilities.

The spacecrafts are tested in a vacuum chamber to simulate the space environment. The chamber can be cooled or heated to extreme temperatures. It can also simulate radiation and other space hazards.

Testing Can

Testing Chamber

The spacecrafts are also tested in a vibration table to simulate the launch as shown in the mirror.

Vibration Table

My 2023 Swift Student Challenge

2023-05-17T00:00:00Z

Ah, Swift Student Challenge, the once in a year competition from our dearest Apple.

From the very first moment I have decided to make some educational apps since I have seen an accepted submission which teaches the user about asymmetric cryptography. In fact, I had several inspirations on my list:

Combine AR technology to show a 4D object projected onto a 3D space.
Introduce signal processing from why some people sing better than others.
Introduce the Iterated Function System to show that Math can be fun and beautiful.

And at last I chose the third one since it's the most approachable one and time is quite limited to me. It's also because I have made a small app QIFS about this concept. (However the code base is messy and unmaintained.)

IFS

In short, IFS is a set of functions \(\lbrace f_i: X \mapsto X \mid i \in [1,n] \rbrace, n \subset \mathbb{N}\) under a metric space \(X\). The image is get by repeating the following process infinite times:

\[S \gets \bigcup_{i=1}^{n} \bigcup_{s \in S} f_i(s)\]

In most cases, we want to keep things simple, so we choose \(X = \mathbb{R}^2\) and \(f_i, \forall i\) to be affine transformations. The most famous example is the Sierpinski triangle, which is generated by the following three functions:

\begin{align*} & f_1(x,y) = (\frac{x}{2}, \frac{y}{2}) \\ & f_2(x,y) = (\frac{x}{2} + \frac{1}{2}, \frac{y}{2}) \\ & f_3(x,y) = (\frac{x}{2} + \frac{1}{4}, \frac{y}{2} + \frac{\sqrt{3}}{4}) \end{align*}

More examples can be found here. Thanks to the chaos game algorithm, the IFS can be easily plotted by keep choosing a random function from the set and apply it to the current point. The barebone of the app is thus finished...

class IFSSystem {
    var position: CGPoint = CGPoint(x: 0.5, y: 0.5) // Some random point
    var transforms: [CGAffineTransform]

    init(_ t: [CGAffineTransform]) {
        transforms = t
    }

    func chaosGameStep() -> CGPoint {
        let selected = Int.random(in: 0..<transforms.count)
        position = position.applying(transforms[selected])
        return position
    }
}

... in actually 3 lines of code (Thanks to CoreGraphics or I'll have to add 10 more lines). Now the only thing left is to make it interactive and intuitive. The key part is to visualize the transforms \(f\). Since we know it's an affine transformation, which can be decomposed into a linear transformation and a translation. We can represent it using a parallelogram where one point represents the translation and the other two points represent the linear transformation. That is, for transformation:

\[f(x,y) = \begin{bmatrix} a & b \\ c & d \end{bmatrix} \begin{bmatrix} x \\ y \end{bmatrix} + \begin{bmatrix} e \\ f \end{bmatrix}\]

The four points are \(A(e,f)\), \(B(a+e,c+f)\), \(C(b+e,d+f)\) and \(D(a+b+e,c+d+f)\). In fact, \(\overrightarrow{AB}\) and \(\overrightarrow{AC}\) represents the two transformed \(\hat{i}\) and \(\hat{j}\).

Having these in mind, we can now visualize the IFS system easily.

func iterate(_ transforms: [CGAffineTransform]) {
    var newTs: [CGAffineTransform] = []
    for t in transforms {
        for t2 in transforms {
            newTs.append(
                t2.concatenating(t)
            )
        }
    }
    return newTs
}

And the only thing left is to implement the UI now.

For the construction part I made the parallellogram draggable. Although users can't control the coordinates precisely (which is not necessary), they can still get a sense of how the transformation works.

Construction

For the visualization part, I made an "Iterate" buttom which will call the iterate function above and plot the new parallelograms.

Visualization 0

Visualization 1

Visualization 2

And it can goes on and on until the device runs out of memory.

In the end for the rendering part, I utilized the chaosGameStep function above and plot the points on the screen. To make the image look better I added random colors to each transform function.

Render

The final image can also be zoomed in so that users can see the self-similarity of the fractal.

Zoom in

And that's it! The app is finished. You can find the source code here.

Results

I submitted the app on the last day of the submission period. It was a bit rushed but I think it's still acceptable. And I got the result on the 9th of May. Unfortunately, I didn't get accepted. I think the main reason is that the app is not very "useful". In the cryptography example, asymmetrical cryptography is used in everyday life and is indeed quite important. However, IFS is just a mathematical concept and is not very useful in real life. Despite the result, I still think it's a good experience and I have learned a lot from it. I will definitely try again next year.

Kerbalhopper: PID explained with KSP

2023-04-30T00:00:00Z

Introduction

The Starship test flight by SpaceX is incredibly thrilling! True to your old habits, you've determined to recreate it in Kerbal Space Program. Perhaps it would be wise to begin by constructing a Starhopper replica. After all, you just need to take off and maintain your altitude for a few seconds, right?

The rocket design is straightforward. All you need to do is affix a Dart engine beneath a Rockomax Fuel Tank, integrate landing legs, a probe core and battery together, and you're ready to launch.

KerbalHopper Craft

After fiddling aroud with this craft, you decide to automate this go-to-an-altitude-and-hold-it process. Being a programmer, automation comes naturally to you.

Thanks to the community, a mod called krpc exposes the underlying API of KSP. You can use it to write a script that controls your craft.

The math way

You want to figure this problem out by turing it into an optimization problem. In short, you need to figure out a function \(f: \mathbb{R} \mapsto [0,1], \text{time} \mapsto \text{throttle}\). According to Newton's law:

\[F = ma\]

while the corresponding \(F\), \(m\) and \(a\) are:

\begin{align*} & F = f(t) + mg + \text{drag}(\frac{\mathrm{d}x}{\mathrm{d}t}) \\ & m = \text{wet mass} - \text{fuel consumption}(\int_{0}^{t} f(u) \mathrm{d}u) \\ & a = \frac{\mathrm{d}^2 x}{\mathrm{d}t^2} \end{align*}

And you want at some time \(t_0\):

\begin{align*} & x = h \\ & \frac{\mathrm{d}x}{\mathrm{d}t} = 0 \end{align*}

Ok it seems that things are getting out of hand. Too many variables are affecting each other. You wonder if there is a better way to do this. And it turns out that this is an engineering question: You don't have to find an optimal solution, you just need to find a good enough one.

The engineering way

Time to be creative!

A pretty straightforward way is to let your throttle be proportional to how far you still need to fly before reaching height \(h\).

Let \(E = h - x\), then your \(f\) can be written into:

\[f = KE\]

And you implement this into Python:

import krpc, time

HEIGHT = 200
K = 0.01 # Some constant?
DELTA_T = 0.01


class Controller:
    def __init__(
        self,
        target: float,
        k: float
    ) -> None:
        self.target = target
        self.k = k

    def step(self, current: float, dt: float) -> float:
        # f = KE
        error = self.target - current
        return error * self.k


def main():
    conn = krpc.connect(name="KerbalHopper Controller")
    vessel = conn.space_center.active_vessel
    controller = Controller(
        target=HEIGHT,
        k=K,
    )

    input("Press enter to launch.")
    vessel.control.activate_next_stage()

    while True:
        flight = vessel.flight()
        alt = flight.surface_altitude
        throttle = controller.step(
            current=alt,
            dt=DELTA_T
        )
        vessel.control.throttle = throttle
        print(
            "Altitude: {alt} Throttle: {throttle}".format(
                alt=alt,
                throttle=throttle,
            )
        )
        time.sleep(DELTA_T)

if __name__ == "__main__":
    main()

After a few trials, you find that the craft isn't going anywhere no matter what \(K\) is. Ship keeps oscillating dramatically between \(30\) and \(230\). This method need some workarounds.

Recall what you do when you're trying to maintain the altitude: When you're approaching the height, you try not to let the ship fly too fast.

How do you describe not going too fast while approaching? Yes that's \(-\frac{\mathrm{d}x}{\mathrm{d}t} = \frac{\mathrm{d}E}{\mathrm{d}t}\). Again, you take the value, snap a content \(K_d\) onto it and hope this works.

\[f = K_p E + K_d \frac{\mathrm{d}E}{\mathrm{d}t}\]

And you implement this in Python:

import krpc, time

HEIGHT = 200
KP = 0.02
KD = 0.008 # Some more constant!
DELTA_T = 0.01


class Controller:
    def __init__(self, target: float, kp: float, kd: float) -> None:
        self.target = target
        self.kp = kp
        self.kd = kd
        self.last_error = 0

    def step(self, current: float, dt: float) -> float:
        error = self.target - current

        p = error * self.kp

        # discrete version of dE
        dE = (error - self.last_error) / dt
        d = self.kd * dE

        self.last_error = error
        return p + d


def main():
    conn = krpc.connect(name="KerbalHopper Controller")
    vessel = conn.space_center.active_vessel
    controller = Controller(
        target=HEIGHT,
        kp=KP,
        kd=KD,
    )
    # ...snip

The method is working! The ship now tends to keep its throttle in an appropriate range. \(K_p\) is controlling how fast you want to reach \(h\) and \(K_d\) is controlling how ease reaching \(h\).

Floating at alt 180

However, the ship stuck at somewhere beneath \(200\). You pick up a pen and try to figure out where it reaches the balance, that is \(\text{thrust}=\text{gravity}\):

\begin{align*} f = mg \\ K_p (h-x) + 0 = mg \\ x = -\frac{mg}{K_p} + h \end{align*}

\(h-x = \frac{mg}{K_p}\), which means that the rocket can never reach target height \(h\)!

You have tried to taking \(E\) and \(E'\) into account however none of them helped. What will you do if you observe your ship is not going to reach \(h\)? As time goes by you will gradually become impatient and throttle up. How to measure yourself losing patience? Yes that's \(\int E \mathrm{d}t\)! As usual, you snap a constant \(K_i\) onto it and hope this works.

\[f = K_p E + K_d \frac{\mathrm{d}E}{\mathrm{d}t} + K_i \int^{t}_{0} E \mathrm{d}u\]

And you implement this in Python:

import krpc, time

HEIGHT = 200
KP = 0.02
KI = 0.001
KD = 0.01
DELTA_T = 0.01


class Controller:
    def __init__(
            self,
            target: float,
            kp: float,
            kd: float,
            ki: float
    ) -> None:
        self.target = target
        self.kp = kp
        self.kd = kd
        self.ki = ki
        self.last_error = 0
        self.integral = 0

    def step(self, current: float, dt: float) -> float:
        error = self.target - current

        p = error * self.kp

        dE = (error - self.last_error) / dt
        d = self.kd * dE

        i = self.ki * self.integral

        self.last_error = error
        self.integral += error * dt

        return p + d + i


def main():
    conn = krpc.connect(name="KerbalHopper Controller")
    vessel = conn.space_center.active_vessel
    controller = Controller(
        target=HEIGHT,
        kp=KP,
        kd=KD,
        ki=KI,
    )

    input("Press enter to launch.")
    vessel.control.activate_next_stage()

    while True:
        flight = vessel.flight()
        alt = flight.surface_altitude
        throttle = controller.step(current=alt, dt=DELTA_T)
        vessel.control.throttle = throttle
        print(
            "Altitude: {alt} Throttle: {throttle}".format(
                alt=alt,
                throttle=throttle,
            )
        )
        time.sleep(DELTA_T)


if __name__ == "__main__":
    main()

Floating at alt 200

And there you go! Your hard work has paid off. The ship is now floating at \(200\) meters above the ground. You can now sit back and relax until it runs out of fuel!

Conclusion

It's such a weird method with some nice symmetrical properties. \(K_p E\) controls this moment, \(K_d \frac{\mathrm{d}E}{\mathrm{d}t}\) predicts the future and \(K_i \int E \mathrm{d}t\) reflects the past. You are fascinated by how easy and effective this 28-line of code is - it made no assumptions with the system you are interacting. The same laws still make sense on Duna and Eve. You decide to name it PID, taking the first letter of Proposal, Integral and Derivative.

...and you find out frustratingly that it was invented in 1940s. There's even a Wikipedia page for it.

Source code of this article can be found here.

An Introduction to Lambda Calculus

2023-02-09T00:00:00Z

Introduction

Who doesn't like simplicity! To me simplicity is not only a preference but a belief. I always has a werid feeling that only the simple things last.

In the world of calculation, the most simple thing might be a Turing machine, a mathematical model of computation that is capable of implementing any algorithm using a tape, a head, a state and instructions. However besides the tape stuff, another extremely simple mathematical model was also invented at roughly the same time. Don't be surprised when you see its name: Lambda calculus (\(\lambda\)-calculus). It consists a set of notation system and reduction rules. Compared with the Turing machine, it is more "math-y" than "computer-y".

Notation System

I've used it! you may think. Correct! Lambda calculus is the fundamental building blocks in Functional Programming language. It's extremely likely to meet it in most modern programming languages, for example Python, JavaScript and even OO languages such as C++ and Java. Let's take a look at an example:

\[\lambda x . x\]

A little bit confused huh? Let's write it in Python:

lambda x: x

Much more intuitive now! It simply outputs whatever is inputed.

It can be applied to another expression by writing the expresstion after the function:

\[(\lambda x.x) y\]

And it resolves into \(y\). We'll cover the details later.

This is one of the so-called lambda expressions. There are three kinds of lambda expressions:

Name: just a trivial name representing anything. e.g. \(x\)
Abstraction: \(\lambda param . body\), where \(param\) is a name and body is the substitution rule. e.g. \(\lambda xy.xyx\) (which is in infact an abbreviation of \(\lambda x.\lambda y.xyx\))
Application: a list of expressions. e.g. \((\lambda xz.xxz)ij\)

You can check out the formal definition at Wikipedia. It's totally fine to treat the lambda expression notation system as a minimal programming language whose keywords are only \(.\) (dot) and \(\lambda\) (lambda). There are also optional quotes in lambda expressions. Without quotes we phrase the expression from left to right.

In an abstraction, or function, there're two types of variables: bounded and free variables. A variable is bounded means it appears in the "params" section and free is the opposite. This is similar to local and global variables. For example in \((\lambda x.xy)\), \(x\) is bounded and \(y\) is free.

Reduction Rules

The reduction rules have horrible names: \(\alpha\)-conversion and \(\beta\)-reduction.

\(\alpha\)-conversion is very stupid: a name can be written in another if its bounded. For exmaple \(\lambda x.xy\) is equivalent to \(\lambda z.zy\).

\(\beta\)-reduction is also a dumb operation: it means substituting using the rules defined in the body of the function. For example, resolve the application:

\[(\lambda x.x) y = [y/x] x = y\]

The \([a/b]\) mark simply means substituting \(b\) with \(a\). Now try a more complex one:

\begin{align*} & (\lambda xy.xyx)ab \\ & = (((\lambda x . \lambda y . xyx)) a ) b \\ & = (\boxed{[a/x]} (\lambda y . \boxed{x} y \boxed{x})) b \\ & = (\lambda y . \boxed{a} y \boxed{a}) b \\ & = \boxed{[b/y]} a \boxed{y} a = a \boxed{b} a \end{align*}

Still confused? Try it out in Python.

(lambda x: (lambda y: x + y + x))('a')('b')
# => 'aba'

Of course no one will write such horrible program. Let's try naming it (however few real lambda functions are given names):

def l1(x):
    def l2(y):
        return x + y + x
    return l2

l('a')
# => <function __main__.l1.<locals>.l2(y)>
l('a')('b')
# => 'b'

Note that for l2 (the inner lambda function) variable \(x\) is free. However for the whole expression it's bounded.

Arithmetic

Time to do some calculations! Let's start by defining \(0\).

\[\lambda sz.z\]

And yes! \(0\) is a function! Try it out:

\[(\lambda sz.z) a = (\lambda s . (\lambda z.z)) a = [a/s](\lambda z.z) = \lambda z.z\]

The input \(a\) is thrown away, leaving only \(\lambda z.z\) which is called a "identity function". There're also many other ways defining \(0\), but there are good reasons using this. Just keep going by defining \(1, 2, ...\) and all the natural numbers.

Successor

One approach to this is to define a "successor operation", which basically returns the number that is one greater than the input. It goes as follows (yes we are giving it a name since it's quite common):

\[\mathbf{S} = \lambda wyx.y(wyx)\]

Actually I prefer the form of:

\[\mathbf{S} = \lambda w . (\lambda yx.y(wyx))\]

Apply our \(0\) to it:

\begin{align*} & \mathbf{S} 0 \\ & = \mathbf{S} (\lambda sz.z) \\ & = (\lambda wyx.y(wyx))(\lambda sz.z) \\ & = \boxed{[\lambda sz.z / w]} (\lambda yx.y(\boxed{w} y x)) \\ & = \lambda yx.y(\boxed{(\lambda sz.z)} yx) \\ & = \lambda yx.y((\lambda z.z) x) \\ & = \lambda yx.y(x) = \lambda sz.s(z) = 1 \end{align*}

Another really weird function huh? Compared with \(0\), \(z\) is quoted by \(s\) in \(1\) and that's how we encode out natural numbers. Recall that this is not the only way to encode natural numbers, but we find defining calculations for it much eaiser (covered later). Rewrite it in Python if you are still confused:

def zero(s):
    return lambda z: z


def S(w):
    # Define function "inner" for the sake of less nasty lambda nesting.
    def inner(y):
        # We know that w is a function, hence we're going to call it instead of join (+) it.
        return lambda x: y + w(y)(x)
    return inner

Since \(w\) is always in the form of \(\lambda sz.s(s(s( ... (z))))\), by calling \(w\) using \((wyx)\) we "unwrap" the head of \(w\) and "de-function" it. The \(y\) at the head of \(\boxed{y}(wyx)\) adds another layer of nesting.

Now you have an idea what it is doing. Now try to get \(2\):

\begin{align*} & \mathbf{S} 1 = (\lambda \boxed{w}yx.y(\boxed{w}yx))\boxed{(\lambda yx.y(x))} \\ & = \lambda yx.y(\boxed{(\lambda sz.s(z))}yx) \\ & = \lambda yx.y(y(x)) \\ & = \lambda sz.s(s(z)) = 2 \end{align*}

Note that we have renamed the variables for clarity.

Each time \(\mathbf{S}\) is applied, the nesting goes deeper. We can even test it in Python!

zero('s')('z')
# => 'z'
one = S(zero)
one('s')('z')
# => 'sz'
two = S(one)
two('s')('z')
# => 'ssz'

Addition

Addition can also be achieved by the successor function. Write a number before \(\mathbf{S}\):

\begin{align*} & 2\mathbf{S} \\ & = (\lambda s . \lambda z . s (s(z))) \mathbf{S} \\ & = \lambda z.\mathbf{S}(\mathbf{S}(z)) \end{align*}

It's resolved into a function with \(2\) successor operations! Now it's trivial to calculate \(2+3\) using it:

\[2\mathbf{S}3 = \mathbf{S}\mathbf{S}3 = \mathbf{S}4 = 5\]

Numbers defined in a recursive way make this operation a breeze.

Multiplication

Multiplication is also made easy by the defination of numbers.

\[\mathbf{M} = \lambda xyz.x(yz)\]

It "unwraps" \(y\) and apply the repeated sequence to \(x\), say \(2 \times 3\):

\begin{align*} & (\mathbf{M}2)3 = (\lambda xyz.x(yz)2)3 \\ & = \lambda z.2(3z) \\ & = \lambda z.(\lambda uw . u(u(w)))((\lambda ij.i(i(i(j))))z) \\ & = \lambda z.(\lambda uw . u(u(w)))(\lambda j.z(z(z(j)))) \\ & = \lambda z.(\lambda w . \boxed{\lambda j.z(z(z(j)))}(\boxed{\lambda j.z(z(z(j)))}(w))) \\ & = \lambda z.(\lambda w . z(z(z(z(z(z(w))))))) \\ & = \lambda s. \lambda z . s(s(s(s(s(s(z)))))) = 6 \\ \end{align*}

Whoa so many brackets! But trust me it's doing the right thing.

匀速圆周运动加速度的推导

2022-07-12T00:00:00Z

人教版的物理必修二中跳过了对匀速圆周运动的向心力的推导，用精确的实验表明，向心力的大小可以表示为...或...这一套模糊的说辞蒙混过关了。这篇文章旨在帮助高中生理解公式的来历。

考虑一个物体在圆周上运动。我们记圆周运动的半径为\(r\)，线速率为\(v\)，角速度为\(\omega\)，\(0\)和\(t\)时刻的线速度为\(\vec{v_{i}}\)和\(\vec{v_{j}}\)，经过的角度为\(\alpha\)，易知\(\lvert \vec{v_{i}} \rvert = \lvert \vec{v_{j}} \rvert = v\)，且都与圆相切。

这一段时间中的平均加速度为

\[\vec{a} = \frac{\vec{v_{j}}-\vec{v_{i}}}{t}\]

当\(t\rightarrow 0\)时候\(\vec{a}\)为瞬时加速度。

可以看到在式子中我们要将两个向量相减。我们可以通过平移把两个向量尾尾相接便于计算。由切线的性质，可以发现平移后的\(\vec{v_{i}'}\)和\(\vec{v_{j}'}\)夹角\(\alpha_{1}=\alpha\)。

我们可以在图片中画出\(\overrightarrow{\triangle v}=\vec{v_{j}'}-\vec{v_{i}'}\)。不熟悉向量减法的可以用\(\overrightarrow{\triangle v}+\vec{v_{i}'}=\vec{v_{j}'}\)思考，即\(\vec{v_{i}'}\)加上一个向量等于\(\vec{v_{j}'}\)。

接下来一步至关重要。由于\(AB=AC\)，\(DE=DF\)，\(\alpha_{1}=\alpha\)，可以证明\(\triangle ABC \sim \triangle DEF\)。所以

\[\frac{\lvert \overrightarrow{\triangle v} \rvert}{\lvert \vec{v_{i}'} \rvert} = \frac {BC} {AB} = \frac {BC} {r}\]

由于我们在求解瞬时加速度，\(t\rightarrow 0\)时\(\alpha \rightarrow 0\)，\(BC \rightarrow \overset{\LARGE\frown}{BC}\)，所以

\[\frac{\lvert \overrightarrow{\triangle v} \rvert}{\lvert \vec{v_{i}'} \rvert} = \frac {\overset{\LARGE\frown}{BC}} {r} = \frac {\alpha r} {r} = \alpha\]

\[\lvert \overrightarrow{\triangle v} \rvert = \alpha \lvert \vec{v_{i}'} \rvert = \alpha v\]

将得到的\(\lvert \overrightarrow{\triangle v} \rvert\)代入\(\vec{a}\)，可以求出瞬时加速度的大小

\[\lvert \vec{a} \rvert = \lvert \frac{\vec{v_{j}}-\vec{v_{i}}}{t} \rvert = \frac{\lvert \overrightarrow{\triangle v} \rvert}{t} = \frac{\alpha v}{t}\]

由线速度和角速度的定义，可以得到

\[\lvert \vec{a} \rvert = v \omega\]

但这只是加速度的大小。观察以下图像：

易得当\(t \rightarrow 0\)时\(\alpha_{1} \rightarrow 0\)，此时\(\overrightarrow{\triangle v}\)与圆的切线垂直，即\(\vec{a}\)朝向圆心。

Invent wheels with Autotools & C

2020-08-08T00:00:00Z

This how-to guide will teach you how to invent wheels with Autotools & C. Note that it isn't detailed, just to give you some ideas how the whole system works.

Introduction

Requirements

My Autotools versions are:

Automake 1.16.1
Autoconf 2.69
Libtool 2.4.6

And I'm on OS X. Installation guide will not be included.

Product

We'll make a simple C lib (C++ compatible) called libts helps you to get time duration between two function calls.

Procedures

Time to actually make something!

A simple lib

Our project starts simply like this, including a header file and a source file:

.
├── ts.c
└── ts.h

0 directories, 2 files

And codes are shown below:

ts.h

#ifndef __TS_H__
#define __TS_H__

#include <sys/time.h>
#include "config.h" /* This file will be generated later */

/* For C++ compatiblity */
#ifdef __cplusplus
extern "C" {
#endif

#define FIRST_CALL -1.0

/*
* Returns the time passed in seconds before the latest call.
* If it's the first time called, return FIRST_CALL.
*/
extern double getTimeDuration(void);

/* End of the extern "C" above */
#ifdef __cplusplus
}
#endif

#endif /* __TS_H__ */

ts.c

#include "ts.h"

double getTimeDuration()
{
    static double latest = 0; /* Last call */
    double sec; /* Current time in second */
    double ret; /* Return value */

    #if HAVE_GETTIMEOFDAY /* This macro comes from config.h */

    /* In some specific OS, gettimeofday() is available */
    /* See https://man7.org/linux/man-pages/man2/gettimeofday.2.html */

    struct timeval tv;
    gettimeofday(&tv, NULL);
    sec = tv.tv_sec;
    sec += tv.tv_usec / 1000000.0;

    #else /* HAVE_GETTIMEOFDAY */

    /* Or we can use time() instead. */

    sec = time(NULL);

    #endif /* HAVE_GETTIMEOFDAY */

    ret = sec - latest; /* Calculate difference */
    latest = sec; /* Update latest */
    if (ret == sec) /* First call, return special value */
        return FIRST_CALL;
    else
        return ret;
}

Now the source code is done. Let's setup Autotools!

Autotools

Autotools is a complicated build system. We have to create several files.

Note: The following commands are run at the root of the source code.

configure.ac

configure.ac is a file for Autoconf to generate an configure script. It checks availability (in our example, if gettimeofday() and time() are available) and generates Makefile from Makefile.in, which will be generated later.

Let's start with an autoscan GNU provided. It scans your code and generates an configure.ac automatically.

autoscan

The directory should be like this:

.
├── autoscan.log
├── configure.scan
├── ts.c
└── ts.h

0 directories, 4 files

The autoscan.log can be removed safely. What matters is configure.scan. We have to rename it to configure.ac first:

rm -f autoscan.log
mv configure.scan configure.ac

configure.ac looks like this:

#                                               -*- Autoconf -*-
# Process this file with autoconf to produce a configure script.

AC_PREREQ([2.69])
AC_INIT([FULL-PACKAGE-NAME], [VERSION], [BUG-REPORT-ADDRESS])
AC_CONFIG_SRCDIR([ts.c])
AC_CONFIG_HEADERS([config.h])

# Checks for programs.
AC_PROG_CC

# Checks for libraries.

# Checks for header files.
AC_CHECK_HEADERS([sys/time.h])

# Checks for typedefs, structures, and compiler characteristics.

# Checks for library functions.
AC_CHECK_FUNCS([gettimeofday])

AC_OUTPUT

It's actually a piece of m4 language, and all those AC_XXX stuffs are macros and will be expanded into bash scripts. You can write bash in the configure.ac directly as well.

As you can see, it's smart to include AC_CHECK_FUNCS([gettimeofday]). This will checks if gettimeofday is available. Magic! But, we have to modify it anyway.

#                                               -*- Autoconf -*-
# Process this file with autoconf to produce a configure script.

AC_PREREQ([2.69]) # 1
AC_INIT([libts], [0.1], [username@example.com]) # 2
AC_CONFIG_SRCDIR([ts.c]) # 3
AC_CONFIG_HEADERS([config.h]) # 4

AM_INIT_AUTOMAKE # Modified 5

# Checks for programs.
AC_PROG_CC # 6

# Checks for libraries.

# Checks for header files.
AC_CHECK_HEADERS([sys/time.h]) # 7

# Checks for typedefs, structures, and compiler characteristics.

# Checks for library functions.
AC_CHECK_FUNCS([gettimeofday]) # 8

LT_INIT # Modified 9
AC_CONFIG_FILES([Makefile]) # Modified 10

AC_OUTPUT # 11

1: Checks the minimal version of autoconf.
2 & 11: Start and end of every configure.ac. It also includes some info for your project.
3: Check if the source code exists.
4: Generates the configuration header named config.h.
5: Prepare for generating Makefile.
6: Determine a C compiler to use.
7: Check if header file sys/time.h is available.
8: Check if function gettimeofday is available.
9: Initialize Libtool. This will be used later.
10: Generate Makefile from Makefile.in, which will be generated later.

And to generate the configure file:

aclocal
autoconf
autoheader

And your project will be like this:

.
├── aclocal.m4
├── autom4te.cache
│   ├── output.0
│   ├── output.1
│   ├── output.2
│   ├── output.3
│   ├── requests
│   ├── traces.0
│   ├── traces.1
│   ├── traces.2
│   └── traces.3
├── config.h.in
├── configure
├── configure.ac
├── ts.c
└── ts.h

Makefile.am

Makefile.am is a file for automake to generate the Makefile.in mentioned above. Now create a Makefile.am and write the following stuffs:

AUTOMAKE_OPTIONS = foreign
include_HEADERS=ts.h
lib_LTLIBRARIES = libts.la
libts_la_SOURCES=ts.c

The build target is libts.la, containing the source file ts.c, which uses Libtool to sustain portability. It's simpler than configure.ac.

Also, note that AUTOMAKE_OPTIONS is set to foreign, so it won't force us to create those NEWS, AUTHOR, ChangeLog, etc.

To generate Makefile.in, run:

libtoolize # Generate supporting files for Libtool
automake --add-missing

Tests

Tests are always needed. Let's do this in Autotools' way. First create test.c:

#include "ts.h"
#include <assert.h>
#include <stdio.h>

/* Program exits with 0 means tests has passed */
int main(int args, char *argv[])
{
    double first = getTimeDuration();
    assert(first == FIRST_CALL);
    double second = getTimeDuration();
    assert(second != FIRST_CALL);
    puts("OK");
    return 0;
}

You can use modern test frameworks too.

Makefile.am:

# Lib
AUTOMAKE_OPTIONS = foreign
include_HEADERS=ts.h
lib_LTLIBRARIES = libts.la
libts_la_SOURCES=ts.c

# Tests
TESTS = checkTS
check_PROGRAMS = checkTS
checkTS_SOURCES = test.c
checkTS_LDFLAGS = libts.la

Also, if you don't want to type the above aclocal and stuff again:

autoreconf -i

configure & build

Simple! Everything is ready now. Do this as usual:

./configure
make

And to install:

sudo make install

To test:

make check

To make a distribution package:

make dist

Whoa, you did that! To use this lib in your own programs, just #include <ts.h> and link this library (-lts)!

Product

This demo's distribution can be found here.

Yi's Blog

LLM and (Math) Education

三年LLM：过去和未来

一小段历史

我的经历

未来展望

Color Recreation from First Principles

《死亡搁浅》玩后感及艺术评论思考

《星际拓荒》玩后感

Review on ASUS Zenbook S14 Laptop (LNL) with Linux

LLM will NEVER be AGI: The Proof

On Programming Languages

By computation, you mean...

That's enough metaphysics nonsense. Why would I care?

But I don't code using JMP and LOAD/STORE either!

And by creating languages you mean...

Don't you play tricks on me

Simulating Gravitational Lensing

Visiting NASA Goddard Space Flight Center

My 2023 Swift Student Challenge

IFS

Results

Kerbalhopper: PID explained with KSP

Introduction

The math way

The engineering way

Conclusion

An Introduction to Lambda Calculus

Introduction

Notation System

Reduction Rules

Arithmetic

Further Reading

匀速圆周运动加速度的推导

Invent wheels with Autotools & C

Introduction

Procedures

But I don't code using `JMP` and `LOAD`/`STORE` either!