Zhéyuán Chén

Model Training Memory Simulator

Sun, 08 Feb 2026 00:00:00 +0000

What This Visualizes

This simulator models a simplified training input pipeline as three stages:

Data loading into a CPU-side prefetch queue (often pinned host memory).
Host-to-device transfer into a GPU-side VRAM backlog queue.
GPU compute consuming queued batches.

Each stage has a throughput and each queue has a capacity. The key idea is that memory pressure is created by mismatch between rates, not just by one parameter in isolation.

Tradeoffs It Tries To Show

Larger prefetch can improve utilization, but it increases pinned RAM usage.
Faster loading helps only if transfer and compute can keep up.
Faster transfer helps only if data is available and compute can drain VRAM.
Larger VRAM backlog capacity can smooth bursts, but it can also increase VRAM residency.
Bigger batch size raises memory footprint everywhere at once (CPU queue, transfer payload, GPU queue).

Practical Reading Guide

If prefetch queue fills and pinned memory saturates, reduce prefetch depth, loader rate, or batch size.
If the VRAM backlog queue fills and VRAM saturates, reduce backlog depth or batch size, or speed up compute.
If transfer is starved, the loader is too slow for the downstream pipeline.
Stable throughput comes from balancing all stages, not maximizing any single slider.

This is a first-order mental model for input-pipeline pressure during training. In real systems, total VRAM also includes relatively stable components (weights, gradients, optimizer state) plus activation/workspace effects.

Park construction observation journal

Thu, 05 Oct 2023 00:00:00 +0000

Recently, construction started at a park near my home. It has presented me with a unique opportunity to observe the intricacies of a construction site up close. Having majored in urban planning, I find it especially enlightening to witness these procedures firsthand.

Just today, I noticed a new addition to the site – straw wattles. They were installed along the edges. A shallow trench was dug specifically for placing these wattles. They weren’t simply laid down; the wattles were anchored securely with long wooden stakes. Moreover, the ends of the wattles overlapped, ensuring their stability.

I did some research for the purpose of these installations and found that they might be mainly for sediment control.

Before construction, the park’s terrain was covered by a dense spread of wild plants, holding the soil together. However, as construction advanced, the natural vegetation was removed, and the once compact dirt would be loosened. This transformation poses a risk, especially during storms. Rainwater could wash away the loose dirt and other construction debris, spilling it onto the nearby roads. This not only disrupts traffic but can also block the street drainages. These wattles act as barriers, effectively preventing sediment and debris from leaving the construction site.

Another possible purpose is to act as cushions, protecting the adjacent concrete sidewalks from being accidentally damaged by construction machineries.

Straw wattles secured by wooden stakes

Humbled by Fork

Sat, 11 Feb 2023 00:00:00 +0000

Luckily, I have never had to use fork() in my everyday work. Otherwise, I guess I would produce 10x more bugs. Here is an example why I think so.

In a nutshell, fork() creates a child process who copies the parent’s current status, including the instruction pointer, data/stack/heap space and etc.

Here’s a short example.

// test.c
#include <stdio.h>
#include <unistd.h>

int main() {
  int x = 42;
  if (fork() == 0) {
    printf("child pid = %d, forked by %d\n", getpid(), getppid());
    printf("x in child = %d\n", x);
  } else {
    printf("parent pid: %d\n", getpid());
    printf("x in parent = %d\n", x);
  }
  sleep(1);
}

The output of the above problem will be something like this.

> ./test
parent pid: 47557
x in parent = 42
child pid = 47558, forked by 47557
x in child = 42

Notice that x is copied from the parent’s to the child’s memory space after fork.

Here is a brain teaser. Can you predict how many lines the following program outputs?

// test.c
#include <stdio.h>
#include <unistd.h>

int main() {
  for (int i = 0; i < 2; i++) {
    if (fork() == 0) {
      printf("iteration %d: child pid = %d, forked by %d\n", i, getpid(), getppid());
    } else {
      printf("iteration %d: parent pid: %d\n", i, getpid());
    }
  }
  sleep(1);
}

If you run it in terminal, you will find something like below.

> ./test

iteration 0: parent pid: 48102
iteration 1: parent pid: 48102
iteration 0: child pid = 48103, forked by 48102
iteration 1: child pid = 48104, forked by 48102
iteration 1: parent pid: 48103
iteration 1: child pid = 48105, forked by 48103

Here is what happened.

When fork() is called in iteration 0, parent process 48102 (line 1) will create a child 48103 (line 3).
Since the full process status is copied, 48102 and 48103 will each increment i and continue the loop. So you will see
1. 48102 creates a child 48104 in iteration 1, where the parent 48102 outputs line 2 and the child 48104 outputs line 4.
2. Similarly, the child 48103 created during iteration 0 will create its own child 48105 in iteration 1, which then print line 5 and line 6 correspondingly.

Here is an illustration of the parent-child relations of all processes.

48102: root process
- 48103: created in iteration 0
  - 48105: created in iteration 1
- 48104: created in iteration 1

Now is the most interesting part. Can you predict the output of below?

> ./test | wc -l

You may think wc -l will just print the count of lines which should be 6, but surprisingly the output is 8. What the hell is happening now?

Here is a clearer picture.

> ./test > test.output
> cat test.output

iteration 0: parent pid: 48230
iteration 1: child pid = 48232, forked by 48230
iteration 0: child pid = 48231, forked by 48230
iteration 1: child pid = 48233, forked by 48231
iteration 0: child pid = 48231, forked by 48230
iteration 1: parent pid: 48231
iteration 0: parent pid: 48230
iteration 1: parent pid: 48230

The output file will also contain 8 lines, if you redirect the program output. Remember that the child will copy the parent’s memory space. What has caused this behavior is that the child has copied the stdout buffer of the parent, just like the x variable we saw before, but somehow more implicitly.

What is buffer? You may think of it as just a limited size in-memory array that holds the characters before writing to stdout. To reduce the syscalls and IO operations, instead of writing to stdout every time a new character arrives, the buffer will hold the characters up for a while until it really needs flushed out to stdout.

There are 2 buffering modes: line buffering and full buffering.

Line buffering will flush every time when there is a newline character. Terminal uses this mode, which is what we observed when running ./test directly.
Full buffering will flush when the buffer reaches its size limit, which is what we observed when piping to wc -l or redirecting to a file.

In the later case, when the parent process calls printf(...) in iteration 0, the characters will be held in the buffer without flushing. When fork() is called during iteration 1, the buffer array is copied to the child as it is. So when the child prints, the line will be appended to the buffer and eventually get flushed containing the output previously printed by the parent.

Here is the detailed sequence of events producing test.output.

After the first fork(), the parent process 48230 will print iteration 0: parent pid: 48230\n and hold it in its buffer. The child process 48231 will print iteration 0: child pid = 48231, forked by 48230\n and hold it in its own buffer.
After the second fork(), child 48232 will be created by 48230, which copies 48230’s buffer first and prints iteration 1: child pid = 48232, forked by 48230\n. At this point, 48232’s buffer contains iteration 0: parent pid: 48230\niteration 1: child pid = 48232, forked by 48230\n. At the end of this process, the buffer is flushed and produces line 1 and line 2 as we see in test.output.
Similarly, line 3 and line 4 are produced by process 48233, where line 3 has been copied from its parent process 48231.
Line 5 and 6 get flushed at the end of process 48231, while line 7 and 8 are flushed at the end of process 48230.

As another experiment, if you add fflush(stdout); after each printf(...);, the output file will have 6 lines just like printing directly in the terminal.

Imagining what other data that we can accidently copy during fork that we are fully unaware of and the side effects they can possibly cause, I’m so humbled now.

Combinatorics is Fun

Sat, 10 Dec 2022 00:00:00 +0000

I did some fun combinatorial exercises to reach an optimal O(n) solution for an “easy” level leetcode problem (LeetCode 1588).

Look at the problem and think for 5 minutes. It is relatively easy to reach this approach: For each element \(a_i\), if you can find the count of odd-length sub-arrays containing it, denoted as \(n_i\), the sum of all odd-length sub-arrays will be equal to \(\sum a_i n_i\). The interesting part is how we can find out \(n_i\).

Step 1: visualize all sub-arrays

Let’s use a tuple (i,j) to denote a sub-array where i and j are the start and end index. Then we can plot all sub-arrays of an array with length L in the table below.

(0,  0)
(0,  1)  (1,  1)
(0,  2)  (1,  2)  (2,  2)
(0,  3)  (1,  3)  (2,  3)  (3,  3)
(0,  4)  (1,  4)  (2,  4)  (3,  4)  (4,  4)
...      ...      ...      ...      ...     ... 
(0,L-1)  (1,L-1)  (2,L-1)  (3,L-1)  (4,L-1) ... (L-1,L-1)

Step 2: visualize all sub-arrays containing a specific element

For an element \(a_i\), let’s mark all sub-arrays containing it in the table below. For example, those surrounded in the box below are the sub-arrays who contain \(a_1\).

 (0,  0)          sub-arrays containing a1
+----------------+
|(0,  1)  (1,  1)|
|(0,  2)  (1,  2)| (2,  2)
|(0,  3)  (1,  3)| (2,  3)  (3,  3)
|(0,  4)  (1,  4)| (2,  4)  (3,  4)  (4,  4)
|...      ...    | ...      ...      ...     ... 
|(0,L-1)  (1,L-1)| (2,L-1)  (3,L-1)  (4,L-1) ... (L-1,L-1)
+----------------+

As another example, below are the sub-arrays who contain \(a_3\).

 (0,  0)
 (0,  1)  (1,  1)
 (0,  2)  (1,  2)  (2,  2)           sub-arrays containing a3
+----------------------------------+
|(0,  3)  (1,  3)  (2,  3)  (3,  3)|
|(0,  4)  (1,  4)  (2,  4)  (3,  4)| (4,  4)
|...      ...      ...      ...    | ...     ... 
|(0,L-1)  (1,L-1)  (2,L-1)  (3,L-1)| (4,L-1) ... (L-1,L-1)
+----------------------------------+ 

For generalization, given any \(a_i\), there exists a rectangular “table”, where each “cell” represents a sub-array containing \(a_i\), illustrated as below.

+-------------------------------------+
|(0,  i)  (1,  i)  (2,  3) ... (i,  i)|
|(0,i+1)  (1,i+1)  (2,i+1) ... (i,i+1)|
|...      ...      ...     ... ...    |
|(0,L-1)  (1,L-1)  (2,L-1) ... (i,L-1)|
+-------------------------------------+ 

We can see the width of the table is \((i+1)\) and the height is \((L-i)\) so there are \((i+1) \times (L-i)\) sub-arrays in total.

A non-visual proof: For a sub-array starting at \(m\) and ending at \(n\), we have \(m \leq i \leq n\) if \(a_i\) is in it. Thus, there are \(i + 1\) choices to pick m in the range of 0...i and \(L - i\) choices of n in the range of i...L-1.

Step 3: find out how many sub-arrays in the table have odd lengths

Observation 1: the top-right corner cell (i, i) is a sub-array with length = 1 which is odd.

Observation 2: given any cell, its 4 neighbors (top, down, left, right) must have a length with different parity. i.e.

If a cell is even length, all 4 neighbors must be odd.
If a cell is odd length, all 4 neighbors must be even.

Let’s mark odd-length cells with o and even-length with x. We obtain a chessboard-like shape and just need to find out how many o are there in the table.

+----------+
|.. x o x o|<--- the top-right cell must be o
|.. o x o x|
|.. x o x o|
|..........|
|..........|
+----------+

Observation 3: there are half of the cells are o (in most cases). See examples below.

+---+
|x o|
|o x|
+---+

+-----+
|o x o|
|x o x|
+-----+

+---+
|x o|
|o x|
|x o|
+---+

Observation 4: there is an exception: if the total number of cells is an odd number, there will be one more o than x.

+-----+
|o x o|
|x o x|
|o x o|
+-----+

Given all the observations above, we can tell the total number of o cells are (N + 1) // 2, where N is the total number of cells in the table, which we already know in step 2 is \((i+1)\times(L-i)\).

Final solution in Python

class Solution:
    def sumOddLengthSubarrays(self, arr):
        return sum(((i + 1) * (len(arr) - i) + 1) // 2 * n for i, n in enumerate(arr))

Appendix

Some refresh of tricks about division: In Python x // y is a round-down division. For round-up division, one way is to import math and use math.ceil. Another way of rounding up is (x + y - 1) // y. In the exercise above, (N + 1) // 2 is a special case of this formula.

>>> for x in range(20):
...     print(x, math.ceil(x / 5), (x + 4) // 5)
...
0 0
1 1
1 1
1 1
1 1
1 1
2 2
2 2
2 2
2 2
2 2
3 3
3 3
3 3
3 3
3 3
4 4
4 4
4 4
4 4

Java Duck Typing without Reflection

Sun, 06 Mar 2022 00:00:00 +0000

Can we implement duck typing in Java without using reflection?

Consider there are 2 classes defined by an external library that is out of our control.

class Duck {
  void swim() {...}
}

class Whale {
  void swim() {...}
}

We cannot do below.

Stream.of(new Duck(), new Whale()).forEach(obj -> {
  obj.swim(); // Compilation error since obj is of type `Object` which has no swim() method
});

Ideally, we want to define a common interface with a swim() method, and let Duck and Whale both implement it. But since this is an external library, we cannot modify the definitions. Instead, we can use a pattern like below to achieve duck typing.

interface CanSwim {
  static CanSwim coerce(Duck duck) {
    return new CanSwim() {
      @Override
      public void swim() {
        duck.swim();
      }
    };
  }

  static CanSwim coerce(Whale whale) {
    return new CanSwim() {
      @Override
      public void swim() {
        whale.swim();
      }
    };
  }

  void swim();
}

Usage of CanSwim

Stream.of(CanSwim.coerce(new Duck()), CanSwim.coerce(new Whale())).forEach(obj -> {
  obj.swim(); // obj is a CanSwim now, which has the swim() method
});

Streaming birds using Raspberry Pi

Thu, 10 Jun 2021 00:00:00 +0000

最近几天，我家阳台经常出现了一只哀鸽(mourning dove)。这是北美常见的一种鸟，它一大早就来，停在那里像是观察什么。

前天，忽然出现了两只鸽子，一只趴在壁灯上，另一只衔来树枝给它，想必是要筑巢。然而一天下来再去观察，由于壁灯上空间太小，树枝一根不剩全掉落在地上。

于是昨天一大早，我用包装鸡蛋的纸盒，给它们搭了一个宽敞些的台子。它们看起来甚是喜欢，雄鸟不断衔来新的树枝，雌鸟负责做窝，一整天下来鸟巢有了不少起色。

可是好景不长，傍晚时分我再去看时，地上树枝散落一地，还有一个碎掉的鸟蛋。鸟巢还没造好，就失去一个未出世的孩子，想必非常可怜。晚上，雌鸟在那里一动不动地趴了一夜。

今天一大早，我早早起床，看那雌鸟还在那里趴着。不久，雄鸟飞来把它接走，我开始担心它们不会回来了。不过趁它们不在，我又稍微加固了平台。把原先三面围合的平台，做成了四面围合，希望这样鸟蛋不要再掉下来了。

几天下来，我和家人都非常牵挂这两只小鸟，希望它们能在阳台住下，抚育后代。于是，我腾出手头的一台Raspberry Pi，搭设了一个观鸟的直播流，来更好地近距离观察它们的动静。

不一会后，它们终于回来了。于是我美滋滋地看起了直播。

附录. 直播耗材：

Raspberry Pi 3B+ with Camera Module。用ffmpeg推送摄像头信号给Nginx。
特地买了个6刀的DigitalOcean服务器，装上Nginx + rtmp-module，用来接收Raspberry Pi的视频信号，并作为直播服务器推送给最终客户端。
在Github Page上添加了一个新页面，用hls.js做客户端直播。

Name of my son

Thu, 30 Jul 2020 00:00:00 +0000

Our newborn son just arrived in the early morning on July 26, Sunday. My wife and I decided to name him “Luke”.

According to Wikipedia,

The name Luke is the English form of the Latin name Lucas. It is derived from the Latin name Lucius, and it either means “the great Lucius”, or it is a shortened form of the Latin name. Lucius means “the bright one” or “the one born at dawn”

Meanwhile, Luke is not just his English name, but also the alphabet spelling of his Chinese name “麓(lù)珂(kē)”.

“麓” means “foothill”, for he was born in Mountain View, the city located at the foothill of the Santa Cruz Mountains. This character also has the same pronunciation as “Six”(陆) of the Chinese capital number character, for he was born on June 6 (06/06) of Chinese Lunar Calendar. (Six is also considered to be the lucky number in China, similar to 7 in the western culture.)

“珂” means “pure white jade-like stone”, with our wish of being a bright person of him, similar to the meaning of the Latin origin of his English name.

The first argument of Stream::reduce does not need to be an identity in Java

Thu, 24 Oct 2019 00:00:00 +0000

The official documentation of Java claims that the first argument of T Stream::reduce(T identity, BinaryOperator<T> accumulator) must be an identity.

The identity value must be an identity for the accumulator function. This means that for all t, accumulator.apply(identity, t) is equal to t. The accumulator function must be an associative function.

Stream::reduce works almost identically to foldl in Haskell. In Haskell, you can use foldl as below.

> foldl (+) 0 [1, 2, 3]
6
> foldl (+) 10 [1, 2, 3]
16

As we see, it is not required that the initial value (the second argument) of foldl be an identity in Haskell (For the addition operation, 0 is the identity but 10 is not). Actually, you can even do the same in Java.

> Arrays.asList(1,2,3).stream().reduce(0, (a, b) -> a + b)
6
> Arrays.asList(1,2,3).stream().reduce(10, (a, b) -> a + b)
16

However, according to the Java doc, the second use case is violating the contract although the result is the same as that of foldl.

So why is identity required by the reduce in Java? In fact, the Java doc also writes:

Performs a reduction on the elements of this stream, using the provided identity value and an associative accumulation function, and returns the reduced value … but is not constrained to execute sequentially.

It implies that the requirement of the identity and associativity must be related to parallelism.

The actual problem occurs when you want to use “parallel stream”. For example, the following code gives 36 as result on my machine instead of 16.

> Arrays.asList(1,2,3).stream().parallel().reduce(10, (a, b) -> a + b)
36

Then, I found a similar question on StackOverflow, and one of the answers gives a plausible explanation. The main reason of this behavior seems because Java will assign the initial value to each parallelized reduce job. Given my previous example with input [1, 2, 3], 3 threads were started, each of which was assigned with 10 as the initial value, performing the following computation in parallel.

(10, 1) -> 10 + 1
(10, 2) -> 10 + 2
(10, 3) -> 10 + 3

After all jobs finished, the final result was summed up to be the wrong answer 36, unfortunately.

Here is the point I want to make: is it really necessary that the initial value must be an identity to allow reduce to be executed in parallel? I strongly believe not, and the associativity of BinaryOperator alone should be enough to enable parallelism.

Given an expression A op B op C op D where op is the binary operator, associativity guarantees that its evaluation is equivalent to (A op B) op (C op D), such that we would be able to evaluate A op B and C op D in parallel and combine their results afterward. The only reason I can think of why Java requires identity here is that the language developers wanted to simplify the implementation and keep all sub jobs symmetric. Otherwise, they may have had to differentiate parallelized jobs with/without initial values.

My gut feeling tells me that there must exist a simple implementation that does not require the initial value to be an identity. So I tried to write a “parallel reduce” pareduce function in Haskell as a proof of concept (with my limited Haskell proficiency).

import Control.Parallel

partitionSize = 100

pareduce :: (a -> a -> a) -> a -> [a] -> a
pareduce f n xs = pareduce1 f (n:xs)

pareduce1 :: (a -> a -> a) -> [a] -> a
pareduce1 f xs = case tail of [] -> headRes
                              _  -> headRes `par` f headRes tailRes
                  where head = take partitionSize xs
                        tail = drop partitionSize xs
                        headRes = foldl1 f head
                        tailRes = pareduce1 f tail

> pareduce (+) 100 []
100
> pareduce (+) 10 [1..100]
5060
> foldl (+) 10 [1..100]
5060

Some premature benchmarks show pareduce runs around 5 times faster than foldl on my machine to sum up [1..100000000].

Yet Another e Explained

Mon, 02 Sep 2019 00:00:00 +0000

不尽人意的例子

虽然有不少关于自然常数e的解释，浏览下来不少都从复利计算的例子展开。其中的逻辑是，如果年利率是100%，如果按每年计算利息，一年后获得的财富将是200%；如果按每半年，一年后获得\((1 + \frac{100\%}{2})^2 = 225\%\)；如果按每月，一年后获得\((1 + \frac{100\%}{12})^{12} = 261.3\%\)；如果按无限小的时间单位计算，一年后获得\(\underbrace{(1 + \frac{1}{N})^N}_{N \rightarrow \infty}\)，而这个数就是e。

在历史上，虽然e是在对复利的研究中被发现的，但我觉得这可能并不是一个足够直观的例子。其中的悖论是，既然我们规定了年利率是100%，将每半年的利率当作50%的算法显得很随意粗暴，这么一来，我们一年后实际获得的财富也就超过了100%的既定利率了呀？而且，既然e被称作“自然”常数，这种看似人为随意规定的规则到底和自然有什么关系呢？

核心概念

e背后的核心概念，是用来描述和“自身大小”相关的“增长率”。比如，滚一大一小两个雪球，因为大的雪球表面积更大能吸附更多的雪，相同单位时间内，大的雪球比小的雪球变大得更多，换句话说，雪球大小的增长率和它自身的大小正相关。再比如，比较两个培养皿中的细菌，假设其他条件相同，单位时间内大的群落比小的群落能繁殖更多细菌，也就是说，细菌群落的繁殖速率和群落本身的大小有关。可以想像现实中存在很多类似的例子，我们不妨暂且将这类变化称作“自然增长”。（其实，也可能是减少。）

接下来，我们来看“自然增长”与e之间的关系。我们将“自身大小”的量记作y，把时间记作x，当大小的增长率和自身大小成正比，我们就有了以下式子：

\[\frac{d y}{d x} = k y\]

其中k是一个代表权重的常量，所以我们不妨先研究\(k=1\)时候的情景。即：

\[\frac{d y}{d x} = y\]

稍有微积分基础的人都能看出，\(y = e^x\)这个函数满足上面的式子，也就是说，\(e^x\)的导数是其本身。

\[\frac{d e^x}{d x} = e^x\]

换句话说，如果大小y和时间x满足\(y = e^x\)，那它符合我们描述的“自然增长”的特征。

唯一性

其实，\(e^x\)并不是唯一满足“导数是其本身”这一性质的函数：任何\(y = c e^x\)（c为常数）的导数也都是其本身，即

\[\frac{d (c e^x)}{d x} = c e^x\]

除此以外，还有其他函数的导数是其本身吗？答案是没有。我们可以通过反证法证明。

假设存在一个函数\(f(x)\)不满足\(c e^x\)的形式，但有\(\frac{d f(x)}{d x} = f(x)\)的性质。那么，我们可以得出\(e^{-x} f(x)\)的导数为0的结论：

\[\begin{aligned} (e^{-x} f(x))' & = e^{-x} f'(x) + (e^{-x})' f(x) \\ & = e^{-x} f(x) - e^{-x} f(x) \\ & = 0 \end{aligned}\]

也就是说，\(e^{-x} f(x) = a\)，\(a\)是一个常数。可推出，\(f(x) = a e^x\)，与假设矛盾。Q.E.D

一般化

那么对任意的权重k，\(\frac{d y}{d x} = k y\)的原函数是什么呢？答案是\(y = c e^{k x}\)。我们可以轻松验算得出：

\[(c e^{k x})' = c (k x)' e^{k x} = k (c e^{k x})\]

至此，我们可以说\(y = c e^{k x}\)是“自然增长”函数的一般形式。其中，c是自身“绝对大小”的权重，k是“增速”和“大小”之比的权重。

再看复利

回头看复利，复利也满足“自然增长”的特征，它就和“滚雪球”类似，单位时间内获得额外利息的多少和本金多少成正比。

所以，\((1 + \frac{1}{N})^N = e\)究竟在描述什么现象？假设我们将1年分成\(\Delta x\)时长的N等分，即\(\Delta x = \frac{1 (year)}{N}\)，那这个式子也就变成了\((1 + 100\% \Delta x) ^ N\)。翻译成自然语言就是：对于任意小的一段时间\(\Delta x\)，我们始终保持100%的增长速率，那么经过N个\(\Delta x\)（1年）以后，我们的财富将变成e倍。

也就是说，如果你在“任意瞬间”都是100%的年利率增长（\(\frac{d y}{d x} = k y\), where \(k = 100\%\)），那1年后你的财富将变成\(e\)倍，2年后你的财富将变成\(e^2\)倍···（\(y = e^x\)）。当然，现实中银行多是按月或者按年计算复利，我可不知道哪家银行会按e的指数函数连续计算复利，这也是我觉得用复利作为例子的不够直观的另外一个原因。

自然衰减的例子

之前我们稍微提及了，e不但可以描述增加，也可以描述减少。这里我们举一个热水降温的例子：我们可以直观地想象出，热水降温的速度，和自身温度与室温的温差有关。温差越大，热交换越快，降温也就越快。

为了方便讨论，我们假设室温为0摄氏度，假设热水温度是y摄氏度，时间是x，那么我们有如下关于水温随时间变化率的式子：

\[\frac{d y}{d x} = - k (y - 0) = - k y\]

其中(y - 0)代表温差，k是一个线性常数，前面的负号代表温度下降。

这个式子除了符号相反，不是正好满足了之前讨论“自然增长”时的公式形式吗？我们可以很容易得出，水温y和时间x之间满足\(y = c e^{-k x}\)的关系。

One-liner curry decorator in Python

Fri, 01 Mar 2019 00:00:00 +0000

I discovered the following trick.

from functools import partial
curry = lambda n: partial(*[partial] * n)

Usage:

@curry(3)
def add(x, y, z):
    return x + y + z

print(add(2)(3)(4))
# output = 9

A more obfuscated way will be:

from functools import partial
curry = lambda f: partial(*[partial] * f.__code__.co_argcount)(f)

Usage

@curry
def add(x, y, z):
    return x + y + z

print(add(2)(3)(4))
# output = 9