精华内容
下载资源
问答
  • 在搜索时,只查询向量x所在的空间数据库向量或者和几个相邻的数据库向量。这是通过 IndexIVFFlat 索引完成的。这种类型的索引需要训练,可以在与数据库向量具有相同分布的向量集上训练。 实际上,我们只使用数据库...

    一、Faster search

    太慢了,如何再快一点呢?

    为了加快搜索速度,可以将数据集分割为多块。Faiss在d维空间中定义了维诺空间,每个数据库向量都落在其中的一个空间。 在搜索时,只查询向量x所在的空间数据库向量或者和几个相邻的数据库向量。

    这是通过 IndexIVFFlat 索引完成的。这种类型的索引需要训练,可以在与数据库向量具有相同分布的向量集上训练。 实际上,我们只使用数据库向量本身训练就够了。

    IndexIVFFlat 的过程其实分成两步。其中一步是将向量分配切分成维诺空间,每个空间都由一个中心定义,找到向量所属的维诺空间,这一般是由量化器完成,而另一步是在维诺空间找到向量的最近邻,这是另一个索引的任务,它通常是IndexFlatL2。

    两个参数:nlist,单元格数;nprobe,执行搜索时访问的维诺空间数。搜索时间大致随nprobe线性增加。

    python

    nlist = 100

    k = 4

    quantizer = faiss.IndexFlatL2(d) # the other index

    index = faiss.IndexIVFFlat(quantizer, d, nlist)

    assert not index.is_trained

    index.train(xb)

    assert index.is_trained

    index.add(xb) # add may be a bit slower as well

    D, I = index.search(xq, k) # actual search

    print(I[-5:]) # neighbors of the 5 last queries

    index.nprobe = 10 # default nprobe is 1, try a few more

    D, I = index.search(xq, k)

    print(I[-5:]) # neighbors of the 5 last queries

    结果

    对于nprobe=1,结果如下

    [[9900 10500 9831 10808]

    [11055 10812 11321 10260]

    [11353 10164 10719 11013]

    [10571 10203 10793 10952]

    [9582 10304 9622 9229]]

    结果是近似的,与暴力搜索的值不完全相同。这是因为有些结果不在相同的维诺空间中。因此,访问更多的维诺空间可能被证明是有效的。

    将nprobe增加到10确实可以做到这一点:

    [[9900 10500 9309 9831]

    [11055 10895 10812 11321]

    [11353 11103 10164 9787]

    [10571 10664 10632 9638]

    [9628 9554 10036 9582]]

    这是正确的结果。注意,在这种情况下得到完美的结果仅仅是数据分布的作用。 nprobe参数始终是在速度和结果精度之间进行权衡的一种方法。设置nprobe=nlist得到的结果与暴力搜索相同(但速度较慢)。

    二、Lower memory footprint

    如果faiss占用了太多的内存,如何缩小所需存储空间?

    索引IndexFlatL2和 IndexIVFFlat 都存储完整的向量。为了扩展到非常大的数据集,Faiss提供了基于乘积量化器的有损压缩方式。

    向量仍然存储在Voronoi空间中,但是向量的大小压缩到m字节(d必须是m的倍数)。

    压缩基于乘积量化器,该量化器应用于要编码的向量的子向量上。

    在这种情况下,由于向量没有被精确地存储,搜索方法返回的距离也是近似值。

    In Python

    nlist = 100

    m = 8 # number of subquantizers

    k = 4

    quantizer = faiss.IndexFlatL2(d) # this remains the same

    index = faiss.IndexIVFPQ(quantizer, d, nlist, m, 8)

    # 8 specifies that each sub-vector is encoded as 8 bits

    index.train(xb)

    index.add(xb)

    D, I = index.search(xb[:5], k) # sanity check

    print(I)

    print(D)

    index.nprobe = 10 # make comparable with experiment above

    D, I = index.search(xq, k) # search

    print(I[-5:])

    Results

    输出近似为:

    [[ 0 608 220 228]

    [ 1 1063 277 617]

    [ 2 46 114 304]

    [ 3 791 527 316]

    [ 4 159 288 393]]

    [[ 1.40704751 6.19361687 6.34912491 6.35771513]

    [ 1.49901485 5.66632462 5.94188499 6.29570007]

    [ 1.63260388 6.04126883 6.18447495 6.26815748]

    [ 1.5356375 6.33165455 6.64519501 6.86594009]

    [ 1.46203303 6.5022912 6.62621975 6.63154221]]

    我们可以观察到最近邻被正确地找到(它是向量ID本身),但是向量到自身的估计距离不是0,尽管它明显低于到其他邻居的距离。这是由于有损压缩。

    这里我们将长度为64的32位浮点向量压缩到8个字节,所以压缩因子是32。

    搜索实际查询时,结果如下:

    [[ 9432 9649 9900 10287]

    [10229 10403 9829 9740]

    [10847 10824 9787 10089]

    [11268 10935 10260 10571]

    [ 9582 10304 9616 9850]]

    与 IVFFlat 的结果进行比较,大多数结果都是错误的,但是它们位于空间的正确区域中。实际数据的情况更好,因为:正态分布的数据很难索引,因为没有规律性可以用来聚类或降维

    对于自然数据,语义近邻往往比无关结果更接近。

    Simplifying index construction

    由于构建索引可能是非常复杂的,因此faiss 可以通过 factory function 在给定字符串的情况下构造索引。上面的索引可通过以下快速获得:

    index = faiss.index_factory(d, "IVF100,PQ8")

    faiss::Index *index = faiss::index_factory(d, "IVF100,PQ8");

    将PQ4替换为Flat可以获得IndexFlat。当预处理(PCA)应用于输入向量时,factory 特别有用。 例如,预处理为通过PCA投影将向量减少到32D,factory 为:“PCA32,IVF100,Flat”。

    三、Faiss可以完美利用您的nvidia GPU。

    首先,声明一个GPU资源,它封装了GPU内存块:

    In Python

    res = faiss.StandardGpuResources() # use a single GPU

    然后使用GPU资源构建GPU索引:

    # build a flat (CPU) index

    index_flat = faiss.IndexFlatL2(d)

    # make it into a gpu index

    gpu_index_flat = faiss.index_cpu_to_gpu(res, 0, index_flat)

    获得的GPU索引可以与CPU索引以完全相同的方式使用:

    gpu_index_flat.add(xb) # add vectors to the index

    print(gpu_index_flat.ntotal)

    k = 4 # we want to see 4 nearest neighbors

    D, I = gpu_index_flat.search(xq, k) # actual search

    print(I[:5]) # neighbors of the 5 first queries

    print(I[-5:]) # neighbors of the 5 last queries

    结果

    结果与CPU版本相同。还要注意,在小型数据集上,性能的提高不会很明显。

    使用多个GPU

    利用多个GPU主要是需要声明几个GPU资源。在python中,可以使用index_cpu_to_all_gpus helper隐式地完成此操作。

    示例:

    In Python

    ngpus = faiss.get_num_gpus()

    print("number of GPUs:", ngpus)

    cpu_index = faiss.IndexFlatL2(d)

    gpu_index = faiss.index_cpu_to_all_gpus( # build the index

    cpu_index

    )

    gpu_index.add(xb) # add vectors to the index

    print(gpu_index.ntotal)

    k = 4 # we want to see 4 nearest neighbors

    D, I = gpu_index.search(xq, k) # actual search

    print(I[:5]) # neighbors of the 5 first queries

    print(I[-5:]) # neighbors of the 5 last queries

    更多关于faiss的文章,关注@一小撮人;

    展开全文
  • 纯物质热力学计算表正丁烷N-Butane使用说明:在PUREDATA中查找物质序号,填入C6中,并将相应的温度,压力填入F6,I6中,按"F9"键重新计算即可物质序号6查PureData...798.75Kpa临界体积0.25458m3/Kmol临界压缩因子0.27...

    纯物质热力学计算表

    正丁烷  N-Butane

    使用说明:

    PUREDATA

    中查找物质序号,填入

    C6

    ,

    并将相应的温度

    ,

    压力填入

    F6,I6

    ,

    "F9"

    键重新计算即可

    物质序号

    6

    PureData

    温度

    143.23

    C

    压力

    105

    Kpa

    416.23

    K

    中文名

    英文名

    分子式

    分子量

    常压沸点

    272.70

    K

    临界性质

    临界温度

    425.16

    K

    临界压力

    3,798.75

    Kpa

    临界体积

    0.25458

    m

    3

    /Kmol

    临界压缩因子

    0.2736

    Rackett Zra

    0.2728

    分子体积

    0.013

    m

    3

    /Kmol

    偏心因子

    0.1950

    定义值

    修正偏心因子

    0.2010

    SRK, PR方程用

    热性质

    常压沸点汽化热

    2.2388E+04

    KJ/kmol

    生成焓

    -1.2562E+05

    KJ/kmol

    Gibbs

    自由能

    -1.7151E+04

    KJ/kmol

    理想气体热容

    系数

    A

    B

    C

    D

    E

    F

    等压热容

    1.2852E+02

    KJ/kmol.K

    32.53010882

    0.177015227

    0.000287955

    -4.8427E-07

    2.66127E-10

    -5.1657E-14

    蒸汽压

    Antoine

    A

    B

    C

    3.2336E+03

    Kpa

    15.999

    2292.4

    -27.862

    31.92

    atmA

    液相表面张力

    Tension

    A

    B

    4.4965E-04

    N/M

    0.05266

    1.233

    液相密度

    回归法系数

    A

    B

    C

    D

    首选

    6.1036E+00

    Kmol/m^3

    1.1103

    0.27881

    425.18

    0.28377

    354.7426

    Kg/m^3

    1.1228E-01

    m^3/Kmol

    Cavet

    法估算

    517.6306

    Kg/m^3

    1.6500E-01

    m^3/Kmol

    Rickett法估算

    352.2506

    Kg/m^3

    1.6563E-01

    m^3/Kmol

    临界压缩因子法估算

    350.8943

    Kg/m^3

    液相粘度

    Vis

    A

    B

    9.53366E-05

    Pa.S

    265.84

    160.200

    液相热容

    A

    B

    C

    D

    E

    2.1862E+02

    KJ/kmol.K

    290600

    -3003.6

    18.266

    -0.047125

    0.00004704

    汽化热

    A

    B

    C

    D

    7.6248E+03

    KJ/kmol

    33430000

    0.4177

    -0.075

    0.04

    气体粘度

    DipolM

    StielF

    PolarP

    EpsDivK

    MolDia

    Database

    0

    0

    0

    0.0

    0

    Correlation

    261.2

    5.60

    烃类

    1.0303E-02

    mPa.S (CP)

    INT Omega

    0.77851

    2.7684

    正丁烷

    N-Butane

    C4H10

    58.12

    展开全文
  • SQLServer2008查询性能优化 2/2

    热门讨论 2012-03-02 16:26:55
    8.5 填充因子的重要性 209 8.6 自动维护 212 8.7 小结 217 第9章 执行计划缓冲分析 218 9.1 执行计划生成 218 9.1.1 解析器 219 9.1.2 代数化器 220 9.1.3 优化 221 9.2 执行计划缓冲 227 9.3 执行计划...
  • 8.5 填充因子的重要性 209 8.6 自动维护 212 8.7 小结 217 第9章 执行计划缓冲分析 218 9.1 执行计划生成 218 9.1.1 解析器 219 9.1.2 代数化器 220 9.1.3 优化 221 9.2 执行计划缓冲 227 9.3 执行计划...
  • 题目大意: 查询结构, 初始给定一个序列,支持两种操作, 一种是 在区间上每个数都乘上一个x, 一种是查询区间上每个数累乘后的结果的欧拉函数。...euler(n)=n*{因子乘积(1-1/p)}形式, 打表发现...

    题目链接:http://codeforces.com/contest/1114

    题目大意:

    查询结构,
    初始给定一个序列,支持两种操作,
    一种是 在区间上每个数都乘上一个x,
    一种是查询区间上每个数累乘后的结果的欧拉函数。

    题目分析: 

    这道题应该是 比较简单的,
    主要感觉还是考验代码功底吧。
    观察欧拉函数的性质即可,
    euler(n)=n*{因子乘积(1-1/p)}形式,
    打表发现300以内的质数个数刚好是62,用long long存的下,
    那么不难想到,开两颗线段树,一颗维护前面的n,就是普通的区间乘积形式,
    另一种是维护区间中包含的质因子的形式,这方面可以用状压表示该区间到底存放了哪些质因子,
    关于质因子区间性质对应位运算应该是或运算。
    两种区间性质都清楚了代码结构就清楚了,注意逆元最好预处理下不然可能超时。

    #include<bits/stdc++.h>
    using namespace std;
    
    #define debug puts("YES");
    #define rep(x,y,z) for(int (x)=(y);(x)<(z);(x)++)
    #define ll long long
    
    #define lrt int l,int r,int rt
    #define lson l,mid,rt<<1
    #define rson mid+1,r,rt<<1|1
    #define root l,r,rt
    #define mst(a,b) memset((a),(b),sizeof(a))
    #define pii pair<int,int>
    #define fi first
    #define se second
    #define mk(x,y) make_pair(x,y)
    const int mod=1e9+7;
    const int maxn=4e5+10;
    const int ub=1e6;
    const double inf=1e-4;
    ll powmod(ll x,ll y){ll t; for(t=1;y;y>>=1,x=x*x%mod) if(y&1) t=t*x%mod; return t;}
    ll gcd(ll x,ll y){return y?gcd(y,x%y):x;}
    /*
    题目大意:
    查询结构,
    初始给定一个序列,支持两种操作,
    一种是 在区间上每个数都乘上一个x,
    一种是查询区间上每个数累乘后的结果的欧拉函数。
    
    题目分析:
    这道题应该是 比较简单的,
    主要感觉还是考验代码功底吧。
    观察欧拉函数的性质即可,
    euler(n)=n*{因子乘积(1-1/p)}形式,
    打表发现300以内的质数个数刚好是62,用long long存的下,
    那么不难想到,开两颗线段树,一颗维护前面的n,就是普通的区间乘积形式,
    另一种是维护区间中包含的质因子的形式,这方面可以用状压表示该区间到底存放了哪些质因子,
    关于质因子区间性质对应位运算应该是或运算。
    两种区间性质都清楚了代码结构就清楚了,注意逆元最好预处理下不然可能超时。
    
    */
    
    int p[400],vis[400],tot=0;
    ll inv[301];
    void sieve(){
        rep(i,2,300){
            if(!vis[i]) p[tot++]=i;
            rep(j,0,tot){
                if(1LL*i*p[j]>=300) break;
                vis[i*p[j]]=1;
                if(i%p[j]==0) break;
            }
        }
        mst(inv,0),inv[0]=inv[1]=1;
        for(int i=2;i<301;i++) inv[i]=1LL*(mod-mod/i)*inv[mod%i]%mod;
        ///cout<<inv[59]<<" "<<powmod(59LL,mod-2)<<endl;
    }
    int n,m,x;
    ll a[maxn],b[maxn];
    struct seg{
        ll tree[maxn<<2],lazy[maxn<<2];
        int flag;
        void build(lrt){
            lazy[rt]=flag;
            if(l==r){
                if(flag) tree[rt]=b[l];
                else tree[rt]=a[l];
                return ;
            }
            int mid=l+r>>1;
            build(lson),build(rson);
            if(flag) tree[rt]=tree[rt<<1]*tree[rt<<1|1]%mod;
            else tree[rt]=tree[rt<<1]|tree[rt<<1|1];
        }
        void pushdown(int l,int r,int rt){
            int mid=l+r>>1;
            if(lazy[rt]!=flag){
                if(flag){
                    (lazy[rt<<1]*=lazy[rt])%=mod;
                    (lazy[rt<<1|1]*=lazy[rt])%=mod;
                    tree[rt<<1]=tree[rt<<1]*powmod(lazy[rt],mid-l+1)%mod;
                    tree[rt<<1|1]=tree[rt<<1|1]*powmod(lazy[rt],r-mid)%mod;
                }
                else{
                    lazy[rt<<1]|=lazy[rt];
                    lazy[rt<<1|1]|=lazy[rt];
                    tree[rt<<1]|=lazy[rt];
                    tree[rt<<1|1]|=lazy[rt];
                }
                lazy[rt]=flag;
            }
        }
        void update(lrt,int L,int R,ll v){
            if(L<=l&&r<=R){
                if(flag)tree[rt]=tree[rt]*powmod(v,r-l+1)%mod;
                else tree[rt]|=v;
    
                if(flag) (lazy[rt]*=v)%=mod;
                else lazy[rt]|=v;
                return ;
            }
            pushdown(l,r,rt);
            int mid=l+r>>1;
            if(L<=mid)update(lson,L,R,v);
            if(mid<R) update(rson,L,R,v);
            if(flag) tree[rt]=tree[rt<<1]*tree[rt<<1|1]%mod;
            else tree[rt]=tree[rt<<1]|tree[rt<<1|1];
        }
        ll query(lrt,int L,int R){
            if(L<=l&&r<=R)  return tree[rt];
            int mid=l+r>>1;
            pushdown(l,r,rt);
            ll ans=flag;
            if(L<=mid){
                if(flag) ans=ans*query(lson,L,R)%mod;
                else ans|=query(lson,L,R);
            }
            if(mid<R){
                if(flag) ans=ans*query(rson,L,R)%mod;
                else ans|=query(rson,L,R);
            }
            return ans;
        }
    }tree1,tree2;
    int main(){
        sieve();
        cin>>n>>m;
        rep(i,1,n+1){
            cin>>x;b[i]=x;///
            a[i]=0;
            for(int j=2;j<=x;j++)if(x%j==0){
                int pos=lower_bound(p,p+tot,j)-p;
                while(x%j==0) x/=j;
                a[i]|=1LL<<pos;
            }
        }
        tree1.flag=1,tree2.flag=0;
        tree1.build(1,n,1);
        tree2.build(1,n,1);
        rep(i,0,m){
            char op[20];scanf("%s",op);
            int x,y,z;
            if(op[0]=='T'){
               cin>>x>>y;
               ll ret=tree2.query(1,n,1,x,y),ans=tree1.query(1,n,1,x,y);
               rep(j,0,tot) if((1LL<<j)&ret)///这里有点玄学,用==1LL就不行
                    ans=ans*(p[j]-1)%mod*inv[p[j]]%mod;
                cout<<ans<<endl;
            }
            else{
                cin>>x>>y>>z;
                tree1.update(1,n,1,x,y,z);
                ll sta=0;
                for(int j=2;j<=z;j++)if(z%j==0){
                    int pos=lower_bound(p,p+tot,j)-p;
                    sta|=1LL<<pos;
                    while(z%j==0) z/=j;
                }
                tree2.update(1,n,1,x,y,sta);
            }
        }
        return 0;
    }
    

     

    展开全文
  • impala可以处理多个大型表之间的连接。确保统计是来自于所有连接表们的信息。然而,连接多个大表查询确实会消耗比较多的内存...集群总内存需求=连接查询中数据量小的表的数据总量*谓词查询因子*投影运算因子*压缩算...

    impala可以处理多个大型表之间的连接。确保统计是来自于所有连接表们的信息。然而,连接多个大表查询确实会消耗比较多的内存。按照以下步骤可以计算最小内存需求 

     

    假设表B小于表A(但仍然是一个大的表),查询的内存需求是右表(B),在解压、过滤和投影(仅使用某些特定列)之后,必须小于整个集群的总内存。

     集群总内存需求=连接查询中数据量小的表的数据总量*谓词查询因子*投影运算因子*压缩算法比率

     

    因此,如果您有一个10节点的集群,每个节点都有128GB的RAM,而给impala 80%个,那么您就有了1tb的impala可用内存,这超过了此需求的750GB。因此,集群可以处理 这个级别上的连接查询

    展开全文
  • redis的基础知识

    2021-04-15 19:27:54
    缓存雪崩:大量的key同时过期(加时间的随机因子,热度大的因子,热度小的数据因子小) 缓存预热:上线前的工作 缓存降级:缓存失效或者缓存服务挂掉直接访问内存中的默认数据 分布式锁...
  • SQL Server Maintenance plan维护计划

    千次阅读 2012-07-22 22:17:13
     用新的填充(占空)因子重建索引以重组数据和索引页上的数据。这确保数据库页包含相等分布的数据和剩余空间 ,这允许未来更快速成长。 从数据库页中移出空数据页压缩数据文件。更新索引统计以确保查询优化有表分布...
  • SQL Server 2000 Maintenance plan 维护计划

    千次阅读 2004-12-24 14:38:00
    被定期自动执行的维护计划: 用新的填充(占空)因子重建索引以重组数据和索引页上的数据。这确保数据库页包含相等分布的数据和剩余空间 ,这允许未来更快速成长。 从数据库页中移出空数据页压缩数据文件。更新索引...
  • Scylla价格计算器 ...每个操作都将使用复制因子vCPU(假定读取的一致性级别为ALL) 由于商品尺寸过大而导致性能下降:> 10kb perf * = 0.75,> 100kb 0.5,> 1MB 0.25 压缩开销〜1.4倍( ) RAM与磁盘的比例为
  • Lucee+Nutch搜索(源码1)

    热门讨论 2010-06-01 18:23:17
     7.5.3 其他动态排序因子   7.6 Lucene自定义排序   7.6.1 自定义排序比较接口   7.6.2 自定义排序接口类实例   7.6.3 自定义排序结果测试实例   7.6.4 自定义排序测试结果   7.7 Nutch中的结果...
  • java源码包---java 源码 大量 实例

    千次下载 热门讨论 2013-04-18 23:15:26
    java求一个整数的因子 如题。 Java生成密钥的实例 1个目标文件 摘要:Java源码,算法相关,密钥  Java生成密钥、保存密钥的实例源码,通过本源码可以了解到Java如何产生单钥加密的密钥(myKey)、产生双钥的密钥对(key...
  • java源码包2

    千次下载 热门讨论 2013-04-20 11:28:17
    java求一个整数的因子 如题。 Java生成密钥的实例 1个目标文件 摘要:Java源码,算法相关,密钥  Java生成密钥、保存密钥的实例源码,通过本源码可以了解到Java如何产生单钥加密的密钥(myKey)、产生双钥的密钥对...
  • java源码包3

    千次下载 热门讨论 2013-04-20 11:30:13
    java求一个整数的因子 如题。 Java生成密钥的实例 1个目标文件 摘要:Java源码,算法相关,密钥  Java生成密钥、保存密钥的实例源码,通过本源码可以了解到Java如何产生单钥加密的密钥(myKey)、产生双钥的密钥对...
  • java源码包4

    千次下载 热门讨论 2013-04-20 11:31:44
    java求一个整数的因子 如题。 Java生成密钥的实例 1个目标文件 摘要:Java源码,算法相关,密钥  Java生成密钥、保存密钥的实例源码,通过本源码可以了解到Java如何产生单钥加密的密钥(myKey)、产生双钥的密钥对...
  • java求一个整数的因子 如题。 Java生成密钥的实例 1个目标文件 摘要:Java源码,算法相关,密钥 Java生成密钥、保存密钥的实例源码,通过本源码可以了解到Java如何产生单钥加密的密钥(myKey)、产生双钥的密钥对(key...
  • java求一个整数的因子 如题。 Java生成密钥的实例 1个目标文件 摘要:Java源码,算法相关,密钥 Java生成密钥、保存密钥的实例源码,通过本源码可以了解到Java如何产生单钥加密的密钥(myKey)、产生双钥的密钥对(key...
  • 10.2.5 将子查询因子化应用到PL/SQL中 270 10.3 递归子查询 273 10.3.1 一个CONNECT BY的例子 274 10.3.2 使用RSF的例子 275 10.3.3 RSF的限制条件 276 10.3.4 与CONNECT BY的不同点 276 10.4 复制CONNECT BY...
  • java求一个整数的因子 如题。 Java生成密钥的实例 1个目标文件 摘要:Java源码,算法相关,密钥 Java生成密钥、保存密钥的实例源码,通过本源码可以了解到Java如何产生单钥加密的密钥(myKey)、产生双钥的密钥对(key...
  • JAVA上百实例源码以及开源项目

    千次下载 热门讨论 2016-01-03 17:37:40
    java求一个整数的因子 如题。 Java生成密钥的实例 1个目标文件 摘要:Java源码,算法相关,密钥  Java生成密钥、保存密钥的实例源码,通过本源码可以了解到Java如何产生单钥加密的密钥(myKey)、产生双钥的密钥对(key...
  • 10.2.5 将子查询因子化应用到PL/SQL中 270 10.3 递归子查询 273 10.3.1 一个CONNECT BY的例子 274 10.3.2 使用RSF的例子 275 10.3.3 RSF的限制条件 276 10.3.4 与CONNECT BY的不同点 276 10.4 复制CONNECT BY...
  • §13.1.10 压缩索引 165 §13.2 创建索引和使用索引 165 §13.2.1 使用函数索引 165 §13.2.2 使用位图索引- 166 §13.2.3 使用B树索引- 166 §13.2.4 使用反向键索引- 166 §13.2.5 使用索引组织表 166 §13.3 使用...
  • 3.3.4 利用编辑器自动生成查询语句 54 3.3.5 脱机编写SQL语句后连接到服务器 55 3.3.6 全屏显示查询编辑器 55 3.3.7 使用模板编写SQL语句 56 3.3.8 创建自定义模板 57 3.3.9 使用项目脚本和解决方案 58 3.4 ...
  • 3.3.4 利用编辑器自动生成查询语句 54 3.3.5 脱机编写SQL语句后连接到服务器 55 3.3.6 全屏显示查询编辑器 55 3.3.7 使用模板编写SQL语句 56 3.3.8 创建自定义模板 57 3.3.9 使用项目脚本和解决方案 58 3.4 ...
  • 算法导论(原书第三版)

    热门讨论 2013-03-06 14:31:34
    *21.4 带路径压缩的按秩合并的分析 思考题 本章注记 第六部分 图算法 第22章 基本的图算法 22.1 图的表示 22.2 广度优先搜索 22.3 深度优先搜索 22.4 拓扑排序 22.5 强连通分量 思考题 本章注记 第23章 ...
  • 精通DirectX.3D图形与动画程序设计.pdf

    热门讨论 2013-02-17 16:40:18
    9.2 雾化混合因子计算方法 9.3 顶点雾化与像素雾化 9.3.1 顶点雾化与基于范围的雾化 9.3.2 像素雾化和与眼相关深度雾化 9.4 为场景添加雾化效果 9.4.1 顶点雾化示例程序  9.4.2 像素雾化示例程序  9.4.3 基于范围...
  • 算法导论中文版

    2016-10-26 10:13:58
     *21.4 带路径压缩的按秩合并的分析  思考题  本章注记 第六部分 图算法 第22章 基本的图算法  22.1 图的表示  22.2 广度优先搜索  22.3 深度优先搜索  22.4 拓扑排序  22.5 强连通分量  思考题  ...
  • 152 6.1.1 源因子和目标因子 152 6.1.2 启用混合 154 6.1.3 使用混合方程式组合像素 154 6.1.4 混合的样例用法 156 6.1.5 一个混合的例子 157 6.1.6 使用深度缓冲区进行三维混合 159 6.2 抗锯齿 162 6.2.1 对点和...
  • 2.1.1 解压缩 27 2.1.2 里面有什么 27 2.2 从源码编译 28 2.2.1 其他编译目标 30 2.2.2 使用Maven编译 30 2.3 运行Cassandra 30 2.3.1 在Windows平台上运行Cassandra 31 2.3.2 在Linux下运行...

空空如也

空空如也

1 2
收藏数 36
精华内容 14
关键字:

压缩因子查询