#javascript https://tc39.github.io/ecma262/#sec-intro

#Haha #backend #PL #java #cpp #recommended

笑哭 🙈 ice1000/algo4j/jni/math/BigInt.cpp#3

我的高精度 简洁简洁最简洁 逃课去机房我情不自禁 测试测试 在那垃圾的电脑上测试
月光下我看到测试全通过 有时很快有时很慢 感到一种力量驱使我的手速 有了高精度
负数都不怕 加法减法 乘法除法 乘方取余不压位 为了方便输出 为了方便输出 为了方便输出

http://ice1000.org/2017/02/17/TranslationDLPL/ #ai #ann

之前稍微理解了一下 KNN 机器学习，但是不了解人工神经网络，现在看看

#word inline，JIT，fusion(haskell optimization)，tco，lazy，unwrap lambda(absal programming language)
两个没听说过

#lisp #CS #PL http://ice1000.org/gist/eebnf-lisp/

#frontend #css #html 好耶！是 CSS 动画！

header nav ul img:hover, header nav ul i.fa:hover {
  transition: all 0.2s cubic-bezier(0.5, 1.45, 0.64, 1.87);
  transform: translateY(-0.2em);
}

http://ice1000.org/2018/09/24/CodeEditor4/
真香 #blog #code_editor #tech

#c #php #java #recommended http://ice1000.org/2018/09/24/CodeEditor4/

duangsuse 阅读时注意到的事情（本文第一次，作为编辑器后端架构基本蒙蔽）

0. 我又看到了 gap buffer
1. freenode #lisp 有 dalao
2. Oracle 开发 JavaX 的程序员很有文化
3. VSCode 前端程序员们有不考虑字面 literal 包含 EOL 的 Token “优化” 的黑历史
4. 他们曾经也没考虑当前编辑行
5. VS 很厉害，会缓存每行代码渲染后生成的纹理 buffer
我也想试用下 FreeType 来着
可惜后来没时间了 2333
我曾经修改的一个 Rust badge 生成器，现在还在 docs.rs 上，用了 FreeType 的一个 Rust 绑定，当初看不懂 算
6. 冰冰现在也做数据结构 & 算法可视化动画了 LineSpan 的数据结构可视化
7. 太长不看 TLDR
8. 所谓太长不看的大多是 文本序列数据结构的通用性质
讲的还挺好的
+ 一个 item 指文本序列的最小单位，通常是 char 或者 wchar_t
+ 一个 sequence 指一系列以各种方式组合并在逻辑上是连续的 item ，即刚才提到的抽象结构，比如 LinkedList<Character>, std::list<char>
+ 一个 buffer 指一段在物理上连续的 item std::vector<char>::data, java.util.ArrayList<Character>， mmap() 映射的
+ 一个 item 序列如果同时是 sequence 和 buffer 那么它是一个 span like java.lang.String, std::string
+ Ruby/Lua/JavaScript/Dart/Perl 等语言中的 string 是 span
8.5. PHP 也是，如上文，Java 当然也是

// 可以认为 PHP 里 string 是这样的
struct php_string {
  php_refcount rc;
  unsigned long hash;
  size_t length;
  char buffer[1]; // 多出来的一字符用于存储 CString 的 EOS '\00'
};

这里 struct php_string 是一个 item 为 char 的 （sequence 兼 buffer）a.k.a. span，因为它在物理上也是连续的

9. 菜鸡 duangsuse 也是正式入坑 CS 足足一年半后才知道啥是位长度啥是进制的，烫烫烫烫烫烫烫烫烫烫...
10. code 现在使用 Piece Table 来作为存储后端数据结构实现
11. 简单数据库操作 CRUD 简单序列操作 QID

一篇简单的 C# LINQ to Monads 文章 #好文分享

C# 函数式编程：LINQ - 不如隐茶去 - 博客园
https://www.cnblogs.com/JacZhu/p/9729587.html

module A+B where

open import Data.List
open import Data.Nat
open import Agda.Builtin.Equality

a+0=0+a : ∀ a → a + 0 ≡ a
a+0=0+a zero = refl
a+0=0+a (suc a) rewrite a+0=0+a a = refl

++a+b=a+b++ : ∀ a b → suc a + b ≡ a + suc b
++a+b=a+b++ zero b = refl
++a+b=a+b++ (suc a) b rewrite ++a+b=a+b++ a b = refl

a+b=b+a : ∀ a b → a + b ≡ b + a
a+b=b+a zero zero = refl
a+b=b+a zero b
rewrite a+0=0+a b
= refl
a+b=b+a (suc a) b
rewrite a+b=b+a a b
| ++a+b=a+b++ b a
= refl

来源请求 A + B = B + A （加法交换律）证明

module EscapeTheMines where

import Control.Applicative

type XY = (Int, Int)
data Move = U | D | R | L deriving (Eq, Show)

dfs :: [[Bool]] -> [XY] -> XY -> XY -> Maybe [Move]
dfs m v s e
|s == e = Just []
|x < 0 || y < 0 = Nothing
|x >= len m = Nothing
|y >= len (m !! x) = Nothing
|elem s v = Nothing
|not $ m !! x !! y = Nothing
|otherwise = (R:) <$> f (x + 1, y)
<|> (D:) <$> f (x, y + 1)
<|> (L:) <$> f (x - 1, y)
<|> (U:) <$> f (x, y - 1)
where (x, y) = s
len = length
f a = dfs m (s : v) a e
--

solve :: [[Bool]] -> XY -> XY -> [Move]
solve a b c = case dfs a [] b c of Just res -> res

来源请求 函数式 DFS（深度优先搜索）

operator fun <A, B, C> ((B) -> A).plus(p: (C) -> B) = { it: C -> this(p(it)) }

fun main(args: Array<String>) {
val a: (Int) -> String = { it.toString() }
val b: (String) -> ByteArray = { it.toByteArray() }
println((b + a)(233))
val c: (ByteArray) -> List<Int> = { it.map { it.toInt() } }
println((c + b + a)(666)) // Haskell: c . b . a $ 666
}

来源请求 Kotlin Function Composition Kotlin 函数合成

WebPack Gradle http://ice1000.org/gist/posgen-gradle/
知乎 Haskell 蜘蛛 http://ice1000.org/gist/rina-spider-zhihu-stu/
C++ Vector http://ice1000.org/gist/vector/
Agda 类型安全 printf http://ice1000.org/gist/safe-printf-agda/

#recommended #backend #blog #lisp（希望大量转载不会引发版权问题 😶

改天分析一下 https://github.com/ice1000/MapGen

http://ice1000.org/2017/07/01/AntiOptimization/

duangsuse 阅读时注意到的事情（本文第二次，作为位运算优化我还只知道右移二倍 times2...）

1. 普通运算优化为位运算的代码在网上被批判为没有用
2. JavaScript 的 Number 只支持到 2 ^ 53 （53 位二进制数，IEEE 754 浮点的锅）
3. 在进行一些需要比较大精度的运算时就会出现一些诡异的问题
4. JavaScript Number 位运算支持到 32 位
5. Number 类似于 C 里面的 double，但 C 里面的不一定是两个字的数据，所以类似 Java 的 double 或 Rust 的 f64
6. 原版赛高（不要在意 ES6 的 => 箭头函数语法，冰冰非常喜欢使用类似这种的语法...）

fastMul = (a, b, m) => {
  var ret = 0;
  a %= m, b %= m;
  while (b) {
    if(b & 1) ret = (ret + a) % m;
    b >>= 2, a = (a << 1) % m; // patched
  }
  return ret;
}

7. 快速乘就是用于计算 (a×b)%m 的一个巧办法，可以避免 a×b 过大导致整数溢出而使结果不准确。
8. 由于掐掉前面的位并不影响 n&1 这个操作，因此我们还能继续使用（位运算） &
9. b = Math.floor(b / 2), a = (a + a) % m;
10. 原版是

b >>= 2, a = (a << 1) % m

;
11. Math.floor(x) 是向下（单舍）取整的意思
12. b >> 2 和 b / 2 不是等价（废话）（部分等价的是 b >> 1）的，不过我不知道这是不是弄错了
13. 1 << m 换成 Math.pow(2, m)
14. 我去，1 << m 和 m << 1 有区别？一个是 m ** 2 一个是 m * 2 (m + m)
15. 加法溢出问题就是说这个

var a = 9007199254740992;
var mod = 1000000007;
(a + a) % mod;

两个都是合法的 JavaScript Number 可是溢出了，因为 a + a 太大了当然损失精度，但是不知道为什么出现了溢出到负数的结果
等价运算 (a % mod + a % mod) % mod == (a + a) % mod

16. 原版 fashPlus，就是说
fastPlus(x) = (a + b) % m
分情况检查做了几个分支保护原版 fastPlus 不受溢出侵蚀吧

(define fast-plus (lambda (a b m)
  (mod (+ a b) m))))

好吧，由于 Chez Scheme 貌似是用 BigIntegter 的（无限长度不会溢出，真・自然数）... 所以换 ES6

fastPlus = (a, b, mod) => {
 let plus = (a1, b1, m1) => return (a + b) % m, s = a + b;
 if (s >= a && s >= b) return s % mod;
 if (a > m) return plus(a % mod, b, mod);
 if (b > m) return plus(a, b % mod, mod);
 return a - mod + b;
}

http://ice1000.org/2017/04/24/JniObjGlobalRef/

看到字典树，我首先想到的就是 RegularPP 的字符串批量替换功能需要这种数据结构优化.... 😶
但可惜天不遂人愿，C 程序设计语言是不自带 HashMap 的实现的
而且我也懒得再去研究下 HashMap 该怎么写... 据说挺复杂，之前我都没看懂
那么问题来了

class Node():
    def __init__(self):
        self.children = {}
        self.value = None

我们看看第四行的 {} 它是什么？

In [2]: dict()
Out[2]: {}

嗯，一个 dict，或者说是 HashMap，或者管他什么 Map，但是 Python 里这是 HashMap

不过我要做的是被称为 ByteTrie 的东西，幸好 Byte 只有 256 种可能
目前计划好的算法呢... 就是使用 ArrayMap 替换 HashMap 实现 ByteTrie，不过添加额外的优化，类似这样

#include <stdint.h>
#include <list.h>

typedef uint8_t byte;

typedef struct bytepair { byte key; byte value; } BytePair;
typedef struct bytemap { LinkedList list; } ByteMap;

typedef struct bytetrie {
  LinkedList bin0;
  LinkedList bin1;
  LinkedList bin2;
  LinkedList bin3;
  LinkedList bin4;
  LinkedList bin5;
  LinkedList bin6;
  LinkedList bin7;
} ByteTrie;

struct bytetrienode {
  LinkedList bin0to31;
} ByteTrieNode;

根树有 8 个静态桶，所有子树都有 32 个虚拟桶
就是说根树查找最坏 32 次比较 byte （或许已经对齐到 int）可以得到答案（子树或者结束符），而子树最多需要 8 次，虽然是模拟的（所以有额外桶查找开销，桶最坏情况得比较 32 次 byte 才找得到）

API 是这么计划的

typedef struct bytetrieresult {
  byte flags;
  union {
    byte result;
    void *node;
  };
} ByteTrieResult;

struct bytetrieapi {
  ByteTrieResult (*set)(ByteTrie tree, string key, byte value);
  ByteTrieResult (*get)(ByteTrie tree, string key);
  ByteTrieResult (*nget)(ByteTrieNode node, string key);
  ByteTrieResult (*remove)(ByteTrie tree, string key);
  ByteTrieResult (*dirs)(ByteTrie tree, string key);
  ByteTrieResult (*objs)(ByteTrie tree, string key);
};

const struct bytetrieapi btrie = { /* Func ptrs */ };

这里还有类似的 Bitwise Trie

#linux #backend #CS https://en.wikipedia.org/wiki/C_dynamic_memory_allocation#dlmalloc