似乎该恢复这个系列了

shell 脚本的执行方式目前看起来是 依次从脚本中读入一行，执行一行。因此不要在运行中途改脚本。

不同前缀修改字号大小：

tiny
\scriptsize
\footnotesize
\small
\normalsize
\large
\Large
\LARGE
\huge
\Huge

“世界上居然存在从1开始indexing的语言”

函数句柄：f = @(t) 2*t，可以通过 f(2) 等求值
符号表达式： syms x; f = 2 * x; 可以化简相加等，求单点值：subs(f, x, 1)

函数句柄转符号表达式 ： y = f(t)
符号表达式转函数句柄： F = matlabFunction(f)

vpa(x) 转为小数表示

CTRL + R 多行注释，CTRL + T 取消注释

1:0.1:2 将区间 [1,2] 按 0.1 切分
linspace(x1, x2, n) 将区间 [x1, x2] 等分为 n 份
trapz(X, Y) 梯形公式求积分，Y 为函数值 vector，X 为 数或与 Y size 相同 vector

定义函数：

function ouput = name(input)
    // content
end

函数必须在文件末尾

输出：
disp(X)
不在开头输出 X=，直接输出内容

不等于:
~=

for 循环 ：

for i = -7:1e-5:0
end

多维数组 : c = [a;b]
数组总长度 ： length(a)
数组形状 ： size(a)
数组切片 : a(1:2)
数组写入excel : xlswrite("test.xlsx", a)

绘图

ezplot(f, [0, 2]) 绘制 [0, 2] 内函数 f
plot(x, y) 以 x 和 y 内的点作图
grid on 开启网格

矩阵操作

norm(x) : 向量或矩阵 x 的二范数
cond(x) : 矩阵 x 的二条件数
eig(x) : 矩阵 x 全部特征值
vrho(x) : 矩阵 x 谱半径（最大特征值模长）
length(x) : 矩阵 x 最大维度长度

数学函数

normpdf(x) : 标准正态分布函数
normcdf(x) : 标准正态分布函数积分
norminv(x) : normcdf逆函数
chi2cdf(x, n) : 卡方分布函数积分
chi2inv(1-a, n) : idchi2 逆函数

“为什么都大三了还不会用google”

双引号内为完全匹配
减号前是空格，减号后没有空格表示不包含
因此搜索指令选项时可以考虑用引号包括：ls "-alh"

* 为通配符
OR 表示或关系
+ 同时匹配多个关键词
~[word] 表示匹配同义词
inurl:[word] 关键词在url中
intitle:[word] 关键词在标题中
intext:[word] 关键词在正文中
site:[url] 搜索指定网站
filetype:[type] 指定文件类型

“妈的，之后看到的语法要随手记下来”

调用库： use std::io;
生成文档：cargo doc --open
match 关键字：

    match guess.cmp(&secret_number) {
        Ordering::Less => println!("Too small!"),
        Ordering::Greater => println!("Too big!"),
        Ordering::Equal => println!("You win!"),
    }

ownership :
- 每个值有一个变量作为owner
- 同时只能有一个owner
- 当owner到scope外时，值会消失

rust 特性：

所有权机制保证的安全性
显示变量类型语言，但支持类型的推导
作用域特性：变量在定义的作用域外会被丢弃
不允许空值（null）
不允许悬挂指针
不允许 race condition（因此同一个变量只能有一个可变引用 或 多个不可变引用）

! 结尾表示宏展开

通用语法

for 循环：

for x in 0..10 {
    println!("{}", x); // x: i32
}

// enumerate 版本
for (i,j) in (5..10).enumerate() { 
    println!("i = {} and j = {}", i, j);
}

区间： a..b 表示 [a, b)，类型 core::ops::Range ，标准库为其实现了 Iterator 的 trait

match 语句：

match v.get(2) {
    Some(third) => println!("The third element is {}", third),
    None => println!("There is no third element."),
}

同时是 Option<&T> 的应用
Option 定义 ：

enum Option<T> {
    Some(T),
    None,
}

Result 定义 ：

enum Result<T, E> {
    Ok(T),
    Err(E),
}

结构体定义与结构体函数：

struct Point<T, U> {
    x: T,
    y: U,
}

impl<T, U> Point<T, U> {
    fn mixup<V, W>(self, other: Point<V, W>) -> Point<T, W> {
        Point {
            x: self.x,
            y: other.y,
        }
    }
}

tuple 结构体：

struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

let black = Color(0, 0, 0);
let origin = Point(0, 0, 0);
println!("{} {} {}", black.0, black.1, black.2);

triait 定义与使用：

pub trait Summary {
    fn summarize(&self) -> String;
}
impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}, by {} ({})", self.headline, self.author, self.location)
    }
}

trait 参数传入：

pub fn notify(item1: impl Summary, item2: impl Summary) {}
pub fn notify(item: impl Summary + Display) {}
pub fn notify<T: Summary + Display>(item: T) {}

函数 && 泛型： fn largest<T>(list: &[T]) -> T { }

生命周期注解：

&i32        // 引用
&'a i32     // 带有显式生命周期的引用
&'a mut i32 // 带有显式生命周期的可变引用

手动 drop 引用 ：
core::mem::drop(inner);

数组：let mut app_start: [usize; MAX_APP_NUM + 1] = [0; MAX_APP_NUM + 1];

具体其他

新建 vector : let v : Vec<i32> = Vec::new();, let v = vec![1, 2, 3]

box : 在堆上分配内存空间。

// 把栈上变量转移到堆上
let val: u8 = 5;
let boxed: Box<u8> = Box::new(val);

// 把变量从堆上转移到栈上
let boxed: Box<u8> = Box::new(5);
let val: u8 = *boxed;

string :

&str : string slices, 定长，不能 mut，是指向 UTF-8 字节串的 reference
let greeting = "Hello there.";
"Hello there." 为 string literal，类型 &static str，编译时分配，lifetime为整个程序
let s = String::from("hello"); 类型 String
let slice = &s[3..]; 类型 &str，为切片, slice.len()
s.as_str() 类型 &str
let s1 = "Hello world!"; 类型 &str，为切片

数组切片 :

let a = [1,2,3,4,5];
let slice = &a[1..3]; 类型 &[i32] 为数组切片

升级概念（？）

普通指针：类型 & 和 &mut 两种

    let mut num = 5;
    let num_ref = &mut num;
    *num_ref = 100;

胖指针：如切片，保存了指针和长度信息，类型 & 和 &mut 两种

    let mut arr = [1, 2, 3, 4];
    let slice = &mut arr[1..4];
    slice[0] = 100;

裸指针：类似 C++ 指针，可能为 null
创建裸指针为safe操作，读写裸指针为unsafe 操作，类型 *mut 和 *const 两种

    let mut num = 1;
    // 将引用转为裸指针
    let num_raw_point = &mut num as *mut i32;
    unsafe {
        *num_raw_point = 100;
        println!("{} {} {:p}", num, *num_raw_point, &num); 
        // Output: 100 100 0x8d8c6ff6bc
    }

访问 *mut 裸指针元素： *a.offset(1) = 1

#[derive(Copy, Clone)] 在类前添加，让编译器自动添加 Copy/Clone trait，使传参时不会发生所有权转移

结构相关

目录下 mod.rs 和与目录同名的 .rs 文件起到导出内部接口作用