精华内容
下载资源
问答
  • 将戴维斯的人际交往指数应用于韩国的1155名高中生,并将该结果与对年龄相近的美国和荷兰学生的调查所得结果进行比较。 结果,韩国的高中生比其他国家的认知移情更高。 但是,在认知移情上,幻想(FN)低于观点接受...
  • 不同于新榜、清博等数据聚合平台,一些有影响力的平台建立了内部的搜索、阅读数据分析系统,这方面比较有代表的就是百度指数、头条指数。有时候,仅头条一个平台就能决定一个内容商的阅读量,所以我们不能小觑这些大...
  • 用随机森林进行特征重要性评估的思想比较简单,主要是看每个特征在随机森林中的每棵树上做了多大的贡献,然后取平均值,最后比较不同特征之间的贡献大小。贡献度的衡量指标包括:基尼指数(gini)、袋外数据(OOB)错误...

    一般情况下,数据集的特征成百上千,因此有必要从中选取对结果影响较大的特征来进行进一步建模,相关的方法有:主成分分析、lasso等,这里我们介绍的是通过随机森林来进行筛选。

    用随机森林进行特征重要性评估的思想比较简单,主要是看每个特征在随机森林中的每棵树上做了多大的贡献,然后取平均值,最后比较不同特征之间的贡献大小。

    贡献度的衡量指标包括:基尼指数(gini)、袋外数据(OOB)错误率作为评价指标来衡量。

    衍生知识点:权重随机森林的应用(用于增加小样本的识别概率,从而提高总体的分类准确率)

    随机森林/CART树在使用时一般通过gini值作为切分节点的标准,而在加权随机森林(WRF)中,权重的本质是赋给小类较大的权重,给大类较小的权重。也就是给小类更大的惩罚。权重的作用有2个,第1点是用于切分点选择中加权计算gini值,表达式如下:

    055f4e0e54c1afeb90d1fcb91ac2510b.png

    随机森林针对小样本数据类权重设置

    https://wenku.baidu.com/view/07ba98cca0c7aa00b52acfc789eb172ded639998.html

    52f7168672336bca2cc4510d5f099f4d.png

    通过sklearn中的随机森林返回特征的重要性:

    394f8d58d576ce026bb7de2fa6da610b.png

    举个样例:

    8b194ddc020a0616725c15143cd01c9a.png

    sklearn.metrics中的评估方法介绍:

    7a75ace9ab0910fff0c189eafe46a7f7.png

    参考:http://blog.csdn.net/cherdw/article/details/54971771

    网格搜索调参:

    grid.fit():运行网格搜索

    grid_scores_:给出不同参数情况下的评价结果

    best_params_:描述了已取得最佳结果的参数的组合

    best_score_:成员提供优化过程期间观察到的最好的评分

    17a9187e8150780645a65b97b55b09aa.png

    http://www.cnblogs.com/xiaochouk/p/8583255.html

    展开全文
  • 用随机森林进行特征重要性评估的思想比较简单,主要是看每个特征在随机森林中的每棵树上做了多大的贡献,然后取平均值,最后比较不同特征之间的贡献大小。贡献度的衡量指标包括:基尼指数(gini)、袋外数据(OOB)错误...

    一般情况下,数据集的特征成百上千,因此有必要从中选取对结果影响较大的特征来进行进一步建模,相关的方法有:主成分分析、lasso等,这里我们介绍的是通过随机森林来进行筛选。

    用随机森林进行特征重要性评估的思想比较简单,主要是看每个特征在随机森林中的每棵树上做了多大的贡献,然后取平均值,最后比较不同特征之间的贡献大小。

    贡献度的衡量指标包括:基尼指数(gini)、袋外数据(OOB)错误率作为评价指标来衡量。

    衍生知识点:权重随机森林的应用(用于增加小样本的识别概率,从而提高总体的分类准确率)

    随机森林/CART树在使用时一般通过gini值作为切分节点的标准,而在加权随机森林(WRF)中,权重的本质是赋给小类较大的权重,给大类较小的权重。也就是给小类更大的惩罚。权重的作用有2个,第1点是用于切分点选择中加权计算gini值,表达式如下:

    a70dd54ce35e906a1a64d9e270131cd8.png

    随机森林针对小样本数据类权重设置

    https://wenku.baidu.com/view/07ba98cca0c7aa00b52acfc789eb172ded639998.html

    a4090bbb7199b8980128fd0520d92bb3.png

    通过sklearn中的随机森林返回特征的重要性:

    50c39f9176a5bb8624ecbfd9d01452cc.png

    举个样例:

    1e64d30a176da7343ce11201b0e47e2e.png

    sklearn.metrics中的评估方法介绍:

    9739800d06235f6a1ef4a4d7250d4522.png

    参考:http://blog.csdn.net/cherdw/article/details/54971771

    网格搜索调参:

    grid.fit():运行网格搜索

    grid_scores_:给出不同参数情况下的评价结果

    best_params_:描述了已取得最佳结果的参数的组合

    best_score_:成员提供优化过程期间观察到的最好的评分

    d4a7ab71689819f14be44c175c4b9174.png

    http://www.cnblogs.com/xiaochouk/p/8583255.html

    展开全文
  • 从特定时期和地点的所有点数据中提取AOD,埃指数大小分布 计算所有站点的平均值,并按记录数过滤 搜索位于该地区的站点 绘图: 平均值 特定地点的时间序列和大小分布 两参数比较 执照 该项目已获得MIT许可
  • Golang的基础数据类型

    2019-11-02 15:09:43
    整数类型3.1 查询某个变量的字节大小和数据类型3.2 如何证明int和int64不是同一种类型3.3 不同的整数类型不能比较4. 浮点型4.1 浮点数 = 符号位+指数位+尾数位4.2 浮点数都是有符号的4.3 float64 比float32准确4.4 ...


    在这里插入图片描述

    1. Go语言数据类型

    1.1 数据类型分类

    Go语言数据类型大致可以分为两类

    1. 基础类型,其中就包括了我们最常见的一些类型

      类型 名称 长度 零值 说明
      bool 布尔类型 1 false 其值不为真即为家,不可以用数字代表true或false
      byte 字节型 1 0 uint8别名
      rune 字符类型 4 0 专用于存储unicode编码,等价于uint32
      int, uint 整型 4或8 0 32位或64位
      int8, uint8 整型 1 0 -128 ~ 127, 0 ~ 255
      int16, uint16 整型 2 0 -32768 ~ 32767, 0 ~ 65535
      int32, uint32 整型 4 0 -21亿 ~ 21 亿, 0 ~ 42 亿
      int64, uint64 整型 8 0
      float32 浮点型 4 0.0 小数位精确到7位
      float64 浮点型 8 0.0 小数位精确到15位
      complex64 复数类型 8
      complex128 复数类型 16
      uintptr 整型 4或8 ⾜以存储指针的uint32或uint64整数
      string 字符串 “” utf-8字符串
    2. 复合类型, 这些类型构成了Go语言的特点

      1. 指针 (pointer)
      2. 数字 (array)
      3. 切片 (slice)
      4. 字典(map)
      5. 通道 (chan)
      6. 结构体 (struct)
      7. 接口 (interface)

    2. 布尔类型

    1. 也叫做bool类型
    2. bool 类型数据的值只能是true 或者 false
    3. bool 类型默认值是false
    4. bool 类型 占1个字节
    5. bool类型一般用于流程控制
    6. bool类型不能接受其他类型赋值
    7. bool类型不支持自动或者强制类型装换
    package main
    
    import "fmt"
    
    var a bool
    
    func main() {
    	//a = 1 // 错误 cannot use 1 (type int) as type bool in assignment
    	fmt.Printf("type = %T\n", a)
    	fmt.Printf("value = %v\n", a)
    	if a {
    		fmt.Println("this is true")
    	} else {
    		fmt.Println("this is false")
    	}
    }
    
    type = bool
    value = false
    this is false
    

    3. 整数类型

    1. 整数类型就是存放整数值得

    2. int类型和uint类型自动匹配平台长度

      类型 有无符号 占用空间 范围 备注
      int 32位系统4个字节
      64位系统8个字节
      231 2311-2^31~2^31-1
      263 2631-2^63~2^63-1
      uint 32位系统4个字节
      64位系统8个字节
      0 23210~2^32-1
      0 26410~2^64-1
      rune 与int32一样 231 2311-2^31~2^31-1 等价int32,表示一个Unicode码
      byte 与uint8等价 0~255 存储字符使用
    3. Go语言的整型默认声明是int型

    4. 通常int和int32被认为是两种不同的类型,编译器不会做自动装换

    5. 整数类型可以进行数值运算 (加减乘除和求余)

    6. 整数类型可以进行比较运算(> , < ,==, >= , <= ,!=)

    7. 两个不同类型的整数不能比较,即使他们的值看着相同也不行

    3.1 查询某个变量的字节大小和数据类型

    package main
    
    import (
    	"fmt"
    	"unsafe"
    )
    
    var v1 int8
    var v2 int16 = 88
    var v3 int32 = 8978923
    var v4 = 8978989
    var v5 int64
    var v6 rune
    func main(){
    	fmt.Printf("v1 类型是%T, v1 占的字节数是%d\n",v1,unsafe.Sizeof(v1))
    	fmt.Printf("v2 类型是%T, v2 占的字节数是%d\n",v2,unsafe.Sizeof(v2))
    	fmt.Printf("v3 类型是%T, v3 占的字节数是%d\n",v3,unsafe.Sizeof(v3))
    	fmt.Printf("v4 类型是%T, v4 占的字节数是%d\n",v4,unsafe.Sizeof(v4))
    	fmt.Printf("v5 类型是%T, v5 占的字节数是%d\n",v5,unsafe.Sizeof(v5))
    	fmt.Printf("v6 类型是%T, v6 占的字节数是%d\n",v6,unsafe.Sizeof(v6))
    }
    
    v1 类型是int8, v1 占的字节数是1
    v2 类型是int16, v2 占的字节数是2
    v3 类型是int32, v3 占的字节数是4
    v4 类型是int, v4 占的字节数是8
    v5 类型是int64, v5 占的字节数是8
    v6 类型是int32, v6 占的字节数是4
    

    3.2 如何证明int和int64不是同一种类型

    package main
    
    import (
    	"fmt"
    	"unsafe"
    )
    
    var v1 = 99
    var v2 int64
    func main(){
    	fmt.Printf("v1的类型是%T,v1占的字节长度是%d\n",v1,unsafe.Sizeof(v1))
    	fmt.Printf("v2的类型是%T,v2占的字节长度是%d\n",v2,unsafe.Sizeof(v2))
    	// 将v1的值赋给v2
    	//v2 = v1  // 错误 cannot use v1 (type int) as type int64 in assignment
    	v2 = int64(v1) // 通过
    	fmt.Printf("v2的值是%v,v2的类型是%T",v2,v2)
    }
    
    
    v1的类型是int,v1占的字节长度是8
    v2的类型是int64,v2占的字节长度是8
    v2的值是99,v2的类型是int64
    

    3.3 不同的整数类型不能比较

    package main
    
    import "fmt"
    
    var a int32
    var b int64
    func main(){
    	a,b=8,8
    	if a == b{	 //invalid operation: a == b (mismatched types int32 and int64)
    		fmt.Println("===")
    	}
    }
    

    4. 浮点型

    浮点型用于表示包含小数点的数据,例如 1.234 , 0.99 , -9.9等就是一个浮点型数据,Go语言中的浮点型采用 IEEE-754 标准的表达方式

    Go语言定义两个浮点类型float32和float64,其中float32相当于C语言中的float类型, float64等价于C语言中的double类型

    类型 占用存储空间 范围
    单精度float32 4字节 -3.4028234663852886e+38~3.4028234663852886e+38
    双精度float64 8字节 -1.7976931348623157e+308~1.7976931348623157e+308

    4.1 浮点数 = 符号位+指数位+尾数位

    4.2 浮点数都是有符号的

    package main
    
    import "fmt"
    
    func main(){
    	var p float32 = 99.99
    	fmt.Println(p)
    	var p1 float32 = -0.33
    	fmt.Println(p1)
    	var p2 float64 = -79787878.9
    	fmt.Println(p2)
    
    }
    
    99.99
    -0.33
    -7.97878789e+07
    

    4.3 float64 比float32准确

    小数部分可能丢失,造成精度损失,要保存高精度的数应该选择float64

    Go语言的浮点型默认是float64类型

    package main
    
    import "fmt"
    
    func main(){
    	var p1 float32  = 897.0000023
    	var p2 float64  = 897.0000023
    	fmt.Println("p1 = ",p1)
    	fmt.Println("p2 = ",p2)
    	p3 := -12.90
        // GO语言默认是使用float64类型
    	fmt.Printf("p3 type = %T",p3)
    }
    
    p1 =  897
    p2 =  897.0000023
    p3 type = float64
    

    4.4 浮点是强制转换

    需要说明float32 和 float64 是两种类型,不能直接相互赋值

    package main
    
    import "fmt"
    
    var f1 float32
    var f2 float64
    func main() {
    	f2 = 1212.09
    	fmt.Printf("f2 type  is %T, value is %v\n",f2,f2)
        // 运行报错
        //cannot use f2 (type float64) as type float32 in assignment
    	f1 = f2
    	fmt.Printf("f1 type  is %T, value is %v\n",f1,f1)
    }
    
    

    我们看看浮点数float32 和 float64类型怎么转换

    package main
    
    import "fmt"
    
    var f1 float32
    var f2 float64
    func main() {
    	f2 = 1212.09
    	fmt.Printf("f2 type  is %T, value is %v\n",f2,f2)
        // 强制转换成float32类型
    	f1 = float32(f2)
    	fmt.Printf("f1 type  is %T, value is %v\n",f1,f1)
    
    }
    
    f2 type  is float64, value is 1212.09
    f1 type  is float32, value is 1212.09
    

    5. 字符类型

    Go语言中支持两种字符类型 分别是byte 和 rune

    1. byte型 ,实际上是uint8类型的别称,代表了ASCII码的一个字符

    2. rune 类型,代表一个unicode 字符 ,实际是一个int32类型,在处理中文,日文或者其他符合类型时需要用到,Go语言中使用特殊的rune类型来处理Unicode,让基于Unicode的文本处理更为方便

      package main
      
      import "fmt"
      
      func main() {
      	var a byte = 'a'
      	var b rune = '中'
      	// a的值`a`对应的ASCII编码是97 实际类型是uint8
      	fmt.Printf("a value = %d type = %T\n", a, a)
      	// b的值`中`对应的Unicode码是20013 实际类型是int32
      	fmt.Printf("b value = %d type = %T\n", b, b)
      	// 输出对应的字符
      	fmt.Printf("a = %c b = %c",a,b)
      }
      
      a value = 97 type = uint8
      b value = 20013 type = int32
      a = a b =

    Unicode 是字符集,ASCII 也是一种字符集,UTF-8是一种编码规则

    字符集为每一个字符分配一个唯一的ID,我们使用的所有字符在unicode字符集中都有唯一的ID对应.

    utf-8 是编码规则,将unicode字符集中的ID以某种形式进行编码

    在Go语言中,字符的本质是一个数字,格式化输出时%c,会输出该数字对应的unicode字符

    package main
    
    import "fmt"
    
    func main(){
    	var v1 int8 = 102
    	fmt.Printf("v1 = %c\n",v1)
    	var v2 int = 22381
    	fmt.Printf("v2 = %c\n",v2)
    }
    
    v1 = f
    v2 =

    字符串是可以进行运算的

    package main
    
    import "fmt"
    
    func main() {
    	var v1 int = 10
    	v1 += 97
    	fmt.Printf("v1 = %d,unicode = %c",v1,v1)
    }
    
    
    v1 = 107,unicode = k
    

    6. string类型

    Go语言字符串数据对应的字节数组,字符串的只读属性禁止了在程序中对底层字节数组的元素修改,字符串赋值只是赋值了数据地址和对应长度,而不会底层数据的赋值

    字符串是一串固定长度的字符连接起来的字符序列,Go语言的字符串的字节使用utf-8编码标识的unicode文本

    字符串类型也就是string类型定义很简单

    package main
    
    import "fmt"
    
    var s1 string
    func main() {
    	s1 = "Celtic 凯尔特人"
    	s2 := "Lakers 湖人"
    	var s3 string = "Rocket 火箭"
    	fmt.Printf("s1 = %s  type = %T\n",s1,s1)
    	fmt.Printf("s2 = %s  type = %T\n",s2,s2)
    	fmt.Printf("s3 = %s  type = %T\n",s3,s3)
    
    }
    
    s1 = Celtic 凯尔特人  type = string
    s2 = Lakers 湖人  type = string
    s3 = Rocket 火箭  type = string
    

    字符串的内容可以用类似数组下标的方式获取,但是与数组不同的是,字符串的内容不能在初始化之后修改

    package main
    
    import "fmt"
    
    func main() {
    	var s1 string = "hello world ~~"
    	// 使用内置函数len()获取字符串长度
    	l := len(s1)
    	fmt.Printf("s1 的长度是 : %d\n",l)
    	// 获取第一个字符
    	ch1 := s1[8]
    	fmt.Printf("%c ch1 = %v,type = %T\n",ch1,ch1,ch1)
    
    }
    
    
    s1 的长度是 : 14
    r ch1 = 114,type = uint8
    

    看一个错误的例子

    package main
    
    import "fmt"
    
    func main() {
    	var s1 string = "hello world ~~"
        //会报编译错误
    	s1[0] = "H"
    	fmt.Println(s1[0])
    }
    
    
    cannot assign to s1[0]
    

    字符串的两种表示形式

    1. 双引号 ,字符串的值在书写在双引号中是最常见的表达方式,也称为字符串字面量,这种形式不能跨行,如果字符串太长,可以使用 + 拼接
    2. 反引号, 以字符串原生样式输出,包括换行和特殊字符
    package main
    
    import "fmt"
    
    func main() {
    	s0 := "hello" +
    		"world"
    	s0 += "\n 中国"
    	fmt.Println(s0)
    }
    
    helloworld
     中国
    
    package main
    
    import "fmt"
    
    func main() {
        // 定义多行字符串
    	var s1 string = `怒发冲冠
    凭栏处潇潇雨歇
    抬望眼
    仰天长啸`
    	fmt.Println(s1)
    }
    
    
    怒发冲冠
    凭栏处潇潇雨歇
    抬望眼
    仰天长啸
    

    以字节数组方式遍历数组

    package main
    
    import "fmt"
    
    func main(){
    	var s1 string  = "golang 中国"
    	// 因为字符占1个字节,汉字占3个字节 所以参数s1的长度是13
    	l := len(s1)
    	for i:= 0 ;i<l;i++{
    		ch := s1[i]  // 依据下标取字符串中的字符,类型为byte
    		fmt.Printf("%T,%d,%d\n",ch,i,ch)
    	}
    }
    
    
    uint8,0,103
    uint8,1,111
    uint8,2,108
    uint8,3,97
    uint8,4,110
    uint8,5,103
    uint8,6,32
    uint8,7,228
    uint8,8,184
    uint8,9,173
    uint8,10,229
    uint8,11,155
    uint8,12,189
    

    以unicode字符遍历数组

    package main
    
    import "fmt"
    
    func main(){
    	var s1 string  = "golang 中国"
    	for i,v := range  s1{
    		// v是rune类型
    		fmt.Printf("%d,%T,%d,%c\n",i,v,v,v)
    	}
    }
    
    
    0,int32,103,g
    1,int32,111,o
    2,int32,108,l
    3,int32,97,a
    4,int32,110,n
    5,int32,103,g
    6,int32,32, 
    7,int32,20013,中
    10,int32,22269,国
    

    6.1 补充1:基本数据类型转换

    Go语言中不同类型变量之间相互赋值时需要显式转换(不能自动转换)

    转换的表达式 T(v) , 意思是将v转换成T类型

    多见于整数的不同类型之间的转换,或者不同浮点数类型之间的转换,或是整数与浮点数之间的相互转

    package main
    
    import "fmt"
    
    func main() {
    	var v1 int8 = 99
    	var v2 int
    
    	fmt.Printf("v1 type is %T,value is %d\n",v1,v1)
    	fmt.Printf("v2 type is %T,value is %d\n",v2,v2)
    	v2 = int(v1)
    	fmt.Printf("v2 type is %T,value is %d\n",v2,v2)
    }
    
    
    v1 type is int8,value is 99
    v2 type is int,value is 0
    v2 type is int,value is 99
    

    GO语言中数据类型的值范围可以从大向小转换,也可以从小向大转换

    package main
    
    import "fmt"
    
    func main() {
        // int8 的范围是 -128 ~ 127
    	var v1 int8
    	var v2 int64 = 9999999
    	var v3 float64
        // 不会报错, 结果是按溢出处理
    	v1 = int8(v2)
    	v3 = float64(v2)
    	fmt.Printf("%T, %d\n",v1,v1)
    	fmt.Printf("%T, %f\n",v3,v3)
    }
    
    
    int8, 127
    float64, 9999999.000000
    

    6.2 补充2 基本数据类型和string 类型的转换

    在实际应用中,string 类型和基础类型的相互转换非常常见

    例如,整数类和浮点数类型,bool型等与string类型之间的转换

    基础类型转成string类型

    方法1: 通过包 fmt 包的Sprintf()函数去实现

    package main
    
    import "fmt"
    
    func main(){
    	var v1 int64 = 99998767
    	var f float64 = 90.7978
    	var b bool = true
    	var ch byte = 'w'
    	var s string
    	s = fmt.Sprintf("%d",v1)
    	fmt.Printf("v2  = %s, %T\n",s,s)
    	s = fmt.Sprintf("%f",f)
    	fmt.Printf("v2  = %s, %T\n",s,s)
    	s = fmt.Sprintf("%t",b)
    	fmt.Printf("v2  = %s, %T\n",s,s)
    	s = fmt.Sprintf("%c",ch)
    	fmt.Printf("v2  = %s, %T\n",s,s)
    }
    
    
    v2  = 99998767, string
    v2  = 90.797800, string
    v2  = true, string
    v2  = w, string
    

    基础数据类型转换成string类型

    方法2 : 使用 strconv 包中的函数实现

    package main
    
    import (
    	"fmt"
    	"strconv"
    )
    
    func main() {
    	var n  int8  = 12
    	var f float64 = 23.001
    	var b bool  = false
    	// FormatInt函数中传入的第一个参数应该是int64类型
    	s := strconv.FormatInt(int64(n),10)
    	fmt.Printf("s  = %s and type = %T\n",s,s)
        // 其中的参数说明参考文档
    	s = strconv.FormatFloat(f,'f',10,64)
    	fmt.Printf("s  = %s and type = %T\n",s,s)
    	s = strconv.FormatBool(b)
    	fmt.Printf("s  = %s and type = %T\n",s,s)
    }
    
    
    s  = 12 and type = string
    s  = 23.0010000000 and type = string
    s  = false and type = string
    

    strconv 包中有其他的方法可以将string类型转换成整数类型,浮点数类型,bool类型,函数名为 ParseInt() ParseBool() ParseFloat() **ParseUint()

    package main
    
    import (
    	"fmt"
    	"strconv"
    )
    
    func main() {
    	var s1 string = "99090"
    	var s2 string = "12.090"
    	var s3 string = "true"
    	var s4 string = "97"
    	var s5 string = "helloworld"
    	n, _ := strconv.ParseInt(s1, 10, 64)
    	fmt.Printf("n = %d,type = %T\n", n, n)
    	f, _ := strconv.ParseFloat(s2, 64)
    	fmt.Printf("f = %f,type = %T\n", f, f)
    	b, _ := strconv.ParseBool(s3)
    	fmt.Printf("b = %t,type = %T\n", b, b)
    	n2, _ := strconv.ParseUint(s4, 10, 64)
    	fmt.Printf("n2 = %d,type = %T\n", n2, n2)
    	// 错误原因是s5的有效数据不能转换成指定的类型
    	n3, err := strconv.ParseInt(s5, 10, 64)
    	if err !=nil{
    		fmt.Println("error = ",err)
    	}else{
    		fmt.Printf("n = %d,type = %T\n", n3, n3)
    	}
    }
    
    
    
    n = 99090,type = int64
    f = 12.090000,type = float64
    b = true,type = bool
    n2 = 97,type = uint64
    error =  strconv.ParseInt: parsing "helloworld": invalid syntax
    

    7. 补充3 Go语言中常见转义符

    转义符 含义
    \r 回车符(返回行首)
    \n 换行符
    \t 制表符
    \’ 单引号
    \" 双引号
    \\ 反斜杠
    package main
    
    import "fmt"
    
    func main() {
    	var s1 string = "\"D:\\Go\\bin\\go.exe\""
    	fmt.Println(s1)
    }
    
    
    "D:\Go\bin\go.exe"
    
    展开全文
  • 研究发现,不论初始输入功率大小如何,正的初始波前曲率均会导致光束先展宽,而负的初始波前曲率则导致光束先压缩。对于具有不同初始波前曲率的光束,在某一确定的输入功率处,其束宽的演化曲线周期性的相交,而这些交点处...
  • s7-300工程实战总结.pdf

    2009-07-24 18:50:49
    20. 如何确定MMC的大小以便完整地存储STEP 7项目? 6 21. CPU全面复位后哪些设置会保留下来? 6 22. 为什么不能通过MPI在线访问CPU? 6 23. 错误OB的用途是什么? 7 24. 在DP从站或CPU315-2DP型主站里应该编程哪些...
  • 面试题33:把数组排成最小数:首先将数组中的数字全部转换为字符串存储在一个新的数组中,然后比较每两个数字串的拼接的mn和nm的大小,若mn<nm,则m更小,反之n更小,然后把更小的数放入一个新的List中,最后输出...
  • 前 言本书讲述了在互联网上传送数据的“盒子”的内部是如何工作的,这些“盒子”有不同的名称:网桥、路由器、交换机和集线器。本书也讲述了连接到网络上的设备。在这个领域有不少的混乱。大多数术语的定义不准确,...
  • 根据开采技术的需求,把煤层的按倾角大小不同分为3类: 缓倾斜煤层:倾角小于25° 倾斜煤层:倾角25~45° 急倾斜煤层:倾角大于45° 通常又把倾角在8°以下的煤层叫近水平煤层。 19地下水按含水层空隙性质分哪几类?...
  • 回归分析也允许我们去比较那些衡量不同尺度的变量之间的相互影响,如价格变动与促销活动数量之间联系。 这些有利于帮助市场研究人员,数据分析人员以及数据科学家排除并估计出一组最佳的变量,用来构建预测...
  • 编辑推荐通过学习《Oracle Database 10g 性能调整与优化》,读者可以了解到如何选择最优化的索引选项,有效地管理驱动器和磁盘阵列,对查询执行故障检修,以及可靠地预测将来的性能。《Oracle Database 10g 性能调整...
  •  实例162 根据桌面大小调整窗体大小 212  实例163 自定义最大化、最小化和关闭按钮 213  实例164 手动改变自制窗体的大小 215  实例165 禁止改变窗体的大小 218 7.3 设置窗体的标题栏 218  实例166 使窗体...
  • 实例162 根据桌面大小调整窗体大小 实例163 自定义最大化、最小化和关闭按钮 实例164 手动改变自制窗体的大小 实例165 禁止改变窗体的大小 7.3 设置窗体的标题栏 实例166 使窗体标题栏文字右对齐 实例167 ...
  • 实例162 根据桌面大小调整窗体大小 实例163 自定义最大化、最小化和关闭按钮 实例164 手动改变自制窗体的大小 实例165 禁止改变窗体的大小 7.3 设置窗体的标题栏 实例166 使窗体标题栏文字右对齐 实例167 ...
  • 实例162 根据桌面大小调整窗体大小 实例163 自定义最大化、最小化和关闭按钮 实例164 手动改变自制窗体的大小 实例165 禁止改变窗体的大小 7.3 设置窗体的标题栏 实例166 使窗体标题栏文字右对齐 实例167 ...
  • vc++ 开发实例源码包

    2014-12-16 11:25:17
    大家都知道,现在流行的检测硬件软件视乎很神秘,我们要获得各种信息好像比较难.但大多数这种软件或多或少的使用了WMI,如果我们能熟练掌握相信你也做的处理.另外WMI除了查询还能修改,比如3389端口,账号,密码,服务启动...
  • php高级开发教程说明

    2008-11-27 11:39:22
    计划所用时间与项目大小并不一定成比例,例如,想一下要设计的一个搜索算法。这一应 用程序只需要在一堆信息中进行基本的,搜索并能根据规则抽取数据,由于数据已经存在,所 以创建和输出将不会需要太多的努力。这一...

空空如也

空空如也

1 2 3
收藏数 51
精华内容 20
关键字:

不同指数如何比较大小