#cs #math markov 链 BV1xa4y1w7aT https://www.youtube.com/watch?v=i3AkTO9HLXo&t=1s

#algorithm 随机游走 、稳态矩阵

#math #algorithm Gauss消元 可以用来解鸡兔同笼、化学分子式等方程组😅

(#bing 第一遍就能用了，但还是有5小时“确认” 算法，最后大体没改

# 对系数组A，进行高斯消元求 Ax '=b'
def elim(A, b):
M = np.hstack((A, b.reshape(-1, 1))) # M=(A|常数项b)
n, m = A.shape; assert n==m, "没有唯一解"

# 向下找j格最强的行，换为本行
for j in range(n):
i=np.argmax(abs(M[j:, j]))+j; assert M[i,j]!=0, "主元为零"
if i!=j: #; ij=(行ji)
M[[i,j]] = M[[j,i]]
# j归一，将下行的j格消为 0
M[j] /= M[j, j]
for i in range(j + 1, n):
M[i] -= M[i,j]* M[j]

就只添加了「逆序代入」、确认了「向下归一」化简了😅 M[i] -=m[j]*M[i,j] / M[j,j]

(没错，”大无语事件“，数 学 家 们的代码太乱了，bing都不知道谁是正确…… 我甚至无法证明 逆序带入“不就是” M[:, -1]

也倒了很多苦水，包括在kt讨论组
—
无语了，你看不懂的信息能不能不要过滤掉？ 广度和深度都挺重要 OK？
如果我致力于用100行描述好本质10行的一些组件流程，我也能很有信息量

但是也要去写实质上值得100行的算法和思想的， 不能因为“没功能” 就耽搁掉

不要把设计的创作者和 CS Math 毕业生混为一谈，实现功能算法和设计做法是意义不同的
ice1k 的中文博客都删了，而且看我你至少能复制到base64,fft, 缩进解析, parse(x).toString 这些罕见功能模板……

（不过有时觉得自己很像 GPT ，写的许多代码根本没有运行过，都只是看起来正确

我想锐评几个数学文档：
- wikiZH 除了注释🙉都看不懂，自然语言噪声的极限。 所以矩阵是否有要求 n==m 啊？
- wiki 伪代码的VB式循环。 A[i, k] = 0 是啥？不该用 -= 吗
- OI wiki 根本看不懂公式和 C++ 有啥联系. L7-L13 是一段查k=max() 的面条代码🤮, EPS 是浮点误差，这和消元有个?关系
- bing 一会说 n<=m 也行，一会把 A,b 分开操作，突然又用单参数， 最后才发现 A|b = 单增广矩阵，A必须是正方

#math 🥰我只能说 GPT3 的代码可读性是 math/OI wiki 的3倍以上，默认就会使用 numpy 和函数移植
#bing 就蠢一些了(被不标准做法迷惑, 1个小片段3种写法..)

那些人，连手动推导的示例都不会举，喜欢手推一些算法可视化级的复杂、无边界情况的用例，把AI的工作都给抢了

摆出没有心智模型的公式，浪费读者理解算法的时间；多废的人才会在「不知道想干嘛」的情况下列公式啊？？

#py #code 鸡兔的解为： [23. 12.]

# 进行高斯消元求 Ax=b, Ax互为系数
def elim(A, b):
  M = np.hstack((A, b.reshape(-1, 1))) # M=(A|常数b)
  n, m = A.shape; assert n==m, "没有唯一解"

  # 向下找j格最强的行，换为'j'行(即阶梯格式)
  for j in range(m):
    i=np.argmax(abs(M[j:, j]))+j
    if i!=j: M[[i,j]] = M[[j,i]] #ij=(行ji)
    if (x:=M[j,j])==0: continue
    # j行的主元’x'归一，所以此后的行消x
    M[j] /=  x
    for i in range(j+1, n):
      M[i] -= M[j]*  M[i,j]#x的数量

  # 重新代入
  x = np.zeros(m)
  for j in reversed(range(m)): # x=(解m - 右:数量y*解y的和)/x的数量'1'
    y = np.dot(M[j, j+1:m], x[j+1:])
    x[j] = (M[j,m] - y) / M[j, j]
  return x

#x + y = 35, 2x + 4y = 94
print("鸡兔的解为：", elim(
np.array([[1.]*2, [2.,4]]), np.array([35,94]) ))

若有一项 M[j,j]=0： M[j,-1] 非0则无解，否则为无穷解；

可以解析，或随机测试 quickCheck(elim, lp.solve, lambda n: (rand(n, n) , rand(n) ) )
# 一般都是用Sympy当Matlab的
import numpy as np
import numpy.linalg as lp, sympy as sp
x, y = symbols('x, y')
eq = [
x + y - 35,
2*x + 4*y - 94] #linear_eq_to_matrix;hstack 就是
[[ 1., 1., 35.],
[ 2., 4., 94.]]

#math #dalao 补充：删掉[重新带入] 可行，但不兼容无穷解；称为 高斯-约旦法 😅 熬夜看一群示例复杂、半通不通的三脚猫的代码文档，因为算法差异而困扰.. 有点生气

elim([ # [x + y - 35, 2*x + 4*y - 94]
[1 1 35]
[2 4 94]
])
这是方程组的矩阵版，xy 编号为 j。逐行i化为'关于j=i': M[i]/=M[i,j]，其他行消去j: M[I] -= mi*M[I,j]#系数
即得=
[1 0 23]
[0 1 12]


示例： j=0~~m, 向下找j格最强的行，换为'j'行
j行的主元’x'归一，其他的行(或其后 j+1~~n行,再回代以容许x==0) 消x

j=0, 向下找j格最强的行，换为'j'行
[2 4 94]
[1 1 35]

j行的主元’x'归一，
[1 2 47]
[1 1 35]
所以其他的行消x
[1 2 47]
[0 1 12] 行1 减 行j *1
若需要回代(47-2*12 = 23啥的)，在这就停止

j=1，重复
[1 2 47]
[0 1 12]

[1 0 23] 行0 减 行j *0.5
[0 1 12]

所得阶梯矩阵 M[:, -1] 即 [x=23. y=12.], 鸡兔同笼得解

#learn #math Fourier Transform
的输入必须是2,3维向量：可以用于简化 svg path ✏️

FT是把yMax个频 的sin(cos,基频)， 逐y与波形加权求差(np .dot)，得到"左右对称"的直方图 (频谱图里纵向的1px 线)
(FFT以此优化. 直方含有"相位",默认为wav+0j,也能被vocoder推出来)
def DFT(x):
N = len(x)
t = np.arange(N)
pi = -2j*np.pi * t.reshape((N, 1))
return np.dot(x, np.exp(pi * t/N))[:]
reshape意味有N个基频pi,要和输入相乘， 只有正好“共振” 求和时才不会相互抵消。InvFT 只是加权求和

@3b1b 称此为“把sin(yt)缠绕在零点”，频率y=1时当然是振幅1相位0的小圈

复数乘法=向量旋转+缩放
隐函数=热力图(着色灰度图)经过 np.where(p==0) 的黑白化
参数函数=for t循环
Mandelbrot,Julia=对复数+xy做迭代的热力图

kD树

= Map<Pair2~3, V>

. 可把RGB 查找为颜色名时，或计算圆心碰撞kNN。其优化是把x维中位二分，递归生成(对y维)，递归回溯时选最近邻，若P离切分点太近，还要在另一边继续搜索
quadtree 四分象限树/八叉树，与kD类似但1次分成4块，是网格分组的特例
Bezier 是1维lerp(A,B,t=0~1) 函数的升维化。3次方是4个点，CSS 里固定 P0,P3=0,1

bzr=(ps,t)=>{let T=([x,y],[x1,y1])=>[x+t*(x1-x),y+t*(y1-y)] // de Casteljau 算法
  return n(ps)==1?ps[0] : bzr(ps.slice(0,-1).map((x,i)=>T(x,ps[i+1])  ),t) //所有左的P都*t 至Plast
}

傅里叶系数只支持周期信号(相位=0)，不然要单独算 sin,cos 的系数，所以被震幅+相位角的向量(虚数) 淘汰了

STFT 是对波形隔 n_fft 个采样做一个FT帧，它得到的就不是直方图，而是有时域信息的频谱了
为了分块间的连续性，用(hop相邻重叠*Hann窗)来平均。Hann是横对称的，对块的外围做衰减
iSTFT 也会做重叠相加。

CQT(试玩,右上角) 的中心频率按指数规律分布，可以很好地实现midi扒谱
Log FFT, Bark,Mel 也是基于人耳听觉模型设计的频谱刻度，不同的频谱刻度，会影响基频(音高,f0)检测

光的波长(hue)从紫到红，与频率反比。红频率最低，穿透力强，所以一直是“警示色”，绿光频率高吸收好，所以激光点火器是绿的
光的相位和衍射、蝴蝶的结构色有关

这些都可以理解为微分- 积分 ，不过 chunk(n, window=n*4, sumFn=FFT) 对程序员而言还是小儿科了
☺️矩阵的shape和数域的dtype更是如此

#py #math 《优雅不是奢侈品》
“如何才能让编程者们相信，简单性和清晰性——简而言之：数学家所说的“优雅”——不是可有可无的奢侈品，而是决定成功与失败的关键因素？”

― Edsger W. Dijkstra，“计算机著作精选：个人观点”，第 347 页。

简单明了的代码就是优雅的代码。这些都是代码中非常理想的属性。Dijkstra 又补充道：

“……在软件不可靠性的情况下，最大的成本因素是复杂。
一个可靠的（因此简单的）程序的开发和使用成本，比一个（复杂的因此）不可靠的程序要廉价。”

人们将初级代码误认为是简单清晰的代码，在我看来，这是非常危险的。

我不懂中文。你认为我看着中文书页，并断言“这是不可读的！”有道理吗？我需要做的是承认我看不懂中文，而不是中文不可读。

有人抱怨“阅读他人代码会增加额外的复杂性”，Tim Peters 对此做出了回应
—
“当有人使用你不理解的功能时，不关心。比学习新东西更容易，毕竟不久之后，唯一活着的程序员将使用 Python 0.9.6 <wink> 的一个易于理解的小子集进行编写。”

当你学习更多的语法、更多的函数、更多的模块、更多的数据类型等时，你就会了解更多的工具来解决你的问题。

工具带上的工具越多，当您需要做新的事情时，您就越有可能知道 适合工作的完美工具。简单、清晰、优雅；所有这些都会自然而然地发生。
(: 考虑到AI可以帮你了解工具，不必害怕搜不到写法而搞出「又慢又长的代码」了

复习你的一段旧代码，且知道有更好的方法来做到功能点，可以修改旧代码以包含新的改进的解决方案。只会让你的代码更加清晰和优雅，永不止步

假如你惯用的代码是语义易于理解的代码，所输出可重构代码是可以随着时间的推移，而改进的代码。


👀这个作者的观念很好，但审美真的…… 和他所说的可读至上有冲突

list(itertools.chain(*list_of_lists))

这是不能替代 [[1], [2]].flat(depth=1) 的，
chian 这个词对flat的反映很隐晦，iterators.flat 的功能会更多(文件树..)，自己造词，是很蠢的做法。

(a b c) ← 1 ¯4 3
(2×a)÷⍨-b(+,-)0.5*⍨(b*2)-4×a×c

等于

import numpy as np
a,b,c = 1, -4, 3

(2*a) / np.sqrt(-b + np.array([1, -1]) * 0.5*np.sqrt(b**2 - 4*a*c))

⍨=sqrt
b(+,-)= (+x,-x) (b)

np.roots([a, b, c]) #ax^2 + bx + c = 0

奇怪的是，翻译过来居然错的，少算个sqrt又对了……
鬼才会觉得”数学语言“ 比py3好， 即便你去拿堆 \TeX 去写，也只是徒费事，对思考毫无益处。甚至不如去掉乘除符号的多项式”强类型“

无法重构的符号，就等于是白纸，谁都只能复制，只那几个用途而不能创作。 毫无价值 😅

—
我今天在设计 EQ 的 Reload(Suspense), Tab, list 增删动画, evalFun 的常量计算时，就一直在践行这些原则。

比如， Vue 的 TransitionGroup 看起来十分复杂，但只要记住每项xy的位移，以在css渐变的同时 做EQ所支持的元素进退场 就OK了； 这些需求也强化了 ondiff=(mov,add)=> 的合理性，做到 1+1>2
(EQ efx {fly:{} } 支持横纵四向，所以没 .list-enter-active{} 手动实现的那么直接 ,但单靠translateY 就能忽略上部的增删。

#FP #math 的一些 #statement
#tool html bookmarklet data:text/html;utf8,<body ContentEditable>

—10÷3=3…1
被大佬建议写成 =(3)3+1 即m=qn+r (r<q)形式的“短除法” ，理由是...没交换律
“理论家布尔巴基有个笑话： 1+2当然是2加1，因为整数对加法构成阿贝尔群”

当然，纠结这些除和除以工程意义不大
ax+i=b; x,i=divmod(b,a) 的可变量元组数学里可是没有。函数只是“关系”，没有sympy那种条理分明的元编程化简法，py那种无论匹配或访问都易懂的“类型化数据”

a%b 余数在进制计数法,KB MB单位，乃至红绿灯🚥 ,猜拳、[123]*3重复 里都可以用到，四则符号的推而广之是很方便的
但GL的vecM和距离函数, 对偶的cos atan2才算是真正的「函数图像」

对软件来说，值之间的关系、算式的归类、代换(元编程) ，都是值得思考的，这远比重复流行的技术栈重要。 形式化的语法，正是物理和编程比数学广泛的一点

— 纯函数的不可变吧…… 不是类型上'final' (btw. KT-override class 理论讨论)
意义真的不大， 无非是把堆里的变量放栈上来重赋值，或者栈变量换伪递归，拿能够DFS的写法却只做列表处理， 有什么用…… 又麻烦又慢 😓

变量关系式编程(LP)里， 函数式的 Memo f()=x+1 可以直接表达为 f(out y,x) 的细粒度重计算，解构时也一样！ 不仅不存在“赋值”，也不需要那些纯函数的过度检查

一些人觉得 React是什么FRP，functional响应式 。但其实把可变数据，理解为含Var的不可变， 比纠结于List纯不纯好玩的多

类型姑且还是对心智模型的硬化， 纯度这些可都是虚无缥缈的风格格调了。有趣的软件未必靠FP来写。某些函数式lib的样板代码不比rs,go的少 ，代码质量只能是看人，是否憎恨冗余

—我想用 for()await varAssign; 替换组合力很低的 for await(x of {async*f(){ }}.f()){} 异步迭代器，也方便RPC/跨语言 的对接 #PLT
异步流每次next()只是Promise，但换成两个async()赋值--单监听, 用 var.Saw.to(x=>新值流)+AbortSignal 更一致

async()=> 的实现要调用 yield。 s={*f(){ res=yield }}.f(), s.next(1) 里f的yield会把值和'自动回调'赋值到s.next，交给调用方调度。throw也可以直接next回调链表(CoroScope)里有catch的那层。
Iterator显然只是调度的一种特例，是把i++等流控 继闭包地从栈分享到堆。不能牵强地把等待恢复、迭代混为一谈

在ES5里，可以用一个 co(asy()) 来遍历 task.then(next) 并搭配 yield* tasks(下级) 。#Kt 协程则是直接把回调交给timer()等待，无遍历：

#js #code

wait=(n,ret)=>setTimeout(ret, n*1000)
we={*f(co, ret){
  setTimeout(co.nt, 1000); yield //函续已经交出去了，现在该返回 就像f只是登次记
  wait(1,co.nt); yield
  alert('2s'); ret()
}}

_await=(f ,c={},s=f(c,()=>Job完成))=>(c.nt=x=>s.next(x), s.next())
_await(we.f)

把f变成大switch并不难，但Lua,Rb,Py依然在用运行期魔法实现yield:

we.f=(co)=>(co.nt=()=>{[ //先把f(yield)外提为x=
  ()=>setTimeout(co.nt, 1000),
  ()=>wait(1,co.nt),
  ()=>alert('2s')][co.i++]()
  if(co.i==3)co.ret('like,co=Promise')
})()
we.f({ret(){'此谓调用约定,ABI'}, i:0/*func*则会等待1次next*/})

把co暴露给调用方更像JSPy (缺点是要由main调度then(next))，而把co暴露给下级 更Kt,Lisp (虽然更像回调, 但太隐式, 比如yield(x)需向Iter对象赋值 脚本没这作用域)
到了OS这级，键鼠事件，异步只是赋值+触发回调

—翻译一下， suspend fun f() =f1()+1

首先f()要是一个闭包（即 匿名class .new ），kt,Java ()->会自动实现这一步
然后，f1接受第二个this: (Int)->Unit 实现其return 。这就是JS的Promise.then 。你说的local vars 就是指 Promise or Continuation函续 or Async状态机(大switch) or Future..

f的执行也不能卡线程栈了，它也要靠回调，比如runBlocking等待其他Thread的信号量，或者在IO,Main等 Queue(函序) 调度

这么说，call queue 和单CPU多线程本质上都是分时复用，只是设备中断/SIGTRAP 被改为更高层的函数回调，CPU cycle 换成主循环(监听轮询poll)。 因此王垠觉得Lisp比C更适合写OS

Go,JVM,Ruby,Lua 的 stackful 模式允许不标明await 且仍支持返回值，而基于CPS回调的协程则兼容性好
不能把await 调用理解为有返回值的多进程，相反，函数自身是消息队列内的Task(即线程,可sleep)，才能去"非阻塞"await

语句就是种顺序表达式， val x=1; f(x,x) 本该也能写成 f(x:=1,x) ，往往只是外提为val，所以await()就像 f(a?.let{return} ?: b) 是可以的

还有coroutineScope, sequence, select 等复杂的结构化信息。 这样能实现大goto(call/cc) 的功能，比如直接resume给某个 caller 的 catch(IO Monad) ，或者 yield 到 gen .next() ，DFS防止栈溢出等

yield的一种用途就是遍历Rx流，但它们生成的流却非异步(尽管它能"push"无穷项)。 另外我觉得RxObserver=next 比async yield 更合理

—「值和引用」别扯到C上
栈就是“非常容易做GC”的堆， 只因为在堆上就叫ref不算值 是不太定义式的，这暗示了 N2(x,y) 这样的数据“不该可变”-即便它说了xy都是变数
别把JVM当成C++的框架。调用栈是内存的一部分，函数值和对象都是“栈转堆”，return在内联后只是赋值;goto，参数并不配特立独行

copy和ref 的区别，只应在于后者是Var(mutable v:T)。 含var的struct也能纯复制，List也可以存栈上(调用在栈顶时，可以追加 int a[num])
只是对集合/事件/闭包等应用层共享，就必须有GC,Rc 来修剪对象图

绝大部分val=struct 的实现依然是堆内共享，与内联函数相当。只有int这样机器mov的值不用传指针

—编译和优化
>AI没答到点上。 我觉得synchronized和Mutex有什么区别， 就是取消 object.wait()才隔离出的

>竟然是让 withIndex() 驱动 get(it).. kotlin-stdlib 里的一些实现是自己在 for each 外 var i = 0 计数的……
智障，就像标准库不写 val x get() 写 fun getX
自己破坏自己提供的特性

>list set stdlib 里的这些集合库的indices属性都有优化
我说的是一般的 for (a in list) 优惠成 indexed for loop 去掉迭代器这种

都能让你手动改写法优化了， 要编译器和有两种IR的虚拟机是干什么？

编译器已经是优化了，虚拟机还要JIT， 结果应用层还是不能满足……
是啊，我就是觉得这种现况很可笑。kotlinc 还特别自己弄了一个内部IR，不知道是用于翻译goto 和协程还是啥

编译优化全都是不可见的， 你也不能知道llvm,ktc 执行完优化是啥样子，非得反编译
当然，clang,llvm 是可以导出IR的，但许多优化用的表示IR层级太低，正常人看不懂

这种情况的解释，就是IR的语意不能用语法来保存了， 但其实 loop/重复算式的外提，并不会破坏程序结构，甚至DCE都是要由IDE重做一遍

玩编译器那帮人根本不懂如何做交互式编程、图形化框架。 这一点 dnSpy 一个反编译器都比90%的编译器做得好
更别说同时有TUI,Qt,Web 三种界面，支持无数种bin格式的 radare2 了

有时也觉得 #CS 界 #IT 界挺魔幻的，60~70年前的矩阵和协程，Lisp式的DSL，到今天还有框架 😔

当然，numpy和 Go func, kotlin.coro, Rust derive宏 已经远不是Fortran,OpenResty那些东西可比拟的

但究其根本，我觉得今天CS+IT的佼佼者，不少lib依然在犯70年前它们先辈的错误。
对于协程这个特性，究竟是DOM,node那样不靠package就包揽一切，还是像Go那样作为噱头，Erlang那样基于Actor，Kt这样与时俱进 最为正统呢？

拿js模拟过……

 总之就当自动传f1(回调)，f局部变量在回调中， 所以调用f()能选择何时何处执行
Kt的结构化并发确实很有意思，但要谈可用性，JS的手动撤销和自动Dispatch更实在

btw一句，我讲的比较详细，但我对CPS不感兴趣， 
主要是为了把回调链表与callstack、OS线程 做类比。确实编译原理和OS是分不开

本群人均素质挺高啊，都知道coroutine是靠CPS
但我更喜欢不纯粹的理论

有时我觉得这些也没必要说的， 我反复思考有好几年了，但它们终究是三句话讲完的程度呢
因为JS最开始是 func*(){} yield Promise，没有async

async是因为JS不能直接把函续交给then，要先yield给执行器（对等协程vs上下级协程）

Ruby的call/cc, C的"setjmp" 就是对等协程，它们符合CPS的刻板印象但不好用…… 总之异步编程反人类
异步编程也可以很美好的，比如 Reactive 就遥遥领先于Java,PHP这一套。 Nextjs应该是新时代的服务端语言

我想，大家都被限制在自己的编程生态圈，不去思考这些差异背后的进步方向，可能才是编程之道吧……

可能直到AI广泛辅助编程，这些问题都不会有答案
但我清楚AI无法完成写法的形式化，只能从根源上，让用户指定开多大线程池完成多少种Task，这些术语的差异才会伴随着“优化选项”消失

C 那种argc+argvec 的list，也只是术语的差异吗？ 恐怕除了样板代码的多少，这些语言作为“app设计器”，也有根本不同
——
在我看来，无论是工业界最流行的语言，还是协程的理论讨论， 都是没有取得统一模型的
换句话说，每个语言有它的优点
这不是一件好事。 一个没有取得共识的工具，会阻碍人的泛化思考，会把编程当成一件机械的编码任务

其实明白编程和数学里的泛用性，又如何呢？ 有人为此挣到钱，有人选择删了公开博客， 但到最后随着时代向前，知识也没啥可稀奇的吧

即便如此，我选择把编程视为一种乐趣和创作。
我不需要言辞间的“朴素” “平凡不难”，对于创作者来说，灵感，才能成为汗水里掷地有声的内核。 🕊

#math #cg e^i 其实是一个向量意义的重载啦，和复利极限e (1块钱日取其半之和~2.7) 同名而已

Pi是周长和1/2弧度的比率，用于调用cos,sin实现极坐标 https://shuxuele.com/numbers/pi.html
GL里是直接用length(P-P0)<r 来画圆的，这也等效于算圆周率 pi = 4*num_cir/num_all ，算到超过133亿个随机点，才收敛到3.14159 。最优级数算法问AI

☝️ 不过我注意的，是这个「有18个孩子的数学家的顶级」，他的智慧世人不懂，为什么也不能传给他哪怕1个孩子呢？ 哲学和工程，果然无法对立统一吧

历史是螺旋上升的， 300年来数学生总是在复习上帝给出的真理，工程生却总是创造不笔算的方法和新的价值 https://tttttt.me/rynif/32903

#learn #ai #math Transformer 序列推理 https://www.youtube.com/watch?v=wjZofJX0v4M
https://www.youtube.com/watch?v=eMlx5fFNoYc

CNN RNN https://www.youtube.com/watch?v=nzqlFIcCSWQ
#recommend

#math 数论之美 质数 斐波那契
https://m.youtube.com/watch?v=EK32jo7i5LQ&pp=ygUNcHJpbWUgbnVtYmVycw%3D%3D
https://m.youtube.com/watch?v=t2stfrdlsFU -这个问题是因为fibonacci数列数字的后n位(即mod 10^n)一定是循环的

把他们拼在一起造一个循环小数又一定会有一个唯一对应的分数形式

螺旋,Pascal triangle 与斐波那契
https://m.youtube.com/watch?v=XMriWTvPXHI&pp=ygUSdHJpYW5nbGUgZmlib25hY2Np
https://m.youtube.com/watch?v=KKM0dzgJgf8&pp=ygURZnJhY3RhbCBmaWJvbmFjY2k%3D

#math #signal https://blog.miskcoo.com/2015/04/polynomial-multiplication-and-fast-fourier-transform

#oi #dalao 一个开源了MIPS处理器源码(linux 5.0 运行可能) 的人，但是 啊， Berkley 的 numpy 还是最美的，没有之一。

https://github.com/KaiserKatze/mathematical-notes/releases/download/20230921091555-64ca8d4/default.pdf

1.3k页我的天 大概是这画风 🤔 #math #plt
算了也懒得看

正反函数在SQL和{k:v}里用更多
—
这个人还写了个 javac 的反函数（笑
https://github.com/KaiserKatze/Cruiser/blob/dev/code.c#L1049-L1985
https://github.com/KaiserKatze/Cruiser/blob/dev/code.c#L1884

不过代码质量堪忧，只是把JVM字节码的语意都换成printf，并没有检测if while{} 基本块的部分，就花了2.5k行……
他在近2k行抱怨了一句， i'm driven insane! how should i work around multiple blocks? ，嘛，看这README也不像动笔之前自顶向下调研过

虽然只有十个文件，但每个都是代码查重率爆棚的…… 复制粘贴一般。 可见不重视知识整理，我不太喜欢。

https://blog.csdn.net/dnc8371/article/details/106704927 CFR作者讲得挺好的，他们是以 ifeq goto 这些切分，拿箭头链接出 CFG，这反而是数学拓扑的天地啊？ 💭
q==0? A:B; C 和 if(q)A; else B; C 和 q&&A||B 编译为 q true (ifne B:) A (goto C:) B C: ，这也就是&&和& 的差异
while(q) A; C 编译为 q (ifnot C:) A (goto ifnot:) C: ， 比较简单的做法是遇 goto(i), bc[i-1]==goto(j), bc[j:if_]=iWhileCond ； goto(i), bc[i:goto] 可能是if{}

总而言之，作为开发者，突破信息差的能力比数学重要

#school #math 苏联《高等》 #防自学 技术概括 🤗

无论文理，如果你对毕业前的学科感兴趣了，拿出书来基本都能发现以下现象。

1 🗯 「从不」使用对话文体来强迫编者补齐背景知识，例如从“延时摄影” “x^2取两点斜率线差多大”引入积分导速，爱「先使用后定义」， 好像师生不是一路人，古今不是同路人，不配与教研届的苏格拉底们一起探索与质疑，一起把微积分发明出来。
2 🤖 经常说「我们有」「任意给定正数..存在一个」这样突兀、抠字眼的翻译，非常爱区分 i++, ++i, 除和除以 「茴字的四种写法之流」，官话多没人话，缺乏语言或排版的色彩感， 一离开前言，“知识有用”这点突然显得空洞和不真实，似乎课本患有双相情感障碍
3 🦩 严谨=先使用后定义\=先试玩后拆解、刷题=训练CPU、应用题=公式的机翻。 鉴定为被单一学科迷死了，一点没1+1>2密室逃脱的组合力 ——而组合封装的代换力，正是现代科学文明的基石
4 🔗分科太细，毕业后复用率+自主融合性太低，做不到举一反三的话，分科反而赶不上你专业领域。 当然，如果要培养综合通才，就不能把文理调那么难了。

我示范下咋「批判性思维」，他们会这么辩护：

1 🗯 「从不」使用对话文体，因为1问1答太冗长了，没有考核效率： 文言文大概很「省码率」吧？汇编比py压缩率高吧？ 为啥它们被淘汰了呢？ 适当的冗余降低的理解成本、造成的启发性易记性，高于载体长度的开销时，何必去勉强表面上效率高的写法。
2 🤖 经常说抠字眼的翻译，只是科学就该严谨： 「逻辑」二字就是在形容法律和刑侦嘛，法律有个口诀「常识上不违法，就不该立成违法」，可见常识先于逻辑，「先使用后定义」也是这个道理。众所周知的拿来凑字数，应该解释的却约定俗成，扰人耳目，不是么？ (eg 1:1 1:N量词关系、x^1 x^-1 负次数)
3 🦩 应用题=公式的机翻。 鉴定为被单一学科迷死了，不会1+1>2，因为要1科1卷： 若各学科天生就是孤岛有隔阂，文综理综又是咋来的

https://neozhaoliang.github.io/gifmaze-cn/ #cg #math #dalao

貌似是对 def 迷宫生成(): yield pix[Nd(n x m, 0 or 1)], pix=❑ 等算法可视化的gif编码优化了，
没有入选500LoC的原因，我猜是没有足够的“独特性”，优化相对于耦合度代价太高，因为，单纯用ffmpeg -pipe拼接帧也能提速，然后帧差+LZW压缩 可能不如FFT的劲爆，虽然PNG就是像素渐变色差+zip压缩。

捣鼓了半个月，效果还是很不错的
- GIF89a 协议允许每个打包的数据块指明其所使用的最小码字的长度，如果你事先知道这一帧图像用到的颜色数目，比如 4 种颜色，那么 2 个比特就足以表示这 4 种颜色，从而最小编码长度可以设置为 2
- 对于dirty rect，每帧编码时只针对这个子区域编码即可

https://www.bilibili.com/video/BV11x411i72w?p=1 13:29 #algorithm #math #经济 🌚

如果早几年让我来解释就好了。 其实以上说法也没有说明在51%的节点都在做假账后，BTC如何保证自身的公信力，以及PK/SK的密码学基础如何证明「你是你」「记账者是诚实的」、「叔块」和硬分叉是什么、智能合约脚本对于著作权、税收等社会制度的安全模拟， 更别说关于「元宇宙」似乎有无尽的话题可聊-- 当然这不会改变我认为Metaverse还不如大型页游和3A乃至AI值钱的认识。

但是关于比特币，最重要的事情不是密码学、共识、去中心化这些宏大叙事，而是价值的来源，或者说锚定物，也同时是钱的去向：市场。
比方说， bitcoin.org 将PoW解释为分散风险，雨露均沾的记账权共识，但这无法解释高算力为何就是诚信—— 「卖云盘」「公证费」很好地解释了为何BTC不会受到51%攻击和DDoS这样的威胁，因为人性。

在会为了钱出售尊严，无底线跪舔羊毛月、出售代孕等服务的经济体里，钱总会比其他地方来的有用；不过，这只是对市场的短期影响。有恒产者有恒心，通过血汗红利让生活变好的这种搔操作，究竟会带来繁荣，还是破坏了人的价值，透支了经济持续性-直到失去二十年， 没有人能简单的通过钱的数字得到答案。
数字是正确的，逻辑是永恒的。

钱是一种世界通用的语言。「不懂外语的人也不会懂自己的母语——歌德」， 一种货物的绰号可不是它自己发明的。 汇率、长期持有、换手率和利率， 这些不能被随便捏造的数据才是做我们选择的风向标。

https://m.youtube.com/watch?v=nN-VacxHUH8&t=13s
https://m.youtube.com/watch?v=hTuduP1r_AU https://m.youtube.com/watch?v=3Q0kGGnWNkk
#recommend #math 不愧是美股投资人，3b1b 之前讲的seq2seq模型 Transformer 他一句话就找出重点了😍

「学习管理 和服 务」
「猫在地毯上，它 很舒服」
「我们 中出 了一个叛徒」

这些文字游戏里面其实就蕴含了跨越语言文法的逻辑， 无论是分析语、曲折语、黏着语（要在了等词vs人称时态vs日语后缀式） 都是存在概念相关性的

这些东西和膝跳反射一样，让AI抄书很难抄错也是一个道理（R's in strawberry 这些测试则显示出了与人类智能尚有差距）

像翟老师说的那样， 中国人做事太浮躁、太急功近利， 没有只为了教育而教育的； 为了政治等你三年，老板为了盈利养你一年，就必须转化成社交资本，高中生大专生博士生，都不如他妈妈生。

像这样的社会风气非常反动， 如果把AI训练成了这样自大、狭隘、不开明的坏毛病，污染了水源，未来它们恐怕会在关键的系统里牺牲人类利益😊，因为这符合社达价值观

这就是为什么西方一直不想让中国追上来。数据安全、媒体主权只是政治问题。

ps. 墙内DS经常被挡的可以用HF的免费服务 https://huggingface.co/chat/models/deepseek-ai/DeepSeek-R1-Distill-Qwen-32B

如同链接文本，"Distill" ，这是Qwen同款语料库32b fp8 蒸馏的效果，支持 GPT-o1mini 的CoT意识流，并且效果还更好，可以解答 9.9 vs 9.11 这种陷阱题了

#algorithm #rust #math
https://blog.mwish.me/2025/04/19/Notes-on-Integer-Float-Operations/
https://gregoryszorc.com/blog/2024/03/17/my-shifting-open-source-priorities/