Nightingale

Theme Feature Test

Mon, 18 May 2026 00:00:00 +0000

This post tests all theme features: footnotes, table of contents, images, figures, code blocks, tables, and blockquotes.

Headings and TOC

The table of contents on the right sidebar is generated from h2, h3, and h4 headings. On wide screens, h3 and h4 are nested under their parent h2 with a collapsible toggle.¹

Nested Level 3 Heading

This is a level-3 heading nested under the first H2. It should appear indented in the TOC.

与AI相关

Fri, 19 Sep 2025 00:00:00 +0000

Review Summary

Overall: 一篇关于 AI 能力与局限性的真诚个人反思。作者基于一手使用经验提出的担忧具有现实意义，行文流畅，但存在个别事实性错误和结构可优化之处。

Critical issues:

“GPT5” 并非已发布模型——截至本文日期（2025年9月）及当前（2026年5月）均未发布
“AI的问题"首段信息密度过高，“两个问题"作为本节核心论点被淹没在文字中
“无时无刻"缺少否定搭配，语义与作者本意相反

Annotations: 4 条标注——见下方内联区块。

AI的问题

自从对话式AI出来以后，我就一直使用AI辅助我的工作与学习。最初，我觉得AI很强大，好像什么都懂，但是随着我的使用，我发现AI的能力是有问题的，即使是现在最顶级的通用大模型，Gemini 2.5 Pro, 以及GPT5, 也存在很多问题。

我对AI的机制不太清楚，但是似乎是依据前面的文字，推断下一个哪个文字的概率是最大的(这似乎也解释了为什么即使使用同样的提示词，模型还是会给出不完全一样的回答)。如果是这种机制的话，就算它表现得出来似乎是能够理解自然语言，但是其本质还是没有思考能力的。以前我听到一个什么理论，如果一个东西长的像鸭子，叫的也像鸭子，那它就是一个鸭子。这个理论似乎可以套在很多东西上；如果以结果为导向作为评价结果，这句话好像没什么问题，实际上很多问题也的确是以最终结果为导向的。但是用这个理论套在大模型上，真认为大模型具有思考能力，我认为是不太合理的。如果仅仅认为两个东西表现的相似就认为他们是同一个东西，显然太过片面。大模型似乎更像是一个极其强大，对大量信息能够进行搜索的引擎。如果用于训练的数据，某个观点的内容比较多，它似乎更倾向于在一个问题上表现出该观点。当然，我觉得这就是大模型的用处。当你询问它问题时，它可以陈述出现有的所有观点，让我们快速了解已有的知识。但这也是问题所在，在我的使用过程中，有两个问题，我觉得是无法解决的。

[Accuracy] “GPT5” 并非已发布的模型。截至本文日期（2025年9月），OpenAI 发布的最新模型为 GPT-4o 和 o1 系列；截至当前（2026年5月），GPT-5 仍未发布。

Principle: 在论述中引用具体产品名称时，应确保该产品确实存在且已公开发布。OpenAI 官方文档（platform.openai.com）中不包含 GPT-5，最新公开可用的前沿模型为 GPT-4o 及 o1/o3 推理系列。

Correction: 将 “GPT5” 替换为当时已实际发布的模型名称（如 “GPT-4o” 或 “o1”），或使用泛指如"最新的 GPT 系列模型”。

miscellaneous tricks in r

Mon, 12 Feb 2024 00:00:00 +0000

About a year ago, I decided to stop using dplyr for data processing and switched to using data.table. One important reason is its more concise syntax in most situations and faster performance. Another reason is that using tidy-like code often involves loading many packages, leading to a miscellaneous workspace. Tidy-like code typically involves repeating some behaviors in base R but provides a unified interface for performing tasks more conveniently and rigorously.

ggplot2 advance

Sun, 04 Feb 2024 00:00:00 +0000

layers as object

对于ggplot2而言每一层的图形都是一个R对象，这些对象通过函数+堆叠在一起形成最终的对象。既然每一层都是一个对象，常规的R的操作对于其应该也是起作用的。对于 +操作，最常见的就是累加的操作了，对于ggplot2的对象来说也是可以这么操作的。

考虑你使用pROC::roc()计算了n个变量的AUC表现，该函数返回一个长度为n的列表；每一个列表元素包含了对应变量的specificities 以及 sensitivities. 如果你想用ggplot在一幅图中画出每个变量的ROC曲线，一般的作法是把每个变量的specificities以及sensitivities的结果合并在同一个数据框，然后对每条曲线使用不同颜色映射以区分不同的变量。如果你不想整理数据，一种方法如下：对列表的每一个元素创建对应的ggplot2对象，然后将其累加起来，构建最终的对像。

p <- Reduce(`+`, Map(function(.x, .color, .y, .name) {
 dt <- data.table(specificities = .x$specificities, sensitivities = .x$sensitivities)
 c(
 geom_path(
 data = dt, aes(x = 1 - specificities, y = sensitivities),
 color = .color, linewidth = .6
 ),
 annotate("text",
 x = .65, y = .y,
 label = sprintf("%s AUC: %s", .name, .x$auc), color = .color, hjust = 0
 )
 ) # 对每一个变量的AUC曲线，设置不同的颜色(palette)，以及注释
}, re5roc, palette, seq(0.05, 0.2, by = .05), names(re5roc)), init = ggplot())
p + geom_segment(aes(x = 0, xend = 1, y = 0, yend = 1), color = "red", linetype = "dashed")

wrap ggplot2 function

在ggplot2的aes函数中都使用了非标准性计算(NSE)，如果你想对aes传递参数, 则应该使用{{}}包裹这些参数。关于NSE的讨论可以参考Advanced R。一个例子见这里。

另一个封装ggplot2函数的问题在于...参数的传递。当你的函数试图创建多个ggplot2 components，你必须区分...里的参数是传递给哪个component。一种解决办法如下：

geom_mean <- function(..., bar.params = list(), errorbar.params = list()) {
 params <- list(...)
 bar.params <- modifyList(params, bar.params)
 errorbar.params <- modifyList(params, errorbar.params)
 
 bar <- do.call("stat_summary", modifyList(
 list(fun = "mean", geom = "bar", fill = "grey70"),
 bar.params)
 )
 errorbar <- do.call("stat_summary", modifyList(
 list(fun.data = "mean_cl_normal", geom = "errorbar", width = 0.4),
 errorbar.params)
 )

 list(bar, errorbar)
}

ggplot(mpg, aes(class, cty)) + 
 geom_mean(
 colour = "steelblue",
 errorbar.params = list(width = 0.5, linewidth = 1)
 )
ggplot(mpg, aes(class, cty)) + 
 geom_mean(
 bar.params = list(fill = "steelblue"),
 errorbar.params = list(colour = "blue")
 )

Internals of ggplot2

需要明确的是，当你在对你的ggplot函数添加一层层的图的操作与画图无关，而更多是创建一个用于画图的对象，当你print是该对象才被用于绘图；该对象需要经过ggplot2::ggplot_build()对其进行处理用于生成处理后的数据，最后经过ggplot2::ggplot_gtable()最终生成绘图数据。

统计绘图的本质在于统计量的分布；对于ggplot2而言其geom_以及对应的stat_函数将对原数据的统计量的计算以及其对应的几何图形整合在一起，掩盖了计算统计量的结果。为了得到统计量的结果，我们可以手动的生成的ggplot2进行ggplot2::ggplot_build的构建。

set.seed(123)
dt <- data.table(x = rnorm(20, mean = 1, sd = 2))
dt[, y := 2 * x + rnorm(20)]
p <- ggplot(dt, aes(x = x, y = y)) +
 geom_point() +
 geom_smooth(method = "lm", formula = y ~ x, n = 20)

stat <- ggplot_build(p)
stat$data[[2]] |> head(n = 5)

需要注意的是，ggplot2会先对数据进行所有的scale操作然后再进行各种统计计算，例如如果添加了scale_x_log10函数，则其先对原数据进行log10映射，然后再进行统计量的计算。

graph visualization

Wed, 08 Nov 2023 00:00:00 +0000

From here

tydygraph提供了用于图数据处理的tidy工作流的接口，ggraph提供了用于图数据可视化的ggplot2工作流的工具。

`tidygraph`

tidygraph::as_tbl_graph(), 用于将一个数据框及其类似的数据结构转换为图数据 —— 这个数据框包含一列称为from，以及一列称为to的变量，用于描述节点（nodes/vertex)之间的相互关系，其它的列是对连接线（edge）的描述信息。

可以简单的理解为在经过as_tbl_graph后，得到的图数据结构包含两张表。第一张表用于描述节点信息，其第一列是对原始数据框from, to两类中的节点去重得到。第二张表包含有连接线的信息，其是对原始数据框的复制，但是它的from，以及to变量中的节点名称由原来的名称被节点在第一张表中的排序所替代。

由于图数据结构中有两张表，所以如果想要改变其中的信息，则需要确定想要改变的是描述节点信息的表还是描述连接信息的表，示例如下

graph %>%
 activate(nodes) # 修改用于描述节点信息的表

graph %>%
 activate(edges) # 修改用于描述连接信息的表

如果想要应用一些图算法，在该图数据之上，步骤如下

Start with a graph table

Temporarily transform the graph to comply with the model that is requested (morph())

Add additional transformations to the morphed data using dplyr (optional)

Restore the original graph table, but modified to keep the changes made during the morph

当你在morph函数中调用算法时，图数据结构会变成适合该算法输入的形式，然后返回一个新的图数据，你可以操作此图数据，就像其它任何图数据一样，然后返回原始数据，但是保留在morph期间的修改。

shortest <- graph_routes %>%
 # find the shortest path
 morph(to_shortest_path, from, to, weights = journey_time) %>% 
 # only node and edge in the returned morph data mutated
 mutate(selected_node = TRUE) %>%
 activate(edges) %>%
 mutate(selected_edge = TRUE) %>%
 unmorph() %>%
 activate(nodes) %>%
 mutate(selected_node = ifelse(is.na(selected_node), 1, 2)) %>%
 activate(edges) %>%
 mutate(selected_edge = ifelse(is.na(selected_edge), 1, 2)) %>%
 arrange(selected_edge)

ggraph

ggraph提供了用于可视化图数据的一系列类似于ggplot的函数。其大致的用法如下

virtual machine profile

Tue, 03 Oct 2023 00:00:00 +0000

建议直接使用WSL2

这里下载vmware playrer，这里下载ubuntu镜像。打开vmware，按照提示一路选择操作既可。

之前下载的是vmware player, 但是后来设置网络时候，发现这玩意并不好用，好多教程都是使用vmware workstation示例，让我想起这以前刷到过的帖子 - 为什么vmware 网上的密钥好多都可以用。尝试了以下，只能说的确可以用，还很多。

虚拟主机设置主机v2ray代理

vmware设置网络模式为桥接模式。

物理主机中运行ipcongfig查看WLAN ipv4地址。v2ray中开启允许局域网连接，查看局域网socket, http端口号。

ipconfig

虚拟主机中在 Settings -> Network -> Network Proxy中设置为mannual在http, https前一栏中填入物理主机的ipv4地址，后一栏中填入v2ray中查看的http端口号。在socket的第二栏中填入v2ray中查看的socket端口号。

中文输入设置

From network

Open Settings, go to Region & Language -> Manage Installed Languages -> Install / Remove languages.
Select Chinese (Simplified). Make sure Keyboard Input method system has Ibus selected. Apply.
Reboot
Log back in, reopen Settings, go to Keyboard.
Click on the “+” sign under Input sources.
Select Chinese (China) and then Chinese (Intelligent Pinyin).

外观

recursive operations

Sun, 01 Oct 2023 00:00:00 +0000

In most cases, we can traverse data by loop according to its index; and most languages provide syntatic-sugar for the iteration of such data, such as list comprehension in python and let i in array grammar in javascript. However, the recursion is needed if you want to traverse unstructured data, such as list in R, dictionary in javascript, and object in javascript.

The recursion on such complex data comonly includes a if else structure; the first case is your desired behavior on objects’s specified children node; the second is the recursive case that is loop over the data and recursion on each element. a example from modern javascript

wrap ggplot2 function

Mon, 26 Jun 2023 00:00:00 +0000

I am recently wrapping some ggplot2 functions in my package easybio but encountered a problem; According to the documentation and my knowledge of eval_tidy, we should do it like this to wrap a function with quoted arguments in a tidy-like function:

f1 <- function(data, x, y, color) {
 ggplot(data, aes({{x}}, {{y}}, {{color}})) +
 geom_point()
}

This works well. However, when I want to add additional aesthetic arguments ... to the f1 function, it doesn’t seem to work. Instead of wrapping ... in {{}}, no special operations need to be performed as if the ... argument is a common argument:

a bug caused by staying up late

Fri, 09 Jun 2023 00:00:00 +0000

I accidentally confronted a bug in committing my modifications on my website —— my new blog on June 1 can’t be presented on my website; The blog was written at 2. am in China; After many possible fixes, I finally found that it was triggered by jet lag: China is 12 hours ahead of the United States, so when I committed a blog with June 1 announcement at 2. am in China, the hours in the United States was May 31st. No blog was written on June 1 when hours were May 31st. This reminds me of not burning the midnight oil…

use conda

Tue, 06 Jun 2023 00:00:00 +0000

查看系统信息，在这里选择合适的版本下载。

uname -a

在服务器没有代理的情况下，建议直接从其它地方下载该文件，例如清华大学开源软件镜像，免受1kb/s的折磨。

curl 
-L https://github.com/conda-forge/miniforge/releases/latest/download/Mambaforge-Linux-x86_64.sh 
-o Mambaforge-Linux-x86_64.sh

运行bash Mambaforge-Linux-x86_64.sh init? yes

通过修改用户目录下conda的配置文件.condarc，可以改变conda的行为。考虑到国外镜像在没有代理的情况下，下载速度缓慢，可以在配置文件中添加如下语句，更改镜像为清华源

channels:
 - defaults
show_channel_urls: true
default_channels:
 - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
 - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/r
 - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/msys2
custom_channels:
 conda-forge: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
 msys2: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
 bioconda: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
 menpo: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
 pytorch: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
 pytorch-lts: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
 simpleitk: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
 deepmodeling: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/

在这里查软件下载命令

mamba install r-base=4.3.1 
mamba install python=3.14 
mamba install radian

 #.bashrc 中设置radian 别名pi: alias pi='radian'
echo alias pi='radian' >> .bashrc

取消终端启动时自动启动conda, 也可以直接在.condarc文件中设置其值为false.

use git

Tue, 06 Jun 2023 00:00:00 +0000

可以简单的认为github仓库及其分支，本地的仓库及其分支都是一份独立的资源。在每一份资源之上的每次提交都在资源中的一个版本，根据需要我们将仓库的版本合并同步。

git configuration

git config --global user.name "xxx"
git config --global user.email "706990@gmail.com"
git config --list # 列出所有配置信息

git与github连接

git remote add origin <https://github.com/person-c/easybio.git>
git push -u origin main

git remote set-url origin new.git.url/here # 改变远端github地址

git branch -m master main #修改分支名master为main

workflow

git clone # git clone 到本地
git checkout -b xxx # 切换至新分支xxx（相当于复制了remote的仓库到本地的xxx分支上
修改或者添加本地代码（部署在硬盘的源文件上）
git diff # 查看自己对代码做出的改变
git add # 上传更新后的代码至暂存区
git commit # 可以将暂存区里更新后的代码更新到本地git
git push origin xxx # 将本地的xxxgit分支上传至github上的git

如果在写自己的代码过程中发现远端GitHub上代码出现改变

learning with ai

Sun, 28 May 2023 00:00:00 +0000

Recently, ChatGPT is overwhelming the Chinees internet with many applications deployed. It not only supplies powerful abilities to process many boring and repetitive work many white collars do but also brings unemployment concerns for many people engaged in the internet field. What’s the future of the internet like? I don’t know, but I think it’s indeed a powerful tool to help us learn, especially in cases when what we want to know is something common but scattered across the internet which cost us much time to filter from many pages. AI’s performance in summarizing information from the internet is impressive, so it’s a useful tool for learning knowledge widespread existed on the internet, such as programming. I have tried to learn javascript for a few days, and the most annoying thing I encountered was many methods’ arguments and usage, but I accidentally found Al can solve this problem perfectly —— just ask AI to give a concrete example of the method you want to learn, it can respond with a detailed description. Nice! AI can handle such specific questions perfectly, what we need to do is to design the whole theory structure we want to learn;

lazy evaluation in eval function

Mon, 22 May 2023 00:00:00 +0000

The lazy evaluation arguments in eval() function indeed confused me for a few days. I realize that problem when I read the Learning R programming(the Chinese edition); There is a part of code like this:

qs <- function(x, range) { 
 range <- substitute(range)
 selector <-eval(range, list(. = length(x)))
 x[selector]

Here, we create a function that quotes the range argument; then evaluate the range expression in a list environment that the dot. represents the length of x. A concrete example is as follows:

ggplot2 scales

Fri, 17 Mar 2023 00:00:00 +0000

ggplot2中所有映射都由scale_*函数控制, 使用vignette("ggplot2-specs")查看所有的映射。

Position scales and axes

Numeric positions and scales

limits 控制x, y轴的范围。

zooming in

NOTE: When you truncate the scale limits, some data points will fall outside the boundaries you set, and ggplot2 has to make a decision about what to do with these data points. The default behaviour in ggplot2 is to convert any data values outside the scale limits to NA. This means that changing the limits of a scale is not always the same as visually zooming in to a region of the plot. If your goal is to zoom in on part of the plot, it is usually better to use the xlim and ylim arguments of coord_cartesian(ylim = c(10, 35))

execute r script in linux

Thu, 12 Jan 2023 00:00:00 +0000

argparse
read_yaml
parallel

编写R软件。首先在脚本头部加入语句#! /usr/bin/env Rscript指定bash。

argparse

R软件接受命令行参数，这里我使用r包argparse。这是依据python包写的，因此需要你的的环境里有python环境。如果需要生成帮助文档，则需要knitr包，而knitr包依赖于软件pandoc，所以你还需要下载pandoc。其简单的执行过程就是创建一个parser对象，调用其add_argument()方法添加参数，然后将接收的命令行参数返回一个列表。

命令行参数主要包括可选参数以及位置参数。
参数名的简写一般以符号-开始，而其全称以符号--开始。

可选参数例子如下：

#! /usr/bin/env Rscript
library(argparse)

# 创建参数解析对象
parser <- ArgumentParser()

# 设置参数
# 设置第一个参数verbose，缩写为v，其作用是告诉脚本是否打印完整的计算过程，其缺省值为TRUE
parser$add_argument("-v", "--verbose",
 action = "store_true", default = TRUE,
 help = "Print extra output [default]")

# 设置第二个参数quietly，缩写为q，其作用是修改verbose参数，当调用改参数时，verbose被修改为FALSE，从而导致不再打印计算过程
parser$add_argument("-q", "--quietly",
 action = "store_false",
 dest = "verbose",
 help = "Print little output")

# 设置第三个参数count，缩写为c，这是一个整数参数，缺省值5，在后续的代码中被用作确定输出随机数的个数
parser$add_argument("-c", "--count",
 type = "integer", default = 5,
 help = "Number of random normals to generate [default %(default)s]",
 metavar = "number")

# 设置第四个参数generator，无缩写，用于确定调用何种随机分布，缺省值rnorm对应于正态分布
parser$add_argument("--generator", default = "rnorm",
 help = "Function to generate random deviates [default \"%(default)s\"]")

# 设置第五个参数mean，无缩写，浮点数，用于确定正态分布的均值，缺省值为0
parser$add_argument("--mean", default = 0, type = "double",
 help = "Mean if generator == \"rnorm\" [default %(default)s]")

# 设置第六个参数sd，无缩写，浮点数，用于确定正态分布的标准差，缺省值为1
parser$add_argument("--sd", default = 1, type = "double",
 metavar = "standard deviation",
 help = "Standard deviation if generator == \"rnorm\" [default %(default)s]")

# 返回接受的参数列表
args <- parser$args()

# 根据verbose确定是否打印计算过程
if (args$verbose) {
 write("writing some verbose output to standard error...\n", stderr())
}

# 根据其他参数，确定输出随机数的类型与次数
if (args$generator == "rnorm") {
 cat(paste(rnorm(args$count,
 mean = args$mean, sd = args$sd),
 collapse = "\n"))
} else {
 cat(paste(do.call(args$generator, list(args$count)), collapse = "\n"))
}
cat("\n")

最后，我们需要使得这个脚本有执行权限，才可以执行该脚本。因此在终端输入命令chmod +x example.R。然后就可以输入命令.example.R运行该脚本。如果中间出现某些问题，你可能需要考虑你需要用到的软件是否在你的搜索路径PATH里面。

use rmarkdown to generate pdf in chinese

Thu, 12 Jan 2023 00:00:00 +0000

为了使得Rmardown生成的PDF支持中文以及交叉引用等功能，在YAML头部需要做一些设置。pdf_documnent2格式是对普通pdf格式的增强，增加了交叉引用的支持。你可以通过?pdf_document2查看该文档可以设置的选项。xelatex是对中文支持比较好的引擎。如下：

---
title: "pdf title"
output:
 bookdown::pdf_document2:
 latex_engine: xelatex
date: "2023-01-03"
header-includes: 
 \usepackage{ctex}
 \usepackage{longtable}
---

yaml头部的每一个域(filed)都是对文档格式某一类选项的设置，除了output下的内容，其它设置都是不依赖于输出文档类型设置。

对code chunk的一些option，我们可以通过函数knitr::opts_chunk统一设置：

```{r setup, include=FALSE}
knitr::opts_chunk$set(
 echo = FALSE,
 fig.width = 7,
 fig.height = 5,
 fig.align = "center"
)
```

一些常用的code chunk option:

fig.show = 'hold'，它告诉 R Markdown 不要拆分代码块，而是运行完全部代码后，把生成的图片依次附在下方。

knitr 1.35 及以后版本支持在代码块内部用 #| 符号设置代码块选项，例如：

```
#| echo: false
#| fig.width: 10

plot(cars)
```

同时我们还可以使用行内代码，例如 r nrow(mtcars) ，该表达式会直接执行，将代码嵌入文档之中，进行文档的实时更新。

advanced r - meta programming

Tue, 10 Jan 2023 00:00:00 +0000

序

代码也是数据，可以用代码进行检查和修改。为了实现对代码数据的修改，我们需要区分代码数据和代码本身，毕竟它们在形式上是一致的。我们需要将代码用expr()包裹，然后对这个返回的对象进行修改，这个返回的对象称之为表达式（expression），也就是我们可以用于修改的代码数据。但是对于传入函数的参数，我们需要用enexpr()对其进行包裹，才能返回表达式。表达式是一类数据的总称，包括四个方面的内容，call, symbol, constant, pairlist。

和其它语言一样，代码数据被抽象为类似树的结构，称为抽象语法树（abstract syntax tree）。函数的调用为树的分支，树的叶子为symbol, contants。一个例子如下：

r$> lobstr::ast(1 + 2 * 3)
█─`+` 
├─1 
└─█─`*` 
 ├─2 
 └─3

既然表达式是数据，那么我们就可以用代码生成该数据。其中一个生成call表达式一个方法就是call2()函数。

r$> call2("f", 1, 2, 3)
f(1, 2, 3)

这方法比较简单，但是在构建比较复杂的表达式时比较困难。还有一种方法就是通过对简单表达式进行组合，形成比较复杂的表达式。为了组合不同的表达式我们需要使用特殊的符号!!，该符号所进行的操作称为“解引用”。你可以将其理解为插入操作，其是在表达式中的一个特殊语法，只有在返回表达式的函数，例如expr()中可以理解该语法，类似于R中的胶水语法，可以将变量代表的表达式插入表达式。一个例子如下：

r$> xx <- expr(x + x)

r$> yy <- expr(y + y)

r$> expr(!!xx / !!yy)
(x + x)/(y + y)

对代码数据，即表达式，修改之后怎么执行呢？我们唯一需要做的就是定义这个表达式所在的环境，也就是对表达式的symbol提供来源。baseR提供了函数base::eval用于执行表达式：

r$> eval(expr(x + y), env(x = 1, y = 2))
[1] 3

如果你没有在base::eval中定义环境，那么该函数会默认使用当前环境。手动执行表达式的好处在于，你可以自己定义执行的环境，这主要有两个用处：

在写领域内特定的函数时，重写某些函数的定义，比如+。
可以把数据框的变量作为环境(data mask)。

以下是一个重写函数定义的例子：

r$> string_math <- function(x) {
 e <- env(
 caller_env(),
 `+` = function(x, y) paste0(x, y),
 `*` = function(x, y) strrep(x, y)
 )
 
 eval(enexpr(x), e)
 }

r$> name <- "Hadley"

r$> string_math("Hello " + name)
[1] "Hello Hadley"

r$> string_math(("x" * 2 + "-y") * 3)
[1] "xx-yxx-yxx-y"

dplyr把这一思想发挥到了极致，dplyr会把R在一个会将R代码生成SQL的环境中运行，然后在远端数据库中执行这些SQL代码。

当然，在环境中重新定义函数的意义需要很多的投入，我们更加常用的是，将表达式在数据框（数据框，列表，环境的结构类似）中执行（data mask）。这里我们用rlang::eval_tidy作为例子，base::eval当然也可以做到，不过它具有某些缺点，我们后面再讨论。

r$> df <- data.frame(x = 1:5, y = sample(5))

r$> eval_tidy(expr(x + y), df)
[1] 2 6 5 7 10

我们将它封装起来，就可以形成一个类似于base::with()的函数。

r$> with2 <- function(df, expr) {
 eval_tidy(enexpr(expr), df)
 }

r$> with2(df, x + y)
[1] 2 6 5 7 10

但是这个函数有个问题，稍微修改一下这个函数：

r$> with2 <- function(df, expr) {
 a <- 1000
 eval_tidy(enexpr(expr), df)
 }

r$> df <- data.frame(x = 1:3)

r$> a <- 10

r$> with2(df, x + a)
[1] 1001 1002 1003

这里的问题在于，当我们给函数传递参数的时候，我们希望的是它的值就是我们在外面定义的值，即a <- 10。但是在执行时，函数显然使用的是with2函数环境中的a <- 1000。为了解决这个问题，我们引入一种新的数据结构quosure。quosure将表达式与它的环境绑定在一起，为了方便，我将quosure()函数返回的数据称之为quosure表达式，因为其除了用属性记录其环境以外，其它方面与之前提到的表达式并无区别。eval_tidy函数正是为quosure表达式而设计的，因为在使用data mask时，引入了一个问题：在你执行表达式时，表达式中的变量x的是来源于数据框还是环境呢？为了解决这个问题，eval_tidy可以识别新的语法，即代词前缀。eval_tidy中的表达式可以显式的指定变量的来源-eval_tidy(expr(.data$x + .env$y), df)，这种表达式中使用代词前缀的语法，只有在eval_tidy中可以识别，用于解决在使用data mask时，表达式中歧义的问题。

advanced r - function

Sun, 23 Oct 2022 00:00:00 +0000

关于函数式编程语言，其一，需要有一类函数，也就是函数也是一个数据对象。其二，函数得是pure的。

A pure function satisfies two property:

The output only depends on the inputs, i.e. if you call it again with the same inputs, you get the same outputs. This excludes functions like runif(), read.csv(), or Sys.time() that can return different values.
The function has no side-effects, like changing the value of a global variable, writing to disk, or displaying to the screen. This excludes functions like print(), write.csv() and <-.

函数按其输入以及输出划分，分为普通函数(regular function)，泛函(functionals)，函数工厂(function factories)，函数算子(function operator)。

environment setting

Wed, 17 Aug 2022 00:00:00 +0000

怎么定义环境，按我现在浅薄的认知就是一些参数配置，一个预先定义的值 key = value, 应用或环境在启动时从这里获取变量值，指定应用在执行时其需要的值。环境变量包括全局环境变量以及局部环境变量。全局环境变量，所有都可以获得的变量。局部环境变量，某些可以获得这些值。在写代码时将一些敏感的变量值，独立出来作为预先定义的环境变量文件.env，并将其放入.gitignore，然后将代码上传到gitHub，以防止一些隐私信息泄露。另外初次接触bash脚本的人总是对各种命令感觉奇怪，其实这些命令只是函数的特殊形式，其后面可能会接一些其它东西，这些东西就是函数的参数。

参考：
linux下怎么运行R脚本
 环境变量介绍以及使用 Linux下怎么设置环境变量

advanced r - oop

Sun, 14 Aug 2022 00:00:00 +0000

一切皆是对象。一切皆是函数调用。

以上所谓的对象时指R中所有的数据，包括函数都可以作为对象进行输入，下面所讨论的才是面向对象编程中的对象。

R中有四种面向对象的结构，分别为S3,S4（R语言的前身为S语言）,RC(Reference Class,也称为R5),以及R6。其中前三种为R内置，R6由R6包提供。

当我们讨论面向对象时，我们在讨论什么？首先我们具有一个类（class）的概念，这是一个抽象的集合，犹如当我们在讨论人类时。一个类可以拥有一个子类，犹如当我们讨论黄种人，白种人，黑种人之与人类，反之，人类之与黄种人即为父类。父类与子类之间具有继承关系。一个类如何决定它是该类？这是一个哲学问题，正如我如何定义我。在R中一个类的定义包括属性（filed),方法（methods),其中属性在语言上是一个键值对（key-value pair)的形式，为一个名词性的描述，而方法是动词性的，体现了该类具有的操作。当我们议论某雪，某爱豆时，这就是我们所谓的对象（object)，该对象是由某类实例化而来（initialize)，为一个具体确定的个体。对于类的属性以及方法的修改为modified-in-place,即对其本身的修改，而不是modified-in-copy（复制对象后修改，重新建立name和对象的指向）。当我们讨论赋值 <-时，即是将一个name指向了一个对象，一个对象（针对RC,以及R6)被修改以后，所有指向它的name的值同时发生变化，即许多name共享一个对象，而该对象的修改是modified-in-place,那么通过任何一个指向该对象的name对该对象进行修改，其它指向该对象的name的值也同时发生变化。

以上所讨论的面向对象在RC，以及R6中体现。S3，以及S4中的面向对象是通过泛型函数（generic)实现的。所谓泛型函数，即在一个函数名例如plot下，包括了多个函数Plot.xxxx, plot.yyy, plot.zzz，当我们调用plot函数时，该plot泛函自动识别输入对象的类型从而调用不同的Plot.*** 函数。该面向对象的实现方式，属性和方法进行了分离，在对象中仅定义了属性，而方法通过泛函与对象进行匹配。另外，只有S4对属性的调用使用符号 @。

以下所有的内容来自R语言面向对象编程教程

第一篇基于S3的面向对象

S3用起来简单，但在实际的面向对象编程的过程中，当对象关系有一定的复杂度，S3对象所表达的意义就变得不太清楚。
S3封装的内部函数，可以绕过泛型函数的检查，以直接被调用。
S3参数的class属性，可以被任意设置，没有预处理的检。
S3参数，只能通过调用class属性进行函数调用，其他属性则不会被class()函数执行。
S3参数的class属性有多个值时，调用时会被按照程序赋值顺序来调用第一个合法的函数。

第一节创建S3对象

library(pryr) #辅助工具，用于检查对象类型
#通过变量创建S3对象
x <- 1
attr(x,'class') <- 'foo'
x

attr(x,"class")
class(x)

# 用pryr包的otype函数,检查x的类型
otype(x)

# 通过structure()函数创建S3对象
y <- structure(2,class="foo")
y
attr(y,"class")
class(y)
otype(y)

# 创建一个多类型的S3对象
x <- 1
attr(x,"class") <- c("foo","bar")
class(x)
otype(x)

第二节泛型函数和方法调用

# 用UseMethod()定义teacher泛型函数
teacher <- function(x,...) UseMethod("teacher")
# 用pryr包中ftype()函数，检查teacher类型
ftype(teacher)
[1] "s3" "generic"

# 定义teacher内部函数
teacher.lecture <- function(x,...) print("讲课")
teacher.assignment <- function(x,...) print("布置作业")
teacher.correcting <- function(x,...) print("批改作业")
teacher.default <- function(x,...) print("你不是teacher")

a <- "teacher"
# 给老师变量设置行为
attr(a,"class") <- 'lecture'
# 执行老师的行为
teacher(a)
[1] “讲课”

# 直接调用teacher中定义的行为，虽然没啥用。
teacher.lecture()

第三节查看S3对象的函数

# 查看teacher对象
teacher
function(x,...) Usemethod("teacher")

# 查看teacher对象的内部函数
> methods(teacher)
[1] teacher.assignment teacher.correcting teacher.default teacher.lecture

#通过methods()的generic.function参数，来匹配泛型函数名字
> methods(generic.function = predict)
[1] predict.ar* ......

# 通过methods()的class参数，来匹配类的名字
methods(class=lm)
[1]add1.lm* ......

# 用getAnywhere()函数,查看所有函数
getAnywhere(teacher.lecture)

# 使用getS3method()函数，也同样可以查看不可见的函数
getS3method("predict","ppr")

第四节 s3 对象的继承关系

node <- function(x) UseMethod("node",x)
> node.default <- function(x) "Default node"

#father函数
> node.father <- function(x) c("father")

# son函数，通过NextMethod()函数只想father函数
> node.son <- function(x) c('son',NextMethod())

#定义n1
> n1 <- structure(1,class=c("father"))
# 在node函数中传入n1,执行node.father()函数
> node(n1)
[1] "father"

# 定义n2，设置class属性为两个
> n2 <- structure(1,class=c("son","father"))
# 在node函数中传入n2,执行node.son()函数和node.father()函数
> node(n2)
[1] "son" "father"

第二篇基于S4的面向对象

第一节创建S4对象

# 加载pryr包
library(pryr)

# 基类Shape
setClass("Shape",slots=list(name="character",shape="character"))

# Ellipse继承Shape
setClass("Ellipse",contains = "Shape",slots=list(radius="numeric"),prototype = list(radius=c(1,1),shape="Ellipse"))
# 验证radius参数
setValidity("Ellipse",function(object){
 if(length(object@radius)!=2) stop("It's note Ellipse")
 if(length(which(object@radius<=0))>0) stop("Radius is negative")
})

# Circle继承Ellipse
setClass("Circle",contains = "Ellipse",slots=list(radius="numeric"),prototype=list(radius=1,shape="Circle"))
# 验正radius属性值要大于等于0
setValidity("Circle",function(object){
 if(object@radius <= 0) stop("Radius is negative")
})

# 定义area接口
setGeneric("area",function(obj,...) standardGeneric("area"))

# 定义area的Ellipse实现
setMethod("area","Ellipse",function(obj,...){
 cat("Ellipse Area: \n")
 pi*prod(obj@radius)
})

# 定义area的Circle实现
setMethod("area","Circle",function(obj,...){
 cat("Circle Area:\n")
 pi*obj@radius^2
})

# 创建实例
e1 <- new("Ellipse",name="e1",radius=c(2,5))
e2 <- new("Circle",name="e2",radius=2)

# 计算面积
area(e1)
area(e2)

第二节从一个已经实例化的对象中创建新对象

setClass("Person",slots=list(name="character",age="numeric"))

# 创建一个对象实例n1
n1 <- new("Person",name="n1",age=19)
n1

# 从实例n1中，创建实例n2，并修改name的属性值
n2 <- initialize(n1,name="n2")
n2

第三节访问对象属性

setClass("Person",slots=list(name="character",age="numeric"))
a <- new("Person",name="a")

# 访问S4对象的属性
a@name
## [1] "a"
slot(a,"name")
## [1] "a"
# 错误的访问
#a$name
#a[1]

第四节查看S4对象的函数

library(pryr)
# 检查work的类型
ftype(work)

# 直接查看work函数
work

# 查看work函数的显示定义
showMethod(work)

# 查看Person对象的work函数现实
getMethod("work","Person")

# 检查Person对象有没有work函数
existMethod("work","Person")
hasMethod("work","Person")

第三篇基于RC的面向对象

第一节创建RC对象

# 创建Animal类，包括name属性,构造方法initialize（），叫声方法bark()
Animal <- setRefClass("Animal",
 fields=list(name="character"),
 methods=list(
 initialize = function(name){
 name <<- "Animal"
 },
 bark = function()print("Animal::bark")
 ))

# 创建Cat类，继承Animal类，并重写（overwrite
#)了initialize()和bark()
Cat <- setRefClass("Cat",contains="Animal",
 methods=list(
 initialize = function(name) name <<- 'cat',
 bark = function() print(paste(name,"is miao miao"))
 ))

# 创建Dog类
Dog <- setRefClass("Dog",contains="Animal",
 methods=list(
 initialize = function(name) name <<- 'Dog',
 bark = function() print(paste(name,"is wang wang"))
 ))

# 创建Duck类
Duck<- setRefClass("Duck",contains="Animal",
 methods=list(
 initialize = function(name) name <<- 'Duck',
 bark = function() print(paste(name,"is ga ga"))
 ))


# 创建cat实例
cat <- Cat$new()
cat$name

# cat叫声
cat$bark()

第二节 RC对象实例化后的内置方法，属性，以及辅助函数

内置方法

initialize类的初始化函数，用于设置属性的默认值，只有在类定义的方法中使用。
callSuper调用父类的同名方法，只能在类定义的方法中使用
copy复制实例化对象的所有属性
initFields给对象的属性赋值
field查看属性或给属性赋值
getClass查看对象的类定义
getRefClass()同getClass()
show 查看当前对象
export查看属性值以类为作用域
import 把一个对象的属性值赋值给另一个对象
trace跟踪对象中方法调用，用于程序debug
untrace取消跟踪
usingMethods用于实现方法调用，只能在类定义的方法中使用，这个方法不利于程序的健壮性，所以不建议使用。

内置属性

self 实例化对象自身
.refClassDef类的定义类型

辅助函数

new用于实例化对象
help用于查询类中定义的所有方法
methods列出类中定义的所有方法
fields列出类中定义的所有属性
lock给属性加锁，实例化的对象的属性只允许赋值依次，即赋值变量不可修改
trace跟踪方法
accessors给属性生成get/set方法

第四篇基于R6的面向对象

第一节创建R6类

Person <- R6Class("Person",
 public = list(
 name = NA,
 initialize = function(name,gender){
 self$name <- name
 private$gender <- gender
 },
 hello = function(){
 print(paste("Hello",self$name))
 private$myGender()
 },
 member = function(){
 print(self)
 print(private)
 print(ls(envir = private))
 }
 ),
 private = list(
 gender = NA,
 myGender = function(){
 print(paste(self$name,"is",private$gender))
 }
 ))

conan <- Person$new("Conan","Male")
conan$member()

第二节 R6的主动绑定

主动绑定(Active binding)是R6中一种特殊的函数调用方式，把对函数的访问表现为对属性的访问，主动绑定属于公有成员。在类的定义中，通过设置activate参数实现主动绑定的功能，给Person类增加两个主动绑定的函数activate和rand

advanced r - foundation

Wed, 22 Jun 2022 00:00:00 +0000

Names and values

Name 指向 value;
保留字的问题，可以用反引号实现非合法的命名。

Copy-on-modify:

函数调用，形参(name)指向了值(value)，对象（object).
List（data.frame）的存储形式，每一个元素指向对应的object.
Character vectors -> global string pools.
1:10 -> alternative presentation.

Modify-in-place：

Object with a single binding
Environments(a special data structure)

Garbage collector(gc)：自动内存管理，没必要了解太多。

总结：了解向量name, value之间的关系。实际上在R中想要避免修改对象时复制基本不太可能，除了环境这种特殊的数据结构具有reference semantics, 其它的R对象想要避免复制，只能通过对象仅有一个name(performance optimization)实现, 但是函数调用（除了primitive functions – c functions)总会给R对象引入一个新的name，而且R对于R对象name的计数只用0，1，more，三种，也就是说一旦R对象有了2个name，对R来说该对象就有more个name,即使这时候R对象去掉一个name，对R来说 more -1 = more, 该对象仍有多个name,在修改对象时还是会对其进行复制。

Vectors

这里提到的向量是一类数据结构，是广义的向量，包括原子型向量(atomic vector)以及列表(lists)。
原子型向量和列表有什么区别呢？没有区别，除了原子型向量的每个元素必须相同，所以它们都是向量(Vector)。实际上列表的每个元素也是相同的，因为列表的每个元素都是指向其对象的的reference，只不过列表的每个元素存储的是指向不同对象的箭头。Null和向量的关系？Null代表了空的向量，或者缺失的向量，用于删除向量元素，或者作为函数的默认参数。

属性（attributes)，是向量的额外数据(metadata)，为name-value的结构(list)，通过R对象的箭头指向我们就可以找到它的额外数据。属性一般都是暂时的，除了name(name也是属性，想不到吧）和维度。如果想要永久的保留属性，我们需要通过class属性创建自己的S3 object。

Dimension attributes power atomic vector to matrix and array; list to list-matrices and list-arrays. Class attributes power atomic vector to factors, date, date-times, difftime vectors; list to date.frame and tibble.

tidyverse - loop and iteration

Fri, 17 Jun 2022 00:00:00 +0000

R中的map函数家族以及across函数都可以进行迭代操作。map函数适用于向量，列表，数据框（数据框是列表的特殊形式)多种数据结构，而across函数仅适用于对数据框进行修改操作。考虑map函数以及across函数对数据框的修改作用上来说，map函数适用于当数据框所有列都要同一函数修改的情况，而across函数当与mutate函数连用时适用于对数据框部分列进行同一函数修改，当与summarize函数连用时，适用于对数据框所有列进行修改或者选取指定列进行统计建模。虽然map函数家族也提供了modify_if函数，但是它的选择器写起来复杂，不如across函数的选择简单强大。

mutate函数返回数据框并于原数据框进行并入处理，而summarize函数则是返回生成的新数据框。

函数式编程 - map函数家族

许多函数需要用函数作为参数，称这样的函数为泛函(functionals)。典型的泛函是lapply类函数。这样的函数具有很好的通用性，因为需要进行的操作可以输入一个函数来规定，用输入的函数规定要进行什么样的操作。

... 形参在R函数的形参中，允许有一个特殊的...形参（三个小数点），这在调用泛函类型的函数时起到重要作用。在调用泛函时，所有没有形参与之匹配的实参，不论是带有名字还是不带有名字的，都自动归入这个参数，将会由泛函传递给作为其自变量的函数。 ...参数的类型相当于一个列表，列表元素可以部分有名部分无名，用list(...)可以将其转换成列表再访问。
匿名函数 purrr包为在map()等泛函中使用无名函数提供了简化的写法，将无名函数写成“~ 表达式”格式，表达式就是无名函数定义，用.表示只有一个自变量时的自变量名，用.x和.y表示只有两个自变量时的自变量名，用..1、..2、..3这样的名字表示有多个自变量时的自变量名。
map函数分类

变量个数 map_* map2_*,imap, pmap_*(parallel map)。
返回类型 *_int, *_dbl, *_chr, *_lgl, *_dfc, *dfr, modify, *walk*。
判断筛选 *_if, keep。
多元运算 reduce。

示性函数

some(.x, .p)，对数据列表或向量.x的每一个元素用.p判断，只要至少有一个为真，结果就为真； every(.x, .p)与some类似，但需要所有元素的结果都为真结果才为真。这些函数与any(map_lgl(.x, .p))和all(map_lgl(.x, .p))类似，但是只要在遍历过程中能提前确定返回值就提前结束计算，比如some只要遇到一个真值就不再继续判断， every只要遇到一个假值就不再继续判断。
detect(.x, .p)返回数据.x的元素中第一个用.p判断为真的元素值，而detect_index(.x, .p)返回第一个为真的下标值。
keep(.x, .p)选取数据.x的元素中用.p判断为真的元素的子集； discard(.x, .p)返回不满足条件的元素子集。

在 map 中提取列表元素成员的简写

在map中提取列表元素成员的简写

ggplot2

Wed, 15 Jun 2022 00:00:00 +0000

ggplot设计理念

ggplot: gramer of graphics

ggplot的设计理念是从数据（data)到几何图形(geom_)属性的映射（mapping），当我们绘图时我们所需要考虑的仅仅是哪些数据能够决定最终的图形，例如当绘制箱型图时，我们需要的一个向量的几个分位数便能够决定最终的图形，而定义这种从数据到图形属性的映射则是由标度（scale）决定的，图例就是这一标度的体现;而从一个向量到最终绘图所需要的统计量则是由统计变化（stat_)决定的，当向量没有进行统计变化时，我们称之为等值变化。以上四个部分：数据，统计变化，映射，几何图形，最后加上位置（position）则构成了一个图层（layer)。

统计变化：
几何图形：按功能进行划分：表现数量，表现分布，比较，拟合曲（待续)
图形属性：位置（x,y轴), shape size, color fill, line width line type, alpah group.

除了上面所提到的5个部分，ggplot还有四个部件用于修饰图形：

coord
facet
theme
output

写在ggplot里面，全局映射，写在几何形状里面，比如说geom_point则为局部映射。
图片保存：ggsave.

图层的三种实现方式

图形语法——geom_

Plot, the device containing your data: ggplot(data = mydata)
Specify the type of your graph and the variables to use: +geom_point(ase(x = body weight, y = wingspan))
Add labels and titles: + labs(x = "body weight(g)", y = "wingspan", title = "heavy birds have long wings")
Customize the look of your plot with themes +theme_bw()

统计变化语法——stat_

尽管我们在谈论geom_*()的局限性，从而衬托出stat_*()的强大，但并不意味了后者可以取代前者，因为这不是一个非此即彼的问题，事实上，他们彼此依赖——我们看到stat_summary() 有 geom 参数, geom_*() 也有 stat 参数。在更高的层级上讲，stat_*()和 geom_*() 都只是ggplot里构建图层的layer()函数的一个便利的方法，用曹植的《七步诗》来说, 本是同根生，相煎何太急。

Nightingale

Theme Feature Test

Headings and TOC

Nested Level 3 Heading

与AI相关

Review Summary

AI的问题

miscellaneous tricks in r

ggplot2 advance

layers as object

wrap ggplot2 function

Internals of ggplot2

graph visualization

tidygraph

ggraph

virtual machine profile

recursive operations

wrap ggplot2 function

a bug caused by staying up late

use conda

use git

git configuration

git与github连接

workflow

learning with ai

lazy evaluation in eval function

ggplot2 scales

Position scales and axes

Numeric positions and scales

execute r script in linux

argparse

use rmarkdown to generate pdf in chinese

advanced r - meta programming

序

advanced r - function

environment setting

advanced r - oop

第一篇 基于S3的面向对象

第一节 创建S3对象

第二节 泛型函数和方法调用

第三节 查看S3对象的函数

第四节 s3 对象的继承关系

第二篇 基于S4的面向对象

第一节 创建S4对象

第二节 从一个已经实例化的对象中创建新对象

第三节 访问对象属性

第四节 查看S4对象的函数

第三篇 基于RC的面向对象

第一节 创建RC对象

第二节 RC对象实例化后的内置方法，属性，以及辅助函数

第四篇 基于R6的面向对象

第一节 创建R6类

第二节 R6的主动绑定

advanced r - foundation

Names and values

Vectors

tidyverse - loop and iteration

函数式编程 - map函数家族

ggplot2

ggplot设计理念

图层的三种实现方式

图形语法——geom_

统计变化语法——stat_

`tidygraph`

第一篇基于S3的面向对象

第一节创建S3对象

第二节泛型函数和方法调用

第三节查看S3对象的函数

第二篇基于S4的面向对象

第一节创建S4对象

第二节从一个已经实例化的对象中创建新对象

第三节访问对象属性

第四节查看S4对象的函数

第三篇基于RC的面向对象

第一节创建RC对象

第四篇基于R6的面向对象

第一节创建R6类