基数估计的初衷就是为了解决在大数据的前提下，如何以低成本的空间复杂度去计算超大集合的势的问题，换句话说，通过基数估计，单机做到计算亿级别uv，误差在4%以内。解决思路主要是概率估计，具体原理和做法参看 blog和论文原文。

     出于实验的目的，我简单实现了暴力做法bruteforce-bf，布隆过滤器-bbf，loglog-llc和hyperloglog-hllc四个算法，比较一下基数估计这个计算去重指标的逻辑是否可行（llc非常离谱，可能是我分桶数没有调整好，就不贴出结果了）。

预处理方法：1-N生成随机uid，模拟N次（均匀分布），jvm启动-Xmx1024m。

实验结果：

附加说明一下，期望值如何计算：其实这个实验的数学原型就是一个长度为k的均匀分布的（1-N)的随机数列，求不重复的元素个数的期望。我实验里k=n，这是一种极端情况（实验设计纯为方便计算，如果k较大会导致计算超慢，uv5000w时根本无法计算出来，增大k理论上会提高精度，我实验过的一组数据是100w uv 500wpv时 hllc的值是991234，误差<1%），理论上k相当于pv，在递推公式中k趋于无穷时期望等于n。

这个递推的计算可以通过组合分析推导，推导方法不详说了（当然我有可能推导错了~~数学功底 实在 不行了），通项公式见matlab代码。

syms e n;
e = n-(1/n)*((1-2*n+n*n)*((n-1)/n)^(n-2)+(1-n)*n+n*(n-1));

vpa(subs(e,'n',1000000),10)

另外，我个人认为分布式布隆过滤器的方案是非常好的，因为空间和时间都比较均衡，且精确度高，基数估计的方法本质上空间复杂度O(1)，时间复杂度代码高效一点也可以非常快，但是缺点是精确度稍微欠缺，且不易分布式计算（因为它天生适合单进程，llc分桶均衡也是单进程做比较好，分布式完全是牛刀杀鸡）。

ref blog: http://blog.codinglabs.org/articles/cardinality-estimate-exper.html#ref4

算法实现的java代码可见github： https://github.com/changedi/card-estimate

首先从我们计算机人最熟悉的线性代数开始。

今天先写第一篇：向量——vector。另外补充一句，每一个具体类或者包的研究都是示例性质的，具体要用到什么类型的类或者接口，大家应该自己动手去翻阅api doc。

Vector是一个普通的向量。在math包org.apache.commons.math.linear中有RealVector和FieldVector这两种向量，均是接口类型。前者是实数类型的向量，后者是场向量。以实数向量为例，RealVector有AbstractRealVector, ArrayRealVector。具体的结构类图见下：

这个结构可能会有些变化，因为在doc中，可以看到ArrayRealVector是继承AbstractRealVector的，而2.0的代码中ArrayRealVector还是直接实现了RealVector，且包中也没有AbstractRealVector。可见代码的变化和doc中的描述也有不同，虽然doc中说明了AbstractRealVector是since 2.0的，而且ArrayRealVector也是since 2.0的。呵呵，一个不一致。其实是update date的不同了。

向量这个概念是线性代数的基础。RealVector作为基本的接口，已经定义了基本所有的向量操作。比如向量的加减乘除运算、向量外积、向量内积、向量范数等等，当然vector的实现时基于数组类型的。RealVector的内部实现是double []data;。

需要重点解释的是一个操作map***：就像原来的api解释的“The various mapXxx and mapXxxToSelf methods operate on vectors element-wise, i.e. they perform the same operation (adding a scalar, applying a function ...) on each element in turn. The mapXxx versions create a new vector to hold the result and do not change the instance. The mapXxxToSelf versions use the instance itself to store the results, so the instance is changed by these methods. In both cases, the result vector is returned by the methods”。

具体是什么呢？很多的map***操作和map***toself操作就是对向量的每一个元素做固定操作的意思。而map***是返回新的实例的，而map***toself则返回自己。这个从源码可以看出，比如mapAdd()的实现：

1public RealVector mapAdd(double d) {
2        double[] out = new double[data.length];
3        for (int i = 0; i < data.length; i++) {
4            out[i] = data[i] + d;
5        }
6        return new ArrayRealVector(out);
7}
8

而mapAddToSelf()的实现：

1public RealVector mapAddToSelf(double d) {
2        for (int i = 0; i < data.length; i++) {
3            data[i] = data[i] + d;
4        }
5        return this;
6}
7

区别显然了，一个返回new ArrayRealVector，一个返回this。

具体见代码：

 1/** *//**
 2 * 
 3 */
 4package algorithm.math;
 5
 6import org.apache.commons.math.linear.ArrayRealVector;
 7import org.apache.commons.math.linear.RealVector;
 8
 9/** *//**
10 * @author Jia Yu
11 * @date 2010-11-18
12 */
13public class VectorTest {
14
15    /** *//**
16     * @param args
17     */
18    public static void main(String[] args) {
19        // TODO Auto-generated method stub
20        vector();
21    }
22
23    private static void vector() {
24        // TODO Auto-generated method stub
25        double[] vec1 = { 1d, 2d, 3d };
26        double[] vec2 = { 4d, 5d, 6d };
27        ArrayRealVector v1 = new ArrayRealVector(vec1);
28        ArrayRealVector v2 = new ArrayRealVector(vec2);
29
30        // output directly
31        System.out.println("v1 is " + v1);
32        // dimension : size of vector
33        System.out.println("size is " + v1.getDimension());
34        // vector add
35        System.out.println("v1 + v2 = " + v1.add(v2));
36        System.out.println("v1 + v2 = " + v1.add(vec2));
37        // vector substract
38        System.out.println("v1 - v2 = " + v1.subtract(v2));
39        // vector element by element multiply
40        System.out.println("v1 * v2 = " + v1.ebeMultiply(v2));
41        // vector element by element divide
42        System.out.println("v1 / v2 = " + v1.ebeDivide(v2));
43        // get index at 1
44        System.out.println("v1[1] = " + v1.getEntry(1));
45        // vector append
46        RealVector t_vec = v1.append(v2);
47        System.out.println("v1 append v2 is " + t_vec);
48        // vector distance
49        System.out.println("distance between v1 and v2 is "
50                + v1.getDistance(v2));
51        System.out.println("L1 distance between v1 and v2 is "
52                + v1.getL1Distance(v2));
53        // vector norm
54        System.out.println("norm of v1 is " + v1.getNorm());
55        // vector dot product
56        System.out.println("dot product of v1 and v2 is " + v1.dotProduct(v2));
57        // vector outer product
58        System.out.println("outer product of v1 and v2 is "
59                + v1.outerProduct(v2));
60        // vector orthogonal projection
61        System.out.println("hogonal projection of v1 and v2 is "
62                + v1.projection(v2));
63        // vector map operations
64        System.out.println("Map the Math.abs(double) function to v1 is "
65                + v1.mapAbs());
66        v1.mapInvToSelf();
67        System.out.println("Map the 1/x function to v1 itself is " + v1);
68        // vector get sub vector
69        System.out.println("sub vector of v1 is " + v1.getSubVector(0, 2));
70    }
71
72}
73

对应的输出：

v1 is {1; 2; 3}
size is 3
v1 + v2 = {5; 7; 9}
v1 + v2 = {5; 7; 9}
v1 - v2 = {-3; -3; -3}
v1 * v2 = {4; 10; 18}
v1 / v2 = {0.25; 0.4; 0.5}
v1[1] = 2.0
v1 append v2 is {1; 2; 3; 4; 5; 6}
distance between v1 and v2 is 5.196152422706632
L1 distance between v1 and v2 is 9.0
norm of v1 is 3.7416573867739413
dot product of v1 and v2 is 32.0
outer product of v1 and v2 is Array2DRowRealMatrix{{4.0,5.0,6.0},{8.0,10.0,12.0},{12.0,15.0,18.0}}
hogonal projection of v1 and v2 is {1.66; 2.08; 2.49}
Map the Math.abs(double) function to v1 is {1; 2; 3}
Map the 1/x function to v1 itself is {1; 0.5; 0.33}
sub vector of v1 is {1; 0.5}

向量是一个基础数学结构，以后还会大量的提到。Commons Math库为我们提供了这样方便的向量表示，在用Java写起程序来也是得心应手。

当然所有的研究要以文档为主，参看文档写代码这是必须做到的事情。所以，不要嫌麻烦，赶紧把api doc放到桌面上，开始coding吧。

相关资料：

向量定义：http://zh.wikipedia.org/zh/%E7%9F%A2%E9%87%8F

Commons math包：http://commons.apache.org/math/index.html

目录

今天开始着手对commons math 2.1库的研究，标准的名字应该是The Apache Commons Mathematics Library。上网一查，没查到相关的学习资料，没办法，自己对着代码一点点啃吧。正好打发闲散时光，还可以回顾复习一些数学知识，其实一个主要原因是本人本硕阶段均未学习过任何数值分析方面的课程，实在悲哀，于是萌发了研究Math库的热情。当然这份文档记录也可以为以后要用Java写数学代码的同学提供一点参考。

先列出一个目录：（这个目录是根据commons math 2.1库的结构设计的）

Section 1 linear algebra 线性代数（矩阵为主）

1） Vector 向量

2） Matrix 矩阵

3） Matrix Decomposition 矩阵分解

Section 2 analysis 数学分析（函数为主）

1） Function 函数

2） Polynomial 多项式函数

3） Interpolation 插值

4） Integration 积分

5） Solver 求解

Section 3 Probabilityand Statistics 概率和统计

       1）distribution 分布

       2）fraction and complex 分数和复数

       3）random and statistics 随机生成和统计初步
     
   4）cluster and regression聚类和回归