dashuai009

katex-wasm

Thu, 05 Mar 2026 00:00:00 GMT

从 JavaScript 到 Rust：katex-wasm 项目的背景、用法与测试实践

在前端数学公式渲染领域，KaTeX 一直是一个非常实用的方案。它以速度快、渲染效果稳定著称，被广泛用于文档系统、在线编辑器、教育平台和技术博客中。katex-wasm 的目标，则是在这个成熟能力之上，尝试走出另一条路线: 用 Rust 重写核心渲染逻辑，并通过 WebAssembly 在浏览器中运行。

这个项目本质上是一个 KaTeX 的 Rust WASM 移植版本。它希望把原本由 JavaScript 完成的 LaTeX 数学公式解析与渲染流程，迁移到 Rust 侧实现，再以 WebAssembly 的形式提供给 Web 页面使用。这样做的意义不只是“换一种语言重写”，更重要的是验证 Rust 在解析器、渲染引擎、跨端复用和工程化交付上的能力。对于需要更强类型约束、可维护性，或者希望将渲染逻辑复用于本地工具链的场景，这种尝试很有价值。

项目背景与定位

katex-wasm 可以理解为一个“Rust + WebAssembly 版 KaTeX”。它保留了 KaTeX 的核心目标: 将 LaTeX 数学表达式转换为浏览器可展示的 HTML（以及相关结构），但实现路径转向了 Rust。

相比单纯封装原版 KaTeX，这个项目的特点在于它同时覆盖了几种使用形态:

浏览器端直接渲染到 DOM 节点
输出 HTML 字符串，便于嵌入前端框架或服务端拼接
提供本地 CLI，支持批量渲染公式文件

这意味着它不只是一个“能跑在浏览器里的 wasm 包”，也是一个带有本地调试、批处理和对比验证能力的工程化项目。

从架构上看，项目大致延续了 KaTeX 的核心处理链路:

parse/ 负责 LaTeX 解析
build/ 负责从解析树构建 DOM/标记结构
dom_tree/ 提供虚拟 DOM 能力
mathML_tree/ 负责 MathML 树生成
settings/ 管理渲染配置
symbols/、metrics/ 等模块提供符号和字体度量支持

这类分层也决定了项目不只是“暴露几个 API”，而是已经具备相对完整的公式渲染引擎雏形。

对外能力与核心 API

当前项目对外暴露的能力比较清晰，主要集中在几个入口函数上。

浏览器/WASM 侧最核心的两个接口是:

render(expression, base_node, options)：直接把公式渲染到指定 DOM 节点
renderToString(expression, settings)：返回渲染后的 HTML 字符串

Rust 侧则保留了纯 Rust 可调用的能力，例如:

render_to_string(expression, settings)：返回 HTML 字符串
render_to_dom_tree(...)：适合更高级的自定义输出场景

这套 API 设计很务实。对于前端集成方，最常见的需求是“直接渲染”或“返回字符串”；对于 Rust 侧开发者，则可以直接复用底层渲染逻辑，而不必强依赖 JS 环境。

另外，项目在错误处理上也做了比较实用的设计。遇到非法公式时，可以根据配置选择:

直接抛错
降级输出带错误样式的节点或 HTML 片段

这使得它更适合接入真实业务，而不是只停留在实验性质的 demo。

如何构建与运行

1. 构建 WASM 包

项目使用 wasm-pack 作为标准构建入口。最基本的构建命令是:

wasm-pack build

如果要生成更适合发布的优化版本，可以使用:

wasm-pack build --release

从工程配置来看，项目已经针对发布场景做了体积优化，例如 cdylib、opt-level = "s"、lto = true，这些都符合 WASM 包体积敏感的常见需求。

2. 本地运行 Demo

仓库内提供了一个 demo 目录，用于在浏览器中验证渲染效果。典型流程如下:

wasm-pack build cd demo npm install npm start

这里有一个实际开发中很重要的点: demo 通过 file:../pkg 直接依赖根目录构建出来的 wasm 包，因此每次修改 Rust 代码后，都需要重新执行一次 wasm-pack build，否则前端不会拿到最新构建产物。

3. 使用 CLI 进行批量渲染

除了浏览器侧使用方式，项目还提供了一个非常实用的 CLI 工具 katex-rs-cli。它支持读取一个文本文件，并按行渲染其中的公式，适合做本地调试、批量验证、覆盖率采样等工作。

常见用法如下:

cargo run --bin katex-rs-cli -- tests/fixtures/formulas.txt

如果只想渲染某一段范围:

cargo run --bin katex-rs-cli -- tests/fixtures/formulas.txt 1 5

如果只关心最终汇总，不看逐条输出:

cargo run --bin katex-rs-cli -- tests/fixtures/formulas.txt 1 5 --summary-only

如果想关闭并行渲染:

cargo run --bin katex-rs-cli -- tests/fixtures/formulas.txt 1 5 --multi-threaded false

这个 CLI 的价值不只是“命令行版渲染器”，更重要的是它把项目从单纯的前端 wasm 包扩展成了一个可调试、可批处理、可做分析的开发工具。

测试与正确性验证

对于这种“复刻已有成熟库”的项目来说，最大的挑战不是“能跑”，而是“行为是否尽量对齐原版”。katex-wasm 在这方面采用了比较务实的测试思路。

1. 常规测试入口

项目文档中给出了两个基础测试入口:

cargo test

以及:

wasm-pack test --headless --firefox

前者面向 Rust 侧测试，后者是 WASM 场景下的浏览器无头测试入口。当前仓库里可以看到基础测试代码和 wasm-bindgen-test 依赖，说明项目已经为浏览器测试预留了标准路径。

不过从当前状态看，这部分还不算特别完整，更适合描述为“已有测试入口和基础用例”，而不是“已经形成一整套完善的自动化测试矩阵”。

2. JS 与 Rust 的差异对比: diff_harness

这个项目目前最有代表性的验证工具，其实是 tests/diff_harness.mjs。

它的思路很直接:

读取一组 LaTeX 公式
分别调用原版 JS KaTeX 和 Rust WASM 版本进行渲染
对比两边的 HTML 输出
输出逐条结果和最终汇总

使用方式如下:

wasm-pack build && node --experimental-wasm-modules tests/diff_harness.mjs tests/fixtures/formulas.txt

也可以指定范围和日志级别:

wasm-pack build && node --experimental-wasm-modules tests/diff_harness.mjs tests/fixtures/formulas.txt 1 5 --log-level summary

这类 diff harness 对移植项目非常重要。因为在“复刻”类工作里，单元测试只能覆盖局部逻辑，真正能说明问题的是: 面对同一输入，Rust 版本的行为与 JS 版本是否一致。

值得一提的是，这个工具并不是做“完全字符串零容忍比较”。它对部分 em 单位数值误差做了容忍处理，这也符合跨实现中浮点和格式细节可能略有差异的现实情况。换句话说，它关注的是“表达含义和渲染结果是否等价”，而不是机械追求字符级完全一致。

覆盖率测试: 有方案，但仍偏手工

“覆盖率测试”是很多项目介绍里容易被写得过满的部分。就 katex-wasm 当前状态而言，更准确的说法是:

仓库已经提供了覆盖率采集说明
可以在本地生成 Rust 代码覆盖率报告
但这套流程目前还是手工执行为主，尚未形成 CI 自动化闭环

项目中已经有一份专门的文档，说明如何通过 katex-rs-cli 驱动覆盖率统计。核心思路是:

使用 RUSTFLAGS="-Cinstrument-coverage" 编译插桩版本
通过 katex-rs-cli 跑一批公式样本
生成 .profraw 数据
用 llvm-profdata 合并
用 llvm-cov 输出终端摘要或 HTML 报告

典型流程类似这样:

RUSTFLAGS="-Cinstrument-coverage"
CARGO_INCREMENTAL=0
LLVM_PROFILE_FILE="coverage/katex-rs-cli-%p-%m.profraw"
CARGO_TARGET_DIR="target/coverage"
cargo run --bin katex-rs-cli -- tests/fixtures/formulas.txt 1 200

然后再用 LLVM 工具生成报告。

这种方案的优点是非常贴近真实代码路径。因为它不是只靠零散单元测试覆盖逻辑，而是通过批量渲染真实公式，让解析器、构建器、错误处理和部分渲染路径一起被执行到。

但也要如实说明它当前的边界:

还没有看到固定的自动化脚本被纳入仓库主流程
还没有稳定的、持续更新的“官方覆盖率基线”
CI 工作流目前主要用于 demo 构建与部署，不包含覆盖率采集步骤

所以更准确的表述应该是: 项目已经具备本地覆盖率统计能力，并且有清晰文档；但覆盖率体系还处于“可用、可执行、待进一步自动化”的阶段。

工程化方面的亮点

如果把这个项目当作一个工程实践来看，除了“Rust 重写 KaTeX”本身，还有几个值得单独写进博客的亮点。

第一是多入口交付。它既能作为浏览器中的 wasm 包使用，也能通过 CLI 做本地渲染和验证，这比单一库形态更实用。

第二是部署链路比较完整。仓库已经配置了 GitHub Pages 的 demo 部署流程，支持在推送到 main 后自动构建并发布。对于展示型项目来说，这能明显降低体验门槛，也有助于外部验证。

第三是对发布场景做了明确优化。Rust 的 profile 配置已经针对 wasm 体积和发布形态做了处理，这说明项目作者不仅关注“功能能不能跑”，也在意“产物是否适合真正交付”。

第四是与原版 KaTeX 的对照意识很强。仓库中保留了 KaTeX/ 目录和差异对比工具，这种做法很符合“复刻项目”的正确姿势: 修复 Rust 逻辑前，先确认 JS 对应行为，而不是凭直觉改。

目前阶段的价值与下一步方向

就当前状态而言，katex-wasm 已经具备了一个原型级到工程验证级项目的主要特征:

有明确的目标和边界
有核心渲染链路
有浏览器和 CLI 两种使用路径
有基础测试和跨实现对比工具
有本地覆盖率采集方案
有 demo 和自动部署能力

它最适合的定位，不是宣传成“已经完整替代原版 KaTeX 的生产级实现”，而是一个正在持续推进的 Rust/WASM 移植工程。它的价值在于:

验证 Rust 在复杂前端基础库移植中的可行性
为后续性能分析、功能补齐和行为对齐提供工程基础
为类似“用 Rust 复刻成熟 JS 库”的实践提供参考样本

如果后续继续演进，我认为几个方向会很关键:

扩充系统化测试用例，尤其是 wasm 场景下的自动化测试。
把 diff_harness 纳入更稳定的回归流程，而不只是开发期手工执行。
将覆盖率采集脚本化，并接入 CI，形成长期可追踪的质量指标。
持续补齐与原版 KaTeX 的行为差异，优先保证语义一致，再考虑输出细节完全对齐。

结语

katex-wasm 是一个很典型、也很有代表性的 Rust WebAssembly 项目: 它不是为了“把某段 JS 机械翻译成 Rust”，而是借一个成熟场景，验证 Rust 在解析、渲染、跨端调用和工程化能力上的整体表现。

从当前仓库状态来看，这个项目已经不仅仅是一个技术尝试。它已经有了可运行的构建链路、可验证的对比工具、可使用的 CLI、可生成的覆盖率报告，以及可展示的 demo。对于关注 Rust、WebAssembly、前端基础设施，或者对“如何复刻一个成熟 JS 库”感兴趣的开发者来说，这都是一个值得持续跟进的项目。

https:// to ssh

Tue, 20 Jan 2026 00:00:00 GMT

#let date = datetime( year: 2026, month: 1, day: 20, ) #metadata(( title: "https:// to ssh", subtitle: [git], author: "dashuai009", description: "git config", pubDate: date.display(), ))<frontmatter>

== backup

Replace git:// with https:// Rewrite any git:// urls to be https:// but, it won't touch sshurls (git@github.com:)

git config --global url."https://github".insteadOf git://github

or replace with ssh

Use ssh instead of https://

git config --global url."git@github.com:".insteadOf "https://github.com/"

c++20中显式的lambda模板参数列表

Sun, 20 Apr 2025 00:00:00 GMT

问题介绍

想临时写个lambda函数，但lambda函数需要是模板化的，而且模板化的参数既不是输入参数也不是输出参数，只是中间过程需要用到的一个类型。这时候需要用到“c++20中的显式模板参数列表”。

先简单写一个结构体，具有类型擦除的特性。

struct Value {
    int _type = 1;         // 0 for char, 1 for int
    void *_data = nullptr; // the length of _data array is 10.
};

Value类型内部通过一个_type来枚举 _data 存储的数据类型。这里用0表示char数组，1表示int数组。其他值可以留作他用。

_data 表示 _type类型的数据，为了简化问题，这里是长度为10的数组，也就是要么是char [10]要么是int [10]。

后续我们会介绍四个函数，一个初始化init函数，初始化Value的_data数组。三个用于数组批量加上一个整数的函数add1、add2和add3。

一个“普通”的lambda：init

为了初始化Value类型的_data，我们希望用T* init(T d)返回一个长度为10的、初始值都为d的指针，可以写成如下lambda：

auto init = [](auto d) {
    auto x = new decltype(d)[10];
    for (int i = 0; i < 10; ++i) {
        x[i] = d;
    }
    return x;
};

ok，没啥问题，这是个用auto模板化的lambda。

初始化的整个代码如下：

// ...

int main() {
    auto init = [](auto d) {
        auto x = new decltype(d)[10];
        for (int i = 0; i < 10; ++i) {
            x[i] = d;
        }
        return x;
    };

    Value v{._type = 0, ._data = nullptr};

    if (v._type == 0) {
        v._data = (void *)init(42);
    } else if (v._type == 1) {
        v._data = (void *)init('a');
    } else {
        std::abort();
    }
    // ...
}

一个不普通的的lambda和对应的模板函数

现在我们希望通过一个add函数，给Value的每个元素加上一个标量。那么可以将”加“的逻辑抽象出来，不然每个_type用if判断一下，就要复制一遍代码。

先来用add1表示都加上1，这是一个普通的模板函数。

template <typename T> void add1(Value data10) {
    T *x = (T *)data10._data;
    for (int i = 0; i < 10; ++i) {
        x[i] += 1;
        std::cout << x[i] << ' ';
    }
    std::cout << '\n';
}

前边的模板参数T只是针对函数内部某处逻辑上用到的。既不是函数的返回参数，也不是输入参数。

普通模板函数没有太大问题。但是这函数可能只会集中在_type是数组的if大法里，这也是我遇到的问题，需要判断这个类型擦除的数据是不是数组，如果是数组则执行add的逻辑，所以希望这个add函数能够离if大法比较近，一眼就能看完lambda的逻辑，而不是跳来跳去。

但是写lambda会遇到问题，这时不太能用auto来表示模板参数。T既不是入参也不是返回参数。通过询问万能的群友，我们可以用一个固定输入为nullptr或者别的什么的参数，通过输入参数表示这个中间用到的模板参数T。代码如下：

auto add2 = [](const Value &data10, auto *_null) {
    auto *x = (decltype(_null))data10._data;
    for (int i = 0; i < 10; ++i) {
        x[i] += 2;
        std::cout << x[i] << ' ';
    }
    std::cout << '\n';
};

最后一个_null表示一个指针，但是不会在运行时用到他的值，只是在编译期间传递入参的类型信息。函数体第一行auto *x = (decltype(_null))data10._data;用到了这个参数。

比如调用时

if (v._type == 1) {
    add1<char>(v);
    add2(v, (char *)nullptr);
}

用(char *)nullptr来指示需要特化的lambda模板。

最后一个lambda

总感觉这个问题还有naiive的方案。搜了一下auto表示lambda的模板参数竟然是c++14的东西，而不是20的，所以c++20对lambda更新了什么？

然后找到了How to provide template arguments to a lambda with a call operator template

就有了如下代码，c++20的lambda的[]和()之间可以写<>了。

auto add3 = []<typename T>(const Value &data10) {
    auto *x = (T *)data10._data;
    for (int i = 0; i < 10; ++i) {
        x[i] += 3;
        std::cout << x[i] << ' ';
    }
    std::cout << '\n';
};

调用时需要写的比较长，也好理解，lambda其实是匿名函数对象，是个对象，不是狭义上的函数。

if (v._type == 0) {
    add1<int>(v);
    add3.template operator()<int>(v);
}

完整代码

https://godbolt.org/z/f5zYbzj35

上边是完整的一个代码，可以修改第27行，

Value v{._type = 1, ._data = nullptr};

改为

Value v{._type = 1, ._data = nullptr};

可以得到int数组的结果。

参考内容

上边这些内容能解决我的问题了，lambda其他的内容也没有深入研究，列一下参考的链接吧

error LNK2019: unresolved external symbol 的另一种原因：MSVC的mangling导致

Thu, 21 Nov 2024 00:00:00 GMT

问题背景

今天又又又遇到了LNK 2019但是死活没找到原因。

简单来说，有一个struct A，在另一个文件中前置声明为了class A，其他文件如果include顺序再玄学一点，就会出现LNK2019。

问题出现的条件：

MSVC编译器。
混用了struct/class的前置声明。
include顺序比较玄学。

最简单的解决方案是从第二点。由于项目需要和项目比较庞大，第一点和第三点无法简单生效。

看个例子

foo.h的代码如下，Foo是个struct

#pragma once

struct Foo {
  int width;
  int height;
};

bar.h的代码如下，struct Foo 被前置声明为 class，后续有函数用到了Foo。

#pragma once

class Foo;

class Bar {
public:
  Bar(const Foo& fo);

  int width;
};

bar.cpp的代码如下，注意这里的include顺序

#include "foo.h"
#include "bar.h"

Bar::Bar(const Foo &f) : width(f.width) {}

main.cpp的代码如下，注意这里的include顺序

#include "bar.h"
#include "foo.h"
#include <iostream>


int main() {
  Foo f;
  f.width = 998244353;
  Bar b(f);
  std::cout << b.width << '\n';
  return 0;
}

cmake_minimum_required(VERSION 3.0)
project(link_error CXX)

add_executable(link_error bar.h foo.h bar.cpp main.cpp)

使用CMake编译运行

cmake -B .\build\ --build
cmake --build ./build

就会遇到如下错误

MSBuild version 17.11.9+a69bbaaf5 for .NET Framework

  bar.cpp
C:\Users\15258\work\mangle_error\bar.h(3,7): warning C4099: 'Foo': type name first seen using 'struct' now seen using 'class' [C:\Users\15258\work\mangle_error\build\link
_error.vcxproj]
  (compiling source file '../bar.cpp')
      C:\Users\15258\work\mangle_error\foo.h(3,8):
      see declaration of 'Foo'

  link_error.vcxproj -> C:\Users\15258\work\mangle_error\build\Debug\link_error.exe
PS C:\Users\15258\work\mangle_error> cmake --build ./build
MSBuild version 17.11.9+a69bbaaf5 for .NET Framework

  bar.cpp
  main.cpp
C:\Users\15258\work\mangle_error\bar.h(3,7): warning C4099: 'Foo': type name first seen using 'struct' now seen using 'class' [C:\Users\15258\work\mangle_error\build\link
_error.vcxproj]
  (compiling source file '../bar.cpp')
      C:\Users\15258\work\mangle_error\foo.h(3,8):
      see declaration of 'Foo'

C:\Users\15258\work\mangle_error\foo.h(3,8): warning C4099: 'Foo': type name first seen using 'class' now seen using 'struct' [C:\Users\15258\work\mangle_error\build\link
_error.vcxproj]
  (compiling source file '../main.cpp')
      C:\Users\15258\work\mangle_error\foo.h(3,8):
      see declaration of 'Foo'

  Generating Code...
main.obj : error LNK2019: unresolved external symbol "public: __cdecl Bar::Bar(class Foo const &)" (??0Bar@@QEAA@AEBVFoo@@@Z) referenced in function main [C:\Users\15258\
work\mangle_error\build\link_error.vcxproj]
C:\Users\15258\work\mangle_error\build\Debug\link_error.exe : fatal error LNK1120: 1 unresolved externals [C:\Users\15258\work\mangle_error\build\link_error.vcxproj]

msvc确实给出两个编译warning和一个error，在我们的项目中由于海量的warning，完全没有注意到这个事情。

注意，bar.cpp和main.cpp的两处include顺序也比较玄学，如果颠倒其中一处，error会消失，同时颠倒两处include不会出现这个问题。

本地测试过wsl的gcc，没有编译错误，听群里大佬说“能混用前置声明的struct/class，msvc的特殊mangling的问题”

可以dump一下bar.obj看看导出的符号：dumpbin.exe /SYMBOLS .\build\link_error.dir\Debug\bar.obj

File Type: COFF OBJECT

COFF SYMBOL TABLE
000 0105854B ABS    notype       Static       | @comp.id
001 80010190 ABS    notype       Static       | @feat.00
002 00000003 ABS    notype       Static       | @vol.md
003 00000000 SECT1  notype       Static       | .drectve
    Section length   30, #relocs    0, #linenums    0, checksum        0
005 00000000 SECT2  notype       Static       | .debug$S
    Section length  2A8, #relocs    4, #linenums    0, checksum        0
007 00000000 SECT3  notype       Static       | .text$mn
    Section length   20, #relocs    0, #linenums    0, checksum 2E748664
009 00000000 SECT3  notype ()    External     | ??0Bar@@QEAA@AEBUFoo@@@Z (public: __cdecl Bar::Bar(struct Foo const &))
00A 00000000 UNDEF  notype ()    External     | _RTC_InitBase
00B 00000000 UNDEF  notype ()    External     | _RTC_Shutdown
00C 00000000 SECT3  notype       Label        | $LN3
00D 00000000 SECT4  notype       Static       | .xdata
    Section length    8, #relocs    0, #linenums    0, checksum 86016890
00F 00000000 SECT4  notype       Static       | $unwind$??0Bar@@QEAA@AEBUFoo@@@Z
010 00000000 SECT5  notype       Static       | .pdata
    Section length    C, #relocs    3, #linenums    0, checksum F9766256
012 00000000 SECT5  notype       Static       | $pdata$??0Bar@@QEAA@AEBUFoo@@@Z
013 00000000 SECT6  notype       Static       | .rtc$IMZ
    Section length    8, #relocs    1, #linenums    0, checksum        0, selection    2 (pick any)
015 00000000 SECT6  notype       Static       | _RTC_InitBase.rtc$IMZ
016 00000000 SECT7  notype       Static       | .rtc$TMZ
    Section length    8, #relocs    1, #linenums    0, checksum        0, selection    2 (pick any)
018 00000000 SECT7  notype       Static       | _RTC_Shutdown.rtc$TMZ
019 00000000 SECT8  notype       Static       | .debug$T
    Section length   64, #relocs    0, #linenums    0, checksum        0
01B 00000000 SECT9  notype       Static       | .chks64
    Section length   48, #relocs    0, #linenums    0, checksum        0

String Table Size = 0xA6 bytes

  Summary

          48 .chks64
         2A8 .debug$S
          64 .debug$T
          30 .drectve
           C .pdata
           8 .rtc$IMZ
           8 .rtc$TMZ
          20 .text$mn
           8 .xdata

通过对比error中的??0Bar@@QEAA@AEBVFoo@@@Z不同于obj中的 ??0Bar@@QEAA@AEBUFoo@@@Z，只有一个字符的差别。看不懂也没关系，编译器和dump都给出了解释public: __cdecl Bar::Bar(class Foo const &)和public: __cdecl Bar::Bar(struct Foo const &)。这时候终于发现是class不同于struct。而Foo实际应该是struct。

我比较喜欢全局搜一些东西，搜Foo的时候，有点印象Foo应该是struct。这才发现有地方写成了class Foo。唉，不管warning的要命。

error LNK2019: unresolved external symbol

这里列一下error lnk2019的其他可能，复制自gpt。

LNK2019: unresolved external symbol 是一个常见的链接错误，表示链接器找不到某个符号（函数、变量等）的定义。通常发生在编译阶段通过了，但链接阶段失败。

错误的本质

编译器：将代码翻译为中间代码（如 .obj 文件）。
链接器：将所有 .obj 文件及库文件链接成可执行文件或动态链接库。

LNK2019 表示：

声明了一个符号（函数、变量等），但链接器找不到它的实现（定义）。

常见原因及解决方法

1. 函数或变量未定义

原因：

函数或变量的声明（如 extern 或头文件中声明）存在，但实现缺失。

解决方法：

确保提供了函数或变量的实现。

// 声明 (通常在头文件)
void myFunction();

// 定义 (通常在 .cpp 文件)
void myFunction() {
    // Implementation
}

2. 忘记链接目标文件或库

原因：

编译的 .cpp 文件未包含在项目中，或未链接所需的库。

解决方法：

确保 .cpp 文件包含在项目中：
- 检查 项目设置，确认所有相关源文件已加入项目。
如果使用第三方库：
- 确保在项目设置中正确添加库路径和库文件：
  - 在 Visual Studio 中：
    - 配置属性 → 链接器 → 输入 → 附加依赖项。
    - 添加所需的 .lib 文件。

3. 函数名或符号修饰不匹配

原因：

C++ 的 符号修饰（Name Mangling） 不一致。可能发生于以下情况：
- 声明和定义的参数列表不匹配。
- 函数声明为 extern "C"，但定义未加修饰。
- 链接库与项目的编译器调用约定不同。

解决方法：

确保声明与定义的函数签名完全一致。

// 声明
extern "C" void myFunction();

// 定义
extern "C" void myFunction() {
    // Implementation
}

4. 缺少模板定义

原因：

如果使用模板类或函数，声明在头文件中，但实现没有在头文件中定义。

解决方法：

将模板实现移到头文件中。

// 在头文件中：
template<typename T>
void myFunction(T value) {
    // Implementation
}

5. 静态库或动态库缺失

原因：

链接器找不到提供符号实现的 .lib 或 .dll 文件。

解决方法：

确保已添加必要的库文件路径：
- 配置属性 → VC++ 目录 → 库目录。
- 配置属性 → 链接器 → 输入 → 附加依赖项。
- 添加相关的 .lib 文件。

6. 调用约定不匹配

原因：

函数声明和定义的调用约定（如 __stdcall, __cdecl）不同。

解决方法：

明确声明和定义使用相同的调用约定：

void __stdcall myFunction(); // 声明
void __stdcall myFunction() { // 定义
    // Implementation
}

7. 编译器设置不一致

原因：

编译器版本或设置不匹配，例如编译器优化、C++ 标准等。

解决方法：

确保所有源文件使用相同的编译器和设置。
在 Visual Studio 中，检查：
- C/C++ → 语言 → C++ 标准。
- 确保链接的库与项目的编译器兼容。

常见示例

示例 1：函数未定义

错误代码：

// main.cpp
void myFunction(); // 声明
int main() {
    myFunction(); // 调用
}

解决方法：在某个 .cpp 文件中定义 myFunction：

void myFunction() {
    // 实现
}

示例 2：忘记链接库

错误代码：

#include <cmath>
int main() {
    double result = sin(3.14); // 使用了数学库
}

解决方法：在链接器中添加 libm.lib（Windows 下默认 msvcrt.lib 已包含）。

排查步骤

确认符号是否已定义，定义的源文件是否加入项目。
检查函数签名、调用约定是否一致。
确认第三方库是否已正确链接。
如果涉及模板，确保实现位于头文件中。
查看错误符号具体内容（如 dumpbin 工具分析 .obj 文件中的符号表）。

通过这些方法，可以有效解决 LNK2019 错误。

配置电脑

Tue, 22 Oct 2024 00:00:00 GMT

#let date = datetime( year: 2024, month: 10, day: 22, ) #metadata(( title: "配置电脑", subtitle: [CEF], author: "dashuai009", description: "一些软件的配置记录", pubDate: date.display(), ))<frontmatter>

== typst

#link("https://github.com/typst/typst")[官方github] windows 安装和更新

winget install --id Typst.Typst

github release里下载typst-x86_64-unknown-linux-musl.tar.xz，然后解压缩，chmod +x typst

== docker

#link("https://docs.docker.com/engine/install/ubuntu/")[docker ubuntu 安装]

for pkg in docker.io docker-doc docker-compose docker-compose-v2 podman-docker containerd runc; do sudo apt-get remove $pkg; done


# Add Docker's official GPG key:
sudo apt-get update
sudo apt-get install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

# Add the repository to Apt sources:
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update


sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

你的电脑上有多少CEF？

Sun, 20 Oct 2024 00:00:00 GMT

#let date = datetime( year: 2024, month: 10, day: 20, ) #metadata(( title: "你的电脑上有多少CEF？", subtitle: [CEF], author: "dashuai009", description: "你的电脑上有多少CEF？", pubDate: date.display(), ))<frontmatter>

最近电脑C盘爆了，

#figure( image("050/imgs1.png", width: 50%), ) 想起来有个项目#link("https://github.com/ShirasawaSama/CefDetectorX")[【升级版-Electron】Check how many CEFs are on your computer. 检测你电脑上有几个CEF.]能检测电脑上装了多少个#link("https://bitbucket.org/chromiumembedded/cef/")[CEF (Chromium Embedded Framework)]。然后。。。。134个。。。。。。。。

#figure( image("050/imgs2.png"), )

黑神话

Sun, 22 Sep 2024 00:00:00 GMT

#let date = datetime( year: 2024, month: 9, day: 22, ) #metadata(( title: "黑神话", subtitle: [qwen,win32com,python-docx,textextract], author: "dashuai009", description: "", pubDate: date.display(), ))<frontmatter>

要打大石敢当，没有精魄浪里个波，回第一章去打青蛙，打完没钱升级。

查攻略刷钱，碎玉池可以。

发现没有变化灰蛰，回沙村门口，这才村口把这个门打开。

发现没有三王子，回浮屠界舔图。

恶心地图，找半天魔将·莲眼，之前就是不想在浮屠界呆着，赶紧跑了。

再回最下面交给三王子。就有了 huizhe，一次三千二灵蕴。

升级精魄，还缺个青蛙，查了一下是浪波波。巴拉巴拉，走到langbobo的门口，进不去，得收集战车。

好好好，马霸天对话，

马哥在五个章节都会出现，必须完成上一章节对话才能在下章节遇到，第五章击败守护道士之前可以回补。

递归失败

使用yalantinglibs中的反射库格式化自定义struct/enum

Sat, 20 Jul 2024 00:00:00 GMT

#let date = datetime( year: 2024, month: 7, day: 20, ) #metadata(( "title": "使用yalantinglibs中的反射库格式化自定义struct/enum", "author": "dashuai009", description: "", pubDate: date.display(), subtitle: [modules,模块], ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

#date.display();

#outline()

yalantinglibs是一个c++20的库集合。 std::formatter是c++20的新特性，用来格式化内容。

这里尝试使用ylt里的反射库实现自定义struct/enum的格式化输出

== std::format的基本用法 === 基本用法头文件#include <format>

一眼看起来和python rust的格式化语法很类似。实际用起来，受限制很多。比如std::format的控制字符串需要编译期检查，没法运行时生成，也没有python的print(f"a = {a}")（这叫啥？），参数只能放到后面std::println("a = {}", a)。

~~总之，比没有好~~。

#include <format>
#include <string>


int main(){
    int a = 42;
    std::string b{"Hello World!"};
    float c = 10.24;
    std::cout << std::format("a = {}, b = {}, c = {:.4f}\n", a, b, c);
    return 0;
}

输出内容

a = 42, b = Hello World!, c = 10.2400

=== 扩展用法

自定义的struct/enum都没有默认支持，需要自定义std::formatter<T>来实现。

具体来说，需要特化std::formatter<T>，并实现他的两个函数

parse() 实现如何解析类型的格式字符串说明符
format() 为自定义类型的对象/值执行实际格式化

#include <iostream>
#include <format>
#include <string>

struct Person {
    std::string name;
    int age;
};

// 定义Person的formatter
template<>
struct std::formatter<Person> {
    static constexpr auto parse(std::format_parse_context& ctx) {
        return ctx.begin();
    }

    auto format(const Person& p, std::format_context& ctx) const {
        return std::format_to(ctx.out(), "Person(name: {}, age: {})", p.name, p.age);
    }
};

int main() {
    Person p{"Alice", 30};
    std::string s = std::format("{}", p);
    std::cout << s << std::endl;

    return 0;
}

输出

Person(name: Alice, age: 30)

=== 其他用法

太多了，不给自己挖坑了。推荐看这个#link("https://github.com/xiaoweiChen/CXX20-The-Complete-Guide")[c++20 compelte guide]

std::vformat() 和 vformat_to()
格式字符串的语法
标准格式说明符：fill align sign # 0 width .prec L type
全局化，语言环境
错误处理
自定义格式
自定义格式的解析格式字符串

== yalantinglibs的reflection

官方示例#link("https://github.com/alibaba/yalantinglibs/blob/main/src/reflection/tests/test_reflection.cpp")[test_reflection]

文章#link("http://www.purecpp.cn/detail?id=2435")[C++20 非常好用的编译期反射库，划重点【没有宏，没有侵入式】]

=== 几个api

constexpr auto sz = ylt::reflection::members_count<S>();获取S的成员个数。编译期计算。
template <typename T, typename Visit> inline constexpr void for_each(Visit func)遍历struct T的每一个成员。

Visit func可以是

[](auto& field) {}
[](auto &field, auto name, auto index) {}
[](auto& field, auto name) {}

constexpr auto type_name = ylt::reflection::type_string<S>();获取S的类型字符串

有这几个就可以写出struct的formatter了。

=== int[]的formatter

直接放代码吧

我遇到的struct都是C的API，所以没有太复杂的类型。

template<int T>
struct std::formatter<int[T]> {
    constexpr auto parse(std::format_parse_context &ctx) {
        return ctx.begin();
    }

    template<typename FormatContext>
    auto format(const int p[T], FormatContext &ctx) const {
        ctx.out() = std::format_to(ctx.out(), "int[{}]{{", T);
        for (int i = 0; i < T; ++i) {
            if (i == T - 1) {
                ctx.out() = std::format_to(ctx.out(), "{}", p[i]);
            } else {
                ctx.out() = std::format_to(ctx.out(), "{}, ", p[i]);
            }
        }
        ctx.out() = std::format_to(ctx.out(), "}}");
        return ctx.out();
    }

};

可以将int[]数组格式化掉。

=== struct的format函数

这里把formatter的parse函数单独实现为一个模板函数。

template<typename S, typename FormatContext>
auto my_struct_format(const S &p, FormatContext &ctx) {
    constexpr auto struct_name = ylt::reflection::type_string<S>();
    ctx.out() = std::format_to(ctx.out(), "{}{{ ", struct_name);
    constexpr auto sz = ylt::reflection::members_count<S>();
    ylt::reflection::for_each(p, [&ctx](auto &field, auto name, auto index) {
        if (index < sz - 1) {
            ctx.out() = std::format_to(ctx.out(), "{}: {}, ", name, field);
        } else {
            ctx.out() = std::format_to(ctx.out(), "{}: {} }}", name, field);
        }
    });
    return ctx.out();
}

首先获取struct的名字，获取结构体成员个数。

再利用ylt::reflection::for_each遍历每个成员和每个值。特判是否是最后一个成员，处理,。

=== enum的format函数

enum没有出现在官方例子里，~~我这瞎搞了半天，看样子是对的~~。

直接贴一下关键APIget_enum_arr的实现吧

// Enumerate the numbers in a integer sequence to see if they are legal enum
// value
template <typename E, std::int64_t... Is>
constexpr inline auto get_enum_arr(
    const std::integer_sequence<std::int64_t, Is...> &) {
  constexpr std::size_t N = sizeof...(Is);
  std::array<std::string_view, N> enum_names = {};
  std::array<E, N> enum_values = {};
  std::size_t num = 0;
  (([&]() {
     constexpr auto res = try_get_enum_name<E, static_cast<E>(Is)>();
     if constexpr (res.first) {
       //  the Is is a valid enum value
       enum_names[num] = res.second;
       enum_values[num] = static_cast<E>(Is);
       ++num;
     }
   })(),
   ...);
  return std::make_tuple(num, enum_values, enum_names);
}

三个返回值：

num: enum的成员个数
enum_values：每个成员的值，是一个数组，大小是可变模板参数Is的多少。
enum_names: 每个成员的名称，是一个数组，大小同上。

这个函数要求传入定长的integer sequence，一般情况enum的枚举个数不一定一样。我这里直接传个20，假设我要格式化的enum的枚举个数都不超过20。看上边这个代码，20这个参数用来申请内存空间的，多了无所谓，预留默认空值。

这样，enum的格式化函数如下。

template<typename S, typename FormatContext>
auto my_enum_format(const S &p, FormatContext &ctx) {
    constexpr auto index_enum_str = ylt::reflection::get_enum_arr<S>(std::make_integer_sequence<int64_t, 20>{});
    constexpr auto enum_name = ylt::reflection::type_string<S>();
    for (int i = 0; i < 20; ++i) {
        if (std::get<1>(index_enum_str)[i] == p) {
            ctx.out() = std::format_to(
                    ctx.out(),
                    "{}::{}(value = {})",
                    // 这个p别忘了强制转为p，不然无限递归了
                    enum_name, std::get<2>(index_enum_str)[i], (int) p
            );
            break;
        }
    }
    return ctx.out();
}

=== 测试

struct S1 {
    int a;
    float b;
    int c[6];
    float d[3];
};

enum E1 {
    XX = 10,
    YY,
    MAX
};

int main() {
    S1 s{.a = 42, .b = 10.24, .c = {0, 1, 4, 9, 16, 25}, .d = {1.1, 2.2, 3.3}};
    std::cout << std::format("s = {}\n", s);
    E1 y = E1::MAX;
    std::cout << std::format("y = {}", y);
    return 0;
}

输出结果如下

s = S1{ a: 42, b: 10.24, c: int[6]{0, 1, 4, 9, 16, 25}, d: float[3]{1.1, 2.2, 3.3} }
y = E1::MAX(value = 12)

== 所有代码

cmake_minimum_required(VERSION 3.15)
project(test_formatter)

set(CMAKE_CXX_STANDARD 20)


include(FetchContent)

FetchContent_Declare(
        yalantinglibs
        GIT_REPOSITORY https://github.com/alibaba/yalantinglibs.git
        GIT_TAG "0.3.5" # optional ( default master / main )
        GIT_SHALLOW 1 # optional ( --depth=1 )
)

FetchContent_MakeAvailable(yalantinglibs)


add_executable(${PROJECT_NAME} main.cpp)
target_link_libraries(${PROJECT_NAME} PRIVATE yalantinglibs::yalantinglibs)
target_compile_features(${PROJECT_NAME} PRIVATE cxx_std_20)

#link("https://pastebin.ubuntu.com/p/kr2T7hDpbs/")[main.cpp pastebin]

== 后

小坑小点还是挺多的。比如std::formatter的特化没法放到某个namespace里。即

namespace test_space{
    struct S{};
    templace<>
    struct std::formatter<S>{
        // ...
    };
}

会编译失败。

虽然达到我想要的结果了，但是有几个点感觉不是清晰。

int[T]的格式化，能再写成个模板好了，可以迭代的容器的格式化。不知道view行不行。
enum的格式化，感觉应该有个api获取enum的格式，在编译期计算，这样传给get_enum_arr就不会多余或者不够了。应该是我没找到相关内容。
每个struct都要写一个宏。MY_STRUCT_FORMAT(S1); MY_ENUM_FORMAT(E1);这样。

唉，不是不能用。

clash 配置chatgpt的rule

Sun, 23 Jun 2024 00:00:00 GMT

#let date = datetime( year: 2024, month: 6, day: 23, )

#metadata(( "title": "clash 配置chatgpt的rule", "author": "dashuai009", description: "这是一种将C++更加现代的代码组织方式。模块是一组源代码文件，独立于导入它们的翻译单元进行编译。", pubDate: date.display(), subtitle: [clash rule], ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

#date.display();

#outline()

= 问题

openai.com检查的内容很多，clash的rule模式一般过不去。我这里必须切到golbal模式才可以访问。找了半天，clash可以配置Parser，在机场提供的配置文件外，添加规则配置。自定义规则可以单独设置，我想要gpt相关的访问全部走美国节点。

= 使用Parser

Parser是针对机场给的配置文件，新增一些规则，这样机场节点少了也可能还可以复用。

clash > Profiles > 右键配置 > Parsers > Edit parsers

向打开的文件添加以下内容。

parsers: # array
  - url: YOUR_URL
    yaml:
      prepend-proxy-groups:
        - name: 🚀 OpenAI
          type: select
          proxies:
            - 美国 A
            - 美国 B
            - 美国 C
            - 美国 D [0.5x]
            - 美国 E [0.5x]
      prepend-rules:
        - DOMAIN,browser-intake-datadoghq.com,🚀 OpenAI
        - DOMAIN,static.cloudflareinsights.com,🚀 OpenAI
        - DOMAIN-SUFFIX,ai.com,🚀 OpenAI
        - DOMAIN-SUFFIX,algolia.net,🚀 OpenAI
        - DOMAIN-SUFFIX,api.statsig.com,🚀 OpenAI
        - DOMAIN-SUFFIX,auth0.com,🚀 OpenAI
        - DOMAIN-SUFFIX,chatgpt.com,🚀 OpenAI
        - DOMAIN-SUFFIX,chatgpt.livekit.cloud,🚀 OpenAI
        - DOMAIN-SUFFIX,client-api.arkoselabs.com,🚀 OpenAI
        - DOMAIN-SUFFIX,events.statsigapi.net,🚀 OpenAI
        - DOMAIN-SUFFIX,featuregates.org,🚀 OpenAI
        - DOMAIN-SUFFIX,host.livekit.cloud,🚀 OpenAI
        - DOMAIN-SUFFIX,identrust.com,🚀 OpenAI
        - DOMAIN-SUFFIX,intercom.io,🚀 OpenAI
        - DOMAIN-SUFFIX,intercomcdn.com,🚀 OpenAI
        - DOMAIN-SUFFIX,launchdarkly.com,🚀 OpenAI
        - DOMAIN-SUFFIX,oaistatic.com,🚀 OpenAI
        - DOMAIN-SUFFIX,oaiusercontent.com,🚀 OpenAI
        - DOMAIN-SUFFIX,observeit.net,🚀 OpenAI
        - DOMAIN-SUFFIX,segment.io,🚀 OpenAI
        - DOMAIN-SUFFIX,sentry.io,🚀 OpenAI
        - DOMAIN-SUFFIX,stripe.com,🚀 OpenAI
        - DOMAIN-SUFFIX,turn.livekit.cloud,🚀 OpenAI
        - DOMAIN-SUFFIX,openai.com,🚀 OpenAI

注意

url后的YOUR_URL就是机场提供的配置链接。
prepend-proxy-groups是将之后定义的组加到已有groxy-groups的前面。新建一个“🚀 OpenAI”的组，之后在Proxies里就能看到新建了这个组。复制想要的proxies的名字列表。
prepend-rules的配置来自#link("https://github.com/blackmatrix7/ios_rule_script/blob/master/rule/Clash/OpenAI/OpenAI.yaml")[这里]
注意：我的配置文件跟上边不太同，去掉了最后三个个IP的配置和DOMAIN-KEYWORD的配置，报了个错忘了是啥了；加上了- DOMAIN-SUFFIX,openai.com,🚀 OpenAI这一行，让openai.com域名也走美国节点。
可能还需要重启一下clash

= Parser配置说明

#table( columns: (1fr, auto), inset: 10pt, align: horizon, table.header("键", "操作"), "append-rules", "数组合并至原配置 rules 数组后", "prepend-rules", " 数组合并至原配置 rules 数组前", "append-proxies", " 数组合并至原配置 proxies 数组后", "prepend-proxies", " 数组合并至原配置 proxies 数组前", "append-proxy-groups", " 数组合并至原配置 proxy-groups 数组后", "prepend-proxy-groups", " 数组合并至原配置 proxy-groups 数组前", "mix-proxy-providers ", "对象合并至原配置 proxy-providers 中", "mix-rule-providers", " 对象合并至原配置 rule-providers 中", "mix-object", " 对象合并至原配置最外层中", "commands ", "在上面操作完成后执行简单命令操作配置文件", )

modules 模块

Mon, 01 Jan 2024 00:00:00 GMT

#let date = datetime( year: 2024, month: 1, day: 1, ) #metadata(( "title": "modules 模块", "author": "dashuai009", description: "这是一种将C++更加现代的代码组织方式。模块是一组源代码文件，独立于导入它们的翻译单元进行编译。", pubDate: date.display(), subtitle: [modules,模块], ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

这是一种将C++更加现代的代码组织方式。模块是一组源代码文件，独立于导入它们的翻译单元进行编译。

= 模块试图解决的问题

头文件
- module几乎解决了头文件编译的难题，比如头文件的重复替换（复杂项目中，如果一个底层头文件被修改，上层引用的头文件都会被重新编译）。使用module之后，这种问题会得到极大的改善。
封装：对外接口的暴露
- 在模块中声明的宏、预处理器指令和未导出的名称在模块外部不可见。它们对导入模块的翻译单元的编译没有影响。您可以按任意顺序导入模块，而无需考虑宏重定义。导入翻译单元中的声明不参与导入模块中的重载解析或名称查找。
编译速度
- 模块编译一次后，结果将存储在描述所有导出的类型、函数和模板的二进制文件中。编译器处理该文件的速度比头文件快得多。而且，编译器可以在项目中导入模块的每个位置重用它。

= 实现细节

todo

= 常见库支持状态

#link("https://arewemodulesyet.org/")["arewemodulesyet"]

Nope!

= 编译器支持状态

todo

= 基本示例

假设我们现在有如下cpp

int square(int i); // 声明一个函数
class Square {
private:
  int value;

public:
  explicit Square(int i) : value{square(i)} {}
  int getValue() const { return value; }
};
template <typename T> Square toSquare(const T &x) { return Square{x}; }
int square(int i) { // 实现平方函数
  return i * i;
}

只需要两步就可以转成一个模块单元： 1. 在第一行添加export module Square;，这相当于导出一个名为Square的模块。 2. 把想要导出的函数前面加上export关键字。

/** modules/mod0/square.ixx **/
export module Square; // declare module  Square
int square(int i);
export class Square {
private:
  int value;

public:
  explicit Square(int i) : value{square(i)} {}
  int getValue() const { return value; }
};
export template <typename T> Square toSquare(const T &x) { return Square{x}; }
int square(int i) { return i * i; }

在主文件中，就可以愉快地import Square啦~。

/*== mod0/main.cpp ==*/
import std;
import Square; // import module `Square`
int main() {
  Square x = toSquare(42);
  std::cout << x.getValue() << '\n';
}

= 我就喜欢写头文件？模块实现单元（module implementation unit）和模块声明单元（module interface unit）

像上边这个例子，属于实现和声明放在一起了，可以写的很pythonic。模块由若干个模块单元（module units）组成。而且模块可以进行分区（partition），或分为子模块。模块单元是包含模块声明的翻译单元（源文件）。类似.h和.cpp，模块分为接口单元和实现单元。

有几种类型的模块单元：

模块接口单元（module interface unit）包含关键词export module，用于导出模块名称和分区（partition）。和.h文件类似。
模块实现单元（implementation unit）是不导出模块名称、分区名称。顾名思义，它用于实现模块。和cpp文件类似。
主模块接口单元（primary module interface unit）是导出模块名称的模块接口单元。模块中必须有一个且只能有一个主模块接口单元。上边这个例子里还没有模块分区，直接export module Square，算是主模块单元。
模块分区接口单元（partition interface unit）是导出模块分区名称的模块接口单元。
模块分区实现单元（partition implementation unit）是模块实现单元，其模块声明中具有模块分区名称，但没有export关键字。

export关键字仅在接口文件中使用。实现文件可以import另一个模块，但不能export任何名称。实现文件可以具有任何扩展名（这一点编译器还有些特殊处理，好像标准里没有规定）。

= 模块和namespace

不像其它语言，模块不会自动添加一个namespace。就像第一个例子，import Square之后，Square里导出的所有东西都被直接暴露。有两种方法可以处理一下，让代码更加规范：

定义一个和模块同名的namespace，

导出命名空间中需要的接口，则命名空间也会被隐式导出，但是命名空间中，没有被导出的接口则不会暴露

export module Square; // declare module ”Square”
namespace Square {
    int square(int i);// not exported
    export class Square {
        // bala bala ...
    };
    export template<typename T>
    Square toSquare(const T& x) {
        // ...
    }
    int square(int i) { // not exported
        // ...
    }
}

显式导出整个命名空间，则命名空间中的所有声明都会被导出。

export module Square; // declare module ”Square”
int square(int i);
export namespace Square {
    class Square {
        // ...
    };
    template<typename T>
    Square toSquare(const T& x) {
        // ...
    }
}
int square(int i) { // not exported
    // ...
}

这样，在主文件中都可以达到以下效果：

import Square;// 这个是模块名，需要和export匹配
int main(){
    Square::Square x = Square::toSquare(42);
    // ::前Square是命名空间的名字，::Square是类名，这块搞清楚，之后写模块就简单了
    std::cout << x.getValue() << '\n';
}

= 多文件

== 模块接口单元与模块实现单元

模块接口单元用于导出模块名、模块接口。按照模块分区（partition），分为主模块接口单元和分区模块接口单元。直观上，如果整个模块叫做mod1，则含有export module mod1;的文件就是主接口单元；其他文件不能导出mod1这个名字。如果其他文件导出了mod1的子模块export module mod1:submod;则该文件是分区接口单元。

先来说没有分区的模块接口单元：

export module Mod1;  // module declaration

import std;

struct Order {
    int count;
    std::string name;
    double price;

    Order(int c, const std::string& n, double p)
            : count{c}, name{n}, price{p} {
    }
};

export class Customer {
private:
    std::string name;
    std::vector<Order> orders;
public:
    Customer(const std::string& n)
            : name{n} {
    }
    void buy(const std::string& ordername, double price) {
        orders.push_back(Order{1, ordername, price});
    }
    void buy(int num, const std::string& ordername, double price) {
        orders.push_back(Order{num, ordername, price});
    }
    double sumPrice() const;
    double averagePrice() const;
    void print() const;
};

第一行，定义并导出模块的名字：

export module Mod1;  // module declaration

第二行，导入标准模块std：

import std;

之后就是常见的类型声明部分，声明一个订单结构体 struct Order，和一个顾客类。相比于普通头文件，唯一多的就是 class Customer前前面的export关键字，表示导出这个类。

struct Order {
    // ...
}

export class Customer {
    // ....
}

简单来说，首先声明并导出一个模块，导入需要的模块，声明需要类型，导出必要的类型。

接下来，需要实现这些类型（或者函数），类似cpp文件，这里我们分成两个实现单元：

实现单元第一行，标明所属模块，module Mod1;表示该单元属于Mod1模块。接着，这个单元实现void Customer::print() const{}函数。具体用到了format函数，这也是c++20的新功能。

module Mod1;         // implementation unit of module Mod1
import std;

void Customer::print() const
{
    // print name:
    std::cout << name << ":\n";
    // print order entries:
    for (const auto& od : orders) {
        std::cout << std::format("{:3} {:14} {:6.2f} {:6.2f}\n",
                                 od.count, od.name, od.price, od.count * od.price);
    }
    // print sum:
    std::cout << std::format("{:25} ------\n", ' ');
    std::cout << std::format("{:25} {:6.2f}\n", "    Sum:", sumPrice());
}

与上边这个类似，这是另一个实现单元：标明属于Mod1模块，实现了两个函数double Customer::sumPrice() const {} 和另一个函数double Customer::averagePrice() const {}

module Mod1;         // implementation unit of module Mod1

double Customer::sumPrice() const {
    double sum = 0.0;
    for (const Order &od: orders) {
        sum += od.count * od.price;
    }
    return sum;
}

double Customer::averagePrice() const {
    if (orders.empty()) {
        return 0.0;
    }
    return sumPrice() / orders.size();
}

实现单元和cpp文件类似。以上三个文件完整定义并实现了Mod1模块。

具体使用模块如下：

import std;
import Mod1;

int main() {
    Customer c1{"Kim"};
    // Order b1(1, "buy", 590.0); // error Order并没有被导出。

    c1.buy("table", 59.90);
    c1.buy(4, "chair", 9.20);

    c1.print();
    std::cout << "  Average: " << c1.averagePrice() << '\n';
}

输出结果为

上边这种定义与实现分离的方式，cmake支持好像还不太好，没编译过去

== 模块内部（internal）单元，模块分区

有接口和实现单元还不够，c++20的module特性还支持模块划分，每个模块还可以被划分为子模块。类似python中import a.b.c;

分区接口的开头如下：

export module Example:part1;

分区实现单元的开头如下：

module Example:part1;

若要访问另一个分区中的声明，分区必须导入它，但它只能使用分区名称，而不是模块名称：

module Example:part2;
import :part1;// 额外注意：这里不能带模块名，Example:part1不行。

主接口单元必须导入并重新导出模块的所有接口分区文件，如下所示：

export module Example;
// export import :part1; // 如果part1不被export，则part1的所有内容对外不可见（包括export的接口）
export import :part2;// 所有part2导出的接口，都会被导出到Example中。

主接口单元可以导入分区实现文件，但无法导出它们。不允许这些文件导出任何名称。这一限制使模块能够在模块内部保留实现详细信息。

具体的例子看modules/mod2

= 子模块submodule

标准里面没有子模块的规定，但是模块名支持. ，他在模块名中没有特殊含义，但是可以从逻辑上划分模块之间的关系。

export module a;
// export import a.c; 没有被export，如果只import a是看不到a.c的。
export import a.b.c;

= 模块和include

While in theory modules could replace all traditional header files with all their flaws, in practice this will never happen.

=== global module fragment

现在，我们可以确定，有export module xxx的就是模块接口单元，没有export关键字，但是有module xxx都是模块实现单元。

c++为了和旧代码兼容(~~为了留住用户~~)，特地兼容了普通的头文件。用到了全局模块片段(global module fragment)

module; // start module unit with global module fragment
#include <string>
#include <vector>
export module Mod1; // module declaration

// bula bula bula

前面三行就是全局模块片段，不看前三行，和前面说过的模块单元是一样的。但是

include进来的指令（#define and #include）可以正常使用和被看到。
不会导出任何东西（包括macros, declarations, definitions）

== importable header

可被导入的头文件。

比如

import <vector>;
import "myheader.h";

include头文件和import模块之间的主要区别在于：头文件中的任何预处理器定义在语句之后的导入程序中都可见。

= 其他

模块的使用可以提高代码的可读性和可维护性，解决了头文件编译的难题，同时也提高了编译速度。
模块分为接口单元和实现单元，可以通过定义同名的命名空间来更加规范地使用模块。
全局模块片段和可导入的头文件也是模块的一部分，可以提高代码的兼容性和可读性。

gltf-transform使用记录

Wed, 11 Oct 2023 00:00:00 GMT

#let date = datetime( year: 2023, month: 10, day: 11, ) #metadata(( title: "gltf-transform使用记录", subtitle: [gltf], author: "dashuai009", description: "", pubDate: date.display(), ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

 -> ~ gltf-transform --help
node:internal/modules/cjs/loader:1075
  const err = new Error(message);
              ^

Error: Cannot find module 'call-bind'
Require stack:
- /home/dashuai/.nvm/versions/node/v18.15.0/lib/node_modules/@gltf-transform/cli/node_modules/@ljharb/through/index.js
    at Module._resolveFilename (node:internal/modules/cjs/loader:1075:15)
    at Module._load (node:internal/modules/cjs/loader:920:27)
    at Module.require (node:internal/modules/cjs/loader:1141:19)
    at require (node:internal/modules/cjs/helpers:110:18)
    at Object.<anonymous> (/home/dashuai/.nvm/versions/node/v18.15.0/lib/node_modules/@gltf-transform/cli/node_modules/@ljharb/through/index.js:4:16)
    at Module._compile (node:internal/modules/cjs/loader:1254:14)
    at Module._extensions..js (node:internal/modules/cjs/loader:1308:10)
    at Module.load (node:internal/modules/cjs/loader:1117:32)
    at Module._load (node:internal/modules/cjs/loader:958:12)
    at ModuleWrap.<anonymous> (node:internal/modules/esm/translators:169:29) {
  code: 'MODULE_NOT_FOUND',
  requireStack: [
    '/home/dashuai/.nvm/versions/node/v18.15.0/lib/node_modules/@gltf-transform/cli/node_modules/@ljharb/through/index.js'
  ]
}

Node.js v18.15.0

以上错误是因为call-bind没有找到，只需要npm install call-bind即可

使用python和qwen处理doc文件

Sun, 20 Aug 2023 00:00:00 GMT

#let date = datetime( year: 2023, month: 8, day: 20, ) #metadata(( title: "使用python和qwen处理doc文件", subtitle: [qwen,win32com,python-docx,textextract], author: "dashuai009", description: "", pubDate: date.display(), ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

今天帮同学处理了一些docx文件，主要是一些会议通知的文件，总共有一千多份doc、docx、pdf、wps等文件。

目标是提取这些会议通知中的时间、地点、名称、主办单位。

这些文本的格式相对统一，比如

通知
一、会议时间：
xxx年xx月xx日xx点
二、会议地点
xxxx
三、xxx

xxx

   【通知单位】
   年月日
这种算是比较好的，还有啥

通知
一、请xxx于xxx月xx日到xxx参加xxx
xxx
xx

两千份通知，横跨半年，至少四种文件格式（pdf、doc、docx、wps），大体格式至少十几种。

手写regex规则是不可能了，这辈子也不可能了。正好想到最近疯狂开源的大模型，文本直接喂给他们，可以帮我总结这些文本。

首先不考虑chatgpt，死贵死贵，2023年8月19日，16K context $0.003 / 1K tokens，两百万文本就要110人民币。其次，数据传到境外，明显不太安全，这里还是有些敏感数据的。

找了一圈，发现qwen和llama2还可以（早一个月遇到这个问题可能还没这好弄，感谢开源人士）。后边这个中文一般般，有#link("https://huggingface.co/LinkSoul/Chinese-Llama-2-7b")[LinkSoul微调的模型]，我用下来效果一般，我这个任务可能不太对付的问题。前边qwen是阿里开源的，看他们公布的对比测试，很能打，阿里出品，看起来靠谱。（注：我只是对于我的文件进行测试，不代表两个相对好坏）

这两个试用都很方便，hugginface真是大大滴好。qwen文档：#link("https://github.com/QwenLM/Qwen")[Qwen-7B/README_CN.md at main · QwenLM/Qwen-7B (github.com)] 第一次用huggingface，还以为要手动一个个下载pytorch_model-0001-0008.bin文件，原来代码里都处理好这些琐事了。直接跑，自动下载。 qwen还依赖flash-attention，官方推荐git clone -b v1.0.8 ，就别用flash-attention2了，安装会遇到编译问题。 == 文件处理找了半天没找到合适的库去读doc文件

textract #link("https://textract.readthedocs.io/en/stable/")[textract 1.6.1 documentation] 这个说是啥都能读，安装好之后会遇到后边这个报错，调用antiword命令处理时有问题。
其他好多库都不太支持doc，只支持docx
批量转#link("https://www.bilibili.com/read/cv3416134/")[【真技术】批量将doc转为docx的方法 - 哔哩哔哩 (bilibili.com)] 有vba和ps的代码
python的win32com库可以实现上一种方法，具体如后边代码
python-docx可以修改和读取docx

Traceback (most recent call last):
  File "C:\Users\15258\.conda\envs\llm\Lib\site-packages\textract\parsers\utils.py", line 87, in run
    pipe = subprocess.Popen(
           ^^^^^^^^^^^^^^^^^
  File "C:\Users\15258\.conda\envs\llm\Lib\subprocess.py", line 1026, in __init__
    self._execute_child(args, executable, preexec_fn, close_fds,
  File "C:\Users\15258\.conda\envs\llm\Lib\subprocess.py", line 1538, in _execute_child
    hp, ht, pid, tid = _winapi.CreateProcess(executable, args,
                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
FileNotFoundError: [WinError 2] The system cannot find the file specified

处理pdf、doc都可以同word打开，然后重新saveas，pdf用word打开时会有个提示，按理来说可以在python加个-y的参数，自动选yes，没找到资料，跑脚本的时候手动点的yes，还好也就二三十个。有些pdf有加密，不让其他程序读取内容，这些处理不了，只能人工。

== 提示QWEN去提取信息简单，直接加用

f"找出以下通知的会议名称、会议时间、会议地点和主办单位，结果用逗号隔开\n{text}"

text是docx文本。

也就三个步骤：

把pdf、doc转成docx
读取docx
文本加提示词喂给qwen 代码

import os
from win32com import client as wc #导入模块
import textract


word = wc.Dispatch("Word.Application") # 打开word应用程序


base_dir = './docs'

def find_all_file(base, extension):
    for root, ds, fs in os.walk(base):
        for f in fs:
            fullname = os.path.join(root, f)
            if f.endswith(extension):
                yield os.path.abspath(fullname)


for file in find_all_file(base_dir, ".pdf"):
    print(file)
    _file = file.replace("pdf", "docx")
    print(_file)
    if not os.path.exists(_file):
        doc = word.Documents.Open(file) #打开word文件
        doc.SaveAs(_file, 12)#另存为后缀为".docx"的文件，其中参数12指docx文件
        doc.Close() #关闭原来word文件

for file in find_all_file(base_dir, ".doc"):
    print(file)
    _file = file.replace("doc", "docx")
    print(_file)
    if not os.path.exists(_file):
        doc = word.Documents.Open(file) #打开word文件
        doc.SaveAs(_file, 12)#另存为后缀为".docx"的文件，其中参数12指docx文件
        doc.Close() #关闭原来word文件

word.Quit()

import os
from docx import Document
from transformers import AutoModelForCausalLM, AutoTokenizer
from transformers.generation import GenerationConfig

# 请注意：分词器默认行为已更改为默认关闭特殊token攻击防护。
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen-7B-Chat", trust_remote_code=True)

# 打开bf16精度，A100、H100、RTX3060、RTX3070等显卡建议启用以节省显存
# model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen-7B-Chat", device_map="auto", trust_remote_code=True, bf16=True).eval()
# 打开fp16精度，V100、P100、T4等显卡建议启用以节省显存
# model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen-7B-Chat", device_map="auto", trust_remote_code=True, fp16=True).eval()
# 使用CPU进行推理，需要约32GB内存
# model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen-7B-Chat", device_map="cpu", trust_remote_code=True).eval()
# 默认使用自动模式，根据设备自动选择精度
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen-7B-Chat", device_map="auto", trust_remote_code=True).eval()

# 可指定不同的生成长度、top_p等相关超参
model.generation_config = GenerationConfig.from_pretrained("Qwen/Qwen-7B-Chat", trust_remote_code=True)


base_dir = './docs' # 通知文件的文件夹
out_file = open("./doc_out2.txt", "w") #结果输出文件
def find_all_file(base): #和上边代码重复了
    for root, ds, fs in os.walk(base):
        for f in fs:
            fullname = os.path.join(root, f)
            if f.endswith('.docx'):
                yield fullname

cnt = 0
for i in find_all_file(base_dir):
    document = Document(i) #读取docx
    text = ""
    for p in document.paragraphs:
        text += p.text #拼接文本
    text_format = f"找出以下通知的会议名称、会议时间、会议地点和主办单位，结果用逗号隔开\n{text}"
    # 问模型
    response, _ = model.chat(tokenizer, text_format, history = None)
    cnt += 1
    print(cnt, i)
    out_file.write("\n" + "==" * 10 + "\n")
    out_file.write(f"file_name = {i}\n") # 输出结果
    out_file.write(response)

== 总结有了large language model，这种任务一下子简单很多。

结果上，对于比较规整的文件，提取结果非常好。不太规整的文件，人力不好做，大模型也整不明白。

以我的经验，gpt4能把这个任务做的很好，qwen这些开源的7b模型，还是不如人意，比如

输出了多余的提示信息，”您好”、”结果如下“等等
分不清楚主办单位和被通知人，源文件确实复杂
吃内存，4090 24G显存，也就处理4k左右的中文文本，多了爆显存

windows只用键盘如何打开蓝牙，连接蓝牙鼠标？

Sat, 17 Jun 2023 00:00:00 GMT

#let date = datetime( year: 2023, month: 6, day: 17, ) #metadata(( title: "windows只用键盘如何打开蓝牙，连接蓝牙鼠标？", subtitle: [windows], author: "dashuai009", description: "", pubDate: date.display(), ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

== 事故描述今天手残了，用蓝牙鼠标把蓝牙关掉了，鼠标直接切断了。电脑上只有有线键盘还连着。

== 恢复我用的windows11，win+i打开设置，用tab和上下键挪到打开蓝牙的地方，用#strong[空格键]打开蓝牙。之前用enter死活打不开，还是上网搜出来，应该用空格键。

使用c++扩展python

Sat, 17 Jun 2023 00:00:00 GMT

#let date = datetime( year: 2023, month: 6, day: 17, ) #metadata(( title: "使用c++扩展python", subtitle: [cpython,c++], author: "dashuai009", description: "", pubDate: date.display(), ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

= 简介 c++可以编写python的扩展库。

Extending Python with C or C++ — Python 3.11.4 documentation

= 开发环境

linux 下需要安装python3-dev

= CMAKE编写这里给出test.cpp编写的python模块和测试用的test.py

编译与执行

mkdir build

cmake -S . -B ./build

cmake --build ./build

python3 test.py

cmake_minimum_required(VERSION 3.12) # 3.12才可以find_package(python)
project(test_cp)

find_package (Python REQUIRED Interpreter Development)

set(test_cpp_demo_name "test_cpp") # 定义一个库的名字，同时作为py模块的名字
add_definitions(-DPY_MODULE_NAME_STR="${test_cpp_demo_name}")
add_definitions(-DPY_MODULE_NAME=PyInit_${test_cpp_demo_name})


add_library(${test_cpp_demo_name} SHARED test.cpp)
set_target_properties(
        ${test_cpp_demo_name}
        PROPERTIES
        PREFIX "" # 输出前缀没有了
        OUTPUT_NAME ${test_cpp_demo_name}.cpython-310-x86_64-linux-gnu # 注意后边的python版本、平台版本、编译器组织
)
target_include_directories(${test_cpp_demo_name} PRIVATE
        ${Python_INCLUDE_DIRS})

target_link_directories(${test_cpp_demo_name} PRIVATE
        ${Python_LIBRARY_DIRS})

target_link_libraries(${test_cpp_demo_name} PRIVATE
        ${Python_LIBRARIES})

= TEST.CPP 具体可以参考上边给出的链接

#include "Python.h"

//  起一个命名空间
namespace test_cpp {
constexpr int N = 1000;
int f[N];
bool flag = false;
int Fib_impl(int n) {
    if (flag && 0 <= n && n < N) {
        return f[n];
    }
    f[1] = 1;
    for (int i = 2; i < N; ++i) {
        f[i] = f[i - 1] + f[i - 2];
    }
    flag = true;
    return f[n];
}
} // namespace test_cpp

// 给python导出接口
static PyObject *Fib(PyObject * /* unused module reference */, PyObject *o) {
    int n = PyLong_AsLong(o);
    int fn = test_cpp::Fib_impl(n);
    return Py_BuildValue("i", fn);
}

//定义python模块中有哪些函数
static struct PyMethodDef test_cpp_methods[] = {
    {"fast_fib", Fib, METH_O, "fast fib"},
    // Terminate the array with an object containing nulls.
    {nullptr, nullptr, 0, nullptr}};

// 定义模块
static struct PyModuleDef test_cpp_module = {
    PyModuleDef_HEAD_INIT,
    PY_MODULE_NAME_STR, /* name of module */ // python里可以import 这个名字
    nullptr, /* module documentation, may be NULL */
    -1,      /* size of per-interpreter state of the module,
                or -1 if the module keeps state in global variables. */
    test_cpp_methods
    };
//定义模块的初始化函数，import之后会自动执行


// .so的名字要和这个函数的名字、和PyModuleDef里的name对齐
PyMODINIT_FUNC PY_MODULE_NAME(void) {
    PyObject *m;
    m = PyModule_Create(&test_cpp_module);
    if (m == NULL)
        return NULL;
    return m;
}

= PYTHON使用

import sys
# sys.path.append("./build/lib.linux-x86_64-3.10")
sys.path.append("./build")
import test_cpp

a = test_cpp.fast_fib(10);
print(a)

cpp maya plugin example

Wed, 24 May 2023 00:00:00 GMT

#let date = datetime( year: 2023, month: 5, day: 24, ) #metadata(( title: "cpp maya plugin example", subtitle: [MayaPlugin], author: "dashuai009", description: "the examples of cpp maya plugin ", pubDate: date.display(), ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

#link("https://github.com/dashuai009/cpp-maya-plugins")[dashuai009/cpp-maya-plugins]

This is an example collection of cpp maya plugins, sourced from#link("https://help.autodesk.com/view/MAYAUL/2022/ENU/?guid=Maya_SDK_cpp_ref_index_html")[autodesk website];.

#link("https://help.autodesk.com/view/MAYAUL/2022/ENU/?guid=Setting-up-your-build")[Setting-up-your-build]

== how can I get these code? <how-can-i-get-these-code> I use a Python crawler, in cpp_maya_plugins to get these code.

== Develop <develop> First,

cmake_minimum_required(VERSION 3.26)
project(maya_plugins)

set(CMAKE_CXX_STANDARD 17)

# set maya include path
set(MAYA_PATH "C:/Program Files/Autodesk/Maya2022")
include_directories(${MAYA_PATH}/include)
link_directories(${MAYA_PATH}/lib)
set(LINK_FLAGS "/export:initializePlugin /export:uninitializePlugin")
# Maya plug-ins that consist of a single file and are intended for your own individual use or for use within your organization can be distributed by placing the files in a shared directory pointed at by the MAYA_PLUG_IN_PATH in users' Maya.env files.

# You can add several directories to MAYA_PLUG_IN_PATH. Each directory must be separated by a semicolon (;) on Windows or by a colon (:) on macOS and Linux.

set(MAYA_PLUG_IN_PATH "C:/Users/User/work/maya-plugins/out")

add_subdirectory(helloWorld)
add_subdirectory(pickCmd)
add_subdirectory(pluginCallbacks)
add_subdirectory(zoomCameraCmd)

for every single plugin in subdirectry:

cmake_minimum_required(VERSION 3.26)
project(pickCmd)

message(${PROJECT_NAME})
# output a dll
add_library(${PROJECT_NAME} SHARED pickCmd.cpp)

# set the suffix of the output dynamic library to .mll,
# and directly put it into ourself plugin dirs
set_target_properties(
        ${PROJECT_NAME}
        PROPERTIES
            SUFFIX ".mll"
            RUNTIME_OUTPUT_DIRECTORY_DEBUG "${MAYA_PLUG_IN_PATH}/plug-ins") # debug

#set_target_properties(${PROJECT_NAME} PROPERTIES RELEASE_POSTFIX ".mll")

# These two libs are only the core modules of Maya. If you need to use other modules, you need to add other libs, such as OpenMayaUI.lib. You can find all of them in `${MAYA_PATH}/lib`
target_link_libraries(${PROJECT_NAME} Foundation OpenMaya)

== Build <build>

list命令

Sat, 20 May 2023 00:00:00 GMT

#let date = datetime( year: 2023, month: 5, day: 20, ) #metadata(( "title": "list命令", "author": "dashuai009", description: "", pubDate: date.display(), subtitle: [linux,list命令], ))<frontmatter>

#import "../../__template/style.typ": conf #show: conf

= 实验任务

编程实现程序myList.c，列表普通磁盘文件，包括文件名和文件大小。要求能够处理以下几个选项

#table( columns: (auto, auto), table.header("参数", "含义"), -r, [递归方式列出子目录], -a, [列出文件名第一个字符为圆点的普通文件], -l <bytes>, [限定文件大小的最小值（字节）], -h <bytes>, [限定文件大小的最大值（字节）], -m <integer>, [限定文件的最近修改时间必须在n天内], --, [显式地终止命令选项分析], )

= fstat、stat和lstat的区别：

三个函数原型如下

int fstat(int filedes, struct stat *buf);

int stat(const char *path, struct stat *buf);

int lstat(const char *path, struct stat *buf);

fstat系统调用接受的是一个“文件描述符”，而另外两个则直接接受“文件全路径”。文件描述符是需要我们用open系统调用后才能得到的，而文件全路经直接写就可以了。
stat和lstat的区别：当文件是一个符号链接时，lstat返回的是该符号链接本身的信息；而stat返回的是该链接指向的文件的信息。

= 实现步骤

== 选用lstat

能够处理“死链接”，对于符号链接文件，如果链接目标文件不存在，在使用stat函数的情况下，会访问链接的目标文件，导致输出"No such file or directory"。实际上，链接文件link依旧存在，文件大小不为0。而使用fstat不会有这种情况。fstat不会访问目标文件。

== 处理参数

设置以下标志位

#table( columns: (auto, auto), table.header("参数", "含义"), int flag_recurse = 0;, [是否递归遍历子目录，默认为0], int flag_show_hidden = 0;, [是否显示隐藏文件（文件名以.开头）], int min_size = 0;, [文件大小的最小值], int max_size = -1;, [文件大小的最大值，-1表示不受限制], int last_n_days = -1;, [只显示最近n天的文件], )

== 全局变量 #table( columns: (auto, auto), table.header("参数", "含义"), char *target[256];, [输入的目录集合，最多处理256个输入目录], int cntTarget;, [输入目录的个数], char current_dir[] = ".";, [当前目录为'.'，当无输入目录时，默认为当前目录], )

== 所需函数，具体代码在文末

/**

- 满足flag的条件下，输出错误信息并退出整个程序，错误信息存储在可变参数列表...中
- 否则继续正常执行
*/
void handle_error(int flag, int num, ...)

/**
 * 考虑-a参数（是否显示隐藏文件），判断dir是否需要输出
 */
int checkDot(const char *dir)


/**

- 判断文件大小是否符合要求
*/
int checkSize(int fileSize)

/**
 * 判断文件日期是否符合要求
 */
int checkDate(struct timespec ti)

/**

- 输出dir目录，dep是目录深度，这里暂时没有用到
- 输出结果放在一行里
- 输出效果是彩色的。
*/
void myPrint(const char *dir, int dep)

/**
 * 输入是一个目录，
 * 如果设置了-r标志，需要递归遍历
 * 否则只需要输出当前目录
 * 这里使用了lstat，而不是stat，可以处理死链接的情况
 */
void myList(const char *dir, int dep)

/**

- 初始化传入的参数
*/
void init(int argc, char **argv)

主函数

int main(int argc, char **argv) {
    init(argc, argv);
    for (int i = 0; i < cntTarget; ++i) {
        printf("\033[93mSearching  %s\n", target[i]);
        struct stat st;
        int ret = lstat(target[i], &st);
        handle_error(ret == -1, 2, target[i], strerror(errno));
        if (S_ISDIR(st.st_mode)) {//保证遍历的是目录
            myList(target[i]);
        } else {
            myPrint(target[i]);
        }
    }
    return 0;
}

= 编译命令

gcc myList.c -o list

= 运行示例

== ./list

列出默认路径./的文件和文件夹

// <img src="list命令/2021-05-07 17-11-34 的屏幕截图.png" style="zoom:67%;" alt="./list" />

== ./list -r

递归遍历当前目录

// <img src="list命令/2021-05-07 17-11-23 的屏幕截图.png" style="zoom:50%;" alt="./list -r"/>

== ./list ./test/test1 ./test/test2 -a

显示test/test1和test/test2目录下的所有文件，包括隐藏文件

// <img src="list命令/2021-05-02 21-21-43 的屏幕截图.png" style="zoom:50%;" alt="./list ./test/test1 ./test/test2 -a"/>

== ./list .. -l 1000000 -h 3000000

列出父级目录中大于1000000字节，小于3000000字节的文件。通过名利ls -al .. -S可以将父级目录中的文件从大到小排列，得出结果，简单比对即可。

// <img src="list命令/2021-05-02 21-27-58 的屏幕截图.png" style="zoom:50%;" alt="./list .. -l 1000000 -h 3000000"/>

== ./list -r -m 15 ..

递归便利父级目录，列出15天内修改的文件。通过find .. -ctime -15验证，可以的出一样的结果。

// <img src="list命令/2021-05-07 17-12-27 的屏幕截图.png" style="zoom:50%;" alt="./list -r -m 15 .."/>

== ./list ./test/test1 ./test2 -- .. ../..

使用--截断之后的参数分析，之列出前两个参数中的文件。

// <img src="list命令/2021-05-02 21-34-37 的屏幕截图.png" style="zoom:50%;" alt="./list ./test/test1 ./test2 -- .. ../.."/>

= 代码

链接如下

ubuntu paste bin

#include <dirent.h>
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>

int flag_recurse = 0;
int flag_show_hidden = 0;
int min_size = 0;
int max_size = -1;
int last_n_days = -1;
char *target[256];
int cntTarget;
char current_dir[] = ".";
/**

- 满足flag的条件下，输出错误信息并退出整个程序，
- 否则继续正常执行
*/
void handle_error(int flag, int num, ...) {
    if (flag) {
        va_list ap;        // (1) 定义参数列表
        va_start(ap, num); // (2) 初始化参数列表
        printf("\033[91m%sError:");
        for (int i = 0; i < num; ++i) {
            printf("%s ", va_arg(ap, char *));
        }
        printf("\n");
        va_end(ap);
        exit(0);
    }
}

/**

- 考虑-a参数（是否显示隐藏文件），判断dir是否需要输出
*/
int checkDot(const char *dir) {
    if (flag_show_hidden) {
        return 1;
    }
    const char *ptr = strrchr(dir, '/');
    if (ptr == NULL) {
        return dir[0] != '.';
    } else {
        return ptr[1] != '.';
    }
}

/**

- 判断文件大小是否符合要求
*/
int checkSize(int fileSize) {
    return min_size <= fileSize && (max_size == -1 || fileSize <= max_size);
}

/**

- 判断文件日期是否符合要求
*/
int checkDate(struct timespec ti) {
    int lastChange = ti.tv_sec;
    struct timeval t;
    gettimeofday(&t, NULL);
    int currentTime = t.tv_sec;
    return last_n_days == -1 ||
           (currentTime - lastChange) <= 24 * 60 * 60 * last_n_days;
}

/**

- 输出dir目录，
- 输出结果放在一行里，
- 输出效果是彩色的。
*/
void myPrint(const char *dir) { // output in one line
    struct stat st;
    int ret = lstat(dir, &st);
    handle_error(ret == -1, 2, dir, strerror(errno));

    int dotPosition = -1;
    if (checkDot(dir) && checkSize(st.st_size) && checkDate(st.st_ctim)) {
        switch (st.st_mode & S_IFMT) {
        case S_IFBLK:
            printf("\033[32m%15d %s\n", st.st_size, dir); // block device
            break;
        case S_IFCHR:
            printf("\033[33m%15d %s\n", st.st_size, dir); // character device
            break;
        case S_IFDIR:
            printf("\033[95m%15d %s\n", st.st_size, dir); // directory
            break;
        case S_IFIFO:
            printf("\033[32m%15d %s\n", st.st_size, dir); // FIFO/pipe
            break;
        case S_IFLNK:
            printf("\033[32m%15d %s\n", st.st_size, dir); // symlink
            break;
        case S_IFREG:
            printf("\033[96m%15d %s\n", st.st_size, dir); // regular file
            break;
        case S_IFSOCK:
            printf("\033[32m%15d %s\n", st.st_size, dir); // socket
            break;
        default:
            printf("\033[32munknown?\n");
            break;
        }
    }
}

/**

- 输入是一个目录，
- 如果设置了-r标志，需要递归遍历
- 否则只需要输出当前目录
- 这里使用了lstat，而不是stat，可以处理死链接的情况
*/
void myList(const char *dir) {
    DIR *fd = opendir(dir);
    struct dirent *entry;
    while (entry = readdir(fd)) {
        char entry_dir[256];
        sprintf(entry_dir, "%s/%s\0", dir, entry->d_name);

        myPrint(entry_dir);

        struct stat st;
        int ret = lstat(entry_dir, &st);
        handle_error(ret == -1, 2, entry_dir, strerror(errno));
        if (S_ISDIR(st.st_mode)) {
            // printf("%s\n", entry->d_name);
            if (strcmp(entry->d_name, ".") != 0 &&
                strcmp(entry->d_name, "..") != 0 && flag_recurse) {
                myList(entry_dir);
            }
        }
    }
    closedir(fd);
}

/**

- 初始化传入的参数
*/
void init(int argc, char **argv) {
    for (int i = 1; i < argc; ++i) {
        if (strcmp(argv[i], "--") == 0) {
            break;
        } else if (strcmp(argv[i], "-r") == 0) {
            flag_recurse = 1;
        } else if (strcmp(argv[i], "-a") == 0) {
            flag_show_hidden = 1;
        } else if (strcmp(argv[i], "-l") == 0) {
            sscanf(argv[i + 1], "%d", &min_size);
            handle_error(min_size < 0, 1,
                         "The minimum value cannot be less than 0!");
            ++i;
        } else if (strcmp(argv[i], "-h") == 0) {
            sscanf(argv[i + 1], "%d", &max_size);
            handle_error(max_size < 0, 1,
                         "The maximum value cannot be less than 0!");
            ++i;
        } else if (strcmp(argv[i], "-m") == 0) {
            sscanf(argv[i + 1], "%d", &last_n_days);
            handle_error(last_n_days < 0, 1,
                         "The time value cannot be less than 0!");
            ++i;
        } else {
            target[cntTarget++] = argv[i];
        }
    }
    if (cntTarget == 0) {
        target[cntTarget++] = current_dir;
    }
}
int main(int argc, char **argv) {
    init(argc, argv);
    for (int i = 0; i < cntTarget; ++i) {
        printf("\033[93mSearching  %s\n", target[i]);
        struct stat st;
        int ret = lstat(target[i], &st);
        handle_error(ret == -1, 2, target[i], strerror(errno));
        if (S_ISDIR(st.st_mode)) {
            myList(target[i]);
        } else {
            myPrint(target[i]);
        }
    }
    return 0;
}

c++23的std::print简单示例

Thu, 18 May 2023 00:00:00 GMT

#let date = datetime( year: 2023, month: 5, day: 18, ) #metadata(( title: "c++23的std::print简单示例", subtitle: [c++23], author: "dashuai009", description: "", pubDate: date.display(), ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

== 介绍 cpp23中加入了一个标准库std::print，类似python中的print。据说不是基于std::cout，性能应该有保障。

== 支持的编译器目前只有msvc支持了这一标准库。在2023/05/17发布的vs2022 17.7.0 preview1中，加入了#link("https://github.com/microsoft/STL/pull/3337")[相关代码]。

== 示例

import std;

int main() {
    std::vector test{ 10, 2, 3 };
    std::ranges::sort(test);
    for (auto const& [index, value] : std::ranges::enumerate_view(test)) {
        std::println("index = {}, val = {}", index, value);
    }
    return 0;
}

输出

index = 0, val = 2

index = 1, val = 3

index = 2, val = 10

== 看起来不错看起来有点pythonic

[USACO Feb. Gold] Problem1. EQUAL SUM SUBARRAYS

Fri, 03 Mar 2023 00:00:00 GMT

#let date = datetime( year: 2023, month: 3, day: 3, ) #metadata(( title: "[USACO Feb. Gold] Problem1. EQUAL SUM SUBARRAYS", subtitle: [usaco], author: "dashuai009", description: "", pubDate: date.display(), ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

== 题目链接 <题目链接> #link("http://www.usaco.org/index.php?page=viewproblem2&cpid=1305")[USACO]

== 题目描述 <题目描述> 有一个长度为$N$的数组$a$，a的$frac(N (N + 1), 2)$的连续子序列的和各不相同。对于每一个$i$，输出“最少需修改（增大或减少）$a_i$，使得$a$的两个连续子序列的和相等”。

== 题目解析 <题目解析> 首先求出$frac(N (N + 1), 2)$个子数组的和$s_i$，进行排序。每个和对应一个子数组。对于每一个$s_i$，对应于原数组的区间$[l_i , s_i]$，如果通过最少修改$s_i$，让$s_i$等于另一个$s_j$，则$s_j$只能是$s_(i - 1)$或$s_(i + 1)$。维护结果数组$r e s_i$，初始化为最大值，对于每个$s_i$，用$min { lr(|s_i - s_(i - 1)|) , lr(|s_i - s_(i + 1)|) }$去更新$[l_i , r_i]$。最后输出结果即可。

UE4模块系统

Mon, 28 Nov 2022 00:00:00 GMT

#let date = datetime( year: 2022, month: 11, day: 28, ) #metadata(( title: "UE4模块系统", subtitle: [UnrealEngine], author: "dashuai009", description: "详细介绍ue中的模块系统", pubDate: date.display(), ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

参考资料

#link("https://www.youtube.com/watch?v=DqqQ_wiWYOw")[UE4 Modules - YouTube]

#link("https://docs.unrealengine.com/4.27/zh-CN/ProductionPipelines/BuildTools/UnrealBuildTool/")[虚幻编译工具 | 虚幻引擎文档 (unrealengine.com)]

== 简介 <简介> 众所周知，c++17及之前中没有modules概念。模块化的代码的优势有#strong[代码分割];、#strong[代码重用];和#strong[加快编译速度];等。

ue中每个模块都被编译为一个dll，据传ue源代码中有一千多个模块~ ue使用c#编译构建源代码，而不是vs的sln文件。sln仅仅是为了vs方便。所以，如果新建的模块写进C#构建文件后，ubt就可以编译构建，即使sln中不显示新建的ue模块。每次更改.build.cs或者更改了文件夹结构，为了生成sln文件，双击项目目录下的GenerateProject.bat。

== 创建一个模块 <创建一个模块> 每个模块位于一个同名文件夹下，一般来说包含一个Public文件夹、Private文件夹和一个C#构建类。我们创建一个Foo模块，比如说位于Foo文件夹下：

Foo
|--Private
|--Public
|--Foo.build.cs

Public包含可供其他模块引用的头文件（导出类），Private包含cpp源文件及私有头文件。每个.buidl.cs中的模块类需要继承自ModuleRules。Foo.build.cs的最基本的实现如下：

using UnrealBuildTool;

public class Foo : ModuleRules
{
  public FooBar(ReadOnlyTargetRules Target) : base(Target)
  {
     PrivateDependencyModuleNames.AddRange(new string[] {"Core"});
  }
}

== build.cs 中的ModuleRules详解 <build.cs-中的modulerules详解> === 依赖dependency <依赖dependency> PrivateDependencyModuleNames (List<String>) #strong[私有依赖];”：我们的私有代码依赖这些模块，但我们的公共代码不依赖这些模块。

PublicDependencyModuleNames (List<String>) #strong[公共依赖];（不需要路径）（自动执行私有/公共包含）。这些是我们的公共源文件所需要的模块。

添加到依赖中的模块：添加引用模块的public目录到includePath，链接对应的dll（相应的导出函数、类等被引入）。
private依赖不会传递导出的符号：A private/public depends on B，B private depends in C，则A不能看到C的头文件，也不会导入C导出的符号。如果A private/public depends on B，B public depends in C，则A能看到C的头文件，但不会导入C导出的符号。也就是说，B可以public的C的头文件，但始终不能转发链接符号。
如果只是private中的cpp/h依赖了外部模块，建议添加到private dependence中，可以加快编译速度。
Forward declare when you can so you don’t need to mark something as a public dependency.

=== 其他othter <其他othter> #link("https://docs.unrealengine.com/4.27/zh-CN/ProductionPipelines/BuildTools/UnrealBuildTool/ModuleFiles/")[模块 | 虚幻引擎文档 (unrealengine.com)]

== 实现一个模块 <实现一个模块> 现在我们有了一个Foo.build.cs，我们需要用cpp实现它。

=== module.h <module.h> 一般来说，我们要在[YourModuleName]Module.h中声明如下代码（以Foo模块为例）：

#include "Modules/ModuleInterface.h"

class FFooModule : public IModuleInterface
{
public:
    /**
     * Called right after the plugin DLL has been loaded and the plugin object has been created
     */
    virtual void StartupModule();

    /**
     * Called before the plugin is unloaded, right before the plugin object is destroyed.
     */
    virtual void ShutdownModule();

    void DoFoo();
}

FFooModule必须继承自IModuleInterface（位于Modules/ModuleInterface.h）中

=== module.cpp <module.cpp> 在private/FooModule.cpp中实现以下代码：

#include "FooModule.h"
#include "Modules/ModuleManager.h"

IMPLEMENT_MODULE( FFooModule, Foo );

Foo::StartupModule(){
    //do sth right after the dll has been loaded and the static object has been created
    //可以在module中定义一个单例，并在这里初始化
}

Foo::ShutdownModule(){
    // 单例在这析构
}

Foor::DoFoo(){
     //自定义函数
}

IMPLEMENT_MODULE( F[YourModule]Module, Foo) 宏，一个参数是类名（推荐命名方式F[YourModule]Module，第二个是模块名
#strong[IMPLEMENT_GAME_MODULE]
#strong[IMPLEMENT_PRIMARY_GAME_MODULE]
"Modules/ModuleManager.h" 和 "Modules/ModuleInterface.h" 位于Core模块中，这是我们最少依赖的模块。

=== 模块的使用方式 <模块的使用方式> FModuleManager::Get().LoadModuleChecked<FFooModule>(TEXT("Foo")).DoFoo();

== PCH(precompiled headers)预编译头文件 <pchprecompiled-headers预编译头文件> #strong[不推荐使用PCH，初学者可以直接跳过这一节。] 仅适用于代码库比较庞大的情况。

#link("https://learn.microsoft.com/zh-cn/cpp/build/creating-precompiled-header-files?view=msvc-170")[预编译的头文件 | Microsoft Learn]

=== 私有的预编译头文件。 <私有的预编译头文件> 为自己的模块创建的自定义 PCH。使用 PrivatePCHHeaderFile 属性在 Build.cs 文件中定义它。按照惯例，它应该命名为[your-module-name]PrivatePCH.h

using UnrealBuildTool;

public class Foo : ModuleRules
{
  public FooBar(ReadOnlyTargetRules Target) : base(Target)
  {
    PrivatePCHHeaderFile = "FooPrivatePCH.h";//每个模块最多一个pch
    PrivateDependencyModuleNames.AddRange(new string[] {"Core"});
  }
}

Unreal Build Tool 会自动为模块中的所有编译文件注入它。

=== 共享的预编译头文件。 <共享的预编译头文件> 共享 PCH 是指一个模块定义了#strong[给其他依赖模块使用的];预编译头文件。模块本身不能使用它。基础虚幻引擎模块中比较常见（UnrealEd, Engine, Slate, CoreUObject, and Core）。只有引擎模块（engine module可以创建shared PCH）。

您无法选择使用哪一个，虚幻引擎会根据优先级分数从您的模块依赖项之一中为您选择。该优先级分数按模块排序，取决于它依赖的具有共享PCH的其他模块的数量。这是一个有点奇怪的解释，但上面的模块列表已经按优先级排序。例如，如果您的模块依赖于所有五个模块，Unreal将在编译时选择 UnrealEd 的共享 PCH 用于您的模块。

=== 那么什么时候使用哪种预编译头类型呢？ <那么什么时候使用哪种预编译头类型呢> 你实际上有三个选择。

您可以创建自己的私有预编译头文件。

这对于代码库非常大的模块很有用，大型游戏中的主要游戏模块通常就是这种情况。

您必须决定在 PCH 中放入什么以及如何自己平衡它。

您可以使用共享引擎 PCH，这对于所有其他较小的模块来说都是一个不错的选择。

最后，不推荐使用任何 PCH。

这不是很实用，我不知道你为什么要这样做，除非你正在做一些极端的编译调试。

但是你有选择。

因此，让我们看看您在哪里配置这些 PCH 构建设置。

=== 在模块的 Build.cs 文件中设置。 <在模块的-build.cs-文件中设置> 有两个相关的设置来配置它

采用 PCHUsageMode 枚举的 PCHUsage 属性

当您想使用私有 PCH 时，还可以选择 PrivatePCHHeaderFile 属性

这只是标题的字符串路径。

那么，设置PCHUsageMode，我们应该使用哪个设置呢？

嗯，它比 Enum 看起来要简单一些，因为

这三个是遗留的，您应该始终选择 UseExplicitOrSharedPCHs。

该选项默认使用共享 PCH，如果您已通过 PrivatePCHHeaderFile 属性设置，则使用私有 PCH。

从 4.24.2 开始，它实际上已经是默认设置

因此，如果您使用的是在该版本或更高版本上创建的项目，那么您甚至不必设置它。

此设置将来可能会逐步淘汰。

== Include What You Use，通常缩写为 IWYU <include-what-you-use通常缩写为-iwyu> 遵循四个原则

所有头文件包含其所需的依赖性。 #strong[CoreMinimal];头文件包含了UE核心编程环境的常见类型（包括FString、FName、TArray等）。这样，在头文件中首先include该文件，就可以引入这些东西。
Foo.cpp文件首先包含其匹配的Foo.h文件。否则ubt将发出警告（如要禁用，可在模块的*.build.cs文件中将 bEnforceIWYU 设为 false）。
PCH文件已不再是显式包含。
不再包含单块头文件（monolithic header，比如Engine.h、UnrealEd.h）。

=== 启用IWYU <启用iwyu> 在version<=4.23中，IWYU默认不启用，在 .Build.cs 文件中将 PCHMode 属性设置为 UseExplicitOrSharedPCHs 来打开 IWYU。

在version>=4.24.2中，默认启用。具体来说，默认启用是通过#strong[DefaultBuildSettings = BuildSettingsVersion.V2];设置的。该选项做了三件事

PCHUsage gets set to PCHUsageMode.UseExplicitOrSharedPCHs;
#strong[bLegacyPublicIncludePaths] 被设为false，虚幻构建工具会从公共包含路径中省略子文件夹，以减少编译器命令行长度并缩短编译时间。现在必须让每个包含路径都正确。之前你可以只包含Actor.h，现在你必须包含GameFramework/Actor.h。#link("https://docs.unrealengine.com/4.27/zh-CN/ProductionPipelines/BuildTools/UnrealBuildTool/IWYU/IncludeTool/")[包含工具 | 虚幻引擎文档 (unrealengine.com)]
#strong[ShadowVariableWarningLevel gets set to WarningLevel.Error;]

=== 模块日志 <模块日志> === 声明模块日志的类别： <声明模块日志的类别>

DECLARE_LOG_CATEGORY_EXTERN(CategoryName, DefaultVerbosity, CompileTimeVerbosity);

Commonly (Log[ModuleName], Display, All), see Logging/LogVerbosity.h for more.
Declares a category class that extends FLogCategory.
Most practical to put it in its own header file.

=== 定义模块日志的类别（方便过滤）

DEFINE_LOG_CATEGORY(CategoryName);
Instantiates an instance of that log category class, which registers itself with the log suppression system in the constructor.
Put it in the same place where you called IMPLEMENT_MODULE. === 使用模块日志
UE_LOG(Log[ModuleName] Display, TEXT("A wild log appeared!"));

cmake解决visual studio 运行时库链接错误

Sat, 12 Nov 2022 00:00:00 GMT

#let date = datetime( year: 2022, month: 11, day: 12, ) #metadata(( title: "cmake解决visual studio 运行时库链接错误", subtitle: [visual stduio], author: "dashuai009", description: "在visual studio中，连接其他库时会遇到runtime library连接错误，cmake可以设置该参数", pubDate: date.display(), ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

== 错误信息 <错误信息>

Error LNK2038 mismatch detected for 'RuntimeLibrary': value 'MT_StaticRelease' doesn’t match value 'MD_DynamicRelease' in file.obj

在vs中，链接其他库时会遇到这种错误，这是运行时库的版本没有和已有项目对齐。

== RuntimeLibrary是什么 <runtimelibrary是什么>

CRT：C Runtime Library ，C语言运行时库，系统自动为程序加载该库，以便访问C标准函数。同样，C++也有类似的东西。

该库有动态和静态两个版本，现在windows推荐使用动态库。之前还分单线程和线程两种，现在只推荐多线程库。同时，根据是否能调试，总共分为四种库：#strong[多线程静态库，多线程动态库，多线程静态库debug版，多线程动态库debug版];。在vs中通过编译选项控制。

作用：

提供C标准库(如memcpy、printf、malloc等)、C++标准库（STL）的支持。
应用程序添加启动函数，启动函数的主要功能为将要进行的程序初始化，对全局变量进行赋初值，加载用户程序的入口函数。

== 在sln中设置runtimelibrary <在sln中设置runtimelibrary> 项目-> properties -> c/c++ -> code generation -> 改为Multi-threaded(/MT)

#quote[ 我这边的主项目没法修改，默认是/MT。只能把第三方的库编译时选则#strong[静态多线程运行时库];。这样就能接入主项目。 ]

== 在cmake中设置runtimelibrary <在cmake中设置runtimelibrary> cmake中提供了一个变量#link("https://cmake.org/cmake/help/latest/variable/CMAKE_MSVC_RUNTIME_LIBRARY.html")[CMAKE_MSVC_RUNTIME_LIBRARY];可以设置该值。该值有四种值可选

MultiThreaded ，-MT选项
MultiThreadedDLL，-MD选项
MultiThreadedDebug ，-MTd选项
MultiThreadedDebugDLL，-MDd选项

如果设置不正确，会报错（即使是在其他平台下）。设置方法如下：

set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")

（图不放了，很好找

这样在debug/release里使用不同的配置，，在我的问题中，写死set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded")。

== note！！！！！！！！ <note> 上边的都可以不看，这个必须注意

#quote[ Note: This variable has effect only when policy CMP0091 is set to NEW prior to the first project() or enable_language() command that enables a language using a compiler targeting the MSVC ABI. ]

该值必须在第一个project()或enable_language()#strong[之前] 设置规则CMP0091。

也就是说，想要设置该规则，必须在顶级项目（子项目中不行，为了统一所有项目的该值）之前启用该规则。

cmake_mininum_required(VERSION 3.15.0)
if(POLICY CMP0091) # 检测是否可用，也就是cmake的版本是否大于等于3.15
 cmake_policy(SET CMP0091 NEW)
endif()
project(balabala)

if (CMAKE_SYSTEM_NAME  matches "Windows")
 set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded")
endif()

windows cmd切换盘符

Fri, 04 Nov 2022 00:00:00 GMT

#let date = datetime( year: 2022, month: 11, day: 4, ) #metadata(( title: "windows cmd切换盘符", subtitle: [cmd], author: "dashuai009", description: "在windwos里，cmd命令行中，直接输入D:回车，就可以切换盘符。", pubDate: date.display(), ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

在windwos里，cmd命令行中，直接输入D:回车，就可以切换盘符。

之前在win10里死活cd不进D盘，powershell应该没有这种问题。win11没试过。

注意别忘了D后边的冒号。

cmake对c++20 module的支持

Tue, 25 Oct 2022 00:00:00 GMT

#let date = datetime( year: 2022, month: 10, day: 25, ) #metadata(( title: "cmake对c++20 module的支持", subtitle: [c++20,modules,cmake], author: "dashuai009", description: "在cmake中，通过target_source增加了对c++20 module特性的支持。到了3.25版本，这一命令得到大幅改进。看起来是对c++20 module做了应有的支持（编译器不支持的语法，cmake也没办法）。", pubDate: date.display(), ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

== 相关链接 <相关链接> #link("https://zhuanlan.zhihu.com/p/350136757")[知乎孙孟越] 介绍比较详细了，还介绍了 C++ 之父介绍了 modules 的发展进程.

#link("https://github.com/royjacobson/modules-report")[github modules-reportmodules-report]

#link("https://cmake.org/cmake/help/latest/command/target_sources.html")[cmake target_sources]

#link("https://www.youtube.com/watch?v=hkefPcWySzI")[target_sources CMake 2022 C++ Modules and More - Bill Hoffman - CppNow 2022] 22年7月就分享了如何支持module,一直到10月份才出来。

== target_sources <target_sources> 简单示例，上边youtube中的。

#figure( image("037/cmake.png"), caption: [ cmake target_source ], )

== demo <demo> #link("https://www.kitware.com/import-cmake-c20-modules/")[import CMake; C++20 Modules (kitware.com)]

上边是cmake官方给出的例子，比较简单。

我在vs2022 preview 17.6、cmake3.26下测试，模块分区（module internal partition）还不被支持。目前来说（2023.4）c++20的构建系统还不是很完善。

2020ccpc-Weihai威海-D-ABC_Conjecture

Tue, 04 Oct 2022 00:00:00 GMT

#let date = datetime( year: 2022, month: 10, day: 4, ) #metadata(( "title": "2020ccpc-Weihai威海-D-ABC_Conjecture", "author": "dashuai009", description: "", pubDate: date.display(), subtitle: [CCPC, 数论], ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

#date.display();

// #outline()

= 题意

Given a positive integer c, determine if there exists positive integers a, b, such that a + b = c and rad(abc) < c.

where

$ "rad" (n) = product_(p divides n\ p in upright("Prime")) p $

is the product of all distinct prime divisors of n.

== 数据范围

$ 1 lt.eq.slant T lt.eq.slant 10, 1 lt.eq.slant c lt.eq.slant 10^(18) $

= 解析

c=1 输出no
c的质因子的幂均为1, $mu(c)=-1$ 输出no
否则，c的质因子中存在一个幂大于等于2的，输出yes

$ c=p^2k, a=p k, b=p(p-1)k,
a+b=c
a b c= p^4 (p-1) k^3
"rad"(a b c) = "rad"(p^4 (p-1) k^3) ="rad"(p(p-1)k) lt.eq (p-1)k < c $

以上，先筛掉$c$的$10^6$之内的质因子p，如果有输出yes; 否则，$c=p^2$ k中k只能为1，这样判断一下$sqrt(c)$是不是素数即可。

== code

#include <bits/stdc++.h>
#define LL long long
const int N = 1e6 + 20;

LL prime[N];
bool bo[N];
int pcnt;

namespace MillerRabin {
long long Mul(long long a, long long b, long long mo) {
    long long tmp = a * b - (long long)((long double)a / mo * b + 1e-8) * mo;
    return (tmp % mo + mo) % mo;
}

long long Pow(long long a, long long b, long long mo) {
    long long res = 1;
    for (; b; b >>= 1, a = Mul(a, a, mo))
        if (b & 1)
            res = Mul(res, a, mo);
    return res;
}

bool IsPrime(long long n) {
    if (n == 2)
        return 1;
    if (n < 2 || !(n & 1))
        return 0;
    static const auto tester = {2, 3, 5, 7, 11, 13, 17, 19, 23};
    long long x = n - 1;
    int t = 0;
    for (; !(x & 1); x >>= 1)
        ++t;
    for (int p : tester) {
        long long a = p % (n - 1) + 1, res = Pow(a % n, x, n), last = res;
        for (int j = 1; j <= t; ++j) {
            res = Mul(res, res, n);
            if (res == 1 && last != 1 && last != n - 1)
                return 0;
            last = res;
        }
        if (res != 1)
            return 0;
    }
    return 1;
}
} // namespace MillerRabin

namespace PollardRho {
using namespace MillerRabin;
unsigned long long seed;

long long Rand(long long mo) { return (seed += 4179340454199820289ll) % mo; }

long long F(long long x, long long c, long long mo) {
    return (Mul(x, x, mo) + c) % mo;
}

long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }

long long Get(long long c, long long n) {
    long long x = Rand(n), y = F(x, c, n), p = n;
    for (; x != y && (p == n || p == 1);
         x = F(x, c, n), y = F(F(y, c, n), c, n))
        p = x > y ? gcd(n, x - y) : gcd(n, y - x);
    return p;
}

void Divide(long long n, long long p[]) {
    if (n < 2)
        return;
    if (IsPrime(n)) {
        p[++*p] = n;
        return;
    }
    for (;;) {
        long long tmp = Get(Rand(n - 1) + 1, n);
        if (tmp != 1 && tmp != n) {
            Divide(tmp, p);
            Divide(n / tmp, p);
            return;
        }
    }
}
} // namespace PollardRho
void makePrime() {
    for (int i = 2; i < N; ++i) {
        if (!bo[i]) {
            prime[++pcnt] = i;
        }
        for (int j = 1; j <= pcnt && i * prime[j] < N; ++j) {
            bo[i * prime[j]] = true;
            if (i % prime[j]) {
                break;
            }
        }
    }
}

int main() {
    makePrime();
    int T;
    std::cin >> T;
    while (T--) {
        LL c;
        std::cin >> c;
        if (c == 1) {
            std::cout << "no\n";
        } else {
            bool flag = false;
            for (int i = 1; i <= pcnt; ++i) {
                int cnt = 0;
                while (c % prime[i] == 0) {
                    ++cnt;
                    c /= prime[i];
                }
                if (cnt > 1) {
                    flag = true;
                    break;
                }
            }
            if (flag) {
                std::cout << "yes\n";
            } else {
                long long p = sqrt(c);
                if (p * p == c && MillerRabin::IsPrime(p)) {
                    std::cout << "yes\n";
                } else {
                    std::cout << "no\n";
                }
            }
        }
    }
    return 0;
}

梅森素数与完全数

Sun, 02 Oct 2022 00:00:00 GMT

#let date = datetime( year: 2022, month: 10, day: 2, ) #metadata(( title: "梅森素数与完全数", subtitle: [数论], author: "dashuai009", description: "什么是梅森素数，欧几里得完全数公式，$delta$函数的定义，欧拉完全数定理", pubDate: date.display(), ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

== 引入梅森素数 <引入梅森素数> #quote[ 对于整数$a gt.eq 2 , n gt.eq 2$，若$a^n - 1$ 是素数，则$a = 2 , n$ 为素数。 ]

注意反之不一定成立。

注意到，几何级数求和公式 $ a^n - 1 = (a - 1) (a^(n - 1) + a^(n - 2) + dots.h + a + 1) $

若a>2，则$a - 1 > 1 , a - 1 | (a^n - 1)$，与$a^n - 1$是素数冲突。

若n为合数，假设$n = m k$，由上式，

$ a^n - 1 & = (a^m)^k - 1
& = ((a^m) - 1) ((a^m)^(k - 1) + dots.h + a^m + 1) $

所以$a^m - 1 > 1 , a^m - 1 | (a^n - 1)$，冲突。

得证。

#quote[ 对于整数$a gt.eq 2 , n gt.eq 2$，若$a^n + 1$ 是素数，则$n$ 为2的幂次。 ]

证明类似，用到$a^n+1$的公式。

== 梅森素数

我们将形容如$a^p - 1$的素数称为梅森素数。

有无穷多个梅森素数吗？现在仍不知道

== 什么是完全数

#quote[ 真因数之和等于他本身。 ]

比如6=1+2+3，28=1+2+4+7+14

== 欧几里得完全数公式

#quote[ 如果$2^p - 1$是素数，则$2^(p - 1) (2^p - 1)$是完全数 ]

== $sigma$函数

=== 定义 $ sigma (n) = n 的所有因数之和（包括 1 和 n ） $

=== 性质 <性质>

如果p是素数，$k gt.eq 1$，则

$ sigma (p^k) = sum_(i = 0)^n p^i = frac(p^(k + 1) - 1, p - 1) $

如果$gcd (m , n) = 1$，则$sigma (m n) = sigma (n) sigma (m)$

=== 证明

瞪眼法

== 欧拉完全数定理 <欧拉完全数定理> 如果n是偶完全数，则n形如$n = 2^(p - 1) (2^p - 1)$，其中 $2^p - 1$是梅森素数。

=== 证明 <证明> 将偶数中的2都分解出来，则$n = 2^k m$，其中$k gt.eq 1$且m是奇数。则 $ sigma (n) = & sigma (2^k m)
= & sigma (2^k) sigma (m)
= & (2^(k + 1) - 1) sigma (m) $

又n为完全数，则$sigma (n) = 2 n = 2^(k + 1) m$。所以，

$ 2^(k + 1) m = (2^(k + 1) - 1) sigma (m) $

即$2^(k + 1) | (2^(k + 1) - 1) sigma (m)$，即$2^(k + 1) | sigma (m)$。也就是说存在整倍数c，使得$sigma (m) = 2^(k + 1) c$。

#set math.equation(numbering: "(1)") 即 $ 2^{k+1}m=(2^{k+1}-1)\sigma(m)=(2^{k+1}-1)2^{k+1}c $

即

$ m = (2^(k + 1) - 1) c med 且 med sigma (m) = 2^(k + 1) c $

下面，我们来证明c=1.反证法，先假设c>1。

则m至少有三个不同的因数$1 , c , m$。 $ sigma (m) gt.eq 1 + c + m = 1 + c + (2^(k + 1) - 1) c = 1 + 2^(k + 1) c $

又由(1)得， $ 2^(k + 1) c gt.eq 1 + 2^(k + 1) c $ 显然，这是荒谬的。故假设不成立，c因该等于1 。这样，我们得知 $ m = (2^(k + 1) - 1) ，且 sigma (m) = 2^(k + 1) = 1 + m $

后半部分说明m为质数（因数只有1，m）。所以，如果n为偶完全数，则 $ n = 2^k (2^(k + 1) - 1) ，其中 2^(k + 1) - 1 是素数。 $ 。再由梅森素数的定义，原定理得证。

== 奇完全数

存在吗？现在不知。

== 定理

设 $p$ 和 $q$ 是奇素数。若 $p$ 整除 $M_q$ ，则 $p e.not 1 (mod p)$ 且 $p eq.not plus.minus 1 (mod 8)$。

=== 证明

== Pollard's p - 1 algorithm

linux缺页中断次数统计

Fri, 09 Sep 2022 00:00:00 GMT

#let date = datetime( year: 2022, month: 9, day: 9, ) #metadata(( "title": "linux缺页中断次数统计", "author": "dashuai009", description: "", pubDate: date.display(), subtitle: [linux,缺页中断], ))<frontmatter>

#import "../../__template/style.typ": conf #show: conf

#date.display(); #outline()

= 描述

修改内核源代码，使得内核自启动以后，统计发生缺页的次数。

编写程序，输出内核启动时间，和内核统计到的缺页中断次数。

= 实验环境

openeuler20.03LTS qemu x86_64

= 统计次数

== 声明计数变量

在内核文件arch/x86/mm/fault.c中定义了do_page_fault()函数，这是操作系统处理缺页中断的入口。

只需要在这里添加一个计数变量unsigned long pfcount，并在每次执行do_page_fault()时，使计数变量加一。

== 声明为全局变量

在内核文件include/linux/mm.h中，将pfcount声明为全局变量。

== 导出到内核变量全局符号表中

在内核文件kernel/kallsyms.c中，最后一行添加EXPORT_SYMBOL_GPL(pfcount)

EXPORT_SYMBOL_GPL 导出的符号只能被GPL协议的模块读取。 = 重新编译内核

make & make modules_install & make install

这一步真是一言难尽～～之前三步的修改会导致整个内核几乎重新编译一遍。（修改的内容太底层，不是模块方式加载进去）

= 编写模块输出统计变量

编写如下pf.c文件

这里将当前日期和缺页次数，输出到了/proc/pfcount。这里用到了/proc文件系统。之后可以直接通过cat /proc/pfcount直接查看当前的信息。

#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/proc_fs.h>
#include <linux/rtc.h>
#include <linux/time.h>
#include <linux/module.h>
#define BUFSIZE 512
MODULE_LICENSE("GPL");

struct timeval tv;
struct rtc_time tm;

static struct proc_dir_entry *pf;

static ssize_t read_pfcount(struct file *f, char __user *ubuf, size_t count,
                            loff_t *ppos) {

        char buf[BUFSIZE];
        int len=0;
    int year, mon, day, hour, min, sec;
        //printk( KERN_DEBUG "read handler\n");
        if(*ppos > 0 || count < BUFSIZE)
                return 0;

    do_gettimeofday(&tv);
    rtc_time_to_tm(tv.tv_sec, &tm);
    year = tm.tm_year + 1900;
    mon = tm.tm_mon + 1;
    day = tm.tm_mday;
    hour = tm.tm_hour + 8;
    min = tm.tm_min;
    sec = tm.tm_sec;
    len=sprintf(buf,"Current time: %d-%02d-%02d %02d:%02d:%02d pfcount = %ld\n", year,
           mon, day, hour, min, sec, pfcount);

        if(copy_to_user(ubuf,buf,len))
                return -EFAULT;
        *ppos = len;
    return len;
}
static ssize_t write_pfcount(struct file *f, const char __user *buf, size_t len,
                             loff_t *off) {
    printk(KERN_DEBUG "test\n");
    return -1;
}
static const struct file_operations myProc = {
    .owner = THIS_MODULE,
    .write = write_pfcount,
    .read = read_pfcount,
};

static int __init myproc_init(void) {
    printk("Start pf modules...\n");

    pf = proc_create("pfcount", 0660, NULL, &myProc);
    if (pf == NULL)
        return -ENOMEM;
    return 0;
}

static void __exit myproc_exit(void) {
    printk("Exit pf module...\n");
    proc_remove(pf);
}

module_init(myproc_init);
module_exit(myproc_exit);

= 加载并执行模块

执行结果

可以看到系统在09:22:17~09:31:13的536秒中，缺页中断发生了2826616-1693154=1133462次。

= 本次实验的缺点

== volatile

有地方这样写声明全局变量 extern unsigned long volatile pfcount;

volatile 的作用

我这里没有加volatile关键字，不知道有没有影响。~~（编译一次太费劲了）~~

使用g++编译cpp20的module文件

Tue, 06 Sep 2022 00:00:00 GMT

#let date = datetime( year: 2022, month: 9, day: 6, )

#metadata(( title: "使用g++编译cpp20的module文件", subtitle: [c++20], author: "dashuai009", description: "本文简单给出了两个文件，使用了c++20 的module特性，并说明了如何使用g++进行编译。", pubDate: date.display(), ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

== 简介 <简介> 简单记录一下初次尝试c++20中module特性的过程。包括一个main.cpp和子模块 test_include.cxx。编译器为gnu的g++12.2。编译环境是wsl2-arch，glibc>=2.36（g++12.2要求的）。

== demo结构 <demo结构> 两个文件，main.cpp 和子模块 test_include.cxx。直接上代码：

#quote[ main.cpp ]

import TestInclude;//引入TestInclude模块

int main(){
    TestInclude::push(1);// 这个TestInclude是命名空间的名字，不是模块名！！！
    TestInclude::push(3);
    TestInclude::push(2);
    TestInclude::print();
    // std::cout << "error\n"; //美滋滋地把std::cout 隐藏起来， 如果用include这个cout会自动引入
    return 0;
}

#quote[ test_include.cxx ]

//本模块定义一个私有的全局vector，对外导出两个接口，push和print
module;//这一行不能少！
#include<vector>
#include<iostream>

export module TestInclude; //声明一下模块名字

std::vector<int32_t> staticVec;//

export namespace TestInclude{//导出接口外边套一层namespace
    void push(int32_t x){
        staticVec.push_back(x);
    }

    void print(){
        for (auto x:staticVec){
            std::cout << x << ' ';
        }
        std::cout << '\n';
    }
}

== 编译运行 <编译运行> 编译命令 g++ test_include.cxx main.cpp -o o -std=c++20 -fmodules-ts

执行./o 可以如期输出1 3 2

== 总结 <总结>

编译命令需要添加-std=c++20和-fmodules-rs。现在g++编译错误提示还可以，#strike[-fmodule-ts我现在还不知道为什么]
main.cpp是找不到std::cout的，这种module的特性应该大有可为！！封装c库？
test_include.cxx 中手动控制了#strong[模块名];和一个#strong[默认导出的命名空间];同为TestInclude，算是强行伪装了rust中文件名即模块名的特点。利用一个默认导出的命名空间可以规范模块导出的接口，这个意义更为重要，估计会出现在很多编码规范中！（或者限制在某一个命名空间中导出，效果类似，个人更倾向上边这种，export个数少）
g++还可以使用g++ -c -xc++ test_include.cxx -fmodules-ts单独编译某个模块。会生成gcm.cache/TestInclude.gcm和 test_include.o的缓存文件，据说可以加快编译速度。emmm期待编译工具链的支持。

素数的计数

Sat, 03 Sep 2022 00:00:00 GMT

#let date = datetime( year: 2022, month: 9, day: 3, ) #metadata(( title: "素数的计数", subtitle: [math,数论], author: "dashuai009", description: "存在无求多个素数、存在无穷多个模4余3的素数、算术级数的素数狄利克雷定理、素数定理、哥得巴赫猜想、孪生素数猜想、N方+1猜想", pubDate: date.display(), ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

== 无穷多个素数定理 <无穷多个素数定理> 存在无穷多个素数

=== 证明 <证明> 瞪眼法

== 模4余3定理 <模4余3定理> 存在无穷多个模4余3的素数

=== 证明 <证明-1> 假设我们已经有几个模4余3的素数，证明思路：从这几个素数出发可以#strong[不断找到新的];模4余3的素数。

假设初始表为$P_r = { 3 , p_1 , p_2 , p_3 , dots.h , p_r }$，考虑 #set math.equation(numbering: "(1)") $ A=4p_1p_2...p_r+3 $ ，先将其分解为若干个素数乘积， $ A=q_1q_2...q_s, $ ，我们可以得到以下来两个断言。

素数$q_1 , q_2 , dots.h , q_r$至少有一个必定是模4余3

如果该断言不成立，则这s个素数模4余1，那么A应该模4余1，这与(1)相悖
假设$q_i equiv 3 (m o d med 4)$，则$q_i$不在最初的表中，

从(2)可以得到$q_i | A$，但是$3 , p_1 , dots.h , p_r$没有一个整除A的。所以我们得到了一个新的模4余3的素数。

重复以上两步，我们可以得到#strong[无穷多个模4余3的素数]

// #set math.equation(numbering: "") === "模4余1"还能这样求吗？

不能，试一下就可以发现。无法得到无穷多个。

== 算数级数的素数狄利克雷定理 <算数级数的素数狄利克雷定理> 假设a和m是整数，$g c d (a , m) = 1$，则存在无穷多个素数模m余a,即存在无穷多个素数p满足 $ p equiv a (m o d med p) $

=== 证明 <证明-2> 前边证明了(a,m)=(4,1)的情况。其他情况，我不会。

== 素数定理 <素数定理> 当x很大时，小于x的素数的个数近似等于$x / ln (x)$.也就是 $ lim_(x arrow.r oo) frac(pi (x), x / ln (x)) = 1 $

== 三个猜想 <三个猜想> === 歌德巴赫猜想 <歌德巴赫猜想> 每个偶数$n gt.eq 1$可以表示为两个素数之和。

=== 孪生素数猜想 <孪生素数猜想> 存在无穷多个素数p使得p+2也是素数。

=== $N^2 + 1$猜想 <n21猜想> 存在无穷多个形如$N^2 + 1$的素数。

欧拉函数与中国剩余定理

Thu, 01 Sep 2022 00:00:00 GMT

#let date = datetime( year: 2022, month: 9, day: 1, ) #metadata(( title: "欧拉函数与中国剩余定理", subtitle: [math,数论,中国剩余定理], author: "dashuai009", description: "欧拉函数与中国剩余定理", pubDate: date.display(), ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

== $phi.alt$函数公式 <phi函数公式>

如果p是素数，且$k gt.eq 1$，则 $ phi.alt (p^k) = p^k - p^(k - 1) $
如果$g c d (m , n) = 1$，则$phi.alt (m n) = phi.alt (m) phi.alt (n)$

== 证明 <证明> 瞪眼法可得证。

== 中国剩余定理 <中国剩余定理> 设$a_1 , a_2 , dots.h , a_k$是任意整数，且$n_1 , n_2 , dots.h , n_k$两两互素，则同余方程组 $ {( x equiv a_1 (#h(0em) mod med n_1)
x equiv a_2 (#h(0em) mod med n_2)
dots.h
x equiv a_k (#h(0em) mod med n_k) ) $ 有解。令$N = product_(i = 1)^k n_i$，则同余方程组的解在模N下，唯一。

唯一为：

$ x = (sum_(i = 1)^k a_i N / n_i m_i) #h(0em) mod med N $

其中$m_i$为$N / n_i$在模$n_i$下的逆元

欧拉公式

Mon, 29 Aug 2022 00:00:00 GMT

#let date = datetime( year: 2022, month: 8, day: 29, ) #metadata(( title: "欧拉公式", subtitle: [math,数论], author: "dashuai009", description: "欧拉公式及其证明", pubDate: date.display(), ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

== 欧拉函数 <欧拉函数> 在1~m中与m互素的整数的个数，记作$phi.alt (m)$

$ phi.alt (m) = {a | 1 lt.eq a lt.eq m , gcd (a , m) = 1} $

显然，$phi.alt (1) = 0 , phi.alt (p) = p - 1$

== 欧拉公式

若$gcd (a , m) = 1$，则 $ a^(phi.alt (m)) equiv 1 (mod med m) . $

== 证明 <证明> 先来说明一个引理

=== 引理令数列 $1 lt.eq b_1 < b_2 < dots.h < b_(phi.alt (m)) < m$是1~m中与m互素的$phi.alt (m)$个整数。

若$g c d (a , m) = 1$，则数列$ b_1 a , b_2 a , b_3 a , dots.h , b_(phi.alt (m)) a med med (mod med m) , $于数列 $ 1 , 2 , 3 , dots.h , b_(phi.alt (m)) med med (mod med m) , $ 相同（忽略次序）。

=== 引理证明 <引理证明> 证明过程与费马小定理证明过程类似。

注意到$g c d (b_i , m) = g c d (a , m) = 1$，则$g c d (b_i a , m) = 1$.

从而数列(1)与同余于数列(2)每一个数。这两个数列都含有$phi.alt (m)$个数字。

从数列(1)中任取两个数$b_j a$和$b_k a$，假设它们同余： $ b_j a equiv b_k a (mod med p) $

则$p | (j - k) a$，又因为$a equiv.not 0 (mod med m)$，所以$m | (b_j - b_k)$。

而$1 lt.eq b_j , b_k lt.eq m - 1$，则 $0 lt.eq lr(|b_j - b_k|) lt.eq m - 2$，仅有$b_j = b_k$时，$p | 0$。

所以，$b_1 a , b_2 a , b_3 a , dots.h , b_(phi.alt (m)) a$模m不同余。

$phi.alt (m)$个数模m不同余，这$phi.alt (m)$个余数一定就是数列(2)。得证。

== 证明欧拉公式 <证明欧拉公式> 引理中的两个数列连乘得：

$ b_1 a dot.op (b_2 a) dots.h dot.op b_(phi.alt (m)) a equiv b_1 dot.op b_2 dots.h dot.op b_(phi.alt (m)) (mod m) $

即

$ a^(phi.alt (m)) B equiv B (mod med m) $

又有$B$与$m$互素，两边消掉得

$a^(phi.alt (m)) equiv 1 (mod med m)$

得证。

== 卡歇米尔数

如果对于每个满足$gcd (a , m) = 1$的整数a，同余式$a^(m - 1) equiv 1 (#h(0em) mod med m)$成立，则称#strong[合数m为卡歇米尔数];。

例如$m = 561 = 3 * 11 * 17$是卡歇米尔数。

为存有Box的结构体实现Clone

Sun, 28 Aug 2022 00:00:00 GMT

#let date = datetime( year: 2022, month: 8, day: 28, )

#metadata(( title: "为存有Box<dyn T>的结构体实现Clone", subtitle: [rust], author: "dashuai009", description: "为存有Box<dyn T>的结构体实现Clone how to clone a struct storing a boxed trait object", pubDate: date.display(), ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

== 问题描述： <问题描述> 无法为以下结构体实现Clone：


pub trait GetName {
    fn get_name(&self) -> String;
}

#[device(Clone)]
struct Node{
    name: String,
    children: Vec<Box<dyn GetName>>
}

== 参考链接 <参考链接> #link("https://stackoverflow.com/questions/30353462/how-to-clone-a-struct-storing-a-boxed-trait-object")[stackoverflow how-to-clone-a-struct-storing-a-boxed-trait-object]

== 具体实现 <具体实现>

// 先为GetName继承一个能clone的trait
pub trait GetName: NodeClone{
    fn get_name(&self) -> String;
}

//自定义一个clone,里面套默认clone
pub trait NodeClone {
    fn clone_box(&self) -> Box<dyn GetName>;
}

//自定义clone接口，where限制这个NodeClone只是用在GetName上，
//如果不借助这个NodeClone,直接pub tarit GetName:Clone{}是不行的
//没法放在Box<>里
impl<T> NodeClone for T
where
    T: 'static + GetName + Clone,
{
    fn clone_box(&self) -> Box<dyn GetName> {
        Box::new(self.clone())
    }
}


//为Box<dyn T>实现Clone,调用dyn GetName的自定义Clone
impl Clone for Box<dyn GetName> {
    fn clone(&self) -> Box<dyn GetName> {
        self.clone_box()
    }
}

#[derive(Clone)]
pub struct Node {
    name: String,
    children: Vec<Box<dyn GetName>>//子元素只要能GetName就可以
}

impl GetName for Node{
    fn get_name(&self) -> String{
        return self.name.clone();
    }
}

impl Node{
    //将子元素的name拼起来打印
    pub fn print_children(&self)->String{
        let s = self.children.iter()
        .map(|n|n.get_name())
        .collect::<Vec<_>>()
        .join(",");
        format!("[{}]",s)
    }
}

fn main() {

    let a1= Box::new(Node{
        name: "a1111".to_string(),
        children:vec![]
    });
    let a2= Box::new(Node{
        name: "a2".to_string(),
        children:vec![]
    });

    let b = Node{
        name: "bbb".to_string(),
        //测试一下，to_vec()会调用每个元素的Clone
        //a1、a2具体类型是Node,具有GetName、Clone接口，
        children:[a1 as Box<dyn GetName>,a2 as Box<dyn GetName>].to_vec()
    };

    println!("b={}",b.print_children());


}

费马小定理

Sun, 28 Aug 2022 00:00:00 GMT

#let date = datetime( year: 2022, month: 8, day: 28, ) #metadata(( title: "费马小定理", subtitle: [math,数论], author: "dashuai009", description: "费马小定理及其证明", pubDate: date.display(), ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

== 费马小定理 <费马小定理> 设p为素数，a是任意整数，且$a equiv.not 0 (m o d med p)$，则 $ a^(p - 1) equiv 1 (m o d med p) . $

== 证明 <证明> 先来说明一个引理 === 引理

设p是素数，a是任何整数，且$a equiv.not 0 (m o d med p)$，则数列 $ a , 2 a , 3 a , dots.h , (p - 1) a med med (m o d med p) $ 于数列 $ 1 , 2 , 3 , dots.h , (p - 1) med med (m o d med p) $

相同（忽略次序）。

=== 引理证明 <引理证明> 数列$a , 2 a , 3 a , dots.h , (p - 1) a$，含有$p - 1$ 个数字。

任取两个数$j a$和$k a$，假设它们同余： $ j a equiv k a (m o d med p) $

则$p | (j - k) a$，又因为$a equiv.not 0 (m o d med p)$，所以$p | (j - k)$。

而$1 lt.eq j , k lt.eq p - 1$，则 $0 lt.eq lr(|j - k|) lt.eq q - 2$，仅有$j = k$时，$p | 0$。

所以，$a , 2 a , 3 a , dots.h , (p - 1) a$模p不同余。

p-1个数模p不同余，这p-1个余数一定就是$1 , 2 , dots.h , p - 1$。得证。

== 证明费马小定理 <证明费马小定理> 引理中的两个数列连乘得：

$ a dot.op (2 a) dots.h dot.op (p - 1) a equiv 1 dot.op 2 dots.h dot.op (p - 1) (m o d p) $

即

$ a^(p - 1) (p - 1) ! equiv (p - 1) ! (m o d med p) $

又有$(p - 1) !$与$p$互素，两边消掉得

$a^(p - 1) equiv 1 (m o d med p)$

得证。

== 利用费马小定理简单判断一个数是不是质数

a可以随便取，比如取2，只要计算出$2^(m - 1) #h(0em) mod med m eq.not 1$，那就说明m不是质数。比如

当$m = 10^6 + 7$时，$2^(m - 1) #h(0em) mod med m = 399097$，所以$1 e 6 + 7$不是质数。

注意，若 $2^(m-1) mod m eq 1 $，#strong[m不一定是质数]

显卡更新驱动失败黑屏

Fri, 08 Jul 2022 00:00:00 GMT

#let date = datetime( year: 2024, month: 6, day: 26, ) #metadata(( "title": "显卡更新驱动失败黑屏", "author": "dashuai009", description: "", pubDate: "'Jul 08 2022'", subtitle: [4090], ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

#date.display();

#outline()

== 起因

PrtSc截图时，图片色彩失真，偏黄，好像是HDR的问题。我想着显卡驱动还是23年中（去年的），可能更新一下显卡驱动就好。结果更新完，重启后屏幕黑屏。很奇怪，只是显示器没输出，操作系统能正常进去。好像是掉驱动了。

== 网上的答案

换一个显示器。pass。没这个钱。
换数据线的接口。拔插一下。我这没效果。
进安全模式，卸载重装驱动。

== 安全模式卸载驱动

试了一天，电脑重启了无数次，最后卸载驱动重新装的。

把显卡拆掉。这时候能正常进入系统，一切显示正常。
去nvidia官网下载驱动。最新的就行，我这应该时驱动安装错误。
win+r，msconfig，boot，safe boot下次会进入安全模式。
关机，安装显卡，开机进入安全模式，设备管理器，找到显卡，卸载驱动。重复3，关掉安全模式。
重启，应该能进入系统，但是无法识别到显卡。安装驱动。显卡被识别到。

其他问题：

拆掉显卡后找不到设备，没法卸载驱动，就很尴尬。
不安装显卡，没法安装驱动，导致我这反复拔插显卡好几次。
我这显示器绝对有问题，但是没钱换。安全模式，一旦显示器的输入切别的口进来，再切回来的时候，系统直接不再识别，黑屏。

使用python爬取并分析疫情数据

Fri, 08 Jul 2022 00:00:00 GMT

#let date = datetime( year: 2023, month: 5, day: 14, ) #metadata(( "title": "使用python爬取并分析疫情数据", "author": "dashuai009", description: "这是一种将C++更加现代的代码组织方式。模块是一组源代码文件，独立于导入它们的翻译单元进行编译。", pubDate: "'Jul 08 2022'", subtitle: [python,疫情数据分析], ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

#outline()

= 数据获取 <数据获取> 选取#link("https://en.wikipedia.org/w/index.php?title=Template:COVID-19_pandemic_data")[wikipedia];上的疫情数据，总数据页如下

#figure( image("013/data0.png"), caption: [ 总数据页 ], )

每个国家的数据都可以从表格中解析出来，例如United States的详细数据的地址为 #link("https://en.wikipedia.org/wiki/COVID-19_pandemic_in_the_United_States")[Unitedd States];。具体数据可以从下图中的表格解析：

#figure( image("013/data1.png"), caption: [ United States数据页 ], )

仔细分析之后我们可以写以下爬虫代码：

import scrapy
from ..items import FordataItem

class mySpider(scrapy.spiders.Spider):
    name = "forData"

    def start_requests(self):
        beginUrl= "https://en.wikipedia.org/w/index.php?title=Template:COVID-19_pandemic_data"
        myHeader = {
            'Content-Type': 'application/json',
            'User-Agent':'Mozilla/5.0 (X11; Fedora; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0'
        }
        #先爬出数据首页，找到有哪些国家
        yield scrapy.Request(url=beginUrl,callback=self.parseCountryUrl,headers=myHeader)

    def parseCountryUrl(self,response):
        cnt=0
        for each in response.xpath('/html/body/div[3]/div[3]/div[5]/div[1]/div[4]/div[2]/table/tbody/tr'):
            countryName=each.xpath('th[2]/a/text()').get()
            countryUrl=each.xpath('th[2]/a/@href').extract()
            if(countryName!=None and len(countryUrl)>0):
                cnt=cnt+1
                print(countryName,countryUrl)
                countryDataUrl= "https://en.wikipedia.org"+countryUrl[0]
                myHeader = {
                    'Content-Type': 'application/json',
                    'User-Agent':'Mozilla/5.0 (X11; Fedora; Linux x86_64; rv:81.0) Gecko/20100101 Firefox/81.0'
                }
                yield scrapy.Request(url=countryDataUrl,headers=myHeader,callback=lambda response,name=countryName:self.parseCountryCase(response,name))
                #再分别爬取每个国家的数据
        print(cnt)

    def parseCountryCase(self,response,name):
        ct=0
        for tr in response.css('tr.mw-collapsible'):
            item=FordataItem()
            item['country']=name
            item['date']=tr.xpath('td[1]/text()').get()
            item['cases']=tr.xpath('td[3]/span[1]/text()').get()
            item['deaths']=tr.xpath('td[4]/span[1]/text()').get()
            #解析出每个国家的名字、日期、病例、死亡数
            if('2020' in item['date']):
                ct=ct+1
                yield(item)
        if(ct==0):
            print("没有单日数据的的国家：",name)

数据前几行如下：

#figure( image("013/data2.png", width: 90%), caption: [ 疫情数据 ], )

另外，这个网页上并没有人口总数的数据可以从#link("https://en.wikipedia.org/wiki/List_of_countries_and_dependencies_by_population");上继续爬取。

#figure( image("013/data3.png", width: 90%), caption: [ 国家人口对应表的数据来源 ], )

可以写出如下爬虫

import scrapy
from ..items import ForpopulationItem

class mySpider(scrapy.spiders.Spider):
    name = "forPopulation"

    def start_requests(self):
        beginUrl= "https://en.wikipedia.org/wiki/List_of_countries_and_dependencies_by_population"
        myHeader = {
            'Content-Type': 'application/json',
            'User-Agent':'Mozilla/5.0 (X11; Fedora; Linux x86_64; rv:80.0) Gecko/20100101 Firefox/80.0'
        }
        #网页请求
        yield scrapy.Request(url=beginUrl,callback=self.parsePopulation,headers=myHeader)

    def parsePopulation(self,response):
        for tr in response.xpath('/html/body/div[3]/div[3]/div[5]/div[1]/table/tbody/tr'):
            #数据解析
            item=ForpopulationItem()
            item['country']=tr.xpath('td[1]/a/text()').get()
            item['population']=tr.xpath('td[2]/text()').get()
            if(item['country'] and item['population']):
                item['population'].replace(',','')
                print(item)
                yield item

爬取结果如下

#figure( image("013/data4.png", width: 90%), caption: [ 国家人口对应表 ], )

= 数据分析和展示 <数据分析和展示> == 数据读入和清洗 <数据读入和清洗> 从前面爬取的数据文件myData.csv和population.csv中读取数据。对于疫情数据，将空值填充为0，只保留日起在2020-11-30到2020-12-15之间的数据。将病例数cases和deaths格式转换为int64。根据country和date 进行去重。

import pandas
import numpy
import matplotlib
import matplotlib.pyplot as plt
from brokenaxes import brokenaxes
import seaborn

org=pandas.read_csv('myData.csv')
org=org.fillna('0')
org['cases']=org['cases'].str.replace('\D+','').astype(int)
org['deaths']=org['deaths'].str.replace('\D+','').astype(int)
org=org[org['date']<'2020-12-16']
org=org[org['date']>'2020-11-29']
org.drop_duplicates(subset = ['country','date'],keep='first',inplace=True)
myData=org
population=pandas.read_csv('population.csv')
population['population']=population['population'].str.replace('\D+','').astype(int)

print("收集到的",len(myData['country'].value_counts(dropna=False)),"个国家的数据")

收集到的 135 个国家的数据

## 15天中，全球新冠疫情的总体变化趋势


####################################
#a) 15 天中,全球新冠疫情的总体变化趋势#
####################################

print("\n\n====15 天中,全球新冠疫情的总体变化趋势======")

#这十六天内的全球累计病例
totalCase=[0]*16

#这16天内的全球死亡累计病例
totalDeaths=[0]*16

#December表示日期，用字符串存储，方便图例生成
December=['']*16

#根据国家进行分组，全球数量=个国家数量之和，计算累计病例和死亡病例
casesSumByDay=myData.pivot_table(index='date',values=['cases'],aggfunc=sum)
deathsSumByDay=myData.pivot_table(index='date',values=['deaths'],aggfunc=sum)

December[0]='2020-11-30'
totalCase[0]=casesSumByDay.loc['2020-11-30']['cases']
totalDeaths[0]=deathsSumByDay.loc['2020-11-30']['deaths']

for i in range(1,16):
December[i]='2020-12-'+('0' if i<10 else '')+str(i)
totalCase[i]=casesSumByDay.loc[December[i]]['cases']
totalDeaths[i]=deathsSumByDay.loc[December[i]]['deaths']

print("11-30到12-15感染病例：",totalCase)
print("11-30到12-15死亡病例：",totalDeaths)

# matplotlib绘图显示中文

plt.rcParams["font.family"]="SimHei"

#画图部分
mycolors = ['tab:red', 'tab:blue']
fig, ax = plt.subplots(1,1,figsize=(16, 9), dpi= 300)
x  = December
y = numpy.vstack([totalDeaths,totalCase])
labs=['累积死亡数','累积感染病例']
ax = plt.gca()
ax.stackplot(x, y, labels=labs, colors=mycolors, alpha=0.8)
plt.title("15 天中,全球新冠疫情的总体变化趋势")
ax.legend(fontsize=10, ncol=4)
plt.xticks(rotation=30,fontsize=10)  # 这里是调节横坐标的倾斜度
plt.gca().spines["top"].set_alpha(0)
plt.gca().spines["bottom"].set_alpha(.3)
plt.gca().spines["right"].set_alpha(0)
plt.gca().spines["left"].set_alpha(.3)
plt.savefig('a.png')

====15 天中,全球新冠疫情的总体变化趋势======
11-30到12-15感染病例： [58806605, 59867806, 59924956, 60557860, 61163129, 59527002, 60033395, 62585050, 62008006, 63602677, 65008985, 65672468, 63968990, 64505434, 67261669, 68293227]
11-30到12-15死亡病例： [1471087, 1492594, 1494629, 1506452, 1517510, 1475608, 1482627, 1541590, 1516612, 1564328, 1576069, 1588076, 1541701, 1549901, 1611817, 1633944]

#figure( image("013/a.png", width: 100%), caption: [ 15 天中,全球新冠疫情的总体变化趋势 ], )

== 累计确诊数排名前 20 的国家名称及其数量 <累计确诊数排名前-20-的国家名称及其数量>

####################################################
#b) 累计确诊数排名前 20 的国家名称及其数量;           #
####################################################
print("\n\n=======累计确诊数排名前 20 的国家名称及其数量=========")

#总的累计数量只需要看最后一天的数量
casesMaxByCountry=myData.pivot_table(index='country',values=['cases'],aggfunc=max)
casesMaxByCountry=casesMaxByCountry.sort_values('cases', ascending=False)

print(casesMaxByCountry.head(20))

输出结果：

=======累计确诊数排名前 20 的国家名称及其数量=========
cases
country
United States   16022297
India            9906165
Brazil           6970034
Russia           2707945
France           2391447
Turkey           1898447
United Kingdom   1888116
Italy            1870576
Spain            1762212
Argentina        1510186
Colombia         1444646
Germany          1351510
Mexico           1267202
Poland           1147446
Iran             1123474
Peru              987675
Ukraine           919704
South Africa      873679
Indonesia         629429
Netherlands       628577

== 15 天中，每日新增确诊数累计排名前 10 个国家的每日新增确诊数据的曲线图 <天中每日新增确诊数累计排名前-10-个国家的每日新增确诊数据的曲线图>

##########################################################################
#c）15 天中，每日新增确诊数累计排名前 10 个国家的每日新增确诊数据的曲线图;     #
##########################################################################
mycolors=['tab:blue','tab:orange','tab:green','tab:red','tab:purple','tab:brown','tab:pink','tab:gray','tab:olive','tab:cyan']
plt.clf()

#每个国家的12-1之前的累计数量
casesMinByCountry=myData.pivot_table(index='country',values=['cases'],aggfunc=min)

#每个国家12-1到12-15的新增数量
decCaseMaxByCountry=(casesMaxByCountry-casesMinByCountry).sort_values('cases', ascending=False)

cnt=0
countryCName=[]
figC=[0]*10
for index,row in decCaseMaxByCountry.iterrows():
cnt=cnt+1
countryCName.append(index)
yi=myData[myData['country']==index]['cases'].tolist()
for j in range(15,0,-1):#得到每日变化数据
yi[j]=yi[j]-yi[j-1]
figC[cnt-1],=plt.plot(December[1:],yi[1:],color=mycolors[cnt-1],linewidth=2.0,linestyle='-.')
if(cnt>=10):#只保留前十个国家
break

plt.title("每日新增确诊排名前 10 的国家的数据曲线图")
plt.legend(handles=figC,labels=countryCName)
plt.savefig('c.png')

#figure( image("013/c.png", width: 100%), caption: [ 每日新增确诊排名前 10 的国家的数据曲线图 ], )

== 累计确诊人数占国家总人口比例最高的 10 个国家 <累计确诊人数占国家总人口比例最高的-10-个国家>

################################################
#d） 累计确诊人数占国家总人口比例最高的 10 个国家  #
################################################
print("\n\n=====累计确诊人数占国家总人口比例最高的 10 个国家======")

#这会用到populaton.csv的数据
#累计确诊比例
casesRatio=[]
for index,row in casesMaxByCountry.iterrows():
tmp=population[population['country']==index]['population']
if(len(tmp)>0):#这里需要注意没有人口数据的国家
casesRatio.append({'casesRatio':row['cases']/tmp.iloc[0],'name':index})

#升序排序取最后10个
casesRatio.sort(key=lambda x:x['casesRatio'])
for i in casesRatio[-1:-10:-1]:
print(i)

结果如下：

=====累计确诊人数占国家总人口比例最高的 10 个国家======
{'casesRatio': 0.09561146718594844, 'name': 'Andorra'}
{'casesRatio': 0.06748037079864816, 'name': 'Luxembourg'}
{'casesRatio': 0.05548972112860494, 'name': 'Czech Republic'}
{'casesRatio': 0.05271911310260917, 'name': 'Belgium'}
{'casesRatio': 0.05243676244828293, 'name': 'Georgia'}
{'casesRatio': 0.05198869490976536, 'name': 'Qatar'}
{'casesRatio': 0.04872524937150579, 'name': 'Moldova'}
{'casesRatio': 0.04842282774074547, 'name': 'United States'}
{'casesRatio': 0.046797668330376366, 'name': 'Slovenia'}

== 死亡率（累计死亡人数/累计确诊人数）最低的 10 个国家 <死亡率累计死亡人数累计确诊人数最低的-10-个国家>

#########################################################
#e) 死亡率(累计死亡人数/累计确诊人数)最低的 10 个国家;      #
#########################################################
print("\n\n====死亡率(累计死亡人数/累计确诊人数)最低的 10 个国家=======")

#每个国家死亡人数
deathsMaxByCountry=myData.pivot_table(index='country',values=['deaths'],aggfunc=max)
#每个国家的死亡率
deathsRatio=deathsMaxByCountry.rename(columns={'deaths':'deathsRatio'})
deathsRatio=deathsRatio/casesMaxByCountry.rename(columns={'cases':'deathsRatio'})
print((deathsRatio.sort_values('deathsRatio')).head(10))

结果如下：

====死亡率(累计死亡人数/累计确诊人数)最低的 10 个国家=======
deathsRatio
country
Seychelles                           0.000000
Guyana                               0.000000
Saint Lucia                          0.000000
Faroe Islands                        0.000000
Saint Kitts and Nevis                0.000000
Falkland Islands                     0.000000
Brunei                               0.000000
Dominica                             0.000000
Saint Vincent and The Grenadines     0.000000
Singapore                            0.000497

== 用饼图展示各个国家的累计确诊人数的比例 <用饼图展示各个国家的累计确诊人数的比例>


########################################
#f) 用饼图展示各个国家的累计确诊人数的比例#
########################################
print("\n\n=====各个国家的累计确诊人数的比例=======")

#把占比最大的几个国家列出来，直到这些国家占比超过75%，其他国家表示为other
cnt=0
figData=[]
for index,row in casesMaxByCountry.iterrows():
cnt=cnt+row['cases']
if cnt/totalCase[15]>0.75:
break
figData.append((index,row['cases']))
figData.append(('others',(totalCase[15]-cnt)))

#输出一下具体数据
print(figData)

#画图部分
plt.clf()
fig, ax = plt.subplots(figsize=(10, 5), ncols=2,dpi=300)
ax1, ax2 = ax.ravel()
patches, texts = ax1.pie(dict(figData).values(),
shadow=True,startangle=90,
labels=[ str(country)+','+str('%.2lf'%(tot*100/totalCase[15]))+'%' for country, tot in figData])
ax1.set_title('各个国家的累计确诊人数的比例')
ax2.axis('off')
ax2.legend(patches, [i for i,j in figData], loc='center left')
plt.tight_layout()
plt.savefig('f.png')

#figure( image("013/f.png", width: 100%), caption: [ 各个国家的累计确诊人数的比例 ], )

=====各个国家的累计确诊人数的比例=======
[('United States', 16022297), ('India', 9906165), ('Brazil', 6970034), ('Russia', 2707945), ('France', 2391447), ('Turkey', 1898447), ('United Kingdom', 1888116), ('Italy', 1870576), ('Spain', 1762212), ('Argentina', 1510186), ('Colombia', 1444646), ('Germany', 1351510), ('Mexico', 1267202), ('others', 16154998)]

== 展示全球各个国家累计确诊人数的箱型图，有平均值 <展示全球各个国家累计确诊人数的箱型图有平均值>

################################################
#g) 展示全球各个国家累计确诊人数的箱型图,要有平均值#
################################################
print("\n\n=====全球各个国家累计确诊人数的箱型图=====")

plt.clf()
fig, ax = plt.subplots(figsize=(5, 10),dpi=300)
#图中的黄点是平均数据值
seaborn.stripplot(y='cases',data={'cases':[totalCase[15]/135]}, color="orange", size=2.5)
seaborn.boxplot(data=casesMaxByCountry,linewidth=0.3,fliersize=1)
plt.title("全球各个国家累计确诊人数的箱型图")
plt.savefig('g.png')

#figure( image("013/g.png", width: 70%), caption: [ 全球各个国家累计确诊人数的箱型图 ], )

== 另外一些数据 <另外一些数据>

15日新增确诊占累积确诊病例最小的20个国家

########################################

# 15日新增确诊占累积确诊病例最小的20个国家#

########################################
minRatio=(decCaseMaxByCountry/casesMaxByCountry).sort_values('cases')
print(minRatio.head(20))


cases
country
Comoros                0.000000
Singapore              0.002108
Australia              0.005099
Malawi                 0.008553
Isle of Man            0.010724
Suriname               0.012823
Brunei                 0.013158
Guernsey               0.013746
Sierra Leone           0.015912
Qatar                  0.017265
Ivory Coast            0.017774
New Zealand            0.019084
Bolivia                0.020363
Nepal                  0.022645
Benin                  0.024272
Peru                   0.024370
São Tomé and Príncipe  0.024752
Maldives               0.026706
Kuwait                 0.027776
Iceland                0.029580

= 全世界应对新冠疫情最好的10个国家 <全世界应对新冠疫情最好的10个国家> 注意：爬取的数据没有包含中国的数据。

显而易见的，感染人数过多（大于一百万）的国家应对疫情肯定不是最好的。感染人数较少（小于100）也不需要考虑，这可能疫情并没有爆发，只是几个境外输入病例。我们只考虑疫情严重的几个国家。这之后按照人口递减排序，取前10个。


#####################
#最好的10个国家      #
#####################
print("\n\n======应对疫情最好的10个国家========")
good=[]
for index,rows in casesMaxByCountry.iterrows():
tmp=population[population['country']==index]['population']
if((100<rows['cases']<1000000) and len(tmp)>0):
good.append({'population':tmp.iloc[0],'name':index})

good.sort(key=lambda x:-x['population'])

for i in range(10):
print(good[i]['name'])

======应对疫情最好的10个国家========
Indonesia
Pakistan
Nigeria
Japan
Philippines
Ethiopia
Egypt
Vietnam
South Africa
Myanmar

= 预测分析 <预测分析> == 预测方法 <预测方法> 采用线性回归的方法进行预测。新冠疫情存在一定的趋势，但目前数据比较少（只有10天），可以假设不存在季节性。这样，可以采用线性回归的方法进行预测。

== 预测程序 <预测程序>


###################################

# 预测分析                        #

###################################

from sklearn import linear_model
regr = linear_model.LinearRegression()

# 拟合

regr.fit(numpy.array([i for i in range(10)]).reshape(-1, 1), totalCase[1:11])

# 得到直线的斜率、截距

a, b = regr.coef_, regr.intercept_

# 给出待预测日期

predictDate = numpy.array([i for i in range(10,16)]).reshape(-1,1)

#输出一下预测值
print(regr.predict(predictDate))

#画图部分
plt.clf()
fig, ax = plt.subplots(figsize=(16, 10),dpi=300)
plt.scatter(December, totalCase, color='blue')
plt.plot(December[1:], regr.predict(numpy.array([i for i in range(15)]).reshape(-1,1)), color='red', linewidth=4)
plt.savefig('i.png')

======预测分析========
[64229138.06666667 64738456.51515152 65247774.96363637 65757093.41212121
66266411.86060607 66775730.30909091]

== 结果以及分析 <结果以及分析> #figure( image("013/i.png"), caption: [ 预测分析 ], )

最后五天的数据拟合程度较好。

对于短期的数据，线性回归应该是较好的一种预测方法。然而，再实际问题中，还需要考虑各种影响因素。比如，各个国家政策的调整，病毒的变异等等。

= 代码网址 <代码网址> #link("https://paste.ubuntu.com/p/KkGVZwhg7N/")[code]

文本分类

Fri, 08 Jul 2022 00:00:00 GMT

#let date = datetime( year: 2022, month: 3, day: 14, ) #metadata(( "title": "文本分类", "author": "dashuai009", description: "bupt-人工智能课大作业", pubDate: "'Jul 08 2022'", subtitle: [人工智能,文本分类], ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

== 1. 实验目的 <实验目的>

掌握数据预处理的方法，对训练集数据进行预处理；
掌握文本建模的方法，对语料库的文档进行建模；
掌握分类算法的原理，基于有监督的机器学习方法，训练文本分类器；
利用学习的文本分类器，对未知文本进行分类判别；
掌握评价分类器性能的评估方法。

== 2. 实验类型 <实验类型> 数据挖掘算法的设计与编程实现。

== 3. 实验要求 <实验要求>

文本类别数：>=10类；
训练集文档数：>=50000篇；每类平均5000篇。
测试集文档数：>=50000篇；每类平均5000篇。

== 4. 实验内容 <实验内容> 利用分类算法实现对文本的数据挖掘，主要包括：

语料库的构建，主要包括利用爬虫收集Web文档等；
语料库的数据预处理，包括文档建模，如去噪，分词，建立数据字典，使用词袋模型或主题模型表达文档等；
选择分类算法（朴素贝叶斯（必做）、SVM/其他#strike[#strong[实际验收有几个不做的？];];等），训练文本分类器，理解所选的分类算法的建模原理、实现过程和相关参数的含义；
对测试集的文本进行分类
对测试集的分类结果利用正确率和召回率进行分析评价：计算每类正确率、召回率，计算总体正确率和召回率。

== 5. 实验准备 <实验准备> === 5.1. 实验环境 <实验环境> #strong[fedora 33]

个人比较喜欢linux环境，windows环境应该也可以完成下面的步骤。一些文件路径可能会修改。另外，硬盘读取速度等都会影响实验结果（速度等方面）。

=== 数据集准备

#link("http://thuctc.thunlp.org/message")[THUCNews]

数据集大小：1.45GB

样本数量：80多万

数据集详情链接：#link("http://thuctc.thunlp.org")[thuctc]

在解压出的目录下新建两个文件夹trainData和testData。注意：Linux下解压会多一层目录并多一个__MACOSX，这个并不影响实验。

解压结果如下

#figure( image("019/thu.png", width: 200pt), caption: [ 文本分类实验解压结果 ], )

=== cppjieba <cppjieba> #link("https://github.com/yanyiwu/cppjieba")[cppjieba];是”结巴(Jieba)“中文分词的C++版本。这个要比python快10倍，解决本实验足够好用!

用法

依赖软件

> g++ (version >= 4.1 is recommended) or clang++;

> cmake (version >= 2.6 is recommended);

下载和编译 > git clone --depth=10 --branch=master git://github.com/yanyiwu/cppjieba.git > > cd cppjieba > > mkdir build > > cd build > > cmake .. > > make

结果如下

#figure( image("019/jieba.png", width: 200pt), caption: [ 文本分类实验 ], )

我们只需要修改cppjieba\test\demo.cpp}，但我们要在cppjieba\build下执行make进行编译，并执行./demo运行分词程序。

=== 朴素贝叶斯分类器 <朴素贝叶斯分类器> 贝叶斯方法的分类目标是在给定描述实例的属性值 $< a_1 , a_2 , . . . , a_n >$下，得到最可能的目标值$V_(M A P)$。

$ v_(M A P) & = a r g max_(v_j) P (v_j | a_1 , a_2 , . . . , a_n)
& = a r g max_(v_j in V) frac(P (a_1 , a_2 , . . . , a_n) P (v_j), P (a_1 , a_2 , . . . , a_n))
& = a r g max_(v_j in V) P (a_1 , a_2 , . . . , a_n) P (v_j)
& = a r g max_(v_j in V) P (v_j) product_i P (a_i | v_j) $

采纳m-估计方法，即有统一的先验概率并且m等于词汇表的大小，因此 $ P (w_k | v_j) = frac(v_k + 1, n + lr(|V o c a b u l a r y|)) $

定义如下函数：

Learn_Naive_Bayes_Text( Examples, V )

Examples为一组文本文档以及它们的目标值。V为所有可能目标值的集合。此函数作用是学习概率项$P (w_k | v_j)$和$P (v_j)$。

收集Examples中所有的单词、标点符号以及其他记号

Vocabulary <= 在Examples中任意文本文档中出现的所有单词及记号的集合
    计算所需要的概率项$P(vj)$和$P(wk|vj)$
        对V中每个目标值vj
            $docs_j\leftarrow$Examples中目标值为$v_j$的文档子集
            $P(v_j)\leftarrow|docs_j| / |Examples|$
            $Text_j\leftarrow$将$docs_j$中所有成员连接起来建立的单个文档
            $n\leftarrow$在$Text_j$中不同单词位置的总数
            对Vocabulary中每个单词$w_k$
                $n_k\leftarrow$单词$w_k$出现在$Text_j$中的次数
                $P(w_k|v_j)\leftarrow(n_k+1) / (n+|Vocabulary|)$

== $chi^2$检验 <chi2检验> $ chi^2 (t , c) = frac(N (A D - B C)^2, (A + B) (A + C) (C + D) (B + D)) $

=== svm <svm> 下载地址：#link("http://www.csie.ntu.edu.tw/~cjlin/cgi-bin/libsvm.cgi?+http://www.csie.ntu.edu.tw/~cjlin/libsvm+tar.gz")[libsvm]

之后make一下，就会用三个可执行文件，svm-scale svm-train svm-train。分别是数据整理，模型训练和数据预测。

具体参数可以直接输入./svm-scale获得。

更多内容可以自行百度。

== 代码实现 <代码实现> 总共分为五个部分

trainingData();
makeDict();
makeSvm();
testingData();
printAns();

=== 变量声明 <变量声明>

#define MYMODE_RW (S_IRUSR | S_IWUSR)
using namespace std;

const char *const DICT_PATH = "../dict/jieba.dict.utf8";
const char *const HMM_PATH = "../dict/hmm_model.utf8";
const char *const USER_DICT_PATH = "../dict/user.dict.utf8";
const char *const IDF_PATH = "../dict/idf.utf8";
const char *const STOP_WORD_PATH = "../dict/stop_words.utf8";

const string dataSet = "../../THUCNews/THUCNews/";
// const string dataSet = "../../THUCNews/";
const string svmTrainData = "../../THUCNews/trainData/";
const string svmTestData = "../../THUCNews/testData/";

const int MAXS = 8e6 + 10;  //文件大小限制

//Vtot 总的类别数量
//maxCommon取相关性的前200的词组成词袋
//testCnt每个类别如果有2*testCnt篇文章，
//就取testCnt篇作为测试数据，
//再取testCnt篇作为训练数据

const int Vtot = 11, maxCommon = 200, testCnt = 5000;


//所有种类
string V[Vtot] = {"体育", "娱乐", "家居", "彩票", "房产", "教育",
                  "时政", "游戏", "社会", "科技", "财经"};

//dic[i]第i类文章中出现的所有词
map<string, int> dic[Vtot + 1];

//p[i][word] p(word|vj=i)
//第i类文章中，word出现的概率，做平滑处理
map<string, int> p[Vtot];

//kappa[i][word] word和第i类文章的kappa^2值
map<string, int> kappa[Vtot + 1];

//在处理svm数据集时，每个单词的编号
map<string, int> svmIndex;

//idf值
map<string, double> idf;

//fileList[i]第i类文章列表
vector<string> fileList[Vtot];

//混淆矩阵
int confusionMatrix[Vtot][Vtot];
int docs[Vtot + 1];  // docs[i]:第i类文章训练或测试的数目

int n[Vtot + 1];     // n[i]:第i类有多少个单词（有重复）

int precision[Vtot], recall[Vtot];  //准确率和回归率

//多线程id
long unsigned int thrd[Vtot];


#define dictAll dic[Vtot]

//结巴分词器
cppjieba::Jieba jieba(DICT_PATH, HMM_PATH, USER_DICT_PATH, IDF_PATH,
                      STOP_WORD_PATH);

=== {训练数据部分} <训练数据部分> 下面是处理数据的多线程函数

/**
 * 多线程函数
 * 处理数据
 * 读入文件->分词->计算dic[type]->计算kappa[type]
 */
void *trainingData(void *t) {
    int type = (long long)t;
    auto &dict = dic[type];
    auto &kap = kappa[type];
    char sentence[MAXS];
    for (int d = 0; d < docs[type]; ++d) {

        //读入文件
        string fileName = dataSet + V[type] + "/" + fileList[type][d];
        int fd = open(fileName.c_str(), O_RDONLY);
        int len = pread(fd, sentence, MAXS, 0);
        close(fd);
        //如果文件大小超出MAXS会出错
        if (len < 0) continue;
        sentence[len] = '\0';
        vector<pair<string, string>> tagres;
        //分词
        jieba.Tag(sentence, tagres);

        //计算dic[type]->计算kappa[type]
        set<string> thisArticle;//本篇文章单词集合
        for (auto it : tagres) {
            const auto &word = it.first;  //单词
            if (strstr(it.second.c_str(), "n") != NULL &&
                word.length() > 2) {  //名词 且 长度大于一
                dict.find(word) != dict.end() ? dict[word]++ : dict[word] = 1;
                thisArticle.insert(word);
            }
        }
        for (auto it : thisArticle) {
            kap.find(it) != kap.end() ? kap[it]++ : kap[it] = 1;
        }
    }
    cout << V[type] << "\tDone\n";
    return NULL;
}

想要调用上面的线程函数，需要先读取文件列表，如下：

//读取文件列表
void readFileLists(string dir, vector<string> &fileList) {
    // cout<<dir<<'\n';
    DIR *d = opendir(dir.c_str());
    struct dirent *entry;
    while ((entry = readdir(d)) != NULL) {
        if (strstr(entry->d_name, ".txt") != NULL)
            fileList.push_back(entry->d_name);
    }
    closedir(d);
}
//读取文件列表并处理训练数据
void trainingData() {
    for (int i = 0; i < Vtot; ++i) {
        readFileLists(dataSet + V[i], fileList[i]);
    }

    for (int i = 0; i < Vtot; ++i) {
        docs[i] = min(int(fileList[i].size()) / 2, testCnt);
        // testCnt方便测试

        cout << V[i] << " 类的文件个数为 " << docs[i] << '\n';

        docs[Vtot] += docs[i];
        int res = pthread_create(&thrd[i], NULL, trainingData, (void *)i);
        if (res) {
            printf("Create thress NO.%d failed\n", i);
            exit(res);
        }
    }
    for (int i = 0; i < Vtot; ++i) {
        pthread_join(thrd[i], NULL);
    }
}

=== 生成字典部分 <生成字典部分>

//抽取词典，使用kappa^2检验
void makeDict() {
    for (int i = 0; i < Vtot; ++i) {
        vector<pair<double, string>> mostCommon;
        for (auto it : kappa[i]) {
            double A = 0, B = 0, C = 0, D = 0;
            A = it.second;
            C = docs[i] - A;
            const auto &word = it.first;
            for (int j = 0; j < Vtot; ++j)
                if (i != j) {
                    if (kappa[j].find(word) != kappa[j].end()) {
                        B += kappa[j][word];
                    }
                }
            D = docs[Vtot] - docs[i] - B;
            double k = docs[Vtot] * (A * D - B * C) * (A * D - B * C) /
                       ((A + C) * (A + B) * (B + D) * (C + D));
            mostCommon.push_back({k, word});
        }
        sort(mostCommon.begin(), mostCommon.end());

        reverse(mostCommon.begin(), mostCommon.end());
        int item = 0;

        cout << V[i] << ':';

        for (auto it : mostCommon) {
            ++item;
            if (item > maxCommon) break;
            const auto &word = it.second;
            const int cnt = dic[i][word];
            n[i] += cnt;
            dictAll.find(word) != dictAll.end() ? dictAll[word] += cnt
                                                : dictAll[word] = cnt;
        }
        cout << V[i] << "单词个数" << n[i] << '\n';
        n[Vtot] += n[i];

        /*for (int j = max(0, (int)mostCommon.size() - 20);
             j < (int)mostCommon.size(); ++j) {
            cout << "(" << mostCommon[j].first << ' ' << mostCommon[j].second
                 << ") ";
        }
        cout << '\n';*/
    }
}

=== 生成svm的训练数据文件和测试数据文件 <生成svm的训练数据文件和测试数据文件>


/**
 * 多线程函数
 * 整理svm用到的数据文件
 * 包括测试文件和输出文件
 * 要按照libsvm要求的数据格式来
 */

void *svmData(void *t) {
    int type = (long long)t;
    //先打开训练数据文件
    int fdout = open((svmTrainData + V[type]).c_str(), O_RDWR | O_CREAT, MYMODE_RW);
    if (fdout == -1) {
        cout << errno << '\n';
        perror("open");
    }
    auto &dict = dic[type];
    auto &kap = kappa[type];
    string outBuf;
    char sentence[MAXS];
    int fdoffset = 0;

    for (int d = 0; d < (int)fileList[type].size() && d < 2 * docs[type]; ++d) {
        if (d == docs[type]) {  //这之后是测试数据集
            close(fdout);
            fdout = open((svmTestData + V[type]).c_str(), O_RDWR | O_CREAT, MYMODE_RW);
            fdoffset = 0;
            if (fdout == -1) {
                cout << errno << '\n';
                perror("open");
            }
        }

        //读取文件并进行分词
        string fileName = dataSet + V[type] + "/" + fileList[type][d];
        int fd = open(fileName.c_str(), O_RDONLY);
        long long int len = pread(fd, sentence, MAXS, 0);
        close(fd);
        if (len < 0) continue;  //如果文件大小超出MAXS会出错
        sentence[len] = '\0';
        // cout << sentence << '\n';
        vector<pair<string, string>> tagres;
        jieba.Tag(sentence, tagres);

        //统计这篇文章中的词频
        map<string, int> art;
        int totArt = 0;
        for (auto it : tagres) {
            const auto &word = it.first;  //单词
            if (dictAll.find(word) != dictAll.end()) {
                art.find(word) != art.end() ? art[word]++ : art[word] = 1;
                totArt++;
            }
        }

        outBuf = to_string(type) + " ";

        for (auto it : art) {
            auto &word = it.first;
            double tf = it.second * 1.0 / totArt;  // tf-idf=tf*idf
            outBuf += to_string(svmIndex[word]) + ":" +
                      to_string(tf * idf[word]) + " ";
        }
        outBuf += '\n';
        pwrite(fdout, outBuf.c_str(), outBuf.length(), fdoffset);
        fdoffset += outBuf.length();
    }
    close(fdout);
    return NULL;
}
/**
 * 处理svm用到的数据
 */
void makeSvm() {
    //对单词进行编号，并计算idf值
    int item = 0;
    for (auto it : dictAll) {
        auto &word = it.first;
        svmIndex[word] = ++item;
        for (int i = 0; i < Vtot; ++i) {
            if (kappa[i].find(word) != kappa[i].end()) {
                idf.find(word) != idf.end() ? idf[word] += kappa[i][word]
                                            : idf[word] = kappa[i][word];
            }
        }
    }
    for (auto &it : idf) {
        it.second = log10(docs[Vtot] * 2 / (it.second + 1));
    }

    //多线程处理数据，每个线程处理一个类别的数据
    for (int i = 0; i < Vtot; ++i) {
        int res = pthread_create(&thrd[i], NULL, svmData, (void *)i);
        if (res) {
            printf("Create thress NO.%d failed\n", i);
            exit(res);
        }
    }
    for (int i = 0; i < Vtot; ++i) {
        pthread_join(thrd[i], NULL);
    }

    //处理完成之后，将所有类别的数据合到一起
    char buf[MAXS];
    int fdout =
        open((svmTrainData + "trainData.txt").c_str(), O_RDWR | O_CREAT, MYMODE_RW);
    if (fdout == -1) {
        cout << errno << '\n';
        perror("open");
    }

    off_t off = 0;
    for (int i = 0; i < Vtot; ++i) {
        int fd = open((svmTrainData + V[i]).c_str(), O_RDONLY);
        int len = pread(fd, buf, MAXS, 0);
        close(fd);
        if (len < 0) continue;
        buf[len] = '\0';
        pwrite(fdout, buf, strlen(buf), off);
        cout << strlen(buf) << '\n';
        off += strlen(buf);
        cout << V[i] << ' ' << strlen(buf) << ' ' << off << '\n';
    }
    close(fdout);

    fdout = open((svmTestData + "testData.txt").c_str(), O_RDWR | O_CREAT, MYMODE_RW);
    off = 0;
    for (int i = 0; i < Vtot; ++i) {
        int fd = open((svmTestData + V[i]).c_str(), O_RDONLY);
        int len = pread(fd, buf, MAXS, 0);
        close(fd);
        if (len < 0) continue;
        buf[len] = '\0';
        pwrite(fdout, buf, strlen(buf), off);
        off += strlen(buf);
        cout << V[i] << ' ' << strlen(buf) << ' ' << off << '\n';
    }
    close(fdout);
}

=== 进行文本分类 <进行文本分类> 先预处理出p的值，

/**
 * 朴素贝叶斯分类器
 */
void *bayes(void *t) {
    int type = (long long)t;
    cout << "classfiying " << V[type] << "\n";
    char sentence[MAXS];

    for (int f = docs[type]; f < (int)fileList[type].size(); ++f) {
        if (f - docs[type] > docs[type]) break;

        //读取文件
        string fileName = dataSet + V[type] + "/" + fileList[type][f];
        int fd = open(fileName.c_str(), O_RDONLY);
        int len = pread(fd, sentence, MAXS, 0);
        close(fd);
        //分词
        if (len < 0) continue;  //读入出错，buf不够之类的
        sentence[len] = '\0';
        vector<pair<string, string>> tagres;
        jieba.Tag(string(sentence), tagres);

        //计算argmax(p)
        pair<double, int> ans[Vtot];
        for (int i = 0; i < Vtot; ++i) {
            ans[i] = {docs[i] * 1.0 / docs[Vtot], i};
        }
        for (auto it : tagres) {
            if (dictAll.find(it.first) != dictAll.end()) {
                for (int i = 0; i < Vtot; ++i) {
                    ans[i].first += p[i][it.first];
                }
            }
        }
        sort(ans, ans + Vtot);
        confusionMatrix[type][ans[Vtot - 1].second] += 1;
    }
    cout << "classfiy " << V[type] << "\tdone\n";
    return NULL;
}

//训练数据
void testingData() {

    //预处理p[i][word]值
    cout << "字典长度=" << dictAll.size() << '\n';
    for (int vj = 0; vj < Vtot; ++vj) {
        for (auto it : dictAll) {
            const auto &word = it.first;
            if (dic[vj].find(word) != dic[vj].end()) {
                p[vj][word] =
                    log10(dic[vj][word] + 1) - log10(n[vj] + dictAll.size());
            } else {
                p[vj][word] = log10(1) - log10(n[vj] + dictAll.size());
            }
        }
    }

    //多线程进行文本分类
    for (int i = 0; i < Vtot; ++i) {
        int res = pthread_create(&thrd[i], NULL, bayes, (void *)i);
        if (res) {
            printf("Create thress NO.%d failed\n", i);
            exit(res);
        }
    }
    for (int i = 0; i < Vtot; ++i) {
        pthread_join(thrd[i], NULL);
    }
}

=== 输出结果 <输出结果>

//输出想要的答案
void printAns() {
    double avrPre = 0, avrRecall = 0;
    for (int v1 = 0; v1 < Vtot; ++v1) {
        cout << V[v1] << ":\t";
        for (int v2 = 0; v2 < Vtot; ++v2) {
            precision[v2] += confusionMatrix[v1][v2];
            recall[v1] += confusionMatrix[v1][v2];
            cout << confusionMatrix[v1][v2] << '\t';
        }
        cout << '\n';
    }
    for (int v = 0; v < Vtot; ++v) {
        cout << V[v] << '\n';
        cout << "准确率=" << confusionMatrix[v][v] * 100.0 / precision[v]
             << "% ";
        avrPre += confusionMatrix[v][v] * 100.0 / precision[v];
        cout << "召回率=" << confusionMatrix[v][v] * 100.0 / recall[v] << "%\n";
        avrRecall += confusionMatrix[v][v] * 100.0 / recall[v];
    }
    cout << "平均准确率=" << avrRecall / Vtot << "% "
         << "平均召回率=" << avrRecall / Vtot << "\n";
}

== 实验结果 <实验结果> 先输出训练的文件个数，训练完成之后，统计每个类别有多少单词。之后，得出字典长度为2037。

#figure( image("019/ans1.png", width: 300pt), caption: [ 结果 ], )

预测完成之后是混淆矩阵。

#figure( image("019/ans2.png"), caption: [ 文本分类实验混淆矩阵 ], )

输出召回率和准确率，最后输出运行时间。 #strong[可以看到最后运行时间仅为12秒，这就是c++的长处之一。] 总共分析了55000篇文章，从读入到分词，到其他计算。总共执行时间非常短。相比于python的10min左右要好得多。

#figure( image("019/ans3.png", width: 250pt), caption: [ 结果 ], )

最后的实验结果也比较理想。准确率和召回率都比较高。

== svm <svm-1> 这里我并没有用到梯度预测、n折交叉验证（训练时间太长，实验时间不够）。但我们完整实现了用libsvm的工具进行文本分类的必要步骤。以下均在libsvm目录下。

数据整理。 ../THUCNews/trainData/trainData.txt是待训练数据的原始形式，../THUCNews/testData/testData.txt是待预测数据。用./svm-scale -l 0 -r train.scale ../THUCNews/trainData/trainData.txt 和./svm-scale -l 0 -r test.scale ../THUCNews/testData/testData.txt命令, 可以将训练数据、测试数据整理为标准格式，且下界为0.
模型训练 ./svm-train -h 0 -g 0.001 -c 10 train.scale my.model得到模型文件。
数据预测 ./svm-predict test.scale my.model ans.out

结果如下

#figure( image("019/svmans.png"), caption: [ svman ], )

实验结果较为理想。当然，该方法还有很多可以改进的空间，这里就不深究。

== {代码} <代码> #link("https://paste.ubuntu.com/p/nGWbQWmttr/")[超链接]

#link("https://paste.ubuntu.com/p/p9KQmh8Q2T/")[之前一版]

康托展开及康托逆展开

Fri, 08 Jul 2022 00:00:00 GMT

#let date = datetime( year: 2022, month: 3, day: 14, ) #metadata(( "title": "康托展开及康托逆展开", "author": "dashuai009", description: "康托展开及康托逆展开", pubDate: "'Jul 08 2022'", subtitle: [math], ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

== 题目描述 <题目描述> 小 G 喜欢玩排列。现在他手头有两个 $n$ 的排列。$n$ 的排列是由 $0 , 1 , 2 , . . . , n - 1$这 n 的数字组成的。对于一个排列 $p$，$O r d e r (p)$ 表示 $p$ 是字典序第 $O r d e r (p)$ 小的

排列（从 0 开始计数）。对于小于 $n !$ 的非负数 $x$，$P e r m (x)$ 表示字典序第 $x$ 小的排列。

现在，小 G 想求一下他手头两个排列的和。两个排列 $p$ 和 $q$ 的和为 $s u m = P e r m ((O r d e r (p) + O r d e r (q)) % n !)$

== 输入输出格式 <输入输出格式> === 输入格式： <输入格式> 输入文件第一行一个数字 n，含义如题。

接下来两行，每行 n 个用空格隔开的数字，表示小 G 手头的两个排列。

=== 输出格式： <输出格式> 输出一行 n 个数字，用空格隔开，表示两个排列的和

== 输入输出样例 <输入输出样例> === 输入样例#1： <输入样例1>

2
0 1
1 0

=== 输出样例#1： <输出样例1>

1 0

=== 输入样例#2：

3
1 2 0
2 1 0

=== 输出样例#2

1 0 2

== 说明 <说明> 1、2、3、4 测试点，$1 lt.eq n lt.eq 10$。

5、6、7 测试点，$1 lt.eq n lt.eq 5000$，保证第二个排列的 $O r d e r lt.eq 10^5$ 。

8、9、10 测试点，$1 lt.eq n lt.eq 5000$

== code

#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;

const int max_n = 5e4 + 10;
int cnt[max_n], p1[max_n], p2[max_n], pp1[max_n], pp2[max_n], ans[max_n];
int n;

inline int getnum()
{
    int ans = 0; char c; bool flag = false;
    while ((c = getchar()) == ' ' || c == '\n' || c == '\r');
    if (c == '-') flag = true; else ans = c - '0';
    while (isdigit(c = getchar())) ans = ans * 10 + c - '0';
    return ans * (flag ? -1 : 1);
}

int main()
{
    n = getnum();
    for (int i = n; i >= 1; i--) p1[i] = getnum();
    for (int i = n; i >= 1; i--) p2[i] = getnum();

    for (int i = 1; i <= n; i++)
        for (int j = 1; j < i; j++)
            if (p1[j] < p1[i]) pp1[i]++;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j < i; j++)
            if (p2[j] < p2[i]) pp2[i]++;

    for (int i = 2; i <= n; i++)
    {
        ans[i] += pp1[i] + pp2[i];
        ans[i + 1] += ans[i] / i;
        ans[i] %= i;
    }

    for (int i = n; i >= 1; i--)
    {
        int _ = -1;
        while (ans[i] >= 0)
        {
            _++;
            if (!cnt[_]) ans[i]--;
        }
        printf("%d ", _);
        cnt[_] = 1;
    }
}

== 康拓展开： <康拓展开>

const int PermSize = 12;
long long factory[PermSize] = { 1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800 };
long long Cantor(string buf) {
  int i, j, counted;
  long long result = 0;
  for (i = 0; i<PermSize; ++i) {
    counted = 0;
    for (j = i + 1; j<PermSize; ++j){
      if (buf[i]>buf[j])++counted;
    }
    result = result + counted*factory[PermSize - i - 1];
  }
  return result;
}

== 康托逆展开： <康托逆展开>

/*返回由前n个数[1, n]组成的全排列中第m大的排列。*/
vector<int> deCantor(int n, int m) {
    vector<int> res;
    long long buf = 0;
    m--;
    for(int f = 0; n > 0; n--) {
        f = m / facts[n - 1];
        m = m % facts[n - 1];
        while(buf & (1 << (f + 1)))f++;
        res.push_back(f + 1);
        buf |= (1 << (f + 1));
    }
    return res;
}

卡特兰数

Fri, 08 Jul 2022 00:00:00 GMT

#let date = datetime( year: 2022, month: 3, day: 14, ) #metadata(( "title": "卡特兰数", "author": "dashuai009", description: "简单介绍卡特兰数", pubDate: "'Jul 08 2022'", subtitle: [Catalan,math], ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

以下搬运自#link("https://zh.wikipedia.org/wiki/%E5%8D%A1%E5%A1%94%E5%85%B0%E6%95%B0")[wikipedia]

== 卡特兰数 <卡特兰数> $C_n= 1 / (n+1) binom(2n, n)= (2n)! / ((n+1)!n!),n=1,2,3,...$

== 另一种表示形式 <另一种表示形式> $C_n= binom(2n, n) - binom(2n, n+1)$

所以，Cn是一个自然数；这一点在先前的通项公式中并不显而易见。

== 递推关系 <递推关系> $ C_0 & = 1
C_(n + 1) & = sum_(i = 0)^n C_i C_(n - i) $

$ C_0 & = 1
C_(n + 1) & = frac(2 (2 n + 1), n + 1) C_n $

== 卡塔兰数的渐近增长 <卡塔兰数的渐近增长> $C_n tilde.op frac(4^n, n^(3 / 2) sqrt(pi))$

== 所有的奇卡塔兰数$C_n$都满足$n = 2^k - 1$。所有其他的卡塔兰数都是偶数。 <所有的奇卡塔兰数c_n都满足displaystyle-n2k-1所有其他的卡塔兰数都是偶数> == emm <emm> $C_n = integral_0^4 x^n frac(1, 2 pi) sqrt(4 / x - 1)$

== 母函数 <母函数> $ M (x) & = sum_(n gt.eq 0) C_n X^n
& = 1 + sum_(n gt.eq 1) sum_(i = 0)^(n - 1) C_i x^i C_(n - i - 1) x^(n - i - 1) x
& = 1 + x sum_(i gt.eq 0) C_i x^i sum_(n gt.eq 0) C_n x^n
& = 1 + x M^2 (x)
M (x) & = 1 + x M (x)^2
M (x) & = frac(2, 1 + sqrt(1 - 4 x)) = frac(1 - sqrt(1 - 4 x), 2 x) $

生成式的另一个解可以用M(0)特判掉。

== 广义二项式定理 <广义二项式定理> 二项式定理: $(x + y)^n = sum_(k = 0)^n (binom(n, k) x^(n - k) y^k)$, 其中$binom(n, k)$是组合数.

当$n$不是正整数时, $k$无法正好求和到$n$, 因此将一直求和至正无穷, 这样形式上就得到了广义二项式定理: $(x + y)^alpha = sum_(k = 0)^oo binom(alpha, k) x^(alpha - k) y^k$, 其中$binom(alpha, k) = frac(alpha (alpha - 1) . . . (alpha - k + 1), k !) = frac((alpha)^(underline(k)), k !)$是形式上的组合数.

== 展开形式 <展开形式> 先展开$sqrt(1 - 4 x)$,

$ (1 - 4 x)^(1 / 2) & = sum_(n gt.eq 0) binom(1 / 2, n) (- 4 x)^n
& = 1 + sum_(n gt.eq 1) frac(1 / 2^(underline(n)), n !) (- 4 x)^n
$

其中，

$ (1 / 2)^(underline(n)) & = 1 / 2 frac(- 1, 2) frac(- 3, 2) . . . frac(- (2 n - 3), 2)
& = frac((- 1)^(n - 1) (2 n - 3) ! !, 2^n)
& = frac((- 1)^(n - 1) (2 n - 2) !, 2^n (2 n - 2) ! !)
& = frac((- 1)^(n - 1) (2 n - 2) !, 2^(2 n - 1) (n - 1) !)
$

则

$ (1 - 4 x)^(1 / 2) & = 1 + sum_(n gt.eq 1) frac((- 1)^(n - 1) (2 n - 2) !, 2^(2 n - 1) (n - 1) ! n !) (- 4 x)^n
& = 1 - sum_(n gt.eq 1) frac((2 n - 2) !, (n - 1) ! n !) 2 x^n
& = 1 - sum_(n gt.eq 1) binom(2 n - 1, n) frac(1, 2 n - 1) 2 x^n
$

带回

$ M (x) & = frac(1 - sqrt(1 - 4 x), 2 x)
& = frac(1, 2 x) sum_(n gt.eq 1) binom(2 n - 1, n) frac(1, 2 n - 1) 2 x^n
& = sum_(n gt.eq 1) binom(2 n - 1, n) frac(1, 2 n - 1) x^(n - 1)
& = sum_(n gt.eq 0) binom(2 n + 1, n + 1) frac(1, 2 n + 1) x^n
& = sum_(n gt.eq 0) binom(2 n, n) frac(1, n + 1) x^n $

即可得到通项公式

== 应用 <应用>

Cn表示长度2n的dyck word[7]的个数。Dyck词是一个有n个X和n个Y组成的字串，且所有的前缀字串皆满足X的个数大于等于Y的个数。
将上例的X换成左括号，Y换成右括号，Cn表示所有包含n组括号的合法运算式的个数：
Cn表示有n个节点组成不同构二叉树的方案数。
Cn表示有2n+1个节点组成不同构满二叉树的方案数。

#strong[证明];：令1表示进栈，0表示出栈，则可转化为求一个2n位、含n个1、n个0的二进制数，满足从左往右扫描到任意一位时，经过的0数不多于1数。显然含n个1、n个0的2n位二进制数共有$binom(2 n, n)$个，下面考虑不满足要求的数目。

考虑一个含n个1、n个0的2n位二进制数，扫描到第2m+1位上时有m+1个0和m个1（容易证明一定存在这样的情况），则后面的0-1排列中必有n-m个1和n-m-1个0。将2m+2及其以后的部分0变成1、1变成0，则对应一个n+1个0和n-1个1的二进制数。反之亦然（相似的思路证明两者一一对应）。

从而$C_n = binom(2 n, n) - binom(2 n, n + 1) = frac(1, n + 1) binom(2 n, n)$。证毕。

Cn表示所有在n × n格点中不越过对角线的单调路径的个数。
Cn表示通过连结顶点而将n + 2边的凸多边形分成三角形的方法个数。
Cn表示对{1, …, n}依序进出栈的置换个数。一个置换w是依序进出栈的当S(w) = (1, …, n),其中S（w）递归定义如下：令w = unv，其中n为w的最大元素，u和v为更短的数列；再令S(w) = S(u)S(v)n，其中S 为所有含一个元素的数列的单位元。
Cn表示集合{1, …, n}的不交叉划分的个数。那么, Cn永远不大于第n项贝尔数. Cn也表示集合{1, …, 2n}的不交叉划分的个数，其中每个段落的长度为2。综合这两个结论，可以用数学归纳法证明：在魏格纳半圆分布定律中度数大于2的情形下，所有自由的累积量s 为零。该定律在自由概率论和随机矩阵理论中非常重要。
Cn表示用n个长方形填充一个高度为n的阶梯状图形的方法个数。
Cn表示表为2×n的矩阵的标准杨氏矩阵的数量。也就是说，它是数字 1, 2, …, 2n 被放置在一个2×n的矩形中并保证每行每列的数字升序排列的方案数。同样的，该式可由勾长公式的一个特殊情形推导得出。
Cn表示n个无标号物品的半序的个数。

== 汗科尔矩阵 <汗科尔矩阵> == 超级卡特兰数（大施罗德数） <超级卡特兰数大施罗德数> === 递推式 <递推式> $ & S_1 = 1
& forall i gt.eq 2 , s_i = S_(i - 1) + sum_(i = 1)^(n - 1) S_i S_(n - i) $

=== 生成函数 <生成函数> $ S (x) = x S (x) + S^2 (x) + x $

解得

$ S (x) = frac(1 - x - sqrt(x^2 - 6 x + 1), 2) $

=== 化简求通向公式 <化简求通向公式> 广义二项式

=== 通项公式 <通项公式> $ S_n = sum_(i = 1)^n binom(n + i - 1, 2 i) C_i $

=== 一种方法 <一种方法> 接下来给出的一种方法,可以在$O (n k)$的复杂度快速求出$k$次多项式开方后前$n$项的值

设要开方的多项式为$P (x)$,开方后的多项式为$F (x)$.

$ F (x) = P (x)^(1 / 2) = sum_(i = 0)^oo f_i x^i $

两边求导,可得

$ F prime (x) = 1 / 2 P (x)^(- 1 / 2) P prime (x) $

得

$ F (x) P prime (x) = 2 F prime (x) P (x) $

对比每一项系数,不难得到$k + 1$项的递推式.

=== 递推式 <递推式-1> $ (n + 1) f_(n + 1) = (6 n - 3) f_n - (n - 2) f_(n - 1) $

不过要注意这个递推公式除了第一项其他的项都是超级卡特兰数的$1 / 2$

=== 组合意义 <组合意义>

$n + 1$边形的任意剖分方案数。#link("http://noi.openjudge.cn/ch0206/9282/")[例题链接] 还是考虑枚举一条多边形上的边,那么有可能这条边仍然与另一个点拉成一个三角形,也有可能这条边上没有,那么把这两种加起来就是定义的递推式
括号序列,每个位置可能左括号,右括号和0.括号对数与0的个数之和为$n - 1$, 问合法的括号序列数. 同样枚举第一个是左括号还是0. 值得一提的是,可以看成先插括号再插0,那么枚举括号对数i,0有$n - i - 1$个,需要放入$2 i + 1$个位置中,那么不难得到上面通过广义二项式推出来的式子.
从$(0 , 0)$到$(n - 1 , n - 1)$,每次能往右,往上,往右上走,求不超过$y = x$这条直线的方案数. 枚举第一次是走右上还是走右. 同样使用容斥思想,把答案转化为从$(0 , 0)$到$(n - 1 , n - 1)$减去(-1,1)到$(n - 1 , n - 1)$. 那么从$(0 , 0)$到$(n , m)$的路径条数怎么求呢.可以考虑枚举往右上的次数,然后还是考虑先走右和上,然后再把走右上的插入即可.

错排问题

Fri, 08 Jul 2022 00:00:00 GMT

#let date = datetime( year: 2022, month: 3, day: 14, ) #metadata(( title: "错排问题", subtitle: [错排问题,欧拉信封问题], author: "dashuai009", abstract: "", description: "考虑一个有n个元素的排列，若一个排列中所有的元素都不在自己原来的位置上，那么这样的排列就称为原排列的一个错排。", pubDate: "'Jul 08 2022'", ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

== 定义 <定义> 考虑一个有$n$个元素的排列，若一个排列中所有的元素都不在自己原来的位置上，那么这样的排列就称为原排列的一个错排。 $n$个元素的错排数记为$D_n$或$! n$。

== 例子 <例子> 伯努利-欧拉的装错信封的问题。

== 形式化定义 <形式化定义> 记$D_n$为${ 1 , 2 , dots.h , n }$上没有不动点的排列(即$phi.alt : { 1 , 2 , dots.h , n } arrow.r { 1 , 2 , dots.h , n } , med phi.alt (i) eq.not i , med forall 1 lt.eq i lt.eq n$的个数，$D_n$的值如下：（由$n = 1$起） $0 , 1 , 2 , 9 , 44 , 265 , 1854 , 14833 , 133496 , 1334961 , 14684570 , 176214841 , 2290792932 . . .$

== 规律 <规律> $D_n = n D_(n - 1) + (- 1)^n$

== 递推数列法 <递推数列法> 显然$D_1 = 0 , D_2 = 1$。

当$n gt.eq 3$时，不妨设n排在了第k位，其中$k eq.not n$，也就是$1 lt.eq k lt.eq n - 1$。那么我们现在考虑$k$的情况。

当k排在第$n$位时，除了$n$和$k$以外还有$n - 2$个数，其错排数为$D_(n - 2)$。
当$k$不排在第$n$位时，那么将第$n$位重新考虑成一个新的“第$k$位”，这时的包括$k$在内的剩下$n - 1$个数的每一种错排，都等价于只有$n - 1$个数时的错排（只是其中的第k位会换成第n位）。其错排数为$D_(n - 1)$。所以当n排在第$k$位时共有$D_(n - 2) + D_(n - 1)$种错排方法，又$k$有从$1$到$n - 1$共$n - 1$种取法，我们可以得到：

$D_n = (n - 1) (D_(n - 1) + D_(n - 2))$

== 生成函数

=== 一 <一> 根据规律 $D_n = n D_(n - 1) + (- 1)^n$可以得到如下：

$ D (x) & = x D (x) + e^(- x)
& = frac(e^(- x), 1 - x)
& = frac(1 - x + frac(x^2, 2 !) + . . . + (- 1)^n frac(x^n, n !) + . . ., 1 - x) $

=== 二 <二> 从置换环的角度考虑，错排就是指置换环中不存在自环的排列。也就是说不存在长度为 $1$ 的置换环。后者的指数生成函数是

$ sum_(n gt.eq 2) x^n / n = - ln (1 - x) - x $

因此错排数的指数生成函数就是 $exp (- ln (1 - x) - x)$。

== 减掉非错排的情况 <减掉非错排的情况> 非错排：存在$p_i = i$的排列

只存在一个：$C_n^1 D_(n - 1)$,

只存在二个：$C_n^2 D_(n - 2)$,

只存在三个：$C_n^3 D_(n - 3)$,

…

只存在n个：$C_n^n D_(n - n)$,

所以， $ D_n & = n ! - (C_n^1 D_(n - 1) + C_n^2 D_(n - 2) + C_n^3 D_(n - 3) + . . . + C_n^n D_(n - n))
& = sum_(k = 0)^n binom(n, k) (n - k) ! $

#strike[那一定是你程序写错了]

== 通向公式 <通向公式> 令$D_n = n ! M_n$

$M_n - M_(n - 1) = (- 1)^n frac(1, n !)$

$D_n = n ! (frac(1, 2 !) - frac(1, 3 !) + frac(1, 4 !) - . . . + (- 1)^n frac(1, n !))$

== #link("https://zh.wikipedia.org/wiki/%E9%94%99%E6%8E%92%E9%97%AE%E9%A2%98#%E5%A4%9A%E9%A1%B9%E5%BC%8F%E6%A8%A1%E6%8B%9F")[多项式模拟] <多项式模拟> == $D_n$最接近 $frac(n !, e)$ 的整数 <d_n最接近-displaystyle-frac-ne-的整数> 考虑指数函数在 0 处的泰勒展开：

$ e^(- 1) & = 1 + frac((- 1)^1, 1 !) + frac((- 1)^2, 2 !) + frac((- 1)^3, 3 !) + . . . + frac((- 1)^n, n !) + frac(e^(- c), (n + 1) !) ( c - 1 )^n
& = frac(D_n, n !) + R_n $ 其中 $ lr(|R_n|) lt.eq frac(e^0, (n + 1) !) = frac(1, (n + 1) !) $ 所以 $ lr(|frac(n !, e) - D_n|) lt.eq frac(n !, (n + 1) !) = frac(1, n + 1) $ 得 $ D_n = ⌊frac(n !, e) + 0.5⌋ $

A angular binding for lexical

Fri, 08 Jul 2022 00:00:00 GMT

#metadata(( title: "A angular binding for lexical", subtitle: [lexical,angular], author: "dashuai009", description: "Create a lexical's decorate node using angular custom element. We can build a text editor for angular based on lexical.", pubDate: "'Jul 08 2022'", ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

#link("https://angular.io/guide/element")[angular custom element]

== create a normal angular compment <create-a-normal-angular-compment>

@Component({
  selector:'lexical-hr',
  template:'<hr/>'
})
export class LexicalHr{
  constructor() {
  }
}

== declare golcal interface <declare-golcal-interface>

declare global {
  interface HTMLElementTagNameMap {
    'my-dialog': NgElement & WithProperties<{content: string}>;
    'my-other-element': NgElement & WithProperties<{foo: 'bar'}>;
    // 'lexical-image':NgElement & WithProperties<ImageComponent>
    'lexical-hr':NgElement & WithProperties<LexicalHr>
  }
}

== Register the custom element with the browser <register-the-custom-element-with-the-browser>

export class AppComponent{
  constructor(private injector:Injector) {
    const LexicalHrElement = createCustomElement(LexicalHr, {injector});
    customElements.define('lexical-hr', LexicalHrElement);
  }
}

== create lexical’s decorate node <create-lexicals-decorate-node>

export const INSERT_HORIZONTAL_RULE_COMMAND: LexicalCommand<void> =
  createCommand();

export class HorizontalRuleNode extends DecoratorNode<NgElement & WithProperties<LexicalHr>> {
  static getType(): string {
    return 'horizontalrule';
  }

  static clone(node: HorizontalRuleNode): HorizontalRuleNode {
    return new HorizontalRuleNode(node.__key);
  }

  static importDOM(): DOMConversionMap | null {
    return {
      hr: (node: Node) => ({
        conversion: convertHorizontalRuleElement,
        priority: 0,
      }),
    };
  }

  override exportDOM(): DOMExportOutput {
    return {element: document.createElement('hr')};
  }

  override createDOM(): HTMLElement {
    const div = document.createElement('div');
    div.style.display = 'contents';
    return div;
  }

  override getTextContent() {
    return '\n';
  }

  override isTopLevel() {
    return true;
  }

  override updateDOM() {
    return false;
  }

  override decorate():any{
    const myHrNode = document.createElement('lexical-hr');
    return myHrNode;
  }
}

function convertHorizontalRuleElement(): DOMConversionOutput {
  return {node: $createHorizontalRuleNode()};
}

export function $createHorizontalRuleNode(): HorizontalRuleNode {
  return new HorizontalRuleNode();
}

export function $isHorizontalRuleNode(node: LexicalNode | null) {
  return node instanceof HorizontalRuleNode;
}

The type of myHrNode returned by decorate() is NgElement & WithProperties<LexicalHr>, these custom elements will have a property for each input of the corresponding component.

== register decorator listener <register-decorator-listener>

    this.editor.registerDecoratorListener((decorator) => {
      for (let i in decorator) {
        this.editor.getElementByKey(i)?.replaceChildren(decorator[i])
      }
    })

wsl2-arch

Mon, 20 Jun 2022 00:00:00 GMT

#let date = datetime( year: 2022, month: 6, day: 20, )

#metadata(( title: "wsl2-arch", subtitle: [wsl2,archlinux], author: "dashuai009", abstract: "个人癖好：所有软件都要最新的！arch完美戳中了我。ArchWSL！开个blog记录新机都要装什么环境。", description: "这是一种将C++更加现代的代码组织方式。模块是一组源代码文件，独立于导入它们的翻译单元进行编译。", pubDate: date.display(), ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

#outline() == ArchWSL <archwsl> #link("https://github.com/yuk7/ArchWSL")[ArchWSL]

！！！

rust过程宏

Fri, 10 Jun 2022 00:00:00 GMT

#let date = datetime( year: 2022, month: 6, day: 10, ) #metadata(( title: "rust过程宏", subtitle: [rust], author: "dashuai009", description: "使用过程宏自定义一个struct format。", pubDate: date.display(), ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

我们有这样一个结构体

struct TestStruct{
    a:String,
    b:String
}

我们希望自定义一个Display。针对TestStruct{a:String::from("aaa"),b:String::from("bbb")}形式化输出a:aaa;b:bbb;

利用过程宏可以做到这一点，编译时生成std::fmt::Display的trait。

#quote[ 刚开始学习过程宏，简单记录自己怎么实现的和一些坑 ]

直接上代码

extern crate proc_macro;
use proc_macro::TokenStream;

use quote::quote;
use syn::{parse_macro_input, Data, DeriveInput, Fields, Ident};

#[proc_macro_derive(format)]
pub fn derive_format(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let struct_name = input.ident;
    let struct_str = Ident::new("struct_str", struct_name.span());
    let expended = if let Data::Struct(r#struct) = input.data {
        if let Fields::Named(ref fields_name) = r#struct.fields {
            let get_selfs: Vec<_> = fields_name
                .named
                .iter()
                .map(|field| {
                    let f = field.ident.as_ref().unwrap();

                    quote! {
                        stringify!(#f),&self.#f
                    }
                })
                .collect();

            let format_string = "{}:{};".repeat(get_selfs.len());
            let format_literal = proc_macro2::Literal::string(format_string.as_str());
            let struct_fields = quote! {
                #(#get_selfs),*
            };

            quote! {
                impl std::fmt::Display for #struct_name{
                    fn fmt(&self,f:&mut std::fmt::Formatter)->std::fmt::Result{
                        write!(f , #format_literal , #struct_fields)
                    }
                }
            }
        } else {
            panic!("sorry, may it's a complicated struct.")
        }
    } else {
        panic!("sorry, Show is not implemented for union or enum type.")
    };
    expended.into()
}

难点有两个：

proc_macro2::Literal

format!("{}",str);语句中格式控制字符串"{}"是一个字面量literal。

quote内部使用的第三方库proc_macro2，quote语法#ident只接受proc_macro2的{TokenStream,Ident,....}。

在上边代码中，我们需要将一个String变量转为一个字面量。这个一定要用proc_macro2::Literal，用默认库proc_macro::Literal，会报错#strong[mismatches types];。#strike[要了命了才看出来这么个事]

#(#get_selfs),* quote的语法糖

write!(f , #format_literal , #struct_fields) 写出write!(f , "{:?}" , (#(#get_selfs),*))这样可以过编译，最后这个参数会生成一个元组，这又没法自定义格式了。写成write!(f , #format_literal , #(#get_selfs),*)又过不了编译。所以用let struct_fields = quote!{#(#get_selfs),*}套了一层。

rust减少编译警告

Thu, 09 Jun 2022 00:00:00 GMT

#let date = datetime( year: 2022, month: 6, day: 9, ) #metadata(( title: "rust减少编译警告", subtitle: [rust], author: "dashuai009", description: "项目前期开发中，可以通过RUSTFLAGS减少rust编译时给出的警告。后期去掉这些选项即可。", pubDate: date.display(), ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

== rust编译信息 <rust编译信息> #link("https://doc.rust-lang.org/reference/attributes/diagnostics.html")[diagnostics attributes]

#link("https://doc.rust-lang.org/rustc/lints/levels.html")[lints levels]

rust分为四种lint信息：

#strong[allow( C )] overrides the check for C so that violations will go unreported,
#strong[warn( C )] warns about violations of C but continues compilation.
#strong[deny( C )] signals an error after encountering a violation of C,
#strong[forbid( C )] is the same as deny( C ), but also forbids changing the lint level afterwards

默认情况下rust编译会给出#strong[大量警告信息];，比如变量命名不规范、未使用的变量等等。比较烦人，有很多种方法可以减少这些信息。

== 查看所有lint <查看所有lint> rustc -W help

== 通过lint check属性减少编译警告 <通过lint-check属性减少编译警告> （lint check attribute 这不知道咋翻译了

将前边提到的C替换成rustc -W help看到的东西。比如给函数添加#[allow(missing_docs)]可以允许不写相关文档。

== 设置RUSTFLAGS <设置rustflags> 执行rustc之前可以在export一些环境变量。

export RUSTFLAGS="$RUSTFLAGS -A unused"; rustc balbalbaba

在intellij系列的IDE中，可给运行/调试配置中自动添加这些环境变量。不过，配置里#strong[不需要添加引号”];，他会自动加上。

#figure( image("027/clion.png"), caption: [ 示意图 ], )

上边这个脚本配置相当于这条命令： export RUSTFLAGS="$RUSTFLAGS -A dead_code -A unused -A non_snake_case -A non_upper_case_globals -A non_camel_case_types"; wasm-pack build

这里我用到了以下几个

-A dead_code
-A unused 允许未使用（变量、函数等，一个lint group）
-A non_snake_case 允许这三种不推荐的命名方式
-A non_upper_case_globals
-A non_camel_case_types

全给他allow。#strike[美滋滋，编译结果清净了]

核酸检测管里的红色液体是什么？为啥是红色的？

Wed, 25 May 2022 00:00:00 GMT

#let date = datetime( year: 2022, month: 5, day: 25, )

#metadata(( title: "核酸检测管里的红色液体是什么？为啥是红色的？", subtitle: [核酸检测], author: "dashuai009", description: "喜提管长几次，刷知乎遇到这个问题，感觉之前从来没想过这个问题。液体是病毒保存液，红色是酚红。", pubDate: date.display(), ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

转自知乎！

#link("https://www.zhihu.com/question/532237774/answer/2489720812")[知乎作者：比克曼生物]

#link("https://www.zhihu.com/question/532237774/answer/2480186488")[知乎作者：Morpho Asagiri]

红色液体是病毒保存液，分为灭活型和非灭火型。

灭活型体系内含有#strong[高效病毒裂解盐];，采样后灭活病毒，有效防止二次感染风险，保障运输及检测人员安全。适用于新冠病毒、流感病毒、手足口病毒等常见病毒样本采集保存运输工作，可采集咽拭子鼻试子或特定部位组织样本，储存的样本可用于后续的核酸提取或纯化等临床试验。

非灭活型采样管能够保护病毒的蛋白和核酸，使采样的病毒具有其原始性，完整性更好，检出率更高。除了核酸检测外，样本还可以用于其他的病毒研究试验。

保存液显红色是因为溶液里含有酚红，被作为PH指示剂，在酸性时显黄色，中性时显红色，碱性时显紫色。

焦碳酸二乙酯

#figure( image("026/400px-Diethyl_pyrocarbonate.svg.png"), caption: [ 焦碳酸二乙酯 ], )

== 2024后记

这篇博客写于2022年，摘要里有一句“喜提管长几次”。现在回看的时候想了半天管长是啥，还在想这句是不是乱码。

管长：做核酸时，每十个人一组。每个人先排队去领棉签，再依次去被捅嗓子。每十个人，会有一个人领到一个红色液体的管子（上文说的东西），这十个人的棉签会放到这个管子里。这个人称为管长。

angular服务端渲染

Sat, 14 May 2022 00:00:00 GMT

#let date = datetime( year: 2022, month: 5, day: 14, ) #metadata(( "title": "angular服务端渲染", "author": "dashuai009", description: "", pubDate: date.display(), subtitle: [angular,angular_universal,ssr], ))<frontmatter>

#import "../../__template/style.typ": conf #show: conf

#date.display(); #outline()

== Angular 统一平台简介

Angular Universal：Angular 统一平台简介

本指南讲的是Angular Universal（统一平台），一项在服务端运行 Angular 应用的技术。

标准的 Angular 应用会运行在浏览器中，它会在 DOM 中渲染页面，以响应用户的操作。而Angular Universal 会在服务端运行，生成一些静态的应用页面，稍后再通过客户端进行启动。这意味着该应用的渲染通常会更快，让用户可以在应用变得完全可交互之前，先查看应用的布局。

== 参考文档

Angular Universal：Angular 统一平台简介

Rendering on web

Angular Universal: a Complete Practical Guide

== 示例代码

Angular Universal: a Complete Practical Guide

个人代码

== 为何需要服务端渲染？

有三个主要的理由来为你的应用创建一个 Universal 版本。

通过搜索引擎优化(SEO)来帮助网络爬虫。
提升在手机和低功耗设备上的性能
迅速显示出第一个支持首次内容绘制(FCP)的页面

== 案例

以我的博客渲染过程为例。

这里给出一个比较大的例子，为了方便展示setTitle等部分。

如果单纯在服务端向<div></div>插入一段html代码也可以。

== 如何使用

要创建服务端应用模块 app.server.module.ts，请运行以下 CLI 命令。

ng add @nguniversal/express-engine

该命令会创建如下文件夹结构。


src/
index.html                 app web page
main.ts                    bootstrapper for client app
main.server.ts             * bootstrapper for server app
style.css                  styles for the app
app/ ...                   application code
app.server.module.ts     * server-side application module
server.ts                    * express web server
tsconfig.json                TypeScript base configuration
tsconfig.app.json            TypeScript browser application configuration
tsconfig.server.json         TypeScript server application configuration
tsconfig.spec.json           TypeScript tests configuration

在我的package.json中有如下定义


{
  "script":{
    "dev:ssr": "ng run blog:serve-ssr",
    "serve:ssr": "node dist/blog/server/main.js",
    "build:ssr": "ng build --prod && ng run blog:server:production",
    "prerender": "ng run blog:prerender"
  }
}

之后运行npm run dev:ssr(与运行ng run blog:serve-ssr等价)，可以在本地测试。

生产环境下可以用npm run build:ssr编译项目。和 npm run srve:ssr 运行项目。

== 目标

打开一个article的时候

直接从服务器段拿到已经把md渲染为html
前端无需再去请求md文档

== 重复获取数据

=== 了解状态转移API

有了App Shell，现在让我们讨论另一个常见的服务器端渲染优化：客户端启动时服务器到客户端的状态转移。

首先让我们谈谈State Transfer API解决的问题。当我们的Angular Universal应用程序启动时，页面的很大一部分已经被渲染，并且从一开始就对用户可见。

但是请记住，此服务器端呈现的应用程序将从服务器中提取普通的客户端应用程序，然后该应用程序将接管页面。

然后，此Angular客户端应用程序将启动，并且它将做的第一件事是什么？它会联系服务器并再次获取所有数据！

客户端应用程序甚至会在加载数据时打开加载指示器。对于用户来说这很奇怪，因为来自服务器的页面中已经有数据，那么为什么应用程序又要加载它呢？

然后，客户端将重新呈现所有数据，并将其再次传递给页面，并将其显示给用户。

所有这一切都有一个问题：服务器刚刚检索了数据并呈现了数据，那么为什么还要在客户端上再次重复相同的过程呢？这是多余的，它查询服务器两次，并且不能提供良好的用户体验，这是我们首先使用Universal的主要原因。

=== Transfer API如何工作？

为了解决重复数据获取的问题，我们需要的是通用应用程序将其数据存储在页面上某个位置，然后使其可用于客户端应用程序的方式，而无需再次调用服务器。

这正是State Transfer API允许我们执行的操作！State Transfer API为我们提供了一个存储容器，用于在服务器和客户端应用程序之间轻松地传输数据，从而避免了客户端应用程序必须与服务器联系以获取数据的需求。

=== 添加transferStateModule

Here

angular提供了一种在服务器和浏览器之间，进行数据传输的一个接口。数据是附加在html后边中的一个script的标签中。

我踩的坑：这个数据自动进行json的解码转码。不要再对数据进行JSON.parse和JSON.stringify，无法处理html的标签，"<"

分别在app.server.module.ts和app.module.ts中，分别添加ServerTransferStateModule和BrowserTransferStateModule。

=== 编写resovler

在app.module.ts中声明（provider）resoler.ts模块。

之后，就可以在该文件中利用TransferState模块处理数据。

== 服务端是否渲染

进行一些细粒度的控制，可以使用自定义结构指令来实现：appShellRender和appShellNoRender。

#table( columns: (1fr, auto), inset: 10pt, align: horizon, "appShellRender", "服务端渲染", "appShellNoRender", "服务端不渲染", )

请注意，appShellRender和appShellNoRender对客户端没有任何影响！在浏览器中，每次我们浏览单个页面应用程序时，整个模板都会呈现出来。

代码示例

== 编写服务端不渲染的组件

服务端渲染的用法简单，且就这样了。如果想写服务端不加载的组件，又不想在组件里适配，有一种hack的写法，这里简单记录一下。

<my-comp *ngif = "show | sync"></my-comp>

show可以是上层组件中的Observable<boolean>，在服务端传递of(false)即可。这样服务端不会渲染my-comp组件。

ToDo

Sun, 01 May 2022 00:00:00 GMT

#let date = datetime( year: 2022, month: 5, day: 1, ) #metadata(( "title": "ToDo", "author": "dashuai009", description: "", pubDate: date.display(), subtitle: [kotlin,Android], ))<frontmatter>

#import "../../__template/style.typ": conf #show: conf

#date.display();

= 相关技术

== kotlin

在Google I/O 2017中，Google 宣布 Kotlin 成为 Android官方开发语言。官方文档中，java和kotlin是并列出现的。作为一种新型语言，相比与java，它有以下优势：

简洁：大大减少样板代码的数量（没有new关键字，没有分号等）。
安全: 避免空指针异常等整个类的错误。
互操作性: 充分利用 JVM、Android 和浏览器的现有库。
工具友好: 可用任何 Java IDE 或者使用命令行构建。

== room可持久库

Room 在 SQLite 上提供了一个抽象层，以便在充分利用 SQLite的强大功能的同时，能够流畅地访问数据库。更重要的，Google官方强烈建议我们使用Room（而不是SQLite）。

Room 包含 3 个主要组件：

数据库：包含数据库持有者，并作为应用已保留的持久关系型数据的底层连接的主要接入点。

使用 @Database 注释的类应满足以下条件：

是扩展 RoomDatabase 的抽象类。
在注释中添加与数据库关联的实体列表。
包含具有 0 个参数且返回使用@Dao 注释的类的抽象方法。

在运行时，您可以通过调用 Room.databaseBuilder() 或Room.inMemoryDatabaseBuilder() 获取 Database 的实例。

Entity：表示数据库中的表。
DAO：包含用于访问数据库的方法。

应用使用 Room 数据库来获取与该数据库关联的数据访问对象(DAO)。然后，应用使用每个 DAO从数据库中获取实体，然后再将对这些实体的所有更改保存回数据库中。最后，应用使用实体来获取和设置与数据库中的表列相对应的值。

Room 不同组件之间的关系如图 1 所示：

== Android架构

在大多数情况下，桌面应用将桌面或程序启动器当做单个入口点，然后作为单个整体流程运行。Android应用则不然，它们的结构要复杂得多。典型的 Android应用包含多个应用组件，包括Activity、Fragment、Service、内容提供程序和广播接收器。

移动设备的资源也很有限，因此操作系统可能会随时终止某些应用进程，以便为新的进程腾出空间。

鉴于这种环境条件，应用组件可以不按顺序地单独启动，并且操作系统或用户可以随时销毁它们。由于这些事件不受您的控制，因此我们不应在应用组件中存储任何应用数据或状态，并且应用组件不应相互依赖。

== 常见的架构原则

=== 分离关注点

要遵循的最重要的原则是分离关注点。一种常见的错误是在一个 Activity或 Fragment 中编写所有代码。这些基于界面的类应仅包含处理界面和操作系统交互的逻辑。应使这些类尽可能保持精简，这样可以避免许多与生命周期相关的问题。

请注意，我们并非拥有 Activity 和 Fragment 的实现；它们只是表示 Android操作系统与应用之间关系的粘合类。操作系统可能会根据用户互动或因内存不足等系统条件随时销毁它们。为了提供令人满意的用户体验和更易于管理的应用维护体验，最好尽量减少对它们的依赖。

=== 通过模型驱动界面

另一个重要原则是您应该通过模型驱动界面（最好是持久性模型）。模型是负责处理应用数据的组件。它们独立于应用中的View 对象和应用组件，因此不受应用的生命周期以及相关的关注点的影响。

持久性是理想之选，原因如下：

如果 Android 操作系统销毁应用以释放资源，用户不会丢失数据。
当网络连接不稳定或不可用时，应用会继续工作。

应用所基于的模型类应明确定义数据管理职责，这样将使应用更可测试且更一致。

== ToDo的应用结构

Google官方推荐如下架构，在我的ToDo应用中也实现了如下架构，非常amazing。

= 系统功能要求

== 用户需求

普通用户需要一个待办记录软件，希望我们实现如下功能：

记录并展示待办事项。
可编辑每个事项。
可以对事项进行排序。

== 需求分析

通过对用户需求的调查，我们可以得出如下具体的需求。

将每个事项抽象为包括id(编号)、content(待办内容)、priority(优先级)、date(截止日期)、Done(是否完成)。
将所有事项依次展示，形成一个列表。
添加一个事项。

我们可以实现一个添加按钮，用户点击之后，可以添加一个事项，并实时展示相应内容。
编辑事项。

当用户点击列表中的某个事项，可以对该事项进行编辑。
排序。

设定两种排序方式，一种按照id字段进行排序，另一种按照priority,date两个字段进行排序。

= 系统设计与实现

总共设计了MainActivity和NoteActivity两个Acticity组件，db和ui两个模块。

== MainActicity

这是整个程序的主入口。

主要有如下几个函数和接口

onCreate

这是MainActivity的生命周期中的开始部分。绑定视图等内容就是在这里定义和实现。
扩展了NoteListAdapter.NoteListener

对于ListView中的每条目，实现三个接口。onContentClick(curNote: Note),
onCheckBoxClick(curNote: Note),onDeleteBtnClick(curNote: Note)
refresh

用于更新RecylerView的模块，是否排序等。
private lateinit var mSharedPreferences: SharedPreferences

用户保存用户配置：是否排序。
onOptionsItemSelected

右上角给出用户是否排序的选项。
onActivityResult

接收 NoteActivity的返回结果，根据id段是否为0分别进行插入和删除操作。

== NoteActivity

该组件提供给用户编辑条目的界面。当用户新建条目或编辑条目时都会跳转至该界面。

var editText: EditText用于编辑和显示事项的内容。
var dateText: TextView;var timeText: TextView显示选择的日期和时间。
var addBtn: Button提交按钮。
var prioritySpinner: Spinner选择优先级，0,1,2
直接通过xml定义timePicker和datePicker。

== db

这里实现了数据库，使用到了room可持久库，有如下四个部分。

=== dao

定义了NoteDao类，这里实现了数据库的sql语句。

=== entity

有两个类。

Note

这是数据库条目的具体定义，并扩展了Parcelable，利用kotlin的序列化，可以非常方便的在Activity之间传递note类。

DateToLongConverters

android内的SQLite无法直接保存Date类型，定一个转换器，将Date自动转化为Long类型，自动将Long转化回Date类型。

=== NoteRepository

存储库可管理查询，且允许您使用多个后端。在最常见的示例中，存储库可实现对以下任务做出决定时所需的逻辑：是否从网络中提取数据；是否使用缓存在本地数据库中的结果。

=== Room数据库：TodoDateBase

什么是 Room 数据库？

Room 是 SQLite 数据库之上的一个数据库层。
Room 负责您平常使用 SQLiteOpenHelper 所处理的单调乏味的任务。
Room 使用 DAO 向其数据库发出查询请求。
为避免界面性能不佳，默认情况下，Room 不允许在主线程上发出查询请求。当 Room 查询返回 Flow时，这些查询会在后台线程上自动异步运行。
Room 提供 SQLite 语句的编译时检查。

== ui

这里定义了几个关于界面的组件。

=== NoteListAdapter

ListView的适配器。绑定了试图的操作，根据分离关注点的原则，我定义了几个接口，这些接口将在MainActivity中实现（这样比较方便而已，最好是定义在一个单独的类中）。

=== NoteViewModel

ViewModel 的作用是向界面提供数据，不受配置变化的影响。ViewModel充当存储库和界面之间的通信中心。您还可以使用 ViewModel 在 fragment之间共享数据。ViewModel 是 Lifecycle 库的一部分。

ViewModel以一种可以感知生命周期的方式保存应用的界面数据，不受配置变化的影响。它会将应用的界面数据与Activity 和 Fragment 类区分开，让您更好地遵循单一责任原则：activity 和fragment 负责将数据绘制到屏幕上，ViewModel则负责保存并处理界面所需的所有数据。

LiveData 是一种可观察的数据存储器，每当数据发生变化时，都会收到通知。与Flow 不同，LiveData 具有生命周期感知能力，即遵循其他应用组件（如activity 或 fragment）的生命周期。LiveData会根据负责监听变化的组件的生命周期自动停止或恢复观察。因此，LiveData适用于界面使用或显示的可变数据。

ViewModel 会将存储库中的数据从 Flow 转换为 LiveData，并将字词列表作为LiveData传递给界面。这样可以确保每次数据库中的数据发生变化时，界面都会自动更新。

在 Kotlin 中，所有协程都在 CoroutineScope中运行。范围用于控制协程在整个作业过程中的生命周期。如果取消某一范围内的作业，该范围内启动的所有协程也将取消。

AndroidX lifecycle-viewmodel-ktx 库将 viewModelScope 添加为 ViewModel类的扩展函数，使您能够使用范围。

=== 两个Fragment

分别是DatePicker和DatePicker。

= 软件可能的扩展

== 存储库

在这里我们定义并实现了NoteResposity。在当前这个应用中，数据库的来源只有本地的数据库。这个存储库可以实现网络数据的拉取，而不需要更改其他代码。

== 功能更新

可以将事项添加到日历，并添加闹钟。但作为一个普通应用，而不是系统内置应用，访问日历有隐私问题。暂不考虑。

分类。可以将不同的事项分为不同的类。同类产品中有这种功能，实际体验中，用户需求度不高。

== 应用迭代

代码和apk发布在如下github仓库。

github

如果有更新会提交的这里。

= 总结体会

课程体会。本门课程与实际生活关联很大，不仅有用户体验方面的，还有技术实现上。
技术总结。

kotlin。非常的简洁，也避免的null错误等。
room可持久库。避免使用 SQLiteOpenHelper 所处理的单调乏味的任务。
android设计原则。虽然在这次编程中实现的不是很好，但可以明显的看出遵循原则之后，代码比较优美。'

生成函数

Mon, 14 Mar 2022 00:00:00 GMT

#let date = datetime( year: 2022, month: 3, day: 14, ) #metadata(( title: "生成函数", subtitle: [生成函数,math], author: "dashuai009", description: "生成函数", pubDate: date.display(), ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

== 普通生成函数 <普通生成函数> $ F (x) = sum_n a_n a^n (n gt.eq 0) $

=== 等比数列 <等比数列> 数列$< 1 , p , p^2 , p^3 , . . . , p^n , . . . >$的生产成函数$F (x) = sum_(n gt.eq 0) p^n x^n$的封闭式为$F (x) = frac(1, 1 - p x)$

=== $a = < 1 , 2 , 3 , 4 . . . >$ <a1234...> 生成函数 $ F (x) & = sum_(n gt.eq 0) (n + 1) x^n
& = sum_(n gt.eq 1) n x^(n - 1)
& = sum_(n gt.eq 0) (x^n) prime
& = (frac(1, 1 - x)) prime
& = 1 / (1 - x)^2 $

=== $binom(m, n)$,($n gt.eq 0 , m$是常数) <m-choose-nngeq-0m是常数> $ F (x) = sum_(n gt.eq 0) binom(m, n) x^n = (1 + x)^m $

=== $binom(m + n, n)$ <mn-choose-n> $ F (x) = sum_(n gt.eq 0) binom(m + n, n) x^n = 1 / (1 - x)^(m + 1) $

=== 斐波那其数列 $a_0 = 0 , a_1 = 1 , a_n = a_(n - 1) + a_(n - 2) (n > 1)$ <斐波那其数列-a_00a_11a_na_n-1a_n-2n1> $ F (x) & = x F (x) + x^2 F (x) - a_0 x + a_1 x + a_0
& = frac(x, 1 - x - x^2) $

通过求解 $ frac(A, 1 - a x) + frac(B, 1 - b x) = frac(x, 1 - x - x^2) $

得

$ frac(x, 1 - x - x^2) = sum_(n gt.eq 0) x^n 1 / sqrt(5) ((frac(1 + sqrt(5), 2))^n - (frac(1 - sqrt(5), 2))^n) $

== 指数生产成函数(exponential generating function，EGF) <指数生产成函数exponential-generating-functionegf> $ hat(F) (x) = sum_(n gt.eq 0) a_n frac(x^n, n !) $

=== 运算

$ hat(F) (x) hat(G) (x) & = sum_(i gt.eq 0) a_i frac(x^i, i !) sum_(j gt.eq 0) b_j frac(x^j, j !)
& = sum_(n gt.eq 0) x^n sum_(i = 1)^n a_i b_(n - i) frac(1, i ! (n - i) !)
& = sum_(n gt.eq 0) frac(x^n, n !) sum_(i = 0)^n binom(n, i) a_i b_(n - i) $

因此 $hat(F) (x) hat(G) (x)$ 是序列 $< sum_(i = 0)^n binom(n, i) a_i b_(n - i) >$ 的指数生成函数。

=== $< 1 , 1 , 1 , 1 , . . . >$ <section> $ sum_(n gt.eq 1) frac(x^n, n !) = e^x $

=== $< 1 , p , p^2 , . . . >$ <pp2...> $ sum_(n gt.eq 1) frac(p^n x^n, n !) = e^(p x) $

=== $a_n = n !$ <a_nn> $ hat(P) (x) = sum_(n gt.eq 0) frac(n ! x^n, n !) = sum_(n gt.eq 0) x^n = frac(1, 1 - x) $

=== 圆排列 <圆排列> $ hat(Q) (x) = sum_(n gt.eq 1) frac((n - 1) ! x^n, n !) = sum_(n gt.eq 1) x^n / n = - ln (1 - x) = ln (frac(1, 1 - x)) $

=== 圆排列与排列的关系 <圆排列与排列的关系> === 生成树计数 <生成树计数> 如果 $n$ 个点 #strong[带标号] 生成树的 EGF 是 $hat(F) (x)$ ，那么 $n$ 个点 #strong[带标号] 生成森林的 EGF 就是$e x p hat(F) (x)$ ——直观理解为，将 $n$ 个点分成若干个集合，每个集合构成一个生成树的方案数之积。

=== 图 <图> 如果 $n$ 个点带标号无向连通图的 EGF 是 $hat(F) (x)$，那么 $n$ 个点带标号无向图的 EGF 就是 $e x p hat(F) (x)$，后者可以很容易计算得到 $e x p hat(F) (x) = sum_(n gt.eq 0) 2^(binom(n, 2)) frac(x^n, n !)$。因此要计算前者，只需要一次多项式 $ln$ 即可。

=== 错排数:长度为 $n$ 的一个错排是满足 $p_i eq.not i$ 的排列。 <错排数长度为-n-的一个错排是满足-p_ine-i-的排列> === 不动点： <不动点> 有多少个映射 $f : 1 , 2 , dots.h.c , n arrow.r 1 , 2 , dots.h.c , n$，使得

$ underbrace(f circle.stroked.tiny f circle.stroked.tiny dots.h.c circle.stroked.tiny f, k) = underbrace(f circle.stroked.tiny f circle.stroked.tiny dots.h.c circle.stroked.tiny f, k - 1) $

$n k lt.eq 2 times 10^6 , 1 lt.eq k lt.eq 3$。

考虑 $i$ 向 $f (i)$ 连边。相当于我们从任意一个 $i$ 走 $k$ 步和走 $k - 1$ 步到达的是同一个点。也就是说基环树的环是自环且深度不超过 $k$（根结点深度为 $1$）。把这个基环树当成有根树是一样的。因此我们的问题转化为：$n$ 个点带标号，深度不超过 $k$ 的有根树森林的计数。

考虑 $n$ 个点带标号深度不超过 $k$ 的有根树，假设它的生成函数是 $hat(F_k) (x) = sum_(n gt.eq 0) f_(n , k) frac(x^n, n !)$。

考虑递推求 $hat(F_k) (x)$。深度不超过 $k$ 的有根树，实际上就是深度不超过 $k - 1$ 的若干棵有根树，把它们的根结点全部连到一个结点上去。因此

$ hat(F_k) (x) = x exp hat(F)_(k - 1) (x) $

那么答案的指数生成函数就是 $exp hat(F)_k (x)$。求它的第 $n$ 项即可。

=== Lust <lust> 给你一个 $n$ 个数的序列 $a_1 , a_2 , dots.h.c , a_n$，和一个初值为 $0$ 的变量 $s$，要求你重复以下操作 $k$ 次：

在 $1 , 2 , dots.h.c , n$ 中等概率随机选择一个 $x$。
令 $s$ 加上 $product_(i eq.not x) a_i$。
令 $a_x$ 减一。

求 $k$ 次操作后 $s$ 的期望。

$1 lt.eq n lt.eq 5000 , 1 lt.eq k lt.eq 10^9 , 0 lt.eq a_i lt.eq 10^9$。假设 $k$ 次操作后 $a_i$ 减少了 $b_i$，那么实际上

$ s = product_(i = 1)^n a_i - product_(i = 1)^n (a_i - b_i) $

因此实际上我们的问题转化为，求 $k$ 次操作后 $product_(i = 1)^n (a_i - b_i)$ 的期望。

不妨考虑计算每种方案的的 $product_(i = 1)^n (a_i - b_i)$ 的和，最后除以 $n^k$。

而 $k$ 次操作序列中，要使得 $i$ 出现了 $b_i$ 次的方案数是

$ frac(k !, b_1 ! b_2 ! dots.h.c b_n !) $

这与指数生成函数乘法的系数类似。

设 $a_j$ 的指数生成函数是

$ F_j (x) = sum_(i gt.eq 0) (a_j - i) frac(x^i, i !) $

那么答案就是

$ [x^k] product_(j = 1)^n F_j (x) $

为了快速计算答案，我们需要将 $F_j (x)$ 转化为封闭形式：

$ F_j ( x ) & = sum_(i gt.eq 0) a_j frac(x^i, i !) - sum_(i gt.eq 1) frac(x^i, (i - 1) !) med & = a_j e^x - x e^x med & = ( a_j - x ) e^x $

因此我们得到

$ product_(j = 1)^n F_j (x) = e^(n x) product_(j = 1)^n (a_j - x) $

其中 $product_(j = 1)^n (a_j - x)$ 是一个 $n$ 次多项式，可以暴力计算出来。假设它的展开式是 $sum_(i = 0)^n c_i x^i$，那么

$ product_(j = 1)^n F_j (x) & = (sum_(i gt.eq 0) frac(n^i x^i, i !)) (sum_(i = 0)^n c_i x^i) med
& = sum_(i gt.eq 0) sum_(j = 0)^i c_j x^j frac(n^(i - j) x^(i - j), (i - j) !) med
& = sum_(i gt.eq 0) frac(x^i, i !) sum_(j = 0)^i n^(i - j) i^(underline(j)) c_j $

计算这个多项式的 $x^k$ 项系数即可。

陪审团人选

Mon, 14 Mar 2022 00:00:00 GMT

#let date = datetime( year: 2022, month: 3, day: 14, ) #metadata(( title: "陪审团人选", subtitle: [DP], author: "dashuai009", abstract: "", description: "poj上一道DP题。", pubDate: date.display(), ))<frontmatter>

#import "../__template/style.typ": conf #show: conf

== Description <description> In Frobnia, a far-away country, the verdicts in court trials are determined by a jury consisting of members of the general public. Every time a trial is set to begin, a jury has to be selected, which is done as follows. First, several people are drawn randomly from the public. For each person in this pool, defence and prosecution assign a grade from 0 to 20 indicating their preference for this person. 0 means total dislike, 20 on the other hand means that this person is considered ideally suited for the jury.

Based on the grades of the two parties, the judge selects the jury. In order to ensure a fair trial, the tendencies of the jury to favour either defence or prosecution should be as balanced as possible. The jury therefore has to be chosen in a way that is satisfactory to both parties.

We will now make this more precise: given a pool of n potential jurors and two values di (the defence’s value) and pi (the prosecution’s value) for each potential juror i, you are to select a jury of m persons. If J is a subset of {1,…, n} with m elements, then D(J ) = sum(dk) k belong to J and P(J) = sum(pk) k belong to J are the total values of this jury for defence and prosecution.

For an optimal jury J , the value |D(J) - P(J)| must be minimal. If there are several jurys with minimal |D(J) - P(J)|, one which maximizes D(J) + P(J) should be selected since the jury should be as ideal as possible for both parties.

You are to write a program that implements this jury selection process and chooses an optimal jury given a set of candidates.

== Input <input> The input file contains several jury selection rounds. Each round starts with a line containing two integers n and m. n is the number of candidates and m the number of jury members.

These values will satisfy 1<=n<=200, 1<=m<=20 and of course m<=n.~The following n lines contain the two integers pi and di for i = 1,…,n.~A blank line separates each round from the next.

The file ends with a round that has n = m = 0.

== Output <output> For each round output a line containing the number of the jury selection round ('Jury #1', 'Jury #2', etc.).

On the next line print the values D(J ) and P (J ) of your jury as shown below and on another line print the numbers of the m chosen candidates in ascending order. Output a blank before each individual candidate number.

Output an empty line after each test case.

=== Sample Input <sample-input> #quote[ 4 2

1 2

2 3

4 1

6 2

0 0 ]

=== Sample Output #quote[ Jury #1 ]

Best jury has value 6 for prosecution and value 4 for defence: 2 3

== Hint <hint> If your solution is based on an inefficient algorithm, it may not execute in the allotted time.

== Source <source> Southwestern European Regional Contest 1996

== 中文： <中文> 描述

在遥远的国家佛罗布尼亚，嫌犯是否有罪，须由陪审团决定。陪审团是由法官从公众中挑选的。先随机挑选n个人作为陪审团的候选人，然后再从这n个人中选m人组成陪审团。选m人的办法是：

控方和辩方会根据对候选人的喜欢程度，给所有候选人打分，分值从0到20。为了公平起见，法官选出陪审团的原则是：选出的m个人，必须满足辩方总分和控方总分的差的绝对值最小。如果有多种选择方案的辩方总分和控方总分的之差的绝对值相同，那么选辩控双方总分之和最大的方案即可。

输入

输入包含多组数据。每组数据的第一行是两个整数n和m，n是候选人数目，m是陪审团人数。注意，$1 < = n < = 200 , 1 < = m < = 20 , m < = n$。接下来的n行，每行表示一个候选人的信息，它包含2个整数，先后是控方和辩方对该候选人的打分。候选人按出现的先后从1开始编号。两组有效数据之间以空行分隔。最后一组数据$n = m = 0$

输出

对每组数据，先输出一行，表示答案所属的组号,如 'Jury #1', 'Jury #2', 等。接下来的一行要象例子那样输出陪审团的控方总分和辩方总分。再下来一行要以升序输出陪审团里每个成员的编号，两个成员编号之间用空格分隔。每组输出数据须以一个空行结束。

样例输入

#quote[ 4 2

1 2

2 3

4 1

6 2

0 0 ]

样例输出

#quote[ Jury #1 ]

Best jury has value 6 for prosecution and value 4 for defence: 2 3

为叙述问题方便，现将任一选择方案中，辩方总分和控方总分之差简称为“#strong[辩控差];”，辩方总分和控方总分之和称为“#strong[辩控和];”。第i个候选人的辩方总分和控方总分之差记为$V (i)$，辩方总分和控方总分之和记为$S (i)$。现用$f (j , k)$表示，取j个候选人，使其辩控差为k的所有方案中，辩控和最大的那个方案（该方案称为“方案$f (j , k)$”）的辩控和。并且，我们还规定，如果没法选j个人，使其辩控差为k，那么$f (j , k)$的值就为-1，也称方案$f (j , k)$不可行。本题是要求选出m个人，那么，如果对k的所有可能的取值，求出了所有的$f (m , k) (- 20 times m lt.eq k lt.eq 20 times m)$，那么陪审团方案自然就很容易找到了。

问题的关键是建立递推关系。需要从哪些已知条件出发，才能求出$f (j , k)$呢？显然，方案$f (j , k)$是由某个可行的方案$f (j - 1 , x) (- 20 times m lt.eq x lt.eq 20 times m)$演化而来的。可行方案$f (j - 1 , x)$能演化成方案$f (j , k)$的必要条件是：存在某个候选人i，i在方案$f (j - 1 , x)$中没有被选上，且$x + V (i) = k$。在所有满足该必要条件的$f (j - 1 , x)$中，选出$f (j - 1 , x) + S (i)$的值最大的那个，那么方案$f (j - 1 , x)$再加上候选人i，就演变成了方案$f (j , k)$。这中间需要将一个方案都选了哪些人都记录下来。不妨将方案$f (j , k)$中最后选的那个候选人的编号，记在二维数组的元素$p a t h [j] [k]$中。那么方案$f (j , k)$的倒数第二个人选的编号，就是$p a t h [j - 1] [ k - V [p a t h [j] [k]]$。假定最后算出了解方案的辩控差是k，那么从$p a t h [m] [k]$出发，就能顺藤摸瓜一步步求出所有被选中的候选人。初始条件，只能确定$f (0 , 0) = 0$。由此出发，一步步自底向上递推，就能求出所有的可行方案$f (m , k) (- 20 times m lt.eq k lt.eq 20 times m)$。实际解题的时候，会用一个二维数组f来存放$f (j , k)$的值。而且，由于题目中辩控差的值k可以为负数，而程序中数租下标不能为负数，所以，在程序中不妨将辩控差的值都加上400，以免下标为负数导致出错，即题目描述中，如果辩控差为0，则在程序中辩控差为400。

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include<string.h>
usingnamespace std;
int f[30][1000];
//f[j,k]表示：取j个候选人，使其辩控差为k的方案中
//辩控和最大的那个方案（该方案称为“方案f(j,k)”)的控辩和
int Path[30][1000];
//Path数组用来记录选了哪些人
//方案f(j,k)中最后选的那个候选人的编号，记在Path[j][k]中
int P[300];//控方打分
int D[300]; //辩方打分

int Answer[30];//存放最终方案的人选

int cmp(constvoid*a,constvoid*b)
{
    return*(int*)a-*(int*)b;
}

int main()
{
   int i,j,k;
    int t1,t2;
    int n,m;
    int nMinP_D;//辩控双方总分一样时的辩控差
    int iCase;//测试数据编号
    iCase=0;
    while(scanf("%d %d",&n,&m))
    {
        if(n==0&&m==0)break;
        iCase++;
        for(i=1;i<=n;i++)
           scanf("%d %d",&P[i],&D[i]);
        memset(f,-1,sizeof(f));
        memset(Path,0,sizeof(Path));
        nMinP_D=m*20;//题目中的辩控差为0，对应于程序中的辩控差为m*20
        f[0][nMinP_D]=0;
        for(j=0;j<m;j++)//每次循环选出第j个人，共要选出m人
        {
            for(k=0;k<=nMinP_D*2;k++)//可能的辩控差为[0，nMinP_D*2]
            if(f[j][k]>=0)//方案f[j,k]可行
               {
                   for(i=1;i<=n;i++)
                       if(f[j][k]+P[i]+D[i]>f[j+1][k+P[i]-D[i]])
                       {
                           t1=j;t2=k;
                           while(t1>0&&Path[t1][t2]!=i)//验证i是否在前面出现过
                           {
                               t2-=P[Path[t1][t2]]-D[Path[t1][t2]];
                               t1--;
                           }
                           if(t1==0)
                           {
                               f[j+1][k+P[i]-D[i]]=f[j][k]+P[i]+D[i];
                               Path[j+1][k+P[i]-D[i]]=i;
                           }
                       }
               }
        }
        i=nMinP_D;
        j=0;
        while(f[m][i+j]<0&&f[m][i-j]<0)  j++;
        if(f[m][i+j]>f[m][i-j])  k=i+j;
        else k=i-j;
        printf("Jury #%d\n",iCase);
        printf("Best jury has value %d for prosecution and value %d for defence:\n",(k-nMinP_D+f[m][k])/2,(f[m][k]-k+nMinP_D)/2);
        for(i=1;i<=m;i++)
        {
            Answer[i]=Path[m-i+1][k];
            k-=P[Answer[i]]-D[Answer[i]];
        }
        qsort(Answer+1,m,sizeof(int),cmp);
        for(i=1;i<=m;i++)
          printf(" %d",Answer[i]);
        printf("\n\n");

    }
    return 0;
}